]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - ld/ldgram.y
projects / thirdparty / binutils-gdb.git / blob
? search:


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