ld/ldgram.y

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