[deliverable/binutils-gdb.git] / gold / yyscript.y

/* yyscript.y -- linker script grammer for gold.  */

/* Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
   Written by Ian Lance Taylor <iant@google.com>.

   This file is part of gold.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

/* This is a bison grammar to parse a subset of the original GNU ld
   linker script language.  */

%{

#include "config.h"

#include <stddef.h>
#include <stdint.h>

#include "script-c.h"

%}

/* We need to use a pure parser because we might be multi-threaded.
   We pass some arguments through the parser to the lexer.  */

%pure-parser

%parse-param {void* closure}
%lex-param {void* closure}

/* Since we require bison anyhow, we take advantage of it.  */

%error-verbose

/* The values associated with tokens.  */

%union {
  /* A string.  */
  struct Parser_string string;
  /* A number.  */
  uint64_t integer;
  /* An expression.  */
  Expression_ptr expr;
  // Used for version scripts and within VERSION {}
  struct Version_dependency_list* deplist;
  struct Version_expression_list* versyms;
  struct Version_tree* versnode;
}

/* Operators, including a precedence table for expressions.  */

%right PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ
%right '?' ':'
%left OROR
%left ANDAND
%left '|'
%left '^'
%left '&'
%left EQ NE
%left '<' '>' LE GE
%left LSHIFT RSHIFT
%left '+' '-'
%left '*' '/' '%'

/* A fake operator used to indicate unary operator precedence.  */
%right UNARY

/* Constants.  */

%token <string> STRING
%token <string> QUOTED_STRING
%token <integer> INTEGER

/* Keywords.  This list is taken from ldgram.y and ldlex.l in the old
   GNU linker, with the keywords which only appear in MRI mode
   removed.  Not all these keywords are actually used in this grammar.
   In most cases the keyword is recognized as the token name in upper
   case.  The comments indicate where this is not the case.  */

%token ABSOLUTE
%token ADDR
%token ALIGN_K		/* ALIGN */
%token ALIGNOF
%token ASSERT_K		/* ASSERT */
%token AS_NEEDED
%token AT
%token BIND
%token BLOCK
%token BYTE
%token CONSTANT
%token CONSTRUCTORS
%token COPY
%token CREATE_OBJECT_SYMBOLS
%token DATA_SEGMENT_ALIGN
%token DATA_SEGMENT_END
%token DATA_SEGMENT_RELRO_END
%token DEFINED
%token DSECT
%token ENTRY
%token EXCLUDE_FILE
%token EXTERN
%token FILL
%token FLOAT
%token FORCE_COMMON_ALLOCATION
%token GLOBAL		/* global */
%token GROUP
%token HLL
%token INCLUDE
%token INFO
%token INHIBIT_COMMON_ALLOCATION
%token INPUT
%token KEEP
%token LENGTH		/* LENGTH, l, len */
%token LOADADDR
%token LOCAL		/* local */
%token LONG
%token MAP
%token MAX_K		/* MAX */
%token MEMORY
%token MIN_K		/* MIN */
%token NEXT
%token NOCROSSREFS
%token NOFLOAT
%token NOLOAD
%token ONLY_IF_RO
%token ONLY_IF_RW
%token ORIGIN		/* ORIGIN, o, org */
%token OUTPUT
%token OUTPUT_ARCH
%token OUTPUT_FORMAT
%token OVERLAY
%token PHDRS
%token PROVIDE
%token PROVIDE_HIDDEN
%token QUAD
%token SEARCH_DIR
%token SECTIONS
%token SEGMENT_START
%token SHORT
%token SIZEOF
%token SIZEOF_HEADERS	/* SIZEOF_HEADERS, sizeof_headers */
%token SORT_BY_ALIGNMENT
%token SORT_BY_NAME
%token SPECIAL
%token SQUAD
%token STARTUP
%token SUBALIGN
%token SYSLIB
%token TARGET_K		/* TARGET */
%token TRUNCATE
%token VERSIONK		/* VERSION */

/* Keywords, part 2.  These are keywords that are unique to gold,
   and not present in the old GNU linker.  As before, unless the
   comments say otherwise, the keyword is recognized as the token
   name in upper case. */

%token OPTION

/* Special tokens used to tell the grammar what type of tokens we are
   parsing.  The token stream always begins with one of these tokens.
   We do this because version scripts can appear embedded within
   linker scripts, and because --defsym uses the expression
   parser.  */
%token PARSING_LINKER_SCRIPT
%token PARSING_VERSION_SCRIPT
%token PARSING_DEFSYM

/* Non-terminal types, where needed.  */

%type <expr> parse_exp exp
%type <versyms> vers_defns
%type <versnode> vers_tag
%type <deplist> verdep
%type <string> string

%%

