* ldgram.y (DATA_SEGMENT_RELRO_END): Add one argument.
[external/binutils.git] / ld / ldgram.y
1 /* A YACC grammar to parse a superset of the AT&T linker scripting language.
2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003 Free Software Foundation, Inc.
4    Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
5
6 This file is part of GNU ld.
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 %{
23 /*
24
25  */
26
27 #define DONTDECLARE_MALLOC
28
29 #include "bfd.h"
30 #include "sysdep.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
50 lang_memory_region_type *region;
51
52 bfd_boolean ldgram_want_filename = TRUE;
53 FILE *saved_script_handle = NULL;
54 bfd_boolean force_make_executable = FALSE;
55
56 bfd_boolean ldgram_in_script = FALSE;
57 bfd_boolean ldgram_had_equals = FALSE;
58 bfd_boolean ldgram_had_keep = FALSE;
59 char *ldgram_vers_current_lang = NULL;
60
61 #define ERROR_NAME_MAX 20
62 static char *error_names[ERROR_NAME_MAX];
63 static int error_index;
64 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
65 #define POP_ERROR()   error_index--;
66 %}
67 %union {
68   bfd_vma integer;
69   struct big_int
70     {
71       bfd_vma integer;
72       char *str;
73     } bigint;
74   fill_type *fill;
75   char *name;
76   const char *cname;
77   struct wildcard_spec wildcard;
78   struct wildcard_list *wildcard_list;
79   struct name_list *name_list;
80   int token;
81   union etree_union *etree;
82   struct phdr_info
83     {
84       bfd_boolean filehdr;
85       bfd_boolean phdrs;
86       union etree_union *at;
87       union etree_union *flags;
88     } phdr;
89   struct lang_nocrossref *nocrossref;
90   struct lang_output_section_phdr_list *section_phdr;
91   struct bfd_elf_version_deps *deflist;
92   struct bfd_elf_version_expr *versyms;
93   struct bfd_elf_version_tree *versnode;
94 }
95
96 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
97 %type <etree> opt_exp_without_type opt_subalign
98 %type <fill> fill_opt fill_exp
99 %type <name_list> exclude_name_list
100 %type <wildcard_list> file_NAME_list
101 %type <name> memspec_opt casesymlist
102 %type <name> memspec_at_opt
103 %type <cname> wildcard_name
104 %type <wildcard> wildcard_spec
105 %token <bigint> INT
106 %token <name> NAME LNAME
107 %type <integer> length
108 %type <phdr> phdr_qualifiers
109 %type <nocrossref> nocrossref_list
110 %type <section_phdr> phdr_opt
111 %type <integer> opt_nocrossrefs
112
113 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
114 %right <token> '?' ':'
115 %left <token> OROR
116 %left <token>  ANDAND
117 %left <token> '|'
118 %left <token>  '^'
119 %left  <token> '&'
120 %left <token>  EQ NE
121 %left  <token> '<' '>' LE GE
122 %left  <token> LSHIFT RSHIFT
123
124 %left  <token> '+' '-'
125 %left  <token> '*' '/' '%'
126
127 %right UNARY
128 %token END
129 %left <token> '('
130 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
131 %token SECTIONS PHDRS SORT DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
132 %token '{' '}'
133 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
134 %token INHIBIT_COMMON_ALLOCATION
135 %token SIZEOF_HEADERS
136 %token INCLUDE
137 %token MEMORY DEFSYMEND
138 %token NOLOAD DSECT COPY INFO OVERLAY
139 %token NAME LNAME DEFINED TARGET_K SEARCH_DIR MAP ENTRY
140 %token <integer> NEXT
141 %token SIZEOF ADDR LOADADDR MAX_K MIN_K
142 %token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
143 %token ORIGIN FILL
144 %token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
145 %token ALIGNMOD AT SUBALIGN PROVIDE
146 %type <token> assign_op atype attributes_opt sect_constraint
147 %type <name>  filename
148 %token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
149 %token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
150 %token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
151 %token <name> VERS_TAG VERS_IDENTIFIER
152 %token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
153 %token KEEP ONLY_IF_RO ONLY_IF_RW
154 %token EXCLUDE_FILE
155 %type <versyms> vers_defns
156 %type <versnode> vers_tag
157 %type <deflist> verdep
158
159 %%
160
161 file:
162                 INPUT_SCRIPT script_file
163         |       INPUT_MRI_SCRIPT mri_script_file
164         |       INPUT_VERSION_SCRIPT version_script_file
165         |       INPUT_DEFSYM defsym_expr
166         ;
167
168
169 filename:  NAME;
170
171
172 defsym_expr:
173                 { ldlex_defsym(); }
174                 NAME '=' exp
175                 {
176                   ldlex_popstate();
177                   lang_add_assignment(exp_assop($3,$2,$4));
178                 }
179         ;
180
181 /* SYNTAX WITHIN AN MRI SCRIPT FILE */
182 mri_script_file:
183                 {
184                   ldlex_mri_script ();
185                   PUSH_ERROR (_("MRI style script"));
186                 }
187              mri_script_lines
188                 {
189                   ldlex_popstate ();
190                   mri_draw_tree ();
191                   POP_ERROR ();
192                 }
193         ;
194
195 mri_script_lines:
196                 mri_script_lines mri_script_command NEWLINE
197           |
198         ;
199
200 mri_script_command:
201                 CHIP  exp
202         |       CHIP  exp ',' exp
203         |       NAME    {
204                         einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
205                         }
206         |       LIST    {
207                         config.map_filename = "-";
208                         }
209         |       ORDER ordernamelist
210         |       ENDWORD
211         |       PUBLIC NAME '=' exp
212                         { mri_public($2, $4); }
213         |       PUBLIC NAME ',' exp
214                         { mri_public($2, $4); }
215         |       PUBLIC NAME  exp
216                         { mri_public($2, $3); }
217         |       FORMAT NAME
218                         { mri_format($2); }
219         |       SECT NAME ',' exp
220                         { mri_output_section($2, $4);}
221         |       SECT NAME  exp
222                         { mri_output_section($2, $3);}
223         |       SECT NAME '=' exp
224                         { mri_output_section($2, $4);}
225         |       ALIGN_K NAME '=' exp
226                         { mri_align($2,$4); }
227         |       ALIGN_K NAME ',' exp
228                         { mri_align($2,$4); }
229         |       ALIGNMOD NAME '=' exp
230                         { mri_alignmod($2,$4); }
231         |       ALIGNMOD NAME ',' exp
232                         { mri_alignmod($2,$4); }
233         |       ABSOLUTE mri_abs_name_list
234         |       LOAD     mri_load_name_list
235         |       NAMEWORD NAME
236                         { mri_name($2); }
237         |       ALIAS NAME ',' NAME
238                         { mri_alias($2,$4,0);}
239         |       ALIAS NAME ',' INT
240                         { mri_alias ($2, 0, (int) $4.integer); }
241         |       BASE     exp
242                         { mri_base($2); }
243         |       TRUNCATE INT
244                 { mri_truncate ((unsigned int) $2.integer); }
245         |       CASE casesymlist
246         |       EXTERN extern_name_list
247         |       INCLUDE filename
248                 { ldlex_script (); ldfile_open_command_file($2); }
249                 mri_script_lines END
250                 { ldlex_popstate (); }
251         |       START NAME
252                 { lang_add_entry ($2, FALSE); }
253         |
254         ;
255
256 ordernamelist:
257               ordernamelist ',' NAME         { mri_order($3); }
258         |     ordernamelist  NAME         { mri_order($2); }
259         |
260         ;
261
262 mri_load_name_list:
263                 NAME
264                         { mri_load($1); }
265         |       mri_load_name_list ',' NAME { mri_load($3); }
266         ;
267
268 mri_abs_name_list:
269                 NAME
270                         { mri_only_load($1); }
271         |       mri_abs_name_list ','  NAME
272                         { mri_only_load($3); }
273         ;
274
275 casesymlist:
276           /* empty */ { $$ = NULL; }
277         | NAME
278         | casesymlist ',' NAME
279         ;
280
281 extern_name_list:
282           NAME
283                         { ldlang_add_undef ($1); }
284         | extern_name_list NAME
285                         { ldlang_add_undef ($2); }
286         | extern_name_list ',' NAME
287                         { ldlang_add_undef ($3); }
288         ;
289
290 script_file:
291         {
292          ldlex_both();
293         }
294        ifile_list
295         {
296         ldlex_popstate();
297         }
298         ;
299
300
301 ifile_list:
302        ifile_list ifile_p1
303         |
304         ;
305
306
307
308 ifile_p1:
309                 memory
310         |       sections
311         |       phdrs
312         |       startup
313         |       high_level_library
314         |       low_level_library
315         |       floating_point_support
316         |       statement_anywhere
317         |       version
318         |        ';'
319         |       TARGET_K '(' NAME ')'
320                 { lang_add_target($3); }
321         |       SEARCH_DIR '(' filename ')'
322                 { ldfile_add_library_path ($3, FALSE); }
323         |       OUTPUT '(' filename ')'
324                 { lang_add_output($3, 1); }
325         |       OUTPUT_FORMAT '(' NAME ')'
326                   { lang_add_output_format ($3, (char *) NULL,
327                                             (char *) NULL, 1); }
328         |       OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
329                   { lang_add_output_format ($3, $5, $7, 1); }
330         |       OUTPUT_ARCH '(' NAME ')'
331                   { ldfile_set_output_arch ($3, bfd_arch_unknown); }
332         |       FORCE_COMMON_ALLOCATION
333                 { command_line.force_common_definition = TRUE ; }
334         |       INHIBIT_COMMON_ALLOCATION
335                 { command_line.inhibit_common_definition = TRUE ; }
336         |       INPUT '(' input_list ')'
337         |       GROUP
338                   { lang_enter_group (); }
339                     '(' input_list ')'
340                   { lang_leave_group (); }
341         |       MAP '(' filename ')'
342                 { lang_add_map($3); }
343         |       INCLUDE filename
344                 { ldlex_script (); ldfile_open_command_file($2); }
345                 ifile_list END
346                 { ldlex_popstate (); }
347         |       NOCROSSREFS '(' nocrossref_list ')'
348                 {
349                   lang_add_nocrossref ($3);
350                 }
351         |       EXTERN '(' extern_name_list ')'
352         ;
353
354 input_list:
355                 NAME
356                 { lang_add_input_file($1,lang_input_file_is_search_file_enum,
357                                  (char *)NULL); }
358         |       input_list ',' NAME
359                 { lang_add_input_file($3,lang_input_file_is_search_file_enum,
360                                  (char *)NULL); }
361         |       input_list NAME
362                 { lang_add_input_file($2,lang_input_file_is_search_file_enum,
363                                  (char *)NULL); }
364         |       LNAME
365                 { lang_add_input_file($1,lang_input_file_is_l_enum,
366                                  (char *)NULL); }
367         |       input_list ',' LNAME
368                 { lang_add_input_file($3,lang_input_file_is_l_enum,
369                                  (char *)NULL); }
370         |       input_list LNAME
371                 { lang_add_input_file($2,lang_input_file_is_l_enum,
372                                  (char *)NULL); }
373         ;
374
375 sections:
376                 SECTIONS '{' sec_or_group_p1 '}'
377         ;
378
379 sec_or_group_p1:
380                 sec_or_group_p1 section
381         |       sec_or_group_p1 statement_anywhere
382         |
383         ;
384
385 statement_anywhere:
386                 ENTRY '(' NAME ')'
387                 { lang_add_entry ($3, FALSE); }
388         |       assignment end
389         |       ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
390                 { ldlex_popstate ();
391                   lang_add_assignment (exp_assert ($4, $6)); }
392         ;
393
394 /* The '*' and '?' cases are there because the lexer returns them as
395    separate tokens rather than as NAME.  */
396 wildcard_name:
397                 NAME
398                         {
399                           $$ = $1;
400                         }
401         |       '*'
402                         {
403                           $$ = "*";
404                         }
405         |       '?'
406                         {
407                           $$ = "?";
408                         }
409         ;
410
411 wildcard_spec:
412                 wildcard_name
413                         {
414                           $$.name = $1;
415                           $$.sorted = FALSE;
416                           $$.exclude_name_list = NULL;
417                         }
418         |       EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
419                         {
420                           $$.name = $5;
421                           $$.sorted = FALSE;
422                           $$.exclude_name_list = $3;
423                         }
424         |       SORT '(' wildcard_name ')'
425                         {
426                           $$.name = $3;
427                           $$.sorted = TRUE;
428                           $$.exclude_name_list = NULL;
429                         }
430         |       SORT '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
431                         {
432                           $$.name = $7;
433                           $$.sorted = TRUE;
434                           $$.exclude_name_list = $5;
435                         }
436         ;
437
438 exclude_name_list:
439                 exclude_name_list wildcard_name
440                         {
441                           struct name_list *tmp;
442                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
443                           tmp->name = $2;
444                           tmp->next = $1;
445                           $$ = tmp;
446                         }
447         |
448                 wildcard_name
449                         {
450                           struct name_list *tmp;
451                           tmp = (struct name_list *) xmalloc (sizeof *tmp);
452                           tmp->name = $1;
453                           tmp->next = NULL;
454                           $$ = tmp;
455                         }
456         ;
457
458 file_NAME_list:
459                 file_NAME_list opt_comma wildcard_spec
460                         {
461                           struct wildcard_list *tmp;
462                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
463                           tmp->next = $1;
464                           tmp->spec = $3;
465                           $$ = tmp;
466                         }
467         |
468                 wildcard_spec
469                         {
470                           struct wildcard_list *tmp;
471                           tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
472                           tmp->next = NULL;
473                           tmp->spec = $1;
474                           $$ = tmp;
475                         }
476         ;
477
478 input_section_spec_no_keep:
479                 NAME
480                         {
481                           struct wildcard_spec tmp;
482                           tmp.name = $1;
483                           tmp.exclude_name_list = NULL;
484                           tmp.sorted = FALSE;
485                           lang_add_wild (&tmp, NULL, ldgram_had_keep);
486                         }
487         |       '[' file_NAME_list ']'
488                         {
489                           lang_add_wild (NULL, $2, ldgram_had_keep);
490                         }
491         |       wildcard_spec '(' file_NAME_list ')'
492                         {
493                           lang_add_wild (&$1, $3, ldgram_had_keep);
494                         }
495         ;
496
497 input_section_spec:
498                 input_section_spec_no_keep
499         |       KEEP '('
500                         { ldgram_had_keep = TRUE; }
501                 input_section_spec_no_keep ')'
502                         { ldgram_had_keep = FALSE; }
503         ;
504
505 statement:
506                 assignment end
507         |       CREATE_OBJECT_SYMBOLS
508                 {
509                 lang_add_attribute(lang_object_symbols_statement_enum);
510                 }
511         |       ';'
512         |       CONSTRUCTORS
513                 {
514
515                   lang_add_attribute(lang_constructors_statement_enum);
516                 }
517         | SORT '(' CONSTRUCTORS ')'
518                 {
519                   constructors_sorted = TRUE;
520                   lang_add_attribute (lang_constructors_statement_enum);
521                 }
522         | input_section_spec
523         | length '(' mustbe_exp ')'
524                         {
525                           lang_add_data ((int) $1, $3);
526                         }
527
528         | FILL '(' fill_exp ')'
529                         {
530                           lang_add_fill ($3);
531                         }
532         ;
533
534 statement_list:
535                 statement_list statement
536         |       statement
537         ;
538
539 statement_list_opt:
540                 /* empty */
541         |       statement_list
542         ;
543
544 length:
545                 QUAD
546                         { $$ = $1; }
547         |       SQUAD
548                         { $$ = $1; }
549         |       LONG
550                         { $$ = $1; }
551         |       SHORT
552                         { $$ = $1; }
553         |       BYTE
554                         { $$ = $1; }
555         ;
556
557 fill_exp:
558         mustbe_exp
559                 {
560                   $$ = exp_get_fill ($1,
561                                      0,
562                                      "fill value",
563                                      lang_first_phase_enum);
564                 }
565         ;
566
567 fill_opt:
568           '=' fill_exp
569                 { $$ = $2; }
570         |       { $$ = (fill_type *) 0; }
571         ;
572
573 assign_op:
574                 PLUSEQ
575                         { $$ = '+'; }
576         |       MINUSEQ
577                         { $$ = '-'; }
578         |       MULTEQ
579                         { $$ = '*'; }
580         |       DIVEQ
581                         { $$ = '/'; }
582         |       LSHIFTEQ
583                         { $$ = LSHIFT; }
584         |       RSHIFTEQ
585                         { $$ = RSHIFT; }
586         |       ANDEQ
587                         { $$ = '&'; }
588         |       OREQ
589                         { $$ = '|'; }
590
591         ;
592
593 end:    ';' | ','
594         ;
595
596
597 assignment:
598                 NAME '=' mustbe_exp
599                 {
600                   lang_add_assignment (exp_assop ($2, $1, $3));
601                 }
602         |       NAME assign_op mustbe_exp
603                 {
604                   lang_add_assignment (exp_assop ('=', $1,
605                                                   exp_binop ($2,
606                                                              exp_nameop (NAME,
607                                                                          $1),
608                                                              $3)));
609                 }
610         |       PROVIDE '(' NAME '=' mustbe_exp ')'
611                 {
612                   lang_add_assignment (exp_provide ($3, $5));
613                 }
614         ;
615
616
617 opt_comma:
618                 ','     |       ;
619
620
621 memory:
622                 MEMORY '{' memory_spec memory_spec_list '}'
623         ;
624
625 memory_spec_list:
626                 memory_spec_list memory_spec
627         |       memory_spec_list ',' memory_spec
628         |
629         ;
630
631
632 memory_spec:    NAME
633                 { region = lang_memory_region_lookup ($1, TRUE); }
634                 attributes_opt ':'
635                 origin_spec opt_comma length_spec
636                 {}
637         ;
638
639 origin_spec:
640         ORIGIN '=' mustbe_exp
641                 { region->current =
642                  region->origin =
643                  exp_get_vma($3, 0L,"origin", lang_first_phase_enum);
644 }
645         ;
646
647 length_spec:
648              LENGTH '=' mustbe_exp
649                { region->length = exp_get_vma($3,
650                                                ~((bfd_vma)0),
651                                                "length",
652                                                lang_first_phase_enum);
653                 }
654         ;
655
656 attributes_opt:
657                 /* empty */
658                   { /* dummy action to avoid bison 1.25 error message */ }
659         |       '(' attributes_list ')'
660         ;
661
662 attributes_list:
663                 attributes_string
664         |       attributes_list attributes_string
665         ;
666
667 attributes_string:
668                 NAME
669                   { lang_set_flags (region, $1, 0); }
670         |       '!' NAME
671                   { lang_set_flags (region, $2, 1); }
672         ;
673
674 startup:
675         STARTUP '(' filename ')'
676                 { lang_startup($3); }
677         ;
678
679 high_level_library:
680                 HLL '(' high_level_library_NAME_list ')'
681         |       HLL '(' ')'
682                         { ldemul_hll((char *)NULL); }
683         ;
684
685 high_level_library_NAME_list:
686                 high_level_library_NAME_list opt_comma filename
687                         { ldemul_hll($3); }
688         |       filename
689                         { ldemul_hll($1); }
690
691         ;
692
693 low_level_library:
694         SYSLIB '(' low_level_library_NAME_list ')'
695         ; low_level_library_NAME_list:
696                 low_level_library_NAME_list opt_comma filename
697                         { ldemul_syslib($3); }
698         |
699         ;
700
701 floating_point_support:
702                 FLOAT
703                         { lang_float(TRUE); }
704         |       NOFLOAT
705                         { lang_float(FALSE); }
706         ;
707
708 nocrossref_list:
709                 /* empty */
710                 {
711                   $$ = NULL;
712                 }
713         |       NAME nocrossref_list
714                 {
715                   struct lang_nocrossref *n;
716
717                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
718                   n->name = $1;
719                   n->next = $2;
720                   $$ = n;
721                 }
722         |       NAME ',' nocrossref_list
723                 {
724                   struct lang_nocrossref *n;
725
726                   n = (struct lang_nocrossref *) xmalloc (sizeof *n);
727                   n->name = $1;
728                   n->next = $3;
729                   $$ = n;
730                 }
731         ;
732
733 mustbe_exp:              { ldlex_expression(); }
734                 exp
735                          { ldlex_popstate(); $$=$2;}
736         ;
737
738 exp     :
739                 '-' exp %prec UNARY
740                         { $$ = exp_unop('-', $2); }
741         |       '(' exp ')'
742                         { $$ = $2; }
743         |       NEXT '(' exp ')' %prec UNARY
744                         { $$ = exp_unop((int) $1,$3); }
745         |       '!' exp %prec UNARY
746                         { $$ = exp_unop('!', $2); }
747         |       '+' exp %prec UNARY
748                         { $$ = $2; }
749         |       '~' exp %prec UNARY
750                         { $$ = exp_unop('~', $2);}
751
752         |       exp '*' exp
753                         { $$ = exp_binop('*', $1, $3); }
754         |       exp '/' exp
755                         { $$ = exp_binop('/', $1, $3); }
756         |       exp '%' exp
757                         { $$ = exp_binop('%', $1, $3); }
758         |       exp '+' exp
759                         { $$ = exp_binop('+', $1, $3); }
760         |       exp '-' exp
761                         { $$ = exp_binop('-' , $1, $3); }
762         |       exp LSHIFT exp
763                         { $$ = exp_binop(LSHIFT , $1, $3); }
764         |       exp RSHIFT exp
765                         { $$ = exp_binop(RSHIFT , $1, $3); }
766         |       exp EQ exp
767                         { $$ = exp_binop(EQ , $1, $3); }
768         |       exp NE exp
769                         { $$ = exp_binop(NE , $1, $3); }
770         |       exp LE exp
771                         { $$ = exp_binop(LE , $1, $3); }
772         |       exp GE exp
773                         { $$ = exp_binop(GE , $1, $3); }
774         |       exp '<' exp
775                         { $$ = exp_binop('<' , $1, $3); }
776         |       exp '>' exp
777                         { $$ = exp_binop('>' , $1, $3); }
778         |       exp '&' exp
779                         { $$ = exp_binop('&' , $1, $3); }
780         |       exp '^' exp
781                         { $$ = exp_binop('^' , $1, $3); }
782         |       exp '|' exp
783                         { $$ = exp_binop('|' , $1, $3); }
784         |       exp '?' exp ':' exp
785                         { $$ = exp_trinop('?' , $1, $3, $5); }
786         |       exp ANDAND exp
787                         { $$ = exp_binop(ANDAND , $1, $3); }
788         |       exp OROR exp
789                         { $$ = exp_binop(OROR , $1, $3); }
790         |       DEFINED '(' NAME ')'
791                         { $$ = exp_nameop(DEFINED, $3); }
792         |       INT
793                         { $$ = exp_bigintop ($1.integer, $1.str); }
794         |       SIZEOF_HEADERS
795                         { $$ = exp_nameop(SIZEOF_HEADERS,0); }
796
797         |       SIZEOF '(' NAME ')'
798                         { $$ = exp_nameop(SIZEOF,$3); }
799         |       ADDR '(' NAME ')'
800                         { $$ = exp_nameop(ADDR,$3); }
801         |       LOADADDR '(' NAME ')'
802                         { $$ = exp_nameop(LOADADDR,$3); }
803         |       ABSOLUTE '(' exp ')'
804                         { $$ = exp_unop(ABSOLUTE, $3); }
805         |       ALIGN_K '(' exp ')'
806                         { $$ = exp_unop(ALIGN_K,$3); }
807         |       ALIGN_K '(' exp ',' exp ')'
808                         { $$ = exp_binop(ALIGN_K,$3,$5); }
809         |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
810                         { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
811         |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
812                         { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
813         |       DATA_SEGMENT_END '(' exp ')'
814                         { $$ = exp_unop(DATA_SEGMENT_END, $3); }
815         |       BLOCK '(' exp ')'
816                         { $$ = exp_unop(ALIGN_K,$3); }
817         |       NAME
818                         { $$ = exp_nameop(NAME,$1); }
819         |       MAX_K '(' exp ',' exp ')'
820                         { $$ = exp_binop (MAX_K, $3, $5 ); }
821         |       MIN_K '(' exp ',' exp ')'
822                         { $$ = exp_binop (MIN_K, $3, $5 ); }
823         |       ASSERT_K '(' exp ',' NAME ')'
824                         { $$ = exp_assert ($3, $5); }
825         ;
826
827
828 memspec_at_opt:
829                 AT '>' NAME { $$ = $3; }
830         |       { $$ = 0; }
831         ;
832
833 opt_at:
834                 AT '(' exp ')' { $$ = $3; }
835         |       { $$ = 0; }
836         ;
837
838 opt_subalign:
839                 SUBALIGN '(' exp ')' { $$ = $3; }
840         |       { $$ = 0; }
841         ;
842
843 sect_constraint:
844                 ONLY_IF_RO { $$ = ONLY_IF_RO; }
845         |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
846         |       { $$ = 0; }
847         ;
848
849 section:        NAME            { ldlex_expression(); }
850                 opt_exp_with_type
851                 opt_at
852                 opt_subalign    { ldlex_popstate (); ldlex_script (); }
853                 sect_constraint
854                 '{'
855                         {
856                           lang_enter_output_section_statement($1, $3,
857                                                               sectype,
858                                                               0, $5, $4, $7);
859                         }
860                 statement_list_opt
861                 '}' { ldlex_popstate (); ldlex_expression (); }
862                 memspec_opt memspec_at_opt phdr_opt fill_opt
863                 {
864                   ldlex_popstate ();
865                   lang_leave_output_section_statement ($16, $13, $15, $14);
866                 }
867                 opt_comma
868                 {}
869         |       OVERLAY
870                         { ldlex_expression (); }
871                 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
872                         { ldlex_popstate (); ldlex_script (); }
873                 '{'
874                         {
875                           lang_enter_overlay ($3, $6);
876                         }
877                 overlay_section
878                 '}'
879                         { ldlex_popstate (); ldlex_expression (); }
880                 memspec_opt memspec_at_opt phdr_opt fill_opt
881                         {
882                           ldlex_popstate ();
883                           lang_leave_overlay ($5, (int) $4,
884                                               $16, $13, $15, $14);
885                         }
886                 opt_comma
887         |       /* The GROUP case is just enough to support the gcc
888                    svr3.ifile script.  It is not intended to be full
889                    support.  I'm not even sure what GROUP is supposed
890                    to mean.  */
891                 GROUP { ldlex_expression (); }
892                 opt_exp_with_type
893                 {
894                   ldlex_popstate ();
895                   lang_add_assignment (exp_assop ('=', ".", $3));
896                 }
897                 '{' sec_or_group_p1 '}'
898         ;
899
900 type:
901            NOLOAD  { sectype = noload_section; }
902         |  DSECT   { sectype = dsect_section; }
903         |  COPY    { sectype = copy_section; }
904         |  INFO    { sectype = info_section; }
905         |  OVERLAY { sectype = overlay_section; }
906         ;
907
908 atype:
909                 '(' type ')'
910         |       /* EMPTY */ { sectype = normal_section; }
911         |       '(' ')' { sectype = normal_section; }
912         ;
913
914 opt_exp_with_type:
915                 exp atype ':'           { $$ = $1; }
916         |       atype ':'               { $$ = (etree_type *)NULL;  }
917         |       /* The BIND cases are to support the gcc svr3.ifile
918                    script.  They aren't intended to implement full
919                    support for the BIND keyword.  I'm not even sure
920                    what BIND is supposed to mean.  */
921                 BIND '(' exp ')' atype ':' { $$ = $3; }
922         |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
923                 { $$ = $3; }
924         ;
925
926 opt_exp_without_type:
927                 exp ':'         { $$ = $1; }
928         |       ':'             { $$ = (etree_type *) NULL;  }
929         ;
930
931 opt_nocrossrefs:
932                 /* empty */
933                         { $$ = 0; }
934         |       NOCROSSREFS
935                         { $$ = 1; }
936         ;
937
938 memspec_opt:
939                 '>' NAME
940                 { $$ = $2; }
941         |       { $$ = DEFAULT_MEMORY_REGION; }
942         ;
943
944 phdr_opt:
945                 /* empty */
946                 {
947                   $$ = NULL;
948                 }
949         |       phdr_opt ':' NAME
950                 {
951                   struct lang_output_section_phdr_list *n;
952
953                   n = ((struct lang_output_section_phdr_list *)
954                        xmalloc (sizeof *n));
955                   n->name = $3;
956                   n->used = FALSE;
957                   n->next = $1;
958                   $$ = n;
959                 }
960         ;
961
962 overlay_section:
963                 /* empty */
964         |       overlay_section
965                 NAME
966                         {
967                           ldlex_script ();
968                           lang_enter_overlay_section ($2);
969                         }
970                 '{' statement_list_opt '}'
971                         { ldlex_popstate (); ldlex_expression (); }
972                 phdr_opt fill_opt
973                         {
974                           ldlex_popstate ();
975                           lang_leave_overlay_section ($9, $8);
976                         }
977                 opt_comma
978         ;
979
980 phdrs:
981                 PHDRS '{' phdr_list '}'
982         ;
983
984 phdr_list:
985                 /* empty */
986         |       phdr_list phdr
987         ;
988
989 phdr:
990                 NAME { ldlex_expression (); }
991                   phdr_type phdr_qualifiers { ldlex_popstate (); }
992                   ';'
993                 {
994                   lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
995                                  $4.flags);
996                 }
997         ;
998
999 phdr_type:
1000                 exp
1001                 {
1002                   $$ = $1;
1003
1004                   if ($1->type.node_class == etree_name
1005                       && $1->type.node_code == NAME)
1006                     {
1007                       const char *s;
1008                       unsigned int i;
1009                       static const char * const phdr_types[] =
1010                         {
1011                           "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1012                           "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1013                           "PT_PHDR", "PT_TLS"
1014                         };
1015
1016                       s = $1->name.name;
1017                       for (i = 0;
1018                            i < sizeof phdr_types / sizeof phdr_types[0];
1019                            i++)
1020                         if (strcmp (s, phdr_types[i]) == 0)
1021                           {
1022                             $$ = exp_intop (i);
1023                             break;
1024                           }
1025                       if (i == sizeof phdr_types / sizeof phdr_types[0])
1026                         {
1027                           if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1028                             $$ = exp_intop (0x6474e550);
1029                           else if (strcmp (s, "PT_GNU_STACK") == 0)
1030                             $$ = exp_intop (0x6474e551);
1031                           else
1032                             {
1033                               einfo (_("\
1034 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1035                                      s);
1036                               $$ = exp_intop (0);
1037                             }
1038                         }
1039                     }
1040                 }
1041         ;
1042
1043 phdr_qualifiers:
1044                 /* empty */
1045                 {
1046                   memset (&$$, 0, sizeof (struct phdr_info));
1047                 }
1048         |       NAME phdr_val phdr_qualifiers
1049                 {
1050                   $$ = $3;
1051                   if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1052                     $$.filehdr = TRUE;
1053                   else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1054                     $$.phdrs = TRUE;
1055                   else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1056                     $$.flags = $2;
1057                   else
1058                     einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1059                 }
1060         |       AT '(' exp ')' phdr_qualifiers
1061                 {
1062                   $$ = $5;
1063                   $$.at = $3;
1064                 }
1065         ;
1066
1067 phdr_val:
1068                 /* empty */
1069                 {
1070                   $$ = NULL;
1071                 }
1072         | '(' exp ')'
1073                 {
1074                   $$ = $2;
1075                 }
1076         ;
1077
1078 /* This syntax is used within an external version script file.  */
1079
1080 version_script_file:
1081                 {
1082                   ldlex_version_file ();
1083                   PUSH_ERROR (_("VERSION script"));
1084                 }
1085                 vers_nodes
1086                 {
1087                   ldlex_popstate ();
1088                   POP_ERROR ();
1089                 }
1090         ;
1091
1092 /* This is used within a normal linker script file.  */
1093
1094 version:
1095                 {
1096                   ldlex_version_script ();
1097                 }
1098                 VERSIONK '{' vers_nodes '}'
1099                 {
1100                   ldlex_popstate ();
1101                 }
1102         ;
1103
1104 vers_nodes:
1105                 vers_node
1106         |       vers_nodes vers_node
1107         ;
1108
1109 vers_node:
1110                 '{' vers_tag '}' ';'
1111                 {
1112                   lang_register_vers_node (NULL, $2, NULL);
1113                 }
1114         |       VERS_TAG '{' vers_tag '}' ';'
1115                 {
1116                   lang_register_vers_node ($1, $3, NULL);
1117                 }
1118         |       VERS_TAG '{' vers_tag '}' verdep ';'
1119                 {
1120                   lang_register_vers_node ($1, $3, $5);
1121                 }
1122         ;
1123
1124 verdep:
1125                 VERS_TAG
1126                 {
1127                   $$ = lang_add_vers_depend (NULL, $1);
1128                 }
1129         |       verdep VERS_TAG
1130                 {
1131                   $$ = lang_add_vers_depend ($1, $2);
1132                 }
1133         ;
1134
1135 vers_tag:
1136                 /* empty */
1137                 {
1138                   $$ = lang_new_vers_node (NULL, NULL);
1139                 }
1140         |       vers_defns ';'
1141                 {
1142                   $$ = lang_new_vers_node ($1, NULL);
1143                 }
1144         |       GLOBAL ':' vers_defns ';'
1145                 {
1146                   $$ = lang_new_vers_node ($3, NULL);
1147                 }
1148         |       LOCAL ':' vers_defns ';'
1149                 {
1150                   $$ = lang_new_vers_node (NULL, $3);
1151                 }
1152         |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1153                 {
1154                   $$ = lang_new_vers_node ($3, $7);
1155                 }
1156         ;
1157
1158 vers_defns:
1159                 VERS_IDENTIFIER
1160                 {
1161                   $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang);
1162                 }
1163         |       vers_defns ';' VERS_IDENTIFIER
1164                 {
1165                   $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang);
1166                 }
1167         |       vers_defns ';' EXTERN NAME '{'
1168                         {
1169                           $<name>$ = ldgram_vers_current_lang;
1170                           ldgram_vers_current_lang = $4;
1171                         }
1172                 vers_defns opt_semicolon '}'
1173                         {
1174                           $$ = $7;
1175                           ldgram_vers_current_lang = $<name>6;
1176                         }
1177         |       EXTERN NAME '{'
1178                         {
1179                           $<name>$ = ldgram_vers_current_lang;
1180                           ldgram_vers_current_lang = $2;
1181                         }
1182                 vers_defns opt_semicolon '}'
1183                         {
1184                           $$ = $5;
1185                           ldgram_vers_current_lang = $<name>4;
1186                         }
1187         ;
1188
1189 opt_semicolon:
1190                 /* empty */
1191         |       ';'
1192         ;
1193
1194 %%
1195 void
1196 yyerror(arg)
1197      const char *arg;
1198 {
1199   if (ldfile_assumed_script)
1200     einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1201            ldfile_input_filename);
1202   if (error_index > 0 && error_index < ERROR_NAME_MAX)
1203      einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1204   else
1205      einfo ("%P%F:%S: %s\n", arg);
1206 }