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