1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack;
50 static struct obstack map_obstack;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file;
55 static bfd_boolean placed_commons = FALSE;
56 static bfd_boolean stripped_excluded_sections = FALSE;
57 static lang_output_section_statement_type *default_common_section;
58 static bfd_boolean map_option_f;
59 static bfd_vma print_dot;
60 static lang_input_statement_type *first_file;
61 static const char *current_target;
62 static const char *output_target;
63 static lang_statement_list_type statement_list;
64 static struct bfd_hash_table lang_definedness_table;
65 static lang_statement_list_type *stat_save[10];
66 static lang_statement_list_type **stat_save_ptr = &stat_save[0];
68 /* Forward declarations. */
69 static void exp_init_os (etree_type *);
70 static void init_map_userdata (bfd *, asection *, void *);
71 static lang_input_statement_type *lookup_name (const char *);
72 static struct bfd_hash_entry *lang_definedness_newfunc
73 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
74 static void insert_undefined (const char *);
75 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
76 static void print_statement (lang_statement_union_type *,
77 lang_output_section_statement_type *);
78 static void print_statement_list (lang_statement_union_type *,
79 lang_output_section_statement_type *);
80 static void print_statements (void);
81 static void print_input_section (asection *);
82 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
83 static void lang_record_phdrs (void);
84 static void lang_do_version_exports_section (void);
85 static void lang_finalize_version_expr_head
86 (struct bfd_elf_version_expr_head *);
88 /* Exported variables. */
89 lang_output_section_statement_type *abs_output_section;
90 lang_statement_list_type lang_output_section_statement;
91 lang_statement_list_type *stat_ptr = &statement_list;
92 lang_statement_list_type file_chain = { NULL, NULL };
93 lang_statement_list_type input_file_chain;
94 struct bfd_sym_chain entry_symbol = { NULL, NULL };
95 static const char *entry_symbol_default = "start";
96 const char *entry_section = ".text";
97 bfd_boolean entry_from_cmdline;
98 bfd_boolean lang_has_input_file = FALSE;
99 bfd_boolean had_output_filename = FALSE;
100 bfd_boolean lang_float_flag = FALSE;
101 bfd_boolean delete_output_file_on_failure = FALSE;
102 struct lang_phdr *lang_phdr_list;
103 struct lang_nocrossrefs *nocrossref_list;
104 static struct unique_sections *unique_section_list;
105 static bfd_boolean ldlang_sysrooted_script = FALSE;
107 /* Functions that traverse the linker script and might evaluate
108 DEFINED() need to increment this. */
109 int lang_statement_iteration = 0;
111 etree_type *base; /* Relocation base - or null */
113 /* Return TRUE if the PATTERN argument is a wildcard pattern.
114 Although backslashes are treated specially if a pattern contains
115 wildcards, we do not consider the mere presence of a backslash to
116 be enough to cause the pattern to be treated as a wildcard.
117 That lets us handle DOS filenames more naturally. */
118 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
120 #define new_stat(x, y) \
121 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
123 #define outside_section_address(q) \
124 ((q)->output_offset + (q)->output_section->vma)
126 #define outside_symbol_address(q) \
127 ((q)->value + outside_section_address (q->section))
129 #define SECTION_NAME_MAP_LENGTH (16)
132 stat_alloc (size_t size)
134 return obstack_alloc (&stat_obstack, size);
138 name_match (const char *pattern, const char *name)
140 if (wildcardp (pattern))
141 return fnmatch (pattern, name, 0);
142 return strcmp (pattern, name);
145 /* If PATTERN is of the form archive:file, return a pointer to the
146 separator. If not, return NULL. */
149 archive_path (const char *pattern)
153 if (link_info.path_separator == 0)
156 p = strchr (pattern, link_info.path_separator);
157 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
158 if (p == NULL || link_info.path_separator != ':')
161 /* Assume a match on the second char is part of drive specifier,
162 as in "c:\silly.dos". */
163 if (p == pattern + 1 && ISALPHA (*pattern))
164 p = strchr (p + 1, link_info.path_separator);
169 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
170 return whether F matches FILE_SPEC. */
173 input_statement_is_archive_path (const char *file_spec, char *sep,
174 lang_input_statement_type *f)
176 bfd_boolean match = FALSE;
179 || name_match (sep + 1, f->filename) == 0)
180 && ((sep != file_spec)
181 == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
185 if (sep != file_spec)
187 const char *aname = f->the_bfd->my_archive->filename;
189 match = name_match (file_spec, aname) == 0;
190 *sep = link_info.path_separator;
197 unique_section_p (const asection *sec)
199 struct unique_sections *unam;
202 if (link_info.relocatable
203 && sec->owner != NULL
204 && bfd_is_group_section (sec->owner, sec))
208 for (unam = unique_section_list; unam; unam = unam->next)
209 if (name_match (unam->name, secnam) == 0)
215 /* Generic traversal routines for finding matching sections. */
217 /* Try processing a section against a wildcard. This just calls
218 the callback unless the filename exclusion list is present
219 and excludes the file. It's hardly ever present so this
220 function is very fast. */
223 walk_wild_consider_section (lang_wild_statement_type *ptr,
224 lang_input_statement_type *file,
226 struct wildcard_list *sec,
230 struct name_list *list_tmp;
232 /* Don't process sections from files which were excluded. */
233 for (list_tmp = sec->spec.exclude_name_list;
235 list_tmp = list_tmp->next)
237 char *p = archive_path (list_tmp->name);
241 if (input_statement_is_archive_path (list_tmp->name, p, file))
245 else if (name_match (list_tmp->name, file->filename) == 0)
248 /* FIXME: Perhaps remove the following at some stage? Matching
249 unadorned archives like this was never documented and has
250 been superceded by the archive:path syntax. */
251 else if (file->the_bfd != NULL
252 && file->the_bfd->my_archive != NULL
253 && name_match (list_tmp->name,
254 file->the_bfd->my_archive->filename) == 0)
258 (*callback) (ptr, sec, s, file, data);
261 /* Lowest common denominator routine that can handle everything correctly,
265 walk_wild_section_general (lang_wild_statement_type *ptr,
266 lang_input_statement_type *file,
271 struct wildcard_list *sec;
273 for (s = file->the_bfd->sections; s != NULL; s = s->next)
275 sec = ptr->section_list;
277 (*callback) (ptr, sec, s, file, data);
281 bfd_boolean skip = FALSE;
283 if (sec->spec.name != NULL)
285 const char *sname = bfd_get_section_name (file->the_bfd, s);
287 skip = name_match (sec->spec.name, sname) != 0;
291 walk_wild_consider_section (ptr, file, s, sec, callback, data);
298 /* Routines to find a single section given its name. If there's more
299 than one section with that name, we report that. */
303 asection *found_section;
304 bfd_boolean multiple_sections_found;
305 } section_iterator_callback_data;
308 section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
310 section_iterator_callback_data *d = data;
312 if (d->found_section != NULL)
314 d->multiple_sections_found = TRUE;
318 d->found_section = s;
323 find_section (lang_input_statement_type *file,
324 struct wildcard_list *sec,
325 bfd_boolean *multiple_sections_found)
327 section_iterator_callback_data cb_data = { NULL, FALSE };
329 bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
330 section_iterator_callback, &cb_data);
331 *multiple_sections_found = cb_data.multiple_sections_found;
332 return cb_data.found_section;
335 /* Code for handling simple wildcards without going through fnmatch,
336 which can be expensive because of charset translations etc. */
338 /* A simple wild is a literal string followed by a single '*',
339 where the literal part is at least 4 characters long. */
342 is_simple_wild (const char *name)
344 size_t len = strcspn (name, "*?[");
345 return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
349 match_simple_wild (const char *pattern, const char *name)
351 /* The first four characters of the pattern are guaranteed valid
352 non-wildcard characters. So we can go faster. */
353 if (pattern[0] != name[0] || pattern[1] != name[1]
354 || pattern[2] != name[2] || pattern[3] != name[3])
359 while (*pattern != '*')
360 if (*name++ != *pattern++)
366 /* Compare sections ASEC and BSEC according to SORT. */
369 compare_section (sort_type sort, asection *asec, asection *bsec)
378 case by_alignment_name:
379 ret = (bfd_section_alignment (bsec->owner, bsec)
380 - bfd_section_alignment (asec->owner, asec));
386 ret = strcmp (bfd_get_section_name (asec->owner, asec),
387 bfd_get_section_name (bsec->owner, bsec));
390 case by_name_alignment:
391 ret = strcmp (bfd_get_section_name (asec->owner, asec),
392 bfd_get_section_name (bsec->owner, bsec));
398 ret = (bfd_section_alignment (bsec->owner, bsec)
399 - bfd_section_alignment (asec->owner, asec));
406 /* Build a Binary Search Tree to sort sections, unlike insertion sort
407 used in wild_sort(). BST is considerably faster if the number of
408 of sections are large. */
410 static lang_section_bst_type **
411 wild_sort_fast (lang_wild_statement_type *wild,
412 struct wildcard_list *sec,
413 lang_input_statement_type *file ATTRIBUTE_UNUSED,
416 lang_section_bst_type **tree;
419 if (!wild->filenames_sorted
420 && (sec == NULL || sec->spec.sorted == none))
422 /* Append at the right end of tree. */
424 tree = &((*tree)->right);
430 /* Find the correct node to append this section. */
431 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
432 tree = &((*tree)->left);
434 tree = &((*tree)->right);
440 /* Use wild_sort_fast to build a BST to sort sections. */
443 output_section_callback_fast (lang_wild_statement_type *ptr,
444 struct wildcard_list *sec,
446 lang_input_statement_type *file,
447 void *output ATTRIBUTE_UNUSED)
449 lang_section_bst_type *node;
450 lang_section_bst_type **tree;
452 if (unique_section_p (section))
455 node = xmalloc (sizeof (lang_section_bst_type));
458 node->section = section;
460 tree = wild_sort_fast (ptr, sec, file, section);
465 /* Convert a sorted sections' BST back to list form. */
468 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
469 lang_section_bst_type *tree,
473 output_section_callback_tree_to_list (ptr, tree->left, output);
475 lang_add_section (&ptr->children, tree->section,
476 (lang_output_section_statement_type *) output);
479 output_section_callback_tree_to_list (ptr, tree->right, output);
484 /* Specialized, optimized routines for handling different kinds of
488 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
489 lang_input_statement_type *file,
493 /* We can just do a hash lookup for the section with the right name.
494 But if that lookup discovers more than one section with the name
495 (should be rare), we fall back to the general algorithm because
496 we would otherwise have to sort the sections to make sure they
497 get processed in the bfd's order. */
498 bfd_boolean multiple_sections_found;
499 struct wildcard_list *sec0 = ptr->handler_data[0];
500 asection *s0 = find_section (file, sec0, &multiple_sections_found);
502 if (multiple_sections_found)
503 walk_wild_section_general (ptr, file, callback, data);
505 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
509 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
510 lang_input_statement_type *file,
515 struct wildcard_list *wildsec0 = ptr->handler_data[0];
517 for (s = file->the_bfd->sections; s != NULL; s = s->next)
519 const char *sname = bfd_get_section_name (file->the_bfd, s);
520 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
523 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
528 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
529 lang_input_statement_type *file,
534 struct wildcard_list *sec0 = ptr->handler_data[0];
535 struct wildcard_list *wildsec1 = ptr->handler_data[1];
536 bfd_boolean multiple_sections_found;
537 asection *s0 = find_section (file, sec0, &multiple_sections_found);
539 if (multiple_sections_found)
541 walk_wild_section_general (ptr, file, callback, data);
545 /* Note that if the section was not found, s0 is NULL and
546 we'll simply never succeed the s == s0 test below. */
547 for (s = file->the_bfd->sections; s != NULL; s = s->next)
549 /* Recall that in this code path, a section cannot satisfy more
550 than one spec, so if s == s0 then it cannot match
553 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
556 const char *sname = bfd_get_section_name (file->the_bfd, s);
557 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
560 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
567 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
568 lang_input_statement_type *file,
573 struct wildcard_list *sec0 = ptr->handler_data[0];
574 struct wildcard_list *wildsec1 = ptr->handler_data[1];
575 struct wildcard_list *wildsec2 = ptr->handler_data[2];
576 bfd_boolean multiple_sections_found;
577 asection *s0 = find_section (file, sec0, &multiple_sections_found);
579 if (multiple_sections_found)
581 walk_wild_section_general (ptr, file, callback, data);
585 for (s = file->the_bfd->sections; s != NULL; s = s->next)
588 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
591 const char *sname = bfd_get_section_name (file->the_bfd, s);
592 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
595 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
598 skip = !match_simple_wild (wildsec2->spec.name, sname);
600 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
608 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
609 lang_input_statement_type *file,
614 struct wildcard_list *sec0 = ptr->handler_data[0];
615 struct wildcard_list *sec1 = ptr->handler_data[1];
616 struct wildcard_list *wildsec2 = ptr->handler_data[2];
617 struct wildcard_list *wildsec3 = ptr->handler_data[3];
618 bfd_boolean multiple_sections_found;
619 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
621 if (multiple_sections_found)
623 walk_wild_section_general (ptr, file, callback, data);
627 s1 = find_section (file, sec1, &multiple_sections_found);
628 if (multiple_sections_found)
630 walk_wild_section_general (ptr, file, callback, data);
634 for (s = file->the_bfd->sections; s != NULL; s = s->next)
637 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
640 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
643 const char *sname = bfd_get_section_name (file->the_bfd, s);
644 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
648 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
652 skip = !match_simple_wild (wildsec3->spec.name, sname);
654 walk_wild_consider_section (ptr, file, s, wildsec3,
662 walk_wild_section (lang_wild_statement_type *ptr,
663 lang_input_statement_type *file,
667 if (file->just_syms_flag)
670 (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
673 /* Returns TRUE when name1 is a wildcard spec that might match
674 something name2 can match. We're conservative: we return FALSE
675 only if the prefixes of name1 and name2 are different up to the
676 first wildcard character. */
679 wild_spec_can_overlap (const char *name1, const char *name2)
681 size_t prefix1_len = strcspn (name1, "?*[");
682 size_t prefix2_len = strcspn (name2, "?*[");
683 size_t min_prefix_len;
685 /* Note that if there is no wildcard character, then we treat the
686 terminating 0 as part of the prefix. Thus ".text" won't match
687 ".text." or ".text.*", for example. */
688 if (name1[prefix1_len] == '\0')
690 if (name2[prefix2_len] == '\0')
693 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
695 return memcmp (name1, name2, min_prefix_len) == 0;
698 /* Select specialized code to handle various kinds of wildcard
702 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
705 int wild_name_count = 0;
706 struct wildcard_list *sec;
710 ptr->walk_wild_section_handler = walk_wild_section_general;
711 ptr->handler_data[0] = NULL;
712 ptr->handler_data[1] = NULL;
713 ptr->handler_data[2] = NULL;
714 ptr->handler_data[3] = NULL;
717 /* Count how many wildcard_specs there are, and how many of those
718 actually use wildcards in the name. Also, bail out if any of the
719 wildcard names are NULL. (Can this actually happen?
720 walk_wild_section used to test for it.) And bail out if any
721 of the wildcards are more complex than a simple string
722 ending in a single '*'. */
723 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
726 if (sec->spec.name == NULL)
728 if (wildcardp (sec->spec.name))
731 if (!is_simple_wild (sec->spec.name))
736 /* The zero-spec case would be easy to optimize but it doesn't
737 happen in practice. Likewise, more than 4 specs doesn't
738 happen in practice. */
739 if (sec_count == 0 || sec_count > 4)
742 /* Check that no two specs can match the same section. */
743 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
745 struct wildcard_list *sec2;
746 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
748 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
753 signature = (sec_count << 8) + wild_name_count;
757 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
760 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
763 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
766 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
769 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
775 /* Now fill the data array with pointers to the specs, first the
776 specs with non-wildcard names, then the specs with wildcard
777 names. It's OK to process the specs in different order from the
778 given order, because we've already determined that no section
779 will match more than one spec. */
781 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
782 if (!wildcardp (sec->spec.name))
783 ptr->handler_data[data_counter++] = sec;
784 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
785 if (wildcardp (sec->spec.name))
786 ptr->handler_data[data_counter++] = sec;
789 /* Handle a wild statement for a single file F. */
792 walk_wild_file (lang_wild_statement_type *s,
793 lang_input_statement_type *f,
797 if (f->the_bfd == NULL
798 || ! bfd_check_format (f->the_bfd, bfd_archive))
799 walk_wild_section (s, f, callback, data);
804 /* This is an archive file. We must map each member of the
805 archive separately. */
806 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
807 while (member != NULL)
809 /* When lookup_name is called, it will call the add_symbols
810 entry point for the archive. For each element of the
811 archive which is included, BFD will call ldlang_add_file,
812 which will set the usrdata field of the member to the
813 lang_input_statement. */
814 if (member->usrdata != NULL)
816 walk_wild_section (s, member->usrdata, callback, data);
819 member = bfd_openr_next_archived_file (f->the_bfd, member);
825 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
827 const char *file_spec = s->filename;
830 if (file_spec == NULL)
832 /* Perform the iteration over all files in the list. */
833 LANG_FOR_EACH_INPUT_STATEMENT (f)
835 walk_wild_file (s, f, callback, data);
838 else if ((p = archive_path (file_spec)) != NULL)
840 LANG_FOR_EACH_INPUT_STATEMENT (f)
842 if (input_statement_is_archive_path (file_spec, p, f))
843 walk_wild_file (s, f, callback, data);
846 else if (wildcardp (file_spec))
848 LANG_FOR_EACH_INPUT_STATEMENT (f)
850 if (fnmatch (file_spec, f->filename, 0) == 0)
851 walk_wild_file (s, f, callback, data);
856 lang_input_statement_type *f;
858 /* Perform the iteration over a single file. */
859 f = lookup_name (file_spec);
861 walk_wild_file (s, f, callback, data);
865 /* lang_for_each_statement walks the parse tree and calls the provided
866 function for each node. */
869 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
870 lang_statement_union_type *s)
872 for (; s != NULL; s = s->header.next)
876 switch (s->header.type)
878 case lang_constructors_statement_enum:
879 lang_for_each_statement_worker (func, constructor_list.head);
881 case lang_output_section_statement_enum:
882 lang_for_each_statement_worker
883 (func, s->output_section_statement.children.head);
885 case lang_wild_statement_enum:
886 lang_for_each_statement_worker (func,
887 s->wild_statement.children.head);
889 case lang_group_statement_enum:
890 lang_for_each_statement_worker (func,
891 s->group_statement.children.head);
893 case lang_data_statement_enum:
894 case lang_reloc_statement_enum:
895 case lang_object_symbols_statement_enum:
896 case lang_output_statement_enum:
897 case lang_target_statement_enum:
898 case lang_input_section_enum:
899 case lang_input_statement_enum:
900 case lang_assignment_statement_enum:
901 case lang_padding_statement_enum:
902 case lang_address_statement_enum:
903 case lang_fill_statement_enum:
904 case lang_insert_statement_enum:
914 lang_for_each_statement (void (*func) (lang_statement_union_type *))
916 lang_for_each_statement_worker (func, statement_list.head);
919 /*----------------------------------------------------------------------*/
922 lang_list_init (lang_statement_list_type *list)
925 list->tail = &list->head;
929 push_stat_ptr (lang_statement_list_type *new_ptr)
931 if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
933 *stat_save_ptr++ = stat_ptr;
940 if (stat_save_ptr <= stat_save)
942 stat_ptr = *--stat_save_ptr;
945 /* Build a new statement node for the parse tree. */
947 static lang_statement_union_type *
948 new_statement (enum statement_enum type,
950 lang_statement_list_type *list)
952 lang_statement_union_type *new;
954 new = stat_alloc (size);
955 new->header.type = type;
956 new->header.next = NULL;
957 lang_statement_append (list, new, &new->header.next);
961 /* Build a new input file node for the language. There are several
962 ways in which we treat an input file, eg, we only look at symbols,
963 or prefix it with a -l etc.
965 We can be supplied with requests for input files more than once;
966 they may, for example be split over several lines like foo.o(.text)
967 foo.o(.data) etc, so when asked for a file we check that we haven't
968 got it already so we don't duplicate the bfd. */
970 static lang_input_statement_type *
971 new_afile (const char *name,
972 lang_input_file_enum_type file_type,
974 bfd_boolean add_to_list)
976 lang_input_statement_type *p;
979 p = new_stat (lang_input_statement, stat_ptr);
982 p = stat_alloc (sizeof (lang_input_statement_type));
983 p->header.type = lang_input_statement_enum;
984 p->header.next = NULL;
987 lang_has_input_file = TRUE;
989 p->sysrooted = FALSE;
991 if (file_type == lang_input_file_is_l_enum
992 && name[0] == ':' && name[1] != '\0')
994 file_type = lang_input_file_is_search_file_enum;
1000 case lang_input_file_is_symbols_only_enum:
1002 p->is_archive = FALSE;
1004 p->local_sym_name = name;
1005 p->just_syms_flag = TRUE;
1006 p->search_dirs_flag = FALSE;
1008 case lang_input_file_is_fake_enum:
1010 p->is_archive = FALSE;
1012 p->local_sym_name = name;
1013 p->just_syms_flag = FALSE;
1014 p->search_dirs_flag = FALSE;
1016 case lang_input_file_is_l_enum:
1017 p->is_archive = TRUE;
1020 p->local_sym_name = concat ("-l", name, (const char *) NULL);
1021 p->just_syms_flag = FALSE;
1022 p->search_dirs_flag = TRUE;
1024 case lang_input_file_is_marker_enum:
1026 p->is_archive = FALSE;
1028 p->local_sym_name = name;
1029 p->just_syms_flag = FALSE;
1030 p->search_dirs_flag = TRUE;
1032 case lang_input_file_is_search_file_enum:
1033 p->sysrooted = ldlang_sysrooted_script;
1035 p->is_archive = FALSE;
1037 p->local_sym_name = name;
1038 p->just_syms_flag = FALSE;
1039 p->search_dirs_flag = TRUE;
1041 case lang_input_file_is_file_enum:
1043 p->is_archive = FALSE;
1045 p->local_sym_name = name;
1046 p->just_syms_flag = FALSE;
1047 p->search_dirs_flag = FALSE;
1053 p->next_real_file = NULL;
1055 p->dynamic = config.dynamic_link;
1056 p->add_needed = add_needed;
1057 p->as_needed = as_needed;
1058 p->whole_archive = whole_archive;
1060 lang_statement_append (&input_file_chain,
1061 (lang_statement_union_type *) p,
1062 &p->next_real_file);
1066 lang_input_statement_type *
1067 lang_add_input_file (const char *name,
1068 lang_input_file_enum_type file_type,
1071 return new_afile (name, file_type, target, TRUE);
1074 struct out_section_hash_entry
1076 struct bfd_hash_entry root;
1077 lang_statement_union_type s;
1080 /* The hash table. */
1082 static struct bfd_hash_table output_section_statement_table;
1084 /* Support routines for the hash table used by lang_output_section_find,
1085 initialize the table, fill in an entry and remove the table. */
1087 static struct bfd_hash_entry *
1088 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1089 struct bfd_hash_table *table,
1092 lang_output_section_statement_type **nextp;
1093 struct out_section_hash_entry *ret;
1097 entry = bfd_hash_allocate (table, sizeof (*ret));
1102 entry = bfd_hash_newfunc (entry, table, string);
1106 ret = (struct out_section_hash_entry *) entry;
1107 memset (&ret->s, 0, sizeof (ret->s));
1108 ret->s.header.type = lang_output_section_statement_enum;
1109 ret->s.output_section_statement.subsection_alignment = -1;
1110 ret->s.output_section_statement.section_alignment = -1;
1111 ret->s.output_section_statement.block_value = 1;
1112 lang_list_init (&ret->s.output_section_statement.children);
1113 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1115 /* For every output section statement added to the list, except the
1116 first one, lang_output_section_statement.tail points to the "next"
1117 field of the last element of the list. */
1118 if (lang_output_section_statement.head != NULL)
1119 ret->s.output_section_statement.prev
1120 = ((lang_output_section_statement_type *)
1121 ((char *) lang_output_section_statement.tail
1122 - offsetof (lang_output_section_statement_type, next)));
1124 /* GCC's strict aliasing rules prevent us from just casting the
1125 address, so we store the pointer in a variable and cast that
1127 nextp = &ret->s.output_section_statement.next;
1128 lang_statement_append (&lang_output_section_statement,
1130 (lang_statement_union_type **) nextp);
1135 output_section_statement_table_init (void)
1137 if (!bfd_hash_table_init_n (&output_section_statement_table,
1138 output_section_statement_newfunc,
1139 sizeof (struct out_section_hash_entry),
1141 einfo (_("%P%F: can not create hash table: %E\n"));
1145 output_section_statement_table_free (void)
1147 bfd_hash_table_free (&output_section_statement_table);
1150 /* Build enough state so that the parser can build its tree. */
1155 obstack_begin (&stat_obstack, 1000);
1157 stat_ptr = &statement_list;
1159 output_section_statement_table_init ();
1161 lang_list_init (stat_ptr);
1163 lang_list_init (&input_file_chain);
1164 lang_list_init (&lang_output_section_statement);
1165 lang_list_init (&file_chain);
1166 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1168 abs_output_section =
1169 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1171 abs_output_section->bfd_section = bfd_abs_section_ptr;
1173 /* The value "3" is ad-hoc, somewhat related to the expected number of
1174 DEFINED expressions in a linker script. For most default linker
1175 scripts, there are none. Why a hash table then? Well, it's somewhat
1176 simpler to re-use working machinery than using a linked list in terms
1177 of code-complexity here in ld, besides the initialization which just
1178 looks like other code here. */
1179 if (!bfd_hash_table_init_n (&lang_definedness_table,
1180 lang_definedness_newfunc,
1181 sizeof (struct lang_definedness_hash_entry),
1183 einfo (_("%P%F: can not create hash table: %E\n"));
1189 output_section_statement_table_free ();
1192 /*----------------------------------------------------------------------
1193 A region is an area of memory declared with the
1194 MEMORY { name:org=exp, len=exp ... }
1197 We maintain a list of all the regions here.
1199 If no regions are specified in the script, then the default is used
1200 which is created when looked up to be the entire data space.
1202 If create is true we are creating a region inside a MEMORY block.
1203 In this case it is probably an error to create a region that has
1204 already been created. If we are not inside a MEMORY block it is
1205 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1206 and so we issue a warning.
1208 Each region has at least one name. The first name is either
1209 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1210 alias names to an existing region within a script with
1211 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1214 static lang_memory_region_type *lang_memory_region_list;
1215 static lang_memory_region_type **lang_memory_region_list_tail
1216 = &lang_memory_region_list;
1218 lang_memory_region_type *
1219 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1221 lang_memory_region_name *n;
1222 lang_memory_region_type *r;
1223 lang_memory_region_type *new;
1225 /* NAME is NULL for LMA memspecs if no region was specified. */
1229 for (r = lang_memory_region_list; r != NULL; r = r->next)
1230 for (n = &r->name_list; n != NULL; n = n->next)
1231 if (strcmp (n->name, name) == 0)
1234 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1239 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1240 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);
1242 new = stat_alloc (sizeof (lang_memory_region_type));
1244 new->name_list.name = xstrdup (name);
1245 new->name_list.next = NULL;
1248 new->length = ~(bfd_size_type) 0;
1250 new->last_os = NULL;
1253 new->had_full_message = FALSE;
1255 *lang_memory_region_list_tail = new;
1256 lang_memory_region_list_tail = &new->next;
1262 lang_memory_region_alias (const char * alias, const char * region_name)
1264 lang_memory_region_name * n;
1265 lang_memory_region_type * r;
1266 lang_memory_region_type * region;
1268 /* The default region must be unique. This ensures that it is not necessary
1269 to iterate through the name list if someone wants the check if a region is
1270 the default memory region. */
1271 if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1272 || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1273 einfo (_("%F%P:%S: error: alias for default memory region\n"));
1275 /* Look for the target region and check if the alias is not already
1278 for (r = lang_memory_region_list; r != NULL; r = r->next)
1279 for (n = &r->name_list; n != NULL; n = n->next)
1281 if (region == NULL && strcmp (n->name, region_name) == 0)
1283 if (strcmp (n->name, alias) == 0)
1284 einfo (_("%F%P:%S: error: redefinition of memory region "
1289 /* Check if the target region exists. */
1291 einfo (_("%F%P:%S: error: memory region `%s' "
1292 "for alias `%s' does not exist\n"),
1296 /* Add alias to region name list. */
1297 n = stat_alloc (sizeof (lang_memory_region_name));
1298 n->name = xstrdup (alias);
1299 n->next = region->name_list.next;
1300 region->name_list.next = n;
1303 static lang_memory_region_type *
1304 lang_memory_default (asection * section)
1306 lang_memory_region_type *p;
1308 flagword sec_flags = section->flags;
1310 /* Override SEC_DATA to mean a writable section. */
1311 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1312 sec_flags |= SEC_DATA;
1314 for (p = lang_memory_region_list; p != NULL; p = p->next)
1316 if ((p->flags & sec_flags) != 0
1317 && (p->not_flags & sec_flags) == 0)
1322 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1325 lang_output_section_statement_type *
1326 lang_output_section_statement_lookup (const char *const name,
1330 struct out_section_hash_entry *entry;
1332 entry = ((struct out_section_hash_entry *)
1333 bfd_hash_lookup (&output_section_statement_table, name,
1338 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1342 if (entry->s.output_section_statement.name != NULL)
1344 /* We have a section of this name, but it might not have the correct
1346 struct out_section_hash_entry *last_ent;
1347 unsigned long hash = entry->root.hash;
1349 if (create && constraint == SPECIAL)
1350 /* Not traversing to the end reverses the order of the second
1351 and subsequent SPECIAL sections in the hash table chain,
1352 but that shouldn't matter. */
1357 if (entry->s.output_section_statement.constraint >= 0
1360 == entry->s.output_section_statement.constraint)))
1361 return &entry->s.output_section_statement;
1363 entry = (struct out_section_hash_entry *) entry->root.next;
1365 while (entry != NULL
1366 && entry->root.hash == hash
1367 && strcmp (name, entry->s.output_section_statement.name) == 0);
1373 = ((struct out_section_hash_entry *)
1374 output_section_statement_newfunc (NULL,
1375 &output_section_statement_table,
1379 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1382 entry->root = last_ent->root;
1383 last_ent->root.next = &entry->root;
1386 entry->s.output_section_statement.name = name;
1387 entry->s.output_section_statement.constraint = constraint;
1388 return &entry->s.output_section_statement;
1391 /* A variant of lang_output_section_find used by place_orphan.
1392 Returns the output statement that should precede a new output
1393 statement for SEC. If an exact match is found on certain flags,
1396 lang_output_section_statement_type *
1397 lang_output_section_find_by_flags (const asection *sec,
1398 lang_output_section_statement_type **exact,
1399 lang_match_sec_type_func match_type)
1401 lang_output_section_statement_type *first, *look, *found;
1404 /* We know the first statement on this list is *ABS*. May as well
1406 first = &lang_output_section_statement.head->output_section_statement;
1407 first = first->next;
1409 /* First try for an exact match. */
1411 for (look = first; look; look = look->next)
1413 flags = look->flags;
1414 if (look->bfd_section != NULL)
1416 flags = look->bfd_section->flags;
1417 if (match_type && !match_type (link_info.output_bfd,
1422 flags ^= sec->flags;
1423 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1424 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1434 if ((sec->flags & SEC_CODE) != 0
1435 && (sec->flags & SEC_ALLOC) != 0)
1437 /* Try for a rw code section. */
1438 for (look = first; look; look = look->next)
1440 flags = look->flags;
1441 if (look->bfd_section != NULL)
1443 flags = look->bfd_section->flags;
1444 if (match_type && !match_type (link_info.output_bfd,
1449 flags ^= sec->flags;
1450 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1451 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1455 else if ((sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) != 0
1456 && (sec->flags & SEC_ALLOC) != 0)
1458 /* .rodata can go after .text, .sdata2 after .rodata. */
1459 for (look = first; look; look = look->next)
1461 flags = look->flags;
1462 if (look->bfd_section != NULL)
1464 flags = look->bfd_section->flags;
1465 if (match_type && !match_type (link_info.output_bfd,
1470 flags ^= sec->flags;
1471 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1473 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1477 else if ((sec->flags & SEC_SMALL_DATA) != 0
1478 && (sec->flags & SEC_ALLOC) != 0)
1480 /* .sdata goes after .data, .sbss after .sdata. */
1481 for (look = first; look; look = look->next)
1483 flags = look->flags;
1484 if (look->bfd_section != NULL)
1486 flags = look->bfd_section->flags;
1487 if (match_type && !match_type (link_info.output_bfd,
1492 flags ^= sec->flags;
1493 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1494 | SEC_THREAD_LOCAL))
1495 || ((look->flags & SEC_SMALL_DATA)
1496 && !(sec->flags & SEC_HAS_CONTENTS)))
1500 else if ((sec->flags & SEC_HAS_CONTENTS) != 0
1501 && (sec->flags & SEC_ALLOC) != 0)
1503 /* .data goes after .rodata. */
1504 for (look = first; look; look = look->next)
1506 flags = look->flags;
1507 if (look->bfd_section != NULL)
1509 flags = look->bfd_section->flags;
1510 if (match_type && !match_type (link_info.output_bfd,
1515 flags ^= sec->flags;
1516 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1517 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1521 else if ((sec->flags & SEC_ALLOC) != 0)
1523 /* .bss goes after any other alloc section. */
1524 for (look = first; look; look = look->next)
1526 flags = look->flags;
1527 if (look->bfd_section != NULL)
1529 flags = look->bfd_section->flags;
1530 if (match_type && !match_type (link_info.output_bfd,
1535 flags ^= sec->flags;
1536 if (!(flags & SEC_ALLOC))
1542 /* non-alloc go last. */
1543 for (look = first; look; look = look->next)
1545 flags = look->flags;
1546 if (look->bfd_section != NULL)
1547 flags = look->bfd_section->flags;
1548 flags ^= sec->flags;
1549 if (!(flags & SEC_DEBUGGING))
1555 if (found || !match_type)
1558 return lang_output_section_find_by_flags (sec, NULL, NULL);
1561 /* Find the last output section before given output statement.
1562 Used by place_orphan. */
1565 output_prev_sec_find (lang_output_section_statement_type *os)
1567 lang_output_section_statement_type *lookup;
1569 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1571 if (lookup->constraint < 0)
1574 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1575 return lookup->bfd_section;
1581 /* Look for a suitable place for a new output section statement. The
1582 idea is to skip over anything that might be inside a SECTIONS {}
1583 statement in a script, before we find another output section
1584 statement. Assignments to "dot" before an output section statement
1585 are assumed to belong to it. An exception to this rule is made for
1586 the first assignment to dot, otherwise we might put an orphan
1587 before . = . + SIZEOF_HEADERS or similar assignments that set the
1590 static lang_statement_union_type **
1591 insert_os_after (lang_output_section_statement_type *after)
1593 lang_statement_union_type **where;
1594 lang_statement_union_type **assign = NULL;
1595 bfd_boolean ignore_first;
1598 = after == &lang_output_section_statement.head->output_section_statement;
1600 for (where = &after->header.next;
1602 where = &(*where)->header.next)
1604 switch ((*where)->header.type)
1606 case lang_assignment_statement_enum:
1609 lang_assignment_statement_type *ass;
1611 ass = &(*where)->assignment_statement;
1612 if (ass->exp->type.node_class != etree_assert
1613 && ass->exp->assign.dst[0] == '.'
1614 && ass->exp->assign.dst[1] == 0
1618 ignore_first = FALSE;
1620 case lang_wild_statement_enum:
1621 case lang_input_section_enum:
1622 case lang_object_symbols_statement_enum:
1623 case lang_fill_statement_enum:
1624 case lang_data_statement_enum:
1625 case lang_reloc_statement_enum:
1626 case lang_padding_statement_enum:
1627 case lang_constructors_statement_enum:
1630 case lang_output_section_statement_enum:
1634 case lang_input_statement_enum:
1635 case lang_address_statement_enum:
1636 case lang_target_statement_enum:
1637 case lang_output_statement_enum:
1638 case lang_group_statement_enum:
1639 case lang_insert_statement_enum:
1648 lang_output_section_statement_type *
1649 lang_insert_orphan (asection *s,
1650 const char *secname,
1652 lang_output_section_statement_type *after,
1653 struct orphan_save *place,
1654 etree_type *address,
1655 lang_statement_list_type *add_child)
1657 lang_statement_list_type add;
1659 lang_output_section_statement_type *os;
1660 lang_output_section_statement_type **os_tail;
1662 /* If we have found an appropriate place for the output section
1663 statements for this orphan, add them to our own private list,
1664 inserting them later into the global statement list. */
1667 lang_list_init (&add);
1668 push_stat_ptr (&add);
1672 if (config.build_constructors)
1674 /* If the name of the section is representable in C, then create
1675 symbols to mark the start and the end of the section. */
1676 for (ps = secname; *ps != '\0'; ps++)
1677 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1682 etree_type *e_align;
1684 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1685 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1686 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1687 e_align = exp_unop (ALIGN_K,
1688 exp_intop ((bfd_vma) 1 << s->alignment_power));
1689 lang_add_assignment (exp_assop ('=', ".", e_align));
1690 lang_add_assignment (exp_provide (symname,
1691 exp_nameop (NAME, "."),
1696 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1697 address = exp_intop (0);
1699 os_tail = ((lang_output_section_statement_type **)
1700 lang_output_section_statement.tail);
1701 os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
1704 if (add_child == NULL)
1705 add_child = &os->children;
1706 lang_add_section (add_child, s, os);
1708 lang_leave_output_section_statement (0, "*default*", NULL, NULL);
1710 if (config.build_constructors && *ps == '\0')
1714 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1715 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1716 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1717 lang_add_assignment (exp_provide (symname,
1718 exp_nameop (NAME, "."),
1722 /* Restore the global list pointer. */
1726 if (after != NULL && os->bfd_section != NULL)
1728 asection *snew, *as;
1730 snew = os->bfd_section;
1732 /* Shuffle the bfd section list to make the output file look
1733 neater. This is really only cosmetic. */
1734 if (place->section == NULL
1735 && after != (&lang_output_section_statement.head
1736 ->output_section_statement))
1738 asection *bfd_section = after->bfd_section;
1740 /* If the output statement hasn't been used to place any input
1741 sections (and thus doesn't have an output bfd_section),
1742 look for the closest prior output statement having an
1744 if (bfd_section == NULL)
1745 bfd_section = output_prev_sec_find (after);
1747 if (bfd_section != NULL && bfd_section != snew)
1748 place->section = &bfd_section->next;
1751 if (place->section == NULL)
1752 place->section = &link_info.output_bfd->sections;
1754 as = *place->section;
1758 /* Put the section at the end of the list. */
1760 /* Unlink the section. */
1761 bfd_section_list_remove (link_info.output_bfd, snew);
1763 /* Now tack it back on in the right place. */
1764 bfd_section_list_append (link_info.output_bfd, snew);
1766 else if (as != snew && as->prev != snew)
1768 /* Unlink the section. */
1769 bfd_section_list_remove (link_info.output_bfd, snew);
1771 /* Now tack it back on in the right place. */
1772 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1775 /* Save the end of this list. Further ophans of this type will
1776 follow the one we've just added. */
1777 place->section = &snew->next;
1779 /* The following is non-cosmetic. We try to put the output
1780 statements in some sort of reasonable order here, because they
1781 determine the final load addresses of the orphan sections.
1782 In addition, placing output statements in the wrong order may
1783 require extra segments. For instance, given a typical
1784 situation of all read-only sections placed in one segment and
1785 following that a segment containing all the read-write
1786 sections, we wouldn't want to place an orphan read/write
1787 section before or amongst the read-only ones. */
1788 if (add.head != NULL)
1790 lang_output_section_statement_type *newly_added_os;
1792 if (place->stmt == NULL)
1794 lang_statement_union_type **where = insert_os_after (after);
1799 place->os_tail = &after->next;
1803 /* Put it after the last orphan statement we added. */
1804 *add.tail = *place->stmt;
1805 *place->stmt = add.head;
1808 /* Fix the global list pointer if we happened to tack our
1809 new list at the tail. */
1810 if (*stat_ptr->tail == add.head)
1811 stat_ptr->tail = add.tail;
1813 /* Save the end of this list. */
1814 place->stmt = add.tail;
1816 /* Do the same for the list of output section statements. */
1817 newly_added_os = *os_tail;
1819 newly_added_os->prev = (lang_output_section_statement_type *)
1820 ((char *) place->os_tail
1821 - offsetof (lang_output_section_statement_type, next));
1822 newly_added_os->next = *place->os_tail;
1823 if (newly_added_os->next != NULL)
1824 newly_added_os->next->prev = newly_added_os;
1825 *place->os_tail = newly_added_os;
1826 place->os_tail = &newly_added_os->next;
1828 /* Fixing the global list pointer here is a little different.
1829 We added to the list in lang_enter_output_section_statement,
1830 trimmed off the new output_section_statment above when
1831 assigning *os_tail = NULL, but possibly added it back in
1832 the same place when assigning *place->os_tail. */
1833 if (*os_tail == NULL)
1834 lang_output_section_statement.tail
1835 = (lang_statement_union_type **) os_tail;
1842 lang_map_flags (flagword flag)
1844 if (flag & SEC_ALLOC)
1847 if (flag & SEC_CODE)
1850 if (flag & SEC_READONLY)
1853 if (flag & SEC_DATA)
1856 if (flag & SEC_LOAD)
1863 lang_memory_region_type *m;
1864 bfd_boolean dis_header_printed = FALSE;
1867 LANG_FOR_EACH_INPUT_STATEMENT (file)
1871 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1872 || file->just_syms_flag)
1875 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1876 if ((s->output_section == NULL
1877 || s->output_section->owner != link_info.output_bfd)
1878 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1880 if (! dis_header_printed)
1882 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1883 dis_header_printed = TRUE;
1886 print_input_section (s);
1890 minfo (_("\nMemory Configuration\n\n"));
1891 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1892 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1894 for (m = lang_memory_region_list; m != NULL; m = m->next)
1899 fprintf (config.map_file, "%-16s ", m->name_list.name);
1901 sprintf_vma (buf, m->origin);
1902 minfo ("0x%s ", buf);
1910 minfo ("0x%V", m->length);
1911 if (m->flags || m->not_flags)
1919 lang_map_flags (m->flags);
1925 lang_map_flags (m->not_flags);
1932 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1934 if (! link_info.reduce_memory_overheads)
1936 obstack_begin (&map_obstack, 1000);
1937 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1938 bfd_map_over_sections (p, init_map_userdata, 0);
1939 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1941 lang_statement_iteration ++;
1942 print_statements ();
1946 init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
1948 void *data ATTRIBUTE_UNUSED)
1950 fat_section_userdata_type *new_data
1951 = ((fat_section_userdata_type *) (stat_alloc
1952 (sizeof (fat_section_userdata_type))));
1954 ASSERT (get_userdata (sec) == NULL);
1955 get_userdata (sec) = new_data;
1956 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1960 sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
1961 void *info ATTRIBUTE_UNUSED)
1963 if (hash_entry->type == bfd_link_hash_defined
1964 || hash_entry->type == bfd_link_hash_defweak)
1966 struct fat_user_section_struct *ud;
1967 struct map_symbol_def *def;
1969 ud = get_userdata (hash_entry->u.def.section);
1972 /* ??? What do we have to do to initialize this beforehand? */
1973 /* The first time we get here is bfd_abs_section... */
1974 init_map_userdata (0, hash_entry->u.def.section, 0);
1975 ud = get_userdata (hash_entry->u.def.section);
1977 else if (!ud->map_symbol_def_tail)
1978 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1980 def = obstack_alloc (&map_obstack, sizeof *def);
1981 def->entry = hash_entry;
1982 *(ud->map_symbol_def_tail) = def;
1983 ud->map_symbol_def_tail = &def->next;
1988 /* Initialize an output section. */
1991 init_os (lang_output_section_statement_type *s, asection *isec,
1994 if (s->bfd_section != NULL)
1997 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1998 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2000 if (s->constraint != SPECIAL)
2001 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2002 if (s->bfd_section == NULL)
2003 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2005 if (s->bfd_section == NULL)
2007 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2008 link_info.output_bfd->xvec->name, s->name);
2010 s->bfd_section->output_section = s->bfd_section;
2011 s->bfd_section->output_offset = 0;
2013 if (!link_info.reduce_memory_overheads)
2015 fat_section_userdata_type *new
2016 = stat_alloc (sizeof (fat_section_userdata_type));
2017 memset (new, 0, sizeof (fat_section_userdata_type));
2018 get_userdata (s->bfd_section) = new;
2021 /* If there is a base address, make sure that any sections it might
2022 mention are initialized. */
2023 if (s->addr_tree != NULL)
2024 exp_init_os (s->addr_tree);
2026 if (s->load_base != NULL)
2027 exp_init_os (s->load_base);
2029 /* If supplied an alignment, set it. */
2030 if (s->section_alignment != -1)
2031 s->bfd_section->alignment_power = s->section_alignment;
2034 bfd_init_private_section_data (isec->owner, isec,
2035 link_info.output_bfd, s->bfd_section,
2039 /* Make sure that all output sections mentioned in an expression are
2043 exp_init_os (etree_type *exp)
2045 switch (exp->type.node_class)
2049 exp_init_os (exp->assign.src);
2053 exp_init_os (exp->binary.lhs);
2054 exp_init_os (exp->binary.rhs);
2058 exp_init_os (exp->trinary.cond);
2059 exp_init_os (exp->trinary.lhs);
2060 exp_init_os (exp->trinary.rhs);
2064 exp_init_os (exp->assert_s.child);
2068 exp_init_os (exp->unary.child);
2072 switch (exp->type.node_code)
2078 lang_output_section_statement_type *os;
2080 os = lang_output_section_find (exp->name.name);
2081 if (os != NULL && os->bfd_section == NULL)
2082 init_os (os, NULL, 0);
2093 section_already_linked (bfd *abfd, asection *sec, void *data)
2095 lang_input_statement_type *entry = data;
2097 /* If we are only reading symbols from this object, then we want to
2098 discard all sections. */
2099 if (entry->just_syms_flag)
2101 bfd_link_just_syms (abfd, sec, &link_info);
2105 if (!(abfd->flags & DYNAMIC))
2106 bfd_section_already_linked (abfd, sec, &link_info);
2109 /* The wild routines.
2111 These expand statements like *(.text) and foo.o to a list of
2112 explicit actions, like foo.o(.text), bar.o(.text) and
2113 foo.o(.text, .data). */
2115 /* Add SECTION to the output section OUTPUT. Do this by creating a
2116 lang_input_section statement which is placed at PTR. FILE is the
2117 input file which holds SECTION. */
2120 lang_add_section (lang_statement_list_type *ptr,
2122 lang_output_section_statement_type *output)
2124 flagword flags = section->flags;
2125 bfd_boolean discard;
2127 /* Discard sections marked with SEC_EXCLUDE. */
2128 discard = (flags & SEC_EXCLUDE) != 0;
2130 /* Discard input sections which are assigned to a section named
2131 DISCARD_SECTION_NAME. */
2132 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2135 /* Discard debugging sections if we are stripping debugging
2137 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2138 && (flags & SEC_DEBUGGING) != 0)
2143 if (section->output_section == NULL)
2145 /* This prevents future calls from assigning this section. */
2146 section->output_section = bfd_abs_section_ptr;
2151 if (section->output_section == NULL)
2154 lang_input_section_type *new;
2157 flags = section->flags;
2159 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2160 to an output section, because we want to be able to include a
2161 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2162 section (I don't know why we want to do this, but we do).
2163 build_link_order in ldwrite.c handles this case by turning
2164 the embedded SEC_NEVER_LOAD section into a fill. */
2166 flags &= ~ SEC_NEVER_LOAD;
2168 switch (output->sectype)
2170 case normal_section:
2171 case overlay_section:
2173 case noalloc_section:
2174 flags &= ~SEC_ALLOC;
2176 case noload_section:
2178 flags |= SEC_NEVER_LOAD;
2182 if (output->bfd_section == NULL)
2183 init_os (output, section, flags);
2185 first = ! output->bfd_section->linker_has_input;
2186 output->bfd_section->linker_has_input = 1;
2188 if (!link_info.relocatable
2189 && !stripped_excluded_sections)
2191 asection *s = output->bfd_section->map_tail.s;
2192 output->bfd_section->map_tail.s = section;
2193 section->map_head.s = NULL;
2194 section->map_tail.s = s;
2196 s->map_head.s = section;
2198 output->bfd_section->map_head.s = section;
2201 /* Add a section reference to the list. */
2202 new = new_stat (lang_input_section, ptr);
2204 new->section = section;
2205 section->output_section = output->bfd_section;
2207 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2208 already been processed. One reason to do this is that on pe
2209 format targets, .text$foo sections go into .text and it's odd
2210 to see .text with SEC_LINK_ONCE set. */
2212 if (! link_info.relocatable)
2213 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
2215 /* If this is not the first input section, and the SEC_READONLY
2216 flag is not currently set, then don't set it just because the
2217 input section has it set. */
2219 if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
2220 flags &= ~ SEC_READONLY;
2222 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2224 && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2225 != (flags & (SEC_MERGE | SEC_STRINGS))
2226 || ((flags & SEC_MERGE)
2227 && output->bfd_section->entsize != section->entsize)))
2229 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2230 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2233 output->bfd_section->flags |= flags;
2235 if (flags & SEC_MERGE)
2236 output->bfd_section->entsize = section->entsize;
2238 /* If SEC_READONLY is not set in the input section, then clear
2239 it from the output section. */
2240 if ((section->flags & SEC_READONLY) == 0)
2241 output->bfd_section->flags &= ~SEC_READONLY;
2243 /* Copy over SEC_SMALL_DATA. */
2244 if (section->flags & SEC_SMALL_DATA)
2245 output->bfd_section->flags |= SEC_SMALL_DATA;
2247 if (section->alignment_power > output->bfd_section->alignment_power)
2248 output->bfd_section->alignment_power = section->alignment_power;
2250 if (bfd_get_arch (section->owner) == bfd_arch_tic54x
2251 && (section->flags & SEC_TIC54X_BLOCK) != 0)
2253 output->bfd_section->flags |= SEC_TIC54X_BLOCK;
2254 /* FIXME: This value should really be obtained from the bfd... */
2255 output->block_value = 128;
2260 /* Handle wildcard sorting. This returns the lang_input_section which
2261 should follow the one we are going to create for SECTION and FILE,
2262 based on the sorting requirements of WILD. It returns NULL if the
2263 new section should just go at the end of the current list. */
2265 static lang_statement_union_type *
2266 wild_sort (lang_wild_statement_type *wild,
2267 struct wildcard_list *sec,
2268 lang_input_statement_type *file,
2271 const char *section_name;
2272 lang_statement_union_type *l;
2274 if (!wild->filenames_sorted
2275 && (sec == NULL || sec->spec.sorted == none))
2278 section_name = bfd_get_section_name (file->the_bfd, section);
2279 for (l = wild->children.head; l != NULL; l = l->header.next)
2281 lang_input_section_type *ls;
2283 if (l->header.type != lang_input_section_enum)
2285 ls = &l->input_section;
2287 /* Sorting by filename takes precedence over sorting by section
2290 if (wild->filenames_sorted)
2292 const char *fn, *ln;
2296 /* The PE support for the .idata section as generated by
2297 dlltool assumes that files will be sorted by the name of
2298 the archive and then the name of the file within the
2301 if (file->the_bfd != NULL
2302 && bfd_my_archive (file->the_bfd) != NULL)
2304 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2309 fn = file->filename;
2313 if (bfd_my_archive (ls->section->owner) != NULL)
2315 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2320 ln = ls->section->owner->filename;
2324 i = strcmp (fn, ln);
2333 fn = file->filename;
2335 ln = ls->section->owner->filename;
2337 i = strcmp (fn, ln);
2345 /* Here either the files are not sorted by name, or we are
2346 looking at the sections for this file. */
2348 if (sec != NULL && sec->spec.sorted != none)
2349 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2356 /* Expand a wild statement for a particular FILE. SECTION may be
2357 NULL, in which case it is a wild card. */
2360 output_section_callback (lang_wild_statement_type *ptr,
2361 struct wildcard_list *sec,
2363 lang_input_statement_type *file,
2366 lang_statement_union_type *before;
2368 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2369 if (unique_section_p (section))
2372 before = wild_sort (ptr, sec, file, section);
2374 /* Here BEFORE points to the lang_input_section which
2375 should follow the one we are about to add. If BEFORE
2376 is NULL, then the section should just go at the end
2377 of the current list. */
2380 lang_add_section (&ptr->children, section,
2381 (lang_output_section_statement_type *) output);
2384 lang_statement_list_type list;
2385 lang_statement_union_type **pp;
2387 lang_list_init (&list);
2388 lang_add_section (&list, section,
2389 (lang_output_section_statement_type *) output);
2391 /* If we are discarding the section, LIST.HEAD will
2393 if (list.head != NULL)
2395 ASSERT (list.head->header.next == NULL);
2397 for (pp = &ptr->children.head;
2399 pp = &(*pp)->header.next)
2400 ASSERT (*pp != NULL);
2402 list.head->header.next = *pp;
2408 /* Check if all sections in a wild statement for a particular FILE
2412 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2413 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2415 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2418 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2419 if (unique_section_p (section))
2422 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2423 ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
2426 /* This is passed a file name which must have been seen already and
2427 added to the statement tree. We will see if it has been opened
2428 already and had its symbols read. If not then we'll read it. */
2430 static lang_input_statement_type *
2431 lookup_name (const char *name)
2433 lang_input_statement_type *search;
2435 for (search = (lang_input_statement_type *) input_file_chain.head;
2437 search = (lang_input_statement_type *) search->next_real_file)
2439 /* Use the local_sym_name as the name of the file that has
2440 already been loaded as filename might have been transformed
2441 via the search directory lookup mechanism. */
2442 const char *filename = search->local_sym_name;
2444 if (filename != NULL
2445 && strcmp (filename, name) == 0)
2450 search = new_afile (name, lang_input_file_is_search_file_enum,
2451 default_target, FALSE);
2453 /* If we have already added this file, or this file is not real
2454 don't add this file. */
2455 if (search->loaded || !search->real)
2458 if (! load_symbols (search, NULL))
2464 /* Save LIST as a list of libraries whose symbols should not be exported. */
2469 struct excluded_lib *next;
2471 static struct excluded_lib *excluded_libs;
2474 add_excluded_libs (const char *list)
2476 const char *p = list, *end;
2480 struct excluded_lib *entry;
2481 end = strpbrk (p, ",:");
2483 end = p + strlen (p);
2484 entry = xmalloc (sizeof (*entry));
2485 entry->next = excluded_libs;
2486 entry->name = xmalloc (end - p + 1);
2487 memcpy (entry->name, p, end - p);
2488 entry->name[end - p] = '\0';
2489 excluded_libs = entry;
2497 check_excluded_libs (bfd *abfd)
2499 struct excluded_lib *lib = excluded_libs;
2503 int len = strlen (lib->name);
2504 const char *filename = lbasename (abfd->filename);
2506 if (strcmp (lib->name, "ALL") == 0)
2508 abfd->no_export = TRUE;
2512 if (strncmp (lib->name, filename, len) == 0
2513 && (filename[len] == '\0'
2514 || (filename[len] == '.' && filename[len + 1] == 'a'
2515 && filename[len + 2] == '\0')))
2517 abfd->no_export = TRUE;
2525 /* Get the symbols for an input file. */
2528 load_symbols (lang_input_statement_type *entry,
2529 lang_statement_list_type *place)
2536 ldfile_open_file (entry);
2538 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2539 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2542 bfd_boolean save_ldlang_sysrooted_script;
2543 bfd_boolean save_as_needed, save_add_needed;
2545 err = bfd_get_error ();
2547 /* See if the emulation has some special knowledge. */
2548 if (ldemul_unrecognized_file (entry))
2551 if (err == bfd_error_file_ambiguously_recognized)
2555 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2556 einfo (_("%B: matching formats:"), entry->the_bfd);
2557 for (p = matching; *p != NULL; p++)
2561 else if (err != bfd_error_file_not_recognized
2563 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2565 bfd_close (entry->the_bfd);
2566 entry->the_bfd = NULL;
2568 /* Try to interpret the file as a linker script. */
2569 ldfile_open_command_file (entry->filename);
2571 push_stat_ptr (place);
2572 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2573 ldlang_sysrooted_script = entry->sysrooted;
2574 save_as_needed = as_needed;
2575 as_needed = entry->as_needed;
2576 save_add_needed = add_needed;
2577 add_needed = entry->add_needed;
2579 ldfile_assumed_script = TRUE;
2580 parser_input = input_script;
2581 /* We want to use the same -Bdynamic/-Bstatic as the one for
2583 config.dynamic_link = entry->dynamic;
2585 ldfile_assumed_script = FALSE;
2587 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2588 as_needed = save_as_needed;
2589 add_needed = save_add_needed;
2595 if (ldemul_recognized_file (entry))
2598 /* We don't call ldlang_add_file for an archive. Instead, the
2599 add_symbols entry point will call ldlang_add_file, via the
2600 add_archive_element callback, for each element of the archive
2602 switch (bfd_get_format (entry->the_bfd))
2608 ldlang_add_file (entry);
2609 if (trace_files || trace_file_tries)
2610 info_msg ("%I\n", entry);
2614 check_excluded_libs (entry->the_bfd);
2616 if (entry->whole_archive)
2619 bfd_boolean loaded = TRUE;
2623 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2628 if (! bfd_check_format (member, bfd_object))
2630 einfo (_("%F%B: member %B in archive is not an object\n"),
2631 entry->the_bfd, member);
2635 if (! ((*link_info.callbacks->add_archive_element)
2636 (&link_info, member, "--whole-archive")))
2639 if (! bfd_link_add_symbols (member, &link_info))
2641 einfo (_("%F%B: could not read symbols: %E\n"), member);
2646 entry->loaded = loaded;
2652 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2653 entry->loaded = TRUE;
2655 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2657 return entry->loaded;
2660 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2661 may be NULL, indicating that it is a wildcard. Separate
2662 lang_input_section statements are created for each part of the
2663 expansion; they are added after the wild statement S. OUTPUT is
2664 the output section. */
2667 wild (lang_wild_statement_type *s,
2668 const char *target ATTRIBUTE_UNUSED,
2669 lang_output_section_statement_type *output)
2671 struct wildcard_list *sec;
2673 if (s->handler_data[0]
2674 && s->handler_data[0]->spec.sorted == by_name
2675 && !s->filenames_sorted)
2677 lang_section_bst_type *tree;
2679 walk_wild (s, output_section_callback_fast, output);
2684 output_section_callback_tree_to_list (s, tree, output);
2689 walk_wild (s, output_section_callback, output);
2691 if (default_common_section == NULL)
2692 for (sec = s->section_list; sec != NULL; sec = sec->next)
2693 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2695 /* Remember the section that common is going to in case we
2696 later get something which doesn't know where to put it. */
2697 default_common_section = output;
2702 /* Return TRUE iff target is the sought target. */
2705 get_target (const bfd_target *target, void *data)
2707 const char *sought = data;
2709 return strcmp (target->name, sought) == 0;
2712 /* Like strcpy() but convert to lower case as well. */
2715 stricpy (char *dest, char *src)
2719 while ((c = *src++) != 0)
2720 *dest++ = TOLOWER (c);
2725 /* Remove the first occurrence of needle (if any) in haystack
2729 strcut (char *haystack, char *needle)
2731 haystack = strstr (haystack, needle);
2737 for (src = haystack + strlen (needle); *src;)
2738 *haystack++ = *src++;
2744 /* Compare two target format name strings.
2745 Return a value indicating how "similar" they are. */
2748 name_compare (char *first, char *second)
2754 copy1 = xmalloc (strlen (first) + 1);
2755 copy2 = xmalloc (strlen (second) + 1);
2757 /* Convert the names to lower case. */
2758 stricpy (copy1, first);
2759 stricpy (copy2, second);
2761 /* Remove size and endian strings from the name. */
2762 strcut (copy1, "big");
2763 strcut (copy1, "little");
2764 strcut (copy2, "big");
2765 strcut (copy2, "little");
2767 /* Return a value based on how many characters match,
2768 starting from the beginning. If both strings are
2769 the same then return 10 * their length. */
2770 for (result = 0; copy1[result] == copy2[result]; result++)
2771 if (copy1[result] == 0)
2783 /* Set by closest_target_match() below. */
2784 static const bfd_target *winner;
2786 /* Scan all the valid bfd targets looking for one that has the endianness
2787 requirement that was specified on the command line, and is the nearest
2788 match to the original output target. */
2791 closest_target_match (const bfd_target *target, void *data)
2793 const bfd_target *original = data;
2795 if (command_line.endian == ENDIAN_BIG
2796 && target->byteorder != BFD_ENDIAN_BIG)
2799 if (command_line.endian == ENDIAN_LITTLE
2800 && target->byteorder != BFD_ENDIAN_LITTLE)
2803 /* Must be the same flavour. */
2804 if (target->flavour != original->flavour)
2807 /* Ignore generic big and little endian elf vectors. */
2808 if (strcmp (target->name, "elf32-big") == 0
2809 || strcmp (target->name, "elf64-big") == 0
2810 || strcmp (target->name, "elf32-little") == 0
2811 || strcmp (target->name, "elf64-little") == 0)
2814 /* If we have not found a potential winner yet, then record this one. */
2821 /* Oh dear, we now have two potential candidates for a successful match.
2822 Compare their names and choose the better one. */
2823 if (name_compare (target->name, original->name)
2824 > name_compare (winner->name, original->name))
2827 /* Keep on searching until wqe have checked them all. */
2831 /* Return the BFD target format of the first input file. */
2834 get_first_input_target (void)
2836 char *target = NULL;
2838 LANG_FOR_EACH_INPUT_STATEMENT (s)
2840 if (s->header.type == lang_input_statement_enum
2843 ldfile_open_file (s);
2845 if (s->the_bfd != NULL
2846 && bfd_check_format (s->the_bfd, bfd_object))
2848 target = bfd_get_target (s->the_bfd);
2860 lang_get_output_target (void)
2864 /* Has the user told us which output format to use? */
2865 if (output_target != NULL)
2866 return output_target;
2868 /* No - has the current target been set to something other than
2870 if (current_target != default_target)
2871 return current_target;
2873 /* No - can we determine the format of the first input file? */
2874 target = get_first_input_target ();
2878 /* Failed - use the default output target. */
2879 return default_target;
2882 /* Open the output file. */
2885 open_output (const char *name)
2887 output_target = lang_get_output_target ();
2889 /* Has the user requested a particular endianness on the command
2891 if (command_line.endian != ENDIAN_UNSET)
2893 const bfd_target *target;
2894 enum bfd_endian desired_endian;
2896 /* Get the chosen target. */
2897 target = bfd_search_for_target (get_target, (void *) output_target);
2899 /* If the target is not supported, we cannot do anything. */
2902 if (command_line.endian == ENDIAN_BIG)
2903 desired_endian = BFD_ENDIAN_BIG;
2905 desired_endian = BFD_ENDIAN_LITTLE;
2907 /* See if the target has the wrong endianness. This should
2908 not happen if the linker script has provided big and
2909 little endian alternatives, but some scrips don't do
2911 if (target->byteorder != desired_endian)
2913 /* If it does, then see if the target provides
2914 an alternative with the correct endianness. */
2915 if (target->alternative_target != NULL
2916 && (target->alternative_target->byteorder == desired_endian))
2917 output_target = target->alternative_target->name;
2920 /* Try to find a target as similar as possible to
2921 the default target, but which has the desired
2922 endian characteristic. */
2923 bfd_search_for_target (closest_target_match,
2926 /* Oh dear - we could not find any targets that
2927 satisfy our requirements. */
2929 einfo (_("%P: warning: could not find any targets"
2930 " that match endianness requirement\n"));
2932 output_target = winner->name;
2938 link_info.output_bfd = bfd_openw (name, output_target);
2940 if (link_info.output_bfd == NULL)
2942 if (bfd_get_error () == bfd_error_invalid_target)
2943 einfo (_("%P%F: target %s not found\n"), output_target);
2945 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2948 delete_output_file_on_failure = TRUE;
2950 if (! bfd_set_format (link_info.output_bfd, bfd_object))
2951 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2952 if (! bfd_set_arch_mach (link_info.output_bfd,
2953 ldfile_output_architecture,
2954 ldfile_output_machine))
2955 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2957 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
2958 if (link_info.hash == NULL)
2959 einfo (_("%P%F: can not create hash table: %E\n"));
2961 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
2965 ldlang_open_output (lang_statement_union_type *statement)
2967 switch (statement->header.type)
2969 case lang_output_statement_enum:
2970 ASSERT (link_info.output_bfd == NULL);
2971 open_output (statement->output_statement.name);
2972 ldemul_set_output_arch ();
2973 if (config.magic_demand_paged && !link_info.relocatable)
2974 link_info.output_bfd->flags |= D_PAGED;
2976 link_info.output_bfd->flags &= ~D_PAGED;
2977 if (config.text_read_only)
2978 link_info.output_bfd->flags |= WP_TEXT;
2980 link_info.output_bfd->flags &= ~WP_TEXT;
2981 if (link_info.traditional_format)
2982 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2984 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2987 case lang_target_statement_enum:
2988 current_target = statement->target_statement.target;
2995 /* Convert between addresses in bytes and sizes in octets.
2996 For currently supported targets, octets_per_byte is always a power
2997 of two, so we can use shifts. */
2998 #define TO_ADDR(X) ((X) >> opb_shift)
2999 #define TO_SIZE(X) ((X) << opb_shift)
3001 /* Support the above. */
3002 static unsigned int opb_shift = 0;
3007 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3008 ldfile_output_machine);
3011 while ((x & 1) == 0)
3019 /* Open all the input files. */
3022 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
3024 for (; s != NULL; s = s->header.next)
3026 switch (s->header.type)
3028 case lang_constructors_statement_enum:
3029 open_input_bfds (constructor_list.head, force);
3031 case lang_output_section_statement_enum:
3032 open_input_bfds (s->output_section_statement.children.head, force);
3034 case lang_wild_statement_enum:
3035 /* Maybe we should load the file's symbols. */
3036 if (s->wild_statement.filename
3037 && !wildcardp (s->wild_statement.filename)
3038 && !archive_path (s->wild_statement.filename))
3039 lookup_name (s->wild_statement.filename);
3040 open_input_bfds (s->wild_statement.children.head, force);
3042 case lang_group_statement_enum:
3044 struct bfd_link_hash_entry *undefs;
3046 /* We must continually search the entries in the group
3047 until no new symbols are added to the list of undefined
3052 undefs = link_info.hash->undefs_tail;
3053 open_input_bfds (s->group_statement.children.head, TRUE);
3055 while (undefs != link_info.hash->undefs_tail);
3058 case lang_target_statement_enum:
3059 current_target = s->target_statement.target;
3061 case lang_input_statement_enum:
3062 if (s->input_statement.real)
3064 lang_statement_union_type **os_tail;
3065 lang_statement_list_type add;
3067 s->input_statement.target = current_target;
3069 /* If we are being called from within a group, and this
3070 is an archive which has already been searched, then
3071 force it to be researched unless the whole archive
3072 has been loaded already. */
3074 && !s->input_statement.whole_archive
3075 && s->input_statement.loaded
3076 && bfd_check_format (s->input_statement.the_bfd,
3078 s->input_statement.loaded = FALSE;
3080 os_tail = lang_output_section_statement.tail;
3081 lang_list_init (&add);
3083 if (! load_symbols (&s->input_statement, &add))
3084 config.make_executable = FALSE;
3086 if (add.head != NULL)
3088 /* If this was a script with output sections then
3089 tack any added statements on to the end of the
3090 list. This avoids having to reorder the output
3091 section statement list. Very likely the user
3092 forgot -T, and whatever we do here will not meet
3093 naive user expectations. */
3094 if (os_tail != lang_output_section_statement.tail)
3096 einfo (_("%P: warning: %s contains output sections;"
3097 " did you forget -T?\n"),
3098 s->input_statement.filename);
3099 *stat_ptr->tail = add.head;
3100 stat_ptr->tail = add.tail;
3104 *add.tail = s->header.next;
3105 s->header.next = add.head;
3116 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3119 lang_track_definedness (const char *name)
3121 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3122 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3125 /* New-function for the definedness hash table. */
3127 static struct bfd_hash_entry *
3128 lang_definedness_newfunc (struct bfd_hash_entry *entry,
3129 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3130 const char *name ATTRIBUTE_UNUSED)
3132 struct lang_definedness_hash_entry *ret
3133 = (struct lang_definedness_hash_entry *) entry;
3136 ret = (struct lang_definedness_hash_entry *)
3137 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3140 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3142 ret->iteration = -1;
3146 /* Return the iteration when the definition of NAME was last updated. A
3147 value of -1 means that the symbol is not defined in the linker script
3148 or the command line, but may be defined in the linker symbol table. */
3151 lang_symbol_definition_iteration (const char *name)
3153 struct lang_definedness_hash_entry *defentry
3154 = (struct lang_definedness_hash_entry *)
3155 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3157 /* We've already created this one on the presence of DEFINED in the
3158 script, so it can't be NULL unless something is borked elsewhere in
3160 if (defentry == NULL)
3163 return defentry->iteration;
3166 /* Update the definedness state of NAME. */
3169 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3171 struct lang_definedness_hash_entry *defentry
3172 = (struct lang_definedness_hash_entry *)
3173 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3175 /* We don't keep track of symbols not tested with DEFINED. */
3176 if (defentry == NULL)
3179 /* If the symbol was already defined, and not from an earlier statement
3180 iteration, don't update the definedness iteration, because that'd
3181 make the symbol seem defined in the linker script at this point, and
3182 it wasn't; it was defined in some object. If we do anyway, DEFINED
3183 would start to yield false before this point and the construct "sym =
3184 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3186 if (h->type != bfd_link_hash_undefined
3187 && h->type != bfd_link_hash_common
3188 && h->type != bfd_link_hash_new
3189 && defentry->iteration == -1)
3192 defentry->iteration = lang_statement_iteration;
3195 /* Add the supplied name to the symbol table as an undefined reference.
3196 This is a two step process as the symbol table doesn't even exist at
3197 the time the ld command line is processed. First we put the name
3198 on a list, then, once the output file has been opened, transfer the
3199 name to the symbol table. */
3201 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3203 #define ldlang_undef_chain_list_head entry_symbol.next
3206 ldlang_add_undef (const char *const name)
3208 ldlang_undef_chain_list_type *new =
3209 stat_alloc (sizeof (ldlang_undef_chain_list_type));
3211 new->next = ldlang_undef_chain_list_head;
3212 ldlang_undef_chain_list_head = new;
3214 new->name = xstrdup (name);
3216 if (link_info.output_bfd != NULL)
3217 insert_undefined (new->name);
3220 /* Insert NAME as undefined in the symbol table. */
3223 insert_undefined (const char *name)
3225 struct bfd_link_hash_entry *h;
3227 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3229 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3230 if (h->type == bfd_link_hash_new)
3232 h->type = bfd_link_hash_undefined;
3233 h->u.undef.abfd = NULL;
3234 bfd_link_add_undef (link_info.hash, h);
3238 /* Run through the list of undefineds created above and place them
3239 into the linker hash table as undefined symbols belonging to the
3243 lang_place_undefineds (void)
3245 ldlang_undef_chain_list_type *ptr;
3247 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3248 insert_undefined (ptr->name);
3251 /* Check for all readonly or some readwrite sections. */
3254 check_input_sections
3255 (lang_statement_union_type *s,
3256 lang_output_section_statement_type *output_section_statement)
3258 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3260 switch (s->header.type)
3262 case lang_wild_statement_enum:
3263 walk_wild (&s->wild_statement, check_section_callback,
3264 output_section_statement);
3265 if (! output_section_statement->all_input_readonly)
3268 case lang_constructors_statement_enum:
3269 check_input_sections (constructor_list.head,
3270 output_section_statement);
3271 if (! output_section_statement->all_input_readonly)
3274 case lang_group_statement_enum:
3275 check_input_sections (s->group_statement.children.head,
3276 output_section_statement);
3277 if (! output_section_statement->all_input_readonly)
3286 /* Update wildcard statements if needed. */
3289 update_wild_statements (lang_statement_union_type *s)
3291 struct wildcard_list *sec;
3293 switch (sort_section)
3303 for (; s != NULL; s = s->header.next)
3305 switch (s->header.type)
3310 case lang_wild_statement_enum:
3311 sec = s->wild_statement.section_list;
3312 for (sec = s->wild_statement.section_list; sec != NULL;
3315 switch (sec->spec.sorted)
3318 sec->spec.sorted = sort_section;
3321 if (sort_section == by_alignment)
3322 sec->spec.sorted = by_name_alignment;
3325 if (sort_section == by_name)
3326 sec->spec.sorted = by_alignment_name;
3334 case lang_constructors_statement_enum:
3335 update_wild_statements (constructor_list.head);
3338 case lang_output_section_statement_enum:
3339 update_wild_statements
3340 (s->output_section_statement.children.head);
3343 case lang_group_statement_enum:
3344 update_wild_statements (s->group_statement.children.head);
3352 /* Open input files and attach to output sections. */
3355 map_input_to_output_sections
3356 (lang_statement_union_type *s, const char *target,
3357 lang_output_section_statement_type *os)
3361 for (; s != NULL; s = s->header.next)
3363 switch (s->header.type)
3365 case lang_wild_statement_enum:
3366 wild (&s->wild_statement, target, os);
3368 case lang_constructors_statement_enum:
3369 map_input_to_output_sections (constructor_list.head,
3373 case lang_output_section_statement_enum:
3374 if (s->output_section_statement.constraint)
3376 if (s->output_section_statement.constraint != ONLY_IF_RW
3377 && s->output_section_statement.constraint != ONLY_IF_RO)
3379 s->output_section_statement.all_input_readonly = TRUE;
3380 check_input_sections (s->output_section_statement.children.head,
3381 &s->output_section_statement);
3382 if ((s->output_section_statement.all_input_readonly
3383 && s->output_section_statement.constraint == ONLY_IF_RW)
3384 || (!s->output_section_statement.all_input_readonly
3385 && s->output_section_statement.constraint == ONLY_IF_RO))
3387 s->output_section_statement.constraint = -1;
3392 map_input_to_output_sections (s->output_section_statement.children.head,
3394 &s->output_section_statement);
3396 case lang_output_statement_enum:
3398 case lang_target_statement_enum:
3399 target = s->target_statement.target;
3401 case lang_group_statement_enum:
3402 map_input_to_output_sections (s->group_statement.children.head,
3406 case lang_data_statement_enum:
3407 /* Make sure that any sections mentioned in the expression
3409 exp_init_os (s->data_statement.exp);
3410 flags = SEC_HAS_CONTENTS;
3411 /* The output section gets contents, and then we inspect for
3412 any flags set in the input script which override any ALLOC. */
3413 if (!(os->flags & SEC_NEVER_LOAD))
3414 flags |= SEC_ALLOC | SEC_LOAD;
3415 if (os->bfd_section == NULL)
3416 init_os (os, NULL, flags);
3418 os->bfd_section->flags |= flags;
3420 case lang_input_section_enum:
3422 case lang_fill_statement_enum:
3423 case lang_object_symbols_statement_enum:
3424 case lang_reloc_statement_enum:
3425 case lang_padding_statement_enum:
3426 case lang_input_statement_enum:
3427 if (os != NULL && os->bfd_section == NULL)
3428 init_os (os, NULL, 0);
3430 case lang_assignment_statement_enum:
3431 if (os != NULL && os->bfd_section == NULL)
3432 init_os (os, NULL, 0);
3434 /* Make sure that any sections mentioned in the assignment
3436 exp_init_os (s->assignment_statement.exp);
3438 case lang_address_statement_enum:
3439 /* Mark the specified section with the supplied address.
3440 If this section was actually a segment marker, then the
3441 directive is ignored if the linker script explicitly
3442 processed the segment marker. Originally, the linker
3443 treated segment directives (like -Ttext on the
3444 command-line) as section directives. We honor the
3445 section directive semantics for backwards compatibilty;
3446 linker scripts that do not specifically check for
3447 SEGMENT_START automatically get the old semantics. */
3448 if (!s->address_statement.segment
3449 || !s->address_statement.segment->used)
3451 lang_output_section_statement_type *aos
3452 = (lang_output_section_statement_lookup
3453 (s->address_statement.section_name, 0, TRUE));
3455 if (aos->bfd_section == NULL)
3456 init_os (aos, NULL, 0);
3457 aos->addr_tree = s->address_statement.address;
3460 case lang_insert_statement_enum:
3466 /* An insert statement snips out all the linker statements from the
3467 start of the list and places them after the output section
3468 statement specified by the insert. This operation is complicated
3469 by the fact that we keep a doubly linked list of output section
3470 statements as well as the singly linked list of all statements. */
3473 process_insert_statements (void)
3475 lang_statement_union_type **s;
3476 lang_output_section_statement_type *first_os = NULL;
3477 lang_output_section_statement_type *last_os = NULL;
3478 lang_output_section_statement_type *os;
3480 /* "start of list" is actually the statement immediately after
3481 the special abs_section output statement, so that it isn't
3483 s = &lang_output_section_statement.head;
3484 while (*(s = &(*s)->header.next) != NULL)
3486 if ((*s)->header.type == lang_output_section_statement_enum)
3488 /* Keep pointers to the first and last output section
3489 statement in the sequence we may be about to move. */
3490 os = &(*s)->output_section_statement;
3492 ASSERT (last_os == NULL || last_os->next == os);
3495 /* Set constraint negative so that lang_output_section_find
3496 won't match this output section statement. At this
3497 stage in linking constraint has values in the range
3498 [-1, ONLY_IN_RW]. */
3499 last_os->constraint = -2 - last_os->constraint;
3500 if (first_os == NULL)
3503 else if ((*s)->header.type == lang_insert_statement_enum)
3505 lang_insert_statement_type *i = &(*s)->insert_statement;
3506 lang_output_section_statement_type *where;
3507 lang_statement_union_type **ptr;
3508 lang_statement_union_type *first;
3510 where = lang_output_section_find (i->where);
3511 if (where != NULL && i->is_before)
3514 where = where->prev;
3515 while (where != NULL && where->constraint < 0);
3519 einfo (_("%F%P: %s not found for insert\n"), i->where);
3523 /* Deal with reordering the output section statement list. */
3524 if (last_os != NULL)
3526 asection *first_sec, *last_sec;
3527 struct lang_output_section_statement_struct **next;
3529 /* Snip out the output sections we are moving. */
3530 first_os->prev->next = last_os->next;
3531 if (last_os->next == NULL)
3533 next = &first_os->prev->next;
3534 lang_output_section_statement.tail
3535 = (lang_statement_union_type **) next;
3538 last_os->next->prev = first_os->prev;
3539 /* Add them in at the new position. */
3540 last_os->next = where->next;
3541 if (where->next == NULL)
3543 next = &last_os->next;
3544 lang_output_section_statement.tail
3545 = (lang_statement_union_type **) next;
3548 where->next->prev = last_os;
3549 first_os->prev = where;
3550 where->next = first_os;
3552 /* Move the bfd sections in the same way. */
3555 for (os = first_os; os != NULL; os = os->next)
3557 os->constraint = -2 - os->constraint;
3558 if (os->bfd_section != NULL
3559 && os->bfd_section->owner != NULL)
3561 last_sec = os->bfd_section;
3562 if (first_sec == NULL)
3563 first_sec = last_sec;
3568 if (last_sec != NULL)
3570 asection *sec = where->bfd_section;
3572 sec = output_prev_sec_find (where);
3574 /* The place we want to insert must come after the
3575 sections we are moving. So if we find no
3576 section or if the section is the same as our
3577 last section, then no move is needed. */
3578 if (sec != NULL && sec != last_sec)
3580 /* Trim them off. */
3581 if (first_sec->prev != NULL)
3582 first_sec->prev->next = last_sec->next;
3584 link_info.output_bfd->sections = last_sec->next;
3585 if (last_sec->next != NULL)
3586 last_sec->next->prev = first_sec->prev;
3588 link_info.output_bfd->section_last = first_sec->prev;
3590 last_sec->next = sec->next;
3591 if (sec->next != NULL)
3592 sec->next->prev = last_sec;
3594 link_info.output_bfd->section_last = last_sec;
3595 first_sec->prev = sec;
3596 sec->next = first_sec;
3604 ptr = insert_os_after (where);
3605 /* Snip everything after the abs_section output statement we
3606 know is at the start of the list, up to and including
3607 the insert statement we are currently processing. */
3608 first = lang_output_section_statement.head->header.next;
3609 lang_output_section_statement.head->header.next = (*s)->header.next;
3610 /* Add them back where they belong. */
3613 statement_list.tail = s;
3615 s = &lang_output_section_statement.head;
3619 /* Undo constraint twiddling. */
3620 for (os = first_os; os != NULL; os = os->next)
3622 os->constraint = -2 - os->constraint;
3628 /* An output section might have been removed after its statement was
3629 added. For example, ldemul_before_allocation can remove dynamic
3630 sections if they turn out to be not needed. Clean them up here. */
3633 strip_excluded_output_sections (void)
3635 lang_output_section_statement_type *os;
3637 /* Run lang_size_sections (if not already done). */
3638 if (expld.phase != lang_mark_phase_enum)
3640 expld.phase = lang_mark_phase_enum;
3641 expld.dataseg.phase = exp_dataseg_none;
3642 one_lang_size_sections_pass (NULL, FALSE);
3643 lang_reset_memory_regions ();
3646 for (os = &lang_output_section_statement.head->output_section_statement;
3650 asection *output_section;
3651 bfd_boolean exclude;
3653 if (os->constraint < 0)
3656 output_section = os->bfd_section;
3657 if (output_section == NULL)
3660 exclude = (output_section->rawsize == 0
3661 && (output_section->flags & SEC_KEEP) == 0
3662 && !bfd_section_removed_from_list (link_info.output_bfd,
3665 /* Some sections have not yet been sized, notably .gnu.version,
3666 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3667 input sections, so don't drop output sections that have such
3668 input sections unless they are also marked SEC_EXCLUDE. */
3669 if (exclude && output_section->map_head.s != NULL)
3673 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3674 if ((s->flags & SEC_LINKER_CREATED) != 0
3675 && (s->flags & SEC_EXCLUDE) == 0)
3682 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3683 output_section->map_head.link_order = NULL;
3684 output_section->map_tail.link_order = NULL;
3688 /* We don't set bfd_section to NULL since bfd_section of the
3689 removed output section statement may still be used. */
3690 if (!os->section_relative_symbol
3691 && !os->update_dot_tree)
3693 output_section->flags |= SEC_EXCLUDE;
3694 bfd_section_list_remove (link_info.output_bfd, output_section);
3695 link_info.output_bfd->section_count--;
3699 /* Stop future calls to lang_add_section from messing with map_head
3700 and map_tail link_order fields. */
3701 stripped_excluded_sections = TRUE;
3705 print_output_section_statement
3706 (lang_output_section_statement_type *output_section_statement)
3708 asection *section = output_section_statement->bfd_section;
3711 if (output_section_statement != abs_output_section)
3713 minfo ("\n%s", output_section_statement->name);
3715 if (section != NULL)
3717 print_dot = section->vma;
3719 len = strlen (output_section_statement->name);
3720 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3725 while (len < SECTION_NAME_MAP_LENGTH)
3731 minfo ("0x%V %W", section->vma, section->size);
3733 if (section->vma != section->lma)
3734 minfo (_(" load address 0x%V"), section->lma);
3736 if (output_section_statement->update_dot_tree != NULL)
3737 exp_fold_tree (output_section_statement->update_dot_tree,
3738 bfd_abs_section_ptr, &print_dot);
3744 print_statement_list (output_section_statement->children.head,
3745 output_section_statement);
3748 /* Scan for the use of the destination in the right hand side
3749 of an expression. In such cases we will not compute the
3750 correct expression, since the value of DST that is used on
3751 the right hand side will be its final value, not its value
3752 just before this expression is evaluated. */
3755 scan_for_self_assignment (const char * dst, etree_type * rhs)
3757 if (rhs == NULL || dst == NULL)
3760 switch (rhs->type.node_class)
3763 return scan_for_self_assignment (dst, rhs->binary.lhs)
3764 || scan_for_self_assignment (dst, rhs->binary.rhs);
3767 return scan_for_self_assignment (dst, rhs->trinary.lhs)
3768 || scan_for_self_assignment (dst, rhs->trinary.rhs);
3771 case etree_provided:
3773 if (strcmp (dst, rhs->assign.dst) == 0)
3775 return scan_for_self_assignment (dst, rhs->assign.src);
3778 return scan_for_self_assignment (dst, rhs->unary.child);
3782 return strcmp (dst, rhs->value.str) == 0;
3787 return strcmp (dst, rhs->name.name) == 0;
3799 print_assignment (lang_assignment_statement_type *assignment,
3800 lang_output_section_statement_type *output_section)
3804 bfd_boolean computation_is_valid = TRUE;
3807 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3810 if (assignment->exp->type.node_class == etree_assert)
3813 tree = assignment->exp->assert_s.child;
3814 computation_is_valid = TRUE;
3818 const char *dst = assignment->exp->assign.dst;
3820 is_dot = (dst[0] == '.' && dst[1] == 0);
3821 tree = assignment->exp->assign.src;
3822 computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
3825 exp_fold_tree (tree, output_section->bfd_section, &print_dot);
3826 if (expld.result.valid_p)
3830 if (computation_is_valid)
3832 value = expld.result.value;
3834 if (expld.result.section)
3835 value += expld.result.section->vma;
3837 minfo ("0x%V", value);
3843 struct bfd_link_hash_entry *h;
3845 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3846 FALSE, FALSE, TRUE);
3849 value = h->u.def.value;
3851 if (expld.result.section)
3852 value += expld.result.section->vma;
3854 minfo ("[0x%V]", value);
3857 minfo ("[unresolved]");
3869 exp_print_tree (assignment->exp);
3874 print_input_statement (lang_input_statement_type *statm)
3876 if (statm->filename != NULL
3877 && (statm->the_bfd == NULL
3878 || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
3879 fprintf (config.map_file, "LOAD %s\n", statm->filename);
3882 /* Print all symbols defined in a particular section. This is called
3883 via bfd_link_hash_traverse, or by print_all_symbols. */
3886 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
3888 asection *sec = ptr;
3890 if ((hash_entry->type == bfd_link_hash_defined
3891 || hash_entry->type == bfd_link_hash_defweak)
3892 && sec == hash_entry->u.def.section)
3896 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3899 (hash_entry->u.def.value
3900 + hash_entry->u.def.section->output_offset
3901 + hash_entry->u.def.section->output_section->vma));
3903 minfo (" %T\n", hash_entry->root.string);
3910 print_all_symbols (asection *sec)
3912 struct fat_user_section_struct *ud = get_userdata (sec);
3913 struct map_symbol_def *def;
3918 *ud->map_symbol_def_tail = 0;
3919 for (def = ud->map_symbol_def_head; def; def = def->next)
3920 print_one_symbol (def->entry, sec);
3923 /* Print information about an input section to the map file. */
3926 print_input_section (asection *i)
3928 bfd_size_type size = i->size;
3935 minfo ("%s", i->name);
3937 len = 1 + strlen (i->name);
3938 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3943 while (len < SECTION_NAME_MAP_LENGTH)
3949 if (i->output_section != NULL
3950 && i->output_section->owner == link_info.output_bfd)
3951 addr = i->output_section->vma + i->output_offset;
3958 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
3960 if (size != i->rawsize && i->rawsize != 0)
3962 len = SECTION_NAME_MAP_LENGTH + 3;
3974 minfo (_("%W (size before relaxing)\n"), i->rawsize);
3977 if (i->output_section != NULL
3978 && i->output_section->owner == link_info.output_bfd)
3980 if (link_info.reduce_memory_overheads)
3981 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
3983 print_all_symbols (i);
3985 /* Update print_dot, but make sure that we do not move it
3986 backwards - this could happen if we have overlays and a
3987 later overlay is shorter than an earier one. */
3988 if (addr + TO_ADDR (size) > print_dot)
3989 print_dot = addr + TO_ADDR (size);
3994 print_fill_statement (lang_fill_statement_type *fill)
3998 fputs (" FILL mask 0x", config.map_file);
3999 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4000 fprintf (config.map_file, "%02x", *p);
4001 fputs ("\n", config.map_file);
4005 print_data_statement (lang_data_statement_type *data)
4013 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4016 addr = data->output_offset;
4017 if (data->output_section != NULL)
4018 addr += data->output_section->vma;
4046 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4048 if (data->exp->type.node_class != etree_value)
4051 exp_print_tree (data->exp);
4056 print_dot = addr + TO_ADDR (size);
4059 /* Print an address statement. These are generated by options like
4063 print_address_statement (lang_address_statement_type *address)
4065 minfo (_("Address of section %s set to "), address->section_name);
4066 exp_print_tree (address->address);
4070 /* Print a reloc statement. */
4073 print_reloc_statement (lang_reloc_statement_type *reloc)
4080 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4083 addr = reloc->output_offset;
4084 if (reloc->output_section != NULL)
4085 addr += reloc->output_section->vma;
4087 size = bfd_get_reloc_size (reloc->howto);
4089 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4091 if (reloc->name != NULL)
4092 minfo ("%s+", reloc->name);
4094 minfo ("%s+", reloc->section->name);
4096 exp_print_tree (reloc->addend_exp);
4100 print_dot = addr + TO_ADDR (size);
4104 print_padding_statement (lang_padding_statement_type *s)
4112 len = sizeof " *fill*" - 1;
4113 while (len < SECTION_NAME_MAP_LENGTH)
4119 addr = s->output_offset;
4120 if (s->output_section != NULL)
4121 addr += s->output_section->vma;
4122 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4124 if (s->fill->size != 0)
4128 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4129 fprintf (config.map_file, "%02x", *p);
4134 print_dot = addr + TO_ADDR (s->size);
4138 print_wild_statement (lang_wild_statement_type *w,
4139 lang_output_section_statement_type *os)
4141 struct wildcard_list *sec;
4145 if (w->filenames_sorted)
4147 if (w->filename != NULL)
4148 minfo ("%s", w->filename);
4151 if (w->filenames_sorted)
4155 for (sec = w->section_list; sec; sec = sec->next)
4157 if (sec->spec.sorted)
4159 if (sec->spec.exclude_name_list != NULL)
4162 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4163 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4164 minfo (" %s", tmp->name);
4167 if (sec->spec.name != NULL)
4168 minfo ("%s", sec->spec.name);
4171 if (sec->spec.sorted)
4180 print_statement_list (w->children.head, os);
4183 /* Print a group statement. */
4186 print_group (lang_group_statement_type *s,
4187 lang_output_section_statement_type *os)
4189 fprintf (config.map_file, "START GROUP\n");
4190 print_statement_list (s->children.head, os);
4191 fprintf (config.map_file, "END GROUP\n");
4194 /* Print the list of statements in S.
4195 This can be called for any statement type. */
4198 print_statement_list (lang_statement_union_type *s,
4199 lang_output_section_statement_type *os)
4203 print_statement (s, os);
4208 /* Print the first statement in statement list S.
4209 This can be called for any statement type. */
4212 print_statement (lang_statement_union_type *s,
4213 lang_output_section_statement_type *os)
4215 switch (s->header.type)
4218 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4221 case lang_constructors_statement_enum:
4222 if (constructor_list.head != NULL)
4224 if (constructors_sorted)
4225 minfo (" SORT (CONSTRUCTORS)\n");
4227 minfo (" CONSTRUCTORS\n");
4228 print_statement_list (constructor_list.head, os);
4231 case lang_wild_statement_enum:
4232 print_wild_statement (&s->wild_statement, os);
4234 case lang_address_statement_enum:
4235 print_address_statement (&s->address_statement);
4237 case lang_object_symbols_statement_enum:
4238 minfo (" CREATE_OBJECT_SYMBOLS\n");
4240 case lang_fill_statement_enum:
4241 print_fill_statement (&s->fill_statement);
4243 case lang_data_statement_enum:
4244 print_data_statement (&s->data_statement);
4246 case lang_reloc_statement_enum:
4247 print_reloc_statement (&s->reloc_statement);
4249 case lang_input_section_enum:
4250 print_input_section (s->input_section.section);
4252 case lang_padding_statement_enum:
4253 print_padding_statement (&s->padding_statement);
4255 case lang_output_section_statement_enum:
4256 print_output_section_statement (&s->output_section_statement);
4258 case lang_assignment_statement_enum:
4259 print_assignment (&s->assignment_statement, os);
4261 case lang_target_statement_enum:
4262 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4264 case lang_output_statement_enum:
4265 minfo ("OUTPUT(%s", s->output_statement.name);
4266 if (output_target != NULL)
4267 minfo (" %s", output_target);
4270 case lang_input_statement_enum:
4271 print_input_statement (&s->input_statement);
4273 case lang_group_statement_enum:
4274 print_group (&s->group_statement, os);
4276 case lang_insert_statement_enum:
4277 minfo ("INSERT %s %s\n",
4278 s->insert_statement.is_before ? "BEFORE" : "AFTER",
4279 s->insert_statement.where);
4285 print_statements (void)
4287 print_statement_list (statement_list.head, abs_output_section);
4290 /* Print the first N statements in statement list S to STDERR.
4291 If N == 0, nothing is printed.
4292 If N < 0, the entire list is printed.
4293 Intended to be called from GDB. */
4296 dprint_statement (lang_statement_union_type *s, int n)
4298 FILE *map_save = config.map_file;
4300 config.map_file = stderr;
4303 print_statement_list (s, abs_output_section);
4306 while (s && --n >= 0)
4308 print_statement (s, abs_output_section);
4313 config.map_file = map_save;
4317 insert_pad (lang_statement_union_type **ptr,
4319 unsigned int alignment_needed,
4320 asection *output_section,
4323 static fill_type zero_fill = { 1, { 0 } };
4324 lang_statement_union_type *pad = NULL;
4326 if (ptr != &statement_list.head)
4327 pad = ((lang_statement_union_type *)
4328 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4330 && pad->header.type == lang_padding_statement_enum
4331 && pad->padding_statement.output_section == output_section)
4333 /* Use the existing pad statement. */
4335 else if ((pad = *ptr) != NULL
4336 && pad->header.type == lang_padding_statement_enum
4337 && pad->padding_statement.output_section == output_section)
4339 /* Use the existing pad statement. */
4343 /* Make a new padding statement, linked into existing chain. */
4344 pad = stat_alloc (sizeof (lang_padding_statement_type));
4345 pad->header.next = *ptr;
4347 pad->header.type = lang_padding_statement_enum;
4348 pad->padding_statement.output_section = output_section;
4351 pad->padding_statement.fill = fill;
4353 pad->padding_statement.output_offset = dot - output_section->vma;
4354 pad->padding_statement.size = alignment_needed;
4355 output_section->size += alignment_needed;
4358 /* Work out how much this section will move the dot point. */
4362 (lang_statement_union_type **this_ptr,
4363 lang_output_section_statement_type *output_section_statement,
4367 lang_input_section_type *is = &((*this_ptr)->input_section);
4368 asection *i = is->section;
4370 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4371 && (i->flags & SEC_EXCLUDE) == 0)
4373 unsigned int alignment_needed;
4376 /* Align this section first to the input sections requirement,
4377 then to the output section's requirement. If this alignment
4378 is greater than any seen before, then record it too. Perform
4379 the alignment by inserting a magic 'padding' statement. */
4381 if (output_section_statement->subsection_alignment != -1)
4382 i->alignment_power = output_section_statement->subsection_alignment;
4384 o = output_section_statement->bfd_section;
4385 if (o->alignment_power < i->alignment_power)
4386 o->alignment_power = i->alignment_power;
4388 alignment_needed = align_power (dot, i->alignment_power) - dot;
4390 if (alignment_needed != 0)
4392 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4393 dot += alignment_needed;
4396 /* Remember where in the output section this input section goes. */
4398 i->output_offset = dot - o->vma;
4400 /* Mark how big the output section must be to contain this now. */
4401 dot += TO_ADDR (i->size);
4402 o->size = TO_SIZE (dot - o->vma);
4406 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4413 sort_sections_by_lma (const void *arg1, const void *arg2)
4415 const asection *sec1 = *(const asection **) arg1;
4416 const asection *sec2 = *(const asection **) arg2;
4418 if (bfd_section_lma (sec1->owner, sec1)
4419 < bfd_section_lma (sec2->owner, sec2))
4421 else if (bfd_section_lma (sec1->owner, sec1)
4422 > bfd_section_lma (sec2->owner, sec2))
4424 else if (sec1->id < sec2->id)
4426 else if (sec1->id > sec2->id)
4432 #define IGNORE_SECTION(s) \
4433 ((s->flags & SEC_NEVER_LOAD) != 0 \
4434 || (s->flags & SEC_ALLOC) == 0 \
4435 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4436 && (s->flags & SEC_LOAD) == 0))
4438 /* Check to see if any allocated sections overlap with other allocated
4439 sections. This can happen if a linker script specifies the output
4440 section addresses of the two sections. Also check whether any memory
4441 region has overflowed. */
4444 lang_check_section_addresses (void)
4447 asection **sections, **spp;
4454 lang_memory_region_type *m;
4456 if (bfd_count_sections (link_info.output_bfd) <= 1)
4459 amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4460 sections = xmalloc (amt);
4462 /* Scan all sections in the output list. */
4464 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4466 /* Only consider loadable sections with real contents. */
4467 if (IGNORE_SECTION (s) || s->size == 0)
4470 sections[count] = s;
4477 qsort (sections, (size_t) count, sizeof (asection *),
4478 sort_sections_by_lma);
4482 s_start = bfd_section_lma (link_info.output_bfd, s);
4483 s_end = s_start + TO_ADDR (s->size) - 1;
4484 for (count--; count; count--)
4486 /* We must check the sections' LMA addresses not their VMA
4487 addresses because overlay sections can have overlapping VMAs
4488 but they must have distinct LMAs. */
4493 s_start = bfd_section_lma (link_info.output_bfd, s);
4494 s_end = s_start + TO_ADDR (s->size) - 1;
4496 /* Look for an overlap. */
4497 if (s_end >= os_start && s_start <= os_end)
4498 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4499 s->name, s_start, s_end, os->name, os_start, os_end);
4504 /* If any memory region has overflowed, report by how much.
4505 We do not issue this diagnostic for regions that had sections
4506 explicitly placed outside their bounds; os_region_check's
4507 diagnostics are adequate for that case.
4509 FIXME: It is conceivable that m->current - (m->origin + m->length)
4510 might overflow a 32-bit integer. There is, alas, no way to print
4511 a bfd_vma quantity in decimal. */
4512 for (m = lang_memory_region_list; m; m = m->next)
4513 if (m->had_full_message)
4514 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4515 m->name_list.name, (long)(m->current - (m->origin + m->length)));
4519 /* Make sure the new address is within the region. We explicitly permit the
4520 current address to be at the exact end of the region when the address is
4521 non-zero, in case the region is at the end of addressable memory and the
4522 calculation wraps around. */
4525 os_region_check (lang_output_section_statement_type *os,
4526 lang_memory_region_type *region,
4530 if ((region->current < region->origin
4531 || (region->current - region->origin > region->length))
4532 && ((region->current != region->origin + region->length)
4537 einfo (_("%X%P: address 0x%v of %B section `%s'"
4538 " is not within region `%s'\n"),
4540 os->bfd_section->owner,
4541 os->bfd_section->name,
4542 region->name_list.name);
4544 else if (!region->had_full_message)
4546 region->had_full_message = TRUE;
4548 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4549 os->bfd_section->owner,
4550 os->bfd_section->name,
4551 region->name_list.name);
4556 /* Set the sizes for all the output sections. */
4559 lang_size_sections_1
4560 (lang_statement_union_type *s,
4561 lang_output_section_statement_type *output_section_statement,
4562 lang_statement_union_type **prev,
4566 bfd_boolean check_regions)
4568 /* Size up the sections from their constituent parts. */
4569 for (; s != NULL; s = s->header.next)
4571 switch (s->header.type)
4573 case lang_output_section_statement_enum:
4575 bfd_vma newdot, after;
4576 lang_output_section_statement_type *os;
4577 lang_memory_region_type *r;
4579 os = &s->output_section_statement;
4580 if (os->addr_tree != NULL)
4582 os->processed_vma = FALSE;
4583 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4585 if (expld.result.valid_p)
4586 dot = expld.result.value + expld.result.section->vma;
4587 else if (expld.phase != lang_mark_phase_enum)
4588 einfo (_("%F%S: non constant or forward reference"
4589 " address expression for section %s\n"),
4593 if (os->bfd_section == NULL)
4594 /* This section was removed or never actually created. */
4597 /* If this is a COFF shared library section, use the size and
4598 address from the input section. FIXME: This is COFF
4599 specific; it would be cleaner if there were some other way
4600 to do this, but nothing simple comes to mind. */
4601 if (((bfd_get_flavour (link_info.output_bfd)
4602 == bfd_target_ecoff_flavour)
4603 || (bfd_get_flavour (link_info.output_bfd)
4604 == bfd_target_coff_flavour))
4605 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4609 if (os->children.head == NULL
4610 || os->children.head->header.next != NULL
4611 || (os->children.head->header.type
4612 != lang_input_section_enum))
4613 einfo (_("%P%X: Internal error on COFF shared library"
4614 " section %s\n"), os->name);
4616 input = os->children.head->input_section.section;
4617 bfd_set_section_vma (os->bfd_section->owner,
4619 bfd_section_vma (input->owner, input));
4620 os->bfd_section->size = input->size;
4625 if (bfd_is_abs_section (os->bfd_section))
4627 /* No matter what happens, an abs section starts at zero. */
4628 ASSERT (os->bfd_section->vma == 0);
4634 if (os->addr_tree == NULL)
4636 /* No address specified for this section, get one
4637 from the region specification. */
4638 if (os->region == NULL
4639 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4640 && os->region->name_list.name[0] == '*'
4641 && strcmp (os->region->name_list.name,
4642 DEFAULT_MEMORY_REGION) == 0))
4644 os->region = lang_memory_default (os->bfd_section);
4647 /* If a loadable section is using the default memory
4648 region, and some non default memory regions were
4649 defined, issue an error message. */
4651 && !IGNORE_SECTION (os->bfd_section)
4652 && ! link_info.relocatable
4654 && strcmp (os->region->name_list.name,
4655 DEFAULT_MEMORY_REGION) == 0
4656 && lang_memory_region_list != NULL
4657 && (strcmp (lang_memory_region_list->name_list.name,
4658 DEFAULT_MEMORY_REGION) != 0
4659 || lang_memory_region_list->next != NULL)
4660 && expld.phase != lang_mark_phase_enum)
4662 /* By default this is an error rather than just a
4663 warning because if we allocate the section to the
4664 default memory region we can end up creating an
4665 excessively large binary, or even seg faulting when
4666 attempting to perform a negative seek. See
4667 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4668 for an example of this. This behaviour can be
4669 overridden by the using the --no-check-sections
4671 if (command_line.check_section_addresses)
4672 einfo (_("%P%F: error: no memory region specified"
4673 " for loadable section `%s'\n"),
4674 bfd_get_section_name (link_info.output_bfd,
4677 einfo (_("%P: warning: no memory region specified"
4678 " for loadable section `%s'\n"),
4679 bfd_get_section_name (link_info.output_bfd,
4683 newdot = os->region->current;
4684 align = os->bfd_section->alignment_power;
4687 align = os->section_alignment;
4689 /* Align to what the section needs. */
4692 bfd_vma savedot = newdot;
4693 newdot = align_power (newdot, align);
4695 if (newdot != savedot
4696 && (config.warn_section_align
4697 || os->addr_tree != NULL)
4698 && expld.phase != lang_mark_phase_enum)
4699 einfo (_("%P: warning: changing start of section"
4700 " %s by %lu bytes\n"),
4701 os->name, (unsigned long) (newdot - savedot));
4704 /* PR 6945: Do not update the vma's of output sections
4705 when performing a relocatable link on COFF objects. */
4706 if (! link_info.relocatable
4707 || (bfd_get_flavour (link_info.output_bfd)
4708 != bfd_target_coff_flavour))
4709 bfd_set_section_vma (0, os->bfd_section, newdot);
4711 os->bfd_section->output_offset = 0;
4714 lang_size_sections_1 (os->children.head, os, &os->children.head,
4715 os->fill, newdot, relax, check_regions);
4717 os->processed_vma = TRUE;
4719 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4720 /* Except for some special linker created sections,
4721 no output section should change from zero size
4722 after strip_excluded_output_sections. A non-zero
4723 size on an ignored section indicates that some
4724 input section was not sized early enough. */
4725 ASSERT (os->bfd_section->size == 0);
4728 dot = os->bfd_section->vma;
4730 /* Put the section within the requested block size, or
4731 align at the block boundary. */
4733 + TO_ADDR (os->bfd_section->size)
4734 + os->block_value - 1)
4735 & - (bfd_vma) os->block_value);
4737 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4740 /* Set section lma. */
4743 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4747 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4748 os->bfd_section->lma = lma;
4750 else if (os->lma_region != NULL)
4752 bfd_vma lma = os->lma_region->current;
4754 if (os->section_alignment != -1)
4755 lma = align_power (lma, os->section_alignment);
4756 os->bfd_section->lma = lma;
4758 else if (r->last_os != NULL
4759 && (os->bfd_section->flags & SEC_ALLOC) != 0)
4764 last = r->last_os->output_section_statement.bfd_section;
4766 /* A backwards move of dot should be accompanied by
4767 an explicit assignment to the section LMA (ie.
4768 os->load_base set) because backwards moves can
4769 create overlapping LMAs. */
4771 && os->bfd_section->size != 0
4772 && dot + os->bfd_section->size <= last->vma)
4774 /* If dot moved backwards then leave lma equal to
4775 vma. This is the old default lma, which might
4776 just happen to work when the backwards move is
4777 sufficiently large. Nag if this changes anything,
4778 so people can fix their linker scripts. */
4780 if (last->vma != last->lma)
4781 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4786 /* If this is an overlay, set the current lma to that
4787 at the end of the previous section. */
4788 if (os->sectype == overlay_section)
4789 lma = last->lma + last->size;
4791 /* Otherwise, keep the same lma to vma relationship
4792 as the previous section. */
4794 lma = dot + last->lma - last->vma;
4796 if (os->section_alignment != -1)
4797 lma = align_power (lma, os->section_alignment);
4798 os->bfd_section->lma = lma;
4801 os->processed_lma = TRUE;
4803 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4806 /* Keep track of normal sections using the default
4807 lma region. We use this to set the lma for
4808 following sections. Overlays or other linker
4809 script assignment to lma might mean that the
4810 default lma == vma is incorrect.
4811 To avoid warnings about dot moving backwards when using
4812 -Ttext, don't start tracking sections until we find one
4813 of non-zero size or with lma set differently to vma. */
4814 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4815 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4816 && (os->bfd_section->flags & SEC_ALLOC) != 0
4817 && (os->bfd_section->size != 0
4818 || (r->last_os == NULL
4819 && os->bfd_section->vma != os->bfd_section->lma)
4820 || (r->last_os != NULL
4821 && dot >= (r->last_os->output_section_statement
4822 .bfd_section->vma)))
4823 && os->lma_region == NULL
4824 && !link_info.relocatable)
4827 /* .tbss sections effectively have zero size. */
4828 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4829 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4830 || link_info.relocatable)
4831 dot += TO_ADDR (os->bfd_section->size);
4833 if (os->update_dot_tree != 0)
4834 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4836 /* Update dot in the region ?
4837 We only do this if the section is going to be allocated,
4838 since unallocated sections do not contribute to the region's
4839 overall size in memory.
4841 If the SEC_NEVER_LOAD bit is not set, it will affect the
4842 addresses of sections after it. We have to update
4844 if (os->region != NULL
4845 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4846 || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4848 os->region->current = dot;
4851 /* Make sure the new address is within the region. */
4852 os_region_check (os, os->region, os->addr_tree,
4853 os->bfd_section->vma);
4855 if (os->lma_region != NULL && os->lma_region != os->region
4856 && (os->bfd_section->flags & SEC_LOAD))
4858 os->lma_region->current
4859 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
4862 os_region_check (os, os->lma_region, NULL,
4863 os->bfd_section->lma);
4869 case lang_constructors_statement_enum:
4870 dot = lang_size_sections_1 (constructor_list.head,
4871 output_section_statement,
4872 &s->wild_statement.children.head,
4873 fill, dot, relax, check_regions);
4876 case lang_data_statement_enum:
4878 unsigned int size = 0;
4880 s->data_statement.output_offset =
4881 dot - output_section_statement->bfd_section->vma;
4882 s->data_statement.output_section =
4883 output_section_statement->bfd_section;
4885 /* We might refer to provided symbols in the expression, and
4886 need to mark them as needed. */
4887 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4889 switch (s->data_statement.type)
4907 if (size < TO_SIZE ((unsigned) 1))
4908 size = TO_SIZE ((unsigned) 1);
4909 dot += TO_ADDR (size);
4910 output_section_statement->bfd_section->size += size;
4914 case lang_reloc_statement_enum:
4918 s->reloc_statement.output_offset =
4919 dot - output_section_statement->bfd_section->vma;
4920 s->reloc_statement.output_section =
4921 output_section_statement->bfd_section;
4922 size = bfd_get_reloc_size (s->reloc_statement.howto);
4923 dot += TO_ADDR (size);
4924 output_section_statement->bfd_section->size += size;
4928 case lang_wild_statement_enum:
4929 dot = lang_size_sections_1 (s->wild_statement.children.head,
4930 output_section_statement,
4931 &s->wild_statement.children.head,
4932 fill, dot, relax, check_regions);
4935 case lang_object_symbols_statement_enum:
4936 link_info.create_object_symbols_section =
4937 output_section_statement->bfd_section;
4940 case lang_output_statement_enum:
4941 case lang_target_statement_enum:
4944 case lang_input_section_enum:
4948 i = (*prev)->input_section.section;
4953 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4954 einfo (_("%P%F: can't relax section: %E\n"));
4958 dot = size_input_section (prev, output_section_statement,
4959 output_section_statement->fill, dot);
4963 case lang_input_statement_enum:
4966 case lang_fill_statement_enum:
4967 s->fill_statement.output_section =
4968 output_section_statement->bfd_section;
4970 fill = s->fill_statement.fill;
4973 case lang_assignment_statement_enum:
4975 bfd_vma newdot = dot;
4976 etree_type *tree = s->assignment_statement.exp;
4978 expld.dataseg.relro = exp_dataseg_relro_none;
4980 exp_fold_tree (tree,
4981 output_section_statement->bfd_section,
4984 if (expld.dataseg.relro == exp_dataseg_relro_start)
4986 if (!expld.dataseg.relro_start_stat)
4987 expld.dataseg.relro_start_stat = s;
4990 ASSERT (expld.dataseg.relro_start_stat == s);
4993 else if (expld.dataseg.relro == exp_dataseg_relro_end)
4995 if (!expld.dataseg.relro_end_stat)
4996 expld.dataseg.relro_end_stat = s;
4999 ASSERT (expld.dataseg.relro_end_stat == s);
5002 expld.dataseg.relro = exp_dataseg_relro_none;
5004 /* This symbol is relative to this section. */
5005 if ((tree->type.node_class == etree_provided
5006 || tree->type.node_class == etree_assign)
5007 && (tree->assign.dst [0] != '.'
5008 || tree->assign.dst [1] != '\0'))
5009 output_section_statement->section_relative_symbol = 1;
5011 if (!output_section_statement->ignored)
5013 if (output_section_statement == abs_output_section)
5015 /* If we don't have an output section, then just adjust
5016 the default memory address. */
5017 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5018 FALSE)->current = newdot;
5020 else if (newdot != dot)
5022 /* Insert a pad after this statement. We can't
5023 put the pad before when relaxing, in case the
5024 assignment references dot. */
5025 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5026 output_section_statement->bfd_section, dot);
5028 /* Don't neuter the pad below when relaxing. */
5031 /* If dot is advanced, this implies that the section
5032 should have space allocated to it, unless the
5033 user has explicitly stated that the section
5034 should never be loaded. */
5035 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
5036 output_section_statement->bfd_section->flags |= SEC_ALLOC;
5043 case lang_padding_statement_enum:
5044 /* If this is the first time lang_size_sections is called,
5045 we won't have any padding statements. If this is the
5046 second or later passes when relaxing, we should allow
5047 padding to shrink. If padding is needed on this pass, it
5048 will be added back in. */
5049 s->padding_statement.size = 0;
5051 /* Make sure output_offset is valid. If relaxation shrinks
5052 the section and this pad isn't needed, it's possible to
5053 have output_offset larger than the final size of the
5054 section. bfd_set_section_contents will complain even for
5055 a pad size of zero. */
5056 s->padding_statement.output_offset
5057 = dot - output_section_statement->bfd_section->vma;
5060 case lang_group_statement_enum:
5061 dot = lang_size_sections_1 (s->group_statement.children.head,
5062 output_section_statement,
5063 &s->group_statement.children.head,
5064 fill, dot, relax, check_regions);
5067 case lang_insert_statement_enum:
5070 /* We can only get here when relaxing is turned on. */
5071 case lang_address_statement_enum:
5078 prev = &s->header.next;
5083 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5084 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5085 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5086 segments. We are allowed an opportunity to override this decision. */
5089 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5090 bfd * abfd ATTRIBUTE_UNUSED,
5091 asection * current_section,
5092 asection * previous_section,
5093 bfd_boolean new_segment)
5095 lang_output_section_statement_type * cur;
5096 lang_output_section_statement_type * prev;
5098 /* The checks below are only necessary when the BFD library has decided
5099 that the two sections ought to be placed into the same segment. */
5103 /* Paranoia checks. */
5104 if (current_section == NULL || previous_section == NULL)
5107 /* Find the memory regions associated with the two sections.
5108 We call lang_output_section_find() here rather than scanning the list
5109 of output sections looking for a matching section pointer because if
5110 we have a large number of sections then a hash lookup is faster. */
5111 cur = lang_output_section_find (current_section->name);
5112 prev = lang_output_section_find (previous_section->name);
5114 /* More paranoia. */
5115 if (cur == NULL || prev == NULL)
5118 /* If the regions are different then force the sections to live in
5119 different segments. See the email thread starting at the following
5120 URL for the reasons why this is necessary:
5121 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5122 return cur->region != prev->region;
5126 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5128 lang_statement_iteration++;
5129 lang_size_sections_1 (statement_list.head, abs_output_section,
5130 &statement_list.head, 0, 0, relax, check_regions);
5134 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5136 expld.phase = lang_allocating_phase_enum;
5137 expld.dataseg.phase = exp_dataseg_none;
5139 one_lang_size_sections_pass (relax, check_regions);
5140 if (expld.dataseg.phase == exp_dataseg_end_seen
5141 && link_info.relro && expld.dataseg.relro_end)
5143 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5144 to put expld.dataseg.relro on a (common) page boundary. */
5145 bfd_vma min_base, old_base, relro_end, maxpage;
5147 expld.dataseg.phase = exp_dataseg_relro_adjust;
5148 maxpage = expld.dataseg.maxpagesize;
5149 /* MIN_BASE is the absolute minimum address we are allowed to start the
5150 read-write segment (byte before will be mapped read-only). */
5151 min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5152 /* OLD_BASE is the address for a feasible minimum address which will
5153 still not cause a data overlap inside MAXPAGE causing file offset skip
5155 old_base = expld.dataseg.base;
5156 expld.dataseg.base += (-expld.dataseg.relro_end
5157 & (expld.dataseg.pagesize - 1));
5158 /* Compute the expected PT_GNU_RELRO segment end. */
5159 relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5160 & ~(expld.dataseg.pagesize - 1));
5161 if (min_base + maxpage < expld.dataseg.base)
5163 expld.dataseg.base -= maxpage;
5164 relro_end -= maxpage;
5166 lang_reset_memory_regions ();
5167 one_lang_size_sections_pass (relax, check_regions);
5168 if (expld.dataseg.relro_end > relro_end)
5170 /* The alignment of sections between DATA_SEGMENT_ALIGN
5171 and DATA_SEGMENT_RELRO_END caused huge padding to be
5172 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5173 that the section alignments will fit in. */
5175 unsigned int max_alignment_power = 0;
5177 /* Find maximum alignment power of sections between
5178 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5179 for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5180 if (sec->vma >= expld.dataseg.base
5181 && sec->vma < expld.dataseg.relro_end
5182 && sec->alignment_power > max_alignment_power)
5183 max_alignment_power = sec->alignment_power;
5185 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5187 if (expld.dataseg.base - (1 << max_alignment_power) < old_base)
5188 expld.dataseg.base += expld.dataseg.pagesize;
5189 expld.dataseg.base -= (1 << max_alignment_power);
5190 lang_reset_memory_regions ();
5191 one_lang_size_sections_pass (relax, check_regions);
5194 link_info.relro_start = expld.dataseg.base;
5195 link_info.relro_end = expld.dataseg.relro_end;
5197 else if (expld.dataseg.phase == exp_dataseg_end_seen)
5199 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5200 a page could be saved in the data segment. */
5201 bfd_vma first, last;
5203 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5204 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5206 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5207 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5208 && first + last <= expld.dataseg.pagesize)
5210 expld.dataseg.phase = exp_dataseg_adjust;
5211 lang_reset_memory_regions ();
5212 one_lang_size_sections_pass (relax, check_regions);
5216 expld.phase = lang_final_phase_enum;
5219 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5222 lang_do_assignments_1 (lang_statement_union_type *s,
5223 lang_output_section_statement_type *current_os,
5227 for (; s != NULL; s = s->header.next)
5229 switch (s->header.type)
5231 case lang_constructors_statement_enum:
5232 dot = lang_do_assignments_1 (constructor_list.head,
5233 current_os, fill, dot);
5236 case lang_output_section_statement_enum:
5238 lang_output_section_statement_type *os;
5240 os = &(s->output_section_statement);
5241 if (os->bfd_section != NULL && !os->ignored)
5243 dot = os->bfd_section->vma;
5245 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5247 /* .tbss sections effectively have zero size. */
5248 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5249 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5250 || link_info.relocatable)
5251 dot += TO_ADDR (os->bfd_section->size);
5253 if (os->update_dot_tree != NULL)
5254 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5259 case lang_wild_statement_enum:
5261 dot = lang_do_assignments_1 (s->wild_statement.children.head,
5262 current_os, fill, dot);
5265 case lang_object_symbols_statement_enum:
5266 case lang_output_statement_enum:
5267 case lang_target_statement_enum:
5270 case lang_data_statement_enum:
5271 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5272 if (expld.result.valid_p)
5273 s->data_statement.value = (expld.result.value
5274 + expld.result.section->vma);
5276 einfo (_("%F%P: invalid data statement\n"));
5279 switch (s->data_statement.type)
5297 if (size < TO_SIZE ((unsigned) 1))
5298 size = TO_SIZE ((unsigned) 1);
5299 dot += TO_ADDR (size);
5303 case lang_reloc_statement_enum:
5304 exp_fold_tree (s->reloc_statement.addend_exp,
5305 bfd_abs_section_ptr, &dot);
5306 if (expld.result.valid_p)
5307 s->reloc_statement.addend_value = expld.result.value;
5309 einfo (_("%F%P: invalid reloc statement\n"));
5310 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5313 case lang_input_section_enum:
5315 asection *in = s->input_section.section;
5317 if ((in->flags & SEC_EXCLUDE) == 0)
5318 dot += TO_ADDR (in->size);
5322 case lang_input_statement_enum:
5325 case lang_fill_statement_enum:
5326 fill = s->fill_statement.fill;
5329 case lang_assignment_statement_enum:
5330 exp_fold_tree (s->assignment_statement.exp,
5331 current_os->bfd_section,
5335 case lang_padding_statement_enum:
5336 dot += TO_ADDR (s->padding_statement.size);
5339 case lang_group_statement_enum:
5340 dot = lang_do_assignments_1 (s->group_statement.children.head,
5341 current_os, fill, dot);
5344 case lang_insert_statement_enum:
5347 case lang_address_statement_enum:
5359 lang_do_assignments (void)
5361 lang_statement_iteration++;
5362 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5365 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5366 operator .startof. (section_name), it produces an undefined symbol
5367 .startof.section_name. Similarly, when it sees
5368 .sizeof. (section_name), it produces an undefined symbol
5369 .sizeof.section_name. For all the output sections, we look for
5370 such symbols, and set them to the correct value. */
5373 lang_set_startof (void)
5377 if (link_info.relocatable)
5380 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5382 const char *secname;
5384 struct bfd_link_hash_entry *h;
5386 secname = bfd_get_section_name (link_info.output_bfd, s);
5387 buf = xmalloc (10 + strlen (secname));
5389 sprintf (buf, ".startof.%s", secname);
5390 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5391 if (h != NULL && h->type == bfd_link_hash_undefined)
5393 h->type = bfd_link_hash_defined;
5394 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5395 h->u.def.section = bfd_abs_section_ptr;
5398 sprintf (buf, ".sizeof.%s", secname);
5399 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5400 if (h != NULL && h->type == bfd_link_hash_undefined)
5402 h->type = bfd_link_hash_defined;
5403 h->u.def.value = TO_ADDR (s->size);
5404 h->u.def.section = bfd_abs_section_ptr;
5414 struct bfd_link_hash_entry *h;
5417 if ((link_info.relocatable && !link_info.gc_sections)
5418 || (link_info.shared && !link_info.executable))
5419 warn = entry_from_cmdline;
5423 /* Force the user to specify a root when generating a relocatable with
5425 if (link_info.gc_sections && link_info.relocatable
5426 && (entry_symbol.name == NULL
5427 && ldlang_undef_chain_list_head == NULL))
5428 einfo (_("%P%F: gc-sections requires either an entry or "
5429 "an undefined symbol\n"));
5431 if (entry_symbol.name == NULL)
5433 /* No entry has been specified. Look for the default entry, but
5434 don't warn if we don't find it. */
5435 entry_symbol.name = entry_symbol_default;
5439 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5440 FALSE, FALSE, TRUE);
5442 && (h->type == bfd_link_hash_defined
5443 || h->type == bfd_link_hash_defweak)
5444 && h->u.def.section->output_section != NULL)
5448 val = (h->u.def.value
5449 + bfd_get_section_vma (link_info.output_bfd,
5450 h->u.def.section->output_section)
5451 + h->u.def.section->output_offset);
5452 if (! bfd_set_start_address (link_info.output_bfd, val))
5453 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5460 /* We couldn't find the entry symbol. Try parsing it as a
5462 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5465 if (! bfd_set_start_address (link_info.output_bfd, val))
5466 einfo (_("%P%F: can't set start address\n"));
5472 /* Can't find the entry symbol, and it's not a number. Use
5473 the first address in the text section. */
5474 ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5478 einfo (_("%P: warning: cannot find entry symbol %s;"
5479 " defaulting to %V\n"),
5481 bfd_get_section_vma (link_info.output_bfd, ts));
5482 if (!(bfd_set_start_address
5483 (link_info.output_bfd,
5484 bfd_get_section_vma (link_info.output_bfd, ts))))
5485 einfo (_("%P%F: can't set start address\n"));
5490 einfo (_("%P: warning: cannot find entry symbol %s;"
5491 " not setting start address\n"),
5497 /* Don't bfd_hash_table_free (&lang_definedness_table);
5498 map file output may result in a call of lang_track_definedness. */
5501 /* This is a small function used when we want to ignore errors from
5505 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5507 /* Don't do anything. */
5510 /* Check that the architecture of all the input files is compatible
5511 with the output file. Also call the backend to let it do any
5512 other checking that is needed. */
5517 lang_statement_union_type *file;
5519 const bfd_arch_info_type *compatible;
5521 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5523 input_bfd = file->input_statement.the_bfd;
5525 = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5526 command_line.accept_unknown_input_arch);
5528 /* In general it is not possible to perform a relocatable
5529 link between differing object formats when the input
5530 file has relocations, because the relocations in the
5531 input format may not have equivalent representations in
5532 the output format (and besides BFD does not translate
5533 relocs for other link purposes than a final link). */
5534 if ((link_info.relocatable || link_info.emitrelocations)
5535 && (compatible == NULL
5536 || (bfd_get_flavour (input_bfd)
5537 != bfd_get_flavour (link_info.output_bfd)))
5538 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5540 einfo (_("%P%F: Relocatable linking with relocations from"
5541 " format %s (%B) to format %s (%B) is not supported\n"),
5542 bfd_get_target (input_bfd), input_bfd,
5543 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5544 /* einfo with %F exits. */
5547 if (compatible == NULL)
5549 if (command_line.warn_mismatch)
5550 einfo (_("%P%X: %s architecture of input file `%B'"
5551 " is incompatible with %s output\n"),
5552 bfd_printable_name (input_bfd), input_bfd,
5553 bfd_printable_name (link_info.output_bfd));
5555 else if (bfd_count_sections (input_bfd))
5557 /* If the input bfd has no contents, it shouldn't set the
5558 private data of the output bfd. */
5560 bfd_error_handler_type pfn = NULL;
5562 /* If we aren't supposed to warn about mismatched input
5563 files, temporarily set the BFD error handler to a
5564 function which will do nothing. We still want to call
5565 bfd_merge_private_bfd_data, since it may set up
5566 information which is needed in the output file. */
5567 if (! command_line.warn_mismatch)
5568 pfn = bfd_set_error_handler (ignore_bfd_errors);
5569 if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5571 if (command_line.warn_mismatch)
5572 einfo (_("%P%X: failed to merge target specific data"
5573 " of file %B\n"), input_bfd);
5575 if (! command_line.warn_mismatch)
5576 bfd_set_error_handler (pfn);
5581 /* Look through all the global common symbols and attach them to the
5582 correct section. The -sort-common command line switch may be used
5583 to roughly sort the entries by alignment. */
5588 if (command_line.inhibit_common_definition)
5590 if (link_info.relocatable
5591 && ! command_line.force_common_definition)
5594 if (! config.sort_common)
5595 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5600 if (config.sort_common == sort_descending)
5602 for (power = 4; power > 0; power--)
5603 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5606 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5610 for (power = 0; power <= 4; power++)
5611 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5614 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5619 /* Place one common symbol in the correct section. */
5622 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5624 unsigned int power_of_two;
5628 if (h->type != bfd_link_hash_common)
5632 power_of_two = h->u.c.p->alignment_power;
5634 if (config.sort_common == sort_descending
5635 && power_of_two < *(unsigned int *) info)
5637 else if (config.sort_common == sort_ascending
5638 && power_of_two > *(unsigned int *) info)
5641 section = h->u.c.p->section;
5642 if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
5643 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5646 if (config.map_file != NULL)
5648 static bfd_boolean header_printed;
5653 if (! header_printed)
5655 minfo (_("\nAllocating common symbols\n"));
5656 minfo (_("Common symbol size file\n\n"));
5657 header_printed = TRUE;
5660 name = bfd_demangle (link_info.output_bfd, h->root.string,
5661 DMGL_ANSI | DMGL_PARAMS);
5664 minfo ("%s", h->root.string);
5665 len = strlen (h->root.string);
5670 len = strlen (name);
5686 if (size <= 0xffffffff)
5687 sprintf (buf, "%lx", (unsigned long) size);
5689 sprintf_vma (buf, size);
5699 minfo ("%B\n", section->owner);
5705 /* Run through the input files and ensure that every input section has
5706 somewhere to go. If one is found without a destination then create
5707 an input request and place it into the statement tree. */
5710 lang_place_orphans (void)
5712 LANG_FOR_EACH_INPUT_STATEMENT (file)
5716 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5718 if (s->output_section == NULL)
5720 /* This section of the file is not attached, root
5721 around for a sensible place for it to go. */
5723 if (file->just_syms_flag)
5724 bfd_link_just_syms (file->the_bfd, s, &link_info);
5725 else if ((s->flags & SEC_EXCLUDE) != 0)
5726 s->output_section = bfd_abs_section_ptr;
5727 else if (strcmp (s->name, "COMMON") == 0)
5729 /* This is a lonely common section which must have
5730 come from an archive. We attach to the section
5731 with the wildcard. */
5732 if (! link_info.relocatable
5733 || command_line.force_common_definition)
5735 if (default_common_section == NULL)
5736 default_common_section
5737 = lang_output_section_statement_lookup (".bss", 0,
5739 lang_add_section (&default_common_section->children, s,
5740 default_common_section);
5745 const char *name = s->name;
5748 if (config.unique_orphan_sections || unique_section_p (s))
5749 constraint = SPECIAL;
5751 if (!ldemul_place_orphan (s, name, constraint))
5753 lang_output_section_statement_type *os;
5754 os = lang_output_section_statement_lookup (name,
5757 lang_add_section (&os->children, s, os);
5766 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5768 flagword *ptr_flags;
5770 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5776 *ptr_flags |= SEC_ALLOC;
5780 *ptr_flags |= SEC_READONLY;
5784 *ptr_flags |= SEC_DATA;
5788 *ptr_flags |= SEC_CODE;
5793 *ptr_flags |= SEC_LOAD;
5797 einfo (_("%P%F: invalid syntax in flags\n"));
5804 /* Call a function on each input file. This function will be called
5805 on an archive, but not on the elements. */
5808 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5810 lang_input_statement_type *f;
5812 for (f = (lang_input_statement_type *) input_file_chain.head;
5814 f = (lang_input_statement_type *) f->next_real_file)
5818 /* Call a function on each file. The function will be called on all
5819 the elements of an archive which are included in the link, but will
5820 not be called on the archive file itself. */
5823 lang_for_each_file (void (*func) (lang_input_statement_type *))
5825 LANG_FOR_EACH_INPUT_STATEMENT (f)
5832 ldlang_add_file (lang_input_statement_type *entry)
5834 lang_statement_append (&file_chain,
5835 (lang_statement_union_type *) entry,
5838 /* The BFD linker needs to have a list of all input BFDs involved in
5840 ASSERT (entry->the_bfd->link_next == NULL);
5841 ASSERT (entry->the_bfd != link_info.output_bfd);
5843 *link_info.input_bfds_tail = entry->the_bfd;
5844 link_info.input_bfds_tail = &entry->the_bfd->link_next;
5845 entry->the_bfd->usrdata = entry;
5846 bfd_set_gp_size (entry->the_bfd, g_switch_value);
5848 /* Look through the sections and check for any which should not be
5849 included in the link. We need to do this now, so that we can
5850 notice when the backend linker tries to report multiple
5851 definition errors for symbols which are in sections we aren't
5852 going to link. FIXME: It might be better to entirely ignore
5853 symbols which are defined in sections which are going to be
5854 discarded. This would require modifying the backend linker for
5855 each backend which might set the SEC_LINK_ONCE flag. If we do
5856 this, we should probably handle SEC_EXCLUDE in the same way. */
5858 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5862 lang_add_output (const char *name, int from_script)
5864 /* Make -o on command line override OUTPUT in script. */
5865 if (!had_output_filename || !from_script)
5867 output_filename = name;
5868 had_output_filename = TRUE;
5872 static lang_output_section_statement_type *current_section;
5883 for (l = 0; l < 32; l++)
5885 if (i >= (unsigned int) x)
5893 lang_output_section_statement_type *
5894 lang_enter_output_section_statement (const char *output_section_statement_name,
5895 etree_type *address_exp,
5896 enum section_type sectype,
5898 etree_type *subalign,
5902 lang_output_section_statement_type *os;
5904 os = lang_output_section_statement_lookup (output_section_statement_name,
5906 current_section = os;
5908 if (os->addr_tree == NULL)
5910 os->addr_tree = address_exp;
5912 os->sectype = sectype;
5913 if (sectype != noload_section)
5914 os->flags = SEC_NO_FLAGS;
5916 os->flags = SEC_NEVER_LOAD;
5917 os->block_value = 1;
5919 /* Make next things chain into subchain of this. */
5920 push_stat_ptr (&os->children);
5922 os->subsection_alignment =
5923 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5924 os->section_alignment =
5925 topower (exp_get_value_int (align, -1, "section alignment"));
5927 os->load_base = ebase;
5934 lang_output_statement_type *new;
5936 new = new_stat (lang_output_statement, stat_ptr);
5937 new->name = output_filename;
5940 /* Reset the current counters in the regions. */
5943 lang_reset_memory_regions (void)
5945 lang_memory_region_type *p = lang_memory_region_list;
5947 lang_output_section_statement_type *os;
5949 for (p = lang_memory_region_list; p != NULL; p = p->next)
5951 p->current = p->origin;
5955 for (os = &lang_output_section_statement.head->output_section_statement;
5959 os->processed_vma = FALSE;
5960 os->processed_lma = FALSE;
5963 for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
5965 /* Save the last size for possible use by bfd_relax_section. */
5966 o->rawsize = o->size;
5971 /* Worker for lang_gc_sections_1. */
5974 gc_section_callback (lang_wild_statement_type *ptr,
5975 struct wildcard_list *sec ATTRIBUTE_UNUSED,
5977 lang_input_statement_type *file ATTRIBUTE_UNUSED,
5978 void *data ATTRIBUTE_UNUSED)
5980 /* If the wild pattern was marked KEEP, the member sections
5981 should be as well. */
5982 if (ptr->keep_sections)
5983 section->flags |= SEC_KEEP;
5986 /* Iterate over sections marking them against GC. */
5989 lang_gc_sections_1 (lang_statement_union_type *s)
5991 for (; s != NULL; s = s->header.next)
5993 switch (s->header.type)
5995 case lang_wild_statement_enum:
5996 walk_wild (&s->wild_statement, gc_section_callback, NULL);
5998 case lang_constructors_statement_enum:
5999 lang_gc_sections_1 (constructor_list.head);
6001 case lang_output_section_statement_enum:
6002 lang_gc_sections_1 (s->output_section_statement.children.head);
6004 case lang_group_statement_enum:
6005 lang_gc_sections_1 (s->group_statement.children.head);
6014 lang_gc_sections (void)
6016 /* Keep all sections so marked in the link script. */
6018 lang_gc_sections_1 (statement_list.head);
6020 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6021 the special case of debug info. (See bfd/stabs.c)
6022 Twiddle the flag here, to simplify later linker code. */
6023 if (link_info.relocatable)
6025 LANG_FOR_EACH_INPUT_STATEMENT (f)
6028 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6029 if ((sec->flags & SEC_DEBUGGING) == 0)
6030 sec->flags &= ~SEC_EXCLUDE;
6034 if (link_info.gc_sections)
6035 bfd_gc_sections (link_info.output_bfd, &link_info);
6038 /* Worker for lang_find_relro_sections_1. */
6041 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6042 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6044 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6047 /* Discarded, excluded and ignored sections effectively have zero
6049 if (section->output_section != NULL
6050 && section->output_section->owner == link_info.output_bfd
6051 && (section->output_section->flags & SEC_EXCLUDE) == 0
6052 && !IGNORE_SECTION (section)
6053 && section->size != 0)
6055 bfd_boolean *has_relro_section = (bfd_boolean *) data;
6056 *has_relro_section = TRUE;
6060 /* Iterate over sections for relro sections. */
6063 lang_find_relro_sections_1 (lang_statement_union_type *s,
6064 bfd_boolean *has_relro_section)
6066 if (*has_relro_section)
6069 for (; s != NULL; s = s->header.next)
6071 if (s == expld.dataseg.relro_end_stat)
6074 switch (s->header.type)
6076 case lang_wild_statement_enum:
6077 walk_wild (&s->wild_statement,
6078 find_relro_section_callback,
6081 case lang_constructors_statement_enum:
6082 lang_find_relro_sections_1 (constructor_list.head,
6085 case lang_output_section_statement_enum:
6086 lang_find_relro_sections_1 (s->output_section_statement.children.head,
6089 case lang_group_statement_enum:
6090 lang_find_relro_sections_1 (s->group_statement.children.head,
6100 lang_find_relro_sections (void)
6102 bfd_boolean has_relro_section = FALSE;
6104 /* Check all sections in the link script. */
6106 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6107 &has_relro_section);
6109 if (!has_relro_section)
6110 link_info.relro = FALSE;
6113 /* Relax all sections until bfd_relax_section gives up. */
6116 relax_sections (void)
6118 /* Keep relaxing until bfd_relax_section gives up. */
6119 bfd_boolean relax_again;
6121 link_info.relax_trip = -1;
6124 relax_again = FALSE;
6125 link_info.relax_trip++;
6127 /* Note: pe-dll.c does something like this also. If you find
6128 you need to change this code, you probably need to change
6129 pe-dll.c also. DJ */
6131 /* Do all the assignments with our current guesses as to
6133 lang_do_assignments ();
6135 /* We must do this after lang_do_assignments, because it uses
6137 lang_reset_memory_regions ();
6139 /* Perform another relax pass - this time we know where the
6140 globals are, so can make a better guess. */
6141 lang_size_sections (&relax_again, FALSE);
6143 while (relax_again);
6149 /* Finalize dynamic list. */
6150 if (link_info.dynamic_list)
6151 lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6153 current_target = default_target;
6155 /* Open the output file. */
6156 lang_for_each_statement (ldlang_open_output);
6159 ldemul_create_output_section_statements ();
6161 /* Add to the hash table all undefineds on the command line. */
6162 lang_place_undefineds ();
6164 if (!bfd_section_already_linked_table_init ())
6165 einfo (_("%P%F: Failed to create hash table\n"));
6167 /* Create a bfd for each input file. */
6168 current_target = default_target;
6169 open_input_bfds (statement_list.head, FALSE);
6171 link_info.gc_sym_list = &entry_symbol;
6172 if (entry_symbol.name == NULL)
6173 link_info.gc_sym_list = ldlang_undef_chain_list_head;
6175 ldemul_after_open ();
6177 bfd_section_already_linked_table_free ();
6179 /* Make sure that we're not mixing architectures. We call this
6180 after all the input files have been opened, but before we do any
6181 other processing, so that any operations merge_private_bfd_data
6182 does on the output file will be known during the rest of the
6186 /* Handle .exports instead of a version script if we're told to do so. */
6187 if (command_line.version_exports_section)
6188 lang_do_version_exports_section ();
6190 /* Build all sets based on the information gathered from the input
6192 ldctor_build_sets ();
6194 /* Remove unreferenced sections if asked to. */
6195 lang_gc_sections ();
6197 /* Size up the common data. */
6200 /* Update wild statements. */
6201 update_wild_statements (statement_list.head);
6203 /* Run through the contours of the script and attach input sections
6204 to the correct output sections. */
6205 map_input_to_output_sections (statement_list.head, NULL, NULL);
6207 process_insert_statements ();
6209 /* Find any sections not attached explicitly and handle them. */
6210 lang_place_orphans ();
6212 if (! link_info.relocatable)
6216 /* Merge SEC_MERGE sections. This has to be done after GC of
6217 sections, so that GCed sections are not merged, but before
6218 assigning dynamic symbols, since removing whole input sections
6220 bfd_merge_sections (link_info.output_bfd, &link_info);
6222 /* Look for a text section and set the readonly attribute in it. */
6223 found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6227 if (config.text_read_only)
6228 found->flags |= SEC_READONLY;
6230 found->flags &= ~SEC_READONLY;
6234 /* Do anything special before sizing sections. This is where ELF
6235 and other back-ends size dynamic sections. */
6236 ldemul_before_allocation ();
6238 /* We must record the program headers before we try to fix the
6239 section positions, since they will affect SIZEOF_HEADERS. */
6240 lang_record_phdrs ();
6242 /* Check relro sections. */
6243 if (link_info.relro && ! link_info.relocatable)
6244 lang_find_relro_sections ();
6246 /* Size up the sections. */
6247 lang_size_sections (NULL, !command_line.relax);
6249 /* Now run around and relax if we can. */
6250 if (command_line.relax)
6252 /* We may need more than one relaxation pass. */
6253 int i = link_info.relax_pass;
6255 /* The backend can use it to determine the current pass. */
6256 link_info.relax_pass = 0;
6261 link_info.relax_pass++;
6264 /* Final extra sizing to report errors. */
6265 lang_do_assignments ();
6266 lang_reset_memory_regions ();
6267 lang_size_sections (NULL, TRUE);
6270 /* See if anything special should be done now we know how big
6272 ldemul_after_allocation ();
6274 /* Fix any .startof. or .sizeof. symbols. */
6275 lang_set_startof ();
6277 /* Do all the assignments, now that we know the final resting places
6278 of all the symbols. */
6280 lang_do_assignments ();
6284 /* Make sure that the section addresses make sense. */
6285 if (command_line.check_section_addresses)
6286 lang_check_section_addresses ();
6291 /* EXPORTED TO YACC */
6294 lang_add_wild (struct wildcard_spec *filespec,
6295 struct wildcard_list *section_list,
6296 bfd_boolean keep_sections)
6298 struct wildcard_list *curr, *next;
6299 lang_wild_statement_type *new;
6301 /* Reverse the list as the parser puts it back to front. */
6302 for (curr = section_list, section_list = NULL;
6304 section_list = curr, curr = next)
6306 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6307 placed_commons = TRUE;
6310 curr->next = section_list;
6313 if (filespec != NULL && filespec->name != NULL)
6315 if (strcmp (filespec->name, "*") == 0)
6316 filespec->name = NULL;
6317 else if (! wildcardp (filespec->name))
6318 lang_has_input_file = TRUE;
6321 new = new_stat (lang_wild_statement, stat_ptr);
6322 new->filename = NULL;
6323 new->filenames_sorted = FALSE;
6324 if (filespec != NULL)
6326 new->filename = filespec->name;
6327 new->filenames_sorted = filespec->sorted == by_name;
6329 new->section_list = section_list;
6330 new->keep_sections = keep_sections;
6331 lang_list_init (&new->children);
6332 analyze_walk_wild_section_handler (new);
6336 lang_section_start (const char *name, etree_type *address,
6337 const segment_type *segment)
6339 lang_address_statement_type *ad;
6341 ad = new_stat (lang_address_statement, stat_ptr);
6342 ad->section_name = name;
6343 ad->address = address;
6344 ad->segment = segment;
6347 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6348 because of a -e argument on the command line, or zero if this is
6349 called by ENTRY in a linker script. Command line arguments take
6353 lang_add_entry (const char *name, bfd_boolean cmdline)
6355 if (entry_symbol.name == NULL
6357 || ! entry_from_cmdline)
6359 entry_symbol.name = name;
6360 entry_from_cmdline = cmdline;
6364 /* Set the default start symbol to NAME. .em files should use this,
6365 not lang_add_entry, to override the use of "start" if neither the
6366 linker script nor the command line specifies an entry point. NAME
6367 must be permanently allocated. */
6369 lang_default_entry (const char *name)
6371 entry_symbol_default = name;
6375 lang_add_target (const char *name)
6377 lang_target_statement_type *new;
6379 new = new_stat (lang_target_statement, stat_ptr);
6384 lang_add_map (const char *name)
6391 map_option_f = TRUE;
6399 lang_add_fill (fill_type *fill)
6401 lang_fill_statement_type *new;
6403 new = new_stat (lang_fill_statement, stat_ptr);
6408 lang_add_data (int type, union etree_union *exp)
6410 lang_data_statement_type *new;
6412 new = new_stat (lang_data_statement, stat_ptr);
6417 /* Create a new reloc statement. RELOC is the BFD relocation type to
6418 generate. HOWTO is the corresponding howto structure (we could
6419 look this up, but the caller has already done so). SECTION is the
6420 section to generate a reloc against, or NAME is the name of the
6421 symbol to generate a reloc against. Exactly one of SECTION and
6422 NAME must be NULL. ADDEND is an expression for the addend. */
6425 lang_add_reloc (bfd_reloc_code_real_type reloc,
6426 reloc_howto_type *howto,
6429 union etree_union *addend)
6431 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6435 p->section = section;
6437 p->addend_exp = addend;
6439 p->addend_value = 0;
6440 p->output_section = NULL;
6441 p->output_offset = 0;
6444 lang_assignment_statement_type *
6445 lang_add_assignment (etree_type *exp)
6447 lang_assignment_statement_type *new;
6449 new = new_stat (lang_assignment_statement, stat_ptr);
6455 lang_add_attribute (enum statement_enum attribute)
6457 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6461 lang_startup (const char *name)
6463 if (startup_file != NULL)
6465 einfo (_("%P%F: multiple STARTUP files\n"));
6467 first_file->filename = name;
6468 first_file->local_sym_name = name;
6469 first_file->real = TRUE;
6471 startup_file = name;
6475 lang_float (bfd_boolean maybe)
6477 lang_float_flag = maybe;
6481 /* Work out the load- and run-time regions from a script statement, and
6482 store them in *LMA_REGION and *REGION respectively.
6484 MEMSPEC is the name of the run-time region, or the value of
6485 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6486 LMA_MEMSPEC is the name of the load-time region, or null if the
6487 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6488 had an explicit load address.
6490 It is an error to specify both a load region and a load address. */
6493 lang_get_regions (lang_memory_region_type **region,
6494 lang_memory_region_type **lma_region,
6495 const char *memspec,
6496 const char *lma_memspec,
6497 bfd_boolean have_lma,
6498 bfd_boolean have_vma)
6500 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6502 /* If no runtime region or VMA has been specified, but the load region
6503 has been specified, then use the load region for the runtime region
6505 if (lma_memspec != NULL
6507 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6508 *region = *lma_region;
6510 *region = lang_memory_region_lookup (memspec, FALSE);
6512 if (have_lma && lma_memspec != 0)
6513 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6517 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6518 lang_output_section_phdr_list *phdrs,
6519 const char *lma_memspec)
6521 lang_get_regions (¤t_section->region,
6522 ¤t_section->lma_region,
6523 memspec, lma_memspec,
6524 current_section->load_base != NULL,
6525 current_section->addr_tree != NULL);
6527 /* If this section has no load region or base, but has the same
6528 region as the previous section, then propagate the previous
6529 section's load region. */
6531 if (!current_section->lma_region && !current_section->load_base
6532 && current_section->region == current_section->prev->region)
6533 current_section->lma_region = current_section->prev->lma_region;
6535 current_section->fill = fill;
6536 current_section->phdrs = phdrs;
6540 /* Create an absolute symbol with the given name with the value of the
6541 address of first byte of the section named.
6543 If the symbol already exists, then do nothing. */
6546 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6548 struct bfd_link_hash_entry *h;
6550 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6552 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6554 if (h->type == bfd_link_hash_new
6555 || h->type == bfd_link_hash_undefined)
6559 h->type = bfd_link_hash_defined;
6561 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6565 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
6567 h->u.def.section = bfd_abs_section_ptr;
6571 /* Create an absolute symbol with the given name with the value of the
6572 address of the first byte after the end of the section named.
6574 If the symbol already exists, then do nothing. */
6577 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6579 struct bfd_link_hash_entry *h;
6581 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6583 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6585 if (h->type == bfd_link_hash_new
6586 || h->type == bfd_link_hash_undefined)
6590 h->type = bfd_link_hash_defined;
6592 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6596 h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
6597 + TO_ADDR (sec->size));
6599 h->u.def.section = bfd_abs_section_ptr;
6604 lang_statement_append (lang_statement_list_type *list,
6605 lang_statement_union_type *element,
6606 lang_statement_union_type **field)
6608 *(list->tail) = element;
6612 /* Set the output format type. -oformat overrides scripts. */
6615 lang_add_output_format (const char *format,
6620 if (output_target == NULL || !from_script)
6622 if (command_line.endian == ENDIAN_BIG
6625 else if (command_line.endian == ENDIAN_LITTLE
6629 output_target = format;
6634 lang_add_insert (const char *where, int is_before)
6636 lang_insert_statement_type *new;
6638 new = new_stat (lang_insert_statement, stat_ptr);
6640 new->is_before = is_before;
6641 saved_script_handle = previous_script_handle;
6644 /* Enter a group. This creates a new lang_group_statement, and sets
6645 stat_ptr to build new statements within the group. */
6648 lang_enter_group (void)
6650 lang_group_statement_type *g;
6652 g = new_stat (lang_group_statement, stat_ptr);
6653 lang_list_init (&g->children);
6654 push_stat_ptr (&g->children);
6657 /* Leave a group. This just resets stat_ptr to start writing to the
6658 regular list of statements again. Note that this will not work if
6659 groups can occur inside anything else which can adjust stat_ptr,
6660 but currently they can't. */
6663 lang_leave_group (void)
6668 /* Add a new program header. This is called for each entry in a PHDRS
6669 command in a linker script. */
6672 lang_new_phdr (const char *name,
6674 bfd_boolean filehdr,
6679 struct lang_phdr *n, **pp;
6681 n = stat_alloc (sizeof (struct lang_phdr));
6684 n->type = exp_get_value_int (type, 0, "program header type");
6685 n->filehdr = filehdr;
6690 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6695 /* Record the program header information in the output BFD. FIXME: We
6696 should not be calling an ELF specific function here. */
6699 lang_record_phdrs (void)
6703 lang_output_section_phdr_list *last;
6704 struct lang_phdr *l;
6705 lang_output_section_statement_type *os;
6708 secs = xmalloc (alc * sizeof (asection *));
6711 for (l = lang_phdr_list; l != NULL; l = l->next)
6718 for (os = &lang_output_section_statement.head->output_section_statement;
6722 lang_output_section_phdr_list *pl;
6724 if (os->constraint < 0)
6732 if (os->sectype == noload_section
6733 || os->bfd_section == NULL
6734 || (os->bfd_section->flags & SEC_ALLOC) == 0)
6737 /* Don't add orphans to PT_INTERP header. */
6743 lang_output_section_statement_type * tmp_os;
6745 /* If we have not run across a section with a program
6746 header assigned to it yet, then scan forwards to find
6747 one. This prevents inconsistencies in the linker's
6748 behaviour when a script has specified just a single
6749 header and there are sections in that script which are
6750 not assigned to it, and which occur before the first
6751 use of that header. See here for more details:
6752 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6753 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6756 last = tmp_os->phdrs;
6760 einfo (_("%F%P: no sections assigned to phdrs\n"));
6765 if (os->bfd_section == NULL)
6768 for (; pl != NULL; pl = pl->next)
6770 if (strcmp (pl->name, l->name) == 0)
6775 secs = xrealloc (secs, alc * sizeof (asection *));
6777 secs[c] = os->bfd_section;
6784 if (l->flags == NULL)
6787 flags = exp_get_vma (l->flags, 0, "phdr flags");
6792 at = exp_get_vma (l->at, 0, "phdr load address");
6794 if (! bfd_record_phdr (link_info.output_bfd, l->type,
6795 l->flags != NULL, flags, l->at != NULL,
6796 at, l->filehdr, l->phdrs, c, secs))
6797 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6802 /* Make sure all the phdr assignments succeeded. */
6803 for (os = &lang_output_section_statement.head->output_section_statement;
6807 lang_output_section_phdr_list *pl;
6809 if (os->constraint < 0
6810 || os->bfd_section == NULL)
6813 for (pl = os->phdrs;
6816 if (! pl->used && strcmp (pl->name, "NONE") != 0)
6817 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6818 os->name, pl->name);
6822 /* Record a list of sections which may not be cross referenced. */
6825 lang_add_nocrossref (lang_nocrossref_type *l)
6827 struct lang_nocrossrefs *n;
6829 n = xmalloc (sizeof *n);
6830 n->next = nocrossref_list;
6832 nocrossref_list = n;
6834 /* Set notice_all so that we get informed about all symbols. */
6835 link_info.notice_all = TRUE;
6838 /* Overlay handling. We handle overlays with some static variables. */
6840 /* The overlay virtual address. */
6841 static etree_type *overlay_vma;
6842 /* And subsection alignment. */
6843 static etree_type *overlay_subalign;
6845 /* An expression for the maximum section size seen so far. */
6846 static etree_type *overlay_max;
6848 /* A list of all the sections in this overlay. */
6850 struct overlay_list {
6851 struct overlay_list *next;
6852 lang_output_section_statement_type *os;
6855 static struct overlay_list *overlay_list;
6857 /* Start handling an overlay. */
6860 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
6862 /* The grammar should prevent nested overlays from occurring. */
6863 ASSERT (overlay_vma == NULL
6864 && overlay_subalign == NULL
6865 && overlay_max == NULL);
6867 overlay_vma = vma_expr;
6868 overlay_subalign = subalign;
6871 /* Start a section in an overlay. We handle this by calling
6872 lang_enter_output_section_statement with the correct VMA.
6873 lang_leave_overlay sets up the LMA and memory regions. */
6876 lang_enter_overlay_section (const char *name)
6878 struct overlay_list *n;
6881 lang_enter_output_section_statement (name, overlay_vma, overlay_section,
6882 0, overlay_subalign, 0, 0);
6884 /* If this is the first section, then base the VMA of future
6885 sections on this one. This will work correctly even if `.' is
6886 used in the addresses. */
6887 if (overlay_list == NULL)
6888 overlay_vma = exp_nameop (ADDR, name);
6890 /* Remember the section. */
6891 n = xmalloc (sizeof *n);
6892 n->os = current_section;
6893 n->next = overlay_list;
6896 size = exp_nameop (SIZEOF, name);
6898 /* Arrange to work out the maximum section end address. */
6899 if (overlay_max == NULL)
6902 overlay_max = exp_binop (MAX_K, overlay_max, size);
6905 /* Finish a section in an overlay. There isn't any special to do
6909 lang_leave_overlay_section (fill_type *fill,
6910 lang_output_section_phdr_list *phdrs)
6917 name = current_section->name;
6919 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6920 region and that no load-time region has been specified. It doesn't
6921 really matter what we say here, since lang_leave_overlay will
6923 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6925 /* Define the magic symbols. */
6927 clean = xmalloc (strlen (name) + 1);
6929 for (s1 = name; *s1 != '\0'; s1++)
6930 if (ISALNUM (*s1) || *s1 == '_')
6934 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6935 sprintf (buf, "__load_start_%s", clean);
6936 lang_add_assignment (exp_provide (buf,
6937 exp_nameop (LOADADDR, name),
6940 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6941 sprintf (buf, "__load_stop_%s", clean);
6942 lang_add_assignment (exp_provide (buf,
6944 exp_nameop (LOADADDR, name),
6945 exp_nameop (SIZEOF, name)),
6951 /* Finish an overlay. If there are any overlay wide settings, this
6952 looks through all the sections in the overlay and sets them. */
6955 lang_leave_overlay (etree_type *lma_expr,
6958 const char *memspec,
6959 lang_output_section_phdr_list *phdrs,
6960 const char *lma_memspec)
6962 lang_memory_region_type *region;
6963 lang_memory_region_type *lma_region;
6964 struct overlay_list *l;
6965 lang_nocrossref_type *nocrossref;
6967 lang_get_regions (®ion, &lma_region,
6968 memspec, lma_memspec,
6969 lma_expr != NULL, FALSE);
6973 /* After setting the size of the last section, set '.' to end of the
6975 if (overlay_list != NULL)
6976 overlay_list->os->update_dot_tree
6977 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6982 struct overlay_list *next;
6984 if (fill != NULL && l->os->fill == NULL)
6987 l->os->region = region;
6988 l->os->lma_region = lma_region;
6990 /* The first section has the load address specified in the
6991 OVERLAY statement. The rest are worked out from that.
6992 The base address is not needed (and should be null) if
6993 an LMA region was specified. */
6996 l->os->load_base = lma_expr;
6997 l->os->sectype = normal_section;
6999 if (phdrs != NULL && l->os->phdrs == NULL)
7000 l->os->phdrs = phdrs;
7004 lang_nocrossref_type *nc;
7006 nc = xmalloc (sizeof *nc);
7007 nc->name = l->os->name;
7008 nc->next = nocrossref;
7017 if (nocrossref != NULL)
7018 lang_add_nocrossref (nocrossref);
7021 overlay_list = NULL;
7025 /* Version handling. This is only useful for ELF. */
7027 /* This global variable holds the version tree that we build. */
7029 struct bfd_elf_version_tree *lang_elf_version_info;
7031 /* If PREV is NULL, return first version pattern matching particular symbol.
7032 If PREV is non-NULL, return first version pattern matching particular
7033 symbol after PREV (previously returned by lang_vers_match). */
7035 static struct bfd_elf_version_expr *
7036 lang_vers_match (struct bfd_elf_version_expr_head *head,
7037 struct bfd_elf_version_expr *prev,
7040 const char *cxx_sym = sym;
7041 const char *java_sym = sym;
7042 struct bfd_elf_version_expr *expr = NULL;
7044 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7046 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
7050 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7052 java_sym = cplus_demangle (sym, DMGL_JAVA);
7057 if (head->htab && (prev == NULL || prev->literal))
7059 struct bfd_elf_version_expr e;
7061 switch (prev ? prev->mask : 0)
7064 if (head->mask & BFD_ELF_VERSION_C_TYPE)
7067 expr = htab_find (head->htab, &e);
7068 while (expr && strcmp (expr->pattern, sym) == 0)
7069 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7075 case BFD_ELF_VERSION_C_TYPE:
7076 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7078 e.pattern = cxx_sym;
7079 expr = htab_find (head->htab, &e);
7080 while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7081 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7087 case BFD_ELF_VERSION_CXX_TYPE:
7088 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7090 e.pattern = java_sym;
7091 expr = htab_find (head->htab, &e);
7092 while (expr && strcmp (expr->pattern, java_sym) == 0)
7093 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7104 /* Finally, try the wildcards. */
7105 if (prev == NULL || prev->literal)
7106 expr = head->remaining;
7109 for (; expr; expr = expr->next)
7116 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7119 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7121 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7125 if (fnmatch (expr->pattern, s, 0) == 0)
7131 free ((char *) cxx_sym);
7132 if (java_sym != sym)
7133 free ((char *) java_sym);
7137 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7138 return a pointer to the symbol name with any backslash quotes removed. */
7141 realsymbol (const char *pattern)
7144 bfd_boolean changed = FALSE, backslash = FALSE;
7145 char *s, *symbol = xmalloc (strlen (pattern) + 1);
7147 for (p = pattern, s = symbol; *p != '\0'; ++p)
7149 /* It is a glob pattern only if there is no preceding
7153 /* Remove the preceding backslash. */
7160 if (*p == '?' || *p == '*' || *p == '[')
7167 backslash = *p == '\\';
7183 /* This is called for each variable name or match expression. NEW is
7184 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7185 pattern to be matched against symbol names. */
7187 struct bfd_elf_version_expr *
7188 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7191 bfd_boolean literal_p)
7193 struct bfd_elf_version_expr *ret;
7195 ret = xmalloc (sizeof *ret);
7199 ret->literal = TRUE;
7200 ret->pattern = literal_p ? new : realsymbol (new);
7201 if (ret->pattern == NULL)
7204 ret->literal = FALSE;
7207 if (lang == NULL || strcasecmp (lang, "C") == 0)
7208 ret->mask = BFD_ELF_VERSION_C_TYPE;
7209 else if (strcasecmp (lang, "C++") == 0)
7210 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7211 else if (strcasecmp (lang, "Java") == 0)
7212 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7215 einfo (_("%X%P: unknown language `%s' in version information\n"),
7217 ret->mask = BFD_ELF_VERSION_C_TYPE;
7220 return ldemul_new_vers_pattern (ret);
7223 /* This is called for each set of variable names and match
7226 struct bfd_elf_version_tree *
7227 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7228 struct bfd_elf_version_expr *locals)
7230 struct bfd_elf_version_tree *ret;
7232 ret = xcalloc (1, sizeof *ret);
7233 ret->globals.list = globals;
7234 ret->locals.list = locals;
7235 ret->match = lang_vers_match;
7236 ret->name_indx = (unsigned int) -1;
7240 /* This static variable keeps track of version indices. */
7242 static int version_index;
7245 version_expr_head_hash (const void *p)
7247 const struct bfd_elf_version_expr *e = p;
7249 return htab_hash_string (e->pattern);
7253 version_expr_head_eq (const void *p1, const void *p2)
7255 const struct bfd_elf_version_expr *e1 = p1;
7256 const struct bfd_elf_version_expr *e2 = p2;
7258 return strcmp (e1->pattern, e2->pattern) == 0;
7262 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7265 struct bfd_elf_version_expr *e, *next;
7266 struct bfd_elf_version_expr **list_loc, **remaining_loc;
7268 for (e = head->list; e; e = e->next)
7272 head->mask |= e->mask;
7277 head->htab = htab_create (count * 2, version_expr_head_hash,
7278 version_expr_head_eq, NULL);
7279 list_loc = &head->list;
7280 remaining_loc = &head->remaining;
7281 for (e = head->list; e; e = next)
7287 remaining_loc = &e->next;
7291 void **loc = htab_find_slot (head->htab, e, INSERT);
7295 struct bfd_elf_version_expr *e1, *last;
7301 if (e1->mask == e->mask)
7309 while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7313 /* This is a duplicate. */
7314 /* FIXME: Memory leak. Sometimes pattern is not
7315 xmalloced alone, but in larger chunk of memory. */
7316 /* free (e->pattern); */
7321 e->next = last->next;
7329 list_loc = &e->next;
7333 *remaining_loc = NULL;
7334 *list_loc = head->remaining;
7337 head->remaining = head->list;
7340 /* This is called when we know the name and dependencies of the
7344 lang_register_vers_node (const char *name,
7345 struct bfd_elf_version_tree *version,
7346 struct bfd_elf_version_deps *deps)
7348 struct bfd_elf_version_tree *t, **pp;
7349 struct bfd_elf_version_expr *e1;
7354 if ((name[0] == '\0' && lang_elf_version_info != NULL)
7355 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
7357 einfo (_("%X%P: anonymous version tag cannot be combined"
7358 " with other version tags\n"));
7363 /* Make sure this node has a unique name. */
7364 for (t = lang_elf_version_info; t != NULL; t = t->next)
7365 if (strcmp (t->name, name) == 0)
7366 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7368 lang_finalize_version_expr_head (&version->globals);
7369 lang_finalize_version_expr_head (&version->locals);
7371 /* Check the global and local match names, and make sure there
7372 aren't any duplicates. */
7374 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7376 for (t = lang_elf_version_info; t != NULL; t = t->next)
7378 struct bfd_elf_version_expr *e2;
7380 if (t->locals.htab && e1->literal)
7382 e2 = htab_find (t->locals.htab, e1);
7383 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7385 if (e1->mask == e2->mask)
7386 einfo (_("%X%P: duplicate expression `%s'"
7387 " in version information\n"), e1->pattern);
7391 else if (!e1->literal)
7392 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7393 if (strcmp (e1->pattern, e2->pattern) == 0
7394 && e1->mask == e2->mask)
7395 einfo (_("%X%P: duplicate expression `%s'"
7396 " in version information\n"), e1->pattern);
7400 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7402 for (t = lang_elf_version_info; t != NULL; t = t->next)
7404 struct bfd_elf_version_expr *e2;
7406 if (t->globals.htab && e1->literal)
7408 e2 = htab_find (t->globals.htab, e1);
7409 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7411 if (e1->mask == e2->mask)
7412 einfo (_("%X%P: duplicate expression `%s'"
7413 " in version information\n"),
7418 else if (!e1->literal)
7419 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7420 if (strcmp (e1->pattern, e2->pattern) == 0
7421 && e1->mask == e2->mask)
7422 einfo (_("%X%P: duplicate expression `%s'"
7423 " in version information\n"), e1->pattern);
7427 version->deps = deps;
7428 version->name = name;
7429 if (name[0] != '\0')
7432 version->vernum = version_index;
7435 version->vernum = 0;
7437 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7442 /* This is called when we see a version dependency. */
7444 struct bfd_elf_version_deps *
7445 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7447 struct bfd_elf_version_deps *ret;
7448 struct bfd_elf_version_tree *t;
7450 ret = xmalloc (sizeof *ret);
7453 for (t = lang_elf_version_info; t != NULL; t = t->next)
7455 if (strcmp (t->name, name) == 0)
7457 ret->version_needed = t;
7462 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7468 lang_do_version_exports_section (void)
7470 struct bfd_elf_version_expr *greg = NULL, *lreg;
7472 LANG_FOR_EACH_INPUT_STATEMENT (is)
7474 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7482 contents = xmalloc (len);
7483 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7484 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7487 while (p < contents + len)
7489 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7490 p = strchr (p, '\0') + 1;
7493 /* Do not free the contents, as we used them creating the regex. */
7495 /* Do not include this section in the link. */
7496 sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7499 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7500 lang_register_vers_node (command_line.version_exports_section,
7501 lang_new_vers_node (greg, lreg), NULL);
7505 lang_add_unique (const char *name)
7507 struct unique_sections *ent;
7509 for (ent = unique_section_list; ent; ent = ent->next)
7510 if (strcmp (ent->name, name) == 0)
7513 ent = xmalloc (sizeof *ent);
7514 ent->name = xstrdup (name);
7515 ent->next = unique_section_list;
7516 unique_section_list = ent;
7519 /* Append the list of dynamic symbols to the existing one. */
7522 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7524 if (link_info.dynamic_list)
7526 struct bfd_elf_version_expr *tail;
7527 for (tail = dynamic; tail->next != NULL; tail = tail->next)
7529 tail->next = link_info.dynamic_list->head.list;
7530 link_info.dynamic_list->head.list = dynamic;
7534 struct bfd_elf_dynamic_list *d;
7536 d = xcalloc (1, sizeof *d);
7537 d->head.list = dynamic;
7538 d->match = lang_vers_match;
7539 link_info.dynamic_list = d;
7543 /* Append the list of C++ typeinfo dynamic symbols to the existing
7547 lang_append_dynamic_list_cpp_typeinfo (void)
7549 const char * symbols [] =
7551 "typeinfo name for*",
7554 struct bfd_elf_version_expr *dynamic = NULL;
7557 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7558 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7561 lang_append_dynamic_list (dynamic);
7564 /* Append the list of C++ operator new and delete dynamic symbols to the
7568 lang_append_dynamic_list_cpp_new (void)
7570 const char * symbols [] =
7575 struct bfd_elf_version_expr *dynamic = NULL;
7578 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7579 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7582 lang_append_dynamic_list (dynamic);