daily update
[binutils.git] / ld / ldlang.c
blobb06cabd40b63f7965e2da2e88259fa4997362ca0
1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "libiberty.h"
26 #include "safe-ctype.h"
27 #include "obstack.h"
28 #include "bfdlink.h"
30 #include "ld.h"
31 #include "ldmain.h"
32 #include "ldexp.h"
33 #include "ldlang.h"
34 #include <ldgram.h>
35 #include "ldlex.h"
36 #include "ldmisc.h"
37 #include "ldctor.h"
38 #include "ldfile.h"
39 #include "ldemul.h"
40 #include "fnmatch.h"
41 #include "demangle.h"
42 #include "hashtab.h"
44 #ifndef offsetof
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
46 #endif
48 /* Locals variables. */
49 static struct obstack stat_obstack;
50 static struct obstack map_obstack;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file;
55 static bfd_boolean placed_commons = FALSE;
56 static bfd_boolean stripped_excluded_sections = FALSE;
57 static lang_output_section_statement_type *default_common_section;
58 static bfd_boolean map_option_f;
59 static bfd_vma print_dot;
60 static lang_input_statement_type *first_file;
61 static const char *current_target;
62 static const char *output_target;
63 static lang_statement_list_type statement_list;
64 static struct bfd_hash_table lang_definedness_table;
66 /* Forward declarations. */
67 static void exp_init_os (etree_type *);
68 static void init_map_userdata (bfd *, asection *, void *);
69 static lang_input_statement_type *lookup_name (const char *);
70 static struct bfd_hash_entry *lang_definedness_newfunc
71 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
72 static void insert_undefined (const char *);
73 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
74 static void print_statement (lang_statement_union_type *,
75 lang_output_section_statement_type *);
76 static void print_statement_list (lang_statement_union_type *,
77 lang_output_section_statement_type *);
78 static void print_statements (void);
79 static void print_input_section (asection *);
80 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
81 static void lang_record_phdrs (void);
82 static void lang_do_version_exports_section (void);
83 static void lang_finalize_version_expr_head
84 (struct bfd_elf_version_expr_head *);
86 /* Exported variables. */
87 lang_output_section_statement_type *abs_output_section;
88 lang_statement_list_type lang_output_section_statement;
89 lang_statement_list_type *stat_ptr = &statement_list;
90 lang_statement_list_type file_chain = { NULL, NULL };
91 lang_statement_list_type input_file_chain;
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)
129 void *
130 stat_alloc (size_t size)
132 return obstack_alloc (&stat_obstack, size);
135 bfd_boolean
136 unique_section_p (const asection *sec)
138 struct unique_sections *unam;
139 const char *secnam;
141 if (link_info.relocatable
142 && sec->owner != NULL
143 && bfd_is_group_section (sec->owner, sec))
144 return TRUE;
146 secnam = sec->name;
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)
152 return TRUE;
155 return FALSE;
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. */
165 static void
166 walk_wild_consider_section (lang_wild_statement_type *ptr,
167 lang_input_statement_type *file,
168 asection *s,
169 struct wildcard_list *sec,
170 callback_t callback,
171 void *data)
173 bfd_boolean skip = FALSE;
174 struct name_list *list_tmp;
176 /* Don't process sections from files which were
177 excluded. */
178 for (list_tmp = sec->spec.exclude_name_list;
179 list_tmp;
180 list_tmp = list_tmp->next)
182 bfd_boolean is_wildcard = wildcardp (list_tmp->name);
183 if (is_wildcard)
184 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
185 else
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)
194 if (is_wildcard)
195 skip = fnmatch (list_tmp->name,
196 file->the_bfd->my_archive->filename,
197 0) == 0;
198 else
199 skip = strcmp (list_tmp->name,
200 file->the_bfd->my_archive->filename) == 0;
203 if (skip)
204 break;
207 if (!skip)
208 (*callback) (ptr, sec, s, file, data);
211 /* Lowest common denominator routine that can handle everything correctly,
212 but slowly. */
214 static void
215 walk_wild_section_general (lang_wild_statement_type *ptr,
216 lang_input_statement_type *file,
217 callback_t callback,
218 void *data)
220 asection *s;
221 struct wildcard_list *sec;
223 for (s = file->the_bfd->sections; s != NULL; s = s->next)
225 sec = ptr->section_list;
226 if (sec == NULL)
227 (*callback) (ptr, sec, s, file, data);
229 while (sec != NULL)
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;
239 else
240 skip = strcmp (sec->spec.name, sname) != 0;
243 if (!skip)
244 walk_wild_consider_section (ptr, file, s, sec, callback, data);
246 sec = sec->next;
251 /* Routines to find a single section given its name. If there's more
252 than one section with that name, we report that. */
254 typedef struct
256 asection *found_section;
257 bfd_boolean multiple_sections_found;
258 } section_iterator_callback_data;
260 static bfd_boolean
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;
268 return TRUE;
271 d->found_section = s;
272 return FALSE;
275 static asection *
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. */
294 static bfd_boolean
295 is_simple_wild (const char *name)
297 size_t len = strcspn (name, "*?[");
298 return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
301 static bfd_boolean
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])
308 return FALSE;
310 pattern += 4;
311 name += 4;
312 while (*pattern != '*')
313 if (*name++ != *pattern++)
314 return FALSE;
316 return TRUE;
319 /* Compare sections ASEC and BSEC according to SORT. */
321 static int
322 compare_section (sort_type sort, asection *asec, asection *bsec)
324 int ret;
326 switch (sort)
328 default:
329 abort ();
331 case by_alignment_name:
332 ret = (bfd_section_alignment (bsec->owner, bsec)
333 - bfd_section_alignment (asec->owner, asec));
334 if (ret)
335 break;
336 /* Fall through. */
338 case by_name:
339 ret = strcmp (bfd_get_section_name (asec->owner, asec),
340 bfd_get_section_name (bsec->owner, bsec));
341 break;
343 case by_name_alignment:
344 ret = strcmp (bfd_get_section_name (asec->owner, asec),
345 bfd_get_section_name (bsec->owner, bsec));
346 if (ret)
347 break;
348 /* Fall through. */
350 case by_alignment:
351 ret = (bfd_section_alignment (bsec->owner, bsec)
352 - bfd_section_alignment (asec->owner, asec));
353 break;
356 return ret;
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,
367 asection *section)
369 lang_section_bst_type **tree;
371 tree = &wild->tree;
372 if (!wild->filenames_sorted
373 && (sec == NULL || sec->spec.sorted == none))
375 /* Append at the right end of tree. */
376 while (*tree)
377 tree = &((*tree)->right);
378 return tree;
381 while (*tree)
383 /* Find the correct node to append this section. */
384 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
385 tree = &((*tree)->left);
386 else
387 tree = &((*tree)->right);
390 return tree;
393 /* Use wild_sort_fast to build a BST to sort sections. */
395 static void
396 output_section_callback_fast (lang_wild_statement_type *ptr,
397 struct wildcard_list *sec,
398 asection *section,
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))
406 return;
408 node = xmalloc (sizeof (lang_section_bst_type));
409 node->left = 0;
410 node->right = 0;
411 node->section = section;
413 tree = wild_sort_fast (ptr, sec, file, section);
414 if (tree != NULL)
415 *tree = node;
418 /* Convert a sorted sections' BST back to list form. */
420 static void
421 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
422 lang_section_bst_type *tree,
423 void *output)
425 if (tree->left)
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);
431 if (tree->right)
432 output_section_callback_tree_to_list (ptr, tree->right, output);
434 free (tree);
437 /* Specialized, optimized routines for handling different kinds of
438 wildcards */
440 static void
441 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
442 lang_input_statement_type *file,
443 callback_t callback,
444 void *data)
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);
457 else if (s0)
458 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
461 static void
462 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
463 lang_input_statement_type *file,
464 callback_t callback,
465 void *data)
467 asection *s;
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);
475 if (!skip)
476 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
480 static void
481 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
482 lang_input_statement_type *file,
483 callback_t callback,
484 void *data)
486 asection *s;
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);
495 return;
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
504 wildspec1. */
505 if (s == s0)
506 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
507 else
509 const char *sname = bfd_get_section_name (file->the_bfd, s);
510 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
512 if (!skip)
513 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
514 data);
519 static void
520 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
521 lang_input_statement_type *file,
522 callback_t callback,
523 void *data)
525 asection *s;
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);
535 return;
538 for (s = file->the_bfd->sections; s != NULL; s = s->next)
540 if (s == s0)
541 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
542 else
544 const char *sname = bfd_get_section_name (file->the_bfd, s);
545 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
547 if (!skip)
548 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
549 else
551 skip = !match_simple_wild (wildsec2->spec.name, sname);
552 if (!skip)
553 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
554 data);
560 static void
561 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
562 lang_input_statement_type *file,
563 callback_t callback,
564 void *data)
566 asection *s;
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);
577 return;
580 s1 = find_section (file, sec1, &multiple_sections_found);
581 if (multiple_sections_found)
583 walk_wild_section_general (ptr, file, callback, data);
584 return;
587 for (s = file->the_bfd->sections; s != NULL; s = s->next)
589 if (s == s0)
590 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
591 else
592 if (s == s1)
593 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
594 else
596 const char *sname = bfd_get_section_name (file->the_bfd, s);
597 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
598 sname);
600 if (!skip)
601 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
602 data);
603 else
605 skip = !match_simple_wild (wildsec3->spec.name, sname);
606 if (!skip)
607 walk_wild_consider_section (ptr, file, s, wildsec3,
608 callback, data);
614 static void
615 walk_wild_section (lang_wild_statement_type *ptr,
616 lang_input_statement_type *file,
617 callback_t callback,
618 void *data)
620 if (file->just_syms_flag)
621 return;
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. */
631 static bfd_boolean
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')
642 prefix1_len++;
643 if (name2[prefix2_len] == '\0')
644 prefix2_len++;
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
652 statements. */
654 static void
655 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
657 int sec_count = 0;
658 int wild_name_count = 0;
659 struct wildcard_list *sec;
660 int signature;
661 int data_counter;
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;
668 ptr->tree = 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)
678 ++sec_count;
679 if (sec->spec.name == NULL)
680 return;
681 if (wildcardp (sec->spec.name))
683 ++wild_name_count;
684 if (!is_simple_wild (sec->spec.name))
685 return;
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)
693 return;
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))
702 return;
706 signature = (sec_count << 8) + wild_name_count;
707 switch (signature)
709 case 0x0100:
710 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
711 break;
712 case 0x0101:
713 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
714 break;
715 case 0x0201:
716 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
717 break;
718 case 0x0302:
719 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
720 break;
721 case 0x0402:
722 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
723 break;
724 default:
725 return;
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. */
733 data_counter = 0;
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. */
744 static void
745 walk_wild_file (lang_wild_statement_type *s,
746 lang_input_statement_type *f,
747 callback_t callback,
748 void *data)
750 if (f->the_bfd == NULL
751 || ! bfd_check_format (f->the_bfd, bfd_archive))
752 walk_wild_section (s, f, callback, data);
753 else
755 bfd *member;
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);
777 static void
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);
798 else
800 lang_input_statement_type *f;
802 /* Perform the iteration over a single file. */
803 f = lookup_name (file_spec);
804 if (f)
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. */
812 static void
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)
818 func (s);
820 switch (s->header.type)
822 case lang_constructors_statement_enum:
823 lang_for_each_statement_worker (func, constructor_list.head);
824 break;
825 case lang_output_section_statement_enum:
826 lang_for_each_statement_worker
827 (func, s->output_section_statement.children.head);
828 break;
829 case lang_wild_statement_enum:
830 lang_for_each_statement_worker (func,
831 s->wild_statement.children.head);
832 break;
833 case lang_group_statement_enum:
834 lang_for_each_statement_worker (func,
835 s->group_statement.children.head);
836 break;
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:
848 break;
849 default:
850 FAIL ();
851 break;
856 void
857 lang_for_each_statement (void (*func) (lang_statement_union_type *))
859 lang_for_each_statement_worker (func, statement_list.head);
862 /*----------------------------------------------------------------------*/
864 void
865 lang_list_init (lang_statement_list_type *list)
867 list->head = NULL;
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,
875 size_t size,
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);
884 return new;
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,
899 const char *target,
900 bfd_boolean add_to_list)
902 lang_input_statement_type *p;
904 if (add_to_list)
905 p = new_stat (lang_input_statement, stat_ptr);
906 else
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;
914 p->target = target;
915 p->sysrooted = FALSE;
917 if (file_type == lang_input_file_is_l_enum
918 && name[0] == ':' && name[1] != '\0')
920 file_type = lang_input_file_is_search_file_enum;
921 name = name + 1;
924 switch (file_type)
926 case lang_input_file_is_symbols_only_enum:
927 p->filename = name;
928 p->is_archive = FALSE;
929 p->real = TRUE;
930 p->local_sym_name = name;
931 p->just_syms_flag = TRUE;
932 p->search_dirs_flag = FALSE;
933 break;
934 case lang_input_file_is_fake_enum:
935 p->filename = name;
936 p->is_archive = FALSE;
937 p->real = FALSE;
938 p->local_sym_name = name;
939 p->just_syms_flag = FALSE;
940 p->search_dirs_flag = FALSE;
941 break;
942 case lang_input_file_is_l_enum:
943 p->is_archive = TRUE;
944 p->filename = name;
945 p->real = TRUE;
946 p->local_sym_name = concat ("-l", name, NULL);
947 p->just_syms_flag = FALSE;
948 p->search_dirs_flag = TRUE;
949 break;
950 case lang_input_file_is_marker_enum:
951 p->filename = name;
952 p->is_archive = FALSE;
953 p->real = FALSE;
954 p->local_sym_name = name;
955 p->just_syms_flag = FALSE;
956 p->search_dirs_flag = TRUE;
957 break;
958 case lang_input_file_is_search_file_enum:
959 p->sysrooted = ldlang_sysrooted_script;
960 p->filename = name;
961 p->is_archive = FALSE;
962 p->real = TRUE;
963 p->local_sym_name = name;
964 p->just_syms_flag = FALSE;
965 p->search_dirs_flag = TRUE;
966 break;
967 case lang_input_file_is_file_enum:
968 p->filename = name;
969 p->is_archive = FALSE;
970 p->real = TRUE;
971 p->local_sym_name = name;
972 p->just_syms_flag = FALSE;
973 p->search_dirs_flag = FALSE;
974 break;
975 default:
976 FAIL ();
978 p->the_bfd = NULL;
979 p->asymbols = NULL;
980 p->next_real_file = NULL;
981 p->next = NULL;
982 p->symbol_count = 0;
983 p->dynamic = config.dynamic_link;
984 p->add_needed = add_needed;
985 p->as_needed = as_needed;
986 p->whole_archive = whole_archive;
987 p->loaded = FALSE;
988 lang_statement_append (&input_file_chain,
989 (lang_statement_union_type *) p,
990 &p->next_real_file);
991 return p;
994 lang_input_statement_type *
995 lang_add_input_file (const char *name,
996 lang_input_file_enum_type file_type,
997 const char *target)
999 return new_afile (name, file_type, target, TRUE);
1002 struct out_section_hash_entry
1004 struct bfd_hash_entry root;
1005 lang_statement_union_type s;
1008 /* The hash table. */
1010 static struct bfd_hash_table output_section_statement_table;
1012 /* Support routines for the hash table used by lang_output_section_find,
1013 initialize the table, fill in an entry and remove the table. */
1015 static struct bfd_hash_entry *
1016 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1017 struct bfd_hash_table *table,
1018 const char *string)
1020 lang_output_section_statement_type **nextp;
1021 struct out_section_hash_entry *ret;
1023 if (entry == NULL)
1025 entry = bfd_hash_allocate (table, sizeof (*ret));
1026 if (entry == NULL)
1027 return entry;
1030 entry = bfd_hash_newfunc (entry, table, string);
1031 if (entry == NULL)
1032 return entry;
1034 ret = (struct out_section_hash_entry *) entry;
1035 memset (&ret->s, 0, sizeof (ret->s));
1036 ret->s.header.type = lang_output_section_statement_enum;
1037 ret->s.output_section_statement.subsection_alignment = -1;
1038 ret->s.output_section_statement.section_alignment = -1;
1039 ret->s.output_section_statement.block_value = 1;
1040 lang_list_init (&ret->s.output_section_statement.children);
1041 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1043 /* For every output section statement added to the list, except the
1044 first one, lang_output_section_statement.tail points to the "next"
1045 field of the last element of the list. */
1046 if (lang_output_section_statement.head != NULL)
1047 ret->s.output_section_statement.prev
1048 = ((lang_output_section_statement_type *)
1049 ((char *) lang_output_section_statement.tail
1050 - offsetof (lang_output_section_statement_type, next)));
1052 /* GCC's strict aliasing rules prevent us from just casting the
1053 address, so we store the pointer in a variable and cast that
1054 instead. */
1055 nextp = &ret->s.output_section_statement.next;
1056 lang_statement_append (&lang_output_section_statement,
1057 &ret->s,
1058 (lang_statement_union_type **) nextp);
1059 return &ret->root;
1062 static void
1063 output_section_statement_table_init (void)
1065 if (!bfd_hash_table_init_n (&output_section_statement_table,
1066 output_section_statement_newfunc,
1067 sizeof (struct out_section_hash_entry),
1068 61))
1069 einfo (_("%P%F: can not create hash table: %E\n"));
1072 static void
1073 output_section_statement_table_free (void)
1075 bfd_hash_table_free (&output_section_statement_table);
1078 /* Build enough state so that the parser can build its tree. */
1080 void
1081 lang_init (void)
1083 obstack_begin (&stat_obstack, 1000);
1085 stat_ptr = &statement_list;
1087 output_section_statement_table_init ();
1089 lang_list_init (stat_ptr);
1091 lang_list_init (&input_file_chain);
1092 lang_list_init (&lang_output_section_statement);
1093 lang_list_init (&file_chain);
1094 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1095 NULL);
1096 abs_output_section =
1097 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
1099 abs_output_section->bfd_section = bfd_abs_section_ptr;
1101 /* The value "3" is ad-hoc, somewhat related to the expected number of
1102 DEFINED expressions in a linker script. For most default linker
1103 scripts, there are none. Why a hash table then? Well, it's somewhat
1104 simpler to re-use working machinery than using a linked list in terms
1105 of code-complexity here in ld, besides the initialization which just
1106 looks like other code here. */
1107 if (!bfd_hash_table_init_n (&lang_definedness_table,
1108 lang_definedness_newfunc,
1109 sizeof (struct lang_definedness_hash_entry),
1111 einfo (_("%P%F: can not create hash table: %E\n"));
1114 void
1115 lang_finish (void)
1117 output_section_statement_table_free ();
1120 /*----------------------------------------------------------------------
1121 A region is an area of memory declared with the
1122 MEMORY { name:org=exp, len=exp ... }
1123 syntax.
1125 We maintain a list of all the regions here.
1127 If no regions are specified in the script, then the default is used
1128 which is created when looked up to be the entire data space.
1130 If create is true we are creating a region inside a MEMORY block.
1131 In this case it is probably an error to create a region that has
1132 already been created. If we are not inside a MEMORY block it is
1133 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1134 and so we issue a warning. */
1136 static lang_memory_region_type *lang_memory_region_list;
1137 static lang_memory_region_type **lang_memory_region_list_tail
1138 = &lang_memory_region_list;
1140 lang_memory_region_type *
1141 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1143 lang_memory_region_type *p;
1144 lang_memory_region_type *new;
1146 /* NAME is NULL for LMA memspecs if no region was specified. */
1147 if (name == NULL)
1148 return NULL;
1150 for (p = lang_memory_region_list; p != NULL; p = p->next)
1151 if (strcmp (p->name, name) == 0)
1153 if (create)
1154 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1155 name);
1156 return p;
1159 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1160 einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
1162 new = stat_alloc (sizeof (lang_memory_region_type));
1164 new->name = xstrdup (name);
1165 new->next = NULL;
1166 new->origin = 0;
1167 new->length = ~(bfd_size_type) 0;
1168 new->current = 0;
1169 new->last_os = NULL;
1170 new->flags = 0;
1171 new->not_flags = 0;
1172 new->had_full_message = FALSE;
1174 *lang_memory_region_list_tail = new;
1175 lang_memory_region_list_tail = &new->next;
1177 return new;
1180 static lang_memory_region_type *
1181 lang_memory_default (asection *section)
1183 lang_memory_region_type *p;
1185 flagword sec_flags = section->flags;
1187 /* Override SEC_DATA to mean a writable section. */
1188 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1189 sec_flags |= SEC_DATA;
1191 for (p = lang_memory_region_list; p != NULL; p = p->next)
1193 if ((p->flags & sec_flags) != 0
1194 && (p->not_flags & sec_flags) == 0)
1196 return p;
1199 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1202 lang_output_section_statement_type *
1203 lang_output_section_find (const char *const name)
1205 struct out_section_hash_entry *entry;
1206 unsigned long hash;
1208 entry = ((struct out_section_hash_entry *)
1209 bfd_hash_lookup (&output_section_statement_table, name,
1210 FALSE, FALSE));
1211 if (entry == NULL)
1212 return NULL;
1214 hash = entry->root.hash;
1217 if (entry->s.output_section_statement.constraint != -1)
1218 return &entry->s.output_section_statement;
1219 entry = (struct out_section_hash_entry *) entry->root.next;
1221 while (entry != NULL
1222 && entry->root.hash == hash
1223 && strcmp (name, entry->s.output_section_statement.name) == 0);
1225 return NULL;
1228 static lang_output_section_statement_type *
1229 lang_output_section_statement_lookup_1 (const char *const name, int constraint)
1231 struct out_section_hash_entry *entry;
1232 struct out_section_hash_entry *last_ent;
1233 unsigned long hash;
1235 entry = ((struct out_section_hash_entry *)
1236 bfd_hash_lookup (&output_section_statement_table, name,
1237 TRUE, FALSE));
1238 if (entry == NULL)
1240 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1241 return NULL;
1244 if (entry->s.output_section_statement.name != NULL)
1246 /* We have a section of this name, but it might not have the correct
1247 constraint. */
1248 hash = entry->root.hash;
1251 if (entry->s.output_section_statement.constraint != -1
1252 && (constraint == 0
1253 || (constraint == entry->s.output_section_statement.constraint
1254 && constraint != SPECIAL)))
1255 return &entry->s.output_section_statement;
1256 last_ent = entry;
1257 entry = (struct out_section_hash_entry *) entry->root.next;
1259 while (entry != NULL
1260 && entry->root.hash == hash
1261 && strcmp (name, entry->s.output_section_statement.name) == 0);
1263 entry
1264 = ((struct out_section_hash_entry *)
1265 output_section_statement_newfunc (NULL,
1266 &output_section_statement_table,
1267 name));
1268 if (entry == NULL)
1270 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1271 return NULL;
1273 entry->root = last_ent->root;
1274 last_ent->root.next = &entry->root;
1277 entry->s.output_section_statement.name = name;
1278 entry->s.output_section_statement.constraint = constraint;
1279 return &entry->s.output_section_statement;
1282 lang_output_section_statement_type *
1283 lang_output_section_statement_lookup (const char *const name)
1285 return lang_output_section_statement_lookup_1 (name, 0);
1288 /* A variant of lang_output_section_find used by place_orphan.
1289 Returns the output statement that should precede a new output
1290 statement for SEC. If an exact match is found on certain flags,
1291 sets *EXACT too. */
1293 lang_output_section_statement_type *
1294 lang_output_section_find_by_flags (const asection *sec,
1295 lang_output_section_statement_type **exact,
1296 lang_match_sec_type_func match_type)
1298 lang_output_section_statement_type *first, *look, *found;
1299 flagword flags;
1301 /* We know the first statement on this list is *ABS*. May as well
1302 skip it. */
1303 first = &lang_output_section_statement.head->output_section_statement;
1304 first = first->next;
1306 /* First try for an exact match. */
1307 found = NULL;
1308 for (look = first; look; look = look->next)
1310 flags = look->flags;
1311 if (look->bfd_section != NULL)
1313 flags = look->bfd_section->flags;
1314 if (match_type && !match_type (output_bfd, look->bfd_section,
1315 sec->owner, sec))
1316 continue;
1318 flags ^= sec->flags;
1319 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1320 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1321 found = look;
1323 if (found != NULL)
1325 if (exact != NULL)
1326 *exact = found;
1327 return found;
1330 if (sec->flags & SEC_CODE)
1332 /* Try for a rw code section. */
1333 for (look = first; look; look = look->next)
1335 flags = look->flags;
1336 if (look->bfd_section != NULL)
1338 flags = look->bfd_section->flags;
1339 if (match_type && !match_type (output_bfd, look->bfd_section,
1340 sec->owner, sec))
1341 continue;
1343 flags ^= sec->flags;
1344 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1345 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1346 found = look;
1349 else if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
1351 /* .rodata can go after .text, .sdata2 after .rodata. */
1352 for (look = first; look; look = look->next)
1354 flags = look->flags;
1355 if (look->bfd_section != NULL)
1357 flags = look->bfd_section->flags;
1358 if (match_type && !match_type (output_bfd, look->bfd_section,
1359 sec->owner, sec))
1360 continue;
1362 flags ^= sec->flags;
1363 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1364 | SEC_READONLY))
1365 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1366 found = look;
1369 else if (sec->flags & SEC_SMALL_DATA)
1371 /* .sdata goes after .data, .sbss after .sdata. */
1372 for (look = first; look; look = look->next)
1374 flags = look->flags;
1375 if (look->bfd_section != NULL)
1377 flags = look->bfd_section->flags;
1378 if (match_type && !match_type (output_bfd, look->bfd_section,
1379 sec->owner, sec))
1380 continue;
1382 flags ^= sec->flags;
1383 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1384 | SEC_THREAD_LOCAL))
1385 || ((look->flags & SEC_SMALL_DATA)
1386 && !(sec->flags & SEC_HAS_CONTENTS)))
1387 found = look;
1390 else if (sec->flags & SEC_HAS_CONTENTS)
1392 /* .data goes after .rodata. */
1393 for (look = first; look; look = look->next)
1395 flags = look->flags;
1396 if (look->bfd_section != NULL)
1398 flags = look->bfd_section->flags;
1399 if (match_type && !match_type (output_bfd, look->bfd_section,
1400 sec->owner, sec))
1401 continue;
1403 flags ^= sec->flags;
1404 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1405 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1406 found = look;
1409 else
1411 /* .bss goes last. */
1412 for (look = first; look; look = look->next)
1414 flags = look->flags;
1415 if (look->bfd_section != NULL)
1417 flags = look->bfd_section->flags;
1418 if (match_type && !match_type (output_bfd, look->bfd_section,
1419 sec->owner, sec))
1420 continue;
1422 flags ^= sec->flags;
1423 if (!(flags & SEC_ALLOC))
1424 found = look;
1428 if (found || !match_type)
1429 return found;
1431 return lang_output_section_find_by_flags (sec, NULL, NULL);
1434 /* Find the last output section before given output statement.
1435 Used by place_orphan. */
1437 static asection *
1438 output_prev_sec_find (lang_output_section_statement_type *os)
1440 lang_output_section_statement_type *lookup;
1442 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1444 if (lookup->constraint == -1)
1445 continue;
1447 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1448 return lookup->bfd_section;
1451 return NULL;
1454 lang_output_section_statement_type *
1455 lang_insert_orphan (asection *s,
1456 const char *secname,
1457 lang_output_section_statement_type *after,
1458 struct orphan_save *place,
1459 etree_type *address,
1460 lang_statement_list_type *add_child)
1462 lang_statement_list_type *old;
1463 lang_statement_list_type add;
1464 const char *ps;
1465 lang_output_section_statement_type *os;
1466 lang_output_section_statement_type **os_tail;
1468 /* Start building a list of statements for this section.
1469 First save the current statement pointer. */
1470 old = stat_ptr;
1472 /* If we have found an appropriate place for the output section
1473 statements for this orphan, add them to our own private list,
1474 inserting them later into the global statement list. */
1475 if (after != NULL)
1477 stat_ptr = &add;
1478 lang_list_init (stat_ptr);
1481 ps = NULL;
1482 if (config.build_constructors)
1484 /* If the name of the section is representable in C, then create
1485 symbols to mark the start and the end of the section. */
1486 for (ps = secname; *ps != '\0'; ps++)
1487 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1488 break;
1489 if (*ps == '\0')
1491 char *symname;
1492 etree_type *e_align;
1494 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1495 symname[0] = bfd_get_symbol_leading_char (output_bfd);
1496 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1497 e_align = exp_unop (ALIGN_K,
1498 exp_intop ((bfd_vma) 1 << s->alignment_power));
1499 lang_add_assignment (exp_assop ('=', ".", e_align));
1500 lang_add_assignment (exp_provide (symname,
1501 exp_nameop (NAME, "."),
1502 FALSE));
1506 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1507 address = exp_intop (0);
1509 os_tail = ((lang_output_section_statement_type **)
1510 lang_output_section_statement.tail);
1511 os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
1512 NULL, 0);
1514 if (add_child == NULL)
1515 add_child = &os->children;
1516 lang_add_section (add_child, s, os);
1518 lang_leave_output_section_statement (0, "*default*", NULL, NULL);
1520 if (config.build_constructors && *ps == '\0')
1522 char *symname;
1524 /* lang_leave_ouput_section_statement resets stat_ptr.
1525 Put stat_ptr back where we want it. */
1526 if (after != NULL)
1527 stat_ptr = &add;
1529 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1530 symname[0] = bfd_get_symbol_leading_char (output_bfd);
1531 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1532 lang_add_assignment (exp_provide (symname,
1533 exp_nameop (NAME, "."),
1534 FALSE));
1537 /* Restore the global list pointer. */
1538 if (after != NULL)
1539 stat_ptr = old;
1541 if (after != NULL && os->bfd_section != NULL)
1543 asection *snew, *as;
1545 snew = os->bfd_section;
1547 /* Shuffle the bfd section list to make the output file look
1548 neater. This is really only cosmetic. */
1549 if (place->section == NULL
1550 && after != (&lang_output_section_statement.head
1551 ->output_section_statement))
1553 asection *bfd_section = after->bfd_section;
1555 /* If the output statement hasn't been used to place any input
1556 sections (and thus doesn't have an output bfd_section),
1557 look for the closest prior output statement having an
1558 output section. */
1559 if (bfd_section == NULL)
1560 bfd_section = output_prev_sec_find (after);
1562 if (bfd_section != NULL && bfd_section != snew)
1563 place->section = &bfd_section->next;
1566 if (place->section == NULL)
1567 place->section = &output_bfd->sections;
1569 as = *place->section;
1571 if (!as)
1573 /* Put the section at the end of the list. */
1575 /* Unlink the section. */
1576 bfd_section_list_remove (output_bfd, snew);
1578 /* Now tack it back on in the right place. */
1579 bfd_section_list_append (output_bfd, snew);
1581 else if (as != snew && as->prev != snew)
1583 /* Unlink the section. */
1584 bfd_section_list_remove (output_bfd, snew);
1586 /* Now tack it back on in the right place. */
1587 bfd_section_list_insert_before (output_bfd, as, snew);
1590 /* Save the end of this list. Further ophans of this type will
1591 follow the one we've just added. */
1592 place->section = &snew->next;
1594 /* The following is non-cosmetic. We try to put the output
1595 statements in some sort of reasonable order here, because they
1596 determine the final load addresses of the orphan sections.
1597 In addition, placing output statements in the wrong order may
1598 require extra segments. For instance, given a typical
1599 situation of all read-only sections placed in one segment and
1600 following that a segment containing all the read-write
1601 sections, we wouldn't want to place an orphan read/write
1602 section before or amongst the read-only ones. */
1603 if (add.head != NULL)
1605 lang_output_section_statement_type *newly_added_os;
1607 if (place->stmt == NULL)
1609 lang_statement_union_type **where;
1610 lang_statement_union_type **assign = NULL;
1611 bfd_boolean ignore_first;
1613 /* Look for a suitable place for the new statement list.
1614 The idea is to skip over anything that might be inside
1615 a SECTIONS {} statement in a script, before we find
1616 another output_section_statement. Assignments to "dot"
1617 before an output section statement are assumed to
1618 belong to it. An exception to this rule is made for
1619 the first assignment to dot, otherwise we might put an
1620 orphan before . = . + SIZEOF_HEADERS or similar
1621 assignments that set the initial address. */
1623 ignore_first = after == (&lang_output_section_statement.head
1624 ->output_section_statement);
1625 for (where = &after->header.next;
1626 *where != NULL;
1627 where = &(*where)->header.next)
1629 switch ((*where)->header.type)
1631 case lang_assignment_statement_enum:
1632 if (assign == NULL)
1634 lang_assignment_statement_type *ass;
1635 ass = &(*where)->assignment_statement;
1636 if (ass->exp->type.node_class != etree_assert
1637 && ass->exp->assign.dst[0] == '.'
1638 && ass->exp->assign.dst[1] == 0
1639 && !ignore_first)
1640 assign = where;
1642 ignore_first = FALSE;
1643 continue;
1644 case lang_wild_statement_enum:
1645 case lang_input_section_enum:
1646 case lang_object_symbols_statement_enum:
1647 case lang_fill_statement_enum:
1648 case lang_data_statement_enum:
1649 case lang_reloc_statement_enum:
1650 case lang_padding_statement_enum:
1651 case lang_constructors_statement_enum:
1652 assign = NULL;
1653 continue;
1654 case lang_output_section_statement_enum:
1655 if (assign != NULL)
1656 where = assign;
1657 break;
1658 case lang_input_statement_enum:
1659 case lang_address_statement_enum:
1660 case lang_target_statement_enum:
1661 case lang_output_statement_enum:
1662 case lang_group_statement_enum:
1663 case lang_afile_asection_pair_statement_enum:
1664 continue;
1666 break;
1669 *add.tail = *where;
1670 *where = add.head;
1672 place->os_tail = &after->next;
1674 else
1676 /* Put it after the last orphan statement we added. */
1677 *add.tail = *place->stmt;
1678 *place->stmt = add.head;
1681 /* Fix the global list pointer if we happened to tack our
1682 new list at the tail. */
1683 if (*old->tail == add.head)
1684 old->tail = add.tail;
1686 /* Save the end of this list. */
1687 place->stmt = add.tail;
1689 /* Do the same for the list of output section statements. */
1690 newly_added_os = *os_tail;
1691 *os_tail = NULL;
1692 newly_added_os->prev = (lang_output_section_statement_type *)
1693 ((char *) place->os_tail
1694 - offsetof (lang_output_section_statement_type, next));
1695 newly_added_os->next = *place->os_tail;
1696 if (newly_added_os->next != NULL)
1697 newly_added_os->next->prev = newly_added_os;
1698 *place->os_tail = newly_added_os;
1699 place->os_tail = &newly_added_os->next;
1701 /* Fixing the global list pointer here is a little different.
1702 We added to the list in lang_enter_output_section_statement,
1703 trimmed off the new output_section_statment above when
1704 assigning *os_tail = NULL, but possibly added it back in
1705 the same place when assigning *place->os_tail. */
1706 if (*os_tail == NULL)
1707 lang_output_section_statement.tail
1708 = (lang_statement_union_type **) os_tail;
1711 return os;
1714 static void
1715 lang_map_flags (flagword flag)
1717 if (flag & SEC_ALLOC)
1718 minfo ("a");
1720 if (flag & SEC_CODE)
1721 minfo ("x");
1723 if (flag & SEC_READONLY)
1724 minfo ("r");
1726 if (flag & SEC_DATA)
1727 minfo ("w");
1729 if (flag & SEC_LOAD)
1730 minfo ("l");
1733 void
1734 lang_map (void)
1736 lang_memory_region_type *m;
1737 bfd_boolean dis_header_printed = FALSE;
1738 bfd *p;
1740 LANG_FOR_EACH_INPUT_STATEMENT (file)
1742 asection *s;
1744 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1745 || file->just_syms_flag)
1746 continue;
1748 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1749 if ((s->output_section == NULL
1750 || s->output_section->owner != output_bfd)
1751 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1753 if (! dis_header_printed)
1755 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1756 dis_header_printed = TRUE;
1759 print_input_section (s);
1763 minfo (_("\nMemory Configuration\n\n"));
1764 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1765 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1767 for (m = lang_memory_region_list; m != NULL; m = m->next)
1769 char buf[100];
1770 int len;
1772 fprintf (config.map_file, "%-16s ", m->name);
1774 sprintf_vma (buf, m->origin);
1775 minfo ("0x%s ", buf);
1776 len = strlen (buf);
1777 while (len < 16)
1779 print_space ();
1780 ++len;
1783 minfo ("0x%V", m->length);
1784 if (m->flags || m->not_flags)
1786 #ifndef BFD64
1787 minfo (" ");
1788 #endif
1789 if (m->flags)
1791 print_space ();
1792 lang_map_flags (m->flags);
1795 if (m->not_flags)
1797 minfo (" !");
1798 lang_map_flags (m->not_flags);
1802 print_nl ();
1805 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1807 if (! link_info.reduce_memory_overheads)
1809 obstack_begin (&map_obstack, 1000);
1810 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1811 bfd_map_over_sections (p, init_map_userdata, 0);
1812 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1814 lang_statement_iteration ++;
1815 print_statements ();
1818 static void
1819 init_map_userdata (abfd, sec, data)
1820 bfd *abfd ATTRIBUTE_UNUSED;
1821 asection *sec;
1822 void *data ATTRIBUTE_UNUSED;
1824 fat_section_userdata_type *new_data
1825 = ((fat_section_userdata_type *) (stat_alloc
1826 (sizeof (fat_section_userdata_type))));
1828 ASSERT (get_userdata (sec) == NULL);
1829 get_userdata (sec) = new_data;
1830 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1833 static bfd_boolean
1834 sort_def_symbol (hash_entry, info)
1835 struct bfd_link_hash_entry *hash_entry;
1836 void *info ATTRIBUTE_UNUSED;
1838 if (hash_entry->type == bfd_link_hash_defined
1839 || hash_entry->type == bfd_link_hash_defweak)
1841 struct fat_user_section_struct *ud;
1842 struct map_symbol_def *def;
1844 ud = get_userdata (hash_entry->u.def.section);
1845 if (! ud)
1847 /* ??? What do we have to do to initialize this beforehand? */
1848 /* The first time we get here is bfd_abs_section... */
1849 init_map_userdata (0, hash_entry->u.def.section, 0);
1850 ud = get_userdata (hash_entry->u.def.section);
1852 else if (!ud->map_symbol_def_tail)
1853 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1855 def = obstack_alloc (&map_obstack, sizeof *def);
1856 def->entry = hash_entry;
1857 *(ud->map_symbol_def_tail) = def;
1858 ud->map_symbol_def_tail = &def->next;
1860 return TRUE;
1863 /* Initialize an output section. */
1865 static void
1866 init_os (lang_output_section_statement_type *s, asection *isec,
1867 flagword flags)
1869 if (s->bfd_section != NULL)
1870 return;
1872 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1873 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
1875 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
1876 if (s->bfd_section == NULL)
1877 s->bfd_section = bfd_make_section_with_flags (output_bfd, s->name,
1878 flags);
1879 if (s->bfd_section == NULL)
1881 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1882 output_bfd->xvec->name, s->name);
1884 s->bfd_section->output_section = s->bfd_section;
1885 s->bfd_section->output_offset = 0;
1887 if (!link_info.reduce_memory_overheads)
1889 fat_section_userdata_type *new
1890 = stat_alloc (sizeof (fat_section_userdata_type));
1891 memset (new, 0, sizeof (fat_section_userdata_type));
1892 get_userdata (s->bfd_section) = new;
1895 /* If there is a base address, make sure that any sections it might
1896 mention are initialized. */
1897 if (s->addr_tree != NULL)
1898 exp_init_os (s->addr_tree);
1900 if (s->load_base != NULL)
1901 exp_init_os (s->load_base);
1903 /* If supplied an alignment, set it. */
1904 if (s->section_alignment != -1)
1905 s->bfd_section->alignment_power = s->section_alignment;
1907 if (isec)
1908 bfd_init_private_section_data (isec->owner, isec,
1909 output_bfd, s->bfd_section,
1910 &link_info);
1913 /* Make sure that all output sections mentioned in an expression are
1914 initialized. */
1916 static void
1917 exp_init_os (etree_type *exp)
1919 switch (exp->type.node_class)
1921 case etree_assign:
1922 case etree_provide:
1923 exp_init_os (exp->assign.src);
1924 break;
1926 case etree_binary:
1927 exp_init_os (exp->binary.lhs);
1928 exp_init_os (exp->binary.rhs);
1929 break;
1931 case etree_trinary:
1932 exp_init_os (exp->trinary.cond);
1933 exp_init_os (exp->trinary.lhs);
1934 exp_init_os (exp->trinary.rhs);
1935 break;
1937 case etree_assert:
1938 exp_init_os (exp->assert_s.child);
1939 break;
1941 case etree_unary:
1942 exp_init_os (exp->unary.child);
1943 break;
1945 case etree_name:
1946 switch (exp->type.node_code)
1948 case ADDR:
1949 case LOADADDR:
1950 case SIZEOF:
1952 lang_output_section_statement_type *os;
1954 os = lang_output_section_find (exp->name.name);
1955 if (os != NULL && os->bfd_section == NULL)
1956 init_os (os, NULL, 0);
1959 break;
1961 default:
1962 break;
1966 static void
1967 section_already_linked (bfd *abfd, asection *sec, void *data)
1969 lang_input_statement_type *entry = data;
1971 /* If we are only reading symbols from this object, then we want to
1972 discard all sections. */
1973 if (entry->just_syms_flag)
1975 bfd_link_just_syms (abfd, sec, &link_info);
1976 return;
1979 if (!(abfd->flags & DYNAMIC))
1980 bfd_section_already_linked (abfd, sec, &link_info);
1983 /* The wild routines.
1985 These expand statements like *(.text) and foo.o to a list of
1986 explicit actions, like foo.o(.text), bar.o(.text) and
1987 foo.o(.text, .data). */
1989 /* Add SECTION to the output section OUTPUT. Do this by creating a
1990 lang_input_section statement which is placed at PTR. FILE is the
1991 input file which holds SECTION. */
1993 void
1994 lang_add_section (lang_statement_list_type *ptr,
1995 asection *section,
1996 lang_output_section_statement_type *output)
1998 flagword flags = section->flags;
1999 bfd_boolean discard;
2001 /* Discard sections marked with SEC_EXCLUDE. */
2002 discard = (flags & SEC_EXCLUDE) != 0;
2004 /* Discard input sections which are assigned to a section named
2005 DISCARD_SECTION_NAME. */
2006 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2007 discard = TRUE;
2009 /* Discard debugging sections if we are stripping debugging
2010 information. */
2011 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2012 && (flags & SEC_DEBUGGING) != 0)
2013 discard = TRUE;
2015 if (discard)
2017 if (section->output_section == NULL)
2019 /* This prevents future calls from assigning this section. */
2020 section->output_section = bfd_abs_section_ptr;
2022 return;
2025 if (section->output_section == NULL)
2027 bfd_boolean first;
2028 lang_input_section_type *new;
2029 flagword flags;
2031 flags = section->flags;
2033 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2034 to an output section, because we want to be able to include a
2035 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2036 section (I don't know why we want to do this, but we do).
2037 build_link_order in ldwrite.c handles this case by turning
2038 the embedded SEC_NEVER_LOAD section into a fill. */
2040 flags &= ~ SEC_NEVER_LOAD;
2042 switch (output->sectype)
2044 case normal_section:
2045 case overlay_section:
2046 break;
2047 case noalloc_section:
2048 flags &= ~SEC_ALLOC;
2049 break;
2050 case noload_section:
2051 flags &= ~SEC_LOAD;
2052 flags |= SEC_NEVER_LOAD;
2053 break;
2056 if (output->bfd_section == NULL)
2057 init_os (output, section, flags);
2059 first = ! output->bfd_section->linker_has_input;
2060 output->bfd_section->linker_has_input = 1;
2062 if (!link_info.relocatable
2063 && !stripped_excluded_sections)
2065 asection *s = output->bfd_section->map_tail.s;
2066 output->bfd_section->map_tail.s = section;
2067 section->map_head.s = NULL;
2068 section->map_tail.s = s;
2069 if (s != NULL)
2070 s->map_head.s = section;
2071 else
2072 output->bfd_section->map_head.s = section;
2075 /* Add a section reference to the list. */
2076 new = new_stat (lang_input_section, ptr);
2078 new->section = section;
2079 section->output_section = output->bfd_section;
2081 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2082 already been processed. One reason to do this is that on pe
2083 format targets, .text$foo sections go into .text and it's odd
2084 to see .text with SEC_LINK_ONCE set. */
2086 if (! link_info.relocatable)
2087 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
2089 /* If this is not the first input section, and the SEC_READONLY
2090 flag is not currently set, then don't set it just because the
2091 input section has it set. */
2093 if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
2094 flags &= ~ SEC_READONLY;
2096 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2097 if (! first
2098 && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2099 != (flags & (SEC_MERGE | SEC_STRINGS))
2100 || ((flags & SEC_MERGE)
2101 && output->bfd_section->entsize != section->entsize)))
2103 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2104 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2107 output->bfd_section->flags |= flags;
2109 if (flags & SEC_MERGE)
2110 output->bfd_section->entsize = section->entsize;
2112 /* If SEC_READONLY is not set in the input section, then clear
2113 it from the output section. */
2114 if ((section->flags & SEC_READONLY) == 0)
2115 output->bfd_section->flags &= ~SEC_READONLY;
2117 /* Copy over SEC_SMALL_DATA. */
2118 if (section->flags & SEC_SMALL_DATA)
2119 output->bfd_section->flags |= SEC_SMALL_DATA;
2121 if (section->alignment_power > output->bfd_section->alignment_power)
2122 output->bfd_section->alignment_power = section->alignment_power;
2124 if (bfd_get_arch (section->owner) == bfd_arch_tic54x
2125 && (section->flags & SEC_TIC54X_BLOCK) != 0)
2127 output->bfd_section->flags |= SEC_TIC54X_BLOCK;
2128 /* FIXME: This value should really be obtained from the bfd... */
2129 output->block_value = 128;
2134 /* Handle wildcard sorting. This returns the lang_input_section which
2135 should follow the one we are going to create for SECTION and FILE,
2136 based on the sorting requirements of WILD. It returns NULL if the
2137 new section should just go at the end of the current list. */
2139 static lang_statement_union_type *
2140 wild_sort (lang_wild_statement_type *wild,
2141 struct wildcard_list *sec,
2142 lang_input_statement_type *file,
2143 asection *section)
2145 const char *section_name;
2146 lang_statement_union_type *l;
2148 if (!wild->filenames_sorted
2149 && (sec == NULL || sec->spec.sorted == none))
2150 return NULL;
2152 section_name = bfd_get_section_name (file->the_bfd, section);
2153 for (l = wild->children.head; l != NULL; l = l->header.next)
2155 lang_input_section_type *ls;
2157 if (l->header.type != lang_input_section_enum)
2158 continue;
2159 ls = &l->input_section;
2161 /* Sorting by filename takes precedence over sorting by section
2162 name. */
2164 if (wild->filenames_sorted)
2166 const char *fn, *ln;
2167 bfd_boolean fa, la;
2168 int i;
2170 /* The PE support for the .idata section as generated by
2171 dlltool assumes that files will be sorted by the name of
2172 the archive and then the name of the file within the
2173 archive. */
2175 if (file->the_bfd != NULL
2176 && bfd_my_archive (file->the_bfd) != NULL)
2178 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2179 fa = TRUE;
2181 else
2183 fn = file->filename;
2184 fa = FALSE;
2187 if (bfd_my_archive (ls->section->owner) != NULL)
2189 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2190 la = TRUE;
2192 else
2194 ln = ls->section->owner->filename;
2195 la = FALSE;
2198 i = strcmp (fn, ln);
2199 if (i > 0)
2200 continue;
2201 else if (i < 0)
2202 break;
2204 if (fa || la)
2206 if (fa)
2207 fn = file->filename;
2208 if (la)
2209 ln = ls->section->owner->filename;
2211 i = strcmp (fn, ln);
2212 if (i > 0)
2213 continue;
2214 else if (i < 0)
2215 break;
2219 /* Here either the files are not sorted by name, or we are
2220 looking at the sections for this file. */
2222 if (sec != NULL && sec->spec.sorted != none)
2223 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2224 break;
2227 return l;
2230 /* Expand a wild statement for a particular FILE. SECTION may be
2231 NULL, in which case it is a wild card. */
2233 static void
2234 output_section_callback (lang_wild_statement_type *ptr,
2235 struct wildcard_list *sec,
2236 asection *section,
2237 lang_input_statement_type *file,
2238 void *output)
2240 lang_statement_union_type *before;
2242 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2243 if (unique_section_p (section))
2244 return;
2246 before = wild_sort (ptr, sec, file, section);
2248 /* Here BEFORE points to the lang_input_section which
2249 should follow the one we are about to add. If BEFORE
2250 is NULL, then the section should just go at the end
2251 of the current list. */
2253 if (before == NULL)
2254 lang_add_section (&ptr->children, section,
2255 (lang_output_section_statement_type *) output);
2256 else
2258 lang_statement_list_type list;
2259 lang_statement_union_type **pp;
2261 lang_list_init (&list);
2262 lang_add_section (&list, section,
2263 (lang_output_section_statement_type *) output);
2265 /* If we are discarding the section, LIST.HEAD will
2266 be NULL. */
2267 if (list.head != NULL)
2269 ASSERT (list.head->header.next == NULL);
2271 for (pp = &ptr->children.head;
2272 *pp != before;
2273 pp = &(*pp)->header.next)
2274 ASSERT (*pp != NULL);
2276 list.head->header.next = *pp;
2277 *pp = list.head;
2282 /* Check if all sections in a wild statement for a particular FILE
2283 are readonly. */
2285 static void
2286 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2287 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2288 asection *section,
2289 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2290 void *data)
2292 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2293 if (unique_section_p (section))
2294 return;
2296 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2297 ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
2300 /* This is passed a file name which must have been seen already and
2301 added to the statement tree. We will see if it has been opened
2302 already and had its symbols read. If not then we'll read it. */
2304 static lang_input_statement_type *
2305 lookup_name (const char *name)
2307 lang_input_statement_type *search;
2309 for (search = (lang_input_statement_type *) input_file_chain.head;
2310 search != NULL;
2311 search = (lang_input_statement_type *) search->next_real_file)
2313 /* Use the local_sym_name as the name of the file that has
2314 already been loaded as filename might have been transformed
2315 via the search directory lookup mechanism. */
2316 const char *filename = search->local_sym_name;
2318 if (filename != NULL
2319 && strcmp (filename, name) == 0)
2320 break;
2323 if (search == NULL)
2324 search = new_afile (name, lang_input_file_is_search_file_enum,
2325 default_target, FALSE);
2327 /* If we have already added this file, or this file is not real
2328 don't add this file. */
2329 if (search->loaded || !search->real)
2330 return search;
2332 if (! load_symbols (search, NULL))
2333 return NULL;
2335 return search;
2338 /* Save LIST as a list of libraries whose symbols should not be exported. */
2340 struct excluded_lib
2342 char *name;
2343 struct excluded_lib *next;
2345 static struct excluded_lib *excluded_libs;
2347 void
2348 add_excluded_libs (const char *list)
2350 const char *p = list, *end;
2352 while (*p != '\0')
2354 struct excluded_lib *entry;
2355 end = strpbrk (p, ",:");
2356 if (end == NULL)
2357 end = p + strlen (p);
2358 entry = xmalloc (sizeof (*entry));
2359 entry->next = excluded_libs;
2360 entry->name = xmalloc (end - p + 1);
2361 memcpy (entry->name, p, end - p);
2362 entry->name[end - p] = '\0';
2363 excluded_libs = entry;
2364 if (*end == '\0')
2365 break;
2366 p = end + 1;
2370 static void
2371 check_excluded_libs (bfd *abfd)
2373 struct excluded_lib *lib = excluded_libs;
2375 while (lib)
2377 int len = strlen (lib->name);
2378 const char *filename = lbasename (abfd->filename);
2380 if (strcmp (lib->name, "ALL") == 0)
2382 abfd->no_export = TRUE;
2383 return;
2386 if (strncmp (lib->name, filename, len) == 0
2387 && (filename[len] == '\0'
2388 || (filename[len] == '.' && filename[len + 1] == 'a'
2389 && filename[len + 2] == '\0')))
2391 abfd->no_export = TRUE;
2392 return;
2395 lib = lib->next;
2399 /* Get the symbols for an input file. */
2401 bfd_boolean
2402 load_symbols (lang_input_statement_type *entry,
2403 lang_statement_list_type *place)
2405 char **matching;
2407 if (entry->loaded)
2408 return TRUE;
2410 ldfile_open_file (entry);
2412 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2413 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2415 bfd_error_type err;
2416 lang_statement_list_type *hold;
2417 bfd_boolean bad_load = TRUE;
2418 bfd_boolean save_ldlang_sysrooted_script;
2419 bfd_boolean save_as_needed, save_add_needed;
2421 err = bfd_get_error ();
2423 /* See if the emulation has some special knowledge. */
2424 if (ldemul_unrecognized_file (entry))
2425 return TRUE;
2427 if (err == bfd_error_file_ambiguously_recognized)
2429 char **p;
2431 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2432 einfo (_("%B: matching formats:"), entry->the_bfd);
2433 for (p = matching; *p != NULL; p++)
2434 einfo (" %s", *p);
2435 einfo ("%F\n");
2437 else if (err != bfd_error_file_not_recognized
2438 || place == NULL)
2439 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2440 else
2441 bad_load = FALSE;
2443 bfd_close (entry->the_bfd);
2444 entry->the_bfd = NULL;
2446 /* Try to interpret the file as a linker script. */
2447 ldfile_open_command_file (entry->filename);
2449 hold = stat_ptr;
2450 stat_ptr = place;
2451 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2452 ldlang_sysrooted_script = entry->sysrooted;
2453 save_as_needed = as_needed;
2454 as_needed = entry->as_needed;
2455 save_add_needed = add_needed;
2456 add_needed = entry->add_needed;
2458 ldfile_assumed_script = TRUE;
2459 parser_input = input_script;
2460 /* We want to use the same -Bdynamic/-Bstatic as the one for
2461 ENTRY. */
2462 config.dynamic_link = entry->dynamic;
2463 yyparse ();
2464 ldfile_assumed_script = FALSE;
2466 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2467 as_needed = save_as_needed;
2468 add_needed = save_add_needed;
2469 stat_ptr = hold;
2471 return ! bad_load;
2474 if (ldemul_recognized_file (entry))
2475 return TRUE;
2477 /* We don't call ldlang_add_file for an archive. Instead, the
2478 add_symbols entry point will call ldlang_add_file, via the
2479 add_archive_element callback, for each element of the archive
2480 which is used. */
2481 switch (bfd_get_format (entry->the_bfd))
2483 default:
2484 break;
2486 case bfd_object:
2487 ldlang_add_file (entry);
2488 if (trace_files || trace_file_tries)
2489 info_msg ("%I\n", entry);
2490 break;
2492 case bfd_archive:
2493 check_excluded_libs (entry->the_bfd);
2495 if (entry->whole_archive)
2497 bfd *member = NULL;
2498 bfd_boolean loaded = TRUE;
2500 for (;;)
2502 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2504 if (member == NULL)
2505 break;
2507 if (! bfd_check_format (member, bfd_object))
2509 einfo (_("%F%B: member %B in archive is not an object\n"),
2510 entry->the_bfd, member);
2511 loaded = FALSE;
2514 if (! ((*link_info.callbacks->add_archive_element)
2515 (&link_info, member, "--whole-archive")))
2516 abort ();
2518 if (! bfd_link_add_symbols (member, &link_info))
2520 einfo (_("%F%B: could not read symbols: %E\n"), member);
2521 loaded = FALSE;
2525 entry->loaded = loaded;
2526 return loaded;
2528 break;
2531 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2532 entry->loaded = TRUE;
2533 else
2534 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2536 return entry->loaded;
2539 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2540 may be NULL, indicating that it is a wildcard. Separate
2541 lang_input_section statements are created for each part of the
2542 expansion; they are added after the wild statement S. OUTPUT is
2543 the output section. */
2545 static void
2546 wild (lang_wild_statement_type *s,
2547 const char *target ATTRIBUTE_UNUSED,
2548 lang_output_section_statement_type *output)
2550 struct wildcard_list *sec;
2552 if (s->handler_data[0]
2553 && s->handler_data[0]->spec.sorted == by_name
2554 && !s->filenames_sorted)
2556 lang_section_bst_type *tree;
2558 walk_wild (s, output_section_callback_fast, output);
2560 tree = s->tree;
2561 if (tree)
2563 output_section_callback_tree_to_list (s, tree, output);
2564 s->tree = NULL;
2567 else
2568 walk_wild (s, output_section_callback, output);
2570 if (default_common_section == NULL)
2571 for (sec = s->section_list; sec != NULL; sec = sec->next)
2572 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2574 /* Remember the section that common is going to in case we
2575 later get something which doesn't know where to put it. */
2576 default_common_section = output;
2577 break;
2581 /* Return TRUE iff target is the sought target. */
2583 static int
2584 get_target (const bfd_target *target, void *data)
2586 const char *sought = data;
2588 return strcmp (target->name, sought) == 0;
2591 /* Like strcpy() but convert to lower case as well. */
2593 static void
2594 stricpy (char *dest, char *src)
2596 char c;
2598 while ((c = *src++) != 0)
2599 *dest++ = TOLOWER (c);
2601 *dest = 0;
2604 /* Remove the first occurrence of needle (if any) in haystack
2605 from haystack. */
2607 static void
2608 strcut (char *haystack, char *needle)
2610 haystack = strstr (haystack, needle);
2612 if (haystack)
2614 char *src;
2616 for (src = haystack + strlen (needle); *src;)
2617 *haystack++ = *src++;
2619 *haystack = 0;
2623 /* Compare two target format name strings.
2624 Return a value indicating how "similar" they are. */
2626 static int
2627 name_compare (char *first, char *second)
2629 char *copy1;
2630 char *copy2;
2631 int result;
2633 copy1 = xmalloc (strlen (first) + 1);
2634 copy2 = xmalloc (strlen (second) + 1);
2636 /* Convert the names to lower case. */
2637 stricpy (copy1, first);
2638 stricpy (copy2, second);
2640 /* Remove size and endian strings from the name. */
2641 strcut (copy1, "big");
2642 strcut (copy1, "little");
2643 strcut (copy2, "big");
2644 strcut (copy2, "little");
2646 /* Return a value based on how many characters match,
2647 starting from the beginning. If both strings are
2648 the same then return 10 * their length. */
2649 for (result = 0; copy1[result] == copy2[result]; result++)
2650 if (copy1[result] == 0)
2652 result *= 10;
2653 break;
2656 free (copy1);
2657 free (copy2);
2659 return result;
2662 /* Set by closest_target_match() below. */
2663 static const bfd_target *winner;
2665 /* Scan all the valid bfd targets looking for one that has the endianness
2666 requirement that was specified on the command line, and is the nearest
2667 match to the original output target. */
2669 static int
2670 closest_target_match (const bfd_target *target, void *data)
2672 const bfd_target *original = data;
2674 if (command_line.endian == ENDIAN_BIG
2675 && target->byteorder != BFD_ENDIAN_BIG)
2676 return 0;
2678 if (command_line.endian == ENDIAN_LITTLE
2679 && target->byteorder != BFD_ENDIAN_LITTLE)
2680 return 0;
2682 /* Must be the same flavour. */
2683 if (target->flavour != original->flavour)
2684 return 0;
2686 /* If we have not found a potential winner yet, then record this one. */
2687 if (winner == NULL)
2689 winner = target;
2690 return 0;
2693 /* Oh dear, we now have two potential candidates for a successful match.
2694 Compare their names and choose the better one. */
2695 if (name_compare (target->name, original->name)
2696 > name_compare (winner->name, original->name))
2697 winner = target;
2699 /* Keep on searching until wqe have checked them all. */
2700 return 0;
2703 /* Return the BFD target format of the first input file. */
2705 static char *
2706 get_first_input_target (void)
2708 char *target = NULL;
2710 LANG_FOR_EACH_INPUT_STATEMENT (s)
2712 if (s->header.type == lang_input_statement_enum
2713 && s->real)
2715 ldfile_open_file (s);
2717 if (s->the_bfd != NULL
2718 && bfd_check_format (s->the_bfd, bfd_object))
2720 target = bfd_get_target (s->the_bfd);
2722 if (target != NULL)
2723 break;
2728 return target;
2731 const char *
2732 lang_get_output_target (void)
2734 const char *target;
2736 /* Has the user told us which output format to use? */
2737 if (output_target != NULL)
2738 return output_target;
2740 /* No - has the current target been set to something other than
2741 the default? */
2742 if (current_target != default_target)
2743 return current_target;
2745 /* No - can we determine the format of the first input file? */
2746 target = get_first_input_target ();
2747 if (target != NULL)
2748 return target;
2750 /* Failed - use the default output target. */
2751 return default_target;
2754 /* Open the output file. */
2756 static bfd *
2757 open_output (const char *name)
2759 bfd *output;
2761 output_target = lang_get_output_target ();
2763 /* Has the user requested a particular endianness on the command
2764 line? */
2765 if (command_line.endian != ENDIAN_UNSET)
2767 const bfd_target *target;
2768 enum bfd_endian desired_endian;
2770 /* Get the chosen target. */
2771 target = bfd_search_for_target (get_target, (void *) output_target);
2773 /* If the target is not supported, we cannot do anything. */
2774 if (target != NULL)
2776 if (command_line.endian == ENDIAN_BIG)
2777 desired_endian = BFD_ENDIAN_BIG;
2778 else
2779 desired_endian = BFD_ENDIAN_LITTLE;
2781 /* See if the target has the wrong endianness. This should
2782 not happen if the linker script has provided big and
2783 little endian alternatives, but some scrips don't do
2784 this. */
2785 if (target->byteorder != desired_endian)
2787 /* If it does, then see if the target provides
2788 an alternative with the correct endianness. */
2789 if (target->alternative_target != NULL
2790 && (target->alternative_target->byteorder == desired_endian))
2791 output_target = target->alternative_target->name;
2792 else
2794 /* Try to find a target as similar as possible to
2795 the default target, but which has the desired
2796 endian characteristic. */
2797 bfd_search_for_target (closest_target_match,
2798 (void *) target);
2800 /* Oh dear - we could not find any targets that
2801 satisfy our requirements. */
2802 if (winner == NULL)
2803 einfo (_("%P: warning: could not find any targets"
2804 " that match endianness requirement\n"));
2805 else
2806 output_target = winner->name;
2812 output = bfd_openw (name, output_target);
2814 if (output == NULL)
2816 if (bfd_get_error () == bfd_error_invalid_target)
2817 einfo (_("%P%F: target %s not found\n"), output_target);
2819 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2822 delete_output_file_on_failure = TRUE;
2824 if (! bfd_set_format (output, bfd_object))
2825 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2826 if (! bfd_set_arch_mach (output,
2827 ldfile_output_architecture,
2828 ldfile_output_machine))
2829 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2831 link_info.hash = bfd_link_hash_table_create (output);
2832 if (link_info.hash == NULL)
2833 einfo (_("%P%F: can not create hash table: %E\n"));
2835 bfd_set_gp_size (output, g_switch_value);
2836 return output;
2839 static void
2840 ldlang_open_output (lang_statement_union_type *statement)
2842 switch (statement->header.type)
2844 case lang_output_statement_enum:
2845 ASSERT (output_bfd == NULL);
2846 output_bfd = open_output (statement->output_statement.name);
2847 ldemul_set_output_arch ();
2848 if (config.magic_demand_paged && !link_info.relocatable)
2849 output_bfd->flags |= D_PAGED;
2850 else
2851 output_bfd->flags &= ~D_PAGED;
2852 if (config.text_read_only)
2853 output_bfd->flags |= WP_TEXT;
2854 else
2855 output_bfd->flags &= ~WP_TEXT;
2856 if (link_info.traditional_format)
2857 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2858 else
2859 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2860 break;
2862 case lang_target_statement_enum:
2863 current_target = statement->target_statement.target;
2864 break;
2865 default:
2866 break;
2870 /* Convert between addresses in bytes and sizes in octets.
2871 For currently supported targets, octets_per_byte is always a power
2872 of two, so we can use shifts. */
2873 #define TO_ADDR(X) ((X) >> opb_shift)
2874 #define TO_SIZE(X) ((X) << opb_shift)
2876 /* Support the above. */
2877 static unsigned int opb_shift = 0;
2879 static void
2880 init_opb (void)
2882 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2883 ldfile_output_machine);
2884 opb_shift = 0;
2885 if (x > 1)
2886 while ((x & 1) == 0)
2888 x >>= 1;
2889 ++opb_shift;
2891 ASSERT (x == 1);
2894 /* Open all the input files. */
2896 static void
2897 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
2899 for (; s != NULL; s = s->header.next)
2901 switch (s->header.type)
2903 case lang_constructors_statement_enum:
2904 open_input_bfds (constructor_list.head, force);
2905 break;
2906 case lang_output_section_statement_enum:
2907 open_input_bfds (s->output_section_statement.children.head, force);
2908 break;
2909 case lang_wild_statement_enum:
2910 /* Maybe we should load the file's symbols. */
2911 if (s->wild_statement.filename
2912 && ! wildcardp (s->wild_statement.filename))
2913 lookup_name (s->wild_statement.filename);
2914 open_input_bfds (s->wild_statement.children.head, force);
2915 break;
2916 case lang_group_statement_enum:
2918 struct bfd_link_hash_entry *undefs;
2920 /* We must continually search the entries in the group
2921 until no new symbols are added to the list of undefined
2922 symbols. */
2926 undefs = link_info.hash->undefs_tail;
2927 open_input_bfds (s->group_statement.children.head, TRUE);
2929 while (undefs != link_info.hash->undefs_tail);
2931 break;
2932 case lang_target_statement_enum:
2933 current_target = s->target_statement.target;
2934 break;
2935 case lang_input_statement_enum:
2936 if (s->input_statement.real)
2938 lang_statement_list_type add;
2940 s->input_statement.target = current_target;
2942 /* If we are being called from within a group, and this
2943 is an archive which has already been searched, then
2944 force it to be researched unless the whole archive
2945 has been loaded already. */
2946 if (force
2947 && !s->input_statement.whole_archive
2948 && s->input_statement.loaded
2949 && bfd_check_format (s->input_statement.the_bfd,
2950 bfd_archive))
2951 s->input_statement.loaded = FALSE;
2953 lang_list_init (&add);
2955 if (! load_symbols (&s->input_statement, &add))
2956 config.make_executable = FALSE;
2958 if (add.head != NULL)
2960 *add.tail = s->header.next;
2961 s->header.next = add.head;
2964 break;
2965 default:
2966 break;
2971 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2973 void
2974 lang_track_definedness (const char *name)
2976 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
2977 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
2980 /* New-function for the definedness hash table. */
2982 static struct bfd_hash_entry *
2983 lang_definedness_newfunc (struct bfd_hash_entry *entry,
2984 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
2985 const char *name ATTRIBUTE_UNUSED)
2987 struct lang_definedness_hash_entry *ret
2988 = (struct lang_definedness_hash_entry *) entry;
2990 if (ret == NULL)
2991 ret = (struct lang_definedness_hash_entry *)
2992 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
2994 if (ret == NULL)
2995 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
2997 ret->iteration = -1;
2998 return &ret->root;
3001 /* Return the iteration when the definition of NAME was last updated. A
3002 value of -1 means that the symbol is not defined in the linker script
3003 or the command line, but may be defined in the linker symbol table. */
3006 lang_symbol_definition_iteration (const char *name)
3008 struct lang_definedness_hash_entry *defentry
3009 = (struct lang_definedness_hash_entry *)
3010 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3012 /* We've already created this one on the presence of DEFINED in the
3013 script, so it can't be NULL unless something is borked elsewhere in
3014 the code. */
3015 if (defentry == NULL)
3016 FAIL ();
3018 return defentry->iteration;
3021 /* Update the definedness state of NAME. */
3023 void
3024 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3026 struct lang_definedness_hash_entry *defentry
3027 = (struct lang_definedness_hash_entry *)
3028 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3030 /* We don't keep track of symbols not tested with DEFINED. */
3031 if (defentry == NULL)
3032 return;
3034 /* If the symbol was already defined, and not from an earlier statement
3035 iteration, don't update the definedness iteration, because that'd
3036 make the symbol seem defined in the linker script at this point, and
3037 it wasn't; it was defined in some object. If we do anyway, DEFINED
3038 would start to yield false before this point and the construct "sym =
3039 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3040 in an object. */
3041 if (h->type != bfd_link_hash_undefined
3042 && h->type != bfd_link_hash_common
3043 && h->type != bfd_link_hash_new
3044 && defentry->iteration == -1)
3045 return;
3047 defentry->iteration = lang_statement_iteration;
3050 /* Add the supplied name to the symbol table as an undefined reference.
3051 This is a two step process as the symbol table doesn't even exist at
3052 the time the ld command line is processed. First we put the name
3053 on a list, then, once the output file has been opened, transfer the
3054 name to the symbol table. */
3056 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3058 #define ldlang_undef_chain_list_head entry_symbol.next
3060 void
3061 ldlang_add_undef (const char *const name)
3063 ldlang_undef_chain_list_type *new =
3064 stat_alloc (sizeof (ldlang_undef_chain_list_type));
3066 new->next = ldlang_undef_chain_list_head;
3067 ldlang_undef_chain_list_head = new;
3069 new->name = xstrdup (name);
3071 if (output_bfd != NULL)
3072 insert_undefined (new->name);
3075 /* Insert NAME as undefined in the symbol table. */
3077 static void
3078 insert_undefined (const char *name)
3080 struct bfd_link_hash_entry *h;
3082 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3083 if (h == NULL)
3084 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3085 if (h->type == bfd_link_hash_new)
3087 h->type = bfd_link_hash_undefined;
3088 h->u.undef.abfd = NULL;
3089 bfd_link_add_undef (link_info.hash, h);
3093 /* Run through the list of undefineds created above and place them
3094 into the linker hash table as undefined symbols belonging to the
3095 script file. */
3097 static void
3098 lang_place_undefineds (void)
3100 ldlang_undef_chain_list_type *ptr;
3102 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3103 insert_undefined (ptr->name);
3106 /* Check for all readonly or some readwrite sections. */
3108 static void
3109 check_input_sections
3110 (lang_statement_union_type *s,
3111 lang_output_section_statement_type *output_section_statement)
3113 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3115 switch (s->header.type)
3117 case lang_wild_statement_enum:
3118 walk_wild (&s->wild_statement, check_section_callback,
3119 output_section_statement);
3120 if (! output_section_statement->all_input_readonly)
3121 return;
3122 break;
3123 case lang_constructors_statement_enum:
3124 check_input_sections (constructor_list.head,
3125 output_section_statement);
3126 if (! output_section_statement->all_input_readonly)
3127 return;
3128 break;
3129 case lang_group_statement_enum:
3130 check_input_sections (s->group_statement.children.head,
3131 output_section_statement);
3132 if (! output_section_statement->all_input_readonly)
3133 return;
3134 break;
3135 default:
3136 break;
3141 /* Update wildcard statements if needed. */
3143 static void
3144 update_wild_statements (lang_statement_union_type *s)
3146 struct wildcard_list *sec;
3148 switch (sort_section)
3150 default:
3151 FAIL ();
3153 case none:
3154 break;
3156 case by_name:
3157 case by_alignment:
3158 for (; s != NULL; s = s->header.next)
3160 switch (s->header.type)
3162 default:
3163 break;
3165 case lang_wild_statement_enum:
3166 sec = s->wild_statement.section_list;
3167 for (sec = s->wild_statement.section_list; sec != NULL;
3168 sec = sec->next)
3170 switch (sec->spec.sorted)
3172 case none:
3173 sec->spec.sorted = sort_section;
3174 break;
3175 case by_name:
3176 if (sort_section == by_alignment)
3177 sec->spec.sorted = by_name_alignment;
3178 break;
3179 case by_alignment:
3180 if (sort_section == by_name)
3181 sec->spec.sorted = by_alignment_name;
3182 break;
3183 default:
3184 break;
3187 break;
3189 case lang_constructors_statement_enum:
3190 update_wild_statements (constructor_list.head);
3191 break;
3193 case lang_output_section_statement_enum:
3194 update_wild_statements
3195 (s->output_section_statement.children.head);
3196 break;
3198 case lang_group_statement_enum:
3199 update_wild_statements (s->group_statement.children.head);
3200 break;
3203 break;
3207 /* Open input files and attach to output sections. */
3209 static void
3210 map_input_to_output_sections
3211 (lang_statement_union_type *s, const char *target,
3212 lang_output_section_statement_type *os)
3214 flagword flags;
3216 for (; s != NULL; s = s->header.next)
3218 switch (s->header.type)
3220 case lang_wild_statement_enum:
3221 wild (&s->wild_statement, target, os);
3222 break;
3223 case lang_constructors_statement_enum:
3224 map_input_to_output_sections (constructor_list.head,
3225 target,
3226 os);
3227 break;
3228 case lang_output_section_statement_enum:
3229 if (s->output_section_statement.constraint)
3231 if (s->output_section_statement.constraint != ONLY_IF_RW
3232 && s->output_section_statement.constraint != ONLY_IF_RO)
3233 break;
3234 s->output_section_statement.all_input_readonly = TRUE;
3235 check_input_sections (s->output_section_statement.children.head,
3236 &s->output_section_statement);
3237 if ((s->output_section_statement.all_input_readonly
3238 && s->output_section_statement.constraint == ONLY_IF_RW)
3239 || (!s->output_section_statement.all_input_readonly
3240 && s->output_section_statement.constraint == ONLY_IF_RO))
3242 s->output_section_statement.constraint = -1;
3243 break;
3247 map_input_to_output_sections (s->output_section_statement.children.head,
3248 target,
3249 &s->output_section_statement);
3250 break;
3251 case lang_output_statement_enum:
3252 break;
3253 case lang_target_statement_enum:
3254 target = s->target_statement.target;
3255 break;
3256 case lang_group_statement_enum:
3257 map_input_to_output_sections (s->group_statement.children.head,
3258 target,
3259 os);
3260 break;
3261 case lang_data_statement_enum:
3262 /* Make sure that any sections mentioned in the expression
3263 are initialized. */
3264 exp_init_os (s->data_statement.exp);
3265 flags = SEC_HAS_CONTENTS;
3266 /* The output section gets contents, and then we inspect for
3267 any flags set in the input script which override any ALLOC. */
3268 if (!(os->flags & SEC_NEVER_LOAD))
3269 flags |= SEC_ALLOC | SEC_LOAD;
3270 if (os->bfd_section == NULL)
3271 init_os (os, NULL, flags);
3272 else
3273 os->bfd_section->flags |= flags;
3274 break;
3275 case lang_input_section_enum:
3276 break;
3277 case lang_fill_statement_enum:
3278 case lang_object_symbols_statement_enum:
3279 case lang_reloc_statement_enum:
3280 case lang_padding_statement_enum:
3281 case lang_input_statement_enum:
3282 if (os != NULL && os->bfd_section == NULL)
3283 init_os (os, NULL, 0);
3284 break;
3285 case lang_assignment_statement_enum:
3286 if (os != NULL && os->bfd_section == NULL)
3287 init_os (os, NULL, 0);
3289 /* Make sure that any sections mentioned in the assignment
3290 are initialized. */
3291 exp_init_os (s->assignment_statement.exp);
3292 break;
3293 case lang_afile_asection_pair_statement_enum:
3294 FAIL ();
3295 break;
3296 case lang_address_statement_enum:
3297 /* Mark the specified section with the supplied address.
3299 If this section was actually a segment marker, then the
3300 directive is ignored if the linker script explicitly
3301 processed the segment marker. Originally, the linker
3302 treated segment directives (like -Ttext on the
3303 command-line) as section directives. We honor the
3304 section directive semantics for backwards compatibilty;
3305 linker scripts that do not specifically check for
3306 SEGMENT_START automatically get the old semantics. */
3307 if (!s->address_statement.segment
3308 || !s->address_statement.segment->used)
3310 lang_output_section_statement_type *aos
3311 = (lang_output_section_statement_lookup
3312 (s->address_statement.section_name));
3314 if (aos->bfd_section == NULL)
3315 init_os (aos, NULL, 0);
3316 aos->addr_tree = s->address_statement.address;
3318 break;
3323 /* An output section might have been removed after its statement was
3324 added. For example, ldemul_before_allocation can remove dynamic
3325 sections if they turn out to be not needed. Clean them up here. */
3327 void
3328 strip_excluded_output_sections (void)
3330 lang_output_section_statement_type *os;
3332 /* Run lang_size_sections (if not already done). */
3333 if (expld.phase != lang_mark_phase_enum)
3335 expld.phase = lang_mark_phase_enum;
3336 expld.dataseg.phase = exp_dataseg_none;
3337 one_lang_size_sections_pass (NULL, FALSE);
3338 lang_reset_memory_regions ();
3341 for (os = &lang_output_section_statement.head->output_section_statement;
3342 os != NULL;
3343 os = os->next)
3345 asection *output_section;
3346 bfd_boolean exclude;
3348 if (os->constraint == -1)
3349 continue;
3351 output_section = os->bfd_section;
3352 if (output_section == NULL)
3353 continue;
3355 exclude = (output_section->rawsize == 0
3356 && (output_section->flags & SEC_KEEP) == 0
3357 && !bfd_section_removed_from_list (output_bfd,
3358 output_section));
3360 /* Some sections have not yet been sized, notably .gnu.version,
3361 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3362 input sections, so don't drop output sections that have such
3363 input sections unless they are also marked SEC_EXCLUDE. */
3364 if (exclude && output_section->map_head.s != NULL)
3366 asection *s;
3368 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3369 if ((s->flags & SEC_LINKER_CREATED) != 0
3370 && (s->flags & SEC_EXCLUDE) == 0)
3372 exclude = FALSE;
3373 break;
3377 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3378 output_section->map_head.link_order = NULL;
3379 output_section->map_tail.link_order = NULL;
3381 if (exclude)
3383 /* We don't set bfd_section to NULL since bfd_section of the
3384 removed output section statement may still be used. */
3385 if (!os->section_relative_symbol
3386 && !os->update_dot_tree)
3387 os->ignored = TRUE;
3388 output_section->flags |= SEC_EXCLUDE;
3389 bfd_section_list_remove (output_bfd, output_section);
3390 output_bfd->section_count--;
3394 /* Stop future calls to lang_add_section from messing with map_head
3395 and map_tail link_order fields. */
3396 stripped_excluded_sections = TRUE;
3399 static void
3400 print_output_section_statement
3401 (lang_output_section_statement_type *output_section_statement)
3403 asection *section = output_section_statement->bfd_section;
3404 int len;
3406 if (output_section_statement != abs_output_section)
3408 minfo ("\n%s", output_section_statement->name);
3410 if (section != NULL)
3412 print_dot = section->vma;
3414 len = strlen (output_section_statement->name);
3415 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3417 print_nl ();
3418 len = 0;
3420 while (len < SECTION_NAME_MAP_LENGTH)
3422 print_space ();
3423 ++len;
3426 minfo ("0x%V %W", section->vma, section->size);
3428 if (section->vma != section->lma)
3429 minfo (_(" load address 0x%V"), section->lma);
3432 print_nl ();
3435 print_statement_list (output_section_statement->children.head,
3436 output_section_statement);
3439 /* Scan for the use of the destination in the right hand side
3440 of an expression. In such cases we will not compute the
3441 correct expression, since the value of DST that is used on
3442 the right hand side will be its final value, not its value
3443 just before this expression is evaluated. */
3445 static bfd_boolean
3446 scan_for_self_assignment (const char * dst, etree_type * rhs)
3448 if (rhs == NULL || dst == NULL)
3449 return FALSE;
3451 switch (rhs->type.node_class)
3453 case etree_binary:
3454 return scan_for_self_assignment (dst, rhs->binary.lhs)
3455 || scan_for_self_assignment (dst, rhs->binary.rhs);
3457 case etree_trinary:
3458 return scan_for_self_assignment (dst, rhs->trinary.lhs)
3459 || scan_for_self_assignment (dst, rhs->trinary.rhs);
3461 case etree_assign:
3462 case etree_provided:
3463 case etree_provide:
3464 if (strcmp (dst, rhs->assign.dst) == 0)
3465 return TRUE;
3466 return scan_for_self_assignment (dst, rhs->assign.src);
3468 case etree_unary:
3469 return scan_for_self_assignment (dst, rhs->unary.child);
3471 case etree_value:
3472 if (rhs->value.str)
3473 return strcmp (dst, rhs->value.str) == 0;
3474 return FALSE;
3476 case etree_name:
3477 if (rhs->name.name)
3478 return strcmp (dst, rhs->name.name) == 0;
3479 return FALSE;
3481 default:
3482 break;
3485 return FALSE;
3489 static void
3490 print_assignment (lang_assignment_statement_type *assignment,
3491 lang_output_section_statement_type *output_section)
3493 unsigned int i;
3494 bfd_boolean is_dot;
3495 bfd_boolean computation_is_valid = TRUE;
3496 etree_type *tree;
3498 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3499 print_space ();
3501 if (assignment->exp->type.node_class == etree_assert)
3503 is_dot = FALSE;
3504 tree = assignment->exp->assert_s.child;
3505 computation_is_valid = TRUE;
3507 else
3509 const char *dst = assignment->exp->assign.dst;
3511 is_dot = (dst[0] == '.' && dst[1] == 0);
3512 tree = assignment->exp->assign.src;
3513 computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
3516 exp_fold_tree (tree, output_section->bfd_section, &print_dot);
3517 if (expld.result.valid_p)
3519 bfd_vma value;
3521 if (computation_is_valid)
3523 value = expld.result.value;
3525 if (expld.result.section)
3526 value += expld.result.section->vma;
3528 minfo ("0x%V", value);
3529 if (is_dot)
3530 print_dot = value;
3532 else
3534 struct bfd_link_hash_entry *h;
3536 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3537 FALSE, FALSE, TRUE);
3538 if (h)
3540 value = h->u.def.value;
3542 if (expld.result.section)
3543 value += expld.result.section->vma;
3545 minfo ("[0x%V]", value);
3547 else
3548 minfo ("[unresolved]");
3551 else
3553 minfo ("*undef* ");
3554 #ifdef BFD64
3555 minfo (" ");
3556 #endif
3559 minfo (" ");
3560 exp_print_tree (assignment->exp);
3561 print_nl ();
3564 static void
3565 print_input_statement (lang_input_statement_type *statm)
3567 if (statm->filename != NULL)
3569 fprintf (config.map_file, "LOAD %s\n", statm->filename);
3573 /* Print all symbols defined in a particular section. This is called
3574 via bfd_link_hash_traverse, or by print_all_symbols. */
3576 static bfd_boolean
3577 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
3579 asection *sec = ptr;
3581 if ((hash_entry->type == bfd_link_hash_defined
3582 || hash_entry->type == bfd_link_hash_defweak)
3583 && sec == hash_entry->u.def.section)
3585 int i;
3587 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3588 print_space ();
3589 minfo ("0x%V ",
3590 (hash_entry->u.def.value
3591 + hash_entry->u.def.section->output_offset
3592 + hash_entry->u.def.section->output_section->vma));
3594 minfo (" %T\n", hash_entry->root.string);
3597 return TRUE;
3600 static void
3601 print_all_symbols (asection *sec)
3603 struct fat_user_section_struct *ud = get_userdata (sec);
3604 struct map_symbol_def *def;
3606 if (!ud)
3607 return;
3609 *ud->map_symbol_def_tail = 0;
3610 for (def = ud->map_symbol_def_head; def; def = def->next)
3611 print_one_symbol (def->entry, sec);
3614 /* Print information about an input section to the map file. */
3616 static void
3617 print_input_section (asection *i)
3619 bfd_size_type size = i->size;
3620 int len;
3621 bfd_vma addr;
3623 init_opb ();
3625 print_space ();
3626 minfo ("%s", i->name);
3628 len = 1 + strlen (i->name);
3629 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3631 print_nl ();
3632 len = 0;
3634 while (len < SECTION_NAME_MAP_LENGTH)
3636 print_space ();
3637 ++len;
3640 if (i->output_section != NULL && i->output_section->owner == output_bfd)
3641 addr = i->output_section->vma + i->output_offset;
3642 else
3644 addr = print_dot;
3645 size = 0;
3648 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
3650 if (size != i->rawsize && i->rawsize != 0)
3652 len = SECTION_NAME_MAP_LENGTH + 3;
3653 #ifdef BFD64
3654 len += 16;
3655 #else
3656 len += 8;
3657 #endif
3658 while (len > 0)
3660 print_space ();
3661 --len;
3664 minfo (_("%W (size before relaxing)\n"), i->rawsize);
3667 if (i->output_section != NULL && i->output_section->owner == output_bfd)
3669 if (link_info.reduce_memory_overheads)
3670 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
3671 else
3672 print_all_symbols (i);
3674 print_dot = addr + TO_ADDR (size);
3678 static void
3679 print_fill_statement (lang_fill_statement_type *fill)
3681 size_t size;
3682 unsigned char *p;
3683 fputs (" FILL mask 0x", config.map_file);
3684 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
3685 fprintf (config.map_file, "%02x", *p);
3686 fputs ("\n", config.map_file);
3689 static void
3690 print_data_statement (lang_data_statement_type *data)
3692 int i;
3693 bfd_vma addr;
3694 bfd_size_type size;
3695 const char *name;
3697 init_opb ();
3698 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3699 print_space ();
3701 addr = data->output_offset;
3702 if (data->output_section != NULL)
3703 addr += data->output_section->vma;
3705 switch (data->type)
3707 default:
3708 abort ();
3709 case BYTE:
3710 size = BYTE_SIZE;
3711 name = "BYTE";
3712 break;
3713 case SHORT:
3714 size = SHORT_SIZE;
3715 name = "SHORT";
3716 break;
3717 case LONG:
3718 size = LONG_SIZE;
3719 name = "LONG";
3720 break;
3721 case QUAD:
3722 size = QUAD_SIZE;
3723 name = "QUAD";
3724 break;
3725 case SQUAD:
3726 size = QUAD_SIZE;
3727 name = "SQUAD";
3728 break;
3731 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
3733 if (data->exp->type.node_class != etree_value)
3735 print_space ();
3736 exp_print_tree (data->exp);
3739 print_nl ();
3741 print_dot = addr + TO_ADDR (size);
3744 /* Print an address statement. These are generated by options like
3745 -Ttext. */
3747 static void
3748 print_address_statement (lang_address_statement_type *address)
3750 minfo (_("Address of section %s set to "), address->section_name);
3751 exp_print_tree (address->address);
3752 print_nl ();
3755 /* Print a reloc statement. */
3757 static void
3758 print_reloc_statement (lang_reloc_statement_type *reloc)
3760 int i;
3761 bfd_vma addr;
3762 bfd_size_type size;
3764 init_opb ();
3765 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3766 print_space ();
3768 addr = reloc->output_offset;
3769 if (reloc->output_section != NULL)
3770 addr += reloc->output_section->vma;
3772 size = bfd_get_reloc_size (reloc->howto);
3774 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
3776 if (reloc->name != NULL)
3777 minfo ("%s+", reloc->name);
3778 else
3779 minfo ("%s+", reloc->section->name);
3781 exp_print_tree (reloc->addend_exp);
3783 print_nl ();
3785 print_dot = addr + TO_ADDR (size);
3788 static void
3789 print_padding_statement (lang_padding_statement_type *s)
3791 int len;
3792 bfd_vma addr;
3794 init_opb ();
3795 minfo (" *fill*");
3797 len = sizeof " *fill*" - 1;
3798 while (len < SECTION_NAME_MAP_LENGTH)
3800 print_space ();
3801 ++len;
3804 addr = s->output_offset;
3805 if (s->output_section != NULL)
3806 addr += s->output_section->vma;
3807 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
3809 if (s->fill->size != 0)
3811 size_t size;
3812 unsigned char *p;
3813 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
3814 fprintf (config.map_file, "%02x", *p);
3817 print_nl ();
3819 print_dot = addr + TO_ADDR (s->size);
3822 static void
3823 print_wild_statement (lang_wild_statement_type *w,
3824 lang_output_section_statement_type *os)
3826 struct wildcard_list *sec;
3828 print_space ();
3830 if (w->filenames_sorted)
3831 minfo ("SORT(");
3832 if (w->filename != NULL)
3833 minfo ("%s", w->filename);
3834 else
3835 minfo ("*");
3836 if (w->filenames_sorted)
3837 minfo (")");
3839 minfo ("(");
3840 for (sec = w->section_list; sec; sec = sec->next)
3842 if (sec->spec.sorted)
3843 minfo ("SORT(");
3844 if (sec->spec.exclude_name_list != NULL)
3846 name_list *tmp;
3847 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
3848 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
3849 minfo (" %s", tmp->name);
3850 minfo (") ");
3852 if (sec->spec.name != NULL)
3853 minfo ("%s", sec->spec.name);
3854 else
3855 minfo ("*");
3856 if (sec->spec.sorted)
3857 minfo (")");
3858 if (sec->next)
3859 minfo (" ");
3861 minfo (")");
3863 print_nl ();
3865 print_statement_list (w->children.head, os);
3868 /* Print a group statement. */
3870 static void
3871 print_group (lang_group_statement_type *s,
3872 lang_output_section_statement_type *os)
3874 fprintf (config.map_file, "START GROUP\n");
3875 print_statement_list (s->children.head, os);
3876 fprintf (config.map_file, "END GROUP\n");
3879 /* Print the list of statements in S.
3880 This can be called for any statement type. */
3882 static void
3883 print_statement_list (lang_statement_union_type *s,
3884 lang_output_section_statement_type *os)
3886 while (s != NULL)
3888 print_statement (s, os);
3889 s = s->header.next;
3893 /* Print the first statement in statement list S.
3894 This can be called for any statement type. */
3896 static void
3897 print_statement (lang_statement_union_type *s,
3898 lang_output_section_statement_type *os)
3900 switch (s->header.type)
3902 default:
3903 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
3904 FAIL ();
3905 break;
3906 case lang_constructors_statement_enum:
3907 if (constructor_list.head != NULL)
3909 if (constructors_sorted)
3910 minfo (" SORT (CONSTRUCTORS)\n");
3911 else
3912 minfo (" CONSTRUCTORS\n");
3913 print_statement_list (constructor_list.head, os);
3915 break;
3916 case lang_wild_statement_enum:
3917 print_wild_statement (&s->wild_statement, os);
3918 break;
3919 case lang_address_statement_enum:
3920 print_address_statement (&s->address_statement);
3921 break;
3922 case lang_object_symbols_statement_enum:
3923 minfo (" CREATE_OBJECT_SYMBOLS\n");
3924 break;
3925 case lang_fill_statement_enum:
3926 print_fill_statement (&s->fill_statement);
3927 break;
3928 case lang_data_statement_enum:
3929 print_data_statement (&s->data_statement);
3930 break;
3931 case lang_reloc_statement_enum:
3932 print_reloc_statement (&s->reloc_statement);
3933 break;
3934 case lang_input_section_enum:
3935 print_input_section (s->input_section.section);
3936 break;
3937 case lang_padding_statement_enum:
3938 print_padding_statement (&s->padding_statement);
3939 break;
3940 case lang_output_section_statement_enum:
3941 print_output_section_statement (&s->output_section_statement);
3942 break;
3943 case lang_assignment_statement_enum:
3944 print_assignment (&s->assignment_statement, os);
3945 break;
3946 case lang_target_statement_enum:
3947 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
3948 break;
3949 case lang_output_statement_enum:
3950 minfo ("OUTPUT(%s", s->output_statement.name);
3951 if (output_target != NULL)
3952 minfo (" %s", output_target);
3953 minfo (")\n");
3954 break;
3955 case lang_input_statement_enum:
3956 print_input_statement (&s->input_statement);
3957 break;
3958 case lang_group_statement_enum:
3959 print_group (&s->group_statement, os);
3960 break;
3961 case lang_afile_asection_pair_statement_enum:
3962 FAIL ();
3963 break;
3967 static void
3968 print_statements (void)
3970 print_statement_list (statement_list.head, abs_output_section);
3973 /* Print the first N statements in statement list S to STDERR.
3974 If N == 0, nothing is printed.
3975 If N < 0, the entire list is printed.
3976 Intended to be called from GDB. */
3978 void
3979 dprint_statement (lang_statement_union_type *s, int n)
3981 FILE *map_save = config.map_file;
3983 config.map_file = stderr;
3985 if (n < 0)
3986 print_statement_list (s, abs_output_section);
3987 else
3989 while (s && --n >= 0)
3991 print_statement (s, abs_output_section);
3992 s = s->header.next;
3996 config.map_file = map_save;
3999 static void
4000 insert_pad (lang_statement_union_type **ptr,
4001 fill_type *fill,
4002 unsigned int alignment_needed,
4003 asection *output_section,
4004 bfd_vma dot)
4006 static fill_type zero_fill = { 1, { 0 } };
4007 lang_statement_union_type *pad = NULL;
4009 if (ptr != &statement_list.head)
4010 pad = ((lang_statement_union_type *)
4011 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4012 if (pad != NULL
4013 && pad->header.type == lang_padding_statement_enum
4014 && pad->padding_statement.output_section == output_section)
4016 /* Use the existing pad statement. */
4018 else if ((pad = *ptr) != NULL
4019 && pad->header.type == lang_padding_statement_enum
4020 && pad->padding_statement.output_section == output_section)
4022 /* Use the existing pad statement. */
4024 else
4026 /* Make a new padding statement, linked into existing chain. */
4027 pad = stat_alloc (sizeof (lang_padding_statement_type));
4028 pad->header.next = *ptr;
4029 *ptr = pad;
4030 pad->header.type = lang_padding_statement_enum;
4031 pad->padding_statement.output_section = output_section;
4032 if (fill == NULL)
4033 fill = &zero_fill;
4034 pad->padding_statement.fill = fill;
4036 pad->padding_statement.output_offset = dot - output_section->vma;
4037 pad->padding_statement.size = alignment_needed;
4038 output_section->size += alignment_needed;
4041 /* Work out how much this section will move the dot point. */
4043 static bfd_vma
4044 size_input_section
4045 (lang_statement_union_type **this_ptr,
4046 lang_output_section_statement_type *output_section_statement,
4047 fill_type *fill,
4048 bfd_vma dot)
4050 lang_input_section_type *is = &((*this_ptr)->input_section);
4051 asection *i = is->section;
4053 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4054 && (i->flags & SEC_EXCLUDE) == 0)
4056 unsigned int alignment_needed;
4057 asection *o;
4059 /* Align this section first to the input sections requirement,
4060 then to the output section's requirement. If this alignment
4061 is greater than any seen before, then record it too. Perform
4062 the alignment by inserting a magic 'padding' statement. */
4064 if (output_section_statement->subsection_alignment != -1)
4065 i->alignment_power = output_section_statement->subsection_alignment;
4067 o = output_section_statement->bfd_section;
4068 if (o->alignment_power < i->alignment_power)
4069 o->alignment_power = i->alignment_power;
4071 alignment_needed = align_power (dot, i->alignment_power) - dot;
4073 if (alignment_needed != 0)
4075 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4076 dot += alignment_needed;
4079 /* Remember where in the output section this input section goes. */
4081 i->output_offset = dot - o->vma;
4083 /* Mark how big the output section must be to contain this now. */
4084 dot += TO_ADDR (i->size);
4085 o->size = TO_SIZE (dot - o->vma);
4087 else
4089 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4092 return dot;
4095 static int
4096 sort_sections_by_lma (const void *arg1, const void *arg2)
4098 const asection *sec1 = *(const asection **) arg1;
4099 const asection *sec2 = *(const asection **) arg2;
4101 if (bfd_section_lma (sec1->owner, sec1)
4102 < bfd_section_lma (sec2->owner, sec2))
4103 return -1;
4104 else if (bfd_section_lma (sec1->owner, sec1)
4105 > bfd_section_lma (sec2->owner, sec2))
4106 return 1;
4107 else if (sec1->id < sec2->id)
4108 return -1;
4109 else if (sec1->id > sec2->id)
4110 return 1;
4112 return 0;
4115 #define IGNORE_SECTION(s) \
4116 ((s->flags & SEC_NEVER_LOAD) != 0 \
4117 || (s->flags & SEC_ALLOC) == 0 \
4118 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4119 && (s->flags & SEC_LOAD) == 0))
4121 /* Check to see if any allocated sections overlap with other allocated
4122 sections. This can happen if a linker script specifies the output
4123 section addresses of the two sections. */
4125 static void
4126 lang_check_section_addresses (void)
4128 asection *s, *os;
4129 asection **sections, **spp;
4130 unsigned int count;
4131 bfd_vma s_start;
4132 bfd_vma s_end;
4133 bfd_vma os_start;
4134 bfd_vma os_end;
4135 bfd_size_type amt;
4137 if (bfd_count_sections (output_bfd) <= 1)
4138 return;
4140 amt = bfd_count_sections (output_bfd) * sizeof (asection *);
4141 sections = xmalloc (amt);
4143 /* Scan all sections in the output list. */
4144 count = 0;
4145 for (s = output_bfd->sections; s != NULL; s = s->next)
4147 /* Only consider loadable sections with real contents. */
4148 if (IGNORE_SECTION (s) || s->size == 0)
4149 continue;
4151 sections[count] = s;
4152 count++;
4155 if (count <= 1)
4156 return;
4158 qsort (sections, (size_t) count, sizeof (asection *),
4159 sort_sections_by_lma);
4161 spp = sections;
4162 s = *spp++;
4163 s_start = bfd_section_lma (output_bfd, s);
4164 s_end = s_start + TO_ADDR (s->size) - 1;
4165 for (count--; count; count--)
4167 /* We must check the sections' LMA addresses not their VMA
4168 addresses because overlay sections can have overlapping VMAs
4169 but they must have distinct LMAs. */
4170 os = s;
4171 os_start = s_start;
4172 os_end = s_end;
4173 s = *spp++;
4174 s_start = bfd_section_lma (output_bfd, s);
4175 s_end = s_start + TO_ADDR (s->size) - 1;
4177 /* Look for an overlap. */
4178 if (s_end >= os_start && s_start <= os_end)
4179 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4180 s->name, s_start, s_end, os->name, os_start, os_end);
4183 free (sections);
4186 /* Make sure the new address is within the region. We explicitly permit the
4187 current address to be at the exact end of the region when the address is
4188 non-zero, in case the region is at the end of addressable memory and the
4189 calculation wraps around. */
4191 static void
4192 os_region_check (lang_output_section_statement_type *os,
4193 lang_memory_region_type *region,
4194 etree_type *tree,
4195 bfd_vma base)
4197 if ((region->current < region->origin
4198 || (region->current - region->origin > region->length))
4199 && ((region->current != region->origin + region->length)
4200 || base == 0))
4202 if (tree != NULL)
4204 einfo (_("%X%P: address 0x%v of %B section %s"
4205 " is not within region %s\n"),
4206 region->current,
4207 os->bfd_section->owner,
4208 os->bfd_section->name,
4209 region->name);
4211 else
4213 einfo (_("%X%P: region %s is full (%B section %s)\n"),
4214 region->name,
4215 os->bfd_section->owner,
4216 os->bfd_section->name);
4218 /* Reset the region pointer. */
4219 region->current = region->origin;
4223 /* Set the sizes for all the output sections. */
4225 static bfd_vma
4226 lang_size_sections_1
4227 (lang_statement_union_type *s,
4228 lang_output_section_statement_type *output_section_statement,
4229 lang_statement_union_type **prev,
4230 fill_type *fill,
4231 bfd_vma dot,
4232 bfd_boolean *relax,
4233 bfd_boolean check_regions)
4235 /* Size up the sections from their constituent parts. */
4236 for (; s != NULL; s = s->header.next)
4238 switch (s->header.type)
4240 case lang_output_section_statement_enum:
4242 bfd_vma newdot, after;
4243 lang_output_section_statement_type *os;
4244 lang_memory_region_type *r;
4246 os = &s->output_section_statement;
4247 if (os->addr_tree != NULL)
4249 os->processed_vma = FALSE;
4250 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4252 if (expld.result.valid_p)
4253 dot = expld.result.value + expld.result.section->vma;
4254 else if (expld.phase != lang_mark_phase_enum)
4255 einfo (_("%F%S: non constant or forward reference"
4256 " address expression for section %s\n"),
4257 os->name);
4260 if (os->bfd_section == NULL)
4261 /* This section was removed or never actually created. */
4262 break;
4264 /* If this is a COFF shared library section, use the size and
4265 address from the input section. FIXME: This is COFF
4266 specific; it would be cleaner if there were some other way
4267 to do this, but nothing simple comes to mind. */
4268 if ((bfd_get_flavour (output_bfd) == bfd_target_ecoff_flavour
4269 || bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
4270 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4272 asection *input;
4274 if (os->children.head == NULL
4275 || os->children.head->header.next != NULL
4276 || (os->children.head->header.type
4277 != lang_input_section_enum))
4278 einfo (_("%P%X: Internal error on COFF shared library"
4279 " section %s\n"), os->name);
4281 input = os->children.head->input_section.section;
4282 bfd_set_section_vma (os->bfd_section->owner,
4283 os->bfd_section,
4284 bfd_section_vma (input->owner, input));
4285 os->bfd_section->size = input->size;
4286 break;
4289 newdot = dot;
4290 if (bfd_is_abs_section (os->bfd_section))
4292 /* No matter what happens, an abs section starts at zero. */
4293 ASSERT (os->bfd_section->vma == 0);
4295 else
4297 int align;
4299 if (os->addr_tree == NULL)
4301 /* No address specified for this section, get one
4302 from the region specification. */
4303 if (os->region == NULL
4304 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4305 && os->region->name[0] == '*'
4306 && strcmp (os->region->name,
4307 DEFAULT_MEMORY_REGION) == 0))
4309 os->region = lang_memory_default (os->bfd_section);
4312 /* If a loadable section is using the default memory
4313 region, and some non default memory regions were
4314 defined, issue an error message. */
4315 if (!os->ignored
4316 && !IGNORE_SECTION (os->bfd_section)
4317 && ! link_info.relocatable
4318 && check_regions
4319 && strcmp (os->region->name,
4320 DEFAULT_MEMORY_REGION) == 0
4321 && lang_memory_region_list != NULL
4322 && (strcmp (lang_memory_region_list->name,
4323 DEFAULT_MEMORY_REGION) != 0
4324 || lang_memory_region_list->next != NULL)
4325 && expld.phase != lang_mark_phase_enum)
4327 /* By default this is an error rather than just a
4328 warning because if we allocate the section to the
4329 default memory region we can end up creating an
4330 excessively large binary, or even seg faulting when
4331 attempting to perform a negative seek. See
4332 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4333 for an example of this. This behaviour can be
4334 overridden by the using the --no-check-sections
4335 switch. */
4336 if (command_line.check_section_addresses)
4337 einfo (_("%P%F: error: no memory region specified"
4338 " for loadable section `%s'\n"),
4339 bfd_get_section_name (output_bfd,
4340 os->bfd_section));
4341 else
4342 einfo (_("%P: warning: no memory region specified"
4343 " for loadable section `%s'\n"),
4344 bfd_get_section_name (output_bfd,
4345 os->bfd_section));
4348 newdot = os->region->current;
4349 align = os->bfd_section->alignment_power;
4351 else
4352 align = os->section_alignment;
4354 /* Align to what the section needs. */
4355 if (align > 0)
4357 bfd_vma savedot = newdot;
4358 newdot = align_power (newdot, align);
4360 if (newdot != savedot
4361 && (config.warn_section_align
4362 || os->addr_tree != NULL)
4363 && expld.phase != lang_mark_phase_enum)
4364 einfo (_("%P: warning: changing start of section"
4365 " %s by %lu bytes\n"),
4366 os->name, (unsigned long) (newdot - savedot));
4369 bfd_set_section_vma (0, os->bfd_section, newdot);
4371 os->bfd_section->output_offset = 0;
4374 lang_size_sections_1 (os->children.head, os, &os->children.head,
4375 os->fill, newdot, relax, check_regions);
4377 os->processed_vma = TRUE;
4379 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4380 /* Except for some special linker created sections,
4381 no output section should change from zero size
4382 after strip_excluded_output_sections. A non-zero
4383 size on an ignored section indicates that some
4384 input section was not sized early enough. */
4385 ASSERT (os->bfd_section->size == 0);
4386 else
4388 dot = os->bfd_section->vma;
4390 /* Put the section within the requested block size, or
4391 align at the block boundary. */
4392 after = ((dot
4393 + TO_ADDR (os->bfd_section->size)
4394 + os->block_value - 1)
4395 & - (bfd_vma) os->block_value);
4397 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4400 /* Set section lma. */
4401 r = os->region;
4402 if (r == NULL)
4403 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4405 if (os->load_base)
4407 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4408 os->bfd_section->lma = lma;
4410 else if (os->region != NULL
4411 && os->lma_region != NULL
4412 && os->lma_region != os->region)
4414 bfd_vma lma = os->lma_region->current;
4416 if (os->section_alignment != -1)
4417 lma = align_power (lma, os->section_alignment);
4418 os->bfd_section->lma = lma;
4420 else if (r->last_os != NULL
4421 && (os->bfd_section->flags & SEC_ALLOC) != 0)
4423 bfd_vma lma;
4424 asection *last;
4426 last = r->last_os->output_section_statement.bfd_section;
4428 /* A backwards move of dot should be accompanied by
4429 an explicit assignment to the section LMA (ie.
4430 os->load_base set) because backwards moves can
4431 create overlapping LMAs. */
4432 if (dot < last->vma
4433 && os->bfd_section->size != 0
4434 && dot + os->bfd_section->size <= last->vma)
4436 /* If dot moved backwards then leave lma equal to
4437 vma. This is the old default lma, which might
4438 just happen to work when the backwards move is
4439 sufficiently large. Nag if this changes anything,
4440 so people can fix their linker scripts. */
4442 if (last->vma != last->lma)
4443 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4444 os->name);
4446 else
4448 /* If this is an overlay, set the current lma to that
4449 at the end of the previous section. */
4450 if (os->sectype == overlay_section)
4451 lma = last->lma + last->size;
4453 /* Otherwise, keep the same lma to vma relationship
4454 as the previous section. */
4455 else
4456 lma = dot + last->lma - last->vma;
4458 if (os->section_alignment != -1)
4459 lma = align_power (lma, os->section_alignment);
4460 os->bfd_section->lma = lma;
4463 os->processed_lma = TRUE;
4465 if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4466 break;
4468 /* Keep track of normal sections using the default
4469 lma region. We use this to set the lma for
4470 following sections. Overlays or other linker
4471 script assignment to lma might mean that the
4472 default lma == vma is incorrect.
4473 To avoid warnings about dot moving backwards when using
4474 -Ttext, don't start tracking sections until we find one
4475 of non-zero size or with lma set differently to vma. */
4476 if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4477 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4478 && (os->bfd_section->flags & SEC_ALLOC) != 0
4479 && (os->bfd_section->size != 0
4480 || (r->last_os == NULL
4481 && os->bfd_section->vma != os->bfd_section->lma)
4482 || (r->last_os != NULL
4483 && dot >= (r->last_os->output_section_statement
4484 .bfd_section->vma)))
4485 && os->lma_region == NULL
4486 && !link_info.relocatable)
4487 r->last_os = s;
4489 /* .tbss sections effectively have zero size. */
4490 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4491 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4492 || link_info.relocatable)
4493 dot += TO_ADDR (os->bfd_section->size);
4495 if (os->update_dot_tree != 0)
4496 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4498 /* Update dot in the region ?
4499 We only do this if the section is going to be allocated,
4500 since unallocated sections do not contribute to the region's
4501 overall size in memory.
4503 If the SEC_NEVER_LOAD bit is not set, it will affect the
4504 addresses of sections after it. We have to update
4505 dot. */
4506 if (os->region != NULL
4507 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4508 || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4510 os->region->current = dot;
4512 if (check_regions)
4513 /* Make sure the new address is within the region. */
4514 os_region_check (os, os->region, os->addr_tree,
4515 os->bfd_section->vma);
4517 if (os->lma_region != NULL && os->lma_region != os->region)
4519 os->lma_region->current
4520 = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
4522 if (check_regions)
4523 os_region_check (os, os->lma_region, NULL,
4524 os->bfd_section->lma);
4528 break;
4530 case lang_constructors_statement_enum:
4531 dot = lang_size_sections_1 (constructor_list.head,
4532 output_section_statement,
4533 &s->wild_statement.children.head,
4534 fill, dot, relax, check_regions);
4535 break;
4537 case lang_data_statement_enum:
4539 unsigned int size = 0;
4541 s->data_statement.output_offset =
4542 dot - output_section_statement->bfd_section->vma;
4543 s->data_statement.output_section =
4544 output_section_statement->bfd_section;
4546 /* We might refer to provided symbols in the expression, and
4547 need to mark them as needed. */
4548 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4550 switch (s->data_statement.type)
4552 default:
4553 abort ();
4554 case QUAD:
4555 case SQUAD:
4556 size = QUAD_SIZE;
4557 break;
4558 case LONG:
4559 size = LONG_SIZE;
4560 break;
4561 case SHORT:
4562 size = SHORT_SIZE;
4563 break;
4564 case BYTE:
4565 size = BYTE_SIZE;
4566 break;
4568 if (size < TO_SIZE ((unsigned) 1))
4569 size = TO_SIZE ((unsigned) 1);
4570 dot += TO_ADDR (size);
4571 output_section_statement->bfd_section->size += size;
4573 break;
4575 case lang_reloc_statement_enum:
4577 int size;
4579 s->reloc_statement.output_offset =
4580 dot - output_section_statement->bfd_section->vma;
4581 s->reloc_statement.output_section =
4582 output_section_statement->bfd_section;
4583 size = bfd_get_reloc_size (s->reloc_statement.howto);
4584 dot += TO_ADDR (size);
4585 output_section_statement->bfd_section->size += size;
4587 break;
4589 case lang_wild_statement_enum:
4590 dot = lang_size_sections_1 (s->wild_statement.children.head,
4591 output_section_statement,
4592 &s->wild_statement.children.head,
4593 fill, dot, relax, check_regions);
4594 break;
4596 case lang_object_symbols_statement_enum:
4597 link_info.create_object_symbols_section =
4598 output_section_statement->bfd_section;
4599 break;
4601 case lang_output_statement_enum:
4602 case lang_target_statement_enum:
4603 break;
4605 case lang_input_section_enum:
4607 asection *i;
4609 i = (*prev)->input_section.section;
4610 if (relax)
4612 bfd_boolean again;
4614 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4615 einfo (_("%P%F: can't relax section: %E\n"));
4616 if (again)
4617 *relax = TRUE;
4619 dot = size_input_section (prev, output_section_statement,
4620 output_section_statement->fill, dot);
4622 break;
4624 case lang_input_statement_enum:
4625 break;
4627 case lang_fill_statement_enum:
4628 s->fill_statement.output_section =
4629 output_section_statement->bfd_section;
4631 fill = s->fill_statement.fill;
4632 break;
4634 case lang_assignment_statement_enum:
4636 bfd_vma newdot = dot;
4637 etree_type *tree = s->assignment_statement.exp;
4639 expld.dataseg.relro = exp_dataseg_relro_none;
4641 exp_fold_tree (tree,
4642 output_section_statement->bfd_section,
4643 &newdot);
4645 if (expld.dataseg.relro == exp_dataseg_relro_start)
4647 if (!expld.dataseg.relro_start_stat)
4648 expld.dataseg.relro_start_stat = s;
4649 else
4651 ASSERT (expld.dataseg.relro_start_stat == s);
4654 else if (expld.dataseg.relro == exp_dataseg_relro_end)
4656 if (!expld.dataseg.relro_end_stat)
4657 expld.dataseg.relro_end_stat = s;
4658 else
4660 ASSERT (expld.dataseg.relro_end_stat == s);
4663 expld.dataseg.relro = exp_dataseg_relro_none;
4665 /* This symbol is relative to this section. */
4666 if ((tree->type.node_class == etree_provided
4667 || tree->type.node_class == etree_assign)
4668 && (tree->assign.dst [0] != '.'
4669 || tree->assign.dst [1] != '\0'))
4670 output_section_statement->section_relative_symbol = 1;
4672 if (!output_section_statement->ignored)
4674 if (output_section_statement == abs_output_section)
4676 /* If we don't have an output section, then just adjust
4677 the default memory address. */
4678 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
4679 FALSE)->current = newdot;
4681 else if (newdot != dot)
4683 /* Insert a pad after this statement. We can't
4684 put the pad before when relaxing, in case the
4685 assignment references dot. */
4686 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
4687 output_section_statement->bfd_section, dot);
4689 /* Don't neuter the pad below when relaxing. */
4690 s = s->header.next;
4692 /* If dot is advanced, this implies that the section
4693 should have space allocated to it, unless the
4694 user has explicitly stated that the section
4695 should never be loaded. */
4696 if (!(output_section_statement->flags
4697 & (SEC_NEVER_LOAD | SEC_ALLOC)))
4698 output_section_statement->bfd_section->flags |= SEC_ALLOC;
4700 dot = newdot;
4703 break;
4705 case lang_padding_statement_enum:
4706 /* If this is the first time lang_size_sections is called,
4707 we won't have any padding statements. If this is the
4708 second or later passes when relaxing, we should allow
4709 padding to shrink. If padding is needed on this pass, it
4710 will be added back in. */
4711 s->padding_statement.size = 0;
4713 /* Make sure output_offset is valid. If relaxation shrinks
4714 the section and this pad isn't needed, it's possible to
4715 have output_offset larger than the final size of the
4716 section. bfd_set_section_contents will complain even for
4717 a pad size of zero. */
4718 s->padding_statement.output_offset
4719 = dot - output_section_statement->bfd_section->vma;
4720 break;
4722 case lang_group_statement_enum:
4723 dot = lang_size_sections_1 (s->group_statement.children.head,
4724 output_section_statement,
4725 &s->group_statement.children.head,
4726 fill, dot, relax, check_regions);
4727 break;
4729 default:
4730 FAIL ();
4731 break;
4733 /* We can only get here when relaxing is turned on. */
4734 case lang_address_statement_enum:
4735 break;
4737 prev = &s->header.next;
4739 return dot;
4742 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4743 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4744 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4745 segments. We are allowed an opportunity to override this decision. */
4747 bfd_boolean
4748 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
4749 bfd * abfd ATTRIBUTE_UNUSED,
4750 asection * current_section,
4751 asection * previous_section,
4752 bfd_boolean new_segment)
4754 lang_output_section_statement_type * cur;
4755 lang_output_section_statement_type * prev;
4757 /* The checks below are only necessary when the BFD library has decided
4758 that the two sections ought to be placed into the same segment. */
4759 if (new_segment)
4760 return TRUE;
4762 /* Paranoia checks. */
4763 if (current_section == NULL || previous_section == NULL)
4764 return new_segment;
4766 /* Find the memory regions associated with the two sections.
4767 We call lang_output_section_find() here rather than scanning the list
4768 of output sections looking for a matching section pointer because if
4769 we have a large number of sections then a hash lookup is faster. */
4770 cur = lang_output_section_find (current_section->name);
4771 prev = lang_output_section_find (previous_section->name);
4773 /* More paranoia. */
4774 if (cur == NULL || prev == NULL)
4775 return new_segment;
4777 /* If the regions are different then force the sections to live in
4778 different segments. See the email thread starting at the following
4779 URL for the reasons why this is necessary:
4780 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
4781 return cur->region != prev->region;
4784 void
4785 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
4787 lang_statement_iteration++;
4788 lang_size_sections_1 (statement_list.head, abs_output_section,
4789 &statement_list.head, 0, 0, relax, check_regions);
4792 void
4793 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
4795 expld.phase = lang_allocating_phase_enum;
4796 expld.dataseg.phase = exp_dataseg_none;
4798 one_lang_size_sections_pass (relax, check_regions);
4799 if (expld.dataseg.phase == exp_dataseg_end_seen
4800 && link_info.relro && expld.dataseg.relro_end)
4802 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4803 to put expld.dataseg.relro on a (common) page boundary. */
4804 bfd_vma old_min_base, relro_end, maxpage;
4806 expld.dataseg.phase = exp_dataseg_relro_adjust;
4807 old_min_base = expld.dataseg.min_base;
4808 maxpage = expld.dataseg.maxpagesize;
4809 expld.dataseg.base += (-expld.dataseg.relro_end
4810 & (expld.dataseg.pagesize - 1));
4811 /* Compute the expected PT_GNU_RELRO segment end. */
4812 relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
4813 & ~(expld.dataseg.pagesize - 1);
4814 if (old_min_base + maxpage < expld.dataseg.base)
4816 expld.dataseg.base -= maxpage;
4817 relro_end -= maxpage;
4819 lang_reset_memory_regions ();
4820 one_lang_size_sections_pass (relax, check_regions);
4821 if (expld.dataseg.relro_end > relro_end)
4823 /* The alignment of sections between DATA_SEGMENT_ALIGN
4824 and DATA_SEGMENT_RELRO_END caused huge padding to be
4825 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4826 asection *sec;
4827 unsigned int max_alignment_power = 0;
4829 /* Find maximum alignment power of sections between
4830 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4831 for (sec = output_bfd->sections; sec; sec = sec->next)
4832 if (sec->vma >= expld.dataseg.base
4833 && sec->vma < expld.dataseg.relro_end
4834 && sec->alignment_power > max_alignment_power)
4835 max_alignment_power = sec->alignment_power;
4837 if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
4839 if (expld.dataseg.base - (1 << max_alignment_power)
4840 < old_min_base)
4841 expld.dataseg.base += expld.dataseg.pagesize;
4842 expld.dataseg.base -= (1 << max_alignment_power);
4843 lang_reset_memory_regions ();
4844 one_lang_size_sections_pass (relax, check_regions);
4847 link_info.relro_start = expld.dataseg.base;
4848 link_info.relro_end = expld.dataseg.relro_end;
4850 else if (expld.dataseg.phase == exp_dataseg_end_seen)
4852 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4853 a page could be saved in the data segment. */
4854 bfd_vma first, last;
4856 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
4857 last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
4858 if (first && last
4859 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
4860 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
4861 && first + last <= expld.dataseg.pagesize)
4863 expld.dataseg.phase = exp_dataseg_adjust;
4864 lang_reset_memory_regions ();
4865 one_lang_size_sections_pass (relax, check_regions);
4869 expld.phase = lang_final_phase_enum;
4872 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4874 static bfd_vma
4875 lang_do_assignments_1 (lang_statement_union_type *s,
4876 lang_output_section_statement_type *current_os,
4877 fill_type *fill,
4878 bfd_vma dot)
4880 for (; s != NULL; s = s->header.next)
4882 switch (s->header.type)
4884 case lang_constructors_statement_enum:
4885 dot = lang_do_assignments_1 (constructor_list.head,
4886 current_os, fill, dot);
4887 break;
4889 case lang_output_section_statement_enum:
4891 lang_output_section_statement_type *os;
4893 os = &(s->output_section_statement);
4894 if (os->bfd_section != NULL && !os->ignored)
4896 dot = os->bfd_section->vma;
4898 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
4900 /* .tbss sections effectively have zero size. */
4901 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4902 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4903 || link_info.relocatable)
4904 dot += TO_ADDR (os->bfd_section->size);
4907 break;
4909 case lang_wild_statement_enum:
4911 dot = lang_do_assignments_1 (s->wild_statement.children.head,
4912 current_os, fill, dot);
4913 break;
4915 case lang_object_symbols_statement_enum:
4916 case lang_output_statement_enum:
4917 case lang_target_statement_enum:
4918 break;
4920 case lang_data_statement_enum:
4921 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4922 if (expld.result.valid_p)
4923 s->data_statement.value = (expld.result.value
4924 + expld.result.section->vma);
4925 else
4926 einfo (_("%F%P: invalid data statement\n"));
4928 unsigned int size;
4929 switch (s->data_statement.type)
4931 default:
4932 abort ();
4933 case QUAD:
4934 case SQUAD:
4935 size = QUAD_SIZE;
4936 break;
4937 case LONG:
4938 size = LONG_SIZE;
4939 break;
4940 case SHORT:
4941 size = SHORT_SIZE;
4942 break;
4943 case BYTE:
4944 size = BYTE_SIZE;
4945 break;
4947 if (size < TO_SIZE ((unsigned) 1))
4948 size = TO_SIZE ((unsigned) 1);
4949 dot += TO_ADDR (size);
4951 break;
4953 case lang_reloc_statement_enum:
4954 exp_fold_tree (s->reloc_statement.addend_exp,
4955 bfd_abs_section_ptr, &dot);
4956 if (expld.result.valid_p)
4957 s->reloc_statement.addend_value = expld.result.value;
4958 else
4959 einfo (_("%F%P: invalid reloc statement\n"));
4960 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
4961 break;
4963 case lang_input_section_enum:
4965 asection *in = s->input_section.section;
4967 if ((in->flags & SEC_EXCLUDE) == 0)
4968 dot += TO_ADDR (in->size);
4970 break;
4972 case lang_input_statement_enum:
4973 break;
4975 case lang_fill_statement_enum:
4976 fill = s->fill_statement.fill;
4977 break;
4979 case lang_assignment_statement_enum:
4980 exp_fold_tree (s->assignment_statement.exp,
4981 current_os->bfd_section,
4982 &dot);
4983 break;
4985 case lang_padding_statement_enum:
4986 dot += TO_ADDR (s->padding_statement.size);
4987 break;
4989 case lang_group_statement_enum:
4990 dot = lang_do_assignments_1 (s->group_statement.children.head,
4991 current_os, fill, dot);
4992 break;
4994 default:
4995 FAIL ();
4996 break;
4998 case lang_address_statement_enum:
4999 break;
5002 return dot;
5005 void
5006 lang_do_assignments (void)
5008 lang_statement_iteration++;
5009 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5012 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5013 operator .startof. (section_name), it produces an undefined symbol
5014 .startof.section_name. Similarly, when it sees
5015 .sizeof. (section_name), it produces an undefined symbol
5016 .sizeof.section_name. For all the output sections, we look for
5017 such symbols, and set them to the correct value. */
5019 static void
5020 lang_set_startof (void)
5022 asection *s;
5024 if (link_info.relocatable)
5025 return;
5027 for (s = output_bfd->sections; s != NULL; s = s->next)
5029 const char *secname;
5030 char *buf;
5031 struct bfd_link_hash_entry *h;
5033 secname = bfd_get_section_name (output_bfd, s);
5034 buf = xmalloc (10 + strlen (secname));
5036 sprintf (buf, ".startof.%s", secname);
5037 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5038 if (h != NULL && h->type == bfd_link_hash_undefined)
5040 h->type = bfd_link_hash_defined;
5041 h->u.def.value = bfd_get_section_vma (output_bfd, s);
5042 h->u.def.section = bfd_abs_section_ptr;
5045 sprintf (buf, ".sizeof.%s", secname);
5046 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5047 if (h != NULL && h->type == bfd_link_hash_undefined)
5049 h->type = bfd_link_hash_defined;
5050 h->u.def.value = TO_ADDR (s->size);
5051 h->u.def.section = bfd_abs_section_ptr;
5054 free (buf);
5058 static void
5059 lang_end (void)
5061 struct bfd_link_hash_entry *h;
5062 bfd_boolean warn;
5064 if (link_info.relocatable || link_info.shared)
5065 warn = FALSE;
5066 else
5067 warn = TRUE;
5069 if (entry_symbol.name == NULL)
5071 /* No entry has been specified. Look for the default entry, but
5072 don't warn if we don't find it. */
5073 entry_symbol.name = entry_symbol_default;
5074 warn = FALSE;
5077 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5078 FALSE, FALSE, TRUE);
5079 if (h != NULL
5080 && (h->type == bfd_link_hash_defined
5081 || h->type == bfd_link_hash_defweak)
5082 && h->u.def.section->output_section != NULL)
5084 bfd_vma val;
5086 val = (h->u.def.value
5087 + bfd_get_section_vma (output_bfd,
5088 h->u.def.section->output_section)
5089 + h->u.def.section->output_offset);
5090 if (! bfd_set_start_address (output_bfd, val))
5091 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5093 else
5095 bfd_vma val;
5096 const char *send;
5098 /* We couldn't find the entry symbol. Try parsing it as a
5099 number. */
5100 val = bfd_scan_vma (entry_symbol.name, &send, 0);
5101 if (*send == '\0')
5103 if (! bfd_set_start_address (output_bfd, val))
5104 einfo (_("%P%F: can't set start address\n"));
5106 else
5108 asection *ts;
5110 /* Can't find the entry symbol, and it's not a number. Use
5111 the first address in the text section. */
5112 ts = bfd_get_section_by_name (output_bfd, entry_section);
5113 if (ts != NULL)
5115 if (warn)
5116 einfo (_("%P: warning: cannot find entry symbol %s;"
5117 " defaulting to %V\n"),
5118 entry_symbol.name,
5119 bfd_get_section_vma (output_bfd, ts));
5120 if (! bfd_set_start_address (output_bfd,
5121 bfd_get_section_vma (output_bfd,
5122 ts)))
5123 einfo (_("%P%F: can't set start address\n"));
5125 else
5127 if (warn)
5128 einfo (_("%P: warning: cannot find entry symbol %s;"
5129 " not setting start address\n"),
5130 entry_symbol.name);
5135 /* Don't bfd_hash_table_free (&lang_definedness_table);
5136 map file output may result in a call of lang_track_definedness. */
5139 /* This is a small function used when we want to ignore errors from
5140 BFD. */
5142 static void
5143 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5145 /* Don't do anything. */
5148 /* Check that the architecture of all the input files is compatible
5149 with the output file. Also call the backend to let it do any
5150 other checking that is needed. */
5152 static void
5153 lang_check (void)
5155 lang_statement_union_type *file;
5156 bfd *input_bfd;
5157 const bfd_arch_info_type *compatible;
5159 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5161 input_bfd = file->input_statement.the_bfd;
5162 compatible
5163 = bfd_arch_get_compatible (input_bfd, output_bfd,
5164 command_line.accept_unknown_input_arch);
5166 /* In general it is not possible to perform a relocatable
5167 link between differing object formats when the input
5168 file has relocations, because the relocations in the
5169 input format may not have equivalent representations in
5170 the output format (and besides BFD does not translate
5171 relocs for other link purposes than a final link). */
5172 if ((link_info.relocatable || link_info.emitrelocations)
5173 && (compatible == NULL
5174 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
5175 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5177 einfo (_("%P%F: Relocatable linking with relocations from"
5178 " format %s (%B) to format %s (%B) is not supported\n"),
5179 bfd_get_target (input_bfd), input_bfd,
5180 bfd_get_target (output_bfd), output_bfd);
5181 /* einfo with %F exits. */
5184 if (compatible == NULL)
5186 if (command_line.warn_mismatch)
5187 einfo (_("%P%X: %s architecture of input file `%B'"
5188 " is incompatible with %s output\n"),
5189 bfd_printable_name (input_bfd), input_bfd,
5190 bfd_printable_name (output_bfd));
5192 else if (bfd_count_sections (input_bfd))
5194 /* If the input bfd has no contents, it shouldn't set the
5195 private data of the output bfd. */
5197 bfd_error_handler_type pfn = NULL;
5199 /* If we aren't supposed to warn about mismatched input
5200 files, temporarily set the BFD error handler to a
5201 function which will do nothing. We still want to call
5202 bfd_merge_private_bfd_data, since it may set up
5203 information which is needed in the output file. */
5204 if (! command_line.warn_mismatch)
5205 pfn = bfd_set_error_handler (ignore_bfd_errors);
5206 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
5208 if (command_line.warn_mismatch)
5209 einfo (_("%P%X: failed to merge target specific data"
5210 " of file %B\n"), input_bfd);
5212 if (! command_line.warn_mismatch)
5213 bfd_set_error_handler (pfn);
5218 /* Look through all the global common symbols and attach them to the
5219 correct section. The -sort-common command line switch may be used
5220 to roughly sort the entries by size. */
5222 static void
5223 lang_common (void)
5225 if (command_line.inhibit_common_definition)
5226 return;
5227 if (link_info.relocatable
5228 && ! command_line.force_common_definition)
5229 return;
5231 if (! config.sort_common)
5232 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5233 else
5235 int power;
5237 for (power = 4; power >= 0; power--)
5238 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5242 /* Place one common symbol in the correct section. */
5244 static bfd_boolean
5245 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5247 unsigned int power_of_two;
5248 bfd_vma size;
5249 asection *section;
5251 if (h->type != bfd_link_hash_common)
5252 return TRUE;
5254 size = h->u.c.size;
5255 power_of_two = h->u.c.p->alignment_power;
5257 if (config.sort_common
5258 && power_of_two < (unsigned int) *(int *) info)
5259 return TRUE;
5261 section = h->u.c.p->section;
5263 /* Increase the size of the section to align the common sym. */
5264 section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
5265 section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
5267 /* Adjust the alignment if necessary. */
5268 if (power_of_two > section->alignment_power)
5269 section->alignment_power = power_of_two;
5271 /* Change the symbol from common to defined. */
5272 h->type = bfd_link_hash_defined;
5273 h->u.def.section = section;
5274 h->u.def.value = section->size;
5276 /* Increase the size of the section. */
5277 section->size += size;
5279 /* Make sure the section is allocated in memory, and make sure that
5280 it is no longer a common section. */
5281 section->flags |= SEC_ALLOC;
5282 section->flags &= ~SEC_IS_COMMON;
5284 if (config.map_file != NULL)
5286 static bfd_boolean header_printed;
5287 int len;
5288 char *name;
5289 char buf[50];
5291 if (! header_printed)
5293 minfo (_("\nAllocating common symbols\n"));
5294 minfo (_("Common symbol size file\n\n"));
5295 header_printed = TRUE;
5298 name = bfd_demangle (output_bfd, h->root.string,
5299 DMGL_ANSI | DMGL_PARAMS);
5300 if (name == NULL)
5302 minfo ("%s", h->root.string);
5303 len = strlen (h->root.string);
5305 else
5307 minfo ("%s", name);
5308 len = strlen (name);
5309 free (name);
5312 if (len >= 19)
5314 print_nl ();
5315 len = 0;
5317 while (len < 20)
5319 print_space ();
5320 ++len;
5323 minfo ("0x");
5324 if (size <= 0xffffffff)
5325 sprintf (buf, "%lx", (unsigned long) size);
5326 else
5327 sprintf_vma (buf, size);
5328 minfo ("%s", buf);
5329 len = strlen (buf);
5331 while (len < 16)
5333 print_space ();
5334 ++len;
5337 minfo ("%B\n", section->owner);
5340 return TRUE;
5343 /* Run through the input files and ensure that every input section has
5344 somewhere to go. If one is found without a destination then create
5345 an input request and place it into the statement tree. */
5347 static void
5348 lang_place_orphans (void)
5350 LANG_FOR_EACH_INPUT_STATEMENT (file)
5352 asection *s;
5354 for (s = file->the_bfd->sections; s != NULL; s = s->next)
5356 if (s->output_section == NULL)
5358 /* This section of the file is not attached, root
5359 around for a sensible place for it to go. */
5361 if (file->just_syms_flag)
5362 bfd_link_just_syms (file->the_bfd, s, &link_info);
5363 else if ((s->flags & SEC_EXCLUDE) != 0)
5364 s->output_section = bfd_abs_section_ptr;
5365 else if (strcmp (s->name, "COMMON") == 0)
5367 /* This is a lonely common section which must have
5368 come from an archive. We attach to the section
5369 with the wildcard. */
5370 if (! link_info.relocatable
5371 || command_line.force_common_definition)
5373 if (default_common_section == NULL)
5375 default_common_section =
5376 lang_output_section_statement_lookup (".bss");
5379 lang_add_section (&default_common_section->children, s,
5380 default_common_section);
5383 else if (ldemul_place_orphan (s))
5385 else
5387 lang_output_section_statement_type *os;
5389 os = lang_output_section_statement_lookup (s->name);
5390 lang_add_section (&os->children, s, os);
5397 void
5398 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5400 flagword *ptr_flags;
5402 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5403 while (*flags)
5405 switch (*flags)
5407 case 'A': case 'a':
5408 *ptr_flags |= SEC_ALLOC;
5409 break;
5411 case 'R': case 'r':
5412 *ptr_flags |= SEC_READONLY;
5413 break;
5415 case 'W': case 'w':
5416 *ptr_flags |= SEC_DATA;
5417 break;
5419 case 'X': case 'x':
5420 *ptr_flags |= SEC_CODE;
5421 break;
5423 case 'L': case 'l':
5424 case 'I': case 'i':
5425 *ptr_flags |= SEC_LOAD;
5426 break;
5428 default:
5429 einfo (_("%P%F: invalid syntax in flags\n"));
5430 break;
5432 flags++;
5436 /* Call a function on each input file. This function will be called
5437 on an archive, but not on the elements. */
5439 void
5440 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5442 lang_input_statement_type *f;
5444 for (f = (lang_input_statement_type *) input_file_chain.head;
5445 f != NULL;
5446 f = (lang_input_statement_type *) f->next_real_file)
5447 func (f);
5450 /* Call a function on each file. The function will be called on all
5451 the elements of an archive which are included in the link, but will
5452 not be called on the archive file itself. */
5454 void
5455 lang_for_each_file (void (*func) (lang_input_statement_type *))
5457 LANG_FOR_EACH_INPUT_STATEMENT (f)
5459 func (f);
5463 void
5464 ldlang_add_file (lang_input_statement_type *entry)
5466 lang_statement_append (&file_chain,
5467 (lang_statement_union_type *) entry,
5468 &entry->next);
5470 /* The BFD linker needs to have a list of all input BFDs involved in
5471 a link. */
5472 ASSERT (entry->the_bfd->link_next == NULL);
5473 ASSERT (entry->the_bfd != output_bfd);
5475 *link_info.input_bfds_tail = entry->the_bfd;
5476 link_info.input_bfds_tail = &entry->the_bfd->link_next;
5477 entry->the_bfd->usrdata = entry;
5478 bfd_set_gp_size (entry->the_bfd, g_switch_value);
5480 /* Look through the sections and check for any which should not be
5481 included in the link. We need to do this now, so that we can
5482 notice when the backend linker tries to report multiple
5483 definition errors for symbols which are in sections we aren't
5484 going to link. FIXME: It might be better to entirely ignore
5485 symbols which are defined in sections which are going to be
5486 discarded. This would require modifying the backend linker for
5487 each backend which might set the SEC_LINK_ONCE flag. If we do
5488 this, we should probably handle SEC_EXCLUDE in the same way. */
5490 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5493 void
5494 lang_add_output (const char *name, int from_script)
5496 /* Make -o on command line override OUTPUT in script. */
5497 if (!had_output_filename || !from_script)
5499 output_filename = name;
5500 had_output_filename = TRUE;
5504 static lang_output_section_statement_type *current_section;
5506 static int
5507 topower (int x)
5509 unsigned int i = 1;
5510 int l;
5512 if (x < 0)
5513 return -1;
5515 for (l = 0; l < 32; l++)
5517 if (i >= (unsigned int) x)
5518 return l;
5519 i <<= 1;
5522 return 0;
5525 lang_output_section_statement_type *
5526 lang_enter_output_section_statement (const char *output_section_statement_name,
5527 etree_type *address_exp,
5528 enum section_type sectype,
5529 etree_type *align,
5530 etree_type *subalign,
5531 etree_type *ebase,
5532 int constraint)
5534 lang_output_section_statement_type *os;
5536 os = lang_output_section_statement_lookup_1 (output_section_statement_name,
5537 constraint);
5538 current_section = os;
5540 /* Make next things chain into subchain of this. */
5542 if (os->addr_tree == NULL)
5544 os->addr_tree = address_exp;
5546 os->sectype = sectype;
5547 if (sectype != noload_section)
5548 os->flags = SEC_NO_FLAGS;
5549 else
5550 os->flags = SEC_NEVER_LOAD;
5551 os->block_value = 1;
5552 stat_ptr = &os->children;
5554 os->subsection_alignment =
5555 topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5556 os->section_alignment =
5557 topower (exp_get_value_int (align, -1, "section alignment"));
5559 os->load_base = ebase;
5560 return os;
5563 void
5564 lang_final (void)
5566 lang_output_statement_type *new;
5568 new = new_stat (lang_output_statement, stat_ptr);
5569 new->name = output_filename;
5572 /* Reset the current counters in the regions. */
5574 void
5575 lang_reset_memory_regions (void)
5577 lang_memory_region_type *p = lang_memory_region_list;
5578 asection *o;
5579 lang_output_section_statement_type *os;
5581 for (p = lang_memory_region_list; p != NULL; p = p->next)
5583 p->current = p->origin;
5584 p->last_os = NULL;
5587 for (os = &lang_output_section_statement.head->output_section_statement;
5588 os != NULL;
5589 os = os->next)
5591 os->processed_vma = FALSE;
5592 os->processed_lma = FALSE;
5595 for (o = output_bfd->sections; o != NULL; o = o->next)
5597 /* Save the last size for possible use by bfd_relax_section. */
5598 o->rawsize = o->size;
5599 o->size = 0;
5603 /* Worker for lang_gc_sections_1. */
5605 static void
5606 gc_section_callback (lang_wild_statement_type *ptr,
5607 struct wildcard_list *sec ATTRIBUTE_UNUSED,
5608 asection *section,
5609 lang_input_statement_type *file ATTRIBUTE_UNUSED,
5610 void *data ATTRIBUTE_UNUSED)
5612 /* If the wild pattern was marked KEEP, the member sections
5613 should be as well. */
5614 if (ptr->keep_sections)
5615 section->flags |= SEC_KEEP;
5618 /* Iterate over sections marking them against GC. */
5620 static void
5621 lang_gc_sections_1 (lang_statement_union_type *s)
5623 for (; s != NULL; s = s->header.next)
5625 switch (s->header.type)
5627 case lang_wild_statement_enum:
5628 walk_wild (&s->wild_statement, gc_section_callback, NULL);
5629 break;
5630 case lang_constructors_statement_enum:
5631 lang_gc_sections_1 (constructor_list.head);
5632 break;
5633 case lang_output_section_statement_enum:
5634 lang_gc_sections_1 (s->output_section_statement.children.head);
5635 break;
5636 case lang_group_statement_enum:
5637 lang_gc_sections_1 (s->group_statement.children.head);
5638 break;
5639 default:
5640 break;
5645 static void
5646 lang_gc_sections (void)
5648 struct bfd_link_hash_entry *h;
5649 ldlang_undef_chain_list_type *ulist;
5651 /* Keep all sections so marked in the link script. */
5653 lang_gc_sections_1 (statement_list.head);
5655 /* Keep all sections containing symbols undefined on the command-line,
5656 and the section containing the entry symbol. */
5658 for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
5660 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
5661 FALSE, FALSE, FALSE);
5663 if (h != NULL
5664 && (h->type == bfd_link_hash_defined
5665 || h->type == bfd_link_hash_defweak)
5666 && ! bfd_is_abs_section (h->u.def.section))
5668 h->u.def.section->flags |= SEC_KEEP;
5672 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5673 the special case of debug info. (See bfd/stabs.c)
5674 Twiddle the flag here, to simplify later linker code. */
5675 if (link_info.relocatable)
5677 LANG_FOR_EACH_INPUT_STATEMENT (f)
5679 asection *sec;
5680 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
5681 if ((sec->flags & SEC_DEBUGGING) == 0)
5682 sec->flags &= ~SEC_EXCLUDE;
5686 if (link_info.gc_sections)
5687 bfd_gc_sections (output_bfd, &link_info);
5690 /* Worker for lang_find_relro_sections_1. */
5692 static void
5693 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
5694 struct wildcard_list *sec ATTRIBUTE_UNUSED,
5695 asection *section,
5696 lang_input_statement_type *file ATTRIBUTE_UNUSED,
5697 void *data)
5699 /* Discarded, excluded and ignored sections effectively have zero
5700 size. */
5701 if (section->output_section != NULL
5702 && section->output_section->owner == output_bfd
5703 && (section->output_section->flags & SEC_EXCLUDE) == 0
5704 && !IGNORE_SECTION (section)
5705 && section->size != 0)
5707 bfd_boolean *has_relro_section = (bfd_boolean *) data;
5708 *has_relro_section = TRUE;
5712 /* Iterate over sections for relro sections. */
5714 static void
5715 lang_find_relro_sections_1 (lang_statement_union_type *s,
5716 bfd_boolean *has_relro_section)
5718 if (*has_relro_section)
5719 return;
5721 for (; s != NULL; s = s->header.next)
5723 if (s == expld.dataseg.relro_end_stat)
5724 break;
5726 switch (s->header.type)
5728 case lang_wild_statement_enum:
5729 walk_wild (&s->wild_statement,
5730 find_relro_section_callback,
5731 has_relro_section);
5732 break;
5733 case lang_constructors_statement_enum:
5734 lang_find_relro_sections_1 (constructor_list.head,
5735 has_relro_section);
5736 break;
5737 case lang_output_section_statement_enum:
5738 lang_find_relro_sections_1 (s->output_section_statement.children.head,
5739 has_relro_section);
5740 break;
5741 case lang_group_statement_enum:
5742 lang_find_relro_sections_1 (s->group_statement.children.head,
5743 has_relro_section);
5744 break;
5745 default:
5746 break;
5751 static void
5752 lang_find_relro_sections (void)
5754 bfd_boolean has_relro_section = FALSE;
5756 /* Check all sections in the link script. */
5758 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
5759 &has_relro_section);
5761 if (!has_relro_section)
5762 link_info.relro = FALSE;
5765 /* Relax all sections until bfd_relax_section gives up. */
5767 static void
5768 relax_sections (void)
5770 /* Keep relaxing until bfd_relax_section gives up. */
5771 bfd_boolean relax_again;
5773 link_info.relax_trip = -1;
5776 relax_again = FALSE;
5777 link_info.relax_trip++;
5779 /* Note: pe-dll.c does something like this also. If you find
5780 you need to change this code, you probably need to change
5781 pe-dll.c also. DJ */
5783 /* Do all the assignments with our current guesses as to
5784 section sizes. */
5785 lang_do_assignments ();
5787 /* We must do this after lang_do_assignments, because it uses
5788 size. */
5789 lang_reset_memory_regions ();
5791 /* Perform another relax pass - this time we know where the
5792 globals are, so can make a better guess. */
5793 lang_size_sections (&relax_again, FALSE);
5795 while (relax_again);
5798 void
5799 lang_process (void)
5801 /* Finalize dynamic list. */
5802 if (link_info.dynamic_list)
5803 lang_finalize_version_expr_head (&link_info.dynamic_list->head);
5805 current_target = default_target;
5807 /* Open the output file. */
5808 lang_for_each_statement (ldlang_open_output);
5809 init_opb ();
5811 ldemul_create_output_section_statements ();
5813 /* Add to the hash table all undefineds on the command line. */
5814 lang_place_undefineds ();
5816 if (!bfd_section_already_linked_table_init ())
5817 einfo (_("%P%F: Failed to create hash table\n"));
5819 /* Create a bfd for each input file. */
5820 current_target = default_target;
5821 open_input_bfds (statement_list.head, FALSE);
5823 link_info.gc_sym_list = &entry_symbol;
5824 if (entry_symbol.name == NULL)
5825 link_info.gc_sym_list = ldlang_undef_chain_list_head;
5827 ldemul_after_open ();
5829 bfd_section_already_linked_table_free ();
5831 /* Make sure that we're not mixing architectures. We call this
5832 after all the input files have been opened, but before we do any
5833 other processing, so that any operations merge_private_bfd_data
5834 does on the output file will be known during the rest of the
5835 link. */
5836 lang_check ();
5838 /* Handle .exports instead of a version script if we're told to do so. */
5839 if (command_line.version_exports_section)
5840 lang_do_version_exports_section ();
5842 /* Build all sets based on the information gathered from the input
5843 files. */
5844 ldctor_build_sets ();
5846 /* Remove unreferenced sections if asked to. */
5847 lang_gc_sections ();
5849 /* Size up the common data. */
5850 lang_common ();
5852 /* Update wild statements. */
5853 update_wild_statements (statement_list.head);
5855 /* Run through the contours of the script and attach input sections
5856 to the correct output sections. */
5857 map_input_to_output_sections (statement_list.head, NULL, NULL);
5859 /* Find any sections not attached explicitly and handle them. */
5860 lang_place_orphans ();
5862 if (! link_info.relocatable)
5864 asection *found;
5866 /* Merge SEC_MERGE sections. This has to be done after GC of
5867 sections, so that GCed sections are not merged, but before
5868 assigning dynamic symbols, since removing whole input sections
5869 is hard then. */
5870 bfd_merge_sections (output_bfd, &link_info);
5872 /* Look for a text section and set the readonly attribute in it. */
5873 found = bfd_get_section_by_name (output_bfd, ".text");
5875 if (found != NULL)
5877 if (config.text_read_only)
5878 found->flags |= SEC_READONLY;
5879 else
5880 found->flags &= ~SEC_READONLY;
5884 /* Do anything special before sizing sections. This is where ELF
5885 and other back-ends size dynamic sections. */
5886 ldemul_before_allocation ();
5888 /* We must record the program headers before we try to fix the
5889 section positions, since they will affect SIZEOF_HEADERS. */
5890 lang_record_phdrs ();
5892 /* Check relro sections. */
5893 if (link_info.relro && ! link_info.relocatable)
5894 lang_find_relro_sections ();
5896 /* Size up the sections. */
5897 lang_size_sections (NULL, !command_line.relax);
5899 /* Now run around and relax if we can. */
5900 if (command_line.relax)
5902 /* We may need more than one relaxation pass. */
5903 int i = link_info.relax_pass;
5905 /* The backend can use it to determine the current pass. */
5906 link_info.relax_pass = 0;
5908 while (i--)
5910 relax_sections ();
5911 link_info.relax_pass++;
5914 /* Final extra sizing to report errors. */
5915 lang_do_assignments ();
5916 lang_reset_memory_regions ();
5917 lang_size_sections (NULL, TRUE);
5920 /* See if anything special should be done now we know how big
5921 everything is. */
5922 ldemul_after_allocation ();
5924 /* Fix any .startof. or .sizeof. symbols. */
5925 lang_set_startof ();
5927 /* Do all the assignments, now that we know the final resting places
5928 of all the symbols. */
5930 lang_do_assignments ();
5932 ldemul_finish ();
5934 /* Make sure that the section addresses make sense. */
5935 if (! link_info.relocatable
5936 && command_line.check_section_addresses)
5937 lang_check_section_addresses ();
5939 lang_end ();
5942 /* EXPORTED TO YACC */
5944 void
5945 lang_add_wild (struct wildcard_spec *filespec,
5946 struct wildcard_list *section_list,
5947 bfd_boolean keep_sections)
5949 struct wildcard_list *curr, *next;
5950 lang_wild_statement_type *new;
5952 /* Reverse the list as the parser puts it back to front. */
5953 for (curr = section_list, section_list = NULL;
5954 curr != NULL;
5955 section_list = curr, curr = next)
5957 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
5958 placed_commons = TRUE;
5960 next = curr->next;
5961 curr->next = section_list;
5964 if (filespec != NULL && filespec->name != NULL)
5966 if (strcmp (filespec->name, "*") == 0)
5967 filespec->name = NULL;
5968 else if (! wildcardp (filespec->name))
5969 lang_has_input_file = TRUE;
5972 new = new_stat (lang_wild_statement, stat_ptr);
5973 new->filename = NULL;
5974 new->filenames_sorted = FALSE;
5975 if (filespec != NULL)
5977 new->filename = filespec->name;
5978 new->filenames_sorted = filespec->sorted == by_name;
5980 new->section_list = section_list;
5981 new->keep_sections = keep_sections;
5982 lang_list_init (&new->children);
5983 analyze_walk_wild_section_handler (new);
5986 void
5987 lang_section_start (const char *name, etree_type *address,
5988 const segment_type *segment)
5990 lang_address_statement_type *ad;
5992 ad = new_stat (lang_address_statement, stat_ptr);
5993 ad->section_name = name;
5994 ad->address = address;
5995 ad->segment = segment;
5998 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5999 because of a -e argument on the command line, or zero if this is
6000 called by ENTRY in a linker script. Command line arguments take
6001 precedence. */
6003 void
6004 lang_add_entry (const char *name, bfd_boolean cmdline)
6006 if (entry_symbol.name == NULL
6007 || cmdline
6008 || ! entry_from_cmdline)
6010 entry_symbol.name = name;
6011 entry_from_cmdline = cmdline;
6015 /* Set the default start symbol to NAME. .em files should use this,
6016 not lang_add_entry, to override the use of "start" if neither the
6017 linker script nor the command line specifies an entry point. NAME
6018 must be permanently allocated. */
6019 void
6020 lang_default_entry (const char *name)
6022 entry_symbol_default = name;
6025 void
6026 lang_add_target (const char *name)
6028 lang_target_statement_type *new;
6030 new = new_stat (lang_target_statement, stat_ptr);
6031 new->target = name;
6034 void
6035 lang_add_map (const char *name)
6037 while (*name)
6039 switch (*name)
6041 case 'F':
6042 map_option_f = TRUE;
6043 break;
6045 name++;
6049 void
6050 lang_add_fill (fill_type *fill)
6052 lang_fill_statement_type *new;
6054 new = new_stat (lang_fill_statement, stat_ptr);
6055 new->fill = fill;
6058 void
6059 lang_add_data (int type, union etree_union *exp)
6061 lang_data_statement_type *new;
6063 new = new_stat (lang_data_statement, stat_ptr);
6064 new->exp = exp;
6065 new->type = type;
6068 /* Create a new reloc statement. RELOC is the BFD relocation type to
6069 generate. HOWTO is the corresponding howto structure (we could
6070 look this up, but the caller has already done so). SECTION is the
6071 section to generate a reloc against, or NAME is the name of the
6072 symbol to generate a reloc against. Exactly one of SECTION and
6073 NAME must be NULL. ADDEND is an expression for the addend. */
6075 void
6076 lang_add_reloc (bfd_reloc_code_real_type reloc,
6077 reloc_howto_type *howto,
6078 asection *section,
6079 const char *name,
6080 union etree_union *addend)
6082 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6084 p->reloc = reloc;
6085 p->howto = howto;
6086 p->section = section;
6087 p->name = name;
6088 p->addend_exp = addend;
6090 p->addend_value = 0;
6091 p->output_section = NULL;
6092 p->output_offset = 0;
6095 lang_assignment_statement_type *
6096 lang_add_assignment (etree_type *exp)
6098 lang_assignment_statement_type *new;
6100 new = new_stat (lang_assignment_statement, stat_ptr);
6101 new->exp = exp;
6102 return new;
6105 void
6106 lang_add_attribute (enum statement_enum attribute)
6108 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6111 void
6112 lang_startup (const char *name)
6114 if (startup_file != NULL)
6116 einfo (_("%P%F: multiple STARTUP files\n"));
6118 first_file->filename = name;
6119 first_file->local_sym_name = name;
6120 first_file->real = TRUE;
6122 startup_file = name;
6125 void
6126 lang_float (bfd_boolean maybe)
6128 lang_float_flag = maybe;
6132 /* Work out the load- and run-time regions from a script statement, and
6133 store them in *LMA_REGION and *REGION respectively.
6135 MEMSPEC is the name of the run-time region, or the value of
6136 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6137 LMA_MEMSPEC is the name of the load-time region, or null if the
6138 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6139 had an explicit load address.
6141 It is an error to specify both a load region and a load address. */
6143 static void
6144 lang_get_regions (lang_memory_region_type **region,
6145 lang_memory_region_type **lma_region,
6146 const char *memspec,
6147 const char *lma_memspec,
6148 bfd_boolean have_lma,
6149 bfd_boolean have_vma)
6151 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6153 /* If no runtime region or VMA has been specified, but the load region
6154 has been specified, then use the load region for the runtime region
6155 as well. */
6156 if (lma_memspec != NULL
6157 && ! have_vma
6158 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6159 *region = *lma_region;
6160 else
6161 *region = lang_memory_region_lookup (memspec, FALSE);
6163 if (have_lma && lma_memspec != 0)
6164 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6167 void
6168 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6169 lang_output_section_phdr_list *phdrs,
6170 const char *lma_memspec)
6172 lang_get_regions (&current_section->region,
6173 &current_section->lma_region,
6174 memspec, lma_memspec,
6175 current_section->load_base != NULL,
6176 current_section->addr_tree != NULL);
6177 current_section->fill = fill;
6178 current_section->phdrs = phdrs;
6179 stat_ptr = &statement_list;
6182 /* Create an absolute symbol with the given name with the value of the
6183 address of first byte of the section named.
6185 If the symbol already exists, then do nothing. */
6187 void
6188 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6190 struct bfd_link_hash_entry *h;
6192 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6193 if (h == NULL)
6194 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6196 if (h->type == bfd_link_hash_new
6197 || h->type == bfd_link_hash_undefined)
6199 asection *sec;
6201 h->type = bfd_link_hash_defined;
6203 sec = bfd_get_section_by_name (output_bfd, secname);
6204 if (sec == NULL)
6205 h->u.def.value = 0;
6206 else
6207 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
6209 h->u.def.section = bfd_abs_section_ptr;
6213 /* Create an absolute symbol with the given name with the value of the
6214 address of the first byte after the end of the section named.
6216 If the symbol already exists, then do nothing. */
6218 void
6219 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6221 struct bfd_link_hash_entry *h;
6223 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6224 if (h == NULL)
6225 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6227 if (h->type == bfd_link_hash_new
6228 || h->type == bfd_link_hash_undefined)
6230 asection *sec;
6232 h->type = bfd_link_hash_defined;
6234 sec = bfd_get_section_by_name (output_bfd, secname);
6235 if (sec == NULL)
6236 h->u.def.value = 0;
6237 else
6238 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
6239 + TO_ADDR (sec->size));
6241 h->u.def.section = bfd_abs_section_ptr;
6245 void
6246 lang_statement_append (lang_statement_list_type *list,
6247 lang_statement_union_type *element,
6248 lang_statement_union_type **field)
6250 *(list->tail) = element;
6251 list->tail = field;
6254 /* Set the output format type. -oformat overrides scripts. */
6256 void
6257 lang_add_output_format (const char *format,
6258 const char *big,
6259 const char *little,
6260 int from_script)
6262 if (output_target == NULL || !from_script)
6264 if (command_line.endian == ENDIAN_BIG
6265 && big != NULL)
6266 format = big;
6267 else if (command_line.endian == ENDIAN_LITTLE
6268 && little != NULL)
6269 format = little;
6271 output_target = format;
6275 /* Enter a group. This creates a new lang_group_statement, and sets
6276 stat_ptr to build new statements within the group. */
6278 void
6279 lang_enter_group (void)
6281 lang_group_statement_type *g;
6283 g = new_stat (lang_group_statement, stat_ptr);
6284 lang_list_init (&g->children);
6285 stat_ptr = &g->children;
6288 /* Leave a group. This just resets stat_ptr to start writing to the
6289 regular list of statements again. Note that this will not work if
6290 groups can occur inside anything else which can adjust stat_ptr,
6291 but currently they can't. */
6293 void
6294 lang_leave_group (void)
6296 stat_ptr = &statement_list;
6299 /* Add a new program header. This is called for each entry in a PHDRS
6300 command in a linker script. */
6302 void
6303 lang_new_phdr (const char *name,
6304 etree_type *type,
6305 bfd_boolean filehdr,
6306 bfd_boolean phdrs,
6307 etree_type *at,
6308 etree_type *flags)
6310 struct lang_phdr *n, **pp;
6312 n = stat_alloc (sizeof (struct lang_phdr));
6313 n->next = NULL;
6314 n->name = name;
6315 n->type = exp_get_value_int (type, 0, "program header type");
6316 n->filehdr = filehdr;
6317 n->phdrs = phdrs;
6318 n->at = at;
6319 n->flags = flags;
6321 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6323 *pp = n;
6326 /* Record the program header information in the output BFD. FIXME: We
6327 should not be calling an ELF specific function here. */
6329 static void
6330 lang_record_phdrs (void)
6332 unsigned int alc;
6333 asection **secs;
6334 lang_output_section_phdr_list *last;
6335 struct lang_phdr *l;
6336 lang_output_section_statement_type *os;
6338 alc = 10;
6339 secs = xmalloc (alc * sizeof (asection *));
6340 last = NULL;
6342 for (l = lang_phdr_list; l != NULL; l = l->next)
6344 unsigned int c;
6345 flagword flags;
6346 bfd_vma at;
6348 c = 0;
6349 for (os = &lang_output_section_statement.head->output_section_statement;
6350 os != NULL;
6351 os = os->next)
6353 lang_output_section_phdr_list *pl;
6355 if (os->constraint == -1)
6356 continue;
6358 pl = os->phdrs;
6359 if (pl != NULL)
6360 last = pl;
6361 else
6363 if (os->sectype == noload_section
6364 || os->bfd_section == NULL
6365 || (os->bfd_section->flags & SEC_ALLOC) == 0)
6366 continue;
6368 if (last == NULL)
6370 lang_output_section_statement_type * tmp_os;
6372 /* If we have not run across a section with a program
6373 header assigned to it yet, then scan forwards to find
6374 one. This prevents inconsistencies in the linker's
6375 behaviour when a script has specified just a single
6376 header and there are sections in that script which are
6377 not assigned to it, and which occur before the first
6378 use of that header. See here for more details:
6379 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6380 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6381 if (tmp_os->phdrs)
6383 last = tmp_os->phdrs;
6384 break;
6386 if (last == NULL)
6387 einfo (_("%F%P: no sections assigned to phdrs\n"));
6389 pl = last;
6392 if (os->bfd_section == NULL)
6393 continue;
6395 for (; pl != NULL; pl = pl->next)
6397 if (strcmp (pl->name, l->name) == 0)
6399 if (c >= alc)
6401 alc *= 2;
6402 secs = xrealloc (secs, alc * sizeof (asection *));
6404 secs[c] = os->bfd_section;
6405 ++c;
6406 pl->used = TRUE;
6411 if (l->flags == NULL)
6412 flags = 0;
6413 else
6414 flags = exp_get_vma (l->flags, 0, "phdr flags");
6416 if (l->at == NULL)
6417 at = 0;
6418 else
6419 at = exp_get_vma (l->at, 0, "phdr load address");
6421 if (! bfd_record_phdr (output_bfd, l->type,
6422 l->flags != NULL, flags, l->at != NULL,
6423 at, l->filehdr, l->phdrs, c, secs))
6424 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6427 free (secs);
6429 /* Make sure all the phdr assignments succeeded. */
6430 for (os = &lang_output_section_statement.head->output_section_statement;
6431 os != NULL;
6432 os = os->next)
6434 lang_output_section_phdr_list *pl;
6436 if (os->constraint == -1
6437 || os->bfd_section == NULL)
6438 continue;
6440 for (pl = os->phdrs;
6441 pl != NULL;
6442 pl = pl->next)
6443 if (! pl->used && strcmp (pl->name, "NONE") != 0)
6444 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6445 os->name, pl->name);
6449 /* Record a list of sections which may not be cross referenced. */
6451 void
6452 lang_add_nocrossref (lang_nocrossref_type *l)
6454 struct lang_nocrossrefs *n;
6456 n = xmalloc (sizeof *n);
6457 n->next = nocrossref_list;
6458 n->list = l;
6459 nocrossref_list = n;
6461 /* Set notice_all so that we get informed about all symbols. */
6462 link_info.notice_all = TRUE;
6465 /* Overlay handling. We handle overlays with some static variables. */
6467 /* The overlay virtual address. */
6468 static etree_type *overlay_vma;
6469 /* And subsection alignment. */
6470 static etree_type *overlay_subalign;
6472 /* An expression for the maximum section size seen so far. */
6473 static etree_type *overlay_max;
6475 /* A list of all the sections in this overlay. */
6477 struct overlay_list {
6478 struct overlay_list *next;
6479 lang_output_section_statement_type *os;
6482 static struct overlay_list *overlay_list;
6484 /* Start handling an overlay. */
6486 void
6487 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
6489 /* The grammar should prevent nested overlays from occurring. */
6490 ASSERT (overlay_vma == NULL
6491 && overlay_subalign == NULL
6492 && overlay_max == NULL);
6494 overlay_vma = vma_expr;
6495 overlay_subalign = subalign;
6498 /* Start a section in an overlay. We handle this by calling
6499 lang_enter_output_section_statement with the correct VMA.
6500 lang_leave_overlay sets up the LMA and memory regions. */
6502 void
6503 lang_enter_overlay_section (const char *name)
6505 struct overlay_list *n;
6506 etree_type *size;
6508 lang_enter_output_section_statement (name, overlay_vma, overlay_section,
6509 0, overlay_subalign, 0, 0);
6511 /* If this is the first section, then base the VMA of future
6512 sections on this one. This will work correctly even if `.' is
6513 used in the addresses. */
6514 if (overlay_list == NULL)
6515 overlay_vma = exp_nameop (ADDR, name);
6517 /* Remember the section. */
6518 n = xmalloc (sizeof *n);
6519 n->os = current_section;
6520 n->next = overlay_list;
6521 overlay_list = n;
6523 size = exp_nameop (SIZEOF, name);
6525 /* Arrange to work out the maximum section end address. */
6526 if (overlay_max == NULL)
6527 overlay_max = size;
6528 else
6529 overlay_max = exp_binop (MAX_K, overlay_max, size);
6532 /* Finish a section in an overlay. There isn't any special to do
6533 here. */
6535 void
6536 lang_leave_overlay_section (fill_type *fill,
6537 lang_output_section_phdr_list *phdrs)
6539 const char *name;
6540 char *clean, *s2;
6541 const char *s1;
6542 char *buf;
6544 name = current_section->name;
6546 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6547 region and that no load-time region has been specified. It doesn't
6548 really matter what we say here, since lang_leave_overlay will
6549 override it. */
6550 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6552 /* Define the magic symbols. */
6554 clean = xmalloc (strlen (name) + 1);
6555 s2 = clean;
6556 for (s1 = name; *s1 != '\0'; s1++)
6557 if (ISALNUM (*s1) || *s1 == '_')
6558 *s2++ = *s1;
6559 *s2 = '\0';
6561 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6562 sprintf (buf, "__load_start_%s", clean);
6563 lang_add_assignment (exp_provide (buf,
6564 exp_nameop (LOADADDR, name),
6565 FALSE));
6567 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6568 sprintf (buf, "__load_stop_%s", clean);
6569 lang_add_assignment (exp_provide (buf,
6570 exp_binop ('+',
6571 exp_nameop (LOADADDR, name),
6572 exp_nameop (SIZEOF, name)),
6573 FALSE));
6575 free (clean);
6578 /* Finish an overlay. If there are any overlay wide settings, this
6579 looks through all the sections in the overlay and sets them. */
6581 void
6582 lang_leave_overlay (etree_type *lma_expr,
6583 int nocrossrefs,
6584 fill_type *fill,
6585 const char *memspec,
6586 lang_output_section_phdr_list *phdrs,
6587 const char *lma_memspec)
6589 lang_memory_region_type *region;
6590 lang_memory_region_type *lma_region;
6591 struct overlay_list *l;
6592 lang_nocrossref_type *nocrossref;
6594 lang_get_regions (&region, &lma_region,
6595 memspec, lma_memspec,
6596 lma_expr != NULL, FALSE);
6598 nocrossref = NULL;
6600 /* After setting the size of the last section, set '.' to end of the
6601 overlay region. */
6602 if (overlay_list != NULL)
6603 overlay_list->os->update_dot_tree
6604 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6606 l = overlay_list;
6607 while (l != NULL)
6609 struct overlay_list *next;
6611 if (fill != NULL && l->os->fill == NULL)
6612 l->os->fill = fill;
6614 l->os->region = region;
6615 l->os->lma_region = lma_region;
6617 /* The first section has the load address specified in the
6618 OVERLAY statement. The rest are worked out from that.
6619 The base address is not needed (and should be null) if
6620 an LMA region was specified. */
6621 if (l->next == 0)
6623 l->os->load_base = lma_expr;
6624 l->os->sectype = normal_section;
6626 if (phdrs != NULL && l->os->phdrs == NULL)
6627 l->os->phdrs = phdrs;
6629 if (nocrossrefs)
6631 lang_nocrossref_type *nc;
6633 nc = xmalloc (sizeof *nc);
6634 nc->name = l->os->name;
6635 nc->next = nocrossref;
6636 nocrossref = nc;
6639 next = l->next;
6640 free (l);
6641 l = next;
6644 if (nocrossref != NULL)
6645 lang_add_nocrossref (nocrossref);
6647 overlay_vma = NULL;
6648 overlay_list = NULL;
6649 overlay_max = NULL;
6652 /* Version handling. This is only useful for ELF. */
6654 /* This global variable holds the version tree that we build. */
6656 struct bfd_elf_version_tree *lang_elf_version_info;
6658 /* If PREV is NULL, return first version pattern matching particular symbol.
6659 If PREV is non-NULL, return first version pattern matching particular
6660 symbol after PREV (previously returned by lang_vers_match). */
6662 static struct bfd_elf_version_expr *
6663 lang_vers_match (struct bfd_elf_version_expr_head *head,
6664 struct bfd_elf_version_expr *prev,
6665 const char *sym)
6667 const char *cxx_sym = sym;
6668 const char *java_sym = sym;
6669 struct bfd_elf_version_expr *expr = NULL;
6671 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6673 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
6674 if (!cxx_sym)
6675 cxx_sym = sym;
6677 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6679 java_sym = cplus_demangle (sym, DMGL_JAVA);
6680 if (!java_sym)
6681 java_sym = sym;
6684 if (head->htab && (prev == NULL || prev->symbol))
6686 struct bfd_elf_version_expr e;
6688 switch (prev ? prev->mask : 0)
6690 case 0:
6691 if (head->mask & BFD_ELF_VERSION_C_TYPE)
6693 e.symbol = sym;
6694 expr = htab_find (head->htab, &e);
6695 while (expr && strcmp (expr->symbol, sym) == 0)
6696 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
6697 goto out_ret;
6698 else
6699 expr = expr->next;
6701 /* Fallthrough */
6702 case BFD_ELF_VERSION_C_TYPE:
6703 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6705 e.symbol = cxx_sym;
6706 expr = htab_find (head->htab, &e);
6707 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
6708 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6709 goto out_ret;
6710 else
6711 expr = expr->next;
6713 /* Fallthrough */
6714 case BFD_ELF_VERSION_CXX_TYPE:
6715 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6717 e.symbol = java_sym;
6718 expr = htab_find (head->htab, &e);
6719 while (expr && strcmp (expr->symbol, java_sym) == 0)
6720 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6721 goto out_ret;
6722 else
6723 expr = expr->next;
6725 /* Fallthrough */
6726 default:
6727 break;
6731 /* Finally, try the wildcards. */
6732 if (prev == NULL || prev->symbol)
6733 expr = head->remaining;
6734 else
6735 expr = prev->next;
6736 for (; expr; expr = expr->next)
6738 const char *s;
6740 if (!expr->pattern)
6741 continue;
6743 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
6744 break;
6746 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6747 s = java_sym;
6748 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6749 s = cxx_sym;
6750 else
6751 s = sym;
6752 if (fnmatch (expr->pattern, s, 0) == 0)
6753 break;
6756 out_ret:
6757 if (cxx_sym != sym)
6758 free ((char *) cxx_sym);
6759 if (java_sym != sym)
6760 free ((char *) java_sym);
6761 return expr;
6764 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6765 return a string pointing to the symbol name. */
6767 static const char *
6768 realsymbol (const char *pattern)
6770 const char *p;
6771 bfd_boolean changed = FALSE, backslash = FALSE;
6772 char *s, *symbol = xmalloc (strlen (pattern) + 1);
6774 for (p = pattern, s = symbol; *p != '\0'; ++p)
6776 /* It is a glob pattern only if there is no preceding
6777 backslash. */
6778 if (! backslash && (*p == '?' || *p == '*' || *p == '['))
6780 free (symbol);
6781 return NULL;
6784 if (backslash)
6786 /* Remove the preceding backslash. */
6787 *(s - 1) = *p;
6788 changed = TRUE;
6790 else
6791 *s++ = *p;
6793 backslash = *p == '\\';
6796 if (changed)
6798 *s = '\0';
6799 return symbol;
6801 else
6803 free (symbol);
6804 return pattern;
6808 /* This is called for each variable name or match expression. NEW is
6809 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6810 pattern to be matched against symbol names. */
6812 struct bfd_elf_version_expr *
6813 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
6814 const char *new,
6815 const char *lang,
6816 bfd_boolean literal_p)
6818 struct bfd_elf_version_expr *ret;
6820 ret = xmalloc (sizeof *ret);
6821 ret->next = orig;
6822 ret->pattern = literal_p ? NULL : new;
6823 ret->symver = 0;
6824 ret->script = 0;
6825 ret->symbol = literal_p ? new : realsymbol (new);
6827 if (lang == NULL || strcasecmp (lang, "C") == 0)
6828 ret->mask = BFD_ELF_VERSION_C_TYPE;
6829 else if (strcasecmp (lang, "C++") == 0)
6830 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
6831 else if (strcasecmp (lang, "Java") == 0)
6832 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
6833 else
6835 einfo (_("%X%P: unknown language `%s' in version information\n"),
6836 lang);
6837 ret->mask = BFD_ELF_VERSION_C_TYPE;
6840 return ldemul_new_vers_pattern (ret);
6843 /* This is called for each set of variable names and match
6844 expressions. */
6846 struct bfd_elf_version_tree *
6847 lang_new_vers_node (struct bfd_elf_version_expr *globals,
6848 struct bfd_elf_version_expr *locals)
6850 struct bfd_elf_version_tree *ret;
6852 ret = xcalloc (1, sizeof *ret);
6853 ret->globals.list = globals;
6854 ret->locals.list = locals;
6855 ret->match = lang_vers_match;
6856 ret->name_indx = (unsigned int) -1;
6857 return ret;
6860 /* This static variable keeps track of version indices. */
6862 static int version_index;
6864 static hashval_t
6865 version_expr_head_hash (const void *p)
6867 const struct bfd_elf_version_expr *e = p;
6869 return htab_hash_string (e->symbol);
6872 static int
6873 version_expr_head_eq (const void *p1, const void *p2)
6875 const struct bfd_elf_version_expr *e1 = p1;
6876 const struct bfd_elf_version_expr *e2 = p2;
6878 return strcmp (e1->symbol, e2->symbol) == 0;
6881 static void
6882 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
6884 size_t count = 0;
6885 struct bfd_elf_version_expr *e, *next;
6886 struct bfd_elf_version_expr **list_loc, **remaining_loc;
6888 for (e = head->list; e; e = e->next)
6890 if (e->symbol)
6891 count++;
6892 head->mask |= e->mask;
6895 if (count)
6897 head->htab = htab_create (count * 2, version_expr_head_hash,
6898 version_expr_head_eq, NULL);
6899 list_loc = &head->list;
6900 remaining_loc = &head->remaining;
6901 for (e = head->list; e; e = next)
6903 next = e->next;
6904 if (!e->symbol)
6906 *remaining_loc = e;
6907 remaining_loc = &e->next;
6909 else
6911 void **loc = htab_find_slot (head->htab, e, INSERT);
6913 if (*loc)
6915 struct bfd_elf_version_expr *e1, *last;
6917 e1 = *loc;
6918 last = NULL;
6921 if (e1->mask == e->mask)
6923 last = NULL;
6924 break;
6926 last = e1;
6927 e1 = e1->next;
6929 while (e1 && strcmp (e1->symbol, e->symbol) == 0);
6931 if (last == NULL)
6933 /* This is a duplicate. */
6934 /* FIXME: Memory leak. Sometimes pattern is not
6935 xmalloced alone, but in larger chunk of memory. */
6936 /* free (e->symbol); */
6937 free (e);
6939 else
6941 e->next = last->next;
6942 last->next = e;
6945 else
6947 *loc = e;
6948 *list_loc = e;
6949 list_loc = &e->next;
6953 *remaining_loc = NULL;
6954 *list_loc = head->remaining;
6956 else
6957 head->remaining = head->list;
6960 /* This is called when we know the name and dependencies of the
6961 version. */
6963 void
6964 lang_register_vers_node (const char *name,
6965 struct bfd_elf_version_tree *version,
6966 struct bfd_elf_version_deps *deps)
6968 struct bfd_elf_version_tree *t, **pp;
6969 struct bfd_elf_version_expr *e1;
6971 if (name == NULL)
6972 name = "";
6974 if ((name[0] == '\0' && lang_elf_version_info != NULL)
6975 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
6977 einfo (_("%X%P: anonymous version tag cannot be combined"
6978 " with other version tags\n"));
6979 free (version);
6980 return;
6983 /* Make sure this node has a unique name. */
6984 for (t = lang_elf_version_info; t != NULL; t = t->next)
6985 if (strcmp (t->name, name) == 0)
6986 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
6988 lang_finalize_version_expr_head (&version->globals);
6989 lang_finalize_version_expr_head (&version->locals);
6991 /* Check the global and local match names, and make sure there
6992 aren't any duplicates. */
6994 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
6996 for (t = lang_elf_version_info; t != NULL; t = t->next)
6998 struct bfd_elf_version_expr *e2;
7000 if (t->locals.htab && e1->symbol)
7002 e2 = htab_find (t->locals.htab, e1);
7003 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7005 if (e1->mask == e2->mask)
7006 einfo (_("%X%P: duplicate expression `%s'"
7007 " in version information\n"), e1->symbol);
7008 e2 = e2->next;
7011 else if (!e1->symbol)
7012 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7013 if (strcmp (e1->pattern, e2->pattern) == 0
7014 && e1->mask == e2->mask)
7015 einfo (_("%X%P: duplicate expression `%s'"
7016 " in version information\n"), e1->pattern);
7020 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7022 for (t = lang_elf_version_info; t != NULL; t = t->next)
7024 struct bfd_elf_version_expr *e2;
7026 if (t->globals.htab && e1->symbol)
7028 e2 = htab_find (t->globals.htab, e1);
7029 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7031 if (e1->mask == e2->mask)
7032 einfo (_("%X%P: duplicate expression `%s'"
7033 " in version information\n"),
7034 e1->symbol);
7035 e2 = e2->next;
7038 else if (!e1->symbol)
7039 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7040 if (strcmp (e1->pattern, e2->pattern) == 0
7041 && e1->mask == e2->mask)
7042 einfo (_("%X%P: duplicate expression `%s'"
7043 " in version information\n"), e1->pattern);
7047 version->deps = deps;
7048 version->name = name;
7049 if (name[0] != '\0')
7051 ++version_index;
7052 version->vernum = version_index;
7054 else
7055 version->vernum = 0;
7057 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7059 *pp = version;
7062 /* This is called when we see a version dependency. */
7064 struct bfd_elf_version_deps *
7065 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7067 struct bfd_elf_version_deps *ret;
7068 struct bfd_elf_version_tree *t;
7070 ret = xmalloc (sizeof *ret);
7071 ret->next = list;
7073 for (t = lang_elf_version_info; t != NULL; t = t->next)
7075 if (strcmp (t->name, name) == 0)
7077 ret->version_needed = t;
7078 return ret;
7082 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7084 return ret;
7087 static void
7088 lang_do_version_exports_section (void)
7090 struct bfd_elf_version_expr *greg = NULL, *lreg;
7092 LANG_FOR_EACH_INPUT_STATEMENT (is)
7094 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7095 char *contents, *p;
7096 bfd_size_type len;
7098 if (sec == NULL)
7099 continue;
7101 len = sec->size;
7102 contents = xmalloc (len);
7103 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7104 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7106 p = contents;
7107 while (p < contents + len)
7109 greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7110 p = strchr (p, '\0') + 1;
7113 /* Do not free the contents, as we used them creating the regex. */
7115 /* Do not include this section in the link. */
7116 sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7119 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7120 lang_register_vers_node (command_line.version_exports_section,
7121 lang_new_vers_node (greg, lreg), NULL);
7124 void
7125 lang_add_unique (const char *name)
7127 struct unique_sections *ent;
7129 for (ent = unique_section_list; ent; ent = ent->next)
7130 if (strcmp (ent->name, name) == 0)
7131 return;
7133 ent = xmalloc (sizeof *ent);
7134 ent->name = xstrdup (name);
7135 ent->next = unique_section_list;
7136 unique_section_list = ent;
7139 /* Append the list of dynamic symbols to the existing one. */
7141 void
7142 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7144 if (link_info.dynamic_list)
7146 struct bfd_elf_version_expr *tail;
7147 for (tail = dynamic; tail->next != NULL; tail = tail->next)
7149 tail->next = link_info.dynamic_list->head.list;
7150 link_info.dynamic_list->head.list = dynamic;
7152 else
7154 struct bfd_elf_dynamic_list *d;
7156 d = xcalloc (1, sizeof *d);
7157 d->head.list = dynamic;
7158 d->match = lang_vers_match;
7159 link_info.dynamic_list = d;
7163 /* Append the list of C++ typeinfo dynamic symbols to the existing
7164 one. */
7166 void
7167 lang_append_dynamic_list_cpp_typeinfo (void)
7169 const char * symbols [] =
7171 "typeinfo name for*",
7172 "typeinfo for*"
7174 struct bfd_elf_version_expr *dynamic = NULL;
7175 unsigned int i;
7177 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7178 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7179 FALSE);
7181 lang_append_dynamic_list (dynamic);
7184 /* Append the list of C++ operator new and delete dynamic symbols to the
7185 existing one. */
7187 void
7188 lang_append_dynamic_list_cpp_new (void)
7190 const char * symbols [] =
7192 "operator new*",
7193 "operator delete*"
7195 struct bfd_elf_version_expr *dynamic = NULL;
7196 unsigned int i;
7198 for (i = 0; i < ARRAY_SIZE (symbols); i++)
7199 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7200 FALSE);
7202 lang_append_dynamic_list (dynamic);