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
6This file is part of GNU ld.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, 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
48static enum section_type sectype;
49
50lang_memory_region_type *region;
51
52bfd_boolean ldgram_want_filename = TRUE;
53FILE *saved_script_handle = NULL;
54bfd_boolean force_make_executable = FALSE;
55
56bfd_boolean ldgram_in_script = FALSE;
57bfd_boolean ldgram_had_equals = FALSE;
58bfd_boolean ldgram_had_keep = FALSE;
59char *ldgram_vers_current_lang = NULL;
60
61#define ERROR_NAME_MAX 20
62static char *error_names[ERROR_NAME_MAX];
63static 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
161file:
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
169filename:  NAME;
170
171
172defsym_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 */
182mri_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
195mri_script_lines:
196		mri_script_lines mri_script_command NEWLINE
197          |
198	;
199
200mri_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
256ordernamelist:
257	      ordernamelist ',' NAME         { mri_order($3); }
258	|     ordernamelist  NAME         { mri_order($2); }
259      	|
260	;
261
262mri_load_name_list:
263		NAME
264			{ mri_load($1); }
265	|	mri_load_name_list ',' NAME { mri_load($3); }
266	;
267
268mri_abs_name_list:
269 		NAME
270 			{ mri_only_load($1); }
271	|	mri_abs_name_list ','  NAME
272 			{ mri_only_load($3); }
273	;
274
275casesymlist:
276	  /* empty */ { $$ = NULL; }
277	| NAME
278	| casesymlist ',' NAME
279	;
280
281extern_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
290script_file:
291	{
292	 ldlex_both();
293	}
294       ifile_list
295	{
296	ldlex_popstate();
297	}
298        ;
299
300
301ifile_list:
302       ifile_list ifile_p1
303        |
304	;
305
306
307
308ifile_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
354input_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
375sections:
376		SECTIONS '{' sec_or_group_p1 '}'
377	;
378
379sec_or_group_p1:
380		sec_or_group_p1 section
381	|	sec_or_group_p1 statement_anywhere
382	|
383	;
384
385statement_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.  */
396wildcard_name:
397		NAME
398			{
399			  $$ = $1;
400			}
401	|	'*'
402			{
403			  $$ = "*";
404			}
405	|	'?'
406			{
407			  $$ = "?";
408			}
409	;
410
411wildcard_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
438exclude_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
458file_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
478input_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
497input_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
505statement:
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
534statement_list:
535		statement_list statement
536  	|  	statement
537	;
538
539statement_list_opt:
540		/* empty */
541	|	statement_list
542	;
543
544length:
545		QUAD
546			{ $$ = $1; }
547	|	SQUAD
548			{ $$ = $1; }
549	|	LONG
550			{ $$ = $1; }
551	| 	SHORT
552			{ $$ = $1; }
553	|	BYTE
554			{ $$ = $1; }
555	;
556
557fill_exp:
558	mustbe_exp
559		{
560		  $$ = exp_get_fill ($1,
561				     0,
562				     "fill value",
563				     lang_first_phase_enum);
564		}
565	;
566
567fill_opt:
568	  '=' fill_exp
569		{ $$ = $2; }
570	| 	{ $$ = (fill_type *) 0; }
571	;
572
573assign_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
593end:	';' | ','
594	;
595
596
597assignment:
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
617opt_comma:
618		','	|	;
619
620
621memory:
622		MEMORY '{' memory_spec memory_spec_list '}'
623	;
624
625memory_spec_list:
626		memory_spec_list memory_spec
627	|	memory_spec_list ',' memory_spec
628	|
629	;
630
631
632memory_spec: 	NAME
633		{ region = lang_memory_region_lookup ($1, TRUE); }
634		attributes_opt ':'
635		origin_spec opt_comma length_spec
636		{}
637	;
638
639origin_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
647length_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
656attributes_opt:
657		/* empty */
658		  { /* dummy action to avoid bison 1.25 error message */ }
659	|	'(' attributes_list ')'
660	;
661
662attributes_list:
663		attributes_string
664	|	attributes_list attributes_string
665	;
666
667attributes_string:
668		NAME
669		  { lang_set_flags (region, $1, 0); }
670	|	'!' NAME
671		  { lang_set_flags (region, $2, 1); }
672	;
673
674startup:
675	STARTUP '(' filename ')'
676		{ lang_startup($3); }
677	;
678
679high_level_library:
680		HLL '(' high_level_library_NAME_list ')'
681	|	HLL '(' ')'
682			{ ldemul_hll((char *)NULL); }
683	;
684
685high_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
693low_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
701floating_point_support:
702		FLOAT
703			{ lang_float(TRUE); }
704	|	NOFLOAT
705			{ lang_float(FALSE); }
706	;
707
708nocrossref_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
733mustbe_exp:		 { ldlex_expression(); }
734		exp
735			 { ldlex_popstate(); $$=$2;}
736	;
737
738exp	:
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
826memspec_at_opt:
827                AT '>' NAME { $$ = $3; }
828        |       { $$ = 0; }
829        ;
830
831opt_at:
832		AT '(' exp ')' { $$ = $3; }
833	|	{ $$ = 0; }
834	;
835
836opt_subalign:
837		SUBALIGN '(' exp ')' { $$ = $3; }
838	|	{ $$ = 0; }
839	;
840
841section:	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
891type:
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
899atype:
900	 	'(' type ')'
901  	| 	/* EMPTY */ { sectype = normal_section; }
902  	| 	'(' ')' { sectype = normal_section; }
903	;
904
905opt_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
917opt_exp_without_type:
918		exp ':'		{ $$ = $1; }
919	|	':'		{ $$ = (etree_type *) NULL;  }
920	;
921
922opt_nocrossrefs:
923		/* empty */
924			{ $$ = 0; }
925	|	NOCROSSREFS
926			{ $$ = 1; }
927	;
928
929memspec_opt:
930		'>' NAME
931		{ $$ = $2; }
932	|	{ $$ = DEFAULT_MEMORY_REGION; }
933	;
934
935phdr_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
953overlay_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
971phdrs:
972		PHDRS '{' phdr_list '}'
973	;
974
975phdr_list:
976		/* empty */
977	|	phdr_list phdr
978	;
979
980phdr:
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
990phdr_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 if (strcmp (s, "PT_OPENBSD_RANDOMIZE") == 0)
1023			    $$ = exp_intop (0x65a3dbe6);
1024			  else if (strcmp (s, "PT_OPENBSD_MUTABLE") == 0)
1025			    $$ = exp_intop (0x65a3dbe5);
1026			  else
1027			    {
1028			      einfo (_("\
1029%X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1030				     s);
1031			      $$ = exp_intop (0);
1032			    }
1033			}
1034		    }
1035		}
1036	;
1037
1038phdr_qualifiers:
1039		/* empty */
1040		{
1041		  memset (&$$, 0, sizeof (struct phdr_info));
1042		}
1043	|	NAME phdr_val phdr_qualifiers
1044		{
1045		  $$ = $3;
1046		  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1047		    $$.filehdr = TRUE;
1048		  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1049		    $$.phdrs = TRUE;
1050		  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1051		    $$.flags = $2;
1052		  else
1053		    einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1054		}
1055	|	AT '(' exp ')' phdr_qualifiers
1056		{
1057		  $$ = $5;
1058		  $$.at = $3;
1059		}
1060	;
1061
1062phdr_val:
1063		/* empty */
1064		{
1065		  $$ = NULL;
1066		}
1067	| '(' exp ')'
1068		{
1069		  $$ = $2;
1070		}
1071	;
1072
1073/* This syntax is used within an external version script file.  */
1074
1075version_script_file:
1076		{
1077		  ldlex_version_file ();
1078		  PUSH_ERROR (_("VERSION script"));
1079		}
1080		vers_nodes
1081		{
1082		  ldlex_popstate ();
1083		  POP_ERROR ();
1084		}
1085	;
1086
1087/* This is used within a normal linker script file.  */
1088
1089version:
1090		{
1091		  ldlex_version_script ();
1092		}
1093		VERSIONK '{' vers_nodes '}'
1094		{
1095		  ldlex_popstate ();
1096		}
1097	;
1098
1099vers_nodes:
1100		vers_node
1101	|	vers_nodes vers_node
1102	;
1103
1104vers_node:
1105		'{' vers_tag '}' ';'
1106		{
1107		  lang_register_vers_node (NULL, $2, NULL);
1108		}
1109	|	VERS_TAG '{' vers_tag '}' ';'
1110		{
1111		  lang_register_vers_node ($1, $3, NULL);
1112		}
1113	|	VERS_TAG '{' vers_tag '}' verdep ';'
1114		{
1115		  lang_register_vers_node ($1, $3, $5);
1116		}
1117	;
1118
1119verdep:
1120		VERS_TAG
1121		{
1122		  $$ = lang_add_vers_depend (NULL, $1);
1123		}
1124	|	verdep VERS_TAG
1125		{
1126		  $$ = lang_add_vers_depend ($1, $2);
1127		}
1128	;
1129
1130vers_tag:
1131		/* empty */
1132		{
1133		  $$ = lang_new_vers_node (NULL, NULL);
1134		}
1135	|	vers_defns ';'
1136		{
1137		  $$ = lang_new_vers_node ($1, NULL);
1138		}
1139	|	GLOBAL ':' vers_defns ';'
1140		{
1141		  $$ = lang_new_vers_node ($3, NULL);
1142		}
1143	|	LOCAL ':' vers_defns ';'
1144		{
1145		  $$ = lang_new_vers_node (NULL, $3);
1146		}
1147	|	GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1148		{
1149		  $$ = lang_new_vers_node ($3, $7);
1150		}
1151	;
1152
1153vers_defns:
1154		VERS_IDENTIFIER
1155		{
1156		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang);
1157		}
1158	|	vers_defns ';' VERS_IDENTIFIER
1159		{
1160		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang);
1161		}
1162	|	vers_defns ';' EXTERN NAME '{'
1163			{
1164			  $<name>$ = ldgram_vers_current_lang;
1165			  ldgram_vers_current_lang = $4;
1166			}
1167		vers_defns opt_semicolon '}'
1168			{
1169			  $$ = $7;
1170			  ldgram_vers_current_lang = $<name>6;
1171			}
1172	|	EXTERN NAME '{'
1173			{
1174			  $<name>$ = ldgram_vers_current_lang;
1175			  ldgram_vers_current_lang = $2;
1176			}
1177		vers_defns opt_semicolon '}'
1178			{
1179			  $$ = $5;
1180			  ldgram_vers_current_lang = $<name>4;
1181			}
1182	;
1183
1184opt_semicolon:
1185		/* empty */
1186	|	';'
1187	;
1188
1189%%
1190void
1191yyerror(arg)
1192     const char *arg;
1193{
1194  if (ldfile_assumed_script)
1195    einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1196	   ldfile_input_filename);
1197  if (error_index > 0 && error_index < ERROR_NAME_MAX)
1198     einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1199  else
1200     einfo ("%P%F:%S: %s\n", arg);
1201}
1202