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