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 FILE *saved_script_handle = NULL;
52 bfd_boolean force_make_executable = FALSE;
53
54 bfd_boolean ldgram_in_script = FALSE;
55 bfd_boolean ldgram_had_equals = FALSE;
56 bfd_boolean ldgram_had_keep = FALSE;
57 char *ldgram_vers_current_lang = NULL;
58
59 #define ERROR_NAME_MAX 20
60 static char *error_names[ERROR_NAME_MAX];
61 static int error_index;
62 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
63 #define POP_ERROR() error_index--;
64 %}
65 %union {
66 bfd_vma integer;
67 struct big_int
68 {
69 bfd_vma integer;
70 char *str;
71 } bigint;
72 fill_type *fill;
73 char *name;
74 const char *cname;
75 struct wildcard_spec wildcard;
76 struct wildcard_list *wildcard_list;
77 struct name_list *name_list;
78 int token;
79 union etree_union *etree;
80 struct phdr_info
81 {
82 bfd_boolean filehdr;
83 bfd_boolean phdrs;
84 union etree_union *at;
85 union etree_union *flags;
86 } phdr;
87 struct lang_nocrossref *nocrossref;
88 struct lang_output_section_phdr_list *section_phdr;
89 struct bfd_elf_version_deps *deflist;
90 struct bfd_elf_version_expr *versyms;
91 struct bfd_elf_version_tree *versnode;
92 }
93
94 %type <etree> exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
95 %type <etree> opt_exp_without_type opt_subalign opt_align
96 %type <fill> fill_opt fill_exp
97 %type <name_list> exclude_name_list
98 %type <wildcard_list> file_NAME_list
99 %type <name> memspec_opt casesymlist
100 %type <name> memspec_at_opt
101 %type <cname> wildcard_name
102 %type <wildcard> wildcard_spec
103 %token <bigint> INT
104 %token <name> NAME LNAME
105 %type <integer> length
106 %type <phdr> phdr_qualifiers
107 %type <nocrossref> nocrossref_list
108 %type <section_phdr> phdr_opt
109 %type <integer> opt_nocrossrefs
110
111 %right <token> PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ
112 %right <token> '?' ':'
113 %left <token> OROR
114 %left <token> ANDAND
115 %left <token> '|'
116 %left <token> '^'
117 %left <token> '&'
118 %left <token> EQ NE
119 %left <token> '<' '>' LE GE
120 %left <token> LSHIFT RSHIFT
121
122 %left <token> '+' '-'
123 %left <token> '*' '/' '%'
124
125 %right UNARY
126 %token END
127 %left <token> '('
128 %token <token> ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
129 %token SECTIONS PHDRS DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
130 %token SORT_BY_NAME SORT_BY_ALIGNMENT
131 %token '{' '}'
132 %token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
133 %token INHIBIT_COMMON_ALLOCATION
134 %token SIZEOF_HEADERS
135 %token SEGMENT_START
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 PROVIDE_HIDDEN AS_NEEDED
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 SPECIAL
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 | AS_NEEDED '('
374 { $<integer>$ = as_needed; as_needed = TRUE; }
375 input_list ')'
376 { as_needed = $<integer>3; }
377 | input_list ',' AS_NEEDED '('
378 { $<integer>$ = as_needed; as_needed = TRUE; }
379 input_list ')'
380 { as_needed = $<integer>5; }
381 | input_list AS_NEEDED '('
382 { $<integer>$ = as_needed; as_needed = TRUE; }
383 input_list ')'
384 { as_needed = $<integer>4; }
385 ;
386
387 sections:
388 SECTIONS '{' sec_or_group_p1 '}'
389 ;
390
391 sec_or_group_p1:
392 sec_or_group_p1 section
393 | sec_or_group_p1 statement_anywhere
394 |
395 ;
396
397 statement_anywhere:
398 ENTRY '(' NAME ')'
399 { lang_add_entry ($3, FALSE); }
400 | assignment end
401 | ASSERT_K {ldlex_expression ();} '(' exp ',' NAME ')'
402 { ldlex_popstate ();
403 lang_add_assignment (exp_assert ($4, $6)); }
404 ;
405
406 /* The '*' and '?' cases are there because the lexer returns them as
407 separate tokens rather than as NAME. */
408 wildcard_name:
409 NAME
410 {
411 $$ = $1;
412 }
413 | '*'
414 {
415 $$ = "*";
416 }
417 | '?'
418 {
419 $$ = "?";
420 }
421 ;
422
423 wildcard_spec:
424 wildcard_name
425 {
426 $$.name = $1;
427 $$.sorted = none;
428 $$.exclude_name_list = NULL;
429 }
430 | EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
431 {
432 $$.name = $5;
433 $$.sorted = none;
434 $$.exclude_name_list = $3;
435 }
436 | SORT_BY_NAME '(' wildcard_name ')'
437 {
438 $$.name = $3;
439 $$.sorted = by_name;
440 $$.exclude_name_list = NULL;
441 }
442 | SORT_BY_ALIGNMENT '(' wildcard_name ')'
443 {
444 $$.name = $3;
445 $$.sorted = by_alignment;
446 $$.exclude_name_list = NULL;
447 }
448 | SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
449 {
450 $$.name = $5;
451 $$.sorted = by_name_alignment;
452 $$.exclude_name_list = NULL;
453 }
454 | SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
455 {
456 $$.name = $5;
457 $$.sorted = by_name;
458 $$.exclude_name_list = NULL;
459 }
460 | SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
461 {
462 $$.name = $5;
463 $$.sorted = by_alignment_name;
464 $$.exclude_name_list = NULL;
465 }
466 | SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
467 {
468 $$.name = $5;
469 $$.sorted = by_alignment;
470 $$.exclude_name_list = NULL;
471 }
472 | SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
473 {
474 $$.name = $7;
475 $$.sorted = by_name;
476 $$.exclude_name_list = $5;
477 }
478 ;
479
480 exclude_name_list:
481 exclude_name_list wildcard_name
482 {
483 struct name_list *tmp;
484 tmp = (struct name_list *) xmalloc (sizeof *tmp);
485 tmp->name = $2;
486 tmp->next = $1;
487 $$ = tmp;
488 }
489 |
490 wildcard_name
491 {
492 struct name_list *tmp;
493 tmp = (struct name_list *) xmalloc (sizeof *tmp);
494 tmp->name = $1;
495 tmp->next = NULL;
496 $$ = tmp;
497 }
498 ;
499
500 file_NAME_list:
501 file_NAME_list opt_comma wildcard_spec
502 {
503 struct wildcard_list *tmp;
504 tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
505 tmp->next = $1;
506 tmp->spec = $3;
507 $$ = tmp;
508 }
509 |
510 wildcard_spec
511 {
512 struct wildcard_list *tmp;
513 tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
514 tmp->next = NULL;
515 tmp->spec = $1;
516 $$ = tmp;
517 }
518 ;
519
520 input_section_spec_no_keep:
521 NAME
522 {
523 struct wildcard_spec tmp;
524 tmp.name = $1;
525 tmp.exclude_name_list = NULL;
526 tmp.sorted = none;
527 lang_add_wild (&tmp, NULL, ldgram_had_keep);
528 }
529 | '[' file_NAME_list ']'
530 {
531 lang_add_wild (NULL, $2, ldgram_had_keep);
532 }
533 | wildcard_spec '(' file_NAME_list ')'
534 {
535 lang_add_wild (&$1, $3, ldgram_had_keep);
536 }
537 ;
538
539 input_section_spec:
540 input_section_spec_no_keep
541 | KEEP '('
542 { ldgram_had_keep = TRUE; }
543 input_section_spec_no_keep ')'
544 { ldgram_had_keep = FALSE; }
545 ;
546
547 statement:
548 assignment end
549 | CREATE_OBJECT_SYMBOLS
550 {
551 lang_add_attribute(lang_object_symbols_statement_enum);
552 }
553 | ';'
554 | CONSTRUCTORS
555 {
556
557 lang_add_attribute(lang_constructors_statement_enum);
558 }
559 | SORT_BY_NAME '(' CONSTRUCTORS ')'
560 {
561 constructors_sorted = TRUE;
562 lang_add_attribute (lang_constructors_statement_enum);
563 }
564 | input_section_spec
565 | length '(' mustbe_exp ')'
566 {
567 lang_add_data ((int) $1, $3);
568 }
569
570 | FILL '(' fill_exp ')'
571 {
572 lang_add_fill ($3);
573 }
574 ;
575
576 statement_list:
577 statement_list statement
578 | statement
579 ;
580
581 statement_list_opt:
582 /* empty */
583 | statement_list
584 ;
585
586 length:
587 QUAD
588 { $$ = $1; }
589 | SQUAD
590 { $$ = $1; }
591 | LONG
592 { $$ = $1; }
593 | SHORT
594 { $$ = $1; }
595 | BYTE
596 { $$ = $1; }
597 ;
598
599 fill_exp:
600 mustbe_exp
601 {
602 $$ = exp_get_fill ($1, 0, "fill value");
603 }
604 ;
605
606 fill_opt:
607 '=' fill_exp
608 { $$ = $2; }
609 | { $$ = (fill_type *) 0; }
610 ;
611
612 assign_op:
613 PLUSEQ
614 { $$ = '+'; }
615 | MINUSEQ
616 { $$ = '-'; }
617 | MULTEQ
618 { $$ = '*'; }
619 | DIVEQ
620 { $$ = '/'; }
621 | LSHIFTEQ
622 { $$ = LSHIFT; }
623 | RSHIFTEQ
624 { $$ = RSHIFT; }
625 | ANDEQ
626 { $$ = '&'; }
627 | OREQ
628 { $$ = '|'; }
629
630 ;
631
632 end: ';' | ','
633 ;
634
635
636 assignment:
637 NAME '=' mustbe_exp
638 {
639 lang_add_assignment (exp_assop ($2, $1, $3));
640 }
641 | NAME assign_op mustbe_exp
642 {
643 lang_add_assignment (exp_assop ('=', $1,
644 exp_binop ($2,
645 exp_nameop (NAME,
646 $1),
647 $3)));
648 }
649 | PROVIDE '(' NAME '=' mustbe_exp ')'
650 {
651 lang_add_assignment (exp_provide ($3, $5, FALSE));
652 }
653 | PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
654 {
655 lang_add_assignment (exp_provide ($3, $5, TRUE));
656 }
657 ;
658
659
660 opt_comma:
661 ',' | ;
662
663
664 memory:
665 MEMORY '{' memory_spec memory_spec_list '}'
666 ;
667
668 memory_spec_list:
669 memory_spec_list memory_spec
670 | memory_spec_list ',' memory_spec
671 |
672 ;
673
674
675 memory_spec: NAME
676 { region = lang_memory_region_lookup ($1, TRUE); }
677 attributes_opt ':'
678 origin_spec opt_comma length_spec
679 {}
680 ;
681
682 origin_spec:
683 ORIGIN '=' mustbe_exp
684 {
685 region->origin = exp_get_vma ($3, 0, "origin");
686 region->current = region->origin;
687 }
688 ;
689
690 length_spec:
691 LENGTH '=' mustbe_exp
692 {
693 region->length = exp_get_vma ($3, -1, "length");
694 }
695 ;
696
697 attributes_opt:
698 /* empty */
699 { /* dummy action to avoid bison 1.25 error message */ }
700 | '(' attributes_list ')'
701 ;
702
703 attributes_list:
704 attributes_string
705 | attributes_list attributes_string
706 ;
707
708 attributes_string:
709 NAME
710 { lang_set_flags (region, $1, 0); }
711 | '!' NAME
712 { lang_set_flags (region, $2, 1); }
713 ;
714
715 startup:
716 STARTUP '(' filename ')'
717 { lang_startup($3); }
718 ;
719
720 high_level_library:
721 HLL '(' high_level_library_NAME_list ')'
722 | HLL '(' ')'
723 { ldemul_hll((char *)NULL); }
724 ;
725
726 high_level_library_NAME_list:
727 high_level_library_NAME_list opt_comma filename
728 { ldemul_hll($3); }
729 | filename
730 { ldemul_hll($1); }
731
732 ;
733
734 low_level_library:
735 SYSLIB '(' low_level_library_NAME_list ')'
736 ; low_level_library_NAME_list:
737 low_level_library_NAME_list opt_comma filename
738 { ldemul_syslib($3); }
739 |
740 ;
741
742 floating_point_support:
743 FLOAT
744 { lang_float(TRUE); }
745 | NOFLOAT
746 { lang_float(FALSE); }
747 ;
748
749 nocrossref_list:
750 /* empty */
751 {
752 $$ = NULL;
753 }
754 | NAME nocrossref_list
755 {
756 struct lang_nocrossref *n;
757
758 n = (struct lang_nocrossref *) xmalloc (sizeof *n);
759 n->name = $1;
760 n->next = $2;
761 $$ = n;
762 }
763 | NAME ',' nocrossref_list
764 {
765 struct lang_nocrossref *n;
766
767 n = (struct lang_nocrossref *) xmalloc (sizeof *n);
768 n->name = $1;
769 n->next = $3;
770 $$ = n;
771 }
772 ;
773
774 mustbe_exp: { ldlex_expression (); }
775 exp
776 { ldlex_popstate (); $$=$2;}
777 ;
778
779 exp :
780 '-' exp %prec UNARY
781 { $$ = exp_unop ('-', $2); }
782 | '(' exp ')'
783 { $$ = $2; }
784 | NEXT '(' exp ')' %prec UNARY
785 { $$ = exp_unop ((int) $1,$3); }
786 | '!' exp %prec UNARY
787 { $$ = exp_unop ('!', $2); }
788 | '+' exp %prec UNARY
789 { $$ = $2; }
790 | '~' exp %prec UNARY
791 { $$ = exp_unop ('~', $2);}
792
793 | exp '*' exp
794 { $$ = exp_binop ('*', $1, $3); }
795 | exp '/' exp
796 { $$ = exp_binop ('/', $1, $3); }
797 | exp '%' exp
798 { $$ = exp_binop ('%', $1, $3); }
799 | exp '+' exp
800 { $$ = exp_binop ('+', $1, $3); }
801 | exp '-' exp
802 { $$ = exp_binop ('-' , $1, $3); }
803 | exp LSHIFT exp
804 { $$ = exp_binop (LSHIFT , $1, $3); }
805 | exp RSHIFT exp
806 { $$ = exp_binop (RSHIFT , $1, $3); }
807 | exp EQ exp
808 { $$ = exp_binop (EQ , $1, $3); }
809 | exp NE exp
810 { $$ = exp_binop (NE , $1, $3); }
811 | exp LE exp
812 { $$ = exp_binop (LE , $1, $3); }
813 | exp GE exp
814 { $$ = exp_binop (GE , $1, $3); }
815 | exp '<' exp
816 { $$ = exp_binop ('<' , $1, $3); }
817 | exp '>' exp
818 { $$ = exp_binop ('>' , $1, $3); }
819 | exp '&' exp
820 { $$ = exp_binop ('&' , $1, $3); }
821 | exp '^' exp
822 { $$ = exp_binop ('^' , $1, $3); }
823 | exp '|' exp
824 { $$ = exp_binop ('|' , $1, $3); }
825 | exp '?' exp ':' exp
826 { $$ = exp_trinop ('?' , $1, $3, $5); }
827 | exp ANDAND exp
828 { $$ = exp_binop (ANDAND , $1, $3); }
829 | exp OROR exp
830 { $$ = exp_binop (OROR , $1, $3); }
831 | DEFINED '(' NAME ')'
832 { $$ = exp_nameop (DEFINED, $3); }
833 | INT
834 { $$ = exp_bigintop ($1.integer, $1.str); }
835 | SIZEOF_HEADERS
836 { $$ = exp_nameop (SIZEOF_HEADERS,0); }
837
838 | SIZEOF '(' NAME ')'
839 { $$ = exp_nameop (SIZEOF,$3); }
840 | ADDR '(' NAME ')'
841 { $$ = exp_nameop (ADDR,$3); }
842 | LOADADDR '(' NAME ')'
843 { $$ = exp_nameop (LOADADDR,$3); }
844 | ABSOLUTE '(' exp ')'
845 { $$ = exp_unop (ABSOLUTE, $3); }
846 | ALIGN_K '(' exp ')'
847 { $$ = exp_unop (ALIGN_K,$3); }
848 | ALIGN_K '(' exp ',' exp ')'
849 { $$ = exp_binop (ALIGN_K,$3,$5); }
850 | DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
851 { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
852 | DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
853 { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
854 | DATA_SEGMENT_END '(' exp ')'
855 { $$ = exp_unop (DATA_SEGMENT_END, $3); }
856 | SEGMENT_START '(' NAME ',' exp ')'
857 { /* The operands to the expression node are
858 placed in the opposite order from the way
859 in which they appear in the script as
860 that allows us to reuse more code in
861 fold_binary. */
862 $$ = exp_binop (SEGMENT_START,
863 $5,
864 exp_nameop (NAME, $3)); }
865 | BLOCK '(' exp ')'
866 { $$ = exp_unop (ALIGN_K,$3); }
867 | NAME
868 { $$ = exp_nameop (NAME,$1); }
869 | MAX_K '(' exp ',' exp ')'
870 { $$ = exp_binop (MAX_K, $3, $5 ); }
871 | MIN_K '(' exp ',' exp ')'
872 { $$ = exp_binop (MIN_K, $3, $5 ); }
873 | ASSERT_K '(' exp ',' NAME ')'
874 { $$ = exp_assert ($3, $5); }
875 | ORIGIN '(' NAME ')'
876 { $$ = exp_nameop (ORIGIN, $3); }
877 | LENGTH '(' NAME ')'
878 { $$ = exp_nameop (LENGTH, $3); }
879 ;
880
881
882 memspec_at_opt:
883 AT '>' NAME { $$ = $3; }
884 | { $$ = 0; }
885 ;
886
887 opt_at:
888 AT '(' exp ')' { $$ = $3; }
889 | { $$ = 0; }
890 ;
891
892 opt_align:
893 ALIGN_K '(' exp ')' { $$ = $3; }
894 | { $$ = 0; }
895 ;
896
897 opt_subalign:
898 SUBALIGN '(' exp ')' { $$ = $3; }
899 | { $$ = 0; }
900 ;
901
902 sect_constraint:
903 ONLY_IF_RO { $$ = ONLY_IF_RO; }
904 | ONLY_IF_RW { $$ = ONLY_IF_RW; }
905 | SPECIAL { $$ = SPECIAL; }
906 | { $$ = 0; }
907 ;
908
909 section: NAME { ldlex_expression(); }
910 opt_exp_with_type
911 opt_at
912 opt_align
913 opt_subalign { ldlex_popstate (); ldlex_script (); }
914 sect_constraint
915 '{'
916 {
917 lang_enter_output_section_statement($1, $3,
918 sectype,
919 $5, $6, $4, $8);
920 }
921 statement_list_opt
922 '}' { ldlex_popstate (); ldlex_expression (); }
923 memspec_opt memspec_at_opt phdr_opt fill_opt
924 {
925 ldlex_popstate ();
926 lang_leave_output_section_statement ($17, $14, $16, $15);
927 }
928 opt_comma
929 {}
930 | OVERLAY
931 { ldlex_expression (); }
932 opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
933 { ldlex_popstate (); ldlex_script (); }
934 '{'
935 {
936 lang_enter_overlay ($3, $6);
937 }
938 overlay_section
939 '}'
940 { ldlex_popstate (); ldlex_expression (); }
941 memspec_opt memspec_at_opt phdr_opt fill_opt
942 {
943 ldlex_popstate ();
944 lang_leave_overlay ($5, (int) $4,
945 $16, $13, $15, $14);
946 }
947 opt_comma
948 | /* The GROUP case is just enough to support the gcc
949 svr3.ifile script. It is not intended to be full
950 support. I'm not even sure what GROUP is supposed
951 to mean. */
952 GROUP { ldlex_expression (); }
953 opt_exp_with_type
954 {
955 ldlex_popstate ();
956 lang_add_assignment (exp_assop ('=', ".", $3));
957 }
958 '{' sec_or_group_p1 '}'
959 ;
960
961 type:
962 NOLOAD { sectype = noload_section; }
963 | DSECT { sectype = dsect_section; }
964 | COPY { sectype = copy_section; }
965 | INFO { sectype = info_section; }
966 | OVERLAY { sectype = overlay_section; }
967 ;
968
969 atype:
970 '(' type ')'
971 | /* EMPTY */ { sectype = normal_section; }
972 | '(' ')' { sectype = normal_section; }
973 ;
974
975 opt_exp_with_type:
976 exp atype ':' { $$ = $1; }
977 | atype ':' { $$ = (etree_type *)NULL; }
978 | /* The BIND cases are to support the gcc svr3.ifile
979 script. They aren't intended to implement full
980 support for the BIND keyword. I'm not even sure
981 what BIND is supposed to mean. */
982 BIND '(' exp ')' atype ':' { $$ = $3; }
983 | BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
984 { $$ = $3; }
985 ;
986
987 opt_exp_without_type:
988 exp ':' { $$ = $1; }
989 | ':' { $$ = (etree_type *) NULL; }
990 ;
991
992 opt_nocrossrefs:
993 /* empty */
994 { $$ = 0; }
995 | NOCROSSREFS
996 { $$ = 1; }
997 ;
998
999 memspec_opt:
1000 '>' NAME
1001 { $$ = $2; }
1002 | { $$ = DEFAULT_MEMORY_REGION; }
1003 ;
1004
1005 phdr_opt:
1006 /* empty */
1007 {
1008 $$ = NULL;
1009 }
1010 | phdr_opt ':' NAME
1011 {
1012 struct lang_output_section_phdr_list *n;
1013
1014 n = ((struct lang_output_section_phdr_list *)
1015 xmalloc (sizeof *n));
1016 n->name = $3;
1017 n->used = FALSE;
1018 n->next = $1;
1019 $$ = n;
1020 }
1021 ;
1022
1023 overlay_section:
1024 /* empty */
1025 | overlay_section
1026 NAME
1027 {
1028 ldlex_script ();
1029 lang_enter_overlay_section ($2);
1030 }
1031 '{' statement_list_opt '}'
1032 { ldlex_popstate (); ldlex_expression (); }
1033 phdr_opt fill_opt
1034 {
1035 ldlex_popstate ();
1036 lang_leave_overlay_section ($9, $8);
1037 }
1038 opt_comma
1039 ;
1040
1041 phdrs:
1042 PHDRS '{' phdr_list '}'
1043 ;
1044
1045 phdr_list:
1046 /* empty */
1047 | phdr_list phdr
1048 ;
1049
1050 phdr:
1051 NAME { ldlex_expression (); }
1052 phdr_type phdr_qualifiers { ldlex_popstate (); }
1053 ';'
1054 {
1055 lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1056 $4.flags);
1057 }
1058 ;
1059
1060 phdr_type:
1061 exp
1062 {
1063 $$ = $1;
1064
1065 if ($1->type.node_class == etree_name
1066 && $1->type.node_code == NAME)
1067 {
1068 const char *s;
1069 unsigned int i;
1070 static const char * const phdr_types[] =
1071 {
1072 "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1073 "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1074 "PT_PHDR", "PT_TLS"
1075 };
1076
1077 s = $1->name.name;
1078 for (i = 0;
1079 i < sizeof phdr_types / sizeof phdr_types[0];
1080 i++)
1081 if (strcmp (s, phdr_types[i]) == 0)
1082 {
1083 $$ = exp_intop (i);
1084 break;
1085 }
1086 if (i == sizeof phdr_types / sizeof phdr_types[0])
1087 {
1088 if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1089 $$ = exp_intop (0x6474e550);
1090 else if (strcmp (s, "PT_GNU_STACK") == 0)
1091 $$ = exp_intop (0x6474e551);
1092 else
1093 {
1094 einfo (_("\
1095 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1096 s);
1097 $$ = exp_intop (0);
1098 }
1099 }
1100 }
1101 }
1102 ;
1103
1104 phdr_qualifiers:
1105 /* empty */
1106 {
1107 memset (&$$, 0, sizeof (struct phdr_info));
1108 }
1109 | NAME phdr_val phdr_qualifiers
1110 {
1111 $$ = $3;
1112 if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1113 $$.filehdr = TRUE;
1114 else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1115 $$.phdrs = TRUE;
1116 else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1117 $$.flags = $2;
1118 else
1119 einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1120 }
1121 | AT '(' exp ')' phdr_qualifiers
1122 {
1123 $$ = $5;
1124 $$.at = $3;
1125 }
1126 ;
1127
1128 phdr_val:
1129 /* empty */
1130 {
1131 $$ = NULL;
1132 }
1133 | '(' exp ')'
1134 {
1135 $$ = $2;
1136 }
1137 ;
1138
1139 /* This syntax is used within an external version script file. */
1140
1141 version_script_file:
1142 {
1143 ldlex_version_file ();
1144 PUSH_ERROR (_("VERSION script"));
1145 }
1146 vers_nodes
1147 {
1148 ldlex_popstate ();
1149 POP_ERROR ();
1150 }
1151 ;
1152
1153 /* This is used within a normal linker script file. */
1154
1155 version:
1156 {
1157 ldlex_version_script ();
1158 }
1159 VERSIONK '{' vers_nodes '}'
1160 {
1161 ldlex_popstate ();
1162 }
1163 ;
1164
1165 vers_nodes:
1166 vers_node
1167 | vers_nodes vers_node
1168 ;
1169
1170 vers_node:
1171 '{' vers_tag '}' ';'
1172 {
1173 lang_register_vers_node (NULL, $2, NULL);
1174 }
1175 | VERS_TAG '{' vers_tag '}' ';'
1176 {
1177 lang_register_vers_node ($1, $3, NULL);
1178 }
1179 | VERS_TAG '{' vers_tag '}' verdep ';'
1180 {
1181 lang_register_vers_node ($1, $3, $5);
1182 }
1183 ;
1184
1185 verdep:
1186 VERS_TAG
1187 {
1188 $$ = lang_add_vers_depend (NULL, $1);
1189 }
1190 | verdep VERS_TAG
1191 {
1192 $$ = lang_add_vers_depend ($1, $2);
1193 }
1194 ;
1195
1196 vers_tag:
1197 /* empty */
1198 {
1199 $$ = lang_new_vers_node (NULL, NULL);
1200 }
1201 | vers_defns ';'
1202 {
1203 $$ = lang_new_vers_node ($1, NULL);
1204 }
1205 | GLOBAL ':' vers_defns ';'
1206 {
1207 $$ = lang_new_vers_node ($3, NULL);
1208 }
1209 | LOCAL ':' vers_defns ';'
1210 {
1211 $$ = lang_new_vers_node (NULL, $3);
1212 }
1213 | GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1214 {
1215 $$ = lang_new_vers_node ($3, $7);
1216 }
1217 ;
1218
1219 vers_defns:
1220 VERS_IDENTIFIER
1221 {
1222 $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1223 }
1224 | NAME
1225 {
1226 $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1227 }
1228 | vers_defns ';' VERS_IDENTIFIER
1229 {
1230 $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1231 }
1232 | vers_defns ';' NAME
1233 {
1234 $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1235 }
1236 | vers_defns ';' EXTERN NAME '{'
1237 {
1238 $<name>$ = ldgram_vers_current_lang;
1239 ldgram_vers_current_lang = $4;
1240 }
1241 vers_defns opt_semicolon '}'
1242 {
1243 struct bfd_elf_version_expr *pat;
1244 for (pat = $7; pat->next != NULL; pat = pat->next);
1245 pat->next = $1;
1246 $$ = $7;
1247 ldgram_vers_current_lang = $<name>6;
1248 }
1249 | EXTERN NAME '{'
1250 {
1251 $<name>$ = ldgram_vers_current_lang;
1252 ldgram_vers_current_lang = $2;
1253 }
1254 vers_defns opt_semicolon '}'
1255 {
1256 $$ = $5;
1257 ldgram_vers_current_lang = $<name>4;
1258 }
1259 | GLOBAL
1260 {
1261 $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1262 }
1263 | vers_defns ';' GLOBAL
1264 {
1265 $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1266 }
1267 | LOCAL
1268 {
1269 $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1270 }
1271 | vers_defns ';' LOCAL
1272 {
1273 $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1274 }
1275 | EXTERN
1276 {
1277 $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1278 }
1279 | vers_defns ';' EXTERN
1280 {
1281 $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1282 }
1283 ;
1284
1285 opt_semicolon:
1286 /* empty */
1287 | ';'
1288 ;
1289
1290 %%
1291 void
yyerror(arg)1292 yyerror(arg)
1293 const char *arg;
1294 {
1295 if (ldfile_assumed_script)
1296 einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1297 ldfile_input_filename);
1298 if (error_index > 0 && error_index < ERROR_NAME_MAX)
1299 einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1300 else
1301 einfo ("%P%F:%S: %s\n", arg);
1302 }
1303