1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD 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 2, or (at your option)
13 GLD 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.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
45 static lang_statement_union_type *new_statement
46 PARAMS ((enum statement_enum, size_t, lang_statement_list_type *));
49 static struct obstack stat_obstack;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
53 static const char *startup_file;
54 static lang_statement_list_type input_file_chain;
55 static boolean placed_commons = false;
56 static lang_output_section_statement_type *default_common_section;
57 static boolean map_option_f;
58 static bfd_vma print_dot;
59 static lang_input_statement_type *first_file;
60 static const char *current_target;
61 static const char *output_target;
62 static lang_statement_list_type statement_list;
63 static struct lang_phdr *lang_phdr_list;
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*) (lang_statement_union_type *),
67 lang_statement_union_type *));
68 static lang_input_statement_type *new_afile
69 PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
70 static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
71 static void lang_map_flags PARAMS ((flagword));
72 static void init_os PARAMS ((lang_output_section_statement_type *));
73 static void exp_init_os PARAMS ((etree_type *));
74 static void section_already_linked PARAMS ((bfd *, asection *, PTR));
75 static struct bfd_hash_entry *already_linked_newfunc
76 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
77 static void already_linked_table_init PARAMS ((void));
78 static void already_linked_table_free PARAMS ((void));
79 static boolean wildcardp PARAMS ((const char *));
80 static lang_statement_union_type *wild_sort
81 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
83 static void output_section_callback
84 PARAMS ((lang_wild_statement_type *, asection *,
85 lang_input_statement_type *, PTR));
86 static lang_input_statement_type *lookup_name PARAMS ((const char *));
87 static void load_symbols
88 PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
90 PARAMS ((lang_wild_statement_type *, const char *, const char *,
91 const char *, lang_output_section_statement_type *));
92 static bfd *open_output PARAMS ((const char *));
93 static void ldlang_open_output PARAMS ((lang_statement_union_type *));
94 static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
95 static void lang_reasonable_defaults PARAMS ((void));
96 static void lang_place_undefineds PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type *, const char *,
99 lang_output_section_statement_type *));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type *));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type *,
104 lang_output_section_statement_type *));
105 static void print_input_statement PARAMS ((lang_input_statement_type *));
106 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
107 static void print_input_section PARAMS ((lang_input_section_type *));
108 static void print_fill_statement PARAMS ((lang_fill_statement_type *));
109 static void print_data_statement PARAMS ((lang_data_statement_type *));
110 static void print_address_statement PARAMS ((lang_address_statement_type *));
111 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
112 static void print_padding_statement PARAMS ((lang_padding_statement_type *));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
115 static void print_group
116 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
117 static void print_statement
118 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
121 static void print_statements PARAMS ((void));
122 static bfd_vma insert_pad
123 PARAMS ((lang_statement_union_type **, fill_type,
124 unsigned int, asection *, bfd_vma));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
127 fill_type, bfd_vma, boolean));
128 static void lang_finish PARAMS ((void));
129 static void ignore_bfd_errors PARAMS ((const char *, ...));
130 static void record_bfd_errors PARAMS ((const char *, ...));
131 static void lang_check PARAMS ((void));
132 static void lang_common PARAMS ((void));
133 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
134 static void lang_place_orphans PARAMS ((void));
135 static int topower PARAMS ((int));
136 static void lang_set_startof PARAMS ((void));
137 static void reset_memory_regions PARAMS ((void));
138 static void gc_section_callback
139 PARAMS ((lang_wild_statement_type *, asection *,
140 lang_input_statement_type *, PTR));
141 static void lang_record_phdrs PARAMS ((void));
142 static void lang_gc_wild
143 PARAMS ((lang_wild_statement_type *, const char *, const char *));
144 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
145 static void lang_gc_sections PARAMS ((void));
146 static int lang_vers_match_lang_c
147 PARAMS ((struct bfd_elf_version_expr *, const char *));
148 static int lang_vers_match_lang_cplusplus
149 PARAMS ((struct bfd_elf_version_expr *, const char *));
150 static int lang_vers_match_lang_java
151 PARAMS ((struct bfd_elf_version_expr *, const char *));
152 static void lang_do_version_exports_section PARAMS ((void));
153 static void lang_check_section_addresses PARAMS ((void));
154 static void os_region_check
155 PARAMS ((lang_output_section_statement_type *,
156 struct memory_region_struct *, etree_type *, bfd_vma));
158 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
159 asection *, lang_input_statement_type *,
161 static void walk_wild
162 PARAMS ((lang_wild_statement_type *, const char *, const char *,
164 static void walk_wild_section
165 PARAMS ((lang_wild_statement_type *, const char *,
166 lang_input_statement_type *, callback_t, PTR));
167 static void walk_wild_file
168 PARAMS ((lang_wild_statement_type *, const char *,
169 lang_input_statement_type *, callback_t, PTR));
171 static int get_target PARAMS ((const bfd_target *, PTR));
172 static void stricpy PARAMS ((char *, char *));
173 static void strcut PARAMS ((char *, char *));
174 static int name_compare PARAMS ((char *, char *));
175 static int closest_target_match PARAMS ((const bfd_target *, PTR));
176 static char * get_first_input_target PARAMS ((void));
179 lang_output_section_statement_type *abs_output_section;
180 lang_statement_list_type lang_output_section_statement;
181 lang_statement_list_type *stat_ptr = &statement_list;
182 lang_statement_list_type file_chain = { NULL, NULL };
183 const char *entry_symbol = NULL;
184 boolean entry_from_cmdline;
185 boolean lang_has_input_file = false;
186 boolean had_output_filename = false;
187 boolean lang_float_flag = false;
188 boolean delete_output_file_on_failure = false;
189 struct lang_nocrossrefs *nocrossref_list;
190 struct unique_sections *unique_section_list;
192 etree_type *base; /* Relocation base - or null */
194 #if defined (__STDC__) || defined (ALMOST_STDC)
195 #define cat(a,b) a##b
197 #define cat(a,b) a/**/b
200 /* Don't beautify the line below with "innocent" whitespace, it breaks
201 the K&R C preprocessor! */
202 #define new_stat(x, y) \
203 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
205 #define outside_section_address(q) \
206 ((q)->output_offset + (q)->output_section->vma)
208 #define outside_symbol_address(q) \
209 ((q)->value + outside_section_address (q->section))
211 #define SECTION_NAME_MAP_LENGTH (16)
217 return obstack_alloc (&stat_obstack, size);
221 unique_section_p (secnam)
224 struct unique_sections *unam;
226 for (unam = unique_section_list; unam; unam = unam->next)
227 if (wildcardp (unam->name)
228 ? fnmatch (unam->name, secnam, 0) == 0
229 : strcmp (unam->name, secnam) == 0)
237 /* Generic traversal routines for finding matching sections. */
240 walk_wild_section (ptr, section, file, callback, data)
241 lang_wild_statement_type *ptr;
243 lang_input_statement_type *file;
247 /* Don't process sections from files which were excluded. */
248 if (ptr->exclude_filename_list != NULL)
250 struct name_list *list_tmp;
251 for (list_tmp = ptr->exclude_filename_list;
253 list_tmp = list_tmp->next)
257 if (wildcardp (list_tmp->name))
258 match = fnmatch (list_tmp->name, file->filename, 0) == 0;
260 match = strcmp (list_tmp->name, file->filename) == 0;
267 if (file->just_syms_flag == false)
269 register asection *s;
270 boolean wildcard = false;
273 wildcard = wildcardp (section);
275 for (s = file->the_bfd->sections; s != NULL; s = s->next)
278 const char *sname = bfd_get_section_name (file->the_bfd, s);
283 match = fnmatch (section, sname, 0) == 0;
285 match = strcmp (section, sname) == 0;
287 /* If this is a wild-card output section statement, exclude
288 sections that match UNIQUE_SECTION_LIST. */
289 if (match && (data == NULL || !unique_section_p (sname)))
290 (*callback) (ptr, s, file, data);
295 /* Handle a wild statement for a single file F. */
298 walk_wild_file (s, section, f, callback, data)
299 lang_wild_statement_type *s;
301 lang_input_statement_type *f;
305 if (f->the_bfd == NULL
306 || ! bfd_check_format (f->the_bfd, bfd_archive))
307 walk_wild_section (s, section, f, callback, data);
312 /* This is an archive file. We must map each member of the
313 archive separately. */
314 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
315 while (member != NULL)
317 /* When lookup_name is called, it will call the add_symbols
318 entry point for the archive. For each element of the
319 archive which is included, BFD will call ldlang_add_file,
320 which will set the usrdata field of the member to the
321 lang_input_statement. */
322 if (member->usrdata != NULL)
324 walk_wild_section (s, section,
325 (lang_input_statement_type *) member->usrdata,
329 member = bfd_openr_next_archived_file (f->the_bfd, member);
335 walk_wild (s, section, file, callback, data)
336 lang_wild_statement_type *s;
342 if (file == (char *) NULL)
344 /* Perform the iteration over all files in the list. */
345 LANG_FOR_EACH_INPUT_STATEMENT (f)
347 walk_wild_file (s, section, f, callback, data);
350 else if (wildcardp (file))
352 LANG_FOR_EACH_INPUT_STATEMENT (f)
354 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
355 walk_wild_file (s, section, f, callback, data);
360 lang_input_statement_type *f;
362 /* Perform the iteration over a single file. */
363 f = lookup_name (file);
364 walk_wild_file (s, section, f, callback, data);
368 /* lang_for_each_statement walks the parse tree and calls the provided
369 function for each node. */
372 lang_for_each_statement_worker (func, s)
373 void (*func) PARAMS ((lang_statement_union_type *));
374 lang_statement_union_type *s;
376 for (; s != (lang_statement_union_type *) NULL; s = s->next)
380 switch (s->header.type)
382 case lang_constructors_statement_enum:
383 lang_for_each_statement_worker (func, constructor_list.head);
385 case lang_output_section_statement_enum:
386 lang_for_each_statement_worker
388 s->output_section_statement.children.head);
390 case lang_wild_statement_enum:
391 lang_for_each_statement_worker
393 s->wild_statement.children.head);
395 case lang_group_statement_enum:
396 lang_for_each_statement_worker (func,
397 s->group_statement.children.head);
399 case lang_data_statement_enum:
400 case lang_reloc_statement_enum:
401 case lang_object_symbols_statement_enum:
402 case lang_output_statement_enum:
403 case lang_target_statement_enum:
404 case lang_input_section_enum:
405 case lang_input_statement_enum:
406 case lang_assignment_statement_enum:
407 case lang_padding_statement_enum:
408 case lang_address_statement_enum:
409 case lang_fill_statement_enum:
419 lang_for_each_statement (func)
420 void (*func) PARAMS ((lang_statement_union_type *));
422 lang_for_each_statement_worker (func, statement_list.head);
425 /*----------------------------------------------------------------------*/
428 lang_list_init (list)
429 lang_statement_list_type *list;
431 list->head = (lang_statement_union_type *) NULL;
432 list->tail = &list->head;
435 /* Build a new statement node for the parse tree. */
437 static lang_statement_union_type *
438 new_statement (type, size, list)
439 enum statement_enum type;
441 lang_statement_list_type *list;
443 lang_statement_union_type *new = (lang_statement_union_type *)
446 new->header.type = type;
447 new->header.next = (lang_statement_union_type *) NULL;
448 lang_statement_append (list, new, &new->header.next);
452 /* Build a new input file node for the language. There are several
453 ways in which we treat an input file, eg, we only look at symbols,
454 or prefix it with a -l etc.
456 We can be supplied with requests for input files more than once;
457 they may, for example be split over serveral lines like foo.o(.text)
458 foo.o(.data) etc, so when asked for a file we check that we haven't
459 got it already so we don't duplicate the bfd. */
461 static lang_input_statement_type *
462 new_afile (name, file_type, target, add_to_list)
464 lang_input_file_enum_type file_type;
468 lang_input_statement_type *p;
471 p = new_stat (lang_input_statement, stat_ptr);
474 p = ((lang_input_statement_type *)
475 stat_alloc (sizeof (lang_input_statement_type)));
476 p->header.next = NULL;
479 lang_has_input_file = true;
483 case lang_input_file_is_symbols_only_enum:
485 p->is_archive = false;
487 p->local_sym_name = name;
488 p->just_syms_flag = true;
489 p->search_dirs_flag = false;
491 case lang_input_file_is_fake_enum:
493 p->is_archive = false;
495 p->local_sym_name = name;
496 p->just_syms_flag = false;
497 p->search_dirs_flag = false;
499 case lang_input_file_is_l_enum:
500 p->is_archive = true;
503 p->local_sym_name = concat ("-l", name, (const char *) NULL);
504 p->just_syms_flag = false;
505 p->search_dirs_flag = true;
507 case lang_input_file_is_marker_enum:
509 p->is_archive = false;
511 p->local_sym_name = name;
512 p->just_syms_flag = false;
513 p->search_dirs_flag = true;
515 case lang_input_file_is_search_file_enum:
517 p->is_archive = false;
519 p->local_sym_name = name;
520 p->just_syms_flag = false;
521 p->search_dirs_flag = true;
523 case lang_input_file_is_file_enum:
525 p->is_archive = false;
527 p->local_sym_name = name;
528 p->just_syms_flag = false;
529 p->search_dirs_flag = false;
534 p->the_bfd = (bfd *) NULL;
535 p->asymbols = (asymbol **) NULL;
536 p->next_real_file = (lang_statement_union_type *) NULL;
537 p->next = (lang_statement_union_type *) NULL;
539 p->dynamic = config.dynamic_link;
540 p->whole_archive = whole_archive;
542 lang_statement_append (&input_file_chain,
543 (lang_statement_union_type *) p,
548 lang_input_statement_type *
549 lang_add_input_file (name, file_type, target)
551 lang_input_file_enum_type file_type;
554 lang_has_input_file = true;
555 return new_afile (name, file_type, target, true);
558 /* Build enough state so that the parser can build its tree. */
563 obstack_begin (&stat_obstack, 1000);
565 stat_ptr = &statement_list;
567 lang_list_init (stat_ptr);
569 lang_list_init (&input_file_chain);
570 lang_list_init (&lang_output_section_statement);
571 lang_list_init (&file_chain);
572 first_file = lang_add_input_file ((char *) NULL,
573 lang_input_file_is_marker_enum,
576 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
578 abs_output_section->bfd_section = bfd_abs_section_ptr;
582 /*----------------------------------------------------------------------
583 A region is an area of memory declared with the
584 MEMORY { name:org=exp, len=exp ... }
587 We maintain a list of all the regions here.
589 If no regions are specified in the script, then the default is used
590 which is created when looked up to be the entire data space. */
592 static lang_memory_region_type *lang_memory_region_list;
593 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
595 lang_memory_region_type *
596 lang_memory_region_lookup (name)
597 const char *const name;
599 lang_memory_region_type *p;
601 for (p = lang_memory_region_list;
602 p != (lang_memory_region_type *) NULL;
605 if (strcmp (p->name, name) == 0)
612 /* This code used to always use the first region in the list as the
613 default region. I changed it to instead use a region
614 encompassing all of memory as the default region. This permits
615 NOLOAD sections to work reasonably without requiring a region.
616 People should specify what region they mean, if they really want
618 if (strcmp (name, "*default*") == 0)
620 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
622 return lang_memory_region_list;
628 lang_memory_region_type *new =
629 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
631 new->name = xstrdup (name);
632 new->next = (lang_memory_region_type *) NULL;
634 *lang_memory_region_list_tail = new;
635 lang_memory_region_list_tail = &new->next;
639 new->length = ~(bfd_size_type) 0;
641 new->had_full_message = false;
647 static lang_memory_region_type *
648 lang_memory_default (section)
651 lang_memory_region_type *p;
653 flagword sec_flags = section->flags;
655 /* Override SEC_DATA to mean a writable section. */
656 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
657 sec_flags |= SEC_DATA;
659 for (p = lang_memory_region_list;
660 p != (lang_memory_region_type *) NULL;
663 if ((p->flags & sec_flags) != 0
664 && (p->not_flags & sec_flags) == 0)
669 return lang_memory_region_lookup ("*default*");
672 lang_output_section_statement_type *
673 lang_output_section_find (name)
674 const char *const name;
676 lang_statement_union_type *u;
677 lang_output_section_statement_type *lookup;
679 for (u = lang_output_section_statement.head;
680 u != (lang_statement_union_type *) NULL;
683 lookup = &u->output_section_statement;
684 if (strcmp (name, lookup->name) == 0)
689 return (lang_output_section_statement_type *) NULL;
692 lang_output_section_statement_type *
693 lang_output_section_statement_lookup (name)
694 const char *const name;
696 lang_output_section_statement_type *lookup;
698 lookup = lang_output_section_find (name);
699 if (lookup == (lang_output_section_statement_type *) NULL)
702 lookup = (lang_output_section_statement_type *)
703 new_stat (lang_output_section_statement, stat_ptr);
704 lookup->region = (lang_memory_region_type *) NULL;
705 lookup->lma_region = (lang_memory_region_type *) NULL;
707 lookup->block_value = 1;
710 lookup->next = (lang_statement_union_type *) NULL;
711 lookup->bfd_section = (asection *) NULL;
712 lookup->processed = false;
713 lookup->sectype = normal_section;
714 lookup->addr_tree = (etree_type *) NULL;
715 lang_list_init (&lookup->children);
717 lookup->memspec = (const char *) NULL;
719 lookup->subsection_alignment = -1;
720 lookup->section_alignment = -1;
721 lookup->load_base = (union etree_union *) NULL;
722 lookup->phdrs = NULL;
724 lang_statement_append (&lang_output_section_statement,
725 (lang_statement_union_type *) lookup,
732 lang_map_flags (flag)
735 if (flag & SEC_ALLOC)
741 if (flag & SEC_READONLY)
754 lang_memory_region_type *m;
756 minfo (_("\nMemory Configuration\n\n"));
757 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
758 _("Name"), _("Origin"), _("Length"), _("Attributes"));
760 for (m = lang_memory_region_list;
761 m != (lang_memory_region_type *) NULL;
767 fprintf (config.map_file, "%-16s ", m->name);
769 sprintf_vma (buf, m->origin);
770 minfo ("0x%s ", buf);
778 minfo ("0x%V", m->length);
779 if (m->flags || m->not_flags)
787 lang_map_flags (m->flags);
793 lang_map_flags (m->not_flags);
800 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
805 /* Initialize an output section. */
809 lang_output_section_statement_type *s;
811 section_userdata_type *new;
813 if (s->bfd_section != NULL)
816 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
817 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
819 new = ((section_userdata_type *)
820 stat_alloc (sizeof (section_userdata_type)));
822 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
823 if (s->bfd_section == (asection *) NULL)
824 s->bfd_section = bfd_make_section (output_bfd, s->name);
825 if (s->bfd_section == (asection *) NULL)
827 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
828 output_bfd->xvec->name, s->name);
830 s->bfd_section->output_section = s->bfd_section;
832 /* We initialize an output sections output offset to minus its own
833 vma to allow us to output a section through itself. */
834 s->bfd_section->output_offset = 0;
835 get_userdata (s->bfd_section) = (PTR) new;
837 /* If there is a base address, make sure that any sections it might
838 mention are initialized. */
839 if (s->addr_tree != NULL)
840 exp_init_os (s->addr_tree);
843 /* Make sure that all output sections mentioned in an expression are
850 switch (exp->type.node_class)
853 exp_init_os (exp->assign.src);
857 exp_init_os (exp->binary.lhs);
858 exp_init_os (exp->binary.rhs);
862 exp_init_os (exp->trinary.cond);
863 exp_init_os (exp->trinary.lhs);
864 exp_init_os (exp->trinary.rhs);
868 exp_init_os (exp->unary.child);
872 switch (exp->type.node_code)
878 lang_output_section_statement_type *os;
880 os = lang_output_section_find (exp->name.name);
881 if (os != NULL && os->bfd_section == NULL)
892 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
893 once into the output. This routine checks each section, and
894 arrange to discard it if a section of the same name has already
895 been linked. If the section has COMDAT information, then it uses
896 that to decide whether the section should be included. This code
897 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
898 that is, it does not depend solely upon the section name.
899 section_already_linked is called via bfd_map_over_sections. */
901 /* This is the shape of the elements inside the already_linked hash
902 table. It maps a name onto a list of already_linked elements with
903 the same name. It's possible to get more than one element in a
904 list if the COMDAT sections have different names. */
906 struct already_linked_hash_entry
908 struct bfd_hash_entry root;
909 struct already_linked *entry;
912 struct already_linked
914 struct already_linked *next;
918 /* The hash table. */
920 static struct bfd_hash_table already_linked_table;
923 section_already_linked (abfd, sec, data)
928 lang_input_statement_type *entry = (lang_input_statement_type *) data;
931 struct already_linked *l;
932 struct already_linked_hash_entry *already_linked_list;
934 /* If we are only reading symbols from this object, then we want to
935 discard all sections. */
936 if (entry->just_syms_flag)
938 sec->output_section = bfd_abs_section_ptr;
939 sec->output_offset = sec->vma;
943 flags = bfd_get_section_flags (abfd, sec);
945 if ((flags & SEC_LINK_ONCE) == 0)
948 /* FIXME: When doing a relocatable link, we may have trouble
949 copying relocations in other sections that refer to local symbols
950 in the section being discarded. Those relocations will have to
951 be converted somehow; as of this writing I'm not sure that any of
952 the backends handle that correctly.
954 It is tempting to instead not discard link once sections when
955 doing a relocatable link (technically, they should be discarded
956 whenever we are building constructors). However, that fails,
957 because the linker winds up combining all the link once sections
958 into a single large link once section, which defeats the purpose
959 of having link once sections in the first place.
961 Also, not merging link once sections in a relocatable link
962 causes trouble for MIPS ELF, which relies in link once semantics
963 to handle the .reginfo section correctly. */
965 name = bfd_get_section_name (abfd, sec);
967 already_linked_list =
968 ((struct already_linked_hash_entry *)
969 bfd_hash_lookup (&already_linked_table, name, true, false));
971 for (l = already_linked_list->entry; l != NULL; l = l->next)
973 if (sec->comdat == NULL
974 || l->sec->comdat == NULL
975 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
977 /* The section has already been linked. See if we should
979 switch (flags & SEC_LINK_DUPLICATES)
984 case SEC_LINK_DUPLICATES_DISCARD:
987 case SEC_LINK_DUPLICATES_ONE_ONLY:
988 if (sec->comdat == NULL)
989 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
992 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
993 abfd, name, sec->comdat->name);
996 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
997 /* FIXME: We should really dig out the contents of both
998 sections and memcmp them. The COFF/PE spec says that
999 the Microsoft linker does not implement this
1000 correctly, so I'm not going to bother doing it
1003 case SEC_LINK_DUPLICATES_SAME_SIZE:
1004 if (bfd_section_size (abfd, sec)
1005 != bfd_section_size (l->sec->owner, l->sec))
1006 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1011 /* Set the output_section field so that wild_doit does not
1012 create a lang_input_section structure for this section.
1013 Since there might be a symbol in the section being
1014 discarded, we must retain a pointer to the section which
1015 we are really going to use. */
1016 sec->output_section = bfd_abs_section_ptr;
1017 sec->kept_section = l->sec;
1023 /* This is the first section with this name. Record it. Allocate
1024 the memory from the same obstack as the hash table is kept in. */
1026 l = ((struct already_linked *)
1027 bfd_hash_allocate (&already_linked_table, sizeof *l));
1030 l->next = already_linked_list->entry;
1031 already_linked_list->entry = l;
1034 /* Support routines for the hash table used by section_already_linked,
1035 initialize the table, fill in an entry and remove the table. */
1037 static struct bfd_hash_entry *
1038 already_linked_newfunc (entry, table, string)
1039 struct bfd_hash_entry *entry ATTRIBUTE_UNUSED;
1040 struct bfd_hash_table *table;
1041 const char *string ATTRIBUTE_UNUSED;
1043 struct already_linked_hash_entry *ret =
1044 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
1048 return (struct bfd_hash_entry *) ret;
1052 already_linked_table_init ()
1054 if (! bfd_hash_table_init_n (&already_linked_table,
1055 already_linked_newfunc,
1057 einfo (_("%P%F: Failed to create hash table\n"));
1061 already_linked_table_free ()
1063 bfd_hash_table_free (&already_linked_table);
1066 /* The wild routines.
1068 These expand statements like *(.text) and foo.o to a list of
1069 explicit actions, like foo.o(.text), bar.o(.text) and
1070 foo.o(.text, .data). */
1072 /* Return true if the PATTERN argument is a wildcard pattern.
1073 Although backslashes are treated specially if a pattern contains
1074 wildcards, we do not consider the mere presence of a backslash to
1075 be enough to cause the the pattern to be treated as a wildcard.
1076 That lets us handle DOS filenames more naturally. */
1080 const char *pattern;
1084 for (s = pattern; *s != '\0'; ++s)
1092 /* Add SECTION to the output section OUTPUT. Do this by creating a
1093 lang_input_section statement which is placed at PTR. FILE is the
1094 input file which holds SECTION. */
1097 wild_doit (ptr, section, output, file)
1098 lang_statement_list_type *ptr;
1100 lang_output_section_statement_type *output;
1101 lang_input_statement_type *file;
1106 flags = bfd_get_section_flags (section->owner, section);
1110 /* If we are doing a final link, discard sections marked with
1112 if (! link_info.relocateable
1113 && (flags & SEC_EXCLUDE) != 0)
1116 /* Discard input sections which are assigned to a section named
1117 DISCARD_SECTION_NAME. */
1118 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1121 /* Discard debugging sections if we are stripping debugging
1123 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1124 && (flags & SEC_DEBUGGING) != 0)
1129 if (section->output_section == NULL)
1131 /* This prevents future calls from assigning this section. */
1132 section->output_section = bfd_abs_section_ptr;
1137 if (section->output_section == NULL)
1140 lang_input_section_type *new;
1143 if (output->bfd_section == NULL)
1146 first = ! output->bfd_section->linker_has_input;
1147 output->bfd_section->linker_has_input = 1;
1149 /* Add a section reference to the list. */
1150 new = new_stat (lang_input_section, ptr);
1152 new->section = section;
1154 section->output_section = output->bfd_section;
1156 flags = section->flags;
1158 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1159 to an output section, because we want to be able to include a
1160 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1161 section (I don't know why we want to do this, but we do).
1162 build_link_order in ldwrite.c handles this case by turning
1163 the embedded SEC_NEVER_LOAD section into a fill. */
1165 flags &= ~ SEC_NEVER_LOAD;
1167 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1168 already been processed. One reason to do this is that on pe
1169 format targets, .text$foo sections go into .text and it's odd
1170 to see .text with SEC_LINK_ONCE set. */
1172 if (! link_info.relocateable)
1173 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1175 /* If this is not the first input section, and the SEC_READONLY
1176 flag is not currently set, then don't set it just because the
1177 input section has it set. */
1179 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1180 flags &= ~ SEC_READONLY;
1182 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1184 && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1185 != (flags & (SEC_MERGE | SEC_STRINGS))
1186 || ((flags & SEC_MERGE)
1187 && section->output_section->entsize != section->entsize)))
1189 section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1190 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1193 section->output_section->flags |= flags;
1195 if (flags & SEC_MERGE)
1196 section->output_section->entsize = section->entsize;
1198 /* If SEC_READONLY is not set in the input section, then clear
1199 it from the output section. */
1200 if ((section->flags & SEC_READONLY) == 0)
1201 section->output_section->flags &= ~SEC_READONLY;
1203 switch (output->sectype)
1205 case normal_section:
1210 case overlay_section:
1211 output->bfd_section->flags &= ~SEC_ALLOC;
1213 case noload_section:
1214 output->bfd_section->flags &= ~SEC_LOAD;
1215 output->bfd_section->flags |= SEC_NEVER_LOAD;
1219 /* Copy over SEC_SMALL_DATA. */
1220 if (section->flags & SEC_SMALL_DATA)
1221 section->output_section->flags |= SEC_SMALL_DATA;
1223 if (section->alignment_power > output->bfd_section->alignment_power)
1224 output->bfd_section->alignment_power = section->alignment_power;
1226 /* If supplied an aligment, then force it. */
1227 if (output->section_alignment != -1)
1228 output->bfd_section->alignment_power = output->section_alignment;
1230 if (section->flags & SEC_BLOCK)
1232 section->output_section->flags |= SEC_BLOCK;
1233 /* FIXME: This value should really be obtained from the bfd... */
1234 output->block_value = 128;
1239 /* Handle wildcard sorting. This returns the lang_input_section which
1240 should follow the one we are going to create for SECTION and FILE,
1241 based on the sorting requirements of WILD. It returns NULL if the
1242 new section should just go at the end of the current list. */
1244 static lang_statement_union_type *
1245 wild_sort (wild, file, section)
1246 lang_wild_statement_type *wild;
1247 lang_input_statement_type *file;
1250 const char *section_name;
1251 lang_statement_union_type *l;
1253 if (! wild->filenames_sorted && ! wild->sections_sorted)
1256 section_name = bfd_get_section_name (file->the_bfd, section);
1257 for (l = wild->children.head; l != NULL; l = l->next)
1259 lang_input_section_type *ls;
1261 if (l->header.type != lang_input_section_enum)
1263 ls = &l->input_section;
1265 /* Sorting by filename takes precedence over sorting by section
1268 if (wild->filenames_sorted)
1270 const char *fn, *ln;
1274 /* The PE support for the .idata section as generated by
1275 dlltool assumes that files will be sorted by the name of
1276 the archive and then the name of the file within the
1279 if (file->the_bfd != NULL
1280 && bfd_my_archive (file->the_bfd) != NULL)
1282 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1287 fn = file->filename;
1291 if (ls->ifile->the_bfd != NULL
1292 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1294 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1299 ln = ls->ifile->filename;
1303 i = strcmp (fn, ln);
1312 fn = file->filename;
1314 ln = ls->ifile->filename;
1316 i = strcmp (fn, ln);
1324 /* Here either the files are not sorted by name, or we are
1325 looking at the sections for this file. */
1327 if (wild->sections_sorted)
1329 if (strcmp (section_name,
1330 bfd_get_section_name (ls->ifile->the_bfd,
1340 /* Expand a wild statement for a particular FILE. SECTION may be
1341 NULL, in which case it is a wild card. */
1344 output_section_callback (ptr, section, file, output)
1345 lang_wild_statement_type *ptr;
1347 lang_input_statement_type *file;
1350 lang_statement_union_type *before;
1352 /* If the wild pattern was marked KEEP, the member sections
1353 should be as well. */
1354 if (ptr->keep_sections)
1355 section->flags |= SEC_KEEP;
1357 before = wild_sort (ptr, file, section);
1359 /* Here BEFORE points to the lang_input_section which
1360 should follow the one we are about to add. If BEFORE
1361 is NULL, then the section should just go at the end
1362 of the current list. */
1365 wild_doit (&ptr->children, section,
1366 (lang_output_section_statement_type *) output,
1370 lang_statement_list_type list;
1371 lang_statement_union_type **pp;
1373 lang_list_init (&list);
1374 wild_doit (&list, section,
1375 (lang_output_section_statement_type *) output,
1378 /* If we are discarding the section, LIST.HEAD will
1380 if (list.head != NULL)
1382 ASSERT (list.head->next == NULL);
1384 for (pp = &ptr->children.head;
1387 ASSERT (*pp != NULL);
1389 list.head->next = *pp;
1395 /* This is passed a file name which must have been seen already and
1396 added to the statement tree. We will see if it has been opened
1397 already and had its symbols read. If not then we'll read it. */
1399 static lang_input_statement_type *
1403 lang_input_statement_type *search;
1405 for (search = (lang_input_statement_type *) input_file_chain.head;
1406 search != (lang_input_statement_type *) NULL;
1407 search = (lang_input_statement_type *) search->next_real_file)
1409 if (search->filename == (char *) NULL && name == (char *) NULL)
1411 if (search->filename != (char *) NULL
1412 && name != (char *) NULL
1413 && strcmp (search->filename, name) == 0)
1417 if (search == (lang_input_statement_type *) NULL)
1418 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1421 /* If we have already added this file, or this file is not real
1422 (FIXME: can that ever actually happen?) or the name is NULL
1423 (FIXME: can that ever actually happen?) don't add this file. */
1426 || search->filename == (const char *) NULL)
1429 load_symbols (search, (lang_statement_list_type *) NULL);
1434 /* Get the symbols for an input file. */
1437 load_symbols (entry, place)
1438 lang_input_statement_type *entry;
1439 lang_statement_list_type *place;
1446 ldfile_open_file (entry);
1448 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1449 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1452 lang_statement_list_type *hold;
1454 err = bfd_get_error ();
1456 /* See if the emulation has some special knowledge. */
1457 if (ldemul_unrecognized_file (entry))
1460 if (err == bfd_error_file_ambiguously_recognized)
1464 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1465 einfo (_("%B: matching formats:"), entry->the_bfd);
1466 for (p = matching; *p != NULL; p++)
1470 else if (err != bfd_error_file_not_recognized
1472 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1474 bfd_close (entry->the_bfd);
1475 entry->the_bfd = NULL;
1477 /* Try to interpret the file as a linker script. */
1478 ldfile_open_command_file (entry->filename);
1483 ldfile_assumed_script = true;
1484 parser_input = input_script;
1486 ldfile_assumed_script = false;
1493 if (ldemul_recognized_file (entry))
1496 /* We don't call ldlang_add_file for an archive. Instead, the
1497 add_symbols entry point will call ldlang_add_file, via the
1498 add_archive_element callback, for each element of the archive
1500 switch (bfd_get_format (entry->the_bfd))
1506 ldlang_add_file (entry);
1507 if (trace_files || trace_file_tries)
1508 info_msg ("%I\n", entry);
1512 if (entry->whole_archive)
1514 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1516 while (member != NULL)
1518 if (! bfd_check_format (member, bfd_object))
1519 einfo (_("%F%B: object %B in archive is not object\n"),
1520 entry->the_bfd, member);
1521 if (! ((*link_info.callbacks->add_archive_element)
1522 (&link_info, member, "--whole-archive")))
1524 if (! bfd_link_add_symbols (member, &link_info))
1525 einfo (_("%F%B: could not read symbols: %E\n"), member);
1526 member = bfd_openr_next_archived_file (entry->the_bfd,
1530 entry->loaded = true;
1536 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1537 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1539 entry->loaded = true;
1542 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1543 indicating that it is a wildcard. Separate lang_input_section
1544 statements are created for each part of the expansion; they are
1545 added after the wild statement S. OUTPUT is the output section. */
1548 wild (s, section, file, target, output)
1549 lang_wild_statement_type *s;
1550 const char *section;
1552 const char *target ATTRIBUTE_UNUSED;
1553 lang_output_section_statement_type *output;
1555 walk_wild (s, section, file, output_section_callback, (PTR) output);
1557 if (section != (char *) NULL
1558 && strcmp (section, "COMMON") == 0
1559 && default_common_section == NULL)
1561 /* Remember the section that common is going to in case we later
1562 get something which doesn't know where to put it. */
1563 default_common_section = output;
1567 /* Return true iff target is the sought target. */
1570 get_target (target, data)
1571 const bfd_target *target;
1574 const char *sought = (const char *) data;
1576 return strcmp (target->name, sought) == 0;
1579 /* Like strcpy() but convert to lower case as well. */
1588 while ((c = *src++) != 0)
1590 if (isupper ((unsigned char) c))
1599 /* Remove the first occurance of needle (if any) in haystack
1603 strcut (haystack, needle)
1607 haystack = strstr (haystack, needle);
1613 for (src = haystack + strlen (needle); *src;)
1614 *haystack++ = *src++;
1620 /* Compare two target format name strings.
1621 Return a value indicating how "similar" they are. */
1624 name_compare (first, second)
1632 copy1 = xmalloc (strlen (first) + 1);
1633 copy2 = xmalloc (strlen (second) + 1);
1635 /* Convert the names to lower case. */
1636 stricpy (copy1, first);
1637 stricpy (copy2, second);
1639 /* Remove and endian strings from the name. */
1640 strcut (copy1, "big");
1641 strcut (copy1, "little");
1642 strcut (copy2, "big");
1643 strcut (copy2, "little");
1645 /* Return a value based on how many characters match,
1646 starting from the beginning. If both strings are
1647 the same then return 10 * their length. */
1648 for (result = 0; copy1[result] == copy2[result]; result++)
1649 if (copy1[result] == 0)
1661 /* Set by closest_target_match() below. */
1662 static const bfd_target *winner;
1664 /* Scan all the valid bfd targets looking for one that has the endianness
1665 requirement that was specified on the command line, and is the nearest
1666 match to the original output target. */
1669 closest_target_match (target, data)
1670 const bfd_target *target;
1673 const bfd_target *original = (const bfd_target *) data;
1675 if (command_line.endian == ENDIAN_BIG
1676 && target->byteorder != BFD_ENDIAN_BIG)
1679 if (command_line.endian == ENDIAN_LITTLE
1680 && target->byteorder != BFD_ENDIAN_LITTLE)
1683 /* Must be the same flavour. */
1684 if (target->flavour != original->flavour)
1687 /* If we have not found a potential winner yet, then record this one. */
1694 /* Oh dear, we now have two potential candidates for a successful match.
1695 Compare their names and choose the better one. */
1696 if (name_compare (target->name, original->name)
1697 > name_compare (winner->name, original->name))
1700 /* Keep on searching until wqe have checked them all. */
1704 /* Return the BFD target format of the first input file. */
1707 get_first_input_target ()
1709 char *target = NULL;
1711 LANG_FOR_EACH_INPUT_STATEMENT (s)
1713 if (s->header.type == lang_input_statement_enum
1716 ldfile_open_file (s);
1718 if (s->the_bfd != NULL
1719 && bfd_check_format (s->the_bfd, bfd_object))
1721 target = bfd_get_target (s->the_bfd);
1732 /* Open the output file. */
1740 /* Has the user told us which output format to use? */
1741 if (output_target == (char *) NULL)
1743 /* No - has the current target been set to something other than
1745 if (current_target != default_target)
1746 output_target = current_target;
1748 /* No - can we determine the format of the first input file? */
1751 output_target = get_first_input_target ();
1753 /* Failed - use the default output target. */
1754 if (output_target == NULL)
1755 output_target = default_target;
1759 /* Has the user requested a particular endianness on the command
1761 if (command_line.endian != ENDIAN_UNSET)
1763 const bfd_target *target;
1764 enum bfd_endian desired_endian;
1766 /* Get the chosen target. */
1767 target = bfd_search_for_target (get_target, (PTR) output_target);
1769 /* If the target is not supported, we cannot do anything. */
1772 if (command_line.endian == ENDIAN_BIG)
1773 desired_endian = BFD_ENDIAN_BIG;
1775 desired_endian = BFD_ENDIAN_LITTLE;
1777 /* See if the target has the wrong endianness. This should
1778 not happen if the linker script has provided big and
1779 little endian alternatives, but some scrips don't do
1781 if (target->byteorder != desired_endian)
1783 /* If it does, then see if the target provides
1784 an alternative with the correct endianness. */
1785 if (target->alternative_target != NULL
1786 && (target->alternative_target->byteorder == desired_endian))
1787 output_target = target->alternative_target->name;
1790 /* Try to find a target as similar as possible to
1791 the default target, but which has the desired
1792 endian characteristic. */
1793 (void) bfd_search_for_target (closest_target_match,
1796 /* Oh dear - we could not find any targets that
1797 satisfy our requirements. */
1799 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1801 output_target = winner->name;
1807 output = bfd_openw (name, output_target);
1809 if (output == (bfd *) NULL)
1811 if (bfd_get_error () == bfd_error_invalid_target)
1812 einfo (_("%P%F: target %s not found\n"), output_target);
1814 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1817 delete_output_file_on_failure = true;
1820 output->flags |= D_PAGED;
1823 if (! bfd_set_format (output, bfd_object))
1824 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1825 if (! bfd_set_arch_mach (output,
1826 ldfile_output_architecture,
1827 ldfile_output_machine))
1828 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1830 link_info.hash = bfd_link_hash_table_create (output);
1831 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1832 einfo (_("%P%F: can not create link hash table: %E\n"));
1834 bfd_set_gp_size (output, g_switch_value);
1839 ldlang_open_output (statement)
1840 lang_statement_union_type *statement;
1842 switch (statement->header.type)
1844 case lang_output_statement_enum:
1845 ASSERT (output_bfd == (bfd *) NULL);
1846 output_bfd = open_output (statement->output_statement.name);
1847 ldemul_set_output_arch ();
1848 if (config.magic_demand_paged && !link_info.relocateable)
1849 output_bfd->flags |= D_PAGED;
1851 output_bfd->flags &= ~D_PAGED;
1852 if (config.text_read_only)
1853 output_bfd->flags |= WP_TEXT;
1855 output_bfd->flags &= ~WP_TEXT;
1856 if (link_info.traditional_format)
1857 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1859 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1862 case lang_target_statement_enum:
1863 current_target = statement->target_statement.target;
1870 /* Open all the input files. */
1873 open_input_bfds (s, force)
1874 lang_statement_union_type *s;
1877 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1879 switch (s->header.type)
1881 case lang_constructors_statement_enum:
1882 open_input_bfds (constructor_list.head, force);
1884 case lang_output_section_statement_enum:
1885 open_input_bfds (s->output_section_statement.children.head, force);
1887 case lang_wild_statement_enum:
1888 /* Maybe we should load the file's symbols. */
1889 if (s->wild_statement.filename
1890 && ! wildcardp (s->wild_statement.filename))
1891 (void) lookup_name (s->wild_statement.filename);
1892 open_input_bfds (s->wild_statement.children.head, force);
1894 case lang_group_statement_enum:
1896 struct bfd_link_hash_entry *undefs;
1898 /* We must continually search the entries in the group
1899 until no new symbols are added to the list of undefined
1904 undefs = link_info.hash->undefs_tail;
1905 open_input_bfds (s->group_statement.children.head, true);
1907 while (undefs != link_info.hash->undefs_tail);
1910 case lang_target_statement_enum:
1911 current_target = s->target_statement.target;
1913 case lang_input_statement_enum:
1914 if (s->input_statement.real)
1916 lang_statement_list_type add;
1917 bfd_error_handler_type pfn;
1919 s->input_statement.target = current_target;
1921 /* If we are being called from within a group, and this
1922 is an archive which has already been searched, then
1923 force it to be researched unless the whole archive
1924 has been loaded already. */
1926 && !s->input_statement.whole_archive
1927 && s->input_statement.loaded
1928 && bfd_check_format (s->input_statement.the_bfd,
1930 s->input_statement.loaded = false;
1932 lang_list_init (&add);
1934 /* We need to know if an error occurs whilst loading the
1935 symbols, since this means that a valid executable can
1937 pfn = bfd_set_error_handler (record_bfd_errors);
1939 load_symbols (&s->input_statement, &add);
1941 bfd_set_error_handler (pfn);
1943 if (add.head != NULL)
1945 *add.tail = s->next;
1956 /* If there are [COMMONS] statements, put a wild one into the bss
1960 lang_reasonable_defaults ()
1963 lang_output_section_statement_lookup (".text");
1964 lang_output_section_statement_lookup (".data");
1966 default_common_section = lang_output_section_statement_lookup (".bss");
1968 if (placed_commons == false)
1970 lang_wild_statement_type *new =
1971 new_stat (lang_wild_statement,
1972 &default_common_section->children);
1974 new->section_name = "COMMON";
1975 new->filename = (char *) NULL;
1976 lang_list_init (&new->children);
1981 /* Add the supplied name to the symbol table as an undefined reference.
1982 Remove items from the chain as we open input bfds. */
1983 typedef struct ldlang_undef_chain_list
1985 struct ldlang_undef_chain_list *next;
1987 } ldlang_undef_chain_list_type;
1989 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1992 ldlang_add_undef (name)
1993 const char *const name;
1995 ldlang_undef_chain_list_type *new =
1996 ((ldlang_undef_chain_list_type *)
1997 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1999 new->next = ldlang_undef_chain_list_head;
2000 ldlang_undef_chain_list_head = new;
2002 new->name = xstrdup (name);
2005 /* Run through the list of undefineds created above and place them
2006 into the linker hash table as undefined symbols belonging to the
2010 lang_place_undefineds ()
2012 ldlang_undef_chain_list_type *ptr;
2014 for (ptr = ldlang_undef_chain_list_head;
2015 ptr != (ldlang_undef_chain_list_type *) NULL;
2018 struct bfd_link_hash_entry *h;
2020 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2021 if (h == (struct bfd_link_hash_entry *) NULL)
2022 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2023 if (h->type == bfd_link_hash_new)
2025 h->type = bfd_link_hash_undefined;
2026 h->u.undef.abfd = NULL;
2027 bfd_link_add_undef (link_info.hash, h);
2032 /* Open input files and attatch to output sections. */
2035 map_input_to_output_sections (s, target, output_section_statement)
2036 lang_statement_union_type *s;
2038 lang_output_section_statement_type *output_section_statement;
2040 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2042 switch (s->header.type)
2045 case lang_wild_statement_enum:
2046 wild (&s->wild_statement, s->wild_statement.section_name,
2047 s->wild_statement.filename, target,
2048 output_section_statement);
2051 case lang_constructors_statement_enum:
2052 map_input_to_output_sections (constructor_list.head,
2054 output_section_statement);
2056 case lang_output_section_statement_enum:
2057 map_input_to_output_sections (s->output_section_statement.children.head,
2059 &s->output_section_statement);
2061 case lang_output_statement_enum:
2063 case lang_target_statement_enum:
2064 target = s->target_statement.target;
2066 case lang_group_statement_enum:
2067 map_input_to_output_sections (s->group_statement.children.head,
2069 output_section_statement);
2071 case lang_fill_statement_enum:
2072 case lang_input_section_enum:
2073 case lang_object_symbols_statement_enum:
2074 case lang_data_statement_enum:
2075 case lang_reloc_statement_enum:
2076 case lang_padding_statement_enum:
2077 case lang_input_statement_enum:
2078 if (output_section_statement != NULL
2079 && output_section_statement->bfd_section == NULL)
2080 init_os (output_section_statement);
2082 case lang_assignment_statement_enum:
2083 if (output_section_statement != NULL
2084 && output_section_statement->bfd_section == NULL)
2085 init_os (output_section_statement);
2087 /* Make sure that any sections mentioned in the assignment
2089 exp_init_os (s->assignment_statement.exp);
2091 case lang_afile_asection_pair_statement_enum:
2094 case lang_address_statement_enum:
2095 /* Mark the specified section with the supplied address. */
2097 lang_output_section_statement_type *os =
2098 lang_output_section_statement_lookup
2099 (s->address_statement.section_name);
2101 if (os->bfd_section == NULL)
2103 os->addr_tree = s->address_statement.address;
2111 print_output_section_statement (output_section_statement)
2112 lang_output_section_statement_type *output_section_statement;
2114 asection *section = output_section_statement->bfd_section;
2117 if (output_section_statement != abs_output_section)
2119 minfo ("\n%s", output_section_statement->name);
2121 if (section != NULL)
2123 print_dot = section->vma;
2125 len = strlen (output_section_statement->name);
2126 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2131 while (len < SECTION_NAME_MAP_LENGTH)
2137 minfo ("0x%V %W", section->vma, section->_raw_size);
2139 if (output_section_statement->load_base != NULL)
2143 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2144 "load base", lang_final_phase_enum);
2145 minfo (_(" load address 0x%V"), addr);
2152 print_statement_list (output_section_statement->children.head,
2153 output_section_statement);
2157 print_assignment (assignment, output_section)
2158 lang_assignment_statement_type *assignment;
2159 lang_output_section_statement_type *output_section;
2162 etree_value_type result;
2164 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2167 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2168 lang_final_phase_enum, print_dot, &print_dot);
2170 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2181 exp_print_tree (assignment->exp);
2187 print_input_statement (statm)
2188 lang_input_statement_type *statm;
2190 if (statm->filename != (char *) NULL)
2192 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2196 /* Print all symbols defined in a particular section. This is called
2197 via bfd_link_hash_traverse. */
2200 print_one_symbol (hash_entry, ptr)
2201 struct bfd_link_hash_entry *hash_entry;
2204 asection *sec = (asection *) ptr;
2206 if ((hash_entry->type == bfd_link_hash_defined
2207 || hash_entry->type == bfd_link_hash_defweak)
2208 && sec == hash_entry->u.def.section)
2212 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2215 (hash_entry->u.def.value
2216 + hash_entry->u.def.section->output_offset
2217 + hash_entry->u.def.section->output_section->vma));
2219 minfo (" %T\n", hash_entry->root.string);
2225 /* Print information about an input section to the map file. */
2228 print_input_section (in)
2229 lang_input_section_type *in;
2231 asection *i = in->section;
2232 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2233 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2234 ldfile_output_machine);
2239 minfo ("%s", i->name);
2241 if (i->output_section != NULL)
2245 len = 1 + strlen (i->name);
2246 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2251 while (len < SECTION_NAME_MAP_LENGTH)
2257 minfo ("0x%V %W %B\n",
2258 i->output_section->vma + i->output_offset, size / opb,
2261 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2263 len = SECTION_NAME_MAP_LENGTH + 3;
2275 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2278 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2280 print_dot = i->output_section->vma + i->output_offset + size / opb;
2286 print_fill_statement (fill)
2287 lang_fill_statement_type *fill;
2289 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2293 print_data_statement (data)
2294 lang_data_statement_type *data;
2300 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2301 ldfile_output_machine);
2303 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2306 addr = data->output_vma;
2307 if (data->output_section != NULL)
2308 addr += data->output_section->vma;
2336 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2338 if (data->exp->type.node_class != etree_value)
2341 exp_print_tree (data->exp);
2346 print_dot = addr + size / opb;
2350 /* Print an address statement. These are generated by options like
2354 print_address_statement (address)
2355 lang_address_statement_type *address;
2357 minfo (_("Address of section %s set to "), address->section_name);
2358 exp_print_tree (address->address);
2362 /* Print a reloc statement. */
2365 print_reloc_statement (reloc)
2366 lang_reloc_statement_type *reloc;
2371 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2372 ldfile_output_machine);
2374 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2377 addr = reloc->output_vma;
2378 if (reloc->output_section != NULL)
2379 addr += reloc->output_section->vma;
2381 size = bfd_get_reloc_size (reloc->howto);
2383 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2385 if (reloc->name != NULL)
2386 minfo ("%s+", reloc->name);
2388 minfo ("%s+", reloc->section->name);
2390 exp_print_tree (reloc->addend_exp);
2394 print_dot = addr + size / opb;
2398 print_padding_statement (s)
2399 lang_padding_statement_type *s;
2403 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2404 ldfile_output_machine);
2408 len = sizeof " *fill*" - 1;
2409 while (len < SECTION_NAME_MAP_LENGTH)
2415 addr = s->output_offset;
2416 if (s->output_section != NULL)
2417 addr += s->output_section->vma;
2418 minfo ("0x%V %W", addr, s->size);
2421 minfo (" %u", s->fill);
2425 print_dot = addr + s->size / opb;
2429 print_wild_statement (w, os)
2430 lang_wild_statement_type *w;
2431 lang_output_section_statement_type *os;
2435 if (w->filenames_sorted)
2437 if (w->exclude_filename_list != NULL)
2440 minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
2441 for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
2442 minfo (", %s", tmp->name);
2445 if (w->filename != NULL)
2446 minfo ("%s", w->filename);
2449 if (w->filenames_sorted)
2453 if (w->sections_sorted)
2455 if (w->section_name != NULL)
2456 minfo ("%s", w->section_name);
2459 if (w->sections_sorted)
2465 print_statement_list (w->children.head, os);
2468 /* Print a group statement. */
2472 lang_group_statement_type *s;
2473 lang_output_section_statement_type *os;
2475 fprintf (config.map_file, "START GROUP\n");
2476 print_statement_list (s->children.head, os);
2477 fprintf (config.map_file, "END GROUP\n");
2480 /* Print the list of statements in S.
2481 This can be called for any statement type. */
2484 print_statement_list (s, os)
2485 lang_statement_union_type *s;
2486 lang_output_section_statement_type *os;
2490 print_statement (s, os);
2495 /* Print the first statement in statement list S.
2496 This can be called for any statement type. */
2499 print_statement (s, os)
2500 lang_statement_union_type *s;
2501 lang_output_section_statement_type *os;
2503 switch (s->header.type)
2506 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2509 case lang_constructors_statement_enum:
2510 if (constructor_list.head != NULL)
2512 if (constructors_sorted)
2513 minfo (" SORT (CONSTRUCTORS)\n");
2515 minfo (" CONSTRUCTORS\n");
2516 print_statement_list (constructor_list.head, os);
2519 case lang_wild_statement_enum:
2520 print_wild_statement (&s->wild_statement, os);
2522 case lang_address_statement_enum:
2523 print_address_statement (&s->address_statement);
2525 case lang_object_symbols_statement_enum:
2526 minfo (" CREATE_OBJECT_SYMBOLS\n");
2528 case lang_fill_statement_enum:
2529 print_fill_statement (&s->fill_statement);
2531 case lang_data_statement_enum:
2532 print_data_statement (&s->data_statement);
2534 case lang_reloc_statement_enum:
2535 print_reloc_statement (&s->reloc_statement);
2537 case lang_input_section_enum:
2538 print_input_section (&s->input_section);
2540 case lang_padding_statement_enum:
2541 print_padding_statement (&s->padding_statement);
2543 case lang_output_section_statement_enum:
2544 print_output_section_statement (&s->output_section_statement);
2546 case lang_assignment_statement_enum:
2547 print_assignment (&s->assignment_statement, os);
2549 case lang_target_statement_enum:
2550 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2552 case lang_output_statement_enum:
2553 minfo ("OUTPUT(%s", s->output_statement.name);
2554 if (output_target != NULL)
2555 minfo (" %s", output_target);
2558 case lang_input_statement_enum:
2559 print_input_statement (&s->input_statement);
2561 case lang_group_statement_enum:
2562 print_group (&s->group_statement, os);
2564 case lang_afile_asection_pair_statement_enum:
2573 print_statement_list (statement_list.head, abs_output_section);
2576 /* Print the first N statements in statement list S to STDERR.
2577 If N == 0, nothing is printed.
2578 If N < 0, the entire list is printed.
2579 Intended to be called from GDB. */
2582 dprint_statement (s, n)
2583 lang_statement_union_type *s;
2586 FILE *map_save = config.map_file;
2588 config.map_file = stderr;
2591 print_statement_list (s, abs_output_section);
2594 while (s && --n >= 0)
2596 print_statement (s, abs_output_section);
2601 config.map_file = map_save;
2605 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2606 lang_statement_union_type **this_ptr;
2609 asection *output_section_statement;
2612 /* Align this section first to the
2613 input sections requirement, then
2614 to the output section's requirement.
2615 If this alignment is > than any seen before,
2616 then record it too. Perform the alignment by
2617 inserting a magic 'padding' statement. */
2619 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2620 ldfile_output_machine);
2621 unsigned int alignment_needed = align_power (dot, power) - dot;
2623 if (alignment_needed != 0)
2625 lang_statement_union_type *new =
2626 ((lang_statement_union_type *)
2627 stat_alloc (sizeof (lang_padding_statement_type)));
2629 /* Link into existing chain. */
2630 new->header.next = *this_ptr;
2632 new->header.type = lang_padding_statement_enum;
2633 new->padding_statement.output_section = output_section_statement;
2634 new->padding_statement.output_offset =
2635 dot - output_section_statement->vma;
2636 new->padding_statement.fill = fill;
2637 new->padding_statement.size = alignment_needed * opb;
2640 /* Remember the most restrictive alignment. */
2641 if (power > output_section_statement->alignment_power)
2643 output_section_statement->alignment_power = power;
2645 output_section_statement->_raw_size += alignment_needed * opb;
2647 return dot + alignment_needed;
2650 /* Work out how much this section will move the dot point. */
2653 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2654 lang_statement_union_type **this_ptr;
2655 lang_output_section_statement_type *output_section_statement;
2658 boolean relax ATTRIBUTE_UNUSED;
2660 lang_input_section_type *is = &((*this_ptr)->input_section);
2661 asection *i = is->section;
2662 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2663 ldfile_output_machine);
2665 if (is->ifile->just_syms_flag == false)
2667 if (output_section_statement->subsection_alignment != -1)
2668 i->alignment_power =
2669 output_section_statement->subsection_alignment;
2671 dot = insert_pad (this_ptr, fill, i->alignment_power,
2672 output_section_statement->bfd_section, dot);
2674 /* Remember where in the output section this input section goes. */
2676 i->output_offset = dot - output_section_statement->bfd_section->vma;
2678 /* Mark how big the output section must be to contain this now. */
2679 if (i->_cooked_size != 0)
2680 dot += i->_cooked_size / opb;
2682 dot += i->_raw_size / opb;
2683 output_section_statement->bfd_section->_raw_size =
2684 (dot - output_section_statement->bfd_section->vma) * opb;
2688 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2694 #define IGNORE_SECTION(bfd, s) \
2695 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2696 != (SEC_ALLOC | SEC_LOAD)) \
2697 || bfd_section_size (bfd, s) == 0)
2699 /* Check to see if any allocated sections overlap with other allocated
2700 sections. This can happen when the linker script specifically specifies
2701 the output section addresses of the two sections. */
2704 lang_check_section_addresses ()
2707 unsigned opb = bfd_octets_per_byte (output_bfd);
2709 /* Scan all sections in the output list. */
2710 for (s = output_bfd->sections; s != NULL; s = s->next)
2714 /* Ignore sections which are not loaded or which have no contents. */
2715 if (IGNORE_SECTION (output_bfd, s))
2718 /* Once we reach section 's' stop our seach. This prevents two
2719 warning messages from being produced, one for 'section A overlaps
2720 section B' and one for 'section B overlaps section A'. */
2721 for (os = output_bfd->sections; os != s; os = os->next)
2728 /* Only consider loadable sections with real contents. */
2729 if (IGNORE_SECTION (output_bfd, os))
2732 /* We must check the sections' LMA addresses not their
2733 VMA addresses because overlay sections can have
2734 overlapping VMAs but they must have distinct LMAs. */
2735 s_start = bfd_section_lma (output_bfd, s);
2736 os_start = bfd_section_lma (output_bfd, os);
2737 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2738 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2740 /* Look for an overlap. */
2741 if ((s_end < os_start) || (s_start > os_end))
2745 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2746 s->name, s_start, s_end, os->name, os_start, os_end);
2748 /* Once we have found one overlap for this section,
2749 stop looking for others. */
2755 /* This variable indicates whether bfd_relax_section should be called
2758 static boolean relax_again;
2760 /* Make sure the new address is within the region. We explicitly permit the
2761 current address to be at the exact end of the region when the address is
2762 non-zero, in case the region is at the end of addressable memory and the
2763 calculation wraps around. */
2766 os_region_check (os, region, tree, base)
2767 lang_output_section_statement_type *os;
2768 struct memory_region_struct *region;
2772 if ((region->current < region->origin
2773 || (region->current - region->origin > region->length))
2774 && ((region->current != region->origin + region->length)
2777 if (tree != (etree_type *) NULL)
2779 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2781 os->bfd_section->owner,
2782 os->bfd_section->name,
2787 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2789 os->bfd_section->owner,
2790 os->bfd_section->name);
2792 /* Reset the region pointer. */
2793 region->current = region->origin;
2797 /* Set the sizes for all the output sections. */
2800 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2801 lang_statement_union_type *s;
2802 lang_output_section_statement_type *output_section_statement;
2803 lang_statement_union_type **prev;
2808 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2809 ldfile_output_machine);
2811 /* Size up the sections from their constituent parts. */
2812 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2814 switch (s->header.type)
2816 case lang_output_section_statement_enum:
2819 lang_output_section_statement_type *os;
2821 os = &s->output_section_statement;
2822 if (os->bfd_section == NULL)
2823 /* This section was never actually created. */
2826 /* If this is a COFF shared library section, use the size and
2827 address from the input section. FIXME: This is COFF
2828 specific; it would be cleaner if there were some other way
2829 to do this, but nothing simple comes to mind. */
2830 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2834 if (os->children.head == NULL
2835 || os->children.head->next != NULL
2836 || os->children.head->header.type != lang_input_section_enum)
2837 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2840 input = os->children.head->input_section.section;
2841 bfd_set_section_vma (os->bfd_section->owner,
2843 bfd_section_vma (input->owner, input));
2844 os->bfd_section->_raw_size = input->_raw_size;
2848 if (bfd_is_abs_section (os->bfd_section))
2850 /* No matter what happens, an abs section starts at zero. */
2851 ASSERT (os->bfd_section->vma == 0);
2855 if (os->addr_tree == (etree_type *) NULL)
2857 /* No address specified for this section, get one
2858 from the region specification. */
2859 if (os->region == (lang_memory_region_type *) NULL
2860 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2861 & (SEC_ALLOC | SEC_LOAD)) != 0)
2862 && os->region->name[0] == '*'
2863 && strcmp (os->region->name, "*default*") == 0))
2865 os->region = lang_memory_default (os->bfd_section);
2868 /* If a loadable section is using the default memory
2869 region, and some non default memory regions were
2870 defined, issue a warning. */
2871 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2872 & (SEC_ALLOC | SEC_LOAD)) != 0
2873 && ! link_info.relocateable
2874 && strcmp (os->region->name, "*default*") == 0
2875 && lang_memory_region_list != NULL
2876 && (strcmp (lang_memory_region_list->name,
2878 || lang_memory_region_list->next != NULL))
2879 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2880 bfd_get_section_name (output_bfd,
2883 dot = os->region->current;
2885 if (os->section_alignment == -1)
2890 dot = align_power (dot,
2891 os->bfd_section->alignment_power);
2893 if (dot != olddot && config.warn_section_align)
2894 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2895 os->name, (unsigned int) (dot - olddot));
2902 r = exp_fold_tree (os->addr_tree,
2904 lang_allocating_phase_enum,
2906 if (r.valid_p == false)
2908 einfo (_("%F%S: non constant address expression for section %s\n"),
2911 dot = r.value + r.section->bfd_section->vma;
2914 /* The section starts here.
2915 First, align to what the section needs. */
2917 if (os->section_alignment != -1)
2918 dot = align_power (dot, os->section_alignment);
2920 bfd_set_section_vma (0, os->bfd_section, dot);
2922 os->bfd_section->output_offset = 0;
2925 (void) lang_size_sections (os->children.head, os,
2927 os->fill, dot, relax);
2929 /* Put the section within the requested block size, or
2930 align at the block boundary. */
2931 after = ALIGN_N (os->bfd_section->vma
2932 + os->bfd_section->_raw_size / opb,
2933 /* The coercion here is important, see ld.h. */
2934 (bfd_vma) os->block_value);
2936 if (bfd_is_abs_section (os->bfd_section))
2937 ASSERT (after == os->bfd_section->vma);
2939 os->bfd_section->_raw_size =
2940 (after - os->bfd_section->vma) * opb;
2941 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2942 os->processed = true;
2944 /* Update dot in the region ?
2945 We only do this if the section is going to be allocated,
2946 since unallocated sections do not contribute to the region's
2947 overall size in memory.
2949 If the SEC_NEVER_LOAD bit is not set, it will affect the
2950 addresses of sections after it. We have to update
2952 if (os->region != (lang_memory_region_type *) NULL
2953 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2954 & SEC_NEVER_LOAD) == 0
2955 || (bfd_get_section_flags (output_bfd, os->bfd_section)
2956 & (SEC_ALLOC | SEC_LOAD))))
2958 os->region->current = dot;
2960 /* Make sure the new address is within the region. */
2961 os_region_check (os, os->region, os->addr_tree,
2962 os->bfd_section->vma);
2964 /* If there's no load address specified, use the run
2965 region as the load region. */
2966 if (os->lma_region == NULL && os->load_base == NULL)
2967 os->lma_region = os->region;
2969 if (os->lma_region != NULL)
2971 if (os->load_base != NULL)
2973 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2977 /* Don't allocate twice. */
2978 if (os->lma_region != os->region)
2980 /* Set load_base, which will be handled later. */
2982 exp_intop (os->lma_region->current);
2983 os->lma_region->current +=
2984 os->bfd_section->_raw_size / opb;
2985 os_region_check (os, os->lma_region, NULL,
2986 os->bfd_section->lma);
2994 case lang_constructors_statement_enum:
2995 dot = lang_size_sections (constructor_list.head,
2996 output_section_statement,
2997 &s->wild_statement.children.head,
3002 case lang_data_statement_enum:
3004 unsigned int size = 0;
3006 s->data_statement.output_vma =
3007 dot - output_section_statement->bfd_section->vma;
3008 s->data_statement.output_section =
3009 output_section_statement->bfd_section;
3011 switch (s->data_statement.type)
3032 output_section_statement->bfd_section->_raw_size += size;
3033 /* The output section gets contents, and then we inspect for
3034 any flags set in the input script which override any ALLOC. */
3035 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3036 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3038 output_section_statement->bfd_section->flags |=
3039 SEC_ALLOC | SEC_LOAD;
3044 case lang_reloc_statement_enum:
3048 s->reloc_statement.output_vma =
3049 dot - output_section_statement->bfd_section->vma;
3050 s->reloc_statement.output_section =
3051 output_section_statement->bfd_section;
3052 size = bfd_get_reloc_size (s->reloc_statement.howto);
3054 output_section_statement->bfd_section->_raw_size += size;
3058 case lang_wild_statement_enum:
3060 dot = lang_size_sections (s->wild_statement.children.head,
3061 output_section_statement,
3062 &s->wild_statement.children.head,
3067 case lang_object_symbols_statement_enum:
3068 link_info.create_object_symbols_section =
3069 output_section_statement->bfd_section;
3071 case lang_output_statement_enum:
3072 case lang_target_statement_enum:
3074 case lang_input_section_enum:
3078 i = (*prev)->input_section.section;
3081 if (i->_cooked_size == 0)
3082 i->_cooked_size = i->_raw_size;
3088 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3089 einfo (_("%P%F: can't relax section: %E\n"));
3093 dot = size_input_section (prev,
3094 output_section_statement,
3095 output_section_statement->fill,
3099 case lang_input_statement_enum:
3101 case lang_fill_statement_enum:
3102 s->fill_statement.output_section =
3103 output_section_statement->bfd_section;
3105 fill = s->fill_statement.fill;
3107 case lang_assignment_statement_enum:
3109 bfd_vma newdot = dot;
3111 exp_fold_tree (s->assignment_statement.exp,
3112 output_section_statement,
3113 lang_allocating_phase_enum,
3119 /* The assignment changed dot. Insert a pad. */
3120 if (output_section_statement == abs_output_section)
3122 /* If we don't have an output section, then just adjust
3123 the default memory address. */
3124 lang_memory_region_lookup ("*default*")->current = newdot;
3128 lang_statement_union_type *new =
3129 ((lang_statement_union_type *)
3130 stat_alloc (sizeof (lang_padding_statement_type)));
3132 /* Link into existing chain. */
3133 new->header.next = *prev;
3135 new->header.type = lang_padding_statement_enum;
3136 new->padding_statement.output_section =
3137 output_section_statement->bfd_section;
3138 new->padding_statement.output_offset =
3139 dot - output_section_statement->bfd_section->vma;
3140 new->padding_statement.fill = fill;
3141 new->padding_statement.size = (newdot - dot) * opb;
3142 output_section_statement->bfd_section->_raw_size +=
3143 new->padding_statement.size;
3151 case lang_padding_statement_enum:
3152 /* If we are relaxing, and this is not the first pass, some
3153 padding statements may have been inserted during previous
3154 passes. We may have to move the padding statement to a new
3155 location if dot has a different value at this point in this
3156 pass than it did at this point in the previous pass. */
3157 s->padding_statement.output_offset =
3158 dot - output_section_statement->bfd_section->vma;
3159 dot += s->padding_statement.size / opb;
3160 output_section_statement->bfd_section->_raw_size +=
3161 s->padding_statement.size;
3164 case lang_group_statement_enum:
3165 dot = lang_size_sections (s->group_statement.children.head,
3166 output_section_statement,
3167 &s->group_statement.children.head,
3175 /* This can only get here when relaxing is turned on. */
3177 case lang_address_statement_enum:
3180 prev = &s->header.next;
3186 lang_do_assignments (s, output_section_statement, fill, dot)
3187 lang_statement_union_type *s;
3188 lang_output_section_statement_type *output_section_statement;
3192 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3193 ldfile_output_machine);
3195 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3197 switch (s->header.type)
3199 case lang_constructors_statement_enum:
3200 dot = lang_do_assignments (constructor_list.head,
3201 output_section_statement,
3206 case lang_output_section_statement_enum:
3208 lang_output_section_statement_type *os;
3210 os = &(s->output_section_statement);
3211 if (os->bfd_section != NULL)
3213 dot = os->bfd_section->vma;
3214 (void) lang_do_assignments (os->children.head, os,
3216 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3221 /* If nothing has been placed into the output section then
3222 it won't have a bfd_section. */
3223 if (os->bfd_section)
3225 os->bfd_section->lma
3226 = exp_get_abs_int (os->load_base, 0, "load base",
3227 lang_final_phase_enum);
3232 case lang_wild_statement_enum:
3234 dot = lang_do_assignments (s->wild_statement.children.head,
3235 output_section_statement,
3240 case lang_object_symbols_statement_enum:
3241 case lang_output_statement_enum:
3242 case lang_target_statement_enum:
3244 case lang_common_statement_enum:
3247 case lang_data_statement_enum:
3249 etree_value_type value;
3251 value = exp_fold_tree (s->data_statement.exp,
3253 lang_final_phase_enum, dot, &dot);
3254 s->data_statement.value = value.value;
3255 if (value.valid_p == false)
3256 einfo (_("%F%P: invalid data statement\n"));
3260 switch (s->data_statement.type)
3284 case lang_reloc_statement_enum:
3286 etree_value_type value;
3288 value = exp_fold_tree (s->reloc_statement.addend_exp,
3290 lang_final_phase_enum, dot, &dot);
3291 s->reloc_statement.addend_value = value.value;
3292 if (value.valid_p == false)
3293 einfo (_("%F%P: invalid reloc statement\n"));
3295 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3298 case lang_input_section_enum:
3300 asection *in = s->input_section.section;
3302 if (in->_cooked_size != 0)
3303 dot += in->_cooked_size / opb;
3305 dot += in->_raw_size / opb;
3309 case lang_input_statement_enum:
3311 case lang_fill_statement_enum:
3312 fill = s->fill_statement.fill;
3314 case lang_assignment_statement_enum:
3316 exp_fold_tree (s->assignment_statement.exp,
3317 output_section_statement,
3318 lang_final_phase_enum,
3324 case lang_padding_statement_enum:
3325 dot += s->padding_statement.size / opb;
3328 case lang_group_statement_enum:
3329 dot = lang_do_assignments (s->group_statement.children.head,
3330 output_section_statement,
3338 case lang_address_statement_enum:
3346 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3347 operator .startof. (section_name), it produces an undefined symbol
3348 .startof.section_name. Similarly, when it sees
3349 .sizeof. (section_name), it produces an undefined symbol
3350 .sizeof.section_name. For all the output sections, we look for
3351 such symbols, and set them to the correct value. */
3358 if (link_info.relocateable)
3361 for (s = output_bfd->sections; s != NULL; s = s->next)
3363 const char *secname;
3365 struct bfd_link_hash_entry *h;
3367 secname = bfd_get_section_name (output_bfd, s);
3368 buf = xmalloc (10 + strlen (secname));
3370 sprintf (buf, ".startof.%s", secname);
3371 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3372 if (h != NULL && h->type == bfd_link_hash_undefined)
3374 h->type = bfd_link_hash_defined;
3375 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3376 h->u.def.section = bfd_abs_section_ptr;
3379 sprintf (buf, ".sizeof.%s", secname);
3380 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3381 if (h != NULL && h->type == bfd_link_hash_undefined)
3385 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3386 ldfile_output_machine);
3387 h->type = bfd_link_hash_defined;
3388 if (s->_cooked_size != 0)
3389 h->u.def.value = s->_cooked_size / opb;
3391 h->u.def.value = s->_raw_size / opb;
3392 h->u.def.section = bfd_abs_section_ptr;
3402 struct bfd_link_hash_entry *h;
3405 if (link_info.relocateable || link_info.shared)
3410 if (entry_symbol == (char *) NULL)
3412 /* No entry has been specified. Look for start, but don't warn
3413 if we don't find it. */
3414 entry_symbol = "start";
3418 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3419 if (h != (struct bfd_link_hash_entry *) NULL
3420 && (h->type == bfd_link_hash_defined
3421 || h->type == bfd_link_hash_defweak)
3422 && h->u.def.section->output_section != NULL)
3426 val = (h->u.def.value
3427 + bfd_get_section_vma (output_bfd,
3428 h->u.def.section->output_section)
3429 + h->u.def.section->output_offset);
3430 if (! bfd_set_start_address (output_bfd, val))
3431 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3438 /* We couldn't find the entry symbol. Try parsing it as a
3440 val = bfd_scan_vma (entry_symbol, &send, 0);
3443 if (! bfd_set_start_address (output_bfd, val))
3444 einfo (_("%P%F: can't set start address\n"));
3450 /* Can't find the entry symbol, and it's not a number. Use
3451 the first address in the text section. */
3452 ts = bfd_get_section_by_name (output_bfd, ".text");
3453 if (ts != (asection *) NULL)
3456 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3457 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3458 if (! bfd_set_start_address (output_bfd,
3459 bfd_get_section_vma (output_bfd,
3461 einfo (_("%P%F: can't set start address\n"));
3466 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3473 /* This is the routine to handle BFD error messages. */
3475 #ifdef ANSI_PROTOTYPES
3478 record_bfd_errors (const char *s, ...)
3486 vfprintf (stderr, s, p);
3490 fprintf (stderr, "\n");
3495 #else /* ! defined (ANSI_PROTOTYPES) */
3498 record_bfd_errors (va_alist)
3508 s = va_arg (p, const char *);
3509 vfprintf (stderr, s, p);
3513 fprintf (stderr, "\n");
3518 #endif /* ! defined (ANSI_PROTOTYPES) */
3520 /* This is a small function used when we want to ignore errors from
3524 #ifdef ANSI_PROTOTYPES
3525 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3527 ignore_bfd_errors (s)
3528 const char *s ATTRIBUTE_UNUSED;
3531 /* Don't do anything. */
3534 /* Check that the architecture of all the input files is compatible
3535 with the output file. Also call the backend to let it do any
3536 other checking that is needed. */
3541 lang_statement_union_type *file;
3543 const bfd_arch_info_type *compatible;
3545 for (file = file_chain.head;
3546 file != (lang_statement_union_type *) NULL;
3547 file = file->input_statement.next)
3549 input_bfd = file->input_statement.the_bfd;
3550 compatible = bfd_arch_get_compatible (input_bfd,
3552 if (compatible == NULL)
3554 if (command_line.warn_mismatch)
3555 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3556 bfd_printable_name (input_bfd), input_bfd,
3557 bfd_printable_name (output_bfd));
3559 else if (bfd_count_sections (input_bfd))
3561 /* If the input bfd has no contents, it shouldn't set the
3562 private data of the output bfd. */
3564 bfd_error_handler_type pfn = NULL;
3566 /* If we aren't supposed to warn about mismatched input
3567 files, temporarily set the BFD error handler to a
3568 function which will do nothing. We still want to call
3569 bfd_merge_private_bfd_data, since it may set up
3570 information which is needed in the output file. */
3571 if (! command_line.warn_mismatch)
3572 pfn = bfd_set_error_handler (ignore_bfd_errors);
3573 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3575 if (command_line.warn_mismatch)
3576 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3579 if (! command_line.warn_mismatch)
3580 bfd_set_error_handler (pfn);
3585 /* Look through all the global common symbols and attach them to the
3586 correct section. The -sort-common command line switch may be used
3587 to roughly sort the entries by size. */
3592 if (link_info.relocateable
3593 && ! command_line.force_common_definition)
3596 if (! config.sort_common)
3597 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3602 for (power = 4; power >= 0; power--)
3603 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3608 /* Place one common symbol in the correct section. */
3611 lang_one_common (h, info)
3612 struct bfd_link_hash_entry *h;
3615 unsigned int power_of_two;
3618 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3619 ldfile_output_machine);
3621 if (h->type != bfd_link_hash_common)
3625 power_of_two = h->u.c.p->alignment_power;
3627 if (config.sort_common
3628 && power_of_two < (unsigned int) *(int *) info)
3631 section = h->u.c.p->section;
3633 /* Increase the size of the section. */
3634 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3635 (bfd_size_type) (1 << power_of_two)) * opb;
3637 /* Adjust the alignment if necessary. */
3638 if (power_of_two > section->alignment_power)
3639 section->alignment_power = power_of_two;
3641 /* Change the symbol from common to defined. */
3642 h->type = bfd_link_hash_defined;
3643 h->u.def.section = section;
3644 h->u.def.value = section->_cooked_size;
3646 /* Increase the size of the section. */
3647 section->_cooked_size += size;
3649 /* Make sure the section is allocated in memory, and make sure that
3650 it is no longer a common section. */
3651 section->flags |= SEC_ALLOC;
3652 section->flags &= ~SEC_IS_COMMON;
3654 if (config.map_file != NULL)
3656 static boolean header_printed;
3661 if (! header_printed)
3663 minfo (_("\nAllocating common symbols\n"));
3664 minfo (_("Common symbol size file\n\n"));
3665 header_printed = true;
3668 name = demangle (h->root.string);
3670 len = strlen (name);
3685 if (size <= 0xffffffff)
3686 sprintf (buf, "%lx", (unsigned long) size);
3688 sprintf_vma (buf, size);
3698 minfo ("%B\n", section->owner);
3704 /* Run through the input files and ensure that every input section has
3705 somewhere to go. If one is found without a destination then create
3706 an input request and place it into the statement tree. */
3709 lang_place_orphans ()
3711 LANG_FOR_EACH_INPUT_STATEMENT (file)
3715 for (s = file->the_bfd->sections;
3716 s != (asection *) NULL;
3719 if (s->output_section == (asection *) NULL)
3721 /* This section of the file is not attatched, root
3722 around for a sensible place for it to go. */
3724 if (file->just_syms_flag)
3726 /* We are only retrieving symbol values from this
3727 file. We want the symbols to act as though the
3728 values in the file are absolute. */
3729 s->output_section = bfd_abs_section_ptr;
3730 s->output_offset = s->vma;
3732 else if (strcmp (s->name, "COMMON") == 0)
3734 /* This is a lonely common section which must have
3735 come from an archive. We attach to the section
3736 with the wildcard. */
3737 if (! link_info.relocateable
3738 || command_line.force_common_definition)
3740 if (default_common_section == NULL)
3743 /* This message happens when using the
3744 svr3.ifile linker script, so I have
3746 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3748 default_common_section =
3749 lang_output_section_statement_lookup (".bss");
3752 wild_doit (&default_common_section->children, s,
3753 default_common_section, file);
3756 else if (ldemul_place_orphan (file, s))
3760 lang_output_section_statement_type *os =
3761 lang_output_section_statement_lookup (s->name);
3763 wild_doit (&os->children, s, os, file);
3771 lang_set_flags (ptr, flags, invert)
3772 lang_memory_region_type *ptr;
3776 flagword *ptr_flags;
3778 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3784 *ptr_flags |= SEC_ALLOC;
3788 *ptr_flags |= SEC_READONLY;
3792 *ptr_flags |= SEC_DATA;
3796 *ptr_flags |= SEC_CODE;
3801 *ptr_flags |= SEC_LOAD;
3805 einfo (_("%P%F: invalid syntax in flags\n"));
3812 /* Call a function on each input file. This function will be called
3813 on an archive, but not on the elements. */
3816 lang_for_each_input_file (func)
3817 void (*func) PARAMS ((lang_input_statement_type *));
3819 lang_input_statement_type *f;
3821 for (f = (lang_input_statement_type *) input_file_chain.head;
3823 f = (lang_input_statement_type *) f->next_real_file)
3827 /* Call a function on each file. The function will be called on all
3828 the elements of an archive which are included in the link, but will
3829 not be called on the archive file itself. */
3832 lang_for_each_file (func)
3833 void (*func) PARAMS ((lang_input_statement_type *));
3835 LANG_FOR_EACH_INPUT_STATEMENT (f)
3846 lang_for_each_input_section (func)
3847 void (*func) PARAMS ((bfd *ab, asection *as));
3849 LANG_FOR_EACH_INPUT_STATEMENT (f)
3853 for (s = f->the_bfd->sections;
3854 s != (asection *) NULL;
3857 func (f->the_bfd, s);
3865 ldlang_add_file (entry)
3866 lang_input_statement_type *entry;
3870 lang_statement_append (&file_chain,
3871 (lang_statement_union_type *) entry,
3874 /* The BFD linker needs to have a list of all input BFDs involved in
3876 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3877 ASSERT (entry->the_bfd != output_bfd);
3878 for (pp = &link_info.input_bfds;
3879 *pp != (bfd *) NULL;
3880 pp = &(*pp)->link_next)
3882 *pp = entry->the_bfd;
3883 entry->the_bfd->usrdata = (PTR) entry;
3884 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3886 /* Look through the sections and check for any which should not be
3887 included in the link. We need to do this now, so that we can
3888 notice when the backend linker tries to report multiple
3889 definition errors for symbols which are in sections we aren't
3890 going to link. FIXME: It might be better to entirely ignore
3891 symbols which are defined in sections which are going to be
3892 discarded. This would require modifying the backend linker for
3893 each backend which might set the SEC_LINK_ONCE flag. If we do
3894 this, we should probably handle SEC_EXCLUDE in the same way. */
3896 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3900 lang_add_output (name, from_script)
3904 /* Make -o on command line override OUTPUT in script. */
3905 if (had_output_filename == false || !from_script)
3907 output_filename = name;
3908 had_output_filename = true;
3912 static lang_output_section_statement_type *current_section;
3924 for (l = 0; l < 32; l++)
3926 if (i >= (unsigned int) x)
3934 lang_output_section_statement_type *
3935 lang_enter_output_section_statement (output_section_statement_name,
3936 address_exp, sectype, block_value,
3937 align, subalign, ebase)
3938 const char *output_section_statement_name;
3939 etree_type *address_exp;
3940 enum section_type sectype;
3941 bfd_vma block_value;
3943 etree_type *subalign;
3946 lang_output_section_statement_type *os;
3950 lang_output_section_statement_lookup (output_section_statement_name);
3952 /* Add this statement to tree. */
3954 add_statement (lang_output_section_statement_enum,
3955 output_section_statement);
3957 /* Make next things chain into subchain of this. */
3959 if (os->addr_tree == (etree_type *) NULL)
3961 os->addr_tree = address_exp;
3963 os->sectype = sectype;
3964 if (sectype != noload_section)
3965 os->flags = SEC_NO_FLAGS;
3967 os->flags = SEC_NEVER_LOAD;
3968 os->block_value = block_value ? block_value : 1;
3969 stat_ptr = &os->children;
3971 os->subsection_alignment =
3972 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
3973 os->section_alignment =
3974 topower (exp_get_value_int (align, -1, "section alignment", 0));
3976 os->load_base = ebase;
3983 lang_output_statement_type *new =
3984 new_stat (lang_output_statement, stat_ptr);
3986 new->name = output_filename;
3989 /* Reset the current counters in the regions. */
3992 reset_memory_regions ()
3994 lang_memory_region_type *p = lang_memory_region_list;
3996 for (p = lang_memory_region_list;
3997 p != (lang_memory_region_type *) NULL;
4000 p->old_length = (bfd_size_type) (p->current - p->origin);
4001 p->current = p->origin;
4005 /* Expand a wild statement for a particular FILE, marking its sections KEEP
4006 as needed. SECTION may be NULL, in which case it is a wild card. */
4009 gc_section_callback (ptr, section, file, data)
4010 lang_wild_statement_type *ptr;
4012 lang_input_statement_type *file ATTRIBUTE_UNUSED;
4013 PTR data ATTRIBUTE_UNUSED;
4015 /* If the wild pattern was marked KEEP, the member sections
4016 should be as well. */
4017 if (ptr->keep_sections)
4018 section->flags |= SEC_KEEP;
4021 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
4022 may be NULL, indicating that it is a wildcard. */
4025 lang_gc_wild (s, section, file)
4026 lang_wild_statement_type *s;
4027 const char *section;
4030 walk_wild (s, section, file, gc_section_callback, NULL);
4033 /* Iterate over sections marking them against GC. */
4036 lang_gc_sections_1 (s)
4037 lang_statement_union_type *s;
4039 for (; s != (lang_statement_union_type *) NULL; s = s->next)
4041 switch (s->header.type)
4043 case lang_wild_statement_enum:
4044 lang_gc_wild (&s->wild_statement,
4045 s->wild_statement.section_name,
4046 s->wild_statement.filename);
4048 case lang_constructors_statement_enum:
4049 lang_gc_sections_1 (constructor_list.head);
4051 case lang_output_section_statement_enum:
4052 lang_gc_sections_1 (s->output_section_statement.children.head);
4054 case lang_group_statement_enum:
4055 lang_gc_sections_1 (s->group_statement.children.head);
4066 struct bfd_link_hash_entry *h;
4067 ldlang_undef_chain_list_type *ulist, fake_list_start;
4069 /* Keep all sections so marked in the link script. */
4071 lang_gc_sections_1 (statement_list.head);
4073 /* Keep all sections containing symbols undefined on the command-line.
4074 Handle the entry symbol at the same time. */
4076 if (entry_symbol != NULL)
4078 fake_list_start.next = ldlang_undef_chain_list_head;
4079 fake_list_start.name = (char *) entry_symbol;
4080 ulist = &fake_list_start;
4083 ulist = ldlang_undef_chain_list_head;
4085 for (; ulist; ulist = ulist->next)
4087 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4088 false, false, false);
4090 if (h != (struct bfd_link_hash_entry *) NULL
4091 && (h->type == bfd_link_hash_defined
4092 || h->type == bfd_link_hash_defweak)
4093 && ! bfd_is_abs_section (h->u.def.section))
4095 h->u.def.section->flags |= SEC_KEEP;
4099 bfd_gc_sections (output_bfd, &link_info);
4105 lang_reasonable_defaults ();
4106 current_target = default_target;
4108 /* Open the output file. */
4109 lang_for_each_statement (ldlang_open_output);
4111 ldemul_create_output_section_statements ();
4113 /* Add to the hash table all undefineds on the command line. */
4114 lang_place_undefineds ();
4116 already_linked_table_init ();
4118 /* Create a bfd for each input file. */
4119 current_target = default_target;
4120 open_input_bfds (statement_list.head, false);
4122 ldemul_after_open ();
4124 already_linked_table_free ();
4126 /* Make sure that we're not mixing architectures. We call this
4127 after all the input files have been opened, but before we do any
4128 other processing, so that any operations merge_private_bfd_data
4129 does on the output file will be known during the rest of the
4133 /* Handle .exports instead of a version script if we're told to do so. */
4134 if (command_line.version_exports_section)
4135 lang_do_version_exports_section ();
4137 /* Build all sets based on the information gathered from the input
4139 ldctor_build_sets ();
4141 /* Remove unreferenced sections if asked to. */
4142 if (command_line.gc_sections)
4143 lang_gc_sections ();
4145 /* If there were any SEC_MERGE sections, finish their merging, so that
4146 section sizes can be computed. This has to be done after GC of sections,
4147 so that GCed sections are not merged, but before assigning output
4148 sections, since removing whole input sections is hard then. */
4149 bfd_merge_sections (output_bfd, &link_info);
4151 /* Size up the common data. */
4154 /* Run through the contours of the script and attach input sections
4155 to the correct output sections. */
4156 map_input_to_output_sections (statement_list.head, (char *) NULL,
4157 (lang_output_section_statement_type *) NULL);
4159 /* Find any sections not attached explicitly and handle them. */
4160 lang_place_orphans ();
4162 ldemul_before_allocation ();
4164 /* We must record the program headers before we try to fix the
4165 section positions, since they will affect SIZEOF_HEADERS. */
4166 lang_record_phdrs ();
4168 /* Now run around and relax if we can. */
4169 if (command_line.relax)
4171 /* First time round is a trial run to get the 'worst case'
4172 addresses of the objects if there was no relaxing. */
4173 lang_size_sections (statement_list.head,
4175 &(statement_list.head), 0, (bfd_vma) 0, false);
4177 /* Keep relaxing until bfd_relax_section gives up. */
4180 reset_memory_regions ();
4182 relax_again = false;
4184 /* Note: pe-dll.c does something like this also. If you find
4185 you need to change this code, you probably need to change
4186 pe-dll.c also. DJ */
4188 /* Do all the assignments with our current guesses as to
4190 lang_do_assignments (statement_list.head,
4192 (fill_type) 0, (bfd_vma) 0);
4194 /* Perform another relax pass - this time we know where the
4195 globals are, so can make better guess. */
4196 lang_size_sections (statement_list.head,
4198 &(statement_list.head), 0, (bfd_vma) 0, true);
4200 while (relax_again);
4204 /* Size up the sections. */
4205 lang_size_sections (statement_list.head,
4207 &(statement_list.head), 0, (bfd_vma) 0, false);
4210 /* See if anything special should be done now we know how big
4212 ldemul_after_allocation ();
4214 /* Fix any .startof. or .sizeof. symbols. */
4215 lang_set_startof ();
4217 /* Do all the assignments, now that we know the final resting places
4218 of all the symbols. */
4220 lang_do_assignments (statement_list.head,
4222 (fill_type) 0, (bfd_vma) 0);
4224 /* Make sure that the section addresses make sense. */
4225 if (! link_info.relocateable
4226 && command_line.check_section_addresses)
4227 lang_check_section_addresses ();
4235 /* EXPORTED TO YACC */
4238 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
4239 keep_sections, exclude_filename_list)
4240 const char *const section_name;
4241 boolean sections_sorted;
4242 const char *const filename;
4243 boolean filenames_sorted;
4244 boolean keep_sections;
4245 struct name_list *exclude_filename_list;
4247 lang_wild_statement_type *new = new_stat (lang_wild_statement,
4250 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4252 placed_commons = true;
4254 if (filename != NULL && ! wildcardp (filename))
4256 lang_has_input_file = true;
4258 new->section_name = section_name;
4259 new->sections_sorted = sections_sorted;
4260 new->filename = filename;
4261 new->filenames_sorted = filenames_sorted;
4262 new->keep_sections = keep_sections;
4263 new->exclude_filename_list = exclude_filename_list;
4264 lang_list_init (&new->children);
4268 lang_section_start (name, address)
4270 etree_type *address;
4272 lang_address_statement_type *ad;
4274 ad = new_stat (lang_address_statement, stat_ptr);
4275 ad->section_name = name;
4276 ad->address = address;
4279 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4280 because of a -e argument on the command line, or zero if this is
4281 called by ENTRY in a linker script. Command line arguments take
4285 lang_add_entry (name, cmdline)
4289 if (entry_symbol == NULL
4291 || ! entry_from_cmdline)
4293 entry_symbol = name;
4294 entry_from_cmdline = cmdline;
4299 lang_add_target (name)
4302 lang_target_statement_type *new = new_stat (lang_target_statement,
4318 map_option_f = true;
4329 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4336 lang_add_data (type, exp)
4338 union etree_union *exp;
4341 lang_data_statement_type *new = new_stat (lang_data_statement,
4349 /* Create a new reloc statement. RELOC is the BFD relocation type to
4350 generate. HOWTO is the corresponding howto structure (we could
4351 look this up, but the caller has already done so). SECTION is the
4352 section to generate a reloc against, or NAME is the name of the
4353 symbol to generate a reloc against. Exactly one of SECTION and
4354 NAME must be NULL. ADDEND is an expression for the addend. */
4357 lang_add_reloc (reloc, howto, section, name, addend)
4358 bfd_reloc_code_real_type reloc;
4359 reloc_howto_type *howto;
4362 union etree_union *addend;
4364 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4368 p->section = section;
4370 p->addend_exp = addend;
4372 p->addend_value = 0;
4373 p->output_section = NULL;
4377 lang_assignment_statement_type *
4378 lang_add_assignment (exp)
4381 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4389 lang_add_attribute (attribute)
4390 enum statement_enum attribute;
4392 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4399 if (startup_file != (char *) NULL)
4401 einfo (_("%P%Fmultiple STARTUP files\n"));
4403 first_file->filename = name;
4404 first_file->local_sym_name = name;
4405 first_file->real = true;
4407 startup_file = name;
4414 lang_float_flag = maybe;
4418 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4420 const char *memspec;
4421 struct lang_output_section_phdr_list *phdrs;
4422 const char *lma_memspec;
4424 current_section->fill = fill;
4425 current_section->region = lang_memory_region_lookup (memspec);
4426 if (strcmp (lma_memspec, "*default*") != 0)
4428 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4429 /* If no runtime region has been given, but the load region has
4430 been, use the load region. */
4431 if (strcmp (memspec, "*default*") == 0)
4432 current_section->region = lang_memory_region_lookup (lma_memspec);
4434 current_section->phdrs = phdrs;
4435 stat_ptr = &statement_list;
4438 /* Create an absolute symbol with the given name with the value of the
4439 address of first byte of the section named.
4441 If the symbol already exists, then do nothing. */
4444 lang_abs_symbol_at_beginning_of (secname, name)
4445 const char *secname;
4448 struct bfd_link_hash_entry *h;
4450 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4451 if (h == (struct bfd_link_hash_entry *) NULL)
4452 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4454 if (h->type == bfd_link_hash_new
4455 || h->type == bfd_link_hash_undefined)
4459 h->type = bfd_link_hash_defined;
4461 sec = bfd_get_section_by_name (output_bfd, secname);
4462 if (sec == (asection *) NULL)
4465 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4467 h->u.def.section = bfd_abs_section_ptr;
4471 /* Create an absolute symbol with the given name with the value of the
4472 address of the first byte after the end of the section named.
4474 If the symbol already exists, then do nothing. */
4477 lang_abs_symbol_at_end_of (secname, name)
4478 const char *secname;
4481 struct bfd_link_hash_entry *h;
4483 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4484 if (h == (struct bfd_link_hash_entry *) NULL)
4485 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4487 if (h->type == bfd_link_hash_new
4488 || h->type == bfd_link_hash_undefined)
4492 h->type = bfd_link_hash_defined;
4494 sec = bfd_get_section_by_name (output_bfd, secname);
4495 if (sec == (asection *) NULL)
4498 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4499 + bfd_section_size (output_bfd, sec) /
4500 bfd_octets_per_byte (output_bfd));
4502 h->u.def.section = bfd_abs_section_ptr;
4507 lang_statement_append (list, element, field)
4508 lang_statement_list_type *list;
4509 lang_statement_union_type *element;
4510 lang_statement_union_type **field;
4512 *(list->tail) = element;
4516 /* Set the output format type. -oformat overrides scripts. */
4519 lang_add_output_format (format, big, little, from_script)
4525 if (output_target == NULL || !from_script)
4527 if (command_line.endian == ENDIAN_BIG
4530 else if (command_line.endian == ENDIAN_LITTLE
4534 output_target = format;
4538 /* Enter a group. This creates a new lang_group_statement, and sets
4539 stat_ptr to build new statements within the group. */
4544 lang_group_statement_type *g;
4546 g = new_stat (lang_group_statement, stat_ptr);
4547 lang_list_init (&g->children);
4548 stat_ptr = &g->children;
4551 /* Leave a group. This just resets stat_ptr to start writing to the
4552 regular list of statements again. Note that this will not work if
4553 groups can occur inside anything else which can adjust stat_ptr,
4554 but currently they can't. */
4559 stat_ptr = &statement_list;
4562 /* Add a new program header. This is called for each entry in a PHDRS
4563 command in a linker script. */
4566 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4574 struct lang_phdr *n, **pp;
4576 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4579 n->type = exp_get_value_int (type, 0, "program header type",
4580 lang_final_phase_enum);
4581 n->filehdr = filehdr;
4586 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4591 /* Record the program header information in the output BFD. FIXME: We
4592 should not be calling an ELF specific function here. */
4595 lang_record_phdrs ()
4599 struct lang_output_section_phdr_list *last;
4600 struct lang_phdr *l;
4601 lang_statement_union_type *u;
4604 secs = (asection **) xmalloc (alc * sizeof (asection *));
4606 for (l = lang_phdr_list; l != NULL; l = l->next)
4613 for (u = lang_output_section_statement.head;
4615 u = u->output_section_statement.next)
4617 lang_output_section_statement_type *os;
4618 struct lang_output_section_phdr_list *pl;
4620 os = &u->output_section_statement;
4627 if (os->sectype == noload_section
4628 || os->bfd_section == NULL
4629 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4634 if (os->bfd_section == NULL)
4637 for (; pl != NULL; pl = pl->next)
4639 if (strcmp (pl->name, l->name) == 0)
4644 secs = ((asection **)
4645 xrealloc (secs, alc * sizeof (asection *)));
4647 secs[c] = os->bfd_section;
4654 if (l->flags == NULL)
4657 flags = exp_get_vma (l->flags, 0, "phdr flags",
4658 lang_final_phase_enum);
4663 at = exp_get_vma (l->at, 0, "phdr load address",
4664 lang_final_phase_enum);
4666 if (! bfd_record_phdr (output_bfd, l->type,
4667 l->flags != NULL, flags, l->at != NULL,
4668 at, l->filehdr, l->phdrs, c, secs))
4669 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4674 /* Make sure all the phdr assignments succeeded. */
4675 for (u = lang_output_section_statement.head;
4677 u = u->output_section_statement.next)
4679 struct lang_output_section_phdr_list *pl;
4681 if (u->output_section_statement.bfd_section == NULL)
4684 for (pl = u->output_section_statement.phdrs;
4687 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4688 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4689 u->output_section_statement.name, pl->name);
4693 /* Record a list of sections which may not be cross referenced. */
4696 lang_add_nocrossref (l)
4697 struct lang_nocrossref *l;
4699 struct lang_nocrossrefs *n;
4701 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4702 n->next = nocrossref_list;
4704 nocrossref_list = n;
4706 /* Set notice_all so that we get informed about all symbols. */
4707 link_info.notice_all = true;
4710 /* Overlay handling. We handle overlays with some static variables. */
4712 /* The overlay virtual address. */
4713 static etree_type *overlay_vma;
4715 /* The overlay load address. */
4716 static etree_type *overlay_lma;
4718 /* Whether nocrossrefs is set for this overlay. */
4719 static int overlay_nocrossrefs;
4721 /* An expression for the maximum section size seen so far. */
4722 static etree_type *overlay_max;
4724 /* A list of all the sections in this overlay. */
4726 struct overlay_list {
4727 struct overlay_list *next;
4728 lang_output_section_statement_type *os;
4731 static struct overlay_list *overlay_list;
4733 /* Start handling an overlay. */
4736 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4737 etree_type *vma_expr;
4738 etree_type *lma_expr;
4741 /* The grammar should prevent nested overlays from occurring. */
4742 ASSERT (overlay_vma == NULL
4743 && overlay_lma == NULL
4744 && overlay_list == NULL
4745 && overlay_max == NULL);
4747 overlay_vma = vma_expr;
4748 overlay_lma = lma_expr;
4749 overlay_nocrossrefs = nocrossrefs;
4752 /* Start a section in an overlay. We handle this by calling
4753 lang_enter_output_section_statement with the correct VMA and LMA. */
4756 lang_enter_overlay_section (name)
4759 struct overlay_list *n;
4762 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4763 0, 0, 0, overlay_lma);
4765 /* If this is the first section, then base the VMA and LMA of future
4766 sections on this one. This will work correctly even if `.' is
4767 used in the addresses. */
4768 if (overlay_list == NULL)
4770 overlay_vma = exp_nameop (ADDR, name);
4771 overlay_lma = exp_nameop (LOADADDR, name);
4774 /* Remember the section. */
4775 n = (struct overlay_list *) xmalloc (sizeof *n);
4776 n->os = current_section;
4777 n->next = overlay_list;
4780 size = exp_nameop (SIZEOF, name);
4782 /* Adjust the LMA for the next section. */
4783 overlay_lma = exp_binop ('+', overlay_lma, size);
4785 /* Arrange to work out the maximum section end address. */
4786 if (overlay_max == NULL)
4789 overlay_max = exp_binop (MAX_K, overlay_max, size);
4792 /* Finish a section in an overlay. There isn't any special to do
4796 lang_leave_overlay_section (fill, phdrs)
4798 struct lang_output_section_phdr_list *phdrs;
4805 name = current_section->name;
4807 lang_leave_output_section_statement (fill, "*default*",
4808 phdrs, "*default*");
4810 /* Define the magic symbols. */
4812 clean = xmalloc (strlen (name) + 1);
4814 for (s1 = name; *s1 != '\0'; s1++)
4815 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4819 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4820 sprintf (buf, "__load_start_%s", clean);
4821 lang_add_assignment (exp_assop ('=', buf,
4822 exp_nameop (LOADADDR, name)));
4824 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4825 sprintf (buf, "__load_stop_%s", clean);
4826 lang_add_assignment (exp_assop ('=', buf,
4828 exp_nameop (LOADADDR, name),
4829 exp_nameop (SIZEOF, name))));
4834 /* Finish an overlay. If there are any overlay wide settings, this
4835 looks through all the sections in the overlay and sets them. */
4838 lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
4840 const char *memspec;
4841 struct lang_output_section_phdr_list *phdrs;
4842 const char *lma_memspec;
4844 lang_memory_region_type *region;
4845 lang_memory_region_type *lma_region;
4846 struct overlay_list *l;
4847 struct lang_nocrossref *nocrossref;
4849 if (memspec == NULL)
4852 region = lang_memory_region_lookup (memspec);
4854 if (lma_memspec == NULL)
4857 lma_region = lang_memory_region_lookup (lma_memspec);
4864 struct overlay_list *next;
4866 if (fill != 0 && l->os->fill == 0)
4868 if (region != NULL && l->os->region == NULL)
4869 l->os->region = region;
4870 /* We only set lma_region for the first overlay section, as
4871 subsequent overlay sections will have load_base set relative
4872 to the first section. Also, don't set lma_region if
4873 load_base is specified. FIXME: There should really be a test
4874 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4875 rather than letting LDADDR simply override LMA_REGION. */
4876 if (lma_region != NULL && l->os->lma_region == NULL
4877 && l->next == NULL && l->os->load_base == NULL)
4878 l->os->lma_region = lma_region;
4879 if (phdrs != NULL && l->os->phdrs == NULL)
4880 l->os->phdrs = phdrs;
4882 if (overlay_nocrossrefs)
4884 struct lang_nocrossref *nc;
4886 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4887 nc->name = l->os->name;
4888 nc->next = nocrossref;
4897 if (nocrossref != NULL)
4898 lang_add_nocrossref (nocrossref);
4900 /* Update . for the end of the overlay. */
4901 lang_add_assignment (exp_assop ('=', ".",
4902 exp_binop ('+', overlay_vma, overlay_max)));
4906 overlay_nocrossrefs = 0;
4907 overlay_list = NULL;
4911 /* Version handling. This is only useful for ELF. */
4913 /* This global variable holds the version tree that we build. */
4915 struct bfd_elf_version_tree *lang_elf_version_info;
4918 lang_vers_match_lang_c (expr, sym)
4919 struct bfd_elf_version_expr *expr;
4922 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4924 return fnmatch (expr->pattern, sym, 0) == 0;
4928 lang_vers_match_lang_cplusplus (expr, sym)
4929 struct bfd_elf_version_expr *expr;
4935 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4938 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4941 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4942 Should we early out false in this case? */
4943 result = fnmatch (expr->pattern, sym, 0) == 0;
4947 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4955 lang_vers_match_lang_java (expr, sym)
4956 struct bfd_elf_version_expr *expr;
4962 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4965 alt_sym = cplus_demangle (sym, DMGL_JAVA);
4968 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4969 Should we early out false in this case? */
4970 result = fnmatch (expr->pattern, sym, 0) == 0;
4974 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4981 /* This is called for each variable name or match expression. */
4983 struct bfd_elf_version_expr *
4984 lang_new_vers_regex (orig, new, lang)
4985 struct bfd_elf_version_expr *orig;
4989 struct bfd_elf_version_expr *ret;
4991 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4995 if (lang == NULL || strcasecmp (lang, "C") == 0)
4996 ret->match = lang_vers_match_lang_c;
4997 else if (strcasecmp (lang, "C++") == 0)
4998 ret->match = lang_vers_match_lang_cplusplus;
4999 else if (strcasecmp (lang, "Java") == 0)
5000 ret->match = lang_vers_match_lang_java;
5003 einfo (_("%X%P: unknown language `%s' in version information\n"),
5005 ret->match = lang_vers_match_lang_c;
5011 /* This is called for each set of variable names and match
5014 struct bfd_elf_version_tree *
5015 lang_new_vers_node (globals, locals)
5016 struct bfd_elf_version_expr *globals;
5017 struct bfd_elf_version_expr *locals;
5019 struct bfd_elf_version_tree *ret;
5021 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5025 ret->globals = globals;
5026 ret->locals = locals;
5028 ret->name_indx = (unsigned int) -1;
5033 /* This static variable keeps track of version indices. */
5035 static int version_index;
5037 /* This is called when we know the name and dependencies of the
5041 lang_register_vers_node (name, version, deps)
5043 struct bfd_elf_version_tree *version;
5044 struct bfd_elf_version_deps *deps;
5046 struct bfd_elf_version_tree *t, **pp;
5047 struct bfd_elf_version_expr *e1;
5049 /* Make sure this node has a unique name. */
5050 for (t = lang_elf_version_info; t != NULL; t = t->next)
5051 if (strcmp (t->name, name) == 0)
5052 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5054 /* Check the global and local match names, and make sure there
5055 aren't any duplicates. */
5057 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5059 for (t = lang_elf_version_info; t != NULL; t = t->next)
5061 struct bfd_elf_version_expr *e2;
5063 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5064 if (strcmp (e1->pattern, e2->pattern) == 0)
5065 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5070 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5072 for (t = lang_elf_version_info; t != NULL; t = t->next)
5074 struct bfd_elf_version_expr *e2;
5076 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5077 if (strcmp (e1->pattern, e2->pattern) == 0)
5078 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5083 version->deps = deps;
5084 version->name = name;
5086 version->vernum = version_index;
5088 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5093 /* This is called when we see a version dependency. */
5095 struct bfd_elf_version_deps *
5096 lang_add_vers_depend (list, name)
5097 struct bfd_elf_version_deps *list;
5100 struct bfd_elf_version_deps *ret;
5101 struct bfd_elf_version_tree *t;
5103 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5106 for (t = lang_elf_version_info; t != NULL; t = t->next)
5108 if (strcmp (t->name, name) == 0)
5110 ret->version_needed = t;
5115 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5121 lang_do_version_exports_section ()
5123 struct bfd_elf_version_expr *greg = NULL, *lreg;
5125 LANG_FOR_EACH_INPUT_STATEMENT (is)
5127 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5134 len = bfd_section_size (is->the_bfd, sec);
5135 contents = xmalloc (len);
5136 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5137 einfo (_("%X%P: unable to read .exports section contents"), sec);
5140 while (p < contents + len)
5142 greg = lang_new_vers_regex (greg, p, NULL);
5143 p = strchr (p, '\0') + 1;
5146 /* Do not free the contents, as we used them creating the regex. */
5148 /* Do not include this section in the link. */
5149 bfd_set_section_flags (is->the_bfd, sec,
5150 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5153 lreg = lang_new_vers_regex (NULL, "*", NULL);
5154 lang_register_vers_node (command_line.version_exports_section,
5155 lang_new_vers_node (greg, lreg), NULL);
5159 lang_add_unique (name)
5162 struct unique_sections *ent;
5164 for (ent = unique_section_list; ent; ent = ent->next)
5165 if (strcmp (ent->name, name) == 0)
5168 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5169 ent->name = xstrdup (name);
5170 ent->next = unique_section_list;
5171 unique_section_list = ent;