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