1/* A YACC grammar to parse a superset of the AT&T linker scripting language.
2   Copyright (C) 1991-2022 Free Software Foundation, Inc.
3   Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
4
5   This file is part of the GNU Binutils.
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 3 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20   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 "ctf-api.h"
33#include "ld.h"
34#include "ldexp.h"
35#include "ldver.h"
36#include "ldlang.h"
37#include "ldfile.h"
38#include "ldemul.h"
39#include "ldmisc.h"
40#include "ldmain.h"
41#include "mri.h"
42#include "ldctor.h"
43#include "ldlex.h"
44
45#ifndef YYDEBUG
46#define YYDEBUG 1
47#endif
48
49static enum section_type sectype;
50static etree_type *sectype_value;
51static lang_memory_region_type *region;
52
53static bool ldgram_had_keep = false;
54static char *ldgram_vers_current_lang = NULL;
55
56#define ERROR_NAME_MAX 20
57static char *error_names[ERROR_NAME_MAX];
58static int error_index;
59#define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
60#define POP_ERROR()   error_index--;
61%}
62%union {
63  bfd_vma integer;
64  struct big_int
65    {
66      bfd_vma integer;
67      char *str;
68    } bigint;
69  fill_type *fill;
70  char *name;
71  const char *cname;
72  struct wildcard_spec wildcard;
73  struct wildcard_list *wildcard_list;
74  struct name_list *name_list;
75  struct flag_info_list *flag_info_list;
76  struct flag_info *flag_info;
77  int token;
78  union etree_union *etree;
79  struct phdr_info
80    {
81      bool filehdr;
82      bool phdrs;
83      union etree_union *at;
84      union etree_union *flags;
85    } phdr;
86  struct lang_nocrossref *nocrossref;
87  struct lang_output_section_phdr_list *section_phdr;
88  struct bfd_elf_version_deps *deflist;
89  struct bfd_elf_version_expr *versyms;
90  struct bfd_elf_version_tree *versnode;
91}
92
93%type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
94%type <etree> opt_exp_without_type opt_subalign opt_align
95%type <fill> fill_opt fill_exp
96%type <name_list> exclude_name_list
97%type <wildcard_list> section_name_list
98%type <flag_info_list> sect_flag_list
99%type <flag_info> sect_flags
100%type <name> memspec_opt memspec_at_opt paren_script_name casesymlist
101%type <cname> wildcard_name
102%type <wildcard> section_name_spec filename_spec wildcard_maybe_exclude
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 INSERT_K AFTER BEFORE
130%token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
131%token SORT_BY_NAME SORT_BY_ALIGNMENT SORT_NONE
132%token SORT_BY_INIT_PRIORITY
133%token '{' '}'
134%token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
135%token INHIBIT_COMMON_ALLOCATION FORCE_GROUP_ALLOCATION
136%token SEGMENT_START
137%token INCLUDE
138%token MEMORY
139%token REGION_ALIAS
140%token LD_FEATURE
141%token NOLOAD DSECT COPY INFO OVERLAY
142%token READONLY
143%token TYPE
144%token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
145%token <integer> NEXT
146%token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
147%token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS NOCROSSREFS_TO
148%token ORIGIN FILL
149%token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
150%token ALIGNMOD AT SUBALIGN HIDDEN PROVIDE PROVIDE_HIDDEN AS_NEEDED
151%type <token> assign_op atype attributes_opt sect_constraint opt_align_with_input
152%type <name>  filename
153%token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
154%token LOG2CEIL FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
155%token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
156%token <name> VERS_TAG VERS_IDENTIFIER
157%token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
158%token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL INPUT_SECTION_FLAGS ALIGN_WITH_INPUT
159%token EXCLUDE_FILE
160%token CONSTANT
161%type <versyms> vers_defns
162%type <versnode> vers_tag
163%type <deflist> verdep
164%token INPUT_DYNAMIC_LIST
165
166%%
167
168file:
169		INPUT_SCRIPT script_file
170	|	INPUT_MRI_SCRIPT mri_script_file
171	|	INPUT_VERSION_SCRIPT version_script_file
172	|	INPUT_DYNAMIC_LIST dynamic_list_file
173	|	INPUT_DEFSYM defsym_expr
174	;
175
176
177filename:  NAME;
178
179
180defsym_expr:
181		{ ldlex_expression(); }
182		assignment
183		{ ldlex_popstate(); }
184	;
185
186/* SYNTAX WITHIN AN MRI SCRIPT FILE */
187mri_script_file:
188		{
189		  ldlex_mri_script ();
190		  PUSH_ERROR (_("MRI style script"));
191		}
192	     mri_script_lines
193		{
194		  ldlex_popstate ();
195		  mri_draw_tree ();
196		  POP_ERROR ();
197		}
198	;
199
200mri_script_lines:
201		mri_script_lines mri_script_command NEWLINE
202	|
203	;
204
205mri_script_command:
206		CHIP  exp
207	|	CHIP  exp ',' exp
208	|	NAME	{
209			einfo(_("%F%P: unrecognised keyword in MRI style script '%s'\n"),$1);
210			}
211	|	LIST	{
212			config.map_filename = "-";
213			}
214	|	ORDER ordernamelist
215	|	ENDWORD
216	|	PUBLIC NAME '=' exp
217			{ mri_public($2, $4); }
218	|	PUBLIC NAME ',' exp
219			{ mri_public($2, $4); }
220	|	PUBLIC NAME  exp
221			{ mri_public($2, $3); }
222	|	FORMAT NAME
223			{ mri_format($2); }
224	|	SECT NAME ',' exp
225			{ mri_output_section($2, $4);}
226	|	SECT NAME  exp
227			{ mri_output_section($2, $3);}
228	|	SECT NAME '=' exp
229			{ mri_output_section($2, $4);}
230	|	ALIGN_K NAME '=' exp
231			{ mri_align($2,$4); }
232	|	ALIGN_K NAME ',' exp
233			{ mri_align($2,$4); }
234	|	ALIGNMOD NAME '=' exp
235			{ mri_alignmod($2,$4); }
236	|	ALIGNMOD NAME ',' exp
237			{ mri_alignmod($2,$4); }
238	|	ABSOLUTE mri_abs_name_list
239	|	LOAD	 mri_load_name_list
240	|	NAMEWORD NAME
241			{ mri_name($2); }
242	|	ALIAS NAME ',' NAME
243			{ mri_alias($2,$4,0);}
244	|	ALIAS NAME ',' INT
245			{ mri_alias ($2, 0, (int) $4.integer); }
246	|	BASE	 exp
247			{ mri_base($2); }
248	|	TRUNCATE INT
249		{ mri_truncate ((unsigned int) $2.integer); }
250	|	CASE casesymlist
251	|	EXTERN extern_name_list
252	|	INCLUDE filename
253		{ ldfile_open_command_file ($2); }
254		mri_script_lines END
255	|	START NAME
256		{ lang_add_entry ($2, false); }
257	|
258	;
259
260ordernamelist:
261	      ordernamelist ',' NAME	     { mri_order($3); }
262	|     ordernamelist  NAME	  { mri_order($2); }
263	|
264	;
265
266mri_load_name_list:
267		NAME
268			{ mri_load($1); }
269	|	mri_load_name_list ',' NAME { mri_load($3); }
270	;
271
272mri_abs_name_list:
273		NAME
274			{ mri_only_load($1); }
275	|	mri_abs_name_list ','  NAME
276			{ mri_only_load($3); }
277	;
278
279casesymlist:
280	  /* empty */ { $$ = NULL; }
281	| NAME
282	| casesymlist ',' NAME
283	;
284
285extern_name_list:
286	NAME
287			{ ldlang_add_undef ($1, false); }
288	| extern_name_list NAME
289			{ ldlang_add_undef ($2, false); }
290	| extern_name_list ',' NAME
291			{ ldlang_add_undef ($3, false); }
292	;
293
294script_file:
295	{ ldlex_script (); }
296	ifile_list
297	{ ldlex_popstate (); }
298	;
299
300ifile_list:
301	ifile_list ifile_p1
302	|
303	;
304
305
306ifile_p1:
307		memory
308	|	sections
309	|	phdrs
310	|	startup
311	|	high_level_library
312	|	low_level_library
313	|	floating_point_support
314	|	statement_anywhere
315	|	version
316	|	 ';'
317	|	TARGET_K '(' NAME ')'
318		{ lang_add_target($3); }
319	|	SEARCH_DIR '(' filename ')'
320		{ ldfile_add_library_path ($3, false); }
321	|	OUTPUT '(' filename ')'
322		{ lang_add_output($3, 1); }
323	|	OUTPUT_FORMAT '(' NAME ')'
324		  { lang_add_output_format ($3, (char *) NULL,
325					    (char *) NULL, 1); }
326	|	OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
327		  { lang_add_output_format ($3, $5, $7, 1); }
328	|	OUTPUT_ARCH '(' NAME ')'
329		  { ldfile_set_output_arch ($3, bfd_arch_unknown); }
330	|	FORCE_COMMON_ALLOCATION
331		{ command_line.force_common_definition = true ; }
332	|	FORCE_GROUP_ALLOCATION
333		{ command_line.force_group_allocation = true ; }
334	|	INHIBIT_COMMON_ALLOCATION
335		{ link_info.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		{ ldfile_open_command_file ($2); }
345		ifile_list END
346	|	NOCROSSREFS '(' nocrossref_list ')'
347		{
348		  lang_add_nocrossref ($3);
349		}
350	|	NOCROSSREFS_TO '(' nocrossref_list ')'
351		{
352		  lang_add_nocrossref_to ($3);
353		}
354	|	EXTERN '(' { ldlex_expression (); } extern_name_list ')'
355			{ ldlex_popstate (); }
356	|	INSERT_K AFTER NAME
357		{ lang_add_insert ($3, 0); }
358	|	INSERT_K BEFORE NAME
359		{ lang_add_insert ($3, 1); }
360	|	REGION_ALIAS '(' NAME ',' NAME ')'
361		{ lang_memory_region_alias ($3, $5); }
362	|	LD_FEATURE '(' NAME ')'
363		{ lang_ld_feature ($3); }
364	;
365
366input_list:
367		{ ldlex_inputlist(); }
368		input_list1
369		{ ldlex_popstate(); }
370
371input_list1:
372		NAME
373		{ lang_add_input_file($1,lang_input_file_is_search_file_enum,
374				 (char *)NULL); }
375	|	input_list1 ',' NAME
376		{ lang_add_input_file($3,lang_input_file_is_search_file_enum,
377				 (char *)NULL); }
378	|	input_list1 NAME
379		{ lang_add_input_file($2,lang_input_file_is_search_file_enum,
380				 (char *)NULL); }
381	|	LNAME
382		{ lang_add_input_file($1,lang_input_file_is_l_enum,
383				 (char *)NULL); }
384	|	input_list1 ',' LNAME
385		{ lang_add_input_file($3,lang_input_file_is_l_enum,
386				 (char *)NULL); }
387	|	input_list1 LNAME
388		{ lang_add_input_file($2,lang_input_file_is_l_enum,
389				 (char *)NULL); }
390	|	AS_NEEDED '('
391		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
392		    input_flags.add_DT_NEEDED_for_regular = true; }
393		     input_list1 ')'
394		  { input_flags.add_DT_NEEDED_for_regular = $<integer>3; }
395	|	input_list1 ',' AS_NEEDED '('
396		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
397		    input_flags.add_DT_NEEDED_for_regular = true; }
398		     input_list1 ')'
399		  { input_flags.add_DT_NEEDED_for_regular = $<integer>5; }
400	|	input_list1 AS_NEEDED '('
401		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
402		    input_flags.add_DT_NEEDED_for_regular = true; }
403		     input_list1 ')'
404		  { input_flags.add_DT_NEEDED_for_regular = $<integer>4; }
405	;
406
407sections:
408		SECTIONS '{' sec_or_group_p1 '}'
409	;
410
411sec_or_group_p1:
412		sec_or_group_p1 section
413	|	sec_or_group_p1 statement_anywhere
414	|
415	;
416
417statement_anywhere:
418		ENTRY '(' NAME ')'
419		{ lang_add_entry ($3, false); }
420	|	assignment separator
421	|	ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
422		{ ldlex_popstate ();
423		  lang_add_assignment (exp_assert ($4, $6)); }
424	;
425
426wildcard_name:
427		NAME
428			{
429			  $$ = $1;
430			}
431	;
432
433wildcard_maybe_exclude:
434		wildcard_name
435			{
436			  $$.name = $1;
437			  $$.sorted = none;
438			  $$.exclude_name_list = NULL;
439			  $$.section_flag_list = NULL;
440			}
441	|	EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
442			{
443			  $$.name = $5;
444			  $$.sorted = none;
445			  $$.exclude_name_list = $3;
446			  $$.section_flag_list = NULL;
447			}
448	;
449
450filename_spec:
451		wildcard_maybe_exclude
452	|	SORT_BY_NAME '(' wildcard_maybe_exclude ')'
453			{
454			  $$ = $3;
455			  $$.sorted = by_name;
456			}
457	|	SORT_NONE '(' wildcard_maybe_exclude ')'
458			{
459			  $$ = $3;
460			  $$.sorted = by_none;
461			}
462	;
463
464section_name_spec:
465		wildcard_maybe_exclude
466	|	SORT_BY_NAME '(' wildcard_maybe_exclude ')'
467			{
468			  $$ = $3;
469			  $$.sorted = by_name;
470			}
471	|	SORT_BY_ALIGNMENT '(' wildcard_maybe_exclude ')'
472			{
473			  $$ = $3;
474			  $$.sorted = by_alignment;
475			}
476	|	SORT_NONE '(' wildcard_maybe_exclude ')'
477			{
478			  $$ = $3;
479			  $$.sorted = by_none;
480			}
481	|	SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_maybe_exclude ')' ')'
482			{
483			  $$ = $5;
484			  $$.sorted = by_name_alignment;
485			}
486	|	SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_maybe_exclude ')' ')'
487			{
488			  $$ = $5;
489			  $$.sorted = by_name;
490			}
491	|	SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_maybe_exclude ')' ')'
492			{
493			  $$ = $5;
494			  $$.sorted = by_alignment_name;
495			}
496	|	SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_maybe_exclude ')' ')'
497			{
498			  $$ = $5;
499			  $$.sorted = by_alignment;
500			}
501	|	SORT_BY_INIT_PRIORITY '(' wildcard_maybe_exclude ')'
502			{
503			  $$ = $3;
504			  $$.sorted = by_init_priority;
505			}
506	;
507
508sect_flag_list:	NAME
509			{
510			  struct flag_info_list *n;
511			  n = ((struct flag_info_list *) xmalloc (sizeof *n));
512			  if ($1[0] == '!')
513			    {
514			      n->with = without_flags;
515			      n->name = &$1[1];
516			    }
517			  else
518			    {
519			      n->with = with_flags;
520			      n->name = $1;
521			    }
522			  n->valid = false;
523			  n->next = NULL;
524			  $$ = n;
525			}
526	|	sect_flag_list '&' NAME
527			{
528			  struct flag_info_list *n;
529			  n = ((struct flag_info_list *) xmalloc (sizeof *n));
530			  if ($3[0] == '!')
531			    {
532			      n->with = without_flags;
533			      n->name = &$3[1];
534			    }
535			  else
536			    {
537			      n->with = with_flags;
538			      n->name = $3;
539			    }
540			  n->valid = false;
541			  n->next = $1;
542			  $$ = n;
543			}
544	;
545
546sect_flags:
547		INPUT_SECTION_FLAGS '(' sect_flag_list ')'
548			{
549			  struct flag_info *n;
550			  n = ((struct flag_info *) xmalloc (sizeof *n));
551			  n->flag_list = $3;
552			  n->flags_initialized = false;
553			  n->not_with_flags = 0;
554			  n->only_with_flags = 0;
555			  $$ = n;
556			}
557	;
558
559exclude_name_list:
560		exclude_name_list wildcard_name
561			{
562			  struct name_list *tmp;
563			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
564			  tmp->name = $2;
565			  tmp->next = $1;
566			  $$ = tmp;
567			}
568	|
569		wildcard_name
570			{
571			  struct name_list *tmp;
572			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
573			  tmp->name = $1;
574			  tmp->next = NULL;
575			  $$ = tmp;
576			}
577	;
578
579section_name_list:
580		section_name_list opt_comma section_name_spec
581			{
582			  struct wildcard_list *tmp;
583			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
584			  tmp->next = $1;
585			  tmp->spec = $3;
586			  $$ = tmp;
587			}
588	|
589		section_name_spec
590			{
591			  struct wildcard_list *tmp;
592			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
593			  tmp->next = NULL;
594			  tmp->spec = $1;
595			  $$ = tmp;
596			}
597	;
598
599input_section_spec_no_keep:
600		NAME
601			{
602			  struct wildcard_spec tmp;
603			  tmp.name = $1;
604			  tmp.exclude_name_list = NULL;
605			  tmp.sorted = none;
606			  tmp.section_flag_list = NULL;
607			  lang_add_wild (&tmp, NULL, ldgram_had_keep);
608			}
609	|	sect_flags NAME
610			{
611			  struct wildcard_spec tmp;
612			  tmp.name = $2;
613			  tmp.exclude_name_list = NULL;
614			  tmp.sorted = none;
615			  tmp.section_flag_list = $1;
616			  lang_add_wild (&tmp, NULL, ldgram_had_keep);
617			}
618	|	'[' section_name_list ']'
619			{
620			  lang_add_wild (NULL, $2, ldgram_had_keep);
621			}
622	|	sect_flags '[' section_name_list ']'
623			{
624			  struct wildcard_spec tmp;
625			  tmp.name = NULL;
626			  tmp.exclude_name_list = NULL;
627			  tmp.sorted = none;
628			  tmp.section_flag_list = $1;
629			  lang_add_wild (&tmp, $3, ldgram_had_keep);
630			}
631	|	filename_spec '(' section_name_list ')'
632			{
633			  lang_add_wild (&$1, $3, ldgram_had_keep);
634			}
635	|	sect_flags filename_spec '(' section_name_list ')'
636			{
637			  $2.section_flag_list = $1;
638			  lang_add_wild (&$2, $4, ldgram_had_keep);
639			}
640	;
641
642input_section_spec:
643		input_section_spec_no_keep
644	|	KEEP '('
645			{ ldgram_had_keep = true; }
646		input_section_spec_no_keep ')'
647			{ ldgram_had_keep = false; }
648	;
649
650statement:
651	';'
652	| assignment separator
653	| CREATE_OBJECT_SYMBOLS
654		{
655		  lang_add_attribute (lang_object_symbols_statement_enum);
656		}
657	| CONSTRUCTORS
658		{
659		  lang_add_attribute (lang_constructors_statement_enum);
660		}
661	| SORT_BY_NAME '(' CONSTRUCTORS ')'
662		{
663		  constructors_sorted = true;
664		  lang_add_attribute (lang_constructors_statement_enum);
665		}
666	| input_section_spec
667	| length '(' mustbe_exp ')'
668		{
669		  lang_add_data ((int) $1, $3);
670		}
671
672	| FILL '(' fill_exp ')'
673		{
674		  lang_add_fill ($3);
675		}
676	| ASSERT_K
677		{ ldlex_expression (); }
678	  '(' exp ',' NAME ')' separator
679		{
680		  ldlex_popstate ();
681		  lang_add_assignment (exp_assert ($4, $6));
682		}
683	| INCLUDE filename
684		{
685		  ldfile_open_command_file ($2);
686		}
687	  statement_list_opt END
688	;
689
690statement_list:
691		statement_list statement
692	|	statement
693	;
694
695statement_list_opt:
696		/* empty */
697	|	statement_list
698	;
699
700length:
701		QUAD
702			{ $$ = $1; }
703	|	SQUAD
704			{ $$ = $1; }
705	|	LONG
706			{ $$ = $1; }
707	|	SHORT
708			{ $$ = $1; }
709	|	BYTE
710			{ $$ = $1; }
711	;
712
713fill_exp:
714	mustbe_exp
715		{
716		  $$ = exp_get_fill ($1, 0, "fill value");
717		}
718	;
719
720fill_opt:
721	  '=' fill_exp
722		{ $$ = $2; }
723	|	{ $$ = (fill_type *) 0; }
724	;
725
726assign_op:
727		PLUSEQ
728			{ $$ = '+'; }
729	|	MINUSEQ
730			{ $$ = '-'; }
731	|	MULTEQ
732			{ $$ = '*'; }
733	|	DIVEQ
734			{ $$ = '/'; }
735	|	LSHIFTEQ
736			{ $$ = LSHIFT; }
737	|	RSHIFTEQ
738			{ $$ = RSHIFT; }
739	|	ANDEQ
740			{ $$ = '&'; }
741	|	OREQ
742			{ $$ = '|'; }
743
744	;
745
746separator:	';' | ','
747	;
748
749
750assignment:
751		NAME '=' mustbe_exp
752		{
753		  lang_add_assignment (exp_assign ($1, $3, false));
754		}
755	|	NAME assign_op mustbe_exp
756		{
757		  lang_add_assignment (exp_assign ($1,
758						   exp_binop ($2,
759							      exp_nameop (NAME,
760									  $1),
761							      $3), false));
762		}
763	|	HIDDEN '(' NAME '=' mustbe_exp ')'
764		{
765		  lang_add_assignment (exp_assign ($3, $5, true));
766		}
767	|	PROVIDE '(' NAME '=' mustbe_exp ')'
768		{
769		  lang_add_assignment (exp_provide ($3, $5, false));
770		}
771	|	PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
772		{
773		  lang_add_assignment (exp_provide ($3, $5, true));
774		}
775	;
776
777
778opt_comma:
779		','	|	;
780
781
782memory:
783		MEMORY '{' memory_spec_list_opt '}'
784	;
785
786memory_spec_list_opt: memory_spec_list | ;
787
788memory_spec_list:
789		memory_spec_list opt_comma memory_spec
790	|	memory_spec
791	;
792
793
794memory_spec:	NAME
795		{ region = lang_memory_region_lookup ($1, true); }
796		attributes_opt ':'
797		origin_spec opt_comma length_spec
798		{}
799	|	INCLUDE filename
800		{ ldfile_open_command_file ($2); }
801		memory_spec_list_opt END
802	;
803
804origin_spec:
805	ORIGIN '=' mustbe_exp
806		{
807		  region->origin_exp = $3;
808		}
809	;
810
811length_spec:
812	     LENGTH '=' mustbe_exp
813		{
814		  if (yychar == NAME)
815		    {
816		      yyclearin;
817		      ldlex_backup ();
818		    }
819		  region->length_exp = $3;
820		}
821	;
822
823attributes_opt:
824		/* empty */
825		  { /* dummy action to avoid bison 1.25 error message */ }
826	|	'(' attributes_list ')'
827	;
828
829attributes_list:
830		attributes_string
831	|	attributes_list attributes_string
832	;
833
834attributes_string:
835		NAME
836		  { lang_set_flags (region, $1, 0); }
837	|	'!' NAME
838		  { lang_set_flags (region, $2, 1); }
839	;
840
841startup:
842	STARTUP '(' filename ')'
843		{ lang_startup($3); }
844	;
845
846high_level_library:
847		HLL '(' high_level_library_NAME_list ')'
848	|	HLL '(' ')'
849			{ ldemul_hll((char *)NULL); }
850	;
851
852high_level_library_NAME_list:
853		high_level_library_NAME_list opt_comma filename
854			{ ldemul_hll($3); }
855	|	filename
856			{ ldemul_hll($1); }
857	;
858
859low_level_library:
860	SYSLIB '(' low_level_library_NAME_list ')'
861	;
862
863low_level_library_NAME_list:
864		low_level_library_NAME_list opt_comma filename
865			{ ldemul_syslib($3); }
866	|
867	;
868
869floating_point_support:
870		FLOAT
871			{ lang_float(true); }
872	|	NOFLOAT
873			{ lang_float(false); }
874	;
875
876nocrossref_list:
877		/* empty */
878		{
879		  $$ = NULL;
880		}
881	|	NAME nocrossref_list
882		{
883		  struct lang_nocrossref *n;
884
885		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
886		  n->name = $1;
887		  n->next = $2;
888		  $$ = n;
889		}
890	|	NAME ',' nocrossref_list
891		{
892		  struct lang_nocrossref *n;
893
894		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
895		  n->name = $1;
896		  n->next = $3;
897		  $$ = n;
898		}
899	;
900
901paren_script_name:	{ ldlex_script (); }
902		'(' NAME ')'
903			{ ldlex_popstate (); $$ = $3; }
904
905mustbe_exp:		{ ldlex_expression (); }
906		exp
907			{ ldlex_popstate (); $$ = $2; }
908	;
909
910exp	:
911		'-' exp %prec UNARY
912			{ $$ = exp_unop ('-', $2); }
913	|	'(' exp ')'
914			{ $$ = $2; }
915	|	NEXT '(' exp ')' %prec UNARY
916			{ $$ = exp_unop ((int) $1,$3); }
917	|	'!' exp %prec UNARY
918			{ $$ = exp_unop ('!', $2); }
919	|	'+' exp %prec UNARY
920			{ $$ = $2; }
921	|	'~' exp %prec UNARY
922			{ $$ = exp_unop ('~', $2);}
923
924	|	exp '*' exp
925			{ $$ = exp_binop ('*', $1, $3); }
926	|	exp '/' exp
927			{ $$ = exp_binop ('/', $1, $3); }
928	|	exp '%' exp
929			{ $$ = exp_binop ('%', $1, $3); }
930	|	exp '+' exp
931			{ $$ = exp_binop ('+', $1, $3); }
932	|	exp '-' exp
933			{ $$ = exp_binop ('-' , $1, $3); }
934	|	exp LSHIFT exp
935			{ $$ = exp_binop (LSHIFT , $1, $3); }
936	|	exp RSHIFT exp
937			{ $$ = exp_binop (RSHIFT , $1, $3); }
938	|	exp EQ exp
939			{ $$ = exp_binop (EQ , $1, $3); }
940	|	exp NE exp
941			{ $$ = exp_binop (NE , $1, $3); }
942	|	exp LE exp
943			{ $$ = exp_binop (LE , $1, $3); }
944	|	exp GE exp
945			{ $$ = exp_binop (GE , $1, $3); }
946	|	exp '<' exp
947			{ $$ = exp_binop ('<' , $1, $3); }
948	|	exp '>' exp
949			{ $$ = exp_binop ('>' , $1, $3); }
950	|	exp '&' exp
951			{ $$ = exp_binop ('&' , $1, $3); }
952	|	exp '^' exp
953			{ $$ = exp_binop ('^' , $1, $3); }
954	|	exp '|' exp
955			{ $$ = exp_binop ('|' , $1, $3); }
956	|	exp '?' exp ':' exp
957			{ $$ = exp_trinop ('?' , $1, $3, $5); }
958	|	exp ANDAND exp
959			{ $$ = exp_binop (ANDAND , $1, $3); }
960	|	exp OROR exp
961			{ $$ = exp_binop (OROR , $1, $3); }
962	|	DEFINED '(' NAME ')'
963			{ $$ = exp_nameop (DEFINED, $3); }
964	|	INT
965			{ $$ = exp_bigintop ($1.integer, $1.str); }
966	|	SIZEOF_HEADERS
967			{ $$ = exp_nameop (SIZEOF_HEADERS,0); }
968
969	|	ALIGNOF paren_script_name
970			{ $$ = exp_nameop (ALIGNOF, $2); }
971	|	SIZEOF	paren_script_name
972			{ $$ = exp_nameop (SIZEOF, $2); }
973	|	ADDR	paren_script_name
974			{ $$ = exp_nameop (ADDR, $2); }
975	|	LOADADDR paren_script_name
976			{ $$ = exp_nameop (LOADADDR, $2); }
977	|	CONSTANT '(' NAME ')'
978			{ $$ = exp_nameop (CONSTANT,$3); }
979	|	ABSOLUTE '(' exp ')'
980			{ $$ = exp_unop (ABSOLUTE, $3); }
981	|	ALIGN_K '(' exp ')'
982			{ $$ = exp_unop (ALIGN_K,$3); }
983	|	ALIGN_K '(' exp ',' exp ')'
984			{ $$ = exp_binop (ALIGN_K,$3,$5); }
985	|	DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
986			{ $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
987	|	DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
988			{ $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
989	|	DATA_SEGMENT_END '(' exp ')'
990			{ $$ = exp_unop (DATA_SEGMENT_END, $3); }
991	|	SEGMENT_START { ldlex_script (); } '(' NAME
992			{ ldlex_popstate (); } ',' exp ')'
993			{ /* The operands to the expression node are
994			     placed in the opposite order from the way
995			     in which they appear in the script as
996			     that allows us to reuse more code in
997			     fold_binary.  */
998			  $$ = exp_binop (SEGMENT_START,
999					  $7,
1000					  exp_nameop (NAME, $4)); }
1001	|	BLOCK '(' exp ')'
1002			{ $$ = exp_unop (ALIGN_K,$3); }
1003	|	NAME
1004			{ $$ = exp_nameop (NAME,$1); }
1005	|	MAX_K '(' exp ',' exp ')'
1006			{ $$ = exp_binop (MAX_K, $3, $5 ); }
1007	|	MIN_K '(' exp ',' exp ')'
1008			{ $$ = exp_binop (MIN_K, $3, $5 ); }
1009	|	ASSERT_K '(' exp ',' NAME ')'
1010			{ $$ = exp_assert ($3, $5); }
1011	|	ORIGIN paren_script_name
1012			{ $$ = exp_nameop (ORIGIN, $2); }
1013	|	LENGTH paren_script_name
1014			{ $$ = exp_nameop (LENGTH, $2); }
1015	|	LOG2CEIL '(' exp ')'
1016			{ $$ = exp_unop (LOG2CEIL, $3); }
1017	;
1018
1019
1020memspec_at_opt:
1021		AT '>' NAME { $$ = $3; }
1022	|	{ $$ = 0; }
1023	;
1024
1025opt_at:
1026		AT '(' exp ')' { $$ = $3; }
1027	|	{ $$ = 0; }
1028	;
1029
1030opt_align:
1031		ALIGN_K '(' exp ')' { $$ = $3; }
1032	|	{ $$ = 0; }
1033	;
1034
1035opt_align_with_input:
1036		ALIGN_WITH_INPUT { $$ = ALIGN_WITH_INPUT; }
1037	|	{ $$ = 0; }
1038	;
1039
1040opt_subalign:
1041		SUBALIGN '(' exp ')' { $$ = $3; }
1042	|	{ $$ = 0; }
1043	;
1044
1045sect_constraint:
1046		ONLY_IF_RO { $$ = ONLY_IF_RO; }
1047	|	ONLY_IF_RW { $$ = ONLY_IF_RW; }
1048	|	SPECIAL { $$ = SPECIAL; }
1049	|	{ $$ = 0; }
1050	;
1051
1052section:	NAME
1053			{ ldlex_expression(); }
1054		opt_exp_with_type
1055		opt_at
1056		opt_align
1057		opt_align_with_input
1058		opt_subalign
1059		sect_constraint
1060			{
1061			  ldlex_popstate ();
1062			  ldlex_wild ();
1063			  lang_enter_output_section_statement ($1, $3, sectype,
1064					sectype_value, $5, $7, $4, $8, $6);
1065			}
1066		'{'
1067		statement_list_opt
1068		'}'
1069			{ ldlex_popstate (); }
1070		memspec_opt memspec_at_opt phdr_opt fill_opt
1071			{
1072			  /* fill_opt may have switched the lexer into
1073			     expression state, and back again, but in
1074			     order to find the end of the fill
1075			     expression the parser must look ahead one
1076			     token.  If it is a NAME, throw it away as
1077			     it will have been lexed in the wrong
1078			     state.  */
1079			  if (yychar == NAME)
1080			    {
1081			      yyclearin;
1082			      ldlex_backup ();
1083			    }
1084			  lang_leave_output_section_statement ($17, $14,
1085							       $16, $15);
1086			}
1087		opt_comma
1088	|	OVERLAY
1089			{ ldlex_expression (); }
1090		opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
1091			{ ldlex_popstate (); }
1092		'{'
1093			{
1094			  lang_enter_overlay ($3, $6);
1095			}
1096		overlay_section
1097		'}'
1098		memspec_opt memspec_at_opt phdr_opt fill_opt
1099			{
1100			  if (yychar == NAME)
1101			    {
1102			      yyclearin;
1103			      ldlex_backup ();
1104			    }
1105			  lang_leave_overlay ($5, (int) $4,
1106					      $15, $12, $14, $13);
1107			}
1108		opt_comma
1109	|	/* The GROUP case is just enough to support the gcc
1110		   svr3.ifile script.  It is not intended to be full
1111		   support.  I'm not even sure what GROUP is supposed
1112		   to mean.  */
1113		GROUP
1114			{ ldlex_expression (); }
1115		opt_exp_with_type
1116			{
1117			  ldlex_popstate ();
1118			  lang_add_assignment (exp_assign (".", $3, false));
1119			}
1120		'{' sec_or_group_p1 '}'
1121	|	INCLUDE filename
1122			{
1123			  ldfile_open_command_file ($2);
1124			}
1125		sec_or_group_p1 END
1126	;
1127
1128type:
1129	   NOLOAD  { sectype = noload_section; }
1130	|  DSECT   { sectype = noalloc_section; }
1131	|  COPY    { sectype = noalloc_section; }
1132	|  INFO    { sectype = noalloc_section; }
1133	|  OVERLAY { sectype = noalloc_section; }
1134        |  READONLY '(' TYPE '=' exp ')' { sectype = typed_readonly_section; sectype_value = $5; }
1135	|  READONLY { sectype = readonly_section; }
1136	|  TYPE '=' exp { sectype = type_section; sectype_value = $3; }
1137        ;
1138
1139atype:
1140		'(' type ')'
1141	|	/* EMPTY */ { sectype = normal_section; }
1142	|	'(' ')' { sectype = normal_section; }
1143	;
1144
1145opt_exp_with_type:
1146		exp atype ':'		{ $$ = $1; }
1147	|	atype ':'		{ $$ = (etree_type *)NULL;  }
1148	|	/* The BIND cases are to support the gcc svr3.ifile
1149		   script.  They aren't intended to implement full
1150		   support for the BIND keyword.  I'm not even sure
1151		   what BIND is supposed to mean.  */
1152		BIND '(' exp ')' atype ':' { $$ = $3; }
1153	|	BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
1154		{ $$ = $3; }
1155	;
1156
1157opt_exp_without_type:
1158		exp ':'		{ $$ = $1; }
1159	|	':'		{ $$ = (etree_type *) NULL;  }
1160	;
1161
1162opt_nocrossrefs:
1163		/* empty */
1164			{ $$ = 0; }
1165	|	NOCROSSREFS
1166			{ $$ = 1; }
1167	;
1168
1169memspec_opt:
1170		'>' NAME
1171		{ $$ = $2; }
1172	|	{ $$ = DEFAULT_MEMORY_REGION; }
1173	;
1174
1175phdr_opt:
1176		/* empty */
1177		{
1178		  $$ = NULL;
1179		}
1180	|	phdr_opt ':' NAME
1181		{
1182		  struct lang_output_section_phdr_list *n;
1183
1184		  n = ((struct lang_output_section_phdr_list *)
1185		       xmalloc (sizeof *n));
1186		  n->name = $3;
1187		  n->used = false;
1188		  n->next = $1;
1189		  $$ = n;
1190		}
1191	;
1192
1193overlay_section:
1194		/* empty */
1195	|	overlay_section
1196		NAME
1197			{
1198			  ldlex_wild ();
1199			  lang_enter_overlay_section ($2);
1200			}
1201		'{'
1202		statement_list_opt
1203		'}'
1204			{ ldlex_popstate (); }
1205		phdr_opt fill_opt
1206			{
1207			  if (yychar == NAME)
1208			    {
1209			      yyclearin;
1210			      ldlex_backup ();
1211			    }
1212			  lang_leave_overlay_section ($9, $8);
1213			}
1214		opt_comma
1215	;
1216
1217phdrs:
1218		PHDRS '{' phdr_list '}'
1219	;
1220
1221phdr_list:
1222		/* empty */
1223	|	phdr_list phdr
1224	;
1225
1226phdr:
1227		NAME { ldlex_expression (); }
1228		  phdr_type phdr_qualifiers { ldlex_popstate (); }
1229		  ';'
1230		{
1231		  lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1232				 $4.flags);
1233		}
1234	;
1235
1236phdr_type:
1237		exp
1238		{
1239		  $$ = $1;
1240
1241		  if ($1->type.node_class == etree_name
1242		      && $1->type.node_code == NAME)
1243		    {
1244		      const char *s;
1245		      unsigned int i;
1246		      static const char * const phdr_types[] =
1247			{
1248			  "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1249			  "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1250			  "PT_PHDR", "PT_TLS"
1251			};
1252
1253		      s = $1->name.name;
1254		      for (i = 0;
1255			   i < sizeof phdr_types / sizeof phdr_types[0];
1256			   i++)
1257			if (strcmp (s, phdr_types[i]) == 0)
1258			  {
1259			    $$ = exp_intop (i);
1260			    break;
1261			  }
1262		      if (i == sizeof phdr_types / sizeof phdr_types[0])
1263			{
1264			  if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1265			    $$ = exp_intop (0x6474e550);
1266			  else if (strcmp (s, "PT_GNU_STACK") == 0)
1267			    $$ = exp_intop (0x6474e551);
1268			  else if (strcmp (s, "PT_GNU_RELRO") == 0)
1269			    $$ = exp_intop (0x6474e552);
1270			  else if (strcmp (s, "PT_GNU_PROPERTY") == 0)
1271			    $$ = exp_intop (0x6474e553);
1272			  else
1273			    {
1274			      einfo (_("\
1275%X%P:%pS: unknown phdr type `%s' (try integer literal)\n"),
1276				     NULL, s);
1277			      $$ = exp_intop (0);
1278			    }
1279			}
1280		    }
1281		}
1282	;
1283
1284phdr_qualifiers:
1285		/* empty */
1286		{
1287		  memset (&$$, 0, sizeof (struct phdr_info));
1288		}
1289	|	NAME phdr_val phdr_qualifiers
1290		{
1291		  $$ = $3;
1292		  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1293		    $$.filehdr = true;
1294		  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1295		    $$.phdrs = true;
1296		  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1297		    $$.flags = $2;
1298		  else
1299		    einfo (_("%X%P:%pS: PHDRS syntax error at `%s'\n"),
1300			   NULL, $1);
1301		}
1302	|	AT '(' exp ')' phdr_qualifiers
1303		{
1304		  $$ = $5;
1305		  $$.at = $3;
1306		}
1307	;
1308
1309phdr_val:
1310		/* empty */
1311		{
1312		  $$ = NULL;
1313		}
1314	| '(' exp ')'
1315		{
1316		  $$ = $2;
1317		}
1318	;
1319
1320dynamic_list_file:
1321		{
1322		  ldlex_version_file ();
1323		  PUSH_ERROR (_("dynamic list"));
1324		}
1325		dynamic_list_nodes
1326		{
1327		  ldlex_popstate ();
1328		  POP_ERROR ();
1329		}
1330	;
1331
1332dynamic_list_nodes:
1333		dynamic_list_node
1334	|	dynamic_list_nodes dynamic_list_node
1335	;
1336
1337dynamic_list_node:
1338		'{' dynamic_list_tag '}' ';'
1339	;
1340
1341dynamic_list_tag:
1342		vers_defns ';'
1343		{
1344		  lang_append_dynamic_list (current_dynamic_list_p, $1);
1345		}
1346	;
1347
1348/* This syntax is used within an external version script file.  */
1349
1350version_script_file:
1351		{
1352		  ldlex_version_file ();
1353		  PUSH_ERROR (_("VERSION script"));
1354		}
1355		vers_nodes
1356		{
1357		  ldlex_popstate ();
1358		  POP_ERROR ();
1359		}
1360	;
1361
1362/* This is used within a normal linker script file.  */
1363
1364version:
1365		{
1366		  ldlex_version_script ();
1367		}
1368		VERSIONK '{' vers_nodes '}'
1369		{
1370		  ldlex_popstate ();
1371		}
1372	;
1373
1374vers_nodes:
1375		vers_node
1376	|	vers_nodes vers_node
1377	;
1378
1379vers_node:
1380		'{' vers_tag '}' ';'
1381		{
1382		  lang_register_vers_node (NULL, $2, NULL);
1383		}
1384	|	VERS_TAG '{' vers_tag '}' ';'
1385		{
1386		  lang_register_vers_node ($1, $3, NULL);
1387		}
1388	|	VERS_TAG '{' vers_tag '}' verdep ';'
1389		{
1390		  lang_register_vers_node ($1, $3, $5);
1391		}
1392	;
1393
1394verdep:
1395		VERS_TAG
1396		{
1397		  $$ = lang_add_vers_depend (NULL, $1);
1398		}
1399	|	verdep VERS_TAG
1400		{
1401		  $$ = lang_add_vers_depend ($1, $2);
1402		}
1403	;
1404
1405vers_tag:
1406		/* empty */
1407		{
1408		  $$ = lang_new_vers_node (NULL, NULL);
1409		}
1410	|	vers_defns ';'
1411		{
1412		  $$ = lang_new_vers_node ($1, NULL);
1413		}
1414	|	GLOBAL ':' vers_defns ';'
1415		{
1416		  $$ = lang_new_vers_node ($3, NULL);
1417		}
1418	|	LOCAL ':' vers_defns ';'
1419		{
1420		  $$ = lang_new_vers_node (NULL, $3);
1421		}
1422	|	GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1423		{
1424		  $$ = lang_new_vers_node ($3, $7);
1425		}
1426	;
1427
1428vers_defns:
1429		VERS_IDENTIFIER
1430		{
1431		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, false);
1432		}
1433	|	NAME
1434		{
1435		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, true);
1436		}
1437	|	vers_defns ';' VERS_IDENTIFIER
1438		{
1439		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, false);
1440		}
1441	|	vers_defns ';' NAME
1442		{
1443		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, true);
1444		}
1445	|	vers_defns ';' EXTERN NAME '{'
1446			{
1447			  $<name>$ = ldgram_vers_current_lang;
1448			  ldgram_vers_current_lang = $4;
1449			}
1450		vers_defns opt_semicolon '}'
1451			{
1452			  struct bfd_elf_version_expr *pat;
1453			  for (pat = $7; pat->next != NULL; pat = pat->next);
1454			  pat->next = $1;
1455			  $$ = $7;
1456			  ldgram_vers_current_lang = $<name>6;
1457			}
1458	|	EXTERN NAME '{'
1459			{
1460			  $<name>$ = ldgram_vers_current_lang;
1461			  ldgram_vers_current_lang = $2;
1462			}
1463		vers_defns opt_semicolon '}'
1464			{
1465			  $$ = $5;
1466			  ldgram_vers_current_lang = $<name>4;
1467			}
1468	|	GLOBAL
1469		{
1470		  $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, false);
1471		}
1472	|	vers_defns ';' GLOBAL
1473		{
1474		  $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, false);
1475		}
1476	|	LOCAL
1477		{
1478		  $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, false);
1479		}
1480	|	vers_defns ';' LOCAL
1481		{
1482		  $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, false);
1483		}
1484	|	EXTERN
1485		{
1486		  $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, false);
1487		}
1488	|	vers_defns ';' EXTERN
1489		{
1490		  $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, false);
1491		}
1492	;
1493
1494opt_semicolon:
1495		/* empty */
1496	|	';'
1497	;
1498
1499%%
1500void
1501yyerror(arg)
1502     const char *arg;
1503{
1504  if (ldfile_assumed_script)
1505    einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1506	   ldlex_filename ());
1507  if (error_index > 0 && error_index < ERROR_NAME_MAX)
1508    einfo ("%F%P:%pS: %s in %s\n", NULL, arg, error_names[error_index - 1]);
1509  else
1510    einfo ("%F%P:%pS: %s\n", NULL, arg);
1511}
1512