projects / deliverable / binutils-gdb.git / blob
? search:


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