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, 2010, 2011
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"
46 #endif /* ENABLE_PLUGINS */
49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
52 /* Locals variables. */
53 static struct obstack stat_obstack;
54 static struct obstack map_obstack;
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 static const char *startup_file;
59 static const char *entry_symbol_default = "start";
60 static bfd_boolean placed_commons = FALSE;
61 static bfd_boolean stripped_excluded_sections = FALSE;
62 static lang_output_section_statement_type *default_common_section;
63 static bfd_boolean map_option_f;
64 static bfd_vma print_dot;
65 static lang_input_statement_type *first_file;
66 static const char *current_target;
67 static lang_statement_list_type statement_list;
68 static struct bfd_hash_table lang_definedness_table;
69 static lang_statement_list_type *stat_save[10];
70 static lang_statement_list_type **stat_save_ptr = &stat_save[0];
71 static struct unique_sections *unique_section_list;
72 static bfd_boolean ldlang_sysrooted_script = FALSE;
74 /* Forward declarations. */
75 static void exp_init_os (etree_type *);
76 static void init_map_userdata (bfd *, asection *, void *);
77 static lang_input_statement_type *lookup_name (const char *);
78 static struct bfd_hash_entry *lang_definedness_newfunc
79 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
80 static void insert_undefined (const char *);
81 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
82 static void print_statement (lang_statement_union_type *,
83 lang_output_section_statement_type *);
84 static void print_statement_list (lang_statement_union_type *,
85 lang_output_section_statement_type *);
86 static void print_statements (void);
87 static void print_input_section (asection *, bfd_boolean);
88 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
89 static void lang_record_phdrs (void);
90 static void lang_do_version_exports_section (void);
91 static void lang_finalize_version_expr_head
92 (struct bfd_elf_version_expr_head *);
94 /* Exported variables. */
95 const char *output_target;
96 lang_output_section_statement_type *abs_output_section;
97 lang_statement_list_type lang_output_section_statement;
98 lang_statement_list_type *stat_ptr = &statement_list;
99 lang_statement_list_type file_chain = { NULL, NULL };
100 lang_statement_list_type input_file_chain;
101 struct bfd_sym_chain entry_symbol = { NULL, NULL };
102 const char *entry_section = ".text";
103 bfd_boolean entry_from_cmdline;
104 bfd_boolean undef_from_cmdline;
105 bfd_boolean lang_has_input_file = FALSE;
106 bfd_boolean had_output_filename = FALSE;
107 bfd_boolean lang_float_flag = FALSE;
108 bfd_boolean delete_output_file_on_failure = FALSE;
109 struct lang_phdr *lang_phdr_list;
110 struct lang_nocrossrefs *nocrossref_list;
111 bfd_boolean missing_file = FALSE;
113 /* Functions that traverse the linker script and might evaluate
114 DEFINED() need to increment this. */
115 int lang_statement_iteration = 0;
117 etree_type *base; /* Relocation base - or null */
119 /* Return TRUE if the PATTERN argument is a wildcard pattern.
120 Although backslashes are treated specially if a pattern contains
121 wildcards, we do not consider the mere presence of a backslash to
122 be enough to cause the pattern to be treated as a wildcard.
123 That lets us handle DOS filenames more naturally. */
124 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
126 #define new_stat(x, y) \
127 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
129 #define outside_section_address(q) \
130 ((q)->output_offset + (q)->output_section->vma)
132 #define outside_symbol_address(q) \
133 ((q)->value + outside_section_address (q->section))
135 #define SECTION_NAME_MAP_LENGTH (16)
138 stat_alloc (size_t size)
140 return obstack_alloc (&stat_obstack, size);
144 name_match (const char *pattern, const char *name)
146 if (wildcardp (pattern))
147 return fnmatch (pattern, name, 0);
148 return strcmp (pattern, name);
151 /* If PATTERN is of the form archive:file, return a pointer to the
152 separator. If not, return NULL. */
155 archive_path (const char *pattern)
159 if (link_info.path_separator == 0)
162 p = strchr (pattern, link_info.path_separator);
163 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
164 if (p == NULL || link_info.path_separator != ':')
167 /* Assume a match on the second char is part of drive specifier,
168 as in "c:\silly.dos". */
169 if (p == pattern + 1 && ISALPHA (*pattern))
170 p = strchr (p + 1, link_info.path_separator);
175 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
176 return whether F matches FILE_SPEC. */
179 input_statement_is_archive_path (const char *file_spec, char *sep,
180 lang_input_statement_type *f)
182 bfd_boolean match = FALSE;
185 || name_match (sep + 1, f->filename) == 0)
186 && ((sep != file_spec)
187 == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
191 if (sep != file_spec)
193 const char *aname = f->the_bfd->my_archive->filename;
195 match = name_match (file_spec, aname) == 0;
196 *sep = link_info.path_separator;
203 unique_section_p (const asection *sec,
204 const lang_output_section_statement_type *os)
206 struct unique_sections *unam;
209 if (link_info.relocatable
210 && sec->owner != NULL
211 && bfd_is_group_section (sec->owner, sec))
213 && strcmp (os->name, DISCARD_SECTION_NAME) == 0);
216 for (unam = unique_section_list; unam; unam = unam->next)
217 if (name_match (unam->name, secnam) == 0)
223 /* Generic traversal routines for finding matching sections. */
225 /* Try processing a section against a wildcard. This just calls
226 the callback unless the filename exclusion list is present
227 and excludes the file. It's hardly ever present so this
228 function is very fast. */
231 walk_wild_consider_section (lang_wild_statement_type *ptr,
232 lang_input_statement_type *file,
234 struct wildcard_list *sec,
238 struct name_list *list_tmp;
240 /* Don't process sections from files which were excluded. */
241 for (list_tmp = sec->spec.exclude_name_list;
243 list_tmp = list_tmp->next)
245 char *p = archive_path (list_tmp->name);
249 if (input_statement_is_archive_path (list_tmp->name, p, file))
253 else if (name_match (list_tmp->name, file->filename) == 0)
256 /* FIXME: Perhaps remove the following at some stage? Matching
257 unadorned archives like this was never documented and has
258 been superceded by the archive:path syntax. */
259 else if (file->the_bfd != NULL
260 && file->the_bfd->my_archive != NULL
261 && name_match (list_tmp->name,
262 file->the_bfd->my_archive->filename) == 0)
266 (*callback) (ptr, sec, s, file, data);
269 /* Lowest common denominator routine that can handle everything correctly,
273 walk_wild_section_general (lang_wild_statement_type *ptr,
274 lang_input_statement_type *file,
279 struct wildcard_list *sec;
281 for (s = file->the_bfd->sections; s != NULL; s = s->next)
283 sec = ptr->section_list;
285 (*callback) (ptr, sec, s, file, data);
289 bfd_boolean skip = FALSE;
291 if (sec->spec.name != NULL)
293 const char *sname = bfd_get_section_name (file->the_bfd, s);
295 skip = name_match (sec->spec.name, sname) != 0;
299 walk_wild_consider_section (ptr, file, s, sec, callback, data);
306 /* Routines to find a single section given its name. If there's more
307 than one section with that name, we report that. */
311 asection *found_section;
312 bfd_boolean multiple_sections_found;
313 } section_iterator_callback_data;
316 section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data)
318 section_iterator_callback_data *d = (section_iterator_callback_data *) data;
320 if (d->found_section != NULL)
322 d->multiple_sections_found = TRUE;
326 d->found_section = s;
331 find_section (lang_input_statement_type *file,
332 struct wildcard_list *sec,
333 bfd_boolean *multiple_sections_found)
335 section_iterator_callback_data cb_data = { NULL, FALSE };
337 bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
338 section_iterator_callback, &cb_data);
339 *multiple_sections_found = cb_data.multiple_sections_found;
340 return cb_data.found_section;
343 /* Code for handling simple wildcards without going through fnmatch,
344 which can be expensive because of charset translations etc. */
346 /* A simple wild is a literal string followed by a single '*',
347 where the literal part is at least 4 characters long. */
350 is_simple_wild (const char *name)
352 size_t len = strcspn (name, "*?[");
353 return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
357 match_simple_wild (const char *pattern, const char *name)
359 /* The first four characters of the pattern are guaranteed valid
360 non-wildcard characters. So we can go faster. */
361 if (pattern[0] != name[0] || pattern[1] != name[1]
362 || pattern[2] != name[2] || pattern[3] != name[3])
367 while (*pattern != '*')
368 if (*name++ != *pattern++)
374 /* Compare sections ASEC and BSEC according to SORT. */
377 compare_section (sort_type sort, asection *asec, asection *bsec)
386 case by_alignment_name:
387 ret = (bfd_section_alignment (bsec->owner, bsec)
388 - bfd_section_alignment (asec->owner, asec));
394 ret = strcmp (bfd_get_section_name (asec->owner, asec),
395 bfd_get_section_name (bsec->owner, bsec));
398 case by_name_alignment:
399 ret = strcmp (bfd_get_section_name (asec->owner, asec),
400 bfd_get_section_name (bsec->owner, bsec));
406 ret = (bfd_section_alignment (bsec->owner, bsec)
407 - bfd_section_alignment (asec->owner, asec));
414 /* Build a Binary Search Tree to sort sections, unlike insertion sort
415 used in wild_sort(). BST is considerably faster if the number of
416 of sections are large. */
418 static lang_section_bst_type **
419 wild_sort_fast (lang_wild_statement_type *wild,
420 struct wildcard_list *sec,
421 lang_input_statement_type *file ATTRIBUTE_UNUSED,
424 lang_section_bst_type **tree;
427 if (!wild->filenames_sorted
428 && (sec == NULL || sec->spec.sorted == none))
430 /* Append at the right end of tree. */
432 tree = &((*tree)->right);
438 /* Find the correct node to append this section. */
439 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
440 tree = &((*tree)->left);
442 tree = &((*tree)->right);
448 /* Use wild_sort_fast to build a BST to sort sections. */
451 output_section_callback_fast (lang_wild_statement_type *ptr,
452 struct wildcard_list *sec,
454 lang_input_statement_type *file,
457 lang_section_bst_type *node;
458 lang_section_bst_type **tree;
459 lang_output_section_statement_type *os;
461 os = (lang_output_section_statement_type *) output;
463 if (unique_section_p (section, os))
466 node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
469 node->section = section;
471 tree = wild_sort_fast (ptr, sec, file, section);
476 /* Convert a sorted sections' BST back to list form. */
479 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
480 lang_section_bst_type *tree,
484 output_section_callback_tree_to_list (ptr, tree->left, output);
486 lang_add_section (&ptr->children, tree->section,
487 (lang_output_section_statement_type *) output);
490 output_section_callback_tree_to_list (ptr, tree->right, output);
495 /* Specialized, optimized routines for handling different kinds of
499 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
500 lang_input_statement_type *file,
504 /* We can just do a hash lookup for the section with the right name.
505 But if that lookup discovers more than one section with the name
506 (should be rare), we fall back to the general algorithm because
507 we would otherwise have to sort the sections to make sure they
508 get processed in the bfd's order. */
509 bfd_boolean multiple_sections_found;
510 struct wildcard_list *sec0 = ptr->handler_data[0];
511 asection *s0 = find_section (file, sec0, &multiple_sections_found);
513 if (multiple_sections_found)
514 walk_wild_section_general (ptr, file, callback, data);
516 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
520 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
521 lang_input_statement_type *file,
526 struct wildcard_list *wildsec0 = ptr->handler_data[0];
528 for (s = file->the_bfd->sections; s != NULL; s = s->next)
530 const char *sname = bfd_get_section_name (file->the_bfd, s);
531 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
534 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
539 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
540 lang_input_statement_type *file,
545 struct wildcard_list *sec0 = ptr->handler_data[0];
546 struct wildcard_list *wildsec1 = ptr->handler_data[1];
547 bfd_boolean multiple_sections_found;
548 asection *s0 = find_section (file, sec0, &multiple_sections_found);
550 if (multiple_sections_found)
552 walk_wild_section_general (ptr, file, callback, data);
556 /* Note that if the section was not found, s0 is NULL and
557 we'll simply never succeed the s == s0 test below. */
558 for (s = file->the_bfd->sections; s != NULL; s = s->next)
560 /* Recall that in this code path, a section cannot satisfy more
561 than one spec, so if s == s0 then it cannot match
564 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
567 const char *sname = bfd_get_section_name (file->the_bfd, s);
568 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
571 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
578 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
579 lang_input_statement_type *file,
584 struct wildcard_list *sec0 = ptr->handler_data[0];
585 struct wildcard_list *wildsec1 = ptr->handler_data[1];
586 struct wildcard_list *wildsec2 = ptr->handler_data[2];
587 bfd_boolean multiple_sections_found;
588 asection *s0 = find_section (file, sec0, &multiple_sections_found);
590 if (multiple_sections_found)
592 walk_wild_section_general (ptr, file, callback, data);
596 for (s = file->the_bfd->sections; s != NULL; s = s->next)
599 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
602 const char *sname = bfd_get_section_name (file->the_bfd, s);
603 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
606 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
609 skip = !match_simple_wild (wildsec2->spec.name, sname);
611 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
619 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
620 lang_input_statement_type *file,
625 struct wildcard_list *sec0 = ptr->handler_data[0];
626 struct wildcard_list *sec1 = ptr->handler_data[1];
627 struct wildcard_list *wildsec2 = ptr->handler_data[2];
628 struct wildcard_list *wildsec3 = ptr->handler_data[3];
629 bfd_boolean multiple_sections_found;
630 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
632 if (multiple_sections_found)
634 walk_wild_section_general (ptr, file, callback, data);
638 s1 = find_section (file, sec1, &multiple_sections_found);
639 if (multiple_sections_found)
641 walk_wild_section_general (ptr, file, callback, data);
645 for (s = file->the_bfd->sections; s != NULL; s = s->next)
648 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
651 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
654 const char *sname = bfd_get_section_name (file->the_bfd, s);
655 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
659 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
663 skip = !match_simple_wild (wildsec3->spec.name, sname);
665 walk_wild_consider_section (ptr, file, s, wildsec3,
673 walk_wild_section (lang_wild_statement_type *ptr,
674 lang_input_statement_type *file,
678 if (file->just_syms_flag)
681 (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
684 /* Returns TRUE when name1 is a wildcard spec that might match
685 something name2 can match. We're conservative: we return FALSE
686 only if the prefixes of name1 and name2 are different up to the
687 first wildcard character. */
690 wild_spec_can_overlap (const char *name1, const char *name2)
692 size_t prefix1_len = strcspn (name1, "?*[");
693 size_t prefix2_len = strcspn (name2, "?*[");
694 size_t min_prefix_len;
696 /* Note that if there is no wildcard character, then we treat the
697 terminating 0 as part of the prefix. Thus ".text" won't match
698 ".text." or ".text.*", for example. */
699 if (name1[prefix1_len] == '\0')
701 if (name2[prefix2_len] == '\0')
704 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
706 return memcmp (name1, name2, min_prefix_len) == 0;
709 /* Select specialized code to handle various kinds of wildcard
713 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
716 int wild_name_count = 0;
717 struct wildcard_list *sec;
721 ptr->walk_wild_section_handler = walk_wild_section_general;
722 ptr->handler_data[0] = NULL;
723 ptr->handler_data[1] = NULL;
724 ptr->handler_data[2] = NULL;
725 ptr->handler_data[3] = NULL;
728 /* Count how many wildcard_specs there are, and how many of those
729 actually use wildcards in the name. Also, bail out if any of the
730 wildcard names are NULL. (Can this actually happen?
731 walk_wild_section used to test for it.) And bail out if any
732 of the wildcards are more complex than a simple string
733 ending in a single '*'. */
734 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
737 if (sec->spec.name == NULL)
739 if (wildcardp (sec->spec.name))
742 if (!is_simple_wild (sec->spec.name))
747 /* The zero-spec case would be easy to optimize but it doesn't
748 happen in practice. Likewise, more than 4 specs doesn't
749 happen in practice. */
750 if (sec_count == 0 || sec_count > 4)
753 /* Check that no two specs can match the same section. */
754 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
756 struct wildcard_list *sec2;
757 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
759 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
764 signature = (sec_count << 8) + wild_name_count;
768 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
771 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
774 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
777 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
780 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
786 /* Now fill the data array with pointers to the specs, first the
787 specs with non-wildcard names, then the specs with wildcard
788 names. It's OK to process the specs in different order from the
789 given order, because we've already determined that no section
790 will match more than one spec. */
792 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
793 if (!wildcardp (sec->spec.name))
794 ptr->handler_data[data_counter++] = sec;
795 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
796 if (wildcardp (sec->spec.name))
797 ptr->handler_data[data_counter++] = sec;
800 /* Handle a wild statement for a single file F. */
803 walk_wild_file (lang_wild_statement_type *s,
804 lang_input_statement_type *f,
808 if (f->the_bfd == NULL
809 || ! bfd_check_format (f->the_bfd, bfd_archive))
810 walk_wild_section (s, f, callback, data);
815 /* This is an archive file. We must map each member of the
816 archive separately. */
817 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
818 while (member != NULL)
820 /* When lookup_name is called, it will call the add_symbols
821 entry point for the archive. For each element of the
822 archive which is included, BFD will call ldlang_add_file,
823 which will set the usrdata field of the member to the
824 lang_input_statement. */
825 if (member->usrdata != NULL)
827 walk_wild_section (s,
828 (lang_input_statement_type *) member->usrdata,
832 member = bfd_openr_next_archived_file (f->the_bfd, member);
838 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
840 const char *file_spec = s->filename;
843 if (file_spec == NULL)
845 /* Perform the iteration over all files in the list. */
846 LANG_FOR_EACH_INPUT_STATEMENT (f)
848 walk_wild_file (s, f, callback, data);
851 else if ((p = archive_path (file_spec)) != NULL)
853 LANG_FOR_EACH_INPUT_STATEMENT (f)
855 if (input_statement_is_archive_path (file_spec, p, f))
856 walk_wild_file (s, f, callback, data);
859 else if (wildcardp (file_spec))
861 LANG_FOR_EACH_INPUT_STATEMENT (f)
863 if (fnmatch (file_spec, f->filename, 0) == 0)
864 walk_wild_file (s, f, callback, data);
869 lang_input_statement_type *f;
871 /* Perform the iteration over a single file. */
872 f = lookup_name (file_spec);
874 walk_wild_file (s, f, callback, data);
878 /* lang_for_each_statement walks the parse tree and calls the provided
879 function for each node, except those inside output section statements
880 with constraint set to -1. */
883 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
884 lang_statement_union_type *s)
886 for (; s != NULL; s = s->header.next)
890 switch (s->header.type)
892 case lang_constructors_statement_enum:
893 lang_for_each_statement_worker (func, constructor_list.head);
895 case lang_output_section_statement_enum:
896 if (s->output_section_statement.constraint != -1)
897 lang_for_each_statement_worker
898 (func, s->output_section_statement.children.head);
900 case lang_wild_statement_enum:
901 lang_for_each_statement_worker (func,
902 s->wild_statement.children.head);
904 case lang_group_statement_enum:
905 lang_for_each_statement_worker (func,
906 s->group_statement.children.head);
908 case lang_data_statement_enum:
909 case lang_reloc_statement_enum:
910 case lang_object_symbols_statement_enum:
911 case lang_output_statement_enum:
912 case lang_target_statement_enum:
913 case lang_input_section_enum:
914 case lang_input_statement_enum:
915 case lang_assignment_statement_enum:
916 case lang_padding_statement_enum:
917 case lang_address_statement_enum:
918 case lang_fill_statement_enum:
919 case lang_insert_statement_enum:
929 lang_for_each_statement (void (*func) (lang_statement_union_type *))
931 lang_for_each_statement_worker (func, statement_list.head);
934 /*----------------------------------------------------------------------*/
937 lang_list_init (lang_statement_list_type *list)
940 list->tail = &list->head;
944 push_stat_ptr (lang_statement_list_type *new_ptr)
946 if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
948 *stat_save_ptr++ = stat_ptr;
955 if (stat_save_ptr <= stat_save)
957 stat_ptr = *--stat_save_ptr;
960 /* Build a new statement node for the parse tree. */
962 static lang_statement_union_type *
963 new_statement (enum statement_enum type,
965 lang_statement_list_type *list)
967 lang_statement_union_type *new_stmt;
969 new_stmt = (lang_statement_union_type *) stat_alloc (size);
970 new_stmt->header.type = type;
971 new_stmt->header.next = NULL;
972 lang_statement_append (list, new_stmt, &new_stmt->header.next);
976 /* Build a new input file node for the language. There are several
977 ways in which we treat an input file, eg, we only look at symbols,
978 or prefix it with a -l etc.
980 We can be supplied with requests for input files more than once;
981 they may, for example be split over several lines like foo.o(.text)
982 foo.o(.data) etc, so when asked for a file we check that we haven't
983 got it already so we don't duplicate the bfd. */
985 static lang_input_statement_type *
986 new_afile (const char *name,
987 lang_input_file_enum_type file_type,
989 bfd_boolean add_to_list)
991 lang_input_statement_type *p;
994 p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
997 p = (lang_input_statement_type *)
998 stat_alloc (sizeof (lang_input_statement_type));
999 p->header.type = lang_input_statement_enum;
1000 p->header.next = NULL;
1003 lang_has_input_file = TRUE;
1005 p->sysrooted = FALSE;
1007 if (file_type == lang_input_file_is_l_enum
1008 && name[0] == ':' && name[1] != '\0')
1010 file_type = lang_input_file_is_search_file_enum;
1016 case lang_input_file_is_symbols_only_enum:
1018 p->maybe_archive = FALSE;
1020 p->local_sym_name = name;
1021 p->just_syms_flag = TRUE;
1022 p->search_dirs_flag = FALSE;
1024 case lang_input_file_is_fake_enum:
1026 p->maybe_archive = FALSE;
1028 p->local_sym_name = name;
1029 p->just_syms_flag = FALSE;
1030 p->search_dirs_flag = FALSE;
1032 case lang_input_file_is_l_enum:
1033 p->maybe_archive = TRUE;
1036 p->local_sym_name = concat ("-l", name, (const char *) NULL);
1037 p->just_syms_flag = FALSE;
1038 p->search_dirs_flag = TRUE;
1040 case lang_input_file_is_marker_enum:
1042 p->maybe_archive = FALSE;
1044 p->local_sym_name = name;
1045 p->just_syms_flag = FALSE;
1046 p->search_dirs_flag = TRUE;
1048 case lang_input_file_is_search_file_enum:
1049 p->sysrooted = ldlang_sysrooted_script;
1051 p->maybe_archive = FALSE;
1053 p->local_sym_name = name;
1054 p->just_syms_flag = FALSE;
1055 p->search_dirs_flag = TRUE;
1057 case lang_input_file_is_file_enum:
1059 p->maybe_archive = FALSE;
1061 p->local_sym_name = name;
1062 p->just_syms_flag = FALSE;
1063 p->search_dirs_flag = FALSE;
1069 p->next_real_file = NULL;
1071 p->dynamic = config.dynamic_link;
1072 p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
1073 p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
1074 p->whole_archive = whole_archive;
1076 p->missing_file = FALSE;
1078 lang_statement_append (&input_file_chain,
1079 (lang_statement_union_type *) p,
1080 &p->next_real_file);
1084 lang_input_statement_type *
1085 lang_add_input_file (const char *name,
1086 lang_input_file_enum_type file_type,
1089 return new_afile (name, file_type, target, TRUE);
1092 struct out_section_hash_entry
1094 struct bfd_hash_entry root;
1095 lang_statement_union_type s;
1098 /* The hash table. */
1100 static struct bfd_hash_table output_section_statement_table;
1102 /* Support routines for the hash table used by lang_output_section_find,
1103 initialize the table, fill in an entry and remove the table. */
1105 static struct bfd_hash_entry *
1106 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1107 struct bfd_hash_table *table,
1110 lang_output_section_statement_type **nextp;
1111 struct out_section_hash_entry *ret;
1115 entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1121 entry = bfd_hash_newfunc (entry, table, string);
1125 ret = (struct out_section_hash_entry *) entry;
1126 memset (&ret->s, 0, sizeof (ret->s));
1127 ret->s.header.type = lang_output_section_statement_enum;
1128 ret->s.output_section_statement.subsection_alignment = -1;
1129 ret->s.output_section_statement.section_alignment = -1;
1130 ret->s.output_section_statement.block_value = 1;
1131 lang_list_init (&ret->s.output_section_statement.children);
1132 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1134 /* For every output section statement added to the list, except the
1135 first one, lang_output_section_statement.tail points to the "next"
1136 field of the last element of the list. */
1137 if (lang_output_section_statement.head != NULL)
1138 ret->s.output_section_statement.prev
1139 = ((lang_output_section_statement_type *)
1140 ((char *) lang_output_section_statement.tail
1141 - offsetof (lang_output_section_statement_type, next)));
1143 /* GCC's strict aliasing rules prevent us from just casting the
1144 address, so we store the pointer in a variable and cast that
1146 nextp = &ret->s.output_section_statement.next;
1147 lang_statement_append (&lang_output_section_statement,
1149 (lang_statement_union_type **) nextp);
1154 output_section_statement_table_init (void)
1156 if (!bfd_hash_table_init_n (&output_section_statement_table,
1157 output_section_statement_newfunc,
1158 sizeof (struct out_section_hash_entry),
1160 einfo (_("%P%F: can not create hash table: %E\n"));
1164 output_section_statement_table_free (void)
1166 bfd_hash_table_free (&output_section_statement_table);
1169 /* Build enough state so that the parser can build its tree. */
1174 obstack_begin (&stat_obstack, 1000);
1176 stat_ptr = &statement_list;
1178 output_section_statement_table_init ();
1180 lang_list_init (stat_ptr);
1182 lang_list_init (&input_file_chain);
1183 lang_list_init (&lang_output_section_statement);
1184 lang_list_init (&file_chain);
1185 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1187 abs_output_section =
1188 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1190 abs_output_section->bfd_section = bfd_abs_section_ptr;
1192 /* The value "3" is ad-hoc, somewhat related to the expected number of
1193 DEFINED expressions in a linker script. For most default linker
1194 scripts, there are none. Why a hash table then? Well, it's somewhat
1195 simpler to re-use working machinery than using a linked list in terms
1196 of code-complexity here in ld, besides the initialization which just
1197 looks like other code here. */
1198 if (!bfd_hash_table_init_n (&lang_definedness_table,
1199 lang_definedness_newfunc,
1200 sizeof (struct lang_definedness_hash_entry),
1202 einfo (_("%P%F: can not create hash table: %E\n"));
1208 output_section_statement_table_free ();
1211 /*----------------------------------------------------------------------
1212 A region is an area of memory declared with the
1213 MEMORY { name:org=exp, len=exp ... }
1216 We maintain a list of all the regions here.
1218 If no regions are specified in the script, then the default is used
1219 which is created when looked up to be the entire data space.
1221 If create is true we are creating a region inside a MEMORY block.
1222 In this case it is probably an error to create a region that has
1223 already been created. If we are not inside a MEMORY block it is
1224 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1225 and so we issue a warning.
1227 Each region has at least one name. The first name is either
1228 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1229 alias names to an existing region within a script with
1230 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1233 static lang_memory_region_type *lang_memory_region_list;
1234 static lang_memory_region_type **lang_memory_region_list_tail
1235 = &lang_memory_region_list;
1237 lang_memory_region_type *
1238 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1240 lang_memory_region_name *n;
1241 lang_memory_region_type *r;
1242 lang_memory_region_type *new_region;
1244 /* NAME is NULL for LMA memspecs if no region was specified. */
1248 for (r = lang_memory_region_list; r != NULL; r = r->next)
1249 for (n = &r->name_list; n != NULL; n = n->next)
1250 if (strcmp (n->name, name) == 0)
1253 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1258 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1259 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);
1261 new_region = (lang_memory_region_type *)
1262 stat_alloc (sizeof (lang_memory_region_type));
1264 new_region->name_list.name = xstrdup (name);
1265 new_region->name_list.next = NULL;
1266 new_region->next = NULL;
1267 new_region->origin = 0;
1268 new_region->length = ~(bfd_size_type) 0;
1269 new_region->current = 0;
1270 new_region->last_os = NULL;
1271 new_region->flags = 0;
1272 new_region->not_flags = 0;
1273 new_region->had_full_message = FALSE;
1275 *lang_memory_region_list_tail = new_region;
1276 lang_memory_region_list_tail = &new_region->next;
1282 lang_memory_region_alias (const char * alias, const char * region_name)
1284 lang_memory_region_name * n;
1285 lang_memory_region_type * r;
1286 lang_memory_region_type * region;
1288 /* The default region must be unique. This ensures that it is not necessary
1289 to iterate through the name list if someone wants the check if a region is
1290 the default memory region. */
1291 if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1292 || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1293 einfo (_("%F%P:%S: error: alias for default memory region\n"));
1295 /* Look for the target region and check if the alias is not already
1298 for (r = lang_memory_region_list; r != NULL; r = r->next)
1299 for (n = &r->name_list; n != NULL; n = n->next)
1301 if (region == NULL && strcmp (n->name, region_name) == 0)
1303 if (strcmp (n->name, alias) == 0)
1304 einfo (_("%F%P:%S: error: redefinition of memory region "
1309 /* Check if the target region exists. */
1311 einfo (_("%F%P:%S: error: memory region `%s' "
1312 "for alias `%s' does not exist\n"),
1316 /* Add alias to region name list. */
1317 n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
1318 n->name = xstrdup (alias);
1319 n->next = region->name_list.next;
1320 region->name_list.next = n;
1323 static lang_memory_region_type *
1324 lang_memory_default (asection * section)
1326 lang_memory_region_type *p;
1328 flagword sec_flags = section->flags;
1330 /* Override SEC_DATA to mean a writable section. */
1331 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1332 sec_flags |= SEC_DATA;
1334 for (p = lang_memory_region_list; p != NULL; p = p->next)
1336 if ((p->flags & sec_flags) != 0
1337 && (p->not_flags & sec_flags) == 0)
1342 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1345 /* Find or create an output_section_statement with the given NAME.
1346 If CONSTRAINT is non-zero match one with that constraint, otherwise
1347 match any non-negative constraint. If CREATE, always make a
1348 new output_section_statement for SPECIAL CONSTRAINT. */
1350 lang_output_section_statement_type *
1351 lang_output_section_statement_lookup (const char *name,
1355 struct out_section_hash_entry *entry;
1357 entry = ((struct out_section_hash_entry *)
1358 bfd_hash_lookup (&output_section_statement_table, name,
1363 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1367 if (entry->s.output_section_statement.name != NULL)
1369 /* We have a section of this name, but it might not have the correct
1371 struct out_section_hash_entry *last_ent;
1373 name = entry->s.output_section_statement.name;
1374 if (create && constraint == SPECIAL)
1375 /* Not traversing to the end reverses the order of the second
1376 and subsequent SPECIAL sections in the hash table chain,
1377 but that shouldn't matter. */
1382 if (constraint == entry->s.output_section_statement.constraint
1384 && entry->s.output_section_statement.constraint >= 0))
1385 return &entry->s.output_section_statement;
1387 entry = (struct out_section_hash_entry *) entry->root.next;
1389 while (entry != NULL
1390 && name == entry->s.output_section_statement.name);
1396 = ((struct out_section_hash_entry *)
1397 output_section_statement_newfunc (NULL,
1398 &output_section_statement_table,
1402 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1405 entry->root = last_ent->root;
1406 last_ent->root.next = &entry->root;
1409 entry->s.output_section_statement.name = name;
1410 entry->s.output_section_statement.constraint = constraint;
1411 return &entry->s.output_section_statement;
1414 /* Find the next output_section_statement with the same name as OS.
1415 If CONSTRAINT is non-zero, find one with that constraint otherwise
1416 match any non-negative constraint. */
1418 lang_output_section_statement_type *
1419 next_matching_output_section_statement (lang_output_section_statement_type *os,
1422 /* All output_section_statements are actually part of a
1423 struct out_section_hash_entry. */
1424 struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1426 - offsetof (struct out_section_hash_entry, s.output_section_statement));
1427 const char *name = os->name;
1429 ASSERT (name == entry->root.string);
1432 entry = (struct out_section_hash_entry *) entry->root.next;
1434 || name != entry->s.output_section_statement.name)
1437 while (constraint != entry->s.output_section_statement.constraint
1439 || entry->s.output_section_statement.constraint < 0));
1441 return &entry->s.output_section_statement;
1444 /* A variant of lang_output_section_find used by place_orphan.
1445 Returns the output statement that should precede a new output
1446 statement for SEC. If an exact match is found on certain flags,
1449 lang_output_section_statement_type *
1450 lang_output_section_find_by_flags (const asection *sec,
1451 lang_output_section_statement_type **exact,
1452 lang_match_sec_type_func match_type)
1454 lang_output_section_statement_type *first, *look, *found;
1457 /* We know the first statement on this list is *ABS*. May as well
1459 first = &lang_output_section_statement.head->output_section_statement;
1460 first = first->next;
1462 /* First try for an exact match. */
1464 for (look = first; look; look = look->next)
1466 flags = look->flags;
1467 if (look->bfd_section != NULL)
1469 flags = look->bfd_section->flags;
1470 if (match_type && !match_type (link_info.output_bfd,
1475 flags ^= sec->flags;
1476 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1477 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1487 if ((sec->flags & SEC_CODE) != 0
1488 && (sec->flags & SEC_ALLOC) != 0)
1490 /* Try for a rw code section. */
1491 for (look = first; look; look = look->next)
1493 flags = look->flags;
1494 if (look->bfd_section != NULL)
1496 flags = look->bfd_section->flags;
1497 if (match_type && !match_type (link_info.output_bfd,
1502 flags ^= sec->flags;
1503 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1504 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1508 else if ((sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) != 0
1509 && (sec->flags & SEC_ALLOC) != 0)
1511 /* .rodata can go after .text, .sdata2 after .rodata. */
1512 for (look = first; look; look = look->next)
1514 flags = look->flags;
1515 if (look->bfd_section != NULL)
1517 flags = look->bfd_section->flags;
1518 if (match_type && !match_type (link_info.output_bfd,
1523 flags ^= sec->flags;
1524 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1526 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1530 else if ((sec->flags & SEC_SMALL_DATA) != 0
1531 && (sec->flags & SEC_ALLOC) != 0)
1533 /* .sdata goes after .data, .sbss after .sdata. */
1534 for (look = first; look; look = look->next)
1536 flags = look->flags;
1537 if (look->bfd_section != NULL)
1539 flags = look->bfd_section->flags;
1540 if (match_type && !match_type (link_info.output_bfd,
1545 flags ^= sec->flags;
1546 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1547 | SEC_THREAD_LOCAL))
1548 || ((look->flags & SEC_SMALL_DATA)
1549 && !(sec->flags & SEC_HAS_CONTENTS)))
1553 else if ((sec->flags & SEC_HAS_CONTENTS) != 0
1554 && (sec->flags & SEC_ALLOC) != 0)
1556 /* .data goes after .rodata. */
1557 for (look = first; look; look = look->next)
1559 flags = look->flags;
1560 if (look->bfd_section != NULL)
1562 flags = look->bfd_section->flags;
1563 if (match_type && !match_type (link_info.output_bfd,
1568 flags ^= sec->flags;
1569 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1570 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1574 else if ((sec->flags & SEC_ALLOC) != 0)
1576 /* .bss goes after any other alloc section. */
1577 for (look = first; look; look = look->next)
1579 flags = look->flags;
1580 if (look->bfd_section != NULL)
1582 flags = look->bfd_section->flags;
1583 if (match_type && !match_type (link_info.output_bfd,
1588 flags ^= sec->flags;
1589 if (!(flags & SEC_ALLOC))
1595 /* non-alloc go last. */
1596 for (look = first; look; look = look->next)
1598 flags = look->flags;
1599 if (look->bfd_section != NULL)
1600 flags = look->bfd_section->flags;
1601 flags ^= sec->flags;
1602 if (!(flags & SEC_DEBUGGING))
1608 if (found || !match_type)
1611 return lang_output_section_find_by_flags (sec, NULL, NULL);
1614 /* Find the last output section before given output statement.
1615 Used by place_orphan. */
1618 output_prev_sec_find (lang_output_section_statement_type *os)
1620 lang_output_section_statement_type *lookup;
1622 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1624 if (lookup->constraint < 0)
1627 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1628 return lookup->bfd_section;
1634 /* Look for a suitable place for a new output section statement. The
1635 idea is to skip over anything that might be inside a SECTIONS {}
1636 statement in a script, before we find another output section
1637 statement. Assignments to "dot" before an output section statement
1638 are assumed to belong to it, except in two cases; The first
1639 assignment to dot, and assignments before non-alloc sections.
1640 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1641 similar assignments that set the initial address, or we might
1642 insert non-alloc note sections among assignments setting end of
1645 static lang_statement_union_type **
1646 insert_os_after (lang_output_section_statement_type *after)
1648 lang_statement_union_type **where;
1649 lang_statement_union_type **assign = NULL;
1650 bfd_boolean ignore_first;
1653 = after == &lang_output_section_statement.head->output_section_statement;
1655 for (where = &after->header.next;
1657 where = &(*where)->header.next)
1659 switch ((*where)->header.type)
1661 case lang_assignment_statement_enum:
1664 lang_assignment_statement_type *ass;
1666 ass = &(*where)->assignment_statement;
1667 if (ass->exp->type.node_class != etree_assert
1668 && ass->exp->assign.dst[0] == '.'
1669 && ass->exp->assign.dst[1] == 0
1673 ignore_first = FALSE;
1675 case lang_wild_statement_enum:
1676 case lang_input_section_enum:
1677 case lang_object_symbols_statement_enum:
1678 case lang_fill_statement_enum:
1679 case lang_data_statement_enum:
1680 case lang_reloc_statement_enum:
1681 case lang_padding_statement_enum:
1682 case lang_constructors_statement_enum:
1685 case lang_output_section_statement_enum:
1688 asection *s = (*where)->output_section_statement.bfd_section;
1691 || s->map_head.s == NULL
1692 || (s->flags & SEC_ALLOC) != 0)
1696 case lang_input_statement_enum:
1697 case lang_address_statement_enum:
1698 case lang_target_statement_enum:
1699 case lang_output_statement_enum:
1700 case lang_group_statement_enum:
1701 case lang_insert_statement_enum:
1710 lang_output_section_statement_type *
1711 lang_insert_orphan (asection *s,
1712 const char *secname,
1714 lang_output_section_statement_type *after,
1715 struct orphan_save *place,
1716 etree_type *address,
1717 lang_statement_list_type *add_child)
1719 lang_statement_list_type add;
1721 lang_output_section_statement_type *os;
1722 lang_output_section_statement_type **os_tail;
1724 /* If we have found an appropriate place for the output section
1725 statements for this orphan, add them to our own private list,
1726 inserting them later into the global statement list. */
1729 lang_list_init (&add);
1730 push_stat_ptr (&add);
1733 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1734 address = exp_intop (0);
1736 os_tail = ((lang_output_section_statement_type **)
1737 lang_output_section_statement.tail);
1738 os = lang_enter_output_section_statement (secname, address, normal_section,
1739 NULL, NULL, NULL, constraint);
1742 if (config.build_constructors && *os_tail == os)
1744 /* If the name of the section is representable in C, then create
1745 symbols to mark the start and the end of the section. */
1746 for (ps = secname; *ps != '\0'; ps++)
1747 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1752 etree_type *e_align;
1754 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1755 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1756 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1757 e_align = exp_unop (ALIGN_K,
1758 exp_intop ((bfd_vma) 1 << s->alignment_power));
1759 lang_add_assignment (exp_assign (".", e_align));
1760 lang_add_assignment (exp_provide (symname,
1762 exp_nameop (NAME, ".")),
1767 if (add_child == NULL)
1768 add_child = &os->children;
1769 lang_add_section (add_child, s, os);
1771 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1773 const char *region = (after->region
1774 ? after->region->name_list.name
1775 : DEFAULT_MEMORY_REGION);
1776 const char *lma_region = (after->lma_region
1777 ? after->lma_region->name_list.name
1779 lang_leave_output_section_statement (NULL, region, after->phdrs,
1783 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1786 if (ps != NULL && *ps == '\0')
1790 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1791 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1792 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1793 lang_add_assignment (exp_provide (symname,
1794 exp_nameop (NAME, "."),
1798 /* Restore the global list pointer. */
1802 if (after != NULL && os->bfd_section != NULL)
1804 asection *snew, *as;
1806 snew = os->bfd_section;
1808 /* Shuffle the bfd section list to make the output file look
1809 neater. This is really only cosmetic. */
1810 if (place->section == NULL
1811 && after != (&lang_output_section_statement.head
1812 ->output_section_statement))
1814 asection *bfd_section = after->bfd_section;
1816 /* If the output statement hasn't been used to place any input
1817 sections (and thus doesn't have an output bfd_section),
1818 look for the closest prior output statement having an
1820 if (bfd_section == NULL)
1821 bfd_section = output_prev_sec_find (after);
1823 if (bfd_section != NULL && bfd_section != snew)
1824 place->section = &bfd_section->next;
1827 if (place->section == NULL)
1828 place->section = &link_info.output_bfd->sections;
1830 as = *place->section;
1834 /* Put the section at the end of the list. */
1836 /* Unlink the section. */
1837 bfd_section_list_remove (link_info.output_bfd, snew);
1839 /* Now tack it back on in the right place. */
1840 bfd_section_list_append (link_info.output_bfd, snew);
1842 else if (as != snew && as->prev != snew)
1844 /* Unlink the section. */
1845 bfd_section_list_remove (link_info.output_bfd, snew);
1847 /* Now tack it back on in the right place. */
1848 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1851 /* Save the end of this list. Further ophans of this type will
1852 follow the one we've just added. */
1853 place->section = &snew->next;
1855 /* The following is non-cosmetic. We try to put the output
1856 statements in some sort of reasonable order here, because they
1857 determine the final load addresses of the orphan sections.
1858 In addition, placing output statements in the wrong order may
1859 require extra segments. For instance, given a typical
1860 situation of all read-only sections placed in one segment and
1861 following that a segment containing all the read-write
1862 sections, we wouldn't want to place an orphan read/write
1863 section before or amongst the read-only ones. */
1864 if (add.head != NULL)
1866 lang_output_section_statement_type *newly_added_os;
1868 if (place->stmt == NULL)
1870 lang_statement_union_type **where = insert_os_after (after);
1875 place->os_tail = &after->next;
1879 /* Put it after the last orphan statement we added. */
1880 *add.tail = *place->stmt;
1881 *place->stmt = add.head;
1884 /* Fix the global list pointer if we happened to tack our
1885 new list at the tail. */
1886 if (*stat_ptr->tail == add.head)
1887 stat_ptr->tail = add.tail;
1889 /* Save the end of this list. */
1890 place->stmt = add.tail;
1892 /* Do the same for the list of output section statements. */
1893 newly_added_os = *os_tail;
1895 newly_added_os->prev = (lang_output_section_statement_type *)
1896 ((char *) place->os_tail
1897 - offsetof (lang_output_section_statement_type, next));
1898 newly_added_os->next = *place->os_tail;
1899 if (newly_added_os->next != NULL)
1900 newly_added_os->next->prev = newly_added_os;
1901 *place->os_tail = newly_added_os;
1902 place->os_tail = &newly_added_os->next;
1904 /* Fixing the global list pointer here is a little different.
1905 We added to the list in lang_enter_output_section_statement,
1906 trimmed off the new output_section_statment above when
1907 assigning *os_tail = NULL, but possibly added it back in
1908 the same place when assigning *place->os_tail. */
1909 if (*os_tail == NULL)
1910 lang_output_section_statement.tail
1911 = (lang_statement_union_type **) os_tail;
1918 lang_map_flags (flagword flag)
1920 if (flag & SEC_ALLOC)
1923 if (flag & SEC_CODE)
1926 if (flag & SEC_READONLY)
1929 if (flag & SEC_DATA)
1932 if (flag & SEC_LOAD)
1939 lang_memory_region_type *m;
1940 bfd_boolean dis_header_printed = FALSE;
1943 LANG_FOR_EACH_INPUT_STATEMENT (file)
1947 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1948 || file->just_syms_flag)
1951 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1952 if ((s->output_section == NULL
1953 || s->output_section->owner != link_info.output_bfd)
1954 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1956 if (! dis_header_printed)
1958 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1959 dis_header_printed = TRUE;
1962 print_input_section (s, TRUE);
1966 minfo (_("\nMemory Configuration\n\n"));
1967 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1968 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1970 for (m = lang_memory_region_list; m != NULL; m = m->next)
1975 fprintf (config.map_file, "%-16s ", m->name_list.name);
1977 sprintf_vma (buf, m->origin);
1978 minfo ("0x%s ", buf);
1986 minfo ("0x%V", m->length);
1987 if (m->flags || m->not_flags)
1995 lang_map_flags (m->flags);
2001 lang_map_flags (m->not_flags);
2008 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2010 if (! link_info.reduce_memory_overheads)
2012 obstack_begin (&map_obstack, 1000);
2013 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2014 bfd_map_over_sections (p, init_map_userdata, 0);
2015 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2017 lang_statement_iteration ++;
2018 print_statements ();
2022 init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2024 void *data ATTRIBUTE_UNUSED)
2026 fat_section_userdata_type *new_data
2027 = ((fat_section_userdata_type *) (stat_alloc
2028 (sizeof (fat_section_userdata_type))));
2030 ASSERT (get_userdata (sec) == NULL);
2031 get_userdata (sec) = new_data;
2032 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2033 new_data->map_symbol_def_count = 0;
2037 sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2038 void *info ATTRIBUTE_UNUSED)
2040 if (hash_entry->type == bfd_link_hash_warning)
2041 hash_entry = (struct bfd_link_hash_entry *) hash_entry->u.i.link;
2043 if (hash_entry->type == bfd_link_hash_defined
2044 || hash_entry->type == bfd_link_hash_defweak)
2046 struct fat_user_section_struct *ud;
2047 struct map_symbol_def *def;
2049 ud = (struct fat_user_section_struct *)
2050 get_userdata (hash_entry->u.def.section);
2053 /* ??? What do we have to do to initialize this beforehand? */
2054 /* The first time we get here is bfd_abs_section... */
2055 init_map_userdata (0, hash_entry->u.def.section, 0);
2056 ud = (struct fat_user_section_struct *)
2057 get_userdata (hash_entry->u.def.section);
2059 else if (!ud->map_symbol_def_tail)
2060 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2062 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2063 def->entry = hash_entry;
2064 *(ud->map_symbol_def_tail) = def;
2065 ud->map_symbol_def_tail = &def->next;
2066 ud->map_symbol_def_count++;
2071 /* Initialize an output section. */
2074 init_os (lang_output_section_statement_type *s, flagword flags)
2076 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2077 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2079 if (s->constraint != SPECIAL)
2080 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2081 if (s->bfd_section == NULL)
2082 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2084 if (s->bfd_section == NULL)
2086 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2087 link_info.output_bfd->xvec->name, s->name);
2089 s->bfd_section->output_section = s->bfd_section;
2090 s->bfd_section->output_offset = 0;
2092 if (!link_info.reduce_memory_overheads)
2094 fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2095 stat_alloc (sizeof (fat_section_userdata_type));
2096 memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2097 get_userdata (s->bfd_section) = new_userdata;
2100 /* If there is a base address, make sure that any sections it might
2101 mention are initialized. */
2102 if (s->addr_tree != NULL)
2103 exp_init_os (s->addr_tree);
2105 if (s->load_base != NULL)
2106 exp_init_os (s->load_base);
2108 /* If supplied an alignment, set it. */
2109 if (s->section_alignment != -1)
2110 s->bfd_section->alignment_power = s->section_alignment;
2113 /* Make sure that all output sections mentioned in an expression are
2117 exp_init_os (etree_type *exp)
2119 switch (exp->type.node_class)
2123 exp_init_os (exp->assign.src);
2127 exp_init_os (exp->binary.lhs);
2128 exp_init_os (exp->binary.rhs);
2132 exp_init_os (exp->trinary.cond);
2133 exp_init_os (exp->trinary.lhs);
2134 exp_init_os (exp->trinary.rhs);
2138 exp_init_os (exp->assert_s.child);
2142 exp_init_os (exp->unary.child);
2146 switch (exp->type.node_code)
2152 lang_output_section_statement_type *os;
2154 os = lang_output_section_find (exp->name.name);
2155 if (os != NULL && os->bfd_section == NULL)
2167 section_already_linked (bfd *abfd, asection *sec, void *data)
2169 lang_input_statement_type *entry = (lang_input_statement_type *) data;
2171 /* If we are only reading symbols from this object, then we want to
2172 discard all sections. */
2173 if (entry->just_syms_flag)
2175 bfd_link_just_syms (abfd, sec, &link_info);
2179 if (!(abfd->flags & DYNAMIC))
2180 bfd_section_already_linked (abfd, sec, &link_info);
2183 /* The wild routines.
2185 These expand statements like *(.text) and foo.o to a list of
2186 explicit actions, like foo.o(.text), bar.o(.text) and
2187 foo.o(.text, .data). */
2189 /* Add SECTION to the output section OUTPUT. Do this by creating a
2190 lang_input_section statement which is placed at PTR. FILE is the
2191 input file which holds SECTION. */
2194 lang_add_section (lang_statement_list_type *ptr,
2196 lang_output_section_statement_type *output)
2198 flagword flags = section->flags;
2199 bfd_boolean discard;
2200 lang_input_section_type *new_section;
2202 /* Discard sections marked with SEC_EXCLUDE. */
2203 discard = (flags & SEC_EXCLUDE) != 0;
2205 /* Discard input sections which are assigned to a section named
2206 DISCARD_SECTION_NAME. */
2207 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2210 /* Discard debugging sections if we are stripping debugging
2212 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2213 && (flags & SEC_DEBUGGING) != 0)
2218 if (section->output_section == NULL)
2220 /* This prevents future calls from assigning this section. */
2221 section->output_section = bfd_abs_section_ptr;
2226 if (section->output_section != NULL)
2229 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2230 to an output section, because we want to be able to include a
2231 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2232 section (I don't know why we want to do this, but we do).
2233 build_link_order in ldwrite.c handles this case by turning
2234 the embedded SEC_NEVER_LOAD section into a fill. */
2235 flags &= ~ SEC_NEVER_LOAD;
2237 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2238 already been processed. One reason to do this is that on pe
2239 format targets, .text$foo sections go into .text and it's odd
2240 to see .text with SEC_LINK_ONCE set. */
2242 if (!link_info.relocatable)
2243 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2245 switch (output->sectype)
2247 case normal_section:
2248 case overlay_section:
2250 case noalloc_section:
2251 flags &= ~SEC_ALLOC;
2253 case noload_section:
2255 flags |= SEC_NEVER_LOAD;
2256 /* Unfortunately GNU ld has managed to evolve two different
2257 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2258 alloc, no contents section. All others get a noload, noalloc
2260 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2261 flags &= ~SEC_HAS_CONTENTS;
2263 flags &= ~SEC_ALLOC;
2267 if (output->bfd_section == NULL)
2268 init_os (output, flags);
2270 /* If SEC_READONLY is not set in the input section, then clear
2271 it from the output section. */
2272 output->bfd_section->flags &= flags | ~SEC_READONLY;
2274 if (output->bfd_section->linker_has_input)
2276 /* Only set SEC_READONLY flag on the first input section. */
2277 flags &= ~ SEC_READONLY;
2279 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2280 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2281 != (flags & (SEC_MERGE | SEC_STRINGS))
2282 || ((flags & SEC_MERGE) != 0
2283 && output->bfd_section->entsize != section->entsize))
2285 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2286 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2289 output->bfd_section->flags |= flags;
2291 if (!output->bfd_section->linker_has_input)
2293 output->bfd_section->linker_has_input = 1;
2294 /* This must happen after flags have been updated. The output
2295 section may have been created before we saw its first input
2296 section, eg. for a data statement. */
2297 bfd_init_private_section_data (section->owner, section,
2298 link_info.output_bfd,
2299 output->bfd_section,
2301 if ((flags & SEC_MERGE) != 0)
2302 output->bfd_section->entsize = section->entsize;
2305 if ((flags & SEC_TIC54X_BLOCK) != 0
2306 && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2308 /* FIXME: This value should really be obtained from the bfd... */
2309 output->block_value = 128;
2312 if (section->alignment_power > output->bfd_section->alignment_power)
2313 output->bfd_section->alignment_power = section->alignment_power;
2315 section->output_section = output->bfd_section;
2317 if (!link_info.relocatable
2318 && !stripped_excluded_sections)
2320 asection *s = output->bfd_section->map_tail.s;
2321 output->bfd_section->map_tail.s = section;
2322 section->map_head.s = NULL;
2323 section->map_tail.s = s;
2325 s->map_head.s = section;
2327 output->bfd_section->map_head.s = section;
2330 /* Add a section reference to the list. */
2331 new_section = new_stat (lang_input_section, ptr);
2332 new_section->section = section;
2335 /* Handle wildcard sorting. This returns the lang_input_section which
2336 should follow the one we are going to create for SECTION and FILE,
2337 based on the sorting requirements of WILD. It returns NULL if the
2338 new section should just go at the end of the current list. */
2340 static lang_statement_union_type *
2341 wild_sort (lang_wild_statement_type *wild,
2342 struct wildcard_list *sec,
2343 lang_input_statement_type *file,
2346 lang_statement_union_type *l;
2348 if (!wild->filenames_sorted
2349 && (sec == NULL || sec->spec.sorted == none))
2352 for (l = wild->children.head; l != NULL; l = l->header.next)
2354 lang_input_section_type *ls;
2356 if (l->header.type != lang_input_section_enum)
2358 ls = &l->input_section;
2360 /* Sorting by filename takes precedence over sorting by section
2363 if (wild->filenames_sorted)
2365 const char *fn, *ln;
2369 /* The PE support for the .idata section as generated by
2370 dlltool assumes that files will be sorted by the name of
2371 the archive and then the name of the file within the
2374 if (file->the_bfd != NULL
2375 && bfd_my_archive (file->the_bfd) != NULL)
2377 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2382 fn = file->filename;
2386 if (bfd_my_archive (ls->section->owner) != NULL)
2388 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2393 ln = ls->section->owner->filename;
2397 i = strcmp (fn, ln);
2406 fn = file->filename;
2408 ln = ls->section->owner->filename;
2410 i = strcmp (fn, ln);
2418 /* Here either the files are not sorted by name, or we are
2419 looking at the sections for this file. */
2421 if (sec != NULL && sec->spec.sorted != none)
2422 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2429 /* Expand a wild statement for a particular FILE. SECTION may be
2430 NULL, in which case it is a wild card. */
2433 output_section_callback (lang_wild_statement_type *ptr,
2434 struct wildcard_list *sec,
2436 lang_input_statement_type *file,
2439 lang_statement_union_type *before;
2440 lang_output_section_statement_type *os;
2442 os = (lang_output_section_statement_type *) output;
2444 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2445 if (unique_section_p (section, os))
2448 before = wild_sort (ptr, sec, file, section);
2450 /* Here BEFORE points to the lang_input_section which
2451 should follow the one we are about to add. If BEFORE
2452 is NULL, then the section should just go at the end
2453 of the current list. */
2456 lang_add_section (&ptr->children, section, os);
2459 lang_statement_list_type list;
2460 lang_statement_union_type **pp;
2462 lang_list_init (&list);
2463 lang_add_section (&list, section, os);
2465 /* If we are discarding the section, LIST.HEAD will
2467 if (list.head != NULL)
2469 ASSERT (list.head->header.next == NULL);
2471 for (pp = &ptr->children.head;
2473 pp = &(*pp)->header.next)
2474 ASSERT (*pp != NULL);
2476 list.head->header.next = *pp;
2482 /* Check if all sections in a wild statement for a particular FILE
2486 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2487 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2489 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2492 lang_output_section_statement_type *os;
2494 os = (lang_output_section_statement_type *) output;
2496 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2497 if (unique_section_p (section, os))
2500 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2501 os->all_input_readonly = FALSE;
2504 /* This is passed a file name which must have been seen already and
2505 added to the statement tree. We will see if it has been opened
2506 already and had its symbols read. If not then we'll read it. */
2508 static lang_input_statement_type *
2509 lookup_name (const char *name)
2511 lang_input_statement_type *search;
2513 for (search = (lang_input_statement_type *) input_file_chain.head;
2515 search = (lang_input_statement_type *) search->next_real_file)
2517 /* Use the local_sym_name as the name of the file that has
2518 already been loaded as filename might have been transformed
2519 via the search directory lookup mechanism. */
2520 const char *filename = search->local_sym_name;
2522 if (filename != NULL
2523 && strcmp (filename, name) == 0)
2528 search = new_afile (name, lang_input_file_is_search_file_enum,
2529 default_target, FALSE);
2531 /* If we have already added this file, or this file is not real
2532 don't add this file. */
2533 if (search->loaded || !search->real)
2536 if (! load_symbols (search, NULL))
2542 /* Save LIST as a list of libraries whose symbols should not be exported. */
2547 struct excluded_lib *next;
2549 static struct excluded_lib *excluded_libs;
2552 add_excluded_libs (const char *list)
2554 const char *p = list, *end;
2558 struct excluded_lib *entry;
2559 end = strpbrk (p, ",:");
2561 end = p + strlen (p);
2562 entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2563 entry->next = excluded_libs;
2564 entry->name = (char *) xmalloc (end - p + 1);
2565 memcpy (entry->name, p, end - p);
2566 entry->name[end - p] = '\0';
2567 excluded_libs = entry;
2575 check_excluded_libs (bfd *abfd)
2577 struct excluded_lib *lib = excluded_libs;
2581 int len = strlen (lib->name);
2582 const char *filename = lbasename (abfd->filename);
2584 if (strcmp (lib->name, "ALL") == 0)
2586 abfd->no_export = TRUE;
2590 if (strncmp (lib->name, filename, len) == 0
2591 && (filename[len] == '\0'
2592 || (filename[len] == '.' && filename[len + 1] == 'a'
2593 && filename[len + 2] == '\0')))
2595 abfd->no_export = TRUE;
2603 /* Get the symbols for an input file. */
2606 load_symbols (lang_input_statement_type *entry,
2607 lang_statement_list_type *place)
2614 ldfile_open_file (entry);
2616 /* Do not process further if the file was missing. */
2617 if (entry->missing_file)
2620 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2621 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2624 bfd_boolean save_ldlang_sysrooted_script;
2625 bfd_boolean save_add_DT_NEEDED_for_regular;
2626 bfd_boolean save_add_DT_NEEDED_for_dynamic;
2627 bfd_boolean save_whole_archive;
2629 err = bfd_get_error ();
2631 /* See if the emulation has some special knowledge. */
2632 if (ldemul_unrecognized_file (entry))
2635 if (err == bfd_error_file_ambiguously_recognized)
2639 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2640 einfo (_("%B: matching formats:"), entry->the_bfd);
2641 for (p = matching; *p != NULL; p++)
2645 else if (err != bfd_error_file_not_recognized
2647 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2649 bfd_close (entry->the_bfd);
2650 entry->the_bfd = NULL;
2652 /* Try to interpret the file as a linker script. */
2653 ldfile_open_command_file (entry->filename);
2655 push_stat_ptr (place);
2656 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2657 ldlang_sysrooted_script = entry->sysrooted;
2658 save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2659 add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2660 save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2661 add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2662 save_whole_archive = whole_archive;
2663 whole_archive = entry->whole_archive;
2665 ldfile_assumed_script = TRUE;
2666 parser_input = input_script;
2667 /* We want to use the same -Bdynamic/-Bstatic as the one for
2669 config.dynamic_link = entry->dynamic;
2671 ldfile_assumed_script = FALSE;
2673 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2674 add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2675 add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2676 whole_archive = save_whole_archive;
2682 if (ldemul_recognized_file (entry))
2685 /* We don't call ldlang_add_file for an archive. Instead, the
2686 add_symbols entry point will call ldlang_add_file, via the
2687 add_archive_element callback, for each element of the archive
2689 switch (bfd_get_format (entry->the_bfd))
2695 ldlang_add_file (entry);
2696 if (trace_files || trace_file_tries)
2697 info_msg ("%I\n", entry);
2701 check_excluded_libs (entry->the_bfd);
2703 if (entry->whole_archive)
2706 bfd_boolean loaded = TRUE;
2711 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2716 if (! bfd_check_format (member, bfd_object))
2718 einfo (_("%F%B: member %B in archive is not an object\n"),
2719 entry->the_bfd, member);
2724 if (!(*link_info.callbacks
2725 ->add_archive_element) (&link_info, member,
2726 "--whole-archive", &subsbfd))
2729 /* Potentially, the add_archive_element hook may have set a
2730 substitute BFD for us. */
2731 if (!bfd_link_add_symbols (subsbfd, &link_info))
2733 einfo (_("%F%B: could not read symbols: %E\n"), member);
2738 entry->loaded = loaded;
2744 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2745 entry->loaded = TRUE;
2747 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2749 return entry->loaded;
2752 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2753 may be NULL, indicating that it is a wildcard. Separate
2754 lang_input_section statements are created for each part of the
2755 expansion; they are added after the wild statement S. OUTPUT is
2756 the output section. */
2759 wild (lang_wild_statement_type *s,
2760 const char *target ATTRIBUTE_UNUSED,
2761 lang_output_section_statement_type *output)
2763 struct wildcard_list *sec;
2765 if (s->handler_data[0]
2766 && s->handler_data[0]->spec.sorted == by_name
2767 && !s->filenames_sorted)
2769 lang_section_bst_type *tree;
2771 walk_wild (s, output_section_callback_fast, output);
2776 output_section_callback_tree_to_list (s, tree, output);
2781 walk_wild (s, output_section_callback, output);
2783 if (default_common_section == NULL)
2784 for (sec = s->section_list; sec != NULL; sec = sec->next)
2785 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2787 /* Remember the section that common is going to in case we
2788 later get something which doesn't know where to put it. */
2789 default_common_section = output;
2794 /* Return TRUE iff target is the sought target. */
2797 get_target (const bfd_target *target, void *data)
2799 const char *sought = (const char *) data;
2801 return strcmp (target->name, sought) == 0;
2804 /* Like strcpy() but convert to lower case as well. */
2807 stricpy (char *dest, char *src)
2811 while ((c = *src++) != 0)
2812 *dest++ = TOLOWER (c);
2817 /* Remove the first occurrence of needle (if any) in haystack
2821 strcut (char *haystack, char *needle)
2823 haystack = strstr (haystack, needle);
2829 for (src = haystack + strlen (needle); *src;)
2830 *haystack++ = *src++;
2836 /* Compare two target format name strings.
2837 Return a value indicating how "similar" they are. */
2840 name_compare (char *first, char *second)
2846 copy1 = (char *) xmalloc (strlen (first) + 1);
2847 copy2 = (char *) xmalloc (strlen (second) + 1);
2849 /* Convert the names to lower case. */
2850 stricpy (copy1, first);
2851 stricpy (copy2, second);
2853 /* Remove size and endian strings from the name. */
2854 strcut (copy1, "big");
2855 strcut (copy1, "little");
2856 strcut (copy2, "big");
2857 strcut (copy2, "little");
2859 /* Return a value based on how many characters match,
2860 starting from the beginning. If both strings are
2861 the same then return 10 * their length. */
2862 for (result = 0; copy1[result] == copy2[result]; result++)
2863 if (copy1[result] == 0)
2875 /* Set by closest_target_match() below. */
2876 static const bfd_target *winner;
2878 /* Scan all the valid bfd targets looking for one that has the endianness
2879 requirement that was specified on the command line, and is the nearest
2880 match to the original output target. */
2883 closest_target_match (const bfd_target *target, void *data)
2885 const bfd_target *original = (const bfd_target *) data;
2887 if (command_line.endian == ENDIAN_BIG
2888 && target->byteorder != BFD_ENDIAN_BIG)
2891 if (command_line.endian == ENDIAN_LITTLE
2892 && target->byteorder != BFD_ENDIAN_LITTLE)
2895 /* Must be the same flavour. */
2896 if (target->flavour != original->flavour)
2899 /* Ignore generic big and little endian elf vectors. */
2900 if (strcmp (target->name, "elf32-big") == 0
2901 || strcmp (target->name, "elf64-big") == 0
2902 || strcmp (target->name, "elf32-little") == 0
2903 || strcmp (target->name, "elf64-little") == 0)
2906 /* If we have not found a potential winner yet, then record this one. */
2913 /* Oh dear, we now have two potential candidates for a successful match.
2914 Compare their names and choose the better one. */
2915 if (name_compare (target->name, original->name)
2916 > name_compare (winner->name, original->name))
2919 /* Keep on searching until wqe have checked them all. */
2923 /* Return the BFD target format of the first input file. */
2926 get_first_input_target (void)
2928 char *target = NULL;
2930 LANG_FOR_EACH_INPUT_STATEMENT (s)
2932 if (s->header.type == lang_input_statement_enum
2935 ldfile_open_file (s);
2937 if (s->the_bfd != NULL
2938 && bfd_check_format (s->the_bfd, bfd_object))
2940 target = bfd_get_target (s->the_bfd);
2952 lang_get_output_target (void)
2956 /* Has the user told us which output format to use? */
2957 if (output_target != NULL)
2958 return output_target;
2960 /* No - has the current target been set to something other than
2962 if (current_target != default_target)
2963 return current_target;
2965 /* No - can we determine the format of the first input file? */
2966 target = get_first_input_target ();
2970 /* Failed - use the default output target. */
2971 return default_target;
2974 /* Open the output file. */
2977 open_output (const char *name)
2979 output_target = lang_get_output_target ();
2981 /* Has the user requested a particular endianness on the command
2983 if (command_line.endian != ENDIAN_UNSET)
2985 const bfd_target *target;
2986 enum bfd_endian desired_endian;
2988 /* Get the chosen target. */
2989 target = bfd_search_for_target (get_target, (void *) output_target);
2991 /* If the target is not supported, we cannot do anything. */
2994 if (command_line.endian == ENDIAN_BIG)
2995 desired_endian = BFD_ENDIAN_BIG;
2997 desired_endian = BFD_ENDIAN_LITTLE;
2999 /* See if the target has the wrong endianness. This should
3000 not happen if the linker script has provided big and
3001 little endian alternatives, but some scrips don't do
3003 if (target->byteorder != desired_endian)
3005 /* If it does, then see if the target provides
3006 an alternative with the correct endianness. */
3007 if (target->alternative_target != NULL
3008 && (target->alternative_target->byteorder == desired_endian))
3009 output_target = target->alternative_target->name;
3012 /* Try to find a target as similar as possible to
3013 the default target, but which has the desired
3014 endian characteristic. */
3015 bfd_search_for_target (closest_target_match,
3018 /* Oh dear - we could not find any targets that
3019 satisfy our requirements. */
3021 einfo (_("%P: warning: could not find any targets"
3022 " that match endianness requirement\n"));
3024 output_target = winner->name;
3030 link_info.output_bfd = bfd_openw (name, output_target);
3032 if (link_info.output_bfd == NULL)
3034 if (bfd_get_error () == bfd_error_invalid_target)
3035 einfo (_("%P%F: target %s not found\n"), output_target);
3037 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3040 delete_output_file_on_failure = TRUE;
3042 if (! bfd_set_format (link_info.output_bfd, bfd_object))
3043 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3044 if (! bfd_set_arch_mach (link_info.output_bfd,
3045 ldfile_output_architecture,
3046 ldfile_output_machine))
3047 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3049 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3050 if (link_info.hash == NULL)
3051 einfo (_("%P%F: can not create hash table: %E\n"));
3053 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3057 ldlang_open_output (lang_statement_union_type *statement)
3059 switch (statement->header.type)
3061 case lang_output_statement_enum:
3062 ASSERT (link_info.output_bfd == NULL);
3063 open_output (statement->output_statement.name);
3064 ldemul_set_output_arch ();
3065 if (config.magic_demand_paged && !link_info.relocatable)
3066 link_info.output_bfd->flags |= D_PAGED;
3068 link_info.output_bfd->flags &= ~D_PAGED;
3069 if (config.text_read_only)
3070 link_info.output_bfd->flags |= WP_TEXT;
3072 link_info.output_bfd->flags &= ~WP_TEXT;
3073 if (link_info.traditional_format)
3074 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3076 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3079 case lang_target_statement_enum:
3080 current_target = statement->target_statement.target;
3087 /* Convert between addresses in bytes and sizes in octets.
3088 For currently supported targets, octets_per_byte is always a power
3089 of two, so we can use shifts. */
3090 #define TO_ADDR(X) ((X) >> opb_shift)
3091 #define TO_SIZE(X) ((X) << opb_shift)
3093 /* Support the above. */
3094 static unsigned int opb_shift = 0;
3099 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3100 ldfile_output_machine);
3103 while ((x & 1) == 0)
3111 /* Open all the input files. */
3114 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
3116 for (; s != NULL; s = s->header.next)
3118 switch (s->header.type)
3120 case lang_constructors_statement_enum:
3121 open_input_bfds (constructor_list.head, force);
3123 case lang_output_section_statement_enum:
3124 open_input_bfds (s->output_section_statement.children.head, force);
3126 case lang_wild_statement_enum:
3127 /* Maybe we should load the file's symbols. */
3128 if (s->wild_statement.filename
3129 && !wildcardp (s->wild_statement.filename)
3130 && !archive_path (s->wild_statement.filename))
3131 lookup_name (s->wild_statement.filename);
3132 open_input_bfds (s->wild_statement.children.head, force);
3134 case lang_group_statement_enum:
3136 struct bfd_link_hash_entry *undefs;
3138 /* We must continually search the entries in the group
3139 until no new symbols are added to the list of undefined
3144 undefs = link_info.hash->undefs_tail;
3145 open_input_bfds (s->group_statement.children.head, TRUE);
3147 while (undefs != link_info.hash->undefs_tail);
3150 case lang_target_statement_enum:
3151 current_target = s->target_statement.target;
3153 case lang_input_statement_enum:
3154 if (s->input_statement.real)
3156 lang_statement_union_type **os_tail;
3157 lang_statement_list_type add;
3159 s->input_statement.target = current_target;
3161 /* If we are being called from within a group, and this
3162 is an archive which has already been searched, then
3163 force it to be researched unless the whole archive
3164 has been loaded already. */
3166 && !s->input_statement.whole_archive
3167 && s->input_statement.loaded
3168 && bfd_check_format (s->input_statement.the_bfd,
3170 s->input_statement.loaded = FALSE;
3172 os_tail = lang_output_section_statement.tail;
3173 lang_list_init (&add);
3175 if (! load_symbols (&s->input_statement, &add))
3176 config.make_executable = FALSE;
3178 if (add.head != NULL)
3180 /* If this was a script with output sections then
3181 tack any added statements on to the end of the
3182 list. This avoids having to reorder the output
3183 section statement list. Very likely the user
3184 forgot -T, and whatever we do here will not meet
3185 naive user expectations. */
3186 if (os_tail != lang_output_section_statement.tail)
3188 einfo (_("%P: warning: %s contains output sections;"
3189 " did you forget -T?\n"),
3190 s->input_statement.filename);
3191 *stat_ptr->tail = add.head;
3192 stat_ptr->tail = add.tail;
3196 *add.tail = s->header.next;
3197 s->header.next = add.head;
3202 case lang_assignment_statement_enum:
3203 if (s->assignment_statement.exp->assign.hidden)
3204 /* This is from a --defsym on the command line. */
3205 exp_fold_tree_no_dot (s->assignment_statement.exp);
3212 /* Exit if any of the files were missing. */
3217 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3220 lang_track_definedness (const char *name)
3222 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3223 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3226 /* New-function for the definedness hash table. */
3228 static struct bfd_hash_entry *
3229 lang_definedness_newfunc (struct bfd_hash_entry *entry,
3230 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3231 const char *name ATTRIBUTE_UNUSED)
3233 struct lang_definedness_hash_entry *ret
3234 = (struct lang_definedness_hash_entry *) entry;
3237 ret = (struct lang_definedness_hash_entry *)
3238 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3241 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3243 ret->iteration = -1;
3247 /* Return the iteration when the definition of NAME was last updated. A
3248 value of -1 means that the symbol is not defined in the linker script
3249 or the command line, but may be defined in the linker symbol table. */
3252 lang_symbol_definition_iteration (const char *name)
3254 struct lang_definedness_hash_entry *defentry
3255 = (struct lang_definedness_hash_entry *)
3256 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3258 /* We've already created this one on the presence of DEFINED in the
3259 script, so it can't be NULL unless something is borked elsewhere in
3261 if (defentry == NULL)
3264 return defentry->iteration;
3267 /* Update the definedness state of NAME. */
3270 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3272 struct lang_definedness_hash_entry *defentry
3273 = (struct lang_definedness_hash_entry *)
3274 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3276 /* We don't keep track of symbols not tested with DEFINED. */
3277 if (defentry == NULL)
3280 /* If the symbol was already defined, and not from an earlier statement
3281 iteration, don't update the definedness iteration, because that'd
3282 make the symbol seem defined in the linker script at this point, and
3283 it wasn't; it was defined in some object. If we do anyway, DEFINED
3284 would start to yield false before this point and the construct "sym =
3285 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3287 if (h->type != bfd_link_hash_undefined
3288 && h->type != bfd_link_hash_common
3289 && h->type != bfd_link_hash_new
3290 && defentry->iteration == -1)
3293 defentry->iteration = lang_statement_iteration;
3296 /* Add the supplied name to the symbol table as an undefined reference.
3297 This is a two step process as the symbol table doesn't even exist at
3298 the time the ld command line is processed. First we put the name
3299 on a list, then, once the output file has been opened, transfer the
3300 name to the symbol table. */
3302 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3304 #define ldlang_undef_chain_list_head entry_symbol.next
3307 ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3309 ldlang_undef_chain_list_type *new_undef;
3311 undef_from_cmdline = undef_from_cmdline || cmdline;
3312 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3313 new_undef->next = ldlang_undef_chain_list_head;
3314 ldlang_undef_chain_list_head = new_undef;
3316 new_undef->name = xstrdup (name);
3318 if (link_info.output_bfd != NULL)
3319 insert_undefined (new_undef->name);
3322 /* Insert NAME as undefined in the symbol table. */
3325 insert_undefined (const char *name)
3327 struct bfd_link_hash_entry *h;
3329 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3331 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3332 if (h->type == bfd_link_hash_new)
3334 h->type = bfd_link_hash_undefined;
3335 h->u.undef.abfd = NULL;
3336 bfd_link_add_undef (link_info.hash, h);
3340 /* Run through the list of undefineds created above and place them
3341 into the linker hash table as undefined symbols belonging to the
3345 lang_place_undefineds (void)
3347 ldlang_undef_chain_list_type *ptr;
3349 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3350 insert_undefined (ptr->name);
3353 /* Check for all readonly or some readwrite sections. */
3356 check_input_sections
3357 (lang_statement_union_type *s,
3358 lang_output_section_statement_type *output_section_statement)
3360 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3362 switch (s->header.type)
3364 case lang_wild_statement_enum:
3365 walk_wild (&s->wild_statement, check_section_callback,
3366 output_section_statement);
3367 if (! output_section_statement->all_input_readonly)
3370 case lang_constructors_statement_enum:
3371 check_input_sections (constructor_list.head,
3372 output_section_statement);
3373 if (! output_section_statement->all_input_readonly)
3376 case lang_group_statement_enum:
3377 check_input_sections (s->group_statement.children.head,
3378 output_section_statement);
3379 if (! output_section_statement->all_input_readonly)
3388 /* Update wildcard statements if needed. */
3391 update_wild_statements (lang_statement_union_type *s)
3393 struct wildcard_list *sec;
3395 switch (sort_section)
3405 for (; s != NULL; s = s->header.next)
3407 switch (s->header.type)
3412 case lang_wild_statement_enum:
3413 sec = s->wild_statement.section_list;
3414 for (sec = s->wild_statement.section_list; sec != NULL;
3417 switch (sec->spec.sorted)
3420 sec->spec.sorted = sort_section;
3423 if (sort_section == by_alignment)
3424 sec->spec.sorted = by_name_alignment;
3427 if (sort_section == by_name)
3428 sec->spec.sorted = by_alignment_name;
3436 case lang_constructors_statement_enum:
3437 update_wild_statements (constructor_list.head);
3440 case lang_output_section_statement_enum:
3441 update_wild_statements
3442 (s->output_section_statement.children.head);
3445 case lang_group_statement_enum:
3446 update_wild_statements (s->group_statement.children.head);
3454 /* Open input files and attach to output sections. */
3457 map_input_to_output_sections
3458 (lang_statement_union_type *s, const char *target,
3459 lang_output_section_statement_type *os)
3461 for (; s != NULL; s = s->header.next)
3463 lang_output_section_statement_type *tos;
3466 switch (s->header.type)
3468 case lang_wild_statement_enum:
3469 wild (&s->wild_statement, target, os);
3471 case lang_constructors_statement_enum:
3472 map_input_to_output_sections (constructor_list.head,
3476 case lang_output_section_statement_enum:
3477 tos = &s->output_section_statement;
3478 if (tos->constraint != 0)
3480 if (tos->constraint != ONLY_IF_RW
3481 && tos->constraint != ONLY_IF_RO)
3483 tos->all_input_readonly = TRUE;
3484 check_input_sections (tos->children.head, tos);
3485 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3487 tos->constraint = -1;
3491 map_input_to_output_sections (tos->children.head,
3495 case lang_output_statement_enum:
3497 case lang_target_statement_enum:
3498 target = s->target_statement.target;
3500 case lang_group_statement_enum:
3501 map_input_to_output_sections (s->group_statement.children.head,
3505 case lang_data_statement_enum:
3506 /* Make sure that any sections mentioned in the expression
3508 exp_init_os (s->data_statement.exp);
3509 /* The output section gets CONTENTS, ALLOC and LOAD, but
3510 these may be overridden by the script. */
3511 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3512 switch (os->sectype)
3514 case normal_section:
3515 case overlay_section:
3517 case noalloc_section:
3518 flags = SEC_HAS_CONTENTS;
3520 case noload_section:
3521 if (bfd_get_flavour (link_info.output_bfd)
3522 == bfd_target_elf_flavour)
3523 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3525 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3528 if (os->bfd_section == NULL)
3529 init_os (os, flags);
3531 os->bfd_section->flags |= flags;
3533 case lang_input_section_enum:
3535 case lang_fill_statement_enum:
3536 case lang_object_symbols_statement_enum:
3537 case lang_reloc_statement_enum:
3538 case lang_padding_statement_enum:
3539 case lang_input_statement_enum:
3540 if (os != NULL && os->bfd_section == NULL)
3543 case lang_assignment_statement_enum:
3544 if (os != NULL && os->bfd_section == NULL)
3547 /* Make sure that any sections mentioned in the assignment
3549 exp_init_os (s->assignment_statement.exp);
3551 case lang_address_statement_enum:
3552 /* Mark the specified section with the supplied address.
3553 If this section was actually a segment marker, then the
3554 directive is ignored if the linker script explicitly
3555 processed the segment marker. Originally, the linker
3556 treated segment directives (like -Ttext on the
3557 command-line) as section directives. We honor the
3558 section directive semantics for backwards compatibilty;
3559 linker scripts that do not specifically check for
3560 SEGMENT_START automatically get the old semantics. */
3561 if (!s->address_statement.segment
3562 || !s->address_statement.segment->used)
3564 const char *name = s->address_statement.section_name;
3566 /* Create the output section statement here so that
3567 orphans with a set address will be placed after other
3568 script sections. If we let the orphan placement code
3569 place them in amongst other sections then the address
3570 will affect following script sections, which is
3571 likely to surprise naive users. */
3572 tos = lang_output_section_statement_lookup (name, 0, TRUE);
3573 tos->addr_tree = s->address_statement.address;
3574 if (tos->bfd_section == NULL)
3578 case lang_insert_statement_enum:
3584 /* An insert statement snips out all the linker statements from the
3585 start of the list and places them after the output section
3586 statement specified by the insert. This operation is complicated
3587 by the fact that we keep a doubly linked list of output section
3588 statements as well as the singly linked list of all statements. */
3591 process_insert_statements (void)
3593 lang_statement_union_type **s;
3594 lang_output_section_statement_type *first_os = NULL;
3595 lang_output_section_statement_type *last_os = NULL;
3596 lang_output_section_statement_type *os;
3598 /* "start of list" is actually the statement immediately after
3599 the special abs_section output statement, so that it isn't
3601 s = &lang_output_section_statement.head;
3602 while (*(s = &(*s)->header.next) != NULL)
3604 if ((*s)->header.type == lang_output_section_statement_enum)
3606 /* Keep pointers to the first and last output section
3607 statement in the sequence we may be about to move. */
3608 os = &(*s)->output_section_statement;
3610 ASSERT (last_os == NULL || last_os->next == os);
3613 /* Set constraint negative so that lang_output_section_find
3614 won't match this output section statement. At this
3615 stage in linking constraint has values in the range
3616 [-1, ONLY_IN_RW]. */
3617 last_os->constraint = -2 - last_os->constraint;
3618 if (first_os == NULL)
3621 else if ((*s)->header.type == lang_insert_statement_enum)
3623 lang_insert_statement_type *i = &(*s)->insert_statement;
3624 lang_output_section_statement_type *where;
3625 lang_statement_union_type **ptr;
3626 lang_statement_union_type *first;
3628 where = lang_output_section_find (i->where);
3629 if (where != NULL && i->is_before)
3632 where = where->prev;
3633 while (where != NULL && where->constraint < 0);
3637 einfo (_("%F%P: %s not found for insert\n"), i->where);
3641 /* Deal with reordering the output section statement list. */
3642 if (last_os != NULL)
3644 asection *first_sec, *last_sec;
3645 struct lang_output_section_statement_struct **next;
3647 /* Snip out the output sections we are moving. */
3648 first_os->prev->next = last_os->next;
3649 if (last_os->next == NULL)
3651 next = &first_os->prev->next;
3652 lang_output_section_statement.tail
3653 = (lang_statement_union_type **) next;
3656 last_os->next->prev = first_os->prev;
3657 /* Add them in at the new position. */
3658 last_os->next = where->next;
3659 if (where->next == NULL)
3661 next = &last_os->next;
3662 lang_output_section_statement.tail
3663 = (lang_statement_union_type **) next;
3666 where->next->prev = last_os;
3667 first_os->prev = where;
3668 where->next = first_os;
3670 /* Move the bfd sections in the same way. */
3673 for (os = first_os; os != NULL; os = os->next)
3675 os->constraint = -2 - os->constraint;
3676 if (os->bfd_section != NULL
3677 && os->bfd_section->owner != NULL)
3679 last_sec = os->bfd_section;
3680 if (first_sec == NULL)
3681 first_sec = last_sec;
3686 if (last_sec != NULL)
3688 asection *sec = where->bfd_section;
3690 sec = output_prev_sec_find (where);
3692 /* The place we want to insert must come after the
3693 sections we are moving. So if we find no
3694 section or if the section is the same as our
3695 last section, then no move is needed. */
3696 if (sec != NULL && sec != last_sec)
3698 /* Trim them off. */
3699 if (first_sec->prev != NULL)
3700 first_sec->prev->next = last_sec->next;
3702 link_info.output_bfd->sections = last_sec->next;
3703 if (last_sec->next != NULL)
3704 last_sec->next->prev = first_sec->prev;
3706 link_info.output_bfd->section_last = first_sec->prev;
3708 last_sec->next = sec->next;
3709 if (sec->next != NULL)
3710 sec->next->prev = last_sec;
3712 link_info.output_bfd->section_last = last_sec;
3713 first_sec->prev = sec;
3714 sec->next = first_sec;
3722 ptr = insert_os_after (where);
3723 /* Snip everything after the abs_section output statement we
3724 know is at the start of the list, up to and including
3725 the insert statement we are currently processing. */
3726 first = lang_output_section_statement.head->header.next;
3727 lang_output_section_statement.head->header.next = (*s)->header.next;
3728 /* Add them back where they belong. */
3731 statement_list.tail = s;
3733 s = &lang_output_section_statement.head;
3737 /* Undo constraint twiddling. */
3738 for (os = first_os; os != NULL; os = os->next)
3740 os->constraint = -2 - os->constraint;
3746 /* An output section might have been removed after its statement was
3747 added. For example, ldemul_before_allocation can remove dynamic
3748 sections if they turn out to be not needed. Clean them up here. */
3751 strip_excluded_output_sections (void)
3753 lang_output_section_statement_type *os;
3755 /* Run lang_size_sections (if not already done). */
3756 if (expld.phase != lang_mark_phase_enum)
3758 expld.phase = lang_mark_phase_enum;
3759 expld.dataseg.phase = exp_dataseg_none;
3760 one_lang_size_sections_pass (NULL, FALSE);
3761 lang_reset_memory_regions ();
3764 for (os = &lang_output_section_statement.head->output_section_statement;
3768 asection *output_section;
3769 bfd_boolean exclude;
3771 if (os->constraint < 0)
3774 output_section = os->bfd_section;
3775 if (output_section == NULL)
3778 exclude = (output_section->rawsize == 0
3779 && (output_section->flags & SEC_KEEP) == 0
3780 && !bfd_section_removed_from_list (link_info.output_bfd,
3783 /* Some sections have not yet been sized, notably .gnu.version,
3784 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3785 input sections, so don't drop output sections that have such
3786 input sections unless they are also marked SEC_EXCLUDE. */
3787 if (exclude && output_section->map_head.s != NULL)
3791 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3792 if ((s->flags & SEC_LINKER_CREATED) != 0
3793 && (s->flags & SEC_EXCLUDE) == 0)
3800 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3801 output_section->map_head.link_order = NULL;
3802 output_section->map_tail.link_order = NULL;
3806 /* We don't set bfd_section to NULL since bfd_section of the
3807 removed output section statement may still be used. */
3808 if (!os->section_relative_symbol
3809 && !os->update_dot_tree)
3811 output_section->flags |= SEC_EXCLUDE;
3812 bfd_section_list_remove (link_info.output_bfd, output_section);
3813 link_info.output_bfd->section_count--;
3817 /* Stop future calls to lang_add_section from messing with map_head
3818 and map_tail link_order fields. */
3819 stripped_excluded_sections = TRUE;
3823 print_output_section_statement
3824 (lang_output_section_statement_type *output_section_statement)
3826 asection *section = output_section_statement->bfd_section;
3829 if (output_section_statement != abs_output_section)
3831 minfo ("\n%s", output_section_statement->name);
3833 if (section != NULL)
3835 print_dot = section->vma;
3837 len = strlen (output_section_statement->name);
3838 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3843 while (len < SECTION_NAME_MAP_LENGTH)
3849 minfo ("0x%V %W", section->vma, section->size);
3851 if (section->vma != section->lma)
3852 minfo (_(" load address 0x%V"), section->lma);
3854 if (output_section_statement->update_dot_tree != NULL)
3855 exp_fold_tree (output_section_statement->update_dot_tree,
3856 bfd_abs_section_ptr, &print_dot);
3862 print_statement_list (output_section_statement->children.head,
3863 output_section_statement);
3866 /* Scan for the use of the destination in the right hand side
3867 of an expression. In such cases we will not compute the
3868 correct expression, since the value of DST that is used on
3869 the right hand side will be its final value, not its value
3870 just before this expression is evaluated. */
3873 scan_for_self_assignment (const char * dst, etree_type * rhs)
3875 if (rhs == NULL || dst == NULL)
3878 switch (rhs->type.node_class)
3881 return (scan_for_self_assignment (dst, rhs->binary.lhs)
3882 || scan_for_self_assignment (dst, rhs->binary.rhs));
3885 return (scan_for_self_assignment (dst, rhs->trinary.lhs)
3886 || scan_for_self_assignment (dst, rhs->trinary.rhs));
3889 case etree_provided:
3891 if (strcmp (dst, rhs->assign.dst) == 0)
3893 return scan_for_self_assignment (dst, rhs->assign.src);
3896 return scan_for_self_assignment (dst, rhs->unary.child);
3900 return strcmp (dst, rhs->value.str) == 0;
3905 return strcmp (dst, rhs->name.name) == 0;
3917 print_assignment (lang_assignment_statement_type *assignment,
3918 lang_output_section_statement_type *output_section)
3922 bfd_boolean computation_is_valid = TRUE;
3926 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3929 if (assignment->exp->type.node_class == etree_assert)
3932 tree = assignment->exp->assert_s.child;
3933 computation_is_valid = TRUE;
3937 const char *dst = assignment->exp->assign.dst;
3939 is_dot = (dst[0] == '.' && dst[1] == 0);
3940 tree = assignment->exp->assign.src;
3941 computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
3944 osec = output_section->bfd_section;
3946 osec = bfd_abs_section_ptr;
3947 exp_fold_tree (tree, osec, &print_dot);
3948 if (expld.result.valid_p)
3952 if (computation_is_valid)
3954 value = expld.result.value;
3956 if (expld.result.section != NULL)
3957 value += expld.result.section->vma;
3959 minfo ("0x%V", value);
3965 struct bfd_link_hash_entry *h;
3967 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3968 FALSE, FALSE, TRUE);
3971 value = h->u.def.value;
3973 if (expld.result.section != NULL)
3974 value += expld.result.section->vma;
3976 minfo ("[0x%V]", value);
3979 minfo ("[unresolved]");
3991 exp_print_tree (assignment->exp);
3996 print_input_statement (lang_input_statement_type *statm)
3998 if (statm->filename != NULL
3999 && (statm->the_bfd == NULL
4000 || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
4001 fprintf (config.map_file, "LOAD %s\n", statm->filename);
4004 /* Print all symbols defined in a particular section. This is called
4005 via bfd_link_hash_traverse, or by print_all_symbols. */
4008 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4010 asection *sec = (asection *) ptr;
4012 if ((hash_entry->type == bfd_link_hash_defined
4013 || hash_entry->type == bfd_link_hash_defweak)
4014 && sec == hash_entry->u.def.section)
4018 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4021 (hash_entry->u.def.value
4022 + hash_entry->u.def.section->output_offset
4023 + hash_entry->u.def.section->output_section->vma));
4025 minfo (" %T\n", hash_entry->root.string);
4032 hash_entry_addr_cmp (const void *a, const void *b)
4034 const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4035 const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4037 if (l->u.def.value < r->u.def.value)
4039 else if (l->u.def.value > r->u.def.value)
4046 print_all_symbols (asection *sec)
4048 struct fat_user_section_struct *ud =
4049 (struct fat_user_section_struct *) get_userdata (sec);
4050 struct map_symbol_def *def;
4051 struct bfd_link_hash_entry **entries;
4057 *ud->map_symbol_def_tail = 0;
4059 /* Sort the symbols by address. */
4060 entries = (struct bfd_link_hash_entry **)
4061 obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4063 for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4064 entries[i] = def->entry;
4066 qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4067 hash_entry_addr_cmp);
4069 /* Print the symbols. */
4070 for (i = 0; i < ud->map_symbol_def_count; i++)
4071 print_one_symbol (entries[i], sec);
4073 obstack_free (&map_obstack, entries);
4076 /* Print information about an input section to the map file. */
4079 print_input_section (asection *i, bfd_boolean is_discarded)
4081 bfd_size_type size = i->size;
4088 minfo ("%s", i->name);
4090 len = 1 + strlen (i->name);
4091 if (len >= SECTION_NAME_MAP_LENGTH - 1)
4096 while (len < SECTION_NAME_MAP_LENGTH)
4102 if (i->output_section != NULL
4103 && i->output_section->owner == link_info.output_bfd)
4104 addr = i->output_section->vma + i->output_offset;
4112 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4114 if (size != i->rawsize && i->rawsize != 0)
4116 len = SECTION_NAME_MAP_LENGTH + 3;
4128 minfo (_("%W (size before relaxing)\n"), i->rawsize);
4131 if (i->output_section != NULL
4132 && i->output_section->owner == link_info.output_bfd)
4134 if (link_info.reduce_memory_overheads)
4135 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4137 print_all_symbols (i);
4139 /* Update print_dot, but make sure that we do not move it
4140 backwards - this could happen if we have overlays and a
4141 later overlay is shorter than an earier one. */
4142 if (addr + TO_ADDR (size) > print_dot)
4143 print_dot = addr + TO_ADDR (size);
4148 print_fill_statement (lang_fill_statement_type *fill)
4152 fputs (" FILL mask 0x", config.map_file);
4153 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4154 fprintf (config.map_file, "%02x", *p);
4155 fputs ("\n", config.map_file);
4159 print_data_statement (lang_data_statement_type *data)
4167 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4170 addr = data->output_offset;
4171 if (data->output_section != NULL)
4172 addr += data->output_section->vma;
4200 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4202 if (data->exp->type.node_class != etree_value)
4205 exp_print_tree (data->exp);
4210 print_dot = addr + TO_ADDR (size);
4213 /* Print an address statement. These are generated by options like
4217 print_address_statement (lang_address_statement_type *address)
4219 minfo (_("Address of section %s set to "), address->section_name);
4220 exp_print_tree (address->address);
4224 /* Print a reloc statement. */
4227 print_reloc_statement (lang_reloc_statement_type *reloc)
4234 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4237 addr = reloc->output_offset;
4238 if (reloc->output_section != NULL)
4239 addr += reloc->output_section->vma;
4241 size = bfd_get_reloc_size (reloc->howto);
4243 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4245 if (reloc->name != NULL)
4246 minfo ("%s+", reloc->name);
4248 minfo ("%s+", reloc->section->name);
4250 exp_print_tree (reloc->addend_exp);
4254 print_dot = addr + TO_ADDR (size);
4258 print_padding_statement (lang_padding_statement_type *s)
4266 len = sizeof " *fill*" - 1;
4267 while (len < SECTION_NAME_MAP_LENGTH)
4273 addr = s->output_offset;
4274 if (s->output_section != NULL)
4275 addr += s->output_section->vma;
4276 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4278 if (s->fill->size != 0)
4282 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4283 fprintf (config.map_file, "%02x", *p);
4288 print_dot = addr + TO_ADDR (s->size);
4292 print_wild_statement (lang_wild_statement_type *w,
4293 lang_output_section_statement_type *os)
4295 struct wildcard_list *sec;
4299 if (w->filenames_sorted)
4301 if (w->filename != NULL)
4302 minfo ("%s", w->filename);
4305 if (w->filenames_sorted)
4309 for (sec = w->section_list; sec; sec = sec->next)
4311 if (sec->spec.sorted)
4313 if (sec->spec.exclude_name_list != NULL)
4316 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4317 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4318 minfo (" %s", tmp->name);
4321 if (sec->spec.name != NULL)
4322 minfo ("%s", sec->spec.name);
4325 if (sec->spec.sorted)
4334 print_statement_list (w->children.head, os);
4337 /* Print a group statement. */
4340 print_group (lang_group_statement_type *s,
4341 lang_output_section_statement_type *os)
4343 fprintf (config.map_file, "START GROUP\n");
4344 print_statement_list (s->children.head, os);
4345 fprintf (config.map_file, "END GROUP\n");
4348 /* Print the list of statements in S.
4349 This can be called for any statement type. */
4352 print_statement_list (lang_statement_union_type *s,
4353 lang_output_section_statement_type *os)
4357 print_statement (s, os);
4362 /* Print the first statement in statement list S.
4363 This can be called for any statement type. */
4366 print_statement (lang_statement_union_type *s,
4367 lang_output_section_statement_type *os)
4369 switch (s->header.type)
4372 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4375 case lang_constructors_statement_enum:
4376 if (constructor_list.head != NULL)
4378 if (constructors_sorted)
4379 minfo (" SORT (CONSTRUCTORS)\n");
4381 minfo (" CONSTRUCTORS\n");
4382 print_statement_list (constructor_list.head, os);
4385 case lang_wild_statement_enum:
4386 print_wild_statement (&s->wild_statement, os);
4388 case lang_address_statement_enum:
4389 print_address_statement (&s->address_statement);
4391 case lang_object_symbols_statement_enum:
4392 minfo (" CREATE_OBJECT_SYMBOLS\n");
4394 case lang_fill_statement_enum:
4395 print_fill_statement (&s->fill_statement);
4397 case lang_data_statement_enum:
4398 print_data_statement (&s->data_statement);
4400 case lang_reloc_statement_enum:
4401 print_reloc_statement (&s->reloc_statement);
4403 case lang_input_section_enum:
4404 print_input_section (s->input_section.section, FALSE);
4406 case lang_padding_statement_enum:
4407 print_padding_statement (&s->padding_statement);
4409 case lang_output_section_statement_enum:
4410 print_output_section_statement (&s->output_section_statement);
4412 case lang_assignment_statement_enum:
4413 print_assignment (&s->assignment_statement, os);
4415 case lang_target_statement_enum:
4416 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4418 case lang_output_statement_enum:
4419 minfo ("OUTPUT(%s", s->output_statement.name);
4420 if (output_target != NULL)
4421 minfo (" %s", output_target);
4424 case lang_input_statement_enum:
4425 print_input_statement (&s->input_statement);
4427 case lang_group_statement_enum:
4428 print_group (&s->group_statement, os);
4430 case lang_insert_statement_enum:
4431 minfo ("INSERT %s %s\n",
4432 s->insert_statement.is_before ? "BEFORE" : "AFTER",
4433 s->insert_statement.where);
4439 print_statements (void)
4441 print_statement_list (statement_list.head, abs_output_section);
4444 /* Print the first N statements in statement list S to STDERR.
4445 If N == 0, nothing is printed.
4446 If N < 0, the entire list is printed.
4447 Intended to be called from GDB. */
4450 dprint_statement (lang_statement_union_type *s, int n)
4452 FILE *map_save = config.map_file;
4454 config.map_file = stderr;
4457 print_statement_list (s, abs_output_section);
4460 while (s && --n >= 0)
4462 print_statement (s, abs_output_section);
4467 config.map_file = map_save;
4471 insert_pad (lang_statement_union_type **ptr,
4473 unsigned int alignment_needed,
4474 asection *output_section,
4477 static fill_type zero_fill = { 1, { 0 } };
4478 lang_statement_union_type *pad = NULL;
4480 if (ptr != &statement_list.head)
4481 pad = ((lang_statement_union_type *)
4482 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4484 && pad->header.type == lang_padding_statement_enum
4485 && pad->padding_statement.output_section == output_section)
4487 /* Use the existing pad statement. */
4489 else if ((pad = *ptr) != NULL
4490 && pad->header.type == lang_padding_statement_enum
4491 && pad->padding_statement.output_section == output_section)
4493 /* Use the existing pad statement. */
4497 /* Make a new padding statement, linked into existing chain. */
4498 pad = (lang_statement_union_type *)
4499 stat_alloc (sizeof (lang_padding_statement_type));
4500 pad->header.next = *ptr;
4502 pad->header.type = lang_padding_statement_enum;
4503 pad->padding_statement.output_section = output_section;
4506 pad->padding_statement.fill = fill;
4508 pad->padding_statement.output_offset = dot - output_section->vma;
4509 pad->padding_statement.size = alignment_needed;
4510 output_section->size += alignment_needed;
4513 /* Work out how much this section will move the dot point. */
4517 (lang_statement_union_type **this_ptr,
4518 lang_output_section_statement_type *output_section_statement,
4522 lang_input_section_type *is = &((*this_ptr)->input_section);
4523 asection *i = is->section;
4525 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4526 && (i->flags & SEC_EXCLUDE) == 0)
4528 unsigned int alignment_needed;
4531 /* Align this section first to the input sections requirement,
4532 then to the output section's requirement. If this alignment
4533 is greater than any seen before, then record it too. Perform
4534 the alignment by inserting a magic 'padding' statement. */
4536 if (output_section_statement->subsection_alignment != -1)
4537 i->alignment_power = output_section_statement->subsection_alignment;
4539 o = output_section_statement->bfd_section;
4540 if (o->alignment_power < i->alignment_power)
4541 o->alignment_power = i->alignment_power;
4543 alignment_needed = align_power (dot, i->alignment_power) - dot;
4545 if (alignment_needed != 0)
4547 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4548 dot += alignment_needed;
4551 /* Remember where in the output section this input section goes. */
4553 i->output_offset = dot - o->vma;
4555 /* Mark how big the output section must be to contain this now. */
4556 dot += TO_ADDR (i->size);
4557 o->size = TO_SIZE (dot - o->vma);
4561 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4568 sort_sections_by_lma (const void *arg1, const void *arg2)
4570 const asection *sec1 = *(const asection **) arg1;
4571 const asection *sec2 = *(const asection **) arg2;
4573 if (bfd_section_lma (sec1->owner, sec1)
4574 < bfd_section_lma (sec2->owner, sec2))
4576 else if (bfd_section_lma (sec1->owner, sec1)
4577 > bfd_section_lma (sec2->owner, sec2))
4579 else if (sec1->id < sec2->id)
4581 else if (sec1->id > sec2->id)
4587 #define IGNORE_SECTION(s) \
4588 ((s->flags & SEC_ALLOC) == 0 \
4589 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4590 && (s->flags & SEC_LOAD) == 0))
4592 /* Check to see if any allocated sections overlap with other allocated
4593 sections. This can happen if a linker script specifies the output
4594 section addresses of the two sections. Also check whether any memory
4595 region has overflowed. */
4598 lang_check_section_addresses (void)
4601 asection **sections, **spp;
4608 lang_memory_region_type *m;
4610 if (bfd_count_sections (link_info.output_bfd) <= 1)
4613 amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4614 sections = (asection **) xmalloc (amt);
4616 /* Scan all sections in the output list. */
4618 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4620 /* Only consider loadable sections with real contents. */
4621 if (!(s->flags & SEC_LOAD)
4622 || !(s->flags & SEC_ALLOC)
4626 sections[count] = s;
4633 qsort (sections, (size_t) count, sizeof (asection *),
4634 sort_sections_by_lma);
4639 s_end = s_start + TO_ADDR (s->size) - 1;
4640 for (count--; count; count--)
4642 /* We must check the sections' LMA addresses not their VMA
4643 addresses because overlay sections can have overlapping VMAs
4644 but they must have distinct LMAs. */
4650 s_end = s_start + TO_ADDR (s->size) - 1;
4652 /* Look for an overlap. We have sorted sections by lma, so we
4653 know that s_start >= p_start. Besides the obvious case of
4654 overlap when the current section starts before the previous
4655 one ends, we also must have overlap if the previous section
4656 wraps around the address space. */
4657 if (s_start <= p_end
4659 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4660 s->name, s_start, s_end, p->name, p_start, p_end);
4665 /* If any memory region has overflowed, report by how much.
4666 We do not issue this diagnostic for regions that had sections
4667 explicitly placed outside their bounds; os_region_check's
4668 diagnostics are adequate for that case.
4670 FIXME: It is conceivable that m->current - (m->origin + m->length)
4671 might overflow a 32-bit integer. There is, alas, no way to print
4672 a bfd_vma quantity in decimal. */
4673 for (m = lang_memory_region_list; m; m = m->next)
4674 if (m->had_full_message)
4675 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4676 m->name_list.name, (long)(m->current - (m->origin + m->length)));
4680 /* Make sure the new address is within the region. We explicitly permit the
4681 current address to be at the exact end of the region when the address is
4682 non-zero, in case the region is at the end of addressable memory and the
4683 calculation wraps around. */
4686 os_region_check (lang_output_section_statement_type *os,
4687 lang_memory_region_type *region,
4691 if ((region->current < region->origin
4692 || (region->current - region->origin > region->length))
4693 && ((region->current != region->origin + region->length)
4698 einfo (_("%X%P: address 0x%v of %B section `%s'"
4699 " is not within region `%s'\n"),
4701 os->bfd_section->owner,
4702 os->bfd_section->name,
4703 region->name_list.name);
4705 else if (!region->had_full_message)
4707 region->had_full_message = TRUE;
4709 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4710 os->bfd_section->owner,
4711 os->bfd_section->name,
4712 region->name_list.name);
4717 /* Set the sizes for all the output sections. */
4720 lang_size_sections_1
4721 (lang_statement_union_type **prev,
4722 lang_output_section_statement_type *output_section_statement,
4726 bfd_boolean check_regions)
4728 lang_statement_union_type *s;
4730 /* Size up the sections from their constituent parts. */
4731 for (s = *prev; s != NULL; s = s->header.next)
4733 switch (s->header.type)
4735 case lang_output_section_statement_enum:
4737 bfd_vma newdot, after;
4738 lang_output_section_statement_type *os;
4739 lang_memory_region_type *r;
4740 int section_alignment = 0;
4742 os = &s->output_section_statement;
4743 if (os->constraint == -1)
4746 /* FIXME: We shouldn't need to zero section vmas for ld -r
4747 here, in lang_insert_orphan, or in the default linker scripts.
4748 This is covering for coff backend linker bugs. See PR6945. */
4749 if (os->addr_tree == NULL
4750 && link_info.relocatable
4751 && (bfd_get_flavour (link_info.output_bfd)
4752 == bfd_target_coff_flavour))
4753 os->addr_tree = exp_intop (0);
4754 if (os->addr_tree != NULL)
4756 os->processed_vma = FALSE;
4757 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4759 if (expld.result.valid_p)
4761 dot = expld.result.value;
4762 if (expld.result.section != NULL)
4763 dot += expld.result.section->vma;
4765 else if (expld.phase != lang_mark_phase_enum)
4766 einfo (_("%F%S: non constant or forward reference"
4767 " address expression for section %s\n"),
4771 if (os->bfd_section == NULL)
4772 /* This section was removed or never actually created. */
4775 /* If this is a COFF shared library section, use the size and
4776 address from the input section. FIXME: This is COFF
4777 specific; it would be cleaner if there were some other way
4778 to do this, but nothing simple comes to mind. */
4779 if (((bfd_get_flavour (link_info.output_bfd)
4780 == bfd_target_ecoff_flavour)
4781 || (bfd_get_flavour (link_info.output_bfd)
4782 == bfd_target_coff_flavour))
4783 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4787 if (os->children.head == NULL
4788 || os->children.head->header.next != NULL
4789 || (os->children.head->header.type
4790 != lang_input_section_enum))
4791 einfo (_("%P%X: Internal error on COFF shared library"
4792 " section %s\n"), os->name);
4794 input = os->children.head->input_section.section;
4795 bfd_set_section_vma (os->bfd_section->owner,
4797 bfd_section_vma (input->owner, input));
4798 os->bfd_section->size = input->size;
4803 if (bfd_is_abs_section (os->bfd_section))
4805 /* No matter what happens, an abs section starts at zero. */
4806 ASSERT (os->bfd_section->vma == 0);
4810 if (os->addr_tree == NULL)
4812 /* No address specified for this section, get one
4813 from the region specification. */
4814 if (os->region == NULL
4815 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4816 && os->region->name_list.name[0] == '*'
4817 && strcmp (os->region->name_list.name,
4818 DEFAULT_MEMORY_REGION) == 0))
4820 os->region = lang_memory_default (os->bfd_section);
4823 /* If a loadable section is using the default memory
4824 region, and some non default memory regions were
4825 defined, issue an error message. */
4827 && !IGNORE_SECTION (os->bfd_section)
4828 && ! link_info.relocatable
4830 && strcmp (os->region->name_list.name,
4831 DEFAULT_MEMORY_REGION) == 0
4832 && lang_memory_region_list != NULL
4833 && (strcmp (lang_memory_region_list->name_list.name,
4834 DEFAULT_MEMORY_REGION) != 0
4835 || lang_memory_region_list->next != NULL)
4836 && expld.phase != lang_mark_phase_enum)
4838 /* By default this is an error rather than just a
4839 warning because if we allocate the section to the
4840 default memory region we can end up creating an
4841 excessively large binary, or even seg faulting when
4842 attempting to perform a negative seek. See
4843 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4844 for an example of this. This behaviour can be
4845 overridden by the using the --no-check-sections
4847 if (command_line.check_section_addresses)
4848 einfo (_("%P%F: error: no memory region specified"
4849 " for loadable section `%s'\n"),
4850 bfd_get_section_name (link_info.output_bfd,
4853 einfo (_("%P: warning: no memory region specified"
4854 " for loadable section `%s'\n"),
4855 bfd_get_section_name (link_info.output_bfd,
4859 newdot = os->region->current;
4860 section_alignment = os->bfd_section->alignment_power;
4863 section_alignment = os->section_alignment;
4865 /* Align to what the section needs. */
4866 if (section_alignment > 0)
4868 bfd_vma savedot = newdot;
4869 newdot = align_power (newdot, section_alignment);
4871 if (newdot != savedot
4872 && (config.warn_section_align
4873 || os->addr_tree != NULL)
4874 && expld.phase != lang_mark_phase_enum)
4875 einfo (_("%P: warning: changing start of section"
4876 " %s by %lu bytes\n"),
4877 os->name, (unsigned long) (newdot - savedot));
4880 bfd_set_section_vma (0, os->bfd_section, newdot);
4882 os->bfd_section->output_offset = 0;
4885 lang_size_sections_1 (&os->children.head, os,
4886 os->fill, newdot, relax, check_regions);
4888 os->processed_vma = TRUE;
4890 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4891 /* Except for some special linker created sections,
4892 no output section should change from zero size
4893 after strip_excluded_output_sections. A non-zero
4894 size on an ignored section indicates that some
4895 input section was not sized early enough. */
4896 ASSERT (os->bfd_section->size == 0);
4899 dot = os->bfd_section->vma;
4901 /* Put the section within the requested block size, or
4902 align at the block boundary. */
4904 + TO_ADDR (os->bfd_section->size)
4905 + os->block_value - 1)
4906 & - (bfd_vma) os->block_value);
4908 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4911 /* Set section lma. */
4914 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4918 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4919 os->bfd_section->lma = lma;
4921 else if (os->lma_region != NULL)
4923 bfd_vma lma = os->lma_region->current;
4925 if (section_alignment > 0)
4926 lma = align_power (lma, section_alignment);
4927 os->bfd_section->lma = lma;
4929 else if (r->last_os != NULL
4930 && (os->bfd_section->flags & SEC_ALLOC) != 0)
4935 last = r->last_os->output_section_statement.bfd_section;
4937 /* A backwards move of dot should be accompanied by
4938 an explicit assignment to the section LMA (ie.
4939 os->load_base set) because backwards moves can
4940 create overlapping LMAs. */
4942 && os->bfd_section->size != 0
4943 && dot + os->bfd_section->size <= last->vma)
4945 /* If dot moved backwards then leave lma equal to
4946 vma. This is the old default lma, which might
4947 just happen to work when the backwards move is
4948 sufficiently large. Nag if this changes anything,
4949 so people can fix their linker scripts. */
4951 if (last->vma != last->lma)
4952 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4957 /* If this is an overlay, set the current lma to that
4958 at the end of the previous section. */
4959 if (os->sectype == overlay_section)
4960 lma = last->lma + last->size;
4962 /* Otherwise, keep the same lma to vma relationship
4963 as the previous section. */
4965 lma = dot + last->lma - last->vma;
4967 if (section_alignment > 0)
4968 lma = align_power (lma, section_alignment);
4969 os->bfd_section->lma = lma;
4972 os->processed_lma = TRUE;
4974 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4977 /* Keep track of normal sections using the default
4978 lma region. We use this to set the lma for
4979 following sections. Overlays or other linker
4980 script assignment to lma might mean that the
4981 default lma == vma is incorrect.
4982 To avoid warnings about dot moving backwards when using
4983 -Ttext, don't start tracking sections until we find one
4984 of non-zero size or with lma set differently to vma. */
4985 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4986 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4987 && (os->bfd_section->flags & SEC_ALLOC) != 0
4988 && (os->bfd_section->size != 0
4989 || (r->last_os == NULL
4990 && os->bfd_section->vma != os->bfd_section->lma)
4991 || (r->last_os != NULL
4992 && dot >= (r->last_os->output_section_statement
4993 .bfd_section->vma)))
4994 && os->lma_region == NULL
4995 && !link_info.relocatable)
4998 /* .tbss sections effectively have zero size. */
4999 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5000 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5001 || link_info.relocatable)
5002 dot += TO_ADDR (os->bfd_section->size);
5004 if (os->update_dot_tree != 0)
5005 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5007 /* Update dot in the region ?
5008 We only do this if the section is going to be allocated,
5009 since unallocated sections do not contribute to the region's
5010 overall size in memory. */
5011 if (os->region != NULL
5012 && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5014 os->region->current = dot;
5017 /* Make sure the new address is within the region. */
5018 os_region_check (os, os->region, os->addr_tree,
5019 os->bfd_section->vma);
5021 if (os->lma_region != NULL && os->lma_region != os->region
5022 && (os->bfd_section->flags & SEC_LOAD))
5024 os->lma_region->current
5025 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
5028 os_region_check (os, os->lma_region, NULL,
5029 os->bfd_section->lma);
5035 case lang_constructors_statement_enum:
5036 dot = lang_size_sections_1 (&constructor_list.head,
5037 output_section_statement,
5038 fill, dot, relax, check_regions);
5041 case lang_data_statement_enum:
5043 unsigned int size = 0;
5045 s->data_statement.output_offset =
5046 dot - output_section_statement->bfd_section->vma;
5047 s->data_statement.output_section =
5048 output_section_statement->bfd_section;
5050 /* We might refer to provided symbols in the expression, and
5051 need to mark them as needed. */
5052 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5054 switch (s->data_statement.type)
5072 if (size < TO_SIZE ((unsigned) 1))
5073 size = TO_SIZE ((unsigned) 1);
5074 dot += TO_ADDR (size);
5075 output_section_statement->bfd_section->size += size;
5079 case lang_reloc_statement_enum:
5083 s->reloc_statement.output_offset =
5084 dot - output_section_statement->bfd_section->vma;
5085 s->reloc_statement.output_section =
5086 output_section_statement->bfd_section;
5087 size = bfd_get_reloc_size (s->reloc_statement.howto);
5088 dot += TO_ADDR (size);
5089 output_section_statement->bfd_section->size += size;
5093 case lang_wild_statement_enum:
5094 dot = lang_size_sections_1 (&s->wild_statement.children.head,
5095 output_section_statement,
5096 fill, dot, relax, check_regions);
5099 case lang_object_symbols_statement_enum:
5100 link_info.create_object_symbols_section =
5101 output_section_statement->bfd_section;
5104 case lang_output_statement_enum:
5105 case lang_target_statement_enum:
5108 case lang_input_section_enum:
5112 i = s->input_section.section;
5117 if (! bfd_relax_section (i->owner, i, &link_info, &again))
5118 einfo (_("%P%F: can't relax section: %E\n"));
5122 dot = size_input_section (prev, output_section_statement,
5123 output_section_statement->fill, dot);
5127 case lang_input_statement_enum:
5130 case lang_fill_statement_enum:
5131 s->fill_statement.output_section =
5132 output_section_statement->bfd_section;
5134 fill = s->fill_statement.fill;
5137 case lang_assignment_statement_enum:
5139 bfd_vma newdot = dot;
5140 etree_type *tree = s->assignment_statement.exp;
5142 expld.dataseg.relro = exp_dataseg_relro_none;
5144 exp_fold_tree (tree,
5145 output_section_statement->bfd_section,
5148 if (expld.dataseg.relro == exp_dataseg_relro_start)
5150 if (!expld.dataseg.relro_start_stat)
5151 expld.dataseg.relro_start_stat = s;
5154 ASSERT (expld.dataseg.relro_start_stat == s);
5157 else if (expld.dataseg.relro == exp_dataseg_relro_end)
5159 if (!expld.dataseg.relro_end_stat)
5160 expld.dataseg.relro_end_stat = s;
5163 ASSERT (expld.dataseg.relro_end_stat == s);
5166 expld.dataseg.relro = exp_dataseg_relro_none;
5168 /* This symbol is relative to this section. */
5169 if ((tree->type.node_class == etree_provided
5170 || tree->type.node_class == etree_assign)
5171 && (tree->assign.dst [0] != '.'
5172 || tree->assign.dst [1] != '\0'))
5173 output_section_statement->section_relative_symbol = 1;
5175 if (!output_section_statement->ignored)
5177 if (output_section_statement == abs_output_section)
5179 /* If we don't have an output section, then just adjust
5180 the default memory address. */
5181 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5182 FALSE)->current = newdot;
5184 else if (newdot != dot)
5186 /* Insert a pad after this statement. We can't
5187 put the pad before when relaxing, in case the
5188 assignment references dot. */
5189 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5190 output_section_statement->bfd_section, dot);
5192 /* Don't neuter the pad below when relaxing. */
5195 /* If dot is advanced, this implies that the section
5196 should have space allocated to it, unless the
5197 user has explicitly stated that the section
5198 should not be allocated. */
5199 if (output_section_statement->sectype != noalloc_section
5200 && (output_section_statement->sectype != noload_section
5201 || (bfd_get_flavour (link_info.output_bfd)
5202 == bfd_target_elf_flavour)))
5203 output_section_statement->bfd_section->flags |= SEC_ALLOC;
5210 case lang_padding_statement_enum:
5211 /* If this is the first time lang_size_sections is called,
5212 we won't have any padding statements. If this is the
5213 second or later passes when relaxing, we should allow
5214 padding to shrink. If padding is needed on this pass, it
5215 will be added back in. */
5216 s->padding_statement.size = 0;
5218 /* Make sure output_offset is valid. If relaxation shrinks
5219 the section and this pad isn't needed, it's possible to
5220 have output_offset larger than the final size of the
5221 section. bfd_set_section_contents will complain even for
5222 a pad size of zero. */
5223 s->padding_statement.output_offset
5224 = dot - output_section_statement->bfd_section->vma;
5227 case lang_group_statement_enum:
5228 dot = lang_size_sections_1 (&s->group_statement.children.head,
5229 output_section_statement,
5230 fill, dot, relax, check_regions);
5233 case lang_insert_statement_enum:
5236 /* We can only get here when relaxing is turned on. */
5237 case lang_address_statement_enum:
5244 prev = &s->header.next;
5249 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5250 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5251 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5252 segments. We are allowed an opportunity to override this decision. */
5255 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5256 bfd * abfd ATTRIBUTE_UNUSED,
5257 asection * current_section,
5258 asection * previous_section,
5259 bfd_boolean new_segment)
5261 lang_output_section_statement_type * cur;
5262 lang_output_section_statement_type * prev;
5264 /* The checks below are only necessary when the BFD library has decided
5265 that the two sections ought to be placed into the same segment. */
5269 /* Paranoia checks. */
5270 if (current_section == NULL || previous_section == NULL)
5273 /* Find the memory regions associated with the two sections.
5274 We call lang_output_section_find() here rather than scanning the list
5275 of output sections looking for a matching section pointer because if
5276 we have a large number of sections then a hash lookup is faster. */
5277 cur = lang_output_section_find (current_section->name);
5278 prev = lang_output_section_find (previous_section->name);
5280 /* More paranoia. */
5281 if (cur == NULL || prev == NULL)
5284 /* If the regions are different then force the sections to live in
5285 different segments. See the email thread starting at the following
5286 URL for the reasons why this is necessary:
5287 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5288 return cur->region != prev->region;
5292 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5294 lang_statement_iteration++;
5295 lang_size_sections_1 (&statement_list.head, abs_output_section,
5296 0, 0, relax, check_regions);
5300 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5302 expld.phase = lang_allocating_phase_enum;
5303 expld.dataseg.phase = exp_dataseg_none;
5305 one_lang_size_sections_pass (relax, check_regions);
5306 if (expld.dataseg.phase == exp_dataseg_end_seen
5307 && link_info.relro && expld.dataseg.relro_end)
5309 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5310 to put expld.dataseg.relro on a (common) page boundary. */
5311 bfd_vma min_base, old_base, relro_end, maxpage;
5313 expld.dataseg.phase = exp_dataseg_relro_adjust;
5314 maxpage = expld.dataseg.maxpagesize;
5315 /* MIN_BASE is the absolute minimum address we are allowed to start the
5316 read-write segment (byte before will be mapped read-only). */
5317 min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5318 /* OLD_BASE is the address for a feasible minimum address which will
5319 still not cause a data overlap inside MAXPAGE causing file offset skip
5321 old_base = expld.dataseg.base;
5322 expld.dataseg.base += (-expld.dataseg.relro_end
5323 & (expld.dataseg.pagesize - 1));
5324 /* Compute the expected PT_GNU_RELRO segment end. */
5325 relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5326 & ~(expld.dataseg.pagesize - 1));
5327 if (min_base + maxpage < expld.dataseg.base)
5329 expld.dataseg.base -= maxpage;
5330 relro_end -= maxpage;
5332 lang_reset_memory_regions ();
5333 one_lang_size_sections_pass (relax, check_regions);
5334 if (expld.dataseg.relro_end > relro_end)
5336 /* The alignment of sections between DATA_SEGMENT_ALIGN
5337 and DATA_SEGMENT_RELRO_END caused huge padding to be
5338 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5339 that the section alignments will fit in. */
5341 unsigned int max_alignment_power = 0;
5343 /* Find maximum alignment power of sections between
5344 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5345 for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5346 if (sec->vma >= expld.dataseg.base
5347 && sec->vma < expld.dataseg.relro_end
5348 && sec->alignment_power > max_alignment_power)
5349 max_alignment_power = sec->alignment_power;
5351 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5353 if (expld.dataseg.base - (1 << max_alignment_power) < old_base)
5354 expld.dataseg.base += expld.dataseg.pagesize;
5355 expld.dataseg.base -= (1 << max_alignment_power);
5356 lang_reset_memory_regions ();
5357 one_lang_size_sections_pass (relax, check_regions);
5360 link_info.relro_start = expld.dataseg.base;
5361 link_info.relro_end = expld.dataseg.relro_end;
5363 else if (expld.dataseg.phase == exp_dataseg_end_seen)
5365 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5366 a page could be saved in the data segment. */
5367 bfd_vma first, last;
5369 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5370 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5372 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5373 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5374 && first + last <= expld.dataseg.pagesize)
5376 expld.dataseg.phase = exp_dataseg_adjust;
5377 lang_reset_memory_regions ();
5378 one_lang_size_sections_pass (relax, check_regions);
5381 expld.dataseg.phase = exp_dataseg_done;
5384 expld.dataseg.phase = exp_dataseg_done;
5387 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5390 lang_do_assignments_1 (lang_statement_union_type *s,
5391 lang_output_section_statement_type *current_os,
5395 for (; s != NULL; s = s->header.next)
5397 switch (s->header.type)
5399 case lang_constructors_statement_enum:
5400 dot = lang_do_assignments_1 (constructor_list.head,
5401 current_os, fill, dot);
5404 case lang_output_section_statement_enum:
5406 lang_output_section_statement_type *os;
5408 os = &(s->output_section_statement);
5409 if (os->bfd_section != NULL && !os->ignored)
5411 dot = os->bfd_section->vma;
5413 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5415 /* .tbss sections effectively have zero size. */
5416 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5417 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5418 || link_info.relocatable)
5419 dot += TO_ADDR (os->bfd_section->size);
5421 if (os->update_dot_tree != NULL)
5422 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5427 case lang_wild_statement_enum:
5429 dot = lang_do_assignments_1 (s->wild_statement.children.head,
5430 current_os, fill, dot);
5433 case lang_object_symbols_statement_enum:
5434 case lang_output_statement_enum:
5435 case lang_target_statement_enum:
5438 case lang_data_statement_enum:
5439 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5440 if (expld.result.valid_p)
5442 s->data_statement.value = expld.result.value;
5443 if (expld.result.section != NULL)
5444 s->data_statement.value += expld.result.section->vma;
5447 einfo (_("%F%P: invalid data statement\n"));
5450 switch (s->data_statement.type)
5468 if (size < TO_SIZE ((unsigned) 1))
5469 size = TO_SIZE ((unsigned) 1);
5470 dot += TO_ADDR (size);
5474 case lang_reloc_statement_enum:
5475 exp_fold_tree (s->reloc_statement.addend_exp,
5476 bfd_abs_section_ptr, &dot);
5477 if (expld.result.valid_p)
5478 s->reloc_statement.addend_value = expld.result.value;
5480 einfo (_("%F%P: invalid reloc statement\n"));
5481 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5484 case lang_input_section_enum:
5486 asection *in = s->input_section.section;
5488 if ((in->flags & SEC_EXCLUDE) == 0)
5489 dot += TO_ADDR (in->size);
5493 case lang_input_statement_enum:
5496 case lang_fill_statement_enum:
5497 fill = s->fill_statement.fill;
5500 case lang_assignment_statement_enum:
5501 exp_fold_tree (s->assignment_statement.exp,
5502 current_os->bfd_section,
5506 case lang_padding_statement_enum:
5507 dot += TO_ADDR (s->padding_statement.size);
5510 case lang_group_statement_enum:
5511 dot = lang_do_assignments_1 (s->group_statement.children.head,
5512 current_os, fill, dot);
5515 case lang_insert_statement_enum:
5518 case lang_address_statement_enum:
5530 lang_do_assignments (void)
5532 lang_statement_iteration++;
5533 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5536 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5537 operator .startof. (section_name), it produces an undefined symbol
5538 .startof.section_name. Similarly, when it sees
5539 .sizeof. (section_name), it produces an undefined symbol
5540 .sizeof.section_name. For all the output sections, we look for
5541 such symbols, and set them to the correct value. */
5544 lang_set_startof (void)
5548 if (link_info.relocatable)
5551 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5553 const char *secname;
5555 struct bfd_link_hash_entry *h;
5557 secname = bfd_get_section_name (link_info.output_bfd, s);
5558 buf = (char *) xmalloc (10 + strlen (secname));
5560 sprintf (buf, ".startof.%s", secname);
5561 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5562 if (h != NULL && h->type == bfd_link_hash_undefined)
5564 h->type = bfd_link_hash_defined;
5565 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5566 h->u.def.section = bfd_abs_section_ptr;
5569 sprintf (buf, ".sizeof.%s", secname);
5570 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5571 if (h != NULL && h->type == bfd_link_hash_undefined)
5573 h->type = bfd_link_hash_defined;
5574 h->u.def.value = TO_ADDR (s->size);
5575 h->u.def.section = bfd_abs_section_ptr;
5585 struct bfd_link_hash_entry *h;
5588 if ((link_info.relocatable && !link_info.gc_sections)
5589 || (link_info.shared && !link_info.executable))
5590 warn = entry_from_cmdline;
5594 /* Force the user to specify a root when generating a relocatable with
5596 if (link_info.gc_sections && link_info.relocatable
5597 && !(entry_from_cmdline || undef_from_cmdline))
5598 einfo (_("%P%F: gc-sections requires either an entry or "
5599 "an undefined symbol\n"));
5601 if (entry_symbol.name == NULL)
5603 /* No entry has been specified. Look for the default entry, but
5604 don't warn if we don't find it. */
5605 entry_symbol.name = entry_symbol_default;
5609 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5610 FALSE, FALSE, TRUE);
5612 && (h->type == bfd_link_hash_defined
5613 || h->type == bfd_link_hash_defweak)
5614 && h->u.def.section->output_section != NULL)
5618 val = (h->u.def.value
5619 + bfd_get_section_vma (link_info.output_bfd,
5620 h->u.def.section->output_section)
5621 + h->u.def.section->output_offset);
5622 if (! bfd_set_start_address (link_info.output_bfd, val))
5623 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5630 /* We couldn't find the entry symbol. Try parsing it as a
5632 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5635 if (! bfd_set_start_address (link_info.output_bfd, val))
5636 einfo (_("%P%F: can't set start address\n"));
5642 /* Can't find the entry symbol, and it's not a number. Use
5643 the first address in the text section. */
5644 ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5648 einfo (_("%P: warning: cannot find entry symbol %s;"
5649 " defaulting to %V\n"),
5651 bfd_get_section_vma (link_info.output_bfd, ts));
5652 if (!(bfd_set_start_address
5653 (link_info.output_bfd,
5654 bfd_get_section_vma (link_info.output_bfd, ts))))
5655 einfo (_("%P%F: can't set start address\n"));
5660 einfo (_("%P: warning: cannot find entry symbol %s;"
5661 " not setting start address\n"),
5667 /* Don't bfd_hash_table_free (&lang_definedness_table);
5668 map file output may result in a call of lang_track_definedness. */
5671 /* This is a small function used when we want to ignore errors from
5675 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5677 /* Don't do anything. */
5680 /* Check that the architecture of all the input files is compatible
5681 with the output file. Also call the backend to let it do any
5682 other checking that is needed. */
5687 lang_statement_union_type *file;
5689 const bfd_arch_info_type *compatible;
5691 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5693 input_bfd = file->input_statement.the_bfd;
5695 = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5696 command_line.accept_unknown_input_arch);
5698 /* In general it is not possible to perform a relocatable
5699 link between differing object formats when the input
5700 file has relocations, because the relocations in the
5701 input format may not have equivalent representations in
5702 the output format (and besides BFD does not translate
5703 relocs for other link purposes than a final link). */
5704 if ((link_info.relocatable || link_info.emitrelocations)
5705 && (compatible == NULL
5706 || (bfd_get_flavour (input_bfd)
5707 != bfd_get_flavour (link_info.output_bfd)))
5708 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5710 einfo (_("%P%F: Relocatable linking with relocations from"
5711 " format %s (%B) to format %s (%B) is not supported\n"),
5712 bfd_get_target (input_bfd), input_bfd,
5713 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5714 /* einfo with %F exits. */
5717 if (compatible == NULL)
5719 if (command_line.warn_mismatch)
5720 einfo (_("%P%X: %s architecture of input file `%B'"
5721 " is incompatible with %s output\n"),
5722 bfd_printable_name (input_bfd), input_bfd,
5723 bfd_printable_name (link_info.output_bfd));
5725 else if (bfd_count_sections (input_bfd))
5727 /* If the input bfd has no contents, it shouldn't set the
5728 private data of the output bfd. */
5730 bfd_error_handler_type pfn = NULL;
5732 /* If we aren't supposed to warn about mismatched input
5733 files, temporarily set the BFD error handler to a
5734 function which will do nothing. We still want to call
5735 bfd_merge_private_bfd_data, since it may set up
5736 information which is needed in the output file. */
5737 if (! command_line.warn_mismatch)
5738 pfn = bfd_set_error_handler (ignore_bfd_errors);
5739 if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5741 if (command_line.warn_mismatch)
5742 einfo (_("%P%X: failed to merge target specific data"
5743 " of file %B\n"), input_bfd);
5745 if (! command_line.warn_mismatch)
5746 bfd_set_error_handler (pfn);
5751 /* Look through all the global common symbols and attach them to the
5752 correct section. The -sort-common command line switch may be used
5753 to roughly sort the entries by alignment. */
5758 if (command_line.inhibit_common_definition)
5760 if (link_info.relocatable
5761 && ! command_line.force_common_definition)
5764 if (! config.sort_common)
5765 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5770 if (config.sort_common == sort_descending)
5772 for (power = 4; power > 0; power--)
5773 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5776 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5780 for (power = 0; power <= 4; power++)
5781 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5784 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5789 /* Place one common symbol in the correct section. */
5792 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5794 unsigned int power_of_two;
5798 if (h->type != bfd_link_hash_common)
5802 power_of_two = h->u.c.p->alignment_power;
5804 if (config.sort_common == sort_descending
5805 && power_of_two < *(unsigned int *) info)
5807 else if (config.sort_common == sort_ascending
5808 && power_of_two > *(unsigned int *) info)
5811 section = h->u.c.p->section;
5812 if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
5813 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5816 if (config.map_file != NULL)
5818 static bfd_boolean header_printed;
5823 if (! header_printed)
5825 minfo (_("\nAllocating common symbols\n"));
5826 minfo (_("Common symbol size file\n\n"));
5827 header_printed = TRUE;
5830 name = bfd_demangle (link_info.output_bfd, h->root.string,
5831 DMGL_ANSI | DMGL_PARAMS);
5834 minfo ("%s", h->root.string);
5835 len = strlen (h->root.string);
5840 len = strlen (name);
5856 if (size <= 0xffffffff)
5857 sprintf (buf, "%lx", (unsigned long) size);
5859 sprintf_vma (buf, size);
5869 minfo ("%B\n", section->owner);
5875 /* Run through the input files and ensure that every input section has
5876 somewhere to go. If one is found without a destination then create
5877 an input request and place it into the statement tree. */
5880 lang_place_orphans (void)
5882 LANG_FOR_EACH_INPUT_STATEMENT (file)
5886 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5888 if (s->output_section == NULL)
5890 /* This section of the file is not attached, root
5891 around for a sensible place for it to go. */
5893 if (file->just_syms_flag)
5894 bfd_link_just_syms (file->the_bfd, s, &link_info);
5895 else if ((s->flags & SEC_EXCLUDE) != 0)
5896 s->output_section = bfd_abs_section_ptr;
5897 else if (strcmp (s->name, "COMMON") == 0)
5899 /* This is a lonely common section which must have
5900 come from an archive. We attach to the section
5901 with the wildcard. */
5902 if (! link_info.relocatable
5903 || command_line.force_common_definition)
5905 if (default_common_section == NULL)
5906 default_common_section
5907 = lang_output_section_statement_lookup (".bss", 0,
5909 lang_add_section (&default_common_section->children, s,
5910 default_common_section);
5915 const char *name = s->name;
5918 if (config.unique_orphan_sections
5919 || unique_section_p (s, NULL))
5920 constraint = SPECIAL;
5922 if (!ldemul_place_orphan (s, name, constraint))
5924 lang_output_section_statement_type *os;
5925 os = lang_output_section_statement_lookup (name,
5928 if (os->addr_tree == NULL
5929 && (link_info.relocatable
5930 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
5931 os->addr_tree = exp_intop (0);
5932 lang_add_section (&os->children, s, os);
5941 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5943 flagword *ptr_flags;
5945 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5951 *ptr_flags |= SEC_ALLOC;
5955 *ptr_flags |= SEC_READONLY;
5959 *ptr_flags |= SEC_DATA;
5963 *ptr_flags |= SEC_CODE;
5968 *ptr_flags |= SEC_LOAD;
5972 einfo (_("%P%F: invalid syntax in flags\n"));
5979 /* Call a function on each input file. This function will be called
5980 on an archive, but not on the elements. */
5983 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5985 lang_input_statement_type *f;
5987 for (f = (lang_input_statement_type *) input_file_chain.head;
5989 f = (lang_input_statement_type *) f->next_real_file)
5993 /* Call a function on each file. The function will be called on all
5994 the elements of an archive which are included in the link, but will
5995 not be called on the archive file itself. */
5998 lang_for_each_file (void (*func) (lang_input_statement_type *))
6000 LANG_FOR_EACH_INPUT_STATEMENT (f)
6007 ldlang_add_file (lang_input_statement_type *entry)
6009 lang_statement_append (&file_chain,
6010 (lang_statement_union_type *) entry,
6013 /* The BFD linker needs to have a list of all input BFDs involved in
6015 ASSERT (entry->the_bfd->link_next == NULL);
6016 ASSERT (entry->the_bfd != link_info.output_bfd);
6018 *link_info.input_bfds_tail = entry->the_bfd;
6019 link_info.input_bfds_tail = &entry->the_bfd->link_next;
6020 entry->the_bfd->usrdata = entry;
6021 bfd_set_gp_size (entry->the_bfd, g_switch_value);
6023 /* Look through the sections and check for any which should not be
6024 included in the link. We need to do this now, so that we can
6025 notice when the backend linker tries to report multiple
6026 definition errors for symbols which are in sections we aren't
6027 going to link. FIXME: It might be better to entirely ignore
6028 symbols which are defined in sections which are going to be
6029 discarded. This would require modifying the backend linker for
6030 each backend which might set the SEC_LINK_ONCE flag. If we do
6031 this, we should probably handle SEC_EXCLUDE in the same way. */
6033 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
6037 lang_add_output (const char *name, int from_script)
6039 /* Make -o on command line override OUTPUT in script. */
6040 if (!had_output_filename || !from_script)
6042 output_filename = name;
6043 had_output_filename = TRUE;
6047 static lang_output_section_statement_type *current_section;
6058 for (l = 0; l < 32; l++)
6060 if (i >= (unsigned int) x)
6068 lang_output_section_statement_type *
6069 lang_enter_output_section_statement (const char *output_section_statement_name,
6070 etree_type *address_exp,
6071 enum section_type sectype,
6073 etree_type *subalign,
6077 lang_output_section_statement_type *os;
6079 os = lang_output_section_statement_lookup (output_section_statement_name,
6081 current_section = os;
6083 if (os->addr_tree == NULL)
6085 os->addr_tree = address_exp;
6087 os->sectype = sectype;
6088 if (sectype != noload_section)
6089 os->flags = SEC_NO_FLAGS;
6091 os->flags = SEC_NEVER_LOAD;
6092 os->block_value = 1;
6094 /* Make next things chain into subchain of this. */
6095 push_stat_ptr (&os->children);
6097 os->subsection_alignment =
6098 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
6099 os->section_alignment =
6100 topower (exp_get_value_int (align, -1, "section alignment"));
6102 os->load_base = ebase;
6109 lang_output_statement_type *new_stmt;
6111 new_stmt = new_stat (lang_output_statement, stat_ptr);
6112 new_stmt->name = output_filename;
6116 /* Reset the current counters in the regions. */
6119 lang_reset_memory_regions (void)
6121 lang_memory_region_type *p = lang_memory_region_list;
6123 lang_output_section_statement_type *os;
6125 for (p = lang_memory_region_list; p != NULL; p = p->next)
6127 p->current = p->origin;
6131 for (os = &lang_output_section_statement.head->output_section_statement;
6135 os->processed_vma = FALSE;
6136 os->processed_lma = FALSE;
6139 for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
6141 /* Save the last size for possible use by bfd_relax_section. */
6142 o->rawsize = o->size;
6147 /* Worker for lang_gc_sections_1. */
6150 gc_section_callback (lang_wild_statement_type *ptr,
6151 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6153 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6154 void *data ATTRIBUTE_UNUSED)
6156 /* If the wild pattern was marked KEEP, the member sections
6157 should be as well. */
6158 if (ptr->keep_sections)
6159 section->flags |= SEC_KEEP;
6162 /* Iterate over sections marking them against GC. */
6165 lang_gc_sections_1 (lang_statement_union_type *s)
6167 for (; s != NULL; s = s->header.next)
6169 switch (s->header.type)
6171 case lang_wild_statement_enum:
6172 walk_wild (&s->wild_statement, gc_section_callback, NULL);
6174 case lang_constructors_statement_enum:
6175 lang_gc_sections_1 (constructor_list.head);
6177 case lang_output_section_statement_enum:
6178 lang_gc_sections_1 (s->output_section_statement.children.head);
6180 case lang_group_statement_enum:
6181 lang_gc_sections_1 (s->group_statement.children.head);
6190 lang_gc_sections (void)
6192 /* Keep all sections so marked in the link script. */
6194 lang_gc_sections_1 (statement_list.head);
6196 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6197 the special case of debug info. (See bfd/stabs.c)
6198 Twiddle the flag here, to simplify later linker code. */
6199 if (link_info.relocatable)
6201 LANG_FOR_EACH_INPUT_STATEMENT (f)
6204 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6205 if ((sec->flags & SEC_DEBUGGING) == 0)
6206 sec->flags &= ~SEC_EXCLUDE;
6210 if (link_info.gc_sections)
6211 bfd_gc_sections (link_info.output_bfd, &link_info);
6214 /* Worker for lang_find_relro_sections_1. */
6217 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6218 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6220 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6223 /* Discarded, excluded and ignored sections effectively have zero
6225 if (section->output_section != NULL
6226 && section->output_section->owner == link_info.output_bfd
6227 && (section->output_section->flags & SEC_EXCLUDE) == 0
6228 && !IGNORE_SECTION (section)
6229 && section->size != 0)
6231 bfd_boolean *has_relro_section = (bfd_boolean *) data;
6232 *has_relro_section = TRUE;
6236 /* Iterate over sections for relro sections. */
6239 lang_find_relro_sections_1 (lang_statement_union_type *s,
6240 bfd_boolean *has_relro_section)
6242 if (*has_relro_section)
6245 for (; s != NULL; s = s->header.next)
6247 if (s == expld.dataseg.relro_end_stat)
6250 switch (s->header.type)
6252 case lang_wild_statement_enum:
6253 walk_wild (&s->wild_statement,
6254 find_relro_section_callback,
6257 case lang_constructors_statement_enum:
6258 lang_find_relro_sections_1 (constructor_list.head,
6261 case lang_output_section_statement_enum:
6262 lang_find_relro_sections_1 (s->output_section_statement.children.head,
6265 case lang_group_statement_enum:
6266 lang_find_relro_sections_1 (s->group_statement.children.head,
6276 lang_find_relro_sections (void)
6278 bfd_boolean has_relro_section = FALSE;
6280 /* Check all sections in the link script. */
6282 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6283 &has_relro_section);
6285 if (!has_relro_section)
6286 link_info.relro = FALSE;
6289 /* Relax all sections until bfd_relax_section gives up. */
6292 lang_relax_sections (bfd_boolean need_layout)
6294 if (RELAXATION_ENABLED)
6296 /* We may need more than one relaxation pass. */
6297 int i = link_info.relax_pass;
6299 /* The backend can use it to determine the current pass. */
6300 link_info.relax_pass = 0;
6304 /* Keep relaxing until bfd_relax_section gives up. */
6305 bfd_boolean relax_again;
6307 link_info.relax_trip = -1;
6310 link_info.relax_trip++;
6312 /* Note: pe-dll.c does something like this also. If you find
6313 you need to change this code, you probably need to change
6314 pe-dll.c also. DJ */
6316 /* Do all the assignments with our current guesses as to
6318 lang_do_assignments ();
6320 /* We must do this after lang_do_assignments, because it uses
6322 lang_reset_memory_regions ();
6324 /* Perform another relax pass - this time we know where the
6325 globals are, so can make a better guess. */
6326 relax_again = FALSE;
6327 lang_size_sections (&relax_again, FALSE);
6329 while (relax_again);
6331 link_info.relax_pass++;
6338 /* Final extra sizing to report errors. */
6339 lang_do_assignments ();
6340 lang_reset_memory_regions ();
6341 lang_size_sections (NULL, TRUE);
6348 /* Finalize dynamic list. */
6349 if (link_info.dynamic_list)
6350 lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6352 current_target = default_target;
6354 /* Open the output file. */
6355 lang_for_each_statement (ldlang_open_output);
6358 ldemul_create_output_section_statements ();
6360 /* Add to the hash table all undefineds on the command line. */
6361 lang_place_undefineds ();
6363 if (!bfd_section_already_linked_table_init ())
6364 einfo (_("%P%F: Failed to create hash table\n"));
6366 /* Create a bfd for each input file. */
6367 current_target = default_target;
6368 open_input_bfds (statement_list.head, FALSE);
6370 #ifdef ENABLE_PLUGINS
6372 union lang_statement_union **listend;
6373 /* Now all files are read, let the plugin(s) decide if there
6374 are any more to be added to the link before we call the
6375 emulation's after_open hook. */
6376 listend = statement_list.tail;
6378 if (plugin_call_all_symbols_read ())
6379 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6380 plugin_error_plugin ());
6381 /* If any new files were added, they will be on the end of the
6382 statement list, and we can open them now by getting open_input_bfds
6383 to carry on from where it ended last time. */
6385 open_input_bfds (*listend, FALSE);
6387 #endif /* ENABLE_PLUGINS */
6389 link_info.gc_sym_list = &entry_symbol;
6390 if (entry_symbol.name == NULL)
6391 link_info.gc_sym_list = ldlang_undef_chain_list_head;
6393 ldemul_after_open ();
6395 bfd_section_already_linked_table_free ();
6397 /* Make sure that we're not mixing architectures. We call this
6398 after all the input files have been opened, but before we do any
6399 other processing, so that any operations merge_private_bfd_data
6400 does on the output file will be known during the rest of the
6404 /* Handle .exports instead of a version script if we're told to do so. */
6405 if (command_line.version_exports_section)
6406 lang_do_version_exports_section ();
6408 /* Build all sets based on the information gathered from the input
6410 ldctor_build_sets ();
6412 /* Remove unreferenced sections if asked to. */
6413 lang_gc_sections ();
6415 /* Size up the common data. */
6418 /* Update wild statements. */
6419 update_wild_statements (statement_list.head);
6421 /* Run through the contours of the script and attach input sections
6422 to the correct output sections. */
6423 lang_statement_iteration++;
6424 map_input_to_output_sections (statement_list.head, NULL, NULL);
6426 process_insert_statements ();
6428 /* Find any sections not attached explicitly and handle them. */
6429 lang_place_orphans ();
6431 if (! link_info.relocatable)
6435 /* Merge SEC_MERGE sections. This has to be done after GC of
6436 sections, so that GCed sections are not merged, but before
6437 assigning dynamic symbols, since removing whole input sections
6439 bfd_merge_sections (link_info.output_bfd, &link_info);
6441 /* Look for a text section and set the readonly attribute in it. */
6442 found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6446 if (config.text_read_only)
6447 found->flags |= SEC_READONLY;
6449 found->flags &= ~SEC_READONLY;
6453 /* Do anything special before sizing sections. This is where ELF
6454 and other back-ends size dynamic sections. */
6455 ldemul_before_allocation ();
6457 /* We must record the program headers before we try to fix the
6458 section positions, since they will affect SIZEOF_HEADERS. */
6459 lang_record_phdrs ();
6461 /* Check relro sections. */
6462 if (link_info.relro && ! link_info.relocatable)
6463 lang_find_relro_sections ();
6465 /* Size up the sections. */
6466 lang_size_sections (NULL, ! RELAXATION_ENABLED);
6468 /* See if anything special should be done now we know how big
6469 everything is. This is where relaxation is done. */
6470 ldemul_after_allocation ();
6472 /* Fix any .startof. or .sizeof. symbols. */
6473 lang_set_startof ();
6475 /* Do all the assignments, now that we know the final resting places
6476 of all the symbols. */
6477 expld.phase = lang_final_phase_enum;
6478 lang_do_assignments ();
6482 /* Make sure that the section addresses make sense. */
6483 if (command_line.check_section_addresses)
6484 lang_check_section_addresses ();
6489 /* EXPORTED TO YACC */
6492 lang_add_wild (struct wildcard_spec *filespec,
6493 struct wildcard_list *section_list,
6494 bfd_boolean keep_sections)
6496 struct wildcard_list *curr, *next;
6497 lang_wild_statement_type *new_stmt;
6499 /* Reverse the list as the parser puts it back to front. */
6500 for (curr = section_list, section_list = NULL;
6502 section_list = curr, curr = next)
6504 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6505 placed_commons = TRUE;
6508 curr->next = section_list;
6511 if (filespec != NULL && filespec->name != NULL)
6513 if (strcmp (filespec->name, "*") == 0)
6514 filespec->name = NULL;
6515 else if (! wildcardp (filespec->name))
6516 lang_has_input_file = TRUE;
6519 new_stmt = new_stat (lang_wild_statement, stat_ptr);
6520 new_stmt->filename = NULL;
6521 new_stmt->filenames_sorted = FALSE;
6522 if (filespec != NULL)
6524 new_stmt->filename = filespec->name;
6525 new_stmt->filenames_sorted = filespec->sorted == by_name;
6527 new_stmt->section_list = section_list;
6528 new_stmt->keep_sections = keep_sections;
6529 lang_list_init (&new_stmt->children);
6530 analyze_walk_wild_section_handler (new_stmt);
6534 lang_section_start (const char *name, etree_type *address,
6535 const segment_type *segment)
6537 lang_address_statement_type *ad;
6539 ad = new_stat (lang_address_statement, stat_ptr);
6540 ad->section_name = name;
6541 ad->address = address;
6542 ad->segment = segment;
6545 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6546 because of a -e argument on the command line, or zero if this is
6547 called by ENTRY in a linker script. Command line arguments take
6551 lang_add_entry (const char *name, bfd_boolean cmdline)
6553 if (entry_symbol.name == NULL
6555 || ! entry_from_cmdline)
6557 entry_symbol.name = name;
6558 entry_from_cmdline = cmdline;
6562 /* Set the default start symbol to NAME. .em files should use this,
6563 not lang_add_entry, to override the use of "start" if neither the
6564 linker script nor the command line specifies an entry point. NAME
6565 must be permanently allocated. */
6567 lang_default_entry (const char *name)
6569 entry_symbol_default = name;
6573 lang_add_target (const char *name)
6575 lang_target_statement_type *new_stmt;
6577 new_stmt = new_stat (lang_target_statement, stat_ptr);
6578 new_stmt->target = name;
6582 lang_add_map (const char *name)
6589 map_option_f = TRUE;
6597 lang_add_fill (fill_type *fill)
6599 lang_fill_statement_type *new_stmt;
6601 new_stmt = new_stat (lang_fill_statement, stat_ptr);
6602 new_stmt->fill = fill;
6606 lang_add_data (int type, union etree_union *exp)
6608 lang_data_statement_type *new_stmt;
6610 new_stmt = new_stat (lang_data_statement, stat_ptr);
6611 new_stmt->exp = exp;
6612 new_stmt->type = type;
6615 /* Create a new reloc statement. RELOC is the BFD relocation type to
6616 generate. HOWTO is the corresponding howto structure (we could
6617 look this up, but the caller has already done so). SECTION is the
6618 section to generate a reloc against, or NAME is the name of the
6619 symbol to generate a reloc against. Exactly one of SECTION and
6620 NAME must be NULL. ADDEND is an expression for the addend. */
6623 lang_add_reloc (bfd_reloc_code_real_type reloc,
6624 reloc_howto_type *howto,
6627 union etree_union *addend)
6629 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6633 p->section = section;
6635 p->addend_exp = addend;
6637 p->addend_value = 0;
6638 p->output_section = NULL;
6639 p->output_offset = 0;
6642 lang_assignment_statement_type *
6643 lang_add_assignment (etree_type *exp)
6645 lang_assignment_statement_type *new_stmt;
6647 new_stmt = new_stat (lang_assignment_statement, stat_ptr);
6648 new_stmt->exp = exp;
6653 lang_add_attribute (enum statement_enum attribute)
6655 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6659 lang_startup (const char *name)
6661 if (startup_file != NULL)
6663 einfo (_("%P%F: multiple STARTUP files\n"));
6665 first_file->filename = name;
6666 first_file->local_sym_name = name;
6667 first_file->real = TRUE;
6669 startup_file = name;
6673 lang_float (bfd_boolean maybe)
6675 lang_float_flag = maybe;
6679 /* Work out the load- and run-time regions from a script statement, and
6680 store them in *LMA_REGION and *REGION respectively.
6682 MEMSPEC is the name of the run-time region, or the value of
6683 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6684 LMA_MEMSPEC is the name of the load-time region, or null if the
6685 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6686 had an explicit load address.
6688 It is an error to specify both a load region and a load address. */
6691 lang_get_regions (lang_memory_region_type **region,
6692 lang_memory_region_type **lma_region,
6693 const char *memspec,
6694 const char *lma_memspec,
6695 bfd_boolean have_lma,
6696 bfd_boolean have_vma)
6698 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6700 /* If no runtime region or VMA has been specified, but the load region
6701 has been specified, then use the load region for the runtime region
6703 if (lma_memspec != NULL
6705 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6706 *region = *lma_region;
6708 *region = lang_memory_region_lookup (memspec, FALSE);
6710 if (have_lma && lma_memspec != 0)
6711 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6715 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6716 lang_output_section_phdr_list *phdrs,
6717 const char *lma_memspec)
6719 lang_get_regions (¤t_section->region,
6720 ¤t_section->lma_region,
6721 memspec, lma_memspec,
6722 current_section->load_base != NULL,
6723 current_section->addr_tree != NULL);
6725 /* If this section has no load region or base, but has the same
6726 region as the previous section, then propagate the previous
6727 section's load region. */
6729 if (!current_section->lma_region && !current_section->load_base
6730 && current_section->region == current_section->prev->region)
6731 current_section->lma_region = current_section->prev->lma_region;
6733 current_section->fill = fill;
6734 current_section->phdrs = phdrs;
6738 /* Create an absolute symbol with the given name with the value of the
6739 address of first byte of the section named.
6741 If the symbol already exists, then do nothing. */
6744 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6746 struct bfd_link_hash_entry *h;
6748 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6750 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6752 if (h->type == bfd_link_hash_new
6753 || h->type == bfd_link_hash_undefined)
6757 h->type = bfd_link_hash_defined;
6759 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6763 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
6765 h->u.def.section = bfd_abs_section_ptr;
6769 /* Create an absolute symbol with the given name with the value of the
6770 address of the first byte after the end of the section named.
6772 If the symbol already exists, then do nothing. */
6775 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6777 struct bfd_link_hash_entry *h;
6779 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6781 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6783 if (h->type == bfd_link_hash_new
6784 || h->type == bfd_link_hash_undefined)
6788 h->type = bfd_link_hash_defined;
6790 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6794 h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
6795 + TO_ADDR (sec->size));
6797 h->u.def.section = bfd_abs_section_ptr;
6802 lang_statement_append (lang_statement_list_type *list,
6803 lang_statement_union_type *element,
6804 lang_statement_union_type **field)
6806 *(list->tail) = element;
6810 /* Set the output format type. -oformat overrides scripts. */
6813 lang_add_output_format (const char *format,
6818 if (output_target == NULL || !from_script)
6820 if (command_line.endian == ENDIAN_BIG
6823 else if (command_line.endian == ENDIAN_LITTLE
6827 output_target = format;
6832 lang_add_insert (const char *where, int is_before)
6834 lang_insert_statement_type *new_stmt;
6836 new_stmt = new_stat (lang_insert_statement, stat_ptr);
6837 new_stmt->where = where;
6838 new_stmt->is_before = is_before;
6839 saved_script_handle = previous_script_handle;
6842 /* Enter a group. This creates a new lang_group_statement, and sets
6843 stat_ptr to build new statements within the group. */
6846 lang_enter_group (void)
6848 lang_group_statement_type *g;
6850 g = new_stat (lang_group_statement, stat_ptr);
6851 lang_list_init (&g->children);
6852 push_stat_ptr (&g->children);
6855 /* Leave a group. This just resets stat_ptr to start writing to the
6856 regular list of statements again. Note that this will not work if
6857 groups can occur inside anything else which can adjust stat_ptr,
6858 but currently they can't. */
6861 lang_leave_group (void)
6866 /* Add a new program header. This is called for each entry in a PHDRS
6867 command in a linker script. */
6870 lang_new_phdr (const char *name,
6872 bfd_boolean filehdr,
6877 struct lang_phdr *n, **pp;
6880 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
6883 n->type = exp_get_value_int (type, 0, "program header type");
6884 n->filehdr = filehdr;
6889 hdrs = n->type == 1 && (phdrs || filehdr);
6891 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6894 && !((*pp)->filehdr || (*pp)->phdrs))
6896 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));
6903 /* Record the program header information in the output BFD. FIXME: We
6904 should not be calling an ELF specific function here. */
6907 lang_record_phdrs (void)
6911 lang_output_section_phdr_list *last;
6912 struct lang_phdr *l;
6913 lang_output_section_statement_type *os;
6916 secs = (asection **) xmalloc (alc * sizeof (asection *));
6919 for (l = lang_phdr_list; l != NULL; l = l->next)
6926 for (os = &lang_output_section_statement.head->output_section_statement;
6930 lang_output_section_phdr_list *pl;
6932 if (os->constraint < 0)
6940 if (os->sectype == noload_section
6941 || os->bfd_section == NULL
6942 || (os->bfd_section->flags & SEC_ALLOC) == 0)
6945 /* Don't add orphans to PT_INTERP header. */
6951 lang_output_section_statement_type * tmp_os;
6953 /* If we have not run across a section with a program
6954 header assigned to it yet, then scan forwards to find
6955 one. This prevents inconsistencies in the linker's
6956 behaviour when a script has specified just a single
6957 header and there are sections in that script which are
6958 not assigned to it, and which occur before the first
6959 use of that header. See here for more details:
6960 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6961 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6964 last = tmp_os->phdrs;
6968 einfo (_("%F%P: no sections assigned to phdrs\n"));
6973 if (os->bfd_section == NULL)
6976 for (; pl != NULL; pl = pl->next)
6978 if (strcmp (pl->name, l->name) == 0)
6983 secs = (asection **) xrealloc (secs,
6984 alc * sizeof (asection *));
6986 secs[c] = os->bfd_section;
6993 if (l->flags == NULL)
6996 flags = exp_get_vma (l->flags, 0, "phdr flags");
7001 at = exp_get_vma (l->at, 0, "phdr load address");
7003 if (! bfd_record_phdr (link_info.output_bfd, l->type,
7004 l->flags != NULL, flags, l->at != NULL,
7005 at, l->filehdr, l->phdrs, c, secs))
7006 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7011 /* Make sure all the phdr assignments succeeded. */
7012 for (os = &lang_output_section_statement.head->output_section_statement;
7016 lang_output_section_phdr_list *pl;
7018 if (os->constraint < 0
7019 || os->bfd_section == NULL)
7022 for (pl = os->phdrs;
7025 if (! pl->used && strcmp (pl->name, "NONE") != 0)
7026 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7027 os->name, pl->name);
7031 /* Record a list of sections which may not be cross referenced. */
7034 lang_add_nocrossref (lang_nocrossref_type *l)
7036 struct lang_nocrossrefs *n;
7038 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
7039 n->next = nocrossref_list;
7041 nocrossref_list = n;
7043 /* Set notice_all so that we get informed about all symbols. */
7044 link_info.notice_all = TRUE;
7047 /* Overlay handling. We handle overlays with some static variables. */
7049 /* The overlay virtual address. */
7050 static etree_type *overlay_vma;
7051 /* And subsection alignment. */
7052 static etree_type *overlay_subalign;
7054 /* An expression for the maximum section size seen so far. */
7055 static etree_type *overlay_max;
7057 /* A list of all the sections in this overlay. */
7059 struct overlay_list {
7060 struct overlay_list *next;
7061 lang_output_section_statement_type *os;
7064 static struct overlay_list *overlay_list;
7066 /* Start handling an overlay. */
7069 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
7071 /* The grammar should prevent nested overlays from occurring. */
7072 ASSERT (overlay_vma == NULL
7073 && overlay_subalign == NULL
7074 && overlay_max == NULL);
7076 overlay_vma = vma_expr;
7077 overlay_subalign = subalign;
7080 /* Start a section in an overlay. We handle this by calling
7081 lang_enter_output_section_statement with the correct VMA.
7082 lang_leave_overlay sets up the LMA and memory regions. */
7085 lang_enter_overlay_section (const char *name)
7087 struct overlay_list *n;
7090 lang_enter_output_section_statement (name, overlay_vma, overlay_section,
7091 0, overlay_subalign, 0, 0);
7093 /* If this is the first section, then base the VMA of future
7094 sections on this one. This will work correctly even if `.' is
7095 used in the addresses. */
7096 if (overlay_list == NULL)
7097 overlay_vma = exp_nameop (ADDR, name);
7099 /* Remember the section. */
7100 n = (struct overlay_list *) xmalloc (sizeof *n);
7101 n->os = current_section;
7102 n->next = overlay_list;
7105 size = exp_nameop (SIZEOF, name);
7107 /* Arrange to work out the maximum section end address. */
7108 if (overlay_max == NULL)
7111 overlay_max = exp_binop (MAX_K, overlay_max, size);
7114 /* Finish a section in an overlay. There isn't any special to do
7118 lang_leave_overlay_section (fill_type *fill,
7119 lang_output_section_phdr_list *phdrs)
7126 name = current_section->name;
7128 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7129 region and that no load-time region has been specified. It doesn't
7130 really matter what we say here, since lang_leave_overlay will
7132 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
7134 /* Define the magic symbols. */
7136 clean = (char *) xmalloc (strlen (name) + 1);
7138 for (s1 = name; *s1 != '\0'; s1++)
7139 if (ISALNUM (*s1) || *s1 == '_')
7143 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
7144 sprintf (buf, "__load_start_%s", clean);
7145 lang_add_assignment (exp_provide (buf,
7146 exp_nameop (LOADADDR, name),
7149 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
7150 sprintf (buf, "__load_stop_%s", clean);
7151 lang_add_assignment (exp_provide (buf,
7153 exp_nameop (LOADADDR, name),
7154 exp_nameop (SIZEOF, name)),
7160 /* Finish an overlay. If there are any overlay wide settings, this
7161 looks through all the sections in the overlay and sets them. */
7164 lang_leave_overlay (etree_type *lma_expr,
7167 const char *memspec,
7168 lang_output_section_phdr_list *phdrs,
7169 const char *lma_memspec)
7171 lang_memory_region_type *region;
7172 lang_memory_region_type *lma_region;
7173 struct overlay_list *l;
7174 lang_nocrossref_type *nocrossref;
7176 lang_get_regions (®ion, &lma_region,
7177 memspec, lma_memspec,
7178 lma_expr != NULL, FALSE);
7182 /* After setting the size of the last section, set '.' to end of the
7184 if (overlay_list != NULL)
7185 overlay_list->os->update_dot_tree
7186 = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));
7191 struct overlay_list *next;
7193 if (fill != NULL && l->os->fill == NULL)
7196 l->os->region = region;
7197 l->os->lma_region = lma_region;
7199 /* The first section has the load address specified in the
7200 OVERLAY statement. The rest are worked out from that.
7201 The base address is not needed (and should be null) if
7202 an LMA region was specified. */
7205 l->os->load_base = lma_expr;
7206 l->os->sectype = normal_section;
7208 if (phdrs != NULL && l->os->phdrs == NULL)
7209 l->os->phdrs = phdrs;
7213 lang_nocrossref_type *nc;
7215 nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
7216 nc->name = l->os->name;
7217 nc->next = nocrossref;
7226 if (nocrossref != NULL)
7227 lang_add_nocrossref (nocrossref);
7230 overlay_list = NULL;
7234 /* Version handling. This is only useful for ELF. */
7236 /* This global variable holds the version tree that we build. */
7238 struct bfd_elf_version_tree *lang_elf_version_info;
7240 /* If PREV is NULL, return first version pattern matching particular symbol.
7241 If PREV is non-NULL, return first version pattern matching particular
7242 symbol after PREV (previously returned by lang_vers_match). */
7244 static struct bfd_elf_version_expr *
7245 lang_vers_match (struct bfd_elf_version_expr_head *head,
7246 struct bfd_elf_version_expr *prev,
7249 const char *cxx_sym = sym;
7250 const char *java_sym = sym;
7251 struct bfd_elf_version_expr *expr = NULL;
7253 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7255 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
7259 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7261 java_sym = cplus_demangle (sym, DMGL_JAVA);
7266 if (head->htab && (prev == NULL || prev->literal))
7268 struct bfd_elf_version_expr e;
7270 switch (prev ? prev->mask : 0)
7273 if (head->mask & BFD_ELF_VERSION_C_TYPE)
7276 expr = (struct bfd_elf_version_expr *)
7277 htab_find ((htab_t) head->htab, &e);
7278 while (expr && strcmp (expr->pattern, sym) == 0)
7279 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7285 case BFD_ELF_VERSION_C_TYPE:
7286 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7288 e.pattern = cxx_sym;
7289 expr = (struct bfd_elf_version_expr *)
7290 htab_find ((htab_t) head->htab, &e);
7291 while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7292 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7298 case BFD_ELF_VERSION_CXX_TYPE:
7299 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7301 e.pattern = java_sym;
7302 expr = (struct bfd_elf_version_expr *)
7303 htab_find ((htab_t) head->htab, &e);
7304 while (expr && strcmp (expr->pattern, java_sym) == 0)
7305 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7316 /* Finally, try the wildcards. */
7317 if (prev == NULL || prev->literal)
7318 expr = head->remaining;
7321 for (; expr; expr = expr->next)
7328 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7331 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7333 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7337 if (fnmatch (expr->pattern, s, 0) == 0)
7343 free ((char *) cxx_sym);
7344 if (java_sym != sym)
7345 free ((char *) java_sym);
7349 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7350 return a pointer to the symbol name with any backslash quotes removed. */
7353 realsymbol (const char *pattern)
7356 bfd_boolean changed = FALSE, backslash = FALSE;
7357 char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
7359 for (p = pattern, s = symbol; *p != '\0'; ++p)
7361 /* It is a glob pattern only if there is no preceding
7365 /* Remove the preceding backslash. */
7372 if (*p == '?' || *p == '*' || *p == '[')
7379 backslash = *p == '\\';
7395 /* This is called for each variable name or match expression. NEW_NAME is
7396 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7397 pattern to be matched against symbol names. */
7399 struct bfd_elf_version_expr *
7400 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7401 const char *new_name,
7403 bfd_boolean literal_p)
7405 struct bfd_elf_version_expr *ret;
7407 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
7411 ret->literal = TRUE;
7412 ret->pattern = literal_p ? new_name : realsymbol (new_name);
7413 if (ret->pattern == NULL)
7415 ret->pattern = new_name;
7416 ret->literal = FALSE;
7419 if (lang == NULL || strcasecmp (lang, "C") == 0)
7420 ret->mask = BFD_ELF_VERSION_C_TYPE;
7421 else if (strcasecmp (lang, "C++") == 0)
7422 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7423 else if (strcasecmp (lang, "Java") == 0)
7424 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7427 einfo (_("%X%P: unknown language `%s' in version information\n"),
7429 ret->mask = BFD_ELF_VERSION_C_TYPE;
7432 return ldemul_new_vers_pattern (ret);
7435 /* This is called for each set of variable names and match
7438 struct bfd_elf_version_tree *
7439 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7440 struct bfd_elf_version_expr *locals)
7442 struct bfd_elf_version_tree *ret;
7444 ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
7445 ret->globals.list = globals;
7446 ret->locals.list = locals;
7447 ret->match = lang_vers_match;
7448 ret->name_indx = (unsigned int) -1;
7452 /* This static variable keeps track of version indices. */
7454 static int version_index;
7457 version_expr_head_hash (const void *p)
7459 const struct bfd_elf_version_expr *e =
7460 (const struct bfd_elf_version_expr *) p;
7462 return htab_hash_string (e->pattern);
7466 version_expr_head_eq (const void *p1, const void *p2)
7468 const struct bfd_elf_version_expr *e1 =
7469 (const struct bfd_elf_version_expr *) p1;
7470 const struct bfd_elf_version_expr *e2 =
7471 (const struct bfd_elf_version_expr *) p2;
7473 return strcmp (e1->pattern, e2->pattern) == 0;
7477 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7480 struct bfd_elf_version_expr *e, *next;
7481 struct bfd_elf_version_expr **list_loc, **remaining_loc;
7483 for (e = head->list; e; e = e->next)
7487 head->mask |= e->mask;
7492 head->htab = htab_create (count * 2, version_expr_head_hash,
7493 version_expr_head_eq, NULL);
7494 list_loc = &head->list;
7495 remaining_loc = &head->remaining;
7496 for (e = head->list; e; e = next)
7502 remaining_loc = &e->next;
7506 void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
7510 struct bfd_elf_version_expr *e1, *last;
7512 e1 = (struct bfd_elf_version_expr *) *loc;
7516 if (e1->mask == e->mask)
7524 while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7528 /* This is a duplicate. */
7529 /* FIXME: Memory leak. Sometimes pattern is not
7530 xmalloced alone, but in larger chunk of memory. */
7531 /* free (e->pattern); */
7536 e->next = last->next;
7544 list_loc = &e->next;
7548 *remaining_loc = NULL;
7549 *list_loc = head->remaining;
7552 head->remaining = head->list;
7555 /* This is called when we know the name and dependencies of the
7559 lang_register_vers_node (const char *name,
7560 struct bfd_elf_version_tree *version,
7561 struct bfd_elf_version_deps *deps)
7563 struct bfd_elf_version_tree *t, **pp;
7564 struct bfd_elf_version_expr *e1;
7569 if ((name[0] == '\0' && lang_elf_version_info != NULL)
7570 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
7572 einfo (_("%X%P: anonymous version tag cannot be combined"
7573 " with other version tags\n"));
7578 /* Make sure this node has a unique name. */
7579 for (t = lang_elf_version_info; t != NULL; t = t->next)
7580 if (strcmp (t->name, name) == 0)
7581 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7583 lang_finalize_version_expr_head (&version->globals);
7584 lang_finalize_version_expr_head (&version->locals);
7586 /* Check the global and local match names, and make sure there
7587 aren't any duplicates. */
7589 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7591 for (t = lang_elf_version_info; t != NULL; t = t->next)
7593 struct bfd_elf_version_expr *e2;
7595 if (t->locals.htab && e1->literal)
7597 e2 = (struct bfd_elf_version_expr *)
7598 htab_find ((htab_t) t->locals.htab, e1);
7599 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7601 if (e1->mask == e2->mask)
7602 einfo (_("%X%P: duplicate expression `%s'"
7603 " in version information\n"), e1->pattern);
7607 else if (!e1->literal)
7608 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7609 if (strcmp (e1->pattern, e2->pattern) == 0
7610 && e1->mask == e2->mask)
7611 einfo (_("%X%P: duplicate expression `%s'"
7612 " in version information\n"), e1->pattern);
7616 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7618 for (t = lang_elf_version_info; t != NULL; t = t->next)
7620 struct bfd_elf_version_expr *e2;
7622 if (t->globals.htab && e1->literal)
7624 e2 = (struct bfd_elf_version_expr *)
7625 htab_find ((htab_t) t->globals.htab, e1);
7626 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7628 if (e1->mask == e2->mask)
7629 einfo (_("%X%P: duplicate expression `%s'"
7630 " in version information\n"),
7635 else if (!e1->literal)
7636 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7637 if (strcmp (e1->pattern, e2->pattern) == 0
7638 && e1->mask == e2->mask)
7639 einfo (_("%X%P: duplicate expression `%s'"
7640 " in version information\n"), e1->pattern);
7644 version->deps = deps;
7645 version->name = name;
7646 if (name[0] != '\0')
7649 version->vernum = version_index;
7652 version->vernum = 0;
7654 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7659 /* This is called when we see a version dependency. */
7661 struct bfd_elf_version_deps *
7662 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7664 struct bfd_elf_version_deps *ret;
7665 struct bfd_elf_version_tree *t;
7667 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
7670 for (t = lang_elf_version_info; t != NULL; t = t->next)
7672 if (strcmp (t->name, name) == 0)
7674 ret->version_needed = t;
7679 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7681 ret->version_needed = NULL;
7686 lang_do_version_exports_section (void)
7688 struct bfd_elf_version_expr *greg = NULL, *lreg;
7690 LANG_FOR_EACH_INPUT_STATEMENT (is)
7692 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7700 contents = (char *) xmalloc (len);
7701 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7702 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7705 while (p < contents + len)
7707 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7708 p = strchr (p, '\0') + 1;
7711 /* Do not free the contents, as we used them creating the regex. */
7713 /* Do not include this section in the link. */
7714 sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7717 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7718 lang_register_vers_node (command_line.version_exports_section,
7719 lang_new_vers_node (greg, lreg), NULL);
7723 lang_add_unique (const char *name)
7725 struct unique_sections *ent;
7727 for (ent = unique_section_list; ent; ent = ent->next)
7728 if (strcmp (ent->name, name) == 0)
7731 ent = (struct unique_sections *) xmalloc (sizeof *ent);
7732 ent->name = xstrdup (name);
7733 ent->next = unique_section_list;
7734 unique_section_list = ent;
7737 /* Append the list of dynamic symbols to the existing one. */
7740 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7742 if (link_info.dynamic_list)
7744 struct bfd_elf_version_expr *tail;
7745 for (tail = dynamic; tail->next != NULL; tail = tail->next)
7747 tail->next = link_info.dynamic_list->head.list;
7748 link_info.dynamic_list->head.list = dynamic;
7752 struct bfd_elf_dynamic_list *d;
7754 d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
7755 d->head.list = dynamic;
7756 d->match = lang_vers_match;
7757 link_info.dynamic_list = d;
7761 /* Append the list of C++ typeinfo dynamic symbols to the existing
7765 lang_append_dynamic_list_cpp_typeinfo (void)
7767 const char * symbols [] =
7769 "typeinfo name for*",
7772 struct bfd_elf_version_expr *dynamic = NULL;
7775 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7776 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7779 lang_append_dynamic_list (dynamic);
7782 /* Append the list of C++ operator new and delete dynamic symbols to the
7786 lang_append_dynamic_list_cpp_new (void)
7788 const char * symbols [] =
7793 struct bfd_elf_version_expr *dynamic = NULL;
7796 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7797 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7800 lang_append_dynamic_list (dynamic);
7803 /* Scan a space and/or comma separated string of features. */
7806 lang_ld_feature (char *str)
7814 while (*p == ',' || ISSPACE (*p))
7819 while (*q && *q != ',' && !ISSPACE (*q))
7823 if (strcasecmp (p, "SANE_EXPR") == 0)
7824 config.sane_expr = TRUE;
7826 einfo (_("%X%P: unknown feature `%s'\n"), p);