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