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