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