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 bfd_boolean ldgram_had_keep = FALSE;
  53 char *ldgram_vers_current_lang = NULL;
  54
  55 #define ERROR_NAME_MAX 20
  56 static char *error_names[ERROR_NAME_MAX];
  57 static int error_index;
  58 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
  59 #define POP_ERROR()   error_index--;
  60 %}
  61 %union {
  62   bfd_vma integer;
  63   struct big_int
  64     {
  65       bfd_vma integer;
  66       char *str;
  67     } bigint;
  68   fill_type *fill;
  69   char *name;
  70   const char *cname;
  71   struct wildcard_spec wildcard;
  72   struct wildcard_list *wildcard_list;
  73   struct name_list *name_list;
  74   int token;
  75   union etree_union *etree;
  76   struct phdr_info
  77     {
  78       bfd_boolean filehdr;
  79       bfd_boolean phdrs;
  80       union etree_union *at;
  81       union etree_union *flags;
  82     } phdr;
  83   struct lang_nocrossref *nocrossref;
  84   struct lang_output_section_phdr_list *section_phdr;
  85   struct bfd_elf_version_deps *deflist;
  86   struct bfd_elf_version_expr *versyms;
  87   struct bfd_elf_version_tree *versnode;
  88 }
  89
  90 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
  91 %type <etree> opt_exp_without_type opt_subalign opt_align
  92 %type <fill> fill_opt fill_exp
  93 %type <name_list> exclude_name_list
  94 %type <wildcard_list> file_NAME_list
  95 %type <name> memspec_opt casesymlist
  96 %type <name> memspec_at_opt
  97 %type <cname> wildcard_name
  98 %type <wildcard> wildcard_spec
  99 %token <bigint> INT
 100 %token <name> NAME LNAME
 101 %type <integer> length
 102 %type <phdr> phdr_qualifiers
 103 %type <nocrossref> nocrossref_list
 104 %type <section_phdr> phdr_opt
 105 %type <integer> opt_nocrossrefs
 106
 107 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
 108 %right <token> '?' ':'
 109 %left <token> OROR
 110 %left <token>  ANDAND
 111 %left <token> '|'
 112 %left <token>  '^'
 113 %left  <token> '&'
 114 %left <token>  EQ NE
 115 %left  <token> '<' '>' LE GE
 116 %left  <token> LSHIFT RSHIFT
 117
 118 %left  <token> '+' '-'
 119 %left  <token> '*' '/' '%'
 120
 121 %right UNARY
 122 %token END
 123 %left <token> '('
 124 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
 125 %token SECTIONS PHDRS INSERT_K AFTER BEFORE
 126 %token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
 127 %token SORT_BY_NAME SORT_BY_ALIGNMENT
 128 %token '{' '}'
 129 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
 130 %token INHIBIT_COMMON_ALLOCATION
 131 %token SEGMENT_START
 132 %token INCLUDE
 133 %token MEMORY
 134 %token NOLOAD DSECT COPY INFO OVERLAY
 135 %token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
 136 %token <integer> NEXT
 137 %token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
 138 %token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
 139 %token ORIGIN FILL
 140 %token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
 141 %token ALIGNMOD AT SUBALIGN PROVIDE PROVIDE_HIDDEN AS_NEEDED
 142 %type <token> assign_op atype attributes_opt sect_constraint
 143 %type <name>  filename
 144 %token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
 145 %token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
 146 %token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
 147 %token <name> VERS_TAG VERS_IDENTIFIER
 148 %token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
 149 %token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL
 150 %token EXCLUDE_FILE
 151 %token CONSTANT
 152 %type <versyms> vers_defns
 153 %type <versnode> vers_tag
 154 %type <deflist> verdep
 155 %token INPUT_DYNAMIC_LIST
 156
 157 %%
 158
 159 file:
 160                 INPUT_SCRIPT script_file
 161         |       INPUT_MRI_SCRIPT mri_script_file
 162         |       INPUT_VERSION_SCRIPT version_script_file
 163         |       INPUT_DYNAMIC_LIST dynamic_list_file
 164         |       INPUT_DEFSYM defsym_expr
 165         ;
 166
 167
 168 filename:  NAME;
 169
 170
 171 defsym_expr:
 172                 { ldlex_defsym(); }
 173                 NAME '=' exp
 174                 {
 175                   ldlex_popstate();
 176                   lang_add_assignment(exp_assop($3,$2,$4));
 177                 }
 178         ;
 179
 180 /* SYNTAX WITHIN AN MRI SCRIPT FILE */
 181 mri_script_file:
 182                 {
 183                   ldlex_mri_script ();
 184                   PUSH_ERROR (_("MRI style script"));
 185                 }
 186              mri_script_lines
 187                 {
 188                   ldlex_popstate ();
 189                   mri_draw_tree ();
 190                   POP_ERROR ();
 191                 }
 192         ;
 193
 194 mri_script_lines:
 195                 mri_script_lines mri_script_command NEWLINE
 196           |
 197         ;
 198
 199 mri_script_command:
 200                 CHIP  exp
 201         |       CHIP  exp ',' exp
 202         |       NAME    {
 203                         einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
 204                         }
 205         |       LIST    {
 206                         config.map_filename = "-";
 207                         }
 208         |       ORDER ordernamelist
 209         |       ENDWORD
 210         |       PUBLIC NAME '=' exp
 211                         { mri_public($2, $4); }
 212         |       PUBLIC NAME ',' exp
 213                         { mri_public($2, $4); }
 214         |       PUBLIC NAME  exp
 215                         { mri_public($2, $3); }
 216         |       FORMAT NAME
 217                         { mri_format($2); }
 218         |       SECT NAME ',' exp
 219                         { mri_output_section($2, $4);}
 220         |       SECT NAME  exp
 221                         { mri_output_section($2, $3);}
 222         |       SECT NAME '=' exp
 223                         { mri_output_section($2, $4);}
 224         |       ALIGN_K NAME '=' exp
 225                         { mri_align($2,$4); }
 226         |       ALIGN_K NAME ',' exp
 227                         { mri_align($2,$4); }
 228         |       ALIGNMOD NAME '=' exp
 229                         { mri_alignmod($2,$4); }
 230         |       ALIGNMOD NAME ',' exp
 231                         { mri_alignmod($2,$4); }
 232         |       ABSOLUTE mri_abs_name_list
 233         |       LOAD     mri_load_name_list
 234         |       NAMEWORD NAME
 235                         { mri_name($2); }
 236         |       ALIAS NAME ',' NAME
 237                         { mri_alias($2,$4,0);}
 238         |       ALIAS NAME ',' INT
 239                         { mri_alias ($2, 0, (int) $4.integer); }
 240         |       BASE     exp
 241                         { mri_base($2); }
 242         |       TRUNCATE INT
 243                 { mri_truncate ((unsigned int) $2.integer); }
 244         |       CASE casesymlist
 245         |       EXTERN extern_name_list
 246         |       INCLUDE filename
 247                 { ldlex_script (); ldfile_open_command_file($2); }
 248                 mri_script_lines END
 249                 { ldlex_popstate (); }
 250         |       START NAME
 251                 { lang_add_entry ($2, FALSE); }
 252         |
 253         ;
 254
 255 ordernamelist:
 256               ordernamelist ',' NAME         { mri_order($3); }
 257         |     ordernamelist  NAME         { mri_order($2); }
 258         |
 259         ;
 260
 261 mri_load_name_list:
 262                 NAME
 263                         { mri_load($1); }
 264         |       mri_load_name_list ',' NAME { mri_load($3); }
 265         ;
 266
 267 mri_abs_name_list:
 268                 NAME
 269                         { mri_only_load($1); }
 270         |       mri_abs_name_list ','  NAME
 271                         { mri_only_load($3); }
 272         ;
 273
 274 casesymlist:
 275           /* empty */ { $$ = NULL; }
 276         | NAME
 277         | casesymlist ',' NAME
 278         ;
 279
 280 /* Parsed as expressions so that commas separate entries */
 281 extern_name_list:
 282         { ldlex_expression (); }
 283         extern_name_list_body
 284         { ldlex_popstate (); }
 285
 286 extern_name_list_body:
 287           NAME
 288                         { ldlang_add_undef ($1); }
 289         | extern_name_list_body NAME
 290                         { ldlang_add_undef ($2); }
 291         | extern_name_list_body ',' NAME
 292                         { ldlang_add_undef ($3); }
 293         ;
 294
 295 script_file:
 296         { ldlex_both(); }
 297         ifile_list
 298         { ldlex_popstate(); }
 299         ;
 300
 301 ifile_list:
 302         ifile_list ifile_p1
 303         |
 304         ;
 305
 306
 307 ifile_p1:
 308                 memory
 309         |       sections
 310         |       phdrs
 311         |       startup
 312         |       high_level_library
 313         |       low_level_library
 314         |       floating_point_support
 315         |       statement_anywhere
 316         |       version
 317         |        ';'
 318         |       TARGET_K '(' NAME ')'
 319                 { lang_add_target($3); }
 320         |       SEARCH_DIR '(' filename ')'
 321                 { ldfile_add_library_path ($3, FALSE); }
 322         |       OUTPUT '(' filename ')'
 323                 { lang_add_output($3, 1); }
 324         |       OUTPUT_FORMAT '(' NAME ')'
 325                   { lang_add_output_format ($3, (char *) NULL,
 326                                             (char *) NULL, 1); }
 327         |       OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
 328                   { lang_add_output_format ($3, $5, $7, 1); }
 329         |       OUTPUT_ARCH '(' NAME ')'
 330                   { ldfile_set_output_arch ($3, bfd_arch_unknown); }
 331         |       FORCE_COMMON_ALLOCATION
 332                 { command_line.force_common_definition = TRUE ; }
 333         |       INHIBIT_COMMON_ALLOCATION
 334                 { command_line.inhibit_common_definition = TRUE ; }
 335         |       INPUT '(' input_list ')'
 336         |       GROUP
 337                   { lang_enter_group (); }
 338                     '(' input_list ')'
 339                   { lang_leave_group (); }
 340         |       MAP '(' filename ')'
 341                 { lang_add_map($3); }
 342         |       INCLUDE filename
 343                 { ldlex_script (); ldfile_open_command_file($2); }
 344                 ifile_list END
 345                 { ldlex_popstate (); }
 346         |       NOCROSSREFS '(' nocrossref_list ')'
 347                 {
 348                   lang_add_nocrossref ($3);
 349                 }
 350         |       EXTERN '(' extern_name_list ')'
 351         |       INSERT_K AFTER NAME
 352                 { lang_add_insert ($3, 0); }
 353         |       INSERT_K BEFORE NAME
 354                 { lang_add_insert ($3, 1); }
 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         | INCLUDE filename
 581                 { ldlex_script (); ldfile_open_command_file($2); }
 582                 statement_list_opt END
 583                 { ldlex_popstate (); }
 584         ;
 585
 586 statement_list:
 587                 statement_list statement
 588         |       statement
 589         ;
 590
 591 statement_list_opt:
 592                 /* empty */
 593         |       statement_list
 594         ;
 595
 596 length:
 597                 QUAD
 598                         { $$ = $1; }
 599         |       SQUAD
 600                         { $$ = $1; }
 601         |       LONG
 602                         { $$ = $1; }
 603         |       SHORT
 604                         { $$ = $1; }
 605         |       BYTE
 606                         { $$ = $1; }
 607         ;
 608
 609 fill_exp:
 610         mustbe_exp
 611                 {
 612                   $$ = exp_get_fill ($1, 0, "fill value");
 613                 }
 614         ;
 615
 616 fill_opt:
 617           '=' fill_exp
 618                 { $$ = $2; }
 619         |       { $$ = (fill_type *) 0; }
 620         ;
 621
 622 assign_op:
 623                 PLUSEQ
 624                         { $$ = '+'; }
 625         |       MINUSEQ
 626                         { $$ = '-'; }
 627         |       MULTEQ
 628                         { $$ = '*'; }
 629         |       DIVEQ
 630                         { $$ = '/'; }
 631         |       LSHIFTEQ
 632                         { $$ = LSHIFT; }
 633         |       RSHIFTEQ
 634                         { $$ = RSHIFT; }
 635         |       ANDEQ
 636                         { $$ = '&'; }
 637         |       OREQ
 638                         { $$ = '|'; }
 639
 640         ;
 641
 642 end:    ';' | ','
 643         ;
 644
 645
 646 assignment:
 647                 NAME '=' mustbe_exp
 648                 {
 649                   lang_add_assignment (exp_assop ($2, $1, $3));
 650                 }
 651         |       NAME assign_op mustbe_exp
 652                 {
 653                   lang_add_assignment (exp_assop ('=', $1,
 654                                                   exp_binop ($2,
 655                                                              exp_nameop (NAME,
 656                                                                          $1),
 657                                                              $3)));
 658                 }
 659         |       PROVIDE '(' NAME '=' mustbe_exp ')'
 660                 {
 661                   lang_add_assignment (exp_provide ($3, $5, FALSE));
 662                 }
 663         |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
 664                 {
 665                   lang_add_assignment (exp_provide ($3, $5, TRUE));
 666                 }
 667         ;
 668
 669
 670 opt_comma:
 671                 ','     |       ;
 672
 673
 674 memory:
 675                 MEMORY '{' memory_spec_list_opt '}'
 676         ;
 677
 678 memory_spec_list_opt: memory_spec_list | ;
 679
 680 memory_spec_list:
 681                 memory_spec_list opt_comma memory_spec
 682         |       memory_spec
 683         ;
 684
 685
 686 memory_spec:    NAME
 687                 { region = lang_memory_region_lookup ($1, TRUE); }
 688                 attributes_opt ':'
 689                 origin_spec opt_comma length_spec
 690                 {}
 691         |       INCLUDE filename
 692                 { ldlex_script (); ldfile_open_command_file($2); }
 693                 memory_spec_list_opt END
 694                 { ldlex_popstate (); }
 695         ;
 696
 697 origin_spec:
 698         ORIGIN '=' mustbe_exp
 699                 {
 700                   region->origin = exp_get_vma ($3, 0, "origin");
 701                   region->current = region->origin;
 702                 }
 703         ;
 704
 705 length_spec:
 706              LENGTH '=' mustbe_exp
 707                 {
 708                   region->length = exp_get_vma ($3, -1, "length");
 709                 }
 710         ;
 711
 712 attributes_opt:
 713                 /* empty */
 714                   { /* dummy action to avoid bison 1.25 error message */ }
 715         |       '(' attributes_list ')'
 716         ;
 717
 718 attributes_list:
 719                 attributes_string
 720         |       attributes_list attributes_string
 721         ;
 722
 723 attributes_string:
 724                 NAME
 725                   { lang_set_flags (region, $1, 0); }
 726         |       '!' NAME
 727                   { lang_set_flags (region, $2, 1); }
 728         ;
 729
 730 startup:
 731         STARTUP '(' filename ')'
 732                 { lang_startup($3); }
 733         ;
 734
 735 high_level_library:
 736                 HLL '(' high_level_library_NAME_list ')'
 737         |       HLL '(' ')'
 738                         { ldemul_hll((char *)NULL); }
 739         ;
 740
 741 high_level_library_NAME_list:
 742                 high_level_library_NAME_list opt_comma filename
 743                         { ldemul_hll($3); }
 744         |       filename
 745                         { ldemul_hll($1); }
 746
 747         ;
 748
 749 low_level_library:
 750         SYSLIB '(' low_level_library_NAME_list ')'
 751         ; low_level_library_NAME_list:
 752                 low_level_library_NAME_list opt_comma filename
 753                         { ldemul_syslib($3); }
 754         |
 755         ;
 756
 757 floating_point_support:
 758                 FLOAT
 759                         { lang_float(TRUE); }
 760         |       NOFLOAT
 761                         { lang_float(FALSE); }
 762         ;
 763
 764 nocrossref_list:
 765                 /* empty */
 766                 {
 767                   $$ = NULL;
 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 = $2;
 776                   $$ = n;
 777                 }
 778         |       NAME ',' nocrossref_list
 779                 {
 780                   struct lang_nocrossref *n;
 781
 782                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 783                   n->name = $1;
 784                   n->next = $3;
 785                   $$ = n;
 786                 }
 787         ;
 788
 789 mustbe_exp:              { ldlex_expression (); }
 790                 exp
 791                          { ldlex_popstate (); $$=$2;}
 792         ;
 793
 794 exp     :
 795                 '-' exp %prec UNARY
 796                         { $$ = exp_unop ('-', $2); }
 797         |       '(' exp ')'
 798                         { $$ = $2; }
 799         |       NEXT '(' exp ')' %prec UNARY
 800                         { $$ = exp_unop ((int) $1,$3); }
 801         |       '!' exp %prec UNARY
 802                         { $$ = exp_unop ('!', $2); }
 803         |       '+' exp %prec UNARY
 804                         { $$ = $2; }
 805         |       '~' exp %prec UNARY
 806                         { $$ = exp_unop ('~', $2);}
 807
 808         |       exp '*' exp
 809                         { $$ = exp_binop ('*', $1, $3); }
 810         |       exp '/' exp
 811                         { $$ = exp_binop ('/', $1, $3); }
 812         |       exp '%' exp
 813                         { $$ = exp_binop ('%', $1, $3); }
 814         |       exp '+' exp
 815                         { $$ = exp_binop ('+', $1, $3); }
 816         |       exp '-' exp
 817                         { $$ = exp_binop ('-' , $1, $3); }
 818         |       exp LSHIFT exp
 819                         { $$ = exp_binop (LSHIFT , $1, $3); }
 820         |       exp RSHIFT exp
 821                         { $$ = exp_binop (RSHIFT , $1, $3); }
 822         |       exp EQ exp
 823                         { $$ = exp_binop (EQ , $1, $3); }
 824         |       exp NE exp
 825                         { $$ = exp_binop (NE , $1, $3); }
 826         |       exp LE exp
 827                         { $$ = exp_binop (LE , $1, $3); }
 828         |       exp GE exp
 829                         { $$ = exp_binop (GE , $1, $3); }
 830         |       exp '<' exp
 831                         { $$ = exp_binop ('<' , $1, $3); }
 832         |       exp '>' exp
 833                         { $$ = exp_binop ('>' , $1, $3); }
 834         |       exp '&' exp
 835                         { $$ = exp_binop ('&' , $1, $3); }
 836         |       exp '^' exp
 837                         { $$ = exp_binop ('^' , $1, $3); }
 838         |       exp '|' exp
 839                         { $$ = exp_binop ('|' , $1, $3); }
 840         |       exp '?' exp ':' exp
 841                         { $$ = exp_trinop ('?' , $1, $3, $5); }
 842         |       exp ANDAND exp
 843                         { $$ = exp_binop (ANDAND , $1, $3); }
 844         |       exp OROR exp
 845                         { $$ = exp_binop (OROR , $1, $3); }
 846         |       DEFINED '(' NAME ')'
 847                         { $$ = exp_nameop (DEFINED, $3); }
 848         |       INT
 849                         { $$ = exp_bigintop ($1.integer, $1.str); }
 850         |       SIZEOF_HEADERS
 851                         { $$ = exp_nameop (SIZEOF_HEADERS,0); }
 852
 853         |       ALIGNOF '(' NAME ')'
 854                         { $$ = exp_nameop (ALIGNOF,$3); }
 855         |       SIZEOF '(' NAME ')'
 856                         { $$ = exp_nameop (SIZEOF,$3); }
 857         |       ADDR '(' NAME ')'
 858                         { $$ = exp_nameop (ADDR,$3); }
 859         |       LOADADDR '(' NAME ')'
 860                         { $$ = exp_nameop (LOADADDR,$3); }
 861         |       CONSTANT '(' NAME ')'
 862                         { $$ = exp_nameop (CONSTANT,$3); }
 863         |       ABSOLUTE '(' exp ')'
 864                         { $$ = exp_unop (ABSOLUTE, $3); }
 865         |       ALIGN_K '(' exp ')'
 866                         { $$ = exp_unop (ALIGN_K,$3); }
 867         |       ALIGN_K '(' exp ',' exp ')'
 868                         { $$ = exp_binop (ALIGN_K,$3,$5); }
 869         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 870                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
 871         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 872                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
 873         |       DATA_SEGMENT_END '(' exp ')'
 874                         { $$ = exp_unop (DATA_SEGMENT_END, $3); }
 875         |       SEGMENT_START '(' NAME ',' exp ')'
 876                         { /* The operands to the expression node are
 877                              placed in the opposite order from the way
 878                              in which they appear in the script as
 879                              that allows us to reuse more code in
 880                              fold_binary.  */
 881                           $$ = exp_binop (SEGMENT_START,
 882                                           $5,
 883                                           exp_nameop (NAME, $3)); }
 884         |       BLOCK '(' exp ')'
 885                         { $$ = exp_unop (ALIGN_K,$3); }
 886         |       NAME
 887                         { $$ = exp_nameop (NAME,$1); }
 888         |       MAX_K '(' exp ',' exp ')'
 889                         { $$ = exp_binop (MAX_K, $3, $5 ); }
 890         |       MIN_K '(' exp ',' exp ')'
 891                         { $$ = exp_binop (MIN_K, $3, $5 ); }
 892         |       ASSERT_K '(' exp ',' NAME ')'
 893                         { $$ = exp_assert ($3, $5); }
 894         |       ORIGIN '(' NAME ')'
 895                         { $$ = exp_nameop (ORIGIN, $3); }
 896         |       LENGTH '(' NAME ')'
 897                         { $$ = exp_nameop (LENGTH, $3); }
 898         ;
 899
 900
 901 memspec_at_opt:
 902                 AT '>' NAME { $$ = $3; }
 903         |       { $$ = 0; }
 904         ;
 905
 906 opt_at:
 907                 AT '(' exp ')' { $$ = $3; }
 908         |       { $$ = 0; }
 909         ;
 910
 911 opt_align:
 912                 ALIGN_K '(' exp ')' { $$ = $3; }
 913         |       { $$ = 0; }
 914         ;
 915
 916 opt_subalign:
 917                 SUBALIGN '(' exp ')' { $$ = $3; }
 918         |       { $$ = 0; }
 919         ;
 920
 921 sect_constraint:
 922                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
 923         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
 924         |       SPECIAL { $$ = SPECIAL; }
 925         |       { $$ = 0; }
 926         ;
 927
 928 section:        NAME            { ldlex_expression(); }
 929                 opt_exp_with_type
 930                 opt_at
 931                 opt_align
 932                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
 933                 sect_constraint
 934                 '{'
 935                         {
 936                           lang_enter_output_section_statement($1, $3,
 937                                                               sectype,
 938                                                               $5, $6, $4, $8);
 939                         }
 940                 statement_list_opt
 941                 '}' { ldlex_popstate (); ldlex_expression (); }
 942                 memspec_opt memspec_at_opt phdr_opt fill_opt
 943                 {
 944                   ldlex_popstate ();
 945                   lang_leave_output_section_statement ($17, $14, $16, $15);
 946                 }
 947                 opt_comma
 948                 {}
 949         |       OVERLAY
 950                         { ldlex_expression (); }
 951                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
 952                         { ldlex_popstate (); ldlex_script (); }
 953                 '{'
 954                         {
 955                           lang_enter_overlay ($3, $6);
 956                         }
 957                 overlay_section
 958                 '}'
 959                         { ldlex_popstate (); ldlex_expression (); }
 960                 memspec_opt memspec_at_opt phdr_opt fill_opt
 961                         {
 962                           ldlex_popstate ();
 963                           lang_leave_overlay ($5, (int) $4,
 964                                               $16, $13, $15, $14);
 965                         }
 966                 opt_comma
 967         |       /* The GROUP case is just enough to support the gcc
 968                    svr3.ifile script.  It is not intended to be full
 969                    support.  I'm not even sure what GROUP is supposed
 970                    to mean.  */
 971                 GROUP { ldlex_expression (); }
 972                 opt_exp_with_type
 973                 {
 974                   ldlex_popstate ();
 975                   lang_add_assignment (exp_assop ('=', ".", $3));
 976                 }
 977                 '{' sec_or_group_p1 '}'
 978         |       INCLUDE filename
 979                 { ldlex_script (); ldfile_open_command_file($2); }
 980                 sec_or_group_p1 END
 981                 { ldlex_popstate (); }
 982         ;
 983
 984 type:
 985            NOLOAD  { sectype = noload_section; }
 986         |  DSECT   { sectype = noalloc_section; }
 987         |  COPY    { sectype = noalloc_section; }
 988         |  INFO    { sectype = noalloc_section; }
 989         |  OVERLAY { sectype = noalloc_section; }
 990         ;
 991
 992 atype:
 993                 '(' type ')'
 994         |       /* EMPTY */ { sectype = normal_section; }
 995         |       '(' ')' { sectype = normal_section; }
 996         ;
 997
 998 opt_exp_with_type:
 999                 exp atype ':'           { $$ = $1; }
