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