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