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