ld/ldgram.y

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