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 "filenames.h"
27 #include "safe-ctype.h"
47 #endif /* ENABLE_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Locals variables. */
54 static struct obstack stat_obstack;
55 static struct obstack map_obstack;
57 #define obstack_chunk_alloc xmalloc
58 #define obstack_chunk_free free
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 /* Return the numerical value of the init_priority attribute from
375 section name NAME. */
378 get_init_priority (const char *name)
381 unsigned long init_priority;
383 /* GCC uses the following section names for the init_priority
384 attribute with numerical values 101 and 65535 inclusive. A
385 lower value means a higher priority.
387 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
388 decimal numerical value of the init_priority attribute.
389 The order of execution in .init_array is forward and
390 .fini_array is backward.
391 2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the
392 decimal numerical value of the init_priority attribute.
393 The order of execution in .ctors is backward and .dtors
396 if (strncmp (name, ".init_array.", 12) == 0
397 || strncmp (name, ".fini_array.", 12) == 0)
399 init_priority = strtoul (name + 12, &end, 10);
400 return *end ? 0 : init_priority;
402 else if (strncmp (name, ".ctors.", 7) == 0
403 || strncmp (name, ".dtors.", 7) == 0)
405 init_priority = strtoul (name + 7, &end, 10);
406 return *end ? 0 : 65535 - init_priority;
412 /* Compare sections ASEC and BSEC according to SORT. */
415 compare_section (sort_type sort, asection *asec, asection *bsec)
418 unsigned long ainit_priority, binit_priority;
425 case by_init_priority:
427 = get_init_priority (bfd_get_section_name (asec->owner, asec));
429 = get_init_priority (bfd_get_section_name (bsec->owner, bsec));
430 if (ainit_priority == 0 || binit_priority == 0)
432 ret = ainit_priority - binit_priority;
438 case by_alignment_name:
439 ret = (bfd_section_alignment (bsec->owner, bsec)
440 - bfd_section_alignment (asec->owner, asec));
447 ret = strcmp (bfd_get_section_name (asec->owner, asec),
448 bfd_get_section_name (bsec->owner, bsec));
451 case by_name_alignment:
452 ret = strcmp (bfd_get_section_name (asec->owner, asec),
453 bfd_get_section_name (bsec->owner, bsec));
459 ret = (bfd_section_alignment (bsec->owner, bsec)
460 - bfd_section_alignment (asec->owner, asec));
467 /* Build a Binary Search Tree to sort sections, unlike insertion sort
468 used in wild_sort(). BST is considerably faster if the number of
469 of sections are large. */
471 static lang_section_bst_type **
472 wild_sort_fast (lang_wild_statement_type *wild,
473 struct wildcard_list *sec,
474 lang_input_statement_type *file ATTRIBUTE_UNUSED,
477 lang_section_bst_type **tree;
480 if (!wild->filenames_sorted
481 && (sec == NULL || sec->spec.sorted == none))
483 /* Append at the right end of tree. */
485 tree = &((*tree)->right);
491 /* Find the correct node to append this section. */
492 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
493 tree = &((*tree)->left);
495 tree = &((*tree)->right);
501 /* Use wild_sort_fast to build a BST to sort sections. */
504 output_section_callback_fast (lang_wild_statement_type *ptr,
505 struct wildcard_list *sec,
507 lang_input_statement_type *file,
510 lang_section_bst_type *node;
511 lang_section_bst_type **tree;
512 lang_output_section_statement_type *os;
514 os = (lang_output_section_statement_type *) output;
516 if (unique_section_p (section, os))
519 node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
522 node->section = section;
524 tree = wild_sort_fast (ptr, sec, file, section);
529 /* Convert a sorted sections' BST back to list form. */
532 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
533 lang_section_bst_type *tree,
537 output_section_callback_tree_to_list (ptr, tree->left, output);
539 lang_add_section (&ptr->children, tree->section,
540 (lang_output_section_statement_type *) output);
543 output_section_callback_tree_to_list (ptr, tree->right, output);
548 /* Specialized, optimized routines for handling different kinds of
552 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
553 lang_input_statement_type *file,
557 /* We can just do a hash lookup for the section with the right name.
558 But if that lookup discovers more than one section with the name
559 (should be rare), we fall back to the general algorithm because
560 we would otherwise have to sort the sections to make sure they
561 get processed in the bfd's order. */
562 bfd_boolean multiple_sections_found;
563 struct wildcard_list *sec0 = ptr->handler_data[0];
564 asection *s0 = find_section (file, sec0, &multiple_sections_found);
566 if (multiple_sections_found)
567 walk_wild_section_general (ptr, file, callback, data);
569 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
573 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
574 lang_input_statement_type *file,
579 struct wildcard_list *wildsec0 = ptr->handler_data[0];
581 for (s = file->the_bfd->sections; s != NULL; s = s->next)
583 const char *sname = bfd_get_section_name (file->the_bfd, s);
584 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
587 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
592 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
593 lang_input_statement_type *file,
598 struct wildcard_list *sec0 = ptr->handler_data[0];
599 struct wildcard_list *wildsec1 = ptr->handler_data[1];
600 bfd_boolean multiple_sections_found;
601 asection *s0 = find_section (file, sec0, &multiple_sections_found);
603 if (multiple_sections_found)
605 walk_wild_section_general (ptr, file, callback, data);
609 /* Note that if the section was not found, s0 is NULL and
610 we'll simply never succeed the s == s0 test below. */
611 for (s = file->the_bfd->sections; s != NULL; s = s->next)
613 /* Recall that in this code path, a section cannot satisfy more
614 than one spec, so if s == s0 then it cannot match
617 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
620 const char *sname = bfd_get_section_name (file->the_bfd, s);
621 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
624 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
631 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
632 lang_input_statement_type *file,
637 struct wildcard_list *sec0 = ptr->handler_data[0];
638 struct wildcard_list *wildsec1 = ptr->handler_data[1];
639 struct wildcard_list *wildsec2 = ptr->handler_data[2];
640 bfd_boolean multiple_sections_found;
641 asection *s0 = find_section (file, sec0, &multiple_sections_found);
643 if (multiple_sections_found)
645 walk_wild_section_general (ptr, file, callback, data);
649 for (s = file->the_bfd->sections; s != NULL; s = s->next)
652 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
655 const char *sname = bfd_get_section_name (file->the_bfd, s);
656 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
659 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
662 skip = !match_simple_wild (wildsec2->spec.name, sname);
664 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
672 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
673 lang_input_statement_type *file,
678 struct wildcard_list *sec0 = ptr->handler_data[0];
679 struct wildcard_list *sec1 = ptr->handler_data[1];
680 struct wildcard_list *wildsec2 = ptr->handler_data[2];
681 struct wildcard_list *wildsec3 = ptr->handler_data[3];
682 bfd_boolean multiple_sections_found;
683 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
685 if (multiple_sections_found)
687 walk_wild_section_general (ptr, file, callback, data);
691 s1 = find_section (file, sec1, &multiple_sections_found);
692 if (multiple_sections_found)
694 walk_wild_section_general (ptr, file, callback, data);
698 for (s = file->the_bfd->sections; s != NULL; s = s->next)
701 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
704 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
707 const char *sname = bfd_get_section_name (file->the_bfd, s);
708 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
712 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
716 skip = !match_simple_wild (wildsec3->spec.name, sname);
718 walk_wild_consider_section (ptr, file, s, wildsec3,
726 walk_wild_section (lang_wild_statement_type *ptr,
727 lang_input_statement_type *file,
731 if (file->just_syms_flag)
734 (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
737 /* Returns TRUE when name1 is a wildcard spec that might match
738 something name2 can match. We're conservative: we return FALSE
739 only if the prefixes of name1 and name2 are different up to the
740 first wildcard character. */
743 wild_spec_can_overlap (const char *name1, const char *name2)
745 size_t prefix1_len = strcspn (name1, "?*[");
746 size_t prefix2_len = strcspn (name2, "?*[");
747 size_t min_prefix_len;
749 /* Note that if there is no wildcard character, then we treat the
750 terminating 0 as part of the prefix. Thus ".text" won't match
751 ".text." or ".text.*", for example. */
752 if (name1[prefix1_len] == '\0')
754 if (name2[prefix2_len] == '\0')
757 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
759 return memcmp (name1, name2, min_prefix_len) == 0;
762 /* Select specialized code to handle various kinds of wildcard
766 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
769 int wild_name_count = 0;
770 struct wildcard_list *sec;
774 ptr->walk_wild_section_handler = walk_wild_section_general;
775 ptr->handler_data[0] = NULL;
776 ptr->handler_data[1] = NULL;
777 ptr->handler_data[2] = NULL;
778 ptr->handler_data[3] = NULL;
781 /* Count how many wildcard_specs there are, and how many of those
782 actually use wildcards in the name. Also, bail out if any of the
783 wildcard names are NULL. (Can this actually happen?
784 walk_wild_section used to test for it.) And bail out if any
785 of the wildcards are more complex than a simple string
786 ending in a single '*'. */
787 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
790 if (sec->spec.name == NULL)
792 if (wildcardp (sec->spec.name))
795 if (!is_simple_wild (sec->spec.name))
800 /* The zero-spec case would be easy to optimize but it doesn't
801 happen in practice. Likewise, more than 4 specs doesn't
802 happen in practice. */
803 if (sec_count == 0 || sec_count > 4)
806 /* Check that no two specs can match the same section. */
807 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
809 struct wildcard_list *sec2;
810 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
812 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
817 signature = (sec_count << 8) + wild_name_count;
821 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
824 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
827 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
830 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
833 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
839 /* Now fill the data array with pointers to the specs, first the
840 specs with non-wildcard names, then the specs with wildcard
841 names. It's OK to process the specs in different order from the
842 given order, because we've already determined that no section
843 will match more than one spec. */
845 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
846 if (!wildcardp (sec->spec.name))
847 ptr->handler_data[data_counter++] = sec;
848 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
849 if (wildcardp (sec->spec.name))
850 ptr->handler_data[data_counter++] = sec;
853 /* Handle a wild statement for a single file F. */
856 walk_wild_file (lang_wild_statement_type *s,
857 lang_input_statement_type *f,
861 if (f->the_bfd == NULL
862 || ! bfd_check_format (f->the_bfd, bfd_archive))
863 walk_wild_section (s, f, callback, data);
868 /* This is an archive file. We must map each member of the
869 archive separately. */
870 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
871 while (member != NULL)
873 /* When lookup_name is called, it will call the add_symbols
874 entry point for the archive. For each element of the
875 archive which is included, BFD will call ldlang_add_file,
876 which will set the usrdata field of the member to the
877 lang_input_statement. */
878 if (member->usrdata != NULL)
880 walk_wild_section (s,
881 (lang_input_statement_type *) member->usrdata,
885 member = bfd_openr_next_archived_file (f->the_bfd, member);
891 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
893 const char *file_spec = s->filename;
896 if (file_spec == NULL)
898 /* Perform the iteration over all files in the list. */
899 LANG_FOR_EACH_INPUT_STATEMENT (f)
901 walk_wild_file (s, f, callback, data);
904 else if ((p = archive_path (file_spec)) != NULL)
906 LANG_FOR_EACH_INPUT_STATEMENT (f)
908 if (input_statement_is_archive_path (file_spec, p, f))
909 walk_wild_file (s, f, callback, data);
912 else if (wildcardp (file_spec))
914 LANG_FOR_EACH_INPUT_STATEMENT (f)
916 if (fnmatch (file_spec, f->filename, 0) == 0)
917 walk_wild_file (s, f, callback, data);
922 lang_input_statement_type *f;
924 /* Perform the iteration over a single file. */
925 f = lookup_name (file_spec);
927 walk_wild_file (s, f, callback, data);
931 /* lang_for_each_statement walks the parse tree and calls the provided
932 function for each node, except those inside output section statements
933 with constraint set to -1. */
936 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
937 lang_statement_union_type *s)
939 for (; s != NULL; s = s->header.next)
943 switch (s->header.type)
945 case lang_constructors_statement_enum:
946 lang_for_each_statement_worker (func, constructor_list.head);
948 case lang_output_section_statement_enum:
949 if (s->output_section_statement.constraint != -1)
950 lang_for_each_statement_worker
951 (func, s->output_section_statement.children.head);
953 case lang_wild_statement_enum:
954 lang_for_each_statement_worker (func,
955 s->wild_statement.children.head);
957 case lang_group_statement_enum:
958 lang_for_each_statement_worker (func,
959 s->group_statement.children.head);
961 case lang_data_statement_enum:
962 case lang_reloc_statement_enum:
963 case lang_object_symbols_statement_enum:
964 case lang_output_statement_enum:
965 case lang_target_statement_enum:
966 case lang_input_section_enum:
967 case lang_input_statement_enum:
968 case lang_assignment_statement_enum:
969 case lang_padding_statement_enum:
970 case lang_address_statement_enum:
971 case lang_fill_statement_enum:
972 case lang_insert_statement_enum:
982 lang_for_each_statement (void (*func) (lang_statement_union_type *))
984 lang_for_each_statement_worker (func, statement_list.head);
987 /*----------------------------------------------------------------------*/
990 lang_list_init (lang_statement_list_type *list)
993 list->tail = &list->head;
997 push_stat_ptr (lang_statement_list_type *new_ptr)
999 if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
1001 *stat_save_ptr++ = stat_ptr;
1008 if (stat_save_ptr <= stat_save)
1010 stat_ptr = *--stat_save_ptr;
1013 /* Build a new statement node for the parse tree. */
1015 static lang_statement_union_type *
1016 new_statement (enum statement_enum type,
1018 lang_statement_list_type *list)
1020 lang_statement_union_type *new_stmt;
1022 new_stmt = (lang_statement_union_type *) stat_alloc (size);
1023 new_stmt->header.type = type;
1024 new_stmt->header.next = NULL;
1025 lang_statement_append (list, new_stmt, &new_stmt->header.next);
1029 /* Build a new input file node for the language. There are several
1030 ways in which we treat an input file, eg, we only look at symbols,
1031 or prefix it with a -l etc.
1033 We can be supplied with requests for input files more than once;
1034 they may, for example be split over several lines like foo.o(.text)
1035 foo.o(.data) etc, so when asked for a file we check that we haven't
1036 got it already so we don't duplicate the bfd. */
1038 static lang_input_statement_type *
1039 new_afile (const char *name,
1040 lang_input_file_enum_type file_type,
1042 bfd_boolean add_to_list)
1044 lang_input_statement_type *p;
1047 p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
1050 p = (lang_input_statement_type *)
1051 stat_alloc (sizeof (lang_input_statement_type));
1052 p->header.type = lang_input_statement_enum;
1053 p->header.next = NULL;
1056 lang_has_input_file = TRUE;
1058 p->sysrooted = FALSE;
1060 if (file_type == lang_input_file_is_l_enum
1061 && name[0] == ':' && name[1] != '\0')
1063 file_type = lang_input_file_is_search_file_enum;
1069 case lang_input_file_is_symbols_only_enum:
1071 p->maybe_archive = FALSE;
1073 p->local_sym_name = name;
1074 p->just_syms_flag = TRUE;
1075 p->search_dirs_flag = FALSE;
1077 case lang_input_file_is_fake_enum:
1079 p->maybe_archive = FALSE;
1081 p->local_sym_name = name;
1082 p->just_syms_flag = FALSE;
1083 p->search_dirs_flag = FALSE;
1085 case lang_input_file_is_l_enum:
1086 p->maybe_archive = TRUE;
1089 p->local_sym_name = concat ("-l", name, (const char *) NULL);
1090 p->just_syms_flag = FALSE;
1091 p->search_dirs_flag = TRUE;
1093 case lang_input_file_is_marker_enum:
1095 p->maybe_archive = FALSE;
1097 p->local_sym_name = name;
1098 p->just_syms_flag = FALSE;
1099 p->search_dirs_flag = TRUE;
1101 case lang_input_file_is_search_file_enum:
1102 p->sysrooted = ldlang_sysrooted_script;
1104 p->maybe_archive = FALSE;
1106 p->local_sym_name = name;
1107 p->just_syms_flag = FALSE;
1108 p->search_dirs_flag = TRUE;
1110 case lang_input_file_is_file_enum:
1112 p->maybe_archive = FALSE;
1114 p->local_sym_name = name;
1115 p->just_syms_flag = FALSE;
1116 p->search_dirs_flag = FALSE;
1122 p->next_real_file = NULL;
1124 p->dynamic = config.dynamic_link;
1125 p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
1126 p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
1127 p->whole_archive = whole_archive;
1129 p->missing_file = FALSE;
1130 #ifdef ENABLE_PLUGINS
1132 p->claim_archive = FALSE;
1133 #endif /* ENABLE_PLUGINS */
1135 lang_statement_append (&input_file_chain,
1136 (lang_statement_union_type *) p,
1137 &p->next_real_file);
1141 lang_input_statement_type *
1142 lang_add_input_file (const char *name,
1143 lang_input_file_enum_type file_type,
1146 return new_afile (name, file_type, target, TRUE);
1149 struct out_section_hash_entry
1151 struct bfd_hash_entry root;
1152 lang_statement_union_type s;
1155 /* The hash table. */
1157 static struct bfd_hash_table output_section_statement_table;
1159 /* Support routines for the hash table used by lang_output_section_find,
1160 initialize the table, fill in an entry and remove the table. */
1162 static struct bfd_hash_entry *
1163 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1164 struct bfd_hash_table *table,
1167 lang_output_section_statement_type **nextp;
1168 struct out_section_hash_entry *ret;
1172 entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1178 entry = bfd_hash_newfunc (entry, table, string);
1182 ret = (struct out_section_hash_entry *) entry;
1183 memset (&ret->s, 0, sizeof (ret->s));
1184 ret->s.header.type = lang_output_section_statement_enum;
1185 ret->s.output_section_statement.subsection_alignment = -1;
1186 ret->s.output_section_statement.section_alignment = -1;
1187 ret->s.output_section_statement.block_value = 1;
1188 lang_list_init (&ret->s.output_section_statement.children);
1189 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1191 /* For every output section statement added to the list, except the
1192 first one, lang_output_section_statement.tail points to the "next"
1193 field of the last element of the list. */
1194 if (lang_output_section_statement.head != NULL)
1195 ret->s.output_section_statement.prev
1196 = ((lang_output_section_statement_type *)
1197 ((char *) lang_output_section_statement.tail
1198 - offsetof (lang_output_section_statement_type, next)));
1200 /* GCC's strict aliasing rules prevent us from just casting the
1201 address, so we store the pointer in a variable and cast that
1203 nextp = &ret->s.output_section_statement.next;
1204 lang_statement_append (&lang_output_section_statement,
1206 (lang_statement_union_type **) nextp);
1211 output_section_statement_table_init (void)
1213 if (!bfd_hash_table_init_n (&output_section_statement_table,
1214 output_section_statement_newfunc,
1215 sizeof (struct out_section_hash_entry),
1217 einfo (_("%P%F: can not create hash table: %E\n"));
1221 output_section_statement_table_free (void)
1223 bfd_hash_table_free (&output_section_statement_table);
1226 /* Build enough state so that the parser can build its tree. */
1231 obstack_begin (&stat_obstack, 1000);
1233 stat_ptr = &statement_list;
1235 output_section_statement_table_init ();
1237 lang_list_init (stat_ptr);
1239 lang_list_init (&input_file_chain);
1240 lang_list_init (&lang_output_section_statement);
1241 lang_list_init (&file_chain);
1242 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1244 abs_output_section =
1245 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1247 abs_output_section->bfd_section = bfd_abs_section_ptr;
1249 /* The value "3" is ad-hoc, somewhat related to the expected number of
1250 DEFINED expressions in a linker script. For most default linker
1251 scripts, there are none. Why a hash table then? Well, it's somewhat
1252 simpler to re-use working machinery than using a linked list in terms
1253 of code-complexity here in ld, besides the initialization which just
1254 looks like other code here. */
1255 if (!bfd_hash_table_init_n (&lang_definedness_table,
1256 lang_definedness_newfunc,
1257 sizeof (struct lang_definedness_hash_entry),
1259 einfo (_("%P%F: can not create hash table: %E\n"));
1265 output_section_statement_table_free ();
1268 /*----------------------------------------------------------------------
1269 A region is an area of memory declared with the
1270 MEMORY { name:org=exp, len=exp ... }
1273 We maintain a list of all the regions here.
1275 If no regions are specified in the script, then the default is used
1276 which is created when looked up to be the entire data space.
1278 If create is true we are creating a region inside a MEMORY block.
1279 In this case it is probably an error to create a region that has
1280 already been created. If we are not inside a MEMORY block it is
1281 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1282 and so we issue a warning.
1284 Each region has at least one name. The first name is either
1285 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1286 alias names to an existing region within a script with
1287 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1290 static lang_memory_region_type *lang_memory_region_list;
1291 static lang_memory_region_type **lang_memory_region_list_tail
1292 = &lang_memory_region_list;
1294 lang_memory_region_type *
1295 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1297 lang_memory_region_name *n;
1298 lang_memory_region_type *r;
1299 lang_memory_region_type *new_region;
1301 /* NAME is NULL for LMA memspecs if no region was specified. */
1305 for (r = lang_memory_region_list; r != NULL; r = r->next)
1306 for (n = &r->name_list; n != NULL; n = n->next)
1307 if (strcmp (n->name, name) == 0)
1310 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1315 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1316 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);
1318 new_region = (lang_memory_region_type *)
1319 stat_alloc (sizeof (lang_memory_region_type));
1321 new_region->name_list.name = xstrdup (name);
1322 new_region->name_list.next = NULL;
1323 new_region->next = NULL;
1324 new_region->origin = 0;
1325 new_region->length = ~(bfd_size_type) 0;
1326 new_region->current = 0;
1327 new_region->last_os = NULL;
1328 new_region->flags = 0;
1329 new_region->not_flags = 0;
1330 new_region->had_full_message = FALSE;
1332 *lang_memory_region_list_tail = new_region;
1333 lang_memory_region_list_tail = &new_region->next;
1339 lang_memory_region_alias (const char * alias, const char * region_name)
1341 lang_memory_region_name * n;
1342 lang_memory_region_type * r;
1343 lang_memory_region_type * region;
1345 /* The default region must be unique. This ensures that it is not necessary
1346 to iterate through the name list if someone wants the check if a region is
1347 the default memory region. */
1348 if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1349 || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1350 einfo (_("%F%P:%S: error: alias for default memory region\n"));
1352 /* Look for the target region and check if the alias is not already
1355 for (r = lang_memory_region_list; r != NULL; r = r->next)
1356 for (n = &r->name_list; n != NULL; n = n->next)
1358 if (region == NULL && strcmp (n->name, region_name) == 0)
1360 if (strcmp (n->name, alias) == 0)
1361 einfo (_("%F%P:%S: error: redefinition of memory region "
1366 /* Check if the target region exists. */
1368 einfo (_("%F%P:%S: error: memory region `%s' "
1369 "for alias `%s' does not exist\n"),
1373 /* Add alias to region name list. */
1374 n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
1375 n->name = xstrdup (alias);
1376 n->next = region->name_list.next;
1377 region->name_list.next = n;
1380 static lang_memory_region_type *
1381 lang_memory_default (asection * section)
1383 lang_memory_region_type *p;
1385 flagword sec_flags = section->flags;
1387 /* Override SEC_DATA to mean a writable section. */
1388 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1389 sec_flags |= SEC_DATA;
1391 for (p = lang_memory_region_list; p != NULL; p = p->next)
1393 if ((p->flags & sec_flags) != 0
1394 && (p->not_flags & sec_flags) == 0)
1399 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1402 /* Find or create an output_section_statement with the given NAME.
1403 If CONSTRAINT is non-zero match one with that constraint, otherwise
1404 match any non-negative constraint. If CREATE, always make a
1405 new output_section_statement for SPECIAL CONSTRAINT. */
1407 lang_output_section_statement_type *
1408 lang_output_section_statement_lookup (const char *name,
1412 struct out_section_hash_entry *entry;
1414 entry = ((struct out_section_hash_entry *)
1415 bfd_hash_lookup (&output_section_statement_table, name,
1420 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1424 if (entry->s.output_section_statement.name != NULL)
1426 /* We have a section of this name, but it might not have the correct
1428 struct out_section_hash_entry *last_ent;
1430 name = entry->s.output_section_statement.name;
1431 if (create && constraint == SPECIAL)
1432 /* Not traversing to the end reverses the order of the second
1433 and subsequent SPECIAL sections in the hash table chain,
1434 but that shouldn't matter. */
1439 if (constraint == entry->s.output_section_statement.constraint
1441 && entry->s.output_section_statement.constraint >= 0))
1442 return &entry->s.output_section_statement;
1444 entry = (struct out_section_hash_entry *) entry->root.next;
1446 while (entry != NULL
1447 && name == entry->s.output_section_statement.name);
1453 = ((struct out_section_hash_entry *)
1454 output_section_statement_newfunc (NULL,
1455 &output_section_statement_table,
1459 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1462 entry->root = last_ent->root;
1463 last_ent->root.next = &entry->root;
1466 entry->s.output_section_statement.name = name;
1467 entry->s.output_section_statement.constraint = constraint;
1468 return &entry->s.output_section_statement;
1471 /* Find the next output_section_statement with the same name as OS.
1472 If CONSTRAINT is non-zero, find one with that constraint otherwise
1473 match any non-negative constraint. */
1475 lang_output_section_statement_type *
1476 next_matching_output_section_statement (lang_output_section_statement_type *os,
1479 /* All output_section_statements are actually part of a
1480 struct out_section_hash_entry. */
1481 struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1483 - offsetof (struct out_section_hash_entry, s.output_section_statement));
1484 const char *name = os->name;
1486 ASSERT (name == entry->root.string);
1489 entry = (struct out_section_hash_entry *) entry->root.next;
1491 || name != entry->s.output_section_statement.name)
1494 while (constraint != entry->s.output_section_statement.constraint
1496 || entry->s.output_section_statement.constraint < 0));
1498 return &entry->s.output_section_statement;
1501 /* A variant of lang_output_section_find used by place_orphan.
1502 Returns the output statement that should precede a new output
1503 statement for SEC. If an exact match is found on certain flags,
1506 lang_output_section_statement_type *
1507 lang_output_section_find_by_flags (const asection *sec,
1508 lang_output_section_statement_type **exact,
1509 lang_match_sec_type_func match_type)
1511 lang_output_section_statement_type *first, *look, *found;
1514 /* We know the first statement on this list is *ABS*. May as well
1516 first = &lang_output_section_statement.head->output_section_statement;
1517 first = first->next;
1519 /* First try for an exact match. */
1521 for (look = first; look; look = look->next)
1523 flags = look->flags;
1524 if (look->bfd_section != NULL)
1526 flags = look->bfd_section->flags;
1527 if (match_type && !match_type (link_info.output_bfd,
1532 flags ^= sec->flags;
1533 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1534 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1544 if ((sec->flags & SEC_CODE) != 0
1545 && (sec->flags & SEC_ALLOC) != 0)
1547 /* Try for a rw code section. */
1548 for (look = first; look; look = look->next)
1550 flags = look->flags;
1551 if (look->bfd_section != NULL)
1553 flags = look->bfd_section->flags;
1554 if (match_type && !match_type (link_info.output_bfd,
1559 flags ^= sec->flags;
1560 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1561 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1565 else if ((sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) != 0
1566 && (sec->flags & SEC_ALLOC) != 0)
1568 /* .rodata can go after .text, .sdata2 after .rodata. */
1569 for (look = first; look; look = look->next)
1571 flags = look->flags;
1572 if (look->bfd_section != NULL)
1574 flags = look->bfd_section->flags;
1575 if (match_type && !match_type (link_info.output_bfd,
1580 flags ^= sec->flags;
1581 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1583 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1587 else if ((sec->flags & SEC_SMALL_DATA) != 0
1588 && (sec->flags & SEC_ALLOC) != 0)
1590 /* .sdata goes after .data, .sbss after .sdata. */
1591 for (look = first; look; look = look->next)
1593 flags = look->flags;
1594 if (look->bfd_section != NULL)
1596 flags = look->bfd_section->flags;
1597 if (match_type && !match_type (link_info.output_bfd,
1602 flags ^= sec->flags;
1603 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1604 | SEC_THREAD_LOCAL))
1605 || ((look->flags & SEC_SMALL_DATA)
1606 && !(sec->flags & SEC_HAS_CONTENTS)))
1610 else if ((sec->flags & SEC_HAS_CONTENTS) != 0
1611 && (sec->flags & SEC_ALLOC) != 0)
1613 /* .data goes after .rodata. */
1614 for (look = first; look; look = look->next)
1616 flags = look->flags;
1617 if (look->bfd_section != NULL)
1619 flags = look->bfd_section->flags;
1620 if (match_type && !match_type (link_info.output_bfd,
1625 flags ^= sec->flags;
1626 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1627 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1631 else if ((sec->flags & SEC_ALLOC) != 0)
1633 /* .bss goes after any other alloc section. */
1634 for (look = first; look; look = look->next)
1636 flags = look->flags;
1637 if (look->bfd_section != NULL)
1639 flags = look->bfd_section->flags;
1640 if (match_type && !match_type (link_info.output_bfd,
1645 flags ^= sec->flags;
1646 if (!(flags & SEC_ALLOC))
1652 /* non-alloc go last. */
1653 for (look = first; look; look = look->next)
1655 flags = look->flags;
1656 if (look->bfd_section != NULL)
1657 flags = look->bfd_section->flags;
1658 flags ^= sec->flags;
1659 if (!(flags & SEC_DEBUGGING))
1665 if (found || !match_type)
1668 return lang_output_section_find_by_flags (sec, NULL, NULL);
1671 /* Find the last output section before given output statement.
1672 Used by place_orphan. */
1675 output_prev_sec_find (lang_output_section_statement_type *os)
1677 lang_output_section_statement_type *lookup;
1679 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1681 if (lookup->constraint < 0)
1684 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1685 return lookup->bfd_section;
1691 /* Look for a suitable place for a new output section statement. The
1692 idea is to skip over anything that might be inside a SECTIONS {}
1693 statement in a script, before we find another output section
1694 statement. Assignments to "dot" before an output section statement
1695 are assumed to belong to it, except in two cases; The first
1696 assignment to dot, and assignments before non-alloc sections.
1697 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1698 similar assignments that set the initial address, or we might
1699 insert non-alloc note sections among assignments setting end of
1702 static lang_statement_union_type **
1703 insert_os_after (lang_output_section_statement_type *after)
1705 lang_statement_union_type **where;
1706 lang_statement_union_type **assign = NULL;
1707 bfd_boolean ignore_first;
1710 = after == &lang_output_section_statement.head->output_section_statement;
1712 for (where = &after->header.next;
1714 where = &(*where)->header.next)
1716 switch ((*where)->header.type)
1718 case lang_assignment_statement_enum:
1721 lang_assignment_statement_type *ass;
1723 ass = &(*where)->assignment_statement;
1724 if (ass->exp->type.node_class != etree_assert
1725 && ass->exp->assign.dst[0] == '.'
1726 && ass->exp->assign.dst[1] == 0
1730 ignore_first = FALSE;
1732 case lang_wild_statement_enum:
1733 case lang_input_section_enum:
1734 case lang_object_symbols_statement_enum:
1735 case lang_fill_statement_enum:
1736 case lang_data_statement_enum:
1737 case lang_reloc_statement_enum:
1738 case lang_padding_statement_enum:
1739 case lang_constructors_statement_enum:
1742 case lang_output_section_statement_enum:
1745 asection *s = (*where)->output_section_statement.bfd_section;
1748 || s->map_head.s == NULL
1749 || (s->flags & SEC_ALLOC) != 0)
1753 case lang_input_statement_enum:
1754 case lang_address_statement_enum:
1755 case lang_target_statement_enum:
1756 case lang_output_statement_enum:
1757 case lang_group_statement_enum:
1758 case lang_insert_statement_enum:
1767 lang_output_section_statement_type *
1768 lang_insert_orphan (asection *s,
1769 const char *secname,
1771 lang_output_section_statement_type *after,
1772 struct orphan_save *place,
1773 etree_type *address,
1774 lang_statement_list_type *add_child)
1776 lang_statement_list_type add;
1778 lang_output_section_statement_type *os;
1779 lang_output_section_statement_type **os_tail;
1781 /* If we have found an appropriate place for the output section
1782 statements for this orphan, add them to our own private list,
1783 inserting them later into the global statement list. */
1786 lang_list_init (&add);
1787 push_stat_ptr (&add);
1790 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1791 address = exp_intop (0);
1793 os_tail = ((lang_output_section_statement_type **)
1794 lang_output_section_statement.tail);
1795 os = lang_enter_output_section_statement (secname, address, normal_section,
1796 NULL, NULL, NULL, constraint);
1799 if (config.build_constructors && *os_tail == os)
1801 /* If the name of the section is representable in C, then create
1802 symbols to mark the start and the end of the section. */
1803 for (ps = secname; *ps != '\0'; ps++)
1804 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1809 etree_type *e_align;
1811 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1812 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1813 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1814 e_align = exp_unop (ALIGN_K,
1815 exp_intop ((bfd_vma) 1 << s->alignment_power));
1816 lang_add_assignment (exp_assign (".", e_align));
1817 lang_add_assignment (exp_provide (symname,
1819 exp_nameop (NAME, ".")),
1824 if (add_child == NULL)
1825 add_child = &os->children;
1826 lang_add_section (add_child, s, os);
1828 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1830 const char *region = (after->region
1831 ? after->region->name_list.name
1832 : DEFAULT_MEMORY_REGION);
1833 const char *lma_region = (after->lma_region
1834 ? after->lma_region->name_list.name
1836 lang_leave_output_section_statement (NULL, region, after->phdrs,
1840 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1843 if (ps != NULL && *ps == '\0')
1847 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1848 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1849 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1850 lang_add_assignment (exp_provide (symname,
1851 exp_nameop (NAME, "."),
1855 /* Restore the global list pointer. */
1859 if (after != NULL && os->bfd_section != NULL)
1861 asection *snew, *as;
1863 snew = os->bfd_section;
1865 /* Shuffle the bfd section list to make the output file look
1866 neater. This is really only cosmetic. */
1867 if (place->section == NULL
1868 && after != (&lang_output_section_statement.head
1869 ->output_section_statement))
1871 asection *bfd_section = after->bfd_section;
1873 /* If the output statement hasn't been used to place any input
1874 sections (and thus doesn't have an output bfd_section),
1875 look for the closest prior output statement having an
1877 if (bfd_section == NULL)
1878 bfd_section = output_prev_sec_find (after);
1880 if (bfd_section != NULL && bfd_section != snew)
1881 place->section = &bfd_section->next;
1884 if (place->section == NULL)
1885 place->section = &link_info.output_bfd->sections;
1887 as = *place->section;
1891 /* Put the section at the end of the list. */
1893 /* Unlink the section. */
1894 bfd_section_list_remove (link_info.output_bfd, snew);
1896 /* Now tack it back on in the right place. */
1897 bfd_section_list_append (link_info.output_bfd, snew);
1899 else if (as != snew && as->prev != snew)
1901 /* Unlink the section. */
1902 bfd_section_list_remove (link_info.output_bfd, snew);
1904 /* Now tack it back on in the right place. */
1905 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1908 /* Save the end of this list. Further ophans of this type will
1909 follow the one we've just added. */
1910 place->section = &snew->next;
1912 /* The following is non-cosmetic. We try to put the output
1913 statements in some sort of reasonable order here, because they
1914 determine the final load addresses of the orphan sections.
1915 In addition, placing output statements in the wrong order may
1916 require extra segments. For instance, given a typical
1917 situation of all read-only sections placed in one segment and
1918 following that a segment containing all the read-write
1919 sections, we wouldn't want to place an orphan read/write
1920 section before or amongst the read-only ones. */
1921 if (add.head != NULL)
1923 lang_output_section_statement_type *newly_added_os;
1925 if (place->stmt == NULL)
1927 lang_statement_union_type **where = insert_os_after (after);
1932 place->os_tail = &after->next;
1936 /* Put it after the last orphan statement we added. */
1937 *add.tail = *place->stmt;
1938 *place->stmt = add.head;
1941 /* Fix the global list pointer if we happened to tack our
1942 new list at the tail. */
1943 if (*stat_ptr->tail == add.head)
1944 stat_ptr->tail = add.tail;
1946 /* Save the end of this list. */
1947 place->stmt = add.tail;
1949 /* Do the same for the list of output section statements. */
1950 newly_added_os = *os_tail;
1952 newly_added_os->prev = (lang_output_section_statement_type *)
1953 ((char *) place->os_tail
1954 - offsetof (lang_output_section_statement_type, next));
1955 newly_added_os->next = *place->os_tail;
1956 if (newly_added_os->next != NULL)
1957 newly_added_os->next->prev = newly_added_os;
1958 *place->os_tail = newly_added_os;
1959 place->os_tail = &newly_added_os->next;
1961 /* Fixing the global list pointer here is a little different.
1962 We added to the list in lang_enter_output_section_statement,
1963 trimmed off the new output_section_statment above when
1964 assigning *os_tail = NULL, but possibly added it back in
1965 the same place when assigning *place->os_tail. */
1966 if (*os_tail == NULL)
1967 lang_output_section_statement.tail
1968 = (lang_statement_union_type **) os_tail;
1975 lang_map_flags (flagword flag)
1977 if (flag & SEC_ALLOC)
1980 if (flag & SEC_CODE)
1983 if (flag & SEC_READONLY)
1986 if (flag & SEC_DATA)
1989 if (flag & SEC_LOAD)
1996 lang_memory_region_type *m;
1997 bfd_boolean dis_header_printed = FALSE;
2000 LANG_FOR_EACH_INPUT_STATEMENT (file)
2004 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
2005 || file->just_syms_flag)
2008 for (s = file->the_bfd->sections; s != NULL; s = s->next)
2009 if ((s->output_section == NULL
2010 || s->output_section->owner != link_info.output_bfd)
2011 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
2013 if (! dis_header_printed)
2015 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
2016 dis_header_printed = TRUE;
2019 print_input_section (s, TRUE);
2023 minfo (_("\nMemory Configuration\n\n"));
2024 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
2025 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2027 for (m = lang_memory_region_list; m != NULL; m = m->next)
2032 fprintf (config.map_file, "%-16s ", m->name_list.name);
2034 sprintf_vma (buf, m->origin);
2035 minfo ("0x%s ", buf);
2043 minfo ("0x%V", m->length);
2044 if (m->flags || m->not_flags)
2052 lang_map_flags (m->flags);
2058 lang_map_flags (m->not_flags);
2065 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2067 if (! link_info.reduce_memory_overheads)
2069 obstack_begin (&map_obstack, 1000);
2070 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2071 bfd_map_over_sections (p, init_map_userdata, 0);
2072 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2074 lang_statement_iteration ++;
2075 print_statements ();
2079 init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2081 void *data ATTRIBUTE_UNUSED)
2083 fat_section_userdata_type *new_data
2084 = ((fat_section_userdata_type *) (stat_alloc
2085 (sizeof (fat_section_userdata_type))));
2087 ASSERT (get_userdata (sec) == NULL);
2088 get_userdata (sec) = new_data;
2089 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2090 new_data->map_symbol_def_count = 0;
2094 sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2095 void *info ATTRIBUTE_UNUSED)
2097 if (hash_entry->type == bfd_link_hash_warning)
2098 hash_entry = (struct bfd_link_hash_entry *) hash_entry->u.i.link;
2100 if (hash_entry->type == bfd_link_hash_defined
2101 || hash_entry->type == bfd_link_hash_defweak)
2103 struct fat_user_section_struct *ud;
2104 struct map_symbol_def *def;
2106 ud = (struct fat_user_section_struct *)
2107 get_userdata (hash_entry->u.def.section);
2110 /* ??? What do we have to do to initialize this beforehand? */
2111 /* The first time we get here is bfd_abs_section... */
2112 init_map_userdata (0, hash_entry->u.def.section, 0);
2113 ud = (struct fat_user_section_struct *)
2114 get_userdata (hash_entry->u.def.section);
2116 else if (!ud->map_symbol_def_tail)
2117 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2119 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2120 def->entry = hash_entry;
2121 *(ud->map_symbol_def_tail) = def;
2122 ud->map_symbol_def_tail = &def->next;
2123 ud->map_symbol_def_count++;
2128 /* Initialize an output section. */
2131 init_os (lang_output_section_statement_type *s, flagword flags)
2133 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2134 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2136 if (s->constraint != SPECIAL)
2137 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2138 if (s->bfd_section == NULL)
2139 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2141 if (s->bfd_section == NULL)
2143 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2144 link_info.output_bfd->xvec->name, s->name);
2146 s->bfd_section->output_section = s->bfd_section;
2147 s->bfd_section->output_offset = 0;
2149 if (!link_info.reduce_memory_overheads)
2151 fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2152 stat_alloc (sizeof (fat_section_userdata_type));
2153 memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2154 get_userdata (s->bfd_section) = new_userdata;
2157 /* If there is a base address, make sure that any sections it might
2158 mention are initialized. */
2159 if (s->addr_tree != NULL)
2160 exp_init_os (s->addr_tree);
2162 if (s->load_base != NULL)
2163 exp_init_os (s->load_base);
2165 /* If supplied an alignment, set it. */
2166 if (s->section_alignment != -1)
2167 s->bfd_section->alignment_power = s->section_alignment;
2170 /* Make sure that all output sections mentioned in an expression are
2174 exp_init_os (etree_type *exp)
2176 switch (exp->type.node_class)
2180 exp_init_os (exp->assign.src);
2184 exp_init_os (exp->binary.lhs);
2185 exp_init_os (exp->binary.rhs);
2189 exp_init_os (exp->trinary.cond);
2190 exp_init_os (exp->trinary.lhs);
2191 exp_init_os (exp->trinary.rhs);
2195 exp_init_os (exp->assert_s.child);
2199 exp_init_os (exp->unary.child);
2203 switch (exp->type.node_code)
2209 lang_output_section_statement_type *os;
2211 os = lang_output_section_find (exp->name.name);
2212 if (os != NULL && os->bfd_section == NULL)
2224 section_already_linked (bfd *abfd, asection *sec, void *data)
2226 lang_input_statement_type *entry = (lang_input_statement_type *) data;
2228 /* If we are only reading symbols from this object, then we want to
2229 discard all sections. */
2230 if (entry->just_syms_flag)
2232 bfd_link_just_syms (abfd, sec, &link_info);
2236 if (!(abfd->flags & DYNAMIC))
2237 bfd_section_already_linked (abfd, sec, &link_info);
2240 /* The wild routines.
2242 These expand statements like *(.text) and foo.o to a list of
2243 explicit actions, like foo.o(.text), bar.o(.text) and
2244 foo.o(.text, .data). */
2246 /* Add SECTION to the output section OUTPUT. Do this by creating a
2247 lang_input_section statement which is placed at PTR. FILE is the
2248 input file which holds SECTION. */
2251 lang_add_section (lang_statement_list_type *ptr,
2253 lang_output_section_statement_type *output)
2255 flagword flags = section->flags;
2256 bfd_boolean discard;
2257 lang_input_section_type *new_section;
2259 /* Discard sections marked with SEC_EXCLUDE. */
2260 discard = (flags & SEC_EXCLUDE) != 0;
2262 /* Discard input sections which are assigned to a section named
2263 DISCARD_SECTION_NAME. */
2264 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2267 /* Discard debugging sections if we are stripping debugging
2269 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2270 && (flags & SEC_DEBUGGING) != 0)
2275 if (section->output_section == NULL)
2277 /* This prevents future calls from assigning this section. */
2278 section->output_section = bfd_abs_section_ptr;
2283 if (section->output_section != NULL)
2286 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2287 to an output section, because we want to be able to include a
2288 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2289 section (I don't know why we want to do this, but we do).
2290 build_link_order in ldwrite.c handles this case by turning
2291 the embedded SEC_NEVER_LOAD section into a fill. */
2292 flags &= ~ SEC_NEVER_LOAD;
2294 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2295 already been processed. One reason to do this is that on pe
2296 format targets, .text$foo sections go into .text and it's odd
2297 to see .text with SEC_LINK_ONCE set. */
2299 if (!link_info.relocatable)
2300 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2302 switch (output->sectype)
2304 case normal_section:
2305 case overlay_section:
2307 case noalloc_section:
2308 flags &= ~SEC_ALLOC;
2310 case noload_section:
2312 flags |= SEC_NEVER_LOAD;
2313 /* Unfortunately GNU ld has managed to evolve two different
2314 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2315 alloc, no contents section. All others get a noload, noalloc
2317 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2318 flags &= ~SEC_HAS_CONTENTS;
2320 flags &= ~SEC_ALLOC;
2324 if (output->bfd_section == NULL)
2325 init_os (output, flags);
2327 /* If SEC_READONLY is not set in the input section, then clear
2328 it from the output section. */
2329 output->bfd_section->flags &= flags | ~SEC_READONLY;
2331 if (output->bfd_section->linker_has_input)
2333 /* Only set SEC_READONLY flag on the first input section. */
2334 flags &= ~ SEC_READONLY;
2336 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2337 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2338 != (flags & (SEC_MERGE | SEC_STRINGS))
2339 || ((flags & SEC_MERGE) != 0
2340 && output->bfd_section->entsize != section->entsize))
2342 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2343 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2346 output->bfd_section->flags |= flags;
2348 if (!output->bfd_section->linker_has_input)
2350 output->bfd_section->linker_has_input = 1;
2351 /* This must happen after flags have been updated. The output
2352 section may have been created before we saw its first input
2353 section, eg. for a data statement. */
2354 bfd_init_private_section_data (section->owner, section,
2355 link_info.output_bfd,
2356 output->bfd_section,
2358 if ((flags & SEC_MERGE) != 0)
2359 output->bfd_section->entsize = section->entsize;
2362 if ((flags & SEC_TIC54X_BLOCK) != 0
2363 && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2365 /* FIXME: This value should really be obtained from the bfd... */
2366 output->block_value = 128;
2369 if (section->alignment_power > output->bfd_section->alignment_power)
2370 output->bfd_section->alignment_power = section->alignment_power;
2372 section->output_section = output->bfd_section;
2374 if (!link_info.relocatable
2375 && !stripped_excluded_sections)
2377 asection *s = output->bfd_section->map_tail.s;
2378 output->bfd_section->map_tail.s = section;
2379 section->map_head.s = NULL;
2380 section->map_tail.s = s;
2382 s->map_head.s = section;
2384 output->bfd_section->map_head.s = section;
2387 /* Add a section reference to the list. */
2388 new_section = new_stat (lang_input_section, ptr);
2389 new_section->section = section;
2392 /* Handle wildcard sorting. This returns the lang_input_section which
2393 should follow the one we are going to create for SECTION and FILE,
2394 based on the sorting requirements of WILD. It returns NULL if the
2395 new section should just go at the end of the current list. */
2397 static lang_statement_union_type *
2398 wild_sort (lang_wild_statement_type *wild,
2399 struct wildcard_list *sec,
2400 lang_input_statement_type *file,
2403 lang_statement_union_type *l;
2405 if (!wild->filenames_sorted
2406 && (sec == NULL || sec->spec.sorted == none))
2409 for (l = wild->children.head; l != NULL; l = l->header.next)
2411 lang_input_section_type *ls;
2413 if (l->header.type != lang_input_section_enum)
2415 ls = &l->input_section;
2417 /* Sorting by filename takes precedence over sorting by section
2420 if (wild->filenames_sorted)
2422 const char *fn, *ln;
2426 /* The PE support for the .idata section as generated by
2427 dlltool assumes that files will be sorted by the name of
2428 the archive and then the name of the file within the
2431 if (file->the_bfd != NULL
2432 && bfd_my_archive (file->the_bfd) != NULL)
2434 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2439 fn = file->filename;
2443 if (bfd_my_archive (ls->section->owner) != NULL)
2445 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2450 ln = ls->section->owner->filename;
2454 i = filename_cmp (fn, ln);
2463 fn = file->filename;
2465 ln = ls->section->owner->filename;
2467 i = filename_cmp (fn, ln);
2475 /* Here either the files are not sorted by name, or we are
2476 looking at the sections for this file. */
2478 if (sec != NULL && sec->spec.sorted != none)
2479 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2486 /* Expand a wild statement for a particular FILE. SECTION may be
2487 NULL, in which case it is a wild card. */
2490 output_section_callback (lang_wild_statement_type *ptr,
2491 struct wildcard_list *sec,
2493 lang_input_statement_type *file,
2496 lang_statement_union_type *before;
2497 lang_output_section_statement_type *os;
2499 os = (lang_output_section_statement_type *) output;
2501 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2502 if (unique_section_p (section, os))
2505 before = wild_sort (ptr, sec, file, section);
2507 /* Here BEFORE points to the lang_input_section which
2508 should follow the one we are about to add. If BEFORE
2509 is NULL, then the section should just go at the end
2510 of the current list. */
2513 lang_add_section (&ptr->children, section, os);
2516 lang_statement_list_type list;
2517 lang_statement_union_type **pp;
2519 lang_list_init (&list);
2520 lang_add_section (&list, section, os);
2522 /* If we are discarding the section, LIST.HEAD will
2524 if (list.head != NULL)
2526 ASSERT (list.head->header.next == NULL);
2528 for (pp = &ptr->children.head;
2530 pp = &(*pp)->header.next)
2531 ASSERT (*pp != NULL);
2533 list.head->header.next = *pp;
2539 /* Check if all sections in a wild statement for a particular FILE
2543 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2544 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2546 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2549 lang_output_section_statement_type *os;
2551 os = (lang_output_section_statement_type *) output;
2553 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2554 if (unique_section_p (section, os))
2557 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2558 os->all_input_readonly = FALSE;
2561 /* This is passed a file name which must have been seen already and
2562 added to the statement tree. We will see if it has been opened
2563 already and had its symbols read. If not then we'll read it. */
2565 static lang_input_statement_type *
2566 lookup_name (const char *name)
2568 lang_input_statement_type *search;
2570 for (search = (lang_input_statement_type *) input_file_chain.head;
2572 search = (lang_input_statement_type *) search->next_real_file)
2574 /* Use the local_sym_name as the name of the file that has
2575 already been loaded as filename might have been transformed
2576 via the search directory lookup mechanism. */
2577 const char *filename = search->local_sym_name;
2579 if (filename != NULL
2580 && filename_cmp (filename, name) == 0)
2585 search = new_afile (name, lang_input_file_is_search_file_enum,
2586 default_target, FALSE);
2588 /* If we have already added this file, or this file is not real
2589 don't add this file. */
2590 if (search->loaded || !search->real)
2593 if (! load_symbols (search, NULL))
2599 /* Save LIST as a list of libraries whose symbols should not be exported. */
2604 struct excluded_lib *next;
2606 static struct excluded_lib *excluded_libs;
2609 add_excluded_libs (const char *list)
2611 const char *p = list, *end;
2615 struct excluded_lib *entry;
2616 end = strpbrk (p, ",:");
2618 end = p + strlen (p);
2619 entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2620 entry->next = excluded_libs;
2621 entry->name = (char *) xmalloc (end - p + 1);
2622 memcpy (entry->name, p, end - p);
2623 entry->name[end - p] = '\0';
2624 excluded_libs = entry;
2632 check_excluded_libs (bfd *abfd)
2634 struct excluded_lib *lib = excluded_libs;
2638 int len = strlen (lib->name);
2639 const char *filename = lbasename (abfd->filename);
2641 if (strcmp (lib->name, "ALL") == 0)
2643 abfd->no_export = TRUE;
2647 if (filename_ncmp (lib->name, filename, len) == 0
2648 && (filename[len] == '\0'
2649 || (filename[len] == '.' && filename[len + 1] == 'a'
2650 && filename[len + 2] == '\0')))
2652 abfd->no_export = TRUE;
2660 /* Get the symbols for an input file. */
2663 load_symbols (lang_input_statement_type *entry,
2664 lang_statement_list_type *place)
2671 ldfile_open_file (entry);
2673 /* Do not process further if the file was missing. */
2674 if (entry->missing_file)
2677 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2678 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2681 bfd_boolean save_ldlang_sysrooted_script;
2682 bfd_boolean save_add_DT_NEEDED_for_regular;
2683 bfd_boolean save_add_DT_NEEDED_for_dynamic;
2684 bfd_boolean save_whole_archive;
2686 err = bfd_get_error ();
2688 /* See if the emulation has some special knowledge. */
2689 if (ldemul_unrecognized_file (entry))
2692 if (err == bfd_error_file_ambiguously_recognized)
2696 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2697 einfo (_("%B: matching formats:"), entry->the_bfd);
2698 for (p = matching; *p != NULL; p++)
2702 else if (err != bfd_error_file_not_recognized
2704 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2706 bfd_close (entry->the_bfd);
2707 entry->the_bfd = NULL;
2709 /* Try to interpret the file as a linker script. */
2710 ldfile_open_command_file (entry->filename);
2712 push_stat_ptr (place);
2713 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2714 ldlang_sysrooted_script = entry->sysrooted;
2715 save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2716 add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2717 save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2718 add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2719 save_whole_archive = whole_archive;
2720 whole_archive = entry->whole_archive;
2722 ldfile_assumed_script = TRUE;
2723 parser_input = input_script;
2724 /* We want to use the same -Bdynamic/-Bstatic as the one for
2726 config.dynamic_link = entry->dynamic;
2728 ldfile_assumed_script = FALSE;
2730 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2731 add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2732 add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2733 whole_archive = save_whole_archive;
2739 if (ldemul_recognized_file (entry))
2742 /* We don't call ldlang_add_file for an archive. Instead, the
2743 add_symbols entry point will call ldlang_add_file, via the
2744 add_archive_element callback, for each element of the archive
2746 switch (bfd_get_format (entry->the_bfd))
2752 ldlang_add_file (entry);
2753 if (trace_files || trace_file_tries)
2754 info_msg ("%I\n", entry);
2758 check_excluded_libs (entry->the_bfd);
2760 if (entry->whole_archive)
2763 bfd_boolean loaded = TRUE;
2768 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2773 if (! bfd_check_format (member, bfd_object))
2775 einfo (_("%F%B: member %B in archive is not an object\n"),
2776 entry->the_bfd, member);
2781 if (!(*link_info.callbacks
2782 ->add_archive_element) (&link_info, member,
2783 "--whole-archive", &subsbfd))
2786 /* Potentially, the add_archive_element hook may have set a
2787 substitute BFD for us. */
2788 if (!bfd_link_add_symbols (subsbfd, &link_info))
2790 einfo (_("%F%B: could not read symbols: %E\n"), member);
2795 entry->loaded = loaded;
2801 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2802 entry->loaded = TRUE;
2804 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2806 return entry->loaded;
2809 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2810 may be NULL, indicating that it is a wildcard. Separate
2811 lang_input_section statements are created for each part of the
2812 expansion; they are added after the wild statement S. OUTPUT is
2813 the output section. */
2816 wild (lang_wild_statement_type *s,
2817 const char *target ATTRIBUTE_UNUSED,
2818 lang_output_section_statement_type *output)
2820 struct wildcard_list *sec;
2822 if (s->handler_data[0]
2823 && s->handler_data[0]->spec.sorted == by_name
2824 && !s->filenames_sorted)
2826 lang_section_bst_type *tree;
2828 walk_wild (s, output_section_callback_fast, output);
2833 output_section_callback_tree_to_list (s, tree, output);
2838 walk_wild (s, output_section_callback, output);
2840 if (default_common_section == NULL)
2841 for (sec = s->section_list; sec != NULL; sec = sec->next)
2842 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2844 /* Remember the section that common is going to in case we
2845 later get something which doesn't know where to put it. */
2846 default_common_section = output;
2851 /* Return TRUE iff target is the sought target. */
2854 get_target (const bfd_target *target, void *data)
2856 const char *sought = (const char *) data;
2858 return strcmp (target->name, sought) == 0;
2861 /* Like strcpy() but convert to lower case as well. */
2864 stricpy (char *dest, char *src)
2868 while ((c = *src++) != 0)
2869 *dest++ = TOLOWER (c);
2874 /* Remove the first occurrence of needle (if any) in haystack
2878 strcut (char *haystack, char *needle)
2880 haystack = strstr (haystack, needle);
2886 for (src = haystack + strlen (needle); *src;)
2887 *haystack++ = *src++;
2893 /* Compare two target format name strings.
2894 Return a value indicating how "similar" they are. */
2897 name_compare (char *first, char *second)
2903 copy1 = (char *) xmalloc (strlen (first) + 1);
2904 copy2 = (char *) xmalloc (strlen (second) + 1);
2906 /* Convert the names to lower case. */
2907 stricpy (copy1, first);
2908 stricpy (copy2, second);
2910 /* Remove size and endian strings from the name. */
2911 strcut (copy1, "big");
2912 strcut (copy1, "little");
2913 strcut (copy2, "big");
2914 strcut (copy2, "little");
2916 /* Return a value based on how many characters match,
2917 starting from the beginning. If both strings are
2918 the same then return 10 * their length. */
2919 for (result = 0; copy1[result] == copy2[result]; result++)
2920 if (copy1[result] == 0)
2932 /* Set by closest_target_match() below. */
2933 static const bfd_target *winner;
2935 /* Scan all the valid bfd targets looking for one that has the endianness
2936 requirement that was specified on the command line, and is the nearest
2937 match to the original output target. */
2940 closest_target_match (const bfd_target *target, void *data)
2942 const bfd_target *original = (const bfd_target *) data;
2944 if (command_line.endian == ENDIAN_BIG
2945 && target->byteorder != BFD_ENDIAN_BIG)
2948 if (command_line.endian == ENDIAN_LITTLE
2949 && target->byteorder != BFD_ENDIAN_LITTLE)
2952 /* Must be the same flavour. */
2953 if (target->flavour != original->flavour)
2956 /* Ignore generic big and little endian elf vectors. */
2957 if (strcmp (target->name, "elf32-big") == 0
2958 || strcmp (target->name, "elf64-big") == 0
2959 || strcmp (target->name, "elf32-little") == 0
2960 || strcmp (target->name, "elf64-little") == 0)
2963 /* If we have not found a potential winner yet, then record this one. */
2970 /* Oh dear, we now have two potential candidates for a successful match.
2971 Compare their names and choose the better one. */
2972 if (name_compare (target->name, original->name)
2973 > name_compare (winner->name, original->name))
2976 /* Keep on searching until wqe have checked them all. */
2980 /* Return the BFD target format of the first input file. */
2983 get_first_input_target (void)
2985 char *target = NULL;
2987 LANG_FOR_EACH_INPUT_STATEMENT (s)
2989 if (s->header.type == lang_input_statement_enum
2992 ldfile_open_file (s);
2994 if (s->the_bfd != NULL
2995 && bfd_check_format (s->the_bfd, bfd_object))
2997 target = bfd_get_target (s->the_bfd);
3009 lang_get_output_target (void)
3013 /* Has the user told us which output format to use? */
3014 if (output_target != NULL)
3015 return output_target;
3017 /* No - has the current target been set to something other than
3019 if (current_target != default_target)
3020 return current_target;
3022 /* No - can we determine the format of the first input file? */
3023 target = get_first_input_target ();
3027 /* Failed - use the default output target. */
3028 return default_target;
3031 /* Open the output file. */
3034 open_output (const char *name)
3036 output_target = lang_get_output_target ();
3038 /* Has the user requested a particular endianness on the command
3040 if (command_line.endian != ENDIAN_UNSET)
3042 const bfd_target *target;
3043 enum bfd_endian desired_endian;
3045 /* Get the chosen target. */
3046 target = bfd_search_for_target (get_target, (void *) output_target);
3048 /* If the target is not supported, we cannot do anything. */
3051 if (command_line.endian == ENDIAN_BIG)
3052 desired_endian = BFD_ENDIAN_BIG;
3054 desired_endian = BFD_ENDIAN_LITTLE;
3056 /* See if the target has the wrong endianness. This should
3057 not happen if the linker script has provided big and
3058 little endian alternatives, but some scrips don't do
3060 if (target->byteorder != desired_endian)
3062 /* If it does, then see if the target provides
3063 an alternative with the correct endianness. */
3064 if (target->alternative_target != NULL
3065 && (target->alternative_target->byteorder == desired_endian))
3066 output_target = target->alternative_target->name;
3069 /* Try to find a target as similar as possible to
3070 the default target, but which has the desired
3071 endian characteristic. */
3072 bfd_search_for_target (closest_target_match,
3075 /* Oh dear - we could not find any targets that
3076 satisfy our requirements. */
3078 einfo (_("%P: warning: could not find any targets"
3079 " that match endianness requirement\n"));
3081 output_target = winner->name;
3087 link_info.output_bfd = bfd_openw (name, output_target);
3089 if (link_info.output_bfd == NULL)
3091 if (bfd_get_error () == bfd_error_invalid_target)
3092 einfo (_("%P%F: target %s not found\n"), output_target);
3094 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3097 delete_output_file_on_failure = TRUE;
3099 if (! bfd_set_format (link_info.output_bfd, bfd_object))
3100 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3101 if (! bfd_set_arch_mach (link_info.output_bfd,
3102 ldfile_output_architecture,
3103 ldfile_output_machine))
3104 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3106 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3107 if (link_info.hash == NULL)
3108 einfo (_("%P%F: can not create hash table: %E\n"));
3110 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3114 ldlang_open_output (lang_statement_union_type *statement)
3116 switch (statement->header.type)
3118 case lang_output_statement_enum:
3119 ASSERT (link_info.output_bfd == NULL);
3120 open_output (statement->output_statement.name);
3121 ldemul_set_output_arch ();
3122 if (config.magic_demand_paged && !link_info.relocatable)
3123 link_info.output_bfd->flags |= D_PAGED;
3125 link_info.output_bfd->flags &= ~D_PAGED;
3126 if (config.text_read_only)
3127 link_info.output_bfd->flags |= WP_TEXT;
3129 link_info.output_bfd->flags &= ~WP_TEXT;
3130 if (link_info.traditional_format)
3131 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3133 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3136 case lang_target_statement_enum:
3137 current_target = statement->target_statement.target;
3144 /* Convert between addresses in bytes and sizes in octets.
3145 For currently supported targets, octets_per_byte is always a power
3146 of two, so we can use shifts. */
3147 #define TO_ADDR(X) ((X) >> opb_shift)
3148 #define TO_SIZE(X) ((X) << opb_shift)
3150 /* Support the above. */
3151 static unsigned int opb_shift = 0;
3156 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3157 ldfile_output_machine);
3160 while ((x & 1) == 0)
3168 /* Open all the input files. */
3172 OPEN_BFD_NORMAL = 0,
3176 #ifdef ENABLE_PLUGINS
3177 static lang_input_statement_type *plugin_insert = NULL;
3181 open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)
3183 for (; s != NULL; s = s->header.next)
3185 switch (s->header.type)
3187 case lang_constructors_statement_enum:
3188 open_input_bfds (constructor_list.head, mode);
3190 case lang_output_section_statement_enum:
3191 open_input_bfds (s->output_section_statement.children.head, mode);
3193 case lang_wild_statement_enum:
3194 /* Maybe we should load the file's symbols. */
3195 if ((mode & OPEN_BFD_RESCAN) == 0
3196 && s->wild_statement.filename
3197 && !wildcardp (s->wild_statement.filename)
3198 && !archive_path (s->wild_statement.filename))
3199 lookup_name (s->wild_statement.filename);
3200 open_input_bfds (s->wild_statement.children.head, mode);
3202 case lang_group_statement_enum:
3204 struct bfd_link_hash_entry *undefs;
3206 /* We must continually search the entries in the group
3207 until no new symbols are added to the list of undefined
3212 undefs = link_info.hash->undefs_tail;
3213 open_input_bfds (s->group_statement.children.head,
3214 mode | OPEN_BFD_FORCE);
3216 while (undefs != link_info.hash->undefs_tail);
3219 case lang_target_statement_enum:
3220 current_target = s->target_statement.target;
3222 case lang_input_statement_enum:
3223 if (s->input_statement.real)
3225 lang_statement_union_type **os_tail;
3226 lang_statement_list_type add;
3228 s->input_statement.target = current_target;
3230 /* If we are being called from within a group, and this
3231 is an archive which has already been searched, then
3232 force it to be researched unless the whole archive
3233 has been loaded already. Do the same for a rescan. */
3234 if (mode != OPEN_BFD_NORMAL
3235 #ifdef ENABLE_PLUGINS
3236 && ((mode & OPEN_BFD_RESCAN) == 0
3237 || plugin_insert == NULL)
3239 && !s->input_statement.whole_archive
3240 && s->input_statement.loaded
3241 && bfd_check_format (s->input_statement.the_bfd,
3243 s->input_statement.loaded = FALSE;
3245 os_tail = lang_output_section_statement.tail;
3246 lang_list_init (&add);
3248 if (! load_symbols (&s->input_statement, &add))
3249 config.make_executable = FALSE;
3251 if (add.head != NULL)
3253 /* If this was a script with output sections then
3254 tack any added statements on to the end of the
3255 list. This avoids having to reorder the output
3256 section statement list. Very likely the user
3257 forgot -T, and whatever we do here will not meet
3258 naive user expectations. */
3259 if (os_tail != lang_output_section_statement.tail)
3261 einfo (_("%P: warning: %s contains output sections;"
3262 " did you forget -T?\n"),
3263 s->input_statement.filename);
3264 *stat_ptr->tail = add.head;
3265 stat_ptr->tail = add.tail;
3269 *add.tail = s->header.next;
3270 s->header.next = add.head;
3274 #ifdef ENABLE_PLUGINS
3275 /* If we have found the point at which a plugin added new
3276 files, clear plugin_insert to enable archive rescan. */
3277 if (&s->input_statement == plugin_insert)
3278 plugin_insert = NULL;
3281 case lang_assignment_statement_enum:
3282 if (s->assignment_statement.exp->assign.hidden)
3283 /* This is from a --defsym on the command line. */
3284 exp_fold_tree_no_dot (s->assignment_statement.exp);
3291 /* Exit if any of the files were missing. */
3296 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3299 lang_track_definedness (const char *name)
3301 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3302 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3305 /* New-function for the definedness hash table. */
3307 static struct bfd_hash_entry *
3308 lang_definedness_newfunc (struct bfd_hash_entry *entry,
3309 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3310 const char *name ATTRIBUTE_UNUSED)
3312 struct lang_definedness_hash_entry *ret
3313 = (struct lang_definedness_hash_entry *) entry;
3316 ret = (struct lang_definedness_hash_entry *)
3317 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3320 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3322 ret->iteration = -1;
3326 /* Return the iteration when the definition of NAME was last updated. A
3327 value of -1 means that the symbol is not defined in the linker script
3328 or the command line, but may be defined in the linker symbol table. */
3331 lang_symbol_definition_iteration (const char *name)
3333 struct lang_definedness_hash_entry *defentry
3334 = (struct lang_definedness_hash_entry *)
3335 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3337 /* We've already created this one on the presence of DEFINED in the
3338 script, so it can't be NULL unless something is borked elsewhere in
3340 if (defentry == NULL)
3343 return defentry->iteration;
3346 /* Update the definedness state of NAME. */
3349 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3351 struct lang_definedness_hash_entry *defentry
3352 = (struct lang_definedness_hash_entry *)
3353 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3355 /* We don't keep track of symbols not tested with DEFINED. */
3356 if (defentry == NULL)
3359 /* If the symbol was already defined, and not from an earlier statement
3360 iteration, don't update the definedness iteration, because that'd
3361 make the symbol seem defined in the linker script at this point, and
3362 it wasn't; it was defined in some object. If we do anyway, DEFINED
3363 would start to yield false before this point and the construct "sym =
3364 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3366 if (h->type != bfd_link_hash_undefined
3367 && h->type != bfd_link_hash_common
3368 && h->type != bfd_link_hash_new
3369 && defentry->iteration == -1)
3372 defentry->iteration = lang_statement_iteration;
3375 /* Add the supplied name to the symbol table as an undefined reference.
3376 This is a two step process as the symbol table doesn't even exist at
3377 the time the ld command line is processed. First we put the name
3378 on a list, then, once the output file has been opened, transfer the
3379 name to the symbol table. */
3381 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3383 #define ldlang_undef_chain_list_head entry_symbol.next
3386 ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3388 ldlang_undef_chain_list_type *new_undef;
3390 undef_from_cmdline = undef_from_cmdline || cmdline;
3391 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3392 new_undef->next = ldlang_undef_chain_list_head;
3393 ldlang_undef_chain_list_head = new_undef;
3395 new_undef->name = xstrdup (name);
3397 if (link_info.output_bfd != NULL)
3398 insert_undefined (new_undef->name);
3401 /* Insert NAME as undefined in the symbol table. */
3404 insert_undefined (const char *name)
3406 struct bfd_link_hash_entry *h;
3408 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3410 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3411 if (h->type == bfd_link_hash_new)
3413 h->type = bfd_link_hash_undefined;
3414 h->u.undef.abfd = NULL;
3415 bfd_link_add_undef (link_info.hash, h);
3419 /* Run through the list of undefineds created above and place them
3420 into the linker hash table as undefined symbols belonging to the
3424 lang_place_undefineds (void)
3426 ldlang_undef_chain_list_type *ptr;
3428 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3429 insert_undefined (ptr->name);
3432 /* Check for all readonly or some readwrite sections. */
3435 check_input_sections
3436 (lang_statement_union_type *s,
3437 lang_output_section_statement_type *output_section_statement)
3439 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3441 switch (s->header.type)
3443 case lang_wild_statement_enum:
3444 walk_wild (&s->wild_statement, check_section_callback,
3445 output_section_statement);
3446 if (! output_section_statement->all_input_readonly)
3449 case lang_constructors_statement_enum:
3450 check_input_sections (constructor_list.head,
3451 output_section_statement);
3452 if (! output_section_statement->all_input_readonly)
3455 case lang_group_statement_enum:
3456 check_input_sections (s->group_statement.children.head,
3457 output_section_statement);
3458 if (! output_section_statement->all_input_readonly)
3467 /* Update wildcard statements if needed. */
3470 update_wild_statements (lang_statement_union_type *s)
3472 struct wildcard_list *sec;
3474 switch (sort_section)
3484 for (; s != NULL; s = s->header.next)
3486 switch (s->header.type)
3491 case lang_wild_statement_enum:
3492 sec = s->wild_statement.section_list;
3493 for (sec = s->wild_statement.section_list; sec != NULL;
3496 switch (sec->spec.sorted)
3499 sec->spec.sorted = sort_section;
3502 if (sort_section == by_alignment)
3503 sec->spec.sorted = by_name_alignment;
3506 if (sort_section == by_name)
3507 sec->spec.sorted = by_alignment_name;
3515 case lang_constructors_statement_enum:
3516 update_wild_statements (constructor_list.head);
3519 case lang_output_section_statement_enum:
3520 update_wild_statements
3521 (s->output_section_statement.children.head);
3524 case lang_group_statement_enum:
3525 update_wild_statements (s->group_statement.children.head);
3533 /* Open input files and attach to output sections. */
3536 map_input_to_output_sections
3537 (lang_statement_union_type *s, const char *target,
3538 lang_output_section_statement_type *os)
3540 for (; s != NULL; s = s->header.next)
3542 lang_output_section_statement_type *tos;
3545 switch (s->header.type)
3547 case lang_wild_statement_enum:
3548 wild (&s->wild_statement, target, os);
3550 case lang_constructors_statement_enum:
3551 map_input_to_output_sections (constructor_list.head,
3555 case lang_output_section_statement_enum:
3556 tos = &s->output_section_statement;
3557 if (tos->constraint != 0)
3559 if (tos->constraint != ONLY_IF_RW
3560 && tos->constraint != ONLY_IF_RO)
3562 tos->all_input_readonly = TRUE;
3563 check_input_sections (tos->children.head, tos);
3564 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3566 tos->constraint = -1;
3570 map_input_to_output_sections (tos->children.head,
3574 case lang_output_statement_enum:
3576 case lang_target_statement_enum:
3577 target = s->target_statement.target;
3579 case lang_group_statement_enum:
3580 map_input_to_output_sections (s->group_statement.children.head,
3584 case lang_data_statement_enum:
3585 /* Make sure that any sections mentioned in the expression
3587 exp_init_os (s->data_statement.exp);
3588 /* The output section gets CONTENTS, ALLOC and LOAD, but
3589 these may be overridden by the script. */
3590 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3591 switch (os->sectype)
3593 case normal_section:
3594 case overlay_section:
3596 case noalloc_section:
3597 flags = SEC_HAS_CONTENTS;
3599 case noload_section:
3600 if (bfd_get_flavour (link_info.output_bfd)
3601 == bfd_target_elf_flavour)
3602 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3604 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3607 if (os->bfd_section == NULL)
3608 init_os (os, flags);
3610 os->bfd_section->flags |= flags;
3612 case lang_input_section_enum:
3614 case lang_fill_statement_enum:
3615 case lang_object_symbols_statement_enum:
3616 case lang_reloc_statement_enum:
3617 case lang_padding_statement_enum:
3618 case lang_input_statement_enum:
3619 if (os != NULL && os->bfd_section == NULL)
3622 case lang_assignment_statement_enum:
3623 if (os != NULL && os->bfd_section == NULL)
3626 /* Make sure that any sections mentioned in the assignment
3628 exp_init_os (s->assignment_statement.exp);
3630 case lang_address_statement_enum:
3631 /* Mark the specified section with the supplied address.
3632 If this section was actually a segment marker, then the
3633 directive is ignored if the linker script explicitly
3634 processed the segment marker. Originally, the linker
3635 treated segment directives (like -Ttext on the
3636 command-line) as section directives. We honor the
3637 section directive semantics for backwards compatibilty;
3638 linker scripts that do not specifically check for
3639 SEGMENT_START automatically get the old semantics. */
3640 if (!s->address_statement.segment
3641 || !s->address_statement.segment->used)
3643 const char *name = s->address_statement.section_name;
3645 /* Create the output section statement here so that
3646 orphans with a set address will be placed after other
3647 script sections. If we let the orphan placement code
3648 place them in amongst other sections then the address
3649 will affect following script sections, which is
3650 likely to surprise naive users. */
3651 tos = lang_output_section_statement_lookup (name, 0, TRUE);
3652 tos->addr_tree = s->address_statement.address;
3653 if (tos->bfd_section == NULL)
3657 case lang_insert_statement_enum:
3663 /* An insert statement snips out all the linker statements from the
3664 start of the list and places them after the output section
3665 statement specified by the insert. This operation is complicated
3666 by the fact that we keep a doubly linked list of output section
3667 statements as well as the singly linked list of all statements. */
3670 process_insert_statements (void)
3672 lang_statement_union_type **s;
3673 lang_output_section_statement_type *first_os = NULL;
3674 lang_output_section_statement_type *last_os = NULL;
3675 lang_output_section_statement_type *os;
3677 /* "start of list" is actually the statement immediately after
3678 the special abs_section output statement, so that it isn't
3680 s = &lang_output_section_statement.head;
3681 while (*(s = &(*s)->header.next) != NULL)
3683 if ((*s)->header.type == lang_output_section_statement_enum)
3685 /* Keep pointers to the first and last output section
3686 statement in the sequence we may be about to move. */
3687 os = &(*s)->output_section_statement;
3689 ASSERT (last_os == NULL || last_os->next == os);
3692 /* Set constraint negative so that lang_output_section_find
3693 won't match this output section statement. At this
3694 stage in linking constraint has values in the range
3695 [-1, ONLY_IN_RW]. */
3696 last_os->constraint = -2 - last_os->constraint;
3697 if (first_os == NULL)
3700 else if ((*s)->header.type == lang_insert_statement_enum)
3702 lang_insert_statement_type *i = &(*s)->insert_statement;
3703 lang_output_section_statement_type *where;
3704 lang_statement_union_type **ptr;
3705 lang_statement_union_type *first;
3707 where = lang_output_section_find (i->where);
3708 if (where != NULL && i->is_before)
3711 where = where->prev;
3712 while (where != NULL && where->constraint < 0);
3716 einfo (_("%F%P: %s not found for insert\n"), i->where);
3720 /* Deal with reordering the output section statement list. */
3721 if (last_os != NULL)
3723 asection *first_sec, *last_sec;
3724 struct lang_output_section_statement_struct **next;
3726 /* Snip out the output sections we are moving. */
3727 first_os->prev->next = last_os->next;
3728 if (last_os->next == NULL)
3730 next = &first_os->prev->next;
3731 lang_output_section_statement.tail
3732 = (lang_statement_union_type **) next;
3735 last_os->next->prev = first_os->prev;
3736 /* Add them in at the new position. */
3737 last_os->next = where->next;
3738 if (where->next == NULL)
3740 next = &last_os->next;
3741 lang_output_section_statement.tail
3742 = (lang_statement_union_type **) next;
3745 where->next->prev = last_os;
3746 first_os->prev = where;
3747 where->next = first_os;
3749 /* Move the bfd sections in the same way. */
3752 for (os = first_os; os != NULL; os = os->next)
3754 os->constraint = -2 - os->constraint;
3755 if (os->bfd_section != NULL
3756 && os->bfd_section->owner != NULL)
3758 last_sec = os->bfd_section;
3759 if (first_sec == NULL)
3760 first_sec = last_sec;
3765 if (last_sec != NULL)
3767 asection *sec = where->bfd_section;
3769 sec = output_prev_sec_find (where);
3771 /* The place we want to insert must come after the
3772 sections we are moving. So if we find no
3773 section or if the section is the same as our
3774 last section, then no move is needed. */
3775 if (sec != NULL && sec != last_sec)
3777 /* Trim them off. */
3778 if (first_sec->prev != NULL)
3779 first_sec->prev->next = last_sec->next;
3781 link_info.output_bfd->sections = last_sec->next;
3782 if (last_sec->next != NULL)
3783 last_sec->next->prev = first_sec->prev;
3785 link_info.output_bfd->section_last = first_sec->prev;
3787 last_sec->next = sec->next;
3788 if (sec->next != NULL)
3789 sec->next->prev = last_sec;
3791 link_info.output_bfd->section_last = last_sec;
3792 first_sec->prev = sec;
3793 sec->next = first_sec;
3801 ptr = insert_os_after (where);
3802 /* Snip everything after the abs_section output statement we
3803 know is at the start of the list, up to and including
3804 the insert statement we are currently processing. */
3805 first = lang_output_section_statement.head->header.next;
3806 lang_output_section_statement.head->header.next = (*s)->header.next;
3807 /* Add them back where they belong. */
3810 statement_list.tail = s;
3812 s = &lang_output_section_statement.head;
3816 /* Undo constraint twiddling. */
3817 for (os = first_os; os != NULL; os = os->next)
3819 os->constraint = -2 - os->constraint;
3825 /* An output section might have been removed after its statement was
3826 added. For example, ldemul_before_allocation can remove dynamic
3827 sections if they turn out to be not needed. Clean them up here. */
3830 strip_excluded_output_sections (void)
3832 lang_output_section_statement_type *os;
3834 /* Run lang_size_sections (if not already done). */
3835 if (expld.phase != lang_mark_phase_enum)
3837 expld.phase = lang_mark_phase_enum;
3838 expld.dataseg.phase = exp_dataseg_none;
3839 one_lang_size_sections_pass (NULL, FALSE);
3840 lang_reset_memory_regions ();
3843 for (os = &lang_output_section_statement.head->output_section_statement;
3847 asection *output_section;
3848 bfd_boolean exclude;
3850 if (os->constraint < 0)
3853 output_section = os->bfd_section;
3854 if (output_section == NULL)
3857 exclude = (output_section->rawsize == 0
3858 && (output_section->flags & SEC_KEEP) == 0
3859 && !bfd_section_removed_from_list (link_info.output_bfd,
3862 /* Some sections have not yet been sized, notably .gnu.version,
3863 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3864 input sections, so don't drop output sections that have such
3865 input sections unless they are also marked SEC_EXCLUDE. */
3866 if (exclude && output_section->map_head.s != NULL)
3870 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3871 if ((s->flags & SEC_LINKER_CREATED) != 0
3872 && (s->flags & SEC_EXCLUDE) == 0)
3879 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3880 output_section->map_head.link_order = NULL;
3881 output_section->map_tail.link_order = NULL;
3885 /* We don't set bfd_section to NULL since bfd_section of the
3886 removed output section statement may still be used. */
3887 if (!os->section_relative_symbol
3888 && !os->update_dot_tree)
3890 output_section->flags |= SEC_EXCLUDE;
3891 bfd_section_list_remove (link_info.output_bfd, output_section);
3892 link_info.output_bfd->section_count--;
3896 /* Stop future calls to lang_add_section from messing with map_head
3897 and map_tail link_order fields. */
3898 stripped_excluded_sections = TRUE;
3902 print_output_section_statement
3903 (lang_output_section_statement_type *output_section_statement)
3905 asection *section = output_section_statement->bfd_section;
3908 if (output_section_statement != abs_output_section)
3910 minfo ("\n%s", output_section_statement->name);
3912 if (section != NULL)
3914 print_dot = section->vma;
3916 len = strlen (output_section_statement->name);
3917 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3922 while (len < SECTION_NAME_MAP_LENGTH)
3928 minfo ("0x%V %W", section->vma, section->size);
3930 if (section->vma != section->lma)
3931 minfo (_(" load address 0x%V"), section->lma);
3933 if (output_section_statement->update_dot_tree != NULL)
3934 exp_fold_tree (output_section_statement->update_dot_tree,
3935 bfd_abs_section_ptr, &print_dot);
3941 print_statement_list (output_section_statement->children.head,
3942 output_section_statement);
3945 /* Scan for the use of the destination in the right hand side
3946 of an expression. In such cases we will not compute the
3947 correct expression, since the value of DST that is used on
3948 the right hand side will be its final value, not its value
3949 just before this expression is evaluated. */
3952 scan_for_self_assignment (const char * dst, etree_type * rhs)
3954 if (rhs == NULL || dst == NULL)
3957 switch (rhs->type.node_class)
3960 return (scan_for_self_assignment (dst, rhs->binary.lhs)
3961 || scan_for_self_assignment (dst, rhs->binary.rhs));
3964 return (scan_for_self_assignment (dst, rhs->trinary.lhs)
3965 || scan_for_self_assignment (dst, rhs->trinary.rhs));
3968 case etree_provided:
3970 if (strcmp (dst, rhs->assign.dst) == 0)
3972 return scan_for_self_assignment (dst, rhs->assign.src);
3975 return scan_for_self_assignment (dst, rhs->unary.child);
3979 return strcmp (dst, rhs->value.str) == 0;
3984 return strcmp (dst, rhs->name.name) == 0;
3996 print_assignment (lang_assignment_statement_type *assignment,
3997 lang_output_section_statement_type *output_section)
4001 bfd_boolean computation_is_valid = TRUE;
4005 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4008 if (assignment->exp->type.node_class == etree_assert)
4011 tree = assignment->exp->assert_s.child;
4012 computation_is_valid = TRUE;
4016 const char *dst = assignment->exp->assign.dst;
4018 is_dot = (dst[0] == '.' && dst[1] == 0);
4019 tree = assignment->exp->assign.src;
4020 computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
4023 osec = output_section->bfd_section;
4025 osec = bfd_abs_section_ptr;
4026 exp_fold_tree (tree, osec, &print_dot);
4027 if (expld.result.valid_p)
4031 if (computation_is_valid)
4033 value = expld.result.value;
4035 if (expld.result.section != NULL)
4036 value += expld.result.section->vma;
4038 minfo ("0x%V", value);
4044 struct bfd_link_hash_entry *h;
4046 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
4047 FALSE, FALSE, TRUE);
4050 value = h->u.def.value;
4052 if (expld.result.section != NULL)
4053 value += expld.result.section->vma;
4055 minfo ("[0x%V]", value);
4058 minfo ("[unresolved]");
4070 exp_print_tree (assignment->exp);
4075 print_input_statement (lang_input_statement_type *statm)
4077 if (statm->filename != NULL
4078 && (statm->the_bfd == NULL
4079 || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
4080 fprintf (config.map_file, "LOAD %s\n", statm->filename);
4083 /* Print all symbols defined in a particular section. This is called
4084 via bfd_link_hash_traverse, or by print_all_symbols. */
4087 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4089 asection *sec = (asection *) ptr;
4091 if ((hash_entry->type == bfd_link_hash_defined
4092 || hash_entry->type == bfd_link_hash_defweak)
4093 && sec == hash_entry->u.def.section)
4097 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4100 (hash_entry->u.def.value
4101 + hash_entry->u.def.section->output_offset
4102 + hash_entry->u.def.section->output_section->vma));
4104 minfo (" %T\n", hash_entry->root.string);
4111 hash_entry_addr_cmp (const void *a, const void *b)
4113 const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4114 const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4116 if (l->u.def.value < r->u.def.value)
4118 else if (l->u.def.value > r->u.def.value)
4125 print_all_symbols (asection *sec)
4127 struct fat_user_section_struct *ud =
4128 (struct fat_user_section_struct *) get_userdata (sec);
4129 struct map_symbol_def *def;
4130 struct bfd_link_hash_entry **entries;
4136 *ud->map_symbol_def_tail = 0;
4138 /* Sort the symbols by address. */
4139 entries = (struct bfd_link_hash_entry **)
4140 obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4142 for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4143 entries[i] = def->entry;
4145 qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4146 hash_entry_addr_cmp);
4148 /* Print the symbols. */
4149 for (i = 0; i < ud->map_symbol_def_count; i++)
4150 print_one_symbol (entries[i], sec);
4152 obstack_free (&map_obstack, entries);
4155 /* Print information about an input section to the map file. */
4158 print_input_section (asection *i, bfd_boolean is_discarded)
4160 bfd_size_type size = i->size;
4167 minfo ("%s", i->name);
4169 len = 1 + strlen (i->name);
4170 if (len >= SECTION_NAME_MAP_LENGTH - 1)
4175 while (len < SECTION_NAME_MAP_LENGTH)
4181 if (i->output_section != NULL
4182 && i->output_section->owner == link_info.output_bfd)
4183 addr = i->output_section->vma + i->output_offset;
4191 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4193 if (size != i->rawsize && i->rawsize != 0)
4195 len = SECTION_NAME_MAP_LENGTH + 3;
4207 minfo (_("%W (size before relaxing)\n"), i->rawsize);
4210 if (i->output_section != NULL
4211 && i->output_section->owner == link_info.output_bfd)
4213 if (link_info.reduce_memory_overheads)
4214 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4216 print_all_symbols (i);
4218 /* Update print_dot, but make sure that we do not move it
4219 backwards - this could happen if we have overlays and a
4220 later overlay is shorter than an earier one. */
4221 if (addr + TO_ADDR (size) > print_dot)
4222 print_dot = addr + TO_ADDR (size);
4227 print_fill_statement (lang_fill_statement_type *fill)
4231 fputs (" FILL mask 0x", config.map_file);
4232 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4233 fprintf (config.map_file, "%02x", *p);
4234 fputs ("\n", config.map_file);
4238 print_data_statement (lang_data_statement_type *data)
4246 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4249 addr = data->output_offset;
4250 if (data->output_section != NULL)
4251 addr += data->output_section->vma;
4279 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4281 if (data->exp->type.node_class != etree_value)
4284 exp_print_tree (data->exp);
4289 print_dot = addr + TO_ADDR (size);
4292 /* Print an address statement. These are generated by options like
4296 print_address_statement (lang_address_statement_type *address)
4298 minfo (_("Address of section %s set to "), address->section_name);
4299 exp_print_tree (address->address);
4303 /* Print a reloc statement. */
4306 print_reloc_statement (lang_reloc_statement_type *reloc)
4313 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4316 addr = reloc->output_offset;
4317 if (reloc->output_section != NULL)
4318 addr += reloc->output_section->vma;
4320 size = bfd_get_reloc_size (reloc->howto);
4322 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4324 if (reloc->name != NULL)
4325 minfo ("%s+", reloc->name);
4327 minfo ("%s+", reloc->section->name);
4329 exp_print_tree (reloc->addend_exp);
4333 print_dot = addr + TO_ADDR (size);
4337 print_padding_statement (lang_padding_statement_type *s)
4345 len = sizeof " *fill*" - 1;
4346 while (len < SECTION_NAME_MAP_LENGTH)
4352 addr = s->output_offset;
4353 if (s->output_section != NULL)
4354 addr += s->output_section->vma;
4355 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4357 if (s->fill->size != 0)
4361 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4362 fprintf (config.map_file, "%02x", *p);
4367 print_dot = addr + TO_ADDR (s->size);
4371 print_wild_statement (lang_wild_statement_type *w,
4372 lang_output_section_statement_type *os)
4374 struct wildcard_list *sec;
4378 if (w->filenames_sorted)
4380 if (w->filename != NULL)
4381 minfo ("%s", w->filename);
4384 if (w->filenames_sorted)
4388 for (sec = w->section_list; sec; sec = sec->next)
4390 if (sec->spec.sorted)
4392 if (sec->spec.exclude_name_list != NULL)
4395 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4396 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4397 minfo (" %s", tmp->name);
4400 if (sec->spec.name != NULL)
4401 minfo ("%s", sec->spec.name);
4404 if (sec->spec.sorted)
4413 print_statement_list (w->children.head, os);
4416 /* Print a group statement. */
4419 print_group (lang_group_statement_type *s,
4420 lang_output_section_statement_type *os)
4422 fprintf (config.map_file, "START GROUP\n");
4423 print_statement_list (s->children.head, os);
4424 fprintf (config.map_file, "END GROUP\n");
4427 /* Print the list of statements in S.
4428 This can be called for any statement type. */
4431 print_statement_list (lang_statement_union_type *s,
4432 lang_output_section_statement_type *os)
4436 print_statement (s, os);
4441 /* Print the first statement in statement list S.
4442 This can be called for any statement type. */
4445 print_statement (lang_statement_union_type *s,
4446 lang_output_section_statement_type *os)
4448 switch (s->header.type)
4451 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4454 case lang_constructors_statement_enum:
4455 if (constructor_list.head != NULL)
4457 if (constructors_sorted)
4458 minfo (" SORT (CONSTRUCTORS)\n");
4460 minfo (" CONSTRUCTORS\n");
4461 print_statement_list (constructor_list.head, os);
4464 case lang_wild_statement_enum:
4465 print_wild_statement (&s->wild_statement, os);
4467 case lang_address_statement_enum:
4468 print_address_statement (&s->address_statement);
4470 case lang_object_symbols_statement_enum:
4471 minfo (" CREATE_OBJECT_SYMBOLS\n");
4473 case lang_fill_statement_enum:
4474 print_fill_statement (&s->fill_statement);
4476 case lang_data_statement_enum:
4477 print_data_statement (&s->data_statement);
4479 case lang_reloc_statement_enum:
4480 print_reloc_statement (&s->reloc_statement);
4482 case lang_input_section_enum:
4483 print_input_section (s->input_section.section, FALSE);
4485 case lang_padding_statement_enum:
4486 print_padding_statement (&s->padding_statement);
4488 case lang_output_section_statement_enum:
4489 print_output_section_statement (&s->output_section_statement);
4491 case lang_assignment_statement_enum:
4492 print_assignment (&s->assignment_statement, os);
4494 case lang_target_statement_enum:
4495 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4497 case lang_output_statement_enum:
4498 minfo ("OUTPUT(%s", s->output_statement.name);
4499 if (output_target != NULL)
4500 minfo (" %s", output_target);
4503 case lang_input_statement_enum:
4504 print_input_statement (&s->input_statement);
4506 case lang_group_statement_enum:
4507 print_group (&s->group_statement, os);
4509 case lang_insert_statement_enum:
4510 minfo ("INSERT %s %s\n",
4511 s->insert_statement.is_before ? "BEFORE" : "AFTER",
4512 s->insert_statement.where);
4518 print_statements (void)
4520 print_statement_list (statement_list.head, abs_output_section);
4523 /* Print the first N statements in statement list S to STDERR.
4524 If N == 0, nothing is printed.
4525 If N < 0, the entire list is printed.
4526 Intended to be called from GDB. */
4529 dprint_statement (lang_statement_union_type *s, int n)
4531 FILE *map_save = config.map_file;
4533 config.map_file = stderr;
4536 print_statement_list (s, abs_output_section);
4539 while (s && --n >= 0)
4541 print_statement (s, abs_output_section);
4546 config.map_file = map_save;
4550 insert_pad (lang_statement_union_type **ptr,
4552 unsigned int alignment_needed,
4553 asection *output_section,
4556 static fill_type zero_fill = { 1, { 0 } };
4557 lang_statement_union_type *pad = NULL;
4559 if (ptr != &statement_list.head)
4560 pad = ((lang_statement_union_type *)
4561 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4563 && pad->header.type == lang_padding_statement_enum
4564 && pad->padding_statement.output_section == output_section)
4566 /* Use the existing pad statement. */
4568 else if ((pad = *ptr) != NULL
4569 && pad->header.type == lang_padding_statement_enum
4570 && pad->padding_statement.output_section == output_section)
4572 /* Use the existing pad statement. */
4576 /* Make a new padding statement, linked into existing chain. */
4577 pad = (lang_statement_union_type *)
4578 stat_alloc (sizeof (lang_padding_statement_type));
4579 pad->header.next = *ptr;
4581 pad->header.type = lang_padding_statement_enum;
4582 pad->padding_statement.output_section = output_section;
4585 pad->padding_statement.fill = fill;
4587 pad->padding_statement.output_offset = dot - output_section->vma;
4588 pad->padding_statement.size = alignment_needed;
4589 output_section->size += alignment_needed;
4592 /* Work out how much this section will move the dot point. */
4596 (lang_statement_union_type **this_ptr,
4597 lang_output_section_statement_type *output_section_statement,
4601 lang_input_section_type *is = &((*this_ptr)->input_section);
4602 asection *i = is->section;
4604 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4605 && (i->flags & SEC_EXCLUDE) == 0)
4607 unsigned int alignment_needed;
4610 /* Align this section first to the input sections requirement,
4611 then to the output section's requirement. If this alignment
4612 is greater than any seen before, then record it too. Perform
4613 the alignment by inserting a magic 'padding' statement. */
4615 if (output_section_statement->subsection_alignment != -1)
4616 i->alignment_power = output_section_statement->subsection_alignment;
4618 o = output_section_statement->bfd_section;
4619 if (o->alignment_power < i->alignment_power)
4620 o->alignment_power = i->alignment_power;
4622 alignment_needed = align_power (dot, i->alignment_power) - dot;
4624 if (alignment_needed != 0)
4626 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4627 dot += alignment_needed;
4630 /* Remember where in the output section this input section goes. */
4632 i->output_offset = dot - o->vma;
4634 /* Mark how big the output section must be to contain this now. */
4635 dot += TO_ADDR (i->size);
4636 o->size = TO_SIZE (dot - o->vma);
4640 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4647 sort_sections_by_lma (const void *arg1, const void *arg2)
4649 const asection *sec1 = *(const asection **) arg1;
4650 const asection *sec2 = *(const asection **) arg2;
4652 if (bfd_section_lma (sec1->owner, sec1)
4653 < bfd_section_lma (sec2->owner, sec2))
4655 else if (bfd_section_lma (sec1->owner, sec1)
4656 > bfd_section_lma (sec2->owner, sec2))
4658 else if (sec1->id < sec2->id)
4660 else if (sec1->id > sec2->id)
4666 #define IGNORE_SECTION(s) \
4667 ((s->flags & SEC_ALLOC) == 0 \
4668 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4669 && (s->flags & SEC_LOAD) == 0))
4671 /* Check to see if any allocated sections overlap with other allocated
4672 sections. This can happen if a linker script specifies the output
4673 section addresses of the two sections. Also check whether any memory
4674 region has overflowed. */
4677 lang_check_section_addresses (void)
4680 asection **sections, **spp;
4687 lang_memory_region_type *m;
4689 if (bfd_count_sections (link_info.output_bfd) <= 1)
4692 amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4693 sections = (asection **) xmalloc (amt);
4695 /* Scan all sections in the output list. */
4697 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4699 /* Only consider loadable sections with real contents. */
4700 if (!(s->flags & SEC_LOAD)
4701 || !(s->flags & SEC_ALLOC)
4705 sections[count] = s;
4712 qsort (sections, (size_t) count, sizeof (asection *),
4713 sort_sections_by_lma);
4718 s_end = s_start + TO_ADDR (s->size) - 1;
4719 for (count--; count; count--)
4721 /* We must check the sections' LMA addresses not their VMA
4722 addresses because overlay sections can have overlapping VMAs
4723 but they must have distinct LMAs. */
4729 s_end = s_start + TO_ADDR (s->size) - 1;
4731 /* Look for an overlap. We have sorted sections by lma, so we
4732 know that s_start >= p_start. Besides the obvious case of
4733 overlap when the current section starts before the previous
4734 one ends, we also must have overlap if the previous section
4735 wraps around the address space. */
4736 if (s_start <= p_end
4738 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4739 s->name, s_start, s_end, p->name, p_start, p_end);
4744 /* If any memory region has overflowed, report by how much.
4745 We do not issue this diagnostic for regions that had sections
4746 explicitly placed outside their bounds; os_region_check's
4747 diagnostics are adequate for that case.
4749 FIXME: It is conceivable that m->current - (m->origin + m->length)
4750 might overflow a 32-bit integer. There is, alas, no way to print
4751 a bfd_vma quantity in decimal. */
4752 for (m = lang_memory_region_list; m; m = m->next)
4753 if (m->had_full_message)
4754 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4755 m->name_list.name, (long)(m->current - (m->origin + m->length)));
4759 /* Make sure the new address is within the region. We explicitly permit the
4760 current address to be at the exact end of the region when the address is
4761 non-zero, in case the region is at the end of addressable memory and the
4762 calculation wraps around. */
4765 os_region_check (lang_output_section_statement_type *os,
4766 lang_memory_region_type *region,
4770 if ((region->current < region->origin
4771 || (region->current - region->origin > region->length))
4772 && ((region->current != region->origin + region->length)
4777 einfo (_("%X%P: address 0x%v of %B section `%s'"
4778 " is not within region `%s'\n"),
4780 os->bfd_section->owner,
4781 os->bfd_section->name,
4782 region->name_list.name);
4784 else if (!region->had_full_message)
4786 region->had_full_message = TRUE;
4788 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4789 os->bfd_section->owner,
4790 os->bfd_section->name,
4791 region->name_list.name);
4796 /* Set the sizes for all the output sections. */
4799 lang_size_sections_1
4800 (lang_statement_union_type **prev,
4801 lang_output_section_statement_type *output_section_statement,
4805 bfd_boolean check_regions)
4807 lang_statement_union_type *s;
4809 /* Size up the sections from their constituent parts. */
4810 for (s = *prev; s != NULL; s = s->header.next)
4812 switch (s->header.type)
4814 case lang_output_section_statement_enum:
4816 bfd_vma newdot, after;
4817 lang_output_section_statement_type *os;
4818 lang_memory_region_type *r;
4819 int section_alignment = 0;
4821 os = &s->output_section_statement;
4822 if (os->constraint == -1)
4825 /* FIXME: We shouldn't need to zero section vmas for ld -r
4826 here, in lang_insert_orphan, or in the default linker scripts.
4827 This is covering for coff backend linker bugs. See PR6945. */
4828 if (os->addr_tree == NULL
4829 && link_info.relocatable
4830 && (bfd_get_flavour (link_info.output_bfd)
4831 == bfd_target_coff_flavour))
4832 os->addr_tree = exp_intop (0);
4833 if (os->addr_tree != NULL)
4835 os->processed_vma = FALSE;
4836 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4838 if (expld.result.valid_p)
4840 dot = expld.result.value;
4841 if (expld.result.section != NULL)
4842 dot += expld.result.section->vma;
4844 else if (expld.phase != lang_mark_phase_enum)
4845 einfo (_("%F%S: non constant or forward reference"
4846 " address expression for section %s\n"),
4850 if (os->bfd_section == NULL)
4851 /* This section was removed or never actually created. */
4854 /* If this is a COFF shared library section, use the size and
4855 address from the input section. FIXME: This is COFF
4856 specific; it would be cleaner if there were some other way
4857 to do this, but nothing simple comes to mind. */
4858 if (((bfd_get_flavour (link_info.output_bfd)
4859 == bfd_target_ecoff_flavour)
4860 || (bfd_get_flavour (link_info.output_bfd)
4861 == bfd_target_coff_flavour))
4862 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4866 if (os->children.head == NULL
4867 || os->children.head->header.next != NULL
4868 || (os->children.head->header.type
4869 != lang_input_section_enum))
4870 einfo (_("%P%X: Internal error on COFF shared library"
4871 " section %s\n"), os->name);
4873 input = os->children.head->input_section.section;
4874 bfd_set_section_vma (os->bfd_section->owner,
4876 bfd_section_vma (input->owner, input));
4877 os->bfd_section->size = input->size;
4882 if (bfd_is_abs_section (os->bfd_section))
4884 /* No matter what happens, an abs section starts at zero. */
4885 ASSERT (os->bfd_section->vma == 0);
4889 if (os->addr_tree == NULL)
4891 /* No address specified for this section, get one
4892 from the region specification. */
4893 if (os->region == NULL
4894 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4895 && os->region->name_list.name[0] == '*'
4896 && strcmp (os->region->name_list.name,
4897 DEFAULT_MEMORY_REGION) == 0))
4899 os->region = lang_memory_default (os->bfd_section);
4902 /* If a loadable section is using the default memory
4903 region, and some non default memory regions were
4904 defined, issue an error message. */
4906 && !IGNORE_SECTION (os->bfd_section)
4907 && ! link_info.relocatable
4909 && strcmp (os->region->name_list.name,
4910 DEFAULT_MEMORY_REGION) == 0
4911 && lang_memory_region_list != NULL
4912 && (strcmp (lang_memory_region_list->name_list.name,
4913 DEFAULT_MEMORY_REGION) != 0
4914 || lang_memory_region_list->next != NULL)
4915 && expld.phase != lang_mark_phase_enum)
4917 /* By default this is an error rather than just a
4918 warning because if we allocate the section to the
4919 default memory region we can end up creating an
4920 excessively large binary, or even seg faulting when
4921 attempting to perform a negative seek. See
4922 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4923 for an example of this. This behaviour can be
4924 overridden by the using the --no-check-sections
4926 if (command_line.check_section_addresses)
4927 einfo (_("%P%F: error: no memory region specified"
4928 " for loadable section `%s'\n"),
4929 bfd_get_section_name (link_info.output_bfd,
4932 einfo (_("%P: warning: no memory region specified"
4933 " for loadable section `%s'\n"),
4934 bfd_get_section_name (link_info.output_bfd,
4938 newdot = os->region->current;
4939 section_alignment = os->bfd_section->alignment_power;
4942 section_alignment = os->section_alignment;
4944 /* Align to what the section needs. */
4945 if (section_alignment > 0)
4947 bfd_vma savedot = newdot;
4948 newdot = align_power (newdot, section_alignment);
4950 if (newdot != savedot
4951 && (config.warn_section_align
4952 || os->addr_tree != NULL)
4953 && expld.phase != lang_mark_phase_enum)
4954 einfo (_("%P: warning: changing start of section"
4955 " %s by %lu bytes\n"),
4956 os->name, (unsigned long) (newdot - savedot));
4959 bfd_set_section_vma (0, os->bfd_section, newdot);
4961 os->bfd_section->output_offset = 0;
4964 lang_size_sections_1 (&os->children.head, os,
4965 os->fill, newdot, relax, check_regions);
4967 os->processed_vma = TRUE;
4969 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4970 /* Except for some special linker created sections,
4971 no output section should change from zero size
4972 after strip_excluded_output_sections. A non-zero
4973 size on an ignored section indicates that some
4974 input section was not sized early enough. */
4975 ASSERT (os->bfd_section->size == 0);
4978 dot = os->bfd_section->vma;
4980 /* Put the section within the requested block size, or
4981 align at the block boundary. */
4983 + TO_ADDR (os->bfd_section->size)
4984 + os->block_value - 1)
4985 & - (bfd_vma) os->block_value);
4987 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4990 /* Set section lma. */
4993 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4997 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4998 os->bfd_section->lma = lma;
5000 else if (os->lma_region != NULL)
5002 bfd_vma lma = os->lma_region->current;
5004 if (section_alignment > 0)
5005 lma = align_power (lma, section_alignment);
5006 os->bfd_section->lma = lma;
5008 else if (r->last_os != NULL
5009 && (os->bfd_section->flags & SEC_ALLOC) != 0)
5014 last = r->last_os->output_section_statement.bfd_section;
5016 /* A backwards move of dot should be accompanied by
5017 an explicit assignment to the section LMA (ie.
5018 os->load_base set) because backwards moves can
5019 create overlapping LMAs. */
5021 && os->bfd_section->size != 0
5022 && dot + os->bfd_section->size <= last->vma)
5024 /* If dot moved backwards then leave lma equal to
5025 vma. This is the old default lma, which might
5026 just happen to work when the backwards move is
5027 sufficiently large. Nag if this changes anything,
5028 so people can fix their linker scripts. */
5030 if (last->vma != last->lma)
5031 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5036 /* If this is an overlay, set the current lma to that
5037 at the end of the previous section. */
5038 if (os->sectype == overlay_section)
5039 lma = last->lma + last->size;
5041 /* Otherwise, keep the same lma to vma relationship
5042 as the previous section. */
5044 lma = dot + last->lma - last->vma;
5046 if (section_alignment > 0)
5047 lma = align_power (lma, section_alignment);
5048 os->bfd_section->lma = lma;
5051 os->processed_lma = TRUE;
5053 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5056 /* Keep track of normal sections using the default
5057 lma region. We use this to set the lma for
5058 following sections. Overlays or other linker
5059 script assignment to lma might mean that the
5060 default lma == vma is incorrect.
5061 To avoid warnings about dot moving backwards when using
5062 -Ttext, don't start tracking sections until we find one
5063 of non-zero size or with lma set differently to vma. */
5064 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5065 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
5066 && (os->bfd_section->flags & SEC_ALLOC) != 0
5067 && (os->bfd_section->size != 0
5068 || (r->last_os == NULL
5069 && os->bfd_section->vma != os->bfd_section->lma)
5070 || (r->last_os != NULL
5071 && dot >= (r->last_os->output_section_statement
5072 .bfd_section->vma)))
5073 && os->lma_region == NULL
5074 && !link_info.relocatable)
5077 /* .tbss sections effectively have zero size. */
5078 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5079 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5080 || link_info.relocatable)
5081 dot += TO_ADDR (os->bfd_section->size);
5083 if (os->update_dot_tree != 0)
5084 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5086 /* Update dot in the region ?
5087 We only do this if the section is going to be allocated,
5088 since unallocated sections do not contribute to the region's
5089 overall size in memory. */
5090 if (os->region != NULL
5091 && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5093 os->region->current = dot;
5096 /* Make sure the new address is within the region. */
5097 os_region_check (os, os->region, os->addr_tree,
5098 os->bfd_section->vma);
5100 if (os->lma_region != NULL && os->lma_region != os->region
5101 && (os->bfd_section->flags & SEC_LOAD))
5103 os->lma_region->current
5104 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
5107 os_region_check (os, os->lma_region, NULL,
5108 os->bfd_section->lma);
5114 case lang_constructors_statement_enum:
5115 dot = lang_size_sections_1 (&constructor_list.head,
5116 output_section_statement,
5117 fill, dot, relax, check_regions);
5120 case lang_data_statement_enum:
5122 unsigned int size = 0;
5124 s->data_statement.output_offset =
5125 dot - output_section_statement->bfd_section->vma;
5126 s->data_statement.output_section =
5127 output_section_statement->bfd_section;
5129 /* We might refer to provided symbols in the expression, and
5130 need to mark them as needed. */
5131 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5133 switch (s->data_statement.type)
5151 if (size < TO_SIZE ((unsigned) 1))
5152 size = TO_SIZE ((unsigned) 1);
5153 dot += TO_ADDR (size);
5154 output_section_statement->bfd_section->size += size;
5158 case lang_reloc_statement_enum:
5162 s->reloc_statement.output_offset =
5163 dot - output_section_statement->bfd_section->vma;
5164 s->reloc_statement.output_section =
5165 output_section_statement->bfd_section;
5166 size = bfd_get_reloc_size (s->reloc_statement.howto);
5167 dot += TO_ADDR (size);
5168 output_section_statement->bfd_section->size += size;
5172 case lang_wild_statement_enum:
5173 dot = lang_size_sections_1 (&s->wild_statement.children.head,
5174 output_section_statement,
5175 fill, dot, relax, check_regions);
5178 case lang_object_symbols_statement_enum:
5179 link_info.create_object_symbols_section =
5180 output_section_statement->bfd_section;
5183 case lang_output_statement_enum:
5184 case lang_target_statement_enum:
5187 case lang_input_section_enum:
5191 i = s->input_section.section;
5196 if (! bfd_relax_section (i->owner, i, &link_info, &again))
5197 einfo (_("%P%F: can't relax section: %E\n"));
5201 dot = size_input_section (prev, output_section_statement,
5202 output_section_statement->fill, dot);
5206 case lang_input_statement_enum:
5209 case lang_fill_statement_enum:
5210 s->fill_statement.output_section =
5211 output_section_statement->bfd_section;
5213 fill = s->fill_statement.fill;
5216 case lang_assignment_statement_enum:
5218 bfd_vma newdot = dot;
5219 etree_type *tree = s->assignment_statement.exp;
5221 expld.dataseg.relro = exp_dataseg_relro_none;
5223 exp_fold_tree (tree,
5224 output_section_statement->bfd_section,
5227 if (expld.dataseg.relro == exp_dataseg_relro_start)
5229 if (!expld.dataseg.relro_start_stat)
5230 expld.dataseg.relro_start_stat = s;
5233 ASSERT (expld.dataseg.relro_start_stat == s);
5236 else if (expld.dataseg.relro == exp_dataseg_relro_end)
5238 if (!expld.dataseg.relro_end_stat)
5239 expld.dataseg.relro_end_stat = s;
5242 ASSERT (expld.dataseg.relro_end_stat == s);
5245 expld.dataseg.relro = exp_dataseg_relro_none;
5247 /* This symbol is relative to this section. */
5248 if ((tree->type.node_class == etree_provided
5249 || tree->type.node_class == etree_assign)
5250 && (tree->assign.dst [0] != '.'
5251 || tree->assign.dst [1] != '\0'))
5252 output_section_statement->section_relative_symbol = 1;
5254 if (!output_section_statement->ignored)
5256 if (output_section_statement == abs_output_section)
5258 /* If we don't have an output section, then just adjust
5259 the default memory address. */
5260 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5261 FALSE)->current = newdot;
5263 else if (newdot != dot)
5265 /* Insert a pad after this statement. We can't
5266 put the pad before when relaxing, in case the
5267 assignment references dot. */
5268 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5269 output_section_statement->bfd_section, dot);
5271 /* Don't neuter the pad below when relaxing. */
5274 /* If dot is advanced, this implies that the section
5275 should have space allocated to it, unless the
5276 user has explicitly stated that the section
5277 should not be allocated. */
5278 if (output_section_statement->sectype != noalloc_section
5279 && (output_section_statement->sectype != noload_section
5280 || (bfd_get_flavour (link_info.output_bfd)
5281 == bfd_target_elf_flavour)))
5282 output_section_statement->bfd_section->flags |= SEC_ALLOC;
5289 case lang_padding_statement_enum:
5290 /* If this is the first time lang_size_sections is called,
5291 we won't have any padding statements. If this is the
5292 second or later passes when relaxing, we should allow
5293 padding to shrink. If padding is needed on this pass, it
5294 will be added back in. */
5295 s->padding_statement.size = 0;
5297 /* Make sure output_offset is valid. If relaxation shrinks
5298 the section and this pad isn't needed, it's possible to
5299 have output_offset larger than the final size of the
5300 section. bfd_set_section_contents will complain even for
5301 a pad size of zero. */
5302 s->padding_statement.output_offset
5303 = dot - output_section_statement->bfd_section->vma;
5306 case lang_group_statement_enum:
5307 dot = lang_size_sections_1 (&s->group_statement.children.head,
5308 output_section_statement,
5309 fill, dot, relax, check_regions);
5312 case lang_insert_statement_enum:
5315 /* We can only get here when relaxing is turned on. */
5316 case lang_address_statement_enum:
5323 prev = &s->header.next;
5328 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5329 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5330 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5331 segments. We are allowed an opportunity to override this decision. */
5334 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5335 bfd * abfd ATTRIBUTE_UNUSED,
5336 asection * current_section,
5337 asection * previous_section,
5338 bfd_boolean new_segment)
5340 lang_output_section_statement_type * cur;
5341 lang_output_section_statement_type * prev;
5343 /* The checks below are only necessary when the BFD library has decided
5344 that the two sections ought to be placed into the same segment. */
5348 /* Paranoia checks. */
5349 if (current_section == NULL || previous_section == NULL)
5352 /* Find the memory regions associated with the two sections.
5353 We call lang_output_section_find() here rather than scanning the list
5354 of output sections looking for a matching section pointer because if
5355 we have a large number of sections then a hash lookup is faster. */
5356 cur = lang_output_section_find (current_section->name);
5357 prev = lang_output_section_find (previous_section->name);
5359 /* More paranoia. */
5360 if (cur == NULL || prev == NULL)
5363 /* If the regions are different then force the sections to live in
5364 different segments. See the email thread starting at the following
5365 URL for the reasons why this is necessary:
5366 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5367 return cur->region != prev->region;
5371 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5373 lang_statement_iteration++;
5374 lang_size_sections_1 (&statement_list.head, abs_output_section,
5375 0, 0, relax, check_regions);
5379 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5381 expld.phase = lang_allocating_phase_enum;
5382 expld.dataseg.phase = exp_dataseg_none;
5384 one_lang_size_sections_pass (relax, check_regions);
5385 if (expld.dataseg.phase == exp_dataseg_end_seen
5386 && link_info.relro && expld.dataseg.relro_end)
5388 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5389 to put expld.dataseg.relro on a (common) page boundary. */
5390 bfd_vma min_base, old_base, relro_end, maxpage;
5392 expld.dataseg.phase = exp_dataseg_relro_adjust;
5393 maxpage = expld.dataseg.maxpagesize;
5394 /* MIN_BASE is the absolute minimum address we are allowed to start the
5395 read-write segment (byte before will be mapped read-only). */
5396 min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5397 /* OLD_BASE is the address for a feasible minimum address which will
5398 still not cause a data overlap inside MAXPAGE causing file offset skip
5400 old_base = expld.dataseg.base;
5401 expld.dataseg.base += (-expld.dataseg.relro_end
5402 & (expld.dataseg.pagesize - 1));
5403 /* Compute the expected PT_GNU_RELRO segment end. */
5404 relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5405 & ~(expld.dataseg.pagesize - 1));
5406 if (min_base + maxpage < expld.dataseg.base)
5408 expld.dataseg.base -= maxpage;
5409 relro_end -= maxpage;
5411 lang_reset_memory_regions ();
5412 one_lang_size_sections_pass (relax, check_regions);
5413 if (expld.dataseg.relro_end > relro_end)
5415 /* The alignment of sections between DATA_SEGMENT_ALIGN
5416 and DATA_SEGMENT_RELRO_END caused huge padding to be
5417 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5418 that the section alignments will fit in. */
5420 unsigned int max_alignment_power = 0;
5422 /* Find maximum alignment power of sections between
5423 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5424 for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5425 if (sec->vma >= expld.dataseg.base
5426 && sec->vma < expld.dataseg.relro_end
5427 && sec->alignment_power > max_alignment_power)
5428 max_alignment_power = sec->alignment_power;
5430 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5432 if (expld.dataseg.base - (1 << max_alignment_power) < old_base)
5433 expld.dataseg.base += expld.dataseg.pagesize;
5434 expld.dataseg.base -= (1 << max_alignment_power);
5435 lang_reset_memory_regions ();
5436 one_lang_size_sections_pass (relax, check_regions);
5439 link_info.relro_start = expld.dataseg.base;
5440 link_info.relro_end = expld.dataseg.relro_end;
5442 else if (expld.dataseg.phase == exp_dataseg_end_seen)
5444 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5445 a page could be saved in the data segment. */
5446 bfd_vma first, last;
5448 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5449 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5451 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5452 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5453 && first + last <= expld.dataseg.pagesize)
5455 expld.dataseg.phase = exp_dataseg_adjust;
5456 lang_reset_memory_regions ();
5457 one_lang_size_sections_pass (relax, check_regions);
5460 expld.dataseg.phase = exp_dataseg_done;
5463 expld.dataseg.phase = exp_dataseg_done;
5466 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5469 lang_do_assignments_1 (lang_statement_union_type *s,
5470 lang_output_section_statement_type *current_os,
5474 for (; s != NULL; s = s->header.next)
5476 switch (s->header.type)
5478 case lang_constructors_statement_enum:
5479 dot = lang_do_assignments_1 (constructor_list.head,
5480 current_os, fill, dot);
5483 case lang_output_section_statement_enum:
5485 lang_output_section_statement_type *os;
5487 os = &(s->output_section_statement);
5488 if (os->bfd_section != NULL && !os->ignored)
5490 dot = os->bfd_section->vma;
5492 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5494 /* .tbss sections effectively have zero size. */
5495 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5496 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5497 || link_info.relocatable)
5498 dot += TO_ADDR (os->bfd_section->size);
5500 if (os->update_dot_tree != NULL)
5501 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5506 case lang_wild_statement_enum:
5508 dot = lang_do_assignments_1 (s->wild_statement.children.head,
5509 current_os, fill, dot);
5512 case lang_object_symbols_statement_enum:
5513 case lang_output_statement_enum:
5514 case lang_target_statement_enum:
5517 case lang_data_statement_enum:
5518 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5519 if (expld.result.valid_p)
5521 s->data_statement.value = expld.result.value;
5522 if (expld.result.section != NULL)
5523 s->data_statement.value += expld.result.section->vma;
5526 einfo (_("%F%P: invalid data statement\n"));
5529 switch (s->data_statement.type)
5547 if (size < TO_SIZE ((unsigned) 1))
5548 size = TO_SIZE ((unsigned) 1);
5549 dot += TO_ADDR (size);
5553 case lang_reloc_statement_enum:
5554 exp_fold_tree (s->reloc_statement.addend_exp,
5555 bfd_abs_section_ptr, &dot);
5556 if (expld.result.valid_p)
5557 s->reloc_statement.addend_value = expld.result.value;
5559 einfo (_("%F%P: invalid reloc statement\n"));
5560 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5563 case lang_input_section_enum:
5565 asection *in = s->input_section.section;
5567 if ((in->flags & SEC_EXCLUDE) == 0)
5568 dot += TO_ADDR (in->size);
5572 case lang_input_statement_enum:
5575 case lang_fill_statement_enum:
5576 fill = s->fill_statement.fill;
5579 case lang_assignment_statement_enum:
5580 exp_fold_tree (s->assignment_statement.exp,
5581 current_os->bfd_section,
5585 case lang_padding_statement_enum:
5586 dot += TO_ADDR (s->padding_statement.size);
5589 case lang_group_statement_enum:
5590 dot = lang_do_assignments_1 (s->group_statement.children.head,
5591 current_os, fill, dot);
5594 case lang_insert_statement_enum:
5597 case lang_address_statement_enum:
5609 lang_do_assignments (lang_phase_type phase)
5611 expld.phase = phase;
5612 lang_statement_iteration++;
5613 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5616 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5617 operator .startof. (section_name), it produces an undefined symbol
5618 .startof.section_name. Similarly, when it sees
5619 .sizeof. (section_name), it produces an undefined symbol
5620 .sizeof.section_name. For all the output sections, we look for
5621 such symbols, and set them to the correct value. */
5624 lang_set_startof (void)
5628 if (link_info.relocatable)
5631 for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5633 const char *secname;
5635 struct bfd_link_hash_entry *h;
5637 secname = bfd_get_section_name (link_info.output_bfd, s);
5638 buf = (char *) xmalloc (10 + strlen (secname));
5640 sprintf (buf, ".startof.%s", secname);
5641 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5642 if (h != NULL && h->type == bfd_link_hash_undefined)
5644 h->type = bfd_link_hash_defined;
5645 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5646 h->u.def.section = bfd_abs_section_ptr;
5649 sprintf (buf, ".sizeof.%s", secname);
5650 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5651 if (h != NULL && h->type == bfd_link_hash_undefined)
5653 h->type = bfd_link_hash_defined;
5654 h->u.def.value = TO_ADDR (s->size);
5655 h->u.def.section = bfd_abs_section_ptr;
5665 struct bfd_link_hash_entry *h;
5668 if ((link_info.relocatable && !link_info.gc_sections)
5669 || (link_info.shared && !link_info.executable))
5670 warn = entry_from_cmdline;
5674 /* Force the user to specify a root when generating a relocatable with
5676 if (link_info.gc_sections && link_info.relocatable
5677 && !(entry_from_cmdline || undef_from_cmdline))
5678 einfo (_("%P%F: gc-sections requires either an entry or "
5679 "an undefined symbol\n"));
5681 if (entry_symbol.name == NULL)
5683 /* No entry has been specified. Look for the default entry, but
5684 don't warn if we don't find it. */
5685 entry_symbol.name = entry_symbol_default;
5689 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5690 FALSE, FALSE, TRUE);
5692 && (h->type == bfd_link_hash_defined
5693 || h->type == bfd_link_hash_defweak)
5694 && h->u.def.section->output_section != NULL)
5698 val = (h->u.def.value
5699 + bfd_get_section_vma (link_info.output_bfd,
5700 h->u.def.section->output_section)
5701 + h->u.def.section->output_offset);
5702 if (! bfd_set_start_address (link_info.output_bfd, val))
5703 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5710 /* We couldn't find the entry symbol. Try parsing it as a
5712 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5715 if (! bfd_set_start_address (link_info.output_bfd, val))
5716 einfo (_("%P%F: can't set start address\n"));
5722 /* Can't find the entry symbol, and it's not a number. Use
5723 the first address in the text section. */
5724 ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5728 einfo (_("%P: warning: cannot find entry symbol %s;"
5729 " defaulting to %V\n"),
5731 bfd_get_section_vma (link_info.output_bfd, ts));
5732 if (!(bfd_set_start_address
5733 (link_info.output_bfd,
5734 bfd_get_section_vma (link_info.output_bfd, ts))))
5735 einfo (_("%P%F: can't set start address\n"));
5740 einfo (_("%P: warning: cannot find entry symbol %s;"
5741 " not setting start address\n"),
5747 /* Don't bfd_hash_table_free (&lang_definedness_table);
5748 map file output may result in a call of lang_track_definedness. */
5751 /* This is a small function used when we want to ignore errors from
5755 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5757 /* Don't do anything. */
5760 /* Check that the architecture of all the input files is compatible
5761 with the output file. Also call the backend to let it do any
5762 other checking that is needed. */
5767 lang_statement_union_type *file;
5769 const bfd_arch_info_type *compatible;
5771 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5773 #ifdef ENABLE_PLUGINS
5774 /* Don't check format of files claimed by plugin. */
5775 if (file->input_statement.claimed)
5777 #endif /* ENABLE_PLUGINS */
5778 input_bfd = file->input_statement.the_bfd;
5780 = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5781 command_line.accept_unknown_input_arch);
5783 /* In general it is not possible to perform a relocatable
5784 link between differing object formats when the input
5785 file has relocations, because the relocations in the
5786 input format may not have equivalent representations in
5787 the output format (and besides BFD does not translate
5788 relocs for other link purposes than a final link). */
5789 if ((link_info.relocatable || link_info.emitrelocations)
5790 && (compatible == NULL
5791 || (bfd_get_flavour (input_bfd)
5792 != bfd_get_flavour (link_info.output_bfd)))
5793 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5795 einfo (_("%P%F: Relocatable linking with relocations from"
5796 " format %s (%B) to format %s (%B) is not supported\n"),
5797 bfd_get_target (input_bfd), input_bfd,
5798 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5799 /* einfo with %F exits. */
5802 if (compatible == NULL)
5804 if (command_line.warn_mismatch)
5805 einfo (_("%P%X: %s architecture of input file `%B'"
5806 " is incompatible with %s output\n"),
5807 bfd_printable_name (input_bfd), input_bfd,
5808 bfd_printable_name (link_info.output_bfd));
5810 else if (bfd_count_sections (input_bfd))
5812 /* If the input bfd has no contents, it shouldn't set the
5813 private data of the output bfd. */
5815 bfd_error_handler_type pfn = NULL;
5817 /* If we aren't supposed to warn about mismatched input
5818 files, temporarily set the BFD error handler to a
5819 function which will do nothing. We still want to call
5820 bfd_merge_private_bfd_data, since it may set up
5821 information which is needed in the output file. */
5822 if (! command_line.warn_mismatch)
5823 pfn = bfd_set_error_handler (ignore_bfd_errors);
5824 if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5826 if (command_line.warn_mismatch)
5827 einfo (_("%P%X: failed to merge target specific data"
5828 " of file %B\n"), input_bfd);
5830 if (! command_line.warn_mismatch)
5831 bfd_set_error_handler (pfn);
5836 /* Look through all the global common symbols and attach them to the
5837 correct section. The -sort-common command line switch may be used
5838 to roughly sort the entries by alignment. */
5843 if (command_line.inhibit_common_definition)
5845 if (link_info.relocatable
5846 && ! command_line.force_common_definition)
5849 if (! config.sort_common)
5850 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5855 if (config.sort_common == sort_descending)
5857 for (power = 4; power > 0; power--)
5858 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5861 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5865 for (power = 0; power <= 4; power++)
5866 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5869 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5874 /* Place one common symbol in the correct section. */
5877 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5879 unsigned int power_of_two;
5883 if (h->type != bfd_link_hash_common)
5887 power_of_two = h->u.c.p->alignment_power;
5889 if (config.sort_common == sort_descending
5890 && power_of_two < *(unsigned int *) info)
5892 else if (config.sort_common == sort_ascending
5893 && power_of_two > *(unsigned int *) info)
5896 section = h->u.c.p->section;
5897 if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
5898 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5901 if (config.map_file != NULL)
5903 static bfd_boolean header_printed;
5908 if (! header_printed)
5910 minfo (_("\nAllocating common symbols\n"));
5911 minfo (_("Common symbol size file\n\n"));
5912 header_printed = TRUE;
5915 name = bfd_demangle (link_info.output_bfd, h->root.string,
5916 DMGL_ANSI | DMGL_PARAMS);
5919 minfo ("%s", h->root.string);
5920 len = strlen (h->root.string);
5925 len = strlen (name);
5941 if (size <= 0xffffffff)
5942 sprintf (buf, "%lx", (unsigned long) size);
5944 sprintf_vma (buf, size);
5954 minfo ("%B\n", section->owner);
5960 /* Run through the input files and ensure that every input section has
5961 somewhere to go. If one is found without a destination then create
5962 an input request and place it into the statement tree. */
5965 lang_place_orphans (void)
5967 LANG_FOR_EACH_INPUT_STATEMENT (file)
5971 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5973 if (s->output_section == NULL)
5975 /* This section of the file is not attached, root
5976 around for a sensible place for it to go. */
5978 if (file->just_syms_flag)
5979 bfd_link_just_syms (file->the_bfd, s, &link_info);
5980 else if ((s->flags & SEC_EXCLUDE) != 0)
5981 s->output_section = bfd_abs_section_ptr;
5982 else if (strcmp (s->name, "COMMON") == 0)
5984 /* This is a lonely common section which must have
5985 come from an archive. We attach to the section
5986 with the wildcard. */
5987 if (! link_info.relocatable
5988 || command_line.force_common_definition)
5990 if (default_common_section == NULL)
5991 default_common_section
5992 = lang_output_section_statement_lookup (".bss", 0,
5994 lang_add_section (&default_common_section->children, s,
5995 default_common_section);
6000 const char *name = s->name;
6003 if (config.unique_orphan_sections
6004 || unique_section_p (s, NULL))
6005 constraint = SPECIAL;
6007 if (!ldemul_place_orphan (s, name, constraint))
6009 lang_output_section_statement_type *os;
6010 os = lang_output_section_statement_lookup (name,
6013 if (os->addr_tree == NULL
6014 && (link_info.relocatable
6015 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
6016 os->addr_tree = exp_intop (0);
6017 lang_add_section (&os->children, s, os);
6026 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
6028 flagword *ptr_flags;
6030 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
6036 *ptr_flags |= SEC_ALLOC;
6040 *ptr_flags |= SEC_READONLY;
6044 *ptr_flags |= SEC_DATA;
6048 *ptr_flags |= SEC_CODE;
6053 *ptr_flags |= SEC_LOAD;
6057 einfo (_("%P%F: invalid syntax in flags\n"));
6064 /* Call a function on each input file. This function will be called
6065 on an archive, but not on the elements. */
6068 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
6070 lang_input_statement_type *f;
6072 for (f = (lang_input_statement_type *) input_file_chain.head;
6074 f = (lang_input_statement_type *) f->next_real_file)
6078 /* Call a function on each file. The function will be called on all
6079 the elements of an archive which are included in the link, but will
6080 not be called on the archive file itself. */
6083 lang_for_each_file (void (*func) (lang_input_statement_type *))
6085 LANG_FOR_EACH_INPUT_STATEMENT (f)
6092 ldlang_add_file (lang_input_statement_type *entry)
6094 lang_statement_append (&file_chain,
6095 (lang_statement_union_type *) entry,
6098 /* The BFD linker needs to have a list of all input BFDs involved in
6100 ASSERT (entry->the_bfd->link_next == NULL);
6101 ASSERT (entry->the_bfd != link_info.output_bfd);
6103 *link_info.input_bfds_tail = entry->the_bfd;
6104 link_info.input_bfds_tail = &entry->the_bfd->link_next;
6105 entry->the_bfd->usrdata = entry;
6106 bfd_set_gp_size (entry->the_bfd, g_switch_value);
6108 /* Look through the sections and check for any which should not be
6109 included in the link. We need to do this now, so that we can
6110 notice when the backend linker tries to report multiple
6111 definition errors for symbols which are in sections we aren't
6112 going to link. FIXME: It might be better to entirely ignore
6113 symbols which are defined in sections which are going to be
6114 discarded. This would require modifying the backend linker for
6115 each backend which might set the SEC_LINK_ONCE flag. If we do
6116 this, we should probably handle SEC_EXCLUDE in the same way. */
6118 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
6122 lang_add_output (const char *name, int from_script)
6124 /* Make -o on command line override OUTPUT in script. */
6125 if (!had_output_filename || !from_script)
6127 output_filename = name;
6128 had_output_filename = TRUE;
6132 static lang_output_section_statement_type *current_section;
6143 for (l = 0; l < 32; l++)
6145 if (i >= (unsigned int) x)
6153 lang_output_section_statement_type *
6154 lang_enter_output_section_statement (const char *output_section_statement_name,
6155 etree_type *address_exp,
6156 enum section_type sectype,
6158 etree_type *subalign,
6162 lang_output_section_statement_type *os;
6164 os = lang_output_section_statement_lookup (output_section_statement_name,
6166 current_section = os;
6168 if (os->addr_tree == NULL)
6170 os->addr_tree = address_exp;
6172 os->sectype = sectype;
6173 if (sectype != noload_section)
6174 os->flags = SEC_NO_FLAGS;
6176 os->flags = SEC_NEVER_LOAD;
6177 os->block_value = 1;
6179 /* Make next things chain into subchain of this. */
6180 push_stat_ptr (&os->children);
6182 os->subsection_alignment =
6183 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
6184 os->section_alignment =
6185 topower (exp_get_value_int (align, -1, "section alignment"));
6187 os->load_base = ebase;
6194 lang_output_statement_type *new_stmt;
6196 new_stmt = new_stat (lang_output_statement, stat_ptr);
6197 new_stmt->name = output_filename;
6201 /* Reset the current counters in the regions. */
6204 lang_reset_memory_regions (void)
6206 lang_memory_region_type *p = lang_memory_region_list;
6208 lang_output_section_statement_type *os;
6210 for (p = lang_memory_region_list; p != NULL; p = p->next)
6212 p->current = p->origin;
6216 for (os = &lang_output_section_statement.head->output_section_statement;
6220 os->processed_vma = FALSE;
6221 os->processed_lma = FALSE;
6224 for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
6226 /* Save the last size for possible use by bfd_relax_section. */
6227 o->rawsize = o->size;
6232 /* Worker for lang_gc_sections_1. */
6235 gc_section_callback (lang_wild_statement_type *ptr,
6236 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6238 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6239 void *data ATTRIBUTE_UNUSED)
6241 /* If the wild pattern was marked KEEP, the member sections
6242 should be as well. */
6243 if (ptr->keep_sections)
6244 section->flags |= SEC_KEEP;
6247 /* Iterate over sections marking them against GC. */
6250 lang_gc_sections_1 (lang_statement_union_type *s)
6252 for (; s != NULL; s = s->header.next)
6254 switch (s->header.type)
6256 case lang_wild_statement_enum:
6257 walk_wild (&s->wild_statement, gc_section_callback, NULL);
6259 case lang_constructors_statement_enum:
6260 lang_gc_sections_1 (constructor_list.head);
6262 case lang_output_section_statement_enum:
6263 lang_gc_sections_1 (s->output_section_statement.children.head);
6265 case lang_group_statement_enum:
6266 lang_gc_sections_1 (s->group_statement.children.head);
6275 lang_gc_sections (void)
6277 /* Keep all sections so marked in the link script. */
6279 lang_gc_sections_1 (statement_list.head);
6281 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6282 the special case of debug info. (See bfd/stabs.c)
6283 Twiddle the flag here, to simplify later linker code. */
6284 if (link_info.relocatable)
6286 LANG_FOR_EACH_INPUT_STATEMENT (f)
6289 #ifdef ENABLE_PLUGINS
6293 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6294 if ((sec->flags & SEC_DEBUGGING) == 0)
6295 sec->flags &= ~SEC_EXCLUDE;
6299 if (link_info.gc_sections)
6300 bfd_gc_sections (link_info.output_bfd, &link_info);
6303 /* Worker for lang_find_relro_sections_1. */
6306 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6307 struct wildcard_list *sec ATTRIBUTE_UNUSED,
6309 lang_input_statement_type *file ATTRIBUTE_UNUSED,
6312 /* Discarded, excluded and ignored sections effectively have zero
6314 if (section->output_section != NULL
6315 && section->output_section->owner == link_info.output_bfd
6316 && (section->output_section->flags & SEC_EXCLUDE) == 0
6317 && !IGNORE_SECTION (section)
6318 && section->size != 0)
6320 bfd_boolean *has_relro_section = (bfd_boolean *) data;
6321 *has_relro_section = TRUE;
6325 /* Iterate over sections for relro sections. */
6328 lang_find_relro_sections_1 (lang_statement_union_type *s,
6329 bfd_boolean *has_relro_section)
6331 if (*has_relro_section)
6334 for (; s != NULL; s = s->header.next)
6336 if (s == expld.dataseg.relro_end_stat)
6339 switch (s->header.type)
6341 case lang_wild_statement_enum:
6342 walk_wild (&s->wild_statement,
6343 find_relro_section_callback,
6346 case lang_constructors_statement_enum:
6347 lang_find_relro_sections_1 (constructor_list.head,
6350 case lang_output_section_statement_enum:
6351 lang_find_relro_sections_1 (s->output_section_statement.children.head,
6354 case lang_group_statement_enum:
6355 lang_find_relro_sections_1 (s->group_statement.children.head,
6365 lang_find_relro_sections (void)
6367 bfd_boolean has_relro_section = FALSE;
6369 /* Check all sections in the link script. */
6371 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6372 &has_relro_section);
6374 if (!has_relro_section)
6375 link_info.relro = FALSE;
6378 /* Relax all sections until bfd_relax_section gives up. */
6381 lang_relax_sections (bfd_boolean need_layout)
6383 if (RELAXATION_ENABLED)
6385 /* We may need more than one relaxation pass. */
6386 int i = link_info.relax_pass;
6388 /* The backend can use it to determine the current pass. */
6389 link_info.relax_pass = 0;
6393 /* Keep relaxing until bfd_relax_section gives up. */
6394 bfd_boolean relax_again;
6396 link_info.relax_trip = -1;
6399 link_info.relax_trip++;
6401 /* Note: pe-dll.c does something like this also. If you find
6402 you need to change this code, you probably need to change
6403 pe-dll.c also. DJ */
6405 /* Do all the assignments with our current guesses as to
6407 lang_do_assignments (lang_assigning_phase_enum);
6409 /* We must do this after lang_do_assignments, because it uses
6411 lang_reset_memory_regions ();
6413 /* Perform another relax pass - this time we know where the
6414 globals are, so can make a better guess. */
6415 relax_again = FALSE;
6416 lang_size_sections (&relax_again, FALSE);
6418 while (relax_again);
6420 link_info.relax_pass++;
6427 /* Final extra sizing to report errors. */
6428 lang_do_assignments (lang_assigning_phase_enum);
6429 lang_reset_memory_regions ();
6430 lang_size_sections (NULL, TRUE);
6434 #ifdef ENABLE_PLUGINS
6435 /* Find the insert point for the plugin's replacement files. We
6436 place them after the first claimed real object file, or if the
6437 first claimed object is an archive member, after the last real
6438 object file immediately preceding the archive. In the event
6439 no objects have been claimed at all, we return the first dummy
6440 object file on the list as the insert point; that works, but
6441 the callee must be careful when relinking the file_chain as it
6442 is not actually on that chain, only the statement_list and the
6443 input_file list; in that case, the replacement files must be
6444 inserted at the head of the file_chain. */
6446 static lang_input_statement_type *
6447 find_replacements_insert_point (void)
6449 lang_input_statement_type *claim1, *lastobject;
6450 lastobject = &input_file_chain.head->input_statement;
6451 for (claim1 = &file_chain.head->input_statement;
6453 claim1 = &claim1->next->input_statement)
6455 if (claim1->claimed)
6456 return claim1->claim_archive ? lastobject : claim1;
6457 /* Update lastobject if this is a real object file. */
6458 if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))
6459 lastobject = claim1;
6461 /* No files were claimed by the plugin. Choose the last object
6462 file found on the list (maybe the first, dummy entry) as the
6467 /* Insert SRCLIST into DESTLIST after given element by chaining
6468 on FIELD as the next-pointer. (Counterintuitively does not need
6469 a pointer to the actual after-node itself, just its chain field.) */
6472 lang_list_insert_after (lang_statement_list_type *destlist,
6473 lang_statement_list_type *srclist,
6474 lang_statement_union_type **field)
6476 *(srclist->tail) = *field;
6477 *field = srclist->head;
6478 if (destlist->tail == field)
6479 destlist->tail = srclist->tail;
6482 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6483 was taken as a copy of it and leave them in ORIGLIST. */
6486 lang_list_remove_tail (lang_statement_list_type *destlist,
6487 lang_statement_list_type *origlist)
6489 union lang_statement_union **savetail;
6490 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6491 ASSERT (origlist->head == destlist->head);
6492 savetail = origlist->tail;
6493 origlist->head = *(savetail);
6494 origlist->tail = destlist->tail;
6495 destlist->tail = savetail;
6498 #endif /* ENABLE_PLUGINS */
6503 /* Finalize dynamic list. */
6504 if (link_info.dynamic_list)
6505 lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6507 current_target = default_target;
6509 /* Open the output file. */
6510 lang_for_each_statement (ldlang_open_output);
6513 ldemul_create_output_section_statements ();
6515 /* Add to the hash table all undefineds on the command line. */
6516 lang_place_undefineds ();
6518 if (!bfd_section_already_linked_table_init ())
6519 einfo (_("%P%F: Failed to create hash table\n"));
6521 /* Create a bfd for each input file. */
6522 current_target = default_target;
6523 open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);
6525 #ifdef ENABLE_PLUGINS
6526 if (plugin_active_plugins_p ())
6528 lang_statement_list_type added;
6529 lang_statement_list_type files, inputfiles;
6531 /* Now all files are read, let the plugin(s) decide if there
6532 are any more to be added to the link before we call the
6533 emulation's after_open hook. We create a private list of
6534 input statements for this purpose, which we will eventually
6535 insert into the global statment list after the first claimed
6538 /* We need to manipulate all three chains in synchrony. */
6540 inputfiles = input_file_chain;
6541 if (plugin_call_all_symbols_read ())
6542 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6543 plugin_error_plugin ());
6544 /* Open any newly added files, updating the file chains. */
6545 open_input_bfds (added.head, OPEN_BFD_NORMAL);
6546 /* Restore the global list pointer now they have all been added. */
6547 lang_list_remove_tail (stat_ptr, &added);
6548 /* And detach the fresh ends of the file lists. */
6549 lang_list_remove_tail (&file_chain, &files);
6550 lang_list_remove_tail (&input_file_chain, &inputfiles);
6551 /* Were any new files added? */
6552 if (added.head != NULL)
6554 /* If so, we will insert them into the statement list immediately
6555 after the first input file that was claimed by the plugin. */
6556 plugin_insert = find_replacements_insert_point ();
6557 /* If a plugin adds input files without having claimed any, we
6558 don't really have a good idea where to place them. Just putting
6559 them at the start or end of the list is liable to leave them
6560 outside the crtbegin...crtend range. */
6561 ASSERT (plugin_insert != NULL);
6562 /* Splice the new statement list into the old one. */
6563 lang_list_insert_after (stat_ptr, &added,
6564 &plugin_insert->header.next);
6565 /* Likewise for the file chains. */
6566 lang_list_insert_after (&input_file_chain, &inputfiles,
6567 &plugin_insert->next_real_file);
6568 /* We must be careful when relinking file_chain; we may need to
6569 insert the new files at the head of the list if the insert
6570 point chosen is the dummy first input file. */
6571 if (plugin_insert->filename)
6572 lang_list_insert_after (&file_chain, &files, &plugin_insert->next);
6574 lang_list_insert_after (&file_chain, &files, &file_chain.head);
6576 /* Rescan archives in case new undefined symbols have appeared. */
6577 open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);
6580 #endif /* ENABLE_PLUGINS */
6582 link_info.gc_sym_list = &entry_symbol;
6583 if (entry_symbol.name == NULL)
6584 link_info.gc_sym_list = ldlang_undef_chain_list_head;
6586 ldemul_after_open ();
6588 bfd_section_already_linked_table_free ();
6590 /* Make sure that we're not mixing architectures. We call this
6591 after all the input files have been opened, but before we do any
6592 other processing, so that any operations merge_private_bfd_data
6593 does on the output file will be known during the rest of the
6597 /* Handle .exports instead of a version script if we're told to do so. */
6598 if (command_line.version_exports_section)
6599 lang_do_version_exports_section ();
6601 /* Build all sets based on the information gathered from the input
6603 ldctor_build_sets ();
6605 /* Remove unreferenced sections if asked to. */
6606 lang_gc_sections ();
6608 /* Size up the common data. */
6611 /* Update wild statements. */
6612 update_wild_statements (statement_list.head);
6614 /* Run through the contours of the script and attach input sections
6615 to the correct output sections. */
6616 lang_statement_iteration++;
6617 map_input_to_output_sections (statement_list.head, NULL, NULL);
6619 process_insert_statements ();
6621 /* Find any sections not attached explicitly and handle them. */
6622 lang_place_orphans ();
6624 if (! link_info.relocatable)
6628 /* Merge SEC_MERGE sections. This has to be done after GC of
6629 sections, so that GCed sections are not merged, but before
6630 assigning dynamic symbols, since removing whole input sections
6632 bfd_merge_sections (link_info.output_bfd, &link_info);
6634 /* Look for a text section and set the readonly attribute in it. */
6635 found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6639 if (config.text_read_only)
6640 found->flags |= SEC_READONLY;
6642 found->flags &= ~SEC_READONLY;
6646 /* Do anything special before sizing sections. This is where ELF
6647 and other back-ends size dynamic sections. */
6648 ldemul_before_allocation ();
6650 /* We must record the program headers before we try to fix the
6651 section positions, since they will affect SIZEOF_HEADERS. */
6652 lang_record_phdrs ();
6654 /* Check relro sections. */
6655 if (link_info.relro && ! link_info.relocatable)
6656 lang_find_relro_sections ();
6658 /* Size up the sections. */
6659 lang_size_sections (NULL, ! RELAXATION_ENABLED);
6661 /* See if anything special should be done now we know how big
6662 everything is. This is where relaxation is done. */
6663 ldemul_after_allocation ();
6665 /* Fix any .startof. or .sizeof. symbols. */
6666 lang_set_startof ();
6668 /* Do all the assignments, now that we know the final resting places
6669 of all the symbols. */
6670 lang_do_assignments (lang_final_phase_enum);
6674 /* Make sure that the section addresses make sense. */
6675 if (command_line.check_section_addresses)
6676 lang_check_section_addresses ();
6681 /* EXPORTED TO YACC */
6684 lang_add_wild (struct wildcard_spec *filespec,
6685 struct wildcard_list *section_list,
6686 bfd_boolean keep_sections)
6688 struct wildcard_list *curr, *next;
6689 lang_wild_statement_type *new_stmt;
6691 /* Reverse the list as the parser puts it back to front. */
6692 for (curr = section_list, section_list = NULL;
6694 section_list = curr, curr = next)
6696 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6697 placed_commons = TRUE;
6700 curr->next = section_list;
6703 if (filespec != NULL && filespec->name != NULL)
6705 if (strcmp (filespec->name, "*") == 0)
6706 filespec->name = NULL;
6707 else if (! wildcardp (filespec->name))
6708 lang_has_input_file = TRUE;
6711 new_stmt = new_stat (lang_wild_statement, stat_ptr);
6712 new_stmt->filename = NULL;
6713 new_stmt->filenames_sorted = FALSE;
6714 if (filespec != NULL)
6716 new_stmt->filename = filespec->name;
6717 new_stmt->filenames_sorted = filespec->sorted == by_name;
6719 new_stmt->section_list = section_list;
6720 new_stmt->keep_sections = keep_sections;
6721 lang_list_init (&new_stmt->children);
6722 analyze_walk_wild_section_handler (new_stmt);
6726 lang_section_start (const char *name, etree_type *address,
6727 const segment_type *segment)
6729 lang_address_statement_type *ad;
6731 ad = new_stat (lang_address_statement, stat_ptr);
6732 ad->section_name = name;
6733 ad->address = address;
6734 ad->segment = segment;
6737 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6738 because of a -e argument on the command line, or zero if this is
6739 called by ENTRY in a linker script. Command line arguments take
6743 lang_add_entry (const char *name, bfd_boolean cmdline)
6745 if (entry_symbol.name == NULL
6747 || ! entry_from_cmdline)
6749 entry_symbol.name = name;
6750 entry_from_cmdline = cmdline;
6754 /* Set the default start symbol to NAME. .em files should use this,
6755 not lang_add_entry, to override the use of "start" if neither the
6756 linker script nor the command line specifies an entry point. NAME
6757 must be permanently allocated. */
6759 lang_default_entry (const char *name)
6761 entry_symbol_default = name;
6765 lang_add_target (const char *name)
6767 lang_target_statement_type *new_stmt;
6769 new_stmt = new_stat (lang_target_statement, stat_ptr);
6770 new_stmt->target = name;
6774 lang_add_map (const char *name)
6781 map_option_f = TRUE;
6789 lang_add_fill (fill_type *fill)
6791 lang_fill_statement_type *new_stmt;
6793 new_stmt = new_stat (lang_fill_statement, stat_ptr);
6794 new_stmt->fill = fill;
6798 lang_add_data (int type, union etree_union *exp)
6800 lang_data_statement_type *new_stmt;
6802 new_stmt = new_stat (lang_data_statement, stat_ptr);
6803 new_stmt->exp = exp;
6804 new_stmt->type = type;
6807 /* Create a new reloc statement. RELOC is the BFD relocation type to
6808 generate. HOWTO is the corresponding howto structure (we could
6809 look this up, but the caller has already done so). SECTION is the
6810 section to generate a reloc against, or NAME is the name of the
6811 symbol to generate a reloc against. Exactly one of SECTION and
6812 NAME must be NULL. ADDEND is an expression for the addend. */
6815 lang_add_reloc (bfd_reloc_code_real_type reloc,
6816 reloc_howto_type *howto,
6819 union etree_union *addend)
6821 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6825 p->section = section;
6827 p->addend_exp = addend;
6829 p->addend_value = 0;
6830 p->output_section = NULL;
6831 p->output_offset = 0;
6834 lang_assignment_statement_type *
6835 lang_add_assignment (etree_type *exp)
6837 lang_assignment_statement_type *new_stmt;
6839 new_stmt = new_stat (lang_assignment_statement, stat_ptr);
6840 new_stmt->exp = exp;
6845 lang_add_attribute (enum statement_enum attribute)
6847 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6851 lang_startup (const char *name)
6853 if (first_file->filename != NULL)
6855 einfo (_("%P%F: multiple STARTUP files\n"));
6857 first_file->filename = name;
6858 first_file->local_sym_name = name;
6859 first_file->real = TRUE;
6863 lang_float (bfd_boolean maybe)
6865 lang_float_flag = maybe;
6869 /* Work out the load- and run-time regions from a script statement, and
6870 store them in *LMA_REGION and *REGION respectively.
6872 MEMSPEC is the name of the run-time region, or the value of
6873 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6874 LMA_MEMSPEC is the name of the load-time region, or null if the
6875 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6876 had an explicit load address.
6878 It is an error to specify both a load region and a load address. */
6881 lang_get_regions (lang_memory_region_type **region,
6882 lang_memory_region_type **lma_region,
6883 const char *memspec,
6884 const char *lma_memspec,
6885 bfd_boolean have_lma,
6886 bfd_boolean have_vma)
6888 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6890 /* If no runtime region or VMA has been specified, but the load region
6891 has been specified, then use the load region for the runtime region
6893 if (lma_memspec != NULL
6895 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6896 *region = *lma_region;
6898 *region = lang_memory_region_lookup (memspec, FALSE);
6900 if (have_lma && lma_memspec != 0)
6901 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6905 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6906 lang_output_section_phdr_list *phdrs,
6907 const char *lma_memspec)
6909 lang_get_regions (¤t_section->region,
6910 ¤t_section->lma_region,
6911 memspec, lma_memspec,
6912 current_section->load_base != NULL,
6913 current_section->addr_tree != NULL);
6915 /* If this section has no load region or base, but has the same
6916 region as the previous section, then propagate the previous
6917 section's load region. */
6919 if (!current_section->lma_region && !current_section->load_base
6920 && current_section->region == current_section->prev->region)
6921 current_section->lma_region = current_section->prev->lma_region;
6923 current_section->fill = fill;
6924 current_section->phdrs = phdrs;
6928 /* Create an absolute symbol with the given name with the value of the
6929 address of first byte of the section named.
6931 If the symbol already exists, then do nothing. */
6934 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6936 struct bfd_link_hash_entry *h;
6938 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6940 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6942 if (h->type == bfd_link_hash_new
6943 || h->type == bfd_link_hash_undefined)
6947 h->type = bfd_link_hash_defined;
6949 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6953 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
6955 h->u.def.section = bfd_abs_section_ptr;
6959 /* Create an absolute symbol with the given name with the value of the
6960 address of the first byte after the end of the section named.
6962 If the symbol already exists, then do nothing. */
6965 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6967 struct bfd_link_hash_entry *h;
6969 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6971 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6973 if (h->type == bfd_link_hash_new
6974 || h->type == bfd_link_hash_undefined)
6978 h->type = bfd_link_hash_defined;
6980 sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6984 h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
6985 + TO_ADDR (sec->size));
6987 h->u.def.section = bfd_abs_section_ptr;
6992 lang_statement_append (lang_statement_list_type *list,
6993 lang_statement_union_type *element,
6994 lang_statement_union_type **field)
6996 *(list->tail) = element;
7000 /* Set the output format type. -oformat overrides scripts. */
7003 lang_add_output_format (const char *format,
7008 if (output_target == NULL || !from_script)
7010 if (command_line.endian == ENDIAN_BIG
7013 else if (command_line.endian == ENDIAN_LITTLE
7017 output_target = format;
7022 lang_add_insert (const char *where, int is_before)
7024 lang_insert_statement_type *new_stmt;
7026 new_stmt = new_stat (lang_insert_statement, stat_ptr);
7027 new_stmt->where = where;
7028 new_stmt->is_before = is_before;
7029 saved_script_handle = previous_script_handle;
7032 /* Enter a group. This creates a new lang_group_statement, and sets
7033 stat_ptr to build new statements within the group. */
7036 lang_enter_group (void)
7038 lang_group_statement_type *g;
7040 g = new_stat (lang_group_statement, stat_ptr);
7041 lang_list_init (&g->children);
7042 push_stat_ptr (&g->children);
7045 /* Leave a group. This just resets stat_ptr to start writing to the
7046 regular list of statements again. Note that this will not work if
7047 groups can occur inside anything else which can adjust stat_ptr,
7048 but currently they can't. */
7051 lang_leave_group (void)
7056 /* Add a new program header. This is called for each entry in a PHDRS
7057 command in a linker script. */
7060 lang_new_phdr (const char *name,
7062 bfd_boolean filehdr,
7067 struct lang_phdr *n, **pp;
7070 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
7073 n->type = exp_get_value_int (type, 0, "program header type");
7074 n->filehdr = filehdr;
7079 hdrs = n->type == 1 && (phdrs || filehdr);
7081 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
7084 && !((*pp)->filehdr || (*pp)->phdrs))
7086 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));
7093 /* Record the program header information in the output BFD. FIXME: We
7094 should not be calling an ELF specific function here. */
7097 lang_record_phdrs (void)
7101 lang_output_section_phdr_list *last;
7102 struct lang_phdr *l;
7103 lang_output_section_statement_type *os;
7106 secs = (asection **) xmalloc (alc * sizeof (asection *));
7109 for (l = lang_phdr_list; l != NULL; l = l->next)
7116 for (os = &lang_output_section_statement.head->output_section_statement;
7120 lang_output_section_phdr_list *pl;
7122 if (os->constraint < 0)
7130 if (os->sectype == noload_section
7131 || os->bfd_section == NULL
7132 || (os->bfd_section->flags & SEC_ALLOC) == 0)
7135 /* Don't add orphans to PT_INTERP header. */
7141 lang_output_section_statement_type * tmp_os;
7143 /* If we have not run across a section with a program
7144 header assigned to it yet, then scan forwards to find
7145 one. This prevents inconsistencies in the linker's
7146 behaviour when a script has specified just a single
7147 header and there are sections in that script which are
7148 not assigned to it, and which occur before the first
7149 use of that header. See here for more details:
7150 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7151 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
7154 last = tmp_os->phdrs;
7158 einfo (_("%F%P: no sections assigned to phdrs\n"));
7163 if (os->bfd_section == NULL)
7166 for (; pl != NULL; pl = pl->next)
7168 if (strcmp (pl->name, l->name) == 0)
7173 secs = (asection **) xrealloc (secs,
7174 alc * sizeof (asection *));
7176 secs[c] = os->bfd_section;
7183 if (l->flags == NULL)
7186 flags = exp_get_vma (l->flags, 0, "phdr flags");
7191 at = exp_get_vma (l->at, 0, "phdr load address");
7193 if (! bfd_record_phdr (link_info.output_bfd, l->type,
7194 l->flags != NULL, flags, l->at != NULL,
7195 at, l->filehdr, l->phdrs, c, secs))
7196 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7201 /* Make sure all the phdr assignments succeeded. */
7202 for (os = &lang_output_section_statement.head->output_section_statement;
7206 lang_output_section_phdr_list *pl;
7208 if (os->constraint < 0
7209 || os->bfd_section == NULL)
7212 for (pl = os->phdrs;
7215 if (! pl->used && strcmp (pl->name, "NONE") != 0)
7216 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7217 os->name, pl->name);
7221 /* Record a list of sections which may not be cross referenced. */
7224 lang_add_nocrossref (lang_nocrossref_type *l)
7226 struct lang_nocrossrefs *n;
7228 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
7229 n->next = nocrossref_list;
7231 nocrossref_list = n;
7233 /* Set notice_all so that we get informed about all symbols. */
7234 link_info.notice_all = TRUE;
7237 /* Overlay handling. We handle overlays with some static variables. */
7239 /* The overlay virtual address. */
7240 static etree_type *overlay_vma;
7241 /* And subsection alignment. */
7242 static etree_type *overlay_subalign;
7244 /* An expression for the maximum section size seen so far. */
7245 static etree_type *overlay_max;
7247 /* A list of all the sections in this overlay. */
7249 struct overlay_list {
7250 struct overlay_list *next;
7251 lang_output_section_statement_type *os;
7254 static struct overlay_list *overlay_list;
7256 /* Start handling an overlay. */
7259 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
7261 /* The grammar should prevent nested overlays from occurring. */
7262 ASSERT (overlay_vma == NULL
7263 && overlay_subalign == NULL
7264 && overlay_max == NULL);
7266 overlay_vma = vma_expr;
7267 overlay_subalign = subalign;
7270 /* Start a section in an overlay. We handle this by calling
7271 lang_enter_output_section_statement with the correct VMA.
7272 lang_leave_overlay sets up the LMA and memory regions. */
7275 lang_enter_overlay_section (const char *name)
7277 struct overlay_list *n;
7280 lang_enter_output_section_statement (name, overlay_vma, overlay_section,
7281 0, overlay_subalign, 0, 0);
7283 /* If this is the first section, then base the VMA of future
7284 sections on this one. This will work correctly even if `.' is
7285 used in the addresses. */
7286 if (overlay_list == NULL)
7287 overlay_vma = exp_nameop (ADDR, name);
7289 /* Remember the section. */
7290 n = (struct overlay_list *) xmalloc (sizeof *n);
7291 n->os = current_section;
7292 n->next = overlay_list;
7295 size = exp_nameop (SIZEOF, name);
7297 /* Arrange to work out the maximum section end address. */
7298 if (overlay_max == NULL)
7301 overlay_max = exp_binop (MAX_K, overlay_max, size);
7304 /* Finish a section in an overlay. There isn't any special to do
7308 lang_leave_overlay_section (fill_type *fill,
7309 lang_output_section_phdr_list *phdrs)
7316 name = current_section->name;
7318 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7319 region and that no load-time region has been specified. It doesn't
7320 really matter what we say here, since lang_leave_overlay will
7322 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
7324 /* Define the magic symbols. */
7326 clean = (char *) xmalloc (strlen (name) + 1);
7328 for (s1 = name; *s1 != '\0'; s1++)
7329 if (ISALNUM (*s1) || *s1 == '_')
7333 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
7334 sprintf (buf, "__load_start_%s", clean);
7335 lang_add_assignment (exp_provide (buf,
7336 exp_nameop (LOADADDR, name),
7339 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
7340 sprintf (buf, "__load_stop_%s", clean);
7341 lang_add_assignment (exp_provide (buf,
7343 exp_nameop (LOADADDR, name),
7344 exp_nameop (SIZEOF, name)),
7350 /* Finish an overlay. If there are any overlay wide settings, this
7351 looks through all the sections in the overlay and sets them. */
7354 lang_leave_overlay (etree_type *lma_expr,
7357 const char *memspec,
7358 lang_output_section_phdr_list *phdrs,
7359 const char *lma_memspec)
7361 lang_memory_region_type *region;
7362 lang_memory_region_type *lma_region;
7363 struct overlay_list *l;
7364 lang_nocrossref_type *nocrossref;
7366 lang_get_regions (®ion, &lma_region,
7367 memspec, lma_memspec,
7368 lma_expr != NULL, FALSE);
7372 /* After setting the size of the last section, set '.' to end of the
7374 if (overlay_list != NULL)
7375 overlay_list->os->update_dot_tree
7376 = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));
7381 struct overlay_list *next;
7383 if (fill != NULL && l->os->fill == NULL)
7386 l->os->region = region;
7387 l->os->lma_region = lma_region;
7389 /* The first section has the load address specified in the
7390 OVERLAY statement. The rest are worked out from that.
7391 The base address is not needed (and should be null) if
7392 an LMA region was specified. */
7395 l->os->load_base = lma_expr;
7396 l->os->sectype = normal_section;
7398 if (phdrs != NULL && l->os->phdrs == NULL)
7399 l->os->phdrs = phdrs;
7403 lang_nocrossref_type *nc;
7405 nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
7406 nc->name = l->os->name;
7407 nc->next = nocrossref;
7416 if (nocrossref != NULL)
7417 lang_add_nocrossref (nocrossref);
7420 overlay_list = NULL;
7424 /* Version handling. This is only useful for ELF. */
7426 /* This global variable holds the version tree that we build. */
7428 struct bfd_elf_version_tree *lang_elf_version_info;
7430 /* If PREV is NULL, return first version pattern matching particular symbol.
7431 If PREV is non-NULL, return first version pattern matching particular
7432 symbol after PREV (previously returned by lang_vers_match). */
7434 static struct bfd_elf_version_expr *
7435 lang_vers_match (struct bfd_elf_version_expr_head *head,
7436 struct bfd_elf_version_expr *prev,
7440 const char *cxx_sym = sym;
7441 const char *java_sym = sym;
7442 struct bfd_elf_version_expr *expr = NULL;
7443 enum demangling_styles curr_style;
7445 curr_style = CURRENT_DEMANGLING_STYLE;
7446 cplus_demangle_set_style (no_demangling);
7447 c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);
7450 cplus_demangle_set_style (curr_style);
7452 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7454 cxx_sym = bfd_demangle (link_info.output_bfd, sym,
7455 DMGL_PARAMS | DMGL_ANSI);
7459 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7461 java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);
7466 if (head->htab && (prev == NULL || prev->literal))
7468 struct bfd_elf_version_expr e;
7470 switch (prev ? prev->mask : 0)
7473 if (head->mask & BFD_ELF_VERSION_C_TYPE)
7476 expr = (struct bfd_elf_version_expr *)
7477 htab_find ((htab_t) head->htab, &e);
7478 while (expr && strcmp (expr->pattern, c_sym) == 0)
7479 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7485 case BFD_ELF_VERSION_C_TYPE:
7486 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7488 e.pattern = cxx_sym;
7489 expr = (struct bfd_elf_version_expr *)
7490 htab_find ((htab_t) head->htab, &e);
7491 while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7492 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7498 case BFD_ELF_VERSION_CXX_TYPE:
7499 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7501 e.pattern = java_sym;
7502 expr = (struct bfd_elf_version_expr *)
7503 htab_find ((htab_t) head->htab, &e);
7504 while (expr && strcmp (expr->pattern, java_sym) == 0)
7505 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7516 /* Finally, try the wildcards. */
7517 if (prev == NULL || prev->literal)
7518 expr = head->remaining;
7521 for (; expr; expr = expr->next)
7528 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7531 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7533 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7537 if (fnmatch (expr->pattern, s, 0) == 0)
7543 free ((char *) c_sym);
7545 free ((char *) cxx_sym);
7546 if (java_sym != sym)
7547 free ((char *) java_sym);
7551 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7552 return a pointer to the symbol name with any backslash quotes removed. */
7555 realsymbol (const char *pattern)
7558 bfd_boolean changed = FALSE, backslash = FALSE;
7559 char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
7561 for (p = pattern, s = symbol; *p != '\0'; ++p)
7563 /* It is a glob pattern only if there is no preceding
7567 /* Remove the preceding backslash. */
7574 if (*p == '?' || *p == '*' || *p == '[')
7581 backslash = *p == '\\';
7597 /* This is called for each variable name or match expression. NEW_NAME is
7598 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7599 pattern to be matched against symbol names. */
7601 struct bfd_elf_version_expr *
7602 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7603 const char *new_name,
7605 bfd_boolean literal_p)
7607 struct bfd_elf_version_expr *ret;
7609 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
7613 ret->literal = TRUE;
7614 ret->pattern = literal_p ? new_name : realsymbol (new_name);
7615 if (ret->pattern == NULL)
7617 ret->pattern = new_name;
7618 ret->literal = FALSE;
7621 if (lang == NULL || strcasecmp (lang, "C") == 0)
7622 ret->mask = BFD_ELF_VERSION_C_TYPE;
7623 else if (strcasecmp (lang, "C++") == 0)
7624 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7625 else if (strcasecmp (lang, "Java") == 0)
7626 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7629 einfo (_("%X%P: unknown language `%s' in version information\n"),
7631 ret->mask = BFD_ELF_VERSION_C_TYPE;
7634 return ldemul_new_vers_pattern (ret);
7637 /* This is called for each set of variable names and match
7640 struct bfd_elf_version_tree *
7641 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7642 struct bfd_elf_version_expr *locals)
7644 struct bfd_elf_version_tree *ret;
7646 ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
7647 ret->globals.list = globals;
7648 ret->locals.list = locals;
7649 ret->match = lang_vers_match;
7650 ret->name_indx = (unsigned int) -1;
7654 /* This static variable keeps track of version indices. */
7656 static int version_index;
7659 version_expr_head_hash (const void *p)
7661 const struct bfd_elf_version_expr *e =
7662 (const struct bfd_elf_version_expr *) p;
7664 return htab_hash_string (e->pattern);
7668 version_expr_head_eq (const void *p1, const void *p2)
7670 const struct bfd_elf_version_expr *e1 =
7671 (const struct bfd_elf_version_expr *) p1;
7672 const struct bfd_elf_version_expr *e2 =
7673 (const struct bfd_elf_version_expr *) p2;
7675 return strcmp (e1->pattern, e2->pattern) == 0;
7679 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7682 struct bfd_elf_version_expr *e, *next;
7683 struct bfd_elf_version_expr **list_loc, **remaining_loc;
7685 for (e = head->list; e; e = e->next)
7689 head->mask |= e->mask;
7694 head->htab = htab_create (count * 2, version_expr_head_hash,
7695 version_expr_head_eq, NULL);
7696 list_loc = &head->list;
7697 remaining_loc = &head->remaining;
7698 for (e = head->list; e; e = next)
7704 remaining_loc = &e->next;
7708 void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
7712 struct bfd_elf_version_expr *e1, *last;
7714 e1 = (struct bfd_elf_version_expr *) *loc;
7718 if (e1->mask == e->mask)
7726 while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7730 /* This is a duplicate. */
7731 /* FIXME: Memory leak. Sometimes pattern is not
7732 xmalloced alone, but in larger chunk of memory. */
7733 /* free (e->pattern); */
7738 e->next = last->next;
7746 list_loc = &e->next;
7750 *remaining_loc = NULL;
7751 *list_loc = head->remaining;
7754 head->remaining = head->list;
7757 /* This is called when we know the name and dependencies of the
7761 lang_register_vers_node (const char *name,
7762 struct bfd_elf_version_tree *version,
7763 struct bfd_elf_version_deps *deps)
7765 struct bfd_elf_version_tree *t, **pp;
7766 struct bfd_elf_version_expr *e1;
7771 if ((name[0] == '\0' && lang_elf_version_info != NULL)
7772 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
7774 einfo (_("%X%P: anonymous version tag cannot be combined"
7775 " with other version tags\n"));
7780 /* Make sure this node has a unique name. */
7781 for (t = lang_elf_version_info; t != NULL; t = t->next)
7782 if (strcmp (t->name, name) == 0)
7783 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7785 lang_finalize_version_expr_head (&version->globals);
7786 lang_finalize_version_expr_head (&version->locals);
7788 /* Check the global and local match names, and make sure there
7789 aren't any duplicates. */
7791 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7793 for (t = lang_elf_version_info; t != NULL; t = t->next)
7795 struct bfd_elf_version_expr *e2;
7797 if (t->locals.htab && e1->literal)
7799 e2 = (struct bfd_elf_version_expr *)
7800 htab_find ((htab_t) t->locals.htab, e1);
7801 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7803 if (e1->mask == e2->mask)
7804 einfo (_("%X%P: duplicate expression `%s'"
7805 " in version information\n"), e1->pattern);
7809 else if (!e1->literal)
7810 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7811 if (strcmp (e1->pattern, e2->pattern) == 0
7812 && e1->mask == e2->mask)
7813 einfo (_("%X%P: duplicate expression `%s'"
7814 " in version information\n"), e1->pattern);
7818 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7820 for (t = lang_elf_version_info; t != NULL; t = t->next)
7822 struct bfd_elf_version_expr *e2;
7824 if (t->globals.htab && e1->literal)
7826 e2 = (struct bfd_elf_version_expr *)
7827 htab_find ((htab_t) t->globals.htab, e1);
7828 while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7830 if (e1->mask == e2->mask)
7831 einfo (_("%X%P: duplicate expression `%s'"
7832 " in version information\n"),
7837 else if (!e1->literal)
7838 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7839 if (strcmp (e1->pattern, e2->pattern) == 0
7840 && e1->mask == e2->mask)
7841 einfo (_("%X%P: duplicate expression `%s'"
7842 " in version information\n"), e1->pattern);
7846 version->deps = deps;
7847 version->name = name;
7848 if (name[0] != '\0')
7851 version->vernum = version_index;
7854 version->vernum = 0;
7856 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7861 /* This is called when we see a version dependency. */
7863 struct bfd_elf_version_deps *
7864 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7866 struct bfd_elf_version_deps *ret;
7867 struct bfd_elf_version_tree *t;
7869 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
7872 for (t = lang_elf_version_info; t != NULL; t = t->next)
7874 if (strcmp (t->name, name) == 0)
7876 ret->version_needed = t;
7881 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7883 ret->version_needed = NULL;
7888 lang_do_version_exports_section (void)
7890 struct bfd_elf_version_expr *greg = NULL, *lreg;
7892 LANG_FOR_EACH_INPUT_STATEMENT (is)
7894 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7902 contents = (char *) xmalloc (len);
7903 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7904 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7907 while (p < contents + len)
7909 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7910 p = strchr (p, '\0') + 1;
7913 /* Do not free the contents, as we used them creating the regex. */
7915 /* Do not include this section in the link. */
7916 sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7919 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7920 lang_register_vers_node (command_line.version_exports_section,
7921 lang_new_vers_node (greg, lreg), NULL);
7925 lang_add_unique (const char *name)
7927 struct unique_sections *ent;
7929 for (ent = unique_section_list; ent; ent = ent->next)
7930 if (strcmp (ent->name, name) == 0)
7933 ent = (struct unique_sections *) xmalloc (sizeof *ent);
7934 ent->name = xstrdup (name);
7935 ent->next = unique_section_list;
7936 unique_section_list = ent;
7939 /* Append the list of dynamic symbols to the existing one. */
7942 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7944 if (link_info.dynamic_list)
7946 struct bfd_elf_version_expr *tail;
7947 for (tail = dynamic; tail->next != NULL; tail = tail->next)
7949 tail->next = link_info.dynamic_list->head.list;
7950 link_info.dynamic_list->head.list = dynamic;
7954 struct bfd_elf_dynamic_list *d;
7956 d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
7957 d->head.list = dynamic;
7958 d->match = lang_vers_match;
7959 link_info.dynamic_list = d;
7963 /* Append the list of C++ typeinfo dynamic symbols to the existing
7967 lang_append_dynamic_list_cpp_typeinfo (void)
7969 const char * symbols [] =
7971 "typeinfo name for*",
7974 struct bfd_elf_version_expr *dynamic = NULL;
7977 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7978 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7981 lang_append_dynamic_list (dynamic);
7984 /* Append the list of C++ operator new and delete dynamic symbols to the
7988 lang_append_dynamic_list_cpp_new (void)
7990 const char * symbols [] =
7995 struct bfd_elf_version_expr *dynamic = NULL;
7998 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7999 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
8002 lang_append_dynamic_list (dynamic);
8005 /* Scan a space and/or comma separated string of features. */
8008 lang_ld_feature (char *str)
8016 while (*p == ',' || ISSPACE (*p))
8021 while (*q && *q != ',' && !ISSPACE (*q))
8025 if (strcasecmp (p, "SANE_EXPR") == 0)
8026 config.sane_expr = TRUE;
8028 einfo (_("%X%P: unknown feature `%s'\n"), p);