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