/* Read the special token to see what to read next.  */
top:
	  PARSING_LINKER_SCRIPT linker_script
	| PARSING_VERSION_SCRIPT version_script
	| PARSING_DEFSYM defsym_expr
	;

/* A file contains a list of commands.  */
linker_script:
	  linker_script file_cmd
	| /* empty */
	;

/* A command which may appear at top level of a linker script.  */
file_cmd:
	  GROUP
	    { script_start_group(closure); }
	  '(' input_list ')'
	    { script_end_group(closure); }
        | OPTION '(' string ')'
	    { script_parse_option(closure, $3.value, $3.length); }
        | VERSIONK '{'
            { script_push_lex_into_version_mode(closure); }
          version_script '}'
            { script_pop_lex_mode(closure); }
	| file_or_sections_cmd
	| ignore_cmd
	;

/* Top level commands which we ignore.  The GNU linker uses these to
   select the output format, but we don't offer a choice.  Ignoring
   these is more-or-less OK since most scripts simply explicitly
   choose the default.  */
ignore_cmd:
	  OUTPUT_FORMAT '(' string ')'
	| OUTPUT_FORMAT '(' string ',' string ',' string ')'
	| OUTPUT_ARCH '(' string ')'
	;

/* A list of input file names.  */
input_list:
	  input_list_element
	| input_list opt_comma input_list_element
	;

/* An input file name.  */
input_list_element:
	  string
	    { script_add_file(closure, $1.value, $1.length); }
	| AS_NEEDED
	    { script_start_as_needed(closure); }
	  '(' input_list ')'
	    { script_end_as_needed(closure); }
	;

/* A command which may appear at the top level of a linker script, or
   within a SECTIONS block.  */
file_or_sections_cmd:
	  ENTRY '(' string ')'
	    { script_set_entry(closure, $3.value, $3.length); }
	| assignment end
	;

