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, 2007 Free Software Foundation, Inc.
   4    Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
   5
   6    This file is part of the GNU Binutils.
   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 3 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,
  21    MA 02110-1301, USA.  */
  22
  23 %{
  24 /*
  25
  26  */
  27
  28 #define DONTDECLARE_MALLOC
  29
  30 #include "sysdep.h"
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "ld.h"
  34 #include "ldexp.h"
  35 #include "ldver.h"
  36 #include "ldlang.h"
  37 #include "ldfile.h"
  38 #include "ldemul.h"
  39 #include "ldmisc.h"
  40 #include "ldmain.h"
  41 #include "mri.h"
  42 #include "ldctor.h"
  43 #include "ldlex.h"
  44
  45 #ifndef YYDEBUG
  46 #define YYDEBUG 1
  47 #endif
  48
  49 static enum section_type sectype;
  50 static lang_memory_region_type *region;
  51
  52 FILE *saved_script_handle = NULL;
  53 bfd_boolean force_make_executable = FALSE;
  54
  55 bfd_boolean ldgram_in_script = FALSE;
  56 bfd_boolean ldgram_had_equals = FALSE;
  57 bfd_boolean ldgram_had_keep = FALSE;
  58 char *ldgram_vers_current_lang = NULL;
  59
  60 #define ERROR_NAME_MAX 20
  61 static char *error_names[ERROR_NAME_MAX];
  62 static int error_index;
  63 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
  64 #define POP_ERROR()   error_index--;
  65 %}
  66 %union {
  67   bfd_vma integer;
  68   struct big_int
  69     {
  70       bfd_vma integer;
  71       char *str;
  72     } bigint;
  73   fill_type *fill;
  74   char *name;
  75   const char *cname;
  76   struct wildcard_spec wildcard;
  77   struct wildcard_list *wildcard_list;
  78   struct name_list *name_list;
  79   int token;
  80   union etree_union *etree;
  81   struct phdr_info
  82     {
  83       bfd_boolean filehdr;
  84       bfd_boolean phdrs;
  85       union etree_union *at;
  86       union etree_union *flags;
  87     } phdr;
  88   struct lang_nocrossref *nocrossref;
  89   struct lang_output_section_phdr_list *section_phdr;
  90   struct bfd_elf_version_deps *deflist;
  91   struct bfd_elf_version_expr *versyms;
  92   struct bfd_elf_version_tree *versnode;
  93 }
  94
  95 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
  96 %type <etree> opt_exp_without_type opt_subalign opt_align
  97 %type <fill> fill_opt fill_exp
  98 %type <name_list> exclude_name_list
  99 %type <wildcard_list> file_NAME_list
 100 %type <name> memspec_opt casesymlist
 101 %type <name> memspec_at_opt
 102 %type <cname> wildcard_name
 103 %type <wildcard> wildcard_spec
 104 %token <bigint> INT
 105 %token <name> NAME LNAME
 106 %type <integer> length
 107 %type <phdr> phdr_qualifiers
 108 %type <nocrossref> nocrossref_list
 109 %type <section_phdr> phdr_opt
 110 %type <integer> opt_nocrossrefs
 111
 112 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
 113 %right <token> '?' ':'
 114 %left <token> OROR
 115 %left <token>  ANDAND
 116 %left <token> '|'
 117 %left <token>  '^'
 118 %left  <token> '&'
 119 %left <token>  EQ NE
 120 %left  <token> '<' '>' LE GE
 121 %left  <token> LSHIFT RSHIFT
 122
 123 %left  <token> '+' '-'
 124 %left  <token> '*' '/' '%'
 125
 126 %right UNARY
 127 %token END
 128 %left <token> '('
 129 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
 130 %token SECTIONS PHDRS DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
 131 %token SORT_BY_NAME SORT_BY_ALIGNMENT
 132 %token '{' '}'
 133 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
 134 %token INHIBIT_COMMON_ALLOCATION
 135 %token SEGMENT_START
 136 %token INCLUDE
 137 %token MEMORY
 138 %token NOLOAD DSECT COPY INFO OVERLAY
 139 %token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
 140 %token <integer> NEXT
 141 %token SIZEOF ALIGNOF 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 /* Parsed as expressions so that commas separate entries */
 285 extern_name_list:
 286         { ldlex_expression (); }
 287         extern_name_list_body
 288         { ldlex_popstate (); }
 289
 290 extern_name_list_body:
 291           NAME
 292                         { ldlang_add_undef ($1); }
 293         | extern_name_list_body NAME
 294                         { ldlang_add_undef ($2); }
 295         | extern_name_list_body ',' NAME
 296                         { ldlang_add_undef ($3); }
 297         ;
 298
 299 script_file:
 300         { ldlex_both(); }
 301         ifile_list
 302         { ldlex_popstate(); }
 303         ;
 304
 305 ifile_list:
 306         ifile_list ifile_p1
 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         | ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
 578                         { ldlex_popstate ();
 579                           lang_add_assignment (exp_assert ($4, $6)); }
 580         ;
 581
 582 statement_list:
 583                 statement_list statement
 584         |       statement
 585         ;
 586
 587 statement_list_opt:
 588                 /* empty */
 589         |       statement_list
 590         ;
 591
 592 length:
 593                 QUAD
 594                         { $$ = $1; }
 595         |       SQUAD
 596                         { $$ = $1; }
 597         |       LONG
 598                         { $$ = $1; }
 599         |       SHORT
 600                         { $$ = $1; }
 601         |       BYTE
 602                         { $$ = $1; }
 603         ;
 604
 605 fill_exp:
 606         mustbe_exp
 607                 {
 608                   $$ = exp_get_fill ($1, 0, "fill value");
 609                 }
 610         ;
 611
 612 fill_opt:
 613           '=' fill_exp
 614                 { $$ = $2; }
 615         |       { $$ = (fill_type *) 0; }
 616         ;
 617
 618 assign_op:
 619                 PLUSEQ
 620                         { $$ = '+'; }
 621         |       MINUSEQ
 622                         { $$ = '-'; }
 623         |       MULTEQ
 624                         { $$ = '*'; }
 625         |       DIVEQ
 626                         { $$ = '/'; }
 627         |       LSHIFTEQ
 628                         { $$ = LSHIFT; }
 629         |       RSHIFTEQ
 630                         { $$ = RSHIFT; }
 631         |       ANDEQ
 632                         { $$ = '&'; }
 633         |       OREQ
 634                         { $$ = '|'; }
 635
 636         ;
 637
 638 end:    ';' | ','
 639         ;
 640
 641
 642 assignment:
 643                 NAME '=' mustbe_exp
 644                 {
 645                   lang_add_assignment (exp_assop ($2, $1, $3));
 646                 }
 647         |       NAME assign_op mustbe_exp
 648                 {
 649                   lang_add_assignment (exp_assop ('=', $1,
 650                                                   exp_binop ($2,
 651                                                              exp_nameop (NAME,
 652                                                                          $1),
 653                                                              $3)));
 654                 }
 655         |       PROVIDE '(' NAME '=' mustbe_exp ')'
 656                 {
 657                   lang_add_assignment (exp_provide ($3, $5, FALSE));
 658                 }
 659         |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
 660                 {
 661                   lang_add_assignment (exp_provide ($3, $5, TRUE));
 662                 }
 663         ;
 664
 665
 666 opt_comma:
 667                 ','     |       ;
 668
 669
 670 memory:
 671                 MEMORY '{' memory_spec memory_spec_list '}'
 672         ;
 673
 674 memory_spec_list:
 675                 memory_spec_list memory_spec
 676         |       memory_spec_list ',' memory_spec
 677         |
 678         ;
 679
 680
 681 memory_spec:    NAME
 682                 { region = lang_memory_region_lookup ($1, TRUE); }
 683                 attributes_opt ':'
 684                 origin_spec opt_comma length_spec
 685                 {}
 686         ;
 687
 688 origin_spec:
 689         ORIGIN '=' mustbe_exp
 690                 {
 691                   region->origin = exp_get_vma ($3, 0, "origin");
 692                   region->current = region->origin;
 693                 }
 694         ;
 695
 696 length_spec:
 697              LENGTH '=' mustbe_exp
 698                 {
 699                   region->length = exp_get_vma ($3, -1, "length");
 700                 }
 701         ;
 702
 703 attributes_opt:
 704                 /* empty */
 705                   { /* dummy action to avoid bison 1.25 error message */ }
 706         |       '(' attributes_list ')'
 707         ;
 708
 709 attributes_list:
 710                 attributes_string
 711         |       attributes_list attributes_string
 712         ;
 713
 714 attributes_string:
 715                 NAME
 716                   { lang_set_flags (region, $1, 0); }
 717         |       '!' NAME
 718                   { lang_set_flags (region, $2, 1); }
 719         ;
 720
 721 startup:
 722         STARTUP '(' filename ')'
 723                 { lang_startup($3); }
 724         ;
 725
 726 high_level_library:
 727                 HLL '(' high_level_library_NAME_list ')'
 728         |       HLL '(' ')'
 729                         { ldemul_hll((char *)NULL); }
 730         ;
 731
 732 high_level_library_NAME_list:
 733                 high_level_library_NAME_list opt_comma filename
 734                         { ldemul_hll($3); }
 735         |       filename
 736                         { ldemul_hll($1); }
 737
 738         ;
 739
 740 low_level_library:
 741         SYSLIB '(' low_level_library_NAME_list ')'
 742         ; low_level_library_NAME_list:
 743                 low_level_library_NAME_list opt_comma filename
 744                         { ldemul_syslib($3); }
 745         |
 746         ;
 747
 748 floating_point_support:
 749                 FLOAT
 750                         { lang_float(TRUE); }
 751         |       NOFLOAT
 752                         { lang_float(FALSE); }
 753         ;
 754
 755 nocrossref_list:
 756                 /* empty */
 757                 {
 758                   $$ = NULL;
 759                 }
 760         |       NAME nocrossref_list
 761                 {
 762                   struct lang_nocrossref *n;
 763
 764                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 765                   n->name = $1;
 766                   n->next = $2;
 767                   $$ = n;
 768                 }
 769         |       NAME ',' nocrossref_list
 770                 {
 771                   struct lang_nocrossref *n;
 772
 773                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 774                   n->name = $1;
 775                   n->next = $3;
 776                   $$ = n;
 777                 }
 778         ;
 779
 780 mustbe_exp:              { ldlex_expression (); }
 781                 exp
 782                          { ldlex_popstate (); $$=$2;}
 783         ;
 784
 785 exp     :
 786                 '-' exp %prec UNARY
 787                         { $$ = exp_unop ('-', $2); }
 788         |       '(' exp ')'
 789                         { $$ = $2; }
 790         |       NEXT '(' exp ')' %prec UNARY
 791                         { $$ = exp_unop ((int) $1,$3); }
 792         |       '!' exp %prec UNARY
 793                         { $$ = exp_unop ('!', $2); }
 794         |       '+' exp %prec UNARY
 795                         { $$ = $2; }
 796         |       '~' exp %prec UNARY
 797                         { $$ = exp_unop ('~', $2);}
 798
 799         |       exp '*' exp
 800                         { $$ = exp_binop ('*', $1, $3); }
 801         |       exp '/' exp
 802                         { $$ = exp_binop ('/', $1, $3); }
 803         |       exp '%' exp
 804                         { $$ = exp_binop ('%', $1, $3); }
 805         |       exp '+' exp
 806                         { $$ = exp_binop ('+', $1, $3); }
 807         |       exp '-' exp
 808                         { $$ = exp_binop ('-' , $1, $3); }
 809         |       exp LSHIFT exp
 810                         { $$ = exp_binop (LSHIFT , $1, $3); }
 811         |       exp RSHIFT exp
 812                         { $$ = exp_binop (RSHIFT , $1, $3); }
 813         |       exp EQ exp
 814                         { $$ = exp_binop (EQ , $1, $3); }
 815         |       exp NE exp
 816                         { $$ = exp_binop (NE , $1, $3); }
 817         |       exp LE exp
 818                         { $$ = exp_binop (LE , $1, $3); }
 819         |       exp GE exp
 820                         { $$ = exp_binop (GE , $1, $3); }
 821         |       exp '<' exp
 822                         { $$ = exp_binop ('<' , $1, $3); }
 823         |       exp '>' exp
 824                         { $$ = exp_binop ('>' , $1, $3); }
 825         |       exp '&' exp
 826                         { $$ = exp_binop ('&' , $1, $3); }
 827         |       exp '^' exp
 828                         { $$ = exp_binop ('^' , $1, $3); }
 829         |       exp '|' exp
 830                         { $$ = exp_binop ('|' , $1, $3); }
 831         |       exp '?' exp ':' exp
 832                         { $$ = exp_trinop ('?' , $1, $3, $5); }
 833         |       exp ANDAND exp
 834                         { $$ = exp_binop (ANDAND , $1, $3); }
 835         |       exp OROR exp
 836                         { $$ = exp_binop (OROR , $1, $3); }
 837         |       DEFINED '(' NAME ')'
 838                         { $$ = exp_nameop (DEFINED, $3); }
 839         |       INT
 840                         { $$ = exp_bigintop ($1.integer, $1.str); }
 841         |       SIZEOF_HEADERS
 842                         { $$ = exp_nameop (SIZEOF_HEADERS,0); }
 843
 844         |       ALIGNOF '(' NAME ')'
 845                         { $$ = exp_nameop (ALIGNOF,$3); }
 846         |       SIZEOF '(' NAME ')'
 847                         { $$ = exp_nameop (SIZEOF,$3); }
 848         |       ADDR '(' NAME ')'
 849                         { $$ = exp_nameop (ADDR,$3); }
 850         |       LOADADDR '(' NAME ')'
 851                         { $$ = exp_nameop (LOADADDR,$3); }
 852         |       CONSTANT '(' NAME ')'
 853                         { $$ = exp_nameop (CONSTANT,$3); }
 854         |       ABSOLUTE '(' exp ')'
 855                         { $$ = exp_unop (ABSOLUTE, $3); }
 856         |       ALIGN_K '(' exp ')'
 857                         { $$ = exp_unop (ALIGN_K,$3); }
 858         |       ALIGN_K '(' exp ',' exp ')'
 859                         { $$ = exp_binop (ALIGN_K,$3,$5); }
 860         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 861                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
 862         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 863                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
 864         |       DATA_SEGMENT_END '(' exp ')'
 865                         { $$ = exp_unop (DATA_SEGMENT_END, $3); }
 866         |       SEGMENT_START '(' NAME ',' exp ')'
 867                         { /* The operands to the expression node are
 868                              placed in the opposite order from the way
 869                              in which they appear in the script as
 870                              that allows us to reuse more code in
 871                              fold_binary.  */
 872                           $$ = exp_binop (SEGMENT_START,
 873                                           $5,
 874                                           exp_nameop (NAME, $3)); }
 875         |       BLOCK '(' exp ')'
 876                         { $$ = exp_unop (ALIGN_K,$3); }
 877         |       NAME
 878                         { $$ = exp_nameop (NAME,$1); }
 879         |       MAX_K '(' exp ',' exp ')'
 880                         { $$ = exp_binop (MAX_K, $3, $5 ); }
 881         |       MIN_K '(' exp ',' exp ')'
 882                         { $$ = exp_binop (MIN_K, $3, $5 ); }
 883         |       ASSERT_K '(' exp ',' NAME ')'
 884                         { $$ = exp_assert ($3, $5); }
 885         |       ORIGIN '(' NAME ')'
 886                         { $$ = exp_nameop (ORIGIN, $3); }
 887         |       LENGTH '(' NAME ')'
 888                         { $$ = exp_nameop (LENGTH, $3); }
 889         ;
 890
 891
 892 memspec_at_opt:
 893                 AT '>' NAME { $$ = $3; }
 894         |       { $$ = 0; }
 895         ;
 896
 897 opt_at:
 898                 AT '(' exp ')' { $$ = $3; }
 899         |       { $$ = 0; }
 900         ;
 901
 902 opt_align:
 903                 ALIGN_K '(' exp ')' { $$ = $3; }
 904         |       { $$ = 0; }
 905         ;
 906
 907 opt_subalign:
 908                 SUBALIGN '(' exp ')' { $$ = $3; }
 909         |       { $$ = 0; }
 910         ;
 911
 912 sect_constraint:
 913                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
 914         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
 915         |       SPECIAL { $$ = SPECIAL; }
 916         |       { $$ = 0; }
 917         ;
 918
 919 section:        NAME            { ldlex_expression(); }
 920                 opt_exp_with_type
 921                 opt_at
 922                 opt_align
 923                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
 924                 sect_constraint
 925                 '{'
 926                         {
 927                           lang_enter_output_section_statement($1, $3,
 928                                                               sectype,
 929                                                               $5, $6, $4, $8);
 930                         }
 931                 statement_list_opt
 932                 '}' { ldlex_popstate (); ldlex_expression (); }
 933                 memspec_opt memspec_at_opt phdr_opt fill_opt
 934                 {
 935                   ldlex_popstate ();
 936                   lang_leave_output_section_statement ($17, $14, $16, $15);
 937                 }
 938                 opt_comma
 939                 {}
 940         |       OVERLAY
 941                         { ldlex_expression (); }
 942                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
 943                         { ldlex_popstate (); ldlex_script (); }
 944                 '{'
 945                         {
 946                           lang_enter_overlay ($3, $6);
 947                         }
 948                 overlay_section
 949                 '}'
 950                         { ldlex_popstate (); ldlex_expression (); }
 951                 memspec_opt memspec_at_opt phdr_opt fill_opt
 952                         {
 953                           ldlex_popstate ();
 954                           lang_leave_overlay ($5, (int) $4,
 955                                               $16, $13, $15, $14);
 956                         }
 957                 opt_comma
 958         |       /* The GROUP case is just enough to support the gcc
 959                    svr3.ifile script.  It is not intended to be full
 960                    support.  I'm not even sure what GROUP is supposed
 961                    to mean.  */
 962                 GROUP { ldlex_expression (); }
 963                 opt_exp_with_type
 964                 {
 965                   ldlex_popstate ();
 966                   lang_add_assignment (exp_assop ('=', ".", $3));
 967                 }
 968                 '{' sec_or_group_p1 '}'
 969         ;
 970
 971 type:
 972            NOLOAD  { sectype = noload_section; }
 973         |  DSECT   { sectype = noalloc_section; }
 974         |  COPY    { sectype = noalloc_section; }
 975         |  INFO    { sectype = noalloc_section; }
 976         |  OVERLAY { sectype = noalloc_section; }
 977         ;
 978
 979 atype:
 980                 '(' type ')'
 981         |       /* EMPTY */ { sectype = normal_section; }
 982         |       '(' ')' { sectype = normal_section; }
 983         ;
 984
 985 opt_exp_with_type:
 986                 exp atype ':'           { $$ = $1; }
 987         |       atype ':'               { $$ = (etree_type *)NULL;  }
 988         |       /* The BIND cases are to support the gcc svr3.ifile
 989                    script.  They aren't intended to implement full
 990                    support for the BIND keyword.  I'm not even sure
 991                    what BIND is supposed to mean.  */
 992                 BIND '(' exp ')' atype ':' { $$ = $3; }
 993         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
 994                 { $$ = $3; }
 995         ;
 996
 997 opt_exp_without_type:
 998                 exp ':'         { $$ = $1; }
 999         |       ':'             { $$ = (etree_type *) NULL;  }
