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