contrib/binutils-2.21/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, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
   6
   7    This file is part of the GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 %{
  25 /*
  26
  27  */
  28
  29 #define DONTDECLARE_MALLOC
  30
  31 #include "sysdep.h"
  32 #include "bfd.h"
  33 #include "bfdlink.h"
  34 #include "ld.h"
  35 #include "ldexp.h"
  36 #include "ldver.h"
  37 #include "ldlang.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "ldmisc.h"
  41 #include "ldmain.h"
  42 #include "mri.h"
  43 #include "ldctor.h"
  44 #include "ldlex.h"
  45
  46 #ifndef YYDEBUG
  47 #define YYDEBUG 1
  48 #endif
  49
  50 static enum section_type sectype;
  51 static lang_memory_region_type *region;
  52
  53 bfd_boolean ldgram_had_keep = FALSE;
  54 char *ldgram_vers_current_lang = NULL;
  55
  56 #define ERROR_NAME_MAX 20
  57 static char *error_names[ERROR_NAME_MAX];
  58 static int error_index;
  59 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
  60 #define POP_ERROR()   error_index--;
  61 %}
  62 %union {
  63   bfd_vma integer;
  64   struct big_int
  65     {
  66       bfd_vma integer;
  67       char *str;
  68     } bigint;
  69   fill_type *fill;
  70   char *name;
  71   const char *cname;
  72   struct wildcard_spec wildcard;
  73   struct wildcard_list *wildcard_list;
  74   struct name_list *name_list;
  75   int token;
  76   union etree_union *etree;
  77   struct phdr_info
  78     {
  79       bfd_boolean filehdr;
  80       bfd_boolean phdrs;
  81       union etree_union *at;
  82       union etree_union *flags;
  83     } phdr;
  84   struct lang_nocrossref *nocrossref;
  85   struct lang_output_section_phdr_list *section_phdr;
  86   struct bfd_elf_version_deps *deflist;
  87   struct bfd_elf_version_expr *versyms;
  88   struct bfd_elf_version_tree *versnode;
  89 }
  90
  91 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
  92 %type <etree> opt_exp_without_type opt_subalign opt_align
  93 %type <fill> fill_opt fill_exp
  94 %type <name_list> exclude_name_list
  95 %type <wildcard_list> file_NAME_list
  96 %type <name> memspec_opt casesymlist
  97 %type <name> memspec_at_opt
  98 %type <cname> wildcard_name
  99 %type <wildcard> wildcard_spec
 100 %token <bigint> INT
 101 %token <name> NAME LNAME
 102 %type <integer> length
 103 %type <phdr> phdr_qualifiers
 104 %type <nocrossref> nocrossref_list
 105 %type <section_phdr> phdr_opt
 106 %type <integer> opt_nocrossrefs
 107
 108 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
 109 %right <token> '?' ':'
 110 %left <token> OROR
 111 %left <token>  ANDAND
 112 %left <token> '|'
 113 %left <token>  '^'
 114 %left  <token> '&'
 115 %left <token>  EQ NE
 116 %left  <token> '<' '>' LE GE
 117 %left  <token> LSHIFT RSHIFT
 118
 119 %left  <token> '+' '-'
 120 %left  <token> '*' '/' '%'
 121
 122 %right UNARY
 123 %token END
 124 %left <token> '('
 125 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
 126 %token SECTIONS PHDRS INSERT_K AFTER BEFORE
 127 %token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
 128 %token SORT_BY_NAME SORT_BY_ALIGNMENT
 129 %token '{' '}'
 130 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
 131 %token INHIBIT_COMMON_ALLOCATION
 132 %token SEGMENT_START
 133 %token INCLUDE
 134 %token MEMORY
 135 %token REGION_ALIAS
 136 %token LD_FEATURE
 137 %token NOLOAD DSECT COPY INFO OVERLAY
 138 %token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
 139 %token <integer> NEXT
 140 %token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
 141 %token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
 142 %token ORIGIN FILL
 143 %token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
 144 %token ALIGNMOD AT SUBALIGN PROVIDE PROVIDE_HIDDEN AS_NEEDED
 145 %type <token> assign_op atype attributes_opt sect_constraint
 146 %type <name>  filename
 147 %token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
 148 %token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
 149 %token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
 150 %token <name> VERS_TAG VERS_IDENTIFIER
 151 %token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
 152 %token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL
 153 %token EXCLUDE_FILE
 154 %token CONSTANT
 155 %type <versyms> vers_defns
 156 %type <versnode> vers_tag
 157 %type <deflist> verdep
 158 %token INPUT_DYNAMIC_LIST
 159
 160 %%
 161
 162 file:
 163                 INPUT_SCRIPT script_file
 164         |       INPUT_MRI_SCRIPT mri_script_file
 165         |       INPUT_VERSION_SCRIPT version_script_file
 166         |       INPUT_DYNAMIC_LIST dynamic_list_file
 167         |       INPUT_DEFSYM defsym_expr
 168         ;
 169
 170
 171 filename:  NAME;
 172
 173
 174 defsym_expr:
 175                 { ldlex_defsym(); }
 176                 NAME '=' exp
 177                 {
 178                   ldlex_popstate();
 179                   lang_add_assignment (exp_defsym ($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, FALSE); }
 292         | extern_name_list_body NAME
 293                         { ldlang_add_undef ($2, FALSE); }
 294         | extern_name_list_body ',' NAME
 295                         { ldlang_add_undef ($3, FALSE); }
 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         |       INSERT_K AFTER NAME
 355                 { lang_add_insert ($3, 0); }
 356         |       INSERT_K BEFORE NAME
 357                 { lang_add_insert ($3, 1); }
 358         |       REGION_ALIAS '(' NAME ',' NAME ')'
 359                 { lang_memory_region_alias ($3, $5); }
 360         |       LD_FEATURE '(' NAME ')'
 361                 { lang_ld_feature ($3); }
 362         ;
 363
 364 input_list:
 365                 NAME
 366                 { lang_add_input_file($1,lang_input_file_is_search_file_enum,
 367                                  (char *)NULL); }
 368         |       input_list ',' NAME
 369                 { lang_add_input_file($3,lang_input_file_is_search_file_enum,
 370                                  (char *)NULL); }
 371         |       input_list NAME
 372                 { lang_add_input_file($2,lang_input_file_is_search_file_enum,
 373                                  (char *)NULL); }
 374         |       LNAME
 375                 { lang_add_input_file($1,lang_input_file_is_l_enum,
 376                                  (char *)NULL); }
 377         |       input_list ',' LNAME
 378                 { lang_add_input_file($3,lang_input_file_is_l_enum,
 379                                  (char *)NULL); }
 380         |       input_list LNAME
 381                 { lang_add_input_file($2,lang_input_file_is_l_enum,
 382                                  (char *)NULL); }
 383         |       AS_NEEDED '('
 384                   { $<integer>$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
 385                      input_list ')'
 386                   { add_DT_NEEDED_for_regular = $<integer>3; }
 387         |       input_list ',' AS_NEEDED '('
 388                   { $<integer>$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
 389                      input_list ')'
 390                   { add_DT_NEEDED_for_regular = $<integer>5; }
 391         |       input_list AS_NEEDED '('
 392                   { $<integer>$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
 393                      input_list ')'
 394                   { add_DT_NEEDED_for_regular = $<integer>4; }
 395         ;
 396
 397 sections:
 398                 SECTIONS '{' sec_or_group_p1 '}'
 399         ;
 400
 401 sec_or_group_p1:
 402                 sec_or_group_p1 section
 403         |       sec_or_group_p1 statement_anywhere
 404         |
 405         ;
 406
 407 statement_anywhere:
 408                 ENTRY '(' NAME ')'
 409                 { lang_add_entry ($3, FALSE); }
 410         |       assignment end
 411         |       ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
 412                 { ldlex_popstate ();
 413                   lang_add_assignment (exp_assert ($4, $6)); }
 414         ;
 415
 416 /* The '*' and '?' cases are there because the lexer returns them as
 417    separate tokens rather than as NAME.  */
 418 wildcard_name:
 419                 NAME
 420                         {
 421                           $$ = $1;
 422                         }
 423         |       '*'
 424                         {
 425                           $$ = "*";
 426                         }
 427         |       '?'
 428                         {
 429                           $$ = "?";
 430                         }
 431         ;
 432
 433 wildcard_spec:
 434                 wildcard_name
 435                         {
 436                           $$.name = $1;
 437                           $$.sorted = none;
 438                           $$.exclude_name_list = NULL;
 439                         }
 440         |       EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
 441                         {
 442                           $$.name = $5;
 443                           $$.sorted = none;
 444                           $$.exclude_name_list = $3;
 445                         }
 446         |       SORT_BY_NAME '(' wildcard_name ')'
 447                         {
 448                           $$.name = $3;
 449                           $$.sorted = by_name;
 450                           $$.exclude_name_list = NULL;
 451                         }
 452         |       SORT_BY_ALIGNMENT '(' wildcard_name ')'
 453                         {
 454                           $$.name = $3;
 455                           $$.sorted = by_alignment;
 456                           $$.exclude_name_list = NULL;
 457                         }
 458         |       SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
 459                         {
 460                           $$.name = $5;
 461                           $$.sorted = by_name_alignment;
 462                           $$.exclude_name_list = NULL;
 463                         }
 464         |       SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
 465                         {
 466                           $$.name = $5;
 467                           $$.sorted = by_name;
 468                           $$.exclude_name_list = NULL;
 469                         }
 470         |       SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
 471                         {
 472                           $$.name = $5;
 473                           $$.sorted = by_alignment_name;
 474                           $$.exclude_name_list = NULL;
 475                         }
 476         |       SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
 477                         {
 478                           $$.name = $5;
 479                           $$.sorted = by_alignment;
 480                           $$.exclude_name_list = NULL;
 481                         }
 482         |       SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
 483                         {
 484                           $$.name = $7;
 485                           $$.sorted = by_name;
 486                           $$.exclude_name_list = $5;
 487                         }
 488         ;
 489
 490 exclude_name_list:
 491                 exclude_name_list wildcard_name
 492                         {
 493                           struct name_list *tmp;
 494                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
 495                           tmp->name = $2;
 496                           tmp->next = $1;
 497                           $$ = tmp;
 498                         }
 499         |
 500                 wildcard_name
 501                         {
 502                           struct name_list *tmp;
 503                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
 504                           tmp->name = $1;
 505                           tmp->next = NULL;
 506                           $$ = tmp;
 507                         }
 508         ;
 509
 510 file_NAME_list:
 511                 file_NAME_list opt_comma wildcard_spec
 512                         {
 513                           struct wildcard_list *tmp;
 514                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
 515                           tmp->next = $1;
 516                           tmp->spec = $3;
 517                           $$ = tmp;
 518                         }
 519         |
 520                 wildcard_spec
 521                         {
 522                           struct wildcard_list *tmp;
 523                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
 524                           tmp->next = NULL;
 525                           tmp->spec = $1;
 526                           $$ = tmp;
 527                         }
 528         ;
 529
 530 input_section_spec_no_keep:
 531                 NAME
 532                         {
 533                           struct wildcard_spec tmp;
 534                           tmp.name = $1;
 535                           tmp.exclude_name_list = NULL;
 536                           tmp.sorted = none;
 537                           lang_add_wild (&tmp, NULL, ldgram_had_keep);
 538                         }
 539         |       '[' file_NAME_list ']'
 540                         {
 541                           lang_add_wild (NULL, $2, ldgram_had_keep);
 542                         }
 543         |       wildcard_spec '(' file_NAME_list ')'
 544                         {
 545                           lang_add_wild (&$1, $3, ldgram_had_keep);
 546                         }
 547         ;
 548
 549 input_section_spec:
 550                 input_section_spec_no_keep
 551         |       KEEP '('
 552                         { ldgram_had_keep = TRUE; }
 553                 input_section_spec_no_keep ')'
 554                         { ldgram_had_keep = FALSE; }
 555         ;
 556
 557 statement:
 558                 assignment end
 559         |       CREATE_OBJECT_SYMBOLS
 560                 {
 561                 lang_add_attribute(lang_object_symbols_statement_enum);
 562                 }
 563         |       ';'
 564         |       CONSTRUCTORS
 565                 {
 566
 567                   lang_add_attribute(lang_constructors_statement_enum);
 568                 }
 569         | SORT_BY_NAME '(' CONSTRUCTORS ')'
 570                 {
 571                   constructors_sorted = TRUE;
 572                   lang_add_attribute (lang_constructors_statement_enum);
 573                 }
 574         | input_section_spec
 575         | length '(' mustbe_exp ')'
 576                         {
 577                           lang_add_data ((int) $1, $3);
 578                         }
 579
 580         | FILL '(' fill_exp ')'
 581                         {
 582                           lang_add_fill ($3);
 583                         }
 584         | ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
 585                         { ldlex_popstate ();
 586                           lang_add_assignment (exp_assert ($4, $6)); }
 587         | INCLUDE filename
 588                 { ldlex_script (); ldfile_open_command_file($2); }
 589                 statement_list_opt END
 590                 { ldlex_popstate (); }
 591         ;
 592
 593 statement_list:
 594                 statement_list statement
 595         |       statement
 596         ;
 597
 598 statement_list_opt:
 599                 /* empty */
 600         |       statement_list
 601         ;
 602
 603 length:
 604                 QUAD
 605                         { $$ = $1; }
 606         |       SQUAD
 607                         { $$ = $1; }
 608         |       LONG
 609                         { $$ = $1; }
 610         |       SHORT
 611                         { $$ = $1; }
 612         |       BYTE
 613                         { $$ = $1; }
 614         ;
 615
 616 fill_exp:
 617         mustbe_exp
 618                 {
 619                   $$ = exp_get_fill ($1, 0, "fill value");
 620                 }
 621         ;
 622
 623 fill_opt:
 624           '=' fill_exp
 625                 { $$ = $2; }
 626         |       { $$ = (fill_type *) 0; }
 627         ;
 628
 629 assign_op:
 630                 PLUSEQ
 631                         { $$ = '+'; }
 632         |       MINUSEQ
 633                         { $$ = '-'; }
 634         |       MULTEQ
 635                         { $$ = '*'; }
 636         |       DIVEQ
 637                         { $$ = '/'; }
 638         |       LSHIFTEQ
 639                         { $$ = LSHIFT; }
 640         |       RSHIFTEQ
 641                         { $$ = RSHIFT; }
 642         |       ANDEQ
 643                         { $$ = '&'; }
 644         |       OREQ
 645                         { $$ = '|'; }
 646
 647         ;
 648
 649 end:    ';' | ','
 650         ;
 651
 652
 653 assignment:
 654                 NAME '=' mustbe_exp
 655                 {
 656                   lang_add_assignment (exp_assign ($1, $3));
 657                 }
 658         |       NAME assign_op mustbe_exp
 659                 {
 660                   lang_add_assignment (exp_assign ($1,
 661                                                    exp_binop ($2,
 662                                                               exp_nameop (NAME,
 663                                                                           $1),
 664                                                               $3)));
 665                 }
 666         |       PROVIDE '(' NAME '=' mustbe_exp ')'
 667                 {
 668                   lang_add_assignment (exp_provide ($3, $5, FALSE));
 669                 }
 670         |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
 671                 {
 672                   lang_add_assignment (exp_provide ($3, $5, TRUE));
 673                 }
 674         ;
 675
 676
 677 opt_comma:
 678                 ','     |       ;
 679
 680
 681 memory:
 682                 MEMORY '{' memory_spec_list_opt '}'
 683         ;
 684
 685 memory_spec_list_opt: memory_spec_list | ;
 686
 687 memory_spec_list:
 688                 memory_spec_list opt_comma memory_spec
 689         |       memory_spec
 690         ;
 691
 692
 693 memory_spec:    NAME
 694                 { region = lang_memory_region_lookup ($1, TRUE); }
 695                 attributes_opt ':'
 696                 origin_spec opt_comma length_spec
 697                 {}
 698         |       INCLUDE filename
 699                 { ldlex_script (); ldfile_open_command_file($2); }
 700                 memory_spec_list_opt END
 701                 { ldlex_popstate (); }
 702         ;
 703
 704 origin_spec:
 705         ORIGIN '=' mustbe_exp
 706                 {
 707                   region->origin = exp_get_vma ($3, 0, "origin");
 708                   region->current = region->origin;
 709                 }
 710         ;
 711
 712 length_spec:
 713              LENGTH '=' mustbe_exp
 714                 {
 715                   region->length = exp_get_vma ($3, -1, "length");
 716                 }
 717         ;
 718
 719 attributes_opt:
 720                 /* empty */
 721                   { /* dummy action to avoid bison 1.25 error message */ }
 722         |       '(' attributes_list ')'
 723         ;
 724
 725 attributes_list:
 726                 attributes_string
 727         |       attributes_list attributes_string
 728         ;
 729
 730 attributes_string:
 731                 NAME
 732                   { lang_set_flags (region, $1, 0); }
 733         |       '!' NAME
 734                   { lang_set_flags (region, $2, 1); }
 735         ;
 736
 737 startup:
 738         STARTUP '(' filename ')'
 739                 { lang_startup($3); }
 740         ;
 741
 742 high_level_library:
 743                 HLL '(' high_level_library_NAME_list ')'
 744         |       HLL '(' ')'
 745                         { ldemul_hll((char *)NULL); }
 746         ;
 747
 748 high_level_library_NAME_list:
 749                 high_level_library_NAME_list opt_comma filename
 750                         { ldemul_hll($3); }
 751         |       filename
 752                         { ldemul_hll($1); }
 753
 754         ;
 755
 756 low_level_library:
 757         SYSLIB '(' low_level_library_NAME_list ')'
 758         ; low_level_library_NAME_list:
 759                 low_level_library_NAME_list opt_comma filename
 760                         { ldemul_syslib($3); }
 761         |
 762         ;
 763
 764 floating_point_support:
 765                 FLOAT
 766                         { lang_float(TRUE); }
 767         |       NOFLOAT
 768                         { lang_float(FALSE); }
 769         ;
 770
 771 nocrossref_list:
 772                 /* empty */
 773                 {
 774                   $$ = NULL;
 775                 }
 776         |       NAME nocrossref_list
 777                 {
 778                   struct lang_nocrossref *n;
 779
 780                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 781                   n->name = $1;
 782                   n->next = $2;
 783                   $$ = n;
 784                 }
 785         |       NAME ',' nocrossref_list
 786                 {
 787                   struct lang_nocrossref *n;
 788
 789                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
 790                   n->name = $1;
 791                   n->next = $3;
 792                   $$ = n;
 793                 }
 794         ;
 795
 796 mustbe_exp:              { ldlex_expression (); }
 797                 exp
 798                          { ldlex_popstate (); $$=$2;}
 799         ;
 800
 801 exp     :
 802                 '-' exp %prec UNARY
 803                         { $$ = exp_unop ('-', $2); }
 804         |       '(' exp ')'
 805                         { $$ = $2; }
 806         |       NEXT '(' exp ')' %prec UNARY
 807                         { $$ = exp_unop ((int) $1,$3); }
 808         |       '!' exp %prec UNARY
 809                         { $$ = exp_unop ('!', $2); }
 810         |       '+' exp %prec UNARY
 811                         { $$ = $2; }
 812         |       '~' exp %prec UNARY
 813                         { $$ = exp_unop ('~', $2);}
 814
 815         |       exp '*' exp
 816                         { $$ = exp_binop ('*', $1, $3); }
 817         |       exp '/' exp
 818                         { $$ = exp_binop ('/', $1, $3); }
 819         |       exp '%' exp
 820                         { $$ = exp_binop ('%', $1, $3); }
 821         |       exp '+' exp
 822                         { $$ = exp_binop ('+', $1, $3); }
 823         |       exp '-' exp
 824                         { $$ = exp_binop ('-' , $1, $3); }
 825         |       exp LSHIFT exp
 826                         { $$ = exp_binop (LSHIFT , $1, $3); }
 827         |       exp RSHIFT exp
 828                         { $$ = exp_binop (RSHIFT , $1, $3); }
 829         |       exp EQ exp
 830                         { $$ = exp_binop (EQ , $1, $3); }
 831         |       exp NE exp
 832                         { $$ = exp_binop (NE , $1, $3); }
 833         |       exp LE exp
 834                         { $$ = exp_binop (LE , $1, $3); }
 835         |       exp GE exp
 836                         { $$ = exp_binop (GE , $1, $3); }
 837         |       exp '<' exp
 838                         { $$ = exp_binop ('<' , $1, $3); }
 839         |       exp '>' exp
 840                         { $$ = exp_binop ('>' , $1, $3); }
 841         |       exp '&' exp
 842                         { $$ = exp_binop ('&' , $1, $3); }
 843         |       exp '^' exp
 844                         { $$ = exp_binop ('^' , $1, $3); }
 845         |       exp '|' exp
 846                         { $$ = exp_binop ('|' , $1, $3); }
 847         |       exp '?' exp ':' exp
 848                         { $$ = exp_trinop ('?' , $1, $3, $5); }
 849         |       exp ANDAND exp
 850                         { $$ = exp_binop (ANDAND , $1, $3); }
 851         |       exp OROR exp
 852                         { $$ = exp_binop (OROR , $1, $3); }
 853         |       DEFINED '(' NAME ')'
 854                         { $$ = exp_nameop (DEFINED, $3); }
 855         |       INT
 856                         { $$ = exp_bigintop ($1.integer, $1.str); }
 857         |       SIZEOF_HEADERS
 858                         { $$ = exp_nameop (SIZEOF_HEADERS,0); }
 859
 860         |       ALIGNOF '(' NAME ')'
 861                         { $$ = exp_nameop (ALIGNOF,$3); }
 862         |       SIZEOF '(' NAME ')'
 863                         { $$ = exp_nameop (SIZEOF,$3); }
 864         |       ADDR '(' NAME ')'
 865                         { $$ = exp_nameop (ADDR,$3); }
 866         |       LOADADDR '(' NAME ')'
 867                         { $$ = exp_nameop (LOADADDR,$3); }
 868         |       CONSTANT '(' NAME ')'
 869                         { $$ = exp_nameop (CONSTANT,$3); }
 870         |       ABSOLUTE '(' exp ')'
 871                         { $$ = exp_unop (ABSOLUTE, $3); }
 872         |       ALIGN_K '(' exp ')'
 873                         { $$ = exp_unop (ALIGN_K,$3); }
 874         |       ALIGN_K '(' exp ',' exp ')'
 875                         { $$ = exp_binop (ALIGN_K,$3,$5); }
 876         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 877                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
 878         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 879                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
 880         |       DATA_SEGMENT_END '(' exp ')'
 881                         { $$ = exp_unop (DATA_SEGMENT_END, $3); }
 882         |       SEGMENT_START '(' NAME ',' exp ')'
 883                         { /* The operands to the expression node are
 884                              placed in the opposite order from the way
 885                              in which they appear in the script as
 886                              that allows us to reuse more code in
 887                              fold_binary.  */
 888                           $$ = exp_binop (SEGMENT_START,
 889                                           $5,
 890                                           exp_nameop (NAME, $3)); }
 891         |       BLOCK '(' exp ')'
 892                         { $$ = exp_unop (ALIGN_K,$3); }
 893         |       NAME
 894                         { $$ = exp_nameop (NAME,$1); }
 895         |       MAX_K '(' exp ',' exp ')'
 896                         { $$ = exp_binop (MAX_K, $3, $5 ); }
 897         |       MIN_K '(' exp ',' exp ')'
 898                         { $$ = exp_binop (MIN_K, $3, $5 ); }
 899         |       ASSERT_K '(' exp ',' NAME ')'
 900                         { $$ = exp_assert ($3, $5); }
 901         |       ORIGIN '(' NAME ')'
 902                         { $$ = exp_nameop (ORIGIN, $3); }
 903         |       LENGTH '(' NAME ')'
 904                         { $$ = exp_nameop (LENGTH, $3); }
 905         ;
 906
 907
 908 memspec_at_opt:
 909                 AT '>' NAME { $$ = $3; }
 910         |       { $$ = 0; }
 911         ;
 912
 913 opt_at:
 914                 AT '(' exp ')' { $$ = $3; }
 915         |       { $$ = 0; }
 916         ;
 917
 918 opt_align:
 919                 ALIGN_K '(' exp ')' { $$ = $3; }
 920         |       { $$ = 0; }
 921         ;
 922
 923 opt_subalign:
 924                 SUBALIGN '(' exp ')' { $$ = $3; }
 925         |       { $$ = 0; }
 926         ;
 927
 928 sect_constraint:
 929                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
 930         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
 931         |       SPECIAL { $$ = SPECIAL; }
 932         |       { $$ = 0; }
 933         ;
 934
 935 section:        NAME            { ldlex_expression(); }
 936                 opt_exp_with_type
 937                 opt_at
 938                 opt_align
 939                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
 940                 sect_constraint
 941                 '{'
 942                         {
 943                           lang_enter_output_section_statement($1, $3,
 944                                                               sectype,
 945                                                               $5, $6, $4, $8);
 946                         }
 947                 statement_list_opt
 948                 '}' { ldlex_popstate (); ldlex_expression (); }
 949                 memspec_opt memspec_at_opt phdr_opt fill_opt
 950                 {
 951                   ldlex_popstate ();
 952                   lang_leave_output_section_statement ($17, $14, $16, $15);
 953                 }
 954                 opt_comma
 955                 {}
 956         |       OVERLAY
 957                         { ldlex_expression (); }
 958                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
 959                         { ldlex_popstate (); ldlex_script (); }
 960                 '{'
 961                         {
 962                           lang_enter_overlay ($3, $6);
 963                         }
 964                 overlay_section
 965                 '}'
 966                         { ldlex_popstate (); ldlex_expression (); }
 967                 memspec_opt memspec_at_opt phdr_opt fill_opt
 968                         {
 969                           ldlex_popstate ();
 970                           lang_leave_overlay ($5, (int) $4,
 971                                               $16, $13, $15, $14);
 972                         }
 973                 opt_comma
 974         |       /* The GROUP case is just enough to support the gcc
 975                    svr3.ifile script.  It is not intended to be full
 976                    support.  I'm not even sure what GROUP is supposed
 977                    to mean.  */
 978                 GROUP { ldlex_expression (); }
 979                 opt_exp_with_type
 980                 {
 981                   ldlex_popstate ();
 982                   lang_add_assignment (exp_assign (".", $3));
 983                 }
 984                 '{' sec_or_group_p1 '}'
 985         |       INCLUDE filename
 986                 { ldlex_script (); ldfile_open_command_file($2); }
 987                 sec_or_group_p1 END
 988                 { ldlex_popstate (); }
 989         ;
 990
 991 type:
 992            NOLOAD  { sectype = noload_section; }
 993         |  DSECT   { sectype = noalloc_section; }
 994         |  COPY    { sectype = noalloc_section; }
 995         |  INFO    { sectype = noalloc_section; }
 996         |  OVERLAY { sectype = noalloc_section; }
 997         ;
 998
 999 atype:
1000                 '(' type ')'
1001         |       /* EMPTY */ { sectype = normal_section; }
1002         |       '(' ')' { sectype = normal_section; }
1003         ;
1004
1005 opt_exp_with_type:
1006                 exp atype ':'           { $$ = $1; }
1007         |       atype ':'               { $$ = (etree_type *)NULL;  }
1008         |       /* The BIND cases are to support the gcc svr3.ifile
1009                    script.  They aren't intended to implement full
1010                    support for the BIND keyword.  I'm not even sure
1011                    what BIND is supposed to mean.  */
1012                 BIND '(' exp ')' atype ':' { $$ = $3; }
1013         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
1014                 { $$ = $3; }
1015         ;
1016
1017 opt_exp_without_type:
1018                 exp ':'         { $$ = $1; }
1019         |       ':'             { $$ = (etree_type *) NULL;  }
1020         ;
1021
1022 opt_nocrossrefs:
1023                 /* empty */
1024                         { $$ = 0; }
1025         |       NOCROSSREFS
1026                         { $$ = 1; }
1027         ;
1028
1029 memspec_opt:
1030                 '>' NAME
1031                 { $$ = $2; }
1032         |       { $$ = DEFAULT_MEMORY_REGION; }
1033         ;
1034
1035 phdr_opt:
1036                 /* empty */
1037                 {
1038                   $$ = NULL;
1039                 }
1040         |       phdr_opt ':' NAME
1041                 {
1042                   struct lang_output_section_phdr_list *n;
1043
1044                   n = ((struct lang_output_section_phdr_list *)
1045                        xmalloc (sizeof *n));
1046                   n->name = $3;
1047                   n->used = FALSE;
1048                   n->next = $1;
1049                   $$ = n;
1050                 }
1051         ;
1052
1053 overlay_section:
1054                 /* empty */
1055         |       overlay_section
1056                 NAME
1057                         {
1058                           ldlex_script ();
1059                           lang_enter_overlay_section ($2);
1060                         }
1061                 '{' statement_list_opt '}'
1062                         { ldlex_popstate (); ldlex_expression (); }
1063                 phdr_opt fill_opt
1064                         {
1065                           ldlex_popstate ();
1066                           lang_leave_overlay_section ($9, $8);
1067                         }
1068                 opt_comma
1069         ;
1070
1071 phdrs:
1072                 PHDRS '{' phdr_list '}'
1073         ;
1074
1075 phdr_list:
1076                 /* empty */
1077         |       phdr_list phdr
1078         ;
1079
1080 phdr:
1081                 NAME { ldlex_expression (); }
1082                   phdr_type phdr_qualifiers { ldlex_popstate (); }
1083                   ';'
1084                 {
1085                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1086                                  $4.flags);
1087                 }
1088         ;
1089
1090 phdr_type:
1091                 exp
1092                 {
1093                   $$ = $1;
1094
1095                   if ($1->type.node_class == etree_name
1096                       && $1->type.node_code == NAME)
1097                     {
1098                       const char *s;
1099                       unsigned int i;
1100                       static const char * const phdr_types[] =
1101                         {
1102                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1103                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1104                           "PT_PHDR", "PT_TLS"
1105                         };
1106
1107                       s = $1->name.name;
1108                       for (i = 0;
1109                            i < sizeof phdr_types / sizeof phdr_types[0];
1110                            i++)
1111                         if (strcmp (s, phdr_types[i]) == 0)
1112                           {
1113                             $$ = exp_intop (i);
1114                             break;
1115                           }
1116                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1117                         {
1118                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1119                             $$ = exp_intop (0x6474e550);
1120                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1121                             $$ = exp_intop (0x6474e551);
1122                           else
1123                             {
1124                               einfo (_("\
1125 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1126                                      s);
1127                               $$ = exp_intop (0);
1128                             }
1129                         }
1130                     }
1131                 }
1132         ;
1133
1134 phdr_qualifiers:
1135                 /* empty */
1136                 {
1137                   memset (&$$, 0, sizeof (struct phdr_info));
1138                 }
1139         |       NAME phdr_val phdr_qualifiers
1140                 {
1141                   $$ = $3;
1142                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1143                     $$.filehdr = TRUE;
1144                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1145                     $$.phdrs = TRUE;
1146                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1147                     $$.flags = $2;
1148                   else
1149                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1150                 }
1151         |       AT '(' exp ')' phdr_qualifiers
1152                 {
1153                   $$ = $5;
1154                   $$.at = $3;
1155                 }
1156         ;
1157
1158 phdr_val:
1159                 /* empty */
1160                 {
1161                   $$ = NULL;
1162                 }
1163         | '(' exp ')'
1164                 {
1165                   $$ = $2;
1166                 }
1167         ;
1168
1169 dynamic_list_file:
1170                 {
1171                   ldlex_version_file ();
1172                   PUSH_ERROR (_("dynamic list"));
1173                 }
1174                 dynamic_list_nodes
1175                 {
1176                   ldlex_popstate ();
1177                   POP_ERROR ();
1178                 }
1179         ;
1180
1181 dynamic_list_nodes:
1182                 dynamic_list_node
1183         |       dynamic_list_nodes dynamic_list_node
1184         ;
1185
1186 dynamic_list_node:
1187                 '{' dynamic_list_tag '}' ';'
1188         ;
1189
1190 dynamic_list_tag:
1191                 vers_defns ';'
1192                 {
1193                   lang_append_dynamic_list ($1);
1194                 }
1195         ;
1196
1197 /* This syntax is used within an external version script file.  */
1198
1199 version_script_file:
1200                 {
1201                   ldlex_version_file ();
1202                   PUSH_ERROR (_("VERSION script"));
1203                 }
1204                 vers_nodes
1205                 {
1206                   ldlex_popstate ();
1207                   POP_ERROR ();
1208                 }
1209         ;
1210
1211 /* This is used within a normal linker script file.  */
1212
1213 version:
1214                 {
1215                   ldlex_version_script ();
1216                 }
1217                 VERSIONK '{' vers_nodes '}'
1218                 {
1219                   ldlex_popstate ();
1220                 }
1221         ;
1222
1223 vers_nodes:
1224                 vers_node
1225         |       vers_nodes vers_node
1226         ;
1227
1228 vers_node:
1229                 '{' vers_tag '}' ';'
1230                 {
1231                   lang_register_vers_node (NULL, $2, NULL);
1232                 }
1233         |       VERS_TAG '{' vers_tag '}' ';'
1234                 {
1235                   lang_register_vers_node ($1, $3, NULL);
1236                 }
1237         |       VERS_TAG '{' vers_tag '}' verdep ';'
1238                 {
1239                   lang_register_vers_node ($1, $3, $5);
1240                 }
1241         ;
1242
1243 verdep:
1244                 VERS_TAG
1245                 {
1246                   $$ = lang_add_vers_depend (NULL, $1);
1247                 }
1248         |       verdep VERS_TAG
1249                 {
1250                   $$ = lang_add_vers_depend ($1, $2);
1251                 }
1252         ;
1253
1254 vers_tag:
1255                 /* empty */
1256                 {
1257                   $$ = lang_new_vers_node (NULL, NULL);
1258                 }
1259         |       vers_defns ';'
1260                 {
1261                   $$ = lang_new_vers_node ($1, NULL);
1262                 }
1263         |       GLOBAL ':' vers_defns ';'
1264                 {
1265                   $$ = lang_new_vers_node ($3, NULL);
1266                 }
1267         |       LOCAL ':' vers_defns ';'
1268                 {
1269                   $$ = lang_new_vers_node (NULL, $3);
1270                 }
1271         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1272                 {
1273                   $$ = lang_new_vers_node ($3, $7);
1274                 }
1275         ;
1276
1277 vers_defns:
1278                 VERS_IDENTIFIER
1279                 {
1280                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1281                 }
1282         |       NAME
1283                 {
1284                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1285                 }
1286         |       vers_defns ';' VERS_IDENTIFIER
1287                 {
1288                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1289                 }
1290         |       vers_defns ';' NAME
1291                 {
1292                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1293                 }
1294         |       vers_defns ';' EXTERN NAME '{'
1295                         {
1296                           $<name>$ = ldgram_vers_current_lang;
1297                           ldgram_vers_current_lang = $4;
1298                         }
1299                 vers_defns opt_semicolon '}'
1300                         {
1301                           struct bfd_elf_version_expr *pat;
1302                           for (pat = $7; pat->next != NULL; pat = pat->next);
1303                           pat->next = $1;
1304                           $$ = $7;
1305                           ldgram_vers_current_lang = $<name>6;
1306                         }
1307         |       EXTERN NAME '{'
1308                         {
1309                           $<name>$ = ldgram_vers_current_lang;
1310                           ldgram_vers_current_lang = $2;
1311                         }
1312                 vers_defns opt_semicolon '}'
1313                         {
1314                           $$ = $5;
1315                           ldgram_vers_current_lang = $<name>4;
1316                         }
1317         |       GLOBAL
1318                 {
1319                   $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1320                 }
1321         |       vers_defns ';' GLOBAL
1322                 {
1323                   $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1324                 }
1325         |       LOCAL
1326                 {
1327                   $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1328                 }
1329         |       vers_defns ';' LOCAL
1330                 {
1331                   $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1332                 }
1333         |       EXTERN
1334                 {
1335                   $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1336                 }
1337         |       vers_defns ';' EXTERN
1338                 {
1339                   $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1340                 }
1341         ;
1342
1343 opt_semicolon:
1344                 /* empty */
1345         |       ';'
1346         ;
1347
1348 %%
1349 void
1350 yyerror(arg)
1351      const char *arg;
1352 {
1353   if (ldfile_assumed_script)
1354     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1355            ldfile_input_filename);
1356   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1357      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1358   else
1359      einfo ("%P%F:%S: %s\n", arg);
1360 }