1000         ;
1001
1002 opt_nocrossrefs:
1003                 /* empty */
1004                         { $$ = 0; }
1005         |       NOCROSSREFS
1006                         { $$ = 1; }
1007         ;
1008
1009 memspec_opt:
1010                 '>' NAME
1011                 { $$ = $2; }
1012         |       { $$ = DEFAULT_MEMORY_REGION; }
1013         ;
1014
1015 phdr_opt:
1016                 /* empty */
1017                 {
1018                   $$ = NULL;
1019                 }
1020         |       phdr_opt ':' NAME
1021                 {
1022                   struct lang_output_section_phdr_list *n;
1023
1024                   n = ((struct lang_output_section_phdr_list *)
1025                        xmalloc (sizeof *n));
1026                   n->name = $3;
1027                   n->used = FALSE;
1028                   n->next = $1;
1029                   $$ = n;
1030                 }
1031         ;
1032
1033 overlay_section:
1034                 /* empty */
1035         |       overlay_section
1036                 NAME
1037                         {
1038                           ldlex_script ();
1039                           lang_enter_overlay_section ($2);
1040                         }
1041                 '{' statement_list_opt '}'
1042                         { ldlex_popstate (); ldlex_expression (); }
1043                 phdr_opt fill_opt
1044                         {
1045                           ldlex_popstate ();
1046                           lang_leave_overlay_section ($9, $8);
1047                         }
1048                 opt_comma
1049         ;
1050
1051 phdrs:
1052                 PHDRS '{' phdr_list '}'
1053         ;
1054
1055 phdr_list:
1056                 /* empty */
1057         |       phdr_list phdr
1058         ;
1059
1060 phdr:
1061                 NAME { ldlex_expression (); }
1062                   phdr_type phdr_qualifiers { ldlex_popstate (); }
1063                   ';'
1064                 {
1065                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1066                                  $4.flags);
1067                 }
1068         ;
1069
1070 phdr_type:
1071                 exp
1072                 {
1073                   $$ = $1;
1074
1075                   if ($1->type.node_class == etree_name
1076                       && $1->type.node_code == NAME)
1077                     {
1078                       const char *s;
1079                       unsigned int i;
1080                       static const char * const phdr_types[] =
1081                         {
1082                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1083                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1084                           "PT_PHDR", "PT_TLS"
1085                         };
1086
1087                       s = $1->name.name;
1088                       for (i = 0;
1089                            i < sizeof phdr_types / sizeof phdr_types[0];
1090                            i++)
1091                         if (strcmp (s, phdr_types[i]) == 0)
1092                           {
1093                             $$ = exp_intop (i);
1094                             break;
1095                           }
1096                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1097                         {
1098                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1099                             $$ = exp_intop (0x6474e550);
1100                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1101                             $$ = exp_intop (0x6474e551);
1102                           else
1103                             {
1104                               einfo (_("\
1105 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1106                                      s);
1107                               $$ = exp_intop (0);
1108                             }
1109                         }
1110                     }
1111                 }
1112         ;
1113
1114 phdr_qualifiers:
1115                 /* empty */
1116                 {
1117                   memset (&$$, 0, sizeof (struct phdr_info));
1118                 }
1119         |       NAME phdr_val phdr_qualifiers
1120                 {
1121                   $$ = $3;
1122                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1123                     $$.filehdr = TRUE;
1124                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1125                     $$.phdrs = TRUE;
1126                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1127                     $$.flags = $2;
1128                   else
1129                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1130                 }
1131         |       AT '(' exp ')' phdr_qualifiers
1132                 {
1133                   $$ = $5;
1134                   $$.at = $3;
1135                 }
1136         ;
1137
1138 phdr_val:
1139                 /* empty */
1140                 {
1141                   $$ = NULL;
1142                 }
1143         | '(' exp ')'
1144                 {
1145                   $$ = $2;
1146                 }
1147         ;
1148
1149 dynamic_list_file:
1150                 {
1151                   ldlex_version_file ();
1152                   PUSH_ERROR (_("dynamic list"));
1153                 }
1154                 dynamic_list_nodes
1155                 {
1156                   ldlex_popstate ();
1157                   POP_ERROR ();
1158                 }
1159         ;
1160
1161 dynamic_list_nodes:
1162                 dynamic_list_node
1163         |       dynamic_list_nodes dynamic_list_node
1164         ;
1165
1166 dynamic_list_node:
1167                 '{' dynamic_list_tag '}' ';'
1168         ;
1169
1170 dynamic_list_tag:
1171                 vers_defns ';'
1172                 {
1173                   lang_append_dynamic_list ($1);
1174                 }
1175         ;
1176
1177 /* This syntax is used within an external version script file.  */
1178
1179 version_script_file:
1180                 {
1181                   ldlex_version_file ();
1182                   PUSH_ERROR (_("VERSION script"));
1183                 }
1184                 vers_nodes
1185                 {
1186                   ldlex_popstate ();
1187                   POP_ERROR ();
1188                 }
1189         ;
1190
1191 /* This is used within a normal linker script file.  */
1192
1193 version:
1194                 {
1195                   ldlex_version_script ();
1196                 }
1197                 VERSIONK '{' vers_nodes '}'
1198                 {
1199                   ldlex_popstate ();
1200                 }
1201         ;
1202
1203 vers_nodes:
1204                 vers_node
1205         |       vers_nodes vers_node
1206         ;
1207
1208 vers_node:
1209                 '{' vers_tag '}' ';'
1210                 {
1211                   lang_register_vers_node (NULL, $2, NULL);
1212                 }
1213         |       VERS_TAG '{' vers_tag '}' ';'
1214                 {
1215                   lang_register_vers_node ($1, $3, NULL);
1216                 }
1217         |       VERS_TAG '{' vers_tag '}' verdep ';'
1218                 {
1219                   lang_register_vers_node ($1, $3, $5);
1220                 }
1221         ;
1222
1223 verdep:
1224                 VERS_TAG
1225                 {
1226                   $$ = lang_add_vers_depend (NULL, $1);
1227                 }
1228         |       verdep VERS_TAG
1229                 {
1230                   $$ = lang_add_vers_depend ($1, $2);
1231                 }
1232         ;
1233
1234 vers_tag:
1235                 /* empty */
1236                 {
1237                   $$ = lang_new_vers_node (NULL, NULL);
1238                 }
1239         |       vers_defns ';'
1240                 {
1241                   $$ = lang_new_vers_node ($1, NULL);
1242                 }
1243         |       GLOBAL ':' vers_defns ';'
1244                 {
1245                   $$ = lang_new_vers_node ($3, NULL);
1246                 }
1247         |       LOCAL ':' vers_defns ';'
1248                 {
1249                   $$ = lang_new_vers_node (NULL, $3);
1250                 }
1251         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1252                 {
1253                   $$ = lang_new_vers_node ($3, $7);
1254                 }
1255         ;
1256
1257 vers_defns:
1258                 VERS_IDENTIFIER
1259                 {
1260                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1261                 }
1262         |       NAME
1263                 {
1264                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1265                 }
1266         |       vers_defns ';' VERS_IDENTIFIER
1267                 {
1268                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1269                 }
1270         |       vers_defns ';' NAME
1271                 {
1272                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1273                 }
1274         |       vers_defns ';' EXTERN NAME '{'
1275                         {
1276                           $<name>$ = ldgram_vers_current_lang;
1277                           ldgram_vers_current_lang = $4;
1278                         }
1279                 vers_defns opt_semicolon '}'
1280                         {
1281                           struct bfd_elf_version_expr *pat;
1282                           for (pat = $7; pat->next != NULL; pat = pat->next);
1283                           pat->next = $1;
1284                           $$ = $7;
1285                           ldgram_vers_current_lang = $<name>6;
1286                         }
1287         |       EXTERN NAME '{'
1288                         {
1289                           $<name>$ = ldgram_vers_current_lang;
1290                           ldgram_vers_current_lang = $2;
1291                         }
1292                 vers_defns opt_semicolon '}'
1293                         {
1294                           $$ = $5;
1295                           ldgram_vers_current_lang = $<name>4;
1296                         }
1297         |       GLOBAL
1298                 {
1299                   $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1300                 }
1301         |       vers_defns ';' GLOBAL
1302                 {
1303                   $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1304                 }
1305         |       LOCAL
1306                 {
1307                   $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1308                 }
1309         |       vers_defns ';' LOCAL
1310                 {
1311                   $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1312                 }
1313         |       EXTERN
1314                 {
1315                   $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1316                 }
1317         |       vers_defns ';' EXTERN
1318                 {
1319                   $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1320                 }
1321         ;
1322
1323 opt_semicolon:
1324                 /* empty */
1325         |       ';'
1326         ;
1327
1328 %%
1329 void
1330 yyerror(arg)
1331      const char *arg;
1332 {
1333   if (ldfile_assumed_script)
1334     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1335            ldfile_input_filename);
1336   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1337      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1338   else
1339      einfo ("%P%F:%S: %s\n", arg);
1340 }