1000         |       atype ':'               { $$ = (etree_type *)NULL;  }
1001         |       /* The BIND cases are to support the gcc svr3.ifile
1002                    script.  They aren't intended to implement full
1003                    support for the BIND keyword.  I'm not even sure
1004                    what BIND is supposed to mean.  */
1005                 BIND '(' exp ')' atype ':' { $$ = $3; }
1006         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
1007                 { $$ = $3; }
1008         ;
1009
1010 opt_exp_without_type:
1011                 exp ':'         { $$ = $1; }
1012         |       ':'             { $$ = (etree_type *) NULL;  }
1013         ;
1014
1015 opt_nocrossrefs:
1016                 /* empty */
1017                         { $$ = 0; }
1018         |       NOCROSSREFS
1019                         { $$ = 1; }
1020         ;
1021
1022 memspec_opt:
1023                 '>' NAME
1024                 { $$ = $2; }
1025         |       { $$ = DEFAULT_MEMORY_REGION; }
1026         ;
1027
1028 phdr_opt:
1029                 /* empty */
1030                 {
1031                   $$ = NULL;
1032                 }
1033         |       phdr_opt ':' NAME
1034                 {
1035                   struct lang_output_section_phdr_list *n;
1036
1037                   n = ((struct lang_output_section_phdr_list *)
1038                        xmalloc (sizeof *n));
1039                   n->name = $3;
1040                   n->used = FALSE;
1041                   n->next = $1;
1042                   $$ = n;
1043                 }
1044         ;
1045
1046 overlay_section:
1047                 /* empty */
1048         |       overlay_section
1049                 NAME
1050                         {
1051                           ldlex_script ();
1052                           lang_enter_overlay_section ($2);
1053                         }
1054                 '{' statement_list_opt '}'
1055                         { ldlex_popstate (); ldlex_expression (); }
1056                 phdr_opt fill_opt
1057                         {
1058                           ldlex_popstate ();
1059                           lang_leave_overlay_section ($9, $8);
1060                         }
1061                 opt_comma
1062         ;
1063
1064 phdrs:
1065                 PHDRS '{' phdr_list '}'
1066         ;
1067
1068 phdr_list:
1069                 /* empty */
1070         |       phdr_list phdr
1071         ;
1072
1073 phdr:
1074                 NAME { ldlex_expression (); }
1075                   phdr_type phdr_qualifiers { ldlex_popstate (); }
1076                   ';'
1077                 {
1078                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1079                                  $4.flags);
1080                 }
1081         ;
1082
1083 phdr_type:
1084                 exp
1085                 {
1086                   $$ = $1;
1087
1088                   if ($1->type.node_class == etree_name
1089                       && $1->type.node_code == NAME)
1090                     {
1091                       const char *s;
1092                       unsigned int i;
1093                       static const char * const phdr_types[] =
1094                         {
1095                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1096                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1097                           "PT_PHDR", "PT_TLS"
1098                         };
1099
1100                       s = $1->name.name;
1101                       for (i = 0;
1102                            i < sizeof phdr_types / sizeof phdr_types[0];
1103                            i++)
1104                         if (strcmp (s, phdr_types[i]) == 0)
1105                           {
1106                             $$ = exp_intop (i);
1107                             break;
1108                           }
1109                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1110                         {
1111                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1112                             $$ = exp_intop (0x6474e550);
1113                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1114                             $$ = exp_intop (0x6474e551);
1115                           else
1116                             {
1117                               einfo (_("\
1118 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1119                                      s);
1120                               $$ = exp_intop (0);
1121                             }
1122                         }
1123                     }
1124                 }
1125         ;
1126
1127 phdr_qualifiers:
1128                 /* empty */
1129                 {
1130                   memset (&$$, 0, sizeof (struct phdr_info));
1131                 }
1132         |       NAME phdr_val phdr_qualifiers
1133                 {
1134                   $$ = $3;
1135                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1136                     $$.filehdr = TRUE;
1137                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1138                     $$.phdrs = TRUE;
1139                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1140                     $$.flags = $2;
1141                   else
1142                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1143                 }
1144         |       AT '(' exp ')' phdr_qualifiers
1145                 {
1146                   $$ = $5;
1147                   $$.at = $3;
1148                 }
1149         ;
1150
1151 phdr_val:
1152                 /* empty */
1153                 {
1154                   $$ = NULL;
1155                 }
1156         | '(' exp ')'
1157                 {
1158                   $$ = $2;
1159                 }
1160         ;
1161
1162 dynamic_list_file:
1163                 {
1164                   ldlex_version_file ();
1165                   PUSH_ERROR (_("dynamic list"));
1166                 }
1167                 dynamic_list_nodes
1168                 {
1169                   ldlex_popstate ();
1170                   POP_ERROR ();
1171                 }
1172         ;
1173
1174 dynamic_list_nodes:
1175                 dynamic_list_node
1176         |       dynamic_list_nodes dynamic_list_node
1177         ;
1178
1179 dynamic_list_node:
1180                 '{' dynamic_list_tag '}' ';'
1181         ;
1182
1183 dynamic_list_tag:
1184                 vers_defns ';'
1185                 {
1186                   lang_append_dynamic_list ($1);
1187                 }
1188         ;
1189
1190 /* This syntax is used within an external version script file.  */
1191
1192 version_script_file:
1193                 {
1194                   ldlex_version_file ();
1195                   PUSH_ERROR (_("VERSION script"));
1196                 }
1197                 vers_nodes
1198                 {
1199                   ldlex_popstate ();
1200                   POP_ERROR ();
1201                 }
1202         ;
1203
1204 /* This is used within a normal linker script file.  */
1205
1206 version:
1207                 {
1208                   ldlex_version_script ();
1209                 }
1210                 VERSIONK '{' vers_nodes '}'
1211                 {
1212                   ldlex_popstate ();
1213                 }
1214         ;
1215
1216 vers_nodes:
1217                 vers_node
1218         |       vers_nodes vers_node
1219         ;
1220
1221 vers_node:
1222                 '{' vers_tag '}' ';'
1223                 {
1224                   lang_register_vers_node (NULL, $2, NULL);
1225                 }
1226         |       VERS_TAG '{' vers_tag '}' ';'
1227                 {
1228                   lang_register_vers_node ($1, $3, NULL);
1229                 }
1230         |       VERS_TAG '{' vers_tag '}' verdep ';'
1231                 {
1232                   lang_register_vers_node ($1, $3, $5);
1233                 }
1234         ;
1235
1236 verdep:
1237                 VERS_TAG
1238                 {
1239                   $$ = lang_add_vers_depend (NULL, $1);
1240                 }
1241         |       verdep VERS_TAG
1242                 {
1243                   $$ = lang_add_vers_depend ($1, $2);
1244                 }
1245         ;
1246
1247 vers_tag:
1248                 /* empty */
1249                 {
1250                   $$ = lang_new_vers_node (NULL, NULL);
1251                 }
1252         |       vers_defns ';'
1253                 {
1254                   $$ = lang_new_vers_node ($1, NULL);
1255                 }
1256         |       GLOBAL ':' vers_defns ';'
1257                 {
1258                   $$ = lang_new_vers_node ($3, NULL);
1259                 }
1260         |       LOCAL ':' vers_defns ';'
1261                 {
1262                   $$ = lang_new_vers_node (NULL, $3);
1263                 }
1264         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1265                 {
1266                   $$ = lang_new_vers_node ($3, $7);
1267                 }
1268         ;
1269
1270 vers_defns:
1271                 VERS_IDENTIFIER
1272                 {
1273                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1274                 }
1275         |       NAME
1276                 {
1277                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1278                 }
1279         |       vers_defns ';' VERS_IDENTIFIER
1280                 {
1281                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1282                 }
1283         |       vers_defns ';' NAME
1284                 {
1285                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1286                 }
1287         |       vers_defns ';' EXTERN NAME '{'
1288                         {
1289                           $<name>$ = ldgram_vers_current_lang;
1290                           ldgram_vers_current_lang = $4;
1291                         }
1292                 vers_defns opt_semicolon '}'
1293                         {
1294                           struct bfd_elf_version_expr *pat;
1295                           for (pat = $7; pat->next != NULL; pat = pat->next);
1296                           pat->next = $1;
1297                           $$ = $7;
1298                           ldgram_vers_current_lang = $<name>6;
1299                         }
1300         |       EXTERN NAME '{'
1301                         {
1302                           $<name>$ = ldgram_vers_current_lang;
1303                           ldgram_vers_current_lang = $2;
1304                         }
1305                 vers_defns opt_semicolon '}'
1306                         {
1307                           $$ = $5;
1308                           ldgram_vers_current_lang = $<name>4;
1309                         }
1310         |       GLOBAL
1311                 {
1312                   $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1313                 }
1314         |       vers_defns ';' GLOBAL
1315                 {
1316                   $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1317                 }
1318         |       LOCAL
1319                 {
1320                   $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1321                 }
1322         |       vers_defns ';' LOCAL
1323                 {
1324                   $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1325                 }
1326         |       EXTERN
1327                 {
1328                   $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1329                 }
1330         |       vers_defns ';' EXTERN
1331                 {
1332                   $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1333                 }
1334         ;
1335
1336 opt_semicolon:
1337                 /* empty */
1338         |       ';'
1339         ;
1340
1341 %%
1342 void
1343 yyerror(arg)
1344      const char *arg;
1345 {
1346   if (ldfile_assumed_script)
1347     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1348            ldfile_input_filename);
1349   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1350      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1351   else
1352      einfo ("%P%F:%S: %s\n", arg);
1353 }