gold/yyscript.y

   1 /* yyscript.y -- linker script grammar for gold.  */
   2
   3 /* Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor <iant@google.com>.
   5
   6    This file is part of gold.
   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 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 /* This is a bison grammar to parse a subset of the original GNU ld
  24    linker script language.  */
  25
  26 %{
  27
  28 #include "config.h"
  29
  30 #include <stddef.h>
  31 #include <stdint.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "script-c.h"
  36
  37 %}
  38
  39 /* We need to use a pure parser because we might be multi-threaded.
  40    We pass some arguments through the parser to the lexer.  */
  41
  42 %pure-parser
  43
  44 %parse-param {void* closure}
  45 %lex-param {void* closure}
  46
  47 /* Since we require bison anyhow, we take advantage of it.  */
  48
  49 %error-verbose
  50
  51 /* The values associated with tokens.  */
  52
  53 %union {
  54   /* A string.  */
  55   struct Parser_string string;
  56   /* A number.  */
  57   uint64_t integer;
  58   /* An expression.  */
  59   Expression_ptr expr;
  60   /* An output section header.  */
  61   struct Parser_output_section_header output_section_header;
  62   /* An output section trailer.  */
  63   struct Parser_output_section_trailer output_section_trailer;
  64   /* A section constraint.  */
  65   enum Section_constraint constraint;
  66   /* A complete input section specification.  */
  67   struct Input_section_spec input_section_spec;
  68   /* A list of wildcard specifications, with exclusions.  */
  69   struct Wildcard_sections wildcard_sections;
  70   /* A single wildcard specification.  */
  71   struct Wildcard_section wildcard_section;
  72   /* A list of strings.  */
  73   String_list_ptr string_list;
  74   /* Information for a program header.  */
  75   struct Phdr_info phdr_info;
  76   /* Used for version scripts and within VERSION {}.  */
  77   struct Version_dependency_list* deplist;
  78   struct Version_expression_list* versyms;
  79   struct Version_tree* versnode;
  80   enum Script_section_type section_type;
  81 }
  82
  83 /* Operators, including a precedence table for expressions.  */
  84
  85 %right PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ
  86 %right '?' ':'
  87 %left OROR
  88 %left ANDAND
  89 %left '|'
  90 %left '^'
  91 %left '&'
  92 %left EQ NE
  93 %left '<' '>' LE GE
  94 %left LSHIFT RSHIFT
  95 %left '+' '-'
  96 %left '*' '/' '%'
  97
  98 /* A fake operator used to indicate unary operator precedence.  */
  99 %right UNARY
 100
 101 /* Constants.  */
 102
 103 %token <string> STRING
 104 %token <string> QUOTED_STRING
 105 %token <integer> INTEGER
 106
 107 /* Keywords.  This list is taken from ldgram.y and ldlex.l in the old
 108    GNU linker, with the keywords which only appear in MRI mode
 109    removed.  Not all these keywords are actually used in this grammar.
 110    In most cases the keyword is recognized as the token name in upper
 111    case.  The comments indicate where this is not the case.  */
 112
 113 %token ABSOLUTE
 114 %token ADDR
 115 %token ALIGN_K          /* ALIGN */
 116 %token ALIGNOF
 117 %token ASSERT_K         /* ASSERT */
 118 %token AS_NEEDED
 119 %token AT
 120 %token BIND
 121 %token BLOCK
 122 %token BYTE
 123 %token CONSTANT
 124 %token CONSTRUCTORS
 125 %token COPY
 126 %token CREATE_OBJECT_SYMBOLS
 127 %token DATA_SEGMENT_ALIGN
 128 %token DATA_SEGMENT_END
 129 %token DATA_SEGMENT_RELRO_END
 130 %token DEFINED
 131 %token DSECT
 132 %token ENTRY
 133 %token EXCLUDE_FILE
 134 %token EXTERN
 135 %token FILL
 136 %token FLOAT
 137 %token FORCE_COMMON_ALLOCATION
 138 %token GLOBAL           /* global */
 139 %token GROUP
 140 %token HLL
 141 %token INCLUDE
 142 %token INHIBIT_COMMON_ALLOCATION
 143 %token INFO
 144 %token INPUT
 145 %token KEEP
 146 %token LENGTH           /* LENGTH, l, len */
 147 %token LOADADDR
 148 %token LOCAL            /* local */
 149 %token LONG
 150 %token MAP
 151 %token MAX_K            /* MAX */
 152 %token MEMORY
 153 %token MIN_K            /* MIN */
 154 %token NEXT
 155 %token NOCROSSREFS
 156 %token NOFLOAT
 157 %token NOLOAD
 158 %token ONLY_IF_RO
 159 %token ONLY_IF_RW
 160 %token ORIGIN           /* ORIGIN, o, org */
 161 %token OUTPUT
 162 %token OUTPUT_ARCH
 163 %token OUTPUT_FORMAT
 164 %token OVERLAY
 165 %token PHDRS
 166 %token PROVIDE
 167 %token PROVIDE_HIDDEN
 168 %token QUAD
 169 %token SEARCH_DIR
 170 %token SECTIONS
 171 %token SEGMENT_START
 172 %token SHORT
 173 %token SIZEOF
 174 %token SIZEOF_HEADERS   /* SIZEOF_HEADERS, sizeof_headers */
 175 %token SORT_BY_ALIGNMENT
 176 %token SORT_BY_NAME
 177 %token SPECIAL
 178 %token SQUAD
 179 %token STARTUP
 180 %token SUBALIGN
 181 %token SYSLIB
 182 %token TARGET_K         /* TARGET */
 183 %token TRUNCATE
 184 %token VERSIONK         /* VERSION */
 185
 186 /* Keywords, part 2.  These are keywords that are unique to gold,
 187    and not present in the old GNU linker.  As before, unless the
 188    comments say otherwise, the keyword is recognized as the token
 189    name in upper case. */
 190
 191 %token OPTION
 192
 193 /* Special tokens used to tell the grammar what type of tokens we are
 194    parsing.  The token stream always begins with one of these tokens.
 195    We do this because version scripts can appear embedded within
 196    linker scripts, and because --defsym uses the expression
 197    parser.  */
 198 %token PARSING_LINKER_SCRIPT
 199 %token PARSING_VERSION_SCRIPT
 200 %token PARSING_DEFSYM
 201 %token PARSING_DYNAMIC_LIST
 202
 203 /* Non-terminal types, where needed.  */
 204
 205 %type <expr> parse_exp exp
 206 %type <expr> opt_at opt_align opt_subalign opt_fill
 207 %type <output_section_header> section_header opt_address_and_section_type
 208 %type <section_type> section_type
 209 %type <output_section_trailer> section_trailer
 210 %type <constraint> opt_constraint
 211 %type <string_list> opt_phdr
 212 %type <integer> data_length
 213 %type <input_section_spec> input_section_no_keep
 214 %type <wildcard_sections> wildcard_sections
 215 %type <wildcard_section> wildcard_file wildcard_section
 216 %type <string_list> exclude_names
 217 %type <string> wildcard_name
 218 %type <integer> phdr_type
 219 %type <phdr_info> phdr_info
 220 %type <versyms> vers_defns
 221 %type <versnode> vers_tag
 222 %type <deplist> verdep
 223 %type <string> string
 224
 225 %%
 226
 227 /* Read the special token to see what to read next.  */
 228 top:
 229           PARSING_LINKER_SCRIPT linker_script
 230         | PARSING_VERSION_SCRIPT version_script
 231         | PARSING_DEFSYM defsym_expr
 232         | PARSING_DYNAMIC_LIST dynamic_list_expr
 233         ;
 234
 235 /* A file contains a list of commands.  */
 236 linker_script:
 237           linker_script file_cmd
 238         | /* empty */
 239         ;
 240
 241 /* A command which may appear at top level of a linker script.  */
 242 file_cmd:
 243           EXTERN '(' extern_name_list ')'
 244         | FORCE_COMMON_ALLOCATION
 245             { script_set_common_allocation(closure, 1); }
 246         | GROUP
 247             { script_start_group(closure); }
 248           '(' input_list ')'
 249             { script_end_group(closure); }
 250         | INHIBIT_COMMON_ALLOCATION
 251             { script_set_common_allocation(closure, 0); }
 252         | INPUT '(' input_list ')'
 253         | OPTION '(' string ')'
 254             { script_parse_option(closure, $3.value, $3.length); }
 255         | OUTPUT_FORMAT '(' string ')'
 256             {
 257               if (!script_check_output_format(closure, $3.value, $3.length,
 258                                               NULL, 0, NULL, 0))
 259                 YYABORT;
 260             }
 261         | OUTPUT_FORMAT '(' string ',' string ',' string ')'
 262             {
 263               if (!script_check_output_format(closure, $3.value, $3.length,
 264                                               $5.value, $5.length,
 265                                               $7.value, $7.length))
 266                 YYABORT;
 267             }
 268         | PHDRS '{' phdrs_defs '}'
 269         | SEARCH_DIR '(' string ')'
 270             { script_add_search_dir(closure, $3.value, $3.length); }
 271         | SECTIONS '{'
 272             { script_start_sections(closure); }
 273           sections_block '}'
 274             { script_finish_sections(closure); }
 275         | TARGET_K '(' string ')'
 276             { script_set_target(closure, $3.value, $3.length); }
 277         | VERSIONK '{'
 278             { script_push_lex_into_version_mode(closure); }
 279           version_script '}'
 280             { script_pop_lex_mode(closure); }
 281         | file_or_sections_cmd
 282         | ignore_cmd
 283         | ';'
 284         ;
 285
 286 /* Top level commands which we ignore.  The GNU linker uses these to
 287    select the output format, but we don't offer a choice.  Ignoring
 288    these is more-or-less OK since most scripts simply explicitly
 289    choose the default.  */
 290 ignore_cmd:
 291           OUTPUT_ARCH '(' string ')'
 292         ;
 293
 294 /* A list of external undefined symbols.  We put the lexer into
 295    expression mode so that commas separate names; this is what the GNU
 296    linker does.  */
 297
 298 extern_name_list:
 299             { script_push_lex_into_expression_mode(closure); }
 300           extern_name_list_body
 301             { script_pop_lex_mode(closure); }
 302         ;
 303
 304 extern_name_list_body:
 305           string
 306             { script_add_extern(closure, $1.value, $1.length); }
 307         | extern_name_list_body string
 308             { script_add_extern(closure, $2.value, $2.length); }
 309         | extern_name_list_body ',' string
 310             { script_add_extern(closure, $3.value, $3.length); }
 311         ;
 312
 313 /* A list of input file names.  */
 314 input_list:
 315           input_list_element
 316         | input_list opt_comma input_list_element
 317         ;
 318
 319 /* An input file name.  */
 320 input_list_element:
 321           string
 322             { script_add_file(closure, $1.value, $1.length); }
 323         | AS_NEEDED
 324             { script_start_as_needed(closure); }
 325           '(' input_list ')'
 326             { script_end_as_needed(closure); }
 327         ;
 328
 329 /* Commands in a SECTIONS block.  */
 330 sections_block:
 331           sections_block section_block_cmd
 332         | /* empty */
 333         ;
 334
 335 /* A command which may appear within a SECTIONS block.  */
 336 section_block_cmd:
 337           file_or_sections_cmd
 338         | string section_header
 339             { script_start_output_section(closure, $1.value, $1.length, &$2); }
 340           '{' section_cmds '}' section_trailer
 341             { script_finish_output_section(closure, &$7); }
 342         ;
 343
 344 /* The header of an output section in a SECTIONS block--everything
 345    after the name.  */
 346 section_header:
 347             { script_push_lex_into_expression_mode(closure); }
 348           opt_address_and_section_type opt_at opt_align opt_subalign
 349             { script_pop_lex_mode(closure); }
 350           opt_constraint
 351             {
 352               $$.address = $2.address;
 353               $$.section_type = $2.section_type;
 354               $$.load_address = $3;
 355               $$.align = $4;
 356               $$.subalign = $5;
 357               $$.constraint = $7;
 358             }
 359         ;
 360
 361 /* The optional address followed by the optional section type.  This
 362    is a separate nonterminal to avoid a shift/reduce conflict on
 363    '(' in section_header.  */
 364
 365 opt_address_and_section_type:
 366         ':'
 367             {
 368               $$.address = NULL;
 369               $$.section_type = SCRIPT_SECTION_TYPE_NONE;
 370             }
 371         | '(' ')' ':'
 372             {
 373               $$.address = NULL;
 374               $$.section_type = SCRIPT_SECTION_TYPE_NONE;
 375             }
 376         | exp ':'
 377             {
 378               $$.address = $1;
 379               $$.section_type = SCRIPT_SECTION_TYPE_NONE;
 380             }
 381         | exp '(' ')' ':'
 382             {
 383               $$.address = $1;
 384               $$.section_type = SCRIPT_SECTION_TYPE_NONE;
 385             }
 386         | '(' section_type ')' ':'
 387             {
 388               $$.address = NULL;
 389               $$.section_type = $2;
 390             }
 391         | exp '(' section_type ')' ':'
 392             {
 393               $$.address = $1;
 394               $$.section_type = $3;
 395             }
 396         ;
 397
 398 /* We only support NOLOAD.  */
 399 section_type:
 400         NOLOAD
 401             { $$ = SCRIPT_SECTION_TYPE_NOLOAD; }
 402         | DSECT
 403             {
 404               yyerror(closure, "DSECT section type is unsupported");
 405               $$ = SCRIPT_SECTION_TYPE_DSECT;
 406             }
 407         | COPY
 408             {
 409               yyerror(closure, "COPY section type is unsupported");
 410               $$ = SCRIPT_SECTION_TYPE_COPY;
 411             }
 412         | INFO
 413             {
 414               yyerror(closure, "INFO section type is unsupported");
 415               $$ = SCRIPT_SECTION_TYPE_INFO;
 416             }
 417         | OVERLAY
 418             {
 419               yyerror(closure, "OVERLAY section type is unsupported");
 420               $$ = SCRIPT_SECTION_TYPE_OVERLAY;
 421             }
 422         ;
 423
 424 /* The address at which an output section should be loaded.  */
 425 opt_at:
 426           /* empty */
 427             { $$ = NULL; }
 428         | AT '(' exp ')'
 429             { $$ = $3; }
 430         ;
 431
 432 /* The alignment of an output section.  */
 433 opt_align:
 434           /* empty */
 435             { $$ = NULL; }
 436         | ALIGN_K '(' exp ')'
 437             { $$ = $3; }
 438         ;
 439
 440 /* The input section alignment within an output section.  */
 441 opt_subalign:
 442           /* empty */
 443             { $$ = NULL; }
 444         | SUBALIGN '(' exp ')'
 445             { $$ = $3; }
 446         ;
 447
 448 /* A section constraint.  */
 449 opt_constraint:
 450           /* empty */
 451             { $$ = CONSTRAINT_NONE; }
 452         | ONLY_IF_RO
 453             { $$ = CONSTRAINT_ONLY_IF_RO; }
 454         | ONLY_IF_RW
 455             { $$ = CONSTRAINT_ONLY_IF_RW; }
 456         | SPECIAL
 457             { $$ = CONSTRAINT_SPECIAL; }
 458         ;
 459
 460 /* The trailer of an output section in a SECTIONS block.  */
 461 section_trailer:
 462           opt_memspec opt_at_memspec opt_phdr opt_fill opt_comma
 463             {
 464               $$.fill = $4;
 465               $$.phdrs = $3;
 466             }
 467         ;
 468
 469 /* A memory specification for an output section.  */
 470 opt_memspec:
 471           '>' string
 472             { yyerror(closure, "memory regions are not supported"); }
 473         | /* empty */
 474         ;
 475
 476 /* A memory specification for where to load an output section.  */
 477 opt_at_memspec:
 478           AT '>' string
 479             { yyerror(closure, "memory regions are not supported"); }
 480         | /* empty */
 481         ;
 482
 483 /* The program segment an output section should go into.  */
 484 opt_phdr:
 485           opt_phdr ':' string
 486             { $$ = script_string_list_push_back($1, $3.value, $3.length); }
 487         | /* empty */
 488             { $$ = NULL; }
 489         ;
 490
 491 /* The value to use to fill an output section.  FIXME: This does not
 492    handle a string of arbitrary length.  */
 493 opt_fill:
 494           '=' parse_exp
 495             { $$ = $2; }
 496         | /* empty */
 497             { $$ = NULL; }
 498         ;
 499
 500 /* Commands which may appear within the description of an output
 501    section in a SECTIONS block.  */
 502 section_cmds:
 503           /* empty */
 504         | section_cmds section_cmd
 505         ;
 506
 507 /* A command which may appear within the description of an output
 508    section in a SECTIONS block.  */
 509 section_cmd:
 510           assignment end
 511         | input_section_spec
 512         | data_length '(' parse_exp ')'
 513             { script_add_data(closure, $1, $3); }
 514         | ASSERT_K '(' parse_exp ',' string ')'
 515             { script_add_assertion(closure, $3, $5.value, $5.length); }
 516         | FILL '(' parse_exp ')'
 517             { script_add_fill(closure, $3); }
 518         | CONSTRUCTORS
 519             {
 520               /* The GNU linker uses CONSTRUCTORS for the a.out object
 521                  file format.  It does nothing when using ELF.  Since
 522                  some ELF linker scripts use it although it does
 523                  nothing, we accept it and ignore it.  */
 524             }
 525         | SORT_BY_NAME '(' CONSTRUCTORS ')'
 526         | ';'
 527         ;
 528
 529 /* The length of data which may appear within the description of an
 530    output section in a SECTIONS block.  */
 531 data_length:
 532           QUAD
 533             { $$ = QUAD; }
 534         | SQUAD
 535             { $$ = SQUAD; }
 536         | LONG
 537             { $$ = LONG; }
 538         | SHORT
 539             { $$ = SHORT; }
 540         | BYTE
 541             { $$ = BYTE; }
 542         ;
 543
 544 /* An input section specification.  This may appear within the
 545    description of an output section in a SECTIONS block.  */
 546 input_section_spec:
 547           input_section_no_keep
 548             { script_add_input_section(closure, &$1, 0); }
 549         | KEEP '(' input_section_no_keep ')'
 550             { script_add_input_section(closure, &$3, 1); }
 551         ;
 552
 553 /* An input section specification within a KEEP clause.  */
 554 input_section_no_keep:
 555           string
 556             {
 557               $$.file.name = $1;
 558               $$.file.sort = SORT_WILDCARD_NONE;
 559               $$.input_sections.sections = NULL;
 560               $$.input_sections.exclude = NULL;
 561             }
 562         | wildcard_file '(' wildcard_sections ')'
 563             {
 564               $$.file = $1;
 565               $$.input_sections = $3;
 566             }
 567         ;
 568
 569 /* A wildcard file specification.  */
 570 wildcard_file:
 571           wildcard_name
 572             {
 573               $$.name = $1;
 574               $$.sort = SORT_WILDCARD_NONE;
 575             }
 576         | SORT_BY_NAME '(' wildcard_name ')'
 577             {
 578               $$.name = $3;
 579               $$.sort = SORT_WILDCARD_BY_NAME;
 580             }
 581         ;
 582
 583 /* A list of wild card section specifications.  */
 584 wildcard_sections:
 585           wildcard_sections opt_comma wildcard_section
 586             {
 587               $$.sections = script_string_sort_list_add($1.sections, &$3);
 588               $$.exclude = $1.exclude;
 589             }
 590         | wildcard_section
 591             {
 592               $$.sections = script_new_string_sort_list(&$1);
 593               $$.exclude = NULL;
 594             }
 595         | wildcard_sections opt_comma EXCLUDE_FILE '(' exclude_names ')'
 596             {
 597               $$.sections = $1.sections;
 598               $$.exclude = script_string_list_append($1.exclude, $5);
 599             }
 600         | EXCLUDE_FILE '(' exclude_names ')'
 601             {
 602               $$.sections = NULL;
 603               $$.exclude = $3;
 604             }
 605         ;
 606
 607 /* A single wild card specification.  */
 608 wildcard_section:
 609           wildcard_name
 610             {
 611               $$.name = $1;
 612               $$.sort = SORT_WILDCARD_NONE;
 613             }
 614         | SORT_BY_NAME '(' wildcard_section ')'
 615             {
 616               $$.name = $3.name;
 617               switch ($3.sort)
 618                 {
 619                 case SORT_WILDCARD_NONE:
 620                   $$.sort = SORT_WILDCARD_BY_NAME;
 621                   break;
 622                 case SORT_WILDCARD_BY_NAME:
 623                 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
 624                   break;
 625                 case SORT_WILDCARD_BY_ALIGNMENT:
 626                 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
 627                   $$.sort = SORT_WILDCARD_BY_NAME_BY_ALIGNMENT;
 628                   break;
 629                 default:
 630                   abort();
 631                 }
 632             }
 633         | SORT_BY_ALIGNMENT '(' wildcard_section ')'
 634             {
 635               $$.name = $3.name;
 636               switch ($3.sort)
 637                 {
 638                 case SORT_WILDCARD_NONE:
 639                   $$.sort = SORT_WILDCARD_BY_ALIGNMENT;
 640                   break;
 641                 case SORT_WILDCARD_BY_ALIGNMENT:
 642                 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
 643                   break;
 644                 case SORT_WILDCARD_BY_NAME:
 645                 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
 646                   $$.sort = SORT_WILDCARD_BY_ALIGNMENT_BY_NAME;
 647                   break;
 648                 default:
 649                   abort();
 650                 }
 651             }
 652         ;
 653
 654 /* A list of file names to exclude.  */
 655 exclude_names:
 656           exclude_names opt_comma wildcard_name
 657             { $$ = script_string_list_push_back($1, $3.value, $3.length); }
 658         | wildcard_name
 659             { $$ = script_new_string_list($1.value, $1.length); }
 660         ;
 661
 662 /* A single wildcard name.  We recognize '*' and '?' specially since
 663    they are expression tokens.  */
 664 wildcard_name:
 665           string
 666             { $$ = $1; }
 667         | '*'
 668             {
 669               $$.value = "*";
 670               $$.length = 1;
 671             }
 672         | '?'
 673             {
 674               $$.value = "?";
 675               $$.length = 1;
 676             }
 677         ;
 678
 679 /* A command which may appear at the top level of a linker script, or
 680    within a SECTIONS block.  */
 681 file_or_sections_cmd:
 682           ENTRY '(' string ')'
 683             { script_set_entry(closure, $3.value, $3.length); }
 684         | assignment end
 685         | ASSERT_K '(' parse_exp ',' string ')'
 686             { script_add_assertion(closure, $3, $5.value, $5.length); }
 687         ;
 688
 689 /* A list of program header definitions.  */
 690 phdrs_defs:
 691           phdrs_defs phdr_def
 692         | /* empty */
 693         ;
 694
 695 /* A program header definition.  */
 696 phdr_def:
 697           string phdr_type phdr_info ';'
 698             { script_add_phdr(closure, $1.value, $1.length, $2, &$3); }
 699         ;
 700
 701 /* A program header type.  The GNU linker accepts a general expression
 702    here, but that would be a pain because we would have to dig into
 703    the expression structure.  It's unlikely that anybody uses anything
 704    other than a string or a number here, so that is all we expect.  */
 705 phdr_type:
 706           string
 707             { $$ = script_phdr_string_to_type(closure, $1.value, $1.length); }
 708         | INTEGER
 709             { $$ = $1; }
 710         ;
 711
 712 /* Additional information for a program header.  */
 713 phdr_info:
 714           /* empty */
 715             { memset(&$$, 0, sizeof(struct Phdr_info)); }
 716         | string phdr_info
 717             {
 718               $$ = $2;
 719               if ($1.length == 7 && strncmp($1.value, "FILEHDR", 7) == 0)
 720                 $$.includes_filehdr = 1;
 721               else
 722                 yyerror(closure, "PHDRS syntax error");
 723             }
 724         | PHDRS phdr_info
 725             {
 726               $$ = $2;
 727               $$.includes_phdrs = 1;
 728             }
 729         | string '(' INTEGER ')' phdr_info
 730             {
 731               $$ = $5;
 732               if ($1.length == 5 && strncmp($1.value, "FLAGS", 5) == 0)
 733                 {
 734                   $$.is_flags_valid = 1;
 735                   $$.flags = $3;
 736                 }
 737               else
 738                 yyerror(closure, "PHDRS syntax error");
 739             }
 740         | AT '(' parse_exp ')' phdr_info
 741             {
 742               $$ = $5;
 743               $$.load_address = $3;
 744             }
 745         ;
 746
 747 /* Set a symbol to a value.  */
 748 assignment:
 749           string '=' parse_exp
 750             { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
 751         | string PLUSEQ parse_exp
 752             {
 753               Expression_ptr s = script_exp_string($1.value, $1.length);
 754               Expression_ptr e = script_exp_binary_add(s, $3);
 755               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 756             }
 757         | string MINUSEQ parse_exp
 758             {
 759               Expression_ptr s = script_exp_string($1.value, $1.length);
 760               Expression_ptr e = script_exp_binary_sub(s, $3);
 761               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 762             }
 763         | string MULTEQ parse_exp
 764             {
 765               Expression_ptr s = script_exp_string($1.value, $1.length);
 766               Expression_ptr e = script_exp_binary_mult(s, $3);
 767               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 768             }
 769         | string DIVEQ parse_exp
 770             {
 771               Expression_ptr s = script_exp_string($1.value, $1.length);
 772               Expression_ptr e = script_exp_binary_div(s, $3);
 773               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 774             }
 775         | string LSHIFTEQ parse_exp
 776             {
 777               Expression_ptr s = script_exp_string($1.value, $1.length);
 778               Expression_ptr e = script_exp_binary_lshift(s, $3);
 779               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 780             }
 781         | string RSHIFTEQ parse_exp
 782             {
 783               Expression_ptr s = script_exp_string($1.value, $1.length);
 784               Expression_ptr e = script_exp_binary_rshift(s, $3);
 785               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 786             }
 787         | string ANDEQ parse_exp
 788             {
 789               Expression_ptr s = script_exp_string($1.value, $1.length);
 790               Expression_ptr e = script_exp_binary_bitwise_and(s, $3);
 791               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 792             }
 793         | string OREQ parse_exp
 794             {
 795               Expression_ptr s = script_exp_string($1.value, $1.length);
 796               Expression_ptr e = script_exp_binary_bitwise_or(s, $3);
 797               script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
 798             }
 799         | PROVIDE '(' string '=' parse_exp ')'
 800             { script_set_symbol(closure, $3.value, $3.length, $5, 1, 0); }
 801         | PROVIDE_HIDDEN '(' string '=' parse_exp ')'
 802             { script_set_symbol(closure, $3.value, $3.length, $5, 1, 1); }
 803         ;
 804
 805 /* Parse an expression, putting the lexer into the right mode.  */
 806 parse_exp:
 807             { script_push_lex_into_expression_mode(closure); }
 808           exp
 809             {
 810               script_pop_lex_mode(closure);
 811               $$ = $2;
 812             }
 813         ;
 814
 815 /* An expression.  */
 816 exp:
 817           '(' exp ')'
 818             { $$ = $2; }
 819         | '-' exp %prec UNARY
 820             { $$ = script_exp_unary_minus($2); }
 821         | '!' exp %prec UNARY
 822             { $$ = script_exp_unary_logical_not($2); }
 823         | '~' exp %prec UNARY
 824             { $$ = script_exp_unary_bitwise_not($2); }
 825         | '+' exp %prec UNARY
 826             { $$ = $2; }
 827         | exp '*' exp
 828             { $$ = script_exp_binary_mult($1, $3); }
 829         | exp '/' exp
 830             { $$ = script_exp_binary_div($1, $3); }
 831         | exp '%' exp
 832             { $$ = script_exp_binary_mod($1, $3); }
 833         | exp '+' exp
 834             { $$ = script_exp_binary_add($1, $3); }
 835         | exp '-' exp
 836             { $$ = script_exp_binary_sub($1, $3); }
 837         | exp LSHIFT exp
 838             { $$ = script_exp_binary_lshift($1, $3); }
 839         | exp RSHIFT exp
 840             { $$ = script_exp_binary_rshift($1, $3); }
 841         | exp EQ exp
 842             { $$ = script_exp_binary_eq($1, $3); }
 843         | exp NE exp
 844             { $$ = script_exp_binary_ne($1, $3); }
 845         | exp LE exp
 846             { $$ = script_exp_binary_le($1, $3); }
 847         | exp GE exp
 848             { $$ = script_exp_binary_ge($1, $3); }
 849         | exp '<' exp
 850             { $$ = script_exp_binary_lt($1, $3); }
 851         | exp '>' exp
 852             { $$ = script_exp_binary_gt($1, $3); }
 853         | exp '&' exp
 854             { $$ = script_exp_binary_bitwise_and($1, $3); }
 855         | exp '^' exp
 856             { $$ = script_exp_binary_bitwise_xor($1, $3); }
 857         | exp '|' exp
 858             { $$ = script_exp_binary_bitwise_or($1, $3); }
 859         | exp ANDAND exp
 860             { $$ = script_exp_binary_logical_and($1, $3); }
 861         | exp OROR exp
 862             { $$ = script_exp_binary_logical_or($1, $3); }
 863         | exp '?' exp ':' exp
 864             { $$ = script_exp_trinary_cond($1, $3, $5); }
 865         | INTEGER
 866             { $$ = script_exp_integer($1); }
 867         | string
 868             { $$ = script_exp_string($1.value, $1.length); }
 869         | MAX_K '(' exp ',' exp ')'
 870             { $$ = script_exp_function_max($3, $5); }
 871         | MIN_K '(' exp ',' exp ')'
 872             { $$ = script_exp_function_min($3, $5); }
 873         | DEFINED '(' string ')'
 874             { $$ = script_exp_function_defined($3.value, $3.length); }
 875         | SIZEOF_HEADERS
 876             { $$ = script_exp_function_sizeof_headers(); }
 877         | ALIGNOF '(' string ')'
 878             { $$ = script_exp_function_alignof($3.value, $3.length); }
 879         | SIZEOF '(' string ')'
 880             { $$ = script_exp_function_sizeof($3.value, $3.length); }
 881         | ADDR '(' string ')'
 882             { $$ = script_exp_function_addr($3.value, $3.length); }
 883         | LOADADDR '(' string ')'
 884             { $$ = script_exp_function_loadaddr($3.value, $3.length); }
 885         | ORIGIN '(' string ')'
 886             { $$ = script_exp_function_origin($3.value, $3.length); }
 887         | LENGTH '(' string ')'
 888             { $$ = script_exp_function_length($3.value, $3.length); }
 889         | CONSTANT '(' string ')'
 890             { $$ = script_exp_function_constant($3.value, $3.length); }
 891         | ABSOLUTE '(' exp ')'
 892             { $$ = script_exp_function_absolute($3); }
 893         | ALIGN_K '(' exp ')'
 894             { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
 895         | ALIGN_K '(' exp ',' exp ')'
 896             { $$ = script_exp_function_align($3, $5); }
 897         | BLOCK '(' exp ')'
 898             { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
 899         | DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
 900             {
 901               script_data_segment_align(closure);
 902               $$ = script_exp_function_data_segment_align($3, $5);
 903             }
 904         | DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
 905             {
 906               script_data_segment_relro_end(closure);
 907               $$ = script_exp_function_data_segment_relro_end($3, $5);
 908             }
 909         | DATA_SEGMENT_END '(' exp ')'
 910             { $$ = script_exp_function_data_segment_end($3); }
 911         | SEGMENT_START '(' string ',' exp ')'
 912             {
 913               $$ = script_exp_function_segment_start($3.value, $3.length, $5);
 914               /* We need to take note of any SEGMENT_START expressions
 915                  because they change the behaviour of -Ttext, -Tdata and
 916                  -Tbss options.  */
 917               script_saw_segment_start_expression(closure);
 918             }
 919         | ASSERT_K '(' exp ',' string ')'
 920             { $$ = script_exp_function_assert($3, $5.value, $5.length); }
 921         ;
 922
 923 /* Handle the --defsym option.  */
 924 defsym_expr:
 925           string '=' parse_exp
 926             { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
 927         ;
 928
 929 /* Handle the --dynamic-list option.  A dynamic list has the format
 930    { sym1; sym2; extern "C++" { namespace::sym3 }; };
 931    We store the symbol we see in the "local" list; that is where
 932    Command_line::in_dynamic_list() will look to do its check.
 933    TODO(csilvers): More than one of these brace-lists can appear, and
 934    should just be merged and treated as a single list.  */
 935 dynamic_list_expr: dynamic_list_nodes ;
 936
 937 dynamic_list_nodes:
 938           dynamic_list_node
 939         | dynamic_list_nodes dynamic_list_node
 940         ;
 941
 942 dynamic_list_node:
 943           '{' vers_defns ';' '}' ';'
 944             { script_new_vers_node (closure, NULL, $2); }
 945         ;
 946
 947 /* A version script.  */
 948 version_script:
 949           vers_nodes
 950         ;
 951
 952 vers_nodes:
 953           vers_node
 954         | vers_nodes vers_node
 955         ;
 956
 957 vers_node:
 958           '{' vers_tag '}' ';'
 959             {
 960               script_register_vers_node (closure, NULL, 0, $2, NULL);
 961             }
 962         | string '{' vers_tag '}' ';'
 963             {
 964               script_register_vers_node (closure, $1.value, $1.length, $3,
 965                                          NULL);
 966             }
 967         | string '{' vers_tag '}' verdep ';'
 968             {
 969               script_register_vers_node (closure, $1.value, $1.length, $3, $5);
 970             }
 971         ;
 972
 973 verdep:
 974           string
 975             {
 976               $$ = script_add_vers_depend (closure, NULL, $1.value, $1.length);
 977             }
 978         | verdep string
 979             {
 980               $$ = script_add_vers_depend (closure, $1, $2.value, $2.length);
 981             }
 982         ;
 983
 984 vers_tag:
 985           /* empty */
 986             { $$ = script_new_vers_node (closure, NULL, NULL); }
 987         | vers_defns ';'
 988             { $$ = script_new_vers_node (closure, $1, NULL); }
 989         | GLOBAL ':' vers_defns ';'
 990             { $$ = script_new_vers_node (closure, $3, NULL); }
 991         | LOCAL ':' vers_defns ';'
 992             { $$ = script_new_vers_node (closure, NULL, $3); }
 993         | GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
 994             { $$ = script_new_vers_node (closure, $3, $7); }
 995         ;
 996
 997 /* Here is one of the rare places we care about the distinction
 998    between STRING and QUOTED_STRING.  For QUOTED_STRING, we do exact
 999    matching on the pattern, so we pass in true for the exact_match
1000    parameter.  For STRING, we do glob matching and pass in false.  */
1001 vers_defns:
1002           STRING
1003             {
1004               $$ = script_new_vers_pattern (closure, NULL, $1.value,
1005                                             $1.length, 0);
1006             }
1007         | QUOTED_STRING
1008             {
1009               $$ = script_new_vers_pattern (closure, NULL, $1.value,
1010                                             $1.length, 1);
1011             }
1012         | vers_defns ';' STRING
1013             {
1014               $$ = script_new_vers_pattern (closure, $1, $3.value,
1015                                             $3.length, 0);
1016             }
1017         | vers_defns ';' QUOTED_STRING
1018             {
1019               $$ = script_new_vers_pattern (closure, $1, $3.value,
1020                                             $3.length, 1);
1021             }
1022         | /* Push string on the language stack. */
1023           EXTERN string '{'
1024             { version_script_push_lang (closure, $2.value, $2.length); }
1025           vers_defns opt_semicolon '}'
1026             {
1027               $$ = $5;
1028               version_script_pop_lang(closure);
1029             }
1030         | /* Push string on the language stack.  This is more complicated
1031              than the other cases because we need to merge the linked-list
1032              state from the pre-EXTERN defns and the post-EXTERN defns.  */
1033           vers_defns ';' EXTERN string '{'
1034             { version_script_push_lang (closure, $4.value, $4.length); }
1035           vers_defns opt_semicolon '}'
1036             {
1037               $$ = script_merge_expressions ($1, $7);
1038               version_script_pop_lang(closure);
1039             }
1040         | EXTERN  // "extern" as a symbol name
1041             {
1042               $$ = script_new_vers_pattern (closure, NULL, "extern",
1043                                             sizeof("extern") - 1, 1);
1044             }
1045         | vers_defns ';' EXTERN
1046             {
1047               $$ = script_new_vers_pattern (closure, $1, "extern",
1048                                             sizeof("extern") - 1, 1);
1049             }
1050         ;
1051
1052 /* A string can be either a STRING or a QUOTED_STRING.  Almost all the
1053    time we don't care, and we use this rule.  */
1054 string:
1055           STRING
1056             { $$ = $1; }
1057         | QUOTED_STRING
1058             { $$ = $1; }
1059         ;
1060
1061 /* Some statements require a terminator, which may be a semicolon or a
1062    comma.  */
1063 end:
1064           ';'
1065         | ','
1066         ;
1067
1068 /* An optional semicolon.  */
1069 opt_semicolon:
1070           ';'
1071         |  /* empty */
1072         ;
1073
1074 /* An optional comma.  */
1075 opt_comma:
1076           ','
1077         | /* empty */
1078         ;
1079
1080 %%