/* Set a symbol to a value.  */
assignment:
	  string '=' parse_exp
	    { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
	| string PLUSEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_add(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string MINUSEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_sub(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string MULTEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_mult(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string DIVEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_div(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string LSHIFTEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_lshift(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string RSHIFTEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_rshift(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string ANDEQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_bitwise_and(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| string OREQ parse_exp
	    {
	      Expression_ptr s = script_exp_string($1.value, $1.length);
	      Expression_ptr e = script_exp_binary_bitwise_or(s, $3);
	      script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	    }
	| PROVIDE '(' string '=' parse_exp ')'
	    { script_set_symbol(closure, $3.value, $3.length, $5, 1, 0); }
	| PROVIDE_HIDDEN '(' string '=' parse_exp ')'
	    { script_set_symbol(closure, $3.value, $3.length, $5, 1, 1); }
	;

/* Parse an expression, putting the lexer into the right mode.  */
parse_exp:
	    { script_push_lex_into_expression_mode(closure); }
	  exp
	    {
	      script_pop_lex_mode(closure);
	      $$ = $2;
	    }
	;

/* An expression.  */
exp:
	  '(' exp ')'
	    { $$ = $2; }
	| '-' exp %prec UNARY
	    { $$ = script_exp_unary_minus($2); }
	| '!' exp %prec UNARY
	    { $$ = script_exp_unary_logical_not($2); }
	| '~' exp %prec UNARY
	    { $$ = script_exp_unary_bitwise_not($2); }
	| '+' exp %prec UNARY
	    { $$ = $2; }
	| exp '*' exp
	    { $$ = script_exp_binary_mult($1, $3); }
	| exp '/' exp
	    { $$ = script_exp_binary_div($1, $3); }
	| exp '%' exp
	    { $$ = script_exp_binary_mod($1, $3); }
	| exp '+' exp
	    { $$ = script_exp_binary_add($1, $3); }
	| exp '-' exp
	    { $$ = script_exp_binary_sub($1, $3); }
	| exp LSHIFT exp
	    { $$ = script_exp_binary_lshift($1, $3); }
	| exp RSHIFT exp
	    { $$ = script_exp_binary_rshift($1, $3); }
	| exp EQ exp
	    { $$ = script_exp_binary_eq($1, $3); }
	| exp NE exp
	    { $$ = script_exp_binary_ne($1, $3); }
	| exp LE exp
	    { $$ = script_exp_binary_le($1, $3); }
	| exp GE exp
	    { $$ = script_exp_binary_ge($1, $3); }
	| exp '<' exp
	    { $$ = script_exp_binary_lt($1, $3); }
	| exp '>' exp
	    { $$ = script_exp_binary_gt($1, $3); }
	| exp '&' exp
	    { $$ = script_exp_binary_bitwise_and($1, $3); }
	| exp '^' exp
	    { $$ = script_exp_binary_bitwise_xor($1, $3); }
	| exp '|' exp
	    { $$ = script_exp_binary_bitwise_or($1, $3); }
	| exp ANDAND exp
	    { $$ = script_exp_binary_logical_and($1, $3); }
	| exp OROR exp
	    { $$ = script_exp_binary_logical_or($1, $3); }
	| exp '?' exp ':' exp
	    { $$ = script_exp_trinary_cond($1, $3, $5); }
	| INTEGER
	    { $$ = script_exp_integer($1); }
	| STRING
	    { $$ = script_exp_string($1.value, $1.length); }
	| QUOTED_STRING
	    { $$ = script_exp_string($1.value, $1.length); }
	| MAX_K '(' exp ',' exp ')'
	    { $$ = script_exp_function_max($3, $5); }
	| MIN_K '(' exp ',' exp ')'
	    { $$ = script_exp_function_min($3, $5); }
	| DEFINED '(' string ')'
	    { $$ = script_exp_function_defined($3.value, $3.length); }
	| SIZEOF_HEADERS
	    { $$ = script_exp_function_sizeof_headers(); }
	| ALIGNOF '(' string ')'
	    { $$ = script_exp_function_alignof($3.value, $3.length); }
	| SIZEOF '(' string ')'
	    { $$ = script_exp_function_sizeof($3.value, $3.length); }
	| ADDR '(' string ')'
	    { $$ = script_exp_function_addr($3.value, $3.length); }
	| LOADADDR '(' string ')'
	    { $$ = script_exp_function_loadaddr($3.value, $3.length); }
	| ORIGIN '(' string ')'
	    { $$ = script_exp_function_origin($3.value, $3.length); }
	| LENGTH '(' string ')'
	    { $$ = script_exp_function_length($3.value, $3.length); }
	| CONSTANT '(' string ')'
	    { $$ = script_exp_function_constant($3.value, $3.length); }
	| ABSOLUTE '(' exp ')'
	    { $$ = script_exp_function_absolute($3); }
	| ALIGN_K '(' exp ')'
	    { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
	| ALIGN_K '(' exp ',' exp ')'
	    { $$ = script_exp_function_align($3, $5); }
	| BLOCK '(' exp ')'
	    { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
	| DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
	    { $$ = script_exp_function_data_segment_align($3, $5); }
	| DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
	    { $$ = script_exp_function_data_segment_relro_end($3, $5); }
	| DATA_SEGMENT_END '(' exp ')'
	    { $$ = script_exp_function_data_segment_end($3); }
	| SEGMENT_START '(' string ',' exp ')'
	    {
	      $$ = script_exp_function_segment_start($3.value, $3.length, $5);
	    }
	| ASSERT_K '(' exp ',' string ')'
	    { $$ = script_exp_function_assert($3, $5.value, $5.length); }
	;

/* Handle the --defsym option.  */
defsym_expr:
	  string '=' parse_exp
	    { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
	;

/* A version script.  */
version_script:
	  vers_nodes
	;

vers_nodes:
	  vers_node
	| vers_nodes vers_node
	;

vers_node:
	  '{' vers_tag '}' ';'
	    {
	      script_register_vers_node (closure, NULL, 0, $2, NULL);
	    }
	| string '{' vers_tag '}' ';'
	    {
	      script_register_vers_node (closure, $1.value, $1.length, $3,
					 NULL);
	    }
	| string '{' vers_tag '}' verdep ';'
	    {
	      script_register_vers_node (closure, $1.value, $1.length, $3, $5);
	    }
	;

verdep:
	  string
	    {
	      $$ = script_add_vers_depend (closure, NULL, $1.value, $1.length);
	    }
	| verdep string
	    {
	      $$ = script_add_vers_depend (closure, $1, $2.value, $2.length);
	    }
	;

vers_tag:
	  /* empty */
	    { $$ = script_new_vers_node (closure, NULL, NULL); }
	| vers_defns ';'
	    { $$ = script_new_vers_node (closure, $1, NULL); }
	| GLOBAL ':' vers_defns ';'
	    { $$ = script_new_vers_node (closure, $3, NULL); }
	| LOCAL ':' vers_defns ';'
	    { $$ = script_new_vers_node (closure, NULL, $3); }
	| GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
	    { $$ = script_new_vers_node (closure, $3, $7); }
	;

/* Here is one of the rare places we care about the distinction
   between STRING and QUOTED_STRING.  For QUOTED_STRING, we do exact
   matching on the pattern, so we pass in true for the exact_match
   parameter.  For STRING, we do glob matching and pass in false.  */
vers_defns:
	  STRING
	    {
	      $$ = script_new_vers_pattern (closure, NULL, $1.value,
					    $1.length, 0);
	    }
	| QUOTED_STRING
	    {
	      $$ = script_new_vers_pattern (closure, NULL, $1.value,
					    $1.length, 1);
	    }
	| vers_defns ';' STRING
	    {
	      $$ = script_new_vers_pattern (closure, $1, $3.value,
                                            $3.length, 0);
	    }
	| vers_defns ';' QUOTED_STRING
	    {
	      $$ = script_new_vers_pattern (closure, $1, $3.value,
                                            $3.length, 1);
	    }
        | /* Push string on the language stack. */
          EXTERN string '{'
	    { version_script_push_lang (closure, $2.value, $2.length); }
	  vers_defns opt_semicolon '}'
	    {
	      $$ = $5;
	      version_script_pop_lang(closure);
	    }
        | /* Push string on the language stack.  This is more complicated
             than the other cases because we need to merge the linked-list
             state from the pre-EXTERN defns and the post-EXTERN defns.  */
          vers_defns ';' EXTERN string '{'
	    { version_script_push_lang (closure, $4.value, $4.length); }
	  vers_defns opt_semicolon '}'
	    {
	      $$ = script_merge_expressions ($1, $7);
	      version_script_pop_lang(closure);
	    }
        | EXTERN  // "extern" as a symbol name
	    {
	      $$ = script_new_vers_pattern (closure, NULL, "extern",
					    sizeof("extern") - 1, 1);
	    }
	| vers_defns ';' EXTERN
	    {
	      $$ = script_new_vers_pattern (closure, $1, "extern",
					    sizeof("extern") - 1, 1);
	    }
	;

/* A string can be either a STRING or a QUOTED_STRING.  Almost all the
   time we don't care, and we use this rule.  */
string:
          STRING
	    { $$ = $1; }
	| QUOTED_STRING
	    { $$ = $1; }
	;

/* Some statements require a terminator, which may be a semicolon or a
   comma.  */
end:
	  ';'
	| ','
	;

/* An optional semicolon.  */
opt_semicolon:
	  ';'
	|  /* empty */
	;

/* An optional comma.  */
opt_comma:
	  ','
	| /* empty */
	;

%%
Commit	Line	Data
dbe717ef ILT	1	/* yyscript.y -- linker script grammer for gold. */
dbe717ef ILT	2
e5756efb	3	/* Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
6cb15b7f ILT	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
dbe717ef ILT	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
	33	#include "script-c.h"
	34
	35	%}
	36
	37	/* We need to use a pure parser because we might be multi-threaded.
	38	We pass some arguments through the parser to the lexer. */
	39
	40	%pure-parser
	41
	42	%parse-param {void* closure}
	43	%lex-param {void* closure}
	44
	45	/* Since we require bison anyhow, we take advantage of it. */
	46
	47	%error-verbose
	48
	49	/* The values associated with tokens. */
	50
	51	%union {
e5756efb ILT	52	/* A string. */
	53	struct Parser_string string;
	54	/* A number. */
	55	uint64_t integer;
	56	/* An expression. */
	57	Expression_ptr expr;
09124467 ILT	58	// Used for version scripts and within VERSION {}
	59	struct Version_dependency_list* deplist;
	60	struct Version_expression_list* versyms;
	61	struct Version_tree* versnode;
dbe717ef ILT	62	}
	63
	64	/* Operators, including a precedence table for expressions. */
	65
	66	%right PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ
	67	%right '?' ':'
	68	%left OROR
	69	%left ANDAND
	70	%left '\|'
	71	%left '^'
	72	%left '&'
	73	%left EQ NE
	74	%left '<' '>' LE GE
	75	%left LSHIFT RSHIFT
	76	%left '+' '-'
	77	%left '*' '/' '%'
	78
e5756efb ILT	79	/* A fake operator used to indicate unary operator precedence. */
	80	%right UNARY
	81
dbe717ef ILT	82	/* Constants. */
	83
	84	%token <string> STRING
10600224	85	%token <string> QUOTED_STRING
dbe717ef ILT	86	%token <integer> INTEGER
	87
	88	/* Keywords. This list is taken from ldgram.y and ldlex.l in the old
	89	GNU linker, with the keywords which only appear in MRI mode
	90	removed. Not all these keywords are actually used in this grammar.
	91	In most cases the keyword is recognized as the token name in upper
	92	case. The comments indicate where this is not the case. */
	93
	94	%token ABSOLUTE
	95	%token ADDR
	96	%token ALIGN_K /* ALIGN */
e5756efb	97	%token ALIGNOF
dbe717ef ILT	98	%token ASSERT_K /* ASSERT */
	99	%token AS_NEEDED
	100	%token AT
	101	%token BIND
	102	%token BLOCK
	103	%token BYTE
	104	%token CONSTANT
	105	%token CONSTRUCTORS
	106	%token COPY
	107	%token CREATE_OBJECT_SYMBOLS
	108	%token DATA_SEGMENT_ALIGN
	109	%token DATA_SEGMENT_END
	110	%token DATA_SEGMENT_RELRO_END
	111	%token DEFINED
	112	%token DSECT
	113	%token ENTRY
	114	%token EXCLUDE_FILE
	115	%token EXTERN
	116	%token FILL
	117	%token FLOAT
	118	%token FORCE_COMMON_ALLOCATION
	119	%token GLOBAL /* global */
	120	%token GROUP
	121	%token HLL
	122	%token INCLUDE
	123	%token INFO
	124	%token INHIBIT_COMMON_ALLOCATION
	125	%token INPUT
	126	%token KEEP
	127	%token LENGTH /* LENGTH, l, len */
	128	%token LOADADDR
	129	%token LOCAL /* local */
	130	%token LONG
	131	%token MAP
	132	%token MAX_K /* MAX */
	133	%token MEMORY
	134	%token MIN_K /* MIN */
	135	%token NEXT
	136	%token NOCROSSREFS
	137	%token NOFLOAT
	138	%token NOLOAD
	139	%token ONLY_IF_RO
	140	%token ONLY_IF_RW
	141	%token ORIGIN /* ORIGIN, o, org */
	142	%token OUTPUT
	143	%token OUTPUT_ARCH
	144	%token OUTPUT_FORMAT
	145	%token OVERLAY
	146	%token PHDRS
	147	%token PROVIDE
	148	%token PROVIDE_HIDDEN
	149	%token QUAD
	150	%token SEARCH_DIR
	151	%token SECTIONS
	152	%token SEGMENT_START
	153	%token SHORT
	154	%token SIZEOF
	155	%token SIZEOF_HEADERS /* SIZEOF_HEADERS, sizeof_headers */
	156	%token SORT_BY_ALIGNMENT
	157	%token SORT_BY_NAME
	158	%token SPECIAL
	159	%token SQUAD
	160	%token STARTUP
	161	%token SUBALIGN
162	%token SYSLIB
163	%token TARGET_K /* TARGET */
164	%token TRUNCATE
165	%token VERSIONK /* VERSION */
166
195e7dc6 ILT	167	/* Keywords, part 2. These are keywords that are unique to gold,
	168	and not present in the old GNU linker. As before, unless the
	169	comments say otherwise, the keyword is recognized as the token
	170	name in upper case. */
	171
	172	%token OPTION
	173
e5756efb ILT	174	/* Special tokens used to tell the grammar what type of tokens we are
	175	parsing. The token stream always begins with one of these tokens.
	176	We do this because version scripts can appear embedded within
	177	linker scripts, and because --defsym uses the expression
	178	parser. */
	179	%token PARSING_LINKER_SCRIPT
	180	%token PARSING_VERSION_SCRIPT
	181	%token PARSING_DEFSYM
	182
	183	/* Non-terminal types, where needed. */
	184
	185	%type <expr> parse_exp exp
09124467 ILT	186	%type <versyms> vers_defns
	187	%type <versnode> vers_tag
	188	%type <deplist> verdep
10600224	189	%type <string> string
e5756efb	190
dbe717ef ILT	191	%%
dbe717ef ILT	192
e5756efb ILT	193	/* Read the special token to see what to read next. */
	194	top:
	195	PARSING_LINKER_SCRIPT linker_script
	196	\| PARSING_VERSION_SCRIPT version_script
	197	\| PARSING_DEFSYM defsym_expr
	198	;
	199
d391083d	200	/* A file contains a list of commands. */
e5756efb ILT	201	linker_script:
e5756efb ILT	202	linker_script file_cmd
dbe717ef ILT	203	\| /* empty */
	204	;
	205
d391083d	206	/* A command which may appear at top level of a linker script. */
dbe717ef	207	file_cmd:
2dd3e587	208	GROUP
dbe717ef ILT	209	{ script_start_group(closure); }
	210	'(' input_list ')'
	211	{ script_end_group(closure); }
10600224	212	\| OPTION '(' string ')'
e5756efb	213	{ script_parse_option(closure, $3.value, $3.length); }
09124467 ILT	214	\| VERSIONK '{'
	215	{ script_push_lex_into_version_mode(closure); }
	216	version_script '}'
	217	{ script_pop_lex_mode(closure); }
d391083d	218	\| file_or_sections_cmd
2dd3e587 ILT	219	\| ignore_cmd
	220	;
	221
	222	/* Top level commands which we ignore. The GNU linker uses these to
	223	select the output format, but we don't offer a choice. Ignoring
	224	these is more-or-less OK since most scripts simply explicitly
	225	choose the default. */
	226	ignore_cmd:
10600224 ILT	227	OUTPUT_FORMAT '(' string ')'
	228	\| OUTPUT_FORMAT '(' string ',' string ',' string ')'
	229	\| OUTPUT_ARCH '(' string ')'
dbe717ef ILT	230	;
dbe717ef ILT	231
d391083d	232	/* A list of input file names. */
dbe717ef ILT	233	input_list:
	234	input_list_element
	235	\| input_list opt_comma input_list_element
	236	;
	237
d391083d	238	/* An input file name. */
dbe717ef	239	input_list_element:
10600224	240	string
e5756efb	241	{ script_add_file(closure, $1.value, $1.length); }
dbe717ef ILT	242	\| AS_NEEDED
	243	{ script_start_as_needed(closure); }
	244	'(' input_list ')'
	245	{ script_end_as_needed(closure); }
	246	;
	247
d391083d ILT	248	/* A command which may appear at the top level of a linker script, or
	249	within a SECTIONS block. */
	250	file_or_sections_cmd:
10600224	251	ENTRY '(' string ')'
e5756efb ILT	252	{ script_set_entry(closure, $3.value, $3.length); }
	253	\| assignment end
	254	;
	255
	256	/* Set a symbol to a value. */
	257	assignment:
10600224	258	string '=' parse_exp
e5756efb	259	{ script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
10600224	260	\| string PLUSEQ parse_exp
e5756efb ILT	261	{
	262	Expression_ptr s = script_exp_string($1.value, $1.length);
	263	Expression_ptr e = script_exp_binary_add(s, $3);
	264	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	265	}
10600224	266	\| string MINUSEQ parse_exp
e5756efb ILT	267	{
	268	Expression_ptr s = script_exp_string($1.value, $1.length);
	269	Expression_ptr e = script_exp_binary_sub(s, $3);
	270	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	271	}
10600224	272	\| string MULTEQ parse_exp
e5756efb ILT	273	{
	274	Expression_ptr s = script_exp_string($1.value, $1.length);
	275	Expression_ptr e = script_exp_binary_mult(s, $3);
	276	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	277	}
10600224	278	\| string DIVEQ parse_exp
e5756efb ILT	279	{
	280	Expression_ptr s = script_exp_string($1.value, $1.length);
	281	Expression_ptr e = script_exp_binary_div(s, $3);
	282	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	283	}
10600224	284	\| string LSHIFTEQ parse_exp
e5756efb ILT	285	{
	286	Expression_ptr s = script_exp_string($1.value, $1.length);
	287	Expression_ptr e = script_exp_binary_lshift(s, $3);
	288	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	289	}
10600224	290	\| string RSHIFTEQ parse_exp
e5756efb ILT	291	{
	292	Expression_ptr s = script_exp_string($1.value, $1.length);
	293	Expression_ptr e = script_exp_binary_rshift(s, $3);
	294	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	295	}
10600224	296	\| string ANDEQ parse_exp
e5756efb ILT	297	{
	298	Expression_ptr s = script_exp_string($1.value, $1.length);
	299	Expression_ptr e = script_exp_binary_bitwise_and(s, $3);
	300	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	301	}
10600224	302	\| string OREQ parse_exp
e5756efb ILT	303	{
	304	Expression_ptr s = script_exp_string($1.value, $1.length);
	305	Expression_ptr e = script_exp_binary_bitwise_or(s, $3);
	306	script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
	307	}
10600224	308	\| PROVIDE '(' string '=' parse_exp ')'
e5756efb	309	{ script_set_symbol(closure, $3.value, $3.length, $5, 1, 0); }
10600224	310	\| PROVIDE_HIDDEN '(' string '=' parse_exp ')'
e5756efb ILT	311	{ script_set_symbol(closure, $3.value, $3.length, $5, 1, 1); }
	312	;
	313
	314	/* Parse an expression, putting the lexer into the right mode. */
	315	parse_exp:
	316	{ script_push_lex_into_expression_mode(closure); }
	317	exp
	318	{
	319	script_pop_lex_mode(closure);
	320	$$ = $2;
	321	}
	322	;
	323
	324	/* An expression. */
	325	exp:
	326	'(' exp ')'
	327	{ $$ = $2; }
	328	\| '-' exp %prec UNARY
	329	{ $$ = script_exp_unary_minus($2); }
	330	\| '!' exp %prec UNARY
	331	{ $$ = script_exp_unary_logical_not($2); }
	332	\| '~' exp %prec UNARY
	333	{ $$ = script_exp_unary_bitwise_not($2); }
	334	\| '+' exp %prec UNARY
	335	{ $$ = $2; }
	336	\| exp '*' exp
	337	{ $$ = script_exp_binary_mult($1, $3); }
	338	\| exp '/' exp
	339	{ $$ = script_exp_binary_div($1, $3); }
	340	\| exp '%' exp
	341	{ $$ = script_exp_binary_mod($1, $3); }
	342	\| exp '+' exp
	343	{ $$ = script_exp_binary_add($1, $3); }
	344	\| exp '-' exp
	345	{ $$ = script_exp_binary_sub($1, $3); }
	346	\| exp LSHIFT exp
	347	{ $$ = script_exp_binary_lshift($1, $3); }
	348	\| exp RSHIFT exp
	349	{ $$ = script_exp_binary_rshift($1, $3); }
	350	\| exp EQ exp
	351	{ $$ = script_exp_binary_eq($1, $3); }
	352	\| exp NE exp
	353	{ $$ = script_exp_binary_ne($1, $3); }
	354	\| exp LE exp
	355	{ $$ = script_exp_binary_le($1, $3); }
	356	\| exp GE exp
	357	{ $$ = script_exp_binary_ge($1, $3); }
	358	\| exp '<' exp
	359	{ $$ = script_exp_binary_lt($1, $3); }
	360	\| exp '>' exp
	361	{ $$ = script_exp_binary_gt($1, $3); }
	362	\| exp '&' exp
	363	{ $$ = script_exp_binary_bitwise_and($1, $3); }
	364	\| exp '^' exp
	365	{ $$ = script_exp_binary_bitwise_xor($1, $3); }
	366	\| exp '\|' exp
	367	{ $$ = script_exp_binary_bitwise_or($1, $3); }
	368	\| exp ANDAND exp
	369	{ $$ = script_exp_binary_logical_and($1, $3); }
	370	\| exp OROR exp
	371	{ $$ = script_exp_binary_logical_or($1, $3); }
	372	\| exp '?' exp ':' exp
	373	{ $$ = script_exp_trinary_cond($1, $3, $5); }
	374	\| INTEGER
375	{ $$ = script_exp_integer($1); }
376	\| STRING
377	{ $$ = script_exp_string($1.value, $1.length); }
10600224 ILT	378	\| QUOTED_STRING
10600224 ILT	379	{ $$ = script_exp_string($1.value, $1.length); }
e5756efb ILT	380	\| MAX_K '(' exp ',' exp ')'
	381	{ $$ = script_exp_function_max($3, $5); }
	382	\| MIN_K '(' exp ',' exp ')'
	383	{ $$ = script_exp_function_min($3, $5); }
10600224	384	\| DEFINED '(' string ')'
e5756efb ILT	385	{ $$ = script_exp_function_defined($3.value, $3.length); }
	386	\| SIZEOF_HEADERS
	387	{ $$ = script_exp_function_sizeof_headers(); }
10600224	388	\| ALIGNOF '(' string ')'
e5756efb	389	{ $$ = script_exp_function_alignof($3.value, $3.length); }
10600224	390	\| SIZEOF '(' string ')'
e5756efb	391	{ $$ = script_exp_function_sizeof($3.value, $3.length); }
10600224	392	\| ADDR '(' string ')'
e5756efb	393	{ $$ = script_exp_function_addr($3.value, $3.length); }
10600224	394	\| LOADADDR '(' string ')'
e5756efb	395	{ $$ = script_exp_function_loadaddr($3.value, $3.length); }
10600224	396	\| ORIGIN '(' string ')'
e5756efb	397	{ $$ = script_exp_function_origin($3.value, $3.length); }
10600224	398	\| LENGTH '(' string ')'
e5756efb	399	{ $$ = script_exp_function_length($3.value, $3.length); }
10600224	400	\| CONSTANT '(' string ')'
e5756efb ILT	401	{ $$ = script_exp_function_constant($3.value, $3.length); }
	402	\| ABSOLUTE '(' exp ')'
	403	{ $$ = script_exp_function_absolute($3); }
	404	\| ALIGN_K '(' exp ')'
	405	{ $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
	406	\| ALIGN_K '(' exp ',' exp ')'
	407	{ $$ = script_exp_function_align($3, $5); }
	408	\| BLOCK '(' exp ')'
	409	{ $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
	410	\| DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
	411	{ $$ = script_exp_function_data_segment_align($3, $5); }
	412	\| DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
	413	{ $$ = script_exp_function_data_segment_relro_end($3, $5); }
	414	\| DATA_SEGMENT_END '(' exp ')'
	415	{ $$ = script_exp_function_data_segment_end($3); }
10600224	416	\| SEGMENT_START '(' string ',' exp ')'
e5756efb ILT	417	{
	418	$$ = script_exp_function_segment_start($3.value, $3.length, $5);
	419	}
10600224	420	\| ASSERT_K '(' exp ',' string ')'
e5756efb ILT	421	{ $$ = script_exp_function_assert($3, $5.value, $5.length); }
	422	;
	423
	424	/* Handle the --defsym option. */
	425	defsym_expr:
10600224	426	string '=' parse_exp
e5756efb ILT	427	{ script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
	428	;
	429
09124467	430	/* A version script. */
e5756efb	431	version_script:
09124467 ILT	432	vers_nodes
	433	;
	434
	435	vers_nodes:
	436	vers_node
	437	\| vers_nodes vers_node
	438	;
	439
	440	vers_node:
	441	'{' vers_tag '}' ';'
	442	{
	443	script_register_vers_node (closure, NULL, 0, $2, NULL);
	444	}
10600224	445	\| string '{' vers_tag '}' ';'
09124467 ILT	446	{
	447	script_register_vers_node (closure, $1.value, $1.length, $3,
	448	NULL);
	449	}
10600224	450	\| string '{' vers_tag '}' verdep ';'
09124467 ILT	451	{
	452	script_register_vers_node (closure, $1.value, $1.length, $3, $5);
	453	}
	454	;
	455
	456	verdep:
10600224	457	string
09124467 ILT	458	{
	459	$$ = script_add_vers_depend (closure, NULL, $1.value, $1.length);
	460	}
10600224	461	\| verdep string
09124467 ILT	462	{
	463	$$ = script_add_vers_depend (closure, $1, $2.value, $2.length);
	464	}
	465	;
	466
	467	vers_tag:
	468	/* empty */
	469	{ $$ = script_new_vers_node (closure, NULL, NULL); }
	470	\| vers_defns ';'
	471	{ $$ = script_new_vers_node (closure, $1, NULL); }
	472	\| GLOBAL ':' vers_defns ';'
	473	{ $$ = script_new_vers_node (closure, $3, NULL); }
	474	\| LOCAL ':' vers_defns ';'
	475	{ $$ = script_new_vers_node (closure, NULL, $3); }
	476	\| GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
	477	{ $$ = script_new_vers_node (closure, $3, $7); }
	478	;
	479
10600224 ILT	480	/* Here is one of the rare places we care about the distinction
	481	between STRING and QUOTED_STRING. For QUOTED_STRING, we do exact
	482	matching on the pattern, so we pass in true for the exact_match
	483	parameter. For STRING, we do glob matching and pass in false. */
09124467 ILT	484	vers_defns:
	485	STRING
	486	{
	487	$$ = script_new_vers_pattern (closure, NULL, $1.value,
10600224 ILT	488	$1.length, 0);
	489	}
	490	\| QUOTED_STRING
	491	{
	492	$$ = script_new_vers_pattern (closure, NULL, $1.value,
	493	$1.length, 1);
09124467 ILT	494	}
	495	\| vers_defns ';' STRING
	496	{
10600224 ILT	497	$$ = script_new_vers_pattern (closure, $1, $3.value,
	498	$3.length, 0);
	499	}
	500	\| vers_defns ';' QUOTED_STRING
	501	{
	502	$$ = script_new_vers_pattern (closure, $1, $3.value,
	503	$3.length, 1);
09124467	504	}
10600224 ILT	505	\| /* Push string on the language stack. */
	506	EXTERN string '{'
	507	{ version_script_push_lang (closure, $2.value, $2.length); }
09124467 ILT	508	vers_defns opt_semicolon '}'
	509	{
	510	$$ = $5;
	511	version_script_pop_lang(closure);
	512	}
10600224 ILT	513	\| /* Push string on the language stack. This is more complicated
	514	than the other cases because we need to merge the linked-list
	515	state from the pre-EXTERN defns and the post-EXTERN defns. */
	516	vers_defns ';' EXTERN string '{'
	517	{ version_script_push_lang (closure, $4.value, $4.length); }
	518	vers_defns opt_semicolon '}'
	519	{
	520	$$ = script_merge_expressions ($1, $7);
	521	version_script_pop_lang(closure);
	522	}
09124467 ILT	523	\| EXTERN // "extern" as a symbol name
	524	{
	525	$$ = script_new_vers_pattern (closure, NULL, "extern",
10600224	526	sizeof("extern") - 1, 1);
09124467 ILT	527	}
	528	\| vers_defns ';' EXTERN
	529	{
	530	$$ = script_new_vers_pattern (closure, $1, "extern",
10600224	531	sizeof("extern") - 1, 1);
09124467	532	}
e5756efb ILT	533	;
e5756efb ILT	534
10600224 ILT	535	/* A string can be either a STRING or a QUOTED_STRING. Almost all the
	536	time we don't care, and we use this rule. */
	537	string:
	538	STRING
	539	{ $$ = $1; }
	540	\| QUOTED_STRING
	541	{ $$ = $1; }
	542	;
	543
e5756efb ILT	544	/* Some statements require a terminator, which may be a semicolon or a
	545	comma. */
	546	end:
	547	';'
	548	\| ','
d391083d ILT	549	;
d391083d ILT	550
09124467 ILT	551	/* An optional semicolon. */
	552	opt_semicolon:
	553	';'
	554	\| /* empty */
	555	;
	556
d391083d	557	/* An optional comma. */
dbe717ef ILT	558	opt_comma:
	559	','
	560	\| /* empty */
	561	;
	562
	563	%%