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
 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_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
 471                         {
 472                           $$.name = $5;
 473                           $$.sorted = by_name_alignment;
 474                           $$.exclude_name_list = NULL;
 475                           $$.section_flag_list = NULL;
 476                         }
 477         |       SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
 478                         {
 479                           $$.name = $5;
 480                           $$.sorted = by_name;
 481                           $$.exclude_name_list = NULL;
 482                           $$.section_flag_list = NULL;
 483                         }
 484         |       SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
 485                         {
 486                           $$.name = $5;
 487                           $$.sorted = by_alignment_name;
 488                           $$.exclude_name_list = NULL;
 489                           $$.section_flag_list = NULL;
 490                         }
 491         |       SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
 492                         {
 493                           $$.name = $5;
 494                           $$.sorted = by_alignment;
 495                           $$.exclude_name_list = NULL;
 496                           $$.section_flag_list = NULL;
 497                         }
 498         |       SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
 499                         {
 500                           $$.name = $7;
 501                           $$.sorted = by_name;
 502                           $$.exclude_name_list = $5;
 503                           $$.section_flag_list = NULL;
 504                         }
 505         |       SORT_BY_INIT_PRIORITY '(' wildcard_name ')'
 506                         {
 507                           $$.name = $3;
 508                           $$.sorted = by_init_priority;
 509                           $$.exclude_name_list = NULL;
 510                           $$.section_flag_list = NULL;
 511                         }
 512         ;
 513
 514 sect_flag_list: NAME
 515                         {
 516                           struct flag_info_list *n;
 517                           n = ((struct flag_info_list *) xmalloc (sizeof *n));
 518                           if ($1[0] == '!')
 519                             {
 520                               n->with = without_flags;
 521                               n->name = &$1[1];
 522                             }
 523                           else
 524                             {
 525                               n->with = with_flags;
 526                               n->name = $1;
 527                             }
 528                           n->valid = FALSE;
 529                           n->next = NULL;
 530                           $$ = n;
 531                         }
 532         |       sect_flag_list '&' NAME
 533                         {
 534                           struct flag_info_list *n;
 535                           n = ((struct flag_info_list *) xmalloc (sizeof *n));
 536                           if ($3[0] == '!')
 537                             {
 538                               n->with = without_flags;
 539                               n->name = &$3[1];
 540                             }
 541                           else
 542                             {
 543                               n->with = with_flags;
 544                               n->name = $3;
 545                             }
 546                           n->valid = FALSE;
 547                           n->next = $1;
 548                           $$ = n;
 549                         }
 550         ;
 551
 552 sect_flags:
 553                 INPUT_SECTION_FLAGS '(' sect_flag_list ')'
 554                         {
 555                           struct flag_info *n;
 556                           n = ((struct flag_info *) xmalloc (sizeof *n));
 557                           n->flag_list = $3;
 558                           n->flags_initialized = FALSE;
 559                           n->not_with_flags = 0;
 560                           n->only_with_flags = 0;
 561                           $$ = n;
 562                         }
 563         ;
 564
 565 exclude_name_list:
 566                 exclude_name_list wildcard_name
 567                         {
 568                           struct name_list *tmp;
 569                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
 570                           tmp->name = $2;
 571                           tmp->next = $1;
 572                           $$ = tmp;
 573                         }
 574         |
 575                 wildcard_name
 576                         {
 577                           struct name_list *tmp;
 578                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
 579                           tmp->name = $1;
 580                           tmp->next = NULL;
 581                           $$ = tmp;
 582                         }
 583         ;
 584
 585 file_NAME_list:
 586                 file_NAME_list opt_comma wildcard_spec
 587                         {
 588                           struct wildcard_list *tmp;
 589                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
 590                           tmp->next = $1;
 591                           tmp->spec = $3;
 592                           $$ = tmp;
 593                         }
 594         |
 595                 wildcard_spec
 596                         {
 597                           struct wildcard_list *tmp;
 598                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
 599                           tmp->next = NULL;
 600                           tmp->spec = $1;
 601                           $$ = tmp;
 602                         }
 603         ;
 604
 605 input_section_spec_no_keep:
 606                 NAME
 607                         {
 608                           struct wildcard_spec tmp;
 609                           tmp.name = $1;
 610                           tmp.exclude_name_list = NULL;
 611                           tmp.sorted = none;
 612                           tmp.section_flag_list = NULL;
 613                           lang_add_wild (&tmp, NULL, ldgram_had_keep);
 614                         }
 615         |       sect_flags NAME
 616                         {
 617                           struct wildcard_spec tmp;
 618                           tmp.name = $2;
 619                           tmp.exclude_name_list = NULL;
 620                           tmp.sorted = none;
 621                           tmp.section_flag_list = $1;
 622                           lang_add_wild (&tmp, NULL, ldgram_had_keep);
 623                         }
 624         |       '[' file_NAME_list ']'
 625                         {
 626                           lang_add_wild (NULL, $2, ldgram_had_keep);
 627                         }
 628         |       sect_flags '[' file_NAME_list ']'
 629                         {
 630                           struct wildcard_spec tmp;
 631                           tmp.name = NULL;
 632                           tmp.exclude_name_list = NULL;
 633                           tmp.sorted = none;
 634                           tmp.section_flag_list = $1;
 635                           lang_add_wild (&tmp, $3, ldgram_had_keep);
 636                         }
 637         |       wildcard_spec '(' file_NAME_list ')'
 638                         {
 639                           lang_add_wild (&$1, $3, ldgram_had_keep);
 640                         }
 641         |       sect_flags wildcard_spec '(' file_NAME_list ')'
 642                         {
 643                           $2.section_flag_list = $1;
 644                           lang_add_wild (&$2, $4, ldgram_had_keep);
 645                         }
 646         ;
 647
 648 input_section_spec:
 649                 input_section_spec_no_keep
 650         |       KEEP '('
 651                         { ldgram_had_keep = TRUE; }
 652                 input_section_spec_no_keep ')'
 653                         { ldgram_had_keep = FALSE; }
 654         ;
 655
 656 statement:
 657                 assignment end
 658         |       CREATE_OBJECT_SYMBOLS
 659                 {
 660                 lang_add_attribute(lang_object_symbols_statement_enum);
 661                 }
 662         |       ';'
 663         |       CONSTRUCTORS
 664                 {
 665
 666                   lang_add_attribute(lang_constructors_statement_enum);
 667                 }
 668         | SORT_BY_NAME '(' CONSTRUCTORS ')'
 669                 {
 670                   constructors_sorted = TRUE;
 671                   lang_add_attribute (lang_constructors_statement_enum);
 672                 }
 673         | input_section_spec
 674         | length '(' mustbe_exp ')'
 675                         {
 676                           lang_add_data ((int) $1, $3);
 677                         }
 678
 679         | FILL '(' fill_exp ')'
 680                         {
 681                           lang_add_fill ($3);
 682                         }
 683         | ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
 684                         { ldlex_popstate ();
 685                           lang_add_assignment (exp_assert ($4, $6)); }
 686         | INCLUDE filename
 687                 { ldlex_script (); ldfile_open_command_file($2); }
 688                 statement_list_opt END
 689                 { ldlex_popstate (); }
 690         ;
 691
 692 statement_list:
 693                 statement_list statement
 694         |       statement
 695         ;
 696
 697 statement_list_opt:
 698                 /* empty */
 699         |       statement_list
 700         ;
 701
 702 length:
 703                 QUAD
 704                         { $$ = $1; }
 705         |       SQUAD
 706                         { $$ = $1; }
 707         |       LONG
 708                         { $$ = $1; }
 709         |       SHORT
 710                         { $$ = $1; }
 711         |       BYTE
 712                         { $$ = $1; }
 713         ;
 714
 715 fill_exp:
 716         mustbe_exp
 717                 {
 718                   $$ = exp_get_fill ($1, 0, "fill value");
 719                 }
 720         ;
 721
 722 fill_opt:
 723           '=' fill_exp
 724                 { $$ = $2; }
 725         |       { $$ = (fill_type *) 0; }
 726         ;
 727
 728 assign_op:
 729                 PLUSEQ
 730                         { $$ = '+'; }
 731         |       MINUSEQ
 732                         { $$ = '-'; }
 733         |       MULTEQ
 734                         { $$ = '*'; }
 735         |       DIVEQ
 736                         { $$ = '/'; }
 737         |       LSHIFTEQ
 738                         { $$ = LSHIFT; }
 739         |       RSHIFTEQ
 740                         { $$ = RSHIFT; }
 741         |       ANDEQ
 742                         { $$ = '&'; }
 743         |       OREQ
 744                         { $$ = '|'; }
 745
 746         ;
 747
 748 end:    ';' | ','
 749         ;
 750
 751
 752 assignment:
 753                 NAME '=' mustbe_exp
 754                 {
 755                   lang_add_assignment (exp_assign ($1, $3));
 756                 }
 757         |       NAME assign_op mustbe_exp
 758                 {
 759                   lang_add_assignment (exp_assign ($1,
 760                                                    exp_binop ($2,
 761                                                               exp_nameop (NAME,
 762                                                                           $1),
 763                                                               $3)));
 764                 }
 765         |       PROVIDE '(' NAME '=' mustbe_exp ')'
 766                 {
 767                   lang_add_assignment (exp_provide ($3, $5, FALSE));
 768                 }
 769         |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
 770                 {
 771                   lang_add_assignment (exp_provide ($3, $5, TRUE));
 772                 }
 773         ;
 774
 775
 776 opt_comma:
 777                 ','     |       ;
 778
 779
 780 memory:
 781                 MEMORY '{' memory_spec_list_opt '}'
 782         ;
 783
 784 memory_spec_list_opt: memory_spec_list | ;
 785
 786 memory_spec_list:
 787                 memory_spec_list opt_comma memory_spec
 788         |       memory_spec
 789         ;
 790
 791
 792 memory_spec:    NAME
 793                 { region = lang_memory_region_lookup ($1, TRUE); }
 794                 attributes_opt ':'
 795                 origin_spec opt_comma length_spec
 796                 {}
 797         |       INCLUDE filename
 798                 { ldlex_script (); ldfile_open_command_file($2); }
 799                 memory_spec_list_opt END
 800                 { ldlex_popstate (); }
 801         ;
 802
 803 origin_spec:
 804         ORIGIN '=' mustbe_exp
 805                 {
 806                   region->origin = exp_get_vma ($3, 0, "origin");
 807                   region->current = region->origin;
 808                 }
 809         ;
 810
 811 length_spec:
 812              LENGTH '=' mustbe_exp
 813                 {
 814                   region->length = exp_get_vma ($3, -1, "length");
 815                 }
 816         ;
 817
 818 attributes_opt:
 819                 /* empty */
 820                   { /* dummy action to avoid bison 1.25 error message */ }
 821         |       '(' attributes_list ')'
 822         ;
 823
 824 attributes_list:
 825                 attributes_string
 826         |       attributes_list attributes_string
 827         ;
 828
 829 attributes_string:
 830                 NAME
 831                   { lang_set_flags (region, $1, 0); }
 832         |       '!' NAME
 833                   { lang_set_flags (region, $2, 1); }
 834         ;
 835
 836 startup:
 837         STARTUP '(' filename ')'
 838                 { lang_startup($3); }
 839         ;
 840
 841 high_level_library:
 842                 HLL '(' high_level_library_NAME_list ')'
 843         |       HLL '(' ')'
 844                         { ldemul_hll((char *)NULL); }
 845         ;
 846
 847 high_level_library_NAME_list:
 848                 high_level_library_NAME_list opt_comma filename
 849                         { ldemul_hll($3); }
 850         |       filename
 851                         { ldemul_hll($1); }
 852
 853         ;
 854
 855 low_level_library:
 856         SYSLIB '(' low_level_library_NAME_list ')'
 857         ; low_level_library_NAME_list:
 858                 low_level_library_NAME_list opt_comma filename
 859                         { ldemul_syslib($3); }
 860         |
 861         ;
 862
 863 floating_point_support:
 864                 FLOAT
 865                         { lang_float(TRUE); }
 866         |       NOFLOAT
 867                         { lang_float(FALSE); }
 868         ;
 869
 870 nocrossref_list:
 871                 /* empty */
 872                 {
 873                   $$ = NULL;
 874                 }
 875         |       NAME nocrossref_list
 876                 {
 877                   struct lang_nocrossref *n;
 878
 879                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 880                   n->name = $1;
 881                   n->next = $2;
 882                   $$ = n;
 883                 }
 884         |       NAME ',' nocrossref_list
 885                 {
 886                   struct lang_nocrossref *n;
 887
 888                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 889                   n->name = $1;
 890                   n->next = $3;
 891                   $$ = n;
 892                 }
 893         ;
 894
 895 mustbe_exp:              { ldlex_expression (); }
 896                 exp
 897                          { ldlex_popstate (); $$=$2;}
 898         ;
 899
 900 exp     :
 901                 '-' exp %prec UNARY
 902                         { $$ = exp_unop ('-', $2); }
 903         |       '(' exp ')'
 904                         { $$ = $2; }
 905         |       NEXT '(' exp ')' %prec UNARY
 906                         { $$ = exp_unop ((int) $1,$3); }
 907         |       '!' exp %prec UNARY
 908                         { $$ = exp_unop ('!', $2); }
 909         |       '+' exp %prec UNARY
 910                         { $$ = $2; }
 911         |       '~' exp %prec UNARY
 912                         { $$ = exp_unop ('~', $2);}
 913
 914         |       exp '*' exp
 915                         { $$ = exp_binop ('*', $1, $3); }
 916         |       exp '/' exp
 917                         { $$ = exp_binop ('/', $1, $3); }
 918         |       exp '%' exp
 919                         { $$ = exp_binop ('%', $1, $3); }
 920         |       exp '+' exp
 921                         { $$ = exp_binop ('+', $1, $3); }
 922         |       exp '-' exp
 923                         { $$ = exp_binop ('-' , $1, $3); }
 924         |       exp LSHIFT exp
 925                         { $$ = exp_binop (LSHIFT , $1, $3); }
 926         |       exp RSHIFT exp
 927                         { $$ = exp_binop (RSHIFT , $1, $3); }
 928         |       exp EQ exp
 929                         { $$ = exp_binop (EQ , $1, $3); }
 930         |       exp NE exp
 931                         { $$ = exp_binop (NE , $1, $3); }
 932         |       exp LE exp
 933                         { $$ = exp_binop (LE , $1, $3); }
 934         |       exp GE exp
 935                         { $$ = exp_binop (GE , $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 '|' exp
 945                         { $$ = exp_binop ('|' , $1, $3); }
 946         |       exp '?' exp ':' exp
 947                         { $$ = exp_trinop ('?' , $1, $3, $5); }
 948         |       exp ANDAND exp
 949                         { $$ = exp_binop (ANDAND , $1, $3); }
 950         |       exp OROR exp
 951                         { $$ = exp_binop (OROR , $1, $3); }
 952         |       DEFINED '(' NAME ')'
 953                         { $$ = exp_nameop (DEFINED, $3); }
 954         |       INT
 955                         { $$ = exp_bigintop ($1.integer, $1.str); }
 956         |       SIZEOF_HEADERS
 957                         { $$ = exp_nameop (SIZEOF_HEADERS,0); }
 958
 959         |       ALIGNOF '(' NAME ')'
 960                         { $$ = exp_nameop (ALIGNOF,$3); }
 961         |       SIZEOF '(' NAME ')'
 962                         { $$ = exp_nameop (SIZEOF,$3); }
 963         |       ADDR '(' NAME ')'
 964                         { $$ = exp_nameop (ADDR,$3); }
 965         |       LOADADDR '(' NAME ')'
 966                         { $$ = exp_nameop (LOADADDR,$3); }
 967         |       CONSTANT '(' NAME ')'
 968                         { $$ = exp_nameop (CONSTANT,$3); }
 969         |       ABSOLUTE '(' exp ')'
 970                         { $$ = exp_unop (ABSOLUTE, $3); }
 971         |       ALIGN_K '(' exp ')'
 972                         { $$ = exp_unop (ALIGN_K,$3); }
 973         |       ALIGN_K '(' exp ',' exp ')'
 974                         { $$ = exp_binop (ALIGN_K,$3,$5); }
 975         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 976                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
 977         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 978                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
 979         |       DATA_SEGMENT_END '(' exp ')'
 980                         { $$ = exp_unop (DATA_SEGMENT_END, $3); }
 981         |       SEGMENT_START '(' NAME ',' exp ')'
 982                         { /* The operands to the expression node are
 983                              placed in the opposite order from the way
 984                              in which they appear in the script as
 985                              that allows us to reuse more code in
 986                              fold_binary.  */
 987                           $$ = exp_binop (SEGMENT_START,
 988                                           $5,
 989                                           exp_nameop (NAME, $3)); }
 990         |       BLOCK '(' exp ')'
 991                         { $$ = exp_unop (ALIGN_K,$3); }
 992         |       NAME
 993                         { $$ = exp_nameop (NAME,$1); }
 994         |       MAX_K '(' exp ',' exp ')'
 995                         { $$ = exp_binop (MAX_K, $3, $5 ); }
 996         |       MIN_K '(' exp ',' exp ')'
 997                         { $$ = exp_binop (MIN_K, $3, $5 ); }
 998         |       ASSERT_K '(' exp ',' NAME ')'
 999                         { $$ = exp_assert ($3, $5); }
1000         |       ORIGIN '(' NAME ')'
1001                         { $$ = exp_nameop (ORIGIN, $3); }
1002         |       LENGTH '(' NAME ')'
1003                         { $$ = exp_nameop (LENGTH, $3); }
1004         ;
1005
1006
1007 memspec_at_opt:
1008                 AT '>' NAME { $$ = $3; }
1009         |       { $$ = 0; }
1010         ;
1011
1012 opt_at:
1013                 AT '(' exp ')' { $$ = $3; }
1014         |       { $$ = 0; }
1015         ;
1016
1017 opt_align:
1018                 ALIGN_K '(' exp ')' { $$ = $3; }
1019         |       { $$ = 0; }
1020         ;
1021
1022 opt_subalign:
1023                 SUBALIGN '(' exp ')' { $$ = $3; }
1024         |       { $$ = 0; }
1025         ;
1026
1027 sect_constraint:
1028                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
1029         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
1030         |       SPECIAL { $$ = SPECIAL; }
1031         |       { $$ = 0; }
1032         ;
1033
1034 section:        NAME            { ldlex_expression(); }
1035                 opt_exp_with_type
1036                 opt_at
1037                 opt_align
1038                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
1039                 sect_constraint
1040                 '{'
1041                         {
1042                           lang_enter_output_section_statement($1, $3,
1043                                                               sectype,
1044                                                               $5, $6, $4, $8);
1045                         }
1046                 statement_list_opt
1047                 '}' { ldlex_popstate (); ldlex_expression (); }
1048                 memspec_opt memspec_at_opt phdr_opt fill_opt
1049                 {
1050                   ldlex_popstate ();
1051                   lang_leave_output_section_statement ($17, $14, $16, $15);
1052                 }
1053                 opt_comma
1054                 {}
1055         |       OVERLAY
1056                         { ldlex_expression (); }
1057                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
1058                         { ldlex_popstate (); ldlex_script (); }
1059                 '{'
1060                         {
1061                           lang_enter_overlay ($3, $6);
1062                         }
1063                 overlay_section
1064                 '}'
1065                         { ldlex_popstate (); ldlex_expression (); }
1066                 memspec_opt memspec_at_opt phdr_opt fill_opt
1067                         {
1068                           ldlex_popstate ();
1069                           lang_leave_overlay ($5, (int) $4,
1070                                               $16, $13, $15, $14);
1071                         }
1072                 opt_comma
1073         |       /* The GROUP case is just enough to support the gcc
1074                    svr3.ifile script.  It is not intended to be full
1075                    support.  I'm not even sure what GROUP is supposed
1076                    to mean.  */
1077                 GROUP { ldlex_expression (); }
1078                 opt_exp_with_type
1079                 {
1080                   ldlex_popstate ();
1081                   lang_add_assignment (exp_assign (".", $3));
1082                 }
1083                 '{' sec_or_group_p1 '}'
1084         |       INCLUDE filename
1085                 { ldlex_script (); ldfile_open_command_file($2); }
1086                 sec_or_group_p1 END
1087                 { ldlex_popstate (); }
1088         ;
1089
1090 type:
1091            NOLOAD  { sectype = noload_section; }
1092         |  DSECT   { sectype = noalloc_section; }
1093         |  COPY    { sectype = noalloc_section; }
1094         |  INFO    { sectype = noalloc_section; }
1095         |  OVERLAY { sectype = noalloc_section; }
1096         ;
1097
1098 atype:
1099                 '(' type ')'
1100         |       /* EMPTY */ { sectype = normal_section; }
1101         |       '(' ')' { sectype = normal_section; }
1102         ;
1103
1104 opt_exp_with_type:
1105                 exp atype ':'           { $$ = $1; }
1106         |       atype ':'               { $$ = (etree_type *)NULL;  }
1107         |       /* The BIND cases are to support the gcc svr3.ifile
1108                    script.  They aren't intended to implement full
1109                    support for the BIND keyword.  I'm not even sure
1110                    what BIND is supposed to mean.  */
1111                 BIND '(' exp ')' atype ':' { $$ = $3; }
1112         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
1113                 { $$ = $3; }
1114         ;
1115
1116 opt_exp_without_type:
1117                 exp ':'         { $$ = $1; }
1118         |       ':'             { $$ = (etree_type *) NULL;  }
1119         ;
1120
1121 opt_nocrossrefs:
1122                 /* empty */
1123                         { $$ = 0; }
1124         |       NOCROSSREFS
1125                         { $$ = 1; }
1126         ;
1127
1128 memspec_opt:
1129                 '>' NAME
1130                 { $$ = $2; }
1131         |       { $$ = DEFAULT_MEMORY_REGION; }
1132         ;
1133
1134 phdr_opt:
1135                 /* empty */
1136                 {
1137                   $$ = NULL;
1138                 }
1139         |       phdr_opt ':' NAME
1140                 {
1141                   struct lang_output_section_phdr_list *n;
1142
1143                   n = ((struct lang_output_section_phdr_list *)
1144                        xmalloc (sizeof *n));
1145                   n->name = $3;
1146                   n->used = FALSE;
1147                   n->next = $1;
1148                   $$ = n;
1149                 }
1150         ;
1151
1152 overlay_section:
1153                 /* empty */
1154         |       overlay_section
1155                 NAME
1156                         {
1157                           ldlex_script ();
1158                           lang_enter_overlay_section ($2);
1159                         }
1160                 '{' statement_list_opt '}'
1161                         { ldlex_popstate (); ldlex_expression (); }
1162                 phdr_opt fill_opt
1163                         {
1164                           ldlex_popstate ();
1165                           lang_leave_overlay_section ($9, $8);
1166                         }
1167                 opt_comma
1168         ;
1169
1170 phdrs:
1171                 PHDRS '{' phdr_list '}'
1172         ;
1173
1174 phdr_list:
1175                 /* empty */
1176         |       phdr_list phdr
1177         ;
1178
1179 phdr:
1180                 NAME { ldlex_expression (); }
1181                   phdr_type phdr_qualifiers { ldlex_popstate (); }
1182                   ';'
1183                 {
1184                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1185                                  $4.flags);
1186                 }
1187         ;
1188
1189 phdr_type:
1190                 exp
1191                 {
1192                   $$ = $1;
1193
1194                   if ($1->type.node_class == etree_name
1195                       && $1->type.node_code == NAME)
1196                     {
1197                       const char *s;
1198                       unsigned int i;
1199                       static const char * const phdr_types[] =
1200                         {
1201                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1202                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1203                           "PT_PHDR", "PT_TLS"
1204                         };
1205
1206                       s = $1->name.name;
1207                       for (i = 0;
1208                            i < sizeof phdr_types / sizeof phdr_types[0];
1209                            i++)
1210                         if (strcmp (s, phdr_types[i]) == 0)
1211                           {
1212                             $$ = exp_intop (i);
1213                             break;
1214                           }
1215                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1216                         {
1217                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1218                             $$ = exp_intop (0x6474e550);
1219                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1220                             $$ = exp_intop (0x6474e551);
1221                           else
1222                             {
1223                               einfo (_("\
1224 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1225                                      NULL, s);
1226                               $$ = exp_intop (0);
1227                             }
1228                         }
1229                     }
1230                 }
1231         ;
1232
1233 phdr_qualifiers:
1234                 /* empty */
1235                 {
1236                   memset (&$$, 0, sizeof (struct phdr_info));
1237                 }
1238         |       NAME phdr_val phdr_qualifiers
1239                 {
1240                   $$ = $3;
1241                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1242                     $$.filehdr = TRUE;
1243                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1244                     $$.phdrs = TRUE;
1245                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1246                     $$.flags = $2;
1247                   else
1248                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"),
1249                            NULL, $1);
1250                 }
1251         |       AT '(' exp ')' phdr_qualifiers
1252                 {
1253                   $$ = $5;
1254                   $$.at = $3;
1255                 }
1256         ;
1257
1258 phdr_val:
1259                 /* empty */
1260                 {
1261                   $$ = NULL;
1262                 }
1263         | '(' exp ')'
1264                 {
1265                   $$ = $2;
1266                 }
1267         ;
1268
1269 dynamic_list_file:
1270                 {
1271                   ldlex_version_file ();
1272                   PUSH_ERROR (_("dynamic list"));
1273                 }
1274                 dynamic_list_nodes
1275                 {
1276                   ldlex_popstate ();
1277                   POP_ERROR ();
1278                 }
1279         ;
1280
1281 dynamic_list_nodes:
1282                 dynamic_list_node
1283         |       dynamic_list_nodes dynamic_list_node
1284         ;
1285
1286 dynamic_list_node:
1287                 '{' dynamic_list_tag '}' ';'
1288         ;
1289
1290 dynamic_list_tag:
1291                 vers_defns ';'
1292                 {
1293                   lang_append_dynamic_list ($1);
1294                 }
1295         ;
1296
1297 /* This syntax is used within an external version script file.  */
1298
1299 version_script_file:
1300                 {
1301                   ldlex_version_file ();
1302                   PUSH_ERROR (_("VERSION script"));
1303                 }
1304                 vers_nodes
1305                 {
1306                   ldlex_popstate ();
1307                   POP_ERROR ();
1308                 }
1309         ;
1310
1311 /* This is used within a normal linker script file.  */
1312
1313 version:
1314                 {
1315                   ldlex_version_script ();
1316                 }
1317                 VERSIONK '{' vers_nodes '}'
1318                 {
1319                   ldlex_popstate ();
1320                 }
1321         ;
1322
1323 vers_nodes:
1324                 vers_node
1325         |       vers_nodes vers_node
1326         ;
1327
1328 vers_node:
1329                 '{' vers_tag '}' ';'
1330                 {
1331                   lang_register_vers_node (NULL, $2, NULL);
1332                 }
1333         |       VERS_TAG '{' vers_tag '}' ';'
1334                 {
1335                   lang_register_vers_node ($1, $3, NULL);
1336                 }
1337         |       VERS_TAG '{' vers_tag '}' verdep ';'
1338                 {
1339                   lang_register_vers_node ($1, $3, $5);
1340                 }
1341         ;
1342
1343 verdep:
1344                 VERS_TAG
1345                 {
1346                   $$ = lang_add_vers_depend (NULL, $1);
1347                 }
1348         |       verdep VERS_TAG
1349                 {
1350                   $$ = lang_add_vers_depend ($1, $2);
1351                 }
1352         ;
1353
1354 vers_tag:
1355                 /* empty */
1356                 {
1357                   $$ = lang_new_vers_node (NULL, NULL);
1358                 }
1359         |       vers_defns ';'
1360                 {
1361                   $$ = lang_new_vers_node ($1, NULL);
1362                 }
1363         |       GLOBAL ':' vers_defns ';'
1364                 {
1365                   $$ = lang_new_vers_node ($3, NULL);
1366                 }
1367         |       LOCAL ':' vers_defns ';'
1368                 {
1369                   $$ = lang_new_vers_node (NULL, $3);
1370                 }
1371         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1372                 {
1373                   $$ = lang_new_vers_node ($3, $7);
1374                 }
1375         ;
1376
1377 vers_defns:
1378                 VERS_IDENTIFIER
1379                 {
1380                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1381                 }
1382         |       NAME
1383                 {
1384                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1385                 }
1386         |       vers_defns ';' VERS_IDENTIFIER
1387                 {
1388                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1389                 }
1390         |       vers_defns ';' NAME
1391                 {
1392                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1393                 }
1394         |       vers_defns ';' EXTERN NAME '{'
1395                         {
1396                           $<name>$ = ldgram_vers_current_lang;
1397                           ldgram_vers_current_lang = $4;
1398                         }
1399                 vers_defns opt_semicolon '}'
1400                         {
1401                           struct bfd_elf_version_expr *pat;
1402                           for (pat = $7; pat->next != NULL; pat = pat->next);
1403                           pat->next = $1;
1404                           $$ = $7;
1405                           ldgram_vers_current_lang = $<name>6;
1406                         }
1407         |       EXTERN NAME '{'
1408                         {
1409                           $<name>$ = ldgram_vers_current_lang;
1410                           ldgram_vers_current_lang = $2;
1411                         }
1412                 vers_defns opt_semicolon '}'
1413                         {
1414                           $$ = $5;
1415                           ldgram_vers_current_lang = $<name>4;
1416                         }
1417         |       GLOBAL
1418                 {
1419                   $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1420                 }
1421         |       vers_defns ';' GLOBAL
1422                 {
1423                   $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1424                 }
1425         |       LOCAL
1426                 {
1427                   $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1428                 }
1429         |       vers_defns ';' LOCAL
1430                 {
1431                   $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1432                 }
1433         |       EXTERN
1434                 {
1435                   $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1436                 }
1437         |       vers_defns ';' EXTERN
1438                 {
1439                   $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1440                 }
1441         ;
1442
1443 opt_semicolon:
1444                 /* empty */
1445         |       ';'
1446         ;
1447
1448 %%
1449 void
1450 yyerror(arg)
1451      const char *arg;
1452 {
1453   if (ldfile_assumed_script)
1454     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1455            ldlex_filename ());
1456   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1457     einfo ("%P%F:%S: %s in %s\n", NULL, arg, error_names[error_index - 1]);
1458   else
1459     einfo ("%P%F:%S: %s\n", NULL, arg);
1460 }