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