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_assign (symname,
1762 exp_nameop (NAME, "."))));
1766 if (add_child == NULL)
1767 add_child = &os->children;
1768 lang_add_section (add_child, s, os);
1770 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1772 const char *region = (after->region
1773 ? after->region->name_list.name
1774 : DEFAULT_MEMORY_REGION);
1775 const char *lma_region = (after->lma_region
1776 ? after->lma_region->name_list.name
1778 lang_leave_output_section_statement (NULL, region, after->phdrs,
1782 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1785 if (ps != NULL && *ps == '\0')
1789 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1790 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1791 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1792 lang_add_assignment (exp_assign (symname,
1793 exp_nameop (NAME, ".")));
1796 /* Restore the global list pointer. */
1800 if (after != NULL && os->bfd_section != NULL)
1802 asection *snew, *as;
1804 snew = os->bfd_section;
1806 /* Shuffle the bfd section list to make the output file look
1807 neater. This is really only cosmetic. */
1808 if (place->section == NULL
1809 && after != (&lang_output_section_statement.head
1810 ->output_section_statement))
1812 asection *bfd_section = after->bfd_section;
1814 /* If the output statement hasn't been used to place any input
1815 sections (and thus doesn't have an output bfd_section),
1816 look for the closest prior output statement having an
1818 if (bfd_section == NULL)
1819 bfd_section = output_prev_sec_find (after);
1821 if (bfd_section != NULL && bfd_section != snew)
1822 place->section = &bfd_section->next;
1825 if (place->section == NULL)
1826 place->section = &link_info.output_bfd->sections;
1828 as = *place->section;
1832 /* Put the section at the end of the list. */
1834 /* Unlink the section. */
1835 bfd_section_list_remove (link_info.output_bfd, snew);
1837 /* Now tack it back on in the right place. */
1838 bfd_section_list_append (link_info.output_bfd, snew);
1840 else if (as != snew && as->prev != snew)
1842 /* Unlink the section. */
1843 bfd_section_list_remove (link_info.output_bfd, snew);
1845 /* Now tack it back on in the right place. */
1846 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1849 /* Save the end of this list. Further ophans of this type will
1850 follow the one we've just added. */
1851 place->section = &snew->next;
1853 /* The following is non-cosmetic. We try to put the output
1854 statements in some sort of reasonable order here, because they
1855 determine the final load addresses of the orphan sections.
1856 In addition, placing output statements in the wrong order may
1857 require extra segments. For instance, given a typical
1858 situation of all read-only sections placed in one segment and
1859 following that a segment containing all the read-write
1860 sections, we wouldn't want to place an orphan read/write
1861 section before or amongst the read-only ones. */
1862 if (add.head != NULL)
1864 lang_output_section_statement_type *newly_added_os;
1866 if (place->stmt == NULL)
1868 lang_statement_union_type **where = insert_os_after (after);
1873 place->os_tail = &after->next;
1877 /* Put it after the last orphan statement we added. */
1878 *add.tail = *place->stmt;
1879 *place->stmt = add.head;
1882 /* Fix the global list pointer if we happened to tack our
1883 new list at the tail. */
1884 if (*stat_ptr->tail == add.head)
1885 stat_ptr->tail = add.tail;
1887 /* Save the end of this list. */
1888 place->stmt = add.tail;
1890 /* Do the same for the list of output section statements. */
1891 newly_added_os = *os_tail;
1893 newly_added_os->prev = (lang_output_section_statement_type *)
1894 ((char *) place->os_tail
1895 - offsetof (lang_output_section_statement_type, next));
1896 newly_added_os->next = *place->os_tail;
1897 if (newly_added_os->next != NULL)
1898 newly_added_os->next->prev = newly_added_os;
1899 *place->os_tail = newly_added_os;
1900 place->os_tail = &newly_added_os->next;
1902 /* Fixing the global list pointer here is a little different.
1903 We added to the list in lang_enter_output_section_statement,
1904 trimmed off the new output_section_statment above when
1905 assigning *os_tail = NULL, but possibly added it back in
1906 the same place when assigning *place->os_tail. */
1907 if (*os_tail == NULL)
1908 lang_output_section_statement.tail
1909 = (lang_statement_union_type **) os_tail;
1916 lang_map_flags (flagword flag)
1918 if (flag & SEC_ALLOC)
1921 if (flag & SEC_CODE)
1924 if (flag & SEC_READONLY)
1927 if (flag & SEC_DATA)
1930 if (flag & SEC_LOAD)
1937 lang_memory_region_type *m;
1938 bfd_boolean dis_header_printed = FALSE;
1941 LANG_FOR_EACH_INPUT_STATEMENT (file)
1945 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1946 || file->just_syms_flag)
1949 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1950 if ((s->output_section == NULL
1951 || s->output_section->owner != link_info.output_bfd)
1952 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1954 if (! dis_header_printed)
1956 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1957 dis_header_printed = TRUE;
1960 print_input_section (s, TRUE);
1964 minfo (_("\nMemory Configuration\n\n"));
1965 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1966 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1968 for (m = lang_memory_region_list; m != NULL; m = m->next)
1973 fprintf (config.map_file, "%-16s ", m->name_list.name);
1975 sprintf_vma (buf, m->origin);
1976 minfo ("0x%s ", buf);
1984 minfo ("0x%V", m->length);
1985 if (m->flags || m->not_flags)
1993 lang_map_flags (m->flags);
1999 lang_map_flags (m->not_flags);
2006 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2008 if (! link_info.reduce_memory_overheads)
2010 obstack_begin (&map_obstack, 1000);
2011 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2012 bfd_map_over_sections (p, init_map_userdata, 0);
2013 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2015 lang_statement_iteration ++;
2016 print_statements ();
2020 init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2022 void *data ATTRIBUTE_UNUSED)
2024 fat_section_userdata_type *new_data
2025 = ((fat_section_userdata_type *) (stat_alloc
2026 (sizeof (fat_section_userdata_type))));
2028 ASSERT (get_userdata (sec) == NULL);
2029 get_userdata (sec) = new_data;
2030 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2031 new_data->map_symbol_def_count = 0;
2035 sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2036 void *info ATTRIBUTE_UNUSED)
2038 if (hash_entry->type == bfd_link_hash_warning)
2039 hash_entry = (struct bfd_link_hash_entry *) hash_entry->u.i.link;
2041 if (hash_entry->type == bfd_link_hash_defined
2042 || hash_entry->type == bfd_link_hash_defweak)
2044 struct fat_user_section_struct *ud;
2045 struct map_symbol_def *def;
2047 ud = (struct fat_user_section_struct *)
2048 get_userdata (hash_entry->u.def.section);
2051 /* ??? What do we have to do to initialize this beforehand? */
2052 /* The first time we get here is bfd_abs_section... */
2053 init_map_userdata (0, hash_entry->u.def.section, 0);
2054 ud = (struct fat_user_section_struct *)
2055 get_userdata (hash_entry->u.def.section);
2057 else if (!ud->map_symbol_def_tail)
2058 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2060 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2061 def->entry = hash_entry;
2062 *(ud->map_symbol_def_tail) = def;
2063 ud->map_symbol_def_tail = &def->next;
2064 ud->map_symbol_def_count++;
2069 /* Initialize an output section. */
2072 init_os (lang_output_section_statement_type *s, flagword flags)
2074 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2075 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2077 if (s->constraint != SPECIAL)
2078 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2079 if (s->bfd_section == NULL)
2080 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2082 if (s->bfd_section == NULL)
2084 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2085 link_info.output_bfd->xvec->name, s->name);
2087 s->bfd_section->output_section = s->bfd_section;
2088 s->bfd_section->output_offset = 0;
2090 if (!link_info.reduce_memory_overheads)
2092 fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2093 stat_alloc (sizeof (fat_section_userdata_type));
2094 memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2095 get_userdata (s->bfd_section) = new_userdata;
2098 /* If there is a base address, make sure that any sections it might
2099 mention are initialized. */
2100 if (s->addr_tree != NULL)
2101 exp_init_os (s->addr_tree);
2103 if (s->load_base != NULL)
2104 exp_init_os (s->load_base);
2106 /* If supplied an alignment, set it. */
2107 if (s->section_alignment != -1)
2108 s->bfd_section->alignment_power = s->section_alignment;
2111 /* Make sure that all output sections mentioned in an expression are
2115 exp_init_os (etree_type *exp)
2117 switch (exp->type.node_class)
2121 exp_init_os (exp->assign.src);
2125 exp_init_os (exp->binary.lhs);
2126 exp_init_os (exp->binary.rhs);
2130 exp_init_os (exp->trinary.cond);
2131 exp_init_os (exp->trinary.lhs);
2132 exp_init_os (exp->trinary.rhs);
2136 exp_init_os (exp->assert_s.child);
2140 exp_init_os (exp->unary.child);
2144 switch (exp->type.node_code)
2150 lang_output_section_statement_type *os;
2152 os = lang_output_section_find (exp->name.name);
2153 if (os != NULL && os->bfd_section == NULL)
2165 section_already_linked (bfd *abfd, asection *sec, void *data)
2167 lang_input_statement_type *entry = (lang_input_statement_type *) data;
2169 /* If we are only reading symbols from this object, then we want to
2170 discard all sections. */
2171 if (entry->just_syms_flag)
2173 bfd_link_just_syms (abfd, sec, &link_info);
2177 if (!(abfd->flags & DYNAMIC))
2178 bfd_section_already_linked (abfd, sec, &link_info);
2181 /* The wild routines.
2183 These expand statements like *(.text) and foo.o to a list of
2184 explicit actions, like foo.o(.text), bar.o(.text) and
2185 foo.o(.text, .data). */
2187 /* Add SECTION to the output section OUTPUT. Do this by creating a
2188 lang_input_section statement which is placed at PTR. FILE is the
2189 input file which holds SECTION. */
2192 lang_add_section (lang_statement_list_type *ptr,
2194 lang_output_section_statement_type *output)
2196 flagword flags = section->flags;
2197 bfd_boolean discard;
2198 lang_input_section_type *new_section;
2200 /* Discard sections marked with SEC_EXCLUDE. */
2201 discard = (flags & SEC_EXCLUDE) != 0;
2203 /* Discard input sections which are assigned to a section named
2204 DISCARD_SECTION_NAME. */
2205 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2208 /* Discard debugging sections if we are stripping debugging
2210 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2211 && (flags & SEC_DEBUGGING) != 0)
2216 if (section->output_section == NULL)
2218 /* This prevents future calls from assigning this section. */
2219 section->output_section = bfd_abs_section_ptr;
2224 if (section->output_section != NULL)
2227 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2228 to an output section, because we want to be able to include a
2229 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2230 section (I don't know why we want to do this, but we do).
2231 build_link_order in ldwrite.c handles this case by turning
2232 the embedded SEC_NEVER_LOAD section into a fill. */
2233 flags &= ~ SEC_NEVER_LOAD;
2235 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2236 already been processed. One reason to do this is that on pe
2237 format targets, .text$foo sections go into .text and it's odd
2238 to see .text with SEC_LINK_ONCE set. */
2240 if (!link_info.relocatable)
2241 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2243 switch (output->sectype)
2245 case normal_section:
2246 case overlay_section:
2248 case noalloc_section:
2249 flags &= ~SEC_ALLOC;
2251 case noload_section:
2253 flags |= SEC_NEVER_LOAD;
2254 /* Unfortunately GNU ld has managed to evolve two different
2255 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2256 alloc, no contents section. All others get a noload, noalloc
2258 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2259 flags &= ~SEC_HAS_CONTENTS;
2261 flags &= ~SEC_ALLOC;
2265 if (output->bfd_section == NULL)
2266 init_os (output, flags);
2268 /* If SEC_READONLY is not set in the input section, then clear
2269 it from the output section. */
2270 output->bfd_section->flags &= flags | ~SEC_READONLY;
2272 if (output->bfd_section->linker_has_input)
2274 /* Only set SEC_READONLY flag on the first input section. */
2275 flags &= ~ SEC_READONLY;
2277 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2278 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2279 != (flags & (SEC_MERGE | SEC_STRINGS))
2280 || ((flags & SEC_MERGE) != 0
2281 && output->bfd_section->entsize != section->entsize))
2283 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2284 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2287 output->bfd_section->flags |= flags;
2289 if (!output->bfd_section->linker_has_input)
2291 output->bfd_section->linker_has_input = 1;
2292 /* This must happen after flags have been updated. The output
2293 section may have been created before we saw its first input
2294 section, eg. for a data statement. */
2295 bfd_init_private_section_data (section->owner, section,
2296 link_info.output_bfd,
2297 output->bfd_section,
2299 if ((flags & SEC_MERGE) != 0)
2300 output->bfd_section->entsize = section->entsize;
2303 if ((flags & SEC_TIC54X_BLOCK) != 0
2304 && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2306 /* FIXME: This value should really be obtained from the bfd... */
2307 output->block_value = 128;
2310 if (section->alignment_power > output->bfd_section->alignment_power)
2311 output->bfd_section->alignment_power = section->alignment_power;
2313 section->output_section = output->bfd_section;
2315 if (!link_info.relocatable
2316 && !stripped_excluded_sections)
2318 asection *s = output->bfd_section->map_tail.s;
2319 output->bfd_section->map_tail.s = section;
2320 section->map_head.s = NULL;
2321 section->map_tail.s = s;
2323 s->map_head.s = section;
2325 output->bfd_section->map_head.s = section;
2328 /* Add a section reference to the list. */
2329 new_section = new_stat (lang_input_section, ptr);
2330 new_section->section = section;
2333 /* Handle wildcard sorting. This returns the lang_input_section which
2334 should follow the one we are going to create for SECTION and FILE,
2335 based on the sorting requirements of WILD. It returns NULL if the
2336 new section should just go at the end of the current list. */
2338 static lang_statement_union_type *
2339 wild_sort (lang_wild_statement_type *wild,
2340 struct wildcard_list *sec,
2341 lang_input_statement_type *file,
2344 lang_statement_union_type *l;
2346 if (!wild->filenames_sorted
2347 && (sec == NULL || sec->spec.sorted == none))
2350 for (l = wild->children.head; l != NULL; l = l->header.next)
2352 lang_input_section_type *ls;
2354 if (l->header.type != lang_input_section_enum)
2356 ls = &l->input_section;
2358 /* Sorting by filename takes precedence over sorting by section
2361 if (wild->filenames_sorted)
2363 const char *fn, *ln;
2367 /* The PE support for the .idata section as generated by
2368 dlltool assumes that files will be sorted by the name of
2369 the archive and then the name of the file within the
2372 if (file->the_bfd != NULL
2373 && bfd_my_archive (file->the_bfd) != NULL)
2375 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2380 fn = file->filename;
2384 if (bfd_my_archive (ls->section->owner) != NULL)
2386 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2391 ln = ls->section->owner->filename;
2395 i = strcmp (fn, ln);
2404 fn = file->filename;
2406 ln = ls->section->owner->filename;
2408 i = strcmp (fn, ln);
2416 /* Here either the files are not sorted by name, or we are
2417 looking at the sections for this file. */
2419 if (sec != NULL && sec->spec.sorted != none)
2420 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2427 /* Expand a wild statement for a particular FILE. SECTION may be
2428 NULL, in which case it is a wild card. */
2431 output_section_callback (lang_wild_statement_type *ptr,
2432 struct wildcard_list *sec,
2434 lang_input_statement_type *file,
2437 lang_statement_union_type *before;
2438 lang_output_section_statement_type *os;
2440 os = (lang_output_section_statement_type *) output;
2442 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2443 if (unique_section_p (section, os))
2446 before = wild_sort (ptr, sec, file, section);
2448 /* Here BEFORE points to the lang_input_section which
2449 should follow the one we are about to add. If BEFORE
2450 is NULL, then the section should just go at the end
2451 of the current list. */
2454 lang_add_section (&ptr->children, section, os);
2457 lang_statement_list_type list;
2458 lang_statement_union_type **pp;
2460 lang_list_init (&list);
2461 lang_add_section (&list, section, os);
2463 /* If we are discarding the section, LIST.HEAD will
2465 if (list.head != NULL)
2467 ASSERT (list.head->header.next == NULL);
2469 for (pp = &ptr->children.head;
2471 pp = &(*pp)->header.next)
2472 ASSERT (*pp != NULL);
2474 list.head->header.next = *pp;
2480 /* Check if all sections in a wild statement for a particular FILE
2484 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2485 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2487 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2490 lang_output_section_statement_type *os;
2492 os = (lang_output_section_statement_type *) output;
2494 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2495 if (unique_section_p (section, os))
2498 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2499 os->all_input_readonly = FALSE;
2502 /* This is passed a file name which must have been seen already and
2503 added to the statement tree. We will see if it has been opened
2504 already and had its symbols read. If not then we'll read it. */
2506 static lang_input_statement_type *
2507 lookup_name (const char *name)
2509 lang_input_statement_type *search;
2511 for (search = (lang_input_statement_type *) input_file_chain.head;
2513 search = (lang_input_statement_type *) search->next_real_file)
2515 /* Use the local_sym_name as the name of the file that has
2516 already been loaded as filename might have been transformed
2517 via the search directory lookup mechanism. */
2518 const char *filename = search->local_sym_name;
2520 if (filename != NULL
2521 && strcmp (filename, name) == 0)
2526 search = new_afile (name, lang_input_file_is_search_file_enum,
2527 default_target, FALSE);
2529 /* If we have already added this file, or this file is not real
2530 don't add this file. */
2531 if (search->loaded || !search->real)
2534 if (! load_symbols (search, NULL))
2540 /* Save LIST as a list of libraries whose symbols should not be exported. */
2545 struct excluded_lib *next;
2547 static struct excluded_lib *excluded_libs;
2550 add_excluded_libs (const char *list)
2552 const char *p = list, *end;
2556 struct excluded_lib *entry;
2557 end = strpbrk (p, ",:");
2559 end = p + strlen (p);
2560 entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2561 entry->next = excluded_libs;
2562 entry->name = (char *) xmalloc (end - p + 1);
2563 memcpy (entry->name, p, end - p);
2564 entry->name[end - p] = '\0';
2565 excluded_libs = entry;
2573 check_excluded_libs (bfd *abfd)
2575 struct excluded_lib *lib = excluded_libs;
2579 int len = strlen (lib->name);
2580 const char *filename = lbasename (abfd->filename);
2582 if (strcmp (lib->name, "ALL") == 0)
2584 abfd->no_export = TRUE;
2588 if (strncmp (lib->name, filename, len) == 0
2589 && (filename[len] == '\0'
2590 || (filename[len] == '.' && filename[len + 1] == 'a'
2591 && filename[len + 2] == '\0')))
2593 abfd->no_export = TRUE;
2601 /* Get the symbols for an input file. */
2604 load_symbols (lang_input_statement_type *entry,
2605 lang_statement_list_type *place)
2612 ldfile_open_file (entry);
2614 /* Do not process further if the file was missing. */
2615 if (entry->missing_file)
2618 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2619 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2622 bfd_boolean save_ldlang_sysrooted_script;
2623 bfd_boolean save_add_DT_NEEDED_for_regular;
2624 bfd_boolean save_add_DT_NEEDED_for_dynamic;
2625 bfd_boolean save_whole_archive;
2627 err = bfd_get_error ();
2629 /* See if the emulation has some special knowledge. */
2630 if (ldemul_unrecognized_file (entry))
2633 if (err == bfd_error_file_ambiguously_recognized)
2637 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2638 einfo (_("%B: matching formats:"), entry->the_bfd);
2639 for (p = matching; *p != NULL; p++)
2643 else if (err != bfd_error_file_not_recognized
2645 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2647 bfd_close (entry->the_bfd);
2648 entry->the_bfd = NULL;
2650 /* Try to interpret the file as a linker script. */
2651 ldfile_open_command_file (entry->filename);
2653 push_stat_ptr (place);
2654 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2655 ldlang_sysrooted_script = entry->sysrooted;
2656 save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2657 add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2658 save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2659 add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2660 save_whole_archive = whole_archive;
2661 whole_archive = entry->whole_archive;
2663 ldfile_assumed_script = TRUE;
2664 parser_input = input_script;
2665 /* We want to use the same -Bdynamic/-Bstatic as the one for
2667 config.dynamic_link = entry->dynamic;
2669 ldfile_assumed_script = FALSE;
2671 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2672 add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2673 add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2674 whole_archive = save_whole_archive;
2680 if (ldemul_recognized_file (entry))
2683 /* We don't call ldlang_add_file for an archive. Instead, the
2684 add_symbols entry point will call ldlang_add_file, via the
2685 add_archive_element callback, for each element of the archive
2687 switch (bfd_get_format (entry->the_bfd))
2693 ldlang_add_file (entry);
2694 if (trace_files || trace_file_tries)
2695 info_msg ("%I\n", entry);
2699 check_excluded_libs (entry->the_bfd);
2701 if (entry->whole_archive)
2704 bfd_boolean loaded = TRUE;
2709 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2714 if (! bfd_check_format (member, bfd_object))
2716 einfo (_("%F%B: member %B in archive is not an object\n"),
2717 entry->the_bfd, member);
2722 if (!(*link_info.callbacks
2723 ->add_archive_element) (&link_info, member,
2724 "--whole-archive", &subsbfd))
2727 /* Potentially, the add_archive_element hook may have set a
2728 substitute BFD for us. */
2729 if (!bfd_link_add_symbols (subsbfd, &link_info))
2731 einfo (_("%F%B: could not read symbols: %E\n"), member);
2736 entry->loaded = loaded;
2742 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2743 entry->loaded = TRUE;
2745 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2747 return entry->loaded;
2750 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2751 may be NULL, indicating that it is a wildcard. Separate
2752 lang_input_section statements are created for each part of the
2753 expansion; they are added after the wild statement S. OUTPUT is
2754 the output section. */
2757 wild (lang_wild_statement_type *s,
2758 const char *target ATTRIBUTE_UNUSED,
2759 lang_output_section_statement_type *output)
2761 struct wildcard_list *sec;
2763 if (s->handler_data[0]
2764 && s->handler_data[0]->spec.sorted == by_name
2765 && !s->filenames_sorted)
2767 lang_section_bst_type *tree;
2769 walk_wild (s, output_section_callback_fast, output);
2774 output_section_callback_tree_to_list (s, tree, output);
2779 walk_wild (s, output_section_callback, output);
2781 if (default_common_section == NULL)
2782 for (sec = s->section_list; sec != NULL; sec = sec->next)
2783 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2785 /* Remember the section that common is going to in case we
2786 later get something which doesn't know where to put it. */
2787 default_common_section = output;
2792 /* Return TRUE iff target is the sought target. */
2795 get_target (const bfd_target *target, void *data)
2797 const char *sought = (const char *) data;
2799 return strcmp (target->name, sought) == 0;
2802 /* Like strcpy() but convert to lower case as well. */
2805 stricpy (char *dest, char *src)
2809 while ((c = *src++) != 0)
2810 *dest++ = TOLOWER (c);
2815 /* Remove the first occurrence of needle (if any) in haystack
2819 strcut (char *haystack, char *needle)
2821 haystack = strstr (haystack, needle);
2827 for (src = haystack + strlen (needle); *src;)
2828 *haystack++ = *src++;
2834 /* Compare two target format name strings.
2835 Return a value indicating how "similar" they are. */
2838 name_compare (char *first, char *second)
2844 copy1 = (char *) xmalloc (strlen (first) + 1);
2845 copy2 = (char *) xmalloc (strlen (second) + 1);
2847 /* Convert the names to lower case. */
2848 stricpy (copy1, first);
2849 stricpy (copy2, second);
2851 /* Remove size and endian strings from the name. */
2852 strcut (copy1, "big");
2853 strcut (copy1, "little");
2854 strcut (copy2, "big");
2855 strcut (copy2, "little");
2857 /* Return a value based on how many characters match,
2858 starting from the beginning. If both strings are
2859 the same then return 10 * their length. */
2860 for (result = 0; copy1[result] == copy2[result]; result++)
2861 if (copy1[result] == 0)
2873 /* Set by closest_target_match() below. */
2874 static const bfd_target *winner;
2876 /* Scan all the valid bfd targets looking for one that has the endianness
2877 requirement that was specified on the command line, and is the nearest
2878 match to the original output target. */
2881 closest_target_match (const bfd_target *target, void *data)
2883 const bfd_target *original = (const bfd_target *) data;
2885 if (command_line.endian == ENDIAN_BIG
2886 && target->byteorder != BFD_ENDIAN_BIG)
2889 if (command_line.endian == ENDIAN_LITTLE
2890 && target->byteorder != BFD_ENDIAN_LITTLE)
2893 /* Must be the same flavour. */
2894 if (target->flavour != original->flavour)
2897 /* Ignore generic big and little endian elf vectors. */
2898 if (strcmp (target->name, "elf32-big") == 0
2899 || strcmp (target->name, "elf64-big") == 0
2900 || strcmp (target->name, "elf32-little") == 0
2901 || strcmp (target->name, "elf64-little") == 0)
2904 /* If we have not found a potential winner yet, then record this one. */
2911 /* Oh dear, we now have two potential candidates for a successful match.
2912 Compare their names and choose the better one. */
2913 if (name_compare (target->name, original->name)
2914 > name_compare (winner->name, original->name))
2917 /* Keep on searching until wqe have checked them all. */
2921 /* Return the BFD target format of the first input file. */
2924 get_first_input_target (void)
2926 char *target = NULL;
2928 LANG_FOR_EACH_INPUT_STATEMENT (s)
2930 if (s->header.type == lang_input_statement_enum
2933 ldfile_open_file (s);
2935 if (s->the_bfd != NULL
2936 && bfd_check_format (s->the_bfd, bfd_object))
2938 target = bfd_get_target (s->the_bfd);
2950 lang_get_output_target (void)
2954 /* Has the user told us which output format to use? */
2955 if (output_target != NULL)
2956 return output_target;
2958 /* No - has the current target been set to something other than
2960 if (current_target != default_target)
2961 return current_target;
2963 /* No - can we determine the format of the first input file? */
2964 target = get_first_input_target ();
2968 /* Failed - use the default output target. */
2969 return default_target;
2972 /* Open the output file. */
2975 open_output (const char *name)
2977 output_target = lang_get_output_target ();
2979 /* Has the user requested a particular endianness on the command
2981 if (command_line.endian != ENDIAN_UNSET)
2983 const bfd_target *target;
2984 enum bfd_endian desired_endian;
2986 /* Get the chosen target. */
2987 target = bfd_search_for_target (get_target, (void *) output_target);
2989 /* If the target is not supported, we cannot do anything. */
2992 if (command_line.endian == ENDIAN_BIG)
2993 desired_endian = BFD_ENDIAN_BIG;
2995 desired_endian = BFD_ENDIAN_LITTLE;
2997 /* See if the target has the wrong endianness. This should
2998 not happen if the linker script has provided big and
2999 little endian alternatives, but some scrips don't do
3001 if (target->byteorder != desired_endian)
3003 /* If it does, then see if the target provides
3004 an alternative with the correct endianness. */
3005 if (target->alternative_target != NULL
3006 && (target->alternative_target->byteorder == desired_endian))
3007 output_target = target->alternative_target->name;
3010 /* Try to find a target as similar as possible to
3011 the default target, but which has the desired
3012 endian characteristic. */
3013 bfd_search_for_target (closest_target_match,
3016 /* Oh dear - we could not find any targets that
3017 satisfy our requirements. */
3019 einfo (_("%P: warning: could not find any targets"
3020 " that match endianness requirement\n"));
3022 output_target = winner->name;
3028 link_info.output_bfd = bfd_openw (name, output_target);
3030 if (link_info.output_bfd == NULL)
3032 if (bfd_get_error () == bfd_error_invalid_target)
3033 einfo (_("%P%F: target %s not found\n"), output_target);
3035 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3038 delete_output_file_on_failure = TRUE;
3040 if (! bfd_set_format (link_info.output_bfd, bfd_object))
3041 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3042 if (! bfd_set_arch_mach (link_info.output_bfd,
3043 ldfile_output_architecture,
3044 ldfile_output_machine))
3045 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3047 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3048 if (link_info.hash == NULL)
3049 einfo (_("%P%F: can not create hash table: %E\n"));
3051 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3055 ldlang_open_output (lang_statement_union_type *statement)
3057 switch (statement->header.type)
3059 case lang_output_statement_enum:
3060 ASSERT (link_info.output_bfd == NULL);
3061 open_output (statement->output_statement.name);
3062 ldemul_set_output_arch ();
3063 if (config.magic_demand_paged && !link_info.relocatable)
3064 link_info.output_bfd->flags |= D_PAGED;
3066 link_info.output_bfd->flags &= ~D_PAGED;
3067 if (config.text_read_only)
3068 link_info.output_bfd->flags |= WP_TEXT;
3070 link_info.output_bfd->flags &= ~WP_TEXT;
3071 if (link_info.traditional_format)
3072 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3074 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3077 case lang_target_statement_enum:
3078 current_target = statement->target_statement.target;
3085 /* Convert between addresses in bytes and sizes in octets.
3086 For currently supported targets, octets_per_byte is always a power
3087 of two, so we can use shifts. */
3088 #define TO_ADDR(X) ((X) >> opb_shift)
3089 #define TO_SIZE(X) ((X) << opb_shift)
3091 /* Support the above. */
3092 static unsigned int opb_shift = 0;
3097 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3098 ldfile_output_machine);
3101 while ((x & 1) == 0)
3109 /* Open all the input files. */
3112 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
3114 for (; s != NULL; s = s->header.next)
3116 switch (s->header.type)
3118 case lang_constructors_statement_enum:
3119 open_input_bfds (constructor_list.head, force);
3121 case lang_output_section_statement_enum:
3122 open_input_bfds (s->output_section_statement.children.head, force);
3124 case lang_wild_statement_enum:
3125 /* Maybe we should load the file's symbols. */
3126 if (s->wild_statement.filename
3127 && !wildcardp (s->wild_statement.filename)
3128 && !archive_path (s->wild_statement.filename))
3129 lookup_name (s->wild_statement.filename);
3130 open_input_bfds (s->wild_statement.children.head, force);
3132 case lang_group_statement_enum:
3134 struct bfd_link_hash_entry *undefs;
3136 /* We must continually search the entries in the group
3137 until no new symbols are added to the list of undefined
3142 undefs = link_info.hash->undefs_tail;
3143 open_input_bfds (s->group_statement.children.head, TRUE);
3145 while (undefs != link_info.hash->undefs_tail);
3148 case lang_target_statement_enum:
3149 current_target = s->target_statement.target;
3151 case lang_input_statement_enum:
3152 if (s->input_statement.real)
3154 lang_statement_union_type **os_tail;
3155 lang_statement_list_type add;
3157 s->input_statement.target = current_target;
3159 /* If we are being called from within a group, and this
3160 is an archive which has already been searched, then
3161 force it to be researched unless the whole archive
3162 has been loaded already. */
3164 && !s->input_statement.whole_archive
3165 && s->input_statement.loaded
3166 && bfd_check_format (s->input_statement.the_bfd,
3168 s->input_statement.loaded = FALSE;
3170 os_tail = lang_output_section_statement.tail;
3171 lang_list_init (&add);
3173 if (! load_symbols (&s->input_statement, &add))
3174 config.make_executable = FALSE;
3176 if (add.head != NULL)
3178 /* If this was a script with output sections then
3179 tack any added statements on to the end of the
3180 list. This avoids having to reorder the output
3181 section statement list. Very likely the user
3182 forgot -T, and whatever we do here will not meet
3183 naive user expectations. */
3184 if (os_tail != lang_output_section_statement.tail)
3186 einfo (_("%P: warning: %s contains output sections;"
3187 " did you forget -T?\n"),
3188 s->input_statement.filename);
3189 *stat_ptr->tail = add.head;
3190 stat_ptr->tail = add.tail;
3194 *add.tail = s->header.next;
3195 s->header.next = add.head;
3200 case lang_assignment_statement_enum:
3201 if (s->assignment_statement.exp->assign.hidden)
3202 /* This is from a --defsym on the command line. */
3203 exp_fold_tree_no_dot (s->assignment_statement.exp);
3210 /* Exit if any of the files were missing. */
3215 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3218 lang_track_definedness (const char *name)
3220 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3221 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3224 /* New-function for the definedness hash table. */
3226 static struct bfd_hash_entry *
3227 lang_definedness_newfunc (struct bfd_hash_entry *entry,
3228 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3229 const char *name ATTRIBUTE_UNUSED)
3231 struct lang_definedness_hash_entry *ret
3232 = (struct lang_definedness_hash_entry *) entry;
3235 ret = (struct lang_definedness_hash_entry *)
3236 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3239 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3241 ret->iteration = -1;
3245 /* Return the iteration when the definition of NAME was last updated. A
3246 value of -1 means that the symbol is not defined in the linker script
3247 or the command line, but may be defined in the linker symbol table. */
3250 lang_symbol_definition_iteration (const char *name)
3252 struct lang_definedness_hash_entry *defentry
3253 = (struct lang_definedness_hash_entry *)
3254 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3256 /* We've already created this one on the presence of DEFINED in the
3257 script, so it can't be NULL unless something is borked elsewhere in
3259 if (defentry == NULL)
3262 return defentry->iteration;
3265 /* Update the definedness state of NAME. */
3268 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3270 struct lang_definedness_hash_entry *defentry
3271 = (struct lang_definedness_hash_entry *)
3272 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3274 /* We don't keep track of symbols not tested with DEFINED. */
3275 if (defentry == NULL)
3278 /* If the symbol was already defined, and not from an earlier statement
3279 iteration, don't update the definedness iteration, because that'd
3280 make the symbol seem defined in the linker script at this point, and
3281 it wasn't; it was defined in some object. If we do anyway, DEFINED
3282 would start to yield false before this point and the construct "sym =
3283 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3285 if (h->type != bfd_link_hash_undefined
3286 && h->type != bfd_link_hash_common
3287 && h->type != bfd_link_hash_new
3288 && defentry->iteration == -1)
3291 defentry->iteration = lang_statement_iteration;
3294 /* Add the supplied name to the symbol table as an undefined reference.
3295 This is a two step process as the symbol table doesn't even exist at
3296 the time the ld command line is processed. First we put the name
3297 on a list, then, once the output file has been opened, transfer the
3298 name to the symbol table. */
3300 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3302 #define ldlang_undef_chain_list_head entry_symbol.next
3305 ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3307 ldlang_undef_chain_list_type *new_undef;
3309 undef_from_cmdline = undef_from_cmdline || cmdline;
3310 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3311 new_undef->next = ldlang_undef_chain_list_head;
3312 ldlang_undef_chain_list_head = new_undef;
3314 new_undef->name = xstrdup (name);
3316 if (link_info.output_bfd != NULL)
3317 insert_undefined (new_undef->name);
3320 /* Insert NAME as undefined in the symbol table. */
3323 insert_undefined (const char *name)
3325 struct bfd_link_hash_entry *h;
3327 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3329 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3330 if (h->type == bfd_link_hash_new)
3332 h->type = bfd_link_hash_undefined;
3333 h->u.undef.abfd = NULL;
3334 bfd_link_add_undef (link_info.hash, h);
3338 /* Run through the list of undefineds created above and place them
3339 into the linker hash table as undefined symbols belonging to the
3343 lang_place_undefineds (void)
3345 ldlang_undef_chain_list_type *ptr;
3347 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3348 insert_undefined (ptr->name);
3351 /* Check for all readonly or some readwrite sections. */
3354 check_input_sections
3355 (lang_statement_union_type *s,
3356 lang_output_section_statement_type *output_section_statement)
3358 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3360 switch (s->header.type)
3362 case lang_wild_statement_enum:
3363 walk_wild (&s->wild_statement, check_section_callback,
3364 output_section_statement);
3365 if (! output_section_statement->all_input_readonly)
3368 case lang_constructors_statement_enum:
3369 check_input_sections (constructor_list.head,
3370 output_section_statement);
3371 if (! output_section_statement->all_input_readonly)
3374 case lang_group_statement_enum:
3375 check_input_sections (s->group_statement.children.head,
3376 output_section_statement);
3377 if (! output_section_statement->all_input_readonly)
3386 /* Update wildcard statements if needed. */
3389 update_wild_statements (lang_statement_union_type *s)
3391 struct wildcard_list *sec;
3393 switch (sort_section)
3403 for (; s != NULL; s = s->header.next)
3405 switch (s->header.type)
3410 case lang_wild_statement_enum:
3411 sec = s->wild_statement.section_list;
3412 for (sec = s->wild_statement.section_list; sec != NULL;
3415 switch (sec->spec.sorted)
3418 sec->spec.sorted = sort_section;
3421 if (sort_section == by_alignment)
3422 sec->spec.sorted = by_name_alignment;
3425 if (sort_section == by_name)
3426 sec->spec.sorted = by_alignment_name;
3434 case lang_constructors_statement_enum:
3435 update_wild_statements (constructor_list.head);
3438 case lang_output_section_statement_enum:
3439 update_wild_statements
3440 (s->output_section_statement.children.head);
3443 case lang_group_statement_enum:
3444 update_wild_statements (s->group_statement.children.head);
3452 /* Open input files and attach to output sections. */
3455 map_input_to_output_sections
3456 (lang_statement_union_type *s, const char *target,
3457 lang_output_section_statement_type *os)
3459 for (; s != NULL; s = s->header.next)
3461 lang_output_section_statement_type *tos;
3464 switch (s->header.type)
3466 case lang_wild_statement_enum:
3467 wild (&s->wild_statement, target, os);
3469 case lang_constructors_statement_enum:
3470 map_input_to_output_sections (constructor_list.head,
3474 case lang_output_section_statement_enum:
3475 tos = &s->output_section_statement;
3476 if (tos->constraint != 0)
3478 if (tos->constraint != ONLY_IF_RW
3479 && tos->constraint != ONLY_IF_RO)
3481 tos->all_input_readonly = TRUE;
3482 check_input_sections (tos->children.head, tos);
3483 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3485 tos->constraint = -1;
3489 map_input_to_output_sections (tos->children.head,
3493 case lang_output_statement_enum:
3495 case lang_target_statement_enum:
3496 target = s->target_statement.target;
3498 case lang_group_statement_enum:
3499 map_input_to_output_sections (s->group_statement.children.head,
3503 case lang_data_statement_enum:
3504 /* Make sure that any sections mentioned in the expression
3506 exp_init_os (s->data_statement.exp);
3507 /* The output section gets CONTENTS, ALLOC and LOAD, but
3508 these may be overridden by the script. */
3509 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3510 switch (os->sectype)
3512 case normal_section:
3513 case overlay_section:
3515 case noalloc_section:
3516 flags = SEC_HAS_CONTENTS;
3518 case noload_section:
3519 if (bfd_get_flavour (link_info.output_bfd)
3520 == bfd_target_elf_flavour)
3521 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3523 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3526 if (os->bfd_section == NULL)
3527 init_os (os, flags);
3529 os->bfd_section->flags |= flags;
3531 case lang_input_section_enum:
3533 case lang_fill_statement_enum:
3534 case lang_object_symbols_statement_enum:
3535 case lang_reloc_statement_enum:
3536 case lang_padding_statement_enum:
3537 case lang_input_statement_enum:
3538 if (os != NULL && os->bfd_section == NULL)
3541 case lang_assignment_statement_enum:
3542 if (os != NULL && os->bfd_section == NULL)
3545 /* Make sure that any sections mentioned in the assignment
3547 exp_init_os (s->assignment_statement.exp);
3549 case lang_address_statement_enum:
3550 /* Mark the specified section with the supplied address.
3551 If this section was actually a segment marker, then the
3552 directive is ignored if the linker script explicitly
3553 processed the segment marker. Originally, the linker
3554 treated segment directives (like -Ttext on the
3555 command-line) as section directives. We honor the
3556 section directive semantics for backwards compatibilty;
3557 linker scripts that do not specifically check for
3558 SEGMENT_START automatically get the old semantics. */
3559 if (!s->address_statement.segment
3560 || !s->address_statement.segment->used)
3562 const char *name = s->address_statement.section_name;
3564 /* Create the output section statement here so that
3565 orphans with a set address will be placed after other
3566 script sections. If we let the orphan placement code
3567 place them in amongst other sections then the address
3568 will affect following script sections, which is
3569 likely to surprise naive users. */
3570 tos = lang_output_section_statement_lookup (name, 0, TRUE);
3571 tos->addr_tree = s->address_statement.address;
3572 if (tos->bfd_section == NULL)
3576 case lang_insert_statement_enum:
3582 /* An insert statement snips out all the linker statements from the
3583 start of the list and places them after the output section
3584 statement specified by the insert. This operation is complicated
3585 by the fact that we keep a doubly linked list of output section
3586 statements as well as the singly linked list of all statements. */
3589 process_insert_statements (void)
3591 lang_statement_union_type **s;
3592 lang_output_section_statement_type *first_os = NULL;
3593 lang_output_section_statement_type *last_os = NULL;
3594 lang_output_section_statement_type *os;
3596 /* "start of list" is actually the statement immediately after
3597 the special abs_section output statement, so that it isn't
3599 s = &lang_output_section_statement.head;
3600 while (*(s = &(*s)->header.next) != NULL)
3602 if ((*s)->header.type == lang_output_section_statement_enum)
3604 /* Keep pointers to the first and last output section
3605 statement in the sequence we may be about to move. */
3606 os = &(*s)->output_section_statement;
3608 ASSERT (last_os == NULL || last_os->next == os);
3611 /* Set constraint negative so that lang_output_section_find
3612 won't match this output section statement. At this
3613 stage in linking constraint has values in the range
3614 [-1, ONLY_IN_RW]. */
3615 last_os->constraint = -2 - last_os->constraint;
3616 if (first_os == NULL)
3619 else if ((*s)->header.type == lang_insert_statement_enum)
3621 lang_insert_statement_type *i = &(*s)->insert_statement;
3622 lang_output_section_statement_type *where;
3623 lang_statement_union_type **ptr;
3624 lang_statement_union_type *first;
3626 where = lang_output_section_find (i->where);
3627 if (where != NULL && i->is_before)
3630 where = where->prev;
3631 while (where != NULL && where->constraint < 0);
3635 einfo (_("%F%P: %s not found for insert\n"), i->where);
3639 /* Deal with reordering the output section statement list. */
3640 if (last_os != NULL)
3642 asection *first_sec, *last_sec;
3643 struct lang_output_section_statement_struct **next;
3645 /* Snip out the output sections we are moving. */
3646 first_os->prev->next = last_os->next;
3647 if (last_os->next == NULL)
3649 next = &first_os->prev->next;
3650 lang_output_section_statement.tail
3651 = (lang_statement_union_type **) next;
3654 last_os->next->prev = first_os->prev;
3655 /* Add them in at the new position. */
3656 last_os->next = where->next;
3657 if (where->next == NULL)
3659 next = &last_os->next;
3660 lang_output_section_statement.tail
3661 = (lang_statement_union_type **) next;
3664 where->next->prev = last_os;
3665 first_os->prev = where;
3666 where->next = first_os;
3668 /* Move the bfd sections in the same way. */
3671 for (os = first_os; os != NULL; os = os->next)
3673 os->constraint = -2 - os->constraint;
3674 if (os->bfd_section != NULL
3675 && os->bfd_section->owner != NULL)
3677 last_sec = os->bfd_section;
3678 if (first_sec == NULL)
3679 first_sec = last_sec;
3684 if (last_sec != NULL)
3686 asection *sec = where->bfd_section;
3688 sec = output_prev_sec_find (where);
3690 /* The place we want to insert must come after the
3691 sections we are moving. So if we find no
3692 section or if the section is the same as our
3693 last section, then no move is needed. */
3694 if (sec != NULL && sec != last_sec)
3696 /* Trim them off. */
3697 if (first_sec->prev != NULL)
3698 first_sec->prev->next = last_sec->next;
3700 link_info.output_bfd->sections = last_sec->next;
3701 if (last_sec->next != NULL)
3702 last_sec->next->prev = first_sec->prev;
3704 link_info.output_bfd->section_last = first_sec->prev;
3706 last_sec->next = sec->next;
3707 if (sec->next != NULL)
3708 sec->next->prev = last_sec;
3710 link_info.output_bfd->section_last = last_sec;
3711 first_sec->prev = sec;
3712 sec->next = first_sec;
3720 ptr = insert_os_after (where);
3721 /* Snip everything after the abs_section output statement we
3722 know is at the start of the list, up to and including
3723 the insert statement we are currently processing. */
3724 first = lang_output_section_statement.head->header.next;
3725 lang_output_section_statement.head->header.next = (*s)->header.next;
3726 /* Add them back where they belong. */
3729 statement_list.tail = s;
3731 s = &lang_output_section_statement.head;
3735 /* Undo constraint twiddling. */
3736 for (os = first_os; os != NULL; os = os->next)
3738 os->constraint = -2 - os->constraint;
3744 /* An output section might have been removed after its statement was
3745 added. For example, ldemul_before_allocation can remove dynamic
3746 sections if they turn out to be not needed. Clean them up here. */
3749 strip_excluded_output_sections (void)
3751 lang_output_section_statement_type *os;
3753 /* Run lang_size_sections (if not already done). */
3754 if (expld.phase != lang_mark_phase_enum)
3756 expld.phase = lang_mark_phase_enum;
3757 expld.dataseg.phase = exp_dataseg_none;
3758 one_lang_size_sections_pass (NULL, FALSE);
3759 lang_reset_memory_regions ();
3762 for (os = &lang_output_section_statement.head->output_section_statement;
3766 asection *output_section;
3767 bfd_boolean exclude;
3769 if (os->constraint < 0)
3772 output_section = os->bfd_section;
3773 if (output_section == NULL)
3776 exclude = (output_section->rawsize == 0
3777 && (output_section->flags & SEC_KEEP) == 0
3778 && !bfd_section_removed_from_list (link_info.output_bfd,
3781 /* Some sections have not yet been sized, notably .gnu.version,
3782 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3783 input sections, so don't drop output sections that have such
3784 input sections unless they are also marked SEC_EXCLUDE. */
3785 if (exclude && output_section->map_head.s != NULL)
3789 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3790 if ((s->flags & SEC_LINKER_CREATED) != 0
3791 && (s->flags & SEC_EXCLUDE) == 0)
3798 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3799 output_section->map_head.link_order = NULL;
3800 output_section->map_tail.link_order = NULL;
3804 /* We don't set bfd_section to NULL since bfd_section of the
3805 removed output section statement may still be used. */
3806 if (!os->section_relative_symbol
3807 && !os->update_dot_tree)
3809 output_section->flags |= SEC_EXCLUDE;
3810 bfd_section_list_remove (link_info.output_bfd, output_section);
3811 link_info.output_bfd->section_count--;
3815 /* Stop future calls to lang_add_section from messing with map_head
3816 and map_tail link_order fields. */
3817 stripped_excluded_sections = TRUE;
3821 print_output_section_statement
3822 (lang_output_section_statement_type *output_section_statement)
3824 asection *section = output_section_statement->bfd_section;
3827 if (output_section_statement != abs_output_section)
3829 minfo ("\n%s", output_section_statement->name);
3831 if (section != NULL)
3833 print_dot = section->vma;
3835 len = strlen (output_section_statement->name);
3836 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3841 while (len < SECTION_NAME_MAP_LENGTH)
3847 minfo ("0x%V %W", section->vma, section->size);
3849 if (section->vma != section->lma)
3850 minfo (_(" load address 0x%V"), section->lma);
3852 if (output_section_statement->update_dot_tree != NULL)
3853 exp_fold_tree (output_section_statement->update_dot_tree,
3854 bfd_abs_section_ptr, &print_dot);
3860 print_statement_list (output_section_statement->children.head,
3861 output_section_statement);
3864 /* Scan for the use of the destination in the right hand side
3865 of an expression. In such cases we will not compute the
3866 correct expression, since the value of DST that is used on
3867 the right hand side will be its final value, not its value
3868 just before this expression is evaluated. */
3871 scan_for_self_assignment (const char * dst, etree_type * rhs)
3873 if (rhs == NULL || dst == NULL)
3876 switch (rhs->type.node_class)
3879 return (scan_for_self_assignment (dst, rhs->binary.lhs)
3880 || scan_for_self_assignment (dst, rhs->binary.rhs));
3883 return (scan_for_self_assignment (dst, rhs->trinary.lhs)
3884 || scan_for_self_assignment (dst, rhs->trinary.rhs));
3887 case etree_provided:
3889 if (strcmp (dst, rhs->assign.dst) == 0)
3891 return scan_for_self_assignment (dst, rhs->assign.src);
3894 return scan_for_self_assignment (dst, rhs->unary.child);
3898 return strcmp (dst, rhs->value.str) == 0;
3903 return strcmp (dst, rhs->name.name) == 0;
3915 print_assignment (lang_assignment_statement_type *assignment,
3916 lang_output_section_statement_type *output_section)
3920 bfd_boolean computation_is_valid = TRUE;
3924 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3927 if (assignment->exp->type.node_class == etree_assert)
3930 tree = assignment->exp->assert_s.child;
3931 computation_is_valid = TRUE;
3935 const char *dst = assignment->exp->assign.dst;
3937 is_dot = (dst[0] == '.' && dst[1] == 0);
3938 tree = assignment->exp->assign.src;
3939 computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
3942 osec = output_section->bfd_section;
3944 osec = bfd_abs_section_ptr;
3945 exp_fold_tree (tree, osec, &print_dot);
3946 if (expld.result.valid_p)
3950 if (computation_is_valid)
3952 value = expld.result.value;
3954 if (expld.result.section != NULL)
3955 value += expld.result.section->vma;
3957 minfo ("0x%V", value);
3963 struct bfd_link_hash_entry *h;
3965 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3966 FALSE, FALSE, TRUE);
3969 value = h->u.def.value;
3971 if (expld.result.section != NULL)
3972 value += expld.result.section->vma;
3974 minfo ("[0x%V]", value);
3977 minfo ("[unresolved]");
3989 exp_print_tree (assignment->exp);
3994 print_input_statement (lang_input_statement_type *statm)
3996 if (statm->filename != NULL
3997 && (statm->the_bfd == NULL
3998 || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
3999 fprintf (config.map_file, "LOAD %s\n", statm->filename);
4002 /* Print all symbols defined in a particular section. This is called
4003 via bfd_link_hash_traverse, or by print_all_symbols. */
4006 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4008 asection *sec = (asection *) ptr;
4010 if ((hash_entry->type == bfd_link_hash_defined
4011 || hash_entry->type == bfd_link_hash_defweak)
4012 && sec == hash_entry->u.def.section)
4016 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4019 (hash_entry->u.def.value
4020 + hash_entry->u.def.section->output_offset
4021 + hash_entry->u.def.section->output_section->vma));
4023 minfo (" %T\n", hash_entry->root.string);
4030 hash_entry_addr_cmp (const void *a, const void *b)
4032 const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4033 const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4035 if (l->u.def.value < r->u.def.value)
4037 else if (l->u.def.value > r->u.def.value)
4044 print_all_symbols (asection *sec)
4046 struct fat_user_section_struct *ud =
4047 (struct fat_user_section_struct *) get_userdata (sec);
4048 struct map_symbol_def *def;
4049 struct bfd_link_hash_entry **entries;
4055 *ud->map_symbol_def_tail = 0;
4057 /* Sort the symbols by address. */
4058 entries = (struct bfd_link_hash_entry **)
4059 obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4061 for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4062 entries[i] = def->entry;
4064 qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4065 hash_entry_addr_cmp);
4067 /* Print the symbols. */
4068 for (i = 0; i < ud->map_symbol_def_count; i++)
4069 print_one_symbol (entries[i], sec);
4071 obstack_free (&map_obstack, entries);
4074 /* Print information about an input section to the map file. */
4077 print_input_section (asection *i, bfd_boolean is_discarded)
4079 bfd_size_type size = i->size;
4086 minfo ("%s", i->name);
4088 len = 1 + strlen (i->name);
4089 if (len >= SECTION_NAME_MAP_LENGTH - 1)
4094 while (len < SECTION_NAME_MAP_LENGTH)
4100 if (i->output_section != NULL
4101 && i->output_section->owner == link_info.output_bfd)
4102 addr = i->output_section->vma + i->output_offset;
4110 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4112 if (size != i->rawsize && i->rawsize != 0)
4114 len = SECTION_NAME_MAP_LENGTH + 3;
4126 minfo (_("%W (size before relaxing)\n"), i->rawsize);
4129 if (i->output_section != NULL
4130 && i->output_section->owner == link_info.output_bfd)
4132 if (link_info.reduce_memory_overheads)
4133 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4135 print_all_symbols (i);
4137 /* Update print_dot, but make sure that we do not move it
4138 backwards - this could happen if we have overlays and a
4139 later overlay is shorter than an earier one. */
4140 if (addr + TO_ADDR (size) > print_dot)
4141 print_dot = addr + TO_ADDR (size);
4146 print_fill_statement (lang_fill_statement_type *fill)
4150 fputs (" FILL mask 0x", config.map_file);
4151 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4152 fprintf (config.map_file, "%02x", *p);
4153 fputs ("\n", config.map_file);
4157 print_data_statement (lang_data_statement_type *data)
4165 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4168 addr = data->output_offset;
4169 if (data->output_section != NULL)
4170 addr += data->output_section->vma;
4198 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4200 if (data->exp->type.node_class != etree_value)
4203 exp_print_tree (data->exp);
4208 print_dot = addr + TO_ADDR (size);
4211 /* Print an address statement. These are generated by options like
4215 print_address_statement (lang_address_statement_type *address)
4217 minfo (_("Address of section %s set to "), address->section_name);
4218 exp_print_tree (address->address);
4222 /* Print a reloc statement. */
4225 print_reloc_statement (lang_reloc_statement_type *reloc)
4232 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4235 addr = reloc->output_offset;
4236 if (reloc->output_section != NULL)
4237 addr += reloc->output_section->vma;
4239 size = bfd_get_reloc_size (reloc->howto);
4241 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4243 if (reloc->name != NULL)
4244 minfo ("%s+", reloc->name);
4246 minfo ("%s+", reloc->section->name);
4248 exp_print_tree (reloc->addend_exp);
4252 print_dot = addr + TO_ADDR (size);
4256 print_padding_statement (lang_padding_statement_type *s)
4264 len = sizeof " *fill*" - 1;
4265 while (len < SECTION_NAME_MAP_LENGTH)
4271 addr = s->output_offset;
4272 if (s->output_section != NULL)
4273 addr += s->output_section->vma;
4274 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4276 if (s->fill->size != 0)
4280 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4281 fprintf (config.map_file, "%02x", *p);
4286 print_dot = addr + TO_ADDR (s->size);
4290 print_wild_statement (lang_wild_statement_type *w,
4291 lang_output_section_statement_type *os)
4293 struct wildcard_list *sec;
4297 if (w->filenames_sorted)
4299 if (w->filename != NULL)
4300 minfo ("%s", w->filename);
4303 if (w->filenames_sorted)
4307 for (sec = w->section_list; sec; sec = sec->next)
4309 if (sec->spec.sorted)
4311 if (sec->spec.exclude_name_list != NULL)
4314 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4315 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4316 minfo (" %s", tmp->name);
4319 if (sec->spec.name != NULL)
4320 minfo ("%s", sec->spec.name);
4323 if (sec->spec.sorted)
4332 print_statement_list (w->children.head, os);
4335 /* Print a group statement. */
4338 print_group (lang_group_statement_type *s,
4339 lang_output_section_statement_type *os)
4341 fprintf (config.map_file, "START GROUP\n");
4342 print_statement_list (s->children.head, os);
4343 fprintf (config.map_file, "END GROUP\n");
4346 /* Print the list of statements in S.
4347 This can be called for any statement type. */
4350 print_statement_list (lang_statement_union_type *s,
4351 lang_output_section_statement_type *os)
4355 print_statement (s, os);
4360 /* Print the first statement in statement list S.
4361 This can be called for any statement type. */
4364 print_statement (lang_statement_union_type *s,
4365 lang_output_section_statement_type *os)
4367 switch (s->header.type)
4370 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4373 case lang_constructors_statement_enum:
4374 if (constructor_list.head != NULL)
4376 if (constructors_sorted)
4377 minfo (" SORT (CONSTRUCTORS)\n");
4379 minfo (" CONSTRUCTORS\n");
4380 print_statement_list (constructor_list.head, os);
4383 case lang_wild_statement_enum:
4384 print_wild_statement (&s->wild_statement, os);
4386 case lang_address_statement_enum:
4387 print_address_statement (&s->address_statement);
4389 case lang_object_symbols_statement_enum:
4390 minfo (" CREATE_OBJECT_SYMBOLS\n");
4392 case lang_fill_statement_enum:
4393 print_fill_statement (&s->fill_statement);
4395 case lang_data_statement_enum:
4396 print_data_statement (&s->data_statement);
4398 case lang_reloc_statement_enum:
4399 print_reloc_statement (&s->reloc_statement);
4401 case lang_input_section_enum:
4402 print_input_section (s->input_section.section, FALSE);
4404 case lang_padding_statement_enum:
4405 print_padding_statement (&s->padding_statement);
4407 case lang_output_section_statement_enum:
4408 print_output_section_statement (&s->output_section_statement);
4410 case lang_assignment_statement_enum:
4411 print_assignment (&s->assignment_statement, os);
4413 case lang_target_statement_enum:
4414 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4416 case lang_output_statement_enum:
4417 minfo ("OUTPUT(%s", s->output_statement.name);
4418 if (output_target != NULL)
4419 minfo (" %s", output_target);
4422 case lang_input_statement_enum:
4423 print_input_statement (&s->input_statement);
4425 case lang_group_statement_enum:
4426 print_group (&s->group_statement, os);
4428 case lang_insert_statement_enum:
4429 minfo ("INSERT %s %s\n",
4430 s->insert_statement.is_before ? "BEFORE" : "AFTER",
4431 s->insert_statement.where);
4437 print_statements (void)
4439 print_statement_list (statement_list.head, abs_output_section);
4442 /* Print the first N statements in statement list S to STDERR.
4443 If N == 0, nothing is printed.
4444 If N < 0, the entire list is printed.
4445 Intended to be called from GDB. */
4448 dprint_statement (lang_statement_union_type *s, int n)
4450 FILE *map_save = config.map_file;
4452 config.map_file = stderr;
4455 print_statement_list (s, abs_output_section);
4458 while (s && --n >= 0)
4460 print_statement (s, abs_output_section);
4465 config.map_file = map_save;
4469 insert_pad (lang_statement_union_type **ptr,
4471 unsigned int alignment_needed,
4472 asection *output_section,
4475 static fill_type zero_fill = { 1, { 0 } };
4476 lang_statement_union_type *pad = NULL;
4478 if (ptr != &statement_list.head)
4479 pad = ((lang_statement_union_type *)
4480 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4482 && pad->header.type == lang_padding_statement_enum
4483 && pad->padding_statement.output_section == output_section)
4485 /* Use the existing pad statement. */
4487 else if ((pad = *ptr) != NULL
4488 && pad->header.type == lang_padding_statement_enum
4489 && pad->padding_statement.output_section == output_section)
4491 /* Use the existing pad statement. */
4495 /* Make a new padding statement, linked into existing chain. */
4496 pad = (lang_statement_union_type *)
4497 stat_alloc (sizeof (lang_padding_statement_type));
4498 pad->header.next = *ptr;
4500 pad->header.type = lang_padding_statement_enum;
4501 pad->padding_statement.output_section = output_section;
4504 pad->padding_statement.fill = fill;
4506 pad->padding_statement.output_offset = dot - output_section->vma;
4507 pad->padding_statement.size = alignment_needed;
4508 output_section->size += alignment_needed;
4511 /* Work out how much this section will move the dot point. */
4515 (lang_statement_union_type **this_ptr,
4516 lang_output_section_statement_type *output_section_statement,
4520 lang_input_section_type *is = &((*this_ptr)->input_section);
4521 asection *i = is->section;
4523 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4524 && (i->flags & SEC_EXCLUDE) == 0)
4526 unsigned int alignment_needed;
4529 /* Align this section first to the input sections requirement,
4530 then to the output section's requirement. If this alignment
4531 is greater than any seen before, then record it too. Perform
4532 the alignment by inserting a magic 'padding' statement. */
4534 if (output_section_statement->subsection_alignment != -1)
4535 i->alignment_power = output_section_statement->subsection_alignment;
4537 o = output_section_statement->bfd_section;
4538 if (o->alignment_power < i->alignment_power)
4539 o->alignment_power = i->alignment_power;
4541 alignment_needed = align_power (dot, i->alignment_power) - dot;
4543 if (alignment_needed != 0)
4545 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4546 dot += alignment_needed;
4549 /* Remember where in the output section this input section goes. */
4551 i->output_offset = dot - o->vma;
4553 /* Mark how big the output section must be to contain this now. */
4554 dot += TO_ADDR (i->size);
4555 o->size = TO_SIZE (dot - o->vma);
4559 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4566 sort_sections_by_lma (const void *arg1, const void *arg2)
4568 const asection *sec1 = *(const asection **) arg1;
4569 const asection *sec2 = *(const asection **) arg2;
4571 if (bfd_section_lma (sec1->owner, sec1)
4572 < bfd_section_lma (sec2->owner, sec2))
4574 else if (bfd_section_lma (sec1->owner, sec1)
4575 > bfd_section_lma (sec2->owner, sec2))
4577 else if (sec1->id < sec2->id)
4579 else if (sec1->id > sec2->id)
4585 #define IGNORE_SECTION(s) \
4586 ((s->flags & SEC_ALLOC) == 0 \
4587 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4588 && (s->flags & SEC_LOAD) == 0))
4590 /* Check to see if any allocated sections overlap with other allocated
4591 sections. This can happen if a linker script specifies the output
4592 section addresses of the two sections. Also check whether any memory
4593 region has overflowed. */
4596 lang_check_section_addresses (void)
4599 asection **sections, **spp;
4606 lang_memory_region_type *m;
4608 if (bfd_count_sections (link_info.output_bfd) <= 1)
4611 amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4612 sections = (asection **) xmalloc (amt);
4614 /* Scan all sections in the output list. */
4616 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4618 /* Only consider loadable sections with real contents. */
4619 if (!(s->flags & SEC_LOAD)
4620 || !(s->flags & SEC_ALLOC)
4624 sections[count] = s;
4631 qsort (sections, (size_t) count, sizeof (asection *),
4632 sort_sections_by_lma);
4637 s_end = s_start + TO_ADDR (s->size) - 1;
4638 for (count--; count; count--)
4640 /* We must check the sections' LMA addresses not their VMA
4641 addresses because overlay sections can have overlapping VMAs
4642 but they must have distinct LMAs. */
4648 s_end = s_start + TO_ADDR (s->size) - 1;
4650 /* Look for an overlap. We have sorted sections by lma, so we
4651 know that s_start >= p_start. Besides the obvious case of
4652 overlap when the current section starts before the previous
4653 one ends, we also must have overlap if the previous section
4654 wraps around the address space. */
4655 if (s_start <= p_end
4657 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4658 s->name, s_start, s_end, p->name, p_start, p_end);
4663 /* If any memory region has overflowed, report by how much.
4664 We do not issue this diagnostic for regions that had sections
4665 explicitly placed outside their bounds; os_region_check's
4666 diagnostics are adequate for that case.
4668 FIXME: It is conceivable that m->current - (m->origin + m->length)
4669 might overflow a 32-bit integer. There is, alas, no way to print
4670 a bfd_vma quantity in decimal. */
4671 for (m = lang_memory_region_list; m; m = m->next)
4672 if (m->had_full_message)
4673 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4674 m->name_list.name, (long)(m->current - (m->origin + m->length)));
4678 /* Make sure the new address is within the region. We explicitly permit the
4679 current address to be at the exact end of the region when the address is
4680 non-zero, in case the region is at the end of addressable memory and the
4681 calculation wraps around. */
4684 os_region_check (lang_output_section_statement_type *os,
4685 lang_memory_region_type *region,
4689 if ((region->current < region->origin
4690 || (region->current - region->origin > region->length))
4691 && ((region->current != region->origin + region->length)
4696 einfo (_("%X%P: address 0x%v of %B section `%s'"
4697 " is not within region `%s'\n"),
4699 os->bfd_section->owner,
4700 os->bfd_section->name,
4701 region->name_list.name);
4703 else if (!region->had_full_message)
4705 region->had_full_message = TRUE;
4707 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4708 os->bfd_section->owner,
4709 os->bfd_section->name,
4710 region->name_list.name);
4715 /* Set the sizes for all the output sections. */
4718 lang_size_sections_1
4719 (lang_statement_union_type **prev,
4720 lang_output_section_statement_type *output_section_statement,
4724 bfd_boolean check_regions)
4726 lang_statement_union_type *s;
4728 /* Size up the sections from their constituent parts. */
4729 for (s = *prev; s != NULL; s = s->header.next)
4731 switch (s->header.type)
4733 case lang_output_section_statement_enum:
4735 bfd_vma newdot, after;
4736 lang_output_section_statement_type *os;
4737 lang_memory_region_type *r;
4738 int section_alignment = 0;
4740 os = &s->output_section_statement;
4741 if (os->constraint == -1)
4744 /* FIXME: We shouldn't need to zero section vmas for ld -r
4745 here, in lang_insert_orphan, or in the default linker scripts.
4746 This is covering for coff backend linker bugs. See PR6945. */
4747 if (os->addr_tree == NULL
4748 && link_info.relocatable
4749 && (bfd_get_flavour (link_info.output_bfd)
4750 == bfd_target_coff_flavour))
4751 os->addr_tree = exp_intop (0);
4752 if (os->addr_tree != NULL)
4754 os->processed_vma = FALSE;
4755 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4757 if (expld.result.valid_p)
4759 dot = expld.result.value;
4760 if (expld.result.section != NULL)
4761 dot += expld.result.section->vma;
4763 else if (expld.phase != lang_mark_phase_enum)
4764 einfo (_("%F%S: non constant or forward reference"
4765 " address expression for section %s\n"),
4769 if (os->bfd_section == NULL)
4770 /* This section was removed or never actually created. */
4773 /* If this is a COFF shared library section, use the size and
4774 address from the input section. FIXME: This is COFF
4775 specific; it would be cleaner if there were some other way
4776 to do this, but nothing simple comes to mind. */
4777 if (((bfd_get_flavour (link_info.output_bfd)
4778 == bfd_target_ecoff_flavour)
4779 || (bfd_get_flavour (link_info.output_bfd)
4780 == bfd_target_coff_flavour))
4781 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4785 if (os->children.head == NULL
4786 || os->children.head->header.next != NULL
4787 || (os->children.head->header.type
4788 != lang_input_section_enum))
4789 einfo (_("%P%X: Internal error on COFF shared library"
4790 " section %s\n"), os->name);
4792 input = os->children.head->input_section.section;
4793 bfd_set_section_vma (os->bfd_section->owner,
4795 bfd_section_vma (input->owner, input));
4796 os->bfd_section->size = input->size;
4801 if (bfd_is_abs_section (os->bfd_section))
4803 /* No matter what happens, an abs section starts at zero. */
4804 ASSERT (os->bfd_section->vma == 0);
4808 if (os->addr_tree == NULL)
4810 /* No address specified for this section, get one
4811 from the region specification. */
4812 if (os->region == NULL
4813 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4814 && os->region->name_list.name[0] == '*'
4815 && strcmp (os->region->name_list.name,
4816 DEFAULT_MEMORY_REGION) == 0))
4818 os->region = lang_memory_default (os->bfd_section);
4821 /* If a loadable section is using the default memory
4822 region, and some non default memory regions were
4823 defined, issue an error message. */
4825 && !IGNORE_SECTION (os->bfd_section)
4826 && ! link_info.relocatable
4828 && strcmp (os->region->name_list.name,
4829 DEFAULT_MEMORY_REGION) == 0
4830 && lang_memory_region_list != NULL
4831 && (strcmp (lang_memory_region_list->name_list.name,
4832 DEFAULT_MEMORY_REGION) != 0
4833 || lang_memory_region_list->next != NULL)
4834 && expld.phase != lang_mark_phase_enum)
4836 /* By default this is an error rather than just a
4837 warning because if we allocate the section to the
4838 default memory region we can end up creating an
4839 excessively large binary, or even seg faulting when
4840 attempting to perform a negative seek. See
4841 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4842 for an example of this. This behaviour can be
4843 overridden by the using the --no-check-sections
4845 if (command_line.check_section_addresses)
4846 einfo (_("%P%F: error: no memory region specified"
4847 " for loadable section `%s'\n"),
4848 bfd_get_section_name (link_info.output_bfd,
4851 einfo (_("%P: warning: no memory region specified"
4852 " for loadable section `%s'\n"),
4853 bfd_get_section_name (link_info.output_bfd,
4857 newdot = os->region->current;
4858 section_alignment = os->bfd_section->alignment_power;
4861 section_alignment = os->section_alignment;
4863 /* Align to what the section needs. */
4864 if (section_alignment > 0)
4866 bfd_vma savedot = newdot;
4867 newdot = align_power (newdot, section_alignment);
4869 if (newdot != savedot
4870 && (config.warn_section_align
4871 || os->addr_tree != NULL)
4872 && expld.phase != lang_mark_phase_enum)
4873 einfo (_("%P: warning: changing start of section"
4874 " %s by %lu bytes\n"),
4875 os->name, (unsigned long) (newdot - savedot));
4878 bfd_set_section_vma (0, os->bfd_section, newdot);
4880 os->bfd_section->output_offset = 0;
4883 lang_size_sections_1 (&os->children.head, os,
4884 os->fill, newdot, relax, check_regions);
4886 os->processed_vma = TRUE;
4888 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4889 /* Except for some special linker created sections,
4890 no output section should change from zero size
4891 after strip_excluded_output_sections. A non-zero
4892 size on an ignored section indicates that some
4893 input section was not sized early enough. */
4894 ASSERT (os->bfd_section->size == 0);
4897 dot = os->bfd_section->vma;
4899 /* Put the section within the requested block size, or
4900 align at the block boundary. */
4902 + TO_ADDR (os->bfd_section->size)
4903 + os->block_value - 1)
4904 & - (bfd_vma) os->block_value);
4906 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4909 /* Set section lma. */
4912 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4916 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4917 os->bfd_section->lma = lma;
4919 else if (os->lma_region != NULL)
4921 bfd_vma lma = os->lma_region->current;
4923 if (section_alignment > 0)
4924 lma = align_power (lma, section_alignment);
4925 os->bfd_section->lma = lma;
4927 else if (r->last_os != NULL
4928 && (os->bfd_section->flags & SEC_ALLOC) != 0)
4933 last = r->last_os->output_section_statement.bfd_section;
4935 /* A backwards move of dot should be accompanied by
4936 an explicit assignment to the section LMA (ie.
4937 os->load_base set) because backwards moves can
4938 create overlapping LMAs. */
4940 && os->bfd_section->size != 0
4941 && dot + os->bfd_section->size <= last->vma)
4943 /* If dot moved backwards then leave lma equal to
4944 vma. This is the old default lma, which might
4945 just happen to work when the backwards move is
4946 sufficiently large. Nag if this changes anything,
4947 so people can fix their linker scripts. */
4949 if (last->vma != last->lma)
4950 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4955 /* If this is an overlay, set the current lma to that
4956 at the end of the previous section. */
4957 if (os->sectype == overlay_section)
4958 lma = last->lma + last->size;
4960 /* Otherwise, keep the same lma to vma relationship
4961 as the previous section. */
4963 lma = dot + last->lma - last->vma;
4965 if (section_alignment > 0)
4966 lma = align_power (lma, section_alignment);
4967 os->bfd_section->lma = lma;
4970 os->processed_lma = TRUE;
4972 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4975 /* Keep track of normal sections using the default
4976 lma region. We use this to set the lma for
4977 following sections. Overlays or other linker
4978 script assignment to lma might mean that the
4979 default lma == vma is incorrect.
4980 To avoid warnings about dot moving backwards when using
4981 -Ttext, don't start tracking sections until we find one
4982 of non-zero size or with lma set differently to vma. */
4983 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4984 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4985 && (os->bfd_section->flags & SEC_ALLOC) != 0
4986 && (os->bfd_section->size != 0
4987 || (r->last_os == NULL
4988 && os->bfd_section->vma != os->bfd_section->lma)
4989 || (r->last_os != NULL
4990 && dot >= (r->last_os->output_section_statement
4991 .bfd_section->vma)))
4992 && os->lma_region == NULL
4993 && !link_info.relocatable)
4996 /* .tbss sections effectively have zero size. */
4997 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4998 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4999 || link_info.relocatable)
5000 dot += TO_ADDR (os->bfd_section->size);
5002 if (os->update_dot_tree != 0)
5003 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5005 /* Update dot in the region ?
5006 We only do this if the section is going to be allocated,
5007 since unallocated sections do not contribute to the region's
5008 overall size in memory. */
5009 if (os->region != NULL
5010 && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5012 os->region->current = dot;
5015 /* Make sure the new address is within the region. */
5016 os_region_check (os, os->region, os->addr_tree,
5017 os->bfd_section->vma);
5019 if (os->lma_region != NULL && os->lma_region != os->region
5020 && (os->bfd_section->flags & SEC_LOAD))
5022 os->lma_region->current
5023 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
5026 os_region_check (os, os->lma_region, NULL,
5027 os->bfd_section->lma);
5033 case lang_constructors_statement_enum:
5034 dot = lang_size_sections_1 (&constructor_list.head,
5035 output_section_statement,
5036 fill, dot, relax, check_regions);
5039 case lang_data_statement_enum:
5041 unsigned int size = 0;
5043 s->data_statement.output_offset =
5044 dot - output_section_statement->bfd_section->vma;
5045 s->data_statement.output_section =
5046 output_section_statement->bfd_section;
5048 /* We might refer to provided symbols in the expression, and
5049 need to mark them as needed. */
5050 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5052 switch (s->data_statement.type)
5070 if (size < TO_SIZE ((unsigned) 1))
5071 size = TO_SIZE ((unsigned) 1);
5072 dot += TO_ADDR (size);
5073 output_section_statement->bfd_section->size += size;
5077 case lang_reloc_statement_enum:
5081 s->reloc_statement.output_offset =
5082 dot - output_section_statement->bfd_section->vma;
5083 s->reloc_statement.output_section =
5084 output_section_statement->bfd_section;
5085 size = bfd_get_reloc_size (s->reloc_statement.howto);
5086 dot += TO_ADDR (size);
5087 output_section_statement->bfd_section->size += size;
5091 case lang_wild_statement_enum:
5092 dot = lang_size_sections_1 (&s->wild_statement.children.head,
5093 output_section_statement,
5094 fill, dot, relax, check_regions);
5097 case lang_object_symbols_statement_enum:
5098 link_info.create_object_symbols_section =
5099 output_section_statement->bfd_section;
5102 case lang_output_statement_enum:
5103 case lang_target_statement_enum:
5106 case lang_input_section_enum:
5110 i = s->input_section.section;
5115 if (! bfd_relax_section (i->owner, i, &link_info, &again))
5116 einfo (_("%P%F: can't relax section: %E\n"));
5120 dot = size_input_section (prev, output_section_statement,
5121 output_section_statement->fill, dot);
5125 case lang_input_statement_enum:
5128 case lang_fill_statement_enum:
5129 s->fill_statement.output_section =
5130 output_section_statement->bfd_section;
5132 fill = s->fill_statement.fill;
5135 case lang_assignment_statement_enum:
5137 bfd_vma newdot = dot;
5138 etree_type *tree = s->assignment_statement.exp;
5140 expld.dataseg.relro = exp_dataseg_relro_none;
5142 exp_fold_tree (tree,
5143 output_section_statement->bfd_section,
5146 if (expld.dataseg.relro == exp_dataseg_relro_start)
5148 if (!expld.dataseg.relro_start_stat)
5149 expld.dataseg.relro_start_stat = s;
5152 ASSERT (expld.dataseg.relro_start_stat == s);
5155 else if (expld.dataseg.relro == exp_dataseg_relro_end)
5157 if (!expld.dataseg.relro_end_stat)
5158 expld.dataseg.relro_end_stat = s;
5161 ASSERT (expld.dataseg.relro_end_stat == s);
5164 expld.dataseg.relro = exp_dataseg_relro_none;
5166 /* This symbol is relative to this section. */
5167 if ((tree->type.node_class == etree_provided
5168 || tree->type.node_class == etree_assign)
5169 && (tree->assign.dst [0] != '.'
5170 || tree->assign.dst [1] != '\0'))
5171 output_section_statement->section_relative_symbol = 1;
5173 if (!output_section_statement->ignored)
5175 if (output_section_statement == abs_output_section)
5177 /* If we don't have an output section, then just adjust
5178 the default memory address. */
5179 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5180 FALSE)->current = newdot;
5182 else if (newdot != dot)
5184 /* Insert a pad after this statement. We can't
5185 put the pad before when relaxing, in case the
5186 assignment references dot. */
5187 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5188 output_section_statement->bfd_section, dot);
5190 /* Don't neuter the pad below when relaxing. */
5193 /* If dot is advanced, this implies that the section
5194 should have space allocated to it, unless the
5195 user has explicitly stated that the section
5196 should not be allocated. */
5197 if (output_section_statement->sectype != noalloc_section
5198 && (output_section_statement->sectype != noload_section
5199 || (bfd_get_flavour (link_info.output_bfd)
5200 == bfd_target_elf_flavour)))
5201 output_section_statement->bfd_section->flags |= SEC_ALLOC;
5208 case lang_padding_statement_enum:
5209 /* If this is the first time lang_size_sections is called,
5210 we won't have any padding statements. If this is the
5211 second or later passes when relaxing, we should allow
5212 padding to shrink. If padding is needed on this pass, it
5213 will be added back in. */
5214 s->padding_statement.size = 0;
5216 /* Make sure output_offset is valid. If relaxation shrinks
5217 the section and this pad isn't needed, it's possible to
5218 have output_offset larger than the final size of the
5219 section. bfd_set_section_contents will complain even for
5220 a pad size of zero. */
5221 s->padding_statement.output_offset
5222 = dot - output_section_statement->bfd_section->vma;
5225 case lang_group_statement_enum:
5226 dot = lang_size_sections_1 (&s->group_statement.children.head,
5227 output_section_statement,
5228 fill, dot, relax, check_regions);
5231 case lang_insert_statement_enum:
5234 /* We can only get here when relaxing is turned on. */
5235 case lang_address_statement_enum:
5242 prev = &s->header.next;
5247 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5248 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5249 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5250 segments. We are allowed an opportunity to override this decision. */
5253 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5254 bfd * abfd ATTRIBUTE_UNUSED,
5255 asection * current_section,
5256 asection * previous_section,
5257 bfd_boolean new_segment)
5259 lang_output_section_statement_type * cur;
5260 lang_output_section_statement_type * prev;
5262 /* The checks below are only necessary when the BFD library has decided
5263 that the two sections ought to be placed into the same segment. */
5267 /* Paranoia checks. */
5268 if (current_section == NULL || previous_section == NULL)
5271 /* Find the memory regions associated with the two sections.
5272 We call lang_output_section_find() here rather than scanning the list
5273 of output sections looking for a matching section pointer because if
5274 we have a large number of sections then a hash lookup is faster. */
5275 cur = lang_output_section_find (current_section->name);
5276 prev = lang_output_section_find (previous_section->name);
5278 /* More paranoia. */
5279 if (cur == NULL || prev == NULL)
5282 /* If the regions are different then force the sections to live in
5283 different segments. See the email thread starting at the following
5284 URL for the reasons why this is necessary:
5285 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5286 return cur->region != prev->region;
5290 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5292 lang_statement_iteration++;
5293 lang_size_sections_1 (&statement_list.head, abs_output_section,
5294 0, 0, relax, check_regions);
5298 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5300 expld.phase = lang_allocating_phase_enum;
5301 expld.dataseg.phase = exp_dataseg_none;
5303 one_lang_size_sections_pass (relax, check_regions);
5304 if (expld.dataseg.phase == exp_dataseg_end_seen
5305 && link_info.relro && expld.dataseg.relro_end)
5307 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5308 to put expld.dataseg.relro on a (common) page boundary. */
5309 bfd_vma min_base, old_base, relro_end, maxpage;
5311 expld.dataseg.phase = exp_dataseg_relro_adjust;
5312 maxpage = expld.dataseg.maxpagesize;
5313 /* MIN_BASE is the absolute minimum address we are allowed to start the
5314 read-write segment (byte before will be mapped read-only). */
5315 min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5316 /* OLD_BASE is the address for a feasible minimum address which will
5317 still not cause a data overlap inside MAXPAGE causing file offset skip
5319 old_base = expld.dataseg.base;
5320 expld.dataseg.base += (-expld.dataseg.relro_end
5321 & (expld.dataseg.pagesize - 1));
5322 /* Compute the expected PT_GNU_RELRO segment end. */
5323 relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5324 & ~(expld.dataseg.pagesize - 1));
5325 if (min_base + maxpage < expld.dataseg.base)
5327 expld.dataseg.base -= maxpage;
5328 relro_end -= maxpage;
5330 lang_reset_memory_regions ();
5331 one_lang_size_sections_pass (relax, check_regions);
5332 if (expld.dataseg.relro_end > relro_end)
5334 /* The alignment of sections between DATA_SEGMENT_ALIGN
5335 and DATA_SEGMENT_RELRO_END caused huge padding to be
5336 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5337 that the section alignments will fit in. */
5339 unsigned int max_alignment_power = 0;
5341 /* Find maximum alignment power of sections between
5342 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5343 for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5344 if (sec->vma >= expld.dataseg.base
5345 && sec->vma < expld.dataseg.relro_end
5346 && sec->alignment_power > max_alignment_power)
5347 max_alignment_power = sec->alignment_power;
5349 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5351 if (expld.dataseg.base - (1 << max_alignment_power) < old_base)
5352 expld.dataseg.base += expld.dataseg.pagesize;
5353 expld.dataseg.base -= (1 << max_alignment_power);
5354 lang_reset_memory_regions ();
5355 one_lang_size_sections_pass (relax, check_regions);
5358 link_info.relro_start = expld.dataseg.base;
5359 link_info.relro_end = expld.dataseg.relro_end;
5361 else if (expld.dataseg.phase == exp_dataseg_end_seen)
5363 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5364 a page could be saved in the data segment. */
5365 bfd_vma first, last;
5367 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5368 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5370 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5371 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5372 && first + last <= expld.dataseg.pagesize)
5374 expld.dataseg.phase = exp_dataseg_adjust;
5375 lang_reset_memory_regions ();
5376 one_lang_size_sections_pass (relax, check_regions);
5379 expld.dataseg.phase = exp_dataseg_done;
5382 expld.dataseg.phase = exp_dataseg_done;
5385 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5388 lang_do_assignments_1 (lang_statement_union_type *s,
5389 lang_output_section_statement_type *current_os,
5393 for (; s != NULL; s = s->header.next)
5395 switch (s->header.type)
5397 case lang_constructors_statement_enum:
5398 dot = lang_do_assignments_1 (constructor_list.head,
5399 current_os, fill, dot);
5402 case lang_output_section_statement_enum:
5404 lang_output_section_statement_type *os;
5406 os = &(s->output_section_statement);
5407 if (os->bfd_section != NULL && !os->ignored)
5409 dot = os->bfd_section->vma;
5411 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5413 /* .tbss sections effectively have zero size. */
5414 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5415 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5416 || link_info.relocatable)
5417 dot += TO_ADDR (os->bfd_section->size);
5419 if (os->update_dot_tree != NULL)
5420 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5425 case lang_wild_statement_enum:
5427 dot = lang_do_assignments_1 (s->wild_statement.children.head,
5428 current_os, fill, dot);
5431 case lang_object_symbols_statement_enum:
5432 case lang_output_statement_enum:
5433 case lang_target_statement_enum:
5436 case lang_data_statement_enum:
5437 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5438 if (expld.result.valid_p)
5440 s->data_statement.value = expld.result.value;
5441 if (expld.result.section != NULL)
5442 s->data_statement.value += expld.result.section->vma;
5445 einfo (_("%F%P: invalid data statement\n"));
5448 switch (s->data_statement.type)
5466 if (size < TO_SIZE ((unsigned) 1))
5467 size = TO_SIZE ((unsigned) 1);
5468 dot += TO_ADDR (size);
5472 case lang_reloc_statement_enum:
5473 exp_fold_tree (s->reloc_statement.addend_exp,
5474 bfd_abs_section_ptr, &dot);
5475 if (expld.result.valid_p)
5476 s->reloc_statement.addend_value = expld.result.value;
5478 einfo (_("%F%P: invalid reloc statement\n"));
5479 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5482 case lang_input_section_enum:
5484 asection *in = s->input_section.section;
5486 if ((in->flags & SEC_EXCLUDE) == 0)
5487 dot += TO_ADDR (in->size);
5491 case lang_input_statement_enum:
5494 case lang_fill_statement_enum:
5495 fill = s->fill_statement.fill;
5498 case lang_assignment_statement_enum:
5499 exp_fold_tree (s->assignment_statement.exp,
5500 current_os->bfd_section,
5504 case lang_padding_statement_enum:
5505 dot += TO_ADDR (s->padding_statement.size);
5508 case lang_group_statement_enum:
5509 dot = lang_do_assignments_1 (s->group_statement.children.head,
5510 current_os, fill, dot);
5513 case lang_insert_statement_enum:
5516 case lang_address_statement_enum:
5528 lang_do_assignments (void)
5530 lang_statement_iteration++;
5531 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5534 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5535 operator .startof. (section_name), it produces an undefined symbol
5536 .startof.section_name. Similarly, when it sees
5537 .sizeof. (section_name), it produces an undefined symbol
5538 .sizeof.section_name. For all the output sections, we look for
5539 such symbols, and set them to the correct value. */
5542 lang_set_startof (void)
5546 if (link_info.relocatable)
5549 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5551 const char *secname;
5553 struct bfd_link_hash_entry *h;
5555 secname = bfd_get_section_name (link_info.output_bfd, s);
5556 buf = (char *) xmalloc (10 + strlen (secname));
5558 sprintf (buf, ".startof.%s", secname);
5559 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5560 if (h != NULL && h->type == bfd_link_hash_undefined)
5562 h->type = bfd_link_hash_defined;
5563 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5564 h->u.def.section = bfd_abs_section_ptr;
5567 sprintf (buf, ".sizeof.%s", secname);
5568 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5569 if (h != NULL && h->type == bfd_link_hash_undefined)
5571 h->type = bfd_link_hash_defined;
5572 h->u.def.value = TO_ADDR (s->size);
5573 h->u.def.section = bfd_abs_section_ptr;
5583 struct bfd_link_hash_entry *h;
5586 if ((link_info.relocatable && !link_info.gc_sections)
5587 || (link_info.shared && !link_info.executable))
5588 warn = entry_from_cmdline;
5592 /* Force the user to specify a root when generating a relocatable with
5594 if (link_info.gc_sections && link_info.relocatable
5595 && !(entry_from_cmdline || undef_from_cmdline))
5596 einfo (_("%P%F: gc-sections requires either an entry or "
5597 "an undefined symbol\n"));
5599 if (entry_symbol.name == NULL)
5601 /* No entry has been specified. Look for the default entry, but
5602 don't warn if we don't find it. */
5603 entry_symbol.name = entry_symbol_default;
5607 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5608 FALSE, FALSE, TRUE);
5610 && (h->type == bfd_link_hash_defined
5611 || h->type == bfd_link_hash_defweak)
5612 && h->u.def.section->output_section != NULL)
5616 val = (h->u.def.value
5617 + bfd_get_section_vma (link_info.output_bfd,
5618 h->u.def.section->output_section)
5619 + h->u.def.section->output_offset);
5620 if (! bfd_set_start_address (link_info.output_bfd, val))
5621 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5628 /* We couldn't find the entry symbol. Try parsing it as a
5630 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5633 if (! bfd_set_start_address (link_info.output_bfd, val))
5634 einfo (_("%P%F: can't set start address\n"));
5640 /* Can't find the entry symbol, and it's not a number. Use
5641 the first address in the text section. */
5642 ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5646 einfo (_("%P: warning: cannot find entry symbol %s;"
5647 " defaulting to %V\n"),
5649 bfd_get_section_vma (link_info.output_bfd, ts));
5650 if (!(bfd_set_start_address
5651 (link_info.output_bfd,
5652 bfd_get_section_vma (link_info.output_bfd, ts))))
5653 einfo (_("%P%F: can't set start address\n"));
5658 einfo (_("%P: warning: cannot find entry symbol %s;"
5659 " not setting start address\n"),
5665 /* Don't bfd_hash_table_free (&lang_definedness_table);
5666 map file output may result in a call of lang_track_definedness. */
5669 /* This is a small function used when we want to ignore errors from
5673 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5675 /* Don't do anything. */
5678 /* Check that the architecture of all the input files is compatible
5679 with the output file. Also call the backend to let it do any
5680 other checking that is needed. */
5685 lang_statement_union_type *file;
5687 const bfd_arch_info_type *compatible;
5689 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5691 input_bfd = file->input_statement.the_bfd;
5693 = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5694 command_line.accept_unknown_input_arch);
5696 /* In general it is not possible to perform a relocatable
5697 link between differing object formats when the input
5698 file has relocations, because the relocations in the
5699 input format may not have equivalent representations in
5700 the output format (and besides BFD does not translate
5701 relocs for other link purposes than a final link). */
5702 if ((link_info.relocatable || link_info.emitrelocations)
5703 && (compatible == NULL
5704 || (bfd_get_flavour (input_bfd)
5705 != bfd_get_flavour (link_info.output_bfd)))
5706 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5708 einfo (_("%P%F: Relocatable linking with relocations from"
5709 " format %s (%B) to format %s (%B) is not supported\n"),
5710 bfd_get_target (input_bfd), input_bfd,
5711 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5712 /* einfo with %F exits. */
5715 if (compatible == NULL)
5717 if (command_line.warn_mismatch)
5718 einfo (_("%P%X: %s architecture of input file `%B'"
5719 " is incompatible with %s output\n"),
5720 bfd_printable_name (input_bfd), input_bfd,
5721 bfd_printable_name (link_info.output_bfd));
5723 else if (bfd_count_sections (input_bfd))
5725 /* If the input bfd has no contents, it shouldn't set the
5726 private data of the output bfd. */
5728 bfd_error_handler_type pfn = NULL;
5730 /* If we aren't supposed to warn about mismatched input
5731 files, temporarily set the BFD error handler to a
5732 function which will do nothing. We still want to call
5733 bfd_merge_private_bfd_data, since it may set up
5734 information which is needed in the output file. */
5735 if (! command_line.warn_mismatch)
5736 pfn = bfd_set_error_handler (ignore_bfd_errors);
5737 if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5739 if (command_line.warn_mismatch)
5740 einfo (_("%P%X: failed to merge target specific data"
5741 " of file %B\n"), input_bfd);
5743 if (! command_line.warn_mismatch)
5744 bfd_set_error_handler (pfn);
5749 /* Look through all the global common symbols and attach them to the
5750 correct section. The -sort-common command line switch may be used
5751 to roughly sort the entries by alignment. */
5756 if (command_line.inhibit_common_definition)
5758 if (link_info.relocatable
5759 && ! command_line.force_common_definition)
5762 if (! config.sort_common)
5763 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5768 if (config.sort_common == sort_descending)
5770 for (power = 4; power > 0; power--)
5771 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5774 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5778 for (power = 0; power <= 4; power++)
5779 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5782 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5787 /* Place one common symbol in the correct section. */
5790 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5792 unsigned int power_of_two;
5796 if (h->type != bfd_link_hash_common)
5800 power_of_two = h->u.c.p->alignment_power;
5802 if (config.sort_common == sort_descending
5803 && power_of_two < *(unsigned int *) info)
5805 else if (config.sort_common == sort_ascending
5806 && power_of_two > *(unsigned int *) info)
5809 section = h->u.c.p->section;
5810 if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
5811 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5814 if (config.map_file != NULL)
5816 static bfd_boolean header_printed;
5821 if (! header_printed)
5823 minfo (_("\nAllocating common symbols\n"));
5824 minfo (_("Common symbol size file\n\n"));
5825 header_printed = TRUE;
5828 name = bfd_demangle (link_info.output_bfd, h->root.string,
5829 DMGL_ANSI | DMGL_PARAMS);
5832 minfo ("%s", h->root.string);
5833 len = strlen (h->root.string);
5838 len = strlen (name);
5854 if (size <= 0xffffffff)
5855 sprintf (buf, "%lx", (unsigned long) size);
5857 sprintf_vma (buf, size);
5867 minfo ("%B\n", section->owner);
5873 /* Run through the input files and ensure that every input section has
5874 somewhere to go. If one is found without a destination then create
5875 an input request and place it into the statement tree. */
5878 lang_place_orphans (void)
5880 LANG_FOR_EACH_INPUT_STATEMENT (file)
5884 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5886 if (s->output_section == NULL)
5888 /* This section of the file is not attached, root
5889 around for a sensible place for it to go. */
5891 if (file->just_syms_flag)
5892 bfd_link_just_syms (file->the_bfd, s, &link_info);
5893 else if ((s->flags & SEC_EXCLUDE) != 0)
5894 s->output_section = bfd_abs_section_ptr;
5895 else if (strcmp (s->name, "COMMON") == 0)
5897 /* This is a lonely common section which must have
5898 come from an archive. We attach to the section
5899 with the wildcard. */
5900 if (! link_info.relocatable
5901 || command_line.force_common_definition)
5903 if (default_common_section == NULL)
5904 default_common_section
5905 = lang_output_section_statement_lookup (".bss", 0,
5907 lang_add_section (&default_common_section->children, s,
5908 default_common_section);
5913 const char *name = s->name;
5916 if (config.unique_orphan_sections
5917 || unique_section_p (s, NULL))
5918 constraint = SPECIAL;
5920 if (!ldemul_place_orphan (s, name, constraint))
5922 lang_output_section_statement_type *os;
5923 os = lang_output_section_statement_lookup (name,
5926 if (os->addr_tree == NULL
5927 && (link_info.relocatable
5928 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
5929 os->addr_tree = exp_intop (0);
5930 lang_add_section (&os->children, s, os);
5939 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5941 flagword *ptr_flags;
5943 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5949 *ptr_flags |= SEC_ALLOC;
5953 *ptr_flags |= SEC_READONLY;
5957 *ptr_flags |= SEC_DATA;
5961 *ptr_flags |= SEC_CODE;
5966 *ptr_flags |= SEC_LOAD;
5970 einfo (_("%P%F: invalid syntax in flags\n"));
5977 /* Call a function on each input file. This function will be called
5978 on an archive, but not on the elements. */
5981 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5983 lang_input_statement_type *f;
5985 for (f = (lang_input_statement_type *) input_file_chain.head;
5987 f = (lang_input_statement_type *) f->next_real_file)
5991 /* Call a function on each file. The function will be called on all
5992 the elements of an archive which are included in the link, but will
5993 not be called on the archive file itself. */
5996 lang_for_each_file (void (*func) (lang_input_statement_type *))
5998 LANG_FOR_EACH_INPUT_STATEMENT (f)
6005 ldlang_add_file (lang_input_statement_type *entry)
6007 lang_statement_append (&file_chain,
6008 (lang_statement_union_type *) entry,
6011 /* The BFD linker needs to have a list of all input BFDs involved in
6013 ASSERT (entry->the_bfd->link_next == NULL);
6014 ASSERT (entry->the_bfd != link_info.output_bfd);
6016 *link_info.input_bfds_tail = entry->the_bfd;
6017 link_info.input_bfds_tail = &entry->the_bfd->link_next;
6018 entry->the_bfd->usrdata = entry;
6019 bfd_set_gp_size (entry->the_bfd, g_switch_value);
6021 /* Look through the sections and check for any which should not be
6022 included in the link. We need to do this now, so that we can
6023 notice when the backend linker tries to report multiple
6024 definition errors for symbols which are in sections we aren't
6025 going to link. FIXME: It might be better to entirely ignore
6026 symbols which are defined in sections which are going to be
6027 discarded. This would require modifying the backend linker for
6028 each backend which might set the SEC_LINK_ONCE flag. If we do
6029 this, we should probably handle SEC_EXCLUDE in the same way. */
6031 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
6035 lang_add_output (const char *name, int from_script)
6037 /* Make -o on command line override OUTPUT in script. */
6038 if (!had_output_filename || !from_script)
6040 output_filename = name;
6041 had_output_filename = TRUE;
6045 static lang_output_section_statement_type *current_section;
6056 for (l = 0; l < 32; l++)
6058 if (i >= (unsigned int) x)
6066 lang_output_section_statement_type *
6067 lang_enter_output_section_statement (const char *output_section_statement_name,
6068 etree_type *address_exp,
6069 enum section_type sectype,
6071 etree_type *subalign,
6075 lang_output_section_statement_type *os;
6077 os = lang_output_section_statement_lookup (output_section_statement_name,
6079 current_section = os;
6081 if (os->addr_tree == NULL)
6083 os->addr_tree = address_exp;
6085 os->sectype = sectype;
6086 if (sectype != noload_section)
6087 os->flags = SEC_NO_FLAGS;
6089 os->flags = SEC_NEVER_LOAD;
6090 os->block_value = 1;
6092 /* Make next things chain into subchain of this. */
6093 push_stat_ptr (&os->children);
6095 os->subsection_alignment =
6096 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
6097 os->section_alignment =
6098 topower (exp_get_value_int (align, -1, "section alignment"));
6100 os->load_base = ebase;
6107 lang_output_statement_type *new_stmt;
6109 new_stmt = new_stat (lang_output_statement, stat_ptr);
6110 new_stmt->name = output_filename;
6114 /* Reset the current counters in the regions. */
6117 lang_reset_memory_regions (void)
6119 lang_memory_region_type *p = lang_memory_region_list;
6121 lang_output_section_statement_type *os;
6123 for (p = lang_memory_region_list; p != NULL; p = p->next)
6125 p->current = p->origin;
6129 for (os = &lang_output_section_statement.head->output_section_statement;
6133 os->processed_vma = FALSE;
6134 os->processed_lma = FALSE;
6137 for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
6139 /* Save the last size for possible use by bfd_relax_section. */
6140 o->rawsize = o->size;
6145 /* Worker for lang_gc_sections_1. */
6148 gc_section_callback (lang_wild_statement_type *ptr,
6149 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6151 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6152 void *data ATTRIBUTE_UNUSED)
6154 /* If the wild pattern was marked KEEP, the member sections
6155 should be as well. */
6156 if (ptr->keep_sections)
6157 section->flags |= SEC_KEEP;
6160 /* Iterate over sections marking them against GC. */
6163 lang_gc_sections_1 (lang_statement_union_type *s)
6165 for (; s != NULL; s = s->header.next)
6167 switch (s->header.type)
6169 case lang_wild_statement_enum:
6170 walk_wild (&s->wild_statement, gc_section_callback, NULL);
6172 case lang_constructors_statement_enum:
6173 lang_gc_sections_1 (constructor_list.head);
6175 case lang_output_section_statement_enum:
6176 lang_gc_sections_1 (s->output_section_statement.children.head);
6178 case lang_group_statement_enum:
6179 lang_gc_sections_1 (s->group_statement.children.head);
6188 lang_gc_sections (void)
6190 /* Keep all sections so marked in the link script. */
6192 lang_gc_sections_1 (statement_list.head);
6194 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6195 the special case of debug info. (See bfd/stabs.c)
6196 Twiddle the flag here, to simplify later linker code. */
6197 if (link_info.relocatable)
6199 LANG_FOR_EACH_INPUT_STATEMENT (f)
6202 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6203 if ((sec->flags & SEC_DEBUGGING) == 0)
6204 sec->flags &= ~SEC_EXCLUDE;
6208 if (link_info.gc_sections)
6209 bfd_gc_sections (link_info.output_bfd, &link_info);
6212 /* Worker for lang_find_relro_sections_1. */
6215 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6216 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6218 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6221 /* Discarded, excluded and ignored sections effectively have zero
6223 if (section->output_section != NULL
6224 && section->output_section->owner == link_info.output_bfd
6225 && (section->output_section->flags & SEC_EXCLUDE) == 0
6226 && !IGNORE_SECTION (section)
6227 && section->size != 0)
6229 bfd_boolean *has_relro_section = (bfd_boolean *) data;
6230 *has_relro_section = TRUE;
6234 /* Iterate over sections for relro sections. */
6237 lang_find_relro_sections_1 (lang_statement_union_type *s,
6238 bfd_boolean *has_relro_section)
6240 if (*has_relro_section)
6243 for (; s != NULL; s = s->header.next)
6245 if (s == expld.dataseg.relro_end_stat)
6248 switch (s->header.type)
6250 case lang_wild_statement_enum:
6251 walk_wild (&s->wild_statement,
6252 find_relro_section_callback,
6255 case lang_constructors_statement_enum:
6256 lang_find_relro_sections_1 (constructor_list.head,
6259 case lang_output_section_statement_enum:
6260 lang_find_relro_sections_1 (s->output_section_statement.children.head,
6263 case lang_group_statement_enum:
6264 lang_find_relro_sections_1 (s->group_statement.children.head,
6274 lang_find_relro_sections (void)
6276 bfd_boolean has_relro_section = FALSE;
6278 /* Check all sections in the link script. */
6280 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6281 &has_relro_section);
6283 if (!has_relro_section)
6284 link_info.relro = FALSE;
6287 /* Relax all sections until bfd_relax_section gives up. */
6290 lang_relax_sections (bfd_boolean need_layout)
6292 if (RELAXATION_ENABLED)
6294 /* We may need more than one relaxation pass. */
6295 int i = link_info.relax_pass;
6297 /* The backend can use it to determine the current pass. */
6298 link_info.relax_pass = 0;
6302 /* Keep relaxing until bfd_relax_section gives up. */
6303 bfd_boolean relax_again;
6305 link_info.relax_trip = -1;
6308 link_info.relax_trip++;
6310 /* Note: pe-dll.c does something like this also. If you find
6311 you need to change this code, you probably need to change
6312 pe-dll.c also. DJ */
6314 /* Do all the assignments with our current guesses as to
6316 lang_do_assignments ();
6318 /* We must do this after lang_do_assignments, because it uses
6320 lang_reset_memory_regions ();
6322 /* Perform another relax pass - this time we know where the
6323 globals are, so can make a better guess. */
6324 relax_again = FALSE;
6325 lang_size_sections (&relax_again, FALSE);
6327 while (relax_again);
6329 link_info.relax_pass++;
6336 /* Final extra sizing to report errors. */
6337 lang_do_assignments ();
6338 lang_reset_memory_regions ();
6339 lang_size_sections (NULL, TRUE);
6346 /* Finalize dynamic list. */
6347 if (link_info.dynamic_list)
6348 lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6350 current_target = default_target;
6352 /* Open the output file. */
6353 lang_for_each_statement (ldlang_open_output);
6356 ldemul_create_output_section_statements ();
6358 /* Add to the hash table all undefineds on the command line. */
6359 lang_place_undefineds ();
6361 if (!bfd_section_already_linked_table_init ())
6362 einfo (_("%P%F: Failed to create hash table\n"));
6364 /* Create a bfd for each input file. */
6365 current_target = default_target;
6366 open_input_bfds (statement_list.head, FALSE);
6368 #ifdef ENABLE_PLUGINS
6370 union lang_statement_union **listend;
6371 /* Now all files are read, let the plugin(s) decide if there
6372 are any more to be added to the link before we call the
6373 emulation's after_open hook. */
6374 listend = statement_list.tail;
6376 if (plugin_call_all_symbols_read ())
6377 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6378 plugin_error_plugin ());
6379 /* If any new files were added, they will be on the end of the
6380 statement list, and we can open them now by getting open_input_bfds
6381 to carry on from where it ended last time. */
6383 open_input_bfds (*listend, FALSE);
6385 #endif /* ENABLE_PLUGINS */
6387 link_info.gc_sym_list = &entry_symbol;
6388 if (entry_symbol.name == NULL)
6389 link_info.gc_sym_list = ldlang_undef_chain_list_head;
6391 ldemul_after_open ();
6393 bfd_section_already_linked_table_free ();
6395 /* Make sure that we're not mixing architectures. We call this
6396 after all the input files have been opened, but before we do any
6397 other processing, so that any operations merge_private_bfd_data
6398 does on the output file will be known during the rest of the
6402 /* Handle .exports instead of a version script if we're told to do so. */
6403 if (command_line.version_exports_section)
6404 lang_do_version_exports_section ();
6406 /* Build all sets based on the information gathered from the input
6408 ldctor_build_sets ();
6410 /* Remove unreferenced sections if asked to. */
6411 lang_gc_sections ();
6413 /* Size up the common data. */
6416 /* Update wild statements. */
6417 update_wild_statements (statement_list.head);
6419 /* Run through the contours of the script and attach input sections
6420 to the correct output sections. */
6421 lang_statement_iteration++;
6422 map_input_to_output_sections (statement_list.head, NULL, NULL);
6424 process_insert_statements ();
6426 /* Find any sections not attached explicitly and handle them. */
6427 lang_place_orphans ();
6429 if (! link_info.relocatable)
6433 /* Merge SEC_MERGE sections. This has to be done after GC of
6434 sections, so that GCed sections are not merged, but before
6435 assigning dynamic symbols, since removing whole input sections
6437 bfd_merge_sections (link_info.output_bfd, &link_info);
6439 /* Look for a text section and set the readonly attribute in it. */
6440 found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6444 if (config.text_read_only)
6445 found->flags |= SEC_READONLY;
6447 found->flags &= ~SEC_READONLY;
6451 /* Do anything special before sizing sections. This is where ELF
6452 and other back-ends size dynamic sections. */
6453 ldemul_before_allocation ();
6455 /* We must record the program headers before we try to fix the
6456 section positions, since they will affect SIZEOF_HEADERS. */
6457 lang_record_phdrs ();
6459 /* Check relro sections. */
6460 if (link_info.relro && ! link_info.relocatable)
6461 lang_find_relro_sections ();
6463 /* Size up the sections. */
6464 lang_size_sections (NULL, ! RELAXATION_ENABLED);
6466 /* See if anything special should be done now we know how big
6467 everything is. This is where relaxation is done. */
6468 ldemul_after_allocation ();
6470 /* Fix any .startof. or .sizeof. symbols. */
6471 lang_set_startof ();
6473 /* Do all the assignments, now that we know the final resting places
6474 of all the symbols. */
6475 expld.phase = lang_final_phase_enum;
6476 lang_do_assignments ();
6480 /* Make sure that the section addresses make sense. */
6481 if (command_line.check_section_addresses)
6482 lang_check_section_addresses ();
6487 /* EXPORTED TO YACC */
6490 lang_add_wild (struct wildcard_spec *filespec,
6491 struct wildcard_list *section_list,
6492 bfd_boolean keep_sections)
6494 struct wildcard_list *curr, *next;
6495 lang_wild_statement_type *new_stmt;
6497 /* Reverse the list as the parser puts it back to front. */
6498 for (curr = section_list, section_list = NULL;
6500 section_list = curr, curr = next)
6502 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6503 placed_commons = TRUE;
6506 curr->next = section_list;
6509 if (filespec != NULL && filespec->name != NULL)
6511 if (strcmp (filespec->name, "*") == 0)
6512 filespec->name = NULL;
6513 else if (! wildcardp (filespec->name))
6514 lang_has_input_file = TRUE;
6517 new_stmt = new_stat (lang_wild_statement, stat_ptr);
6518 new_stmt->filename = NULL;
6519 new_stmt->filenames_sorted = FALSE;
6520 if (filespec != NULL)
6522 new_stmt->filename = filespec->name;
6523 new_stmt->filenames_sorted = filespec->sorted == by_name;
6525 new_stmt->section_list = section_list;
6526 new_stmt->keep_sections = keep_sections;
6527 lang_list_init (&new_stmt->children);
6528 analyze_walk_wild_section_handler (new_stmt);
6532 lang_section_start (const char *name, etree_type *address,
6533 const segment_type *segment)
6535 lang_address_statement_type *ad;
6537 ad = new_stat (lang_address_statement, stat_ptr);
6538 ad->section_name = name;
6539 ad->address = address;
6540 ad->segment = segment;
6543 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6544 because of a -e argument on the command line, or zero if this is
6545 called by ENTRY in a linker script. Command line arguments take
6549 lang_add_entry (const char *name, bfd_boolean cmdline)
6551 if (entry_symbol.name == NULL
6553 || ! entry_from_cmdline)
6555 entry_symbol.name = name;
6556 entry_from_cmdline = cmdline;
6560 /* Set the default start symbol to NAME. .em files should use this,
6561 not lang_add_entry, to override the use of "start" if neither the
6562 linker script nor the command line specifies an entry point. NAME
6563 must be permanently allocated. */
6565 lang_default_entry (const char *name)
6567 entry_symbol_default = name;
6571 lang_add_target (const char *name)
6573 lang_target_statement_type *new_stmt;
6575 new_stmt = new_stat (lang_target_statement, stat_ptr);
6576 new_stmt->target = name;
6580 lang_add_map (const char *name)
6587 map_option_f = TRUE;
6595 lang_add_fill (fill_type *fill)
6597 lang_fill_statement_type *new_stmt;
6599 new_stmt = new_stat (lang_fill_statement, stat_ptr);
6600 new_stmt->fill = fill;
6604 lang_add_data (int type, union etree_union *exp)
6606 lang_data_statement_type *new_stmt;
6608 new_stmt = new_stat (lang_data_statement, stat_ptr);
6609 new_stmt->exp = exp;
6610 new_stmt->type = type;
6613 /* Create a new reloc statement. RELOC is the BFD relocation type to
6614 generate. HOWTO is the corresponding howto structure (we could
6615 look this up, but the caller has already done so). SECTION is the
6616 section to generate a reloc against, or NAME is the name of the
6617 symbol to generate a reloc against. Exactly one of SECTION and
6618 NAME must be NULL. ADDEND is an expression for the addend. */
6621 lang_add_reloc (bfd_reloc_code_real_type reloc,
6622 reloc_howto_type *howto,
6625 union etree_union *addend)
6627 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6631 p->section = section;
6633 p->addend_exp = addend;
6635 p->addend_value = 0;
6636 p->output_section = NULL;
6637 p->output_offset = 0;
6640 lang_assignment_statement_type *
6641 lang_add_assignment (etree_type *exp)
6643 lang_assignment_statement_type *new_stmt;
6645 new_stmt = new_stat (lang_assignment_statement, stat_ptr);
6646 new_stmt->exp = exp;
6651 lang_add_attribute (enum statement_enum attribute)
6653 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6657 lang_startup (const char *name)
6659 if (startup_file != NULL)
6661 einfo (_("%P%F: multiple STARTUP files\n"));
6663 first_file->filename = name;
6664 first_file->local_sym_name = name;
6665 first_file->real = TRUE;
6667 startup_file = name;
6671 lang_float (bfd_boolean maybe)
6673 lang_float_flag = maybe;
6677 /* Work out the load- and run-time regions from a script statement, and
6678 store them in *LMA_REGION and *REGION respectively.
6680 MEMSPEC is the name of the run-time region, or the value of
6681 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6682 LMA_MEMSPEC is the name of the load-time region, or null if the
6683 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6684 had an explicit load address.
6686 It is an error to specify both a load region and a load address. */
6689 lang_get_regions (lang_memory_region_type **region,
6690 lang_memory_region_type **lma_region,
6691 const char *memspec,
6692 const char *lma_memspec,
6693 bfd_boolean have_lma,
6694 bfd_boolean have_vma)
6696 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6698 /* If no runtime region or VMA has been specified, but the load region
6699 has been specified, then use the load region for the runtime region
6701 if (lma_memspec != NULL
6703 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6704 *region = *lma_region;
6706 *region = lang_memory_region_lookup (memspec, FALSE);
6708 if (have_lma && lma_memspec != 0)
6709 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6713 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6714 lang_output_section_phdr_list *phdrs,
6715 const char *lma_memspec)
6717 lang_get_regions (¤t_section->region,
6718 ¤t_section->lma_region,
6719 memspec, lma_memspec,
6720 current_section->load_base != NULL,
6721 current_section->addr_tree != NULL);
6723 /* If this section has no load region or base, but has the same
6724 region as the previous section, then propagate the previous
6725 section's load region. */
6727 if (!current_section->lma_region && !current_section->load_base
6728 && current_section->region == current_section->prev->region)
6729 current_section->lma_region = current_section->prev->lma_region;
6731 current_section->fill = fill;
6732 current_section->phdrs = phdrs;
6736 /* Create an absolute symbol with the given name with the value of the
6737 address of first byte of the section named.
6739 If the symbol already exists, then do nothing. */
6742 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6744 struct bfd_link_hash_entry *h;
6746 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6748 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6750 if (h->type == bfd_link_hash_new
6751 || h->type == bfd_link_hash_undefined)
6755 h->type = bfd_link_hash_defined;
6757 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6761 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
6763 h->u.def.section = bfd_abs_section_ptr;
6767 /* Create an absolute symbol with the given name with the value of the
6768 address of the first byte after the end of the section named.
6770 If the symbol already exists, then do nothing. */
6773 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6775 struct bfd_link_hash_entry *h;
6777 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6779 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6781 if (h->type == bfd_link_hash_new
6782 || h->type == bfd_link_hash_undefined)
6786 h->type = bfd_link_hash_defined;
6788 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6792 h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
6793 + TO_ADDR (sec->size));
6795 h->u.def.section = bfd_abs_section_ptr;
6800 lang_statement_append (lang_statement_list_type *list,
6801 lang_statement_union_type *element,
6802 lang_statement_union_type **field)
6804 *(list->tail) = element;
6808 /* Set the output format type. -oformat overrides scripts. */
6811 lang_add_output_format (const char *format,
6816 if (output_target == NULL || !from_script)
6818 if (command_line.endian == ENDIAN_BIG
6821 else if (command_line.endian == ENDIAN_LITTLE
6825 output_target = format;
6830 lang_add_insert (const char *where, int is_before)
6832 lang_insert_statement_type *new_stmt;
6834 new_stmt = new_stat (lang_insert_statement, stat_ptr);
6835 new_stmt->where = where;
6836 new_stmt->is_before = is_before;
6837 saved_script_handle = previous_script_handle;
6840 /* Enter a group. This creates a new lang_group_statement, and sets
6841 stat_ptr to build new statements within the group. */
6844 lang_enter_group (void)
6846 lang_group_statement_type *g;
6848 g = new_stat (lang_group_statement, stat_ptr);
6849 lang_list_init (&g->children);
6850 push_stat_ptr (&g->children);
6853 /* Leave a group. This just resets stat_ptr to start writing to the
6854 regular list of statements again. Note that this will not work if
6855 groups can occur inside anything else which can adjust stat_ptr,
6856 but currently they can't. */
6859 lang_leave_group (void)
6864 /* Add a new program header. This is called for each entry in a PHDRS
6865 command in a linker script. */
6868 lang_new_phdr (const char *name,
6870 bfd_boolean filehdr,
6875 struct lang_phdr *n, **pp;
6878 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
6881 n->type = exp_get_value_int (type, 0, "program header type");
6882 n->filehdr = filehdr;
6887 hdrs = n->type == 1 && (phdrs || filehdr);
6889 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6892 && !((*pp)->filehdr || (*pp)->phdrs))
6894 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));
6901 /* Record the program header information in the output BFD. FIXME: We
6902 should not be calling an ELF specific function here. */
6905 lang_record_phdrs (void)
6909 lang_output_section_phdr_list *last;
6910 struct lang_phdr *l;
6911 lang_output_section_statement_type *os;
6914 secs = (asection **) xmalloc (alc * sizeof (asection *));
6917 for (l = lang_phdr_list; l != NULL; l = l->next)
6924 for (os = &lang_output_section_statement.head->output_section_statement;
6928 lang_output_section_phdr_list *pl;
6930 if (os->constraint < 0)
6938 if (os->sectype == noload_section
6939 || os->bfd_section == NULL
6940 || (os->bfd_section->flags & SEC_ALLOC) == 0)
6943 /* Don't add orphans to PT_INTERP header. */
6949 lang_output_section_statement_type * tmp_os;
6951 /* If we have not run across a section with a program
6952 header assigned to it yet, then scan forwards to find
6953 one. This prevents inconsistencies in the linker's
6954 behaviour when a script has specified just a single
6955 header and there are sections in that script which are
6956 not assigned to it, and which occur before the first
6957 use of that header. See here for more details:
6958 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6959 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6962 last = tmp_os->phdrs;
6966 einfo (_("%F%P: no sections assigned to phdrs\n"));
6971 if (os->bfd_section == NULL)
6974 for (; pl != NULL; pl = pl->next)
6976 if (strcmp (pl->name, l->name) == 0)
6981 secs = (asection **) xrealloc (secs,
6982 alc * sizeof (asection *));
6984 secs[c] = os->bfd_section;
6991 if (l->flags == NULL)
6994 flags = exp_get_vma (l->flags, 0, "phdr flags");
6999 at = exp_get_vma (l->at, 0, "phdr load address");
7001 if (! bfd_record_phdr (link_info.output_bfd, l->type,
7002 l->flags != NULL, flags, l->at != NULL,
7003 at, l->filehdr, l->phdrs, c, secs))
7004 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7009 /* Make sure all the phdr assignments succeeded. */
7010 for (os = &lang_output_section_statement.head->output_section_statement;
7014 lang_output_section_phdr_list *pl;
7016 if (os->constraint < 0
7017 || os->bfd_section == NULL)
7020 for (pl = os->phdrs;
7023 if (! pl->used && strcmp (pl->name, "NONE") != 0)
7024 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7025 os->name, pl->name);
7029 /* Record a list of sections which may not be cross referenced. */
7032 lang_add_nocrossref (lang_nocrossref_type *l)
7034 struct lang_nocrossrefs *n;
7036 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
7037 n->next = nocrossref_list;
7039 nocrossref_list = n;
7041 /* Set notice_all so that we get informed about all symbols. */
7042 link_info.notice_all = TRUE;
7045 /* Overlay handling. We handle overlays with some static variables. */
7047 /* The overlay virtual address. */
7048 static etree_type *overlay_vma;
7049 /* And subsection alignment. */
7050 static etree_type *overlay_subalign;
7052 /* An expression for the maximum section size seen so far. */
7053 static etree_type *overlay_max;
7055 /* A list of all the sections in this overlay. */
7057 struct overlay_list {
7058 struct overlay_list *next;
7059 lang_output_section_statement_type *os;
7062 static struct overlay_list *overlay_list;
7064 /* Start handling an overlay. */
7067 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
7069 /* The grammar should prevent nested overlays from occurring. */
7070 ASSERT (overlay_vma == NULL
7071 && overlay_subalign == NULL
7072 && overlay_max == NULL);
7074 overlay_vma = vma_expr;
7075 overlay_subalign = subalign;
7078 /* Start a section in an overlay. We handle this by calling
7079 lang_enter_output_section_statement with the correct VMA.
7080 lang_leave_overlay sets up the LMA and memory regions. */
7083 lang_enter_overlay_section (const char *name)
7085 struct overlay_list *n;
7088 lang_enter_output_section_statement (name, overlay_vma, overlay_section,
7089 0, overlay_subalign, 0, 0);
7091 /* If this is the first section, then base the VMA of future
7092 sections on this one. This will work correctly even if `.' is
7093 used in the addresses. */
7094 if (overlay_list == NULL)
7095 overlay_vma = exp_nameop (ADDR, name);
7097 /* Remember the section. */
7098 n = (struct overlay_list *) xmalloc (sizeof *n);
7099 n->os = current_section;
7100 n->next = overlay_list;
7103 size = exp_nameop (SIZEOF, name);
7105 /* Arrange to work out the maximum section end address. */
7106 if (overlay_max == NULL)
7109 overlay_max = exp_binop (MAX_K, overlay_max, size);
7112 /* Finish a section in an overlay. There isn't any special to do
7116 lang_leave_overlay_section (fill_type *fill,
7117 lang_output_section_phdr_list *phdrs)
7124 name = current_section->name;
7126 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7127 region and that no load-time region has been specified. It doesn't
7128 really matter what we say here, since lang_leave_overlay will
7130 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
7132 /* Define the magic symbols. */
7134 clean = (char *) xmalloc (strlen (name) + 1);
7136 for (s1 = name; *s1 != '\0'; s1++)
7137 if (ISALNUM (*s1) || *s1 == '_')
7141 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
7142 sprintf (buf, "__load_start_%s", clean);
7143 lang_add_assignment (exp_provide (buf,
7144 exp_nameop (LOADADDR, name),
7147 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
7148 sprintf (buf, "__load_stop_%s", clean);
7149 lang_add_assignment (exp_provide (buf,
7151 exp_nameop (LOADADDR, name),
7152 exp_nameop (SIZEOF, name)),
7158 /* Finish an overlay. If there are any overlay wide settings, this
7159 looks through all the sections in the overlay and sets them. */
7162 lang_leave_overlay (etree_type *lma_expr,
7165 const char *memspec,
7166 lang_output_section_phdr_list *phdrs,
7167 const char *lma_memspec)
7169 lang_memory_region_type *region;
7170 lang_memory_region_type *lma_region;
7171 struct overlay_list *l;
7172 lang_nocrossref_type *nocrossref;
7174 lang_get_regions (®ion, &lma_region,
7175 memspec, lma_memspec,
7176 lma_expr != NULL, FALSE);
7180 /* After setting the size of the last section, set '.' to end of the
7182 if (overlay_list != NULL)
7183 overlay_list->os->update_dot_tree
7184 = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));
7189 struct overlay_list *next;
7191 if (fill != NULL && l->os->fill == NULL)
7194 l->os->region = region;
7195 l->os->lma_region = lma_region;
7197 /* The first section has the load address specified in the
7198 OVERLAY statement. The rest are worked out from that.
7199 The base address is not needed (and should be null) if
7200 an LMA region was specified. */
7203 l->os->load_base = lma_expr;
7204 l->os->sectype = normal_section;
7206 if (phdrs != NULL && l->os->phdrs == NULL)
7207 l->os->phdrs = phdrs;
7211 lang_nocrossref_type *nc;
7213 nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
7214 nc->name = l->os->name;
7215 nc->next = nocrossref;
7224 if (nocrossref != NULL)
7225 lang_add_nocrossref (nocrossref);
7228 overlay_list = NULL;
7232 /* Version handling. This is only useful for ELF. */
7234 /* This global variable holds the version tree that we build. */
7236 struct bfd_elf_version_tree *lang_elf_version_info;
7238 /* If PREV is NULL, return first version pattern matching particular symbol.
7239 If PREV is non-NULL, return first version pattern matching particular
7240 symbol after PREV (previously returned by lang_vers_match). */
7242 static struct bfd_elf_version_expr *
7243 lang_vers_match (struct bfd_elf_version_expr_head *head,
7244 struct bfd_elf_version_expr *prev,
7247 const char *cxx_sym = sym;
7248 const char *java_sym = sym;
7249 struct bfd_elf_version_expr *expr = NULL;
7251 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7253 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
7257 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7259 java_sym = cplus_demangle (sym, DMGL_JAVA);
7264 if (head->htab && (prev == NULL || prev->literal))
7266 struct bfd_elf_version_expr e;
7268 switch (prev ? prev->mask : 0)
7271 if (head->mask & BFD_ELF_VERSION_C_TYPE)
7274 expr = (struct bfd_elf_version_expr *)
7275 htab_find ((htab_t) head->htab, &e);
7276 while (expr && strcmp (expr->pattern, sym) == 0)
7277 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7283 case BFD_ELF_VERSION_C_TYPE:
7284 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7286 e.pattern = cxx_sym;
7287 expr = (struct bfd_elf_version_expr *)
7288 htab_find ((htab_t) head->htab, &e);
7289 while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7290 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7296 case BFD_ELF_VERSION_CXX_TYPE:
7297 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7299 e.pattern = java_sym;
7300 expr = (struct bfd_elf_version_expr *)
7301 htab_find ((htab_t) head->htab, &e);
7302 while (expr && strcmp (expr->pattern, java_sym) == 0)
7303 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7314 /* Finally, try the wildcards. */
7315 if (prev == NULL || prev->literal)
7316 expr = head->remaining;
7319 for (; expr; expr = expr->next)
7326 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7329 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7331 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7335 if (fnmatch (expr->pattern, s, 0) == 0)
7341 free ((char *) cxx_sym);
7342 if (java_sym != sym)
7343 free ((char *) java_sym);
7347 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7348 return a pointer to the symbol name with any backslash quotes removed. */
7351 realsymbol (const char *pattern)
7354 bfd_boolean changed = FALSE, backslash = FALSE;
7355 char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
7357 for (p = pattern, s = symbol; *p != '\0'; ++p)
7359 /* It is a glob pattern only if there is no preceding
7363 /* Remove the preceding backslash. */
7370 if (*p == '?' || *p == '*' || *p == '[')
7377 backslash = *p == '\\';
7393 /* This is called for each variable name or match expression. NEW_NAME is
7394 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7395 pattern to be matched against symbol names. */
7397 struct bfd_elf_version_expr *
7398 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7399 const char *new_name,
7401 bfd_boolean literal_p)
7403 struct bfd_elf_version_expr *ret;
7405 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
7409 ret->literal = TRUE;
7410 ret->pattern = literal_p ? new_name : realsymbol (new_name);
7411 if (ret->pattern == NULL)
7413 ret->pattern = new_name;
7414 ret->literal = FALSE;
7417 if (lang == NULL || strcasecmp (lang, "C") == 0)
7418 ret->mask = BFD_ELF_VERSION_C_TYPE;
7419 else if (strcasecmp (lang, "C++") == 0)
7420 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7421 else if (strcasecmp (lang, "Java") == 0)
7422 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7425 einfo (_("%X%P: unknown language `%s' in version information\n"),
7427 ret->mask = BFD_ELF_VERSION_C_TYPE;
7430 return ldemul_new_vers_pattern (ret);
7433 /* This is called for each set of variable names and match
7436 struct bfd_elf_version_tree *
7437 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7438 struct bfd_elf_version_expr *locals)
7440 struct bfd_elf_version_tree *ret;
7442 ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
7443 ret->globals.list = globals;
7444 ret->locals.list = locals;
7445 ret->match = lang_vers_match;
7446 ret->name_indx = (unsigned int) -1;
7450 /* This static variable keeps track of version indices. */
7452 static int version_index;
7455 version_expr_head_hash (const void *p)
7457 const struct bfd_elf_version_expr *e =
7458 (const struct bfd_elf_version_expr *) p;
7460 return htab_hash_string (e->pattern);
7464 version_expr_head_eq (const void *p1, const void *p2)
7466 const struct bfd_elf_version_expr *e1 =
7467 (const struct bfd_elf_version_expr *) p1;
7468 const struct bfd_elf_version_expr *e2 =
7469 (const struct bfd_elf_version_expr *) p2;
7471 return strcmp (e1->pattern, e2->pattern) == 0;
7475 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7478 struct bfd_elf_version_expr *e, *next;
7479 struct bfd_elf_version_expr **list_loc, **remaining_loc;
7481 for (e = head->list; e; e = e->next)
7485 head->mask |= e->mask;
7490 head->htab = htab_create (count * 2, version_expr_head_hash,
7491 version_expr_head_eq, NULL);
7492 list_loc = &head->list;
7493 remaining_loc = &head->remaining;
7494 for (e = head->list; e; e = next)
7500 remaining_loc = &e->next;
7504 void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
7508 struct bfd_elf_version_expr *e1, *last;
7510 e1 = (struct bfd_elf_version_expr *) *loc;
7514 if (e1->mask == e->mask)
7522 while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7526 /* This is a duplicate. */
7527 /* FIXME: Memory leak. Sometimes pattern is not
7528 xmalloced alone, but in larger chunk of memory. */
7529 /* free (e->pattern); */
7534 e->next = last->next;
7542 list_loc = &e->next;
7546 *remaining_loc = NULL;
7547 *list_loc = head->remaining;
7550 head->remaining = head->list;
7553 /* This is called when we know the name and dependencies of the
7557 lang_register_vers_node (const char *name,
7558 struct bfd_elf_version_tree *version,
7559 struct bfd_elf_version_deps *deps)
7561 struct bfd_elf_version_tree *t, **pp;
7562 struct bfd_elf_version_expr *e1;
7567 if ((name[0] == '\0' && lang_elf_version_info != NULL)
7568 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
7570 einfo (_("%X%P: anonymous version tag cannot be combined"
7571 " with other version tags\n"));
7576 /* Make sure this node has a unique name. */
7577 for (t = lang_elf_version_info; t != NULL; t = t->next)
7578 if (strcmp (t->name, name) == 0)
7579 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7581 lang_finalize_version_expr_head (&version->globals);
7582 lang_finalize_version_expr_head (&version->locals);
7584 /* Check the global and local match names, and make sure there
7585 aren't any duplicates. */
7587 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7589 for (t = lang_elf_version_info; t != NULL; t = t->next)
7591 struct bfd_elf_version_expr *e2;
7593 if (t->locals.htab && e1->literal)
7595 e2 = (struct bfd_elf_version_expr *)
7596 htab_find ((htab_t) t->locals.htab, e1);
7597 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7599 if (e1->mask == e2->mask)
7600 einfo (_("%X%P: duplicate expression `%s'"
7601 " in version information\n"), e1->pattern);
7605 else if (!e1->literal)
7606 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7607 if (strcmp (e1->pattern, e2->pattern) == 0
7608 && e1->mask == e2->mask)
7609 einfo (_("%X%P: duplicate expression `%s'"
7610 " in version information\n"), e1->pattern);
7614 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7616 for (t = lang_elf_version_info; t != NULL; t = t->next)
7618 struct bfd_elf_version_expr *e2;
7620 if (t->globals.htab && e1->literal)
7622 e2 = (struct bfd_elf_version_expr *)
7623 htab_find ((htab_t) t->globals.htab, e1);
7624 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7626 if (e1->mask == e2->mask)
7627 einfo (_("%X%P: duplicate expression `%s'"
7628 " in version information\n"),
7633 else if (!e1->literal)
7634 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7635 if (strcmp (e1->pattern, e2->pattern) == 0
7636 && e1->mask == e2->mask)
7637 einfo (_("%X%P: duplicate expression `%s'"
7638 " in version information\n"), e1->pattern);
7642 version->deps = deps;
7643 version->name = name;
7644 if (name[0] != '\0')
7647 version->vernum = version_index;
7650 version->vernum = 0;
7652 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7657 /* This is called when we see a version dependency. */
7659 struct bfd_elf_version_deps *
7660 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7662 struct bfd_elf_version_deps *ret;
7663 struct bfd_elf_version_tree *t;
7665 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
7668 for (t = lang_elf_version_info; t != NULL; t = t->next)
7670 if (strcmp (t->name, name) == 0)
7672 ret->version_needed = t;
7677 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7679 ret->version_needed = NULL;
7684 lang_do_version_exports_section (void)
7686 struct bfd_elf_version_expr *greg = NULL, *lreg;
7688 LANG_FOR_EACH_INPUT_STATEMENT (is)
7690 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7698 contents = (char *) xmalloc (len);
7699 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7700 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7703 while (p < contents + len)
7705 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7706 p = strchr (p, '\0') + 1;
7709 /* Do not free the contents, as we used them creating the regex. */
7711 /* Do not include this section in the link. */
7712 sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7715 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7716 lang_register_vers_node (command_line.version_exports_section,
7717 lang_new_vers_node (greg, lreg), NULL);
7721 lang_add_unique (const char *name)
7723 struct unique_sections *ent;
7725 for (ent = unique_section_list; ent; ent = ent->next)
7726 if (strcmp (ent->name, name) == 0)
7729 ent = (struct unique_sections *) xmalloc (sizeof *ent);
7730 ent->name = xstrdup (name);
7731 ent->next = unique_section_list;
7732 unique_section_list = ent;
7735 /* Append the list of dynamic symbols to the existing one. */
7738 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7740 if (link_info.dynamic_list)
7742 struct bfd_elf_version_expr *tail;
7743 for (tail = dynamic; tail->next != NULL; tail = tail->next)
7745 tail->next = link_info.dynamic_list->head.list;
7746 link_info.dynamic_list->head.list = dynamic;
7750 struct bfd_elf_dynamic_list *d;
7752 d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
7753 d->head.list = dynamic;
7754 d->match = lang_vers_match;
7755 link_info.dynamic_list = d;
7759 /* Append the list of C++ typeinfo dynamic symbols to the existing
7763 lang_append_dynamic_list_cpp_typeinfo (void)
7765 const char * symbols [] =
7767 "typeinfo name for*",
7770 struct bfd_elf_version_expr *dynamic = NULL;
7773 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7774 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7777 lang_append_dynamic_list (dynamic);
7780 /* Append the list of C++ operator new and delete dynamic symbols to the
7784 lang_append_dynamic_list_cpp_new (void)
7786 const char * symbols [] =
7791 struct bfd_elf_version_expr *dynamic = NULL;
7794 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7795 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7798 lang_append_dynamic_list (dynamic);
7801 /* Scan a space and/or comma separated string of features. */
7804 lang_ld_feature (char *str)
7812 while (*p == ',' || ISSPACE (*p))
7817 while (*q && *q != ',' && !ISSPACE (*q))
7821 if (strcasecmp (p, "SANE_EXPR") == 0)
7822 config.sane_expr = TRUE;
7824 einfo (_("%X%P: unknown feature `%s'\n"), p);