ld/ldgram.y

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