ld/ldgram.y

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