xref: /openbsd/gnu/usr.bin/binutils/ld/ldgram.y (revision 17df1aa7) 
1 /* A YACC grammar to parse a superset of the AT&T linker scripting language.
2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003 Free Software Foundation, Inc.
4    Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
5 
6 This file is part of GNU ld.
7 
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12 
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17 
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21 
22 %{
23 /*
24 
25  */
26 
27 #define DONTDECLARE_MALLOC
28 
29 #include "bfd.h"
30 #include "sysdep.h"
31 #include "bfdlink.h"
32 #include "ld.h"
33 #include "ldexp.h"
34 #include "ldver.h"
35 #include "ldlang.h"
36 #include "ldfile.h"
37 #include "ldemul.h"
38 #include "ldmisc.h"
39 #include "ldmain.h"
40 #include "mri.h"
41 #include "ldctor.h"
42 #include "ldlex.h"
43 
44 #ifndef YYDEBUG
45 #define YYDEBUG 1
46 #endif
47 
48 static enum section_type sectype;
49 
50 lang_memory_region_type *region;
51 
52 bfd_boolean ldgram_want_filename = TRUE;
53 FILE *saved_script_handle = NULL;
54 bfd_boolean force_make_executable = FALSE;
55 
56 bfd_boolean ldgram_in_script = FALSE;
57 bfd_boolean ldgram_had_equals = FALSE;
58 bfd_boolean ldgram_had_keep = FALSE;
59 char *ldgram_vers_current_lang = NULL;
60 
61 #define ERROR_NAME_MAX 20
62 static char *error_names[ERROR_NAME_MAX];
63 static int error_index;
64 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
65 #define POP_ERROR()   error_index--;
66 %}
67 %union {
68   bfd_vma integer;
69   struct big_int
70     {
71       bfd_vma integer;
72       char *str;
73     } bigint;
74   fill_type *fill;
75   char *name;
76   const char *cname;
77   struct wildcard_spec wildcard;
78   struct wildcard_list *wildcard_list;
79   struct name_list *name_list;
80   int token;
81   union etree_union *etree;
82   struct phdr_info
83     {
84       bfd_boolean filehdr;
85       bfd_boolean phdrs;
86       union etree_union *at;
87       union etree_union *flags;
88     } phdr;
89   struct lang_nocrossref *nocrossref;
90   struct lang_output_section_phdr_list *section_phdr;
91   struct bfd_elf_version_deps *deflist;
92   struct bfd_elf_version_expr *versyms;
93   struct bfd_elf_version_tree *versnode;
94 }
95 
96 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
97 %type <etree> opt_exp_without_type opt_subalign
98 %type <fill> fill_opt fill_exp
99 %type <name_list> exclude_name_list
100 %type <wildcard_list> file_NAME_list
101 %type <name> memspec_opt casesymlist
102 %type <name> memspec_at_opt
103 %type <cname> wildcard_name
104 %type <wildcard> wildcard_spec
105 %token <bigint> INT
106 %token <name> NAME LNAME
107 %type <integer> length
108 %type <phdr> phdr_qualifiers
109 %type <nocrossref> nocrossref_list
110 %type <section_phdr> phdr_opt
111 %type <integer> opt_nocrossrefs
112 
113 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
114 %right <token> '?' ':'
115 %left <token> OROR
116 %left <token>  ANDAND
117 %left <token> '|'
118 %left <token>  '^'
119 %left  <token> '&'
120 %left <token>  EQ NE
121 %left  <token> '<' '>' LE GE
122 %left  <token> LSHIFT RSHIFT
123 
124 %left  <token> '+' '-'
125 %left  <token> '*' '/' '%'
126 
127 %right UNARY
128 %token END
129 %left <token> '('
130 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
131 %token SECTIONS PHDRS SORT DATA_SEGMENT_ALIGN DATA_SEGMENT_END
132 %token '{' '}'
133 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
134 %token INHIBIT_COMMON_ALLOCATION
135 %token SIZEOF_HEADERS
136 %token INCLUDE
137 %token MEMORY DEFSYMEND
138 %token NOLOAD DSECT COPY INFO OVERLAY
139 %token NAME LNAME DEFINED TARGET_K SEARCH_DIR MAP ENTRY
140 %token <integer> NEXT
141 %token SIZEOF ADDR LOADADDR MAX_K MIN_K
142 %token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
143 %token ORIGIN FILL
144 %token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
145 %token ALIGNMOD AT SUBALIGN PROVIDE
146 %type <token> assign_op atype attributes_opt
147 %type <name>  filename
148 %token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
149 %token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
150 %token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
151 %token <name> VERS_TAG VERS_IDENTIFIER
152 %token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
153 %token KEEP
154 %token EXCLUDE_FILE
155 %type <versyms> vers_defns
156 %type <versnode> vers_tag
157 %type <deflist> verdep
158 
159 %%
160 
161 file:
162 		INPUT_SCRIPT script_file
163 	|	INPUT_MRI_SCRIPT mri_script_file
164 	|	INPUT_VERSION_SCRIPT version_script_file
165 	|	INPUT_DEFSYM defsym_expr
166 	;
167 
168 
169 filename:  NAME;
170 
171 
172 defsym_expr:
173 		{ ldlex_defsym(); }
174 		NAME '=' exp
175 		{
176 		  ldlex_popstate();
177 		  lang_add_assignment(exp_assop($3,$2,$4));
178 		}
179 	;
180 
181 /* SYNTAX WITHIN AN MRI SCRIPT FILE */
182 mri_script_file:
183 		{
184 		  ldlex_mri_script ();
185 		  PUSH_ERROR (_("MRI style script"));
186 		}
187 	     mri_script_lines
188 		{
189 		  ldlex_popstate ();
190 		  mri_draw_tree ();
191 		  POP_ERROR ();
192 		}
193 	;
194 
195 mri_script_lines:
196 		mri_script_lines mri_script_command NEWLINE
197           |
198 	;
199 
200 mri_script_command:
201 		CHIP  exp
202 	|	CHIP  exp ',' exp
203 	|	NAME 	{
204 			einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
205 			}
206 	|	LIST  	{
207 			config.map_filename = "-";
208 			}
209         |       ORDER ordernamelist
210 	|       ENDWORD
211         |       PUBLIC NAME '=' exp
212  			{ mri_public($2, $4); }
213         |       PUBLIC NAME ',' exp
214  			{ mri_public($2, $4); }
215         |       PUBLIC NAME  exp
216  			{ mri_public($2, $3); }
217 	| 	FORMAT NAME
218 			{ mri_format($2); }
219 	|	SECT NAME ',' exp
220 			{ mri_output_section($2, $4);}
221 	|	SECT NAME  exp
222 			{ mri_output_section($2, $3);}
223 	|	SECT NAME '=' exp
224 			{ mri_output_section($2, $4);}
225 	|	ALIGN_K NAME '=' exp
226 			{ mri_align($2,$4); }
227 	|	ALIGN_K NAME ',' exp
228 			{ mri_align($2,$4); }
229 	|	ALIGNMOD NAME '=' exp
230 			{ mri_alignmod($2,$4); }
231 	|	ALIGNMOD NAME ',' exp
232 			{ mri_alignmod($2,$4); }
233 	|	ABSOLUTE mri_abs_name_list
234 	|	LOAD	 mri_load_name_list
235 	|       NAMEWORD NAME
236 			{ mri_name($2); }
237 	|	ALIAS NAME ',' NAME
238 			{ mri_alias($2,$4,0);}
239 	|	ALIAS NAME ',' INT
240 			{ mri_alias ($2, 0, (int) $4.integer); }
241 	|	BASE     exp
242 			{ mri_base($2); }
243 	|	TRUNCATE INT
244 		{ mri_truncate ((unsigned int) $2.integer); }
245 	|	CASE casesymlist
246 	|	EXTERN extern_name_list
247 	|	INCLUDE filename
248 		{ ldlex_script (); ldfile_open_command_file($2); }
249 		mri_script_lines END
250 		{ ldlex_popstate (); }
251 	|	START NAME
252 		{ lang_add_entry ($2, FALSE); }
253         |
254 	;
255 
256 ordernamelist:
257 	      ordernamelist ',' NAME         { mri_order($3); }
258 	|     ordernamelist  NAME         { mri_order($2); }
259       	|
260 	;
261 
262 mri_load_name_list:
263 		NAME
264 			{ mri_load($1); }
265 	|	mri_load_name_list ',' NAME { mri_load($3); }
266 	;
267 
268 mri_abs_name_list:
269  		NAME
270  			{ mri_only_load($1); }
271 	|	mri_abs_name_list ','  NAME
272  			{ mri_only_load($3); }
273 	;
274 
275 casesymlist:
276 	  /* empty */ { $$ = NULL; }
277 	| NAME
278 	| casesymlist ',' NAME
279 	;
280 
281 extern_name_list:
282 	  NAME
283 			{ ldlang_add_undef ($1); }
284 	| extern_name_list NAME
285 			{ ldlang_add_undef ($2); }
286 	| extern_name_list ',' NAME
287 			{ ldlang_add_undef ($3); }
288 	;
289 
290 script_file:
291 	{
292 	 ldlex_both();
293 	}
294        ifile_list
295 	{
296 	ldlex_popstate();
297 	}
298         ;
299 
300 
301 ifile_list:
302        ifile_list ifile_p1
303         |
304 	;
305 
306 
307 
308 ifile_p1:
309 		memory
310 	|	sections
311 	|	phdrs
312 	|	startup
313 	|	high_level_library
314 	|	low_level_library
315 	|	floating_point_support
316 	|	statement_anywhere
317 	|	version
318         |	 ';'
319 	|	TARGET_K '(' NAME ')'
320 		{ lang_add_target($3); }
321 	|	SEARCH_DIR '(' filename ')'
322 		{ ldfile_add_library_path ($3, FALSE); }
323 	|	OUTPUT '(' filename ')'
324 		{ lang_add_output($3, 1); }
325         |	OUTPUT_FORMAT '(' NAME ')'
326 		  { lang_add_output_format ($3, (char *) NULL,
327 					    (char *) NULL, 1); }
328 	|	OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
329 		  { lang_add_output_format ($3, $5, $7, 1); }
330         |	OUTPUT_ARCH '(' NAME ')'
331 		  { ldfile_set_output_arch ($3, bfd_arch_unknown); }
332 	|	FORCE_COMMON_ALLOCATION
333 		{ command_line.force_common_definition = TRUE ; }
334 	|	INHIBIT_COMMON_ALLOCATION
335 		{ command_line.inhibit_common_definition = TRUE ; }
336 	|	INPUT '(' input_list ')'
337 	|	GROUP
338 		  { lang_enter_group (); }
339 		    '(' input_list ')'
340 		  { lang_leave_group (); }
341      	|	MAP '(' filename ')'
342 		{ lang_add_map($3); }
343 	|	INCLUDE filename
344 		{ ldlex_script (); ldfile_open_command_file($2); }
345 		ifile_list END
346 		{ ldlex_popstate (); }
347 	|	NOCROSSREFS '(' nocrossref_list ')'
348 		{
349 		  lang_add_nocrossref ($3);
350 		}
351 	|	EXTERN '(' extern_name_list ')'
352 	;
353 
354 input_list:
355 		NAME
356 		{ lang_add_input_file($1,lang_input_file_is_search_file_enum,
357 				 (char *)NULL); }
358 	|	input_list ',' NAME
359 		{ lang_add_input_file($3,lang_input_file_is_search_file_enum,
360 				 (char *)NULL); }
361 	|	input_list NAME
362 		{ lang_add_input_file($2,lang_input_file_is_search_file_enum,
363 				 (char *)NULL); }
364 	|	LNAME
365 		{ lang_add_input_file($1,lang_input_file_is_l_enum,
366 				 (char *)NULL); }
367 	|	input_list ',' LNAME
368 		{ lang_add_input_file($3,lang_input_file_is_l_enum,
369 				 (char *)NULL); }
370 	|	input_list LNAME
371 		{ lang_add_input_file($2,lang_input_file_is_l_enum,
372 				 (char *)NULL); }
373 	;
374 
375 sections:
376 		SECTIONS '{' sec_or_group_p1 '}'
377 	;
378 
379 sec_or_group_p1:
380 		sec_or_group_p1 section
381 	|	sec_or_group_p1 statement_anywhere
382 	|
383 	;
384 
385 statement_anywhere:
386 		ENTRY '(' NAME ')'
387 		{ lang_add_entry ($3, FALSE); }
388 	|	assignment end
389 	|	ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
390 		{ ldlex_popstate ();
391 		  lang_add_assignment (exp_assert ($4, $6)); }
392 	;
393 
394 /* The '*' and '?' cases are there because the lexer returns them as
395    separate tokens rather than as NAME.  */
396 wildcard_name:
397 		NAME
398 			{
399 			  $$ = $1;
400 			}
401 	|	'*'
402 			{
403 			  $$ = "*";
404 			}
405 	|	'?'
406 			{
407 			  $$ = "?";
408 			}
409 	;
410 
411 wildcard_spec:
412 		wildcard_name
413 			{
414 			  $$.name = $1;
415 			  $$.sorted = FALSE;
416 			  $$.exclude_name_list = NULL;
417 			}
418 	| 	EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
419 			{
420 			  $$.name = $5;
421 			  $$.sorted = FALSE;
422 			  $$.exclude_name_list = $3;
423 			}
424 	|	SORT '(' wildcard_name ')'
425 			{
426 			  $$.name = $3;
427 			  $$.sorted = TRUE;
428 			  $$.exclude_name_list = NULL;
429 			}
430 	|	SORT '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
431 			{
432 			  $$.name = $7;
433 			  $$.sorted = TRUE;
434 			  $$.exclude_name_list = $5;
435 			}
436 	;
437 
438 exclude_name_list:
439 		exclude_name_list wildcard_name
440 			{
441 			  struct name_list *tmp;
442 			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
443 			  tmp->name = $2;
444 			  tmp->next = $1;
445 			  $$ = tmp;
446 			}
447 	|
448 		wildcard_name
449 			{
450 			  struct name_list *tmp;
451 			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
452 			  tmp->name = $1;
453 			  tmp->next = NULL;
454 			  $$ = tmp;
455 			}
456 	;
457 
458 file_NAME_list:
459 		file_NAME_list opt_comma wildcard_spec
460 			{
461 			  struct wildcard_list *tmp;
462 			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
463 			  tmp->next = $1;
464 			  tmp->spec = $3;
465 			  $$ = tmp;
466 			}
467 	|
468 		wildcard_spec
469 			{
470 			  struct wildcard_list *tmp;
471 			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
472 			  tmp->next = NULL;
473 			  tmp->spec = $1;
474 			  $$ = tmp;
475 			}
476 	;
477 
478 input_section_spec_no_keep:
479 		NAME
480 			{
481 			  struct wildcard_spec tmp;
482 			  tmp.name = $1;
483 			  tmp.exclude_name_list = NULL;
484 			  tmp.sorted = FALSE;
485 			  lang_add_wild (&tmp, NULL, ldgram_had_keep);
486 			}
487         |	'[' file_NAME_list ']'
488 			{
489 			  lang_add_wild (NULL, $2, ldgram_had_keep);
490 			}
491 	|	wildcard_spec '(' file_NAME_list ')'
492 			{
493 			  lang_add_wild (&$1, $3, ldgram_had_keep);
494 			}
495 	;
496 
497 input_section_spec:
498 		input_section_spec_no_keep
499 	|	KEEP '('
500 			{ ldgram_had_keep = TRUE; }
501 		input_section_spec_no_keep ')'
502 			{ ldgram_had_keep = FALSE; }
503 	;
504 
505 statement:
506 	  	assignment end
507 	|	CREATE_OBJECT_SYMBOLS
508 		{
509  		lang_add_attribute(lang_object_symbols_statement_enum);
510 	      	}
511         |	';'
512         |	CONSTRUCTORS
513 		{
514 
515 		  lang_add_attribute(lang_constructors_statement_enum);
516 		}
517 	| SORT '(' CONSTRUCTORS ')'
518 		{
519 		  constructors_sorted = TRUE;
520 		  lang_add_attribute (lang_constructors_statement_enum);
521 		}
522 	| input_section_spec
523         | length '(' mustbe_exp ')'
524         	        {
525 			  lang_add_data ((int) $1, $3);
526 			}
527 
528 	| FILL '(' fill_exp ')'
529 			{
530 			  lang_add_fill ($3);
531 			}
532 	;
533 
534 statement_list:
535 		statement_list statement
536   	|  	statement
537 	;
538 
539 statement_list_opt:
540 		/* empty */
541 	|	statement_list
542 	;
543 
544 length:
545 		QUAD
546 			{ $$ = $1; }
547 	|	SQUAD
548 			{ $$ = $1; }
549 	|	LONG
550 			{ $$ = $1; }
551 	| 	SHORT
552 			{ $$ = $1; }
553 	|	BYTE
554 			{ $$ = $1; }
555 	;
556 
557 fill_exp:
558 	mustbe_exp
559 		{
560 		  $$ = exp_get_fill ($1,
561 				     0,
562 				     "fill value",
563 				     lang_first_phase_enum);
564 		}
565 	;
566 
567 fill_opt:
568 	  '=' fill_exp
569 		{ $$ = $2; }
570 	| 	{ $$ = (fill_type *) 0; }
571 	;
572 
573 assign_op:
574 		PLUSEQ
575 			{ $$ = '+'; }
576 	|	MINUSEQ
577 			{ $$ = '-'; }
578 	| 	MULTEQ
579 			{ $$ = '*'; }
580 	| 	DIVEQ
581 			{ $$ = '/'; }
582 	| 	LSHIFTEQ
583 			{ $$ = LSHIFT; }
584 	| 	RSHIFTEQ
585 			{ $$ = RSHIFT; }
586 	| 	ANDEQ
587 			{ $$ = '&'; }
588 	| 	OREQ
589 			{ $$ = '|'; }
590 
591 	;
592 
593 end:	';' | ','
594 	;
595 
596 
597 assignment:
598 		NAME '=' mustbe_exp
599 		{
600 		  lang_add_assignment (exp_assop ($2, $1, $3));
601 		}
602 	|	NAME assign_op mustbe_exp
603 		{
604 		  lang_add_assignment (exp_assop ('=', $1,
605 						  exp_binop ($2,
606 							     exp_nameop (NAME,
607 									 $1),
608 							     $3)));
609 		}
610 	|	PROVIDE '(' NAME '=' mustbe_exp ')'
611 		{
612 		  lang_add_assignment (exp_provide ($3, $5));
613 		}
614 	;
615 
616 
617 opt_comma:
618 		','	|	;
619 
620 
621 memory:
622 		MEMORY '{' memory_spec memory_spec_list '}'
623 	;
624 
625 memory_spec_list:
626 		memory_spec_list memory_spec
627 	|	memory_spec_list ',' memory_spec
628 	|
629 	;
630 
631 
632 memory_spec: 	NAME
633 		{ region = lang_memory_region_lookup ($1, TRUE); }
634 		attributes_opt ':'
635 		origin_spec opt_comma length_spec
636 		{}
637 	;
638 
639 origin_spec:
640 	ORIGIN '=' mustbe_exp
641 		{ region->current =
642 		 region->origin =
643 		 exp_get_vma($3, 0L,"origin", lang_first_phase_enum);
644 }
645 	;
646 
647 length_spec:
648              LENGTH '=' mustbe_exp
649                { region->length = exp_get_vma($3,
650 					       ~((bfd_vma)0),
651 					       "length",
652 					       lang_first_phase_enum);
653 		}
654 	;
655 
656 attributes_opt:
657 		/* empty */
658 		  { /* dummy action to avoid bison 1.25 error message */ }
659 	|	'(' attributes_list ')'
660 	;
661 
662 attributes_list:
663 		attributes_string
664 	|	attributes_list attributes_string
665 	;
666 
667 attributes_string:
668 		NAME
669 		  { lang_set_flags (region, $1, 0); }
670 	|	'!' NAME
671 		  { lang_set_flags (region, $2, 1); }
672 	;
673 
674 startup:
675 	STARTUP '(' filename ')'
676 		{ lang_startup($3); }
677 	;
678 
679 high_level_library:
680 		HLL '(' high_level_library_NAME_list ')'
681 	|	HLL '(' ')'
682 			{ ldemul_hll((char *)NULL); }
683 	;
684 
685 high_level_library_NAME_list:
686 		high_level_library_NAME_list opt_comma filename
687 			{ ldemul_hll($3); }
688 	|	filename
689 			{ ldemul_hll($1); }
690 
691 	;
692 
693 low_level_library:
694 	SYSLIB '(' low_level_library_NAME_list ')'
695 	; low_level_library_NAME_list:
696 		low_level_library_NAME_list opt_comma filename
697 			{ ldemul_syslib($3); }
698 	|
699 	;
700 
701 floating_point_support:
702 		FLOAT
703 			{ lang_float(TRUE); }
704 	|	NOFLOAT
705 			{ lang_float(FALSE); }
706 	;
707 
708 nocrossref_list:
709 		/* empty */
710 		{
711 		  $$ = NULL;
712 		}
713 	|	NAME nocrossref_list
714 		{
715 		  struct lang_nocrossref *n;
716 
717 		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
718 		  n->name = $1;
719 		  n->next = $2;
720 		  $$ = n;
721 		}
722 	|	NAME ',' nocrossref_list
723 		{
724 		  struct lang_nocrossref *n;
725 
726 		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
727 		  n->name = $1;
728 		  n->next = $3;
729 		  $$ = n;
730 		}
731 	;
732 
733 mustbe_exp:		 { ldlex_expression(); }
734 		exp
735 			 { ldlex_popstate(); $$=$2;}
736 	;
737 
738 exp	:
739 		'-' exp %prec UNARY
740 			{ $$ = exp_unop('-', $2); }
741 	|	'(' exp ')'
742 			{ $$ = $2; }
743 	|	NEXT '(' exp ')' %prec UNARY
744 			{ $$ = exp_unop((int) $1,$3); }
745 	|	'!' exp %prec UNARY
746 			{ $$ = exp_unop('!', $2); }
747 	|	'+' exp %prec UNARY
748 			{ $$ = $2; }
749 	|	'~' exp %prec UNARY
750 			{ $$ = exp_unop('~', $2);}
751 
752 	|	exp '*' exp
753 			{ $$ = exp_binop('*', $1, $3); }
754 	|	exp '/' exp
755 			{ $$ = exp_binop('/', $1, $3); }
756 	|	exp '%' exp
757 			{ $$ = exp_binop('%', $1, $3); }
758 	|	exp '+' exp
759 			{ $$ = exp_binop('+', $1, $3); }
760 	|	exp '-' exp
761 			{ $$ = exp_binop('-' , $1, $3); }
762 	|	exp LSHIFT exp
763 			{ $$ = exp_binop(LSHIFT , $1, $3); }
764 	|	exp RSHIFT exp
765 			{ $$ = exp_binop(RSHIFT , $1, $3); }
766 	|	exp EQ exp
767 			{ $$ = exp_binop(EQ , $1, $3); }
768 	|	exp NE exp
769 			{ $$ = exp_binop(NE , $1, $3); }
770 	|	exp LE exp
771 			{ $$ = exp_binop(LE , $1, $3); }
772   	|	exp GE exp
773 			{ $$ = exp_binop(GE , $1, $3); }
774 	|	exp '<' exp
775 			{ $$ = exp_binop('<' , $1, $3); }
776 	|	exp '>' exp
777 			{ $$ = exp_binop('>' , $1, $3); }
778 	|	exp '&' exp
779 			{ $$ = exp_binop('&' , $1, $3); }
780 	|	exp '^' exp
781 			{ $$ = exp_binop('^' , $1, $3); }
782 	|	exp '|' exp
783 			{ $$ = exp_binop('|' , $1, $3); }
784 	|	exp '?' exp ':' exp
785 			{ $$ = exp_trinop('?' , $1, $3, $5); }
786 	|	exp ANDAND exp
787 			{ $$ = exp_binop(ANDAND , $1, $3); }
788 	|	exp OROR exp
789 			{ $$ = exp_binop(OROR , $1, $3); }
790 	|	DEFINED '(' NAME ')'
791 			{ $$ = exp_nameop(DEFINED, $3); }
792 	|	INT
793 			{ $$ = exp_bigintop ($1.integer, $1.str); }
794         |	SIZEOF_HEADERS
795 			{ $$ = exp_nameop(SIZEOF_HEADERS,0); }
796 
797 	|	SIZEOF '(' NAME ')'
798 			{ $$ = exp_nameop(SIZEOF,$3); }
799 	|	ADDR '(' NAME ')'
800 			{ $$ = exp_nameop(ADDR,$3); }
801 	|	LOADADDR '(' NAME ')'
802 			{ $$ = exp_nameop(LOADADDR,$3); }
803 	|	ABSOLUTE '(' exp ')'
804 			{ $$ = exp_unop(ABSOLUTE, $3); }
805 	|	ALIGN_K '(' exp ')'
806 			{ $$ = exp_unop(ALIGN_K,$3); }
807 	|	ALIGN_K '(' exp ',' exp ')'
808 			{ $$ = exp_binop(ALIGN_K,$3,$5); }
809 	|	DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
810 			{ $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
811 	|	DATA_SEGMENT_END '(' exp ')'
812 			{ $$ = exp_unop(DATA_SEGMENT_END, $3); }
813 	|	BLOCK '(' exp ')'
814 			{ $$ = exp_unop(ALIGN_K,$3); }
815 	|	NAME
816 			{ $$ = exp_nameop(NAME,$1); }
817 	|	MAX_K '(' exp ',' exp ')'
818 			{ $$ = exp_binop (MAX_K, $3, $5 ); }
819 	|	MIN_K '(' exp ',' exp ')'
820 			{ $$ = exp_binop (MIN_K, $3, $5 ); }
821 	|	ASSERT_K '(' exp ',' NAME ')'
822 			{ $$ = exp_assert ($3, $5); }
823 	;
824 
825 
826 memspec_at_opt:
827                 AT '>' NAME { $$ = $3; }
828         |       { $$ = 0; }
829         ;
830 
831 opt_at:
832 		AT '(' exp ')' { $$ = $3; }
833 	|	{ $$ = 0; }
834 	;
835 
836 opt_subalign:
837 		SUBALIGN '(' exp ')' { $$ = $3; }
838 	|	{ $$ = 0; }
839 	;
840 
841 section:	NAME 		{ ldlex_expression(); }
842 		opt_exp_with_type
843 		opt_at
844 		opt_subalign	{ ldlex_popstate (); ldlex_script (); }
845 		'{'
846 			{
847 			  lang_enter_output_section_statement($1, $3,
848 							      sectype,
849 							      0, $5, $4);
850 			}
851 		statement_list_opt
852  		'}' { ldlex_popstate (); ldlex_expression (); }
853 		memspec_opt memspec_at_opt phdr_opt fill_opt
854 		{
855 		  ldlex_popstate ();
856 		  lang_leave_output_section_statement ($15, $12, $14, $13);
857 		}
858 		opt_comma
859 		{}
860 	|	OVERLAY
861 			{ ldlex_expression (); }
862 		opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
863 			{ ldlex_popstate (); ldlex_script (); }
864 		'{'
865 			{
866 			  lang_enter_overlay ($3, $6);
867 			}
868 		overlay_section
869 		'}'
870 			{ ldlex_popstate (); ldlex_expression (); }
871 		memspec_opt memspec_at_opt phdr_opt fill_opt
872 			{
873 			  ldlex_popstate ();
874 			  lang_leave_overlay ($5, (int) $4,
875 					      $16, $13, $15, $14);
876 			}
877 		opt_comma
878 	|	/* The GROUP case is just enough to support the gcc
879 		   svr3.ifile script.  It is not intended to be full
880 		   support.  I'm not even sure what GROUP is supposed
881 		   to mean.  */
882 		GROUP { ldlex_expression (); }
883 		opt_exp_with_type
884 		{
885 		  ldlex_popstate ();
886 		  lang_add_assignment (exp_assop ('=', ".", $3));
887 		}
888 		'{' sec_or_group_p1 '}'
889 	;
890 
891 type:
892 	   NOLOAD  { sectype = noload_section; }
893 	|  DSECT   { sectype = dsect_section; }
894 	|  COPY    { sectype = copy_section; }
895 	|  INFO    { sectype = info_section; }
896 	|  OVERLAY { sectype = overlay_section; }
897 	;
898 
899 atype:
900 	 	'(' type ')'
901   	| 	/* EMPTY */ { sectype = normal_section; }
902   	| 	'(' ')' { sectype = normal_section; }
903 	;
904 
905 opt_exp_with_type:
906 		exp atype ':'		{ $$ = $1; }
907 	|	atype ':'		{ $$ = (etree_type *)NULL;  }
908 	|	/* The BIND cases are to support the gcc svr3.ifile
909 		   script.  They aren't intended to implement full
910 		   support for the BIND keyword.  I'm not even sure
911 		   what BIND is supposed to mean.  */
912 		BIND '(' exp ')' atype ':' { $$ = $3; }
913 	|	BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
914 		{ $$ = $3; }
915 	;
916 
917 opt_exp_without_type:
918 		exp ':'		{ $$ = $1; }
919 	|	':'		{ $$ = (etree_type *) NULL;  }
920 	;
921 
922 opt_nocrossrefs:
923 		/* empty */
924 			{ $$ = 0; }
925 	|	NOCROSSREFS
926 			{ $$ = 1; }
927 	;
928 
929 memspec_opt:
930 		'>' NAME
931 		{ $$ = $2; }
932 	|	{ $$ = DEFAULT_MEMORY_REGION; }
933 	;
934 
935 phdr_opt:
936 		/* empty */
937 		{
938 		  $$ = NULL;
939 		}
940 	|	phdr_opt ':' NAME
941 		{
942 		  struct lang_output_section_phdr_list *n;
943 
944 		  n = ((struct lang_output_section_phdr_list *)
945 		       xmalloc (sizeof *n));
946 		  n->name = $3;
947 		  n->used = FALSE;
948 		  n->next = $1;
949 		  $$ = n;
950 		}
951 	;
952 
953 overlay_section:
954 		/* empty */
955 	|	overlay_section
956 		NAME
957 			{
958 			  ldlex_script ();
959 			  lang_enter_overlay_section ($2);
960 			}
961 		'{' statement_list_opt '}'
962 			{ ldlex_popstate (); ldlex_expression (); }
963 		phdr_opt fill_opt
964 			{
965 			  ldlex_popstate ();
966 			  lang_leave_overlay_section ($9, $8);
967 			}
968 		opt_comma
969 	;
970 
971 phdrs:
972 		PHDRS '{' phdr_list '}'
973 	;
974 
975 phdr_list:
976 		/* empty */
977 	|	phdr_list phdr
978 	;
979 
980 phdr:
981 		NAME { ldlex_expression (); }
982 		  phdr_type phdr_qualifiers { ldlex_popstate (); }
983 		  ';'
984 		{
985 		  lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
986 				 $4.flags);
987 		}
988 	;
989 
990 phdr_type:
991 		exp
992 		{
993 		  $$ = $1;
994 
995 		  if ($1->type.node_class == etree_name
996 		      && $1->type.node_code == NAME)
997 		    {
998 		      const char *s;
999 		      unsigned int i;
1000 		      static const char * const phdr_types[] =
1001 			{
1002 			  "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1003 			  "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1004 			  "PT_PHDR", "PT_TLS"
1005 			};
1006 
1007 		      s = $1->name.name;
1008 		      for (i = 0;
1009 			   i < sizeof phdr_types / sizeof phdr_types[0];
1010 			   i++)
1011 			if (strcmp (s, phdr_types[i]) == 0)
1012 			  {
1013 			    $$ = exp_intop (i);
1014 			    break;
1015 			  }
1016 		      if (i == sizeof phdr_types / sizeof phdr_types[0])
1017 			{
1018 			  if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1019 			    $$ = exp_intop (0x6474e550);
1020 			  else if (strcmp (s, "PT_GNU_STACK") == 0)
1021 			    $$ = exp_intop (0x6474e551);
1022 			  else
1023 			    {
1024 			      einfo (_("\
1025 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1026 				     s);
1027 			      $$ = exp_intop (0);
1028 			    }
1029 			}
1030 		    }
1031 		}
1032 	;
1033 
1034 phdr_qualifiers:
1035 		/* empty */
1036 		{
1037 		  memset (&$$, 0, sizeof (struct phdr_info));
1038 		}
1039 	|	NAME phdr_val phdr_qualifiers
1040 		{
1041 		  $$ = $3;
1042 		  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1043 		    $$.filehdr = TRUE;
1044 		  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1045 		    $$.phdrs = TRUE;
1046 		  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1047 		    $$.flags = $2;
1048 		  else
1049 		    einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1050 		}
1051 	|	AT '(' exp ')' phdr_qualifiers
1052 		{
1053 		  $$ = $5;
1054 		  $$.at = $3;
1055 		}
1056 	;
1057 
1058 phdr_val:
1059 		/* empty */
1060 		{
1061 		  $$ = NULL;
1062 		}
1063 	| '(' exp ')'
1064 		{
1065 		  $$ = $2;
1066 		}
1067 	;
1068 
1069 /* This syntax is used within an external version script file.  */
1070 
1071 version_script_file:
1072 		{
1073 		  ldlex_version_file ();
1074 		  PUSH_ERROR (_("VERSION script"));
1075 		}
1076 		vers_nodes
1077 		{
1078 		  ldlex_popstate ();
1079 		  POP_ERROR ();
1080 		}
1081 	;
1082 
1083 /* This is used within a normal linker script file.  */
1084 
1085 version:
1086 		{
1087 		  ldlex_version_script ();
1088 		}
1089 		VERSIONK '{' vers_nodes '}'
1090 		{
1091 		  ldlex_popstate ();
1092 		}
1093 	;
1094 
1095 vers_nodes:
1096 		vers_node
1097 	|	vers_nodes vers_node
1098 	;
1099 
1100 vers_node:
1101 		'{' vers_tag '}' ';'
1102 		{
1103 		  lang_register_vers_node (NULL, $2, NULL);
1104 		}
1105 	|	VERS_TAG '{' vers_tag '}' ';'
1106 		{
1107 		  lang_register_vers_node ($1, $3, NULL);
1108 		}
1109 	|	VERS_TAG '{' vers_tag '}' verdep ';'
1110 		{
1111 		  lang_register_vers_node ($1, $3, $5);
1112 		}
1113 	;
1114 
1115 verdep:
1116 		VERS_TAG
1117 		{
1118 		  $$ = lang_add_vers_depend (NULL, $1);
1119 		}
1120 	|	verdep VERS_TAG
1121 		{
1122 		  $$ = lang_add_vers_depend ($1, $2);
1123 		}
1124 	;
1125 
1126 vers_tag:
1127 		/* empty */
1128 		{
1129 		  $$ = lang_new_vers_node (NULL, NULL);
1130 		}
1131 	|	vers_defns ';'
1132 		{
1133 		  $$ = lang_new_vers_node ($1, NULL);
1134 		}
1135 	|	GLOBAL ':' vers_defns ';'
1136 		{
1137 		  $$ = lang_new_vers_node ($3, NULL);
1138 		}
1139 	|	LOCAL ':' vers_defns ';'
1140 		{
1141 		  $$ = lang_new_vers_node (NULL, $3);
1142 		}
1143 	|	GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1144 		{
1145 		  $$ = lang_new_vers_node ($3, $7);
1146 		}
1147 	;
1148 
1149 vers_defns:
1150 		VERS_IDENTIFIER
1151 		{
1152 		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang);
1153 		}
1154 	|	vers_defns ';' VERS_IDENTIFIER
1155 		{
1156 		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang);
1157 		}
1158 	|	vers_defns ';' EXTERN NAME '{'
1159 			{
1160 			  $<name>$ = ldgram_vers_current_lang;
1161 			  ldgram_vers_current_lang = $4;
1162 			}
1163 		vers_defns opt_semicolon '}'
1164 			{
1165 			  $$ = $7;
1166 			  ldgram_vers_current_lang = $<name>6;
1167 			}
1168 	|	EXTERN NAME '{'
1169 			{
1170 			  $<name>$ = ldgram_vers_current_lang;
1171 			  ldgram_vers_current_lang = $2;
1172 			}
1173 		vers_defns opt_semicolon '}'
1174 			{
1175 			  $$ = $5;
1176 			  ldgram_vers_current_lang = $<name>4;
1177 			}
1178 	;
1179 
1180 opt_semicolon:
1181 		/* empty */
1182 	|	';'
1183 	;
1184 
1185 %%
1186 void
1187 yyerror(arg)
1188      const char *arg;
1189 {
1190   if (ldfile_assumed_script)
1191     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1192 	   ldfile_input_filename);
1193   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1194      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1195   else
1196      einfo ("%P%F:%S: %s\n", arg);
1197 }
1198