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 ([email protected]).
   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 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         |       SIZEOF '(' NAME ')'
 844                         { $$ = exp_nameop (SIZEOF,$3); }
 845         |       ADDR '(' NAME ')'
 846                         { $$ = exp_nameop (ADDR,$3); }
 847         |       LOADADDR '(' NAME ')'
 848                         { $$ = exp_nameop (LOADADDR,$3); }
 849         |       CONSTANT '(' NAME ')'
 850                         { $$ = exp_nameop (CONSTANT,$3); }
 851         |       ABSOLUTE '(' exp ')'
 852                         { $$ = exp_unop (ABSOLUTE, $3); }
 853         |       ALIGN_K '(' exp ')'
 854                         { $$ = exp_unop (ALIGN_K,$3); }
 855         |       ALIGN_K '(' exp ',' exp ')'
 856                         { $$ = exp_binop (ALIGN_K,$3,$5); }
 857         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 858                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
 859         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 860                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
 861         |       DATA_SEGMENT_END '(' exp ')'
 862                         { $$ = exp_unop (DATA_SEGMENT_END, $3); }
 863         |       SEGMENT_START '(' NAME ',' exp ')'
 864                         { /* The operands to the expression node are
 865                              placed in the opposite order from the way
 866                              in which they appear in the script as
 867                              that allows us to reuse more code in
 868                              fold_binary.  */
 869                           $$ = exp_binop (SEGMENT_START,
 870                                           $5,
 871                                           exp_nameop (NAME, $3)); }
 872         |       BLOCK '(' exp ')'
 873                         { $$ = exp_unop (ALIGN_K,$3); }
 874         |       NAME
 875                         { $$ = exp_nameop (NAME,$1); }
 876         |       MAX_K '(' exp ',' exp ')'
 877                         { $$ = exp_binop (MAX_K, $3, $5 ); }
 878         |       MIN_K '(' exp ',' exp ')'
 879                         { $$ = exp_binop (MIN_K, $3, $5 ); }
 880         |       ASSERT_K '(' exp ',' NAME ')'
 881                         { $$ = exp_assert ($3, $5); }
 882         |       ORIGIN '(' NAME ')'
 883                         { $$ = exp_nameop (ORIGIN, $3); }
 884         |       LENGTH '(' NAME ')'
 885                         { $$ = exp_nameop (LENGTH, $3); }
 886         ;
 887
 888
 889 memspec_at_opt:
 890                 AT '>' NAME { $$ = $3; }
 891         |       { $$ = 0; }
 892         ;
 893
 894 opt_at:
 895                 AT '(' exp ')' { $$ = $3; }
 896         |       { $$ = 0; }
 897         ;
 898
 899 opt_align:
 900                 ALIGN_K '(' exp ')' { $$ = $3; }
 901         |       { $$ = 0; }
 902         ;
 903
 904 opt_subalign:
 905                 SUBALIGN '(' exp ')' { $$ = $3; }
 906         |       { $$ = 0; }
 907         ;
 908
 909 sect_constraint:
 910                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
 911         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
 912         |       SPECIAL { $$ = SPECIAL; }
 913         |       { $$ = 0; }
 914         ;
 915
 916 section:        NAME            { ldlex_expression(); }
 917                 opt_exp_with_type
 918                 opt_at
 919                 opt_align
 920                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
 921                 sect_constraint
 922                 '{'
 923                         {
 924                           lang_enter_output_section_statement($1, $3,
 925                                                               sectype,
 926                                                               $5, $6, $4, $8);
 927                         }
 928                 statement_list_opt
 929                 '}' { ldlex_popstate (); ldlex_expression (); }
 930                 memspec_opt memspec_at_opt phdr_opt fill_opt
 931                 {
 932                   ldlex_popstate ();
 933                   lang_leave_output_section_statement ($17, $14, $16, $15);
 934                 }
 935                 opt_comma
 936                 {}
 937         |       OVERLAY
 938                         { ldlex_expression (); }
 939                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
 940                         { ldlex_popstate (); ldlex_script (); }
 941                 '{'
 942                         {
 943                           lang_enter_overlay ($3, $6);
 944                         }
 945                 overlay_section
 946                 '}'
 947                         { ldlex_popstate (); ldlex_expression (); }
 948                 memspec_opt memspec_at_opt phdr_opt fill_opt
 949                         {
 950                           ldlex_popstate ();
 951                           lang_leave_overlay ($5, (int) $4,
 952                                               $16, $13, $15, $14);
 953                         }
 954                 opt_comma
 955         |       /* The GROUP case is just enough to support the gcc
 956                    svr3.ifile script.  It is not intended to be full
 957                    support.  I'm not even sure what GROUP is supposed
 958                    to mean.  */
 959                 GROUP { ldlex_expression (); }
 960                 opt_exp_with_type
 961                 {
 962                   ldlex_popstate ();
 963                   lang_add_assignment (exp_assop ('=', ".", $3));
 964                 }
 965                 '{' sec_or_group_p1 '}'
 966         ;
 967
 968 type:
 969            NOLOAD  { sectype = noload_section; }
 970         |  DSECT   { sectype = noalloc_section; }
 971         |  COPY    { sectype = noalloc_section; }
 972         |  INFO    { sectype = noalloc_section; }
 973         |  OVERLAY { sectype = noalloc_section; }
 974         ;
 975
 976 atype:
 977                 '(' type ')'
 978         |       /* EMPTY */ { sectype = normal_section; }
 979         |       '(' ')' { sectype = normal_section; }
 980         ;
 981
 982 opt_exp_with_type:
 983                 exp atype ':'           { $$ = $1; }
 984         |       atype ':'               { $$ = (etree_type *)NULL;  }
 985         |       /* The BIND cases are to support the gcc svr3.ifile
 986                    script.  They aren't intended to implement full
 987                    support for the BIND keyword.  I'm not even sure
 988                    what BIND is supposed to mean.  */
 989                 BIND '(' exp ')' atype ':' { $$ = $3; }
 990         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
 991                 { $$ = $3; }
 992         ;
 993
 994 opt_exp_without_type:
 995                 exp ':'         { $$ = $1; }
 996         |       ':'             { $$ = (etree_type *) NULL;  }
 997         ;
 998
 999 opt_nocrossrefs:
1000                 /* empty */
1001                         { $$ = 0; }
1002         |       NOCROSSREFS
1003                         { $$ = 1; }
1004         ;
1005
1006 memspec_opt:
1007                 '>' NAME
1008                 { $$ = $2; }
1009         |       { $$ = DEFAULT_MEMORY_REGION; }
1010         ;
1011
1012 phdr_opt:
1013                 /* empty */
1014                 {
1015                   $$ = NULL;
1016                 }
1017         |       phdr_opt ':' NAME
1018                 {
1019                   struct lang_output_section_phdr_list *n;
1020
1021                   n = ((struct lang_output_section_phdr_list *)
1022                        xmalloc (sizeof *n));
1023                   n->name = $3;
1024                   n->used = FALSE;
1025                   n->next = $1;
1026                   $$ = n;
1027                 }
1028         ;
1029
1030 overlay_section:
1031                 /* empty */
1032         |       overlay_section
1033                 NAME
1034                         {
1035                           ldlex_script ();
1036                           lang_enter_overlay_section ($2);
1037                         }
1038                 '{' statement_list_opt '}'
1039                         { ldlex_popstate (); ldlex_expression (); }
1040                 phdr_opt fill_opt
1041                         {
1042                           ldlex_popstate ();
1043                           lang_leave_overlay_section ($9, $8);
1044                         }
1045                 opt_comma
1046         ;
1047
1048 phdrs:
1049                 PHDRS '{' phdr_list '}'
1050         ;
1051
1052 phdr_list:
1053                 /* empty */
1054         |       phdr_list phdr
1055         ;
1056
1057 phdr:
1058                 NAME { ldlex_expression (); }
1059                   phdr_type phdr_qualifiers { ldlex_popstate (); }
1060                   ';'
1061                 {
1062                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1063                                  $4.flags);
1064                 }
1065         ;
1066
1067 phdr_type:
1068                 exp
1069                 {
1070                   $$ = $1;
1071
1072                   if ($1->type.node_class == etree_name
1073                       && $1->type.node_code == NAME)
1074                     {
1075                       const char *s;
1076                       unsigned int i;
1077                       static const char * const phdr_types[] =
1078                         {
1079                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1080                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1081                           "PT_PHDR", "PT_TLS"
1082                         };
1083
1084                       s = $1->name.name;
1085                       for (i = 0;
1086                            i < sizeof phdr_types / sizeof phdr_types[0];
1087                            i++)
1088                         if (strcmp (s, phdr_types[i]) == 0)
1089                           {
1090                             $$ = exp_intop (i);
1091                             break;
1092                           }
1093                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1094                         {
1095                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1096                             $$ = exp_intop (0x6474e550);
1097                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1098                             $$ = exp_intop (0x6474e551);
1099                           else
1100                             {
1101                               einfo (_("\
1102 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1103                                      s);
1104                               $$ = exp_intop (0);
1105                             }
1106                         }
1107                     }
1108                 }
1109         ;
1110
1111 phdr_qualifiers:
1112                 /* empty */
1113                 {
1114                   memset (&$$, 0, sizeof (struct phdr_info));
1115                 }
1116         |       NAME phdr_val phdr_qualifiers
1117                 {
1118                   $$ = $3;
1119                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1120                     $$.filehdr = TRUE;
1121                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1122                     $$.phdrs = TRUE;
1123                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1124                     $$.flags = $2;
1125                   else
1126                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1127                 }
1128         |       AT '(' exp ')' phdr_qualifiers
1129                 {
1130                   $$ = $5;
1131                   $$.at = $3;
1132                 }
1133         ;
1134
1135 phdr_val:
1136                 /* empty */
1137                 {
1138                   $$ = NULL;
1139                 }
1140         | '(' exp ')'
1141                 {
1142                   $$ = $2;
1143                 }
1144         ;
1145
1146 dynamic_list_file:
1147                 {
1148                   ldlex_version_file ();
1149                   PUSH_ERROR (_("dynamic list"));
1150                 }
1151                 dynamic_list_nodes
1152                 {
1153                   ldlex_popstate ();
1154                   POP_ERROR ();
1155                 }
1156         ;
1157
1158 dynamic_list_nodes:
1159                 dynamic_list_node
1160         |       dynamic_list_nodes dynamic_list_node
1161         ;
1162
1163 dynamic_list_node:
1164                 '{' dynamic_list_tag '}' ';'
1165         ;
1166
1167 dynamic_list_tag:
1168                 vers_defns ';'
1169                 {
1170                   lang_append_dynamic_list ($1);
1171                 }
1172         ;
1173
1174 /* This syntax is used within an external version script file.  */
1175
1176 version_script_file:
1177                 {
1178                   ldlex_version_file ();
1179                   PUSH_ERROR (_("VERSION script"));
1180                 }
1181                 vers_nodes
1182                 {
1183                   ldlex_popstate ();
1184                   POP_ERROR ();
1185                 }
1186         ;
1187
1188 /* This is used within a normal linker script file.  */
1189
1190 version:
1191                 {
1192                   ldlex_version_script ();
1193                 }
1194                 VERSIONK '{' vers_nodes '}'
1195                 {
1196                   ldlex_popstate ();
1197                 }
1198         ;
1199
1200 vers_nodes:
1201                 vers_node
1202         |       vers_nodes vers_node
1203         ;
1204
1205 vers_node:
1206                 '{' vers_tag '}' ';'
1207                 {
1208                   lang_register_vers_node (NULL, $2, NULL);
1209                 }
1210         |       VERS_TAG '{' vers_tag '}' ';'
1211                 {
1212                   lang_register_vers_node ($1, $3, NULL);
1213                 }
1214         |       VERS_TAG '{' vers_tag '}' verdep ';'
1215                 {
1216                   lang_register_vers_node ($1, $3, $5);
1217                 }
1218         ;
1219
1220 verdep:
1221                 VERS_TAG
1222                 {
1223                   $$ = lang_add_vers_depend (NULL, $1);
1224                 }
1225         |       verdep VERS_TAG
1226                 {
1227                   $$ = lang_add_vers_depend ($1, $2);
1228                 }
1229         ;
1230
1231 vers_tag:
1232                 /* empty */
1233                 {
1234                   $$ = lang_new_vers_node (NULL, NULL);
1235                 }
1236         |       vers_defns ';'
1237                 {
1238                   $$ = lang_new_vers_node ($1, NULL);
1239                 }
1240         |       GLOBAL ':' vers_defns ';'
1241                 {
1242                   $$ = lang_new_vers_node ($3, NULL);
1243                 }
1244         |       LOCAL ':' vers_defns ';'
1245                 {
1246                   $$ = lang_new_vers_node (NULL, $3);
1247                 }
1248         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1249                 {
1250                   $$ = lang_new_vers_node ($3, $7);
1251                 }
1252         ;
1253
1254 vers_defns:
1255                 VERS_IDENTIFIER
1256                 {
1257                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1258                 }
1259         |       NAME
1260                 {
1261                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1262                 }
1263         |       vers_defns ';' VERS_IDENTIFIER
1264                 {
1265                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1266                 }
1267         |       vers_defns ';' NAME
1268                 {
1269                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1270                 }
1271         |       vers_defns ';' EXTERN NAME '{'
1272                         {
1273                           $<name>$ = ldgram_vers_current_lang;
1274                           ldgram_vers_current_lang = $4;
1275                         }
1276                 vers_defns opt_semicolon '}'
1277                         {
1278                           struct bfd_elf_version_expr *pat;
1279                           for (pat = $7; pat->next != NULL; pat = pat->next);
1280                           pat->next = $1;
1281                           $$ = $7;
1282                           ldgram_vers_current_lang = $<name>6;
1283                         }
1284         |       EXTERN NAME '{'
1285                         {
1286                           $<name>$ = ldgram_vers_current_lang;
1287                           ldgram_vers_current_lang = $2;
1288                         }
1289                 vers_defns opt_semicolon '}'
1290                         {
1291                           $$ = $5;
1292                           ldgram_vers_current_lang = $<name>4;
1293                         }
1294         |       GLOBAL
1295                 {
1296                   $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1297                 }
1298         |       vers_defns ';' GLOBAL
1299                 {
1300                   $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1301                 }
1302         |       LOCAL
1303                 {
1304                   $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1305                 }
1306         |       vers_defns ';' LOCAL
1307                 {
1308                   $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1309                 }
1310         |       EXTERN
1311                 {
1312                   $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1313                 }
1314         |       vers_defns ';' EXTERN
1315                 {
1316                   $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1317                 }
1318         ;
1319
1320 opt_semicolon:
1321                 /* empty */
1322         |       ';'
1323         ;
1324
1325 %%
1326 void
1327 yyerror(arg)
1328      const char *arg;
1329 {
1330   if (ldfile_assumed_script)
1331     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1332            ldfile_input_filename);
1333   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1334      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1335   else
1336      einfo ("%P%F:%S: %s\n", arg);
1337 }