ld/ldgram.y

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