ld/ldgram.y

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