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 boolean 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 lang_check PARAMS ((void));
131 static void lang_common PARAMS ((void));
132 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
133 static void lang_place_orphans PARAMS ((void));
134 static int topower PARAMS ((int));
135 static void lang_set_startof PARAMS ((void));
136 static void reset_memory_regions PARAMS ((void));
137 static void gc_section_callback
138 PARAMS ((lang_wild_statement_type *, asection *,
139 lang_input_statement_type *, PTR));
140 static void lang_record_phdrs PARAMS ((void));
141 static void lang_gc_wild
142 PARAMS ((lang_wild_statement_type *, const char *, const char *));
143 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
144 static void lang_gc_sections PARAMS ((void));
145 static int lang_vers_match_lang_c
146 PARAMS ((struct bfd_elf_version_expr *, const char *));
147 static int lang_vers_match_lang_cplusplus
148 PARAMS ((struct bfd_elf_version_expr *, const char *));
149 static int lang_vers_match_lang_java
150 PARAMS ((struct bfd_elf_version_expr *, const char *));
151 static void lang_do_version_exports_section PARAMS ((void));
152 static void lang_check_section_addresses PARAMS ((void));
153 static void os_region_check
154 PARAMS ((lang_output_section_statement_type *,
155 struct memory_region_struct *, etree_type *, bfd_vma));
157 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
158 asection *, lang_input_statement_type *,
160 static void walk_wild
161 PARAMS ((lang_wild_statement_type *, const char *, const char *,
163 static void walk_wild_section
164 PARAMS ((lang_wild_statement_type *, const char *,
165 lang_input_statement_type *, callback_t, PTR));
166 static void walk_wild_file
167 PARAMS ((lang_wild_statement_type *, const char *,
168 lang_input_statement_type *, callback_t, PTR));
170 static int get_target PARAMS ((const bfd_target *, PTR));
171 static void stricpy PARAMS ((char *, char *));
172 static void strcut PARAMS ((char *, char *));
173 static int name_compare PARAMS ((char *, char *));
174 static int closest_target_match PARAMS ((const bfd_target *, PTR));
175 static char * get_first_input_target PARAMS ((void));
178 lang_output_section_statement_type *abs_output_section;
179 lang_statement_list_type lang_output_section_statement;
180 lang_statement_list_type *stat_ptr = &statement_list;
181 lang_statement_list_type file_chain = { NULL, NULL };
182 const char *entry_symbol = NULL;
183 boolean entry_from_cmdline;
184 boolean lang_has_input_file = false;
185 boolean had_output_filename = false;
186 boolean lang_float_flag = false;
187 boolean delete_output_file_on_failure = false;
188 struct lang_nocrossrefs *nocrossref_list;
189 struct unique_sections *unique_section_list;
191 etree_type *base; /* Relocation base - or null */
193 #if defined (__STDC__) || defined (ALMOST_STDC)
194 #define cat(a,b) a##b
196 #define cat(a,b) a/**/b
199 /* Don't beautify the line below with "innocent" whitespace, it breaks
200 the K&R C preprocessor! */
201 #define new_stat(x, y) \
202 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
204 #define outside_section_address(q) \
205 ((q)->output_offset + (q)->output_section->vma)
207 #define outside_symbol_address(q) \
208 ((q)->value + outside_section_address (q->section))
210 #define SECTION_NAME_MAP_LENGTH (16)
216 return obstack_alloc (&stat_obstack, size);
220 unique_section_p (secnam)
223 struct unique_sections *unam;
225 for (unam = unique_section_list; unam; unam = unam->next)
226 if (wildcardp (unam->name)
227 ? fnmatch (unam->name, secnam, 0) == 0
228 : strcmp (unam->name, secnam) == 0)
236 /* Generic traversal routines for finding matching sections. */
239 walk_wild_section (ptr, section, file, callback, data)
240 lang_wild_statement_type *ptr;
242 lang_input_statement_type *file;
246 /* Don't process sections from files which were excluded. */
247 if (ptr->exclude_filename_list != NULL)
249 struct name_list *list_tmp;
250 for (list_tmp = ptr->exclude_filename_list;
252 list_tmp = list_tmp->next)
256 if (wildcardp (list_tmp->name))
257 match = fnmatch (list_tmp->name, file->filename, 0) == 0;
259 match = strcmp (list_tmp->name, file->filename) == 0;
266 if (file->just_syms_flag == false)
268 register asection *s;
269 boolean wildcard = false;
272 wildcard = wildcardp (section);
274 for (s = file->the_bfd->sections; s != NULL; s = s->next)
277 const char *sname = bfd_get_section_name (file->the_bfd, s);
282 match = fnmatch (section, sname, 0) == 0;
284 match = strcmp (section, sname) == 0;
286 /* If this is a wild-card output section statement, exclude
287 sections that match UNIQUE_SECTION_LIST. */
288 if (match && (data == NULL || !unique_section_p (sname)))
289 (*callback) (ptr, s, file, data);
294 /* Handle a wild statement for a single file F. */
297 walk_wild_file (s, section, f, callback, data)
298 lang_wild_statement_type *s;
300 lang_input_statement_type *f;
304 if (f->the_bfd == NULL
305 || ! bfd_check_format (f->the_bfd, bfd_archive))
306 walk_wild_section (s, section, f, callback, data);
311 /* This is an archive file. We must map each member of the
312 archive separately. */
313 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
314 while (member != NULL)
316 /* When lookup_name is called, it will call the add_symbols
317 entry point for the archive. For each element of the
318 archive which is included, BFD will call ldlang_add_file,
319 which will set the usrdata field of the member to the
320 lang_input_statement. */
321 if (member->usrdata != NULL)
323 walk_wild_section (s, section,
324 (lang_input_statement_type *) member->usrdata,
328 member = bfd_openr_next_archived_file (f->the_bfd, member);
334 walk_wild (s, section, file, callback, data)
335 lang_wild_statement_type *s;
341 if (file == (char *) NULL)
343 /* Perform the iteration over all files in the list. */
344 LANG_FOR_EACH_INPUT_STATEMENT (f)
346 walk_wild_file (s, section, f, callback, data);
349 else if (wildcardp (file))
351 LANG_FOR_EACH_INPUT_STATEMENT (f)
353 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
354 walk_wild_file (s, section, f, callback, data);
359 lang_input_statement_type *f;
361 /* Perform the iteration over a single file. */
362 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\n"), 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 if (! load_symbols (search, (lang_statement_list_type *) NULL))
1435 /* Get the symbols for an input file. */
1438 load_symbols (entry, place)
1439 lang_input_statement_type *entry;
1440 lang_statement_list_type *place;
1447 ldfile_open_file (entry);
1449 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1450 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1453 lang_statement_list_type *hold;
1454 boolean bad_load = true;
1456 err = bfd_get_error ();
1458 /* See if the emulation has some special knowledge. */
1459 if (ldemul_unrecognized_file (entry))
1462 if (err == bfd_error_file_ambiguously_recognized)
1466 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1467 einfo (_("%B: matching formats:"), entry->the_bfd);
1468 for (p = matching; *p != NULL; p++)
1472 else if (err != bfd_error_file_not_recognized
1474 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1478 bfd_close (entry->the_bfd);
1479 entry->the_bfd = NULL;
1481 /* Try to interpret the file as a linker script. */
1482 ldfile_open_command_file (entry->filename);
1487 ldfile_assumed_script = true;
1488 parser_input = input_script;
1490 ldfile_assumed_script = false;
1497 if (ldemul_recognized_file (entry))
1500 /* We don't call ldlang_add_file for an archive. Instead, the
1501 add_symbols entry point will call ldlang_add_file, via the
1502 add_archive_element callback, for each element of the archive
1504 switch (bfd_get_format (entry->the_bfd))
1510 ldlang_add_file (entry);
1511 if (trace_files || trace_file_tries)
1512 info_msg ("%I\n", entry);
1516 if (entry->whole_archive)
1518 bfd * member = NULL;
1519 boolean loaded = true;
1523 member = bfd_openr_next_archived_file (entry->the_bfd, member);
1528 if (! bfd_check_format (member, bfd_object))
1530 einfo (_("%F%B: member %B in archive is not an object\n"),
1531 entry->the_bfd, member);
1535 if (! ((*link_info.callbacks->add_archive_element)
1536 (&link_info, member, "--whole-archive")))
1539 if (! bfd_link_add_symbols (member, &link_info))
1541 einfo (_("%F%B: could not read symbols: %E\n"), member);
1546 entry->loaded = loaded;
1552 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1553 entry->loaded = true;
1555 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1557 return entry->loaded;
1560 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1561 indicating that it is a wildcard. Separate lang_input_section
1562 statements are created for each part of the expansion; they are
1563 added after the wild statement S. OUTPUT is the output section. */
1566 wild (s, section, file, target, output)
1567 lang_wild_statement_type *s;
1568 const char *section;
1570 const char *target ATTRIBUTE_UNUSED;
1571 lang_output_section_statement_type *output;
1573 walk_wild (s, section, file, output_section_callback, (PTR) output);
1575 if (section != (char *) NULL
1576 && strcmp (section, "COMMON") == 0
1577 && default_common_section == NULL)
1579 /* Remember the section that common is going to in case we later
1580 get something which doesn't know where to put it. */
1581 default_common_section = output;
1585 /* Return true iff target is the sought target. */
1588 get_target (target, data)
1589 const bfd_target *target;
1592 const char *sought = (const char *) data;
1594 return strcmp (target->name, sought) == 0;
1597 /* Like strcpy() but convert to lower case as well. */
1606 while ((c = *src++) != 0)
1608 if (isupper ((unsigned char) c))
1617 /* Remove the first occurance of needle (if any) in haystack
1621 strcut (haystack, needle)
1625 haystack = strstr (haystack, needle);
1631 for (src = haystack + strlen (needle); *src;)
1632 *haystack++ = *src++;
1638 /* Compare two target format name strings.
1639 Return a value indicating how "similar" they are. */
1642 name_compare (first, second)
1650 copy1 = xmalloc (strlen (first) + 1);
1651 copy2 = xmalloc (strlen (second) + 1);
1653 /* Convert the names to lower case. */
1654 stricpy (copy1, first);
1655 stricpy (copy2, second);
1657 /* Remove and endian strings from the name. */
1658 strcut (copy1, "big");
1659 strcut (copy1, "little");
1660 strcut (copy2, "big");
1661 strcut (copy2, "little");
1663 /* Return a value based on how many characters match,
1664 starting from the beginning. If both strings are
1665 the same then return 10 * their length. */
1666 for (result = 0; copy1[result] == copy2[result]; result++)
1667 if (copy1[result] == 0)
1679 /* Set by closest_target_match() below. */
1680 static const bfd_target *winner;
1682 /* Scan all the valid bfd targets looking for one that has the endianness
1683 requirement that was specified on the command line, and is the nearest
1684 match to the original output target. */
1687 closest_target_match (target, data)
1688 const bfd_target *target;
1691 const bfd_target *original = (const bfd_target *) data;
1693 if (command_line.endian == ENDIAN_BIG
1694 && target->byteorder != BFD_ENDIAN_BIG)
1697 if (command_line.endian == ENDIAN_LITTLE
1698 && target->byteorder != BFD_ENDIAN_LITTLE)
1701 /* Must be the same flavour. */
1702 if (target->flavour != original->flavour)
1705 /* If we have not found a potential winner yet, then record this one. */
1712 /* Oh dear, we now have two potential candidates for a successful match.
1713 Compare their names and choose the better one. */
1714 if (name_compare (target->name, original->name)
1715 > name_compare (winner->name, original->name))
1718 /* Keep on searching until wqe have checked them all. */
1722 /* Return the BFD target format of the first input file. */
1725 get_first_input_target ()
1727 char *target = NULL;
1729 LANG_FOR_EACH_INPUT_STATEMENT (s)
1731 if (s->header.type == lang_input_statement_enum
1734 ldfile_open_file (s);
1736 if (s->the_bfd != NULL
1737 && bfd_check_format (s->the_bfd, bfd_object))
1739 target = bfd_get_target (s->the_bfd);
1750 /* Open the output file. */
1758 /* Has the user told us which output format to use? */
1759 if (output_target == (char *) NULL)
1761 /* No - has the current target been set to something other than
1763 if (current_target != default_target)
1764 output_target = current_target;
1766 /* No - can we determine the format of the first input file? */
1769 output_target = get_first_input_target ();
1771 /* Failed - use the default output target. */
1772 if (output_target == NULL)
1773 output_target = default_target;
1777 /* Has the user requested a particular endianness on the command
1779 if (command_line.endian != ENDIAN_UNSET)
1781 const bfd_target *target;
1782 enum bfd_endian desired_endian;
1784 /* Get the chosen target. */
1785 target = bfd_search_for_target (get_target, (PTR) output_target);
1787 /* If the target is not supported, we cannot do anything. */
1790 if (command_line.endian == ENDIAN_BIG)
1791 desired_endian = BFD_ENDIAN_BIG;
1793 desired_endian = BFD_ENDIAN_LITTLE;
1795 /* See if the target has the wrong endianness. This should
1796 not happen if the linker script has provided big and
1797 little endian alternatives, but some scrips don't do
1799 if (target->byteorder != desired_endian)
1801 /* If it does, then see if the target provides
1802 an alternative with the correct endianness. */
1803 if (target->alternative_target != NULL
1804 && (target->alternative_target->byteorder == desired_endian))
1805 output_target = target->alternative_target->name;
1808 /* Try to find a target as similar as possible to
1809 the default target, but which has the desired
1810 endian characteristic. */
1811 (void) bfd_search_for_target (closest_target_match,
1814 /* Oh dear - we could not find any targets that
1815 satisfy our requirements. */
1817 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1819 output_target = winner->name;
1825 output = bfd_openw (name, output_target);
1827 if (output == (bfd *) NULL)
1829 if (bfd_get_error () == bfd_error_invalid_target)
1830 einfo (_("%P%F: target %s not found\n"), output_target);
1832 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1835 delete_output_file_on_failure = true;
1838 output->flags |= D_PAGED;
1841 if (! bfd_set_format (output, bfd_object))
1842 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1843 if (! bfd_set_arch_mach (output,
1844 ldfile_output_architecture,
1845 ldfile_output_machine))
1846 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1848 link_info.hash = bfd_link_hash_table_create (output);
1849 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1850 einfo (_("%P%F: can not create link hash table: %E\n"));
1852 bfd_set_gp_size (output, g_switch_value);
1857 ldlang_open_output (statement)
1858 lang_statement_union_type *statement;
1860 switch (statement->header.type)
1862 case lang_output_statement_enum:
1863 ASSERT (output_bfd == (bfd *) NULL);
1864 output_bfd = open_output (statement->output_statement.name);
1865 ldemul_set_output_arch ();
1866 if (config.magic_demand_paged && !link_info.relocateable)
1867 output_bfd->flags |= D_PAGED;
1869 output_bfd->flags &= ~D_PAGED;
1870 if (config.text_read_only)
1871 output_bfd->flags |= WP_TEXT;
1873 output_bfd->flags &= ~WP_TEXT;
1874 if (link_info.traditional_format)
1875 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1877 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1880 case lang_target_statement_enum:
1881 current_target = statement->target_statement.target;
1888 /* Open all the input files. */
1891 open_input_bfds (s, force)
1892 lang_statement_union_type *s;
1895 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1897 switch (s->header.type)
1899 case lang_constructors_statement_enum:
1900 open_input_bfds (constructor_list.head, force);
1902 case lang_output_section_statement_enum:
1903 open_input_bfds (s->output_section_statement.children.head, force);
1905 case lang_wild_statement_enum:
1906 /* Maybe we should load the file's symbols. */
1907 if (s->wild_statement.filename
1908 && ! wildcardp (s->wild_statement.filename))
1909 (void) lookup_name (s->wild_statement.filename);
1910 open_input_bfds (s->wild_statement.children.head, force);
1912 case lang_group_statement_enum:
1914 struct bfd_link_hash_entry *undefs;
1916 /* We must continually search the entries in the group
1917 until no new symbols are added to the list of undefined
1922 undefs = link_info.hash->undefs_tail;
1923 open_input_bfds (s->group_statement.children.head, true);
1925 while (undefs != link_info.hash->undefs_tail);
1928 case lang_target_statement_enum:
1929 current_target = s->target_statement.target;
1931 case lang_input_statement_enum:
1932 if (s->input_statement.real)
1934 lang_statement_list_type add;
1936 s->input_statement.target = current_target;
1938 /* If we are being called from within a group, and this
1939 is an archive which has already been searched, then
1940 force it to be researched unless the whole archive
1941 has been loaded already. */
1943 && !s->input_statement.whole_archive
1944 && s->input_statement.loaded
1945 && bfd_check_format (s->input_statement.the_bfd,
1947 s->input_statement.loaded = false;
1949 lang_list_init (&add);
1951 if (! load_symbols (&s->input_statement, &add))
1952 config.make_executable = false;
1954 if (add.head != NULL)
1956 *add.tail = s->next;
1967 /* If there are [COMMONS] statements, put a wild one into the bss
1971 lang_reasonable_defaults ()
1974 lang_output_section_statement_lookup (".text");
1975 lang_output_section_statement_lookup (".data");
1977 default_common_section = lang_output_section_statement_lookup (".bss");
1979 if (placed_commons == false)
1981 lang_wild_statement_type *new =
1982 new_stat (lang_wild_statement,
1983 &default_common_section->children);
1985 new->section_name = "COMMON";
1986 new->filename = (char *) NULL;
1987 lang_list_init (&new->children);
1992 /* Add the supplied name to the symbol table as an undefined reference.
1993 Remove items from the chain as we open input bfds. */
1994 typedef struct ldlang_undef_chain_list
1996 struct ldlang_undef_chain_list *next;
1998 } ldlang_undef_chain_list_type;
2000 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
2003 ldlang_add_undef (name)
2004 const char *const name;
2006 ldlang_undef_chain_list_type *new =
2007 ((ldlang_undef_chain_list_type *)
2008 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
2010 new->next = ldlang_undef_chain_list_head;
2011 ldlang_undef_chain_list_head = new;
2013 new->name = xstrdup (name);
2016 /* Run through the list of undefineds created above and place them
2017 into the linker hash table as undefined symbols belonging to the
2021 lang_place_undefineds ()
2023 ldlang_undef_chain_list_type *ptr;
2025 for (ptr = ldlang_undef_chain_list_head;
2026 ptr != (ldlang_undef_chain_list_type *) NULL;
2029 struct bfd_link_hash_entry *h;
2031 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2032 if (h == (struct bfd_link_hash_entry *) NULL)
2033 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2034 if (h->type == bfd_link_hash_new)
2036 h->type = bfd_link_hash_undefined;
2037 h->u.undef.abfd = NULL;
2038 bfd_link_add_undef (link_info.hash, h);
2043 /* Open input files and attatch to output sections. */
2046 map_input_to_output_sections (s, target, output_section_statement)
2047 lang_statement_union_type *s;
2049 lang_output_section_statement_type *output_section_statement;
2051 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2053 switch (s->header.type)
2056 case lang_wild_statement_enum:
2057 wild (&s->wild_statement, s->wild_statement.section_name,
2058 s->wild_statement.filename, target,
2059 output_section_statement);
2062 case lang_constructors_statement_enum:
2063 map_input_to_output_sections (constructor_list.head,
2065 output_section_statement);
2067 case lang_output_section_statement_enum:
2068 map_input_to_output_sections (s->output_section_statement.children.head,
2070 &s->output_section_statement);
2072 case lang_output_statement_enum:
2074 case lang_target_statement_enum:
2075 target = s->target_statement.target;
2077 case lang_group_statement_enum:
2078 map_input_to_output_sections (s->group_statement.children.head,
2080 output_section_statement);
2082 case lang_fill_statement_enum:
2083 case lang_input_section_enum:
2084 case lang_object_symbols_statement_enum:
2085 case lang_data_statement_enum:
2086 case lang_reloc_statement_enum:
2087 case lang_padding_statement_enum:
2088 case lang_input_statement_enum:
2089 if (output_section_statement != NULL
2090 && output_section_statement->bfd_section == NULL)
2091 init_os (output_section_statement);
2093 case lang_assignment_statement_enum:
2094 if (output_section_statement != NULL
2095 && output_section_statement->bfd_section == NULL)
2096 init_os (output_section_statement);
2098 /* Make sure that any sections mentioned in the assignment
2100 exp_init_os (s->assignment_statement.exp);
2102 case lang_afile_asection_pair_statement_enum:
2105 case lang_address_statement_enum:
2106 /* Mark the specified section with the supplied address. */
2108 lang_output_section_statement_type *os =
2109 lang_output_section_statement_lookup
2110 (s->address_statement.section_name);
2112 if (os->bfd_section == NULL)
2114 os->addr_tree = s->address_statement.address;
2122 print_output_section_statement (output_section_statement)
2123 lang_output_section_statement_type *output_section_statement;
2125 asection *section = output_section_statement->bfd_section;
2128 if (output_section_statement != abs_output_section)
2130 minfo ("\n%s", output_section_statement->name);
2132 if (section != NULL)
2134 print_dot = section->vma;
2136 len = strlen (output_section_statement->name);
2137 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2142 while (len < SECTION_NAME_MAP_LENGTH)
2148 minfo ("0x%V %W", section->vma, section->_raw_size);
2150 if (output_section_statement->load_base != NULL)
2154 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2155 "load base", lang_final_phase_enum);
2156 minfo (_(" load address 0x%V"), addr);
2163 print_statement_list (output_section_statement->children.head,
2164 output_section_statement);
2168 print_assignment (assignment, output_section)
2169 lang_assignment_statement_type *assignment;
2170 lang_output_section_statement_type *output_section;
2173 etree_value_type result;
2175 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2178 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2179 lang_final_phase_enum, print_dot, &print_dot);
2181 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2192 exp_print_tree (assignment->exp);
2198 print_input_statement (statm)
2199 lang_input_statement_type *statm;
2201 if (statm->filename != (char *) NULL)
2203 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2207 /* Print all symbols defined in a particular section. This is called
2208 via bfd_link_hash_traverse. */
2211 print_one_symbol (hash_entry, ptr)
2212 struct bfd_link_hash_entry *hash_entry;
2215 asection *sec = (asection *) ptr;
2217 if ((hash_entry->type == bfd_link_hash_defined
2218 || hash_entry->type == bfd_link_hash_defweak)
2219 && sec == hash_entry->u.def.section)
2223 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2226 (hash_entry->u.def.value
2227 + hash_entry->u.def.section->output_offset
2228 + hash_entry->u.def.section->output_section->vma));
2230 minfo (" %T\n", hash_entry->root.string);
2236 /* Print information about an input section to the map file. */
2239 print_input_section (in)
2240 lang_input_section_type *in;
2242 asection *i = in->section;
2243 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2244 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2245 ldfile_output_machine);
2250 minfo ("%s", i->name);
2252 if (i->output_section != NULL)
2256 len = 1 + strlen (i->name);
2257 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2262 while (len < SECTION_NAME_MAP_LENGTH)
2268 minfo ("0x%V %W %B\n",
2269 i->output_section->vma + i->output_offset, size / opb,
2272 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2274 len = SECTION_NAME_MAP_LENGTH + 3;
2286 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2289 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2291 print_dot = i->output_section->vma + i->output_offset + size / opb;
2297 print_fill_statement (fill)
2298 lang_fill_statement_type *fill;
2300 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2304 print_data_statement (data)
2305 lang_data_statement_type *data;
2311 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2312 ldfile_output_machine);
2314 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2317 addr = data->output_vma;
2318 if (data->output_section != NULL)
2319 addr += data->output_section->vma;
2347 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2349 if (data->exp->type.node_class != etree_value)
2352 exp_print_tree (data->exp);
2357 print_dot = addr + size / opb;
2361 /* Print an address statement. These are generated by options like
2365 print_address_statement (address)
2366 lang_address_statement_type *address;
2368 minfo (_("Address of section %s set to "), address->section_name);
2369 exp_print_tree (address->address);
2373 /* Print a reloc statement. */
2376 print_reloc_statement (reloc)
2377 lang_reloc_statement_type *reloc;
2382 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2383 ldfile_output_machine);
2385 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2388 addr = reloc->output_vma;
2389 if (reloc->output_section != NULL)
2390 addr += reloc->output_section->vma;
2392 size = bfd_get_reloc_size (reloc->howto);
2394 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2396 if (reloc->name != NULL)
2397 minfo ("%s+", reloc->name);
2399 minfo ("%s+", reloc->section->name);
2401 exp_print_tree (reloc->addend_exp);
2405 print_dot = addr + size / opb;
2409 print_padding_statement (s)
2410 lang_padding_statement_type *s;
2414 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2415 ldfile_output_machine);
2419 len = sizeof " *fill*" - 1;
2420 while (len < SECTION_NAME_MAP_LENGTH)
2426 addr = s->output_offset;
2427 if (s->output_section != NULL)
2428 addr += s->output_section->vma;
2429 minfo ("0x%V %W", addr, s->size);
2432 minfo (" %u", s->fill);
2436 print_dot = addr + s->size / opb;
2440 print_wild_statement (w, os)
2441 lang_wild_statement_type *w;
2442 lang_output_section_statement_type *os;
2446 if (w->filenames_sorted)
2448 if (w->exclude_filename_list != NULL)
2451 minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
2452 for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
2453 minfo (", %s", tmp->name);
2456 if (w->filename != NULL)
2457 minfo ("%s", w->filename);
2460 if (w->filenames_sorted)
2464 if (w->sections_sorted)
2466 if (w->section_name != NULL)
2467 minfo ("%s", w->section_name);
2470 if (w->sections_sorted)
2476 print_statement_list (w->children.head, os);
2479 /* Print a group statement. */
2483 lang_group_statement_type *s;
2484 lang_output_section_statement_type *os;
2486 fprintf (config.map_file, "START GROUP\n");
2487 print_statement_list (s->children.head, os);
2488 fprintf (config.map_file, "END GROUP\n");
2491 /* Print the list of statements in S.
2492 This can be called for any statement type. */
2495 print_statement_list (s, os)
2496 lang_statement_union_type *s;
2497 lang_output_section_statement_type *os;
2501 print_statement (s, os);
2506 /* Print the first statement in statement list S.
2507 This can be called for any statement type. */
2510 print_statement (s, os)
2511 lang_statement_union_type *s;
2512 lang_output_section_statement_type *os;
2514 switch (s->header.type)
2517 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2520 case lang_constructors_statement_enum:
2521 if (constructor_list.head != NULL)
2523 if (constructors_sorted)
2524 minfo (" SORT (CONSTRUCTORS)\n");
2526 minfo (" CONSTRUCTORS\n");
2527 print_statement_list (constructor_list.head, os);
2530 case lang_wild_statement_enum:
2531 print_wild_statement (&s->wild_statement, os);
2533 case lang_address_statement_enum:
2534 print_address_statement (&s->address_statement);
2536 case lang_object_symbols_statement_enum:
2537 minfo (" CREATE_OBJECT_SYMBOLS\n");
2539 case lang_fill_statement_enum:
2540 print_fill_statement (&s->fill_statement);
2542 case lang_data_statement_enum:
2543 print_data_statement (&s->data_statement);
2545 case lang_reloc_statement_enum:
2546 print_reloc_statement (&s->reloc_statement);
2548 case lang_input_section_enum:
2549 print_input_section (&s->input_section);
2551 case lang_padding_statement_enum:
2552 print_padding_statement (&s->padding_statement);
2554 case lang_output_section_statement_enum:
2555 print_output_section_statement (&s->output_section_statement);
2557 case lang_assignment_statement_enum:
2558 print_assignment (&s->assignment_statement, os);
2560 case lang_target_statement_enum:
2561 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2563 case lang_output_statement_enum:
2564 minfo ("OUTPUT(%s", s->output_statement.name);
2565 if (output_target != NULL)
2566 minfo (" %s", output_target);
2569 case lang_input_statement_enum:
2570 print_input_statement (&s->input_statement);
2572 case lang_group_statement_enum:
2573 print_group (&s->group_statement, os);
2575 case lang_afile_asection_pair_statement_enum:
2584 print_statement_list (statement_list.head, abs_output_section);
2587 /* Print the first N statements in statement list S to STDERR.
2588 If N == 0, nothing is printed.
2589 If N < 0, the entire list is printed.
2590 Intended to be called from GDB. */
2593 dprint_statement (s, n)
2594 lang_statement_union_type *s;
2597 FILE *map_save = config.map_file;
2599 config.map_file = stderr;
2602 print_statement_list (s, abs_output_section);
2605 while (s && --n >= 0)
2607 print_statement (s, abs_output_section);
2612 config.map_file = map_save;
2616 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2617 lang_statement_union_type **this_ptr;
2620 asection *output_section_statement;
2623 /* Align this section first to the
2624 input sections requirement, then
2625 to the output section's requirement.
2626 If this alignment is > than any seen before,
2627 then record it too. Perform the alignment by
2628 inserting a magic 'padding' statement. */
2630 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2631 ldfile_output_machine);
2632 unsigned int alignment_needed = align_power (dot, power) - dot;
2634 if (alignment_needed != 0)
2636 lang_statement_union_type *new =
2637 ((lang_statement_union_type *)
2638 stat_alloc (sizeof (lang_padding_statement_type)));
2640 /* Link into existing chain. */
2641 new->header.next = *this_ptr;
2643 new->header.type = lang_padding_statement_enum;
2644 new->padding_statement.output_section = output_section_statement;
2645 new->padding_statement.output_offset =
2646 dot - output_section_statement->vma;
2647 new->padding_statement.fill = fill;
2648 new->padding_statement.size = alignment_needed * opb;
2651 /* Remember the most restrictive alignment. */
2652 if (power > output_section_statement->alignment_power)
2654 output_section_statement->alignment_power = power;
2656 output_section_statement->_raw_size += alignment_needed * opb;
2658 return dot + alignment_needed;
2661 /* Work out how much this section will move the dot point. */
2664 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2665 lang_statement_union_type **this_ptr;
2666 lang_output_section_statement_type *output_section_statement;
2669 boolean relax ATTRIBUTE_UNUSED;
2671 lang_input_section_type *is = &((*this_ptr)->input_section);
2672 asection *i = is->section;
2673 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2674 ldfile_output_machine);
2676 if (is->ifile->just_syms_flag == false)
2678 if (output_section_statement->subsection_alignment != -1)
2679 i->alignment_power =
2680 output_section_statement->subsection_alignment;
2682 dot = insert_pad (this_ptr, fill, i->alignment_power,
2683 output_section_statement->bfd_section, dot);
2685 /* Remember where in the output section this input section goes. */
2687 i->output_offset = dot - output_section_statement->bfd_section->vma;
2689 /* Mark how big the output section must be to contain this now. */
2690 if (i->_cooked_size != 0)
2691 dot += i->_cooked_size / opb;
2693 dot += i->_raw_size / opb;
2694 output_section_statement->bfd_section->_raw_size =
2695 (dot - output_section_statement->bfd_section->vma) * opb;
2699 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2705 #define IGNORE_SECTION(bfd, s) \
2706 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2707 != (SEC_ALLOC | SEC_LOAD)) \
2708 || bfd_section_size (bfd, s) == 0)
2710 /* Check to see if any allocated sections overlap with other allocated
2711 sections. This can happen when the linker script specifically specifies
2712 the output section addresses of the two sections. */
2715 lang_check_section_addresses ()
2718 unsigned opb = bfd_octets_per_byte (output_bfd);
2720 /* Scan all sections in the output list. */
2721 for (s = output_bfd->sections; s != NULL; s = s->next)
2725 /* Ignore sections which are not loaded or which have no contents. */
2726 if (IGNORE_SECTION (output_bfd, s))
2729 /* Once we reach section 's' stop our seach. This prevents two
2730 warning messages from being produced, one for 'section A overlaps
2731 section B' and one for 'section B overlaps section A'. */
2732 for (os = output_bfd->sections; os != s; os = os->next)
2739 /* Only consider loadable sections with real contents. */
2740 if (IGNORE_SECTION (output_bfd, os))
2743 /* We must check the sections' LMA addresses not their
2744 VMA addresses because overlay sections can have
2745 overlapping VMAs but they must have distinct LMAs. */
2746 s_start = bfd_section_lma (output_bfd, s);
2747 os_start = bfd_section_lma (output_bfd, os);
2748 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2749 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2751 /* Look for an overlap. */
2752 if ((s_end < os_start) || (s_start > os_end))
2756 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2757 s->name, s_start, s_end, os->name, os_start, os_end);
2759 /* Once we have found one overlap for this section,
2760 stop looking for others. */
2766 /* This variable indicates whether bfd_relax_section should be called
2769 static boolean relax_again;
2771 /* Make sure the new address is within the region. We explicitly permit the
2772 current address to be at the exact end of the region when the address is
2773 non-zero, in case the region is at the end of addressable memory and the
2774 calculation wraps around. */
2777 os_region_check (os, region, tree, base)
2778 lang_output_section_statement_type *os;
2779 struct memory_region_struct *region;
2783 if ((region->current < region->origin
2784 || (region->current - region->origin > region->length))
2785 && ((region->current != region->origin + region->length)
2788 if (tree != (etree_type *) NULL)
2790 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2792 os->bfd_section->owner,
2793 os->bfd_section->name,
2798 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2800 os->bfd_section->owner,
2801 os->bfd_section->name);
2803 /* Reset the region pointer. */
2804 region->current = region->origin;
2808 /* Set the sizes for all the output sections. */
2811 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2812 lang_statement_union_type *s;
2813 lang_output_section_statement_type *output_section_statement;
2814 lang_statement_union_type **prev;
2819 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2820 ldfile_output_machine);
2822 /* Size up the sections from their constituent parts. */
2823 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2825 switch (s->header.type)
2827 case lang_output_section_statement_enum:
2830 lang_output_section_statement_type *os;
2832 os = &s->output_section_statement;
2833 if (os->bfd_section == NULL)
2834 /* This section was never actually created. */
2837 /* If this is a COFF shared library section, use the size and
2838 address from the input section. FIXME: This is COFF
2839 specific; it would be cleaner if there were some other way
2840 to do this, but nothing simple comes to mind. */
2841 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2845 if (os->children.head == NULL
2846 || os->children.head->next != NULL
2847 || os->children.head->header.type != lang_input_section_enum)
2848 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2851 input = os->children.head->input_section.section;
2852 bfd_set_section_vma (os->bfd_section->owner,
2854 bfd_section_vma (input->owner, input));
2855 os->bfd_section->_raw_size = input->_raw_size;
2859 if (bfd_is_abs_section (os->bfd_section))
2861 /* No matter what happens, an abs section starts at zero. */
2862 ASSERT (os->bfd_section->vma == 0);
2866 if (os->addr_tree == (etree_type *) NULL)
2868 /* No address specified for this section, get one
2869 from the region specification. */
2870 if (os->region == (lang_memory_region_type *) NULL
2871 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2872 & (SEC_ALLOC | SEC_LOAD)) != 0)
2873 && os->region->name[0] == '*'
2874 && strcmp (os->region->name, "*default*") == 0))
2876 os->region = lang_memory_default (os->bfd_section);
2879 /* If a loadable section is using the default memory
2880 region, and some non default memory regions were
2881 defined, issue a warning. */
2882 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2883 & (SEC_ALLOC | SEC_LOAD)) != 0
2884 && ! link_info.relocateable
2885 && strcmp (os->region->name, "*default*") == 0
2886 && lang_memory_region_list != NULL
2887 && (strcmp (lang_memory_region_list->name,
2889 || lang_memory_region_list->next != NULL))
2890 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2891 bfd_get_section_name (output_bfd,
2894 dot = os->region->current;
2896 if (os->section_alignment == -1)
2901 dot = align_power (dot,
2902 os->bfd_section->alignment_power);
2904 if (dot != olddot && config.warn_section_align)
2905 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2906 os->name, (unsigned int) (dot - olddot));
2913 r = exp_fold_tree (os->addr_tree,
2915 lang_allocating_phase_enum,
2917 if (r.valid_p == false)
2919 einfo (_("%F%S: non constant address expression for section %s\n"),
2922 dot = r.value + r.section->bfd_section->vma;
2925 /* The section starts here.
2926 First, align to what the section needs. */
2928 if (os->section_alignment != -1)
2929 dot = align_power (dot, os->section_alignment);
2931 bfd_set_section_vma (0, os->bfd_section, dot);
2933 os->bfd_section->output_offset = 0;
2936 (void) lang_size_sections (os->children.head, os,
2938 os->fill, dot, relax);
2940 /* Put the section within the requested block size, or
2941 align at the block boundary. */
2942 after = ALIGN_N (os->bfd_section->vma
2943 + os->bfd_section->_raw_size / opb,
2944 /* The coercion here is important, see ld.h. */
2945 (bfd_vma) os->block_value);
2947 if (bfd_is_abs_section (os->bfd_section))
2948 ASSERT (after == os->bfd_section->vma);
2950 os->bfd_section->_raw_size =
2951 (after - os->bfd_section->vma) * opb;
2952 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2953 os->processed = true;
2955 /* Update dot in the region ?
2956 We only do this if the section is going to be allocated,
2957 since unallocated sections do not contribute to the region's
2958 overall size in memory.
2960 If the SEC_NEVER_LOAD bit is not set, it will affect the
2961 addresses of sections after it. We have to update
2963 if (os->region != (lang_memory_region_type *) NULL
2964 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2965 & SEC_NEVER_LOAD) == 0
2966 || (bfd_get_section_flags (output_bfd, os->bfd_section)
2967 & (SEC_ALLOC | SEC_LOAD))))
2969 os->region->current = dot;
2971 /* Make sure the new address is within the region. */
2972 os_region_check (os, os->region, os->addr_tree,
2973 os->bfd_section->vma);
2975 /* If there's no load address specified, use the run
2976 region as the load region. */
2977 if (os->lma_region == NULL && os->load_base == NULL)
2978 os->lma_region = os->region;
2980 if (os->lma_region != NULL)
2982 if (os->load_base != NULL)
2984 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2988 /* Don't allocate twice. */
2989 if (os->lma_region != os->region)
2991 /* Set load_base, which will be handled later. */
2993 exp_intop (os->lma_region->current);
2994 os->lma_region->current +=
2995 os->bfd_section->_raw_size / opb;
2996 os_region_check (os, os->lma_region, NULL,
2997 os->bfd_section->lma);
3005 case lang_constructors_statement_enum:
3006 dot = lang_size_sections (constructor_list.head,
3007 output_section_statement,
3008 &s->wild_statement.children.head,
3013 case lang_data_statement_enum:
3015 unsigned int size = 0;
3017 s->data_statement.output_vma =
3018 dot - output_section_statement->bfd_section->vma;
3019 s->data_statement.output_section =
3020 output_section_statement->bfd_section;
3022 switch (s->data_statement.type)
3043 output_section_statement->bfd_section->_raw_size += size;
3044 /* The output section gets contents, and then we inspect for
3045 any flags set in the input script which override any ALLOC. */
3046 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3047 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3049 output_section_statement->bfd_section->flags |=
3050 SEC_ALLOC | SEC_LOAD;
3055 case lang_reloc_statement_enum:
3059 s->reloc_statement.output_vma =
3060 dot - output_section_statement->bfd_section->vma;
3061 s->reloc_statement.output_section =
3062 output_section_statement->bfd_section;
3063 size = bfd_get_reloc_size (s->reloc_statement.howto);
3065 output_section_statement->bfd_section->_raw_size += size;
3069 case lang_wild_statement_enum:
3071 dot = lang_size_sections (s->wild_statement.children.head,
3072 output_section_statement,
3073 &s->wild_statement.children.head,
3078 case lang_object_symbols_statement_enum:
3079 link_info.create_object_symbols_section =
3080 output_section_statement->bfd_section;
3082 case lang_output_statement_enum:
3083 case lang_target_statement_enum:
3085 case lang_input_section_enum:
3089 i = (*prev)->input_section.section;
3092 if (i->_cooked_size == 0)
3093 i->_cooked_size = i->_raw_size;
3099 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3100 einfo (_("%P%F: can't relax section: %E\n"));
3104 dot = size_input_section (prev,
3105 output_section_statement,
3106 output_section_statement->fill,
3110 case lang_input_statement_enum:
3112 case lang_fill_statement_enum:
3113 s->fill_statement.output_section =
3114 output_section_statement->bfd_section;
3116 fill = s->fill_statement.fill;
3118 case lang_assignment_statement_enum:
3120 bfd_vma newdot = dot;
3122 exp_fold_tree (s->assignment_statement.exp,
3123 output_section_statement,
3124 lang_allocating_phase_enum,
3130 /* The assignment changed dot. Insert a pad. */
3131 if (output_section_statement == abs_output_section)
3133 /* If we don't have an output section, then just adjust
3134 the default memory address. */
3135 lang_memory_region_lookup ("*default*")->current = newdot;
3139 lang_statement_union_type *new =
3140 ((lang_statement_union_type *)
3141 stat_alloc (sizeof (lang_padding_statement_type)));
3143 /* Link into existing chain. */
3144 new->header.next = *prev;
3146 new->header.type = lang_padding_statement_enum;
3147 new->padding_statement.output_section =
3148 output_section_statement->bfd_section;
3149 new->padding_statement.output_offset =
3150 dot - output_section_statement->bfd_section->vma;
3151 new->padding_statement.fill = fill;
3152 new->padding_statement.size = (newdot - dot) * opb;
3153 output_section_statement->bfd_section->_raw_size +=
3154 new->padding_statement.size;
3162 case lang_padding_statement_enum:
3163 /* If we are relaxing, and this is not the first pass, some
3164 padding statements may have been inserted during previous
3165 passes. We may have to move the padding statement to a new
3166 location if dot has a different value at this point in this
3167 pass than it did at this point in the previous pass. */
3168 s->padding_statement.output_offset =
3169 dot - output_section_statement->bfd_section->vma;
3170 dot += s->padding_statement.size / opb;
3171 output_section_statement->bfd_section->_raw_size +=
3172 s->padding_statement.size;
3175 case lang_group_statement_enum:
3176 dot = lang_size_sections (s->group_statement.children.head,
3177 output_section_statement,
3178 &s->group_statement.children.head,
3186 /* This can only get here when relaxing is turned on. */
3188 case lang_address_statement_enum:
3191 prev = &s->header.next;
3197 lang_do_assignments (s, output_section_statement, fill, dot)
3198 lang_statement_union_type *s;
3199 lang_output_section_statement_type *output_section_statement;
3203 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3204 ldfile_output_machine);
3206 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3208 switch (s->header.type)
3210 case lang_constructors_statement_enum:
3211 dot = lang_do_assignments (constructor_list.head,
3212 output_section_statement,
3217 case lang_output_section_statement_enum:
3219 lang_output_section_statement_type *os;
3221 os = &(s->output_section_statement);
3222 if (os->bfd_section != NULL)
3224 dot = os->bfd_section->vma;
3225 (void) lang_do_assignments (os->children.head, os,
3227 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3232 /* If nothing has been placed into the output section then
3233 it won't have a bfd_section. */
3234 if (os->bfd_section)
3236 os->bfd_section->lma
3237 = exp_get_abs_int (os->load_base, 0, "load base",
3238 lang_final_phase_enum);
3243 case lang_wild_statement_enum:
3245 dot = lang_do_assignments (s->wild_statement.children.head,
3246 output_section_statement,
3251 case lang_object_symbols_statement_enum:
3252 case lang_output_statement_enum:
3253 case lang_target_statement_enum:
3255 case lang_common_statement_enum:
3258 case lang_data_statement_enum:
3260 etree_value_type value;
3262 value = exp_fold_tree (s->data_statement.exp,
3264 lang_final_phase_enum, dot, &dot);
3265 s->data_statement.value = value.value;
3266 if (value.valid_p == false)
3267 einfo (_("%F%P: invalid data statement\n"));
3271 switch (s->data_statement.type)
3295 case lang_reloc_statement_enum:
3297 etree_value_type value;
3299 value = exp_fold_tree (s->reloc_statement.addend_exp,
3301 lang_final_phase_enum, dot, &dot);
3302 s->reloc_statement.addend_value = value.value;
3303 if (value.valid_p == false)
3304 einfo (_("%F%P: invalid reloc statement\n"));
3306 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3309 case lang_input_section_enum:
3311 asection *in = s->input_section.section;
3313 if (in->_cooked_size != 0)
3314 dot += in->_cooked_size / opb;
3316 dot += in->_raw_size / opb;
3320 case lang_input_statement_enum:
3322 case lang_fill_statement_enum:
3323 fill = s->fill_statement.fill;
3325 case lang_assignment_statement_enum:
3327 exp_fold_tree (s->assignment_statement.exp,
3328 output_section_statement,
3329 lang_final_phase_enum,
3335 case lang_padding_statement_enum:
3336 dot += s->padding_statement.size / opb;
3339 case lang_group_statement_enum:
3340 dot = lang_do_assignments (s->group_statement.children.head,
3341 output_section_statement,
3349 case lang_address_statement_enum:
3357 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3358 operator .startof. (section_name), it produces an undefined symbol
3359 .startof.section_name. Similarly, when it sees
3360 .sizeof. (section_name), it produces an undefined symbol
3361 .sizeof.section_name. For all the output sections, we look for
3362 such symbols, and set them to the correct value. */
3369 if (link_info.relocateable)
3372 for (s = output_bfd->sections; s != NULL; s = s->next)
3374 const char *secname;
3376 struct bfd_link_hash_entry *h;
3378 secname = bfd_get_section_name (output_bfd, s);
3379 buf = xmalloc (10 + strlen (secname));
3381 sprintf (buf, ".startof.%s", secname);
3382 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3383 if (h != NULL && h->type == bfd_link_hash_undefined)
3385 h->type = bfd_link_hash_defined;
3386 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3387 h->u.def.section = bfd_abs_section_ptr;
3390 sprintf (buf, ".sizeof.%s", secname);
3391 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3392 if (h != NULL && h->type == bfd_link_hash_undefined)
3396 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3397 ldfile_output_machine);
3398 h->type = bfd_link_hash_defined;
3399 if (s->_cooked_size != 0)
3400 h->u.def.value = s->_cooked_size / opb;
3402 h->u.def.value = s->_raw_size / opb;
3403 h->u.def.section = bfd_abs_section_ptr;
3413 struct bfd_link_hash_entry *h;
3416 if (link_info.relocateable || link_info.shared)
3421 if (entry_symbol == (char *) NULL)
3423 /* No entry has been specified. Look for start, but don't warn
3424 if we don't find it. */
3425 entry_symbol = "start";
3429 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3430 if (h != (struct bfd_link_hash_entry *) NULL
3431 && (h->type == bfd_link_hash_defined
3432 || h->type == bfd_link_hash_defweak)
3433 && h->u.def.section->output_section != NULL)
3437 val = (h->u.def.value
3438 + bfd_get_section_vma (output_bfd,
3439 h->u.def.section->output_section)
3440 + h->u.def.section->output_offset);
3441 if (! bfd_set_start_address (output_bfd, val))
3442 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3449 /* We couldn't find the entry symbol. Try parsing it as a
3451 val = bfd_scan_vma (entry_symbol, &send, 0);
3454 if (! bfd_set_start_address (output_bfd, val))
3455 einfo (_("%P%F: can't set start address\n"));
3461 /* Can't find the entry symbol, and it's not a number. Use
3462 the first address in the text section. */
3463 ts = bfd_get_section_by_name (output_bfd, ".text");
3464 if (ts != (asection *) NULL)
3467 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3468 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3469 if (! bfd_set_start_address (output_bfd,
3470 bfd_get_section_vma (output_bfd,
3472 einfo (_("%P%F: can't set start address\n"));
3477 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3484 /* This is a small function used when we want to ignore errors from
3488 #ifdef ANSI_PROTOTYPES
3489 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3491 ignore_bfd_errors (s)
3492 const char *s ATTRIBUTE_UNUSED;
3495 /* Don't do anything. */
3498 /* Check that the architecture of all the input files is compatible
3499 with the output file. Also call the backend to let it do any
3500 other checking that is needed. */
3505 lang_statement_union_type *file;
3507 const bfd_arch_info_type *compatible;
3509 for (file = file_chain.head;
3510 file != (lang_statement_union_type *) NULL;
3511 file = file->input_statement.next)
3513 input_bfd = file->input_statement.the_bfd;
3514 compatible = bfd_arch_get_compatible (input_bfd,
3516 if (compatible == NULL)
3518 if (command_line.warn_mismatch)
3519 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3520 bfd_printable_name (input_bfd), input_bfd,
3521 bfd_printable_name (output_bfd));
3523 else if (link_info.relocateable
3524 /* In general it is not possible to perform a relocatable
3525 link between differing object formats when the input
3526 file has relocations, because the relocations in the
3527 input format may not have equivalent representations in
3528 the output format (and besides BFD does not translate
3529 relocs for other link purposes than a final link). */
3530 && bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd)
3531 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3532 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3533 bfd_get_target (input_bfd), input_bfd,
3534 bfd_get_target (output_bfd), output_bfd);
3535 else if (bfd_count_sections (input_bfd))
3537 /* If the input bfd has no contents, it shouldn't set the
3538 private data of the output bfd. */
3540 bfd_error_handler_type pfn = NULL;
3542 /* If we aren't supposed to warn about mismatched input
3543 files, temporarily set the BFD error handler to a
3544 function which will do nothing. We still want to call
3545 bfd_merge_private_bfd_data, since it may set up
3546 information which is needed in the output file. */
3547 if (! command_line.warn_mismatch)
3548 pfn = bfd_set_error_handler (ignore_bfd_errors);
3549 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3551 if (command_line.warn_mismatch)
3552 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3555 if (! command_line.warn_mismatch)
3556 bfd_set_error_handler (pfn);
3561 /* Look through all the global common symbols and attach them to the
3562 correct section. The -sort-common command line switch may be used
3563 to roughly sort the entries by size. */
3568 if (link_info.relocateable
3569 && ! command_line.force_common_definition)
3572 if (! config.sort_common)
3573 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3578 for (power = 4; power >= 0; power--)
3579 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3584 /* Place one common symbol in the correct section. */
3587 lang_one_common (h, info)
3588 struct bfd_link_hash_entry *h;
3591 unsigned int power_of_two;
3594 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3595 ldfile_output_machine);
3597 if (h->type != bfd_link_hash_common)
3601 power_of_two = h->u.c.p->alignment_power;
3603 if (config.sort_common
3604 && power_of_two < (unsigned int) *(int *) info)
3607 section = h->u.c.p->section;
3609 /* Increase the size of the section. */
3610 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3611 (bfd_size_type) (1 << power_of_two)) * opb;
3613 /* Adjust the alignment if necessary. */
3614 if (power_of_two > section->alignment_power)
3615 section->alignment_power = power_of_two;
3617 /* Change the symbol from common to defined. */
3618 h->type = bfd_link_hash_defined;
3619 h->u.def.section = section;
3620 h->u.def.value = section->_cooked_size;
3622 /* Increase the size of the section. */
3623 section->_cooked_size += size;
3625 /* Make sure the section is allocated in memory, and make sure that
3626 it is no longer a common section. */
3627 section->flags |= SEC_ALLOC;
3628 section->flags &= ~SEC_IS_COMMON;
3630 if (config.map_file != NULL)
3632 static boolean header_printed;
3637 if (! header_printed)
3639 minfo (_("\nAllocating common symbols\n"));
3640 minfo (_("Common symbol size file\n\n"));
3641 header_printed = true;
3644 name = demangle (h->root.string);
3646 len = strlen (name);
3661 if (size <= 0xffffffff)
3662 sprintf (buf, "%lx", (unsigned long) size);
3664 sprintf_vma (buf, size);
3674 minfo ("%B\n", section->owner);
3680 /* Run through the input files and ensure that every input section has
3681 somewhere to go. If one is found without a destination then create
3682 an input request and place it into the statement tree. */
3685 lang_place_orphans ()
3687 LANG_FOR_EACH_INPUT_STATEMENT (file)
3691 for (s = file->the_bfd->sections;
3692 s != (asection *) NULL;
3695 if (s->output_section == (asection *) NULL)
3697 /* This section of the file is not attatched, root
3698 around for a sensible place for it to go. */
3700 if (file->just_syms_flag)
3702 /* We are only retrieving symbol values from this
3703 file. We want the symbols to act as though the
3704 values in the file are absolute. */
3705 s->output_section = bfd_abs_section_ptr;
3706 s->output_offset = s->vma;
3708 else if (strcmp (s->name, "COMMON") == 0)
3710 /* This is a lonely common section which must have
3711 come from an archive. We attach to the section
3712 with the wildcard. */
3713 if (! link_info.relocateable
3714 || command_line.force_common_definition)
3716 if (default_common_section == NULL)
3719 /* This message happens when using the
3720 svr3.ifile linker script, so I have
3722 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3724 default_common_section =
3725 lang_output_section_statement_lookup (".bss");
3728 wild_doit (&default_common_section->children, s,
3729 default_common_section, file);
3732 else if (ldemul_place_orphan (file, s))
3736 lang_output_section_statement_type *os =
3737 lang_output_section_statement_lookup (s->name);
3739 wild_doit (&os->children, s, os, file);
3747 lang_set_flags (ptr, flags, invert)
3748 lang_memory_region_type *ptr;
3752 flagword *ptr_flags;
3754 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3760 *ptr_flags |= SEC_ALLOC;
3764 *ptr_flags |= SEC_READONLY;
3768 *ptr_flags |= SEC_DATA;
3772 *ptr_flags |= SEC_CODE;
3777 *ptr_flags |= SEC_LOAD;
3781 einfo (_("%P%F: invalid syntax in flags\n"));
3788 /* Call a function on each input file. This function will be called
3789 on an archive, but not on the elements. */
3792 lang_for_each_input_file (func)
3793 void (*func) PARAMS ((lang_input_statement_type *));
3795 lang_input_statement_type *f;
3797 for (f = (lang_input_statement_type *) input_file_chain.head;
3799 f = (lang_input_statement_type *) f->next_real_file)
3803 /* Call a function on each file. The function will be called on all
3804 the elements of an archive which are included in the link, but will
3805 not be called on the archive file itself. */
3808 lang_for_each_file (func)
3809 void (*func) PARAMS ((lang_input_statement_type *));
3811 LANG_FOR_EACH_INPUT_STATEMENT (f)
3822 lang_for_each_input_section (func)
3823 void (*func) PARAMS ((bfd *ab, asection *as));
3825 LANG_FOR_EACH_INPUT_STATEMENT (f)
3829 for (s = f->the_bfd->sections;
3830 s != (asection *) NULL;
3833 func (f->the_bfd, s);
3841 ldlang_add_file (entry)
3842 lang_input_statement_type *entry;
3846 lang_statement_append (&file_chain,
3847 (lang_statement_union_type *) entry,
3850 /* The BFD linker needs to have a list of all input BFDs involved in
3852 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3853 ASSERT (entry->the_bfd != output_bfd);
3854 for (pp = &link_info.input_bfds;
3855 *pp != (bfd *) NULL;
3856 pp = &(*pp)->link_next)
3858 *pp = entry->the_bfd;
3859 entry->the_bfd->usrdata = (PTR) entry;
3860 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3862 /* Look through the sections and check for any which should not be
3863 included in the link. We need to do this now, so that we can
3864 notice when the backend linker tries to report multiple
3865 definition errors for symbols which are in sections we aren't
3866 going to link. FIXME: It might be better to entirely ignore
3867 symbols which are defined in sections which are going to be
3868 discarded. This would require modifying the backend linker for
3869 each backend which might set the SEC_LINK_ONCE flag. If we do
3870 this, we should probably handle SEC_EXCLUDE in the same way. */
3872 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3876 lang_add_output (name, from_script)
3880 /* Make -o on command line override OUTPUT in script. */
3881 if (had_output_filename == false || !from_script)
3883 output_filename = name;
3884 had_output_filename = true;
3888 static lang_output_section_statement_type *current_section;
3900 for (l = 0; l < 32; l++)
3902 if (i >= (unsigned int) x)
3910 lang_output_section_statement_type *
3911 lang_enter_output_section_statement (output_section_statement_name,
3912 address_exp, sectype, block_value,
3913 align, subalign, ebase)
3914 const char *output_section_statement_name;
3915 etree_type *address_exp;
3916 enum section_type sectype;
3917 bfd_vma block_value;
3919 etree_type *subalign;
3922 lang_output_section_statement_type *os;
3926 lang_output_section_statement_lookup (output_section_statement_name);
3928 /* Add this statement to tree. */
3930 add_statement (lang_output_section_statement_enum,
3931 output_section_statement);
3933 /* Make next things chain into subchain of this. */
3935 if (os->addr_tree == (etree_type *) NULL)
3937 os->addr_tree = address_exp;
3939 os->sectype = sectype;
3940 if (sectype != noload_section)
3941 os->flags = SEC_NO_FLAGS;
3943 os->flags = SEC_NEVER_LOAD;
3944 os->block_value = block_value ? block_value : 1;
3945 stat_ptr = &os->children;
3947 os->subsection_alignment =
3948 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
3949 os->section_alignment =
3950 topower (exp_get_value_int (align, -1, "section alignment", 0));
3952 os->load_base = ebase;
3959 lang_output_statement_type *new =
3960 new_stat (lang_output_statement, stat_ptr);
3962 new->name = output_filename;
3965 /* Reset the current counters in the regions. */
3968 reset_memory_regions ()
3970 lang_memory_region_type *p = lang_memory_region_list;
3972 for (p = lang_memory_region_list;
3973 p != (lang_memory_region_type *) NULL;
3976 p->old_length = (bfd_size_type) (p->current - p->origin);
3977 p->current = p->origin;
3981 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3982 as needed. SECTION may be NULL, in which case it is a wild card. */
3985 gc_section_callback (ptr, section, file, data)
3986 lang_wild_statement_type *ptr;
3988 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3989 PTR data ATTRIBUTE_UNUSED;
3991 /* If the wild pattern was marked KEEP, the member sections
3992 should be as well. */
3993 if (ptr->keep_sections)
3994 section->flags |= SEC_KEEP;
3997 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3998 may be NULL, indicating that it is a wildcard. */
4001 lang_gc_wild (s, section, file)
4002 lang_wild_statement_type *s;
4003 const char *section;
4006 walk_wild (s, section, file, gc_section_callback, NULL);
4009 /* Iterate over sections marking them against GC. */
4012 lang_gc_sections_1 (s)
4013 lang_statement_union_type *s;
4015 for (; s != (lang_statement_union_type *) NULL; s = s->next)
4017 switch (s->header.type)
4019 case lang_wild_statement_enum:
4020 lang_gc_wild (&s->wild_statement,
4021 s->wild_statement.section_name,
4022 s->wild_statement.filename);
4024 case lang_constructors_statement_enum:
4025 lang_gc_sections_1 (constructor_list.head);
4027 case lang_output_section_statement_enum:
4028 lang_gc_sections_1 (s->output_section_statement.children.head);
4030 case lang_group_statement_enum:
4031 lang_gc_sections_1 (s->group_statement.children.head);
4042 struct bfd_link_hash_entry *h;
4043 ldlang_undef_chain_list_type *ulist, fake_list_start;
4045 /* Keep all sections so marked in the link script. */
4047 lang_gc_sections_1 (statement_list.head);
4049 /* Keep all sections containing symbols undefined on the command-line.
4050 Handle the entry symbol at the same time. */
4052 if (entry_symbol != NULL)
4054 fake_list_start.next = ldlang_undef_chain_list_head;
4055 fake_list_start.name = (char *) entry_symbol;
4056 ulist = &fake_list_start;
4059 ulist = ldlang_undef_chain_list_head;
4061 for (; ulist; ulist = ulist->next)
4063 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4064 false, false, false);
4066 if (h != (struct bfd_link_hash_entry *) NULL
4067 && (h->type == bfd_link_hash_defined
4068 || h->type == bfd_link_hash_defweak)
4069 && ! bfd_is_abs_section (h->u.def.section))
4071 h->u.def.section->flags |= SEC_KEEP;
4075 bfd_gc_sections (output_bfd, &link_info);
4081 lang_reasonable_defaults ();
4082 current_target = default_target;
4084 /* Open the output file. */
4085 lang_for_each_statement (ldlang_open_output);
4087 ldemul_create_output_section_statements ();
4089 /* Add to the hash table all undefineds on the command line. */
4090 lang_place_undefineds ();
4092 already_linked_table_init ();
4094 /* Create a bfd for each input file. */
4095 current_target = default_target;
4096 open_input_bfds (statement_list.head, false);
4098 ldemul_after_open ();
4100 already_linked_table_free ();
4102 /* Make sure that we're not mixing architectures. We call this
4103 after all the input files have been opened, but before we do any
4104 other processing, so that any operations merge_private_bfd_data
4105 does on the output file will be known during the rest of the
4109 /* Handle .exports instead of a version script if we're told to do so. */
4110 if (command_line.version_exports_section)
4111 lang_do_version_exports_section ();
4113 /* Build all sets based on the information gathered from the input
4115 ldctor_build_sets ();
4117 /* Remove unreferenced sections if asked to. */
4118 if (command_line.gc_sections)
4119 lang_gc_sections ();
4121 /* If there were any SEC_MERGE sections, finish their merging, so that
4122 section sizes can be computed. This has to be done after GC of sections,
4123 so that GCed sections are not merged, but before assigning output
4124 sections, since removing whole input sections is hard then. */
4125 bfd_merge_sections (output_bfd, &link_info);
4127 /* Size up the common data. */
4130 /* Run through the contours of the script and attach input sections
4131 to the correct output sections. */
4132 map_input_to_output_sections (statement_list.head, (char *) NULL,
4133 (lang_output_section_statement_type *) NULL);
4135 /* Find any sections not attached explicitly and handle them. */
4136 lang_place_orphans ();
4138 ldemul_before_allocation ();
4140 /* We must record the program headers before we try to fix the
4141 section positions, since they will affect SIZEOF_HEADERS. */
4142 lang_record_phdrs ();
4144 /* Now run around and relax if we can. */
4145 if (command_line.relax)
4147 /* First time round is a trial run to get the 'worst case'
4148 addresses of the objects if there was no relaxing. */
4149 lang_size_sections (statement_list.head,
4151 &(statement_list.head), 0, (bfd_vma) 0, false);
4153 /* Keep relaxing until bfd_relax_section gives up. */
4156 reset_memory_regions ();
4158 relax_again = false;
4160 /* Note: pe-dll.c does something like this also. If you find
4161 you need to change this code, you probably need to change
4162 pe-dll.c also. DJ */
4164 /* Do all the assignments with our current guesses as to
4166 lang_do_assignments (statement_list.head,
4168 (fill_type) 0, (bfd_vma) 0);
4170 /* Perform another relax pass - this time we know where the
4171 globals are, so can make better guess. */
4172 lang_size_sections (statement_list.head,
4174 &(statement_list.head), 0, (bfd_vma) 0, true);
4176 while (relax_again);
4180 /* Size up the sections. */
4181 lang_size_sections (statement_list.head,
4183 &(statement_list.head), 0, (bfd_vma) 0, false);
4186 /* See if anything special should be done now we know how big
4188 ldemul_after_allocation ();
4190 /* Fix any .startof. or .sizeof. symbols. */
4191 lang_set_startof ();
4193 /* Do all the assignments, now that we know the final resting places
4194 of all the symbols. */
4196 lang_do_assignments (statement_list.head,
4198 (fill_type) 0, (bfd_vma) 0);
4200 /* Make sure that the section addresses make sense. */
4201 if (! link_info.relocateable
4202 && command_line.check_section_addresses)
4203 lang_check_section_addresses ();
4211 /* EXPORTED TO YACC */
4214 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
4215 keep_sections, exclude_filename_list)
4216 const char *const section_name;
4217 boolean sections_sorted;
4218 const char *const filename;
4219 boolean filenames_sorted;
4220 boolean keep_sections;
4221 struct name_list *exclude_filename_list;
4223 lang_wild_statement_type *new = new_stat (lang_wild_statement,
4226 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4228 placed_commons = true;
4230 if (filename != NULL && ! wildcardp (filename))
4232 lang_has_input_file = true;
4234 new->section_name = section_name;
4235 new->sections_sorted = sections_sorted;
4236 new->filename = filename;
4237 new->filenames_sorted = filenames_sorted;
4238 new->keep_sections = keep_sections;
4239 new->exclude_filename_list = exclude_filename_list;
4240 lang_list_init (&new->children);
4244 lang_section_start (name, address)
4246 etree_type *address;
4248 lang_address_statement_type *ad;
4250 ad = new_stat (lang_address_statement, stat_ptr);
4251 ad->section_name = name;
4252 ad->address = address;
4255 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4256 because of a -e argument on the command line, or zero if this is
4257 called by ENTRY in a linker script. Command line arguments take
4261 lang_add_entry (name, cmdline)
4265 if (entry_symbol == NULL
4267 || ! entry_from_cmdline)
4269 entry_symbol = name;
4270 entry_from_cmdline = cmdline;
4275 lang_add_target (name)
4278 lang_target_statement_type *new = new_stat (lang_target_statement,
4294 map_option_f = true;
4305 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4312 lang_add_data (type, exp)
4314 union etree_union *exp;
4317 lang_data_statement_type *new = new_stat (lang_data_statement,
4325 /* Create a new reloc statement. RELOC is the BFD relocation type to
4326 generate. HOWTO is the corresponding howto structure (we could
4327 look this up, but the caller has already done so). SECTION is the
4328 section to generate a reloc against, or NAME is the name of the
4329 symbol to generate a reloc against. Exactly one of SECTION and
4330 NAME must be NULL. ADDEND is an expression for the addend. */
4333 lang_add_reloc (reloc, howto, section, name, addend)
4334 bfd_reloc_code_real_type reloc;
4335 reloc_howto_type *howto;
4338 union etree_union *addend;
4340 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4344 p->section = section;
4346 p->addend_exp = addend;
4348 p->addend_value = 0;
4349 p->output_section = NULL;
4353 lang_assignment_statement_type *
4354 lang_add_assignment (exp)
4357 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4365 lang_add_attribute (attribute)
4366 enum statement_enum attribute;
4368 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4375 if (startup_file != (char *) NULL)
4377 einfo (_("%P%Fmultiple STARTUP files\n"));
4379 first_file->filename = name;
4380 first_file->local_sym_name = name;
4381 first_file->real = true;
4383 startup_file = name;
4390 lang_float_flag = maybe;
4394 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4396 const char *memspec;
4397 struct lang_output_section_phdr_list *phdrs;
4398 const char *lma_memspec;
4400 current_section->fill = fill;
4401 current_section->region = lang_memory_region_lookup (memspec);
4402 if (strcmp (lma_memspec, "*default*") != 0)
4404 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4405 /* If no runtime region has been given, but the load region has
4406 been, use the load region. */
4407 if (strcmp (memspec, "*default*") == 0)
4408 current_section->region = lang_memory_region_lookup (lma_memspec);
4410 current_section->phdrs = phdrs;
4411 stat_ptr = &statement_list;
4414 /* Create an absolute symbol with the given name with the value of the
4415 address of first byte of the section named.
4417 If the symbol already exists, then do nothing. */
4420 lang_abs_symbol_at_beginning_of (secname, name)
4421 const char *secname;
4424 struct bfd_link_hash_entry *h;
4426 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4427 if (h == (struct bfd_link_hash_entry *) NULL)
4428 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4430 if (h->type == bfd_link_hash_new
4431 || h->type == bfd_link_hash_undefined)
4435 h->type = bfd_link_hash_defined;
4437 sec = bfd_get_section_by_name (output_bfd, secname);
4438 if (sec == (asection *) NULL)
4441 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4443 h->u.def.section = bfd_abs_section_ptr;
4447 /* Create an absolute symbol with the given name with the value of the
4448 address of the first byte after the end of the section named.
4450 If the symbol already exists, then do nothing. */
4453 lang_abs_symbol_at_end_of (secname, name)
4454 const char *secname;
4457 struct bfd_link_hash_entry *h;
4459 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4460 if (h == (struct bfd_link_hash_entry *) NULL)
4461 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4463 if (h->type == bfd_link_hash_new
4464 || h->type == bfd_link_hash_undefined)
4468 h->type = bfd_link_hash_defined;
4470 sec = bfd_get_section_by_name (output_bfd, secname);
4471 if (sec == (asection *) NULL)
4474 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4475 + bfd_section_size (output_bfd, sec) /
4476 bfd_octets_per_byte (output_bfd));
4478 h->u.def.section = bfd_abs_section_ptr;
4483 lang_statement_append (list, element, field)
4484 lang_statement_list_type *list;
4485 lang_statement_union_type *element;
4486 lang_statement_union_type **field;
4488 *(list->tail) = element;
4492 /* Set the output format type. -oformat overrides scripts. */
4495 lang_add_output_format (format, big, little, from_script)
4501 if (output_target == NULL || !from_script)
4503 if (command_line.endian == ENDIAN_BIG
4506 else if (command_line.endian == ENDIAN_LITTLE
4510 output_target = format;
4514 /* Enter a group. This creates a new lang_group_statement, and sets
4515 stat_ptr to build new statements within the group. */
4520 lang_group_statement_type *g;
4522 g = new_stat (lang_group_statement, stat_ptr);
4523 lang_list_init (&g->children);
4524 stat_ptr = &g->children;
4527 /* Leave a group. This just resets stat_ptr to start writing to the
4528 regular list of statements again. Note that this will not work if
4529 groups can occur inside anything else which can adjust stat_ptr,
4530 but currently they can't. */
4535 stat_ptr = &statement_list;
4538 /* Add a new program header. This is called for each entry in a PHDRS
4539 command in a linker script. */
4542 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4550 struct lang_phdr *n, **pp;
4552 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4555 n->type = exp_get_value_int (type, 0, "program header type",
4556 lang_final_phase_enum);
4557 n->filehdr = filehdr;
4562 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4567 /* Record the program header information in the output BFD. FIXME: We
4568 should not be calling an ELF specific function here. */
4571 lang_record_phdrs ()
4575 struct lang_output_section_phdr_list *last;
4576 struct lang_phdr *l;
4577 lang_statement_union_type *u;
4580 secs = (asection **) xmalloc (alc * sizeof (asection *));
4582 for (l = lang_phdr_list; l != NULL; l = l->next)
4589 for (u = lang_output_section_statement.head;
4591 u = u->output_section_statement.next)
4593 lang_output_section_statement_type *os;
4594 struct lang_output_section_phdr_list *pl;
4596 os = &u->output_section_statement;
4603 if (os->sectype == noload_section
4604 || os->bfd_section == NULL
4605 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4610 if (os->bfd_section == NULL)
4613 for (; pl != NULL; pl = pl->next)
4615 if (strcmp (pl->name, l->name) == 0)
4620 secs = ((asection **)
4621 xrealloc (secs, alc * sizeof (asection *)));
4623 secs[c] = os->bfd_section;
4630 if (l->flags == NULL)
4633 flags = exp_get_vma (l->flags, 0, "phdr flags",
4634 lang_final_phase_enum);
4639 at = exp_get_vma (l->at, 0, "phdr load address",
4640 lang_final_phase_enum);
4642 if (! bfd_record_phdr (output_bfd, l->type,
4643 l->flags != NULL, flags, l->at != NULL,
4644 at, l->filehdr, l->phdrs, c, secs))
4645 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4650 /* Make sure all the phdr assignments succeeded. */
4651 for (u = lang_output_section_statement.head;
4653 u = u->output_section_statement.next)
4655 struct lang_output_section_phdr_list *pl;
4657 if (u->output_section_statement.bfd_section == NULL)
4660 for (pl = u->output_section_statement.phdrs;
4663 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4664 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4665 u->output_section_statement.name, pl->name);
4669 /* Record a list of sections which may not be cross referenced. */
4672 lang_add_nocrossref (l)
4673 struct lang_nocrossref *l;
4675 struct lang_nocrossrefs *n;
4677 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4678 n->next = nocrossref_list;
4680 nocrossref_list = n;
4682 /* Set notice_all so that we get informed about all symbols. */
4683 link_info.notice_all = true;
4686 /* Overlay handling. We handle overlays with some static variables. */
4688 /* The overlay virtual address. */
4689 static etree_type *overlay_vma;
4691 /* The overlay load address. */
4692 static etree_type *overlay_lma;
4694 /* Whether nocrossrefs is set for this overlay. */
4695 static int overlay_nocrossrefs;
4697 /* An expression for the maximum section size seen so far. */
4698 static etree_type *overlay_max;
4700 /* A list of all the sections in this overlay. */
4702 struct overlay_list {
4703 struct overlay_list *next;
4704 lang_output_section_statement_type *os;
4707 static struct overlay_list *overlay_list;
4709 /* Start handling an overlay. */
4712 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4713 etree_type *vma_expr;
4714 etree_type *lma_expr;
4717 /* The grammar should prevent nested overlays from occurring. */
4718 ASSERT (overlay_vma == NULL
4719 && overlay_lma == NULL
4720 && overlay_list == NULL
4721 && overlay_max == NULL);
4723 overlay_vma = vma_expr;
4724 overlay_lma = lma_expr;
4725 overlay_nocrossrefs = nocrossrefs;
4728 /* Start a section in an overlay. We handle this by calling
4729 lang_enter_output_section_statement with the correct VMA and LMA. */
4732 lang_enter_overlay_section (name)
4735 struct overlay_list *n;
4738 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4739 0, 0, 0, overlay_lma);
4741 /* If this is the first section, then base the VMA and LMA of future
4742 sections on this one. This will work correctly even if `.' is
4743 used in the addresses. */
4744 if (overlay_list == NULL)
4746 overlay_vma = exp_nameop (ADDR, name);
4747 overlay_lma = exp_nameop (LOADADDR, name);
4750 /* Remember the section. */
4751 n = (struct overlay_list *) xmalloc (sizeof *n);
4752 n->os = current_section;
4753 n->next = overlay_list;
4756 size = exp_nameop (SIZEOF, name);
4758 /* Adjust the LMA for the next section. */
4759 overlay_lma = exp_binop ('+', overlay_lma, size);
4761 /* Arrange to work out the maximum section end address. */
4762 if (overlay_max == NULL)
4765 overlay_max = exp_binop (MAX_K, overlay_max, size);
4768 /* Finish a section in an overlay. There isn't any special to do
4772 lang_leave_overlay_section (fill, phdrs)
4774 struct lang_output_section_phdr_list *phdrs;
4781 name = current_section->name;
4783 lang_leave_output_section_statement (fill, "*default*",
4784 phdrs, "*default*");
4786 /* Define the magic symbols. */
4788 clean = xmalloc (strlen (name) + 1);
4790 for (s1 = name; *s1 != '\0'; s1++)
4791 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4795 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4796 sprintf (buf, "__load_start_%s", clean);
4797 lang_add_assignment (exp_assop ('=', buf,
4798 exp_nameop (LOADADDR, name)));
4800 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4801 sprintf (buf, "__load_stop_%s", clean);
4802 lang_add_assignment (exp_assop ('=', buf,
4804 exp_nameop (LOADADDR, name),
4805 exp_nameop (SIZEOF, name))));
4810 /* Finish an overlay. If there are any overlay wide settings, this
4811 looks through all the sections in the overlay and sets them. */
4814 lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
4816 const char *memspec;
4817 struct lang_output_section_phdr_list *phdrs;
4818 const char *lma_memspec;
4820 lang_memory_region_type *region;
4821 lang_memory_region_type * default_region;
4822 lang_memory_region_type *lma_region;
4823 struct overlay_list *l;
4824 struct lang_nocrossref *nocrossref;
4826 default_region = lang_memory_region_lookup ("*default*");
4828 if (memspec == NULL)
4831 region = lang_memory_region_lookup (memspec);
4833 if (lma_memspec == NULL)
4836 lma_region = lang_memory_region_lookup (lma_memspec);
4843 struct overlay_list *next;
4845 if (fill != 0 && l->os->fill == 0)
4848 /* Assign a region to the sections, if one has been specified.
4849 Override the assignment of the default section, but not
4851 if (region != NULL &&
4852 (l->os->region == NULL ||
4853 l->os->region == default_region))
4854 l->os->region = region;
4856 /* We only set lma_region for the first overlay section, as
4857 subsequent overlay sections will have load_base set relative
4858 to the first section. Also, don't set lma_region if
4859 load_base is specified. FIXME: There should really be a test
4860 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4861 rather than letting LDADDR simply override LMA_REGION. */
4862 if (lma_region != NULL && l->os->lma_region == NULL
4863 && l->next == NULL && l->os->load_base == NULL)
4864 l->os->lma_region = lma_region;
4866 if (phdrs != NULL && l->os->phdrs == NULL)
4867 l->os->phdrs = phdrs;
4869 if (overlay_nocrossrefs)
4871 struct lang_nocrossref *nc;
4873 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4874 nc->name = l->os->name;
4875 nc->next = nocrossref;
4884 if (nocrossref != NULL)
4885 lang_add_nocrossref (nocrossref);
4887 /* Update . for the end of the overlay. */
4888 lang_add_assignment (exp_assop ('=', ".",
4889 exp_binop ('+', overlay_vma, overlay_max)));
4893 overlay_nocrossrefs = 0;
4894 overlay_list = NULL;
4898 /* Version handling. This is only useful for ELF. */
4900 /* This global variable holds the version tree that we build. */
4902 struct bfd_elf_version_tree *lang_elf_version_info;
4905 lang_vers_match_lang_c (expr, sym)
4906 struct bfd_elf_version_expr *expr;
4909 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4911 return fnmatch (expr->pattern, sym, 0) == 0;
4915 lang_vers_match_lang_cplusplus (expr, sym)
4916 struct bfd_elf_version_expr *expr;
4922 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4925 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4928 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4929 Should we early out false in this case? */
4930 result = fnmatch (expr->pattern, sym, 0) == 0;
4934 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4942 lang_vers_match_lang_java (expr, sym)
4943 struct bfd_elf_version_expr *expr;
4949 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4952 alt_sym = cplus_demangle (sym, DMGL_JAVA);
4955 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4956 Should we early out false in this case? */
4957 result = fnmatch (expr->pattern, sym, 0) == 0;
4961 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4968 /* This is called for each variable name or match expression. */
4970 struct bfd_elf_version_expr *
4971 lang_new_vers_regex (orig, new, lang)
4972 struct bfd_elf_version_expr *orig;
4976 struct bfd_elf_version_expr *ret;
4978 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4982 if (lang == NULL || strcasecmp (lang, "C") == 0)
4983 ret->match = lang_vers_match_lang_c;
4984 else if (strcasecmp (lang, "C++") == 0)
4985 ret->match = lang_vers_match_lang_cplusplus;
4986 else if (strcasecmp (lang, "Java") == 0)
4987 ret->match = lang_vers_match_lang_java;
4990 einfo (_("%X%P: unknown language `%s' in version information\n"),
4992 ret->match = lang_vers_match_lang_c;
4998 /* This is called for each set of variable names and match
5001 struct bfd_elf_version_tree *
5002 lang_new_vers_node (globals, locals)
5003 struct bfd_elf_version_expr *globals;
5004 struct bfd_elf_version_expr *locals;
5006 struct bfd_elf_version_tree *ret;
5008 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5012 ret->globals = globals;
5013 ret->locals = locals;
5015 ret->name_indx = (unsigned int) -1;
5020 /* This static variable keeps track of version indices. */
5022 static int version_index;
5024 /* This is called when we know the name and dependencies of the
5028 lang_register_vers_node (name, version, deps)
5030 struct bfd_elf_version_tree *version;
5031 struct bfd_elf_version_deps *deps;
5033 struct bfd_elf_version_tree *t, **pp;
5034 struct bfd_elf_version_expr *e1;
5036 /* Make sure this node has a unique name. */
5037 for (t = lang_elf_version_info; t != NULL; t = t->next)
5038 if (strcmp (t->name, name) == 0)
5039 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5041 /* Check the global and local match names, and make sure there
5042 aren't any duplicates. */
5044 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5046 for (t = lang_elf_version_info; t != NULL; t = t->next)
5048 struct bfd_elf_version_expr *e2;
5050 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5051 if (strcmp (e1->pattern, e2->pattern) == 0)
5052 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5057 for (e1 = version->locals; 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->globals; 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 version->deps = deps;
5071 version->name = name;
5073 version->vernum = version_index;
5075 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5080 /* This is called when we see a version dependency. */
5082 struct bfd_elf_version_deps *
5083 lang_add_vers_depend (list, name)
5084 struct bfd_elf_version_deps *list;
5087 struct bfd_elf_version_deps *ret;
5088 struct bfd_elf_version_tree *t;
5090 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5093 for (t = lang_elf_version_info; t != NULL; t = t->next)
5095 if (strcmp (t->name, name) == 0)
5097 ret->version_needed = t;
5102 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5108 lang_do_version_exports_section ()
5110 struct bfd_elf_version_expr *greg = NULL, *lreg;
5112 LANG_FOR_EACH_INPUT_STATEMENT (is)
5114 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5121 len = bfd_section_size (is->the_bfd, sec);
5122 contents = xmalloc (len);
5123 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5124 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5127 while (p < contents + len)
5129 greg = lang_new_vers_regex (greg, p, NULL);
5130 p = strchr (p, '\0') + 1;
5133 /* Do not free the contents, as we used them creating the regex. */
5135 /* Do not include this section in the link. */
5136 bfd_set_section_flags (is->the_bfd, sec,
5137 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5140 lreg = lang_new_vers_regex (NULL, "*", NULL);
5141 lang_register_vers_node (command_line.version_exports_section,
5142 lang_new_vers_node (greg, lreg), NULL);
5146 lang_add_unique (name)
5149 struct unique_sections *ent;
5151 for (ent = unique_section_list; ent; ent = ent->next)
5152 if (strcmp (ent->name, name) == 0)
5155 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5156 ent->name = xstrdup (name);
5157 ent->next = unique_section_list;
5158 unique_section_list = ent;