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