ld/ldgram.y

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