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