Home | History | Annotate | Download | only in ld 
      1 /* A YACC grammar to parse a superset of the AT&T linker scripting language.
      2    Copyright (C) 1991-2016 Free Software Foundation, Inc.
      3    Written by Steve Chamberlain of Cygnus Support (steve (at) cygnus.com).
      4 
      5    This file is part of the GNU Binutils.
      6 
      7    This program is free software; you can redistribute it and/or modify
      8    it under the terms of the GNU General Public License as published by
      9    the Free Software Foundation; either version 3 of the License, or
     10    (at your option) any later version.
     11 
     12    This program is distributed in the hope that it will be useful,
     13    but WITHOUT ANY WARRANTY; without even the implied warranty of
     14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15    GNU General Public License for more details.
     16 
     17    You should have received a copy of the GNU General Public License
     18    along with this program; if not, write to the Free Software
     19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     20    MA 02110-1301, USA.  */
     21 
     22 %{
     23 /*
     24 
     25  */
     26 
     27 #define DONTDECLARE_MALLOC
     28 
     29 #include "sysdep.h"
     30 #include "bfd.h"
     31 #include "bfdlink.h"
     32 #include "ld.h"
     33 #include "ldexp.h"
     34 #include "ldver.h"
     35 #include "ldlang.h"
     36 #include "ldfile.h"
     37 #include "ldemul.h"
     38 #include "ldmisc.h"
     39 #include "ldmain.h"
     40 #include "mri.h"
     41 #include "ldctor.h"
     42 #include "ldlex.h"
     43 
     44 #ifndef YYDEBUG
     45 #define YYDEBUG 1
     46 #endif
     47 
     48 static enum section_type sectype;
     49 static lang_memory_region_type *region;
     50 
     51 bfd_boolean ldgram_had_keep = FALSE;
     52 char *ldgram_vers_current_lang = NULL;
     53 
     54 #define ERROR_NAME_MAX 20
     55 static char *error_names[ERROR_NAME_MAX];
     56 static int error_index;
     57 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
     58 #define POP_ERROR()   error_index--;
     59 %}
     60 %union {
     61   bfd_vma integer;
     62   struct big_int
     63     {
     64       bfd_vma integer;
     65       char *str;
     66     } bigint;
     67   fill_type *fill;
     68   char *name;
     69   const char *cname;
     70   struct wildcard_spec wildcard;
     71   struct wildcard_list *wildcard_list;
     72   struct name_list *name_list;
     73   struct flag_info_list *flag_info_list;
     74   struct flag_info *flag_info;
     75   int token;
     76   union etree_union *etree;
     77   struct phdr_info
     78     {
     79       bfd_boolean filehdr;
     80       bfd_boolean phdrs;
     81       union etree_union *at;
     82       union etree_union *flags;
     83     } phdr;
     84   struct lang_nocrossref *nocrossref;
     85   struct lang_output_section_phdr_list *section_phdr;
     86   struct bfd_elf_version_deps *deflist;
     87   struct bfd_elf_version_expr *versyms;
     88   struct bfd_elf_version_tree *versnode;
     89 }
     90 
     91 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
     92 %type <etree> opt_exp_without_type opt_subalign opt_align
     93 %type <fill> fill_opt fill_exp
     94 %type <name_list> exclude_name_list
     95 %type <wildcard_list> file_NAME_list
     96 %type <flag_info_list> sect_flag_list
     97 %type <flag_info> sect_flags
     98 %type <name> memspec_opt casesymlist
     99 %type <name> memspec_at_opt
    100 %type <cname> wildcard_name
    101 %type <wildcard> wildcard_spec
    102 %token <bigint> INT
    103 %token <name> NAME LNAME
    104 %type <integer> length
    105 %type <phdr> phdr_qualifiers
    106 %type <nocrossref> nocrossref_list
    107 %type <section_phdr> phdr_opt
    108 %type <integer> opt_nocrossrefs
    109 
    110 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
    111 %right <token> '?' ':'
    112 %left <token> OROR
    113 %left <token>  ANDAND
    114 %left <token> '|'
    115 %left <token>  '^'
    116 %left  <token> '&'
    117 %left <token>  EQ NE
    118 %left  <token> '<' '>' LE GE
    119 %left  <token> LSHIFT RSHIFT
    120 
    121 %left  <token> '+' '-'
    122 %left  <token> '*' '/' '%'
    123 
    124 %right UNARY
    125 %token END
    126 %left <token> '('
    127 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
    128 %token SECTIONS PHDRS INSERT_K AFTER BEFORE
    129 %token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
    130 %token SORT_BY_NAME SORT_BY_ALIGNMENT SORT_NONE
    131 %token SORT_BY_INIT_PRIORITY
    132 %token '{' '}'
    133 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
    134 %token INHIBIT_COMMON_ALLOCATION
    135 %token SEGMENT_START
    136 %token INCLUDE
    137 %token MEMORY
    138 %token REGION_ALIAS
    139 %token LD_FEATURE
    140 %token NOLOAD DSECT COPY INFO OVERLAY
    141 %token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
    142 %token <integer> NEXT
    143 %token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
    144 %token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS NOCROSSREFS_TO
    145 %token ORIGIN FILL
    146 %token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
    147 %token ALIGNMOD AT SUBALIGN HIDDEN PROVIDE PROVIDE_HIDDEN AS_NEEDED
    148 %type <token> assign_op atype attributes_opt sect_constraint opt_align_with_input
    149 %type <name>  filename
    150 %token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
    151 %token LOG2CEIL FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
    152 %token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
    153 %token <name> VERS_TAG VERS_IDENTIFIER
    154 %token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
    155 %token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL INPUT_SECTION_FLAGS ALIGN_WITH_INPUT
    156 %token EXCLUDE_FILE
    157 %token CONSTANT
    158 %type <versyms> vers_defns
    159 %type <versnode> vers_tag
    160 %type <deflist> verdep
    161 %token INPUT_DYNAMIC_LIST
    162 
    163 %%
    164 
    165 file:
    166 		INPUT_SCRIPT script_file
    167 	|	INPUT_MRI_SCRIPT mri_script_file
    168 	|	INPUT_VERSION_SCRIPT version_script_file
    169 	|	INPUT_DYNAMIC_LIST dynamic_list_file
    170 	|	INPUT_DEFSYM defsym_expr
    171 	;
    172 
    173 
    174 filename:  NAME;
    175 
    176 
    177 defsym_expr:
    178 		{ ldlex_defsym(); }
    179 		NAME '=' exp
    180 		{
    181 		  ldlex_popstate();
    182 		  lang_add_assignment (exp_defsym ($2, $4));
    183 		}
    184 	;
    185 
    186 /* SYNTAX WITHIN AN MRI SCRIPT FILE */
    187 mri_script_file:
    188 		{
    189 		  ldlex_mri_script ();
    190 		  PUSH_ERROR (_("MRI style script"));
    191 		}
    192 	     mri_script_lines
    193 		{
    194 		  ldlex_popstate ();
    195 		  mri_draw_tree ();
    196 		  POP_ERROR ();
    197 		}
    198 	;
    199 
    200 mri_script_lines:
    201 		mri_script_lines mri_script_command NEWLINE
    202           |
    203 	;
    204 
    205 mri_script_command:
    206 		CHIP  exp
    207 	|	CHIP  exp ',' exp
    208 	|	NAME 	{
    209 			einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
    210 			}
    211 	|	LIST  	{
    212 			config.map_filename = "-";
    213 			}
    214         |       ORDER ordernamelist
    215 	|       ENDWORD
    216         |       PUBLIC NAME '=' exp
    217  			{ mri_public($2, $4); }
    218         |       PUBLIC NAME ',' exp
    219  			{ mri_public($2, $4); }
    220         |       PUBLIC NAME  exp
    221  			{ mri_public($2, $3); }
    222 	| 	FORMAT NAME
    223 			{ mri_format($2); }
    224 	|	SECT NAME ',' exp
    225 			{ mri_output_section($2, $4);}
    226 	|	SECT NAME  exp
    227 			{ mri_output_section($2, $3);}
    228 	|	SECT NAME '=' exp
    229 			{ mri_output_section($2, $4);}
    230 	|	ALIGN_K NAME '=' exp
    231 			{ mri_align($2,$4); }
    232 	|	ALIGN_K NAME ',' exp
    233 			{ mri_align($2,$4); }
    234 	|	ALIGNMOD NAME '=' exp
    235 			{ mri_alignmod($2,$4); }
    236 	|	ALIGNMOD NAME ',' exp
    237 			{ mri_alignmod($2,$4); }
    238 	|	ABSOLUTE mri_abs_name_list
    239 	|	LOAD	 mri_load_name_list
    240 	|       NAMEWORD NAME
    241 			{ mri_name($2); }
    242 	|	ALIAS NAME ',' NAME
    243 			{ mri_alias($2,$4,0);}
    244 	|	ALIAS NAME ',' INT
    245 			{ mri_alias ($2, 0, (int) $4.integer); }
    246 	|	BASE     exp
    247 			{ mri_base($2); }
    248 	|	TRUNCATE INT
    249 		{ mri_truncate ((unsigned int) $2.integer); }
    250 	|	CASE casesymlist
    251 	|	EXTERN extern_name_list
    252 	|	INCLUDE filename
    253 		{ ldlex_script (); ldfile_open_command_file($2); }
    254 		mri_script_lines END
    255 		{ ldlex_popstate (); }
    256 	|	START NAME
    257 		{ lang_add_entry ($2, FALSE); }
    258         |
    259 	;
    260 
    261 ordernamelist:
    262 	      ordernamelist ',' NAME         { mri_order($3); }
    263 	|     ordernamelist  NAME         { mri_order($2); }
    264       	|
    265 	;
    266 
    267 mri_load_name_list:
    268 		NAME
    269 			{ mri_load($1); }
    270 	|	mri_load_name_list ',' NAME { mri_load($3); }
    271 	;
    272 
    273 mri_abs_name_list:
    274  		NAME
    275  			{ mri_only_load($1); }
    276 	|	mri_abs_name_list ','  NAME
    277  			{ mri_only_load($3); }
    278 	;
    279 
    280 casesymlist:
    281 	  /* empty */ { $$ = NULL; }
    282 	| NAME
    283 	| casesymlist ',' NAME
    284 	;
    285 
    286 /* Parsed as expressions so that commas separate entries */
    287 extern_name_list:
    288 	{ ldlex_expression (); }
    289 	extern_name_list_body
    290 	{ ldlex_popstate (); }
    291 
    292 extern_name_list_body:
    293 	  NAME
    294 			{ ldlang_add_undef ($1, FALSE); }
    295 	| extern_name_list_body NAME
    296 			{ ldlang_add_undef ($2, FALSE); }
    297 	| extern_name_list_body ',' NAME
    298 			{ ldlang_add_undef ($3, FALSE); }
    299 	;
    300 
    301 script_file:
    302 	{ ldlex_both(); }
    303 	ifile_list
    304 	{ ldlex_popstate(); }
    305         ;
    306 
    307 ifile_list:
    308 	ifile_list ifile_p1
    309         |
    310 	;
    311 
    312 
    313 ifile_p1:
    314 		memory
    315 	|	sections
    316 	|	phdrs
    317 	|	startup
    318 	|	high_level_library
    319 	|	low_level_library
    320 	|	floating_point_support
    321 	|	statement_anywhere
    322 	|	version
    323         |	 ';'
    324 	|	TARGET_K '(' NAME ')'
    325 		{ lang_add_target($3); }
    326 	|	SEARCH_DIR '(' filename ')'
    327 		{ ldfile_add_library_path ($3, FALSE); }
    328 	|	OUTPUT '(' filename ')'
    329 		{ lang_add_output($3, 1); }
    330         |	OUTPUT_FORMAT '(' NAME ')'
    331 		  { lang_add_output_format ($3, (char *) NULL,
    332 					    (char *) NULL, 1); }
    333 	|	OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
    334 		  { lang_add_output_format ($3, $5, $7, 1); }
    335         |	OUTPUT_ARCH '(' NAME ')'
    336 		  { ldfile_set_output_arch ($3, bfd_arch_unknown); }
    337 	|	FORCE_COMMON_ALLOCATION
    338 		{ command_line.force_common_definition = TRUE ; }
    339 	|	INHIBIT_COMMON_ALLOCATION
    340 		{ command_line.inhibit_common_definition = TRUE ; }
    341 	|	INPUT '(' input_list ')'
    342 	|	GROUP
    343 		  { lang_enter_group (); }
    344 		    '(' input_list ')'
    345 		  { lang_leave_group (); }
    346      	|	MAP '(' filename ')'
    347 		{ lang_add_map($3); }
    348 	|	INCLUDE filename
    349 		{ ldlex_script (); ldfile_open_command_file($2); }
    350 		ifile_list END
    351 		{ ldlex_popstate (); }
    352 	|	NOCROSSREFS '(' nocrossref_list ')'
    353 		{
    354 		  lang_add_nocrossref ($3);
    355 		}
    356 	|	NOCROSSREFS_TO '(' nocrossref_list ')'
    357 		{
    358 		  lang_add_nocrossref_to ($3);
    359 		}
    360 	|	EXTERN '(' extern_name_list ')'
    361 	|	INSERT_K AFTER NAME
    362 		{ lang_add_insert ($3, 0); }
    363 	|	INSERT_K BEFORE NAME
    364 		{ lang_add_insert ($3, 1); }
    365 	|	REGION_ALIAS '(' NAME ',' NAME ')'
    366 		{ lang_memory_region_alias ($3, $5); }
    367 	|	LD_FEATURE '(' NAME ')'
    368 		{ lang_ld_feature ($3); }
    369 	;
    370 
    371 input_list:
    372 		{ ldlex_inputlist(); }
    373 		input_list1
    374 		{ ldlex_popstate(); }
    375 
    376 input_list1:
    377 		NAME
    378 		{ lang_add_input_file($1,lang_input_file_is_search_file_enum,
    379 				 (char *)NULL); }
    380 	|	input_list1 ',' NAME
    381 		{ lang_add_input_file($3,lang_input_file_is_search_file_enum,
    382 				 (char *)NULL); }
    383 	|	input_list1 NAME
    384 		{ lang_add_input_file($2,lang_input_file_is_search_file_enum,
    385 				 (char *)NULL); }
    386 	|	LNAME
    387 		{ lang_add_input_file($1,lang_input_file_is_l_enum,
    388 				 (char *)NULL); }
    389 	|	input_list1 ',' LNAME
    390 		{ lang_add_input_file($3,lang_input_file_is_l_enum,
    391 				 (char *)NULL); }
    392 	|	input_list1 LNAME
    393 		{ lang_add_input_file($2,lang_input_file_is_l_enum,
    394 				 (char *)NULL); }
    395 	|	AS_NEEDED '('
    396 		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
    397 		    input_flags.add_DT_NEEDED_for_regular = TRUE; }
    398 		     input_list1 ')'
    399 		  { input_flags.add_DT_NEEDED_for_regular = $<integer>3; }
    400 	|	input_list1 ',' AS_NEEDED '('
    401 		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
    402 		    input_flags.add_DT_NEEDED_for_regular = TRUE; }
    403 		     input_list1 ')'
    404 		  { input_flags.add_DT_NEEDED_for_regular = $<integer>5; }
    405 	|	input_list1 AS_NEEDED '('
    406 		  { $<integer>$ = input_flags.add_DT_NEEDED_for_regular;
    407 		    input_flags.add_DT_NEEDED_for_regular = TRUE; }
    408 		     input_list1 ')'
    409 		  { input_flags.add_DT_NEEDED_for_regular = $<integer>4; }
    410 	;
    411 
    412 sections:
    413 		SECTIONS '{' sec_or_group_p1 '}'
    414 	;
    415 
    416 sec_or_group_p1:
    417 		sec_or_group_p1 section
    418 	|	sec_or_group_p1 statement_anywhere
    419 	|
    420 	;
    421 
    422 statement_anywhere:
    423 		ENTRY '(' NAME ')'
    424 		{ lang_add_entry ($3, FALSE); }
    425 	|	assignment end
    426 	|	ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
    427 		{ ldlex_popstate ();
    428 		  lang_add_assignment (exp_assert ($4, $6)); }
    429 	;
    430 
    431 /* The '*' and '?' cases are there because the lexer returns them as
    432    separate tokens rather than as NAME.  */
    433 wildcard_name:
    434 		NAME
    435 			{
    436 			  $$ = $1;
    437 			}
    438 	|	'*'
    439 			{
    440 			  $$ = "*";
    441 			}
    442 	|	'?'
    443 			{
    444 			  $$ = "?";
    445 			}
    446 	;
    447 
    448 wildcard_spec:
    449 		wildcard_name
    450 			{
    451 			  $$.name = $1;
    452 			  $$.sorted = none;
    453 			  $$.exclude_name_list = NULL;
    454 			  $$.section_flag_list = NULL;
    455 			}
    456 	| 	EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
    457 			{
    458 			  $$.name = $5;
    459 			  $$.sorted = none;
    460 			  $$.exclude_name_list = $3;
    461 			  $$.section_flag_list = NULL;
    462 			}
    463 	|	SORT_BY_NAME '(' wildcard_name ')'
    464 			{
    465 			  $$.name = $3;
    466 			  $$.sorted = by_name;
    467 			  $$.exclude_name_list = NULL;
    468 			  $$.section_flag_list = NULL;
    469 			}
    470 	|	SORT_BY_ALIGNMENT '(' wildcard_name ')'
    471 			{
    472 			  $$.name = $3;
    473 			  $$.sorted = by_alignment;
    474 			  $$.exclude_name_list = NULL;
    475 			  $$.section_flag_list = NULL;
    476 			}
    477 	|	SORT_NONE '(' wildcard_name ')'
    478 			{
    479 			  $$.name = $3;
    480 			  $$.sorted = by_none;
    481 			  $$.exclude_name_list = NULL;
    482 			  $$.section_flag_list = NULL;
    483 			}
    484 	|	SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
    485 			{
    486 			  $$.name = $5;
    487 			  $$.sorted = by_name_alignment;
    488 			  $$.exclude_name_list = NULL;
    489 			  $$.section_flag_list = NULL;
    490 			}
    491 	|	SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
    492 			{
    493 			  $$.name = $5;
    494 			  $$.sorted = by_name;
    495 			  $$.exclude_name_list = NULL;
    496 			  $$.section_flag_list = NULL;
    497 			}
    498 	|	SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
    499 			{
    500 			  $$.name = $5;
    501 			  $$.sorted = by_alignment_name;
    502 			  $$.exclude_name_list = NULL;
    503 			  $$.section_flag_list = NULL;
    504 			}
    505 	|	SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
    506 			{
    507 			  $$.name = $5;
    508 			  $$.sorted = by_alignment;
    509 			  $$.exclude_name_list = NULL;
    510 			  $$.section_flag_list = NULL;
    511 			}
    512 	|	SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
    513 			{
    514 			  $$.name = $7;
    515 			  $$.sorted = by_name;
    516 			  $$.exclude_name_list = $5;
    517 			  $$.section_flag_list = NULL;
    518 			}
    519 	|	SORT_BY_INIT_PRIORITY '(' wildcard_name ')'
    520 			{
    521 			  $$.name = $3;
    522 			  $$.sorted = by_init_priority;
    523 			  $$.exclude_name_list = NULL;
    524 			  $$.section_flag_list = NULL;
    525 			}
    526 	;
    527 
    528 sect_flag_list:	NAME
    529 			{
    530 			  struct flag_info_list *n;
    531 			  n = ((struct flag_info_list *) xmalloc (sizeof *n));
    532 			  if ($1[0] == '!')
    533 			    {
    534 			      n->with = without_flags;
    535 			      n->name = &$1[1];
    536 			    }
    537 			  else
    538 			    {
    539 			      n->with = with_flags;
    540 			      n->name = $1;
    541 			    }
    542 			  n->valid = FALSE;
    543 			  n->next = NULL;
    544 			  $$ = n;
    545 			}
    546 	|	sect_flag_list '&' NAME
    547 			{
    548 			  struct flag_info_list *n;
    549 			  n = ((struct flag_info_list *) xmalloc (sizeof *n));
    550 			  if ($3[0] == '!')
    551 			    {
    552 			      n->with = without_flags;
    553 			      n->name = &$3[1];
    554 			    }
    555 			  else
    556 			    {
    557 			      n->with = with_flags;
    558 			      n->name = $3;
    559 			    }
    560 			  n->valid = FALSE;
    561 			  n->next = $1;
    562 			  $$ = n;
    563 			}
    564 	;
    565 
    566 sect_flags:
    567 		INPUT_SECTION_FLAGS '(' sect_flag_list ')'
    568 			{
    569 			  struct flag_info *n;
    570 			  n = ((struct flag_info *) xmalloc (sizeof *n));
    571 			  n->flag_list = $3;
    572 			  n->flags_initialized = FALSE;
    573 			  n->not_with_flags = 0;
    574 			  n->only_with_flags = 0;
    575 			  $$ = n;
    576 			}
    577 	;
    578 
    579 exclude_name_list:
    580 		exclude_name_list wildcard_name
    581 			{
    582 			  struct name_list *tmp;
    583 			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
    584 			  tmp->name = $2;
    585 			  tmp->next = $1;
    586 			  $$ = tmp;
    587 			}
    588 	|
    589 		wildcard_name
    590 			{
    591 			  struct name_list *tmp;
    592 			  tmp = (struct name_list *) xmalloc (sizeof *tmp);
    593 			  tmp->name = $1;
    594 			  tmp->next = NULL;
    595 			  $$ = tmp;
    596 			}
    597 	;
    598 
    599 file_NAME_list:
    600 		file_NAME_list opt_comma wildcard_spec
    601 			{
    602 			  struct wildcard_list *tmp;
    603 			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
    604 			  tmp->next = $1;
    605 			  tmp->spec = $3;
    606 			  $$ = tmp;
    607 			}
    608 	|
    609 		wildcard_spec
    610 			{
    611 			  struct wildcard_list *tmp;
    612 			  tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
    613 			  tmp->next = NULL;
    614 			  tmp->spec = $1;
    615 			  $$ = tmp;
    616 			}
    617 	;
    618 
    619 input_section_spec_no_keep:
    620 		NAME
    621 			{
    622 			  struct wildcard_spec tmp;
    623 			  tmp.name = $1;
    624 			  tmp.exclude_name_list = NULL;
    625 			  tmp.sorted = none;
    626 			  tmp.section_flag_list = NULL;
    627 			  lang_add_wild (&tmp, NULL, ldgram_had_keep);
    628 			}
    629 	|	sect_flags NAME
    630 			{
    631 			  struct wildcard_spec tmp;
    632 			  tmp.name = $2;
    633 			  tmp.exclude_name_list = NULL;
    634 			  tmp.sorted = none;
    635 			  tmp.section_flag_list = $1;
    636 			  lang_add_wild (&tmp, NULL, ldgram_had_keep);
    637 			}
    638         |	'[' file_NAME_list ']'
    639 			{
    640 			  lang_add_wild (NULL, $2, ldgram_had_keep);
    641 			}
    642         |	sect_flags '[' file_NAME_list ']'
    643 			{
    644 			  struct wildcard_spec tmp;
    645 			  tmp.name = NULL;
    646 			  tmp.exclude_name_list = NULL;
    647 			  tmp.sorted = none;
    648 			  tmp.section_flag_list = $1;
    649 			  lang_add_wild (&tmp, $3, ldgram_had_keep);
    650 			}
    651 	|	wildcard_spec '(' file_NAME_list ')'
    652 			{
    653 			  lang_add_wild (&$1, $3, ldgram_had_keep);
    654 			}
    655 	|	sect_flags wildcard_spec '(' file_NAME_list ')'
    656 			{
    657 			  $2.section_flag_list = $1;
    658 			  lang_add_wild (&$2, $4, ldgram_had_keep);
    659 			}
    660 	;
    661 
    662 input_section_spec:
    663 		input_section_spec_no_keep
    664 	|	KEEP '('
    665 			{ ldgram_had_keep = TRUE; }
    666 		input_section_spec_no_keep ')'
    667 			{ ldgram_had_keep = FALSE; }
    668 	;
    669 
    670 statement:
    671 	  	assignment end
    672 	|	CREATE_OBJECT_SYMBOLS
    673 		{
    674  		lang_add_attribute(lang_object_symbols_statement_enum);
    675 	      	}
    676         |	';'
    677         |	CONSTRUCTORS
    678 		{
    679 
    680 		  lang_add_attribute(lang_constructors_statement_enum);
    681 		}
    682 	| SORT_BY_NAME '(' CONSTRUCTORS ')'
    683 		{
    684 		  constructors_sorted = TRUE;
    685 		  lang_add_attribute (lang_constructors_statement_enum);
    686 		}
    687 	| input_section_spec
    688         | length '(' mustbe_exp ')'
    689         	        {
    690 			  lang_add_data ((int) $1, $3);
    691 			}
    692 
    693 	| FILL '(' fill_exp ')'
    694 			{
    695 			  lang_add_fill ($3);
    696 			}
    697 	| ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
    698 			{ ldlex_popstate ();
    699 			  lang_add_assignment (exp_assert ($4, $6)); }
    700 	| INCLUDE filename
    701 		{ ldlex_script (); ldfile_open_command_file($2); }
    702 		statement_list_opt END
    703 		{ ldlex_popstate (); }
    704 	;
    705 
    706 statement_list:
    707 		statement_list statement
    708   	|  	statement
    709 	;
    710 
    711 statement_list_opt:
    712 		/* empty */
    713 	|	statement_list
    714 	;
    715 
    716 length:
    717 		QUAD
    718 			{ $$ = $1; }
    719 	|	SQUAD
    720 			{ $$ = $1; }
    721 	|	LONG
    722 			{ $$ = $1; }
    723 	| 	SHORT
    724 			{ $$ = $1; }
    725 	|	BYTE
    726 			{ $$ = $1; }
    727 	;
    728 
    729 fill_exp:
    730 	mustbe_exp
    731 		{
    732 		  $$ = exp_get_fill ($1, 0, "fill value");
    733 		}
    734 	;
    735 
    736 fill_opt:
    737 	  '=' fill_exp
    738 		{ $$ = $2; }
    739 	| 	{ $$ = (fill_type *) 0; }
    740 	;
    741 
    742 assign_op:
    743 		PLUSEQ
    744 			{ $$ = '+'; }
    745 	|	MINUSEQ
    746 			{ $$ = '-'; }
    747 	| 	MULTEQ
    748 			{ $$ = '*'; }
    749 	| 	DIVEQ
    750 			{ $$ = '/'; }
    751 	| 	LSHIFTEQ
    752 			{ $$ = LSHIFT; }
    753 	| 	RSHIFTEQ
    754 			{ $$ = RSHIFT; }
    755 	| 	ANDEQ
    756 			{ $$ = '&'; }
    757 	| 	OREQ
    758 			{ $$ = '|'; }
    759 
    760 	;
    761 
    762 end:	';' | ','
    763 	;
    764 
    765 
    766 assignment:
    767 		NAME '=' mustbe_exp
    768 		{
    769 		  lang_add_assignment (exp_assign ($1, $3, FALSE));
    770 		}
    771 	|	NAME assign_op mustbe_exp
    772 		{
    773 		  lang_add_assignment (exp_assign ($1,
    774 						   exp_binop ($2,
    775 							      exp_nameop (NAME,
    776 									  $1),
    777 							      $3), FALSE));
    778 		}
    779 	|	HIDDEN '(' NAME '=' mustbe_exp ')'
    780 		{
    781 		  lang_add_assignment (exp_assign ($3, $5, TRUE));
    782 		}
    783 	|	PROVIDE '(' NAME '=' mustbe_exp ')'
    784 		{
    785 		  lang_add_assignment (exp_provide ($3, $5, FALSE));
    786 		}
    787 	|	PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
    788 		{
    789 		  lang_add_assignment (exp_provide ($3, $5, TRUE));
    790 		}
    791 	;
    792 
    793 
    794 opt_comma:
    795 		','	|	;
    796 
    797 
    798 memory:
    799 		MEMORY '{' memory_spec_list_opt '}'
    800 	;
    801 
    802 memory_spec_list_opt: memory_spec_list | ;
    803 
    804 memory_spec_list:
    805 		memory_spec_list opt_comma memory_spec
    806 	|	memory_spec
    807 	;
    808 
    809 
    810 memory_spec: 	NAME
    811 		{ region = lang_memory_region_lookup ($1, TRUE); }
    812 		attributes_opt ':'
    813 		origin_spec opt_comma length_spec
    814 		{}
    815 	|	INCLUDE filename
    816 		{ ldlex_script (); ldfile_open_command_file($2); }
    817 		memory_spec_list_opt END
    818 		{ ldlex_popstate (); }
    819 	;
    820 
    821 origin_spec:
    822 	ORIGIN '=' mustbe_exp
    823 		{
    824 		  region->origin_exp = $3;
    825 		  region->current = region->origin;
    826 		}
    827 	;
    828 
    829 length_spec:
    830              LENGTH '=' mustbe_exp
    831 		{
    832 		  region->length_exp = $3;
    833 		}
    834 	;
    835 
    836 attributes_opt:
    837 		/* empty */
    838 		  { /* dummy action to avoid bison 1.25 error message */ }
    839 	|	'(' attributes_list ')'
    840 	;
    841 
    842 attributes_list:
    843 		attributes_string
    844 	|	attributes_list attributes_string
    845 	;
    846 
    847 attributes_string:
    848 		NAME
    849 		  { lang_set_flags (region, $1, 0); }
    850 	|	'!' NAME
    851 		  { lang_set_flags (region, $2, 1); }
    852 	;
    853 
    854 startup:
    855 	STARTUP '(' filename ')'
    856 		{ lang_startup($3); }
    857 	;
    858 
    859 high_level_library:
    860 		HLL '(' high_level_library_NAME_list ')'
    861 	|	HLL '(' ')'
    862 			{ ldemul_hll((char *)NULL); }
    863 	;
    864 
    865 high_level_library_NAME_list:
    866 		high_level_library_NAME_list opt_comma filename
    867 			{ ldemul_hll($3); }
    868 	|	filename
    869 			{ ldemul_hll($1); }
    870 
    871 	;
    872 
    873 low_level_library:
    874 	SYSLIB '(' low_level_library_NAME_list ')'
    875 	; low_level_library_NAME_list:
    876 		low_level_library_NAME_list opt_comma filename
    877 			{ ldemul_syslib($3); }
    878 	|
    879 	;
    880 
    881 floating_point_support:
    882 		FLOAT
    883 			{ lang_float(TRUE); }
    884 	|	NOFLOAT
    885 			{ lang_float(FALSE); }
    886 	;
    887 
    888 nocrossref_list:
    889 		/* empty */
    890 		{
    891 		  $$ = NULL;
    892 		}
    893 	|	NAME nocrossref_list
    894 		{
    895 		  struct lang_nocrossref *n;
    896 
    897 		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
    898 		  n->name = $1;
    899 		  n->next = $2;
    900 		  $$ = n;
    901 		}
    902 	|	NAME ',' nocrossref_list
    903 		{
    904 		  struct lang_nocrossref *n;
    905 
    906 		  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
    907 		  n->name = $1;
    908 		  n->next = $3;
    909 		  $$ = n;
    910 		}
    911 	;
    912 
    913 mustbe_exp:		 { ldlex_expression (); }
    914 		exp
    915 			 { ldlex_popstate (); $$=$2;}
    916 	;
    917 
    918 exp	:
    919 		'-' exp %prec UNARY
    920 			{ $$ = exp_unop ('-', $2); }
    921 	|	'(' exp ')'
    922 			{ $$ = $2; }
    923 	|	NEXT '(' exp ')' %prec UNARY
    924 			{ $$ = exp_unop ((int) $1,$3); }
    925 	|	'!' exp %prec UNARY
    926 			{ $$ = exp_unop ('!', $2); }
    927 	|	'+' exp %prec UNARY
    928 			{ $$ = $2; }
    929 	|	'~' exp %prec UNARY
    930 			{ $$ = exp_unop ('~', $2);}
    931 
    932 	|	exp '*' exp
    933 			{ $$ = exp_binop ('*', $1, $3); }
    934 	|	exp '/' exp
    935 			{ $$ = exp_binop ('/', $1, $3); }
    936 	|	exp '%' exp
    937 			{ $$ = exp_binop ('%', $1, $3); }
    938 	|	exp '+' exp
    939 			{ $$ = exp_binop ('+', $1, $3); }
    940 	|	exp '-' exp
    941 			{ $$ = exp_binop ('-' , $1, $3); }
    942 	|	exp LSHIFT exp
    943 			{ $$ = exp_binop (LSHIFT , $1, $3); }
    944 	|	exp RSHIFT exp
    945 			{ $$ = exp_binop (RSHIFT , $1, $3); }
    946 	|	exp EQ exp
    947 			{ $$ = exp_binop (EQ , $1, $3); }
    948 	|	exp NE exp
    949 			{ $$ = exp_binop (NE , $1, $3); }
    950 	|	exp LE exp
    951 			{ $$ = exp_binop (LE , $1, $3); }
    952   	|	exp GE exp
    953 			{ $$ = exp_binop (GE , $1, $3); }
    954 	|	exp '<' exp
    955 			{ $$ = exp_binop ('<' , $1, $3); }
    956 	|	exp '>' exp
    957 			{ $$ = exp_binop ('>' , $1, $3); }
    958 	|	exp '&' exp
    959 			{ $$ = exp_binop ('&' , $1, $3); }
    960 	|	exp '^' exp
    961 			{ $$ = exp_binop ('^' , $1, $3); }
    962 	|	exp '|' exp
    963 			{ $$ = exp_binop ('|' , $1, $3); }
    964 	|	exp '?' exp ':' exp
    965 			{ $$ = exp_trinop ('?' , $1, $3, $5); }
    966 	|	exp ANDAND exp
    967 			{ $$ = exp_binop (ANDAND , $1, $3); }
    968 	|	exp OROR exp
    969 			{ $$ = exp_binop (OROR , $1, $3); }
    970 	|	DEFINED '(' NAME ')'
    971 			{ $$ = exp_nameop (DEFINED, $3); }
    972 	|	INT
    973 			{ $$ = exp_bigintop ($1.integer, $1.str); }
    974         |	SIZEOF_HEADERS
    975 			{ $$ = exp_nameop (SIZEOF_HEADERS,0); }
    976 
    977 	|	ALIGNOF '(' NAME ')'
    978 			{ $$ = exp_nameop (ALIGNOF,$3); }
    979 	|	SIZEOF '(' NAME ')'
    980 			{ $$ = exp_nameop (SIZEOF,$3); }
    981 	|	ADDR '(' NAME ')'
    982 			{ $$ = exp_nameop (ADDR,$3); }
    983 	|	LOADADDR '(' NAME ')'
    984 			{ $$ = exp_nameop (LOADADDR,$3); }
    985 	|	CONSTANT '(' NAME ')'
    986 			{ $$ = exp_nameop (CONSTANT,$3); }
    987 	|	ABSOLUTE '(' exp ')'
    988 			{ $$ = exp_unop (ABSOLUTE, $3); }
    989 	|	ALIGN_K '(' exp ')'
    990 			{ $$ = exp_unop (ALIGN_K,$3); }
    991 	|	ALIGN_K '(' exp ',' exp ')'
    992 			{ $$ = exp_binop (ALIGN_K,$3,$5); }
    993 	|	DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
    994 			{ $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
    995 	|	DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
    996 			{ $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
    997 	|	DATA_SEGMENT_END '(' exp ')'
    998 			{ $$ = exp_unop (DATA_SEGMENT_END, $3); }
    999         |       SEGMENT_START '(' NAME ',' exp ')'
   1000                         { /* The operands to the expression node are
   1001 			     placed in the opposite order from the way
   1002 			     in which they appear in the script as
   1003 			     that allows us to reuse more code in
   1004 			     fold_binary.  */
   1005 			  $$ = exp_binop (SEGMENT_START,
   1006 					  $5,
   1007 					  exp_nameop (NAME, $3)); }
   1008 	|	BLOCK '(' exp ')'
   1009 			{ $$ = exp_unop (ALIGN_K,$3); }
   1010 	|	NAME
   1011 			{ $$ = exp_nameop (NAME,$1); }
   1012 	|	MAX_K '(' exp ',' exp ')'
   1013 			{ $$ = exp_binop (MAX_K, $3, $5 ); }
   1014 	|	MIN_K '(' exp ',' exp ')'
   1015 			{ $$ = exp_binop (MIN_K, $3, $5 ); }
   1016 	|	ASSERT_K '(' exp ',' NAME ')'
   1017 			{ $$ = exp_assert ($3, $5); }
   1018 	|	ORIGIN '(' NAME ')'
   1019 			{ $$ = exp_nameop (ORIGIN, $3); }
   1020 	|	LENGTH '(' NAME ')'
   1021 			{ $$ = exp_nameop (LENGTH, $3); }
   1022 	|	LOG2CEIL '(' exp ')'
   1023 			{ $$ = exp_unop (LOG2CEIL, $3); }
   1024 	;
   1025 
   1026 
   1027 memspec_at_opt:
   1028                 AT '>' NAME { $$ = $3; }
   1029         |       { $$ = 0; }
   1030         ;
   1031 
   1032 opt_at:
   1033 		AT '(' exp ')' { $$ = $3; }
   1034 	|	{ $$ = 0; }
   1035 	;
   1036 
   1037 opt_align:
   1038 		ALIGN_K '(' exp ')' { $$ = $3; }
   1039 	|	{ $$ = 0; }
   1040 	;
   1041 
   1042 opt_align_with_input:
   1043 		ALIGN_WITH_INPUT { $$ = ALIGN_WITH_INPUT; }
   1044 	|	{ $$ = 0; }
   1045 	;
   1046 
   1047 opt_subalign:
   1048 		SUBALIGN '(' exp ')' { $$ = $3; }
   1049 	|	{ $$ = 0; }
   1050 	;
   1051 
   1052 sect_constraint:
   1053 		ONLY_IF_RO { $$ = ONLY_IF_RO; }
   1054 	|	ONLY_IF_RW { $$ = ONLY_IF_RW; }
   1055 	|	SPECIAL { $$ = SPECIAL; }
   1056 	|	{ $$ = 0; }
   1057 	;
   1058 
   1059 section:	NAME 		{ ldlex_expression(); }
   1060 		opt_exp_with_type
   1061 		opt_at
   1062 		opt_align
   1063 		opt_align_with_input
   1064 		opt_subalign	{ ldlex_popstate (); ldlex_script (); }
   1065 		sect_constraint
   1066 		'{'
   1067 			{
   1068 			  lang_enter_output_section_statement($1, $3,
   1069 							      sectype,
   1070 							      $5, $7, $4, $9, $6);
   1071 			}
   1072 		statement_list_opt
   1073  		'}' { ldlex_popstate (); ldlex_expression (); }
   1074 		memspec_opt memspec_at_opt phdr_opt fill_opt
   1075 		{
   1076 		  ldlex_popstate ();
   1077 		  lang_leave_output_section_statement ($18, $15, $17, $16);
   1078 		}
   1079 		opt_comma
   1080 		{}
   1081 	|	OVERLAY
   1082 			{ ldlex_expression (); }
   1083 		opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
   1084 			{ ldlex_popstate (); ldlex_script (); }
   1085 		'{'
   1086 			{
   1087 			  lang_enter_overlay ($3, $6);
   1088 			}
   1089 		overlay_section
   1090 		'}'
   1091 			{ ldlex_popstate (); ldlex_expression (); }
   1092 		memspec_opt memspec_at_opt phdr_opt fill_opt
   1093 			{
   1094 			  ldlex_popstate ();
   1095 			  lang_leave_overlay ($5, (int) $4,
   1096 					      $16, $13, $15, $14);
   1097 			}
   1098 		opt_comma
   1099 	|	/* The GROUP case is just enough to support the gcc
   1100 		   svr3.ifile script.  It is not intended to be full
   1101 		   support.  I'm not even sure what GROUP is supposed
   1102 		   to mean.  */
   1103 		GROUP { ldlex_expression (); }
   1104 		opt_exp_with_type
   1105 		{
   1106 		  ldlex_popstate ();
   1107 		  lang_add_assignment (exp_assign (".", $3, FALSE));
   1108 		}
   1109 		'{' sec_or_group_p1 '}'
   1110 	|	INCLUDE filename
   1111 		{ ldlex_script (); ldfile_open_command_file($2); }
   1112 		sec_or_group_p1 END
   1113 		{ ldlex_popstate (); }
   1114 	;
   1115 
   1116 type:
   1117 	   NOLOAD  { sectype = noload_section; }
   1118 	|  DSECT   { sectype = noalloc_section; }
   1119 	|  COPY    { sectype = noalloc_section; }
   1120 	|  INFO    { sectype = noalloc_section; }
   1121 	|  OVERLAY { sectype = noalloc_section; }
   1122 	;
   1123 
   1124 atype:
   1125 	 	'(' type ')'
   1126   	| 	/* EMPTY */ { sectype = normal_section; }
   1127   	| 	'(' ')' { sectype = normal_section; }
   1128 	;
   1129 
   1130 opt_exp_with_type:
   1131 		exp atype ':'		{ $$ = $1; }
   1132 	|	atype ':'		{ $$ = (etree_type *)NULL;  }
   1133 	|	/* The BIND cases are to support the gcc svr3.ifile
   1134 		   script.  They aren't intended to implement full
   1135 		   support for the BIND keyword.  I'm not even sure
   1136 		   what BIND is supposed to mean.  */
   1137 		BIND '(' exp ')' atype ':' { $$ = $3; }
   1138 	|	BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
   1139 		{ $$ = $3; }
   1140 	;
   1141 
   1142 opt_exp_without_type:
   1143 		exp ':'		{ $$ = $1; }
   1144 	|	':'		{ $$ = (etree_type *) NULL;  }
   1145 	;
   1146 
   1147 opt_nocrossrefs:
   1148 		/* empty */
   1149 			{ $$ = 0; }
   1150 	|	NOCROSSREFS
   1151 			{ $$ = 1; }
   1152 	;
   1153 
   1154 memspec_opt:
   1155 		'>' NAME
   1156 		{ $$ = $2; }
   1157 	|	{ $$ = DEFAULT_MEMORY_REGION; }
   1158 	;
   1159 
   1160 phdr_opt:
   1161 		/* empty */
   1162 		{
   1163 		  $$ = NULL;
   1164 		}
   1165 	|	phdr_opt ':' NAME
   1166 		{
   1167 		  struct lang_output_section_phdr_list *n;
   1168 
   1169 		  n = ((struct lang_output_section_phdr_list *)
   1170 		       xmalloc (sizeof *n));
   1171 		  n->name = $3;
   1172 		  n->used = FALSE;
   1173 		  n->next = $1;
   1174 		  $$ = n;
   1175 		}
   1176 	;
   1177 
   1178 overlay_section:
   1179 		/* empty */
   1180 	|	overlay_section
   1181 		NAME
   1182 			{
   1183 			  ldlex_script ();
   1184 			  lang_enter_overlay_section ($2);
   1185 			}
   1186 		'{' statement_list_opt '}'
   1187 			{ ldlex_popstate (); ldlex_expression (); }
   1188 		phdr_opt fill_opt
   1189 			{
   1190 			  ldlex_popstate ();
   1191 			  lang_leave_overlay_section ($9, $8);
   1192 			}
   1193 		opt_comma
   1194 	;
   1195 
   1196 phdrs:
   1197 		PHDRS '{' phdr_list '}'
   1198 	;
   1199 
   1200 phdr_list:
   1201 		/* empty */
   1202 	|	phdr_list phdr
   1203 	;
   1204 
   1205 phdr:
   1206 		NAME { ldlex_expression (); }
   1207 		  phdr_type phdr_qualifiers { ldlex_popstate (); }
   1208 		  ';'
   1209 		{
   1210 		  lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
   1211 				 $4.flags);
   1212 		}
   1213 	;
   1214 
   1215 phdr_type:
   1216 		exp
   1217 		{
   1218 		  $$ = $1;
   1219 
   1220 		  if ($1->type.node_class == etree_name
   1221 		      && $1->type.node_code == NAME)
   1222 		    {
   1223 		      const char *s;
   1224 		      unsigned int i;
   1225 		      static const char * const phdr_types[] =
   1226 			{
   1227 			  "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
   1228 			  "PT_INTERP", "PT_NOTE", "PT_SHLIB",
   1229 			  "PT_PHDR", "PT_TLS"
   1230 			};
   1231 
   1232 		      s = $1->name.name;
   1233 		      for (i = 0;
   1234 			   i < sizeof phdr_types / sizeof phdr_types[0];
   1235 			   i++)
   1236 			if (strcmp (s, phdr_types[i]) == 0)
   1237 			  {
   1238 			    $$ = exp_intop (i);
   1239 			    break;
   1240 			  }
   1241 		      if (i == sizeof phdr_types / sizeof phdr_types[0])
   1242 			{
   1243 			  if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
   1244 			    $$ = exp_intop (0x6474e550);
   1245 			  else if (strcmp (s, "PT_GNU_STACK") == 0)
   1246 			    $$ = exp_intop (0x6474e551);
   1247 			  else
   1248 			    {
   1249 			      einfo (_("\
   1250 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
   1251 				     NULL, s);
   1252 			      $$ = exp_intop (0);
   1253 			    }
   1254 			}
   1255 		    }
   1256 		}
   1257 	;
   1258 
   1259 phdr_qualifiers:
   1260 		/* empty */
   1261 		{
   1262 		  memset (&$$, 0, sizeof (struct phdr_info));
   1263 		}
   1264 	|	NAME phdr_val phdr_qualifiers
   1265 		{
   1266 		  $$ = $3;
   1267 		  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
   1268 		    $$.filehdr = TRUE;
   1269 		  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
   1270 		    $$.phdrs = TRUE;
   1271 		  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
   1272 		    $$.flags = $2;
   1273 		  else
   1274 		    einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"),
   1275 			   NULL, $1);
   1276 		}
   1277 	|	AT '(' exp ')' phdr_qualifiers
   1278 		{
   1279 		  $$ = $5;
   1280 		  $$.at = $3;
   1281 		}
   1282 	;
   1283 
   1284 phdr_val:
   1285 		/* empty */
   1286 		{
   1287 		  $$ = NULL;
   1288 		}
   1289 	| '(' exp ')'
   1290 		{
   1291 		  $$ = $2;
   1292 		}
   1293 	;
   1294 
   1295 dynamic_list_file:
   1296 		{
   1297 		  ldlex_version_file ();
   1298 		  PUSH_ERROR (_("dynamic list"));
   1299 		}
   1300 		dynamic_list_nodes
   1301 		{
   1302 		  ldlex_popstate ();
   1303 		  POP_ERROR ();
   1304 		}
   1305 	;
   1306 
   1307 dynamic_list_nodes:
   1308 		dynamic_list_node
   1309 	|	dynamic_list_nodes dynamic_list_node
   1310 	;
   1311 
   1312 dynamic_list_node:
   1313 		'{' dynamic_list_tag '}' ';'
   1314 	;
   1315 
   1316 dynamic_list_tag:
   1317 		vers_defns ';'
   1318 		{
   1319 		  lang_append_dynamic_list ($1);
   1320 		}
   1321 	;
   1322 
   1323 /* This syntax is used within an external version script file.  */
   1324 
   1325 version_script_file:
   1326 		{
   1327 		  ldlex_version_file ();
   1328 		  PUSH_ERROR (_("VERSION script"));
   1329 		}
   1330 		vers_nodes
   1331 		{
   1332 		  ldlex_popstate ();
   1333 		  POP_ERROR ();
   1334 		}
   1335 	;
   1336 
   1337 /* This is used within a normal linker script file.  */
   1338 
   1339 version:
   1340 		{
   1341 		  ldlex_version_script ();
   1342 		}
   1343 		VERSIONK '{' vers_nodes '}'
   1344 		{
   1345 		  ldlex_popstate ();
   1346 		}
   1347 	;
   1348 
   1349 vers_nodes:
   1350 		vers_node
   1351 	|	vers_nodes vers_node
   1352 	;
   1353 
   1354 vers_node:
   1355 		'{' vers_tag '}' ';'
   1356 		{
   1357 		  lang_register_vers_node (NULL, $2, NULL);
   1358 		}
   1359 	|	VERS_TAG '{' vers_tag '}' ';'
   1360 		{
   1361 		  lang_register_vers_node ($1, $3, NULL);
   1362 		}
   1363 	|	VERS_TAG '{' vers_tag '}' verdep ';'
   1364 		{
   1365 		  lang_register_vers_node ($1, $3, $5);
   1366 		}
   1367 	;
   1368 
   1369 verdep:
   1370 		VERS_TAG
   1371 		{
   1372 		  $$ = lang_add_vers_depend (NULL, $1);
   1373 		}
   1374 	|	verdep VERS_TAG
   1375 		{
   1376 		  $$ = lang_add_vers_depend ($1, $2);
   1377 		}
   1378 	;
   1379 
   1380 vers_tag:
   1381 		/* empty */
   1382 		{
   1383 		  $$ = lang_new_vers_node (NULL, NULL);
   1384 		}
   1385 	|	vers_defns ';'
   1386 		{
   1387 		  $$ = lang_new_vers_node ($1, NULL);
   1388 		}
   1389 	|	GLOBAL ':' vers_defns ';'
   1390 		{
   1391 		  $$ = lang_new_vers_node ($3, NULL);
   1392 		}
   1393 	|	LOCAL ':' vers_defns ';'
   1394 		{
   1395 		  $$ = lang_new_vers_node (NULL, $3);
   1396 		}
   1397 	|	GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
   1398 		{
   1399 		  $$ = lang_new_vers_node ($3, $7);
   1400 		}
   1401 	;
   1402 
   1403 vers_defns:
   1404 		VERS_IDENTIFIER
   1405 		{
   1406 		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
   1407 		}
   1408         |       NAME
   1409 		{
   1410 		  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
   1411 		}
   1412 	|	vers_defns ';' VERS_IDENTIFIER
   1413 		{
   1414 		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
   1415 		}
   1416 	|	vers_defns ';' NAME
   1417 		{
   1418 		  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
   1419 		}
   1420 	|	vers_defns ';' EXTERN NAME '{'
   1421 			{
   1422 			  $<name>$ = ldgram_vers_current_lang;
   1423 			  ldgram_vers_current_lang = $4;
   1424 			}
   1425 		vers_defns opt_semicolon '}'
   1426 			{
   1427 			  struct bfd_elf_version_expr *pat;
   1428 			  for (pat = $7; pat->next != NULL; pat = pat->next);
   1429 			  pat->next = $1;
   1430 			  $$ = $7;
   1431 			  ldgram_vers_current_lang = $<name>6;
   1432 			}
   1433 	|	EXTERN NAME '{'
   1434 			{
   1435 			  $<name>$ = ldgram_vers_current_lang;
   1436 			  ldgram_vers_current_lang = $2;
   1437 			}
   1438 		vers_defns opt_semicolon '}'
   1439 			{
   1440 			  $$ = $5;
   1441 			  ldgram_vers_current_lang = $<name>4;
   1442 			}
   1443 	|	GLOBAL
   1444 		{
   1445 		  $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
   1446 		}
   1447 	|	vers_defns ';' GLOBAL
   1448 		{
   1449 		  $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
   1450 		}
   1451 	|	LOCAL
   1452 		{
   1453 		  $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
   1454 		}
   1455 	|	vers_defns ';' LOCAL
   1456 		{
   1457 		  $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
   1458 		}
   1459 	|	EXTERN
   1460 		{
   1461 		  $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
   1462 		}
   1463 	|	vers_defns ';' EXTERN
   1464 		{
   1465 		  $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
   1466 		}
   1467 	;
   1468 
   1469 opt_semicolon:
   1470 		/* empty */
   1471 	|	';'
   1472 	;
   1473 
   1474 %%
   1475 void
   1476 yyerror(arg)
   1477      const char *arg;
   1478 {
   1479   if (ldfile_assumed_script)
   1480     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
   1481 	   ldlex_filename ());
   1482   if (error_index > 0 && error_index < ERROR_NAME_MAX)
   1483     einfo ("%P%F:%S: %s in %s\n", NULL, arg, error_names[error_index - 1]);
   1484   else
   1485     einfo ("%P%F:%S: %s\n", NULL, arg);
   1486 }
   1487