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