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