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 GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack
;
50 static struct obstack map_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static 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)
130 stat_alloc (size_t size
)
132 return obstack_alloc (&stat_obstack
, size
);
136 unique_section_p (const asection
*sec
)
138 struct unique_sections
*unam
;
141 if (link_info
.relocatable
142 && sec
->owner
!= NULL
143 && bfd_is_group_section (sec
->owner
, sec
))
147 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
148 if (wildcardp (unam
->name
)
149 ? fnmatch (unam
->name
, secnam
, 0) == 0
150 : strcmp (unam
->name
, secnam
) == 0)
158 /* Generic traversal routines for finding matching sections. */
160 /* Try processing a section against a wildcard. This just calls
161 the callback unless the filename exclusion list is present
162 and excludes the file. It's hardly ever present so this
163 function is very fast. */
166 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
167 lang_input_statement_type
*file
,
169 struct wildcard_list
*sec
,
173 bfd_boolean skip
= FALSE
;
174 struct name_list
*list_tmp
;
176 /* Don't process sections from files which were
178 for (list_tmp
= sec
->spec
.exclude_name_list
;
180 list_tmp
= list_tmp
->next
)
182 bfd_boolean is_wildcard
= wildcardp (list_tmp
->name
);
184 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
186 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
188 /* If this file is part of an archive, and the archive is
189 excluded, exclude this file. */
190 if (! skip
&& file
->the_bfd
!= NULL
191 && file
->the_bfd
->my_archive
!= NULL
192 && file
->the_bfd
->my_archive
->filename
!= NULL
)
195 skip
= fnmatch (list_tmp
->name
,
196 file
->the_bfd
->my_archive
->filename
,
199 skip
= strcmp (list_tmp
->name
,
200 file
->the_bfd
->my_archive
->filename
) == 0;
208 (*callback
) (ptr
, sec
, s
, file
, data
);
211 /* Lowest common denominator routine that can handle everything correctly,
215 walk_wild_section_general (lang_wild_statement_type
*ptr
,
216 lang_input_statement_type
*file
,
221 struct wildcard_list
*sec
;
223 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
225 sec
= ptr
->section_list
;
227 (*callback
) (ptr
, sec
, s
, file
, data
);
231 bfd_boolean skip
= FALSE
;
233 if (sec
->spec
.name
!= NULL
)
235 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
237 if (wildcardp (sec
->spec
.name
))
238 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
240 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
244 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
251 /* Routines to find a single section given its name. If there's more
252 than one section with that name, we report that. */
256 asection
*found_section
;
257 bfd_boolean multiple_sections_found
;
258 } section_iterator_callback_data
;
261 section_iterator_callback (bfd
*bfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
263 section_iterator_callback_data
*d
= data
;
265 if (d
->found_section
!= NULL
)
267 d
->multiple_sections_found
= TRUE
;
271 d
->found_section
= s
;
276 find_section (lang_input_statement_type
*file
,
277 struct wildcard_list
*sec
,
278 bfd_boolean
*multiple_sections_found
)
280 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
282 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
283 section_iterator_callback
, &cb_data
);
284 *multiple_sections_found
= cb_data
.multiple_sections_found
;
285 return cb_data
.found_section
;
288 /* Code for handling simple wildcards without going through fnmatch,
289 which can be expensive because of charset translations etc. */
291 /* A simple wild is a literal string followed by a single '*',
292 where the literal part is at least 4 characters long. */
295 is_simple_wild (const char *name
)
297 size_t len
= strcspn (name
, "*?[");
298 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
302 match_simple_wild (const char *pattern
, const char *name
)
304 /* The first four characters of the pattern are guaranteed valid
305 non-wildcard characters. So we can go faster. */
306 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
307 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
312 while (*pattern
!= '*')
313 if (*name
++ != *pattern
++)
319 /* Compare sections ASEC and BSEC according to SORT. */
322 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
331 case by_alignment_name
:
332 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
333 - bfd_section_alignment (asec
->owner
, asec
));
339 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
340 bfd_get_section_name (bsec
->owner
, bsec
));
343 case by_name_alignment
:
344 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
345 bfd_get_section_name (bsec
->owner
, bsec
));
351 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
352 - bfd_section_alignment (asec
->owner
, asec
));
359 /* Build a Binary Search Tree to sort sections, unlike insertion sort
360 used in wild_sort(). BST is considerably faster if the number of
361 of sections are large. */
363 static lang_section_bst_type
**
364 wild_sort_fast (lang_wild_statement_type
*wild
,
365 struct wildcard_list
*sec
,
366 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
369 lang_section_bst_type
**tree
;
372 if (!wild
->filenames_sorted
373 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
375 /* Append at the right end of tree. */
377 tree
= &((*tree
)->right
);
383 /* Find the correct node to append this section. */
384 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
385 tree
= &((*tree
)->left
);
387 tree
= &((*tree
)->right
);
393 /* Use wild_sort_fast to build a BST to sort sections. */
396 output_section_callback_fast (lang_wild_statement_type
*ptr
,
397 struct wildcard_list
*sec
,
399 lang_input_statement_type
*file
,
400 void *output ATTRIBUTE_UNUSED
)
402 lang_section_bst_type
*node
;
403 lang_section_bst_type
**tree
;
405 if (unique_section_p (section
))
408 node
= xmalloc (sizeof (lang_section_bst_type
));
411 node
->section
= section
;
413 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
418 /* Convert a sorted sections' BST back to list form. */
421 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
422 lang_section_bst_type
*tree
,
426 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
428 lang_add_section (&ptr
->children
, tree
->section
,
429 (lang_output_section_statement_type
*) output
);
432 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
437 /* Specialized, optimized routines for handling different kinds of
441 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
442 lang_input_statement_type
*file
,
446 /* We can just do a hash lookup for the section with the right name.
447 But if that lookup discovers more than one section with the name
448 (should be rare), we fall back to the general algorithm because
449 we would otherwise have to sort the sections to make sure they
450 get processed in the bfd's order. */
451 bfd_boolean multiple_sections_found
;
452 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
453 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
455 if (multiple_sections_found
)
456 walk_wild_section_general (ptr
, file
, callback
, data
);
458 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
462 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
463 lang_input_statement_type
*file
,
468 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
470 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
472 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
473 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
476 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
481 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
482 lang_input_statement_type
*file
,
487 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
488 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
489 bfd_boolean multiple_sections_found
;
490 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
492 if (multiple_sections_found
)
494 walk_wild_section_general (ptr
, file
, callback
, data
);
498 /* Note that if the section was not found, s0 is NULL and
499 we'll simply never succeed the s == s0 test below. */
500 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
502 /* Recall that in this code path, a section cannot satisfy more
503 than one spec, so if s == s0 then it cannot match
506 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
509 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
510 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
513 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
520 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
521 lang_input_statement_type
*file
,
526 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
527 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
528 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
529 bfd_boolean multiple_sections_found
;
530 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
532 if (multiple_sections_found
)
534 walk_wild_section_general (ptr
, file
, callback
, data
);
538 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
541 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
544 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
545 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
548 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
551 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
553 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
561 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
562 lang_input_statement_type
*file
,
567 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
568 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
569 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
570 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
571 bfd_boolean multiple_sections_found
;
572 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
574 if (multiple_sections_found
)
576 walk_wild_section_general (ptr
, file
, callback
, data
);
580 s1
= find_section (file
, sec1
, &multiple_sections_found
);
581 if (multiple_sections_found
)
583 walk_wild_section_general (ptr
, file
, callback
, data
);
587 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
590 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
593 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
596 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
597 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
601 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
605 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
607 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
615 walk_wild_section (lang_wild_statement_type
*ptr
,
616 lang_input_statement_type
*file
,
620 if (file
->just_syms_flag
)
623 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
626 /* Returns TRUE when name1 is a wildcard spec that might match
627 something name2 can match. We're conservative: we return FALSE
628 only if the prefixes of name1 and name2 are different up to the
629 first wildcard character. */
632 wild_spec_can_overlap (const char *name1
, const char *name2
)
634 size_t prefix1_len
= strcspn (name1
, "?*[");
635 size_t prefix2_len
= strcspn (name2
, "?*[");
636 size_t min_prefix_len
;
638 /* Note that if there is no wildcard character, then we treat the
639 terminating 0 as part of the prefix. Thus ".text" won't match
640 ".text." or ".text.*", for example. */
641 if (name1
[prefix1_len
] == '\0')
643 if (name2
[prefix2_len
] == '\0')
646 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
648 return memcmp (name1
, name2
, min_prefix_len
) == 0;
651 /* Select specialized code to handle various kinds of wildcard
655 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
658 int wild_name_count
= 0;
659 struct wildcard_list
*sec
;
663 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
664 ptr
->handler_data
[0] = NULL
;
665 ptr
->handler_data
[1] = NULL
;
666 ptr
->handler_data
[2] = NULL
;
667 ptr
->handler_data
[3] = NULL
;
670 /* Count how many wildcard_specs there are, and how many of those
671 actually use wildcards in the name. Also, bail out if any of the
672 wildcard names are NULL. (Can this actually happen?
673 walk_wild_section used to test for it.) And bail out if any
674 of the wildcards are more complex than a simple string
675 ending in a single '*'. */
676 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
679 if (sec
->spec
.name
== NULL
)
681 if (wildcardp (sec
->spec
.name
))
684 if (!is_simple_wild (sec
->spec
.name
))
689 /* The zero-spec case would be easy to optimize but it doesn't
690 happen in practice. Likewise, more than 4 specs doesn't
691 happen in practice. */
692 if (sec_count
== 0 || sec_count
> 4)
695 /* Check that no two specs can match the same section. */
696 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
698 struct wildcard_list
*sec2
;
699 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
701 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
706 signature
= (sec_count
<< 8) + wild_name_count
;
710 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
713 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
716 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
719 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
722 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
728 /* Now fill the data array with pointers to the specs, first the
729 specs with non-wildcard names, then the specs with wildcard
730 names. It's OK to process the specs in different order from the
731 given order, because we've already determined that no section
732 will match more than one spec. */
734 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
735 if (!wildcardp (sec
->spec
.name
))
736 ptr
->handler_data
[data_counter
++] = sec
;
737 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
738 if (wildcardp (sec
->spec
.name
))
739 ptr
->handler_data
[data_counter
++] = sec
;
742 /* Handle a wild statement for a single file F. */
745 walk_wild_file (lang_wild_statement_type
*s
,
746 lang_input_statement_type
*f
,
750 if (f
->the_bfd
== NULL
751 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
752 walk_wild_section (s
, f
, callback
, data
);
757 /* This is an archive file. We must map each member of the
758 archive separately. */
759 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
760 while (member
!= NULL
)
762 /* When lookup_name is called, it will call the add_symbols
763 entry point for the archive. For each element of the
764 archive which is included, BFD will call ldlang_add_file,
765 which will set the usrdata field of the member to the
766 lang_input_statement. */
767 if (member
->usrdata
!= NULL
)
769 walk_wild_section (s
, member
->usrdata
, callback
, data
);
772 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
778 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
780 const char *file_spec
= s
->filename
;
782 if (file_spec
== NULL
)
784 /* Perform the iteration over all files in the list. */
785 LANG_FOR_EACH_INPUT_STATEMENT (f
)
787 walk_wild_file (s
, f
, callback
, data
);
790 else if (wildcardp (file_spec
))
792 LANG_FOR_EACH_INPUT_STATEMENT (f
)
794 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
795 walk_wild_file (s
, f
, callback
, data
);
800 lang_input_statement_type
*f
;
802 /* Perform the iteration over a single file. */
803 f
= lookup_name (file_spec
);
805 walk_wild_file (s
, f
, callback
, data
);
809 /* lang_for_each_statement walks the parse tree and calls the provided
810 function for each node. */
813 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
814 lang_statement_union_type
*s
)
816 for (; s
!= NULL
; s
= s
->header
.next
)
820 switch (s
->header
.type
)
822 case lang_constructors_statement_enum
:
823 lang_for_each_statement_worker (func
, constructor_list
.head
);
825 case lang_output_section_statement_enum
:
826 lang_for_each_statement_worker
827 (func
, s
->output_section_statement
.children
.head
);
829 case lang_wild_statement_enum
:
830 lang_for_each_statement_worker (func
,
831 s
->wild_statement
.children
.head
);
833 case lang_group_statement_enum
:
834 lang_for_each_statement_worker (func
,
835 s
->group_statement
.children
.head
);
837 case lang_data_statement_enum
:
838 case lang_reloc_statement_enum
:
839 case lang_object_symbols_statement_enum
:
840 case lang_output_statement_enum
:
841 case lang_target_statement_enum
:
842 case lang_input_section_enum
:
843 case lang_input_statement_enum
:
844 case lang_assignment_statement_enum
:
845 case lang_padding_statement_enum
:
846 case lang_address_statement_enum
:
847 case lang_fill_statement_enum
:
857 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
859 lang_for_each_statement_worker (func
, statement_list
.head
);
862 /*----------------------------------------------------------------------*/
865 lang_list_init (lang_statement_list_type
*list
)
868 list
->tail
= &list
->head
;
871 /* Build a new statement node for the parse tree. */
873 static lang_statement_union_type
*
874 new_statement (enum statement_enum type
,
876 lang_statement_list_type
*list
)
878 lang_statement_union_type
*new;
880 new = stat_alloc (size
);
881 new->header
.type
= type
;
882 new->header
.next
= NULL
;
883 lang_statement_append (list
, new, &new->header
.next
);
887 /* Build a new input file node for the language. There are several
888 ways in which we treat an input file, eg, we only look at symbols,
889 or prefix it with a -l etc.
891 We can be supplied with requests for input files more than once;
892 they may, for example be split over several lines like foo.o(.text)
893 foo.o(.data) etc, so when asked for a file we check that we haven't
894 got it already so we don't duplicate the bfd. */
896 static lang_input_statement_type
*
897 new_afile (const char *name
,
898 lang_input_file_enum_type file_type
,
900 bfd_boolean add_to_list
)
902 lang_input_statement_type
*p
;
905 p
= new_stat (lang_input_statement
, stat_ptr
);
908 p
= stat_alloc (sizeof (lang_input_statement_type
));
909 p
->header
.type
= lang_input_statement_enum
;
910 p
->header
.next
= NULL
;
913 lang_has_input_file
= TRUE
;
915 p
->sysrooted
= FALSE
;
918 case lang_input_file_is_symbols_only_enum
:
920 p
->is_archive
= FALSE
;
922 p
->local_sym_name
= name
;
923 p
->just_syms_flag
= TRUE
;
924 p
->search_dirs_flag
= FALSE
;
926 case lang_input_file_is_fake_enum
:
928 p
->is_archive
= FALSE
;
930 p
->local_sym_name
= name
;
931 p
->just_syms_flag
= FALSE
;
932 p
->search_dirs_flag
= FALSE
;
934 case lang_input_file_is_l_enum
:
935 p
->is_archive
= TRUE
;
938 p
->local_sym_name
= concat ("-l", name
, NULL
);
939 p
->just_syms_flag
= FALSE
;
940 p
->search_dirs_flag
= TRUE
;
942 case lang_input_file_is_marker_enum
:
944 p
->is_archive
= FALSE
;
946 p
->local_sym_name
= name
;
947 p
->just_syms_flag
= FALSE
;
948 p
->search_dirs_flag
= TRUE
;
950 case lang_input_file_is_search_file_enum
:
951 p
->sysrooted
= ldlang_sysrooted_script
;
953 p
->is_archive
= FALSE
;
955 p
->local_sym_name
= name
;
956 p
->just_syms_flag
= FALSE
;
957 p
->search_dirs_flag
= TRUE
;
959 case lang_input_file_is_file_enum
:
961 p
->is_archive
= FALSE
;
963 p
->local_sym_name
= name
;
964 p
->just_syms_flag
= FALSE
;
965 p
->search_dirs_flag
= FALSE
;
972 p
->next_real_file
= NULL
;
975 p
->dynamic
= config
.dynamic_link
;
976 p
->add_needed
= add_needed
;
977 p
->as_needed
= as_needed
;
978 p
->whole_archive
= whole_archive
;
980 lang_statement_append (&input_file_chain
,
981 (lang_statement_union_type
*) p
,
986 lang_input_statement_type
*
987 lang_add_input_file (const char *name
,
988 lang_input_file_enum_type file_type
,
991 return new_afile (name
, file_type
, target
, TRUE
);
994 struct out_section_hash_entry
996 struct bfd_hash_entry root
;
997 lang_statement_union_type s
;
1000 /* The hash table. */
1002 static struct bfd_hash_table output_section_statement_table
;
1004 /* Support routines for the hash table used by lang_output_section_find,
1005 initialize the table, fill in an entry and remove the table. */
1007 static struct bfd_hash_entry
*
1008 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1009 struct bfd_hash_table
*table
,
1012 lang_output_section_statement_type
**nextp
;
1013 struct out_section_hash_entry
*ret
;
1017 entry
= bfd_hash_allocate (table
, sizeof (*ret
));
1022 entry
= bfd_hash_newfunc (entry
, table
, string
);
1026 ret
= (struct out_section_hash_entry
*) entry
;
1027 memset (&ret
->s
, 0, sizeof (ret
->s
));
1028 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1029 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1030 ret
->s
.output_section_statement
.section_alignment
= -1;
1031 ret
->s
.output_section_statement
.block_value
= 1;
1032 lang_list_init (&ret
->s
.output_section_statement
.children
);
1033 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1035 /* For every output section statement added to the list, except the
1036 first one, lang_output_section_statement.tail points to the "next"
1037 field of the last element of the list. */
1038 if (lang_output_section_statement
.head
!= NULL
)
1039 ret
->s
.output_section_statement
.prev
1040 = ((lang_output_section_statement_type
*)
1041 ((char *) lang_output_section_statement
.tail
1042 - offsetof (lang_output_section_statement_type
, next
)));
1044 /* GCC's strict aliasing rules prevent us from just casting the
1045 address, so we store the pointer in a variable and cast that
1047 nextp
= &ret
->s
.output_section_statement
.next
;
1048 lang_statement_append (&lang_output_section_statement
,
1050 (lang_statement_union_type
**) nextp
);
1055 output_section_statement_table_init (void)
1057 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1058 output_section_statement_newfunc
,
1059 sizeof (struct out_section_hash_entry
),
1061 einfo (_("%P%F: can not create hash table: %E\n"));
1065 output_section_statement_table_free (void)
1067 bfd_hash_table_free (&output_section_statement_table
);
1070 /* Build enough state so that the parser can build its tree. */
1075 obstack_begin (&stat_obstack
, 1000);
1077 stat_ptr
= &statement_list
;
1079 output_section_statement_table_init ();
1081 lang_list_init (stat_ptr
);
1083 lang_list_init (&input_file_chain
);
1084 lang_list_init (&lang_output_section_statement
);
1085 lang_list_init (&file_chain
);
1086 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1088 abs_output_section
=
1089 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
1091 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1093 /* The value "3" is ad-hoc, somewhat related to the expected number of
1094 DEFINED expressions in a linker script. For most default linker
1095 scripts, there are none. Why a hash table then? Well, it's somewhat
1096 simpler to re-use working machinery than using a linked list in terms
1097 of code-complexity here in ld, besides the initialization which just
1098 looks like other code here. */
1099 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1100 lang_definedness_newfunc
,
1101 sizeof (struct lang_definedness_hash_entry
),
1103 einfo (_("%P%F: can not create hash table: %E\n"));
1109 output_section_statement_table_free ();
1112 /*----------------------------------------------------------------------
1113 A region is an area of memory declared with the
1114 MEMORY { name:org=exp, len=exp ... }
1117 We maintain a list of all the regions here.
1119 If no regions are specified in the script, then the default is used
1120 which is created when looked up to be the entire data space.
1122 If create is true we are creating a region inside a MEMORY block.
1123 In this case it is probably an error to create a region that has
1124 already been created. If we are not inside a MEMORY block it is
1125 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1126 and so we issue a warning. */
1128 static lang_memory_region_type
*lang_memory_region_list
;
1129 static lang_memory_region_type
**lang_memory_region_list_tail
1130 = &lang_memory_region_list
;
1132 lang_memory_region_type
*
1133 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1135 lang_memory_region_type
*p
;
1136 lang_memory_region_type
*new;
1138 /* NAME is NULL for LMA memspecs if no region was specified. */
1142 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1143 if (strcmp (p
->name
, name
) == 0)
1146 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1151 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1152 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
1154 new = stat_alloc (sizeof (lang_memory_region_type
));
1156 new->name
= xstrdup (name
);
1159 new->length
= ~(bfd_size_type
) 0;
1161 new->last_os
= NULL
;
1164 new->had_full_message
= FALSE
;
1166 *lang_memory_region_list_tail
= new;
1167 lang_memory_region_list_tail
= &new->next
;
1172 static lang_memory_region_type
*
1173 lang_memory_default (asection
*section
)
1175 lang_memory_region_type
*p
;
1177 flagword sec_flags
= section
->flags
;
1179 /* Override SEC_DATA to mean a writable section. */
1180 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1181 sec_flags
|= SEC_DATA
;
1183 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1185 if ((p
->flags
& sec_flags
) != 0
1186 && (p
->not_flags
& sec_flags
) == 0)
1191 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1194 lang_output_section_statement_type
*
1195 lang_output_section_find (const char *const name
)
1197 struct out_section_hash_entry
*entry
;
1200 entry
= ((struct out_section_hash_entry
*)
1201 bfd_hash_lookup (&output_section_statement_table
, name
,
1206 hash
= entry
->root
.hash
;
1209 if (entry
->s
.output_section_statement
.constraint
!= -1)
1210 return &entry
->s
.output_section_statement
;
1211 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1213 while (entry
!= NULL
1214 && entry
->root
.hash
== hash
1215 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1220 static lang_output_section_statement_type
*
1221 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
1223 struct out_section_hash_entry
*entry
;
1224 struct out_section_hash_entry
*last_ent
;
1227 entry
= ((struct out_section_hash_entry
*)
1228 bfd_hash_lookup (&output_section_statement_table
, name
,
1232 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1236 if (entry
->s
.output_section_statement
.name
!= NULL
)
1238 /* We have a section of this name, but it might not have the correct
1240 hash
= entry
->root
.hash
;
1243 if (entry
->s
.output_section_statement
.constraint
!= -1
1245 || (constraint
== entry
->s
.output_section_statement
.constraint
1246 && constraint
!= SPECIAL
)))
1247 return &entry
->s
.output_section_statement
;
1249 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1251 while (entry
!= NULL
1252 && entry
->root
.hash
== hash
1253 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1256 = ((struct out_section_hash_entry
*)
1257 output_section_statement_newfunc (NULL
,
1258 &output_section_statement_table
,
1262 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1265 entry
->root
= last_ent
->root
;
1266 last_ent
->root
.next
= &entry
->root
;
1269 entry
->s
.output_section_statement
.name
= name
;
1270 entry
->s
.output_section_statement
.constraint
= constraint
;
1271 return &entry
->s
.output_section_statement
;
1274 lang_output_section_statement_type
*
1275 lang_output_section_statement_lookup (const char *const name
)
1277 return lang_output_section_statement_lookup_1 (name
, 0);
1280 /* A variant of lang_output_section_find used by place_orphan.
1281 Returns the output statement that should precede a new output
1282 statement for SEC. If an exact match is found on certain flags,
1285 lang_output_section_statement_type
*
1286 lang_output_section_find_by_flags (const asection
*sec
,
1287 lang_output_section_statement_type
**exact
,
1288 lang_match_sec_type_func match_type
)
1290 lang_output_section_statement_type
*first
, *look
, *found
;
1293 /* We know the first statement on this list is *ABS*. May as well
1295 first
= &lang_output_section_statement
.head
->output_section_statement
;
1296 first
= first
->next
;
1298 /* First try for an exact match. */
1300 for (look
= first
; look
; look
= look
->next
)
1302 flags
= look
->flags
;
1303 if (look
->bfd_section
!= NULL
)
1305 flags
= look
->bfd_section
->flags
;
1306 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1310 flags
^= sec
->flags
;
1311 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1312 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1322 if (sec
->flags
& SEC_CODE
)
1324 /* Try for a rw code section. */
1325 for (look
= first
; look
; look
= look
->next
)
1327 flags
= look
->flags
;
1328 if (look
->bfd_section
!= NULL
)
1330 flags
= look
->bfd_section
->flags
;
1331 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1335 flags
^= sec
->flags
;
1336 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1337 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1341 else if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
1343 /* .rodata can go after .text, .sdata2 after .rodata. */
1344 for (look
= first
; look
; look
= look
->next
)
1346 flags
= look
->flags
;
1347 if (look
->bfd_section
!= NULL
)
1349 flags
= look
->bfd_section
->flags
;
1350 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1354 flags
^= sec
->flags
;
1355 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1357 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1361 else if (sec
->flags
& SEC_SMALL_DATA
)
1363 /* .sdata goes after .data, .sbss after .sdata. */
1364 for (look
= first
; look
; look
= look
->next
)
1366 flags
= look
->flags
;
1367 if (look
->bfd_section
!= NULL
)
1369 flags
= look
->bfd_section
->flags
;
1370 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1374 flags
^= sec
->flags
;
1375 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1376 | SEC_THREAD_LOCAL
))
1377 || ((look
->flags
& SEC_SMALL_DATA
)
1378 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1382 else if (sec
->flags
& SEC_HAS_CONTENTS
)
1384 /* .data goes after .rodata. */
1385 for (look
= first
; look
; look
= look
->next
)
1387 flags
= look
->flags
;
1388 if (look
->bfd_section
!= NULL
)
1390 flags
= look
->bfd_section
->flags
;
1391 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1395 flags
^= sec
->flags
;
1396 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1397 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1403 /* .bss goes last. */
1404 for (look
= first
; look
; look
= look
->next
)
1406 flags
= look
->flags
;
1407 if (look
->bfd_section
!= NULL
)
1409 flags
= look
->bfd_section
->flags
;
1410 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1414 flags
^= sec
->flags
;
1415 if (!(flags
& SEC_ALLOC
))
1420 if (found
|| !match_type
)
1423 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1426 /* Find the last output section before given output statement.
1427 Used by place_orphan. */
1430 output_prev_sec_find (lang_output_section_statement_type
*os
)
1432 lang_output_section_statement_type
*lookup
;
1434 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1436 if (lookup
->constraint
== -1)
1439 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1440 return lookup
->bfd_section
;
1446 lang_output_section_statement_type
*
1447 lang_insert_orphan (asection
*s
,
1448 const char *secname
,
1449 lang_output_section_statement_type
*after
,
1450 struct orphan_save
*place
,
1451 etree_type
*address
,
1452 lang_statement_list_type
*add_child
)
1454 lang_statement_list_type
*old
;
1455 lang_statement_list_type add
;
1457 lang_output_section_statement_type
*os
;
1458 lang_output_section_statement_type
**os_tail
;
1460 /* Start building a list of statements for this section.
1461 First save the current statement pointer. */
1464 /* If we have found an appropriate place for the output section
1465 statements for this orphan, add them to our own private list,
1466 inserting them later into the global statement list. */
1470 lang_list_init (stat_ptr
);
1474 if (config
.build_constructors
)
1476 /* If the name of the section is representable in C, then create
1477 symbols to mark the start and the end of the section. */
1478 for (ps
= secname
; *ps
!= '\0'; ps
++)
1479 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1484 etree_type
*e_align
;
1486 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1487 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1488 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1489 e_align
= exp_unop (ALIGN_K
,
1490 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1491 lang_add_assignment (exp_assop ('=', ".", e_align
));
1492 lang_add_assignment (exp_provide (symname
,
1493 exp_nameop (NAME
, "."),
1498 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1499 address
= exp_intop (0);
1501 os_tail
= ((lang_output_section_statement_type
**)
1502 lang_output_section_statement
.tail
);
1503 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
1506 if (add_child
== NULL
)
1507 add_child
= &os
->children
;
1508 lang_add_section (add_child
, s
, os
);
1510 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
1512 if (config
.build_constructors
&& *ps
== '\0')
1516 /* lang_leave_ouput_section_statement resets stat_ptr.
1517 Put stat_ptr back where we want it. */
1521 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1522 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1523 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1524 lang_add_assignment (exp_provide (symname
,
1525 exp_nameop (NAME
, "."),
1529 /* Restore the global list pointer. */
1533 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1535 asection
*snew
, *as
;
1537 snew
= os
->bfd_section
;
1539 /* Shuffle the bfd section list to make the output file look
1540 neater. This is really only cosmetic. */
1541 if (place
->section
== NULL
1542 && after
!= (&lang_output_section_statement
.head
1543 ->output_section_statement
))
1545 asection
*bfd_section
= after
->bfd_section
;
1547 /* If the output statement hasn't been used to place any input
1548 sections (and thus doesn't have an output bfd_section),
1549 look for the closest prior output statement having an
1551 if (bfd_section
== NULL
)
1552 bfd_section
= output_prev_sec_find (after
);
1554 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1555 place
->section
= &bfd_section
->next
;
1558 if (place
->section
== NULL
)
1559 place
->section
= &output_bfd
->sections
;
1561 as
= *place
->section
;
1565 /* Put the section at the end of the list. */
1567 /* Unlink the section. */
1568 bfd_section_list_remove (output_bfd
, snew
);
1570 /* Now tack it back on in the right place. */
1571 bfd_section_list_append (output_bfd
, snew
);
1573 else if (as
!= snew
&& as
->prev
!= snew
)
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_insert_before (output_bfd
, as
, snew
);
1582 /* Save the end of this list. Further ophans of this type will
1583 follow the one we've just added. */
1584 place
->section
= &snew
->next
;
1586 /* The following is non-cosmetic. We try to put the output
1587 statements in some sort of reasonable order here, because they
1588 determine the final load addresses of the orphan sections.
1589 In addition, placing output statements in the wrong order may
1590 require extra segments. For instance, given a typical
1591 situation of all read-only sections placed in one segment and
1592 following that a segment containing all the read-write
1593 sections, we wouldn't want to place an orphan read/write
1594 section before or amongst the read-only ones. */
1595 if (add
.head
!= NULL
)
1597 lang_output_section_statement_type
*newly_added_os
;
1599 if (place
->stmt
== NULL
)
1601 lang_statement_union_type
**where
;
1602 lang_statement_union_type
**assign
= NULL
;
1603 bfd_boolean ignore_first
;
1605 /* Look for a suitable place for the new statement list.
1606 The idea is to skip over anything that might be inside
1607 a SECTIONS {} statement in a script, before we find
1608 another output_section_statement. Assignments to "dot"
1609 before an output section statement are assumed to
1610 belong to it. An exception to this rule is made for
1611 the first assignment to dot, otherwise we might put an
1612 orphan before . = . + SIZEOF_HEADERS or similar
1613 assignments that set the initial address. */
1615 ignore_first
= after
== (&lang_output_section_statement
.head
1616 ->output_section_statement
);
1617 for (where
= &after
->header
.next
;
1619 where
= &(*where
)->header
.next
)
1621 switch ((*where
)->header
.type
)
1623 case lang_assignment_statement_enum
:
1626 lang_assignment_statement_type
*ass
;
1627 ass
= &(*where
)->assignment_statement
;
1628 if (ass
->exp
->type
.node_class
!= etree_assert
1629 && ass
->exp
->assign
.dst
[0] == '.'
1630 && ass
->exp
->assign
.dst
[1] == 0
1634 ignore_first
= FALSE
;
1636 case lang_wild_statement_enum
:
1637 case lang_input_section_enum
:
1638 case lang_object_symbols_statement_enum
:
1639 case lang_fill_statement_enum
:
1640 case lang_data_statement_enum
:
1641 case lang_reloc_statement_enum
:
1642 case lang_padding_statement_enum
:
1643 case lang_constructors_statement_enum
:
1646 case lang_output_section_statement_enum
:
1649 case lang_input_statement_enum
:
1650 case lang_address_statement_enum
:
1651 case lang_target_statement_enum
:
1652 case lang_output_statement_enum
:
1653 case lang_group_statement_enum
:
1654 case lang_afile_asection_pair_statement_enum
:
1663 place
->os_tail
= &after
->next
;
1667 /* Put it after the last orphan statement we added. */
1668 *add
.tail
= *place
->stmt
;
1669 *place
->stmt
= add
.head
;
1672 /* Fix the global list pointer if we happened to tack our
1673 new list at the tail. */
1674 if (*old
->tail
== add
.head
)
1675 old
->tail
= add
.tail
;
1677 /* Save the end of this list. */
1678 place
->stmt
= add
.tail
;
1680 /* Do the same for the list of output section statements. */
1681 newly_added_os
= *os_tail
;
1683 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1684 ((char *) place
->os_tail
1685 - offsetof (lang_output_section_statement_type
, next
));
1686 newly_added_os
->next
= *place
->os_tail
;
1687 if (newly_added_os
->next
!= NULL
)
1688 newly_added_os
->next
->prev
= newly_added_os
;
1689 *place
->os_tail
= newly_added_os
;
1690 place
->os_tail
= &newly_added_os
->next
;
1692 /* Fixing the global list pointer here is a little different.
1693 We added to the list in lang_enter_output_section_statement,
1694 trimmed off the new output_section_statment above when
1695 assigning *os_tail = NULL, but possibly added it back in
1696 the same place when assigning *place->os_tail. */
1697 if (*os_tail
== NULL
)
1698 lang_output_section_statement
.tail
1699 = (lang_statement_union_type
**) os_tail
;
1706 lang_map_flags (flagword flag
)
1708 if (flag
& SEC_ALLOC
)
1711 if (flag
& SEC_CODE
)
1714 if (flag
& SEC_READONLY
)
1717 if (flag
& SEC_DATA
)
1720 if (flag
& SEC_LOAD
)
1727 lang_memory_region_type
*m
;
1728 bfd_boolean dis_header_printed
= FALSE
;
1731 LANG_FOR_EACH_INPUT_STATEMENT (file
)
1735 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
1736 || file
->just_syms_flag
)
1739 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1740 if ((s
->output_section
== NULL
1741 || s
->output_section
->owner
!= output_bfd
)
1742 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
1744 if (! dis_header_printed
)
1746 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
1747 dis_header_printed
= TRUE
;
1750 print_input_section (s
);
1754 minfo (_("\nMemory Configuration\n\n"));
1755 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1756 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1758 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1763 fprintf (config
.map_file
, "%-16s ", m
->name
);
1765 sprintf_vma (buf
, m
->origin
);
1766 minfo ("0x%s ", buf
);
1774 minfo ("0x%V", m
->length
);
1775 if (m
->flags
|| m
->not_flags
)
1783 lang_map_flags (m
->flags
);
1789 lang_map_flags (m
->not_flags
);
1796 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1798 if (! link_info
.reduce_memory_overheads
)
1800 obstack_begin (&map_obstack
, 1000);
1801 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1802 bfd_map_over_sections (p
, init_map_userdata
, 0);
1803 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1805 print_statements ();
1809 init_map_userdata (abfd
, sec
, data
)
1810 bfd
*abfd ATTRIBUTE_UNUSED
;
1812 void *data ATTRIBUTE_UNUSED
;
1814 fat_section_userdata_type
*new_data
1815 = ((fat_section_userdata_type
*) (stat_alloc
1816 (sizeof (fat_section_userdata_type
))));
1818 ASSERT (get_userdata (sec
) == NULL
);
1819 get_userdata (sec
) = new_data
;
1820 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1824 sort_def_symbol (hash_entry
, info
)
1825 struct bfd_link_hash_entry
*hash_entry
;
1826 void *info ATTRIBUTE_UNUSED
;
1828 if (hash_entry
->type
== bfd_link_hash_defined
1829 || hash_entry
->type
== bfd_link_hash_defweak
)
1831 struct fat_user_section_struct
*ud
;
1832 struct map_symbol_def
*def
;
1834 ud
= get_userdata (hash_entry
->u
.def
.section
);
1837 /* ??? What do we have to do to initialize this beforehand? */
1838 /* The first time we get here is bfd_abs_section... */
1839 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1840 ud
= get_userdata (hash_entry
->u
.def
.section
);
1842 else if (!ud
->map_symbol_def_tail
)
1843 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1845 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1846 def
->entry
= hash_entry
;
1847 *(ud
->map_symbol_def_tail
) = def
;
1848 ud
->map_symbol_def_tail
= &def
->next
;
1853 /* Initialize an output section. */
1856 init_os (lang_output_section_statement_type
*s
, asection
*isec
,
1859 if (s
->bfd_section
!= NULL
)
1862 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1863 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1865 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
1866 if (s
->bfd_section
== NULL
)
1867 s
->bfd_section
= bfd_make_section_with_flags (output_bfd
, s
->name
,
1869 if (s
->bfd_section
== NULL
)
1871 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1872 output_bfd
->xvec
->name
, s
->name
);
1874 s
->bfd_section
->output_section
= s
->bfd_section
;
1875 s
->bfd_section
->output_offset
= 0;
1877 if (!link_info
.reduce_memory_overheads
)
1879 fat_section_userdata_type
*new
1880 = stat_alloc (sizeof (fat_section_userdata_type
));
1881 memset (new, 0, sizeof (fat_section_userdata_type
));
1882 get_userdata (s
->bfd_section
) = new;
1885 /* If there is a base address, make sure that any sections it might
1886 mention are initialized. */
1887 if (s
->addr_tree
!= NULL
)
1888 exp_init_os (s
->addr_tree
);
1890 if (s
->load_base
!= NULL
)
1891 exp_init_os (s
->load_base
);
1893 /* If supplied an alignment, set it. */
1894 if (s
->section_alignment
!= -1)
1895 s
->bfd_section
->alignment_power
= s
->section_alignment
;
1898 bfd_init_private_section_data (isec
->owner
, isec
,
1899 output_bfd
, s
->bfd_section
,
1903 /* Make sure that all output sections mentioned in an expression are
1907 exp_init_os (etree_type
*exp
)
1909 switch (exp
->type
.node_class
)
1913 exp_init_os (exp
->assign
.src
);
1917 exp_init_os (exp
->binary
.lhs
);
1918 exp_init_os (exp
->binary
.rhs
);
1922 exp_init_os (exp
->trinary
.cond
);
1923 exp_init_os (exp
->trinary
.lhs
);
1924 exp_init_os (exp
->trinary
.rhs
);
1928 exp_init_os (exp
->assert_s
.child
);
1932 exp_init_os (exp
->unary
.child
);
1936 switch (exp
->type
.node_code
)
1942 lang_output_section_statement_type
*os
;
1944 os
= lang_output_section_find (exp
->name
.name
);
1945 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1946 init_os (os
, NULL
, 0);
1957 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
1959 lang_input_statement_type
*entry
= data
;
1961 /* If we are only reading symbols from this object, then we want to
1962 discard all sections. */
1963 if (entry
->just_syms_flag
)
1965 bfd_link_just_syms (abfd
, sec
, &link_info
);
1969 if (!(abfd
->flags
& DYNAMIC
))
1970 bfd_section_already_linked (abfd
, sec
, &link_info
);
1973 /* The wild routines.
1975 These expand statements like *(.text) and foo.o to a list of
1976 explicit actions, like foo.o(.text), bar.o(.text) and
1977 foo.o(.text, .data). */
1979 /* Add SECTION to the output section OUTPUT. Do this by creating a
1980 lang_input_section statement which is placed at PTR. FILE is the
1981 input file which holds SECTION. */
1984 lang_add_section (lang_statement_list_type
*ptr
,
1986 lang_output_section_statement_type
*output
)
1988 flagword flags
= section
->flags
;
1989 bfd_boolean discard
;
1991 /* Discard sections marked with SEC_EXCLUDE. */
1992 discard
= (flags
& SEC_EXCLUDE
) != 0;
1994 /* Discard input sections which are assigned to a section named
1995 DISCARD_SECTION_NAME. */
1996 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1999 /* Discard debugging sections if we are stripping debugging
2001 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2002 && (flags
& SEC_DEBUGGING
) != 0)
2007 if (section
->output_section
== NULL
)
2009 /* This prevents future calls from assigning this section. */
2010 section
->output_section
= bfd_abs_section_ptr
;
2015 if (section
->output_section
== NULL
)
2018 lang_input_section_type
*new;
2021 flags
= section
->flags
;
2023 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2024 to an output section, because we want to be able to include a
2025 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2026 section (I don't know why we want to do this, but we do).
2027 build_link_order in ldwrite.c handles this case by turning
2028 the embedded SEC_NEVER_LOAD section into a fill. */
2030 flags
&= ~ SEC_NEVER_LOAD
;
2032 switch (output
->sectype
)
2034 case normal_section
:
2036 case noalloc_section
:
2037 flags
&= ~SEC_ALLOC
;
2039 case noload_section
:
2041 flags
|= SEC_NEVER_LOAD
;
2045 if (output
->bfd_section
== NULL
)
2046 init_os (output
, section
, flags
);
2048 first
= ! output
->bfd_section
->linker_has_input
;
2049 output
->bfd_section
->linker_has_input
= 1;
2051 if (!link_info
.relocatable
2052 && !stripped_excluded_sections
)
2054 asection
*s
= output
->bfd_section
->map_tail
.s
;
2055 output
->bfd_section
->map_tail
.s
= section
;
2056 section
->map_head
.s
= NULL
;
2057 section
->map_tail
.s
= s
;
2059 s
->map_head
.s
= section
;
2061 output
->bfd_section
->map_head
.s
= section
;
2064 /* Add a section reference to the list. */
2065 new = new_stat (lang_input_section
, ptr
);
2067 new->section
= section
;
2068 section
->output_section
= output
->bfd_section
;
2070 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2071 already been processed. One reason to do this is that on pe
2072 format targets, .text$foo sections go into .text and it's odd
2073 to see .text with SEC_LINK_ONCE set. */
2075 if (! link_info
.relocatable
)
2076 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
2078 /* If this is not the first input section, and the SEC_READONLY
2079 flag is not currently set, then don't set it just because the
2080 input section has it set. */
2082 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
2083 flags
&= ~ SEC_READONLY
;
2085 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2087 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2088 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2089 || ((flags
& SEC_MERGE
)
2090 && output
->bfd_section
->entsize
!= section
->entsize
)))
2092 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2093 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2096 output
->bfd_section
->flags
|= flags
;
2098 if (flags
& SEC_MERGE
)
2099 output
->bfd_section
->entsize
= section
->entsize
;
2101 /* If SEC_READONLY is not set in the input section, then clear
2102 it from the output section. */
2103 if ((section
->flags
& SEC_READONLY
) == 0)
2104 output
->bfd_section
->flags
&= ~SEC_READONLY
;
2106 /* Copy over SEC_SMALL_DATA. */
2107 if (section
->flags
& SEC_SMALL_DATA
)
2108 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2110 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2111 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2113 if (bfd_get_arch (section
->owner
) == bfd_arch_tic54x
2114 && (section
->flags
& SEC_TIC54X_BLOCK
) != 0)
2116 output
->bfd_section
->flags
|= SEC_TIC54X_BLOCK
;
2117 /* FIXME: This value should really be obtained from the bfd... */
2118 output
->block_value
= 128;
2123 /* Handle wildcard sorting. This returns the lang_input_section which
2124 should follow the one we are going to create for SECTION and FILE,
2125 based on the sorting requirements of WILD. It returns NULL if the
2126 new section should just go at the end of the current list. */
2128 static lang_statement_union_type
*
2129 wild_sort (lang_wild_statement_type
*wild
,
2130 struct wildcard_list
*sec
,
2131 lang_input_statement_type
*file
,
2134 const char *section_name
;
2135 lang_statement_union_type
*l
;
2137 if (!wild
->filenames_sorted
2138 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2141 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
2142 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2144 lang_input_section_type
*ls
;
2146 if (l
->header
.type
!= lang_input_section_enum
)
2148 ls
= &l
->input_section
;
2150 /* Sorting by filename takes precedence over sorting by section
2153 if (wild
->filenames_sorted
)
2155 const char *fn
, *ln
;
2159 /* The PE support for the .idata section as generated by
2160 dlltool assumes that files will be sorted by the name of
2161 the archive and then the name of the file within the
2164 if (file
->the_bfd
!= NULL
2165 && bfd_my_archive (file
->the_bfd
) != NULL
)
2167 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2172 fn
= file
->filename
;
2176 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2178 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2183 ln
= ls
->section
->owner
->filename
;
2187 i
= strcmp (fn
, ln
);
2196 fn
= file
->filename
;
2198 ln
= ls
->section
->owner
->filename
;
2200 i
= strcmp (fn
, ln
);
2208 /* Here either the files are not sorted by name, or we are
2209 looking at the sections for this file. */
2211 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2212 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2219 /* Expand a wild statement for a particular FILE. SECTION may be
2220 NULL, in which case it is a wild card. */
2223 output_section_callback (lang_wild_statement_type
*ptr
,
2224 struct wildcard_list
*sec
,
2226 lang_input_statement_type
*file
,
2229 lang_statement_union_type
*before
;
2231 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2232 if (unique_section_p (section
))
2235 before
= wild_sort (ptr
, sec
, file
, section
);
2237 /* Here BEFORE points to the lang_input_section which
2238 should follow the one we are about to add. If BEFORE
2239 is NULL, then the section should just go at the end
2240 of the current list. */
2243 lang_add_section (&ptr
->children
, section
,
2244 (lang_output_section_statement_type
*) output
);
2247 lang_statement_list_type list
;
2248 lang_statement_union_type
**pp
;
2250 lang_list_init (&list
);
2251 lang_add_section (&list
, section
,
2252 (lang_output_section_statement_type
*) output
);
2254 /* If we are discarding the section, LIST.HEAD will
2256 if (list
.head
!= NULL
)
2258 ASSERT (list
.head
->header
.next
== NULL
);
2260 for (pp
= &ptr
->children
.head
;
2262 pp
= &(*pp
)->header
.next
)
2263 ASSERT (*pp
!= NULL
);
2265 list
.head
->header
.next
= *pp
;
2271 /* Check if all sections in a wild statement for a particular FILE
2275 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2276 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2278 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2281 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2282 if (unique_section_p (section
))
2285 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2286 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
2289 /* This is passed a file name which must have been seen already and
2290 added to the statement tree. We will see if it has been opened
2291 already and had its symbols read. If not then we'll read it. */
2293 static lang_input_statement_type
*
2294 lookup_name (const char *name
)
2296 lang_input_statement_type
*search
;
2298 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2300 search
= (lang_input_statement_type
*) search
->next_real_file
)
2302 /* Use the local_sym_name as the name of the file that has
2303 already been loaded as filename might have been transformed
2304 via the search directory lookup mechanism. */
2305 const char *filename
= search
->local_sym_name
;
2307 if (filename
!= NULL
2308 && strcmp (filename
, name
) == 0)
2313 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2314 default_target
, FALSE
);
2316 /* If we have already added this file, or this file is not real
2317 don't add this file. */
2318 if (search
->loaded
|| !search
->real
)
2321 if (! load_symbols (search
, NULL
))
2327 /* Save LIST as a list of libraries whose symbols should not be exported. */
2332 struct excluded_lib
*next
;
2334 static struct excluded_lib
*excluded_libs
;
2337 add_excluded_libs (const char *list
)
2339 const char *p
= list
, *end
;
2343 struct excluded_lib
*entry
;
2344 end
= strpbrk (p
, ",:");
2346 end
= p
+ strlen (p
);
2347 entry
= xmalloc (sizeof (*entry
));
2348 entry
->next
= excluded_libs
;
2349 entry
->name
= xmalloc (end
- p
+ 1);
2350 memcpy (entry
->name
, p
, end
- p
);
2351 entry
->name
[end
- p
] = '\0';
2352 excluded_libs
= entry
;
2360 check_excluded_libs (bfd
*abfd
)
2362 struct excluded_lib
*lib
= excluded_libs
;
2366 int len
= strlen (lib
->name
);
2367 const char *filename
= lbasename (abfd
->filename
);
2369 if (strcmp (lib
->name
, "ALL") == 0)
2371 abfd
->no_export
= TRUE
;
2375 if (strncmp (lib
->name
, filename
, len
) == 0
2376 && (filename
[len
] == '\0'
2377 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2378 && filename
[len
+ 2] == '\0')))
2380 abfd
->no_export
= TRUE
;
2388 /* Get the symbols for an input file. */
2391 load_symbols (lang_input_statement_type
*entry
,
2392 lang_statement_list_type
*place
)
2399 ldfile_open_file (entry
);
2401 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2402 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2405 lang_statement_list_type
*hold
;
2406 bfd_boolean bad_load
= TRUE
;
2407 bfd_boolean save_ldlang_sysrooted_script
;
2408 bfd_boolean save_as_needed
, save_add_needed
;
2410 err
= bfd_get_error ();
2412 /* See if the emulation has some special knowledge. */
2413 if (ldemul_unrecognized_file (entry
))
2416 if (err
== bfd_error_file_ambiguously_recognized
)
2420 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2421 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2422 for (p
= matching
; *p
!= NULL
; p
++)
2426 else if (err
!= bfd_error_file_not_recognized
2428 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2432 bfd_close (entry
->the_bfd
);
2433 entry
->the_bfd
= NULL
;
2435 /* Try to interpret the file as a linker script. */
2436 ldfile_open_command_file (entry
->filename
);
2440 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2441 ldlang_sysrooted_script
= entry
->sysrooted
;
2442 save_as_needed
= as_needed
;
2443 as_needed
= entry
->as_needed
;
2444 save_add_needed
= add_needed
;
2445 add_needed
= entry
->add_needed
;
2447 ldfile_assumed_script
= TRUE
;
2448 parser_input
= input_script
;
2449 /* We want to use the same -Bdynamic/-Bstatic as the one for
2451 config
.dynamic_link
= entry
->dynamic
;
2453 ldfile_assumed_script
= FALSE
;
2455 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2456 as_needed
= save_as_needed
;
2457 add_needed
= save_add_needed
;
2463 if (ldemul_recognized_file (entry
))
2466 /* We don't call ldlang_add_file for an archive. Instead, the
2467 add_symbols entry point will call ldlang_add_file, via the
2468 add_archive_element callback, for each element of the archive
2470 switch (bfd_get_format (entry
->the_bfd
))
2476 ldlang_add_file (entry
);
2477 if (trace_files
|| trace_file_tries
)
2478 info_msg ("%I\n", entry
);
2482 check_excluded_libs (entry
->the_bfd
);
2484 if (entry
->whole_archive
)
2487 bfd_boolean loaded
= TRUE
;
2491 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2496 if (! bfd_check_format (member
, bfd_object
))
2498 einfo (_("%F%B: member %B in archive is not an object\n"),
2499 entry
->the_bfd
, member
);
2503 if (! ((*link_info
.callbacks
->add_archive_element
)
2504 (&link_info
, member
, "--whole-archive")))
2507 if (! bfd_link_add_symbols (member
, &link_info
))
2509 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2514 entry
->loaded
= loaded
;
2520 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2521 entry
->loaded
= TRUE
;
2523 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2525 return entry
->loaded
;
2528 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2529 may be NULL, indicating that it is a wildcard. Separate
2530 lang_input_section statements are created for each part of the
2531 expansion; they are added after the wild statement S. OUTPUT is
2532 the output section. */
2535 wild (lang_wild_statement_type
*s
,
2536 const char *target ATTRIBUTE_UNUSED
,
2537 lang_output_section_statement_type
*output
)
2539 struct wildcard_list
*sec
;
2541 if (s
->handler_data
[0]
2542 && s
->handler_data
[0]->spec
.sorted
== by_name
2543 && !s
->filenames_sorted
)
2545 lang_section_bst_type
*tree
;
2547 walk_wild (s
, output_section_callback_fast
, output
);
2552 output_section_callback_tree_to_list (s
, tree
, output
);
2557 walk_wild (s
, output_section_callback
, output
);
2559 if (default_common_section
== NULL
)
2560 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2561 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2563 /* Remember the section that common is going to in case we
2564 later get something which doesn't know where to put it. */
2565 default_common_section
= output
;
2570 /* Return TRUE iff target is the sought target. */
2573 get_target (const bfd_target
*target
, void *data
)
2575 const char *sought
= data
;
2577 return strcmp (target
->name
, sought
) == 0;
2580 /* Like strcpy() but convert to lower case as well. */
2583 stricpy (char *dest
, char *src
)
2587 while ((c
= *src
++) != 0)
2588 *dest
++ = TOLOWER (c
);
2593 /* Remove the first occurrence of needle (if any) in haystack
2597 strcut (char *haystack
, char *needle
)
2599 haystack
= strstr (haystack
, needle
);
2605 for (src
= haystack
+ strlen (needle
); *src
;)
2606 *haystack
++ = *src
++;
2612 /* Compare two target format name strings.
2613 Return a value indicating how "similar" they are. */
2616 name_compare (char *first
, char *second
)
2622 copy1
= xmalloc (strlen (first
) + 1);
2623 copy2
= xmalloc (strlen (second
) + 1);
2625 /* Convert the names to lower case. */
2626 stricpy (copy1
, first
);
2627 stricpy (copy2
, second
);
2629 /* Remove size and endian strings from the name. */
2630 strcut (copy1
, "big");
2631 strcut (copy1
, "little");
2632 strcut (copy2
, "big");
2633 strcut (copy2
, "little");
2635 /* Return a value based on how many characters match,
2636 starting from the beginning. If both strings are
2637 the same then return 10 * their length. */
2638 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2639 if (copy1
[result
] == 0)
2651 /* Set by closest_target_match() below. */
2652 static const bfd_target
*winner
;
2654 /* Scan all the valid bfd targets looking for one that has the endianness
2655 requirement that was specified on the command line, and is the nearest
2656 match to the original output target. */
2659 closest_target_match (const bfd_target
*target
, void *data
)
2661 const bfd_target
*original
= data
;
2663 if (command_line
.endian
== ENDIAN_BIG
2664 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2667 if (command_line
.endian
== ENDIAN_LITTLE
2668 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2671 /* Must be the same flavour. */
2672 if (target
->flavour
!= original
->flavour
)
2675 /* If we have not found a potential winner yet, then record this one. */
2682 /* Oh dear, we now have two potential candidates for a successful match.
2683 Compare their names and choose the better one. */
2684 if (name_compare (target
->name
, original
->name
)
2685 > name_compare (winner
->name
, original
->name
))
2688 /* Keep on searching until wqe have checked them all. */
2692 /* Return the BFD target format of the first input file. */
2695 get_first_input_target (void)
2697 char *target
= NULL
;
2699 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2701 if (s
->header
.type
== lang_input_statement_enum
2704 ldfile_open_file (s
);
2706 if (s
->the_bfd
!= NULL
2707 && bfd_check_format (s
->the_bfd
, bfd_object
))
2709 target
= bfd_get_target (s
->the_bfd
);
2721 lang_get_output_target (void)
2725 /* Has the user told us which output format to use? */
2726 if (output_target
!= NULL
)
2727 return output_target
;
2729 /* No - has the current target been set to something other than
2731 if (current_target
!= default_target
)
2732 return current_target
;
2734 /* No - can we determine the format of the first input file? */
2735 target
= get_first_input_target ();
2739 /* Failed - use the default output target. */
2740 return default_target
;
2743 /* Open the output file. */
2746 open_output (const char *name
)
2750 output_target
= lang_get_output_target ();
2752 /* Has the user requested a particular endianness on the command
2754 if (command_line
.endian
!= ENDIAN_UNSET
)
2756 const bfd_target
*target
;
2757 enum bfd_endian desired_endian
;
2759 /* Get the chosen target. */
2760 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2762 /* If the target is not supported, we cannot do anything. */
2765 if (command_line
.endian
== ENDIAN_BIG
)
2766 desired_endian
= BFD_ENDIAN_BIG
;
2768 desired_endian
= BFD_ENDIAN_LITTLE
;
2770 /* See if the target has the wrong endianness. This should
2771 not happen if the linker script has provided big and
2772 little endian alternatives, but some scrips don't do
2774 if (target
->byteorder
!= desired_endian
)
2776 /* If it does, then see if the target provides
2777 an alternative with the correct endianness. */
2778 if (target
->alternative_target
!= NULL
2779 && (target
->alternative_target
->byteorder
== desired_endian
))
2780 output_target
= target
->alternative_target
->name
;
2783 /* Try to find a target as similar as possible to
2784 the default target, but which has the desired
2785 endian characteristic. */
2786 bfd_search_for_target (closest_target_match
,
2789 /* Oh dear - we could not find any targets that
2790 satisfy our requirements. */
2792 einfo (_("%P: warning: could not find any targets"
2793 " that match endianness requirement\n"));
2795 output_target
= winner
->name
;
2801 output
= bfd_openw (name
, output_target
);
2805 if (bfd_get_error () == bfd_error_invalid_target
)
2806 einfo (_("%P%F: target %s not found\n"), output_target
);
2808 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2811 delete_output_file_on_failure
= TRUE
;
2813 if (! bfd_set_format (output
, bfd_object
))
2814 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2815 if (! bfd_set_arch_mach (output
,
2816 ldfile_output_architecture
,
2817 ldfile_output_machine
))
2818 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2820 link_info
.hash
= bfd_link_hash_table_create (output
);
2821 if (link_info
.hash
== NULL
)
2822 einfo (_("%P%F: can not create hash table: %E\n"));
2824 bfd_set_gp_size (output
, g_switch_value
);
2829 ldlang_open_output (lang_statement_union_type
*statement
)
2831 switch (statement
->header
.type
)
2833 case lang_output_statement_enum
:
2834 ASSERT (output_bfd
== NULL
);
2835 output_bfd
= open_output (statement
->output_statement
.name
);
2836 ldemul_set_output_arch ();
2837 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2838 output_bfd
->flags
|= D_PAGED
;
2840 output_bfd
->flags
&= ~D_PAGED
;
2841 if (config
.text_read_only
)
2842 output_bfd
->flags
|= WP_TEXT
;
2844 output_bfd
->flags
&= ~WP_TEXT
;
2845 if (link_info
.traditional_format
)
2846 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2848 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2851 case lang_target_statement_enum
:
2852 current_target
= statement
->target_statement
.target
;
2859 /* Convert between addresses in bytes and sizes in octets.
2860 For currently supported targets, octets_per_byte is always a power
2861 of two, so we can use shifts. */
2862 #define TO_ADDR(X) ((X) >> opb_shift)
2863 #define TO_SIZE(X) ((X) << opb_shift)
2865 /* Support the above. */
2866 static unsigned int opb_shift
= 0;
2871 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2872 ldfile_output_machine
);
2875 while ((x
& 1) == 0)
2883 /* Open all the input files. */
2886 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2888 for (; s
!= NULL
; s
= s
->header
.next
)
2890 switch (s
->header
.type
)
2892 case lang_constructors_statement_enum
:
2893 open_input_bfds (constructor_list
.head
, force
);
2895 case lang_output_section_statement_enum
:
2896 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2898 case lang_wild_statement_enum
:
2899 /* Maybe we should load the file's symbols. */
2900 if (s
->wild_statement
.filename
2901 && ! wildcardp (s
->wild_statement
.filename
))
2902 lookup_name (s
->wild_statement
.filename
);
2903 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2905 case lang_group_statement_enum
:
2907 struct bfd_link_hash_entry
*undefs
;
2909 /* We must continually search the entries in the group
2910 until no new symbols are added to the list of undefined
2915 undefs
= link_info
.hash
->undefs_tail
;
2916 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2918 while (undefs
!= link_info
.hash
->undefs_tail
);
2921 case lang_target_statement_enum
:
2922 current_target
= s
->target_statement
.target
;
2924 case lang_input_statement_enum
:
2925 if (s
->input_statement
.real
)
2927 lang_statement_list_type add
;
2929 s
->input_statement
.target
= current_target
;
2931 /* If we are being called from within a group, and this
2932 is an archive which has already been searched, then
2933 force it to be researched unless the whole archive
2934 has been loaded already. */
2936 && !s
->input_statement
.whole_archive
2937 && s
->input_statement
.loaded
2938 && bfd_check_format (s
->input_statement
.the_bfd
,
2940 s
->input_statement
.loaded
= FALSE
;
2942 lang_list_init (&add
);
2944 if (! load_symbols (&s
->input_statement
, &add
))
2945 config
.make_executable
= FALSE
;
2947 if (add
.head
!= NULL
)
2949 *add
.tail
= s
->header
.next
;
2950 s
->header
.next
= add
.head
;
2960 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2963 lang_track_definedness (const char *name
)
2965 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2966 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2969 /* New-function for the definedness hash table. */
2971 static struct bfd_hash_entry
*
2972 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2973 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2974 const char *name ATTRIBUTE_UNUSED
)
2976 struct lang_definedness_hash_entry
*ret
2977 = (struct lang_definedness_hash_entry
*) entry
;
2980 ret
= (struct lang_definedness_hash_entry
*)
2981 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2984 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2986 ret
->iteration
= -1;
2990 /* Return the iteration when the definition of NAME was last updated. A
2991 value of -1 means that the symbol is not defined in the linker script
2992 or the command line, but may be defined in the linker symbol table. */
2995 lang_symbol_definition_iteration (const char *name
)
2997 struct lang_definedness_hash_entry
*defentry
2998 = (struct lang_definedness_hash_entry
*)
2999 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3001 /* We've already created this one on the presence of DEFINED in the
3002 script, so it can't be NULL unless something is borked elsewhere in
3004 if (defentry
== NULL
)
3007 return defentry
->iteration
;
3010 /* Update the definedness state of NAME. */
3013 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3015 struct lang_definedness_hash_entry
*defentry
3016 = (struct lang_definedness_hash_entry
*)
3017 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3019 /* We don't keep track of symbols not tested with DEFINED. */
3020 if (defentry
== NULL
)
3023 /* If the symbol was already defined, and not from an earlier statement
3024 iteration, don't update the definedness iteration, because that'd
3025 make the symbol seem defined in the linker script at this point, and
3026 it wasn't; it was defined in some object. If we do anyway, DEFINED
3027 would start to yield false before this point and the construct "sym =
3028 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3030 if (h
->type
!= bfd_link_hash_undefined
3031 && h
->type
!= bfd_link_hash_common
3032 && h
->type
!= bfd_link_hash_new
3033 && defentry
->iteration
== -1)
3036 defentry
->iteration
= lang_statement_iteration
;
3039 /* Add the supplied name to the symbol table as an undefined reference.
3040 This is a two step process as the symbol table doesn't even exist at
3041 the time the ld command line is processed. First we put the name
3042 on a list, then, once the output file has been opened, transfer the
3043 name to the symbol table. */
3045 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3047 #define ldlang_undef_chain_list_head entry_symbol.next
3050 ldlang_add_undef (const char *const name
)
3052 ldlang_undef_chain_list_type
*new =
3053 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
3055 new->next
= ldlang_undef_chain_list_head
;
3056 ldlang_undef_chain_list_head
= new;
3058 new->name
= xstrdup (name
);
3060 if (output_bfd
!= NULL
)
3061 insert_undefined (new->name
);
3064 /* Insert NAME as undefined in the symbol table. */
3067 insert_undefined (const char *name
)
3069 struct bfd_link_hash_entry
*h
;
3071 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3073 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3074 if (h
->type
== bfd_link_hash_new
)
3076 h
->type
= bfd_link_hash_undefined
;
3077 h
->u
.undef
.abfd
= NULL
;
3078 bfd_link_add_undef (link_info
.hash
, h
);
3082 /* Run through the list of undefineds created above and place them
3083 into the linker hash table as undefined symbols belonging to the
3087 lang_place_undefineds (void)
3089 ldlang_undef_chain_list_type
*ptr
;
3091 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3092 insert_undefined (ptr
->name
);
3095 /* Check for all readonly or some readwrite sections. */
3098 check_input_sections
3099 (lang_statement_union_type
*s
,
3100 lang_output_section_statement_type
*output_section_statement
)
3102 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3104 switch (s
->header
.type
)
3106 case lang_wild_statement_enum
:
3107 walk_wild (&s
->wild_statement
, check_section_callback
,
3108 output_section_statement
);
3109 if (! output_section_statement
->all_input_readonly
)
3112 case lang_constructors_statement_enum
:
3113 check_input_sections (constructor_list
.head
,
3114 output_section_statement
);
3115 if (! output_section_statement
->all_input_readonly
)
3118 case lang_group_statement_enum
:
3119 check_input_sections (s
->group_statement
.children
.head
,
3120 output_section_statement
);
3121 if (! output_section_statement
->all_input_readonly
)
3130 /* Update wildcard statements if needed. */
3133 update_wild_statements (lang_statement_union_type
*s
)
3135 struct wildcard_list
*sec
;
3137 switch (sort_section
)
3147 for (; s
!= NULL
; s
= s
->header
.next
)
3149 switch (s
->header
.type
)
3154 case lang_wild_statement_enum
:
3155 sec
= s
->wild_statement
.section_list
;
3156 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3159 switch (sec
->spec
.sorted
)
3162 sec
->spec
.sorted
= sort_section
;
3165 if (sort_section
== by_alignment
)
3166 sec
->spec
.sorted
= by_name_alignment
;
3169 if (sort_section
== by_name
)
3170 sec
->spec
.sorted
= by_alignment_name
;
3178 case lang_constructors_statement_enum
:
3179 update_wild_statements (constructor_list
.head
);
3182 case lang_output_section_statement_enum
:
3183 update_wild_statements
3184 (s
->output_section_statement
.children
.head
);
3187 case lang_group_statement_enum
:
3188 update_wild_statements (s
->group_statement
.children
.head
);
3196 /* Open input files and attach to output sections. */
3199 map_input_to_output_sections
3200 (lang_statement_union_type
*s
, const char *target
,
3201 lang_output_section_statement_type
*os
)
3205 for (; s
!= NULL
; s
= s
->header
.next
)
3207 switch (s
->header
.type
)
3209 case lang_wild_statement_enum
:
3210 wild (&s
->wild_statement
, target
, os
);
3212 case lang_constructors_statement_enum
:
3213 map_input_to_output_sections (constructor_list
.head
,
3217 case lang_output_section_statement_enum
:
3218 if (s
->output_section_statement
.constraint
)
3220 if (s
->output_section_statement
.constraint
!= ONLY_IF_RW
3221 && s
->output_section_statement
.constraint
!= ONLY_IF_RO
)
3223 s
->output_section_statement
.all_input_readonly
= TRUE
;
3224 check_input_sections (s
->output_section_statement
.children
.head
,
3225 &s
->output_section_statement
);
3226 if ((s
->output_section_statement
.all_input_readonly
3227 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
3228 || (!s
->output_section_statement
.all_input_readonly
3229 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
3231 s
->output_section_statement
.constraint
= -1;
3236 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
3238 &s
->output_section_statement
);
3240 case lang_output_statement_enum
:
3242 case lang_target_statement_enum
:
3243 target
= s
->target_statement
.target
;
3245 case lang_group_statement_enum
:
3246 map_input_to_output_sections (s
->group_statement
.children
.head
,
3250 case lang_data_statement_enum
:
3251 /* Make sure that any sections mentioned in the expression
3253 exp_init_os (s
->data_statement
.exp
);
3254 flags
= SEC_HAS_CONTENTS
;
3255 /* The output section gets contents, and then we inspect for
3256 any flags set in the input script which override any ALLOC. */
3257 if (!(os
->flags
& SEC_NEVER_LOAD
))
3258 flags
|= SEC_ALLOC
| SEC_LOAD
;
3259 if (os
->bfd_section
== NULL
)
3260 init_os (os
, NULL
, flags
);
3262 os
->bfd_section
->flags
|= flags
;
3264 case lang_input_section_enum
:
3266 case lang_fill_statement_enum
:
3267 case lang_object_symbols_statement_enum
:
3268 case lang_reloc_statement_enum
:
3269 case lang_padding_statement_enum
:
3270 case lang_input_statement_enum
:
3271 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3272 init_os (os
, NULL
, 0);
3274 case lang_assignment_statement_enum
:
3275 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3276 init_os (os
, NULL
, 0);
3278 /* Make sure that any sections mentioned in the assignment
3280 exp_init_os (s
->assignment_statement
.exp
);
3282 case lang_afile_asection_pair_statement_enum
:
3285 case lang_address_statement_enum
:
3286 /* Mark the specified section with the supplied address.
3288 If this section was actually a segment marker, then the
3289 directive is ignored if the linker script explicitly
3290 processed the segment marker. Originally, the linker
3291 treated segment directives (like -Ttext on the
3292 command-line) as section directives. We honor the
3293 section directive semantics for backwards compatibilty;
3294 linker scripts that do not specifically check for
3295 SEGMENT_START automatically get the old semantics. */
3296 if (!s
->address_statement
.segment
3297 || !s
->address_statement
.segment
->used
)
3299 lang_output_section_statement_type
*aos
3300 = (lang_output_section_statement_lookup
3301 (s
->address_statement
.section_name
));
3303 if (aos
->bfd_section
== NULL
)
3304 init_os (aos
, NULL
, 0);
3305 aos
->addr_tree
= s
->address_statement
.address
;
3312 /* An output section might have been removed after its statement was
3313 added. For example, ldemul_before_allocation can remove dynamic
3314 sections if they turn out to be not needed. Clean them up here. */
3317 strip_excluded_output_sections (void)
3319 lang_output_section_statement_type
*os
;
3321 /* Run lang_size_sections (if not already done). */
3322 if (expld
.phase
!= lang_mark_phase_enum
)
3324 expld
.phase
= lang_mark_phase_enum
;
3325 expld
.dataseg
.phase
= exp_dataseg_none
;
3326 one_lang_size_sections_pass (NULL
, FALSE
);
3327 lang_reset_memory_regions ();
3330 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3334 asection
*output_section
;
3335 bfd_boolean exclude
;
3337 if (os
->constraint
== -1)
3340 output_section
= os
->bfd_section
;
3341 if (output_section
== NULL
)
3344 exclude
= (output_section
->rawsize
== 0
3345 && (output_section
->flags
& SEC_KEEP
) == 0
3346 && !bfd_section_removed_from_list (output_bfd
,
3349 /* Some sections have not yet been sized, notably .gnu.version,
3350 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3351 input sections, so don't drop output sections that have such
3352 input sections unless they are also marked SEC_EXCLUDE. */
3353 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3357 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3358 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3359 && (s
->flags
& SEC_EXCLUDE
) == 0)
3366 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3367 output_section
->map_head
.link_order
= NULL
;
3368 output_section
->map_tail
.link_order
= NULL
;
3372 /* We don't set bfd_section to NULL since bfd_section of the
3373 removed output section statement may still be used. */
3374 if (!os
->section_relative_symbol
)
3376 output_section
->flags
|= SEC_EXCLUDE
;
3377 bfd_section_list_remove (output_bfd
, output_section
);
3378 output_bfd
->section_count
--;
3382 /* Stop future calls to lang_add_section from messing with map_head
3383 and map_tail link_order fields. */
3384 stripped_excluded_sections
= TRUE
;
3388 print_output_section_statement
3389 (lang_output_section_statement_type
*output_section_statement
)
3391 asection
*section
= output_section_statement
->bfd_section
;
3394 if (output_section_statement
!= abs_output_section
)
3396 minfo ("\n%s", output_section_statement
->name
);
3398 if (section
!= NULL
)
3400 print_dot
= section
->vma
;
3402 len
= strlen (output_section_statement
->name
);
3403 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3408 while (len
< SECTION_NAME_MAP_LENGTH
)
3414 minfo ("0x%V %W", section
->vma
, section
->size
);
3416 if (section
->vma
!= section
->lma
)
3417 minfo (_(" load address 0x%V"), section
->lma
);
3423 print_statement_list (output_section_statement
->children
.head
,
3424 output_section_statement
);
3427 /* Scan for the use of the destination in the right hand side
3428 of an expression. In such cases we will not compute the
3429 correct expression, since the value of DST that is used on
3430 the right hand side will be its final value, not its value
3431 just before this expression is evaluated. */
3434 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3436 if (rhs
== NULL
|| dst
== NULL
)
3439 switch (rhs
->type
.node_class
)
3442 return scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3443 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
);
3446 return scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3447 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
);
3450 case etree_provided
:
3452 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3454 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3457 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3461 return strcmp (dst
, rhs
->value
.str
) == 0;
3466 return strcmp (dst
, rhs
->name
.name
) == 0;
3478 print_assignment (lang_assignment_statement_type
*assignment
,
3479 lang_output_section_statement_type
*output_section
)
3483 bfd_boolean computation_is_valid
= TRUE
;
3486 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3489 if (assignment
->exp
->type
.node_class
== etree_assert
)
3492 tree
= assignment
->exp
->assert_s
.child
;
3493 computation_is_valid
= TRUE
;
3497 const char *dst
= assignment
->exp
->assign
.dst
;
3499 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
3500 tree
= assignment
->exp
->assign
.src
;
3501 computation_is_valid
= is_dot
|| (scan_for_self_assignment (dst
, tree
) == FALSE
);
3504 exp_fold_tree (tree
, output_section
->bfd_section
, &print_dot
);
3505 if (expld
.result
.valid_p
)
3509 if (computation_is_valid
)
3511 value
= expld
.result
.value
;
3513 if (expld
.result
.section
)
3514 value
+= expld
.result
.section
->vma
;
3516 minfo ("0x%V", value
);
3522 struct bfd_link_hash_entry
*h
;
3524 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
3525 FALSE
, FALSE
, TRUE
);
3528 value
= h
->u
.def
.value
;
3530 if (expld
.result
.section
)
3531 value
+= expld
.result
.section
->vma
;
3533 minfo ("[0x%V]", value
);
3536 minfo ("[unresolved]");
3548 exp_print_tree (assignment
->exp
);
3553 print_input_statement (lang_input_statement_type
*statm
)
3555 if (statm
->filename
!= NULL
)
3557 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
3561 /* Print all symbols defined in a particular section. This is called
3562 via bfd_link_hash_traverse, or by print_all_symbols. */
3565 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
3567 asection
*sec
= ptr
;
3569 if ((hash_entry
->type
== bfd_link_hash_defined
3570 || hash_entry
->type
== bfd_link_hash_defweak
)
3571 && sec
== hash_entry
->u
.def
.section
)
3575 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3578 (hash_entry
->u
.def
.value
3579 + hash_entry
->u
.def
.section
->output_offset
3580 + hash_entry
->u
.def
.section
->output_section
->vma
));
3582 minfo (" %T\n", hash_entry
->root
.string
);
3589 print_all_symbols (asection
*sec
)
3591 struct fat_user_section_struct
*ud
= get_userdata (sec
);
3592 struct map_symbol_def
*def
;
3597 *ud
->map_symbol_def_tail
= 0;
3598 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
3599 print_one_symbol (def
->entry
, sec
);
3602 /* Print information about an input section to the map file. */
3605 print_input_section (asection
*i
)
3607 bfd_size_type size
= i
->size
;
3614 minfo ("%s", i
->name
);
3616 len
= 1 + strlen (i
->name
);
3617 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3622 while (len
< SECTION_NAME_MAP_LENGTH
)
3628 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3629 addr
= i
->output_section
->vma
+ i
->output_offset
;
3636 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
3638 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
3640 len
= SECTION_NAME_MAP_LENGTH
+ 3;
3652 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
3655 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3657 if (link_info
.reduce_memory_overheads
)
3658 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
3660 print_all_symbols (i
);
3662 print_dot
= addr
+ TO_ADDR (size
);
3667 print_fill_statement (lang_fill_statement_type
*fill
)
3671 fputs (" FILL mask 0x", config
.map_file
);
3672 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
3673 fprintf (config
.map_file
, "%02x", *p
);
3674 fputs ("\n", config
.map_file
);
3678 print_data_statement (lang_data_statement_type
*data
)
3686 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3689 addr
= data
->output_offset
;
3690 if (data
->output_section
!= NULL
)
3691 addr
+= data
->output_section
->vma
;
3719 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
3721 if (data
->exp
->type
.node_class
!= etree_value
)
3724 exp_print_tree (data
->exp
);
3729 print_dot
= addr
+ TO_ADDR (size
);
3732 /* Print an address statement. These are generated by options like
3736 print_address_statement (lang_address_statement_type
*address
)
3738 minfo (_("Address of section %s set to "), address
->section_name
);
3739 exp_print_tree (address
->address
);
3743 /* Print a reloc statement. */
3746 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3753 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3756 addr
= reloc
->output_offset
;
3757 if (reloc
->output_section
!= NULL
)
3758 addr
+= reloc
->output_section
->vma
;
3760 size
= bfd_get_reloc_size (reloc
->howto
);
3762 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3764 if (reloc
->name
!= NULL
)
3765 minfo ("%s+", reloc
->name
);
3767 minfo ("%s+", reloc
->section
->name
);
3769 exp_print_tree (reloc
->addend_exp
);
3773 print_dot
= addr
+ TO_ADDR (size
);
3777 print_padding_statement (lang_padding_statement_type
*s
)
3785 len
= sizeof " *fill*" - 1;
3786 while (len
< SECTION_NAME_MAP_LENGTH
)
3792 addr
= s
->output_offset
;
3793 if (s
->output_section
!= NULL
)
3794 addr
+= s
->output_section
->vma
;
3795 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
3797 if (s
->fill
->size
!= 0)
3801 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
3802 fprintf (config
.map_file
, "%02x", *p
);
3807 print_dot
= addr
+ TO_ADDR (s
->size
);
3811 print_wild_statement (lang_wild_statement_type
*w
,
3812 lang_output_section_statement_type
*os
)
3814 struct wildcard_list
*sec
;
3818 if (w
->filenames_sorted
)
3820 if (w
->filename
!= NULL
)
3821 minfo ("%s", w
->filename
);
3824 if (w
->filenames_sorted
)
3828 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
3830 if (sec
->spec
.sorted
)
3832 if (sec
->spec
.exclude_name_list
!= NULL
)
3835 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
3836 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
3837 minfo (" %s", tmp
->name
);
3840 if (sec
->spec
.name
!= NULL
)
3841 minfo ("%s", sec
->spec
.name
);
3844 if (sec
->spec
.sorted
)
3853 print_statement_list (w
->children
.head
, os
);
3856 /* Print a group statement. */
3859 print_group (lang_group_statement_type
*s
,
3860 lang_output_section_statement_type
*os
)
3862 fprintf (config
.map_file
, "START GROUP\n");
3863 print_statement_list (s
->children
.head
, os
);
3864 fprintf (config
.map_file
, "END GROUP\n");
3867 /* Print the list of statements in S.
3868 This can be called for any statement type. */
3871 print_statement_list (lang_statement_union_type
*s
,
3872 lang_output_section_statement_type
*os
)
3876 print_statement (s
, os
);
3881 /* Print the first statement in statement list S.
3882 This can be called for any statement type. */
3885 print_statement (lang_statement_union_type
*s
,
3886 lang_output_section_statement_type
*os
)
3888 switch (s
->header
.type
)
3891 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
3894 case lang_constructors_statement_enum
:
3895 if (constructor_list
.head
!= NULL
)
3897 if (constructors_sorted
)
3898 minfo (" SORT (CONSTRUCTORS)\n");
3900 minfo (" CONSTRUCTORS\n");
3901 print_statement_list (constructor_list
.head
, os
);
3904 case lang_wild_statement_enum
:
3905 print_wild_statement (&s
->wild_statement
, os
);
3907 case lang_address_statement_enum
:
3908 print_address_statement (&s
->address_statement
);
3910 case lang_object_symbols_statement_enum
:
3911 minfo (" CREATE_OBJECT_SYMBOLS\n");
3913 case lang_fill_statement_enum
:
3914 print_fill_statement (&s
->fill_statement
);
3916 case lang_data_statement_enum
:
3917 print_data_statement (&s
->data_statement
);
3919 case lang_reloc_statement_enum
:
3920 print_reloc_statement (&s
->reloc_statement
);
3922 case lang_input_section_enum
:
3923 print_input_section (s
->input_section
.section
);
3925 case lang_padding_statement_enum
:
3926 print_padding_statement (&s
->padding_statement
);
3928 case lang_output_section_statement_enum
:
3929 print_output_section_statement (&s
->output_section_statement
);
3931 case lang_assignment_statement_enum
:
3932 print_assignment (&s
->assignment_statement
, os
);
3934 case lang_target_statement_enum
:
3935 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
3937 case lang_output_statement_enum
:
3938 minfo ("OUTPUT(%s", s
->output_statement
.name
);
3939 if (output_target
!= NULL
)
3940 minfo (" %s", output_target
);
3943 case lang_input_statement_enum
:
3944 print_input_statement (&s
->input_statement
);
3946 case lang_group_statement_enum
:
3947 print_group (&s
->group_statement
, os
);
3949 case lang_afile_asection_pair_statement_enum
:
3956 print_statements (void)
3958 print_statement_list (statement_list
.head
, abs_output_section
);
3961 /* Print the first N statements in statement list S to STDERR.
3962 If N == 0, nothing is printed.
3963 If N < 0, the entire list is printed.
3964 Intended to be called from GDB. */
3967 dprint_statement (lang_statement_union_type
*s
, int n
)
3969 FILE *map_save
= config
.map_file
;
3971 config
.map_file
= stderr
;
3974 print_statement_list (s
, abs_output_section
);
3977 while (s
&& --n
>= 0)
3979 print_statement (s
, abs_output_section
);
3984 config
.map_file
= map_save
;
3988 insert_pad (lang_statement_union_type
**ptr
,
3990 unsigned int alignment_needed
,
3991 asection
*output_section
,
3994 static fill_type zero_fill
= { 1, { 0 } };
3995 lang_statement_union_type
*pad
= NULL
;
3997 if (ptr
!= &statement_list
.head
)
3998 pad
= ((lang_statement_union_type
*)
3999 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4001 && pad
->header
.type
== lang_padding_statement_enum
4002 && pad
->padding_statement
.output_section
== output_section
)
4004 /* Use the existing pad statement. */
4006 else if ((pad
= *ptr
) != NULL
4007 && pad
->header
.type
== lang_padding_statement_enum
4008 && pad
->padding_statement
.output_section
== output_section
)
4010 /* Use the existing pad statement. */
4014 /* Make a new padding statement, linked into existing chain. */
4015 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4016 pad
->header
.next
= *ptr
;
4018 pad
->header
.type
= lang_padding_statement_enum
;
4019 pad
->padding_statement
.output_section
= output_section
;
4022 pad
->padding_statement
.fill
= fill
;
4024 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4025 pad
->padding_statement
.size
= alignment_needed
;
4026 output_section
->size
+= alignment_needed
;
4029 /* Work out how much this section will move the dot point. */
4033 (lang_statement_union_type
**this_ptr
,
4034 lang_output_section_statement_type
*output_section_statement
,
4038 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4039 asection
*i
= is
->section
;
4041 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
4042 && (i
->flags
& SEC_EXCLUDE
) == 0)
4044 unsigned int alignment_needed
;
4047 /* Align this section first to the input sections requirement,
4048 then to the output section's requirement. If this alignment
4049 is greater than any seen before, then record it too. Perform
4050 the alignment by inserting a magic 'padding' statement. */
4052 if (output_section_statement
->subsection_alignment
!= -1)
4053 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4055 o
= output_section_statement
->bfd_section
;
4056 if (o
->alignment_power
< i
->alignment_power
)
4057 o
->alignment_power
= i
->alignment_power
;
4059 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4061 if (alignment_needed
!= 0)
4063 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4064 dot
+= alignment_needed
;
4067 /* Remember where in the output section this input section goes. */
4069 i
->output_offset
= dot
- o
->vma
;
4071 /* Mark how big the output section must be to contain this now. */
4072 dot
+= TO_ADDR (i
->size
);
4073 o
->size
= TO_SIZE (dot
- o
->vma
);
4077 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4084 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4086 const asection
*sec1
= *(const asection
**) arg1
;
4087 const asection
*sec2
= *(const asection
**) arg2
;
4089 if (bfd_section_lma (sec1
->owner
, sec1
)
4090 < bfd_section_lma (sec2
->owner
, sec2
))
4092 else if (bfd_section_lma (sec1
->owner
, sec1
)
4093 > bfd_section_lma (sec2
->owner
, sec2
))
4099 #define IGNORE_SECTION(s) \
4100 ((s->flags & SEC_NEVER_LOAD) != 0 \
4101 || (s->flags & SEC_ALLOC) == 0 \
4102 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4103 && (s->flags & SEC_LOAD) == 0))
4105 /* Check to see if any allocated sections overlap with other allocated
4106 sections. This can happen if a linker script specifies the output
4107 section addresses of the two sections. */
4110 lang_check_section_addresses (void)
4113 asection
**sections
, **spp
;
4121 if (bfd_count_sections (output_bfd
) <= 1)
4124 amt
= bfd_count_sections (output_bfd
) * sizeof (asection
*);
4125 sections
= xmalloc (amt
);
4127 /* Scan all sections in the output list. */
4129 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4131 /* Only consider loadable sections with real contents. */
4132 if (IGNORE_SECTION (s
) || s
->size
== 0)
4135 sections
[count
] = s
;
4142 qsort (sections
, (size_t) count
, sizeof (asection
*),
4143 sort_sections_by_lma
);
4147 s_start
= bfd_section_lma (output_bfd
, s
);
4148 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4149 for (count
--; count
; count
--)
4151 /* We must check the sections' LMA addresses not their VMA
4152 addresses because overlay sections can have overlapping VMAs
4153 but they must have distinct LMAs. */
4158 s_start
= bfd_section_lma (output_bfd
, s
);
4159 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4161 /* Look for an overlap. */
4162 if (s_end
>= os_start
&& s_start
<= os_end
)
4163 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4164 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
4170 /* Make sure the new address is within the region. We explicitly permit the
4171 current address to be at the exact end of the region when the address is
4172 non-zero, in case the region is at the end of addressable memory and the
4173 calculation wraps around. */
4176 os_region_check (lang_output_section_statement_type
*os
,
4177 lang_memory_region_type
*region
,
4181 if ((region
->current
< region
->origin
4182 || (region
->current
- region
->origin
> region
->length
))
4183 && ((region
->current
!= region
->origin
+ region
->length
)
4188 einfo (_("%X%P: address 0x%v of %B section %s"
4189 " is not within region %s\n"),
4191 os
->bfd_section
->owner
,
4192 os
->bfd_section
->name
,
4197 einfo (_("%X%P: region %s is full (%B section %s)\n"),
4199 os
->bfd_section
->owner
,
4200 os
->bfd_section
->name
);
4202 /* Reset the region pointer. */
4203 region
->current
= region
->origin
;
4207 /* Set the sizes for all the output sections. */
4210 lang_size_sections_1
4211 (lang_statement_union_type
*s
,
4212 lang_output_section_statement_type
*output_section_statement
,
4213 lang_statement_union_type
**prev
,
4217 bfd_boolean check_regions
)
4219 /* Size up the sections from their constituent parts. */
4220 for (; s
!= NULL
; s
= s
->header
.next
)
4222 switch (s
->header
.type
)
4224 case lang_output_section_statement_enum
:
4226 bfd_vma newdot
, after
;
4227 lang_output_section_statement_type
*os
;
4228 lang_memory_region_type
*r
;
4230 os
= &s
->output_section_statement
;
4231 if (os
->addr_tree
!= NULL
)
4233 os
->processed_vma
= FALSE
;
4234 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4236 if (!expld
.result
.valid_p
4237 && expld
.phase
!= lang_mark_phase_enum
)
4238 einfo (_("%F%S: non constant or forward reference"
4239 " address expression for section %s\n"),
4242 dot
= expld
.result
.value
+ expld
.result
.section
->vma
;
4245 if (os
->bfd_section
== NULL
)
4246 /* This section was removed or never actually created. */
4249 /* If this is a COFF shared library section, use the size and
4250 address from the input section. FIXME: This is COFF
4251 specific; it would be cleaner if there were some other way
4252 to do this, but nothing simple comes to mind. */
4253 if ((bfd_get_flavour (output_bfd
) == bfd_target_ecoff_flavour
4254 || bfd_get_flavour (output_bfd
) == bfd_target_coff_flavour
)
4255 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4259 if (os
->children
.head
== NULL
4260 || os
->children
.head
->header
.next
!= NULL
4261 || (os
->children
.head
->header
.type
4262 != lang_input_section_enum
))
4263 einfo (_("%P%X: Internal error on COFF shared library"
4264 " section %s\n"), os
->name
);
4266 input
= os
->children
.head
->input_section
.section
;
4267 bfd_set_section_vma (os
->bfd_section
->owner
,
4269 bfd_section_vma (input
->owner
, input
));
4270 os
->bfd_section
->size
= input
->size
;
4275 if (bfd_is_abs_section (os
->bfd_section
))
4277 /* No matter what happens, an abs section starts at zero. */
4278 ASSERT (os
->bfd_section
->vma
== 0);
4284 if (os
->addr_tree
== NULL
)
4286 /* No address specified for this section, get one
4287 from the region specification. */
4288 if (os
->region
== NULL
4289 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4290 && os
->region
->name
[0] == '*'
4291 && strcmp (os
->region
->name
,
4292 DEFAULT_MEMORY_REGION
) == 0))
4294 os
->region
= lang_memory_default (os
->bfd_section
);
4297 /* If a loadable section is using the default memory
4298 region, and some non default memory regions were
4299 defined, issue an error message. */
4301 && !IGNORE_SECTION (os
->bfd_section
)
4302 && ! link_info
.relocatable
4304 && strcmp (os
->region
->name
,
4305 DEFAULT_MEMORY_REGION
) == 0
4306 && lang_memory_region_list
!= NULL
4307 && (strcmp (lang_memory_region_list
->name
,
4308 DEFAULT_MEMORY_REGION
) != 0
4309 || lang_memory_region_list
->next
!= NULL
)
4310 && expld
.phase
!= lang_mark_phase_enum
)
4312 /* By default this is an error rather than just a
4313 warning because if we allocate the section to the
4314 default memory region we can end up creating an
4315 excessively large binary, or even seg faulting when
4316 attempting to perform a negative seek. See
4317 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4318 for an example of this. This behaviour can be
4319 overridden by the using the --no-check-sections
4321 if (command_line
.check_section_addresses
)
4322 einfo (_("%P%F: error: no memory region specified"
4323 " for loadable section `%s'\n"),
4324 bfd_get_section_name (output_bfd
,
4327 einfo (_("%P: warning: no memory region specified"
4328 " for loadable section `%s'\n"),
4329 bfd_get_section_name (output_bfd
,
4333 newdot
= os
->region
->current
;
4334 align
= os
->bfd_section
->alignment_power
;
4337 align
= os
->section_alignment
;
4339 /* Align to what the section needs. */
4342 bfd_vma savedot
= newdot
;
4343 newdot
= align_power (newdot
, align
);
4345 if (newdot
!= savedot
4346 && (config
.warn_section_align
4347 || os
->addr_tree
!= NULL
)
4348 && expld
.phase
!= lang_mark_phase_enum
)
4349 einfo (_("%P: warning: changing start of section"
4350 " %s by %lu bytes\n"),
4351 os
->name
, (unsigned long) (newdot
- savedot
));
4354 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4356 os
->bfd_section
->output_offset
= 0;
4359 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
4360 os
->fill
, newdot
, relax
, check_regions
);
4362 os
->processed_vma
= TRUE
;
4364 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4365 /* Except for some special linker created sections,
4366 no output section should change from zero size
4367 after strip_excluded_output_sections. A non-zero
4368 size on an ignored section indicates that some
4369 input section was not sized early enough. */
4370 ASSERT (os
->bfd_section
->size
== 0);
4373 dot
= os
->bfd_section
->vma
;
4375 /* Put the section within the requested block size, or
4376 align at the block boundary. */
4378 + TO_ADDR (os
->bfd_section
->size
)
4379 + os
->block_value
- 1)
4380 & - (bfd_vma
) os
->block_value
);
4382 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
4385 /* Set section lma. */
4388 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
4392 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
4393 os
->bfd_section
->lma
= lma
;
4395 else if (os
->region
!= NULL
4396 && os
->lma_region
!= NULL
4397 && os
->lma_region
!= os
->region
)
4399 bfd_vma lma
= os
->lma_region
->current
;
4401 if (os
->section_alignment
!= -1)
4402 lma
= align_power (lma
, os
->section_alignment
);
4403 os
->bfd_section
->lma
= lma
;
4405 else if (r
->last_os
!= NULL
4406 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
4411 last
= r
->last_os
->output_section_statement
.bfd_section
;
4413 /* A backwards move of dot should be accompanied by
4414 an explicit assignment to the section LMA (ie.
4415 os->load_base set) because backwards moves can
4416 create overlapping LMAs. */
4418 && os
->bfd_section
->size
!= 0
4419 && dot
+ os
->bfd_section
->size
<= last
->vma
)
4421 /* If dot moved backwards then leave lma equal to
4422 vma. This is the old default lma, which might
4423 just happen to work when the backwards move is
4424 sufficiently large. Nag if this changes anything,
4425 so people can fix their linker scripts. */
4427 if (last
->vma
!= last
->lma
)
4428 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4433 /* If the current vma overlaps the previous section,
4434 then set the current lma to that at the end of
4435 the previous section. The previous section was
4436 probably an overlay. */
4437 if ((dot
>= last
->vma
4438 && dot
< last
->vma
+ last
->size
)
4439 || (last
->vma
>= dot
4440 && last
->vma
< dot
+ os
->bfd_section
->size
))
4441 lma
= last
->lma
+ last
->size
;
4443 /* Otherwise, keep the same lma to vma relationship
4444 as the previous section. */
4446 lma
= dot
+ last
->lma
- last
->vma
;
4448 if (os
->section_alignment
!= -1)
4449 lma
= align_power (lma
, os
->section_alignment
);
4450 os
->bfd_section
->lma
= lma
;
4453 os
->processed_lma
= TRUE
;
4455 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4458 /* Keep track of normal sections using the default
4459 lma region. We use this to set the lma for
4460 following sections. Overlays or other linker
4461 script assignment to lma might mean that the
4462 default lma == vma is incorrect.
4463 To avoid warnings about dot moving backwards when using
4464 -Ttext, don't start tracking sections until we find one
4465 of non-zero size or with lma set differently to vma. */
4466 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4467 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
4468 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
4469 && (os
->bfd_section
->size
!= 0
4470 || (r
->last_os
== NULL
4471 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
4472 || (r
->last_os
!= NULL
4473 && dot
>= (r
->last_os
->output_section_statement
4474 .bfd_section
->vma
)))
4475 && os
->lma_region
== NULL
4476 && !link_info
.relocatable
)
4479 /* .tbss sections effectively have zero size. */
4480 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4481 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4482 || link_info
.relocatable
)
4483 dot
+= TO_ADDR (os
->bfd_section
->size
);
4485 if (os
->update_dot_tree
!= 0)
4486 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
4488 /* Update dot in the region ?
4489 We only do this if the section is going to be allocated,
4490 since unallocated sections do not contribute to the region's
4491 overall size in memory.
4493 If the SEC_NEVER_LOAD bit is not set, it will affect the
4494 addresses of sections after it. We have to update
4496 if (os
->region
!= NULL
4497 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
4498 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
4500 os
->region
->current
= dot
;
4503 /* Make sure the new address is within the region. */
4504 os_region_check (os
, os
->region
, os
->addr_tree
,
4505 os
->bfd_section
->vma
);
4507 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
4509 os
->lma_region
->current
4510 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
4513 os_region_check (os
, os
->lma_region
, NULL
,
4514 os
->bfd_section
->lma
);
4520 case lang_constructors_statement_enum
:
4521 dot
= lang_size_sections_1 (constructor_list
.head
,
4522 output_section_statement
,
4523 &s
->wild_statement
.children
.head
,
4524 fill
, dot
, relax
, check_regions
);
4527 case lang_data_statement_enum
:
4529 unsigned int size
= 0;
4531 s
->data_statement
.output_offset
=
4532 dot
- output_section_statement
->bfd_section
->vma
;
4533 s
->data_statement
.output_section
=
4534 output_section_statement
->bfd_section
;
4536 /* We might refer to provided symbols in the expression, and
4537 need to mark them as needed. */
4538 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4540 switch (s
->data_statement
.type
)
4558 if (size
< TO_SIZE ((unsigned) 1))
4559 size
= TO_SIZE ((unsigned) 1);
4560 dot
+= TO_ADDR (size
);
4561 output_section_statement
->bfd_section
->size
+= size
;
4565 case lang_reloc_statement_enum
:
4569 s
->reloc_statement
.output_offset
=
4570 dot
- output_section_statement
->bfd_section
->vma
;
4571 s
->reloc_statement
.output_section
=
4572 output_section_statement
->bfd_section
;
4573 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
4574 dot
+= TO_ADDR (size
);
4575 output_section_statement
->bfd_section
->size
+= size
;
4579 case lang_wild_statement_enum
:
4580 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
4581 output_section_statement
,
4582 &s
->wild_statement
.children
.head
,
4583 fill
, dot
, relax
, check_regions
);
4586 case lang_object_symbols_statement_enum
:
4587 link_info
.create_object_symbols_section
=
4588 output_section_statement
->bfd_section
;
4591 case lang_output_statement_enum
:
4592 case lang_target_statement_enum
:
4595 case lang_input_section_enum
:
4599 i
= (*prev
)->input_section
.section
;
4604 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
4605 einfo (_("%P%F: can't relax section: %E\n"));
4609 dot
= size_input_section (prev
, output_section_statement
,
4610 output_section_statement
->fill
, dot
);
4614 case lang_input_statement_enum
:
4617 case lang_fill_statement_enum
:
4618 s
->fill_statement
.output_section
=
4619 output_section_statement
->bfd_section
;
4621 fill
= s
->fill_statement
.fill
;
4624 case lang_assignment_statement_enum
:
4626 bfd_vma newdot
= dot
;
4627 etree_type
*tree
= s
->assignment_statement
.exp
;
4629 exp_fold_tree (tree
,
4630 output_section_statement
->bfd_section
,
4633 /* This symbol is relative to this section. */
4634 if ((tree
->type
.node_class
== etree_provided
4635 || tree
->type
.node_class
== etree_assign
)
4636 && (tree
->assign
.dst
[0] != '.'
4637 || tree
->assign
.dst
[1] != '\0'))
4638 output_section_statement
->section_relative_symbol
= 1;
4640 if (!output_section_statement
->ignored
)
4642 if (output_section_statement
== abs_output_section
)
4644 /* If we don't have an output section, then just adjust
4645 the default memory address. */
4646 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
4647 FALSE
)->current
= newdot
;
4649 else if (newdot
!= dot
)
4651 /* Insert a pad after this statement. We can't
4652 put the pad before when relaxing, in case the
4653 assignment references dot. */
4654 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
4655 output_section_statement
->bfd_section
, dot
);
4657 /* Don't neuter the pad below when relaxing. */
4660 /* If dot is advanced, this implies that the section
4661 should have space allocated to it, unless the
4662 user has explicitly stated that the section
4663 should never be loaded. */
4664 if (!(output_section_statement
->flags
4665 & (SEC_NEVER_LOAD
| SEC_ALLOC
)))
4666 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
4673 case lang_padding_statement_enum
:
4674 /* If this is the first time lang_size_sections is called,
4675 we won't have any padding statements. If this is the
4676 second or later passes when relaxing, we should allow
4677 padding to shrink. If padding is needed on this pass, it
4678 will be added back in. */
4679 s
->padding_statement
.size
= 0;
4681 /* Make sure output_offset is valid. If relaxation shrinks
4682 the section and this pad isn't needed, it's possible to
4683 have output_offset larger than the final size of the
4684 section. bfd_set_section_contents will complain even for
4685 a pad size of zero. */
4686 s
->padding_statement
.output_offset
4687 = dot
- output_section_statement
->bfd_section
->vma
;
4690 case lang_group_statement_enum
:
4691 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
4692 output_section_statement
,
4693 &s
->group_statement
.children
.head
,
4694 fill
, dot
, relax
, check_regions
);
4701 /* We can only get here when relaxing is turned on. */
4702 case lang_address_statement_enum
:
4705 prev
= &s
->header
.next
;
4710 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4711 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4712 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4713 segments. We are allowed an opportunity to override this decision. */
4716 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4717 bfd
* abfd ATTRIBUTE_UNUSED
,
4718 asection
* current_section
,
4719 asection
* previous_section
,
4720 bfd_boolean new_segment
)
4722 lang_output_section_statement_type
* cur
;
4723 lang_output_section_statement_type
* prev
;
4725 /* The checks below are only necessary when the BFD library has decided
4726 that the two sections ought to be placed into the same segment. */
4730 /* Paranoia checks. */
4731 if (current_section
== NULL
|| previous_section
== NULL
)
4734 /* Find the memory regions associated with the two sections.
4735 We call lang_output_section_find() here rather than scanning the list
4736 of output sections looking for a matching section pointer because if
4737 we have a large number of sections then a hash lookup is faster. */
4738 cur
= lang_output_section_find (current_section
->name
);
4739 prev
= lang_output_section_find (previous_section
->name
);
4741 /* More paranoia. */
4742 if (cur
== NULL
|| prev
== NULL
)
4745 /* If the regions are different then force the sections to live in
4746 different segments. See the email thread starting at the following
4747 URL for the reasons why this is necessary:
4748 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
4749 return cur
->region
!= prev
->region
;
4753 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
4755 lang_statement_iteration
++;
4756 lang_size_sections_1 (statement_list
.head
, abs_output_section
,
4757 &statement_list
.head
, 0, 0, relax
, check_regions
);
4761 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
4763 expld
.phase
= lang_allocating_phase_enum
;
4764 expld
.dataseg
.phase
= exp_dataseg_none
;
4766 one_lang_size_sections_pass (relax
, check_regions
);
4767 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
4768 && link_info
.relro
&& expld
.dataseg
.relro_end
)
4770 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4771 to put expld.dataseg.relro on a (common) page boundary. */
4772 bfd_vma old_min_base
, relro_end
, maxpage
;
4774 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
4775 old_min_base
= expld
.dataseg
.min_base
;
4776 maxpage
= expld
.dataseg
.maxpagesize
;
4777 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
4778 & (expld
.dataseg
.pagesize
- 1));
4779 /* Compute the expected PT_GNU_RELRO segment end. */
4780 relro_end
= (expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
4781 & ~(expld
.dataseg
.pagesize
- 1);
4782 if (old_min_base
+ maxpage
< expld
.dataseg
.base
)
4784 expld
.dataseg
.base
-= maxpage
;
4785 relro_end
-= maxpage
;
4787 lang_reset_memory_regions ();
4788 one_lang_size_sections_pass (relax
, check_regions
);
4789 if (expld
.dataseg
.relro_end
> relro_end
)
4791 /* The alignment of sections between DATA_SEGMENT_ALIGN
4792 and DATA_SEGMENT_RELRO_END caused huge padding to be
4793 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4795 unsigned int max_alignment_power
= 0;
4797 /* Find maximum alignment power of sections between
4798 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4799 for (sec
= output_bfd
->sections
; sec
; sec
= sec
->next
)
4800 if (sec
->vma
>= expld
.dataseg
.base
4801 && sec
->vma
< expld
.dataseg
.relro_end
4802 && sec
->alignment_power
> max_alignment_power
)
4803 max_alignment_power
= sec
->alignment_power
;
4805 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
4807 if (expld
.dataseg
.base
- (1 << max_alignment_power
)
4809 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
4810 expld
.dataseg
.base
-= (1 << max_alignment_power
);
4811 lang_reset_memory_regions ();
4812 one_lang_size_sections_pass (relax
, check_regions
);
4815 link_info
.relro_start
= expld
.dataseg
.base
;
4816 link_info
.relro_end
= expld
.dataseg
.relro_end
;
4818 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
4820 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4821 a page could be saved in the data segment. */
4822 bfd_vma first
, last
;
4824 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
4825 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
4827 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
4828 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
4829 && first
+ last
<= expld
.dataseg
.pagesize
)
4831 expld
.dataseg
.phase
= exp_dataseg_adjust
;
4832 lang_reset_memory_regions ();
4833 one_lang_size_sections_pass (relax
, check_regions
);
4837 expld
.phase
= lang_final_phase_enum
;
4840 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4843 lang_do_assignments_1 (lang_statement_union_type
*s
,
4844 lang_output_section_statement_type
*current_os
,
4848 for (; s
!= NULL
; s
= s
->header
.next
)
4850 switch (s
->header
.type
)
4852 case lang_constructors_statement_enum
:
4853 dot
= lang_do_assignments_1 (constructor_list
.head
,
4854 current_os
, fill
, dot
);
4857 case lang_output_section_statement_enum
:
4859 lang_output_section_statement_type
*os
;
4861 os
= &(s
->output_section_statement
);
4862 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
4864 dot
= os
->bfd_section
->vma
;
4866 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
4868 /* .tbss sections effectively have zero size. */
4869 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4870 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4871 || link_info
.relocatable
)
4872 dot
+= TO_ADDR (os
->bfd_section
->size
);
4877 case lang_wild_statement_enum
:
4879 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
4880 current_os
, fill
, dot
);
4883 case lang_object_symbols_statement_enum
:
4884 case lang_output_statement_enum
:
4885 case lang_target_statement_enum
:
4888 case lang_data_statement_enum
:
4889 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4890 if (expld
.result
.valid_p
)
4891 s
->data_statement
.value
= (expld
.result
.value
4892 + expld
.result
.section
->vma
);
4894 einfo (_("%F%P: invalid data statement\n"));
4897 switch (s
->data_statement
.type
)
4915 if (size
< TO_SIZE ((unsigned) 1))
4916 size
= TO_SIZE ((unsigned) 1);
4917 dot
+= TO_ADDR (size
);
4921 case lang_reloc_statement_enum
:
4922 exp_fold_tree (s
->reloc_statement
.addend_exp
,
4923 bfd_abs_section_ptr
, &dot
);
4924 if (expld
.result
.valid_p
)
4925 s
->reloc_statement
.addend_value
= expld
.result
.value
;
4927 einfo (_("%F%P: invalid reloc statement\n"));
4928 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
4931 case lang_input_section_enum
:
4933 asection
*in
= s
->input_section
.section
;
4935 if ((in
->flags
& SEC_EXCLUDE
) == 0)
4936 dot
+= TO_ADDR (in
->size
);
4940 case lang_input_statement_enum
:
4943 case lang_fill_statement_enum
:
4944 fill
= s
->fill_statement
.fill
;
4947 case lang_assignment_statement_enum
:
4948 exp_fold_tree (s
->assignment_statement
.exp
,
4949 current_os
->bfd_section
,
4953 case lang_padding_statement_enum
:
4954 dot
+= TO_ADDR (s
->padding_statement
.size
);
4957 case lang_group_statement_enum
:
4958 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
4959 current_os
, fill
, dot
);
4966 case lang_address_statement_enum
:
4974 lang_do_assignments (void)
4976 lang_statement_iteration
++;
4977 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
4980 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4981 operator .startof. (section_name), it produces an undefined symbol
4982 .startof.section_name. Similarly, when it sees
4983 .sizeof. (section_name), it produces an undefined symbol
4984 .sizeof.section_name. For all the output sections, we look for
4985 such symbols, and set them to the correct value. */
4988 lang_set_startof (void)
4992 if (link_info
.relocatable
)
4995 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4997 const char *secname
;
4999 struct bfd_link_hash_entry
*h
;
5001 secname
= bfd_get_section_name (output_bfd
, s
);
5002 buf
= xmalloc (10 + strlen (secname
));
5004 sprintf (buf
, ".startof.%s", secname
);
5005 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5006 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5008 h
->type
= bfd_link_hash_defined
;
5009 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
5010 h
->u
.def
.section
= bfd_abs_section_ptr
;
5013 sprintf (buf
, ".sizeof.%s", secname
);
5014 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5015 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5017 h
->type
= bfd_link_hash_defined
;
5018 h
->u
.def
.value
= TO_ADDR (s
->size
);
5019 h
->u
.def
.section
= bfd_abs_section_ptr
;
5029 struct bfd_link_hash_entry
*h
;
5032 if (link_info
.relocatable
|| link_info
.shared
)
5037 if (entry_symbol
.name
== NULL
)
5039 /* No entry has been specified. Look for the default entry, but
5040 don't warn if we don't find it. */
5041 entry_symbol
.name
= entry_symbol_default
;
5045 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5046 FALSE
, FALSE
, TRUE
);
5048 && (h
->type
== bfd_link_hash_defined
5049 || h
->type
== bfd_link_hash_defweak
)
5050 && h
->u
.def
.section
->output_section
!= NULL
)
5054 val
= (h
->u
.def
.value
5055 + bfd_get_section_vma (output_bfd
,
5056 h
->u
.def
.section
->output_section
)
5057 + h
->u
.def
.section
->output_offset
);
5058 if (! bfd_set_start_address (output_bfd
, val
))
5059 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5066 /* We couldn't find the entry symbol. Try parsing it as a
5068 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5071 if (! bfd_set_start_address (output_bfd
, val
))
5072 einfo (_("%P%F: can't set start address\n"));
5078 /* Can't find the entry symbol, and it's not a number. Use
5079 the first address in the text section. */
5080 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
5084 einfo (_("%P: warning: cannot find entry symbol %s;"
5085 " defaulting to %V\n"),
5087 bfd_get_section_vma (output_bfd
, ts
));
5088 if (! bfd_set_start_address (output_bfd
,
5089 bfd_get_section_vma (output_bfd
,
5091 einfo (_("%P%F: can't set start address\n"));
5096 einfo (_("%P: warning: cannot find entry symbol %s;"
5097 " not setting start address\n"),
5103 /* Don't bfd_hash_table_free (&lang_definedness_table);
5104 map file output may result in a call of lang_track_definedness. */
5107 /* This is a small function used when we want to ignore errors from
5111 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5113 /* Don't do anything. */
5116 /* Check that the architecture of all the input files is compatible
5117 with the output file. Also call the backend to let it do any
5118 other checking that is needed. */
5123 lang_statement_union_type
*file
;
5125 const bfd_arch_info_type
*compatible
;
5127 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5129 input_bfd
= file
->input_statement
.the_bfd
;
5131 = bfd_arch_get_compatible (input_bfd
, output_bfd
,
5132 command_line
.accept_unknown_input_arch
);
5134 /* In general it is not possible to perform a relocatable
5135 link between differing object formats when the input
5136 file has relocations, because the relocations in the
5137 input format may not have equivalent representations in
5138 the output format (and besides BFD does not translate
5139 relocs for other link purposes than a final link). */
5140 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5141 && (compatible
== NULL
5142 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
5143 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5145 einfo (_("%P%F: Relocatable linking with relocations from"
5146 " format %s (%B) to format %s (%B) is not supported\n"),
5147 bfd_get_target (input_bfd
), input_bfd
,
5148 bfd_get_target (output_bfd
), output_bfd
);
5149 /* einfo with %F exits. */
5152 if (compatible
== NULL
)
5154 if (command_line
.warn_mismatch
)
5155 einfo (_("%P: warning: %s architecture of input file `%B'"
5156 " is incompatible with %s output\n"),
5157 bfd_printable_name (input_bfd
), input_bfd
,
5158 bfd_printable_name (output_bfd
));
5160 else if (bfd_count_sections (input_bfd
))
5162 /* If the input bfd has no contents, it shouldn't set the
5163 private data of the output bfd. */
5165 bfd_error_handler_type pfn
= NULL
;
5167 /* If we aren't supposed to warn about mismatched input
5168 files, temporarily set the BFD error handler to a
5169 function which will do nothing. We still want to call
5170 bfd_merge_private_bfd_data, since it may set up
5171 information which is needed in the output file. */
5172 if (! command_line
.warn_mismatch
)
5173 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5174 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
5176 if (command_line
.warn_mismatch
)
5177 einfo (_("%P%X: failed to merge target specific data"
5178 " of file %B\n"), input_bfd
);
5180 if (! command_line
.warn_mismatch
)
5181 bfd_set_error_handler (pfn
);
5186 /* Look through all the global common symbols and attach them to the
5187 correct section. The -sort-common command line switch may be used
5188 to roughly sort the entries by size. */
5193 if (command_line
.inhibit_common_definition
)
5195 if (link_info
.relocatable
5196 && ! command_line
.force_common_definition
)
5199 if (! config
.sort_common
)
5200 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5205 for (power
= 4; power
>= 0; power
--)
5206 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5210 /* Place one common symbol in the correct section. */
5213 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5215 unsigned int power_of_two
;
5219 if (h
->type
!= bfd_link_hash_common
)
5223 power_of_two
= h
->u
.c
.p
->alignment_power
;
5225 if (config
.sort_common
5226 && power_of_two
< (unsigned int) *(int *) info
)
5229 section
= h
->u
.c
.p
->section
;
5231 /* Increase the size of the section to align the common sym. */
5232 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
5233 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
5235 /* Adjust the alignment if necessary. */
5236 if (power_of_two
> section
->alignment_power
)
5237 section
->alignment_power
= power_of_two
;
5239 /* Change the symbol from common to defined. */
5240 h
->type
= bfd_link_hash_defined
;
5241 h
->u
.def
.section
= section
;
5242 h
->u
.def
.value
= section
->size
;
5244 /* Increase the size of the section. */
5245 section
->size
+= size
;
5247 /* Make sure the section is allocated in memory, and make sure that
5248 it is no longer a common section. */
5249 section
->flags
|= SEC_ALLOC
;
5250 section
->flags
&= ~SEC_IS_COMMON
;
5252 if (config
.map_file
!= NULL
)
5254 static bfd_boolean header_printed
;
5259 if (! header_printed
)
5261 minfo (_("\nAllocating common symbols\n"));
5262 minfo (_("Common symbol size file\n\n"));
5263 header_printed
= TRUE
;
5266 name
= demangle (h
->root
.string
);
5268 len
= strlen (name
);
5283 if (size
<= 0xffffffff)
5284 sprintf (buf
, "%lx", (unsigned long) size
);
5286 sprintf_vma (buf
, size
);
5296 minfo ("%B\n", section
->owner
);
5302 /* Run through the input files and ensure that every input section has
5303 somewhere to go. If one is found without a destination then create
5304 an input request and place it into the statement tree. */
5307 lang_place_orphans (void)
5309 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5313 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5315 if (s
->output_section
== NULL
)
5317 /* This section of the file is not attached, root
5318 around for a sensible place for it to go. */
5320 if (file
->just_syms_flag
)
5321 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5322 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5323 s
->output_section
= bfd_abs_section_ptr
;
5324 else if (strcmp (s
->name
, "COMMON") == 0)
5326 /* This is a lonely common section which must have
5327 come from an archive. We attach to the section
5328 with the wildcard. */
5329 if (! link_info
.relocatable
5330 || command_line
.force_common_definition
)
5332 if (default_common_section
== NULL
)
5334 default_common_section
=
5335 lang_output_section_statement_lookup (".bss");
5338 lang_add_section (&default_common_section
->children
, s
,
5339 default_common_section
);
5342 else if (ldemul_place_orphan (s
))
5346 lang_output_section_statement_type
*os
;
5348 os
= lang_output_section_statement_lookup (s
->name
);
5349 lang_add_section (&os
->children
, s
, os
);
5357 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
5359 flagword
*ptr_flags
;
5361 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
5367 *ptr_flags
|= SEC_ALLOC
;
5371 *ptr_flags
|= SEC_READONLY
;
5375 *ptr_flags
|= SEC_DATA
;
5379 *ptr_flags
|= SEC_CODE
;
5384 *ptr_flags
|= SEC_LOAD
;
5388 einfo (_("%P%F: invalid syntax in flags\n"));
5395 /* Call a function on each input file. This function will be called
5396 on an archive, but not on the elements. */
5399 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
5401 lang_input_statement_type
*f
;
5403 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
5405 f
= (lang_input_statement_type
*) f
->next_real_file
)
5409 /* Call a function on each file. The function will be called on all
5410 the elements of an archive which are included in the link, but will
5411 not be called on the archive file itself. */
5414 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
5416 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5423 ldlang_add_file (lang_input_statement_type
*entry
)
5427 lang_statement_append (&file_chain
,
5428 (lang_statement_union_type
*) entry
,
5431 /* The BFD linker needs to have a list of all input BFDs involved in
5433 ASSERT (entry
->the_bfd
->link_next
== NULL
);
5434 ASSERT (entry
->the_bfd
!= output_bfd
);
5435 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
5437 *pp
= entry
->the_bfd
;
5438 entry
->the_bfd
->usrdata
= entry
;
5439 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
5441 /* Look through the sections and check for any which should not be
5442 included in the link. We need to do this now, so that we can
5443 notice when the backend linker tries to report multiple
5444 definition errors for symbols which are in sections we aren't
5445 going to link. FIXME: It might be better to entirely ignore
5446 symbols which are defined in sections which are going to be
5447 discarded. This would require modifying the backend linker for
5448 each backend which might set the SEC_LINK_ONCE flag. If we do
5449 this, we should probably handle SEC_EXCLUDE in the same way. */
5451 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
5455 lang_add_output (const char *name
, int from_script
)
5457 /* Make -o on command line override OUTPUT in script. */
5458 if (!had_output_filename
|| !from_script
)
5460 output_filename
= name
;
5461 had_output_filename
= TRUE
;
5465 static lang_output_section_statement_type
*current_section
;
5476 for (l
= 0; l
< 32; l
++)
5478 if (i
>= (unsigned int) x
)
5486 lang_output_section_statement_type
*
5487 lang_enter_output_section_statement (const char *output_section_statement_name
,
5488 etree_type
*address_exp
,
5489 enum section_type sectype
,
5491 etree_type
*subalign
,
5495 lang_output_section_statement_type
*os
;
5497 os
= lang_output_section_statement_lookup_1 (output_section_statement_name
,
5499 current_section
= os
;
5501 /* Make next things chain into subchain of this. */
5503 if (os
->addr_tree
== NULL
)
5505 os
->addr_tree
= address_exp
;
5507 os
->sectype
= sectype
;
5508 if (sectype
!= noload_section
)
5509 os
->flags
= SEC_NO_FLAGS
;
5511 os
->flags
= SEC_NEVER_LOAD
;
5512 os
->block_value
= 1;
5513 stat_ptr
= &os
->children
;
5515 os
->subsection_alignment
=
5516 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
5517 os
->section_alignment
=
5518 topower (exp_get_value_int (align
, -1, "section alignment"));
5520 os
->load_base
= ebase
;
5527 lang_output_statement_type
*new;
5529 new = new_stat (lang_output_statement
, stat_ptr
);
5530 new->name
= output_filename
;
5533 /* Reset the current counters in the regions. */
5536 lang_reset_memory_regions (void)
5538 lang_memory_region_type
*p
= lang_memory_region_list
;
5540 lang_output_section_statement_type
*os
;
5542 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
5544 p
->current
= p
->origin
;
5548 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5552 os
->processed_vma
= FALSE
;
5553 os
->processed_lma
= FALSE
;
5556 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5558 /* Save the last size for possible use by bfd_relax_section. */
5559 o
->rawsize
= o
->size
;
5564 /* Worker for lang_gc_sections_1. */
5567 gc_section_callback (lang_wild_statement_type
*ptr
,
5568 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5570 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5571 void *data ATTRIBUTE_UNUSED
)
5573 /* If the wild pattern was marked KEEP, the member sections
5574 should be as well. */
5575 if (ptr
->keep_sections
)
5576 section
->flags
|= SEC_KEEP
;
5579 /* Iterate over sections marking them against GC. */
5582 lang_gc_sections_1 (lang_statement_union_type
*s
)
5584 for (; s
!= NULL
; s
= s
->header
.next
)
5586 switch (s
->header
.type
)
5588 case lang_wild_statement_enum
:
5589 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
5591 case lang_constructors_statement_enum
:
5592 lang_gc_sections_1 (constructor_list
.head
);
5594 case lang_output_section_statement_enum
:
5595 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
5597 case lang_group_statement_enum
:
5598 lang_gc_sections_1 (s
->group_statement
.children
.head
);
5607 lang_gc_sections (void)
5609 struct bfd_link_hash_entry
*h
;
5610 ldlang_undef_chain_list_type
*ulist
;
5612 /* Keep all sections so marked in the link script. */
5614 lang_gc_sections_1 (statement_list
.head
);
5616 /* Keep all sections containing symbols undefined on the command-line,
5617 and the section containing the entry symbol. */
5619 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
5621 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
5622 FALSE
, FALSE
, FALSE
);
5625 && (h
->type
== bfd_link_hash_defined
5626 || h
->type
== bfd_link_hash_defweak
)
5627 && ! bfd_is_abs_section (h
->u
.def
.section
))
5629 h
->u
.def
.section
->flags
|= SEC_KEEP
;
5633 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5634 the special case of debug info. (See bfd/stabs.c)
5635 Twiddle the flag here, to simplify later linker code. */
5636 if (link_info
.relocatable
)
5638 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5641 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5642 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
5643 sec
->flags
&= ~SEC_EXCLUDE
;
5647 if (link_info
.gc_sections
)
5648 bfd_gc_sections (output_bfd
, &link_info
);
5651 /* Relax all sections until bfd_relax_section gives up. */
5654 relax_sections (void)
5656 /* Keep relaxing until bfd_relax_section gives up. */
5657 bfd_boolean relax_again
;
5661 relax_again
= FALSE
;
5663 /* Note: pe-dll.c does something like this also. If you find
5664 you need to change this code, you probably need to change
5665 pe-dll.c also. DJ */
5667 /* Do all the assignments with our current guesses as to
5669 lang_do_assignments ();
5671 /* We must do this after lang_do_assignments, because it uses
5673 lang_reset_memory_regions ();
5675 /* Perform another relax pass - this time we know where the
5676 globals are, so can make a better guess. */
5677 lang_size_sections (&relax_again
, FALSE
);
5679 while (relax_again
);
5685 /* Finalize dynamic list. */
5686 if (link_info
.dynamic_list
)
5687 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
5689 current_target
= default_target
;
5691 /* Open the output file. */
5692 lang_for_each_statement (ldlang_open_output
);
5695 ldemul_create_output_section_statements ();
5697 /* Add to the hash table all undefineds on the command line. */
5698 lang_place_undefineds ();
5700 if (!bfd_section_already_linked_table_init ())
5701 einfo (_("%P%F: Failed to create hash table\n"));
5703 /* Create a bfd for each input file. */
5704 current_target
= default_target
;
5705 open_input_bfds (statement_list
.head
, FALSE
);
5707 link_info
.gc_sym_list
= &entry_symbol
;
5708 if (entry_symbol
.name
== NULL
)
5709 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
5711 ldemul_after_open ();
5713 bfd_section_already_linked_table_free ();
5715 /* Make sure that we're not mixing architectures. We call this
5716 after all the input files have been opened, but before we do any
5717 other processing, so that any operations merge_private_bfd_data
5718 does on the output file will be known during the rest of the
5722 /* Handle .exports instead of a version script if we're told to do so. */
5723 if (command_line
.version_exports_section
)
5724 lang_do_version_exports_section ();
5726 /* Build all sets based on the information gathered from the input
5728 ldctor_build_sets ();
5730 /* Remove unreferenced sections if asked to. */
5731 lang_gc_sections ();
5733 /* Size up the common data. */
5736 /* Update wild statements. */
5737 update_wild_statements (statement_list
.head
);
5739 /* Run through the contours of the script and attach input sections
5740 to the correct output sections. */
5741 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
5743 /* Find any sections not attached explicitly and handle them. */
5744 lang_place_orphans ();
5746 if (! link_info
.relocatable
)
5750 /* Merge SEC_MERGE sections. This has to be done after GC of
5751 sections, so that GCed sections are not merged, but before
5752 assigning dynamic symbols, since removing whole input sections
5754 bfd_merge_sections (output_bfd
, &link_info
);
5756 /* Look for a text section and set the readonly attribute in it. */
5757 found
= bfd_get_section_by_name (output_bfd
, ".text");
5761 if (config
.text_read_only
)
5762 found
->flags
|= SEC_READONLY
;
5764 found
->flags
&= ~SEC_READONLY
;
5768 /* Do anything special before sizing sections. This is where ELF
5769 and other back-ends size dynamic sections. */
5770 ldemul_before_allocation ();
5772 /* We must record the program headers before we try to fix the
5773 section positions, since they will affect SIZEOF_HEADERS. */
5774 lang_record_phdrs ();
5776 /* Size up the sections. */
5777 lang_size_sections (NULL
, !command_line
.relax
);
5779 /* Now run around and relax if we can. */
5780 if (command_line
.relax
)
5782 /* We may need more than one relaxation pass. */
5783 int i
= link_info
.relax_pass
;
5785 /* The backend can use it to determine the current pass. */
5786 link_info
.relax_pass
= 0;
5791 link_info
.relax_pass
++;
5794 /* Final extra sizing to report errors. */
5795 lang_do_assignments ();
5796 lang_reset_memory_regions ();
5797 lang_size_sections (NULL
, TRUE
);
5800 /* See if anything special should be done now we know how big
5802 ldemul_after_allocation ();
5804 /* Fix any .startof. or .sizeof. symbols. */
5805 lang_set_startof ();
5807 /* Do all the assignments, now that we know the final resting places
5808 of all the symbols. */
5810 lang_do_assignments ();
5814 /* Make sure that the section addresses make sense. */
5815 if (! link_info
.relocatable
5816 && command_line
.check_section_addresses
)
5817 lang_check_section_addresses ();
5822 /* EXPORTED TO YACC */
5825 lang_add_wild (struct wildcard_spec
*filespec
,
5826 struct wildcard_list
*section_list
,
5827 bfd_boolean keep_sections
)
5829 struct wildcard_list
*curr
, *next
;
5830 lang_wild_statement_type
*new;
5832 /* Reverse the list as the parser puts it back to front. */
5833 for (curr
= section_list
, section_list
= NULL
;
5835 section_list
= curr
, curr
= next
)
5837 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
5838 placed_commons
= TRUE
;
5841 curr
->next
= section_list
;
5844 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
5846 if (strcmp (filespec
->name
, "*") == 0)
5847 filespec
->name
= NULL
;
5848 else if (! wildcardp (filespec
->name
))
5849 lang_has_input_file
= TRUE
;
5852 new = new_stat (lang_wild_statement
, stat_ptr
);
5853 new->filename
= NULL
;
5854 new->filenames_sorted
= FALSE
;
5855 if (filespec
!= NULL
)
5857 new->filename
= filespec
->name
;
5858 new->filenames_sorted
= filespec
->sorted
== by_name
;
5860 new->section_list
= section_list
;
5861 new->keep_sections
= keep_sections
;
5862 lang_list_init (&new->children
);
5863 analyze_walk_wild_section_handler (new);
5867 lang_section_start (const char *name
, etree_type
*address
,
5868 const segment_type
*segment
)
5870 lang_address_statement_type
*ad
;
5872 ad
= new_stat (lang_address_statement
, stat_ptr
);
5873 ad
->section_name
= name
;
5874 ad
->address
= address
;
5875 ad
->segment
= segment
;
5878 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5879 because of a -e argument on the command line, or zero if this is
5880 called by ENTRY in a linker script. Command line arguments take
5884 lang_add_entry (const char *name
, bfd_boolean cmdline
)
5886 if (entry_symbol
.name
== NULL
5888 || ! entry_from_cmdline
)
5890 entry_symbol
.name
= name
;
5891 entry_from_cmdline
= cmdline
;
5895 /* Set the default start symbol to NAME. .em files should use this,
5896 not lang_add_entry, to override the use of "start" if neither the
5897 linker script nor the command line specifies an entry point. NAME
5898 must be permanently allocated. */
5900 lang_default_entry (const char *name
)
5902 entry_symbol_default
= name
;
5906 lang_add_target (const char *name
)
5908 lang_target_statement_type
*new;
5910 new = new_stat (lang_target_statement
, stat_ptr
);
5915 lang_add_map (const char *name
)
5922 map_option_f
= TRUE
;
5930 lang_add_fill (fill_type
*fill
)
5932 lang_fill_statement_type
*new;
5934 new = new_stat (lang_fill_statement
, stat_ptr
);
5939 lang_add_data (int type
, union etree_union
*exp
)
5941 lang_data_statement_type
*new;
5943 new = new_stat (lang_data_statement
, stat_ptr
);
5948 /* Create a new reloc statement. RELOC is the BFD relocation type to
5949 generate. HOWTO is the corresponding howto structure (we could
5950 look this up, but the caller has already done so). SECTION is the
5951 section to generate a reloc against, or NAME is the name of the
5952 symbol to generate a reloc against. Exactly one of SECTION and
5953 NAME must be NULL. ADDEND is an expression for the addend. */
5956 lang_add_reloc (bfd_reloc_code_real_type reloc
,
5957 reloc_howto_type
*howto
,
5960 union etree_union
*addend
)
5962 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
5966 p
->section
= section
;
5968 p
->addend_exp
= addend
;
5970 p
->addend_value
= 0;
5971 p
->output_section
= NULL
;
5972 p
->output_offset
= 0;
5975 lang_assignment_statement_type
*
5976 lang_add_assignment (etree_type
*exp
)
5978 lang_assignment_statement_type
*new;
5980 new = new_stat (lang_assignment_statement
, stat_ptr
);
5986 lang_add_attribute (enum statement_enum attribute
)
5988 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
5992 lang_startup (const char *name
)
5994 if (startup_file
!= NULL
)
5996 einfo (_("%P%F: multiple STARTUP files\n"));
5998 first_file
->filename
= name
;
5999 first_file
->local_sym_name
= name
;
6000 first_file
->real
= TRUE
;
6002 startup_file
= name
;
6006 lang_float (bfd_boolean maybe
)
6008 lang_float_flag
= maybe
;
6012 /* Work out the load- and run-time regions from a script statement, and
6013 store them in *LMA_REGION and *REGION respectively.
6015 MEMSPEC is the name of the run-time region, or the value of
6016 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6017 LMA_MEMSPEC is the name of the load-time region, or null if the
6018 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6019 had an explicit load address.
6021 It is an error to specify both a load region and a load address. */
6024 lang_get_regions (lang_memory_region_type
**region
,
6025 lang_memory_region_type
**lma_region
,
6026 const char *memspec
,
6027 const char *lma_memspec
,
6028 bfd_boolean have_lma
,
6029 bfd_boolean have_vma
)
6031 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
6033 /* If no runtime region or VMA has been specified, but the load region
6034 has been specified, then use the load region for the runtime region
6036 if (lma_memspec
!= NULL
6038 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6039 *region
= *lma_region
;
6041 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6043 if (have_lma
&& lma_memspec
!= 0)
6044 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6048 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6049 lang_output_section_phdr_list
*phdrs
,
6050 const char *lma_memspec
)
6052 lang_get_regions (¤t_section
->region
,
6053 ¤t_section
->lma_region
,
6054 memspec
, lma_memspec
,
6055 current_section
->load_base
!= NULL
,
6056 current_section
->addr_tree
!= NULL
);
6057 current_section
->fill
= fill
;
6058 current_section
->phdrs
= phdrs
;
6059 stat_ptr
= &statement_list
;
6062 /* Create an absolute symbol with the given name with the value of the
6063 address of first byte of the section named.
6065 If the symbol already exists, then do nothing. */
6068 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6070 struct bfd_link_hash_entry
*h
;
6072 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6074 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6076 if (h
->type
== bfd_link_hash_new
6077 || h
->type
== bfd_link_hash_undefined
)
6081 h
->type
= bfd_link_hash_defined
;
6083 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6087 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
6089 h
->u
.def
.section
= bfd_abs_section_ptr
;
6093 /* Create an absolute symbol with the given name with the value of the
6094 address of the first byte after the end of the section named.
6096 If the symbol already exists, then do nothing. */
6099 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6101 struct bfd_link_hash_entry
*h
;
6103 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6105 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6107 if (h
->type
== bfd_link_hash_new
6108 || h
->type
== bfd_link_hash_undefined
)
6112 h
->type
= bfd_link_hash_defined
;
6114 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6118 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
6119 + TO_ADDR (sec
->size
));
6121 h
->u
.def
.section
= bfd_abs_section_ptr
;
6126 lang_statement_append (lang_statement_list_type
*list
,
6127 lang_statement_union_type
*element
,
6128 lang_statement_union_type
**field
)
6130 *(list
->tail
) = element
;
6134 /* Set the output format type. -oformat overrides scripts. */
6137 lang_add_output_format (const char *format
,
6142 if (output_target
== NULL
|| !from_script
)
6144 if (command_line
.endian
== ENDIAN_BIG
6147 else if (command_line
.endian
== ENDIAN_LITTLE
6151 output_target
= format
;
6155 /* Enter a group. This creates a new lang_group_statement, and sets
6156 stat_ptr to build new statements within the group. */
6159 lang_enter_group (void)
6161 lang_group_statement_type
*g
;
6163 g
= new_stat (lang_group_statement
, stat_ptr
);
6164 lang_list_init (&g
->children
);
6165 stat_ptr
= &g
->children
;
6168 /* Leave a group. This just resets stat_ptr to start writing to the
6169 regular list of statements again. Note that this will not work if
6170 groups can occur inside anything else which can adjust stat_ptr,
6171 but currently they can't. */
6174 lang_leave_group (void)
6176 stat_ptr
= &statement_list
;
6179 /* Add a new program header. This is called for each entry in a PHDRS
6180 command in a linker script. */
6183 lang_new_phdr (const char *name
,
6185 bfd_boolean filehdr
,
6190 struct lang_phdr
*n
, **pp
;
6192 n
= stat_alloc (sizeof (struct lang_phdr
));
6195 n
->type
= exp_get_value_int (type
, 0, "program header type");
6196 n
->filehdr
= filehdr
;
6201 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6206 /* Record the program header information in the output BFD. FIXME: We
6207 should not be calling an ELF specific function here. */
6210 lang_record_phdrs (void)
6214 lang_output_section_phdr_list
*last
;
6215 struct lang_phdr
*l
;
6216 lang_output_section_statement_type
*os
;
6219 secs
= xmalloc (alc
* sizeof (asection
*));
6222 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
6229 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6233 lang_output_section_phdr_list
*pl
;
6235 if (os
->constraint
== -1)
6243 if (os
->sectype
== noload_section
6244 || os
->bfd_section
== NULL
6245 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
6252 lang_output_section_statement_type
* tmp_os
;
6254 /* If we have not run across a section with a program
6255 header assigned to it yet, then scan forwards to find
6256 one. This prevents inconsistencies in the linker's
6257 behaviour when a script has specified just a single
6258 header and there are sections in that script which are
6259 not assigned to it, and which occur before the first
6260 use of that header. See here for more details:
6261 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6262 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
6269 if (os
->bfd_section
== NULL
)
6272 for (; pl
!= NULL
; pl
= pl
->next
)
6274 if (strcmp (pl
->name
, l
->name
) == 0)
6279 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
6281 secs
[c
] = os
->bfd_section
;
6288 if (l
->flags
== NULL
)
6291 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
6296 at
= exp_get_vma (l
->at
, 0, "phdr load address");
6298 if (! bfd_record_phdr (output_bfd
, l
->type
,
6299 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
6300 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
6301 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6306 /* Make sure all the phdr assignments succeeded. */
6307 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6311 lang_output_section_phdr_list
*pl
;
6313 if (os
->constraint
== -1
6314 || os
->bfd_section
== NULL
)
6317 for (pl
= os
->phdrs
;
6320 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
6321 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6322 os
->name
, pl
->name
);
6326 /* Record a list of sections which may not be cross referenced. */
6329 lang_add_nocrossref (lang_nocrossref_type
*l
)
6331 struct lang_nocrossrefs
*n
;
6333 n
= xmalloc (sizeof *n
);
6334 n
->next
= nocrossref_list
;
6336 nocrossref_list
= n
;
6338 /* Set notice_all so that we get informed about all symbols. */
6339 link_info
.notice_all
= TRUE
;
6342 /* Overlay handling. We handle overlays with some static variables. */
6344 /* The overlay virtual address. */
6345 static etree_type
*overlay_vma
;
6346 /* And subsection alignment. */
6347 static etree_type
*overlay_subalign
;
6349 /* An expression for the maximum section size seen so far. */
6350 static etree_type
*overlay_max
;
6352 /* A list of all the sections in this overlay. */
6354 struct overlay_list
{
6355 struct overlay_list
*next
;
6356 lang_output_section_statement_type
*os
;
6359 static struct overlay_list
*overlay_list
;
6361 /* Start handling an overlay. */
6364 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
6366 /* The grammar should prevent nested overlays from occurring. */
6367 ASSERT (overlay_vma
== NULL
6368 && overlay_subalign
== NULL
6369 && overlay_max
== NULL
);
6371 overlay_vma
= vma_expr
;
6372 overlay_subalign
= subalign
;
6375 /* Start a section in an overlay. We handle this by calling
6376 lang_enter_output_section_statement with the correct VMA.
6377 lang_leave_overlay sets up the LMA and memory regions. */
6380 lang_enter_overlay_section (const char *name
)
6382 struct overlay_list
*n
;
6385 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
6386 0, overlay_subalign
, 0, 0);
6388 /* If this is the first section, then base the VMA of future
6389 sections on this one. This will work correctly even if `.' is
6390 used in the addresses. */
6391 if (overlay_list
== NULL
)
6392 overlay_vma
= exp_nameop (ADDR
, name
);
6394 /* Remember the section. */
6395 n
= xmalloc (sizeof *n
);
6396 n
->os
= current_section
;
6397 n
->next
= overlay_list
;
6400 size
= exp_nameop (SIZEOF
, name
);
6402 /* Arrange to work out the maximum section end address. */
6403 if (overlay_max
== NULL
)
6406 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
6409 /* Finish a section in an overlay. There isn't any special to do
6413 lang_leave_overlay_section (fill_type
*fill
,
6414 lang_output_section_phdr_list
*phdrs
)
6421 name
= current_section
->name
;
6423 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6424 region and that no load-time region has been specified. It doesn't
6425 really matter what we say here, since lang_leave_overlay will
6427 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
6429 /* Define the magic symbols. */
6431 clean
= xmalloc (strlen (name
) + 1);
6433 for (s1
= name
; *s1
!= '\0'; s1
++)
6434 if (ISALNUM (*s1
) || *s1
== '_')
6438 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
6439 sprintf (buf
, "__load_start_%s", clean
);
6440 lang_add_assignment (exp_provide (buf
,
6441 exp_nameop (LOADADDR
, name
),
6444 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
6445 sprintf (buf
, "__load_stop_%s", clean
);
6446 lang_add_assignment (exp_provide (buf
,
6448 exp_nameop (LOADADDR
, name
),
6449 exp_nameop (SIZEOF
, name
)),
6455 /* Finish an overlay. If there are any overlay wide settings, this
6456 looks through all the sections in the overlay and sets them. */
6459 lang_leave_overlay (etree_type
*lma_expr
,
6462 const char *memspec
,
6463 lang_output_section_phdr_list
*phdrs
,
6464 const char *lma_memspec
)
6466 lang_memory_region_type
*region
;
6467 lang_memory_region_type
*lma_region
;
6468 struct overlay_list
*l
;
6469 lang_nocrossref_type
*nocrossref
;
6471 lang_get_regions (®ion
, &lma_region
,
6472 memspec
, lma_memspec
,
6473 lma_expr
!= NULL
, FALSE
);
6477 /* After setting the size of the last section, set '.' to end of the
6479 if (overlay_list
!= NULL
)
6480 overlay_list
->os
->update_dot_tree
6481 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
6486 struct overlay_list
*next
;
6488 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
6491 l
->os
->region
= region
;
6492 l
->os
->lma_region
= lma_region
;
6494 /* The first section has the load address specified in the
6495 OVERLAY statement. The rest are worked out from that.
6496 The base address is not needed (and should be null) if
6497 an LMA region was specified. */
6499 l
->os
->load_base
= lma_expr
;
6500 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
6501 l
->os
->phdrs
= phdrs
;
6505 lang_nocrossref_type
*nc
;
6507 nc
= xmalloc (sizeof *nc
);
6508 nc
->name
= l
->os
->name
;
6509 nc
->next
= nocrossref
;
6518 if (nocrossref
!= NULL
)
6519 lang_add_nocrossref (nocrossref
);
6522 overlay_list
= NULL
;
6526 /* Version handling. This is only useful for ELF. */
6528 /* This global variable holds the version tree that we build. */
6530 struct bfd_elf_version_tree
*lang_elf_version_info
;
6532 /* If PREV is NULL, return first version pattern matching particular symbol.
6533 If PREV is non-NULL, return first version pattern matching particular
6534 symbol after PREV (previously returned by lang_vers_match). */
6536 static struct bfd_elf_version_expr
*
6537 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
6538 struct bfd_elf_version_expr
*prev
,
6541 const char *cxx_sym
= sym
;
6542 const char *java_sym
= sym
;
6543 struct bfd_elf_version_expr
*expr
= NULL
;
6545 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6547 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
6551 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6553 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
6558 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
6560 struct bfd_elf_version_expr e
;
6562 switch (prev
? prev
->mask
: 0)
6565 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
6568 expr
= htab_find (head
->htab
, &e
);
6569 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
6570 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
6576 case BFD_ELF_VERSION_C_TYPE
:
6577 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6580 expr
= htab_find (head
->htab
, &e
);
6581 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
6582 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6588 case BFD_ELF_VERSION_CXX_TYPE
:
6589 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6591 e
.symbol
= java_sym
;
6592 expr
= htab_find (head
->htab
, &e
);
6593 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
6594 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6605 /* Finally, try the wildcards. */
6606 if (prev
== NULL
|| prev
->symbol
)
6607 expr
= head
->remaining
;
6610 for (; expr
; expr
= expr
->next
)
6617 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
6620 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6622 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6626 if (fnmatch (expr
->pattern
, s
, 0) == 0)
6632 free ((char *) cxx_sym
);
6633 if (java_sym
!= sym
)
6634 free ((char *) java_sym
);
6638 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6639 return a string pointing to the symbol name. */
6642 realsymbol (const char *pattern
)
6645 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
6646 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
6648 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
6650 /* It is a glob pattern only if there is no preceding
6652 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
6660 /* Remove the preceding backslash. */
6667 backslash
= *p
== '\\';
6682 /* This is called for each variable name or match expression. NEW is
6683 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6684 pattern to be matched against symbol names. */
6686 struct bfd_elf_version_expr
*
6687 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
6690 bfd_boolean literal_p
)
6692 struct bfd_elf_version_expr
*ret
;
6694 ret
= xmalloc (sizeof *ret
);
6696 ret
->pattern
= literal_p
? NULL
: new;
6699 ret
->symbol
= literal_p
? new : realsymbol (new);
6701 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
6702 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6703 else if (strcasecmp (lang
, "C++") == 0)
6704 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
6705 else if (strcasecmp (lang
, "Java") == 0)
6706 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
6709 einfo (_("%X%P: unknown language `%s' in version information\n"),
6711 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6714 return ldemul_new_vers_pattern (ret
);
6717 /* This is called for each set of variable names and match
6720 struct bfd_elf_version_tree
*
6721 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
6722 struct bfd_elf_version_expr
*locals
)
6724 struct bfd_elf_version_tree
*ret
;
6726 ret
= xcalloc (1, sizeof *ret
);
6727 ret
->globals
.list
= globals
;
6728 ret
->locals
.list
= locals
;
6729 ret
->match
= lang_vers_match
;
6730 ret
->name_indx
= (unsigned int) -1;
6734 /* This static variable keeps track of version indices. */
6736 static int version_index
;
6739 version_expr_head_hash (const void *p
)
6741 const struct bfd_elf_version_expr
*e
= p
;
6743 return htab_hash_string (e
->symbol
);
6747 version_expr_head_eq (const void *p1
, const void *p2
)
6749 const struct bfd_elf_version_expr
*e1
= p1
;
6750 const struct bfd_elf_version_expr
*e2
= p2
;
6752 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
6756 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
6759 struct bfd_elf_version_expr
*e
, *next
;
6760 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
6762 for (e
= head
->list
; e
; e
= e
->next
)
6766 head
->mask
|= e
->mask
;
6771 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
6772 version_expr_head_eq
, NULL
);
6773 list_loc
= &head
->list
;
6774 remaining_loc
= &head
->remaining
;
6775 for (e
= head
->list
; e
; e
= next
)
6781 remaining_loc
= &e
->next
;
6785 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
6789 struct bfd_elf_version_expr
*e1
, *last
;
6795 if (e1
->mask
== e
->mask
)
6803 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
6807 /* This is a duplicate. */
6808 /* FIXME: Memory leak. Sometimes pattern is not
6809 xmalloced alone, but in larger chunk of memory. */
6810 /* free (e->symbol); */
6815 e
->next
= last
->next
;
6823 list_loc
= &e
->next
;
6827 *remaining_loc
= NULL
;
6828 *list_loc
= head
->remaining
;
6831 head
->remaining
= head
->list
;
6834 /* This is called when we know the name and dependencies of the
6838 lang_register_vers_node (const char *name
,
6839 struct bfd_elf_version_tree
*version
,
6840 struct bfd_elf_version_deps
*deps
)
6842 struct bfd_elf_version_tree
*t
, **pp
;
6843 struct bfd_elf_version_expr
*e1
;
6848 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
6849 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
6851 einfo (_("%X%P: anonymous version tag cannot be combined"
6852 " with other version tags\n"));
6857 /* Make sure this node has a unique name. */
6858 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6859 if (strcmp (t
->name
, name
) == 0)
6860 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
6862 lang_finalize_version_expr_head (&version
->globals
);
6863 lang_finalize_version_expr_head (&version
->locals
);
6865 /* Check the global and local match names, and make sure there
6866 aren't any duplicates. */
6868 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
6870 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6872 struct bfd_elf_version_expr
*e2
;
6874 if (t
->locals
.htab
&& e1
->symbol
)
6876 e2
= htab_find (t
->locals
.htab
, e1
);
6877 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6879 if (e1
->mask
== e2
->mask
)
6880 einfo (_("%X%P: duplicate expression `%s'"
6881 " in version information\n"), e1
->symbol
);
6885 else if (!e1
->symbol
)
6886 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6887 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6888 && e1
->mask
== e2
->mask
)
6889 einfo (_("%X%P: duplicate expression `%s'"
6890 " in version information\n"), e1
->pattern
);
6894 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
6896 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6898 struct bfd_elf_version_expr
*e2
;
6900 if (t
->globals
.htab
&& e1
->symbol
)
6902 e2
= htab_find (t
->globals
.htab
, e1
);
6903 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6905 if (e1
->mask
== e2
->mask
)
6906 einfo (_("%X%P: duplicate expression `%s'"
6907 " in version information\n"),
6912 else if (!e1
->symbol
)
6913 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6914 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6915 && e1
->mask
== e2
->mask
)
6916 einfo (_("%X%P: duplicate expression `%s'"
6917 " in version information\n"), e1
->pattern
);
6921 version
->deps
= deps
;
6922 version
->name
= name
;
6923 if (name
[0] != '\0')
6926 version
->vernum
= version_index
;
6929 version
->vernum
= 0;
6931 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6936 /* This is called when we see a version dependency. */
6938 struct bfd_elf_version_deps
*
6939 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
6941 struct bfd_elf_version_deps
*ret
;
6942 struct bfd_elf_version_tree
*t
;
6944 ret
= xmalloc (sizeof *ret
);
6947 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6949 if (strcmp (t
->name
, name
) == 0)
6951 ret
->version_needed
= t
;
6956 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
6962 lang_do_version_exports_section (void)
6964 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
6966 LANG_FOR_EACH_INPUT_STATEMENT (is
)
6968 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
6976 contents
= xmalloc (len
);
6977 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
6978 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
6981 while (p
< contents
+ len
)
6983 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
6984 p
= strchr (p
, '\0') + 1;
6987 /* Do not free the contents, as we used them creating the regex. */
6989 /* Do not include this section in the link. */
6990 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
6993 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
6994 lang_register_vers_node (command_line
.version_exports_section
,
6995 lang_new_vers_node (greg
, lreg
), NULL
);
6999 lang_add_unique (const char *name
)
7001 struct unique_sections
*ent
;
7003 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
7004 if (strcmp (ent
->name
, name
) == 0)
7007 ent
= xmalloc (sizeof *ent
);
7008 ent
->name
= xstrdup (name
);
7009 ent
->next
= unique_section_list
;
7010 unique_section_list
= ent
;
7013 /* Append the list of dynamic symbols to the existing one. */
7016 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
7018 if (link_info
.dynamic_list
)
7020 struct bfd_elf_version_expr
*tail
;
7021 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
7023 tail
->next
= link_info
.dynamic_list
->head
.list
;
7024 link_info
.dynamic_list
->head
.list
= dynamic
;
7028 struct bfd_elf_dynamic_list
*d
;
7030 d
= xcalloc (1, sizeof *d
);
7031 d
->head
.list
= dynamic
;
7032 d
->match
= lang_vers_match
;
7033 link_info
.dynamic_list
= d
;
7037 /* Append the list of C++ typeinfo dynamic symbols to the existing
7041 lang_append_dynamic_list_cpp_typeinfo (void)
7043 const char * symbols
[] =
7045 "typeinfo name for*",
7048 struct bfd_elf_version_expr
*dynamic
= NULL
;
7051 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7052 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7055 lang_append_dynamic_list (dynamic
);
7058 /* Append the list of C++ operator new and delete dynamic symbols to the
7062 lang_append_dynamic_list_cpp_new (void)
7064 const char * symbols
[] =
7069 struct bfd_elf_version_expr
*dynamic
= NULL
;
7072 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7073 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7076 lang_append_dynamic_list (dynamic
);