1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack;
50 static struct obstack map_obstack;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file;
55 static lang_statement_list_type input_file_chain;
56 static bfd_boolean placed_commons = FALSE;
57 static bfd_boolean stripped_excluded_sections = FALSE;
58 static lang_output_section_statement_type *default_common_section;
59 static bfd_boolean map_option_f;
60 static bfd_vma print_dot;
61 static lang_input_statement_type *first_file;
62 static const char *current_target;
63 static const char *output_target;
64 static lang_statement_list_type statement_list;
65 static struct bfd_hash_table lang_definedness_table;
67 /* Forward declarations. */
68 static void exp_init_os (etree_type *);
69 static void init_map_userdata (bfd *, asection *, void *);
70 static lang_input_statement_type *lookup_name (const char *);
71 static struct bfd_hash_entry *lang_definedness_newfunc
72 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
73 static void insert_undefined (const char *);
74 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
75 static void print_statement (lang_statement_union_type *,
76 lang_output_section_statement_type *);
77 static void print_statement_list (lang_statement_union_type *,
78 lang_output_section_statement_type *);
79 static void print_statements (void);
80 static void print_input_section (asection *);
81 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
82 static void lang_record_phdrs (void);
83 static void lang_do_version_exports_section (void);
84 static void lang_finalize_version_expr_head
85 (struct bfd_elf_version_expr_head *);
87 /* Exported variables. */
88 lang_output_section_statement_type *abs_output_section;
89 lang_statement_list_type lang_output_section_statement;
90 lang_statement_list_type *stat_ptr = &statement_list;
91 lang_statement_list_type file_chain = { NULL, NULL };
92 struct bfd_sym_chain entry_symbol = { NULL, NULL };
93 static const char *entry_symbol_default = "start";
94 const char *entry_section = ".text";
95 bfd_boolean entry_from_cmdline;
96 bfd_boolean lang_has_input_file = FALSE;
97 bfd_boolean had_output_filename = FALSE;
98 bfd_boolean lang_float_flag = FALSE;
99 bfd_boolean delete_output_file_on_failure = FALSE;
100 struct lang_phdr *lang_phdr_list;
101 struct lang_nocrossrefs *nocrossref_list;
102 static struct unique_sections *unique_section_list;
103 static bfd_boolean ldlang_sysrooted_script = FALSE;
105 /* Functions that traverse the linker script and might evaluate
106 DEFINED() need to increment this. */
107 int lang_statement_iteration = 0;
109 etree_type *base; /* Relocation base - or null */
111 /* Return TRUE if the PATTERN argument is a wildcard pattern.
112 Although backslashes are treated specially if a pattern contains
113 wildcards, we do not consider the mere presence of a backslash to
114 be enough to cause the pattern to be treated as a wildcard.
115 That lets us handle DOS filenames more naturally. */
116 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
118 #define new_stat(x, y) \
119 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
121 #define outside_section_address(q) \
122 ((q)->output_offset + (q)->output_section->vma)
124 #define outside_symbol_address(q) \
125 ((q)->value + outside_section_address (q->section))
127 #define SECTION_NAME_MAP_LENGTH (16)
130 stat_alloc (size_t size)
132 return obstack_alloc (&stat_obstack, size);
136 unique_section_p (const asection *sec)
138 struct unique_sections *unam;
141 if (link_info.relocatable
142 && sec->owner != NULL
143 && bfd_is_group_section (sec->owner, sec))
147 for (unam = unique_section_list; unam; unam = unam->next)
148 if (wildcardp (unam->name)
149 ? fnmatch (unam->name, secnam, 0) == 0
150 : strcmp (unam->name, secnam) == 0)
158 /* Generic traversal routines for finding matching sections. */
160 /* Try processing a section against a wildcard. This just calls
161 the callback unless the filename exclusion list is present
162 and excludes the file. It's hardly ever present so this
163 function is very fast. */
166 walk_wild_consider_section (lang_wild_statement_type *ptr,
167 lang_input_statement_type *file,
169 struct wildcard_list *sec,
173 bfd_boolean skip = FALSE;
174 struct name_list *list_tmp;
176 /* Don't process sections from files which were
178 for (list_tmp = sec->spec.exclude_name_list;
180 list_tmp = list_tmp->next)
182 bfd_boolean is_wildcard = wildcardp (list_tmp->name);
184 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
186 skip = strcmp (list_tmp->name, file->filename) == 0;
188 /* If this file is part of an archive, and the archive is
189 excluded, exclude this file. */
190 if (! skip && file->the_bfd != NULL
191 && file->the_bfd->my_archive != NULL
192 && file->the_bfd->my_archive->filename != NULL)
195 skip = fnmatch (list_tmp->name,
196 file->the_bfd->my_archive->filename,
199 skip = strcmp (list_tmp->name,
200 file->the_bfd->my_archive->filename) == 0;
208 (*callback) (ptr, sec, s, file, data);
211 /* Lowest common denominator routine that can handle everything correctly,
215 walk_wild_section_general (lang_wild_statement_type *ptr,
216 lang_input_statement_type *file,
221 struct wildcard_list *sec;
223 for (s = file->the_bfd->sections; s != NULL; s = s->next)
225 sec = ptr->section_list;
227 (*callback) (ptr, sec, s, file, data);
231 bfd_boolean skip = FALSE;
233 if (sec->spec.name != NULL)
235 const char *sname = bfd_get_section_name (file->the_bfd, s);
237 if (wildcardp (sec->spec.name))
238 skip = fnmatch (sec->spec.name, sname, 0) != 0;
240 skip = strcmp (sec->spec.name, sname) != 0;
244 walk_wild_consider_section (ptr, file, s, sec, callback, data);
251 /* Routines to find a single section given its name. If there's more
252 than one section with that name, we report that. */
256 asection *found_section;
257 bfd_boolean multiple_sections_found;
258 } section_iterator_callback_data;
261 section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
263 section_iterator_callback_data *d = data;
265 if (d->found_section != NULL)
267 d->multiple_sections_found = TRUE;
271 d->found_section = s;
276 find_section (lang_input_statement_type *file,
277 struct wildcard_list *sec,
278 bfd_boolean *multiple_sections_found)
280 section_iterator_callback_data cb_data = { NULL, FALSE };
282 bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
283 section_iterator_callback, &cb_data);
284 *multiple_sections_found = cb_data.multiple_sections_found;
285 return cb_data.found_section;
288 /* Code for handling simple wildcards without going through fnmatch,
289 which can be expensive because of charset translations etc. */
291 /* A simple wild is a literal string followed by a single '*',
292 where the literal part is at least 4 characters long. */
295 is_simple_wild (const char *name)
297 size_t len = strcspn (name, "*?[");
298 return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
302 match_simple_wild (const char *pattern, const char *name)
304 /* The first four characters of the pattern are guaranteed valid
305 non-wildcard characters. So we can go faster. */
306 if (pattern[0] != name[0] || pattern[1] != name[1]
307 || pattern[2] != name[2] || pattern[3] != name[3])
312 while (*pattern != '*')
313 if (*name++ != *pattern++)
319 /* Compare sections ASEC and BSEC according to SORT. */
322 compare_section (sort_type sort, asection *asec, asection *bsec)
331 case by_alignment_name:
332 ret = (bfd_section_alignment (bsec->owner, bsec)
333 - bfd_section_alignment (asec->owner, asec));
339 ret = strcmp (bfd_get_section_name (asec->owner, asec),
340 bfd_get_section_name (bsec->owner, bsec));
343 case by_name_alignment:
344 ret = strcmp (bfd_get_section_name (asec->owner, asec),
345 bfd_get_section_name (bsec->owner, bsec));
351 ret = (bfd_section_alignment (bsec->owner, bsec)
352 - bfd_section_alignment (asec->owner, asec));
359 /* Build a Binary Search Tree to sort sections, unlike insertion sort
360 used in wild_sort(). BST is considerably faster if the number of
361 of sections are large. */
363 static lang_section_bst_type **
364 wild_sort_fast (lang_wild_statement_type *wild,
365 struct wildcard_list *sec,
366 lang_input_statement_type *file ATTRIBUTE_UNUSED,
369 lang_section_bst_type **tree;
372 if (!wild->filenames_sorted
373 && (sec == NULL || sec->spec.sorted == none))
375 /* Append at the right end of tree. */
377 tree = &((*tree)->right);
383 /* Find the correct node to append this section. */
384 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
385 tree = &((*tree)->left);
387 tree = &((*tree)->right);
393 /* Use wild_sort_fast to build a BST to sort sections. */
396 output_section_callback_fast (lang_wild_statement_type *ptr,
397 struct wildcard_list *sec,
399 lang_input_statement_type *file,
400 void *output ATTRIBUTE_UNUSED)
402 lang_section_bst_type *node;
403 lang_section_bst_type **tree;
405 if (unique_section_p (section))
408 node = xmalloc (sizeof (lang_section_bst_type));
411 node->section = section;
413 tree = wild_sort_fast (ptr, sec, file, section);
418 /* Convert a sorted sections' BST back to list form. */
421 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
422 lang_section_bst_type *tree,
426 output_section_callback_tree_to_list (ptr, tree->left, output);
428 lang_add_section (&ptr->children, tree->section,
429 (lang_output_section_statement_type *) output);
432 output_section_callback_tree_to_list (ptr, tree->right, output);
437 /* Specialized, optimized routines for handling different kinds of
441 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
442 lang_input_statement_type *file,
446 /* We can just do a hash lookup for the section with the right name.
447 But if that lookup discovers more than one section with the name
448 (should be rare), we fall back to the general algorithm because
449 we would otherwise have to sort the sections to make sure they
450 get processed in the bfd's order. */
451 bfd_boolean multiple_sections_found;
452 struct wildcard_list *sec0 = ptr->handler_data[0];
453 asection *s0 = find_section (file, sec0, &multiple_sections_found);
455 if (multiple_sections_found)
456 walk_wild_section_general (ptr, file, callback, data);
458 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
462 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
463 lang_input_statement_type *file,
468 struct wildcard_list *wildsec0 = ptr->handler_data[0];
470 for (s = file->the_bfd->sections; s != NULL; s = s->next)
472 const char *sname = bfd_get_section_name (file->the_bfd, s);
473 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
476 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
481 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
482 lang_input_statement_type *file,
487 struct wildcard_list *sec0 = ptr->handler_data[0];
488 struct wildcard_list *wildsec1 = ptr->handler_data[1];
489 bfd_boolean multiple_sections_found;
490 asection *s0 = find_section (file, sec0, &multiple_sections_found);
492 if (multiple_sections_found)
494 walk_wild_section_general (ptr, file, callback, data);
498 /* Note that if the section was not found, s0 is NULL and
499 we'll simply never succeed the s == s0 test below. */
500 for (s = file->the_bfd->sections; s != NULL; s = s->next)
502 /* Recall that in this code path, a section cannot satisfy more
503 than one spec, so if s == s0 then it cannot match
506 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
509 const char *sname = bfd_get_section_name (file->the_bfd, s);
510 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
513 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
520 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
521 lang_input_statement_type *file,
526 struct wildcard_list *sec0 = ptr->handler_data[0];
527 struct wildcard_list *wildsec1 = ptr->handler_data[1];
528 struct wildcard_list *wildsec2 = ptr->handler_data[2];
529 bfd_boolean multiple_sections_found;
530 asection *s0 = find_section (file, sec0, &multiple_sections_found);
532 if (multiple_sections_found)
534 walk_wild_section_general (ptr, file, callback, data);
538 for (s = file->the_bfd->sections; s != NULL; s = s->next)
541 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
544 const char *sname = bfd_get_section_name (file->the_bfd, s);
545 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
548 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
551 skip = !match_simple_wild (wildsec2->spec.name, sname);
553 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
561 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
562 lang_input_statement_type *file,
567 struct wildcard_list *sec0 = ptr->handler_data[0];
568 struct wildcard_list *sec1 = ptr->handler_data[1];
569 struct wildcard_list *wildsec2 = ptr->handler_data[2];
570 struct wildcard_list *wildsec3 = ptr->handler_data[3];
571 bfd_boolean multiple_sections_found;
572 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
574 if (multiple_sections_found)
576 walk_wild_section_general (ptr, file, callback, data);
580 s1 = find_section (file, sec1, &multiple_sections_found);
581 if (multiple_sections_found)
583 walk_wild_section_general (ptr, file, callback, data);
587 for (s = file->the_bfd->sections; s != NULL; s = s->next)
590 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
593 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
596 const char *sname = bfd_get_section_name (file->the_bfd, s);
597 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
601 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
605 skip = !match_simple_wild (wildsec3->spec.name, sname);
607 walk_wild_consider_section (ptr, file, s, wildsec3,
615 walk_wild_section (lang_wild_statement_type *ptr,
616 lang_input_statement_type *file,
620 if (file->just_syms_flag)
623 (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
626 /* Returns TRUE when name1 is a wildcard spec that might match
627 something name2 can match. We're conservative: we return FALSE
628 only if the prefixes of name1 and name2 are different up to the
629 first wildcard character. */
632 wild_spec_can_overlap (const char *name1, const char *name2)
634 size_t prefix1_len = strcspn (name1, "?*[");
635 size_t prefix2_len = strcspn (name2, "?*[");
636 size_t min_prefix_len;
638 /* Note that if there is no wildcard character, then we treat the
639 terminating 0 as part of the prefix. Thus ".text" won't match
640 ".text." or ".text.*", for example. */
641 if (name1[prefix1_len] == '\0')
643 if (name2[prefix2_len] == '\0')
646 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
648 return memcmp (name1, name2, min_prefix_len) == 0;
651 /* Select specialized code to handle various kinds of wildcard
655 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
658 int wild_name_count = 0;
659 struct wildcard_list *sec;
663 ptr->walk_wild_section_handler = walk_wild_section_general;
664 ptr->handler_data[0] = NULL;
665 ptr->handler_data[1] = NULL;
666 ptr->handler_data[2] = NULL;
667 ptr->handler_data[3] = NULL;
670 /* Count how many wildcard_specs there are, and how many of those
671 actually use wildcards in the name. Also, bail out if any of the
672 wildcard names are NULL. (Can this actually happen?
673 walk_wild_section used to test for it.) And bail out if any
674 of the wildcards are more complex than a simple string
675 ending in a single '*'. */
676 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
679 if (sec->spec.name == NULL)
681 if (wildcardp (sec->spec.name))
684 if (!is_simple_wild (sec->spec.name))
689 /* The zero-spec case would be easy to optimize but it doesn't
690 happen in practice. Likewise, more than 4 specs doesn't
691 happen in practice. */
692 if (sec_count == 0 || sec_count > 4)
695 /* Check that no two specs can match the same section. */
696 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
698 struct wildcard_list *sec2;
699 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
701 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
706 signature = (sec_count << 8) + wild_name_count;
710 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
713 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
716 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
719 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
722 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
728 /* Now fill the data array with pointers to the specs, first the
729 specs with non-wildcard names, then the specs with wildcard
730 names. It's OK to process the specs in different order from the
731 given order, because we've already determined that no section
732 will match more than one spec. */
734 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
735 if (!wildcardp (sec->spec.name))
736 ptr->handler_data[data_counter++] = sec;
737 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
738 if (wildcardp (sec->spec.name))
739 ptr->handler_data[data_counter++] = sec;
742 /* Handle a wild statement for a single file F. */
745 walk_wild_file (lang_wild_statement_type *s,
746 lang_input_statement_type *f,
750 if (f->the_bfd == NULL
751 || ! bfd_check_format (f->the_bfd, bfd_archive))
752 walk_wild_section (s, f, callback, data);
757 /* This is an archive file. We must map each member of the
758 archive separately. */
759 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
760 while (member != NULL)
762 /* When lookup_name is called, it will call the add_symbols
763 entry point for the archive. For each element of the
764 archive which is included, BFD will call ldlang_add_file,
765 which will set the usrdata field of the member to the
766 lang_input_statement. */
767 if (member->usrdata != NULL)
769 walk_wild_section (s, member->usrdata, callback, data);
772 member = bfd_openr_next_archived_file (f->the_bfd, member);
778 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
780 const char *file_spec = s->filename;
782 if (file_spec == NULL)
784 /* Perform the iteration over all files in the list. */
785 LANG_FOR_EACH_INPUT_STATEMENT (f)
787 walk_wild_file (s, f, callback, data);
790 else if (wildcardp (file_spec))
792 LANG_FOR_EACH_INPUT_STATEMENT (f)
794 if (fnmatch (file_spec, f->filename, 0) == 0)
795 walk_wild_file (s, f, callback, data);
800 lang_input_statement_type *f;
802 /* Perform the iteration over a single file. */
803 f = lookup_name (file_spec);
805 walk_wild_file (s, f, callback, data);
809 /* lang_for_each_statement walks the parse tree and calls the provided
810 function for each node. */
813 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
814 lang_statement_union_type *s)
816 for (; s != NULL; s = s->header.next)
820 switch (s->header.type)
822 case lang_constructors_statement_enum:
823 lang_for_each_statement_worker (func, constructor_list.head);
825 case lang_output_section_statement_enum:
826 lang_for_each_statement_worker
827 (func, s->output_section_statement.children.head);
829 case lang_wild_statement_enum:
830 lang_for_each_statement_worker (func,
831 s->wild_statement.children.head);
833 case lang_group_statement_enum:
834 lang_for_each_statement_worker (func,
835 s->group_statement.children.head);
837 case lang_data_statement_enum:
838 case lang_reloc_statement_enum:
839 case lang_object_symbols_statement_enum:
840 case lang_output_statement_enum:
841 case lang_target_statement_enum:
842 case lang_input_section_enum:
843 case lang_input_statement_enum:
844 case lang_assignment_statement_enum:
845 case lang_padding_statement_enum:
846 case lang_address_statement_enum:
847 case lang_fill_statement_enum:
857 lang_for_each_statement (void (*func) (lang_statement_union_type *))
859 lang_for_each_statement_worker (func, statement_list.head);
862 /*----------------------------------------------------------------------*/
865 lang_list_init (lang_statement_list_type *list)
868 list->tail = &list->head;
871 /* Build a new statement node for the parse tree. */
873 static lang_statement_union_type *
874 new_statement (enum statement_enum type,
876 lang_statement_list_type *list)
878 lang_statement_union_type *new;
880 new = stat_alloc (size);
881 new->header.type = type;
882 new->header.next = NULL;
883 lang_statement_append (list, new, &new->header.next);
887 /* Build a new input file node for the language. There are several
888 ways in which we treat an input file, eg, we only look at symbols,
889 or prefix it with a -l etc.
891 We can be supplied with requests for input files more than once;
892 they may, for example be split over several lines like foo.o(.text)
893 foo.o(.data) etc, so when asked for a file we check that we haven't
894 got it already so we don't duplicate the bfd. */
896 static lang_input_statement_type *
897 new_afile (const char *name,
898 lang_input_file_enum_type file_type,
900 bfd_boolean add_to_list)
902 lang_input_statement_type *p;
905 p = new_stat (lang_input_statement, stat_ptr);
908 p = stat_alloc (sizeof (lang_input_statement_type));
909 p->header.type = lang_input_statement_enum;
910 p->header.next = NULL;
913 lang_has_input_file = TRUE;
915 p->sysrooted = FALSE;
918 case lang_input_file_is_symbols_only_enum:
920 p->is_archive = FALSE;
922 p->local_sym_name = name;
923 p->just_syms_flag = TRUE;
924 p->search_dirs_flag = FALSE;
926 case lang_input_file_is_fake_enum:
928 p->is_archive = FALSE;
930 p->local_sym_name = name;
931 p->just_syms_flag = FALSE;
932 p->search_dirs_flag = FALSE;
934 case lang_input_file_is_l_enum:
935 p->is_archive = TRUE;
938 p->local_sym_name = concat ("-l", name, NULL);
939 p->just_syms_flag = FALSE;
940 p->search_dirs_flag = TRUE;
942 case lang_input_file_is_marker_enum:
944 p->is_archive = FALSE;
946 p->local_sym_name = name;
947 p->just_syms_flag = FALSE;
948 p->search_dirs_flag = TRUE;
950 case lang_input_file_is_search_file_enum:
951 p->sysrooted = ldlang_sysrooted_script;
953 p->is_archive = FALSE;
955 p->local_sym_name = name;
956 p->just_syms_flag = FALSE;
957 p->search_dirs_flag = TRUE;
959 case lang_input_file_is_file_enum:
961 p->is_archive = FALSE;
963 p->local_sym_name = name;
964 p->just_syms_flag = FALSE;
965 p->search_dirs_flag = FALSE;
972 p->next_real_file = NULL;
975 p->dynamic = config.dynamic_link;
976 p->add_needed = add_needed;
977 p->as_needed = as_needed;
978 p->whole_archive = whole_archive;
980 lang_statement_append (&input_file_chain,
981 (lang_statement_union_type *) p,
986 lang_input_statement_type *
987 lang_add_input_file (const char *name,
988 lang_input_file_enum_type file_type,
991 lang_has_input_file = TRUE;
992 return new_afile (name, file_type, target, TRUE);
995 struct out_section_hash_entry
997 struct bfd_hash_entry root;
998 lang_statement_union_type s;
1001 /* The hash table. */
1003 static struct bfd_hash_table output_section_statement_table;
1005 /* Support routines for the hash table used by lang_output_section_find,
1006 initialize the table, fill in an entry and remove the table. */
1008 static struct bfd_hash_entry *
1009 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1010 struct bfd_hash_table *table,
1013 lang_output_section_statement_type **nextp;
1014 struct out_section_hash_entry *ret;
1018 entry = bfd_hash_allocate (table, sizeof (*ret));
1023 entry = bfd_hash_newfunc (entry, table, string);
1027 ret = (struct out_section_hash_entry *) entry;
1028 memset (&ret->s, 0, sizeof (ret->s));
1029 ret->s.header.type = lang_output_section_statement_enum;
1030 ret->s.output_section_statement.subsection_alignment = -1;
1031 ret->s.output_section_statement.section_alignment = -1;
1032 ret->s.output_section_statement.block_value = 1;
1033 lang_list_init (&ret->s.output_section_statement.children);
1034 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1036 /* For every output section statement added to the list, except the
1037 first one, lang_output_section_statement.tail points to the "next"
1038 field of the last element of the list. */
1039 if (lang_output_section_statement.head != NULL)
1040 ret->s.output_section_statement.prev
1041 = ((lang_output_section_statement_type *)
1042 ((char *) lang_output_section_statement.tail
1043 - offsetof (lang_output_section_statement_type, next)));
1045 /* GCC's strict aliasing rules prevent us from just casting the
1046 address, so we store the pointer in a variable and cast that
1048 nextp = &ret->s.output_section_statement.next;
1049 lang_statement_append (&lang_output_section_statement,
1051 (lang_statement_union_type **) nextp);
1056 output_section_statement_table_init (void)
1058 if (!bfd_hash_table_init_n (&output_section_statement_table,
1059 output_section_statement_newfunc,
1060 sizeof (struct out_section_hash_entry),
1062 einfo (_("%P%F: can not create hash table: %E\n"));
1066 output_section_statement_table_free (void)
1068 bfd_hash_table_free (&output_section_statement_table);
1071 /* Build enough state so that the parser can build its tree. */
1076 obstack_begin (&stat_obstack, 1000);
1078 stat_ptr = &statement_list;
1080 output_section_statement_table_init ();
1082 lang_list_init (stat_ptr);
1084 lang_list_init (&input_file_chain);
1085 lang_list_init (&lang_output_section_statement);
1086 lang_list_init (&file_chain);
1087 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1089 abs_output_section =
1090 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
1092 abs_output_section->bfd_section = bfd_abs_section_ptr;
1094 /* The value "3" is ad-hoc, somewhat related to the expected number of
1095 DEFINED expressions in a linker script. For most default linker
1096 scripts, there are none. Why a hash table then? Well, it's somewhat
1097 simpler to re-use working machinery than using a linked list in terms
1098 of code-complexity here in ld, besides the initialization which just
1099 looks like other code here. */
1100 if (!bfd_hash_table_init_n (&lang_definedness_table,
1101 lang_definedness_newfunc,
1102 sizeof (struct lang_definedness_hash_entry),
1104 einfo (_("%P%F: can not create hash table: %E\n"));
1110 output_section_statement_table_free ();
1113 /*----------------------------------------------------------------------
1114 A region is an area of memory declared with the
1115 MEMORY { name:org=exp, len=exp ... }
1118 We maintain a list of all the regions here.
1120 If no regions are specified in the script, then the default is used
1121 which is created when looked up to be the entire data space.
1123 If create is true we are creating a region inside a MEMORY block.
1124 In this case it is probably an error to create a region that has
1125 already been created. If we are not inside a MEMORY block it is
1126 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1127 and so we issue a warning. */
1129 static lang_memory_region_type *lang_memory_region_list;
1130 static lang_memory_region_type **lang_memory_region_list_tail
1131 = &lang_memory_region_list;
1133 lang_memory_region_type *
1134 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1136 lang_memory_region_type *p;
1137 lang_memory_region_type *new;
1139 /* NAME is NULL for LMA memspecs if no region was specified. */
1143 for (p = lang_memory_region_list; p != NULL; p = p->next)
1144 if (strcmp (p->name, name) == 0)
1147 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1152 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1153 einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
1155 new = stat_alloc (sizeof (lang_memory_region_type));
1157 new->name = xstrdup (name);
1160 new->length = ~(bfd_size_type) 0;
1162 new->last_os = NULL;
1165 new->had_full_message = FALSE;
1167 *lang_memory_region_list_tail = new;
1168 lang_memory_region_list_tail = &new->next;
1173 static lang_memory_region_type *
1174 lang_memory_default (asection *section)
1176 lang_memory_region_type *p;
1178 flagword sec_flags = section->flags;
1180 /* Override SEC_DATA to mean a writable section. */
1181 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1182 sec_flags |= SEC_DATA;
1184 for (p = lang_memory_region_list; p != NULL; p = p->next)
1186 if ((p->flags & sec_flags) != 0
1187 && (p->not_flags & sec_flags) == 0)
1192 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1195 lang_output_section_statement_type *
1196 lang_output_section_find (const char *const name)
1198 struct out_section_hash_entry *entry;
1201 entry = ((struct out_section_hash_entry *)
1202 bfd_hash_lookup (&output_section_statement_table, name,
1207 hash = entry->root.hash;
1210 if (entry->s.output_section_statement.constraint != -1)
1211 return &entry->s.output_section_statement;
1212 entry = (struct out_section_hash_entry *) entry->root.next;
1214 while (entry != NULL
1215 && entry->root.hash == hash
1216 && strcmp (name, entry->s.output_section_statement.name) == 0);
1221 static lang_output_section_statement_type *
1222 lang_output_section_statement_lookup_1 (const char *const name, int constraint)
1224 struct out_section_hash_entry *entry;
1225 struct out_section_hash_entry *last_ent;
1228 entry = ((struct out_section_hash_entry *)
1229 bfd_hash_lookup (&output_section_statement_table, name,
1233 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1237 if (entry->s.output_section_statement.name != NULL)
1239 /* We have a section of this name, but it might not have the correct
1241 hash = entry->root.hash;
1244 if (entry->s.output_section_statement.constraint != -1
1246 || (constraint == entry->s.output_section_statement.constraint
1247 && constraint != SPECIAL)))
1248 return &entry->s.output_section_statement;
1250 entry = (struct out_section_hash_entry *) entry->root.next;
1252 while (entry != NULL
1253 && entry->root.hash == hash
1254 && strcmp (name, entry->s.output_section_statement.name) == 0);
1257 = ((struct out_section_hash_entry *)
1258 output_section_statement_newfunc (NULL,
1259 &output_section_statement_table,
1263 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1266 entry->root = last_ent->root;
1267 last_ent->root.next = &entry->root;
1270 entry->s.output_section_statement.name = name;
1271 entry->s.output_section_statement.constraint = constraint;
1272 return &entry->s.output_section_statement;
1275 lang_output_section_statement_type *
1276 lang_output_section_statement_lookup (const char *const name)
1278 return lang_output_section_statement_lookup_1 (name, 0);
1281 /* A variant of lang_output_section_find used by place_orphan.
1282 Returns the output statement that should precede a new output
1283 statement for SEC. If an exact match is found on certain flags,
1286 lang_output_section_statement_type *
1287 lang_output_section_find_by_flags (const asection *sec,
1288 lang_output_section_statement_type **exact,
1289 lang_match_sec_type_func match_type)
1291 lang_output_section_statement_type *first, *look, *found;
1294 /* We know the first statement on this list is *ABS*. May as well
1296 first = &lang_output_section_statement.head->output_section_statement;
1297 first = first->next;
1299 /* First try for an exact match. */
1301 for (look = first; look; look = look->next)
1303 flags = look->flags;
1304 if (look->bfd_section != NULL)
1306 flags = look->bfd_section->flags;
1307 if (match_type && !match_type (output_bfd, look->bfd_section,
1311 flags ^= sec->flags;
1312 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1313 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1323 if (sec->flags & SEC_CODE)
1325 /* Try for a rw code section. */
1326 for (look = first; look; look = look->next)
1328 flags = look->flags;
1329 if (look->bfd_section != NULL)
1331 flags = look->bfd_section->flags;
1332 if (match_type && !match_type (output_bfd, look->bfd_section,
1336 flags ^= sec->flags;
1337 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1338 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1342 else if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
1344 /* .rodata can go after .text, .sdata2 after .rodata. */
1345 for (look = first; look; look = look->next)
1347 flags = look->flags;
1348 if (look->bfd_section != NULL)
1350 flags = look->bfd_section->flags;
1351 if (match_type && !match_type (output_bfd, look->bfd_section,
1355 flags ^= sec->flags;
1356 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1358 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1362 else if (sec->flags & SEC_SMALL_DATA)
1364 /* .sdata goes after .data, .sbss after .sdata. */
1365 for (look = first; look; look = look->next)
1367 flags = look->flags;
1368 if (look->bfd_section != NULL)
1370 flags = look->bfd_section->flags;
1371 if (match_type && !match_type (output_bfd, look->bfd_section,
1375 flags ^= sec->flags;
1376 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1377 | SEC_THREAD_LOCAL))
1378 || ((look->flags & SEC_SMALL_DATA)
1379 && !(sec->flags & SEC_HAS_CONTENTS)))
1383 else if (sec->flags & SEC_HAS_CONTENTS)
1385 /* .data goes after .rodata. */
1386 for (look = first; look; look = look->next)
1388 flags = look->flags;
1389 if (look->bfd_section != NULL)
1391 flags = look->bfd_section->flags;
1392 if (match_type && !match_type (output_bfd, look->bfd_section,
1396 flags ^= sec->flags;
1397 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1398 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1404 /* .bss goes last. */
1405 for (look = first; look; look = look->next)
1407 flags = look->flags;
1408 if (look->bfd_section != NULL)
1410 flags = look->bfd_section->flags;
1411 if (match_type && !match_type (output_bfd, look->bfd_section,
1415 flags ^= sec->flags;
1416 if (!(flags & SEC_ALLOC))
1421 if (found || !match_type)
1424 return lang_output_section_find_by_flags (sec, NULL, NULL);
1427 /* Find the last output section before given output statement.
1428 Used by place_orphan. */
1431 output_prev_sec_find (lang_output_section_statement_type *os)
1433 lang_output_section_statement_type *lookup;
1435 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1437 if (lookup->constraint == -1)
1440 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1441 return lookup->bfd_section;
1447 lang_output_section_statement_type *
1448 lang_insert_orphan (asection *s,
1449 const char *secname,
1450 lang_output_section_statement_type *after,
1451 struct orphan_save *place,
1452 etree_type *address,
1453 lang_statement_list_type *add_child)
1455 lang_statement_list_type *old;
1456 lang_statement_list_type add;
1458 lang_output_section_statement_type *os;
1459 lang_output_section_statement_type **os_tail;
1461 /* Start building a list of statements for this section.
1462 First save the current statement pointer. */
1465 /* If we have found an appropriate place for the output section
1466 statements for this orphan, add them to our own private list,
1467 inserting them later into the global statement list. */
1471 lang_list_init (stat_ptr);
1475 if (config.build_constructors)
1477 /* If the name of the section is representable in C, then create
1478 symbols to mark the start and the end of the section. */
1479 for (ps = secname; *ps != '\0'; ps++)
1480 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1485 etree_type *e_align;
1487 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1488 symname[0] = bfd_get_symbol_leading_char (output_bfd);
1489 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1490 e_align = exp_unop (ALIGN_K,
1491 exp_intop ((bfd_vma) 1 << s->alignment_power));
1492 lang_add_assignment (exp_assop ('=', ".", e_align));
1493 lang_add_assignment (exp_assop ('=', symname,
1494 exp_nameop (NAME, ".")));
1498 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1499 address = exp_intop (0);
1501 os_tail = ((lang_output_section_statement_type **)
1502 lang_output_section_statement.tail);
1503 os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
1506 if (add_child == NULL)
1507 add_child = &os->children;
1508 lang_add_section (add_child, s, os);
1510 lang_leave_output_section_statement (0, "*default*", NULL, NULL);
1512 if (config.build_constructors && *ps == '\0')
1516 /* lang_leave_ouput_section_statement resets stat_ptr.
1517 Put stat_ptr back where we want it. */
1521 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1522 symname[0] = bfd_get_symbol_leading_char (output_bfd);
1523 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1524 lang_add_assignment (exp_assop ('=', symname,
1525 exp_nameop (NAME, ".")));
1528 /* Restore the global list pointer. */
1532 if (after != NULL && os->bfd_section != NULL)
1534 asection *snew, *as;
1536 snew = os->bfd_section;
1538 /* Shuffle the bfd section list to make the output file look
1539 neater. This is really only cosmetic. */
1540 if (place->section == NULL
1541 && after != (&lang_output_section_statement.head
1542 ->output_section_statement))
1544 asection *bfd_section = after->bfd_section;
1546 /* If the output statement hasn't been used to place any input
1547 sections (and thus doesn't have an output bfd_section),
1548 look for the closest prior output statement having an
1550 if (bfd_section == NULL)
1551 bfd_section = output_prev_sec_find (after);
1553 if (bfd_section != NULL && bfd_section != snew)
1554 place->section = &bfd_section->next;
1557 if (place->section == NULL)
1558 place->section = &output_bfd->sections;
1560 as = *place->section;
1564 /* Put the section at the end of the list. */
1566 /* Unlink the section. */
1567 bfd_section_list_remove (output_bfd, snew);
1569 /* Now tack it back on in the right place. */
1570 bfd_section_list_append (output_bfd, snew);
1572 else if (as != snew && as->prev != snew)
1574 /* Unlink the section. */
1575 bfd_section_list_remove (output_bfd, snew);
1577 /* Now tack it back on in the right place. */
1578 bfd_section_list_insert_before (output_bfd, as, snew);
1581 /* Save the end of this list. Further ophans of this type will
1582 follow the one we've just added. */
1583 place->section = &snew->next;
1585 /* The following is non-cosmetic. We try to put the output
1586 statements in some sort of reasonable order here, because they
1587 determine the final load addresses of the orphan sections.
1588 In addition, placing output statements in the wrong order may
1589 require extra segments. For instance, given a typical
1590 situation of all read-only sections placed in one segment and
1591 following that a segment containing all the read-write
1592 sections, we wouldn't want to place an orphan read/write
1593 section before or amongst the read-only ones. */
1594 if (add.head != NULL)
1596 lang_output_section_statement_type *newly_added_os;
1598 if (place->stmt == NULL)
1600 lang_statement_union_type **where;
1601 lang_statement_union_type **assign = NULL;
1602 bfd_boolean ignore_first;
1604 /* Look for a suitable place for the new statement list.
1605 The idea is to skip over anything that might be inside
1606 a SECTIONS {} statement in a script, before we find
1607 another output_section_statement. Assignments to "dot"
1608 before an output section statement are assumed to
1609 belong to it. An exception to this rule is made for
1610 the first assignment to dot, otherwise we might put an
1611 orphan before . = . + SIZEOF_HEADERS or similar
1612 assignments that set the initial address. */
1614 ignore_first = after == (&lang_output_section_statement.head
1615 ->output_section_statement);
1616 for (where = &after->header.next;
1618 where = &(*where)->header.next)
1620 switch ((*where)->header.type)
1622 case lang_assignment_statement_enum:
1625 lang_assignment_statement_type *ass;
1626 ass = &(*where)->assignment_statement;
1627 if (ass->exp->type.node_class != etree_assert
1628 && ass->exp->assign.dst[0] == '.'
1629 && ass->exp->assign.dst[1] == 0
1633 ignore_first = FALSE;
1635 case lang_wild_statement_enum:
1636 case lang_input_section_enum:
1637 case lang_object_symbols_statement_enum:
1638 case lang_fill_statement_enum:
1639 case lang_data_statement_enum:
1640 case lang_reloc_statement_enum:
1641 case lang_padding_statement_enum:
1642 case lang_constructors_statement_enum:
1645 case lang_output_section_statement_enum:
1648 case lang_input_statement_enum:
1649 case lang_address_statement_enum:
1650 case lang_target_statement_enum:
1651 case lang_output_statement_enum:
1652 case lang_group_statement_enum:
1653 case lang_afile_asection_pair_statement_enum:
1662 place->os_tail = &after->next;
1666 /* Put it after the last orphan statement we added. */
1667 *add.tail = *place->stmt;
1668 *place->stmt = add.head;
1671 /* Fix the global list pointer if we happened to tack our
1672 new list at the tail. */
1673 if (*old->tail == add.head)
1674 old->tail = add.tail;
1676 /* Save the end of this list. */
1677 place->stmt = add.tail;
1679 /* Do the same for the list of output section statements. */
1680 newly_added_os = *os_tail;
1682 newly_added_os->prev = (lang_output_section_statement_type *)
1683 ((char *) place->os_tail
1684 - offsetof (lang_output_section_statement_type, next));
1685 newly_added_os->next = *place->os_tail;
1686 if (newly_added_os->next != NULL)
1687 newly_added_os->next->prev = newly_added_os;
1688 *place->os_tail = newly_added_os;
1689 place->os_tail = &newly_added_os->next;
1691 /* Fixing the global list pointer here is a little different.
1692 We added to the list in lang_enter_output_section_statement,
1693 trimmed off the new output_section_statment above when
1694 assigning *os_tail = NULL, but possibly added it back in
1695 the same place when assigning *place->os_tail. */
1696 if (*os_tail == NULL)
1697 lang_output_section_statement.tail
1698 = (lang_statement_union_type **) os_tail;
1705 lang_map_flags (flagword flag)
1707 if (flag & SEC_ALLOC)
1710 if (flag & SEC_CODE)
1713 if (flag & SEC_READONLY)
1716 if (flag & SEC_DATA)
1719 if (flag & SEC_LOAD)
1726 lang_memory_region_type *m;
1727 bfd_boolean dis_header_printed = FALSE;
1730 LANG_FOR_EACH_INPUT_STATEMENT (file)
1734 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1735 || file->just_syms_flag)
1738 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1739 if (s->output_section == NULL
1740 || s->output_section->owner != output_bfd)
1742 if (! dis_header_printed)
1744 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1745 dis_header_printed = TRUE;
1748 print_input_section (s);
1752 minfo (_("\nMemory Configuration\n\n"));
1753 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1754 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1756 for (m = lang_memory_region_list; m != NULL; m = m->next)
1761 fprintf (config.map_file, "%-16s ", m->name);
1763 sprintf_vma (buf, m->origin);
1764 minfo ("0x%s ", buf);
1772 minfo ("0x%V", m->length);
1773 if (m->flags || m->not_flags)
1781 lang_map_flags (m->flags);
1787 lang_map_flags (m->not_flags);
1794 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1796 if (! command_line.reduce_memory_overheads)
1798 obstack_begin (&map_obstack, 1000);
1799 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1800 bfd_map_over_sections (p, init_map_userdata, 0);
1801 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1803 print_statements ();
1807 init_map_userdata (abfd, sec, data)
1808 bfd *abfd ATTRIBUTE_UNUSED;
1810 void *data ATTRIBUTE_UNUSED;
1812 fat_section_userdata_type *new_data
1813 = ((fat_section_userdata_type *) (stat_alloc
1814 (sizeof (fat_section_userdata_type))));
1816 ASSERT (get_userdata (sec) == NULL);
1817 get_userdata (sec) = new_data;
1818 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1822 sort_def_symbol (hash_entry, info)
1823 struct bfd_link_hash_entry *hash_entry;
1824 void *info ATTRIBUTE_UNUSED;
1826 if (hash_entry->type == bfd_link_hash_defined
1827 || hash_entry->type == bfd_link_hash_defweak)
1829 struct fat_user_section_struct *ud;
1830 struct map_symbol_def *def;
1832 ud = get_userdata (hash_entry->u.def.section);
1835 /* ??? What do we have to do to initialize this beforehand? */
1836 /* The first time we get here is bfd_abs_section... */
1837 init_map_userdata (0, hash_entry->u.def.section, 0);
1838 ud = get_userdata (hash_entry->u.def.section);
1840 else if (!ud->map_symbol_def_tail)
1841 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1843 def = obstack_alloc (&map_obstack, sizeof *def);
1844 def->entry = hash_entry;
1845 *(ud->map_symbol_def_tail) = def;
1846 ud->map_symbol_def_tail = &def->next;
1851 /* Initialize an output section. */
1854 init_os (lang_output_section_statement_type *s, asection *isec,
1857 if (s->bfd_section != NULL)
1860 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1861 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
1863 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
1864 if (s->bfd_section == NULL)
1865 s->bfd_section = bfd_make_section_with_flags (output_bfd, s->name,
1867 if (s->bfd_section == NULL)
1869 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1870 output_bfd->xvec->name, s->name);
1872 s->bfd_section->output_section = s->bfd_section;
1873 s->bfd_section->output_offset = 0;
1875 if (!command_line.reduce_memory_overheads)
1877 fat_section_userdata_type *new
1878 = stat_alloc (sizeof (fat_section_userdata_type));
1879 memset (new, 0, sizeof (fat_section_userdata_type));
1880 get_userdata (s->bfd_section) = new;
1883 /* If there is a base address, make sure that any sections it might
1884 mention are initialized. */
1885 if (s->addr_tree != NULL)
1886 exp_init_os (s->addr_tree);
1888 if (s->load_base != NULL)
1889 exp_init_os (s->load_base);
1891 /* If supplied an alignment, set it. */
1892 if (s->section_alignment != -1)
1893 s->bfd_section->alignment_power = s->section_alignment;
1896 bfd_init_private_section_data (isec->owner, isec,
1897 output_bfd, s->bfd_section,
1901 /* Make sure that all output sections mentioned in an expression are
1905 exp_init_os (etree_type *exp)
1907 switch (exp->type.node_class)
1911 exp_init_os (exp->assign.src);
1915 exp_init_os (exp->binary.lhs);
1916 exp_init_os (exp->binary.rhs);
1920 exp_init_os (exp->trinary.cond);
1921 exp_init_os (exp->trinary.lhs);
1922 exp_init_os (exp->trinary.rhs);
1926 exp_init_os (exp->assert_s.child);
1930 exp_init_os (exp->unary.child);
1934 switch (exp->type.node_code)
1940 lang_output_section_statement_type *os;
1942 os = lang_output_section_find (exp->name.name);
1943 if (os != NULL && os->bfd_section == NULL)
1944 init_os (os, NULL, 0);
1955 section_already_linked (bfd *abfd, asection *sec, void *data)
1957 lang_input_statement_type *entry = data;
1959 /* If we are only reading symbols from this object, then we want to
1960 discard all sections. */
1961 if (entry->just_syms_flag)
1963 bfd_link_just_syms (abfd, sec, &link_info);
1967 if (!(abfd->flags & DYNAMIC))
1968 bfd_section_already_linked (abfd, sec);
1971 /* The wild routines.
1973 These expand statements like *(.text) and foo.o to a list of
1974 explicit actions, like foo.o(.text), bar.o(.text) and
1975 foo.o(.text, .data). */
1977 /* Add SECTION to the output section OUTPUT. Do this by creating a
1978 lang_input_section statement which is placed at PTR. FILE is the
1979 input file which holds SECTION. */
1982 lang_add_section (lang_statement_list_type *ptr,
1984 lang_output_section_statement_type *output)
1986 flagword flags = section->flags;
1987 bfd_boolean discard;
1989 /* Discard sections marked with SEC_EXCLUDE. */
1990 discard = (flags & SEC_EXCLUDE) != 0;
1992 /* Discard input sections which are assigned to a section named
1993 DISCARD_SECTION_NAME. */
1994 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1997 /* Discard debugging sections if we are stripping debugging
1999 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2000 && (flags & SEC_DEBUGGING) != 0)
2005 if (section->output_section == NULL)
2007 /* This prevents future calls from assigning this section. */
2008 section->output_section = bfd_abs_section_ptr;
2013 if (section->output_section == NULL)
2016 lang_input_section_type *new;
2019 flags = section->flags;
2021 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2022 to an output section, because we want to be able to include a
2023 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2024 section (I don't know why we want to do this, but we do).
2025 build_link_order in ldwrite.c handles this case by turning
2026 the embedded SEC_NEVER_LOAD section into a fill. */
2028 flags &= ~ SEC_NEVER_LOAD;
2030 switch (output->sectype)
2032 case normal_section:
2034 case noalloc_section:
2035 flags &= ~SEC_ALLOC;
2037 case noload_section:
2039 flags |= SEC_NEVER_LOAD;
2043 if (output->bfd_section == NULL)
2044 init_os (output, section, flags);
2046 first = ! output->bfd_section->linker_has_input;
2047 output->bfd_section->linker_has_input = 1;
2049 if (!link_info.relocatable
2050 && !stripped_excluded_sections)
2052 asection *s = output->bfd_section->map_tail.s;
2053 output->bfd_section->map_tail.s = section;
2054 section->map_head.s = NULL;
2055 section->map_tail.s = s;
2057 s->map_head.s = section;
2059 output->bfd_section->map_head.s = section;
2062 /* Add a section reference to the list. */
2063 new = new_stat (lang_input_section, ptr);
2065 new->section = section;
2066 section->output_section = output->bfd_section;
2068 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2069 already been processed. One reason to do this is that on pe
2070 format targets, .text$foo sections go into .text and it's odd
2071 to see .text with SEC_LINK_ONCE set. */
2073 if (! link_info.relocatable)
2074 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
2076 /* If this is not the first input section, and the SEC_READONLY
2077 flag is not currently set, then don't set it just because the
2078 input section has it set. */
2080 if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
2081 flags &= ~ SEC_READONLY;
2083 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2085 && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2086 != (flags & (SEC_MERGE | SEC_STRINGS))
2087 || ((flags & SEC_MERGE)
2088 && output->bfd_section->entsize != section->entsize)))
2090 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2091 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2094 output->bfd_section->flags |= flags;
2096 if (flags & SEC_MERGE)
2097 output->bfd_section->entsize = section->entsize;
2099 /* If SEC_READONLY is not set in the input section, then clear
2100 it from the output section. */
2101 if ((section->flags & SEC_READONLY) == 0)
2102 output->bfd_section->flags &= ~SEC_READONLY;
2104 /* Copy over SEC_SMALL_DATA. */
2105 if (section->flags & SEC_SMALL_DATA)
2106 output->bfd_section->flags |= SEC_SMALL_DATA;
2108 if (section->alignment_power > output->bfd_section->alignment_power)
2109 output->bfd_section->alignment_power = section->alignment_power;
2111 if (bfd_get_arch (section->owner) == bfd_arch_tic54x
2112 && (section->flags & SEC_TIC54X_BLOCK) != 0)
2114 output->bfd_section->flags |= SEC_TIC54X_BLOCK;
2115 /* FIXME: This value should really be obtained from the bfd... */
2116 output->block_value = 128;
2121 /* Handle wildcard sorting. This returns the lang_input_section which
2122 should follow the one we are going to create for SECTION and FILE,
2123 based on the sorting requirements of WILD. It returns NULL if the
2124 new section should just go at the end of the current list. */
2126 static lang_statement_union_type *
2127 wild_sort (lang_wild_statement_type *wild,
2128 struct wildcard_list *sec,
2129 lang_input_statement_type *file,
2132 const char *section_name;
2133 lang_statement_union_type *l;
2135 if (!wild->filenames_sorted
2136 && (sec == NULL || sec->spec.sorted == none))
2139 section_name = bfd_get_section_name (file->the_bfd, section);
2140 for (l = wild->children.head; l != NULL; l = l->header.next)
2142 lang_input_section_type *ls;
2144 if (l->header.type != lang_input_section_enum)
2146 ls = &l->input_section;
2148 /* Sorting by filename takes precedence over sorting by section
2151 if (wild->filenames_sorted)
2153 const char *fn, *ln;
2157 /* The PE support for the .idata section as generated by
2158 dlltool assumes that files will be sorted by the name of
2159 the archive and then the name of the file within the
2162 if (file->the_bfd != NULL
2163 && bfd_my_archive (file->the_bfd) != NULL)
2165 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2170 fn = file->filename;
2174 if (bfd_my_archive (ls->section->owner) != NULL)
2176 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2181 ln = ls->section->owner->filename;
2185 i = strcmp (fn, ln);
2194 fn = file->filename;
2196 ln = ls->section->owner->filename;
2198 i = strcmp (fn, ln);
2206 /* Here either the files are not sorted by name, or we are
2207 looking at the sections for this file. */
2209 if (sec != NULL && sec->spec.sorted != none)
2210 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2217 /* Expand a wild statement for a particular FILE. SECTION may be
2218 NULL, in which case it is a wild card. */
2221 output_section_callback (lang_wild_statement_type *ptr,
2222 struct wildcard_list *sec,
2224 lang_input_statement_type *file,
2227 lang_statement_union_type *before;
2229 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2230 if (unique_section_p (section))
2233 before = wild_sort (ptr, sec, file, section);
2235 /* Here BEFORE points to the lang_input_section which
2236 should follow the one we are about to add. If BEFORE
2237 is NULL, then the section should just go at the end
2238 of the current list. */
2241 lang_add_section (&ptr->children, section,
2242 (lang_output_section_statement_type *) output);
2245 lang_statement_list_type list;
2246 lang_statement_union_type **pp;
2248 lang_list_init (&list);
2249 lang_add_section (&list, section,
2250 (lang_output_section_statement_type *) output);
2252 /* If we are discarding the section, LIST.HEAD will
2254 if (list.head != NULL)
2256 ASSERT (list.head->header.next == NULL);
2258 for (pp = &ptr->children.head;
2260 pp = &(*pp)->header.next)
2261 ASSERT (*pp != NULL);
2263 list.head->header.next = *pp;
2269 /* Check if all sections in a wild statement for a particular FILE
2273 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2274 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2276 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2279 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2280 if (unique_section_p (section))
2283 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2284 ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
2287 /* This is passed a file name which must have been seen already and
2288 added to the statement tree. We will see if it has been opened
2289 already and had its symbols read. If not then we'll read it. */
2291 static lang_input_statement_type *
2292 lookup_name (const char *name)
2294 lang_input_statement_type *search;
2296 for (search = (lang_input_statement_type *) input_file_chain.head;
2298 search = (lang_input_statement_type *) search->next_real_file)
2300 /* Use the local_sym_name as the name of the file that has
2301 already been loaded as filename might have been transformed
2302 via the search directory lookup mechanism. */
2303 const char *filename = search->local_sym_name;
2305 if (filename != NULL
2306 && strcmp (filename, name) == 0)
2311 search = new_afile (name, lang_input_file_is_search_file_enum,
2312 default_target, FALSE);
2314 /* If we have already added this file, or this file is not real
2315 don't add this file. */
2316 if (search->loaded || !search->real)
2319 if (! load_symbols (search, NULL))
2325 /* Save LIST as a list of libraries whose symbols should not be exported. */
2330 struct excluded_lib *next;
2332 static struct excluded_lib *excluded_libs;
2335 add_excluded_libs (const char *list)
2337 const char *p = list, *end;
2341 struct excluded_lib *entry;
2342 end = strpbrk (p, ",:");
2344 end = p + strlen (p);
2345 entry = xmalloc (sizeof (*entry));
2346 entry->next = excluded_libs;
2347 entry->name = xmalloc (end - p + 1);
2348 memcpy (entry->name, p, end - p);
2349 entry->name[end - p] = '\0';
2350 excluded_libs = entry;
2358 check_excluded_libs (bfd *abfd)
2360 struct excluded_lib *lib = excluded_libs;
2364 int len = strlen (lib->name);
2365 const char *filename = lbasename (abfd->filename);
2367 if (strcmp (lib->name, "ALL") == 0)
2369 abfd->no_export = TRUE;
2373 if (strncmp (lib->name, filename, len) == 0
2374 && (filename[len] == '\0'
2375 || (filename[len] == '.' && filename[len + 1] == 'a'
2376 && filename[len + 2] == '\0')))
2378 abfd->no_export = TRUE;
2386 /* Get the symbols for an input file. */
2389 load_symbols (lang_input_statement_type *entry,
2390 lang_statement_list_type *place)
2397 ldfile_open_file (entry);
2399 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2400 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2403 lang_statement_list_type *hold;
2404 bfd_boolean bad_load = TRUE;
2405 bfd_boolean save_ldlang_sysrooted_script;
2406 bfd_boolean save_as_needed, save_add_needed;
2408 err = bfd_get_error ();
2410 /* See if the emulation has some special knowledge. */
2411 if (ldemul_unrecognized_file (entry))
2414 if (err == bfd_error_file_ambiguously_recognized)
2418 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2419 einfo (_("%B: matching formats:"), entry->the_bfd);
2420 for (p = matching; *p != NULL; p++)
2424 else if (err != bfd_error_file_not_recognized
2426 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2430 bfd_close (entry->the_bfd);
2431 entry->the_bfd = NULL;
2433 /* Try to interpret the file as a linker script. */
2434 ldfile_open_command_file (entry->filename);
2438 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2439 ldlang_sysrooted_script = entry->sysrooted;
2440 save_as_needed = as_needed;
2441 as_needed = entry->as_needed;
2442 save_add_needed = add_needed;
2443 add_needed = entry->add_needed;
2445 ldfile_assumed_script = TRUE;
2446 parser_input = input_script;
2447 /* We want to use the same -Bdynamic/-Bstatic as the one for
2449 config.dynamic_link = entry->dynamic;
2451 ldfile_assumed_script = FALSE;
2453 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2454 as_needed = save_as_needed;
2455 add_needed = save_add_needed;
2461 if (ldemul_recognized_file (entry))
2464 /* We don't call ldlang_add_file for an archive. Instead, the
2465 add_symbols entry point will call ldlang_add_file, via the
2466 add_archive_element callback, for each element of the archive
2468 switch (bfd_get_format (entry->the_bfd))
2474 ldlang_add_file (entry);
2475 if (trace_files || trace_file_tries)
2476 info_msg ("%I\n", entry);
2480 check_excluded_libs (entry->the_bfd);
2482 if (entry->whole_archive)
2485 bfd_boolean loaded = TRUE;
2489 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2494 if (! bfd_check_format (member, bfd_object))
2496 einfo (_("%F%B: member %B in archive is not an object\n"),
2497 entry->the_bfd, member);
2501 if (! ((*link_info.callbacks->add_archive_element)
2502 (&link_info, member, "--whole-archive")))
2505 if (! bfd_link_add_symbols (member, &link_info))
2507 einfo (_("%F%B: could not read symbols: %E\n"), member);
2512 entry->loaded = loaded;
2518 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2519 entry->loaded = TRUE;
2521 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2523 return entry->loaded;
2526 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2527 may be NULL, indicating that it is a wildcard. Separate
2528 lang_input_section statements are created for each part of the
2529 expansion; they are added after the wild statement S. OUTPUT is
2530 the output section. */
2533 wild (lang_wild_statement_type *s,
2534 const char *target ATTRIBUTE_UNUSED,
2535 lang_output_section_statement_type *output)
2537 struct wildcard_list *sec;
2539 if (s->handler_data[0]
2540 && s->handler_data[0]->spec.sorted == by_name
2541 && !s->filenames_sorted)
2543 lang_section_bst_type *tree;
2545 walk_wild (s, output_section_callback_fast, output);
2550 output_section_callback_tree_to_list (s, tree, output);
2555 walk_wild (s, output_section_callback, output);
2557 if (default_common_section == NULL)
2558 for (sec = s->section_list; sec != NULL; sec = sec->next)
2559 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2561 /* Remember the section that common is going to in case we
2562 later get something which doesn't know where to put it. */
2563 default_common_section = output;
2568 /* Return TRUE iff target is the sought target. */
2571 get_target (const bfd_target *target, void *data)
2573 const char *sought = data;
2575 return strcmp (target->name, sought) == 0;
2578 /* Like strcpy() but convert to lower case as well. */
2581 stricpy (char *dest, char *src)
2585 while ((c = *src++) != 0)
2586 *dest++ = TOLOWER (c);
2591 /* Remove the first occurrence of needle (if any) in haystack
2595 strcut (char *haystack, char *needle)
2597 haystack = strstr (haystack, needle);
2603 for (src = haystack + strlen (needle); *src;)
2604 *haystack++ = *src++;
2610 /* Compare two target format name strings.
2611 Return a value indicating how "similar" they are. */
2614 name_compare (char *first, char *second)
2620 copy1 = xmalloc (strlen (first) + 1);
2621 copy2 = xmalloc (strlen (second) + 1);
2623 /* Convert the names to lower case. */
2624 stricpy (copy1, first);
2625 stricpy (copy2, second);
2627 /* Remove size and endian strings from the name. */
2628 strcut (copy1, "big");
2629 strcut (copy1, "little");
2630 strcut (copy2, "big");
2631 strcut (copy2, "little");
2633 /* Return a value based on how many characters match,
2634 starting from the beginning. If both strings are
2635 the same then return 10 * their length. */
2636 for (result = 0; copy1[result] == copy2[result]; result++)
2637 if (copy1[result] == 0)
2649 /* Set by closest_target_match() below. */
2650 static const bfd_target *winner;
2652 /* Scan all the valid bfd targets looking for one that has the endianness
2653 requirement that was specified on the command line, and is the nearest
2654 match to the original output target. */
2657 closest_target_match (const bfd_target *target, void *data)
2659 const bfd_target *original = data;
2661 if (command_line.endian == ENDIAN_BIG
2662 && target->byteorder != BFD_ENDIAN_BIG)
2665 if (command_line.endian == ENDIAN_LITTLE
2666 && target->byteorder != BFD_ENDIAN_LITTLE)
2669 /* Must be the same flavour. */
2670 if (target->flavour != original->flavour)
2673 /* If we have not found a potential winner yet, then record this one. */
2680 /* Oh dear, we now have two potential candidates for a successful match.
2681 Compare their names and choose the better one. */
2682 if (name_compare (target->name, original->name)
2683 > name_compare (winner->name, original->name))
2686 /* Keep on searching until wqe have checked them all. */
2690 /* Return the BFD target format of the first input file. */
2693 get_first_input_target (void)
2695 char *target = NULL;
2697 LANG_FOR_EACH_INPUT_STATEMENT (s)
2699 if (s->header.type == lang_input_statement_enum
2702 ldfile_open_file (s);
2704 if (s->the_bfd != NULL
2705 && bfd_check_format (s->the_bfd, bfd_object))
2707 target = bfd_get_target (s->the_bfd);
2719 lang_get_output_target (void)
2723 /* Has the user told us which output format to use? */
2724 if (output_target != NULL)
2725 return output_target;
2727 /* No - has the current target been set to something other than
2729 if (current_target != default_target)
2730 return current_target;
2732 /* No - can we determine the format of the first input file? */
2733 target = get_first_input_target ();
2737 /* Failed - use the default output target. */
2738 return default_target;
2741 /* Open the output file. */
2744 open_output (const char *name)
2748 output_target = lang_get_output_target ();
2750 /* Has the user requested a particular endianness on the command
2752 if (command_line.endian != ENDIAN_UNSET)
2754 const bfd_target *target;
2755 enum bfd_endian desired_endian;
2757 /* Get the chosen target. */
2758 target = bfd_search_for_target (get_target, (void *) output_target);
2760 /* If the target is not supported, we cannot do anything. */
2763 if (command_line.endian == ENDIAN_BIG)
2764 desired_endian = BFD_ENDIAN_BIG;
2766 desired_endian = BFD_ENDIAN_LITTLE;
2768 /* See if the target has the wrong endianness. This should
2769 not happen if the linker script has provided big and
2770 little endian alternatives, but some scrips don't do
2772 if (target->byteorder != desired_endian)
2774 /* If it does, then see if the target provides
2775 an alternative with the correct endianness. */
2776 if (target->alternative_target != NULL
2777 && (target->alternative_target->byteorder == desired_endian))
2778 output_target = target->alternative_target->name;
2781 /* Try to find a target as similar as possible to
2782 the default target, but which has the desired
2783 endian characteristic. */
2784 bfd_search_for_target (closest_target_match,
2787 /* Oh dear - we could not find any targets that
2788 satisfy our requirements. */
2790 einfo (_("%P: warning: could not find any targets"
2791 " that match endianness requirement\n"));
2793 output_target = winner->name;
2799 output = bfd_openw (name, output_target);
2803 if (bfd_get_error () == bfd_error_invalid_target)
2804 einfo (_("%P%F: target %s not found\n"), output_target);
2806 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2809 delete_output_file_on_failure = TRUE;
2811 if (! bfd_set_format (output, bfd_object))
2812 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2813 if (! bfd_set_arch_mach (output,
2814 ldfile_output_architecture,
2815 ldfile_output_machine))
2816 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2818 link_info.hash = bfd_link_hash_table_create (output);
2819 if (link_info.hash == NULL)
2820 einfo (_("%P%F: can not create hash table: %E\n"));
2822 bfd_set_gp_size (output, g_switch_value);
2827 ldlang_open_output (lang_statement_union_type *statement)
2829 switch (statement->header.type)
2831 case lang_output_statement_enum:
2832 ASSERT (output_bfd == NULL);
2833 output_bfd = open_output (statement->output_statement.name);
2834 ldemul_set_output_arch ();
2835 if (config.magic_demand_paged && !link_info.relocatable)
2836 output_bfd->flags |= D_PAGED;
2838 output_bfd->flags &= ~D_PAGED;
2839 if (config.text_read_only)
2840 output_bfd->flags |= WP_TEXT;
2842 output_bfd->flags &= ~WP_TEXT;
2843 if (link_info.traditional_format)
2844 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2846 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2849 case lang_target_statement_enum:
2850 current_target = statement->target_statement.target;
2857 /* Convert between addresses in bytes and sizes in octets.
2858 For currently supported targets, octets_per_byte is always a power
2859 of two, so we can use shifts. */
2860 #define TO_ADDR(X) ((X) >> opb_shift)
2861 #define TO_SIZE(X) ((X) << opb_shift)
2863 /* Support the above. */
2864 static unsigned int opb_shift = 0;
2869 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2870 ldfile_output_machine);
2873 while ((x & 1) == 0)
2881 /* Open all the input files. */
2884 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
2886 for (; s != NULL; s = s->header.next)
2888 switch (s->header.type)
2890 case lang_constructors_statement_enum:
2891 open_input_bfds (constructor_list.head, force);
2893 case lang_output_section_statement_enum:
2894 open_input_bfds (s->output_section_statement.children.head, force);
2896 case lang_wild_statement_enum:
2897 /* Maybe we should load the file's symbols. */
2898 if (s->wild_statement.filename
2899 && ! wildcardp (s->wild_statement.filename))
2900 lookup_name (s->wild_statement.filename);
2901 open_input_bfds (s->wild_statement.children.head, force);
2903 case lang_group_statement_enum:
2905 struct bfd_link_hash_entry *undefs;
2907 /* We must continually search the entries in the group
2908 until no new symbols are added to the list of undefined
2913 undefs = link_info.hash->undefs_tail;
2914 open_input_bfds (s->group_statement.children.head, TRUE);
2916 while (undefs != link_info.hash->undefs_tail);
2919 case lang_target_statement_enum:
2920 current_target = s->target_statement.target;
2922 case lang_input_statement_enum:
2923 if (s->input_statement.real)
2925 lang_statement_list_type add;
2927 s->input_statement.target = current_target;
2929 /* If we are being called from within a group, and this
2930 is an archive which has already been searched, then
2931 force it to be researched unless the whole archive
2932 has been loaded already. */
2934 && !s->input_statement.whole_archive
2935 && s->input_statement.loaded
2936 && bfd_check_format (s->input_statement.the_bfd,
2938 s->input_statement.loaded = FALSE;
2940 lang_list_init (&add);
2942 if (! load_symbols (&s->input_statement, &add))
2943 config.make_executable = FALSE;
2945 if (add.head != NULL)
2947 *add.tail = s->header.next;
2948 s->header.next = add.head;
2958 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2961 lang_track_definedness (const char *name)
2963 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
2964 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
2967 /* New-function for the definedness hash table. */
2969 static struct bfd_hash_entry *
2970 lang_definedness_newfunc (struct bfd_hash_entry *entry,
2971 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
2972 const char *name ATTRIBUTE_UNUSED)
2974 struct lang_definedness_hash_entry *ret
2975 = (struct lang_definedness_hash_entry *) entry;
2978 ret = (struct lang_definedness_hash_entry *)
2979 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
2982 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
2984 ret->iteration = -1;
2988 /* Return the iteration when the definition of NAME was last updated. A
2989 value of -1 means that the symbol is not defined in the linker script
2990 or the command line, but may be defined in the linker symbol table. */
2993 lang_symbol_definition_iteration (const char *name)
2995 struct lang_definedness_hash_entry *defentry
2996 = (struct lang_definedness_hash_entry *)
2997 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
2999 /* We've already created this one on the presence of DEFINED in the
3000 script, so it can't be NULL unless something is borked elsewhere in
3002 if (defentry == NULL)
3005 return defentry->iteration;
3008 /* Update the definedness state of NAME. */
3011 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3013 struct lang_definedness_hash_entry *defentry
3014 = (struct lang_definedness_hash_entry *)
3015 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3017 /* We don't keep track of symbols not tested with DEFINED. */
3018 if (defentry == NULL)
3021 /* If the symbol was already defined, and not from an earlier statement
3022 iteration, don't update the definedness iteration, because that'd
3023 make the symbol seem defined in the linker script at this point, and
3024 it wasn't; it was defined in some object. If we do anyway, DEFINED
3025 would start to yield false before this point and the construct "sym =
3026 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3028 if (h->type != bfd_link_hash_undefined
3029 && h->type != bfd_link_hash_common
3030 && h->type != bfd_link_hash_new
3031 && defentry->iteration == -1)
3034 defentry->iteration = lang_statement_iteration;
3037 /* Add the supplied name to the symbol table as an undefined reference.
3038 This is a two step process as the symbol table doesn't even exist at
3039 the time the ld command line is processed. First we put the name
3040 on a list, then, once the output file has been opened, transfer the
3041 name to the symbol table. */
3043 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3045 #define ldlang_undef_chain_list_head entry_symbol.next
3048 ldlang_add_undef (const char *const name)
3050 ldlang_undef_chain_list_type *new =
3051 stat_alloc (sizeof (ldlang_undef_chain_list_type));
3053 new->next = ldlang_undef_chain_list_head;
3054 ldlang_undef_chain_list_head = new;
3056 new->name = xstrdup (name);
3058 if (output_bfd != NULL)
3059 insert_undefined (new->name);
3062 /* Insert NAME as undefined in the symbol table. */
3065 insert_undefined (const char *name)
3067 struct bfd_link_hash_entry *h;
3069 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3071 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3072 if (h->type == bfd_link_hash_new)
3074 h->type = bfd_link_hash_undefined;
3075 h->u.undef.abfd = NULL;
3076 bfd_link_add_undef (link_info.hash, h);
3080 /* Run through the list of undefineds created above and place them
3081 into the linker hash table as undefined symbols belonging to the
3085 lang_place_undefineds (void)
3087 ldlang_undef_chain_list_type *ptr;
3089 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3090 insert_undefined (ptr->name);
3093 /* Check for all readonly or some readwrite sections. */
3096 check_input_sections
3097 (lang_statement_union_type *s,
3098 lang_output_section_statement_type *output_section_statement)
3100 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3102 switch (s->header.type)
3104 case lang_wild_statement_enum:
3105 walk_wild (&s->wild_statement, check_section_callback,
3106 output_section_statement);
3107 if (! output_section_statement->all_input_readonly)
3110 case lang_constructors_statement_enum:
3111 check_input_sections (constructor_list.head,
3112 output_section_statement);
3113 if (! output_section_statement->all_input_readonly)
3116 case lang_group_statement_enum:
3117 check_input_sections (s->group_statement.children.head,
3118 output_section_statement);
3119 if (! output_section_statement->all_input_readonly)
3128 /* Update wildcard statements if needed. */
3131 update_wild_statements (lang_statement_union_type *s)
3133 struct wildcard_list *sec;
3135 switch (sort_section)
3145 for (; s != NULL; s = s->header.next)
3147 switch (s->header.type)
3152 case lang_wild_statement_enum:
3153 sec = s->wild_statement.section_list;
3154 for (sec = s->wild_statement.section_list; sec != NULL;
3157 switch (sec->spec.sorted)
3160 sec->spec.sorted = sort_section;
3163 if (sort_section == by_alignment)
3164 sec->spec.sorted = by_name_alignment;
3167 if (sort_section == by_name)
3168 sec->spec.sorted = by_alignment_name;
3176 case lang_constructors_statement_enum:
3177 update_wild_statements (constructor_list.head);
3180 case lang_output_section_statement_enum:
3181 update_wild_statements
3182 (s->output_section_statement.children.head);
3185 case lang_group_statement_enum:
3186 update_wild_statements (s->group_statement.children.head);
3194 /* Open input files and attach to output sections. */
3197 map_input_to_output_sections
3198 (lang_statement_union_type *s, const char *target,
3199 lang_output_section_statement_type *os)
3203 for (; s != NULL; s = s->header.next)
3205 switch (s->header.type)
3207 case lang_wild_statement_enum:
3208 wild (&s->wild_statement, target, os);
3210 case lang_constructors_statement_enum:
3211 map_input_to_output_sections (constructor_list.head,
3215 case lang_output_section_statement_enum:
3216 if (s->output_section_statement.constraint)
3218 if (s->output_section_statement.constraint != ONLY_IF_RW
3219 && s->output_section_statement.constraint != ONLY_IF_RO)
3221 s->output_section_statement.all_input_readonly = TRUE;
3222 check_input_sections (s->output_section_statement.children.head,
3223 &s->output_section_statement);
3224 if ((s->output_section_statement.all_input_readonly
3225 && s->output_section_statement.constraint == ONLY_IF_RW)
3226 || (!s->output_section_statement.all_input_readonly
3227 && s->output_section_statement.constraint == ONLY_IF_RO))
3229 s->output_section_statement.constraint = -1;
3234 map_input_to_output_sections (s->output_section_statement.children.head,
3236 &s->output_section_statement);
3238 case lang_output_statement_enum:
3240 case lang_target_statement_enum:
3241 target = s->target_statement.target;
3243 case lang_group_statement_enum:
3244 map_input_to_output_sections (s->group_statement.children.head,
3248 case lang_data_statement_enum:
3249 /* Make sure that any sections mentioned in the expression
3251 exp_init_os (s->data_statement.exp);
3252 flags = SEC_HAS_CONTENTS;
3253 /* The output section gets contents, and then we inspect for
3254 any flags set in the input script which override any ALLOC. */
3255 if (!(os->flags & SEC_NEVER_LOAD))
3256 flags |= SEC_ALLOC | SEC_LOAD;
3257 if (os->bfd_section == NULL)
3258 init_os (os, NULL, flags);
3260 os->bfd_section->flags |= flags;
3262 case lang_input_section_enum:
3264 case lang_fill_statement_enum:
3265 case lang_object_symbols_statement_enum:
3266 case lang_reloc_statement_enum:
3267 case lang_padding_statement_enum:
3268 case lang_input_statement_enum:
3269 if (os != NULL && os->bfd_section == NULL)
3270 init_os (os, NULL, 0);
3272 case lang_assignment_statement_enum:
3273 if (os != NULL && os->bfd_section == NULL)
3274 init_os (os, NULL, 0);
3276 /* Make sure that any sections mentioned in the assignment
3278 exp_init_os (s->assignment_statement.exp);
3280 case lang_afile_asection_pair_statement_enum:
3283 case lang_address_statement_enum:
3284 /* Mark the specified section with the supplied address.
3286 If this section was actually a segment marker, then the
3287 directive is ignored if the linker script explicitly
3288 processed the segment marker. Originally, the linker
3289 treated segment directives (like -Ttext on the
3290 command-line) as section directives. We honor the
3291 section directive semantics for backwards compatibilty;
3292 linker scripts that do not specifically check for
3293 SEGMENT_START automatically get the old semantics. */
3294 if (!s->address_statement.segment
3295 || !s->address_statement.segment->used)
3297 lang_output_section_statement_type *aos
3298 = (lang_output_section_statement_lookup
3299 (s->address_statement.section_name));
3301 if (aos->bfd_section == NULL)
3302 init_os (aos, NULL, 0);
3303 aos->addr_tree = s->address_statement.address;
3310 /* An output section might have been removed after its statement was
3311 added. For example, ldemul_before_allocation can remove dynamic
3312 sections if they turn out to be not needed. Clean them up here. */
3315 strip_excluded_output_sections (void)
3317 lang_output_section_statement_type *os;
3319 /* Run lang_size_sections (if not already done). */
3320 if (expld.phase != lang_mark_phase_enum)
3322 expld.phase = lang_mark_phase_enum;
3323 expld.dataseg.phase = exp_dataseg_none;
3324 one_lang_size_sections_pass (NULL, FALSE);
3325 lang_reset_memory_regions ();
3328 for (os = &lang_output_section_statement.head->output_section_statement;
3332 asection *output_section;
3333 bfd_boolean exclude;
3335 if (os->constraint == -1)
3338 output_section = os->bfd_section;
3339 if (output_section == NULL)
3342 exclude = (output_section->rawsize == 0
3343 && (output_section->flags & SEC_KEEP) == 0
3344 && !bfd_section_removed_from_list (output_bfd,
3347 /* Some sections have not yet been sized, notably .gnu.version,
3348 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3349 input sections, so don't drop output sections that have such
3350 input sections unless they are also marked SEC_EXCLUDE. */
3351 if (exclude && output_section->map_head.s != NULL)
3355 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3356 if ((s->flags & SEC_LINKER_CREATED) != 0
3357 && (s->flags & SEC_EXCLUDE) == 0)
3364 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3365 output_section->map_head.link_order = NULL;
3366 output_section->map_tail.link_order = NULL;
3370 /* We don't set bfd_section to NULL since bfd_section of the
3371 removed output section statement may still be used. */
3372 if (!os->section_relative_symbol)
3374 output_section->flags |= SEC_EXCLUDE;
3375 bfd_section_list_remove (output_bfd, output_section);
3376 output_bfd->section_count--;
3380 /* Stop future calls to lang_add_section from messing with map_head
3381 and map_tail link_order fields. */
3382 stripped_excluded_sections = TRUE;
3386 print_output_section_statement
3387 (lang_output_section_statement_type *output_section_statement)
3389 asection *section = output_section_statement->bfd_section;
3392 if (output_section_statement != abs_output_section)
3394 minfo ("\n%s", output_section_statement->name);
3396 if (section != NULL)
3398 print_dot = section->vma;
3400 len = strlen (output_section_statement->name);
3401 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3406 while (len < SECTION_NAME_MAP_LENGTH)
3412 minfo ("0x%V %W", section->vma, section->size);
3414 if (output_section_statement->load_base != NULL)
3418 addr = exp_get_abs_int (output_section_statement->load_base, 0,
3420 minfo (_(" load address 0x%V"), addr);
3427 print_statement_list (output_section_statement->children.head,
3428 output_section_statement);
3431 /* Scan for the use of the destination in the right hand side
3432 of an expression. In such cases we will not compute the
3433 correct expression, since the value of DST that is used on
3434 the right hand side will be its final value, not its value
3435 just before this expression is evaluated. */
3438 scan_for_self_assignment (const char * dst, etree_type * rhs)
3440 if (rhs == NULL || dst == NULL)
3443 switch (rhs->type.node_class)
3446 return scan_for_self_assignment (dst, rhs->binary.lhs)
3447 || scan_for_self_assignment (dst, rhs->binary.rhs);
3450 return scan_for_self_assignment (dst, rhs->trinary.lhs)
3451 || scan_for_self_assignment (dst, rhs->trinary.rhs);
3454 case etree_provided:
3456 if (strcmp (dst, rhs->assign.dst) == 0)
3458 return scan_for_self_assignment (dst, rhs->assign.src);
3461 return scan_for_self_assignment (dst, rhs->unary.child);
3465 return strcmp (dst, rhs->value.str) == 0;
3470 return strcmp (dst, rhs->name.name) == 0;
3482 print_assignment (lang_assignment_statement_type *assignment,
3483 lang_output_section_statement_type *output_section)
3487 bfd_boolean computation_is_valid = TRUE;
3490 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3493 if (assignment->exp->type.node_class == etree_assert)
3496 tree = assignment->exp->assert_s.child;
3497 computation_is_valid = TRUE;
3501 const char *dst = assignment->exp->assign.dst;
3503 is_dot = (dst[0] == '.' && dst[1] == 0);
3504 tree = assignment->exp->assign.src;
3505 computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
3508 exp_fold_tree (tree, output_section->bfd_section, &print_dot);
3509 if (expld.result.valid_p)
3513 if (computation_is_valid)
3515 value = expld.result.value;
3517 if (expld.result.section)
3518 value += expld.result.section->vma;
3520 minfo ("0x%V", value);
3526 struct bfd_link_hash_entry *h;
3528 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3529 FALSE, FALSE, TRUE);
3532 value = h->u.def.value;
3534 if (expld.result.section)
3535 value += expld.result.section->vma;
3537 minfo ("[0x%V]", value);
3540 minfo ("[unresolved]");
3552 exp_print_tree (assignment->exp);
3557 print_input_statement (lang_input_statement_type *statm)
3559 if (statm->filename != NULL)
3561 fprintf (config.map_file, "LOAD %s\n", statm->filename);
3565 /* Print all symbols defined in a particular section. This is called
3566 via bfd_link_hash_traverse, or by print_all_symbols. */
3569 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
3571 asection *sec = ptr;
3573 if ((hash_entry->type == bfd_link_hash_defined
3574 || hash_entry->type == bfd_link_hash_defweak)
3575 && sec == hash_entry->u.def.section)
3579 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3582 (hash_entry->u.def.value
3583 + hash_entry->u.def.section->output_offset
3584 + hash_entry->u.def.section->output_section->vma));
3586 minfo (" %T\n", hash_entry->root.string);
3593 print_all_symbols (asection *sec)
3595 struct fat_user_section_struct *ud = get_userdata (sec);
3596 struct map_symbol_def *def;
3601 *ud->map_symbol_def_tail = 0;
3602 for (def = ud->map_symbol_def_head; def; def = def->next)
3603 print_one_symbol (def->entry, sec);
3606 /* Print information about an input section to the map file. */
3609 print_input_section (asection *i)
3611 bfd_size_type size = i->size;
3618 minfo ("%s", i->name);
3620 len = 1 + strlen (i->name);
3621 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3626 while (len < SECTION_NAME_MAP_LENGTH)
3632 if (i->output_section != NULL && i->output_section->owner == output_bfd)
3633 addr = i->output_section->vma + i->output_offset;
3640 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
3642 if (size != i->rawsize && i->rawsize != 0)
3644 len = SECTION_NAME_MAP_LENGTH + 3;
3656 minfo (_("%W (size before relaxing)\n"), i->rawsize);
3659 if (i->output_section != NULL && i->output_section->owner == output_bfd)
3661 if (command_line.reduce_memory_overheads)
3662 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
3664 print_all_symbols (i);
3666 print_dot = addr + TO_ADDR (size);
3671 print_fill_statement (lang_fill_statement_type *fill)
3675 fputs (" FILL mask 0x", config.map_file);
3676 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
3677 fprintf (config.map_file, "%02x", *p);
3678 fputs ("\n", config.map_file);
3682 print_data_statement (lang_data_statement_type *data)
3690 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3693 addr = data->output_offset;
3694 if (data->output_section != NULL)
3695 addr += data->output_section->vma;
3723 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
3725 if (data->exp->type.node_class != etree_value)
3728 exp_print_tree (data->exp);
3733 print_dot = addr + TO_ADDR (size);
3736 /* Print an address statement. These are generated by options like
3740 print_address_statement (lang_address_statement_type *address)
3742 minfo (_("Address of section %s set to "), address->section_name);
3743 exp_print_tree (address->address);
3747 /* Print a reloc statement. */
3750 print_reloc_statement (lang_reloc_statement_type *reloc)
3757 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3760 addr = reloc->output_offset;
3761 if (reloc->output_section != NULL)
3762 addr += reloc->output_section->vma;
3764 size = bfd_get_reloc_size (reloc->howto);
3766 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
3768 if (reloc->name != NULL)
3769 minfo ("%s+", reloc->name);
3771 minfo ("%s+", reloc->section->name);
3773 exp_print_tree (reloc->addend_exp);
3777 print_dot = addr + TO_ADDR (size);
3781 print_padding_statement (lang_padding_statement_type *s)
3789 len = sizeof " *fill*" - 1;
3790 while (len < SECTION_NAME_MAP_LENGTH)
3796 addr = s->output_offset;
3797 if (s->output_section != NULL)
3798 addr += s->output_section->vma;
3799 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
3801 if (s->fill->size != 0)
3805 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
3806 fprintf (config.map_file, "%02x", *p);
3811 print_dot = addr + TO_ADDR (s->size);
3815 print_wild_statement (lang_wild_statement_type *w,
3816 lang_output_section_statement_type *os)
3818 struct wildcard_list *sec;
3822 if (w->filenames_sorted)
3824 if (w->filename != NULL)
3825 minfo ("%s", w->filename);
3828 if (w->filenames_sorted)
3832 for (sec = w->section_list; sec; sec = sec->next)
3834 if (sec->spec.sorted)
3836 if (sec->spec.exclude_name_list != NULL)
3839 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
3840 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
3841 minfo (" %s", tmp->name);
3844 if (sec->spec.name != NULL)
3845 minfo ("%s", sec->spec.name);
3848 if (sec->spec.sorted)
3857 print_statement_list (w->children.head, os);
3860 /* Print a group statement. */
3863 print_group (lang_group_statement_type *s,
3864 lang_output_section_statement_type *os)
3866 fprintf (config.map_file, "START GROUP\n");
3867 print_statement_list (s->children.head, os);
3868 fprintf (config.map_file, "END GROUP\n");
3871 /* Print the list of statements in S.
3872 This can be called for any statement type. */
3875 print_statement_list (lang_statement_union_type *s,
3876 lang_output_section_statement_type *os)
3880 print_statement (s, os);
3885 /* Print the first statement in statement list S.
3886 This can be called for any statement type. */
3889 print_statement (lang_statement_union_type *s,
3890 lang_output_section_statement_type *os)
3892 switch (s->header.type)
3895 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
3898 case lang_constructors_statement_enum:
3899 if (constructor_list.head != NULL)
3901 if (constructors_sorted)
3902 minfo (" SORT (CONSTRUCTORS)\n");
3904 minfo (" CONSTRUCTORS\n");
3905 print_statement_list (constructor_list.head, os);
3908 case lang_wild_statement_enum:
3909 print_wild_statement (&s->wild_statement, os);
3911 case lang_address_statement_enum:
3912 print_address_statement (&s->address_statement);
3914 case lang_object_symbols_statement_enum:
3915 minfo (" CREATE_OBJECT_SYMBOLS\n");
3917 case lang_fill_statement_enum:
3918 print_fill_statement (&s->fill_statement);
3920 case lang_data_statement_enum:
3921 print_data_statement (&s->data_statement);
3923 case lang_reloc_statement_enum:
3924 print_reloc_statement (&s->reloc_statement);
3926 case lang_input_section_enum:
3927 print_input_section (s->input_section.section);
3929 case lang_padding_statement_enum:
3930 print_padding_statement (&s->padding_statement);
3932 case lang_output_section_statement_enum:
3933 print_output_section_statement (&s->output_section_statement);
3935 case lang_assignment_statement_enum:
3936 print_assignment (&s->assignment_statement, os);
3938 case lang_target_statement_enum:
3939 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
3941 case lang_output_statement_enum:
3942 minfo ("OUTPUT(%s", s->output_statement.name);
3943 if (output_target != NULL)
3944 minfo (" %s", output_target);
3947 case lang_input_statement_enum:
3948 print_input_statement (&s->input_statement);
3950 case lang_group_statement_enum:
3951 print_group (&s->group_statement, os);
3953 case lang_afile_asection_pair_statement_enum:
3960 print_statements (void)
3962 print_statement_list (statement_list.head, abs_output_section);
3965 /* Print the first N statements in statement list S to STDERR.
3966 If N == 0, nothing is printed.
3967 If N < 0, the entire list is printed.
3968 Intended to be called from GDB. */
3971 dprint_statement (lang_statement_union_type *s, int n)
3973 FILE *map_save = config.map_file;
3975 config.map_file = stderr;
3978 print_statement_list (s, abs_output_section);
3981 while (s && --n >= 0)
3983 print_statement (s, abs_output_section);
3988 config.map_file = map_save;
3992 insert_pad (lang_statement_union_type **ptr,
3994 unsigned int alignment_needed,
3995 asection *output_section,
3998 static fill_type zero_fill = { 1, { 0 } };
3999 lang_statement_union_type *pad = NULL;
4001 if (ptr != &statement_list.head)
4002 pad = ((lang_statement_union_type *)
4003 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4005 && pad->header.type == lang_padding_statement_enum
4006 && pad->padding_statement.output_section == output_section)
4008 /* Use the existing pad statement. */
4010 else if ((pad = *ptr) != NULL
4011 && pad->header.type == lang_padding_statement_enum
4012 && pad->padding_statement.output_section == output_section)
4014 /* Use the existing pad statement. */
4018 /* Make a new padding statement, linked into existing chain. */
4019 pad = stat_alloc (sizeof (lang_padding_statement_type));
4020 pad->header.next = *ptr;
4022 pad->header.type = lang_padding_statement_enum;
4023 pad->padding_statement.output_section = output_section;
4026 pad->padding_statement.fill = fill;
4028 pad->padding_statement.output_offset = dot - output_section->vma;
4029 pad->padding_statement.size = alignment_needed;
4030 output_section->size += alignment_needed;
4033 /* Work out how much this section will move the dot point. */
4037 (lang_statement_union_type **this_ptr,
4038 lang_output_section_statement_type *output_section_statement,
4042 lang_input_section_type *is = &((*this_ptr)->input_section);
4043 asection *i = is->section;
4045 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4046 && (i->flags & SEC_EXCLUDE) == 0)
4048 unsigned int alignment_needed;
4051 /* Align this section first to the input sections requirement,
4052 then to the output section's requirement. If this alignment
4053 is greater than any seen before, then record it too. Perform
4054 the alignment by inserting a magic 'padding' statement. */
4056 if (output_section_statement->subsection_alignment != -1)
4057 i->alignment_power = output_section_statement->subsection_alignment;
4059 o = output_section_statement->bfd_section;
4060 if (o->alignment_power < i->alignment_power)
4061 o->alignment_power = i->alignment_power;
4063 alignment_needed = align_power (dot, i->alignment_power) - dot;
4065 if (alignment_needed != 0)
4067 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4068 dot += alignment_needed;
4071 /* Remember where in the output section this input section goes. */
4073 i->output_offset = dot - o->vma;
4075 /* Mark how big the output section must be to contain this now. */
4076 dot += TO_ADDR (i->size);
4077 o->size = TO_SIZE (dot - o->vma);
4081 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4088 sort_sections_by_lma (const void *arg1, const void *arg2)
4090 const asection *sec1 = *(const asection **) arg1;
4091 const asection *sec2 = *(const asection **) arg2;
4093 if (bfd_section_lma (sec1->owner, sec1)
4094 < bfd_section_lma (sec2->owner, sec2))
4096 else if (bfd_section_lma (sec1->owner, sec1)
4097 > bfd_section_lma (sec2->owner, sec2))
4103 #define IGNORE_SECTION(s) \
4104 ((s->flags & SEC_NEVER_LOAD) != 0 \
4105 || (s->flags & SEC_ALLOC) == 0 \
4106 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4107 && (s->flags & SEC_LOAD) == 0))
4109 /* Check to see if any allocated sections overlap with other allocated
4110 sections. This can happen if a linker script specifies the output
4111 section addresses of the two sections. */
4114 lang_check_section_addresses (void)
4117 asection **sections, **spp;
4125 if (bfd_count_sections (output_bfd) <= 1)
4128 amt = bfd_count_sections (output_bfd) * sizeof (asection *);
4129 sections = xmalloc (amt);
4131 /* Scan all sections in the output list. */
4133 for (s = output_bfd->sections; s != NULL; s = s->next)
4135 /* Only consider loadable sections with real contents. */
4136 if (IGNORE_SECTION (s) || s->size == 0)
4139 sections[count] = s;
4146 qsort (sections, (size_t) count, sizeof (asection *),
4147 sort_sections_by_lma);
4151 s_start = bfd_section_lma (output_bfd, s);
4152 s_end = s_start + TO_ADDR (s->size) - 1;
4153 for (count--; count; count--)
4155 /* We must check the sections' LMA addresses not their VMA
4156 addresses because overlay sections can have overlapping VMAs
4157 but they must have distinct LMAs. */
4162 s_start = bfd_section_lma (output_bfd, s);
4163 s_end = s_start + TO_ADDR (s->size) - 1;
4165 /* Look for an overlap. */
4166 if (s_end >= os_start && s_start <= os_end)
4167 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4168 s->name, s_start, s_end, os->name, os_start, os_end);
4174 /* Make sure the new address is within the region. We explicitly permit the
4175 current address to be at the exact end of the region when the address is
4176 non-zero, in case the region is at the end of addressable memory and the
4177 calculation wraps around. */
4180 os_region_check (lang_output_section_statement_type *os,
4181 lang_memory_region_type *region,
4185 if ((region->current < region->origin
4186 || (region->current - region->origin > region->length))
4187 && ((region->current != region->origin + region->length)
4192 einfo (_("%X%P: address 0x%v of %B section %s"
4193 " is not within region %s\n"),
4195 os->bfd_section->owner,
4196 os->bfd_section->name,
4201 einfo (_("%X%P: region %s is full (%B section %s)\n"),
4203 os->bfd_section->owner,
4204 os->bfd_section->name);
4206 /* Reset the region pointer. */
4207 region->current = region->origin;
4211 /* Set the sizes for all the output sections. */
4214 lang_size_sections_1
4215 (lang_statement_union_type *s,
4216 lang_output_section_statement_type *output_section_statement,
4217 lang_statement_union_type **prev,
4221 bfd_boolean check_regions)
4223 /* Size up the sections from their constituent parts. */
4224 for (; s != NULL; s = s->header.next)
4226 switch (s->header.type)
4228 case lang_output_section_statement_enum:
4230 bfd_vma newdot, after;
4231 lang_output_section_statement_type *os;
4232 lang_memory_region_type *r;
4234 os = &s->output_section_statement;
4235 if (os->addr_tree != NULL)
4237 os->processed_vma = FALSE;
4238 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4240 if (!expld.result.valid_p
4241 && expld.phase != lang_mark_phase_enum)
4242 einfo (_("%F%S: non constant or forward reference"
4243 " address expression for section %s\n"),
4246 dot = expld.result.value + expld.result.section->vma;
4249 if (os->bfd_section == NULL)
4250 /* This section was removed or never actually created. */
4253 /* If this is a COFF shared library section, use the size and
4254 address from the input section. FIXME: This is COFF
4255 specific; it would be cleaner if there were some other way
4256 to do this, but nothing simple comes to mind. */
4257 if ((bfd_get_flavour (output_bfd) == bfd_target_ecoff_flavour
4258 || bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
4259 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4263 if (os->children.head == NULL
4264 || os->children.head->header.next != NULL
4265 || (os->children.head->header.type
4266 != lang_input_section_enum))
4267 einfo (_("%P%X: Internal error on COFF shared library"
4268 " section %s\n"), os->name);
4270 input = os->children.head->input_section.section;
4271 bfd_set_section_vma (os->bfd_section->owner,
4273 bfd_section_vma (input->owner, input));
4274 os->bfd_section->size = input->size;
4279 if (bfd_is_abs_section (os->bfd_section))
4281 /* No matter what happens, an abs section starts at zero. */
4282 ASSERT (os->bfd_section->vma == 0);
4288 if (os->addr_tree == NULL)
4290 /* No address specified for this section, get one
4291 from the region specification. */
4292 if (os->region == NULL
4293 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4294 && os->region->name[0] == '*'
4295 && strcmp (os->region->name,
4296 DEFAULT_MEMORY_REGION) == 0))
4298 os->region = lang_memory_default (os->bfd_section);
4301 /* If a loadable section is using the default memory
4302 region, and some non default memory regions were
4303 defined, issue an error message. */
4305 && !IGNORE_SECTION (os->bfd_section)
4306 && ! link_info.relocatable
4308 && strcmp (os->region->name,
4309 DEFAULT_MEMORY_REGION) == 0
4310 && lang_memory_region_list != NULL
4311 && (strcmp (lang_memory_region_list->name,
4312 DEFAULT_MEMORY_REGION) != 0
4313 || lang_memory_region_list->next != NULL)
4314 && expld.phase != lang_mark_phase_enum)
4316 /* By default this is an error rather than just a
4317 warning because if we allocate the section to the
4318 default memory region we can end up creating an
4319 excessively large binary, or even seg faulting when
4320 attempting to perform a negative seek. See
4321 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4322 for an example of this. This behaviour can be
4323 overridden by the using the --no-check-sections
4325 if (command_line.check_section_addresses)
4326 einfo (_("%P%F: error: no memory region specified"
4327 " for loadable section `%s'\n"),
4328 bfd_get_section_name (output_bfd,
4331 einfo (_("%P: warning: no memory region specified"
4332 " for loadable section `%s'\n"),
4333 bfd_get_section_name (output_bfd,
4337 newdot = os->region->current;
4338 align = os->bfd_section->alignment_power;
4341 align = os->section_alignment;
4343 /* Align to what the section needs. */
4346 bfd_vma savedot = newdot;
4347 newdot = align_power (newdot, align);
4349 if (newdot != savedot
4350 && (config.warn_section_align
4351 || os->addr_tree != NULL)
4352 && expld.phase != lang_mark_phase_enum)
4353 einfo (_("%P: warning: changing start of section"
4354 " %s by %lu bytes\n"),
4355 os->name, (unsigned long) (newdot - savedot));
4358 bfd_set_section_vma (0, os->bfd_section, newdot);
4360 os->bfd_section->output_offset = 0;
4363 lang_size_sections_1 (os->children.head, os, &os->children.head,
4364 os->fill, newdot, relax, check_regions);
4366 os->processed_vma = TRUE;
4368 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4369 /* Except for some special linker created sections,
4370 no output section should change from zero size
4371 after strip_excluded_output_sections. A non-zero
4372 size on an ignored section indicates that some
4373 input section was not sized early enough. */
4374 ASSERT (os->bfd_section->size == 0);
4377 dot = os->bfd_section->vma;
4379 /* Put the section within the requested block size, or
4380 align at the block boundary. */
4382 + TO_ADDR (os->bfd_section->size)
4383 + os->block_value - 1)
4384 & - (bfd_vma) os->block_value);
4386 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4389 /* Set section lma. */
4392 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4396 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4397 os->bfd_section->lma = lma;
4399 else if (os->region != NULL
4400 && os->lma_region != NULL
4401 && os->lma_region != os->region)
4403 bfd_vma lma = os->lma_region->current;
4405 if (os->section_alignment != -1)
4406 lma = align_power (lma, os->section_alignment);
4407 os->bfd_section->lma = lma;
4409 else if (r->last_os != NULL
4410 && (os->bfd_section->flags & SEC_ALLOC) != 0)
4415 last = r->last_os->output_section_statement.bfd_section;
4417 /* A backwards move of dot should be accompanied by
4418 an explicit assignment to the section LMA (ie.
4419 os->load_base set) because backwards moves normally
4420 create overlapping LMAs. */
4421 if (dot < last->vma)
4423 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4426 /* If dot moved backwards then leave lma equal to
4427 vma. This is the old default lma, which might
4428 just happen to work when the backwards move is
4429 sufficiently large. Nag anyway, so people fix
4430 their linker scripts. */
4434 /* If the current vma overlaps the previous section,
4435 then set the current lma to that at the end of
4436 the previous section. The previous section was
4437 probably an overlay. */
4438 if ((dot >= last->vma
4439 && dot < last->vma + last->size)
4440 || (last->vma >= dot
4441 && last->vma < dot + os->bfd_section->size))
4442 lma = last->lma + last->size;
4444 /* Otherwise, keep the same lma to vma relationship
4445 as the previous section. */
4447 lma = dot + last->lma - last->vma;
4449 if (os->section_alignment != -1)
4450 lma = align_power (lma, os->section_alignment);
4451 os->bfd_section->lma = lma;
4454 os->processed_lma = TRUE;
4456 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4459 /* Keep track of normal sections using the default
4460 lma region. We use this to set the lma for
4461 following sections. Overlays or other linker
4462 script assignment to lma might mean that the
4463 default lma == vma is incorrect.
4464 To avoid warnings about dot moving backwards when using
4465 -Ttext, don't start tracking sections until we find one
4466 of non-zero size or with lma set differently to vma. */
4467 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4468 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4469 && (os->bfd_section->flags & SEC_ALLOC) != 0
4470 && (os->bfd_section->size != 0
4471 || os->bfd_section->vma != os->bfd_section->lma
4472 || r->last_os != NULL)
4473 && os->lma_region == NULL
4474 && !link_info.relocatable)
4477 /* .tbss sections effectively have zero size. */
4478 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4479 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4480 || link_info.relocatable)
4481 dot += TO_ADDR (os->bfd_section->size);
4483 if (os->update_dot_tree != 0)
4484 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4486 /* Update dot in the region ?
4487 We only do this if the section is going to be allocated,
4488 since unallocated sections do not contribute to the region's
4489 overall size in memory.
4491 If the SEC_NEVER_LOAD bit is not set, it will affect the
4492 addresses of sections after it. We have to update
4494 if (os->region != NULL
4495 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4496 || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4498 os->region->current = dot;
4501 /* Make sure the new address is within the region. */
4502 os_region_check (os, os->region, os->addr_tree,
4503 os->bfd_section->vma);
4505 if (os->lma_region != NULL && os->lma_region != os->region)
4507 os->lma_region->current
4508 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
4511 os_region_check (os, os->lma_region, NULL,
4512 os->bfd_section->lma);
4518 case lang_constructors_statement_enum:
4519 dot = lang_size_sections_1 (constructor_list.head,
4520 output_section_statement,
4521 &s->wild_statement.children.head,
4522 fill, dot, relax, check_regions);
4525 case lang_data_statement_enum:
4527 unsigned int size = 0;
4529 s->data_statement.output_offset =
4530 dot - output_section_statement->bfd_section->vma;
4531 s->data_statement.output_section =
4532 output_section_statement->bfd_section;
4534 /* We might refer to provided symbols in the expression, and
4535 need to mark them as needed. */
4536 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4538 switch (s->data_statement.type)
4556 if (size < TO_SIZE ((unsigned) 1))
4557 size = TO_SIZE ((unsigned) 1);
4558 dot += TO_ADDR (size);
4559 output_section_statement->bfd_section->size += size;
4563 case lang_reloc_statement_enum:
4567 s->reloc_statement.output_offset =
4568 dot - output_section_statement->bfd_section->vma;
4569 s->reloc_statement.output_section =
4570 output_section_statement->bfd_section;
4571 size = bfd_get_reloc_size (s->reloc_statement.howto);
4572 dot += TO_ADDR (size);
4573 output_section_statement->bfd_section->size += size;
4577 case lang_wild_statement_enum:
4578 dot = lang_size_sections_1 (s->wild_statement.children.head,
4579 output_section_statement,
4580 &s->wild_statement.children.head,
4581 fill, dot, relax, check_regions);
4584 case lang_object_symbols_statement_enum:
4585 link_info.create_object_symbols_section =
4586 output_section_statement->bfd_section;
4589 case lang_output_statement_enum:
4590 case lang_target_statement_enum:
4593 case lang_input_section_enum:
4597 i = (*prev)->input_section.section;
4602 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4603 einfo (_("%P%F: can't relax section: %E\n"));
4607 dot = size_input_section (prev, output_section_statement,
4608 output_section_statement->fill, dot);
4612 case lang_input_statement_enum:
4615 case lang_fill_statement_enum:
4616 s->fill_statement.output_section =
4617 output_section_statement->bfd_section;
4619 fill = s->fill_statement.fill;
4622 case lang_assignment_statement_enum:
4624 bfd_vma newdot = dot;
4625 etree_type *tree = s->assignment_statement.exp;
4627 exp_fold_tree (tree,
4628 output_section_statement->bfd_section,
4631 /* This symbol is relative to this section. */
4632 if ((tree->type.node_class == etree_provided
4633 || tree->type.node_class == etree_assign)
4634 && (tree->assign.dst [0] != '.'
4635 || tree->assign.dst [1] != '\0'))
4636 output_section_statement->section_relative_symbol = 1;
4638 if (!output_section_statement->ignored)
4640 if (output_section_statement == abs_output_section)
4642 /* If we don't have an output section, then just adjust
4643 the default memory address. */
4644 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
4645 FALSE)->current = newdot;
4647 else if (newdot != dot)
4649 /* Insert a pad after this statement. We can't
4650 put the pad before when relaxing, in case the
4651 assignment references dot. */
4652 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
4653 output_section_statement->bfd_section, dot);
4655 /* Don't neuter the pad below when relaxing. */
4658 /* If dot is advanced, this implies that the section
4659 should have space allocated to it, unless the
4660 user has explicitly stated that the section
4661 should never be loaded. */
4662 if (!(output_section_statement->flags
4663 & (SEC_NEVER_LOAD | SEC_ALLOC)))
4664 output_section_statement->bfd_section->flags |= SEC_ALLOC;
4671 case lang_padding_statement_enum:
4672 /* If this is the first time lang_size_sections is called,
4673 we won't have any padding statements. If this is the
4674 second or later passes when relaxing, we should allow
4675 padding to shrink. If padding is needed on this pass, it
4676 will be added back in. */
4677 s->padding_statement.size = 0;
4679 /* Make sure output_offset is valid. If relaxation shrinks
4680 the section and this pad isn't needed, it's possible to
4681 have output_offset larger than the final size of the
4682 section. bfd_set_section_contents will complain even for
4683 a pad size of zero. */
4684 s->padding_statement.output_offset
4685 = dot - output_section_statement->bfd_section->vma;
4688 case lang_group_statement_enum:
4689 dot = lang_size_sections_1 (s->group_statement.children.head,
4690 output_section_statement,
4691 &s->group_statement.children.head,
4692 fill, dot, relax, check_regions);
4699 /* We can only get here when relaxing is turned on. */
4700 case lang_address_statement_enum:
4703 prev = &s->header.next;
4709 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
4711 lang_statement_iteration++;
4712 lang_size_sections_1 (statement_list.head, abs_output_section,
4713 &statement_list.head, 0, 0, relax, check_regions);
4717 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
4719 expld.phase = lang_allocating_phase_enum;
4720 expld.dataseg.phase = exp_dataseg_none;
4722 one_lang_size_sections_pass (relax, check_regions);
4723 if (expld.dataseg.phase == exp_dataseg_end_seen
4724 && link_info.relro && expld.dataseg.relro_end)
4726 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4727 to put expld.dataseg.relro on a (common) page boundary. */
4728 bfd_vma old_min_base, relro_end, maxpage;
4730 expld.dataseg.phase = exp_dataseg_relro_adjust;
4731 old_min_base = expld.dataseg.min_base;
4732 maxpage = expld.dataseg.maxpagesize;
4733 expld.dataseg.base += (-expld.dataseg.relro_end
4734 & (expld.dataseg.pagesize - 1));
4735 /* Compute the expected PT_GNU_RELRO segment end. */
4736 relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
4737 & ~(expld.dataseg.pagesize - 1);
4738 if (old_min_base + maxpage < expld.dataseg.base)
4740 expld.dataseg.base -= maxpage;
4741 relro_end -= maxpage;
4743 lang_reset_memory_regions ();
4744 one_lang_size_sections_pass (relax, check_regions);
4745 if (expld.dataseg.relro_end > relro_end)
4747 /* The alignment of sections between DATA_SEGMENT_ALIGN
4748 and DATA_SEGMENT_RELRO_END caused huge padding to be
4749 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4751 unsigned int max_alignment_power = 0;
4753 /* Find maximum alignment power of sections between
4754 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4755 for (sec = output_bfd->sections; sec; sec = sec->next)
4756 if (sec->vma >= expld.dataseg.base
4757 && sec->vma < expld.dataseg.relro_end
4758 && sec->alignment_power > max_alignment_power)
4759 max_alignment_power = sec->alignment_power;
4761 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
4763 if (expld.dataseg.base - (1 << max_alignment_power)
4765 expld.dataseg.base += expld.dataseg.pagesize;
4766 expld.dataseg.base -= (1 << max_alignment_power);
4767 lang_reset_memory_regions ();
4768 one_lang_size_sections_pass (relax, check_regions);
4771 link_info.relro_start = expld.dataseg.base;
4772 link_info.relro_end = expld.dataseg.relro_end;
4774 else if (expld.dataseg.phase == exp_dataseg_end_seen)
4776 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4777 a page could be saved in the data segment. */
4778 bfd_vma first, last;
4780 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
4781 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
4783 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
4784 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
4785 && first + last <= expld.dataseg.pagesize)
4787 expld.dataseg.phase = exp_dataseg_adjust;
4788 lang_reset_memory_regions ();
4789 one_lang_size_sections_pass (relax, check_regions);
4793 expld.phase = lang_final_phase_enum;
4796 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4799 lang_do_assignments_1 (lang_statement_union_type *s,
4800 lang_output_section_statement_type *current_os,
4804 for (; s != NULL; s = s->header.next)
4806 switch (s->header.type)
4808 case lang_constructors_statement_enum:
4809 dot = lang_do_assignments_1 (constructor_list.head,
4810 current_os, fill, dot);
4813 case lang_output_section_statement_enum:
4815 lang_output_section_statement_type *os;
4817 os = &(s->output_section_statement);
4818 if (os->bfd_section != NULL && !os->ignored)
4820 dot = os->bfd_section->vma;
4822 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
4824 /* .tbss sections effectively have zero size. */
4825 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4826 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4827 || link_info.relocatable)
4828 dot += TO_ADDR (os->bfd_section->size);
4833 case lang_wild_statement_enum:
4835 dot = lang_do_assignments_1 (s->wild_statement.children.head,
4836 current_os, fill, dot);
4839 case lang_object_symbols_statement_enum:
4840 case lang_output_statement_enum:
4841 case lang_target_statement_enum:
4844 case lang_data_statement_enum:
4845 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4846 if (expld.result.valid_p)
4847 s->data_statement.value = (expld.result.value
4848 + expld.result.section->vma);
4850 einfo (_("%F%P: invalid data statement\n"));
4853 switch (s->data_statement.type)
4871 if (size < TO_SIZE ((unsigned) 1))
4872 size = TO_SIZE ((unsigned) 1);
4873 dot += TO_ADDR (size);
4877 case lang_reloc_statement_enum:
4878 exp_fold_tree (s->reloc_statement.addend_exp,
4879 bfd_abs_section_ptr, &dot);
4880 if (expld.result.valid_p)
4881 s->reloc_statement.addend_value = expld.result.value;
4883 einfo (_("%F%P: invalid reloc statement\n"));
4884 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
4887 case lang_input_section_enum:
4889 asection *in = s->input_section.section;
4891 if ((in->flags & SEC_EXCLUDE) == 0)
4892 dot += TO_ADDR (in->size);
4896 case lang_input_statement_enum:
4899 case lang_fill_statement_enum:
4900 fill = s->fill_statement.fill;
4903 case lang_assignment_statement_enum:
4904 exp_fold_tree (s->assignment_statement.exp,
4905 current_os->bfd_section,
4909 case lang_padding_statement_enum:
4910 dot += TO_ADDR (s->padding_statement.size);
4913 case lang_group_statement_enum:
4914 dot = lang_do_assignments_1 (s->group_statement.children.head,
4915 current_os, fill, dot);
4922 case lang_address_statement_enum:
4930 lang_do_assignments (void)
4932 lang_statement_iteration++;
4933 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
4936 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4937 operator .startof. (section_name), it produces an undefined symbol
4938 .startof.section_name. Similarly, when it sees
4939 .sizeof. (section_name), it produces an undefined symbol
4940 .sizeof.section_name. For all the output sections, we look for
4941 such symbols, and set them to the correct value. */
4944 lang_set_startof (void)
4948 if (link_info.relocatable)
4951 for (s = output_bfd->sections; s != NULL; s = s->next)
4953 const char *secname;
4955 struct bfd_link_hash_entry *h;
4957 secname = bfd_get_section_name (output_bfd, s);
4958 buf = xmalloc (10 + strlen (secname));
4960 sprintf (buf, ".startof.%s", secname);
4961 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4962 if (h != NULL && h->type == bfd_link_hash_undefined)
4964 h->type = bfd_link_hash_defined;
4965 h->u.def.value = bfd_get_section_vma (output_bfd, s);
4966 h->u.def.section = bfd_abs_section_ptr;
4969 sprintf (buf, ".sizeof.%s", secname);
4970 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4971 if (h != NULL && h->type == bfd_link_hash_undefined)
4973 h->type = bfd_link_hash_defined;
4974 h->u.def.value = TO_ADDR (s->size);
4975 h->u.def.section = bfd_abs_section_ptr;
4985 struct bfd_link_hash_entry *h;
4988 if (link_info.relocatable || link_info.shared)
4993 if (entry_symbol.name == NULL)
4995 /* No entry has been specified. Look for the default entry, but
4996 don't warn if we don't find it. */
4997 entry_symbol.name = entry_symbol_default;
5001 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5002 FALSE, FALSE, TRUE);
5004 && (h->type == bfd_link_hash_defined
5005 || h->type == bfd_link_hash_defweak)
5006 && h->u.def.section->output_section != NULL)
5010 val = (h->u.def.value
5011 + bfd_get_section_vma (output_bfd,
5012 h->u.def.section->output_section)
5013 + h->u.def.section->output_offset);
5014 if (! bfd_set_start_address (output_bfd, val))
5015 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5022 /* We couldn't find the entry symbol. Try parsing it as a
5024 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5027 if (! bfd_set_start_address (output_bfd, val))
5028 einfo (_("%P%F: can't set start address\n"));
5034 /* Can't find the entry symbol, and it's not a number. Use
5035 the first address in the text section. */
5036 ts = bfd_get_section_by_name (output_bfd, entry_section);
5040 einfo (_("%P: warning: cannot find entry symbol %s;"
5041 " defaulting to %V\n"),
5043 bfd_get_section_vma (output_bfd, ts));
5044 if (! bfd_set_start_address (output_bfd,
5045 bfd_get_section_vma (output_bfd,
5047 einfo (_("%P%F: can't set start address\n"));
5052 einfo (_("%P: warning: cannot find entry symbol %s;"
5053 " not setting start address\n"),
5059 /* Don't bfd_hash_table_free (&lang_definedness_table);
5060 map file output may result in a call of lang_track_definedness. */
5063 /* This is a small function used when we want to ignore errors from
5067 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5069 /* Don't do anything. */
5072 /* Check that the architecture of all the input files is compatible
5073 with the output file. Also call the backend to let it do any
5074 other checking that is needed. */
5079 lang_statement_union_type *file;
5081 const bfd_arch_info_type *compatible;
5083 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5085 input_bfd = file->input_statement.the_bfd;
5087 = bfd_arch_get_compatible (input_bfd, output_bfd,
5088 command_line.accept_unknown_input_arch);
5090 /* In general it is not possible to perform a relocatable
5091 link between differing object formats when the input
5092 file has relocations, because the relocations in the
5093 input format may not have equivalent representations in
5094 the output format (and besides BFD does not translate
5095 relocs for other link purposes than a final link). */
5096 if ((link_info.relocatable || link_info.emitrelocations)
5097 && (compatible == NULL
5098 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
5099 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5101 einfo (_("%P%F: Relocatable linking with relocations from"
5102 " format %s (%B) to format %s (%B) is not supported\n"),
5103 bfd_get_target (input_bfd), input_bfd,
5104 bfd_get_target (output_bfd), output_bfd);
5105 /* einfo with %F exits. */
5108 if (compatible == NULL)
5110 if (command_line.warn_mismatch)
5111 einfo (_("%P: warning: %s architecture of input file `%B'"
5112 " is incompatible with %s output\n"),
5113 bfd_printable_name (input_bfd), input_bfd,
5114 bfd_printable_name (output_bfd));
5116 else if (bfd_count_sections (input_bfd))
5118 /* If the input bfd has no contents, it shouldn't set the
5119 private data of the output bfd. */
5121 bfd_error_handler_type pfn = NULL;
5123 /* If we aren't supposed to warn about mismatched input
5124 files, temporarily set the BFD error handler to a
5125 function which will do nothing. We still want to call
5126 bfd_merge_private_bfd_data, since it may set up
5127 information which is needed in the output file. */
5128 if (! command_line.warn_mismatch)
5129 pfn = bfd_set_error_handler (ignore_bfd_errors);
5130 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
5132 if (command_line.warn_mismatch)
5133 einfo (_("%P%X: failed to merge target specific data"
5134 " of file %B\n"), input_bfd);
5136 if (! command_line.warn_mismatch)
5137 bfd_set_error_handler (pfn);
5142 /* Look through all the global common symbols and attach them to the
5143 correct section. The -sort-common command line switch may be used
5144 to roughly sort the entries by size. */
5149 if (command_line.inhibit_common_definition)
5151 if (link_info.relocatable
5152 && ! command_line.force_common_definition)
5155 if (! config.sort_common)
5156 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5161 for (power = 4; power >= 0; power--)
5162 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5166 /* Place one common symbol in the correct section. */
5169 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5171 unsigned int power_of_two;
5175 if (h->type != bfd_link_hash_common)
5179 power_of_two = h->u.c.p->alignment_power;
5181 if (config.sort_common
5182 && power_of_two < (unsigned int) *(int *) info)
5185 section = h->u.c.p->section;
5187 /* Increase the size of the section to align the common sym. */
5188 section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
5189 section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
5191 /* Adjust the alignment if necessary. */
5192 if (power_of_two > section->alignment_power)
5193 section->alignment_power = power_of_two;
5195 /* Change the symbol from common to defined. */
5196 h->type = bfd_link_hash_defined;
5197 h->u.def.section = section;
5198 h->u.def.value = section->size;
5200 /* Increase the size of the section. */
5201 section->size += size;
5203 /* Make sure the section is allocated in memory, and make sure that
5204 it is no longer a common section. */
5205 section->flags |= SEC_ALLOC;
5206 section->flags &= ~SEC_IS_COMMON;
5208 if (config.map_file != NULL)
5210 static bfd_boolean header_printed;
5215 if (! header_printed)
5217 minfo (_("\nAllocating common symbols\n"));
5218 minfo (_("Common symbol size file\n\n"));
5219 header_printed = TRUE;
5222 name = demangle (h->root.string);
5224 len = strlen (name);
5239 if (size <= 0xffffffff)
5240 sprintf (buf, "%lx", (unsigned long) size);
5242 sprintf_vma (buf, size);
5252 minfo ("%B\n", section->owner);
5258 /* Run through the input files and ensure that every input section has
5259 somewhere to go. If one is found without a destination then create
5260 an input request and place it into the statement tree. */
5263 lang_place_orphans (void)
5265 LANG_FOR_EACH_INPUT_STATEMENT (file)
5269 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5271 if (s->output_section == NULL)
5273 /* This section of the file is not attached, root
5274 around for a sensible place for it to go. */
5276 if (file->just_syms_flag)
5277 bfd_link_just_syms (file->the_bfd, s, &link_info);
5278 else if ((s->flags & SEC_EXCLUDE) != 0)
5279 s->output_section = bfd_abs_section_ptr;
5280 else if (strcmp (s->name, "COMMON") == 0)
5282 /* This is a lonely common section which must have
5283 come from an archive. We attach to the section
5284 with the wildcard. */
5285 if (! link_info.relocatable
5286 || command_line.force_common_definition)
5288 if (default_common_section == NULL)
5290 default_common_section =
5291 lang_output_section_statement_lookup (".bss");
5294 lang_add_section (&default_common_section->children, s,
5295 default_common_section);
5298 else if (ldemul_place_orphan (s))
5302 lang_output_section_statement_type *os;
5304 os = lang_output_section_statement_lookup (s->name);
5305 lang_add_section (&os->children, s, os);
5313 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5315 flagword *ptr_flags;
5317 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5323 *ptr_flags |= SEC_ALLOC;
5327 *ptr_flags |= SEC_READONLY;
5331 *ptr_flags |= SEC_DATA;
5335 *ptr_flags |= SEC_CODE;
5340 *ptr_flags |= SEC_LOAD;
5344 einfo (_("%P%F: invalid syntax in flags\n"));
5351 /* Call a function on each input file. This function will be called
5352 on an archive, but not on the elements. */
5355 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5357 lang_input_statement_type *f;
5359 for (f = (lang_input_statement_type *) input_file_chain.head;
5361 f = (lang_input_statement_type *) f->next_real_file)
5365 /* Call a function on each file. The function will be called on all
5366 the elements of an archive which are included in the link, but will
5367 not be called on the archive file itself. */
5370 lang_for_each_file (void (*func) (lang_input_statement_type *))
5372 LANG_FOR_EACH_INPUT_STATEMENT (f)
5379 ldlang_add_file (lang_input_statement_type *entry)
5383 lang_statement_append (&file_chain,
5384 (lang_statement_union_type *) entry,
5387 /* The BFD linker needs to have a list of all input BFDs involved in
5389 ASSERT (entry->the_bfd->link_next == NULL);
5390 ASSERT (entry->the_bfd != output_bfd);
5391 for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
5393 *pp = entry->the_bfd;
5394 entry->the_bfd->usrdata = entry;
5395 bfd_set_gp_size (entry->the_bfd, g_switch_value);
5397 /* Look through the sections and check for any which should not be
5398 included in the link. We need to do this now, so that we can
5399 notice when the backend linker tries to report multiple
5400 definition errors for symbols which are in sections we aren't
5401 going to link. FIXME: It might be better to entirely ignore
5402 symbols which are defined in sections which are going to be
5403 discarded. This would require modifying the backend linker for
5404 each backend which might set the SEC_LINK_ONCE flag. If we do
5405 this, we should probably handle SEC_EXCLUDE in the same way. */
5407 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5411 lang_add_output (const char *name, int from_script)
5413 /* Make -o on command line override OUTPUT in script. */
5414 if (!had_output_filename || !from_script)
5416 output_filename = name;
5417 had_output_filename = TRUE;
5421 static lang_output_section_statement_type *current_section;
5432 for (l = 0; l < 32; l++)
5434 if (i >= (unsigned int) x)
5442 lang_output_section_statement_type *
5443 lang_enter_output_section_statement (const char *output_section_statement_name,
5444 etree_type *address_exp,
5445 enum section_type sectype,
5447 etree_type *subalign,
5451 lang_output_section_statement_type *os;
5453 os = lang_output_section_statement_lookup_1 (output_section_statement_name,
5455 current_section = os;
5457 /* Make next things chain into subchain of this. */
5459 if (os->addr_tree == NULL)
5461 os->addr_tree = address_exp;
5463 os->sectype = sectype;
5464 if (sectype != noload_section)
5465 os->flags = SEC_NO_FLAGS;
5467 os->flags = SEC_NEVER_LOAD;
5468 os->block_value = 1;
5469 stat_ptr = &os->children;
5471 os->subsection_alignment =
5472 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5473 os->section_alignment =
5474 topower (exp_get_value_int (align, -1, "section alignment"));
5476 os->load_base = ebase;
5483 lang_output_statement_type *new;
5485 new = new_stat (lang_output_statement, stat_ptr);
5486 new->name = output_filename;
5489 /* Reset the current counters in the regions. */
5492 lang_reset_memory_regions (void)
5494 lang_memory_region_type *p = lang_memory_region_list;
5496 lang_output_section_statement_type *os;
5498 for (p = lang_memory_region_list; p != NULL; p = p->next)
5500 p->current = p->origin;
5504 for (os = &lang_output_section_statement.head->output_section_statement;
5508 os->processed_vma = FALSE;
5509 os->processed_lma = FALSE;
5512 for (o = output_bfd->sections; o != NULL; o = o->next)
5514 /* Save the last size for possible use by bfd_relax_section. */
5515 o->rawsize = o->size;
5520 /* Worker for lang_gc_sections_1. */
5523 gc_section_callback (lang_wild_statement_type *ptr,
5524 struct wildcard_list *sec ATTRIBUTE_UNUSED,
5526 lang_input_statement_type *file ATTRIBUTE_UNUSED,
5527 void *data ATTRIBUTE_UNUSED)
5529 /* If the wild pattern was marked KEEP, the member sections
5530 should be as well. */
5531 if (ptr->keep_sections)
5532 section->flags |= SEC_KEEP;
5535 /* Iterate over sections marking them against GC. */
5538 lang_gc_sections_1 (lang_statement_union_type *s)
5540 for (; s != NULL; s = s->header.next)
5542 switch (s->header.type)
5544 case lang_wild_statement_enum:
5545 walk_wild (&s->wild_statement, gc_section_callback, NULL);
5547 case lang_constructors_statement_enum:
5548 lang_gc_sections_1 (constructor_list.head);
5550 case lang_output_section_statement_enum:
5551 lang_gc_sections_1 (s->output_section_statement.children.head);
5553 case lang_group_statement_enum:
5554 lang_gc_sections_1 (s->group_statement.children.head);
5563 lang_gc_sections (void)
5565 struct bfd_link_hash_entry *h;
5566 ldlang_undef_chain_list_type *ulist;
5568 /* Keep all sections so marked in the link script. */
5570 lang_gc_sections_1 (statement_list.head);
5572 /* Keep all sections containing symbols undefined on the command-line,
5573 and the section containing the entry symbol. */
5575 for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
5577 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
5578 FALSE, FALSE, FALSE);
5581 && (h->type == bfd_link_hash_defined
5582 || h->type == bfd_link_hash_defweak)
5583 && ! bfd_is_abs_section (h->u.def.section))
5585 h->u.def.section->flags |= SEC_KEEP;
5589 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5590 the special case of debug info. (See bfd/stabs.c)
5591 Twiddle the flag here, to simplify later linker code. */
5592 if (link_info.relocatable)
5594 LANG_FOR_EACH_INPUT_STATEMENT (f)
5597 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
5598 if ((sec->flags & SEC_DEBUGGING) == 0)
5599 sec->flags &= ~SEC_EXCLUDE;
5603 if (link_info.gc_sections)
5604 bfd_gc_sections (output_bfd, &link_info);
5607 /* Relax all sections until bfd_relax_section gives up. */
5610 relax_sections (void)
5612 /* Keep relaxing until bfd_relax_section gives up. */
5613 bfd_boolean relax_again;
5617 relax_again = FALSE;
5619 /* Note: pe-dll.c does something like this also. If you find
5620 you need to change this code, you probably need to change
5621 pe-dll.c also. DJ */
5623 /* Do all the assignments with our current guesses as to
5625 lang_do_assignments ();
5627 /* We must do this after lang_do_assignments, because it uses
5629 lang_reset_memory_regions ();
5631 /* Perform another relax pass - this time we know where the
5632 globals are, so can make a better guess. */
5633 lang_size_sections (&relax_again, FALSE);
5635 while (relax_again);
5641 /* Finalize dynamic list. */
5642 if (link_info.dynamic)
5643 lang_finalize_version_expr_head (&link_info.dynamic->head);
5645 current_target = default_target;
5647 /* Open the output file. */
5648 lang_for_each_statement (ldlang_open_output);
5651 ldemul_create_output_section_statements ();
5653 /* Add to the hash table all undefineds on the command line. */
5654 lang_place_undefineds ();
5656 if (!bfd_section_already_linked_table_init ())
5657 einfo (_("%P%F: Failed to create hash table\n"));
5659 /* Create a bfd for each input file. */
5660 current_target = default_target;
5661 open_input_bfds (statement_list.head, FALSE);
5663 link_info.gc_sym_list = &entry_symbol;
5664 if (entry_symbol.name == NULL)
5665 link_info.gc_sym_list = ldlang_undef_chain_list_head;
5667 ldemul_after_open ();
5669 bfd_section_already_linked_table_free ();
5671 /* Make sure that we're not mixing architectures. We call this
5672 after all the input files have been opened, but before we do any
5673 other processing, so that any operations merge_private_bfd_data
5674 does on the output file will be known during the rest of the
5678 /* Handle .exports instead of a version script if we're told to do so. */
5679 if (command_line.version_exports_section)
5680 lang_do_version_exports_section ();
5682 /* Build all sets based on the information gathered from the input
5684 ldctor_build_sets ();
5686 /* Remove unreferenced sections if asked to. */
5687 lang_gc_sections ();
5689 /* Size up the common data. */
5692 /* Update wild statements. */
5693 update_wild_statements (statement_list.head);
5695 /* Run through the contours of the script and attach input sections
5696 to the correct output sections. */
5697 map_input_to_output_sections (statement_list.head, NULL, NULL);
5699 /* Find any sections not attached explicitly and handle them. */
5700 lang_place_orphans ();
5702 if (! link_info.relocatable)
5706 /* Merge SEC_MERGE sections. This has to be done after GC of
5707 sections, so that GCed sections are not merged, but before
5708 assigning dynamic symbols, since removing whole input sections
5710 bfd_merge_sections (output_bfd, &link_info);
5712 /* Look for a text section and set the readonly attribute in it. */
5713 found = bfd_get_section_by_name (output_bfd, ".text");
5717 if (config.text_read_only)
5718 found->flags |= SEC_READONLY;
5720 found->flags &= ~SEC_READONLY;
5724 /* Do anything special before sizing sections. This is where ELF
5725 and other back-ends size dynamic sections. */
5726 ldemul_before_allocation ();
5728 /* We must record the program headers before we try to fix the
5729 section positions, since they will affect SIZEOF_HEADERS. */
5730 lang_record_phdrs ();
5732 /* Size up the sections. */
5733 lang_size_sections (NULL, !command_line.relax);
5735 /* Now run around and relax if we can. */
5736 if (command_line.relax)
5738 /* We may need more than one relaxation pass. */
5739 int i = link_info.relax_pass;
5741 /* The backend can use it to determine the current pass. */
5742 link_info.relax_pass = 0;
5747 link_info.relax_pass++;
5750 /* Final extra sizing to report errors. */
5751 lang_do_assignments ();
5752 lang_reset_memory_regions ();
5753 lang_size_sections (NULL, TRUE);
5756 /* See if anything special should be done now we know how big
5758 ldemul_after_allocation ();
5760 /* Fix any .startof. or .sizeof. symbols. */
5761 lang_set_startof ();
5763 /* Do all the assignments, now that we know the final resting places
5764 of all the symbols. */
5766 lang_do_assignments ();
5770 /* Make sure that the section addresses make sense. */
5771 if (! link_info.relocatable
5772 && command_line.check_section_addresses)
5773 lang_check_section_addresses ();
5778 /* EXPORTED TO YACC */
5781 lang_add_wild (struct wildcard_spec *filespec,
5782 struct wildcard_list *section_list,
5783 bfd_boolean keep_sections)
5785 struct wildcard_list *curr, *next;
5786 lang_wild_statement_type *new;
5788 /* Reverse the list as the parser puts it back to front. */
5789 for (curr = section_list, section_list = NULL;
5791 section_list = curr, curr = next)
5793 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
5794 placed_commons = TRUE;
5797 curr->next = section_list;
5800 if (filespec != NULL && filespec->name != NULL)
5802 if (strcmp (filespec->name, "*") == 0)
5803 filespec->name = NULL;
5804 else if (! wildcardp (filespec->name))
5805 lang_has_input_file = TRUE;
5808 new = new_stat (lang_wild_statement, stat_ptr);
5809 new->filename = NULL;
5810 new->filenames_sorted = FALSE;
5811 if (filespec != NULL)
5813 new->filename = filespec->name;
5814 new->filenames_sorted = filespec->sorted == by_name;
5816 new->section_list = section_list;
5817 new->keep_sections = keep_sections;
5818 lang_list_init (&new->children);
5819 analyze_walk_wild_section_handler (new);
5823 lang_section_start (const char *name, etree_type *address,
5824 const segment_type *segment)
5826 lang_address_statement_type *ad;
5828 ad = new_stat (lang_address_statement, stat_ptr);
5829 ad->section_name = name;
5830 ad->address = address;
5831 ad->segment = segment;
5834 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5835 because of a -e argument on the command line, or zero if this is
5836 called by ENTRY in a linker script. Command line arguments take
5840 lang_add_entry (const char *name, bfd_boolean cmdline)
5842 if (entry_symbol.name == NULL
5844 || ! entry_from_cmdline)
5846 entry_symbol.name = name;
5847 entry_from_cmdline = cmdline;
5851 /* Set the default start symbol to NAME. .em files should use this,
5852 not lang_add_entry, to override the use of "start" if neither the
5853 linker script nor the command line specifies an entry point. NAME
5854 must be permanently allocated. */
5856 lang_default_entry (const char *name)
5858 entry_symbol_default = name;
5862 lang_add_target (const char *name)
5864 lang_target_statement_type *new;
5866 new = new_stat (lang_target_statement, stat_ptr);
5871 lang_add_map (const char *name)
5878 map_option_f = TRUE;
5886 lang_add_fill (fill_type *fill)
5888 lang_fill_statement_type *new;
5890 new = new_stat (lang_fill_statement, stat_ptr);
5895 lang_add_data (int type, union etree_union *exp)
5897 lang_data_statement_type *new;
5899 new = new_stat (lang_data_statement, stat_ptr);
5904 /* Create a new reloc statement. RELOC is the BFD relocation type to
5905 generate. HOWTO is the corresponding howto structure (we could
5906 look this up, but the caller has already done so). SECTION is the
5907 section to generate a reloc against, or NAME is the name of the
5908 symbol to generate a reloc against. Exactly one of SECTION and
5909 NAME must be NULL. ADDEND is an expression for the addend. */
5912 lang_add_reloc (bfd_reloc_code_real_type reloc,
5913 reloc_howto_type *howto,
5916 union etree_union *addend)
5918 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5922 p->section = section;
5924 p->addend_exp = addend;
5926 p->addend_value = 0;
5927 p->output_section = NULL;
5928 p->output_offset = 0;
5931 lang_assignment_statement_type *
5932 lang_add_assignment (etree_type *exp)
5934 lang_assignment_statement_type *new;
5936 new = new_stat (lang_assignment_statement, stat_ptr);
5942 lang_add_attribute (enum statement_enum attribute)
5944 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
5948 lang_startup (const char *name)
5950 if (startup_file != NULL)
5952 einfo (_("%P%F: multiple STARTUP files\n"));
5954 first_file->filename = name;
5955 first_file->local_sym_name = name;
5956 first_file->real = TRUE;
5958 startup_file = name;
5962 lang_float (bfd_boolean maybe)
5964 lang_float_flag = maybe;
5968 /* Work out the load- and run-time regions from a script statement, and
5969 store them in *LMA_REGION and *REGION respectively.
5971 MEMSPEC is the name of the run-time region, or the value of
5972 DEFAULT_MEMORY_REGION if the statement didn't specify one.
5973 LMA_MEMSPEC is the name of the load-time region, or null if the
5974 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5975 had an explicit load address.
5977 It is an error to specify both a load region and a load address. */
5980 lang_get_regions (lang_memory_region_type **region,
5981 lang_memory_region_type **lma_region,
5982 const char *memspec,
5983 const char *lma_memspec,
5984 bfd_boolean have_lma,
5985 bfd_boolean have_vma)
5987 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
5989 /* If no runtime region or VMA has been specified, but the load region
5990 has been specified, then use the load region for the runtime region
5992 if (lma_memspec != NULL
5994 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
5995 *region = *lma_region;
5997 *region = lang_memory_region_lookup (memspec, FALSE);
5999 if (have_lma && lma_memspec != 0)
6000 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6004 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6005 lang_output_section_phdr_list *phdrs,
6006 const char *lma_memspec)
6008 lang_get_regions (¤t_section->region,
6009 ¤t_section->lma_region,
6010 memspec, lma_memspec,
6011 current_section->load_base != NULL,
6012 current_section->addr_tree != NULL);
6013 current_section->fill = fill;
6014 current_section->phdrs = phdrs;
6015 stat_ptr = &statement_list;
6018 /* Create an absolute symbol with the given name with the value of the
6019 address of first byte of the section named.
6021 If the symbol already exists, then do nothing. */
6024 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6026 struct bfd_link_hash_entry *h;
6028 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6030 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6032 if (h->type == bfd_link_hash_new
6033 || h->type == bfd_link_hash_undefined)
6037 h->type = bfd_link_hash_defined;
6039 sec = bfd_get_section_by_name (output_bfd, secname);
6043 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
6045 h->u.def.section = bfd_abs_section_ptr;
6049 /* Create an absolute symbol with the given name with the value of the
6050 address of the first byte after the end of the section named.
6052 If the symbol already exists, then do nothing. */
6055 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6057 struct bfd_link_hash_entry *h;
6059 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6061 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6063 if (h->type == bfd_link_hash_new
6064 || h->type == bfd_link_hash_undefined)
6068 h->type = bfd_link_hash_defined;
6070 sec = bfd_get_section_by_name (output_bfd, secname);
6074 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
6075 + TO_ADDR (sec->size));
6077 h->u.def.section = bfd_abs_section_ptr;
6082 lang_statement_append (lang_statement_list_type *list,
6083 lang_statement_union_type *element,
6084 lang_statement_union_type **field)
6086 *(list->tail) = element;
6090 /* Set the output format type. -oformat overrides scripts. */
6093 lang_add_output_format (const char *format,
6098 if (output_target == NULL || !from_script)
6100 if (command_line.endian == ENDIAN_BIG
6103 else if (command_line.endian == ENDIAN_LITTLE
6107 output_target = format;
6111 /* Enter a group. This creates a new lang_group_statement, and sets
6112 stat_ptr to build new statements within the group. */
6115 lang_enter_group (void)
6117 lang_group_statement_type *g;
6119 g = new_stat (lang_group_statement, stat_ptr);
6120 lang_list_init (&g->children);
6121 stat_ptr = &g->children;
6124 /* Leave a group. This just resets stat_ptr to start writing to the
6125 regular list of statements again. Note that this will not work if
6126 groups can occur inside anything else which can adjust stat_ptr,
6127 but currently they can't. */
6130 lang_leave_group (void)
6132 stat_ptr = &statement_list;
6135 /* Add a new program header. This is called for each entry in a PHDRS
6136 command in a linker script. */
6139 lang_new_phdr (const char *name,
6141 bfd_boolean filehdr,
6146 struct lang_phdr *n, **pp;
6148 n = stat_alloc (sizeof (struct lang_phdr));
6151 n->type = exp_get_value_int (type, 0, "program header type");
6152 n->filehdr = filehdr;
6157 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6162 /* Record the program header information in the output BFD. FIXME: We
6163 should not be calling an ELF specific function here. */
6166 lang_record_phdrs (void)
6170 lang_output_section_phdr_list *last;
6171 struct lang_phdr *l;
6172 lang_output_section_statement_type *os;
6175 secs = xmalloc (alc * sizeof (asection *));
6177 for (l = lang_phdr_list; l != NULL; l = l->next)
6184 for (os = &lang_output_section_statement.head->output_section_statement;
6188 lang_output_section_phdr_list *pl;
6190 if (os->constraint == -1)
6198 if (os->sectype == noload_section
6199 || os->bfd_section == NULL
6200 || (os->bfd_section->flags & SEC_ALLOC) == 0)
6205 if (os->bfd_section == NULL)
6208 for (; pl != NULL; pl = pl->next)
6210 if (strcmp (pl->name, l->name) == 0)
6215 secs = xrealloc (secs, alc * sizeof (asection *));
6217 secs[c] = os->bfd_section;
6224 if (l->flags == NULL)
6227 flags = exp_get_vma (l->flags, 0, "phdr flags");
6232 at = exp_get_vma (l->at, 0, "phdr load address");
6234 if (! bfd_record_phdr (output_bfd, l->type,
6235 l->flags != NULL, flags, l->at != NULL,
6236 at, l->filehdr, l->phdrs, c, secs))
6237 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6242 /* Make sure all the phdr assignments succeeded. */
6243 for (os = &lang_output_section_statement.head->output_section_statement;
6247 lang_output_section_phdr_list *pl;
6249 if (os->constraint == -1
6250 || os->bfd_section == NULL)
6253 for (pl = os->phdrs;
6256 if (! pl->used && strcmp (pl->name, "NONE") != 0)
6257 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6258 os->name, pl->name);
6262 /* Record a list of sections which may not be cross referenced. */
6265 lang_add_nocrossref (lang_nocrossref_type *l)
6267 struct lang_nocrossrefs *n;
6269 n = xmalloc (sizeof *n);
6270 n->next = nocrossref_list;
6272 nocrossref_list = n;
6274 /* Set notice_all so that we get informed about all symbols. */
6275 link_info.notice_all = TRUE;
6278 /* Overlay handling. We handle overlays with some static variables. */
6280 /* The overlay virtual address. */
6281 static etree_type *overlay_vma;
6282 /* And subsection alignment. */
6283 static etree_type *overlay_subalign;
6285 /* An expression for the maximum section size seen so far. */
6286 static etree_type *overlay_max;
6288 /* A list of all the sections in this overlay. */
6290 struct overlay_list {
6291 struct overlay_list *next;
6292 lang_output_section_statement_type *os;
6295 static struct overlay_list *overlay_list;
6297 /* Start handling an overlay. */
6300 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
6302 /* The grammar should prevent nested overlays from occurring. */
6303 ASSERT (overlay_vma == NULL
6304 && overlay_subalign == NULL
6305 && overlay_max == NULL);
6307 overlay_vma = vma_expr;
6308 overlay_subalign = subalign;
6311 /* Start a section in an overlay. We handle this by calling
6312 lang_enter_output_section_statement with the correct VMA.
6313 lang_leave_overlay sets up the LMA and memory regions. */
6316 lang_enter_overlay_section (const char *name)
6318 struct overlay_list *n;
6321 lang_enter_output_section_statement (name, overlay_vma, normal_section,
6322 0, overlay_subalign, 0, 0);
6324 /* If this is the first section, then base the VMA of future
6325 sections on this one. This will work correctly even if `.' is
6326 used in the addresses. */
6327 if (overlay_list == NULL)
6328 overlay_vma = exp_nameop (ADDR, name);
6330 /* Remember the section. */
6331 n = xmalloc (sizeof *n);
6332 n->os = current_section;
6333 n->next = overlay_list;
6336 size = exp_nameop (SIZEOF, name);
6338 /* Arrange to work out the maximum section end address. */
6339 if (overlay_max == NULL)
6342 overlay_max = exp_binop (MAX_K, overlay_max, size);
6345 /* Finish a section in an overlay. There isn't any special to do
6349 lang_leave_overlay_section (fill_type *fill,
6350 lang_output_section_phdr_list *phdrs)
6357 name = current_section->name;
6359 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6360 region and that no load-time region has been specified. It doesn't
6361 really matter what we say here, since lang_leave_overlay will
6363 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6365 /* Define the magic symbols. */
6367 clean = xmalloc (strlen (name) + 1);
6369 for (s1 = name; *s1 != '\0'; s1++)
6370 if (ISALNUM (*s1) || *s1 == '_')
6374 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6375 sprintf (buf, "__load_start_%s", clean);
6376 lang_add_assignment (exp_assop ('=', buf,
6377 exp_nameop (LOADADDR, name)));
6379 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6380 sprintf (buf, "__load_stop_%s", clean);
6381 lang_add_assignment (exp_assop ('=', buf,
6383 exp_nameop (LOADADDR, name),
6384 exp_nameop (SIZEOF, name))));
6389 /* Finish an overlay. If there are any overlay wide settings, this
6390 looks through all the sections in the overlay and sets them. */
6393 lang_leave_overlay (etree_type *lma_expr,
6396 const char *memspec,
6397 lang_output_section_phdr_list *phdrs,
6398 const char *lma_memspec)
6400 lang_memory_region_type *region;
6401 lang_memory_region_type *lma_region;
6402 struct overlay_list *l;
6403 lang_nocrossref_type *nocrossref;
6405 lang_get_regions (®ion, &lma_region,
6406 memspec, lma_memspec,
6407 lma_expr != NULL, FALSE);
6411 /* After setting the size of the last section, set '.' to end of the
6413 if (overlay_list != NULL)
6414 overlay_list->os->update_dot_tree
6415 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6420 struct overlay_list *next;
6422 if (fill != NULL && l->os->fill == NULL)
6425 l->os->region = region;
6426 l->os->lma_region = lma_region;
6428 /* The first section has the load address specified in the
6429 OVERLAY statement. The rest are worked out from that.
6430 The base address is not needed (and should be null) if
6431 an LMA region was specified. */
6433 l->os->load_base = lma_expr;
6435 if (phdrs != NULL && l->os->phdrs == NULL)
6436 l->os->phdrs = phdrs;
6440 lang_nocrossref_type *nc;
6442 nc = xmalloc (sizeof *nc);
6443 nc->name = l->os->name;
6444 nc->next = nocrossref;
6453 if (nocrossref != NULL)
6454 lang_add_nocrossref (nocrossref);
6457 overlay_list = NULL;
6461 /* Version handling. This is only useful for ELF. */
6463 /* This global variable holds the version tree that we build. */
6465 struct bfd_elf_version_tree *lang_elf_version_info;
6467 /* If PREV is NULL, return first version pattern matching particular symbol.
6468 If PREV is non-NULL, return first version pattern matching particular
6469 symbol after PREV (previously returned by lang_vers_match). */
6471 static struct bfd_elf_version_expr *
6472 lang_vers_match (struct bfd_elf_version_expr_head *head,
6473 struct bfd_elf_version_expr *prev,
6476 const char *cxx_sym = sym;
6477 const char *java_sym = sym;
6478 struct bfd_elf_version_expr *expr = NULL;
6480 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6482 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
6486 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6488 java_sym = cplus_demangle (sym, DMGL_JAVA);
6493 if (head->htab && (prev == NULL || prev->symbol))
6495 struct bfd_elf_version_expr e;
6497 switch (prev ? prev->mask : 0)
6500 if (head->mask & BFD_ELF_VERSION_C_TYPE)
6503 expr = htab_find (head->htab, &e);
6504 while (expr && strcmp (expr->symbol, sym) == 0)
6505 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
6511 case BFD_ELF_VERSION_C_TYPE:
6512 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6515 expr = htab_find (head->htab, &e);
6516 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
6517 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6523 case BFD_ELF_VERSION_CXX_TYPE:
6524 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6526 e.symbol = java_sym;
6527 expr = htab_find (head->htab, &e);
6528 while (expr && strcmp (expr->symbol, java_sym) == 0)
6529 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6540 /* Finally, try the wildcards. */
6541 if (prev == NULL || prev->symbol)
6542 expr = head->remaining;
6545 for (; expr; expr = expr->next)
6552 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
6555 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6557 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6561 if (fnmatch (expr->pattern, s, 0) == 0)
6567 free ((char *) cxx_sym);
6568 if (java_sym != sym)
6569 free ((char *) java_sym);
6573 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6574 return a string pointing to the symbol name. */
6577 realsymbol (const char *pattern)
6580 bfd_boolean changed = FALSE, backslash = FALSE;
6581 char *s, *symbol = xmalloc (strlen (pattern) + 1);
6583 for (p = pattern, s = symbol; *p != '\0'; ++p)
6585 /* It is a glob pattern only if there is no preceding
6587 if (! backslash && (*p == '?' || *p == '*' || *p == '['))
6595 /* Remove the preceding backslash. */
6602 backslash = *p == '\\';
6617 /* This is called for each variable name or match expression. NEW is
6618 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6619 pattern to be matched against symbol names. */
6621 struct bfd_elf_version_expr *
6622 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
6625 bfd_boolean literal_p)
6627 struct bfd_elf_version_expr *ret;
6629 ret = xmalloc (sizeof *ret);
6631 ret->pattern = literal_p ? NULL : new;
6634 ret->symbol = literal_p ? new : realsymbol (new);
6636 if (lang == NULL || strcasecmp (lang, "C") == 0)
6637 ret->mask = BFD_ELF_VERSION_C_TYPE;
6638 else if (strcasecmp (lang, "C++") == 0)
6639 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
6640 else if (strcasecmp (lang, "Java") == 0)
6641 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
6644 einfo (_("%X%P: unknown language `%s' in version information\n"),
6646 ret->mask = BFD_ELF_VERSION_C_TYPE;
6649 return ldemul_new_vers_pattern (ret);
6652 /* This is called for each set of variable names and match
6655 struct bfd_elf_version_tree *
6656 lang_new_vers_node (struct bfd_elf_version_expr *globals,
6657 struct bfd_elf_version_expr *locals)
6659 struct bfd_elf_version_tree *ret;
6661 ret = xcalloc (1, sizeof *ret);
6662 ret->globals.list = globals;
6663 ret->locals.list = locals;
6664 ret->match = lang_vers_match;
6665 ret->name_indx = (unsigned int) -1;
6669 /* This static variable keeps track of version indices. */
6671 static int version_index;
6674 version_expr_head_hash (const void *p)
6676 const struct bfd_elf_version_expr *e = p;
6678 return htab_hash_string (e->symbol);
6682 version_expr_head_eq (const void *p1, const void *p2)
6684 const struct bfd_elf_version_expr *e1 = p1;
6685 const struct bfd_elf_version_expr *e2 = p2;
6687 return strcmp (e1->symbol, e2->symbol) == 0;
6691 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
6694 struct bfd_elf_version_expr *e, *next;
6695 struct bfd_elf_version_expr **list_loc, **remaining_loc;
6697 for (e = head->list; e; e = e->next)
6701 head->mask |= e->mask;
6706 head->htab = htab_create (count * 2, version_expr_head_hash,
6707 version_expr_head_eq, NULL);
6708 list_loc = &head->list;
6709 remaining_loc = &head->remaining;
6710 for (e = head->list; e; e = next)
6716 remaining_loc = &e->next;
6720 void **loc = htab_find_slot (head->htab, e, INSERT);
6724 struct bfd_elf_version_expr *e1, *last;
6730 if (e1->mask == e->mask)
6738 while (e1 && strcmp (e1->symbol, e->symbol) == 0);
6742 /* This is a duplicate. */
6743 /* FIXME: Memory leak. Sometimes pattern is not
6744 xmalloced alone, but in larger chunk of memory. */
6745 /* free (e->symbol); */
6750 e->next = last->next;
6758 list_loc = &e->next;
6762 *remaining_loc = NULL;
6763 *list_loc = head->remaining;
6766 head->remaining = head->list;
6769 /* This is called when we know the name and dependencies of the
6773 lang_register_vers_node (const char *name,
6774 struct bfd_elf_version_tree *version,
6775 struct bfd_elf_version_deps *deps)
6777 struct bfd_elf_version_tree *t, **pp;
6778 struct bfd_elf_version_expr *e1;
6783 if ((name[0] == '\0' && lang_elf_version_info != NULL)
6784 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
6786 einfo (_("%X%P: anonymous version tag cannot be combined"
6787 " with other version tags\n"));
6792 /* Make sure this node has a unique name. */
6793 for (t = lang_elf_version_info; t != NULL; t = t->next)
6794 if (strcmp (t->name, name) == 0)
6795 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
6797 lang_finalize_version_expr_head (&version->globals);
6798 lang_finalize_version_expr_head (&version->locals);
6800 /* Check the global and local match names, and make sure there
6801 aren't any duplicates. */
6803 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
6805 for (t = lang_elf_version_info; t != NULL; t = t->next)
6807 struct bfd_elf_version_expr *e2;
6809 if (t->locals.htab && e1->symbol)
6811 e2 = htab_find (t->locals.htab, e1);
6812 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
6814 if (e1->mask == e2->mask)
6815 einfo (_("%X%P: duplicate expression `%s'"
6816 " in version information\n"), e1->symbol);
6820 else if (!e1->symbol)
6821 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
6822 if (strcmp (e1->pattern, e2->pattern) == 0
6823 && e1->mask == e2->mask)
6824 einfo (_("%X%P: duplicate expression `%s'"
6825 " in version information\n"), e1->pattern);
6829 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
6831 for (t = lang_elf_version_info; t != NULL; t = t->next)
6833 struct bfd_elf_version_expr *e2;
6835 if (t->globals.htab && e1->symbol)
6837 e2 = htab_find (t->globals.htab, e1);
6838 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
6840 if (e1->mask == e2->mask)
6841 einfo (_("%X%P: duplicate expression `%s'"
6842 " in version information\n"),
6847 else if (!e1->symbol)
6848 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
6849 if (strcmp (e1->pattern, e2->pattern) == 0
6850 && e1->mask == e2->mask)
6851 einfo (_("%X%P: duplicate expression `%s'"
6852 " in version information\n"), e1->pattern);
6856 version->deps = deps;
6857 version->name = name;
6858 if (name[0] != '\0')
6861 version->vernum = version_index;
6864 version->vernum = 0;
6866 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
6871 /* This is called when we see a version dependency. */
6873 struct bfd_elf_version_deps *
6874 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
6876 struct bfd_elf_version_deps *ret;
6877 struct bfd_elf_version_tree *t;
6879 ret = xmalloc (sizeof *ret);
6882 for (t = lang_elf_version_info; t != NULL; t = t->next)
6884 if (strcmp (t->name, name) == 0)
6886 ret->version_needed = t;
6891 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
6897 lang_do_version_exports_section (void)
6899 struct bfd_elf_version_expr *greg = NULL, *lreg;
6901 LANG_FOR_EACH_INPUT_STATEMENT (is)
6903 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
6911 contents = xmalloc (len);
6912 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6913 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
6916 while (p < contents + len)
6918 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
6919 p = strchr (p, '\0') + 1;
6922 /* Do not free the contents, as we used them creating the regex. */
6924 /* Do not include this section in the link. */
6925 sec->flags |= SEC_EXCLUDE;
6928 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
6929 lang_register_vers_node (command_line.version_exports_section,
6930 lang_new_vers_node (greg, lreg), NULL);
6934 lang_add_unique (const char *name)
6936 struct unique_sections *ent;
6938 for (ent = unique_section_list; ent; ent = ent->next)
6939 if (strcmp (ent->name, name) == 0)
6942 ent = xmalloc (sizeof *ent);
6943 ent->name = xstrdup (name);
6944 ent->next = unique_section_list;
6945 unique_section_list = ent;
6948 /* Append the list of dynamic symbols to the existing one. */
6951 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
6953 if (link_info.dynamic)
6955 struct bfd_elf_version_expr *tail;
6956 for (tail = dynamic; tail->next != NULL; tail = tail->next)
6958 tail->next = link_info.dynamic->head.list;
6959 link_info.dynamic->head.list = dynamic;
6963 struct bfd_elf_dynamic_list *d;
6965 d = xcalloc (1, sizeof *d);
6966 d->head.list = dynamic;
6967 d->match = lang_vers_match;
6968 link_info.dynamic = d;
6972 /* Append the list of C++ typeinfo dynamic symbols to the existing
6976 lang_append_dynamic_list_cpp_typeinfo (void)
6978 const char * symbols [] =
6980 "typeinfo name for*",
6983 struct bfd_elf_version_expr *dynamic = NULL;
6986 for (i = 0; i < ARRAY_SIZE (symbols); i++)
6987 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
6990 lang_append_dynamic_list (dynamic);