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