1 /* Linker command language support.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "safe-ctype.h"
45 #if BFD_SUPPORTS_PLUGINS
47 #endif /* BFD_SUPPORTS_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Convert between addresses in bytes and sizes in octets.
54 For currently supported targets, octets_per_byte is always a power
55 of two, so we can use shifts. */
56 #define TO_ADDR(X) ((X) >> opb_shift)
57 #define TO_SIZE(X) ((X) << opb_shift)
59 /* Local variables. */
60 static struct obstack stat_obstack
;
61 static struct obstack map_obstack
;
63 #define obstack_chunk_alloc xmalloc
64 #define obstack_chunk_free free
65 static const char *entry_symbol_default
= "start";
66 static bfd_boolean map_head_is_link_order
= FALSE
;
67 static lang_output_section_statement_type
*default_common_section
;
68 static bfd_boolean map_option_f
;
69 static bfd_vma print_dot
;
70 static lang_input_statement_type
*first_file
;
71 static const char *current_target
;
72 /* Header for list of statements corresponding to any files involved in the
73 link, either specified from the command-line or added implicitely (eg.
74 archive member used to resolved undefined symbol, wildcard statement from
75 linker script, etc.). Next pointer is in next field of a
76 lang_statement_header_type (reached via header field in a
77 lang_statement_union). */
78 static lang_statement_list_type statement_list
;
79 static lang_statement_list_type
*stat_save
[10];
80 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
81 static struct unique_sections
*unique_section_list
;
82 static struct asneeded_minfo
*asneeded_list_head
;
83 static unsigned int opb_shift
= 0;
85 /* Forward declarations. */
86 static void exp_init_os (etree_type
*);
87 static lang_input_statement_type
*lookup_name (const char *);
88 static void insert_undefined (const char *);
89 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
90 static void print_statement (lang_statement_union_type
*,
91 lang_output_section_statement_type
*);
92 static void print_statement_list (lang_statement_union_type
*,
93 lang_output_section_statement_type
*);
94 static void print_statements (void);
95 static void print_input_section (asection
*, bfd_boolean
);
96 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
97 static void lang_record_phdrs (void);
98 static void lang_do_version_exports_section (void);
99 static void lang_finalize_version_expr_head
100 (struct bfd_elf_version_expr_head
*);
101 static void lang_do_memory_regions (void);
103 /* Exported variables. */
104 const char *output_target
;
105 lang_output_section_statement_type
*abs_output_section
;
106 lang_statement_list_type lang_os_list
;
107 lang_statement_list_type
*stat_ptr
= &statement_list
;
108 /* Header for list of statements corresponding to files used in the final
109 executable. This can be either object file specified on the command-line
110 or library member resolving an undefined reference. Next pointer is in next
111 field of a lang_input_statement_type (reached via input_statement field in a
112 lang_statement_union). */
113 lang_statement_list_type file_chain
= { NULL
, NULL
};
114 /* Header for list of statements corresponding to files specified on the
115 command-line for linking. It thus contains real object files and archive
116 but not archive members. Next pointer is in next_real_file field of a
117 lang_input_statement_type statement (reached via input_statement field in a
118 lang_statement_union). */
119 lang_statement_list_type input_file_chain
;
120 static const char *current_input_file
;
121 struct bfd_elf_dynamic_list
**current_dynamic_list_p
;
122 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
123 const char *entry_section
= ".text";
124 struct lang_input_statement_flags input_flags
;
125 bfd_boolean entry_from_cmdline
;
126 bfd_boolean undef_from_cmdline
;
127 bfd_boolean lang_has_input_file
= FALSE
;
128 bfd_boolean had_output_filename
= FALSE
;
129 bfd_boolean lang_float_flag
= FALSE
;
130 bfd_boolean delete_output_file_on_failure
= FALSE
;
131 struct lang_phdr
*lang_phdr_list
;
132 struct lang_nocrossrefs
*nocrossref_list
;
133 struct asneeded_minfo
**asneeded_list_tail
;
134 static ctf_file_t
*ctf_output
;
136 /* Functions that traverse the linker script and might evaluate
137 DEFINED() need to increment this at the start of the traversal. */
138 int lang_statement_iteration
= 0;
140 /* Count times through one_lang_size_sections_pass after mark phase. */
141 static int lang_sizing_iteration
= 0;
143 /* Return TRUE if the PATTERN argument is a wildcard pattern.
144 Although backslashes are treated specially if a pattern contains
145 wildcards, we do not consider the mere presence of a backslash to
146 be enough to cause the pattern to be treated as a wildcard.
147 That lets us handle DOS filenames more naturally. */
148 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
150 #define new_stat(x, y) \
151 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
153 #define outside_section_address(q) \
154 ((q)->output_offset + (q)->output_section->vma)
156 #define outside_symbol_address(q) \
157 ((q)->value + outside_section_address (q->section))
159 /* CTF sections smaller than this are not compressed: compression of
160 dictionaries this small doesn't gain much, and this lets consumers mmap the
161 sections directly out of the ELF file and use them with no decompression
162 overhead if they want to. */
163 #define CTF_COMPRESSION_THRESHOLD 4096
166 stat_alloc (size_t size
)
168 return obstack_alloc (&stat_obstack
, size
);
172 name_match (const char *pattern
, const char *name
)
174 if (wildcardp (pattern
))
175 return fnmatch (pattern
, name
, 0);
176 return strcmp (pattern
, name
);
180 ldirname (const char *name
)
182 const char *base
= lbasename (name
);
185 while (base
> name
&& IS_DIR_SEPARATOR (base
[-1]))
189 dirname
= strdup (name
);
190 dirname
[base
- name
] = '\0';
194 /* If PATTERN is of the form archive:file, return a pointer to the
195 separator. If not, return NULL. */
198 archive_path (const char *pattern
)
202 if (link_info
.path_separator
== 0)
205 p
= strchr (pattern
, link_info
.path_separator
);
206 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
207 if (p
== NULL
|| link_info
.path_separator
!= ':')
210 /* Assume a match on the second char is part of drive specifier,
211 as in "c:\silly.dos". */
212 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
213 p
= strchr (p
+ 1, link_info
.path_separator
);
218 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
219 return whether F matches FILE_SPEC. */
222 input_statement_is_archive_path (const char *file_spec
, char *sep
,
223 lang_input_statement_type
*f
)
225 bfd_boolean match
= FALSE
;
228 || name_match (sep
+ 1, f
->filename
) == 0)
229 && ((sep
!= file_spec
)
230 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
234 if (sep
!= file_spec
)
236 const char *aname
= bfd_get_filename (f
->the_bfd
->my_archive
);
238 match
= name_match (file_spec
, aname
) == 0;
239 *sep
= link_info
.path_separator
;
246 unique_section_p (const asection
*sec
,
247 const lang_output_section_statement_type
*os
)
249 struct unique_sections
*unam
;
252 if (!link_info
.resolve_section_groups
253 && sec
->owner
!= NULL
254 && bfd_is_group_section (sec
->owner
, sec
))
256 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
259 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
260 if (name_match (unam
->name
, secnam
) == 0)
266 /* Generic traversal routines for finding matching sections. */
268 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
272 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
273 lang_input_statement_type
*file
)
275 struct name_list
*list_tmp
;
277 for (list_tmp
= exclude_list
;
279 list_tmp
= list_tmp
->next
)
281 char *p
= archive_path (list_tmp
->name
);
285 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
289 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
292 /* FIXME: Perhaps remove the following at some stage? Matching
293 unadorned archives like this was never documented and has
294 been superceded by the archive:path syntax. */
295 else if (file
->the_bfd
!= NULL
296 && file
->the_bfd
->my_archive
!= NULL
297 && name_match (list_tmp
->name
,
298 bfd_get_filename (file
->the_bfd
->my_archive
)) == 0)
305 /* Try processing a section against a wildcard. This just calls
306 the callback unless the filename exclusion list is present
307 and excludes the file. It's hardly ever present so this
308 function is very fast. */
311 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
312 lang_input_statement_type
*file
,
314 struct wildcard_list
*sec
,
318 /* Don't process sections from files which were excluded. */
319 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
322 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
325 /* Lowest common denominator routine that can handle everything correctly,
329 walk_wild_section_general (lang_wild_statement_type
*ptr
,
330 lang_input_statement_type
*file
,
335 struct wildcard_list
*sec
;
337 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
339 sec
= ptr
->section_list
;
341 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
345 bfd_boolean skip
= FALSE
;
347 if (sec
->spec
.name
!= NULL
)
349 const char *sname
= bfd_section_name (s
);
351 skip
= name_match (sec
->spec
.name
, sname
) != 0;
355 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
362 /* Routines to find a single section given its name. If there's more
363 than one section with that name, we report that. */
367 asection
*found_section
;
368 bfd_boolean multiple_sections_found
;
369 } section_iterator_callback_data
;
372 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
374 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
376 if (d
->found_section
!= NULL
)
378 d
->multiple_sections_found
= TRUE
;
382 d
->found_section
= s
;
387 find_section (lang_input_statement_type
*file
,
388 struct wildcard_list
*sec
,
389 bfd_boolean
*multiple_sections_found
)
391 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
393 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
394 section_iterator_callback
, &cb_data
);
395 *multiple_sections_found
= cb_data
.multiple_sections_found
;
396 return cb_data
.found_section
;
399 /* Code for handling simple wildcards without going through fnmatch,
400 which can be expensive because of charset translations etc. */
402 /* A simple wild is a literal string followed by a single '*',
403 where the literal part is at least 4 characters long. */
406 is_simple_wild (const char *name
)
408 size_t len
= strcspn (name
, "*?[");
409 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
413 match_simple_wild (const char *pattern
, const char *name
)
415 /* The first four characters of the pattern are guaranteed valid
416 non-wildcard characters. So we can go faster. */
417 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
418 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
423 while (*pattern
!= '*')
424 if (*name
++ != *pattern
++)
430 /* Return the numerical value of the init_priority attribute from
431 section name NAME. */
434 get_init_priority (const asection
*sec
)
436 const char *name
= bfd_section_name (sec
);
439 /* GCC uses the following section names for the init_priority
440 attribute with numerical values 101 to 65535 inclusive. A
441 lower value means a higher priority.
443 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
444 decimal numerical value of the init_priority attribute.
445 The order of execution in .init_array is forward and
446 .fini_array is backward.
447 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
448 decimal numerical value of the init_priority attribute.
449 The order of execution in .ctors is backward and .dtors
452 .init_array.NNNNN sections would normally be placed in an output
453 .init_array section, .fini_array.NNNNN in .fini_array,
454 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
455 we should sort by increasing number (and could just use
456 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
457 being placed in .init_array (which may also contain
458 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
459 placed in .fini_array then we need to extract the init_priority
460 attribute and sort on that. */
461 dot
= strrchr (name
, '.');
462 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
465 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
469 && (strncmp (name
, ".ctors", 6) == 0
470 || strncmp (name
, ".dtors", 6) == 0))
471 init_priority
= 65535 - init_priority
;
472 if (init_priority
<= INT_MAX
)
473 return init_priority
;
479 /* Compare sections ASEC and BSEC according to SORT. */
482 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
485 int a_priority
, b_priority
;
492 case by_init_priority
:
493 a_priority
= get_init_priority (asec
);
494 b_priority
= get_init_priority (bsec
);
495 if (a_priority
< 0 || b_priority
< 0)
497 ret
= a_priority
- b_priority
;
503 case by_alignment_name
:
504 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
511 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
514 case by_name_alignment
:
515 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
521 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
528 /* Build a Binary Search Tree to sort sections, unlike insertion sort
529 used in wild_sort(). BST is considerably faster if the number of
530 of sections are large. */
532 static lang_section_bst_type
**
533 wild_sort_fast (lang_wild_statement_type
*wild
,
534 struct wildcard_list
*sec
,
535 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
538 lang_section_bst_type
**tree
;
541 if (!wild
->filenames_sorted
542 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
544 /* Append at the right end of tree. */
546 tree
= &((*tree
)->right
);
552 /* Find the correct node to append this section. */
553 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
554 tree
= &((*tree
)->left
);
556 tree
= &((*tree
)->right
);
562 /* Use wild_sort_fast to build a BST to sort sections. */
565 output_section_callback_fast (lang_wild_statement_type
*ptr
,
566 struct wildcard_list
*sec
,
568 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
569 lang_input_statement_type
*file
,
572 lang_section_bst_type
*node
;
573 lang_section_bst_type
**tree
;
574 lang_output_section_statement_type
*os
;
576 os
= (lang_output_section_statement_type
*) output
;
578 if (unique_section_p (section
, os
))
581 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
584 node
->section
= section
;
586 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
591 /* Convert a sorted sections' BST back to list form. */
594 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
595 lang_section_bst_type
*tree
,
599 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
601 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
602 (lang_output_section_statement_type
*) output
);
605 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
610 /* Specialized, optimized routines for handling different kinds of
614 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
615 lang_input_statement_type
*file
,
619 /* We can just do a hash lookup for the section with the right name.
620 But if that lookup discovers more than one section with the name
621 (should be rare), we fall back to the general algorithm because
622 we would otherwise have to sort the sections to make sure they
623 get processed in the bfd's order. */
624 bfd_boolean multiple_sections_found
;
625 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
626 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
628 if (multiple_sections_found
)
629 walk_wild_section_general (ptr
, file
, callback
, data
);
631 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
635 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
636 lang_input_statement_type
*file
,
641 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
643 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
645 const char *sname
= bfd_section_name (s
);
646 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
649 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
654 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
655 lang_input_statement_type
*file
,
660 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
661 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
662 bfd_boolean multiple_sections_found
;
663 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
665 if (multiple_sections_found
)
667 walk_wild_section_general (ptr
, file
, callback
, data
);
671 /* Note that if the section was not found, s0 is NULL and
672 we'll simply never succeed the s == s0 test below. */
673 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
675 /* Recall that in this code path, a section cannot satisfy more
676 than one spec, so if s == s0 then it cannot match
679 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
682 const char *sname
= bfd_section_name (s
);
683 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
686 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
693 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
694 lang_input_statement_type
*file
,
699 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
700 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
701 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
702 bfd_boolean multiple_sections_found
;
703 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
705 if (multiple_sections_found
)
707 walk_wild_section_general (ptr
, file
, callback
, data
);
711 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
714 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
717 const char *sname
= bfd_section_name (s
);
718 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
721 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
724 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
726 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
734 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
735 lang_input_statement_type
*file
,
740 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
741 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
742 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
743 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
744 bfd_boolean multiple_sections_found
;
745 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
747 if (multiple_sections_found
)
749 walk_wild_section_general (ptr
, file
, callback
, data
);
753 s1
= find_section (file
, sec1
, &multiple_sections_found
);
754 if (multiple_sections_found
)
756 walk_wild_section_general (ptr
, file
, callback
, data
);
760 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
763 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
766 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
769 const char *sname
= bfd_section_name (s
);
770 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
774 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
778 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
780 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
788 walk_wild_section (lang_wild_statement_type
*ptr
,
789 lang_input_statement_type
*file
,
793 if (file
->flags
.just_syms
)
796 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
799 /* Returns TRUE when name1 is a wildcard spec that might match
800 something name2 can match. We're conservative: we return FALSE
801 only if the prefixes of name1 and name2 are different up to the
802 first wildcard character. */
805 wild_spec_can_overlap (const char *name1
, const char *name2
)
807 size_t prefix1_len
= strcspn (name1
, "?*[");
808 size_t prefix2_len
= strcspn (name2
, "?*[");
809 size_t min_prefix_len
;
811 /* Note that if there is no wildcard character, then we treat the
812 terminating 0 as part of the prefix. Thus ".text" won't match
813 ".text." or ".text.*", for example. */
814 if (name1
[prefix1_len
] == '\0')
816 if (name2
[prefix2_len
] == '\0')
819 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
821 return memcmp (name1
, name2
, min_prefix_len
) == 0;
824 /* Select specialized code to handle various kinds of wildcard
828 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
831 int wild_name_count
= 0;
832 struct wildcard_list
*sec
;
836 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
837 ptr
->handler_data
[0] = NULL
;
838 ptr
->handler_data
[1] = NULL
;
839 ptr
->handler_data
[2] = NULL
;
840 ptr
->handler_data
[3] = NULL
;
843 /* Count how many wildcard_specs there are, and how many of those
844 actually use wildcards in the name. Also, bail out if any of the
845 wildcard names are NULL. (Can this actually happen?
846 walk_wild_section used to test for it.) And bail out if any
847 of the wildcards are more complex than a simple string
848 ending in a single '*'. */
849 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
852 if (sec
->spec
.name
== NULL
)
854 if (wildcardp (sec
->spec
.name
))
857 if (!is_simple_wild (sec
->spec
.name
))
862 /* The zero-spec case would be easy to optimize but it doesn't
863 happen in practice. Likewise, more than 4 specs doesn't
864 happen in practice. */
865 if (sec_count
== 0 || sec_count
> 4)
868 /* Check that no two specs can match the same section. */
869 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
871 struct wildcard_list
*sec2
;
872 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
874 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
879 signature
= (sec_count
<< 8) + wild_name_count
;
883 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
886 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
889 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
892 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
895 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
901 /* Now fill the data array with pointers to the specs, first the
902 specs with non-wildcard names, then the specs with wildcard
903 names. It's OK to process the specs in different order from the
904 given order, because we've already determined that no section
905 will match more than one spec. */
907 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
908 if (!wildcardp (sec
->spec
.name
))
909 ptr
->handler_data
[data_counter
++] = sec
;
910 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
911 if (wildcardp (sec
->spec
.name
))
912 ptr
->handler_data
[data_counter
++] = sec
;
915 /* Handle a wild statement for a single file F. */
918 walk_wild_file (lang_wild_statement_type
*s
,
919 lang_input_statement_type
*f
,
923 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
926 if (f
->the_bfd
== NULL
927 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
928 walk_wild_section (s
, f
, callback
, data
);
933 /* This is an archive file. We must map each member of the
934 archive separately. */
935 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
936 while (member
!= NULL
)
938 /* When lookup_name is called, it will call the add_symbols
939 entry point for the archive. For each element of the
940 archive which is included, BFD will call ldlang_add_file,
941 which will set the usrdata field of the member to the
942 lang_input_statement. */
943 if (bfd_usrdata (member
) != NULL
)
944 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
946 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
952 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
954 const char *file_spec
= s
->filename
;
957 if (file_spec
== NULL
)
959 /* Perform the iteration over all files in the list. */
960 LANG_FOR_EACH_INPUT_STATEMENT (f
)
962 walk_wild_file (s
, f
, callback
, data
);
965 else if ((p
= archive_path (file_spec
)) != NULL
)
967 LANG_FOR_EACH_INPUT_STATEMENT (f
)
969 if (input_statement_is_archive_path (file_spec
, p
, f
))
970 walk_wild_file (s
, f
, callback
, data
);
973 else if (wildcardp (file_spec
))
975 LANG_FOR_EACH_INPUT_STATEMENT (f
)
977 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
978 walk_wild_file (s
, f
, callback
, data
);
983 lang_input_statement_type
*f
;
985 /* Perform the iteration over a single file. */
986 f
= lookup_name (file_spec
);
988 walk_wild_file (s
, f
, callback
, data
);
992 /* lang_for_each_statement walks the parse tree and calls the provided
993 function for each node, except those inside output section statements
994 with constraint set to -1. */
997 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
998 lang_statement_union_type
*s
)
1000 for (; s
!= NULL
; s
= s
->header
.next
)
1004 switch (s
->header
.type
)
1006 case lang_constructors_statement_enum
:
1007 lang_for_each_statement_worker (func
, constructor_list
.head
);
1009 case lang_output_section_statement_enum
:
1010 if (s
->output_section_statement
.constraint
!= -1)
1011 lang_for_each_statement_worker
1012 (func
, s
->output_section_statement
.children
.head
);
1014 case lang_wild_statement_enum
:
1015 lang_for_each_statement_worker (func
,
1016 s
->wild_statement
.children
.head
);
1018 case lang_group_statement_enum
:
1019 lang_for_each_statement_worker (func
,
1020 s
->group_statement
.children
.head
);
1022 case lang_data_statement_enum
:
1023 case lang_reloc_statement_enum
:
1024 case lang_object_symbols_statement_enum
:
1025 case lang_output_statement_enum
:
1026 case lang_target_statement_enum
:
1027 case lang_input_section_enum
:
1028 case lang_input_statement_enum
:
1029 case lang_assignment_statement_enum
:
1030 case lang_padding_statement_enum
:
1031 case lang_address_statement_enum
:
1032 case lang_fill_statement_enum
:
1033 case lang_insert_statement_enum
:
1043 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1045 lang_for_each_statement_worker (func
, statement_list
.head
);
1048 /*----------------------------------------------------------------------*/
1051 lang_list_init (lang_statement_list_type
*list
)
1054 list
->tail
= &list
->head
;
1058 lang_statement_append (lang_statement_list_type
*list
,
1062 *(list
->tail
) = element
;
1067 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1069 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1071 *stat_save_ptr
++ = stat_ptr
;
1078 if (stat_save_ptr
<= stat_save
)
1080 stat_ptr
= *--stat_save_ptr
;
1083 /* Build a new statement node for the parse tree. */
1085 static lang_statement_union_type
*
1086 new_statement (enum statement_enum type
,
1088 lang_statement_list_type
*list
)
1090 lang_statement_union_type
*new_stmt
;
1092 new_stmt
= stat_alloc (size
);
1093 new_stmt
->header
.type
= type
;
1094 new_stmt
->header
.next
= NULL
;
1095 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1099 /* Build a new input file node for the language. There are several
1100 ways in which we treat an input file, eg, we only look at symbols,
1101 or prefix it with a -l etc.
1103 We can be supplied with requests for input files more than once;
1104 they may, for example be split over several lines like foo.o(.text)
1105 foo.o(.data) etc, so when asked for a file we check that we haven't
1106 got it already so we don't duplicate the bfd. */
1108 static lang_input_statement_type
*
1109 new_afile (const char *name
,
1110 lang_input_file_enum_type file_type
,
1112 const char *from_filename
)
1114 lang_input_statement_type
*p
;
1116 lang_has_input_file
= TRUE
;
1118 p
= new_stat (lang_input_statement
, stat_ptr
);
1119 memset (&p
->the_bfd
, 0,
1120 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1121 p
->extra_search_path
= NULL
;
1123 p
->flags
.dynamic
= input_flags
.dynamic
;
1124 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1125 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1126 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1127 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1131 case lang_input_file_is_symbols_only_enum
:
1133 p
->local_sym_name
= name
;
1134 p
->flags
.real
= TRUE
;
1135 p
->flags
.just_syms
= TRUE
;
1137 case lang_input_file_is_fake_enum
:
1139 p
->local_sym_name
= name
;
1141 case lang_input_file_is_l_enum
:
1142 if (name
[0] == ':' && name
[1] != '\0')
1144 p
->filename
= name
+ 1;
1145 p
->flags
.full_name_provided
= TRUE
;
1149 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1150 p
->flags
.maybe_archive
= TRUE
;
1151 p
->flags
.real
= TRUE
;
1152 p
->flags
.search_dirs
= TRUE
;
1154 case lang_input_file_is_marker_enum
:
1156 p
->local_sym_name
= name
;
1157 p
->flags
.search_dirs
= TRUE
;
1159 case lang_input_file_is_search_file_enum
:
1161 p
->local_sym_name
= name
;
1162 /* If name is a relative path, search the directory of the current linker
1164 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1165 p
->extra_search_path
= ldirname (from_filename
);
1166 p
->flags
.real
= TRUE
;
1167 p
->flags
.search_dirs
= TRUE
;
1169 case lang_input_file_is_file_enum
:
1171 p
->local_sym_name
= name
;
1172 p
->flags
.real
= TRUE
;
1178 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1182 lang_input_statement_type
*
1183 lang_add_input_file (const char *name
,
1184 lang_input_file_enum_type file_type
,
1188 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1190 lang_input_statement_type
*ret
;
1191 char *sysrooted_name
1192 = concat (ld_sysroot
,
1193 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1194 (const char *) NULL
);
1196 /* We've now forcibly prepended the sysroot, making the input
1197 file independent of the context. Therefore, temporarily
1198 force a non-sysrooted context for this statement, so it won't
1199 get the sysroot prepended again when opened. (N.B. if it's a
1200 script, any child nodes with input files starting with "/"
1201 will be handled as "sysrooted" as they'll be found to be
1202 within the sysroot subdirectory.) */
1203 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1204 input_flags
.sysrooted
= 0;
1205 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1206 input_flags
.sysrooted
= outer_sysrooted
;
1210 return new_afile (name
, file_type
, target
, current_input_file
);
1213 struct out_section_hash_entry
1215 struct bfd_hash_entry root
;
1216 lang_statement_union_type s
;
1219 /* The hash table. */
1221 static struct bfd_hash_table output_section_statement_table
;
1223 /* Support routines for the hash table used by lang_output_section_find,
1224 initialize the table, fill in an entry and remove the table. */
1226 static struct bfd_hash_entry
*
1227 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1228 struct bfd_hash_table
*table
,
1231 lang_output_section_statement_type
**nextp
;
1232 struct out_section_hash_entry
*ret
;
1236 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1242 entry
= bfd_hash_newfunc (entry
, table
, string
);
1246 ret
= (struct out_section_hash_entry
*) entry
;
1247 memset (&ret
->s
, 0, sizeof (ret
->s
));
1248 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1249 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1250 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1251 ret
->s
.output_section_statement
.block_value
= 1;
1252 lang_list_init (&ret
->s
.output_section_statement
.children
);
1253 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1255 /* For every output section statement added to the list, except the
1256 first one, lang_os_list.tail points to the "next"
1257 field of the last element of the list. */
1258 if (lang_os_list
.head
!= NULL
)
1259 ret
->s
.output_section_statement
.prev
1260 = ((lang_output_section_statement_type
*)
1261 ((char *) lang_os_list
.tail
1262 - offsetof (lang_output_section_statement_type
, next
)));
1264 /* GCC's strict aliasing rules prevent us from just casting the
1265 address, so we store the pointer in a variable and cast that
1267 nextp
= &ret
->s
.output_section_statement
.next
;
1268 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1273 output_section_statement_table_init (void)
1275 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1276 output_section_statement_newfunc
,
1277 sizeof (struct out_section_hash_entry
),
1279 einfo (_("%F%P: can not create hash table: %E\n"));
1283 output_section_statement_table_free (void)
1285 bfd_hash_table_free (&output_section_statement_table
);
1288 /* Build enough state so that the parser can build its tree. */
1293 obstack_begin (&stat_obstack
, 1000);
1295 stat_ptr
= &statement_list
;
1297 output_section_statement_table_init ();
1299 lang_list_init (stat_ptr
);
1301 lang_list_init (&input_file_chain
);
1302 lang_list_init (&lang_os_list
);
1303 lang_list_init (&file_chain
);
1304 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1306 abs_output_section
=
1307 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1309 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1311 asneeded_list_head
= NULL
;
1312 asneeded_list_tail
= &asneeded_list_head
;
1318 output_section_statement_table_free ();
1321 /*----------------------------------------------------------------------
1322 A region is an area of memory declared with the
1323 MEMORY { name:org=exp, len=exp ... }
1326 We maintain a list of all the regions here.
1328 If no regions are specified in the script, then the default is used
1329 which is created when looked up to be the entire data space.
1331 If create is true we are creating a region inside a MEMORY block.
1332 In this case it is probably an error to create a region that has
1333 already been created. If we are not inside a MEMORY block it is
1334 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1335 and so we issue a warning.
1337 Each region has at least one name. The first name is either
1338 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1339 alias names to an existing region within a script with
1340 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1343 static lang_memory_region_type
*lang_memory_region_list
;
1344 static lang_memory_region_type
**lang_memory_region_list_tail
1345 = &lang_memory_region_list
;
1347 lang_memory_region_type
*
1348 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1350 lang_memory_region_name
*n
;
1351 lang_memory_region_type
*r
;
1352 lang_memory_region_type
*new_region
;
1354 /* NAME is NULL for LMA memspecs if no region was specified. */
1358 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1359 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1360 if (strcmp (n
->name
, name
) == 0)
1363 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1368 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1369 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1372 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1374 new_region
->name_list
.name
= xstrdup (name
);
1375 new_region
->name_list
.next
= NULL
;
1376 new_region
->next
= NULL
;
1377 new_region
->origin_exp
= NULL
;
1378 new_region
->origin
= 0;
1379 new_region
->length_exp
= NULL
;
1380 new_region
->length
= ~(bfd_size_type
) 0;
1381 new_region
->current
= 0;
1382 new_region
->last_os
= NULL
;
1383 new_region
->flags
= 0;
1384 new_region
->not_flags
= 0;
1385 new_region
->had_full_message
= FALSE
;
1387 *lang_memory_region_list_tail
= new_region
;
1388 lang_memory_region_list_tail
= &new_region
->next
;
1394 lang_memory_region_alias (const char *alias
, const char *region_name
)
1396 lang_memory_region_name
*n
;
1397 lang_memory_region_type
*r
;
1398 lang_memory_region_type
*region
;
1400 /* The default region must be unique. This ensures that it is not necessary
1401 to iterate through the name list if someone wants the check if a region is
1402 the default memory region. */
1403 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1404 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1405 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1407 /* Look for the target region and check if the alias is not already
1410 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1411 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1413 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1415 if (strcmp (n
->name
, alias
) == 0)
1416 einfo (_("%F%P:%pS: error: redefinition of memory region "
1421 /* Check if the target region exists. */
1423 einfo (_("%F%P:%pS: error: memory region `%s' "
1424 "for alias `%s' does not exist\n"),
1425 NULL
, region_name
, alias
);
1427 /* Add alias to region name list. */
1428 n
= stat_alloc (sizeof (lang_memory_region_name
));
1429 n
->name
= xstrdup (alias
);
1430 n
->next
= region
->name_list
.next
;
1431 region
->name_list
.next
= n
;
1434 static lang_memory_region_type
*
1435 lang_memory_default (asection
*section
)
1437 lang_memory_region_type
*p
;
1439 flagword sec_flags
= section
->flags
;
1441 /* Override SEC_DATA to mean a writable section. */
1442 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1443 sec_flags
|= SEC_DATA
;
1445 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1447 if ((p
->flags
& sec_flags
) != 0
1448 && (p
->not_flags
& sec_flags
) == 0)
1453 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1456 /* Get the output section statement directly from the userdata. */
1458 lang_output_section_statement_type
*
1459 lang_output_section_get (const asection
*output_section
)
1461 return bfd_section_userdata (output_section
);
1464 /* Find or create an output_section_statement with the given NAME.
1465 If CONSTRAINT is non-zero match one with that constraint, otherwise
1466 match any non-negative constraint. If CREATE, always make a
1467 new output_section_statement for SPECIAL CONSTRAINT. */
1469 lang_output_section_statement_type
*
1470 lang_output_section_statement_lookup (const char *name
,
1474 struct out_section_hash_entry
*entry
;
1476 entry
= ((struct out_section_hash_entry
*)
1477 bfd_hash_lookup (&output_section_statement_table
, name
,
1482 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1486 if (entry
->s
.output_section_statement
.name
!= NULL
)
1488 /* We have a section of this name, but it might not have the correct
1490 struct out_section_hash_entry
*last_ent
;
1492 name
= entry
->s
.output_section_statement
.name
;
1493 if (create
&& constraint
== SPECIAL
)
1494 /* Not traversing to the end reverses the order of the second
1495 and subsequent SPECIAL sections in the hash table chain,
1496 but that shouldn't matter. */
1501 if (constraint
== entry
->s
.output_section_statement
.constraint
1503 && entry
->s
.output_section_statement
.constraint
>= 0))
1504 return &entry
->s
.output_section_statement
;
1506 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1508 while (entry
!= NULL
1509 && name
== entry
->s
.output_section_statement
.name
);
1515 = ((struct out_section_hash_entry
*)
1516 output_section_statement_newfunc (NULL
,
1517 &output_section_statement_table
,
1521 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1524 entry
->root
= last_ent
->root
;
1525 last_ent
->root
.next
= &entry
->root
;
1528 entry
->s
.output_section_statement
.name
= name
;
1529 entry
->s
.output_section_statement
.constraint
= constraint
;
1530 return &entry
->s
.output_section_statement
;
1533 /* Find the next output_section_statement with the same name as OS.
1534 If CONSTRAINT is non-zero, find one with that constraint otherwise
1535 match any non-negative constraint. */
1537 lang_output_section_statement_type
*
1538 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1541 /* All output_section_statements are actually part of a
1542 struct out_section_hash_entry. */
1543 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1545 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1546 const char *name
= os
->name
;
1548 ASSERT (name
== entry
->root
.string
);
1551 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1553 || name
!= entry
->s
.output_section_statement
.name
)
1556 while (constraint
!= entry
->s
.output_section_statement
.constraint
1558 || entry
->s
.output_section_statement
.constraint
< 0));
1560 return &entry
->s
.output_section_statement
;
1563 /* A variant of lang_output_section_find used by place_orphan.
1564 Returns the output statement that should precede a new output
1565 statement for SEC. If an exact match is found on certain flags,
1568 lang_output_section_statement_type
*
1569 lang_output_section_find_by_flags (const asection
*sec
,
1571 lang_output_section_statement_type
**exact
,
1572 lang_match_sec_type_func match_type
)
1574 lang_output_section_statement_type
*first
, *look
, *found
;
1575 flagword look_flags
, differ
;
1577 /* We know the first statement on this list is *ABS*. May as well
1579 first
= (void *) lang_os_list
.head
;
1580 first
= first
->next
;
1582 /* First try for an exact match. */
1584 for (look
= first
; look
; look
= look
->next
)
1586 look_flags
= look
->flags
;
1587 if (look
->bfd_section
!= NULL
)
1589 look_flags
= look
->bfd_section
->flags
;
1590 if (match_type
&& !match_type (link_info
.output_bfd
,
1595 differ
= look_flags
^ sec_flags
;
1596 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1597 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1607 if ((sec_flags
& SEC_CODE
) != 0
1608 && (sec_flags
& SEC_ALLOC
) != 0)
1610 /* Try for a rw code section. */
1611 for (look
= first
; look
; look
= look
->next
)
1613 look_flags
= look
->flags
;
1614 if (look
->bfd_section
!= NULL
)
1616 look_flags
= look
->bfd_section
->flags
;
1617 if (match_type
&& !match_type (link_info
.output_bfd
,
1622 differ
= look_flags
^ sec_flags
;
1623 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1624 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1628 else if ((sec_flags
& SEC_READONLY
) != 0
1629 && (sec_flags
& SEC_ALLOC
) != 0)
1631 /* .rodata can go after .text, .sdata2 after .rodata. */
1632 for (look
= first
; look
; look
= look
->next
)
1634 look_flags
= look
->flags
;
1635 if (look
->bfd_section
!= NULL
)
1637 look_flags
= look
->bfd_section
->flags
;
1638 if (match_type
&& !match_type (link_info
.output_bfd
,
1643 differ
= look_flags
^ sec_flags
;
1644 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1645 | SEC_READONLY
| SEC_SMALL_DATA
))
1646 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1648 && !(look_flags
& SEC_SMALL_DATA
)))
1652 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1653 && (sec_flags
& SEC_ALLOC
) != 0)
1655 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1656 as if it were a loaded section, and don't use match_type. */
1657 bfd_boolean seen_thread_local
= FALSE
;
1660 for (look
= first
; look
; look
= look
->next
)
1662 look_flags
= look
->flags
;
1663 if (look
->bfd_section
!= NULL
)
1664 look_flags
= look
->bfd_section
->flags
;
1666 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1667 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1669 /* .tdata and .tbss must be adjacent and in that order. */
1670 if (!(look_flags
& SEC_LOAD
)
1671 && (sec_flags
& SEC_LOAD
))
1672 /* ..so if we're at a .tbss section and we're placing
1673 a .tdata section stop looking and return the
1674 previous section. */
1677 seen_thread_local
= TRUE
;
1679 else if (seen_thread_local
)
1681 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1685 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1686 && (sec_flags
& SEC_ALLOC
) != 0)
1688 /* .sdata goes after .data, .sbss after .sdata. */
1689 for (look
= first
; look
; look
= look
->next
)
1691 look_flags
= look
->flags
;
1692 if (look
->bfd_section
!= NULL
)
1694 look_flags
= look
->bfd_section
->flags
;
1695 if (match_type
&& !match_type (link_info
.output_bfd
,
1700 differ
= look_flags
^ sec_flags
;
1701 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1702 | SEC_THREAD_LOCAL
))
1703 || ((look_flags
& SEC_SMALL_DATA
)
1704 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1708 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1709 && (sec_flags
& SEC_ALLOC
) != 0)
1711 /* .data goes after .rodata. */
1712 for (look
= first
; look
; look
= look
->next
)
1714 look_flags
= look
->flags
;
1715 if (look
->bfd_section
!= NULL
)
1717 look_flags
= look
->bfd_section
->flags
;
1718 if (match_type
&& !match_type (link_info
.output_bfd
,
1723 differ
= look_flags
^ sec_flags
;
1724 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1725 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1729 else if ((sec_flags
& SEC_ALLOC
) != 0)
1731 /* .bss goes after any other alloc section. */
1732 for (look
= first
; look
; look
= look
->next
)
1734 look_flags
= look
->flags
;
1735 if (look
->bfd_section
!= NULL
)
1737 look_flags
= look
->bfd_section
->flags
;
1738 if (match_type
&& !match_type (link_info
.output_bfd
,
1743 differ
= look_flags
^ sec_flags
;
1744 if (!(differ
& SEC_ALLOC
))
1750 /* non-alloc go last. */
1751 for (look
= first
; look
; look
= look
->next
)
1753 look_flags
= look
->flags
;
1754 if (look
->bfd_section
!= NULL
)
1755 look_flags
= look
->bfd_section
->flags
;
1756 differ
= look_flags
^ sec_flags
;
1757 if (!(differ
& SEC_DEBUGGING
))
1763 if (found
|| !match_type
)
1766 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1769 /* Find the last output section before given output statement.
1770 Used by place_orphan. */
1773 output_prev_sec_find (lang_output_section_statement_type
*os
)
1775 lang_output_section_statement_type
*lookup
;
1777 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1779 if (lookup
->constraint
< 0)
1782 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1783 return lookup
->bfd_section
;
1789 /* Look for a suitable place for a new output section statement. The
1790 idea is to skip over anything that might be inside a SECTIONS {}
1791 statement in a script, before we find another output section
1792 statement. Assignments to "dot" before an output section statement
1793 are assumed to belong to it, except in two cases; The first
1794 assignment to dot, and assignments before non-alloc sections.
1795 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1796 similar assignments that set the initial address, or we might
1797 insert non-alloc note sections among assignments setting end of
1800 static lang_statement_union_type
**
1801 insert_os_after (lang_output_section_statement_type
*after
)
1803 lang_statement_union_type
**where
;
1804 lang_statement_union_type
**assign
= NULL
;
1805 bfd_boolean ignore_first
;
1807 ignore_first
= after
== (void *) lang_os_list
.head
;
1809 for (where
= &after
->header
.next
;
1811 where
= &(*where
)->header
.next
)
1813 switch ((*where
)->header
.type
)
1815 case lang_assignment_statement_enum
:
1818 lang_assignment_statement_type
*ass
;
1820 ass
= &(*where
)->assignment_statement
;
1821 if (ass
->exp
->type
.node_class
!= etree_assert
1822 && ass
->exp
->assign
.dst
[0] == '.'
1823 && ass
->exp
->assign
.dst
[1] == 0)
1827 ignore_first
= FALSE
;
1831 case lang_wild_statement_enum
:
1832 case lang_input_section_enum
:
1833 case lang_object_symbols_statement_enum
:
1834 case lang_fill_statement_enum
:
1835 case lang_data_statement_enum
:
1836 case lang_reloc_statement_enum
:
1837 case lang_padding_statement_enum
:
1838 case lang_constructors_statement_enum
:
1840 ignore_first
= FALSE
;
1842 case lang_output_section_statement_enum
:
1845 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1848 || s
->map_head
.s
== NULL
1849 || (s
->flags
& SEC_ALLOC
) != 0)
1853 case lang_input_statement_enum
:
1854 case lang_address_statement_enum
:
1855 case lang_target_statement_enum
:
1856 case lang_output_statement_enum
:
1857 case lang_group_statement_enum
:
1858 case lang_insert_statement_enum
:
1867 lang_output_section_statement_type
*
1868 lang_insert_orphan (asection
*s
,
1869 const char *secname
,
1871 lang_output_section_statement_type
*after
,
1872 struct orphan_save
*place
,
1873 etree_type
*address
,
1874 lang_statement_list_type
*add_child
)
1876 lang_statement_list_type add
;
1877 lang_output_section_statement_type
*os
;
1878 lang_output_section_statement_type
**os_tail
;
1880 /* If we have found an appropriate place for the output section
1881 statements for this orphan, add them to our own private list,
1882 inserting them later into the global statement list. */
1885 lang_list_init (&add
);
1886 push_stat_ptr (&add
);
1889 if (bfd_link_relocatable (&link_info
)
1890 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1891 address
= exp_intop (0);
1893 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1894 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1895 NULL
, NULL
, NULL
, constraint
, 0);
1897 if (add_child
== NULL
)
1898 add_child
= &os
->children
;
1899 lang_add_section (add_child
, s
, NULL
, os
);
1901 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1903 const char *region
= (after
->region
1904 ? after
->region
->name_list
.name
1905 : DEFAULT_MEMORY_REGION
);
1906 const char *lma_region
= (after
->lma_region
1907 ? after
->lma_region
->name_list
.name
1909 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1913 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1916 /* Restore the global list pointer. */
1920 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1922 asection
*snew
, *as
;
1923 bfd_boolean place_after
= place
->stmt
== NULL
;
1924 bfd_boolean insert_after
= TRUE
;
1926 snew
= os
->bfd_section
;
1928 /* Shuffle the bfd section list to make the output file look
1929 neater. This is really only cosmetic. */
1930 if (place
->section
== NULL
1931 && after
!= (void *) lang_os_list
.head
)
1933 asection
*bfd_section
= after
->bfd_section
;
1935 /* If the output statement hasn't been used to place any input
1936 sections (and thus doesn't have an output bfd_section),
1937 look for the closest prior output statement having an
1939 if (bfd_section
== NULL
)
1940 bfd_section
= output_prev_sec_find (after
);
1942 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1943 place
->section
= &bfd_section
->next
;
1946 if (place
->section
== NULL
)
1947 place
->section
= &link_info
.output_bfd
->sections
;
1949 as
= *place
->section
;
1953 /* Put the section at the end of the list. */
1955 /* Unlink the section. */
1956 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1958 /* Now tack it back on in the right place. */
1959 bfd_section_list_append (link_info
.output_bfd
, snew
);
1961 else if ((bfd_get_flavour (link_info
.output_bfd
)
1962 == bfd_target_elf_flavour
)
1963 && (bfd_get_flavour (s
->owner
)
1964 == bfd_target_elf_flavour
)
1965 && ((elf_section_type (s
) == SHT_NOTE
1966 && (s
->flags
& SEC_LOAD
) != 0)
1967 || (elf_section_type (as
) == SHT_NOTE
1968 && (as
->flags
& SEC_LOAD
) != 0)))
1970 /* Make sure that output note sections are grouped and sorted
1971 by alignments when inserting a note section or insert a
1972 section after a note section, */
1974 /* A specific section after which the output note section
1975 should be placed. */
1976 asection
*after_sec
;
1977 /* True if we need to insert the orphan section after a
1978 specific section to maintain output note section order. */
1979 bfd_boolean after_sec_note
= FALSE
;
1981 static asection
*first_orphan_note
= NULL
;
1983 /* Group and sort output note section by alignments in
1986 if (elf_section_type (s
) == SHT_NOTE
1987 && (s
->flags
& SEC_LOAD
) != 0)
1989 /* Search from the beginning for the last output note
1990 section with equal or larger alignments. NB: Don't
1991 place orphan note section after non-note sections. */
1993 first_orphan_note
= NULL
;
1994 for (sec
= link_info
.output_bfd
->sections
;
1996 && !bfd_is_abs_section (sec
));
1999 && elf_section_type (sec
) == SHT_NOTE
2000 && (sec
->flags
& SEC_LOAD
) != 0)
2002 if (!first_orphan_note
)
2003 first_orphan_note
= sec
;
2004 if (sec
->alignment_power
>= s
->alignment_power
)
2007 else if (first_orphan_note
)
2009 /* Stop if there is non-note section after the first
2010 orphan note section. */
2014 /* If this will be the first orphan note section, it can
2015 be placed at the default location. */
2016 after_sec_note
= first_orphan_note
!= NULL
;
2017 if (after_sec
== NULL
&& after_sec_note
)
2019 /* If all output note sections have smaller
2020 alignments, place the section before all
2021 output orphan note sections. */
2022 after_sec
= first_orphan_note
;
2023 insert_after
= FALSE
;
2026 else if (first_orphan_note
)
2028 /* Don't place non-note sections in the middle of orphan
2030 after_sec_note
= TRUE
;
2032 for (sec
= as
->next
;
2034 && !bfd_is_abs_section (sec
));
2036 if (elf_section_type (sec
) == SHT_NOTE
2037 && (sec
->flags
& SEC_LOAD
) != 0)
2045 /* Search forward to insert OS after AFTER_SEC output
2047 lang_output_section_statement_type
*stmt
, *next
;
2048 bfd_boolean found
= FALSE
;
2049 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2054 if (stmt
->bfd_section
== after_sec
)
2064 /* If INSERT_AFTER is FALSE, place OS before
2065 AFTER_SEC output statement. */
2066 if (next
&& next
->bfd_section
== after_sec
)
2076 /* Search backward to insert OS after AFTER_SEC output
2079 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2083 if (stmt
->bfd_section
== after_sec
)
2092 /* If INSERT_AFTER is FALSE, place OS before
2093 AFTER_SEC output statement. */
2094 if (stmt
->next
->bfd_section
== after_sec
)
2104 if (after_sec
== NULL
2105 || (insert_after
&& after_sec
->next
!= snew
)
2106 || (!insert_after
&& after_sec
->prev
!= snew
))
2108 /* Unlink the section. */
2109 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2111 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2116 bfd_section_list_insert_after (link_info
.output_bfd
,
2119 bfd_section_list_insert_before (link_info
.output_bfd
,
2123 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2126 else if (as
!= snew
&& as
->prev
!= snew
)
2128 /* Unlink the section. */
2129 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2131 /* Now tack it back on in the right place. */
2132 bfd_section_list_insert_before (link_info
.output_bfd
,
2136 else if (as
!= snew
&& as
->prev
!= snew
)
2138 /* Unlink the section. */
2139 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2141 /* Now tack it back on in the right place. */
2142 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2145 /* Save the end of this list. Further ophans of this type will
2146 follow the one we've just added. */
2147 place
->section
= &snew
->next
;
2149 /* The following is non-cosmetic. We try to put the output
2150 statements in some sort of reasonable order here, because they
2151 determine the final load addresses of the orphan sections.
2152 In addition, placing output statements in the wrong order may
2153 require extra segments. For instance, given a typical
2154 situation of all read-only sections placed in one segment and
2155 following that a segment containing all the read-write
2156 sections, we wouldn't want to place an orphan read/write
2157 section before or amongst the read-only ones. */
2158 if (add
.head
!= NULL
)
2160 lang_output_section_statement_type
*newly_added_os
;
2162 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2165 lang_statement_union_type
**where
= insert_os_after (after
);
2170 place
->os_tail
= &after
->next
;
2174 /* Put it after the last orphan statement we added. */
2175 *add
.tail
= *place
->stmt
;
2176 *place
->stmt
= add
.head
;
2179 /* Fix the global list pointer if we happened to tack our
2180 new list at the tail. */
2181 if (*stat_ptr
->tail
== add
.head
)
2182 stat_ptr
->tail
= add
.tail
;
2184 /* Save the end of this list. */
2185 place
->stmt
= add
.tail
;
2187 /* Do the same for the list of output section statements. */
2188 newly_added_os
= *os_tail
;
2190 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2191 ((char *) place
->os_tail
2192 - offsetof (lang_output_section_statement_type
, next
));
2193 newly_added_os
->next
= *place
->os_tail
;
2194 if (newly_added_os
->next
!= NULL
)
2195 newly_added_os
->next
->prev
= newly_added_os
;
2196 *place
->os_tail
= newly_added_os
;
2197 place
->os_tail
= &newly_added_os
->next
;
2199 /* Fixing the global list pointer here is a little different.
2200 We added to the list in lang_enter_output_section_statement,
2201 trimmed off the new output_section_statment above when
2202 assigning *os_tail = NULL, but possibly added it back in
2203 the same place when assigning *place->os_tail. */
2204 if (*os_tail
== NULL
)
2205 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2212 lang_print_asneeded (void)
2214 struct asneeded_minfo
*m
;
2216 if (asneeded_list_head
== NULL
)
2219 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2221 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2225 minfo ("%s", m
->soname
);
2226 len
= strlen (m
->soname
);
2240 minfo ("%pB ", m
->ref
);
2241 minfo ("(%pT)\n", m
->name
);
2246 lang_map_flags (flagword flag
)
2248 if (flag
& SEC_ALLOC
)
2251 if (flag
& SEC_CODE
)
2254 if (flag
& SEC_READONLY
)
2257 if (flag
& SEC_DATA
)
2260 if (flag
& SEC_LOAD
)
2267 lang_memory_region_type
*m
;
2268 bfd_boolean dis_header_printed
= FALSE
;
2270 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2274 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2275 || file
->flags
.just_syms
)
2278 if (config
.print_map_discarded
)
2279 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2280 if ((s
->output_section
== NULL
2281 || s
->output_section
->owner
!= link_info
.output_bfd
)
2282 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2284 if (! dis_header_printed
)
2286 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2287 dis_header_printed
= TRUE
;
2290 print_input_section (s
, TRUE
);
2294 minfo (_("\nMemory Configuration\n\n"));
2295 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2296 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2298 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2303 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2305 sprintf_vma (buf
, m
->origin
);
2306 minfo ("0x%s ", buf
);
2314 minfo ("0x%V", m
->length
);
2315 if (m
->flags
|| m
->not_flags
)
2323 lang_map_flags (m
->flags
);
2329 lang_map_flags (m
->not_flags
);
2336 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2338 if (!link_info
.reduce_memory_overheads
)
2340 obstack_begin (&map_obstack
, 1000);
2341 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2343 expld
.phase
= lang_fixed_phase_enum
;
2344 lang_statement_iteration
++;
2345 print_statements ();
2347 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2352 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2353 void *info ATTRIBUTE_UNUSED
)
2355 if ((hash_entry
->type
== bfd_link_hash_defined
2356 || hash_entry
->type
== bfd_link_hash_defweak
)
2357 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2358 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2360 input_section_userdata_type
*ud
;
2361 struct map_symbol_def
*def
;
2363 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2366 ud
= stat_alloc (sizeof (*ud
));
2367 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2368 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2369 ud
->map_symbol_def_count
= 0;
2371 else if (!ud
->map_symbol_def_tail
)
2372 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2374 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2375 def
->entry
= hash_entry
;
2376 *(ud
->map_symbol_def_tail
) = def
;
2377 ud
->map_symbol_def_tail
= &def
->next
;
2378 ud
->map_symbol_def_count
++;
2383 /* Initialize an output section. */
2386 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2388 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2389 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2391 if (s
->constraint
!= SPECIAL
)
2392 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2393 if (s
->bfd_section
== NULL
)
2394 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2396 if (s
->bfd_section
== NULL
)
2398 einfo (_("%F%P: output format %s cannot represent section"
2399 " called %s: %E\n"),
2400 link_info
.output_bfd
->xvec
->name
, s
->name
);
2402 s
->bfd_section
->output_section
= s
->bfd_section
;
2403 s
->bfd_section
->output_offset
= 0;
2405 /* Set the userdata of the output section to the output section
2406 statement to avoid lookup. */
2407 bfd_set_section_userdata (s
->bfd_section
, s
);
2409 /* If there is a base address, make sure that any sections it might
2410 mention are initialized. */
2411 if (s
->addr_tree
!= NULL
)
2412 exp_init_os (s
->addr_tree
);
2414 if (s
->load_base
!= NULL
)
2415 exp_init_os (s
->load_base
);
2417 /* If supplied an alignment, set it. */
2418 if (s
->section_alignment
!= NULL
)
2419 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2420 "section alignment");
2423 /* Make sure that all output sections mentioned in an expression are
2427 exp_init_os (etree_type
*exp
)
2429 switch (exp
->type
.node_class
)
2433 case etree_provided
:
2434 exp_init_os (exp
->assign
.src
);
2438 exp_init_os (exp
->binary
.lhs
);
2439 exp_init_os (exp
->binary
.rhs
);
2443 exp_init_os (exp
->trinary
.cond
);
2444 exp_init_os (exp
->trinary
.lhs
);
2445 exp_init_os (exp
->trinary
.rhs
);
2449 exp_init_os (exp
->assert_s
.child
);
2453 exp_init_os (exp
->unary
.child
);
2457 switch (exp
->type
.node_code
)
2463 lang_output_section_statement_type
*os
;
2465 os
= lang_output_section_find (exp
->name
.name
);
2466 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2478 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2480 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2482 /* If we are only reading symbols from this object, then we want to
2483 discard all sections. */
2484 if (entry
->flags
.just_syms
)
2486 bfd_link_just_syms (abfd
, sec
, &link_info
);
2490 /* Deal with SHF_EXCLUDE ELF sections. */
2491 if (!bfd_link_relocatable (&link_info
)
2492 && (abfd
->flags
& BFD_PLUGIN
) == 0
2493 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2494 sec
->output_section
= bfd_abs_section_ptr
;
2496 if (!(abfd
->flags
& DYNAMIC
))
2497 bfd_section_already_linked (abfd
, sec
, &link_info
);
2501 /* Returns true if SECTION is one we know will be discarded based on its
2502 section flags, otherwise returns false. */
2505 lang_discard_section_p (asection
*section
)
2507 bfd_boolean discard
;
2508 flagword flags
= section
->flags
;
2510 /* Discard sections marked with SEC_EXCLUDE. */
2511 discard
= (flags
& SEC_EXCLUDE
) != 0;
2513 /* Discard the group descriptor sections when we're finally placing the
2514 sections from within the group. */
2515 if ((flags
& SEC_GROUP
) != 0
2516 && link_info
.resolve_section_groups
)
2519 /* Discard debugging sections if we are stripping debugging
2521 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2522 && (flags
& SEC_DEBUGGING
) != 0)
2528 /* The wild routines.
2530 These expand statements like *(.text) and foo.o to a list of
2531 explicit actions, like foo.o(.text), bar.o(.text) and
2532 foo.o(.text, .data). */
2534 /* Add SECTION to the output section OUTPUT. Do this by creating a
2535 lang_input_section statement which is placed at PTR. */
2538 lang_add_section (lang_statement_list_type
*ptr
,
2540 struct flag_info
*sflag_info
,
2541 lang_output_section_statement_type
*output
)
2543 flagword flags
= section
->flags
;
2545 bfd_boolean discard
;
2546 lang_input_section_type
*new_section
;
2547 bfd
*abfd
= link_info
.output_bfd
;
2549 /* Is this section one we know should be discarded? */
2550 discard
= lang_discard_section_p (section
);
2552 /* Discard input sections which are assigned to a section named
2553 DISCARD_SECTION_NAME. */
2554 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2559 if (section
->output_section
== NULL
)
2561 /* This prevents future calls from assigning this section. */
2562 section
->output_section
= bfd_abs_section_ptr
;
2564 else if (link_info
.non_contiguous_regions_warnings
)
2565 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2566 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2567 NULL
, section
, section
->owner
);
2576 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2581 if (section
->output_section
!= NULL
)
2583 if (!link_info
.non_contiguous_regions
)
2586 /* SECTION has already been handled in a special way
2587 (eg. LINK_ONCE): skip it. */
2588 if (bfd_is_abs_section (section
->output_section
))
2591 /* Already assigned to the same output section, do not process
2592 it again, to avoid creating loops between duplicate sections
2594 if (section
->output_section
== output
->bfd_section
)
2597 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2598 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2599 "change behaviour for section `%pA' from '%pB' (assigned to "
2600 "%pA, but additional match: %pA)\n"),
2601 NULL
, section
, section
->owner
, section
->output_section
,
2602 output
->bfd_section
);
2604 /* SECTION has already been assigned to an output section, but
2605 the user allows it to be mapped to another one in case it
2606 overflows. We'll later update the actual output section in
2607 size_input_section as appropriate. */
2610 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2611 to an output section, because we want to be able to include a
2612 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2613 section (I don't know why we want to do this, but we do).
2614 build_link_order in ldwrite.c handles this case by turning
2615 the embedded SEC_NEVER_LOAD section into a fill. */
2616 flags
&= ~ SEC_NEVER_LOAD
;
2618 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2619 already been processed. One reason to do this is that on pe
2620 format targets, .text$foo sections go into .text and it's odd
2621 to see .text with SEC_LINK_ONCE set. */
2622 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2624 if (link_info
.resolve_section_groups
)
2625 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2627 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2629 else if (!bfd_link_relocatable (&link_info
))
2630 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2632 switch (output
->sectype
)
2634 case normal_section
:
2635 case overlay_section
:
2636 case first_overlay_section
:
2638 case noalloc_section
:
2639 flags
&= ~SEC_ALLOC
;
2641 case noload_section
:
2643 flags
|= SEC_NEVER_LOAD
;
2644 /* Unfortunately GNU ld has managed to evolve two different
2645 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2646 alloc, no contents section. All others get a noload, noalloc
2648 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2649 flags
&= ~SEC_HAS_CONTENTS
;
2651 flags
&= ~SEC_ALLOC
;
2655 if (output
->bfd_section
== NULL
)
2656 init_os (output
, flags
);
2658 /* If SEC_READONLY is not set in the input section, then clear
2659 it from the output section. */
2660 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2662 if (output
->bfd_section
->linker_has_input
)
2664 /* Only set SEC_READONLY flag on the first input section. */
2665 flags
&= ~ SEC_READONLY
;
2667 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2668 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2669 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2670 || ((flags
& SEC_MERGE
) != 0
2671 && output
->bfd_section
->entsize
!= section
->entsize
))
2673 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2674 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2677 output
->bfd_section
->flags
|= flags
;
2679 if (!output
->bfd_section
->linker_has_input
)
2681 output
->bfd_section
->linker_has_input
= 1;
2682 /* This must happen after flags have been updated. The output
2683 section may have been created before we saw its first input
2684 section, eg. for a data statement. */
2685 bfd_init_private_section_data (section
->owner
, section
,
2686 link_info
.output_bfd
,
2687 output
->bfd_section
,
2689 if ((flags
& SEC_MERGE
) != 0)
2690 output
->bfd_section
->entsize
= section
->entsize
;
2693 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2694 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2696 /* FIXME: This value should really be obtained from the bfd... */
2697 output
->block_value
= 128;
2700 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2701 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2703 section
->output_section
= output
->bfd_section
;
2705 if (!map_head_is_link_order
)
2707 asection
*s
= output
->bfd_section
->map_tail
.s
;
2708 output
->bfd_section
->map_tail
.s
= section
;
2709 section
->map_head
.s
= NULL
;
2710 section
->map_tail
.s
= s
;
2712 s
->map_head
.s
= section
;
2714 output
->bfd_section
->map_head
.s
= section
;
2717 /* Add a section reference to the list. */
2718 new_section
= new_stat (lang_input_section
, ptr
);
2719 new_section
->section
= section
;
2722 /* Handle wildcard sorting. This returns the lang_input_section which
2723 should follow the one we are going to create for SECTION and FILE,
2724 based on the sorting requirements of WILD. It returns NULL if the
2725 new section should just go at the end of the current list. */
2727 static lang_statement_union_type
*
2728 wild_sort (lang_wild_statement_type
*wild
,
2729 struct wildcard_list
*sec
,
2730 lang_input_statement_type
*file
,
2733 lang_statement_union_type
*l
;
2735 if (!wild
->filenames_sorted
2736 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2739 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2741 lang_input_section_type
*ls
;
2743 if (l
->header
.type
!= lang_input_section_enum
)
2745 ls
= &l
->input_section
;
2747 /* Sorting by filename takes precedence over sorting by section
2750 if (wild
->filenames_sorted
)
2752 const char *fn
, *ln
;
2756 /* The PE support for the .idata section as generated by
2757 dlltool assumes that files will be sorted by the name of
2758 the archive and then the name of the file within the
2761 if (file
->the_bfd
!= NULL
2762 && file
->the_bfd
->my_archive
!= NULL
)
2764 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2769 fn
= file
->filename
;
2773 if (ls
->section
->owner
->my_archive
!= NULL
)
2775 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2780 ln
= bfd_get_filename (ls
->section
->owner
);
2784 i
= filename_cmp (fn
, ln
);
2793 fn
= file
->filename
;
2795 ln
= bfd_get_filename (ls
->section
->owner
);
2797 i
= filename_cmp (fn
, ln
);
2805 /* Here either the files are not sorted by name, or we are
2806 looking at the sections for this file. */
2809 && sec
->spec
.sorted
!= none
2810 && sec
->spec
.sorted
!= by_none
)
2811 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2818 /* Expand a wild statement for a particular FILE. SECTION may be
2819 NULL, in which case it is a wild card. */
2822 output_section_callback (lang_wild_statement_type
*ptr
,
2823 struct wildcard_list
*sec
,
2825 struct flag_info
*sflag_info
,
2826 lang_input_statement_type
*file
,
2829 lang_statement_union_type
*before
;
2830 lang_output_section_statement_type
*os
;
2832 os
= (lang_output_section_statement_type
*) output
;
2834 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2835 if (unique_section_p (section
, os
))
2838 before
= wild_sort (ptr
, sec
, file
, section
);
2840 /* Here BEFORE points to the lang_input_section which
2841 should follow the one we are about to add. If BEFORE
2842 is NULL, then the section should just go at the end
2843 of the current list. */
2846 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2849 lang_statement_list_type list
;
2850 lang_statement_union_type
**pp
;
2852 lang_list_init (&list
);
2853 lang_add_section (&list
, section
, sflag_info
, os
);
2855 /* If we are discarding the section, LIST.HEAD will
2857 if (list
.head
!= NULL
)
2859 ASSERT (list
.head
->header
.next
== NULL
);
2861 for (pp
= &ptr
->children
.head
;
2863 pp
= &(*pp
)->header
.next
)
2864 ASSERT (*pp
!= NULL
);
2866 list
.head
->header
.next
= *pp
;
2872 /* Check if all sections in a wild statement for a particular FILE
2876 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2877 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2879 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2880 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2883 lang_output_section_statement_type
*os
;
2885 os
= (lang_output_section_statement_type
*) output
;
2887 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2888 if (unique_section_p (section
, os
))
2891 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2892 os
->all_input_readonly
= FALSE
;
2895 /* This is passed a file name which must have been seen already and
2896 added to the statement tree. We will see if it has been opened
2897 already and had its symbols read. If not then we'll read it. */
2899 static lang_input_statement_type
*
2900 lookup_name (const char *name
)
2902 lang_input_statement_type
*search
;
2904 for (search
= (void *) input_file_chain
.head
;
2906 search
= search
->next_real_file
)
2908 /* Use the local_sym_name as the name of the file that has
2909 already been loaded as filename might have been transformed
2910 via the search directory lookup mechanism. */
2911 const char *filename
= search
->local_sym_name
;
2913 if (filename
!= NULL
2914 && filename_cmp (filename
, name
) == 0)
2920 /* Arrange to splice the input statement added by new_afile into
2921 statement_list after the current input_file_chain tail.
2922 We know input_file_chain is not an empty list, and that
2923 lookup_name was called via open_input_bfds. Later calls to
2924 lookup_name should always match an existing input_statement. */
2925 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2926 lang_statement_union_type
**after
2927 = (void *) ((char *) input_file_chain
.tail
2928 - offsetof (lang_input_statement_type
, next_real_file
)
2929 + offsetof (lang_input_statement_type
, header
.next
));
2930 lang_statement_union_type
*rest
= *after
;
2931 stat_ptr
->tail
= after
;
2932 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2933 default_target
, NULL
);
2934 *stat_ptr
->tail
= rest
;
2936 stat_ptr
->tail
= tail
;
2939 /* If we have already added this file, or this file is not real
2940 don't add this file. */
2941 if (search
->flags
.loaded
|| !search
->flags
.real
)
2944 if (!load_symbols (search
, NULL
))
2950 /* Save LIST as a list of libraries whose symbols should not be exported. */
2955 struct excluded_lib
*next
;
2957 static struct excluded_lib
*excluded_libs
;
2960 add_excluded_libs (const char *list
)
2962 const char *p
= list
, *end
;
2966 struct excluded_lib
*entry
;
2967 end
= strpbrk (p
, ",:");
2969 end
= p
+ strlen (p
);
2970 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2971 entry
->next
= excluded_libs
;
2972 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2973 memcpy (entry
->name
, p
, end
- p
);
2974 entry
->name
[end
- p
] = '\0';
2975 excluded_libs
= entry
;
2983 check_excluded_libs (bfd
*abfd
)
2985 struct excluded_lib
*lib
= excluded_libs
;
2989 int len
= strlen (lib
->name
);
2990 const char *filename
= lbasename (bfd_get_filename (abfd
));
2992 if (strcmp (lib
->name
, "ALL") == 0)
2994 abfd
->no_export
= TRUE
;
2998 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2999 && (filename
[len
] == '\0'
3000 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3001 && filename
[len
+ 2] == '\0')))
3003 abfd
->no_export
= TRUE
;
3011 /* Get the symbols for an input file. */
3014 load_symbols (lang_input_statement_type
*entry
,
3015 lang_statement_list_type
*place
)
3019 if (entry
->flags
.loaded
)
3022 ldfile_open_file (entry
);
3024 /* Do not process further if the file was missing. */
3025 if (entry
->flags
.missing_file
)
3028 if (trace_files
|| verbose
)
3029 info_msg ("%pI\n", entry
);
3031 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3032 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3035 struct lang_input_statement_flags save_flags
;
3038 err
= bfd_get_error ();
3040 /* See if the emulation has some special knowledge. */
3041 if (ldemul_unrecognized_file (entry
))
3044 if (err
== bfd_error_file_ambiguously_recognized
)
3048 einfo (_("%P: %pB: file not recognized: %E;"
3049 " matching formats:"), entry
->the_bfd
);
3050 for (p
= matching
; *p
!= NULL
; p
++)
3054 else if (err
!= bfd_error_file_not_recognized
3056 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3058 bfd_close (entry
->the_bfd
);
3059 entry
->the_bfd
= NULL
;
3061 /* Try to interpret the file as a linker script. */
3062 save_flags
= input_flags
;
3063 ldfile_open_command_file (entry
->filename
);
3065 push_stat_ptr (place
);
3066 input_flags
.add_DT_NEEDED_for_regular
3067 = entry
->flags
.add_DT_NEEDED_for_regular
;
3068 input_flags
.add_DT_NEEDED_for_dynamic
3069 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3070 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3071 input_flags
.dynamic
= entry
->flags
.dynamic
;
3073 ldfile_assumed_script
= TRUE
;
3074 parser_input
= input_script
;
3075 current_input_file
= entry
->filename
;
3077 current_input_file
= NULL
;
3078 ldfile_assumed_script
= FALSE
;
3080 /* missing_file is sticky. sysrooted will already have been
3081 restored when seeing EOF in yyparse, but no harm to restore
3083 save_flags
.missing_file
|= input_flags
.missing_file
;
3084 input_flags
= save_flags
;
3088 entry
->flags
.loaded
= TRUE
;
3093 if (ldemul_recognized_file (entry
))
3096 /* We don't call ldlang_add_file for an archive. Instead, the
3097 add_symbols entry point will call ldlang_add_file, via the
3098 add_archive_element callback, for each element of the archive
3100 switch (bfd_get_format (entry
->the_bfd
))
3106 if (!entry
->flags
.reload
)
3107 ldlang_add_file (entry
);
3111 check_excluded_libs (entry
->the_bfd
);
3113 bfd_set_usrdata (entry
->the_bfd
, entry
);
3114 if (entry
->flags
.whole_archive
)
3117 bfd_boolean loaded
= TRUE
;
3122 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3127 if (!bfd_check_format (member
, bfd_object
))
3129 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3130 entry
->the_bfd
, member
);
3135 if (!(*link_info
.callbacks
3136 ->add_archive_element
) (&link_info
, member
,
3137 "--whole-archive", &subsbfd
))
3140 /* Potentially, the add_archive_element hook may have set a
3141 substitute BFD for us. */
3142 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3144 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3149 entry
->flags
.loaded
= loaded
;
3155 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3156 entry
->flags
.loaded
= TRUE
;
3158 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3160 return entry
->flags
.loaded
;
3163 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3164 may be NULL, indicating that it is a wildcard. Separate
3165 lang_input_section statements are created for each part of the
3166 expansion; they are added after the wild statement S. OUTPUT is
3167 the output section. */
3170 wild (lang_wild_statement_type
*s
,
3171 const char *target ATTRIBUTE_UNUSED
,
3172 lang_output_section_statement_type
*output
)
3174 struct wildcard_list
*sec
;
3176 if (s
->handler_data
[0]
3177 && s
->handler_data
[0]->spec
.sorted
== by_name
3178 && !s
->filenames_sorted
)
3180 lang_section_bst_type
*tree
;
3182 walk_wild (s
, output_section_callback_fast
, output
);
3187 output_section_callback_tree_to_list (s
, tree
, output
);
3192 walk_wild (s
, output_section_callback
, output
);
3194 if (default_common_section
== NULL
)
3195 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3196 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3198 /* Remember the section that common is going to in case we
3199 later get something which doesn't know where to put it. */
3200 default_common_section
= output
;
3205 /* Return TRUE iff target is the sought target. */
3208 get_target (const bfd_target
*target
, void *data
)
3210 const char *sought
= (const char *) data
;
3212 return strcmp (target
->name
, sought
) == 0;
3215 /* Like strcpy() but convert to lower case as well. */
3218 stricpy (char *dest
, const char *src
)
3222 while ((c
= *src
++) != 0)
3223 *dest
++ = TOLOWER (c
);
3228 /* Remove the first occurrence of needle (if any) in haystack
3232 strcut (char *haystack
, const char *needle
)
3234 haystack
= strstr (haystack
, needle
);
3240 for (src
= haystack
+ strlen (needle
); *src
;)
3241 *haystack
++ = *src
++;
3247 /* Compare two target format name strings.
3248 Return a value indicating how "similar" they are. */
3251 name_compare (const char *first
, const char *second
)
3257 copy1
= (char *) xmalloc (strlen (first
) + 1);
3258 copy2
= (char *) xmalloc (strlen (second
) + 1);
3260 /* Convert the names to lower case. */
3261 stricpy (copy1
, first
);
3262 stricpy (copy2
, second
);
3264 /* Remove size and endian strings from the name. */
3265 strcut (copy1
, "big");
3266 strcut (copy1
, "little");
3267 strcut (copy2
, "big");
3268 strcut (copy2
, "little");
3270 /* Return a value based on how many characters match,
3271 starting from the beginning. If both strings are
3272 the same then return 10 * their length. */
3273 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3274 if (copy1
[result
] == 0)
3286 /* Set by closest_target_match() below. */
3287 static const bfd_target
*winner
;
3289 /* Scan all the valid bfd targets looking for one that has the endianness
3290 requirement that was specified on the command line, and is the nearest
3291 match to the original output target. */
3294 closest_target_match (const bfd_target
*target
, void *data
)
3296 const bfd_target
*original
= (const bfd_target
*) data
;
3298 if (command_line
.endian
== ENDIAN_BIG
3299 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3302 if (command_line
.endian
== ENDIAN_LITTLE
3303 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3306 /* Must be the same flavour. */
3307 if (target
->flavour
!= original
->flavour
)
3310 /* Ignore generic big and little endian elf vectors. */
3311 if (strcmp (target
->name
, "elf32-big") == 0
3312 || strcmp (target
->name
, "elf64-big") == 0
3313 || strcmp (target
->name
, "elf32-little") == 0
3314 || strcmp (target
->name
, "elf64-little") == 0)
3317 /* If we have not found a potential winner yet, then record this one. */
3324 /* Oh dear, we now have two potential candidates for a successful match.
3325 Compare their names and choose the better one. */
3326 if (name_compare (target
->name
, original
->name
)
3327 > name_compare (winner
->name
, original
->name
))
3330 /* Keep on searching until wqe have checked them all. */
3334 /* Return the BFD target format of the first input file. */
3337 get_first_input_target (void)
3339 const char *target
= NULL
;
3341 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3343 if (s
->header
.type
== lang_input_statement_enum
3346 ldfile_open_file (s
);
3348 if (s
->the_bfd
!= NULL
3349 && bfd_check_format (s
->the_bfd
, bfd_object
))
3351 target
= bfd_get_target (s
->the_bfd
);
3363 lang_get_output_target (void)
3367 /* Has the user told us which output format to use? */
3368 if (output_target
!= NULL
)
3369 return output_target
;
3371 /* No - has the current target been set to something other than
3373 if (current_target
!= default_target
&& current_target
!= NULL
)
3374 return current_target
;
3376 /* No - can we determine the format of the first input file? */
3377 target
= get_first_input_target ();
3381 /* Failed - use the default output target. */
3382 return default_target
;
3385 /* Open the output file. */
3388 open_output (const char *name
)
3390 output_target
= lang_get_output_target ();
3392 /* Has the user requested a particular endianness on the command
3394 if (command_line
.endian
!= ENDIAN_UNSET
)
3396 /* Get the chosen target. */
3397 const bfd_target
*target
3398 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3400 /* If the target is not supported, we cannot do anything. */
3403 enum bfd_endian desired_endian
;
3405 if (command_line
.endian
== ENDIAN_BIG
)
3406 desired_endian
= BFD_ENDIAN_BIG
;
3408 desired_endian
= BFD_ENDIAN_LITTLE
;
3410 /* See if the target has the wrong endianness. This should
3411 not happen if the linker script has provided big and
3412 little endian alternatives, but some scrips don't do
3414 if (target
->byteorder
!= desired_endian
)
3416 /* If it does, then see if the target provides
3417 an alternative with the correct endianness. */
3418 if (target
->alternative_target
!= NULL
3419 && (target
->alternative_target
->byteorder
== desired_endian
))
3420 output_target
= target
->alternative_target
->name
;
3423 /* Try to find a target as similar as possible to
3424 the default target, but which has the desired
3425 endian characteristic. */
3426 bfd_iterate_over_targets (closest_target_match
,
3429 /* Oh dear - we could not find any targets that
3430 satisfy our requirements. */
3432 einfo (_("%P: warning: could not find any targets"
3433 " that match endianness requirement\n"));
3435 output_target
= winner
->name
;
3441 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3443 if (link_info
.output_bfd
== NULL
)
3445 if (bfd_get_error () == bfd_error_invalid_target
)
3446 einfo (_("%F%P: target %s not found\n"), output_target
);
3448 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3451 delete_output_file_on_failure
= TRUE
;
3453 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3454 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3455 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3456 ldfile_output_architecture
,
3457 ldfile_output_machine
))
3458 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3460 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3461 if (link_info
.hash
== NULL
)
3462 einfo (_("%F%P: can not create hash table: %E\n"));
3464 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3468 ldlang_open_output (lang_statement_union_type
*statement
)
3470 switch (statement
->header
.type
)
3472 case lang_output_statement_enum
:
3473 ASSERT (link_info
.output_bfd
== NULL
);
3474 open_output (statement
->output_statement
.name
);
3475 ldemul_set_output_arch ();
3476 if (config
.magic_demand_paged
3477 && !bfd_link_relocatable (&link_info
))
3478 link_info
.output_bfd
->flags
|= D_PAGED
;
3480 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3481 if (config
.text_read_only
)
3482 link_info
.output_bfd
->flags
|= WP_TEXT
;
3484 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3485 if (link_info
.traditional_format
)
3486 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3488 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3491 case lang_target_statement_enum
:
3492 current_target
= statement
->target_statement
.target
;
3500 init_opb (asection
*s
)
3505 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3507 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3510 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3511 ldfile_output_machine
);
3513 while ((x
& 1) == 0)
3521 /* Open all the input files. */
3525 OPEN_BFD_NORMAL
= 0,
3529 #if BFD_SUPPORTS_PLUGINS
3530 static lang_input_statement_type
*plugin_insert
= NULL
;
3531 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3535 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3537 for (; s
!= NULL
; s
= s
->header
.next
)
3539 switch (s
->header
.type
)
3541 case lang_constructors_statement_enum
:
3542 open_input_bfds (constructor_list
.head
, mode
);
3544 case lang_output_section_statement_enum
:
3545 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3547 case lang_wild_statement_enum
:
3548 /* Maybe we should load the file's symbols. */
3549 if ((mode
& OPEN_BFD_RESCAN
) == 0
3550 && s
->wild_statement
.filename
3551 && !wildcardp (s
->wild_statement
.filename
)
3552 && !archive_path (s
->wild_statement
.filename
))
3553 lookup_name (s
->wild_statement
.filename
);
3554 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3556 case lang_group_statement_enum
:
3558 struct bfd_link_hash_entry
*undefs
;
3559 #if BFD_SUPPORTS_PLUGINS
3560 lang_input_statement_type
*plugin_insert_save
;
3563 /* We must continually search the entries in the group
3564 until no new symbols are added to the list of undefined
3569 #if BFD_SUPPORTS_PLUGINS
3570 plugin_insert_save
= plugin_insert
;
3572 undefs
= link_info
.hash
->undefs_tail
;
3573 open_input_bfds (s
->group_statement
.children
.head
,
3574 mode
| OPEN_BFD_FORCE
);
3576 while (undefs
!= link_info
.hash
->undefs_tail
3577 #if BFD_SUPPORTS_PLUGINS
3578 /* Objects inserted by a plugin, which are loaded
3579 before we hit this loop, may have added new
3581 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3586 case lang_target_statement_enum
:
3587 current_target
= s
->target_statement
.target
;
3589 case lang_input_statement_enum
:
3590 if (s
->input_statement
.flags
.real
)
3592 lang_statement_union_type
**os_tail
;
3593 lang_statement_list_type add
;
3596 s
->input_statement
.target
= current_target
;
3598 /* If we are being called from within a group, and this
3599 is an archive which has already been searched, then
3600 force it to be researched unless the whole archive
3601 has been loaded already. Do the same for a rescan.
3602 Likewise reload --as-needed shared libs. */
3603 if (mode
!= OPEN_BFD_NORMAL
3604 #if BFD_SUPPORTS_PLUGINS
3605 && ((mode
& OPEN_BFD_RESCAN
) == 0
3606 || plugin_insert
== NULL
)
3608 && s
->input_statement
.flags
.loaded
3609 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3610 && ((bfd_get_format (abfd
) == bfd_archive
3611 && !s
->input_statement
.flags
.whole_archive
)
3612 || (bfd_get_format (abfd
) == bfd_object
3613 && ((abfd
->flags
) & DYNAMIC
) != 0
3614 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3615 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3616 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3618 s
->input_statement
.flags
.loaded
= FALSE
;
3619 s
->input_statement
.flags
.reload
= TRUE
;
3622 os_tail
= lang_os_list
.tail
;
3623 lang_list_init (&add
);
3625 if (!load_symbols (&s
->input_statement
, &add
))
3626 config
.make_executable
= FALSE
;
3628 if (add
.head
!= NULL
)
3630 /* If this was a script with output sections then
3631 tack any added statements on to the end of the
3632 list. This avoids having to reorder the output
3633 section statement list. Very likely the user
3634 forgot -T, and whatever we do here will not meet
3635 naive user expectations. */
3636 if (os_tail
!= lang_os_list
.tail
)
3638 einfo (_("%P: warning: %s contains output sections;"
3639 " did you forget -T?\n"),
3640 s
->input_statement
.filename
);
3641 *stat_ptr
->tail
= add
.head
;
3642 stat_ptr
->tail
= add
.tail
;
3646 *add
.tail
= s
->header
.next
;
3647 s
->header
.next
= add
.head
;
3651 #if BFD_SUPPORTS_PLUGINS
3652 /* If we have found the point at which a plugin added new
3653 files, clear plugin_insert to enable archive rescan. */
3654 if (&s
->input_statement
== plugin_insert
)
3655 plugin_insert
= NULL
;
3658 case lang_assignment_statement_enum
:
3659 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3660 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3667 /* Exit if any of the files were missing. */
3668 if (input_flags
.missing_file
)
3672 /* Open the CTF sections in the input files with libctf: if any were opened,
3673 create a fake input file that we'll write the merged CTF data to later
3677 ldlang_open_ctf (void)
3682 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3686 /* Incoming files from the compiler have a single ctf_file_t in them
3687 (which is presented to us by the libctf API in a ctf_archive_t
3688 wrapper): files derived from a previous relocatable link have a CTF
3689 archive containing possibly many CTF files. */
3691 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3693 if (err
!= ECTF_NOCTFDATA
)
3694 einfo (_("%P: warning: CTF section in `%pI' not loaded: "
3695 "its types will be discarded: `%s'\n"), file
,
3700 /* Prevent the contents of this section from being written, while
3701 requiring the section itself to be duplicated in the output. */
3702 /* This section must exist if ctf_bfdopen() succeeded. */
3703 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3705 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3716 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3719 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3722 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3723 ctf_close (errfile
->the_ctf
);
3726 /* Merge together CTF sections. After this, only the symtab-dependent
3727 function and data object sections need adjustment. */
3730 lang_merge_ctf (void)
3732 asection
*output_sect
;
3737 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3739 /* If the section was discarded, don't waste time merging. */
3740 if (output_sect
== NULL
)
3742 ctf_file_close (ctf_output
);
3745 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3747 ctf_close (file
->the_ctf
);
3748 file
->the_ctf
= NULL
;
3753 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3758 /* Takes ownership of file->u.the_ctfa. */
3759 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3761 einfo (_("%F%P: cannot link with CTF in %pB: %s\n"), file
->the_bfd
,
3762 ctf_errmsg (ctf_errno (ctf_output
)));
3763 ctf_close (file
->the_ctf
);
3764 file
->the_ctf
= NULL
;
3769 if (ctf_link (ctf_output
, CTF_LINK_SHARE_UNCONFLICTED
) < 0)
3771 einfo (_("%F%P: CTF linking failed; output will have no CTF section: %s\n"),
3772 ctf_errmsg (ctf_errno (ctf_output
)));
3775 output_sect
->size
= 0;
3776 output_sect
->flags
|= SEC_EXCLUDE
;
3781 /* Let the emulation examine the symbol table and strtab to help it optimize the
3782 CTF, if supported. */
3785 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms
, bfd_size_type symcount
,
3786 struct elf_strtab_hash
*symstrtab
)
3788 ldemul_examine_strtab_for_ctf (ctf_output
, syms
, symcount
, symstrtab
);
3791 /* Write out the CTF section. Called early, if the emulation isn't going to
3792 need to dedup against the strtab and symtab, then possibly called from the
3793 target linker code if the dedup has happened. */
3795 lang_write_ctf (int late
)
3798 asection
*output_sect
;
3805 /* Emit CTF late if this emulation says it can do so. */
3806 if (ldemul_emit_ctf_early ())
3811 if (!ldemul_emit_ctf_early ())
3817 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3820 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3821 CTF_COMPRESSION_THRESHOLD
);
3822 output_sect
->size
= output_size
;
3823 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3825 if (!output_sect
->contents
)
3827 einfo (_("%F%P: CTF section emission failed; output will have no "
3828 "CTF section: %s\n"), ctf_errmsg (ctf_errno (ctf_output
)));
3829 output_sect
->size
= 0;
3830 output_sect
->flags
|= SEC_EXCLUDE
;
3834 /* This also closes every CTF input file used in the link. */
3835 ctf_file_close (ctf_output
);
3838 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3839 file
->the_ctf
= NULL
;
3842 /* Write out the CTF section late, if the emulation needs that. */
3845 ldlang_write_ctf_late (void)
3847 /* Trigger a "late call", if the emulation needs one. */
3852 /* Add the supplied name to the symbol table as an undefined reference.
3853 This is a two step process as the symbol table doesn't even exist at
3854 the time the ld command line is processed. First we put the name
3855 on a list, then, once the output file has been opened, transfer the
3856 name to the symbol table. */
3858 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3860 #define ldlang_undef_chain_list_head entry_symbol.next
3863 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3865 ldlang_undef_chain_list_type
*new_undef
;
3867 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3868 new_undef
= stat_alloc (sizeof (*new_undef
));
3869 new_undef
->next
= ldlang_undef_chain_list_head
;
3870 ldlang_undef_chain_list_head
= new_undef
;
3872 new_undef
->name
= xstrdup (name
);
3874 if (link_info
.output_bfd
!= NULL
)
3875 insert_undefined (new_undef
->name
);
3878 /* Insert NAME as undefined in the symbol table. */
3881 insert_undefined (const char *name
)
3883 struct bfd_link_hash_entry
*h
;
3885 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3887 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3888 if (h
->type
== bfd_link_hash_new
)
3890 h
->type
= bfd_link_hash_undefined
;
3891 h
->u
.undef
.abfd
= NULL
;
3892 h
->non_ir_ref_regular
= TRUE
;
3893 if (is_elf_hash_table (link_info
.hash
))
3894 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3895 bfd_link_add_undef (link_info
.hash
, h
);
3899 /* Run through the list of undefineds created above and place them
3900 into the linker hash table as undefined symbols belonging to the
3904 lang_place_undefineds (void)
3906 ldlang_undef_chain_list_type
*ptr
;
3908 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3909 insert_undefined (ptr
->name
);
3912 /* Structure used to build the list of symbols that the user has required
3915 struct require_defined_symbol
3918 struct require_defined_symbol
*next
;
3921 /* The list of symbols that the user has required be defined. */
3923 static struct require_defined_symbol
*require_defined_symbol_list
;
3925 /* Add a new symbol NAME to the list of symbols that are required to be
3929 ldlang_add_require_defined (const char *const name
)
3931 struct require_defined_symbol
*ptr
;
3933 ldlang_add_undef (name
, TRUE
);
3934 ptr
= stat_alloc (sizeof (*ptr
));
3935 ptr
->next
= require_defined_symbol_list
;
3936 ptr
->name
= strdup (name
);
3937 require_defined_symbol_list
= ptr
;
3940 /* Check that all symbols the user required to be defined, are defined,
3941 raise an error if we find a symbol that is not defined. */
3944 ldlang_check_require_defined_symbols (void)
3946 struct require_defined_symbol
*ptr
;
3948 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3950 struct bfd_link_hash_entry
*h
;
3952 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3953 FALSE
, FALSE
, TRUE
);
3955 || (h
->type
!= bfd_link_hash_defined
3956 && h
->type
!= bfd_link_hash_defweak
))
3957 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3961 /* Check for all readonly or some readwrite sections. */
3964 check_input_sections
3965 (lang_statement_union_type
*s
,
3966 lang_output_section_statement_type
*output_section_statement
)
3968 for (; s
!= NULL
; s
= s
->header
.next
)
3970 switch (s
->header
.type
)
3972 case lang_wild_statement_enum
:
3973 walk_wild (&s
->wild_statement
, check_section_callback
,
3974 output_section_statement
);
3975 if (!output_section_statement
->all_input_readonly
)
3978 case lang_constructors_statement_enum
:
3979 check_input_sections (constructor_list
.head
,
3980 output_section_statement
);
3981 if (!output_section_statement
->all_input_readonly
)
3984 case lang_group_statement_enum
:
3985 check_input_sections (s
->group_statement
.children
.head
,
3986 output_section_statement
);
3987 if (!output_section_statement
->all_input_readonly
)
3996 /* Update wildcard statements if needed. */
3999 update_wild_statements (lang_statement_union_type
*s
)
4001 struct wildcard_list
*sec
;
4003 switch (sort_section
)
4013 for (; s
!= NULL
; s
= s
->header
.next
)
4015 switch (s
->header
.type
)
4020 case lang_wild_statement_enum
:
4021 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4023 /* Don't sort .init/.fini sections. */
4024 if (strcmp (sec
->spec
.name
, ".init") != 0
4025 && strcmp (sec
->spec
.name
, ".fini") != 0)
4026 switch (sec
->spec
.sorted
)
4029 sec
->spec
.sorted
= sort_section
;
4032 if (sort_section
== by_alignment
)
4033 sec
->spec
.sorted
= by_name_alignment
;
4036 if (sort_section
== by_name
)
4037 sec
->spec
.sorted
= by_alignment_name
;
4044 case lang_constructors_statement_enum
:
4045 update_wild_statements (constructor_list
.head
);
4048 case lang_output_section_statement_enum
:
4049 update_wild_statements
4050 (s
->output_section_statement
.children
.head
);
4053 case lang_group_statement_enum
:
4054 update_wild_statements (s
->group_statement
.children
.head
);
4062 /* Open input files and attach to output sections. */
4065 map_input_to_output_sections
4066 (lang_statement_union_type
*s
, const char *target
,
4067 lang_output_section_statement_type
*os
)
4069 for (; s
!= NULL
; s
= s
->header
.next
)
4071 lang_output_section_statement_type
*tos
;
4074 switch (s
->header
.type
)
4076 case lang_wild_statement_enum
:
4077 wild (&s
->wild_statement
, target
, os
);
4079 case lang_constructors_statement_enum
:
4080 map_input_to_output_sections (constructor_list
.head
,
4084 case lang_output_section_statement_enum
:
4085 tos
= &s
->output_section_statement
;
4086 if (tos
->constraint
!= 0)
4088 if (tos
->constraint
!= ONLY_IF_RW
4089 && tos
->constraint
!= ONLY_IF_RO
)
4091 tos
->all_input_readonly
= TRUE
;
4092 check_input_sections (tos
->children
.head
, tos
);
4093 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4095 tos
->constraint
= -1;
4099 map_input_to_output_sections (tos
->children
.head
,
4103 case lang_output_statement_enum
:
4105 case lang_target_statement_enum
:
4106 target
= s
->target_statement
.target
;
4108 case lang_group_statement_enum
:
4109 map_input_to_output_sections (s
->group_statement
.children
.head
,
4113 case lang_data_statement_enum
:
4114 /* Make sure that any sections mentioned in the expression
4116 exp_init_os (s
->data_statement
.exp
);
4117 /* The output section gets CONTENTS, ALLOC and LOAD, but
4118 these may be overridden by the script. */
4119 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4120 switch (os
->sectype
)
4122 case normal_section
:
4123 case overlay_section
:
4124 case first_overlay_section
:
4126 case noalloc_section
:
4127 flags
= SEC_HAS_CONTENTS
;
4129 case noload_section
:
4130 if (bfd_get_flavour (link_info
.output_bfd
)
4131 == bfd_target_elf_flavour
)
4132 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4134 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4137 if (os
->bfd_section
== NULL
)
4138 init_os (os
, flags
);
4140 os
->bfd_section
->flags
|= flags
;
4142 case lang_input_section_enum
:
4144 case lang_fill_statement_enum
:
4145 case lang_object_symbols_statement_enum
:
4146 case lang_reloc_statement_enum
:
4147 case lang_padding_statement_enum
:
4148 case lang_input_statement_enum
:
4149 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4152 case lang_assignment_statement_enum
:
4153 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4156 /* Make sure that any sections mentioned in the assignment
4158 exp_init_os (s
->assignment_statement
.exp
);
4160 case lang_address_statement_enum
:
4161 /* Mark the specified section with the supplied address.
4162 If this section was actually a segment marker, then the
4163 directive is ignored if the linker script explicitly
4164 processed the segment marker. Originally, the linker
4165 treated segment directives (like -Ttext on the
4166 command-line) as section directives. We honor the
4167 section directive semantics for backwards compatibility;
4168 linker scripts that do not specifically check for
4169 SEGMENT_START automatically get the old semantics. */
4170 if (!s
->address_statement
.segment
4171 || !s
->address_statement
.segment
->used
)
4173 const char *name
= s
->address_statement
.section_name
;
4175 /* Create the output section statement here so that
4176 orphans with a set address will be placed after other
4177 script sections. If we let the orphan placement code
4178 place them in amongst other sections then the address
4179 will affect following script sections, which is
4180 likely to surprise naive users. */
4181 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
4182 tos
->addr_tree
= s
->address_statement
.address
;
4183 if (tos
->bfd_section
== NULL
)
4187 case lang_insert_statement_enum
:
4193 /* An insert statement snips out all the linker statements from the
4194 start of the list and places them after the output section
4195 statement specified by the insert. This operation is complicated
4196 by the fact that we keep a doubly linked list of output section
4197 statements as well as the singly linked list of all statements.
4198 FIXME someday: Twiddling with the list not only moves statements
4199 from the user's script but also input and group statements that are
4200 built from command line object files and --start-group. We only
4201 get away with this because the list pointers used by file_chain
4202 and input_file_chain are not reordered, and processing via
4203 statement_list after this point mostly ignores input statements.
4204 One exception is the map file, where LOAD and START GROUP/END GROUP
4205 can end up looking odd. */
4208 process_insert_statements (lang_statement_union_type
**start
)
4210 lang_statement_union_type
**s
;
4211 lang_output_section_statement_type
*first_os
= NULL
;
4212 lang_output_section_statement_type
*last_os
= NULL
;
4213 lang_output_section_statement_type
*os
;
4218 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4220 /* Keep pointers to the first and last output section
4221 statement in the sequence we may be about to move. */
4222 os
= &(*s
)->output_section_statement
;
4224 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4227 /* Set constraint negative so that lang_output_section_find
4228 won't match this output section statement. At this
4229 stage in linking constraint has values in the range
4230 [-1, ONLY_IN_RW]. */
4231 last_os
->constraint
= -2 - last_os
->constraint
;
4232 if (first_os
== NULL
)
4235 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4237 /* A user might put -T between --start-group and
4238 --end-group. One way this odd construct might arise is
4239 from a wrapper around ld to change library search
4240 behaviour. For example:
4242 exec real_ld --start-group "$@" --end-group
4243 This isn't completely unreasonable so go looking inside a
4244 group statement for insert statements. */
4245 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4247 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4249 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4250 lang_output_section_statement_type
*where
;
4251 lang_statement_union_type
**ptr
;
4252 lang_statement_union_type
*first
;
4254 if (link_info
.non_contiguous_regions
)
4256 einfo (_("warning: INSERT statement in linker script is "
4257 "incompatible with --enable-non-contiguous-regions.\n"));
4260 where
= lang_output_section_find (i
->where
);
4261 if (where
!= NULL
&& i
->is_before
)
4264 where
= where
->prev
;
4265 while (where
!= NULL
&& where
->constraint
< 0);
4269 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4273 /* Deal with reordering the output section statement list. */
4274 if (last_os
!= NULL
)
4276 asection
*first_sec
, *last_sec
;
4277 struct lang_output_section_statement_struct
**next
;
4279 /* Snip out the output sections we are moving. */
4280 first_os
->prev
->next
= last_os
->next
;
4281 if (last_os
->next
== NULL
)
4283 next
= &first_os
->prev
->next
;
4284 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4287 last_os
->next
->prev
= first_os
->prev
;
4288 /* Add them in at the new position. */
4289 last_os
->next
= where
->next
;
4290 if (where
->next
== NULL
)
4292 next
= &last_os
->next
;
4293 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4296 where
->next
->prev
= last_os
;
4297 first_os
->prev
= where
;
4298 where
->next
= first_os
;
4300 /* Move the bfd sections in the same way. */
4303 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4305 os
->constraint
= -2 - os
->constraint
;
4306 if (os
->bfd_section
!= NULL
4307 && os
->bfd_section
->owner
!= NULL
)
4309 last_sec
= os
->bfd_section
;
4310 if (first_sec
== NULL
)
4311 first_sec
= last_sec
;
4316 if (last_sec
!= NULL
)
4318 asection
*sec
= where
->bfd_section
;
4320 sec
= output_prev_sec_find (where
);
4322 /* The place we want to insert must come after the
4323 sections we are moving. So if we find no
4324 section or if the section is the same as our
4325 last section, then no move is needed. */
4326 if (sec
!= NULL
&& sec
!= last_sec
)
4328 /* Trim them off. */
4329 if (first_sec
->prev
!= NULL
)
4330 first_sec
->prev
->next
= last_sec
->next
;
4332 link_info
.output_bfd
->sections
= last_sec
->next
;
4333 if (last_sec
->next
!= NULL
)
4334 last_sec
->next
->prev
= first_sec
->prev
;
4336 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4338 last_sec
->next
= sec
->next
;
4339 if (sec
->next
!= NULL
)
4340 sec
->next
->prev
= last_sec
;
4342 link_info
.output_bfd
->section_last
= last_sec
;
4343 first_sec
->prev
= sec
;
4344 sec
->next
= first_sec
;
4352 ptr
= insert_os_after (where
);
4353 /* Snip everything from the start of the list, up to and
4354 including the insert statement we are currently processing. */
4356 *start
= (*s
)->header
.next
;
4357 /* Add them back where they belong, minus the insert. */
4360 statement_list
.tail
= s
;
4365 s
= &(*s
)->header
.next
;
4368 /* Undo constraint twiddling. */
4369 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4371 os
->constraint
= -2 - os
->constraint
;
4377 /* An output section might have been removed after its statement was
4378 added. For example, ldemul_before_allocation can remove dynamic
4379 sections if they turn out to be not needed. Clean them up here. */
4382 strip_excluded_output_sections (void)
4384 lang_output_section_statement_type
*os
;
4386 /* Run lang_size_sections (if not already done). */
4387 if (expld
.phase
!= lang_mark_phase_enum
)
4389 expld
.phase
= lang_mark_phase_enum
;
4390 expld
.dataseg
.phase
= exp_seg_none
;
4391 one_lang_size_sections_pass (NULL
, FALSE
);
4392 lang_reset_memory_regions ();
4395 for (os
= (void *) lang_os_list
.head
;
4399 asection
*output_section
;
4400 bfd_boolean exclude
;
4402 if (os
->constraint
< 0)
4405 output_section
= os
->bfd_section
;
4406 if (output_section
== NULL
)
4409 exclude
= (output_section
->rawsize
== 0
4410 && (output_section
->flags
& SEC_KEEP
) == 0
4411 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4414 /* Some sections have not yet been sized, notably .gnu.version,
4415 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4416 input sections, so don't drop output sections that have such
4417 input sections unless they are also marked SEC_EXCLUDE. */
4418 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4422 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4423 if ((s
->flags
& SEC_EXCLUDE
) == 0
4424 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4425 || link_info
.emitrelocations
))
4434 /* We don't set bfd_section to NULL since bfd_section of the
4435 removed output section statement may still be used. */
4436 if (!os
->update_dot
)
4438 output_section
->flags
|= SEC_EXCLUDE
;
4439 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4440 link_info
.output_bfd
->section_count
--;
4445 /* Called from ldwrite to clear out asection.map_head and
4446 asection.map_tail for use as link_orders in ldwrite. */
4449 lang_clear_os_map (void)
4451 lang_output_section_statement_type
*os
;
4453 if (map_head_is_link_order
)
4456 for (os
= (void *) lang_os_list
.head
;
4460 asection
*output_section
;
4462 if (os
->constraint
< 0)
4465 output_section
= os
->bfd_section
;
4466 if (output_section
== NULL
)
4469 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4470 output_section
->map_head
.link_order
= NULL
;
4471 output_section
->map_tail
.link_order
= NULL
;
4474 /* Stop future calls to lang_add_section from messing with map_head
4475 and map_tail link_order fields. */
4476 map_head_is_link_order
= TRUE
;
4480 print_output_section_statement
4481 (lang_output_section_statement_type
*output_section_statement
)
4483 asection
*section
= output_section_statement
->bfd_section
;
4486 if (output_section_statement
!= abs_output_section
)
4488 minfo ("\n%s", output_section_statement
->name
);
4490 if (section
!= NULL
)
4492 print_dot
= section
->vma
;
4494 len
= strlen (output_section_statement
->name
);
4495 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4500 while (len
< SECTION_NAME_MAP_LENGTH
)
4506 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4508 if (section
->vma
!= section
->lma
)
4509 minfo (_(" load address 0x%V"), section
->lma
);
4511 if (output_section_statement
->update_dot_tree
!= NULL
)
4512 exp_fold_tree (output_section_statement
->update_dot_tree
,
4513 bfd_abs_section_ptr
, &print_dot
);
4519 print_statement_list (output_section_statement
->children
.head
,
4520 output_section_statement
);
4524 print_assignment (lang_assignment_statement_type
*assignment
,
4525 lang_output_section_statement_type
*output_section
)
4532 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4535 if (assignment
->exp
->type
.node_class
== etree_assert
)
4538 tree
= assignment
->exp
->assert_s
.child
;
4542 const char *dst
= assignment
->exp
->assign
.dst
;
4544 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4545 tree
= assignment
->exp
;
4548 osec
= output_section
->bfd_section
;
4550 osec
= bfd_abs_section_ptr
;
4552 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4553 exp_fold_tree (tree
, osec
, &print_dot
);
4555 expld
.result
.valid_p
= FALSE
;
4557 if (expld
.result
.valid_p
)
4561 if (assignment
->exp
->type
.node_class
== etree_assert
4563 || expld
.assign_name
!= NULL
)
4565 value
= expld
.result
.value
;
4567 if (expld
.result
.section
!= NULL
)
4568 value
+= expld
.result
.section
->vma
;
4570 minfo ("0x%V", value
);
4576 struct bfd_link_hash_entry
*h
;
4578 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4579 FALSE
, FALSE
, TRUE
);
4581 && (h
->type
== bfd_link_hash_defined
4582 || h
->type
== bfd_link_hash_defweak
))
4584 value
= h
->u
.def
.value
;
4585 value
+= h
->u
.def
.section
->output_section
->vma
;
4586 value
+= h
->u
.def
.section
->output_offset
;
4588 minfo ("[0x%V]", value
);
4591 minfo ("[unresolved]");
4596 if (assignment
->exp
->type
.node_class
== etree_provide
)
4597 minfo ("[!provide]");
4604 expld
.assign_name
= NULL
;
4607 exp_print_tree (assignment
->exp
);
4612 print_input_statement (lang_input_statement_type
*statm
)
4614 if (statm
->filename
!= NULL
)
4615 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4618 /* Print all symbols defined in a particular section. This is called
4619 via bfd_link_hash_traverse, or by print_all_symbols. */
4622 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4624 asection
*sec
= (asection
*) ptr
;
4626 if ((hash_entry
->type
== bfd_link_hash_defined
4627 || hash_entry
->type
== bfd_link_hash_defweak
)
4628 && sec
== hash_entry
->u
.def
.section
)
4632 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4635 (hash_entry
->u
.def
.value
4636 + hash_entry
->u
.def
.section
->output_offset
4637 + hash_entry
->u
.def
.section
->output_section
->vma
));
4639 minfo (" %pT\n", hash_entry
->root
.string
);
4646 hash_entry_addr_cmp (const void *a
, const void *b
)
4648 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4649 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4651 if (l
->u
.def
.value
< r
->u
.def
.value
)
4653 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4660 print_all_symbols (asection
*sec
)
4662 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4663 struct map_symbol_def
*def
;
4664 struct bfd_link_hash_entry
**entries
;
4670 *ud
->map_symbol_def_tail
= 0;
4672 /* Sort the symbols by address. */
4673 entries
= (struct bfd_link_hash_entry
**)
4674 obstack_alloc (&map_obstack
,
4675 ud
->map_symbol_def_count
* sizeof (*entries
));
4677 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4678 entries
[i
] = def
->entry
;
4680 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4681 hash_entry_addr_cmp
);
4683 /* Print the symbols. */
4684 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4685 ldemul_print_symbol (entries
[i
], sec
);
4687 obstack_free (&map_obstack
, entries
);
4690 /* Print information about an input section to the map file. */
4693 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4695 bfd_size_type size
= i
->size
;
4702 minfo ("%s", i
->name
);
4704 len
= 1 + strlen (i
->name
);
4705 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4710 while (len
< SECTION_NAME_MAP_LENGTH
)
4716 if (i
->output_section
!= NULL
4717 && i
->output_section
->owner
== link_info
.output_bfd
)
4718 addr
= i
->output_section
->vma
+ i
->output_offset
;
4726 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4728 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4730 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4742 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4745 if (i
->output_section
!= NULL
4746 && i
->output_section
->owner
== link_info
.output_bfd
)
4748 if (link_info
.reduce_memory_overheads
)
4749 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4751 print_all_symbols (i
);
4753 /* Update print_dot, but make sure that we do not move it
4754 backwards - this could happen if we have overlays and a
4755 later overlay is shorter than an earier one. */
4756 if (addr
+ TO_ADDR (size
) > print_dot
)
4757 print_dot
= addr
+ TO_ADDR (size
);
4762 print_fill_statement (lang_fill_statement_type
*fill
)
4766 fputs (" FILL mask 0x", config
.map_file
);
4767 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4768 fprintf (config
.map_file
, "%02x", *p
);
4769 fputs ("\n", config
.map_file
);
4773 print_data_statement (lang_data_statement_type
*data
)
4780 init_opb (data
->output_section
);
4781 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4784 addr
= data
->output_offset
;
4785 if (data
->output_section
!= NULL
)
4786 addr
+= data
->output_section
->vma
;
4814 if (size
< TO_SIZE ((unsigned) 1))
4815 size
= TO_SIZE ((unsigned) 1);
4816 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4818 if (data
->exp
->type
.node_class
!= etree_value
)
4821 exp_print_tree (data
->exp
);
4826 print_dot
= addr
+ TO_ADDR (size
);
4829 /* Print an address statement. These are generated by options like
4833 print_address_statement (lang_address_statement_type
*address
)
4835 minfo (_("Address of section %s set to "), address
->section_name
);
4836 exp_print_tree (address
->address
);
4840 /* Print a reloc statement. */
4843 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4849 init_opb (reloc
->output_section
);
4850 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4853 addr
= reloc
->output_offset
;
4854 if (reloc
->output_section
!= NULL
)
4855 addr
+= reloc
->output_section
->vma
;
4857 size
= bfd_get_reloc_size (reloc
->howto
);
4859 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4861 if (reloc
->name
!= NULL
)
4862 minfo ("%s+", reloc
->name
);
4864 minfo ("%s+", reloc
->section
->name
);
4866 exp_print_tree (reloc
->addend_exp
);
4870 print_dot
= addr
+ TO_ADDR (size
);
4874 print_padding_statement (lang_padding_statement_type
*s
)
4879 init_opb (s
->output_section
);
4882 len
= sizeof " *fill*" - 1;
4883 while (len
< SECTION_NAME_MAP_LENGTH
)
4889 addr
= s
->output_offset
;
4890 if (s
->output_section
!= NULL
)
4891 addr
+= s
->output_section
->vma
;
4892 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4894 if (s
->fill
->size
!= 0)
4898 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4899 fprintf (config
.map_file
, "%02x", *p
);
4904 print_dot
= addr
+ TO_ADDR (s
->size
);
4908 print_wild_statement (lang_wild_statement_type
*w
,
4909 lang_output_section_statement_type
*os
)
4911 struct wildcard_list
*sec
;
4915 if (w
->exclude_name_list
)
4918 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4919 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4920 minfo (" %s", tmp
->name
);
4924 if (w
->filenames_sorted
)
4925 minfo ("SORT_BY_NAME(");
4926 if (w
->filename
!= NULL
)
4927 minfo ("%s", w
->filename
);
4930 if (w
->filenames_sorted
)
4934 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4936 int closing_paren
= 0;
4938 switch (sec
->spec
.sorted
)
4944 minfo ("SORT_BY_NAME(");
4949 minfo ("SORT_BY_ALIGNMENT(");
4953 case by_name_alignment
:
4954 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4958 case by_alignment_name
:
4959 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4964 minfo ("SORT_NONE(");
4968 case by_init_priority
:
4969 minfo ("SORT_BY_INIT_PRIORITY(");
4974 if (sec
->spec
.exclude_name_list
!= NULL
)
4977 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4978 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4979 minfo (" %s", tmp
->name
);
4982 if (sec
->spec
.name
!= NULL
)
4983 minfo ("%s", sec
->spec
.name
);
4986 for (;closing_paren
> 0; closing_paren
--)
4995 print_statement_list (w
->children
.head
, os
);
4998 /* Print a group statement. */
5001 print_group (lang_group_statement_type
*s
,
5002 lang_output_section_statement_type
*os
)
5004 fprintf (config
.map_file
, "START GROUP\n");
5005 print_statement_list (s
->children
.head
, os
);
5006 fprintf (config
.map_file
, "END GROUP\n");
5009 /* Print the list of statements in S.
5010 This can be called for any statement type. */
5013 print_statement_list (lang_statement_union_type
*s
,
5014 lang_output_section_statement_type
*os
)
5018 print_statement (s
, os
);
5023 /* Print the first statement in statement list S.
5024 This can be called for any statement type. */
5027 print_statement (lang_statement_union_type
*s
,
5028 lang_output_section_statement_type
*os
)
5030 switch (s
->header
.type
)
5033 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5036 case lang_constructors_statement_enum
:
5037 if (constructor_list
.head
!= NULL
)
5039 if (constructors_sorted
)
5040 minfo (" SORT (CONSTRUCTORS)\n");
5042 minfo (" CONSTRUCTORS\n");
5043 print_statement_list (constructor_list
.head
, os
);
5046 case lang_wild_statement_enum
:
5047 print_wild_statement (&s
->wild_statement
, os
);
5049 case lang_address_statement_enum
:
5050 print_address_statement (&s
->address_statement
);
5052 case lang_object_symbols_statement_enum
:
5053 minfo (" CREATE_OBJECT_SYMBOLS\n");
5055 case lang_fill_statement_enum
:
5056 print_fill_statement (&s
->fill_statement
);
5058 case lang_data_statement_enum
:
5059 print_data_statement (&s
->data_statement
);
5061 case lang_reloc_statement_enum
:
5062 print_reloc_statement (&s
->reloc_statement
);
5064 case lang_input_section_enum
:
5065 print_input_section (s
->input_section
.section
, FALSE
);
5067 case lang_padding_statement_enum
:
5068 print_padding_statement (&s
->padding_statement
);
5070 case lang_output_section_statement_enum
:
5071 print_output_section_statement (&s
->output_section_statement
);
5073 case lang_assignment_statement_enum
:
5074 print_assignment (&s
->assignment_statement
, os
);
5076 case lang_target_statement_enum
:
5077 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5079 case lang_output_statement_enum
:
5080 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5081 if (output_target
!= NULL
)
5082 minfo (" %s", output_target
);
5085 case lang_input_statement_enum
:
5086 print_input_statement (&s
->input_statement
);
5088 case lang_group_statement_enum
:
5089 print_group (&s
->group_statement
, os
);
5091 case lang_insert_statement_enum
:
5092 minfo ("INSERT %s %s\n",
5093 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5094 s
->insert_statement
.where
);
5100 print_statements (void)
5102 print_statement_list (statement_list
.head
, abs_output_section
);
5105 /* Print the first N statements in statement list S to STDERR.
5106 If N == 0, nothing is printed.
5107 If N < 0, the entire list is printed.
5108 Intended to be called from GDB. */
5111 dprint_statement (lang_statement_union_type
*s
, int n
)
5113 FILE *map_save
= config
.map_file
;
5115 config
.map_file
= stderr
;
5118 print_statement_list (s
, abs_output_section
);
5121 while (s
&& --n
>= 0)
5123 print_statement (s
, abs_output_section
);
5128 config
.map_file
= map_save
;
5132 insert_pad (lang_statement_union_type
**ptr
,
5134 bfd_size_type alignment_needed
,
5135 asection
*output_section
,
5138 static fill_type zero_fill
;
5139 lang_statement_union_type
*pad
= NULL
;
5141 if (ptr
!= &statement_list
.head
)
5142 pad
= ((lang_statement_union_type
*)
5143 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5145 && pad
->header
.type
== lang_padding_statement_enum
5146 && pad
->padding_statement
.output_section
== output_section
)
5148 /* Use the existing pad statement. */
5150 else if ((pad
= *ptr
) != NULL
5151 && pad
->header
.type
== lang_padding_statement_enum
5152 && pad
->padding_statement
.output_section
== output_section
)
5154 /* Use the existing pad statement. */
5158 /* Make a new padding statement, linked into existing chain. */
5159 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5160 pad
->header
.next
= *ptr
;
5162 pad
->header
.type
= lang_padding_statement_enum
;
5163 pad
->padding_statement
.output_section
= output_section
;
5166 pad
->padding_statement
.fill
= fill
;
5168 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5169 pad
->padding_statement
.size
= alignment_needed
;
5170 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5171 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5172 - output_section
->vma
);
5175 /* Work out how much this section will move the dot point. */
5179 (lang_statement_union_type
**this_ptr
,
5180 lang_output_section_statement_type
*output_section_statement
,
5182 bfd_boolean
*removed
,
5185 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5186 asection
*i
= is
->section
;
5187 asection
*o
= output_section_statement
->bfd_section
;
5190 if (link_info
.non_contiguous_regions
)
5192 /* If the input section I has already been successfully assigned
5193 to an output section other than O, don't bother with it and
5194 let the caller remove it from the list. Keep processing in
5195 case we have already handled O, because the repeated passes
5196 have reinitialized its size. */
5197 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5204 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5205 i
->output_offset
= i
->vma
- o
->vma
;
5206 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5207 || output_section_statement
->ignored
)
5208 i
->output_offset
= dot
- o
->vma
;
5211 bfd_size_type alignment_needed
;
5213 /* Align this section first to the input sections requirement,
5214 then to the output section's requirement. If this alignment
5215 is greater than any seen before, then record it too. Perform
5216 the alignment by inserting a magic 'padding' statement. */
5218 if (output_section_statement
->subsection_alignment
!= NULL
)
5220 = exp_get_power (output_section_statement
->subsection_alignment
,
5221 "subsection alignment");
5223 if (o
->alignment_power
< i
->alignment_power
)
5224 o
->alignment_power
= i
->alignment_power
;
5226 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5228 if (alignment_needed
!= 0)
5230 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5231 dot
+= alignment_needed
;
5234 if (link_info
.non_contiguous_regions
)
5236 /* If I would overflow O, let the caller remove I from the
5238 if (output_section_statement
->region
)
5240 bfd_vma end
= output_section_statement
->region
->origin
5241 + output_section_statement
->region
->length
;
5243 if (dot
+ TO_ADDR (i
->size
) > end
)
5245 if (i
->flags
& SEC_LINKER_CREATED
)
5246 einfo (_("%F%P: Output section '%s' not large enough for the "
5247 "linker-created stubs section '%s'.\n"),
5248 i
->output_section
->name
, i
->name
);
5250 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5251 einfo (_("%F%P: Relaxation not supported with "
5252 "--enable-non-contiguous-regions (section '%s' "
5253 "would overflow '%s' after it changed size).\n"),
5254 i
->name
, i
->output_section
->name
);
5258 i
->output_section
= NULL
;
5264 /* Remember where in the output section this input section goes. */
5265 i
->output_offset
= dot
- o
->vma
;
5267 /* Mark how big the output section must be to contain this now. */
5268 dot
+= TO_ADDR (i
->size
);
5269 if (!(o
->flags
& SEC_FIXED_SIZE
))
5270 o
->size
= TO_SIZE (dot
- o
->vma
);
5272 if (link_info
.non_contiguous_regions
)
5274 /* Record that I was successfully assigned to O, and update
5275 its actual output section too. */
5276 i
->already_assigned
= o
;
5277 i
->output_section
= o
;
5291 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5293 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5294 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5296 if (sec1
->lma
< sec2
->lma
)
5298 else if (sec1
->lma
> sec2
->lma
)
5300 else if (sec1
->id
< sec2
->id
)
5302 else if (sec1
->id
> sec2
->id
)
5309 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5311 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5312 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5314 if (sec1
->vma
< sec2
->vma
)
5316 else if (sec1
->vma
> sec2
->vma
)
5318 else if (sec1
->id
< sec2
->id
)
5320 else if (sec1
->id
> sec2
->id
)
5326 #define IS_TBSS(s) \
5327 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5329 #define IGNORE_SECTION(s) \
5330 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5332 /* Check to see if any allocated sections overlap with other allocated
5333 sections. This can happen if a linker script specifies the output
5334 section addresses of the two sections. Also check whether any memory
5335 region has overflowed. */
5338 lang_check_section_addresses (void)
5341 struct check_sec
*sections
;
5346 bfd_vma p_start
= 0;
5348 lang_memory_region_type
*m
;
5349 bfd_boolean overlays
;
5351 /* Detect address space overflow on allocated sections. */
5352 addr_mask
= ((bfd_vma
) 1 <<
5353 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5354 addr_mask
= (addr_mask
<< 1) + 1;
5355 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5356 if ((s
->flags
& SEC_ALLOC
) != 0)
5358 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5359 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5360 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5364 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5365 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5366 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5371 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5374 count
= bfd_count_sections (link_info
.output_bfd
);
5375 sections
= XNEWVEC (struct check_sec
, count
);
5377 /* Scan all sections in the output list. */
5379 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5381 if (IGNORE_SECTION (s
)
5385 sections
[count
].sec
= s
;
5386 sections
[count
].warned
= FALSE
;
5396 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5398 /* First check section LMAs. There should be no overlap of LMAs on
5399 loadable sections, even with overlays. */
5400 for (p
= NULL
, i
= 0; i
< count
; i
++)
5402 s
= sections
[i
].sec
;
5404 if ((s
->flags
& SEC_LOAD
) != 0)
5407 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5409 /* Look for an overlap. We have sorted sections by lma, so
5410 we know that s_start >= p_start. Besides the obvious
5411 case of overlap when the current section starts before
5412 the previous one ends, we also must have overlap if the
5413 previous section wraps around the address space. */
5415 && (s_start
<= p_end
5416 || p_end
< p_start
))
5418 einfo (_("%X%P: section %s LMA [%V,%V]"
5419 " overlaps section %s LMA [%V,%V]\n"),
5420 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5421 sections
[i
].warned
= TRUE
;
5429 /* If any non-zero size allocated section (excluding tbss) starts at
5430 exactly the same VMA as another such section, then we have
5431 overlays. Overlays generated by the OVERLAY keyword will have
5432 this property. It is possible to intentionally generate overlays
5433 that fail this test, but it would be unusual. */
5434 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5436 p_start
= sections
[0].sec
->vma
;
5437 for (i
= 1; i
< count
; i
++)
5439 s_start
= sections
[i
].sec
->vma
;
5440 if (p_start
== s_start
)
5448 /* Now check section VMAs if no overlays were detected. */
5451 for (p
= NULL
, i
= 0; i
< count
; i
++)
5453 s
= sections
[i
].sec
;
5456 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5459 && !sections
[i
].warned
5460 && (s_start
<= p_end
5461 || p_end
< p_start
))
5462 einfo (_("%X%P: section %s VMA [%V,%V]"
5463 " overlaps section %s VMA [%V,%V]\n"),
5464 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5473 /* If any memory region has overflowed, report by how much.
5474 We do not issue this diagnostic for regions that had sections
5475 explicitly placed outside their bounds; os_region_check's
5476 diagnostics are adequate for that case.
5478 FIXME: It is conceivable that m->current - (m->origin + m->length)
5479 might overflow a 32-bit integer. There is, alas, no way to print
5480 a bfd_vma quantity in decimal. */
5481 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5482 if (m
->had_full_message
)
5484 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5485 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5486 "%X%P: region `%s' overflowed by %lu bytes\n",
5488 m
->name_list
.name
, over
);
5492 /* Make sure the new address is within the region. We explicitly permit the
5493 current address to be at the exact end of the region when the address is
5494 non-zero, in case the region is at the end of addressable memory and the
5495 calculation wraps around. */
5498 os_region_check (lang_output_section_statement_type
*os
,
5499 lang_memory_region_type
*region
,
5503 if ((region
->current
< region
->origin
5504 || (region
->current
- region
->origin
> region
->length
))
5505 && ((region
->current
!= region
->origin
+ region
->length
)
5510 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5511 " is not within region `%s'\n"),
5513 os
->bfd_section
->owner
,
5514 os
->bfd_section
->name
,
5515 region
->name_list
.name
);
5517 else if (!region
->had_full_message
)
5519 region
->had_full_message
= TRUE
;
5521 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5522 os
->bfd_section
->owner
,
5523 os
->bfd_section
->name
,
5524 region
->name_list
.name
);
5530 ldlang_check_relro_region (lang_statement_union_type
*s
,
5531 seg_align_type
*seg
)
5533 if (seg
->relro
== exp_seg_relro_start
)
5535 if (!seg
->relro_start_stat
)
5536 seg
->relro_start_stat
= s
;
5539 ASSERT (seg
->relro_start_stat
== s
);
5542 else if (seg
->relro
== exp_seg_relro_end
)
5544 if (!seg
->relro_end_stat
)
5545 seg
->relro_end_stat
= s
;
5548 ASSERT (seg
->relro_end_stat
== s
);
5553 /* Set the sizes for all the output sections. */
5556 lang_size_sections_1
5557 (lang_statement_union_type
**prev
,
5558 lang_output_section_statement_type
*output_section_statement
,
5562 bfd_boolean check_regions
)
5564 lang_statement_union_type
*s
;
5565 lang_statement_union_type
*prev_s
= NULL
;
5566 bfd_boolean removed_prev_s
= FALSE
;
5568 /* Size up the sections from their constituent parts. */
5569 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5571 bfd_boolean removed
=FALSE
;
5573 switch (s
->header
.type
)
5575 case lang_output_section_statement_enum
:
5577 bfd_vma newdot
, after
, dotdelta
;
5578 lang_output_section_statement_type
*os
;
5579 lang_memory_region_type
*r
;
5580 int section_alignment
= 0;
5582 os
= &s
->output_section_statement
;
5583 init_opb (os
->bfd_section
);
5584 if (os
->constraint
== -1)
5587 /* FIXME: We shouldn't need to zero section vmas for ld -r
5588 here, in lang_insert_orphan, or in the default linker scripts.
5589 This is covering for coff backend linker bugs. See PR6945. */
5590 if (os
->addr_tree
== NULL
5591 && bfd_link_relocatable (&link_info
)
5592 && (bfd_get_flavour (link_info
.output_bfd
)
5593 == bfd_target_coff_flavour
))
5594 os
->addr_tree
= exp_intop (0);
5595 if (os
->addr_tree
!= NULL
)
5597 os
->processed_vma
= FALSE
;
5598 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5600 if (expld
.result
.valid_p
)
5602 dot
= expld
.result
.value
;
5603 if (expld
.result
.section
!= NULL
)
5604 dot
+= expld
.result
.section
->vma
;
5606 else if (expld
.phase
!= lang_mark_phase_enum
)
5607 einfo (_("%F%P:%pS: non constant or forward reference"
5608 " address expression for section %s\n"),
5609 os
->addr_tree
, os
->name
);
5612 if (os
->bfd_section
== NULL
)
5613 /* This section was removed or never actually created. */
5616 /* If this is a COFF shared library section, use the size and
5617 address from the input section. FIXME: This is COFF
5618 specific; it would be cleaner if there were some other way
5619 to do this, but nothing simple comes to mind. */
5620 if (((bfd_get_flavour (link_info
.output_bfd
)
5621 == bfd_target_ecoff_flavour
)
5622 || (bfd_get_flavour (link_info
.output_bfd
)
5623 == bfd_target_coff_flavour
))
5624 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5628 if (os
->children
.head
== NULL
5629 || os
->children
.head
->header
.next
!= NULL
5630 || (os
->children
.head
->header
.type
5631 != lang_input_section_enum
))
5632 einfo (_("%X%P: internal error on COFF shared library"
5633 " section %s\n"), os
->name
);
5635 input
= os
->children
.head
->input_section
.section
;
5636 bfd_set_section_vma (os
->bfd_section
,
5637 bfd_section_vma (input
));
5638 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5639 os
->bfd_section
->size
= input
->size
;
5645 if (bfd_is_abs_section (os
->bfd_section
))
5647 /* No matter what happens, an abs section starts at zero. */
5648 ASSERT (os
->bfd_section
->vma
== 0);
5652 if (os
->addr_tree
== NULL
)
5654 /* No address specified for this section, get one
5655 from the region specification. */
5656 if (os
->region
== NULL
5657 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5658 && os
->region
->name_list
.name
[0] == '*'
5659 && strcmp (os
->region
->name_list
.name
,
5660 DEFAULT_MEMORY_REGION
) == 0))
5662 os
->region
= lang_memory_default (os
->bfd_section
);
5665 /* If a loadable section is using the default memory
5666 region, and some non default memory regions were
5667 defined, issue an error message. */
5669 && !IGNORE_SECTION (os
->bfd_section
)
5670 && !bfd_link_relocatable (&link_info
)
5672 && strcmp (os
->region
->name_list
.name
,
5673 DEFAULT_MEMORY_REGION
) == 0
5674 && lang_memory_region_list
!= NULL
5675 && (strcmp (lang_memory_region_list
->name_list
.name
,
5676 DEFAULT_MEMORY_REGION
) != 0
5677 || lang_memory_region_list
->next
!= NULL
)
5678 && lang_sizing_iteration
== 1)
5680 /* By default this is an error rather than just a
5681 warning because if we allocate the section to the
5682 default memory region we can end up creating an
5683 excessively large binary, or even seg faulting when
5684 attempting to perform a negative seek. See
5685 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5686 for an example of this. This behaviour can be
5687 overridden by the using the --no-check-sections
5689 if (command_line
.check_section_addresses
)
5690 einfo (_("%F%P: error: no memory region specified"
5691 " for loadable section `%s'\n"),
5692 bfd_section_name (os
->bfd_section
));
5694 einfo (_("%P: warning: no memory region specified"
5695 " for loadable section `%s'\n"),
5696 bfd_section_name (os
->bfd_section
));
5699 newdot
= os
->region
->current
;
5700 section_alignment
= os
->bfd_section
->alignment_power
;
5703 section_alignment
= exp_get_power (os
->section_alignment
,
5704 "section alignment");
5706 /* Align to what the section needs. */
5707 if (section_alignment
> 0)
5709 bfd_vma savedot
= newdot
;
5712 newdot
= align_power (newdot
, section_alignment
);
5713 dotdelta
= newdot
- savedot
;
5715 if (lang_sizing_iteration
== 1)
5717 else if (lang_sizing_iteration
> 1)
5719 /* Only report adjustments that would change
5720 alignment from what we have already reported. */
5721 diff
= newdot
- os
->bfd_section
->vma
;
5722 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5726 && (config
.warn_section_align
5727 || os
->addr_tree
!= NULL
))
5728 einfo (_("%P: warning: "
5729 "start of section %s changed by %ld\n"),
5730 os
->name
, (long) diff
);
5733 bfd_set_section_vma (os
->bfd_section
, newdot
);
5735 os
->bfd_section
->output_offset
= 0;
5738 lang_size_sections_1 (&os
->children
.head
, os
,
5739 os
->fill
, newdot
, relax
, check_regions
);
5741 os
->processed_vma
= TRUE
;
5743 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5744 /* Except for some special linker created sections,
5745 no output section should change from zero size
5746 after strip_excluded_output_sections. A non-zero
5747 size on an ignored section indicates that some
5748 input section was not sized early enough. */
5749 ASSERT (os
->bfd_section
->size
== 0);
5752 dot
= os
->bfd_section
->vma
;
5754 /* Put the section within the requested block size, or
5755 align at the block boundary. */
5757 + TO_ADDR (os
->bfd_section
->size
)
5758 + os
->block_value
- 1)
5759 & - (bfd_vma
) os
->block_value
);
5761 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5762 os
->bfd_section
->size
= TO_SIZE (after
5763 - os
->bfd_section
->vma
);
5766 /* Set section lma. */
5769 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5773 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5774 os
->bfd_section
->lma
= lma
;
5776 else if (os
->lma_region
!= NULL
)
5778 bfd_vma lma
= os
->lma_region
->current
;
5780 if (os
->align_lma_with_input
)
5784 /* When LMA_REGION is the same as REGION, align the LMA
5785 as we did for the VMA, possibly including alignment
5786 from the bfd section. If a different region, then
5787 only align according to the value in the output
5789 if (os
->lma_region
!= os
->region
)
5790 section_alignment
= exp_get_power (os
->section_alignment
,
5791 "section alignment");
5792 if (section_alignment
> 0)
5793 lma
= align_power (lma
, section_alignment
);
5795 os
->bfd_section
->lma
= lma
;
5797 else if (r
->last_os
!= NULL
5798 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5803 last
= r
->last_os
->output_section_statement
.bfd_section
;
5805 /* A backwards move of dot should be accompanied by
5806 an explicit assignment to the section LMA (ie.
5807 os->load_base set) because backwards moves can
5808 create overlapping LMAs. */
5810 && os
->bfd_section
->size
!= 0
5811 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5813 /* If dot moved backwards then leave lma equal to
5814 vma. This is the old default lma, which might
5815 just happen to work when the backwards move is
5816 sufficiently large. Nag if this changes anything,
5817 so people can fix their linker scripts. */
5819 if (last
->vma
!= last
->lma
)
5820 einfo (_("%P: warning: dot moved backwards "
5821 "before `%s'\n"), os
->name
);
5825 /* If this is an overlay, set the current lma to that
5826 at the end of the previous section. */
5827 if (os
->sectype
== overlay_section
)
5828 lma
= last
->lma
+ TO_ADDR (last
->size
);
5830 /* Otherwise, keep the same lma to vma relationship
5831 as the previous section. */
5833 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5835 if (section_alignment
> 0)
5836 lma
= align_power (lma
, section_alignment
);
5837 os
->bfd_section
->lma
= lma
;
5840 os
->processed_lma
= TRUE
;
5842 /* Keep track of normal sections using the default
5843 lma region. We use this to set the lma for
5844 following sections. Overlays or other linker
5845 script assignment to lma might mean that the
5846 default lma == vma is incorrect.
5847 To avoid warnings about dot moving backwards when using
5848 -Ttext, don't start tracking sections until we find one
5849 of non-zero size or with lma set differently to vma.
5850 Do this tracking before we short-cut the loop so that we
5851 track changes for the case where the section size is zero,
5852 but the lma is set differently to the vma. This is
5853 important, if an orphan section is placed after an
5854 otherwise empty output section that has an explicit lma
5855 set, we want that lma reflected in the orphans lma. */
5856 if (((!IGNORE_SECTION (os
->bfd_section
)
5857 && (os
->bfd_section
->size
!= 0
5858 || (r
->last_os
== NULL
5859 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5860 || (r
->last_os
!= NULL
5861 && dot
>= (r
->last_os
->output_section_statement
5862 .bfd_section
->vma
))))
5863 || os
->sectype
== first_overlay_section
)
5864 && os
->lma_region
== NULL
5865 && !bfd_link_relocatable (&link_info
))
5868 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5871 /* .tbss sections effectively have zero size. */
5872 if (!IS_TBSS (os
->bfd_section
)
5873 || bfd_link_relocatable (&link_info
))
5874 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5879 if (os
->update_dot_tree
!= 0)
5880 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5882 /* Update dot in the region ?
5883 We only do this if the section is going to be allocated,
5884 since unallocated sections do not contribute to the region's
5885 overall size in memory. */
5886 if (os
->region
!= NULL
5887 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5889 os
->region
->current
= dot
;
5892 /* Make sure the new address is within the region. */
5893 os_region_check (os
, os
->region
, os
->addr_tree
,
5894 os
->bfd_section
->vma
);
5896 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5897 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5898 || os
->align_lma_with_input
))
5900 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5903 os_region_check (os
, os
->lma_region
, NULL
,
5904 os
->bfd_section
->lma
);
5910 case lang_constructors_statement_enum
:
5911 dot
= lang_size_sections_1 (&constructor_list
.head
,
5912 output_section_statement
,
5913 fill
, dot
, relax
, check_regions
);
5916 case lang_data_statement_enum
:
5918 unsigned int size
= 0;
5920 s
->data_statement
.output_offset
=
5921 dot
- output_section_statement
->bfd_section
->vma
;
5922 s
->data_statement
.output_section
=
5923 output_section_statement
->bfd_section
;
5925 /* We might refer to provided symbols in the expression, and
5926 need to mark them as needed. */
5927 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5929 switch (s
->data_statement
.type
)
5947 if (size
< TO_SIZE ((unsigned) 1))
5948 size
= TO_SIZE ((unsigned) 1);
5949 dot
+= TO_ADDR (size
);
5950 if (!(output_section_statement
->bfd_section
->flags
5952 output_section_statement
->bfd_section
->size
5953 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5958 case lang_reloc_statement_enum
:
5962 s
->reloc_statement
.output_offset
=
5963 dot
- output_section_statement
->bfd_section
->vma
;
5964 s
->reloc_statement
.output_section
=
5965 output_section_statement
->bfd_section
;
5966 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5967 dot
+= TO_ADDR (size
);
5968 if (!(output_section_statement
->bfd_section
->flags
5970 output_section_statement
->bfd_section
->size
5971 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5975 case lang_wild_statement_enum
:
5976 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5977 output_section_statement
,
5978 fill
, dot
, relax
, check_regions
);
5981 case lang_object_symbols_statement_enum
:
5982 link_info
.create_object_symbols_section
5983 = output_section_statement
->bfd_section
;
5984 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5987 case lang_output_statement_enum
:
5988 case lang_target_statement_enum
:
5991 case lang_input_section_enum
:
5995 i
= s
->input_section
.section
;
6000 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6001 einfo (_("%F%P: can't relax section: %E\n"));
6005 dot
= size_input_section (prev
, output_section_statement
,
6006 fill
, &removed
, dot
);
6010 case lang_input_statement_enum
:
6013 case lang_fill_statement_enum
:
6014 s
->fill_statement
.output_section
=
6015 output_section_statement
->bfd_section
;
6017 fill
= s
->fill_statement
.fill
;
6020 case lang_assignment_statement_enum
:
6022 bfd_vma newdot
= dot
;
6023 etree_type
*tree
= s
->assignment_statement
.exp
;
6025 expld
.dataseg
.relro
= exp_seg_relro_none
;
6027 exp_fold_tree (tree
,
6028 output_section_statement
->bfd_section
,
6031 ldlang_check_relro_region (s
, &expld
.dataseg
);
6033 expld
.dataseg
.relro
= exp_seg_relro_none
;
6035 /* This symbol may be relative to this section. */
6036 if ((tree
->type
.node_class
== etree_provided
6037 || tree
->type
.node_class
== etree_assign
)
6038 && (tree
->assign
.dst
[0] != '.'
6039 || tree
->assign
.dst
[1] != '\0'))
6040 output_section_statement
->update_dot
= 1;
6042 if (!output_section_statement
->ignored
)
6044 if (output_section_statement
== abs_output_section
)
6046 /* If we don't have an output section, then just adjust
6047 the default memory address. */
6048 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6049 FALSE
)->current
= newdot
;
6051 else if (newdot
!= dot
)
6053 /* Insert a pad after this statement. We can't
6054 put the pad before when relaxing, in case the
6055 assignment references dot. */
6056 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6057 output_section_statement
->bfd_section
, dot
);
6059 /* Don't neuter the pad below when relaxing. */
6062 /* If dot is advanced, this implies that the section
6063 should have space allocated to it, unless the
6064 user has explicitly stated that the section
6065 should not be allocated. */
6066 if (output_section_statement
->sectype
!= noalloc_section
6067 && (output_section_statement
->sectype
!= noload_section
6068 || (bfd_get_flavour (link_info
.output_bfd
)
6069 == bfd_target_elf_flavour
)))
6070 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6077 case lang_padding_statement_enum
:
6078 /* If this is the first time lang_size_sections is called,
6079 we won't have any padding statements. If this is the
6080 second or later passes when relaxing, we should allow
6081 padding to shrink. If padding is needed on this pass, it
6082 will be added back in. */
6083 s
->padding_statement
.size
= 0;
6085 /* Make sure output_offset is valid. If relaxation shrinks
6086 the section and this pad isn't needed, it's possible to
6087 have output_offset larger than the final size of the
6088 section. bfd_set_section_contents will complain even for
6089 a pad size of zero. */
6090 s
->padding_statement
.output_offset
6091 = dot
- output_section_statement
->bfd_section
->vma
;
6094 case lang_group_statement_enum
:
6095 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6096 output_section_statement
,
6097 fill
, dot
, relax
, check_regions
);
6100 case lang_insert_statement_enum
:
6103 /* We can only get here when relaxing is turned on. */
6104 case lang_address_statement_enum
:
6112 /* If an input section doesn't fit in the current output
6113 section, remove it from the list. Handle the case where we
6114 have to remove an input_section statement here: there is a
6115 special case to remove the first element of the list. */
6116 if (link_info
.non_contiguous_regions
&& removed
)
6118 /* If we removed the first element during the previous
6119 iteration, override the loop assignment of prev_s. */
6125 /* If there was a real previous input section, just skip
6127 prev_s
->header
.next
=s
->header
.next
;
6129 removed_prev_s
= FALSE
;
6133 /* Remove the first input section of the list. */
6134 *prev
= s
->header
.next
;
6135 removed_prev_s
= TRUE
;
6138 /* Move to next element, unless we removed the head of the
6140 if (!removed_prev_s
)
6141 prev
= &s
->header
.next
;
6145 prev
= &s
->header
.next
;
6146 removed_prev_s
= FALSE
;
6152 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6153 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6154 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6155 segments. We are allowed an opportunity to override this decision. */
6158 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6159 bfd
*abfd ATTRIBUTE_UNUSED
,
6160 asection
*current_section
,
6161 asection
*previous_section
,
6162 bfd_boolean new_segment
)
6164 lang_output_section_statement_type
*cur
;
6165 lang_output_section_statement_type
*prev
;
6167 /* The checks below are only necessary when the BFD library has decided
6168 that the two sections ought to be placed into the same segment. */
6172 /* Paranoia checks. */
6173 if (current_section
== NULL
|| previous_section
== NULL
)
6176 /* If this flag is set, the target never wants code and non-code
6177 sections comingled in the same segment. */
6178 if (config
.separate_code
6179 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6182 /* Find the memory regions associated with the two sections.
6183 We call lang_output_section_find() here rather than scanning the list
6184 of output sections looking for a matching section pointer because if
6185 we have a large number of sections then a hash lookup is faster. */
6186 cur
= lang_output_section_find (current_section
->name
);
6187 prev
= lang_output_section_find (previous_section
->name
);
6189 /* More paranoia. */
6190 if (cur
== NULL
|| prev
== NULL
)
6193 /* If the regions are different then force the sections to live in
6194 different segments. See the email thread starting at the following
6195 URL for the reasons why this is necessary:
6196 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6197 return cur
->region
!= prev
->region
;
6201 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6203 lang_statement_iteration
++;
6204 if (expld
.phase
!= lang_mark_phase_enum
)
6205 lang_sizing_iteration
++;
6206 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6207 0, 0, relax
, check_regions
);
6211 lang_size_segment (seg_align_type
*seg
)
6213 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6214 a page could be saved in the data segment. */
6215 bfd_vma first
, last
;
6217 first
= -seg
->base
& (seg
->pagesize
- 1);
6218 last
= seg
->end
& (seg
->pagesize
- 1);
6220 && ((seg
->base
& ~(seg
->pagesize
- 1))
6221 != (seg
->end
& ~(seg
->pagesize
- 1)))
6222 && first
+ last
<= seg
->pagesize
)
6224 seg
->phase
= exp_seg_adjust
;
6228 seg
->phase
= exp_seg_done
;
6233 lang_size_relro_segment_1 (seg_align_type
*seg
)
6235 bfd_vma relro_end
, desired_end
;
6238 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6239 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6240 & ~(seg
->pagesize
- 1));
6242 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6243 desired_end
= relro_end
- seg
->relro_offset
;
6245 /* For sections in the relro segment.. */
6246 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6247 if ((sec
->flags
& SEC_ALLOC
) != 0
6248 && sec
->vma
>= seg
->base
6249 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6251 /* Where do we want to put this section so that it ends as
6253 bfd_vma start
, end
, bump
;
6255 end
= start
= sec
->vma
;
6257 end
+= TO_ADDR (sec
->size
);
6258 bump
= desired_end
- end
;
6259 /* We'd like to increase START by BUMP, but we must heed
6260 alignment so the increase might be less than optimum. */
6262 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6263 /* This is now the desired end for the previous section. */
6264 desired_end
= start
;
6267 seg
->phase
= exp_seg_relro_adjust
;
6268 ASSERT (desired_end
>= seg
->base
);
6269 seg
->base
= desired_end
;
6274 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6276 bfd_boolean do_reset
= FALSE
;
6277 bfd_boolean do_data_relro
;
6278 bfd_vma data_initial_base
, data_relro_end
;
6280 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6282 do_data_relro
= TRUE
;
6283 data_initial_base
= expld
.dataseg
.base
;
6284 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6288 do_data_relro
= FALSE
;
6289 data_initial_base
= data_relro_end
= 0;
6294 lang_reset_memory_regions ();
6295 one_lang_size_sections_pass (relax
, check_regions
);
6297 /* Assignments to dot, or to output section address in a user
6298 script have increased padding over the original. Revert. */
6299 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6301 expld
.dataseg
.base
= data_initial_base
;;
6306 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6313 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6315 expld
.phase
= lang_allocating_phase_enum
;
6316 expld
.dataseg
.phase
= exp_seg_none
;
6318 one_lang_size_sections_pass (relax
, check_regions
);
6320 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6321 expld
.dataseg
.phase
= exp_seg_done
;
6323 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6325 bfd_boolean do_reset
6326 = lang_size_relro_segment (relax
, check_regions
);
6330 lang_reset_memory_regions ();
6331 one_lang_size_sections_pass (relax
, check_regions
);
6334 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6336 link_info
.relro_start
= expld
.dataseg
.base
;
6337 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6342 static lang_output_section_statement_type
*current_section
;
6343 static lang_assignment_statement_type
*current_assign
;
6344 static bfd_boolean prefer_next_section
;
6346 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6349 lang_do_assignments_1 (lang_statement_union_type
*s
,
6350 lang_output_section_statement_type
*current_os
,
6353 bfd_boolean
*found_end
)
6355 for (; s
!= NULL
; s
= s
->header
.next
)
6357 switch (s
->header
.type
)
6359 case lang_constructors_statement_enum
:
6360 dot
= lang_do_assignments_1 (constructor_list
.head
,
6361 current_os
, fill
, dot
, found_end
);
6364 case lang_output_section_statement_enum
:
6366 lang_output_section_statement_type
*os
;
6369 os
= &(s
->output_section_statement
);
6370 os
->after_end
= *found_end
;
6371 init_opb (os
->bfd_section
);
6372 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6374 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6376 current_section
= os
;
6377 prefer_next_section
= FALSE
;
6379 dot
= os
->bfd_section
->vma
;
6381 newdot
= lang_do_assignments_1 (os
->children
.head
,
6382 os
, os
->fill
, dot
, found_end
);
6385 if (os
->bfd_section
!= NULL
)
6387 /* .tbss sections effectively have zero size. */
6388 if (!IS_TBSS (os
->bfd_section
)
6389 || bfd_link_relocatable (&link_info
))
6390 dot
+= TO_ADDR (os
->bfd_section
->size
);
6392 if (os
->update_dot_tree
!= NULL
)
6393 exp_fold_tree (os
->update_dot_tree
,
6394 bfd_abs_section_ptr
, &dot
);
6402 case lang_wild_statement_enum
:
6404 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6405 current_os
, fill
, dot
, found_end
);
6408 case lang_object_symbols_statement_enum
:
6409 case lang_output_statement_enum
:
6410 case lang_target_statement_enum
:
6413 case lang_data_statement_enum
:
6414 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6415 if (expld
.result
.valid_p
)
6417 s
->data_statement
.value
= expld
.result
.value
;
6418 if (expld
.result
.section
!= NULL
)
6419 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6421 else if (expld
.phase
== lang_final_phase_enum
)
6422 einfo (_("%F%P: invalid data statement\n"));
6425 switch (s
->data_statement
.type
)
6443 if (size
< TO_SIZE ((unsigned) 1))
6444 size
= TO_SIZE ((unsigned) 1);
6445 dot
+= TO_ADDR (size
);
6449 case lang_reloc_statement_enum
:
6450 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6451 bfd_abs_section_ptr
, &dot
);
6452 if (expld
.result
.valid_p
)
6453 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6454 else if (expld
.phase
== lang_final_phase_enum
)
6455 einfo (_("%F%P: invalid reloc statement\n"));
6456 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6459 case lang_input_section_enum
:
6461 asection
*in
= s
->input_section
.section
;
6463 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6464 dot
+= TO_ADDR (in
->size
);
6468 case lang_input_statement_enum
:
6471 case lang_fill_statement_enum
:
6472 fill
= s
->fill_statement
.fill
;
6475 case lang_assignment_statement_enum
:
6476 current_assign
= &s
->assignment_statement
;
6477 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6479 const char *p
= current_assign
->exp
->assign
.dst
;
6481 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6482 prefer_next_section
= TRUE
;
6486 if (strcmp (p
, "end") == 0)
6489 exp_fold_tree (s
->assignment_statement
.exp
,
6490 (current_os
->bfd_section
!= NULL
6491 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6495 case lang_padding_statement_enum
:
6496 dot
+= TO_ADDR (s
->padding_statement
.size
);
6499 case lang_group_statement_enum
:
6500 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6501 current_os
, fill
, dot
, found_end
);
6504 case lang_insert_statement_enum
:
6507 case lang_address_statement_enum
:
6519 lang_do_assignments (lang_phase_type phase
)
6521 bfd_boolean found_end
= FALSE
;
6523 current_section
= NULL
;
6524 prefer_next_section
= FALSE
;
6525 expld
.phase
= phase
;
6526 lang_statement_iteration
++;
6527 lang_do_assignments_1 (statement_list
.head
,
6528 abs_output_section
, NULL
, 0, &found_end
);
6531 /* For an assignment statement outside of an output section statement,
6532 choose the best of neighbouring output sections to use for values
6536 section_for_dot (void)
6540 /* Assignments belong to the previous output section, unless there
6541 has been an assignment to "dot", in which case following
6542 assignments belong to the next output section. (The assumption
6543 is that an assignment to "dot" is setting up the address for the
6544 next output section.) Except that past the assignment to "_end"
6545 we always associate with the previous section. This exception is
6546 for targets like SH that define an alloc .stack or other
6547 weirdness after non-alloc sections. */
6548 if (current_section
== NULL
|| prefer_next_section
)
6550 lang_statement_union_type
*stmt
;
6551 lang_output_section_statement_type
*os
;
6553 for (stmt
= (lang_statement_union_type
*) current_assign
;
6555 stmt
= stmt
->header
.next
)
6556 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6559 os
= &stmt
->output_section_statement
;
6562 && (os
->bfd_section
== NULL
6563 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6564 || bfd_section_removed_from_list (link_info
.output_bfd
,
6568 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6571 s
= os
->bfd_section
;
6573 s
= link_info
.output_bfd
->section_last
;
6575 && ((s
->flags
& SEC_ALLOC
) == 0
6576 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6581 return bfd_abs_section_ptr
;
6585 s
= current_section
->bfd_section
;
6587 /* The section may have been stripped. */
6589 && ((s
->flags
& SEC_EXCLUDE
) != 0
6590 || (s
->flags
& SEC_ALLOC
) == 0
6591 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6592 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6595 s
= link_info
.output_bfd
->sections
;
6597 && ((s
->flags
& SEC_ALLOC
) == 0
6598 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6603 return bfd_abs_section_ptr
;
6606 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6608 static struct bfd_link_hash_entry
**start_stop_syms
;
6609 static size_t start_stop_count
= 0;
6610 static size_t start_stop_alloc
= 0;
6612 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6613 to start_stop_syms. */
6616 lang_define_start_stop (const char *symbol
, asection
*sec
)
6618 struct bfd_link_hash_entry
*h
;
6620 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6623 if (start_stop_count
== start_stop_alloc
)
6625 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6627 = xrealloc (start_stop_syms
,
6628 start_stop_alloc
* sizeof (*start_stop_syms
));
6630 start_stop_syms
[start_stop_count
++] = h
;
6634 /* Check for input sections whose names match references to
6635 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6636 preliminary definitions. */
6639 lang_init_start_stop (void)
6643 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6645 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6646 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6649 const char *secname
= s
->name
;
6651 for (ps
= secname
; *ps
!= '\0'; ps
++)
6652 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6656 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6658 symbol
[0] = leading_char
;
6659 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6660 lang_define_start_stop (symbol
, s
);
6662 symbol
[1] = leading_char
;
6663 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6664 lang_define_start_stop (symbol
+ 1, s
);
6671 /* Iterate over start_stop_syms. */
6674 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6678 for (i
= 0; i
< start_stop_count
; ++i
)
6679 func (start_stop_syms
[i
]);
6682 /* __start and __stop symbols are only supposed to be defined by the
6683 linker for orphan sections, but we now extend that to sections that
6684 map to an output section of the same name. The symbols were
6685 defined early for --gc-sections, before we mapped input to output
6686 sections, so undo those that don't satisfy this rule. */
6689 undef_start_stop (struct bfd_link_hash_entry
*h
)
6691 if (h
->ldscript_def
)
6694 if (h
->u
.def
.section
->output_section
== NULL
6695 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6696 || strcmp (h
->u
.def
.section
->name
,
6697 h
->u
.def
.section
->output_section
->name
) != 0)
6699 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6700 h
->u
.def
.section
->name
);
6703 /* When there are more than one input sections with the same
6704 section name, SECNAME, linker picks the first one to define
6705 __start_SECNAME and __stop_SECNAME symbols. When the first
6706 input section is removed by comdat group, we need to check
6707 if there is still an output section with section name
6710 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6711 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6713 h
->u
.def
.section
= i
;
6717 h
->type
= bfd_link_hash_undefined
;
6718 h
->u
.undef
.abfd
= NULL
;
6723 lang_undef_start_stop (void)
6725 foreach_start_stop (undef_start_stop
);
6728 /* Check for output sections whose names match references to
6729 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6730 preliminary definitions. */
6733 lang_init_startof_sizeof (void)
6737 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6739 const char *secname
= s
->name
;
6740 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6742 sprintf (symbol
, ".startof.%s", secname
);
6743 lang_define_start_stop (symbol
, s
);
6745 memcpy (symbol
+ 1, ".size", 5);
6746 lang_define_start_stop (symbol
+ 1, s
);
6751 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6754 set_start_stop (struct bfd_link_hash_entry
*h
)
6757 || h
->type
!= bfd_link_hash_defined
)
6760 if (h
->root
.string
[0] == '.')
6762 /* .startof. or .sizeof. symbol.
6763 .startof. already has final value. */
6764 if (h
->root
.string
[2] == 'i')
6767 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6768 h
->u
.def
.section
= bfd_abs_section_ptr
;
6773 /* __start or __stop symbol. */
6774 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6776 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6777 if (h
->root
.string
[4 + has_lead
] == 'o')
6780 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6786 lang_finalize_start_stop (void)
6788 foreach_start_stop (set_start_stop
);
6794 struct bfd_link_hash_entry
*h
;
6797 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6798 || bfd_link_dll (&link_info
))
6799 warn
= entry_from_cmdline
;
6803 /* Force the user to specify a root when generating a relocatable with
6804 --gc-sections, unless --gc-keep-exported was also given. */
6805 if (bfd_link_relocatable (&link_info
)
6806 && link_info
.gc_sections
6807 && !link_info
.gc_keep_exported
6808 && !(entry_from_cmdline
|| undef_from_cmdline
))
6809 einfo (_("%F%P: gc-sections requires either an entry or "
6810 "an undefined symbol\n"));
6812 if (entry_symbol
.name
== NULL
)
6814 /* No entry has been specified. Look for the default entry, but
6815 don't warn if we don't find it. */
6816 entry_symbol
.name
= entry_symbol_default
;
6820 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6821 FALSE
, FALSE
, TRUE
);
6823 && (h
->type
== bfd_link_hash_defined
6824 || h
->type
== bfd_link_hash_defweak
)
6825 && h
->u
.def
.section
->output_section
!= NULL
)
6829 val
= (h
->u
.def
.value
6830 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6831 + h
->u
.def
.section
->output_offset
);
6832 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6833 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6840 /* We couldn't find the entry symbol. Try parsing it as a
6842 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6845 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6846 einfo (_("%F%P: can't set start address\n"));
6852 /* Can't find the entry symbol, and it's not a number. Use
6853 the first address in the text section. */
6854 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6858 einfo (_("%P: warning: cannot find entry symbol %s;"
6859 " defaulting to %V\n"),
6861 bfd_section_vma (ts
));
6862 if (!bfd_set_start_address (link_info
.output_bfd
,
6863 bfd_section_vma (ts
)))
6864 einfo (_("%F%P: can't set start address\n"));
6869 einfo (_("%P: warning: cannot find entry symbol %s;"
6870 " not setting start address\n"),
6877 /* This is a small function used when we want to ignore errors from
6881 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6882 va_list ap ATTRIBUTE_UNUSED
)
6884 /* Don't do anything. */
6887 /* Check that the architecture of all the input files is compatible
6888 with the output file. Also call the backend to let it do any
6889 other checking that is needed. */
6894 lang_input_statement_type
*file
;
6896 const bfd_arch_info_type
*compatible
;
6898 for (file
= (void *) file_chain
.head
;
6902 #if BFD_SUPPORTS_PLUGINS
6903 /* Don't check format of files claimed by plugin. */
6904 if (file
->flags
.claimed
)
6906 #endif /* BFD_SUPPORTS_PLUGINS */
6907 input_bfd
= file
->the_bfd
;
6909 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6910 command_line
.accept_unknown_input_arch
);
6912 /* In general it is not possible to perform a relocatable
6913 link between differing object formats when the input
6914 file has relocations, because the relocations in the
6915 input format may not have equivalent representations in
6916 the output format (and besides BFD does not translate
6917 relocs for other link purposes than a final link). */
6918 if ((bfd_link_relocatable (&link_info
)
6919 || link_info
.emitrelocations
)
6920 && (compatible
== NULL
6921 || (bfd_get_flavour (input_bfd
)
6922 != bfd_get_flavour (link_info
.output_bfd
)))
6923 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6925 einfo (_("%F%P: relocatable linking with relocations from"
6926 " format %s (%pB) to format %s (%pB) is not supported\n"),
6927 bfd_get_target (input_bfd
), input_bfd
,
6928 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6929 /* einfo with %F exits. */
6932 if (compatible
== NULL
)
6934 if (command_line
.warn_mismatch
)
6935 einfo (_("%X%P: %s architecture of input file `%pB'"
6936 " is incompatible with %s output\n"),
6937 bfd_printable_name (input_bfd
), input_bfd
,
6938 bfd_printable_name (link_info
.output_bfd
));
6941 /* If the input bfd has no contents, it shouldn't set the
6942 private data of the output bfd. */
6943 else if ((input_bfd
->flags
& DYNAMIC
) != 0
6944 || bfd_count_sections (input_bfd
) != 0)
6946 bfd_error_handler_type pfn
= NULL
;
6948 /* If we aren't supposed to warn about mismatched input
6949 files, temporarily set the BFD error handler to a
6950 function which will do nothing. We still want to call
6951 bfd_merge_private_bfd_data, since it may set up
6952 information which is needed in the output file. */
6953 if (!command_line
.warn_mismatch
)
6954 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6955 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6957 if (command_line
.warn_mismatch
)
6958 einfo (_("%X%P: failed to merge target specific data"
6959 " of file %pB\n"), input_bfd
);
6961 if (!command_line
.warn_mismatch
)
6962 bfd_set_error_handler (pfn
);
6967 /* Look through all the global common symbols and attach them to the
6968 correct section. The -sort-common command line switch may be used
6969 to roughly sort the entries by alignment. */
6974 if (link_info
.inhibit_common_definition
)
6976 if (bfd_link_relocatable (&link_info
)
6977 && !command_line
.force_common_definition
)
6980 if (!config
.sort_common
)
6981 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6986 if (config
.sort_common
== sort_descending
)
6988 for (power
= 4; power
> 0; power
--)
6989 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6992 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6996 for (power
= 0; power
<= 4; power
++)
6997 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6999 power
= (unsigned int) -1;
7000 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7005 /* Place one common symbol in the correct section. */
7008 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7010 unsigned int power_of_two
;
7014 if (h
->type
!= bfd_link_hash_common
)
7018 power_of_two
= h
->u
.c
.p
->alignment_power
;
7020 if (config
.sort_common
== sort_descending
7021 && power_of_two
< *(unsigned int *) info
)
7023 else if (config
.sort_common
== sort_ascending
7024 && power_of_two
> *(unsigned int *) info
)
7027 section
= h
->u
.c
.p
->section
;
7028 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7029 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7032 if (config
.map_file
!= NULL
)
7034 static bfd_boolean header_printed
;
7039 if (!header_printed
)
7041 minfo (_("\nAllocating common symbols\n"));
7042 minfo (_("Common symbol size file\n\n"));
7043 header_printed
= TRUE
;
7046 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7047 DMGL_ANSI
| DMGL_PARAMS
);
7050 minfo ("%s", h
->root
.string
);
7051 len
= strlen (h
->root
.string
);
7056 len
= strlen (name
);
7072 if (size
<= 0xffffffff)
7073 sprintf (buf
, "%lx", (unsigned long) size
);
7075 sprintf_vma (buf
, size
);
7085 minfo ("%pB\n", section
->owner
);
7091 /* Handle a single orphan section S, placing the orphan into an appropriate
7092 output section. The effects of the --orphan-handling command line
7093 option are handled here. */
7096 ldlang_place_orphan (asection
*s
)
7098 if (config
.orphan_handling
== orphan_handling_discard
)
7100 lang_output_section_statement_type
*os
;
7101 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
7103 if (os
->addr_tree
== NULL
7104 && (bfd_link_relocatable (&link_info
)
7105 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7106 os
->addr_tree
= exp_intop (0);
7107 lang_add_section (&os
->children
, s
, NULL
, os
);
7111 lang_output_section_statement_type
*os
;
7112 const char *name
= s
->name
;
7115 if (config
.orphan_handling
== orphan_handling_error
)
7116 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7119 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7120 constraint
= SPECIAL
;
7122 os
= ldemul_place_orphan (s
, name
, constraint
);
7125 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
7126 if (os
->addr_tree
== NULL
7127 && (bfd_link_relocatable (&link_info
)
7128 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7129 os
->addr_tree
= exp_intop (0);
7130 lang_add_section (&os
->children
, s
, NULL
, os
);
7133 if (config
.orphan_handling
== orphan_handling_warn
)
7134 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7135 "placed in section `%s'\n"),
7136 s
, s
->owner
, os
->name
);
7140 /* Run through the input files and ensure that every input section has
7141 somewhere to go. If one is found without a destination then create
7142 an input request and place it into the statement tree. */
7145 lang_place_orphans (void)
7147 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7151 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7153 if (s
->output_section
== NULL
)
7155 /* This section of the file is not attached, root
7156 around for a sensible place for it to go. */
7158 if (file
->flags
.just_syms
)
7159 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7160 else if (lang_discard_section_p (s
))
7161 s
->output_section
= bfd_abs_section_ptr
;
7162 else if (strcmp (s
->name
, "COMMON") == 0)
7164 /* This is a lonely common section which must have
7165 come from an archive. We attach to the section
7166 with the wildcard. */
7167 if (!bfd_link_relocatable (&link_info
)
7168 || command_line
.force_common_definition
)
7170 if (default_common_section
== NULL
)
7171 default_common_section
7172 = lang_output_section_statement_lookup (".bss", 0,
7174 lang_add_section (&default_common_section
->children
, s
,
7175 NULL
, default_common_section
);
7179 ldlang_place_orphan (s
);
7186 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7188 flagword
*ptr_flags
;
7190 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7196 /* PR 17900: An exclamation mark in the attributes reverses
7197 the sense of any of the attributes that follow. */
7200 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7204 *ptr_flags
|= SEC_ALLOC
;
7208 *ptr_flags
|= SEC_READONLY
;
7212 *ptr_flags
|= SEC_DATA
;
7216 *ptr_flags
|= SEC_CODE
;
7221 *ptr_flags
|= SEC_LOAD
;
7225 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7233 /* Call a function on each real input file. This function will be
7234 called on an archive, but not on the elements. */
7237 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7239 lang_input_statement_type
*f
;
7241 for (f
= (void *) input_file_chain
.head
;
7243 f
= f
->next_real_file
)
7248 /* Call a function on each real file. The function will be called on
7249 all the elements of an archive which are included in the link, but
7250 will not be called on the archive file itself. */
7253 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7255 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7263 ldlang_add_file (lang_input_statement_type
*entry
)
7265 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7267 /* The BFD linker needs to have a list of all input BFDs involved in
7269 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
7270 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7272 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7273 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7274 bfd_set_usrdata (entry
->the_bfd
, entry
);
7275 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7277 /* Look through the sections and check for any which should not be
7278 included in the link. We need to do this now, so that we can
7279 notice when the backend linker tries to report multiple
7280 definition errors for symbols which are in sections we aren't
7281 going to link. FIXME: It might be better to entirely ignore
7282 symbols which are defined in sections which are going to be
7283 discarded. This would require modifying the backend linker for
7284 each backend which might set the SEC_LINK_ONCE flag. If we do
7285 this, we should probably handle SEC_EXCLUDE in the same way. */
7287 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7291 lang_add_output (const char *name
, int from_script
)
7293 /* Make -o on command line override OUTPUT in script. */
7294 if (!had_output_filename
|| !from_script
)
7296 output_filename
= name
;
7297 had_output_filename
= TRUE
;
7301 lang_output_section_statement_type
*
7302 lang_enter_output_section_statement (const char *output_section_statement_name
,
7303 etree_type
*address_exp
,
7304 enum section_type sectype
,
7306 etree_type
*subalign
,
7309 int align_with_input
)
7311 lang_output_section_statement_type
*os
;
7313 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7315 current_section
= os
;
7317 if (os
->addr_tree
== NULL
)
7319 os
->addr_tree
= address_exp
;
7321 os
->sectype
= sectype
;
7322 if (sectype
!= noload_section
)
7323 os
->flags
= SEC_NO_FLAGS
;
7325 os
->flags
= SEC_NEVER_LOAD
;
7326 os
->block_value
= 1;
7328 /* Make next things chain into subchain of this. */
7329 push_stat_ptr (&os
->children
);
7331 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7332 if (os
->align_lma_with_input
&& align
!= NULL
)
7333 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7336 os
->subsection_alignment
= subalign
;
7337 os
->section_alignment
= align
;
7339 os
->load_base
= ebase
;
7346 lang_output_statement_type
*new_stmt
;
7348 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7349 new_stmt
->name
= output_filename
;
7352 /* Reset the current counters in the regions. */
7355 lang_reset_memory_regions (void)
7357 lang_memory_region_type
*p
= lang_memory_region_list
;
7359 lang_output_section_statement_type
*os
;
7361 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7363 p
->current
= p
->origin
;
7367 for (os
= (void *) lang_os_list
.head
;
7371 os
->processed_vma
= FALSE
;
7372 os
->processed_lma
= FALSE
;
7375 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7377 /* Save the last size for possible use by bfd_relax_section. */
7378 o
->rawsize
= o
->size
;
7379 if (!(o
->flags
& SEC_FIXED_SIZE
))
7384 /* Worker for lang_gc_sections_1. */
7387 gc_section_callback (lang_wild_statement_type
*ptr
,
7388 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7390 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7391 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7392 void *data ATTRIBUTE_UNUSED
)
7394 /* If the wild pattern was marked KEEP, the member sections
7395 should be as well. */
7396 if (ptr
->keep_sections
)
7397 section
->flags
|= SEC_KEEP
;
7400 /* Iterate over sections marking them against GC. */
7403 lang_gc_sections_1 (lang_statement_union_type
*s
)
7405 for (; s
!= NULL
; s
= s
->header
.next
)
7407 switch (s
->header
.type
)
7409 case lang_wild_statement_enum
:
7410 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7412 case lang_constructors_statement_enum
:
7413 lang_gc_sections_1 (constructor_list
.head
);
7415 case lang_output_section_statement_enum
:
7416 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7418 case lang_group_statement_enum
:
7419 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7428 lang_gc_sections (void)
7430 /* Keep all sections so marked in the link script. */
7431 lang_gc_sections_1 (statement_list
.head
);
7433 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7434 the special case of debug info. (See bfd/stabs.c)
7435 Twiddle the flag here, to simplify later linker code. */
7436 if (bfd_link_relocatable (&link_info
))
7438 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7441 #if BFD_SUPPORTS_PLUGINS
7442 if (f
->flags
.claimed
)
7445 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7446 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7447 sec
->flags
&= ~SEC_EXCLUDE
;
7451 if (link_info
.gc_sections
)
7452 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7455 /* Worker for lang_find_relro_sections_1. */
7458 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7459 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7461 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7462 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7465 /* Discarded, excluded and ignored sections effectively have zero
7467 if (section
->output_section
!= NULL
7468 && section
->output_section
->owner
== link_info
.output_bfd
7469 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7470 && !IGNORE_SECTION (section
)
7471 && section
->size
!= 0)
7473 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7474 *has_relro_section
= TRUE
;
7478 /* Iterate over sections for relro sections. */
7481 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7482 seg_align_type
*seg
,
7483 bfd_boolean
*has_relro_section
)
7485 if (*has_relro_section
)
7488 for (; s
!= NULL
; s
= s
->header
.next
)
7490 if (s
== seg
->relro_end_stat
)
7493 switch (s
->header
.type
)
7495 case lang_wild_statement_enum
:
7496 walk_wild (&s
->wild_statement
,
7497 find_relro_section_callback
,
7500 case lang_constructors_statement_enum
:
7501 lang_find_relro_sections_1 (constructor_list
.head
,
7502 seg
, has_relro_section
);
7504 case lang_output_section_statement_enum
:
7505 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7506 seg
, has_relro_section
);
7508 case lang_group_statement_enum
:
7509 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7510 seg
, has_relro_section
);
7519 lang_find_relro_sections (void)
7521 bfd_boolean has_relro_section
= FALSE
;
7523 /* Check all sections in the link script. */
7525 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7526 &expld
.dataseg
, &has_relro_section
);
7528 if (!has_relro_section
)
7529 link_info
.relro
= FALSE
;
7532 /* Relax all sections until bfd_relax_section gives up. */
7535 lang_relax_sections (bfd_boolean need_layout
)
7537 if (RELAXATION_ENABLED
)
7539 /* We may need more than one relaxation pass. */
7540 int i
= link_info
.relax_pass
;
7542 /* The backend can use it to determine the current pass. */
7543 link_info
.relax_pass
= 0;
7547 /* Keep relaxing until bfd_relax_section gives up. */
7548 bfd_boolean relax_again
;
7550 link_info
.relax_trip
= -1;
7553 link_info
.relax_trip
++;
7555 /* Note: pe-dll.c does something like this also. If you find
7556 you need to change this code, you probably need to change
7557 pe-dll.c also. DJ */
7559 /* Do all the assignments with our current guesses as to
7561 lang_do_assignments (lang_assigning_phase_enum
);
7563 /* We must do this after lang_do_assignments, because it uses
7565 lang_reset_memory_regions ();
7567 /* Perform another relax pass - this time we know where the
7568 globals are, so can make a better guess. */
7569 relax_again
= FALSE
;
7570 lang_size_sections (&relax_again
, FALSE
);
7572 while (relax_again
);
7574 link_info
.relax_pass
++;
7581 /* Final extra sizing to report errors. */
7582 lang_do_assignments (lang_assigning_phase_enum
);
7583 lang_reset_memory_regions ();
7584 lang_size_sections (NULL
, TRUE
);
7588 #if BFD_SUPPORTS_PLUGINS
7589 /* Find the insert point for the plugin's replacement files. We
7590 place them after the first claimed real object file, or if the
7591 first claimed object is an archive member, after the last real
7592 object file immediately preceding the archive. In the event
7593 no objects have been claimed at all, we return the first dummy
7594 object file on the list as the insert point; that works, but
7595 the callee must be careful when relinking the file_chain as it
7596 is not actually on that chain, only the statement_list and the
7597 input_file list; in that case, the replacement files must be
7598 inserted at the head of the file_chain. */
7600 static lang_input_statement_type
*
7601 find_replacements_insert_point (bfd_boolean
*before
)
7603 lang_input_statement_type
*claim1
, *lastobject
;
7604 lastobject
= (void *) input_file_chain
.head
;
7605 for (claim1
= (void *) file_chain
.head
;
7607 claim1
= claim1
->next
)
7609 if (claim1
->flags
.claimed
)
7611 *before
= claim1
->flags
.claim_archive
;
7612 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7614 /* Update lastobject if this is a real object file. */
7615 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7616 lastobject
= claim1
;
7618 /* No files were claimed by the plugin. Choose the last object
7619 file found on the list (maybe the first, dummy entry) as the
7625 /* Find where to insert ADD, an archive element or shared library
7626 added during a rescan. */
7628 static lang_input_statement_type
**
7629 find_rescan_insertion (lang_input_statement_type
*add
)
7631 bfd
*add_bfd
= add
->the_bfd
;
7632 lang_input_statement_type
*f
;
7633 lang_input_statement_type
*last_loaded
= NULL
;
7634 lang_input_statement_type
*before
= NULL
;
7635 lang_input_statement_type
**iter
= NULL
;
7637 if (add_bfd
->my_archive
!= NULL
)
7638 add_bfd
= add_bfd
->my_archive
;
7640 /* First look through the input file chain, to find an object file
7641 before the one we've rescanned. Normal object files always
7642 appear on both the input file chain and the file chain, so this
7643 lets us get quickly to somewhere near the correct place on the
7644 file chain if it is full of archive elements. Archives don't
7645 appear on the file chain, but if an element has been extracted
7646 then their input_statement->next points at it. */
7647 for (f
= (void *) input_file_chain
.head
;
7649 f
= f
->next_real_file
)
7651 if (f
->the_bfd
== add_bfd
)
7653 before
= last_loaded
;
7654 if (f
->next
!= NULL
)
7655 return &f
->next
->next
;
7657 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7661 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7663 iter
= &(*iter
)->next
)
7664 if (!(*iter
)->flags
.claim_archive
7665 && (*iter
)->the_bfd
->my_archive
== NULL
)
7671 /* Insert SRCLIST into DESTLIST after given element by chaining
7672 on FIELD as the next-pointer. (Counterintuitively does not need
7673 a pointer to the actual after-node itself, just its chain field.) */
7676 lang_list_insert_after (lang_statement_list_type
*destlist
,
7677 lang_statement_list_type
*srclist
,
7678 lang_statement_union_type
**field
)
7680 *(srclist
->tail
) = *field
;
7681 *field
= srclist
->head
;
7682 if (destlist
->tail
== field
)
7683 destlist
->tail
= srclist
->tail
;
7686 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7687 was taken as a copy of it and leave them in ORIGLIST. */
7690 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7691 lang_statement_list_type
*origlist
)
7693 union lang_statement_union
**savetail
;
7694 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7695 ASSERT (origlist
->head
== destlist
->head
);
7696 savetail
= origlist
->tail
;
7697 origlist
->head
= *(savetail
);
7698 origlist
->tail
= destlist
->tail
;
7699 destlist
->tail
= savetail
;
7703 static lang_statement_union_type
**
7704 find_next_input_statement (lang_statement_union_type
**s
)
7706 for ( ; *s
; s
= &(*s
)->header
.next
)
7708 lang_statement_union_type
**t
;
7709 switch ((*s
)->header
.type
)
7711 case lang_input_statement_enum
:
7713 case lang_wild_statement_enum
:
7714 t
= &(*s
)->wild_statement
.children
.head
;
7716 case lang_group_statement_enum
:
7717 t
= &(*s
)->group_statement
.children
.head
;
7719 case lang_output_section_statement_enum
:
7720 t
= &(*s
)->output_section_statement
.children
.head
;
7725 t
= find_next_input_statement (t
);
7731 #endif /* BFD_SUPPORTS_PLUGINS */
7733 /* Add NAME to the list of garbage collection entry points. */
7736 lang_add_gc_name (const char *name
)
7738 struct bfd_sym_chain
*sym
;
7743 sym
= stat_alloc (sizeof (*sym
));
7745 sym
->next
= link_info
.gc_sym_list
;
7747 link_info
.gc_sym_list
= sym
;
7750 /* Check relocations. */
7753 lang_check_relocs (void)
7755 if (link_info
.check_relocs_after_open_input
)
7759 for (abfd
= link_info
.input_bfds
;
7760 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7761 if (!bfd_link_check_relocs (abfd
, &link_info
))
7763 /* No object output, fail return. */
7764 config
.make_executable
= FALSE
;
7765 /* Note: we do not abort the loop, but rather
7766 continue the scan in case there are other
7767 bad relocations to report. */
7772 /* Look through all output sections looking for places where we can
7773 propagate forward the lma region. */
7776 lang_propagate_lma_regions (void)
7778 lang_output_section_statement_type
*os
;
7780 for (os
= (void *) lang_os_list
.head
;
7784 if (os
->prev
!= NULL
7785 && os
->lma_region
== NULL
7786 && os
->load_base
== NULL
7787 && os
->addr_tree
== NULL
7788 && os
->region
== os
->prev
->region
)
7789 os
->lma_region
= os
->prev
->lma_region
;
7796 /* Finalize dynamic list. */
7797 if (link_info
.dynamic_list
)
7798 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7800 current_target
= default_target
;
7802 /* Open the output file. */
7803 lang_for_each_statement (ldlang_open_output
);
7806 ldemul_create_output_section_statements ();
7808 /* Add to the hash table all undefineds on the command line. */
7809 lang_place_undefineds ();
7811 if (!bfd_section_already_linked_table_init ())
7812 einfo (_("%F%P: can not create hash table: %E\n"));
7814 /* Create a bfd for each input file. */
7815 current_target
= default_target
;
7816 lang_statement_iteration
++;
7817 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7818 /* open_input_bfds also handles assignments, so we can give values
7819 to symbolic origin/length now. */
7820 lang_do_memory_regions ();
7822 #if BFD_SUPPORTS_PLUGINS
7823 if (link_info
.lto_plugin_active
)
7825 lang_statement_list_type added
;
7826 lang_statement_list_type files
, inputfiles
;
7828 /* Now all files are read, let the plugin(s) decide if there
7829 are any more to be added to the link before we call the
7830 emulation's after_open hook. We create a private list of
7831 input statements for this purpose, which we will eventually
7832 insert into the global statement list after the first claimed
7835 /* We need to manipulate all three chains in synchrony. */
7837 inputfiles
= input_file_chain
;
7838 if (plugin_call_all_symbols_read ())
7839 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7840 plugin_error_plugin ());
7841 /* Open any newly added files, updating the file chains. */
7842 plugin_undefs
= link_info
.hash
->undefs_tail
;
7843 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7844 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7845 plugin_undefs
= NULL
;
7846 /* Restore the global list pointer now they have all been added. */
7847 lang_list_remove_tail (stat_ptr
, &added
);
7848 /* And detach the fresh ends of the file lists. */
7849 lang_list_remove_tail (&file_chain
, &files
);
7850 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7851 /* Were any new files added? */
7852 if (added
.head
!= NULL
)
7854 /* If so, we will insert them into the statement list immediately
7855 after the first input file that was claimed by the plugin,
7856 unless that file was an archive in which case it is inserted
7857 immediately before. */
7859 lang_statement_union_type
**prev
;
7860 plugin_insert
= find_replacements_insert_point (&before
);
7861 /* If a plugin adds input files without having claimed any, we
7862 don't really have a good idea where to place them. Just putting
7863 them at the start or end of the list is liable to leave them
7864 outside the crtbegin...crtend range. */
7865 ASSERT (plugin_insert
!= NULL
);
7866 /* Splice the new statement list into the old one. */
7867 prev
= &plugin_insert
->header
.next
;
7870 prev
= find_next_input_statement (prev
);
7871 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7873 /* We didn't find the expected input statement.
7874 Fall back to adding after plugin_insert. */
7875 prev
= &plugin_insert
->header
.next
;
7878 lang_list_insert_after (stat_ptr
, &added
, prev
);
7879 /* Likewise for the file chains. */
7880 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7881 (void *) &plugin_insert
->next_real_file
);
7882 /* We must be careful when relinking file_chain; we may need to
7883 insert the new files at the head of the list if the insert
7884 point chosen is the dummy first input file. */
7885 if (plugin_insert
->filename
)
7886 lang_list_insert_after (&file_chain
, &files
,
7887 (void *) &plugin_insert
->next
);
7889 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7891 /* Rescan archives in case new undefined symbols have appeared. */
7893 lang_statement_iteration
++;
7894 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7895 lang_list_remove_tail (&file_chain
, &files
);
7896 while (files
.head
!= NULL
)
7898 lang_input_statement_type
**insert
;
7899 lang_input_statement_type
**iter
, *temp
;
7902 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7903 /* All elements from an archive can be added at once. */
7904 iter
= &files
.head
->input_statement
.next
;
7905 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7906 if (my_arch
!= NULL
)
7907 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7908 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7911 *insert
= &files
.head
->input_statement
;
7912 files
.head
= (lang_statement_union_type
*) *iter
;
7914 if (my_arch
!= NULL
)
7916 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7918 parent
->next
= (lang_input_statement_type
*)
7920 - offsetof (lang_input_statement_type
, next
));
7925 #endif /* BFD_SUPPORTS_PLUGINS */
7927 /* Make sure that nobody has tried to add a symbol to this list
7929 ASSERT (link_info
.gc_sym_list
== NULL
);
7931 link_info
.gc_sym_list
= &entry_symbol
;
7933 if (entry_symbol
.name
== NULL
)
7935 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7937 /* entry_symbol is normally initialied by a ENTRY definition in the
7938 linker script or the -e command line option. But if neither of
7939 these have been used, the target specific backend may still have
7940 provided an entry symbol via a call to lang_default_entry().
7941 Unfortunately this value will not be processed until lang_end()
7942 is called, long after this function has finished. So detect this
7943 case here and add the target's entry symbol to the list of starting
7944 points for garbage collection resolution. */
7945 lang_add_gc_name (entry_symbol_default
);
7948 lang_add_gc_name (link_info
.init_function
);
7949 lang_add_gc_name (link_info
.fini_function
);
7951 ldemul_after_open ();
7952 if (config
.map_file
!= NULL
)
7953 lang_print_asneeded ();
7957 bfd_section_already_linked_table_free ();
7959 /* Make sure that we're not mixing architectures. We call this
7960 after all the input files have been opened, but before we do any
7961 other processing, so that any operations merge_private_bfd_data
7962 does on the output file will be known during the rest of the
7966 /* Handle .exports instead of a version script if we're told to do so. */
7967 if (command_line
.version_exports_section
)
7968 lang_do_version_exports_section ();
7970 /* Build all sets based on the information gathered from the input
7972 ldctor_build_sets ();
7974 /* Give initial values for __start and __stop symbols, so that ELF
7975 gc_sections will keep sections referenced by these symbols. Must
7976 be done before lang_do_assignments below. */
7977 if (config
.build_constructors
)
7978 lang_init_start_stop ();
7980 /* PR 13683: We must rerun the assignments prior to running garbage
7981 collection in order to make sure that all symbol aliases are resolved. */
7982 lang_do_assignments (lang_mark_phase_enum
);
7983 expld
.phase
= lang_first_phase_enum
;
7985 /* Size up the common data. */
7988 /* Remove unreferenced sections if asked to. */
7989 lang_gc_sections ();
7991 /* Check relocations. */
7992 lang_check_relocs ();
7994 ldemul_after_check_relocs ();
7996 /* Update wild statements. */
7997 update_wild_statements (statement_list
.head
);
7999 /* Run through the contours of the script and attach input sections
8000 to the correct output sections. */
8001 lang_statement_iteration
++;
8002 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8004 /* Start at the statement immediately after the special abs_section
8005 output statement, so that it isn't reordered. */
8006 process_insert_statements (&lang_os_list
.head
->header
.next
);
8008 ldemul_before_place_orphans ();
8010 /* Find any sections not attached explicitly and handle them. */
8011 lang_place_orphans ();
8013 if (!bfd_link_relocatable (&link_info
))
8017 /* Merge SEC_MERGE sections. This has to be done after GC of
8018 sections, so that GCed sections are not merged, but before
8019 assigning dynamic symbols, since removing whole input sections
8021 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8023 /* Look for a text section and set the readonly attribute in it. */
8024 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8028 if (config
.text_read_only
)
8029 found
->flags
|= SEC_READONLY
;
8031 found
->flags
&= ~SEC_READONLY
;
8035 /* Merge together CTF sections. After this, only the symtab-dependent
8036 function and data object sections need adjustment. */
8039 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8040 examining things laid out late, like the strtab. */
8043 /* Copy forward lma regions for output sections in same lma region. */
8044 lang_propagate_lma_regions ();
8046 /* Defining __start/__stop symbols early for --gc-sections to work
8047 around a glibc build problem can result in these symbols being
8048 defined when they should not be. Fix them now. */
8049 if (config
.build_constructors
)
8050 lang_undef_start_stop ();
8052 /* Define .startof./.sizeof. symbols with preliminary values before
8053 dynamic symbols are created. */
8054 if (!bfd_link_relocatable (&link_info
))
8055 lang_init_startof_sizeof ();
8057 /* Do anything special before sizing sections. This is where ELF
8058 and other back-ends size dynamic sections. */
8059 ldemul_before_allocation ();
8061 /* We must record the program headers before we try to fix the
8062 section positions, since they will affect SIZEOF_HEADERS. */
8063 lang_record_phdrs ();
8065 /* Check relro sections. */
8066 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8067 lang_find_relro_sections ();
8069 /* Size up the sections. */
8070 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8072 /* See if anything special should be done now we know how big
8073 everything is. This is where relaxation is done. */
8074 ldemul_after_allocation ();
8076 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8077 lang_finalize_start_stop ();
8079 /* Do all the assignments again, to report errors. Assignment
8080 statements are processed multiple times, updating symbols; In
8081 open_input_bfds, lang_do_assignments, and lang_size_sections.
8082 Since lang_relax_sections calls lang_do_assignments, symbols are
8083 also updated in ldemul_after_allocation. */
8084 lang_do_assignments (lang_final_phase_enum
);
8088 /* Convert absolute symbols to section relative. */
8089 ldexp_finalize_syms ();
8091 /* Make sure that the section addresses make sense. */
8092 if (command_line
.check_section_addresses
)
8093 lang_check_section_addresses ();
8095 /* Check any required symbols are known. */
8096 ldlang_check_require_defined_symbols ();
8101 /* EXPORTED TO YACC */
8104 lang_add_wild (struct wildcard_spec
*filespec
,
8105 struct wildcard_list
*section_list
,
8106 bfd_boolean keep_sections
)
8108 struct wildcard_list
*curr
, *next
;
8109 lang_wild_statement_type
*new_stmt
;
8111 /* Reverse the list as the parser puts it back to front. */
8112 for (curr
= section_list
, section_list
= NULL
;
8114 section_list
= curr
, curr
= next
)
8117 curr
->next
= section_list
;
8120 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8122 if (strcmp (filespec
->name
, "*") == 0)
8123 filespec
->name
= NULL
;
8124 else if (!wildcardp (filespec
->name
))
8125 lang_has_input_file
= TRUE
;
8128 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8129 new_stmt
->filename
= NULL
;
8130 new_stmt
->filenames_sorted
= FALSE
;
8131 new_stmt
->section_flag_list
= NULL
;
8132 new_stmt
->exclude_name_list
= NULL
;
8133 if (filespec
!= NULL
)
8135 new_stmt
->filename
= filespec
->name
;
8136 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8137 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8138 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8140 new_stmt
->section_list
= section_list
;
8141 new_stmt
->keep_sections
= keep_sections
;
8142 lang_list_init (&new_stmt
->children
);
8143 analyze_walk_wild_section_handler (new_stmt
);
8147 lang_section_start (const char *name
, etree_type
*address
,
8148 const segment_type
*segment
)
8150 lang_address_statement_type
*ad
;
8152 ad
= new_stat (lang_address_statement
, stat_ptr
);
8153 ad
->section_name
= name
;
8154 ad
->address
= address
;
8155 ad
->segment
= segment
;
8158 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8159 because of a -e argument on the command line, or zero if this is
8160 called by ENTRY in a linker script. Command line arguments take
8164 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8166 if (entry_symbol
.name
== NULL
8168 || !entry_from_cmdline
)
8170 entry_symbol
.name
= name
;
8171 entry_from_cmdline
= cmdline
;
8175 /* Set the default start symbol to NAME. .em files should use this,
8176 not lang_add_entry, to override the use of "start" if neither the
8177 linker script nor the command line specifies an entry point. NAME
8178 must be permanently allocated. */
8180 lang_default_entry (const char *name
)
8182 entry_symbol_default
= name
;
8186 lang_add_target (const char *name
)
8188 lang_target_statement_type
*new_stmt
;
8190 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8191 new_stmt
->target
= name
;
8195 lang_add_map (const char *name
)
8202 map_option_f
= TRUE
;
8210 lang_add_fill (fill_type
*fill
)
8212 lang_fill_statement_type
*new_stmt
;
8214 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8215 new_stmt
->fill
= fill
;
8219 lang_add_data (int type
, union etree_union
*exp
)
8221 lang_data_statement_type
*new_stmt
;
8223 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8224 new_stmt
->exp
= exp
;
8225 new_stmt
->type
= type
;
8228 /* Create a new reloc statement. RELOC is the BFD relocation type to
8229 generate. HOWTO is the corresponding howto structure (we could
8230 look this up, but the caller has already done so). SECTION is the
8231 section to generate a reloc against, or NAME is the name of the
8232 symbol to generate a reloc against. Exactly one of SECTION and
8233 NAME must be NULL. ADDEND is an expression for the addend. */
8236 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8237 reloc_howto_type
*howto
,
8240 union etree_union
*addend
)
8242 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8246 p
->section
= section
;
8248 p
->addend_exp
= addend
;
8250 p
->addend_value
= 0;
8251 p
->output_section
= NULL
;
8252 p
->output_offset
= 0;
8255 lang_assignment_statement_type
*
8256 lang_add_assignment (etree_type
*exp
)
8258 lang_assignment_statement_type
*new_stmt
;
8260 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8261 new_stmt
->exp
= exp
;
8266 lang_add_attribute (enum statement_enum attribute
)
8268 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8272 lang_startup (const char *name
)
8274 if (first_file
->filename
!= NULL
)
8276 einfo (_("%F%P: multiple STARTUP files\n"));
8278 first_file
->filename
= name
;
8279 first_file
->local_sym_name
= name
;
8280 first_file
->flags
.real
= TRUE
;
8284 lang_float (bfd_boolean maybe
)
8286 lang_float_flag
= maybe
;
8290 /* Work out the load- and run-time regions from a script statement, and
8291 store them in *LMA_REGION and *REGION respectively.
8293 MEMSPEC is the name of the run-time region, or the value of
8294 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8295 LMA_MEMSPEC is the name of the load-time region, or null if the
8296 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8297 had an explicit load address.
8299 It is an error to specify both a load region and a load address. */
8302 lang_get_regions (lang_memory_region_type
**region
,
8303 lang_memory_region_type
**lma_region
,
8304 const char *memspec
,
8305 const char *lma_memspec
,
8306 bfd_boolean have_lma
,
8307 bfd_boolean have_vma
)
8309 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8311 /* If no runtime region or VMA has been specified, but the load region
8312 has been specified, then use the load region for the runtime region
8314 if (lma_memspec
!= NULL
8316 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8317 *region
= *lma_region
;
8319 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8321 if (have_lma
&& lma_memspec
!= 0)
8322 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8327 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8328 lang_output_section_phdr_list
*phdrs
,
8329 const char *lma_memspec
)
8331 lang_get_regions (¤t_section
->region
,
8332 ¤t_section
->lma_region
,
8333 memspec
, lma_memspec
,
8334 current_section
->load_base
!= NULL
,
8335 current_section
->addr_tree
!= NULL
);
8337 current_section
->fill
= fill
;
8338 current_section
->phdrs
= phdrs
;
8342 /* Set the output format type. -oformat overrides scripts. */
8345 lang_add_output_format (const char *format
,
8350 if (output_target
== NULL
|| !from_script
)
8352 if (command_line
.endian
== ENDIAN_BIG
8355 else if (command_line
.endian
== ENDIAN_LITTLE
8359 output_target
= format
;
8364 lang_add_insert (const char *where
, int is_before
)
8366 lang_insert_statement_type
*new_stmt
;
8368 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8369 new_stmt
->where
= where
;
8370 new_stmt
->is_before
= is_before
;
8371 saved_script_handle
= previous_script_handle
;
8374 /* Enter a group. This creates a new lang_group_statement, and sets
8375 stat_ptr to build new statements within the group. */
8378 lang_enter_group (void)
8380 lang_group_statement_type
*g
;
8382 g
= new_stat (lang_group_statement
, stat_ptr
);
8383 lang_list_init (&g
->children
);
8384 push_stat_ptr (&g
->children
);
8387 /* Leave a group. This just resets stat_ptr to start writing to the
8388 regular list of statements again. Note that this will not work if
8389 groups can occur inside anything else which can adjust stat_ptr,
8390 but currently they can't. */
8393 lang_leave_group (void)
8398 /* Add a new program header. This is called for each entry in a PHDRS
8399 command in a linker script. */
8402 lang_new_phdr (const char *name
,
8404 bfd_boolean filehdr
,
8409 struct lang_phdr
*n
, **pp
;
8412 n
= stat_alloc (sizeof (struct lang_phdr
));
8415 n
->type
= exp_get_vma (type
, 0, "program header type");
8416 n
->filehdr
= filehdr
;
8421 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8423 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8426 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8428 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8429 " when prior PT_LOAD headers lack them\n"), NULL
);
8436 /* Record the program header information in the output BFD. FIXME: We
8437 should not be calling an ELF specific function here. */
8440 lang_record_phdrs (void)
8444 lang_output_section_phdr_list
*last
;
8445 struct lang_phdr
*l
;
8446 lang_output_section_statement_type
*os
;
8449 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8452 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8459 for (os
= (void *) lang_os_list
.head
;
8463 lang_output_section_phdr_list
*pl
;
8465 if (os
->constraint
< 0)
8473 if (os
->sectype
== noload_section
8474 || os
->bfd_section
== NULL
8475 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8478 /* Don't add orphans to PT_INTERP header. */
8484 lang_output_section_statement_type
*tmp_os
;
8486 /* If we have not run across a section with a program
8487 header assigned to it yet, then scan forwards to find
8488 one. This prevents inconsistencies in the linker's
8489 behaviour when a script has specified just a single
8490 header and there are sections in that script which are
8491 not assigned to it, and which occur before the first
8492 use of that header. See here for more details:
8493 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8494 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8497 last
= tmp_os
->phdrs
;
8501 einfo (_("%F%P: no sections assigned to phdrs\n"));
8506 if (os
->bfd_section
== NULL
)
8509 for (; pl
!= NULL
; pl
= pl
->next
)
8511 if (strcmp (pl
->name
, l
->name
) == 0)
8516 secs
= (asection
**) xrealloc (secs
,
8517 alc
* sizeof (asection
*));
8519 secs
[c
] = os
->bfd_section
;
8526 if (l
->flags
== NULL
)
8529 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8534 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8536 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8537 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8538 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8539 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8544 /* Make sure all the phdr assignments succeeded. */
8545 for (os
= (void *) lang_os_list
.head
;
8549 lang_output_section_phdr_list
*pl
;
8551 if (os
->constraint
< 0
8552 || os
->bfd_section
== NULL
)
8555 for (pl
= os
->phdrs
;
8558 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8559 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8560 os
->name
, pl
->name
);
8564 /* Record a list of sections which may not be cross referenced. */
8567 lang_add_nocrossref (lang_nocrossref_type
*l
)
8569 struct lang_nocrossrefs
*n
;
8571 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8572 n
->next
= nocrossref_list
;
8574 n
->onlyfirst
= FALSE
;
8575 nocrossref_list
= n
;
8577 /* Set notice_all so that we get informed about all symbols. */
8578 link_info
.notice_all
= TRUE
;
8581 /* Record a section that cannot be referenced from a list of sections. */
8584 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8586 lang_add_nocrossref (l
);
8587 nocrossref_list
->onlyfirst
= TRUE
;
8590 /* Overlay handling. We handle overlays with some static variables. */
8592 /* The overlay virtual address. */
8593 static etree_type
*overlay_vma
;
8594 /* And subsection alignment. */
8595 static etree_type
*overlay_subalign
;
8597 /* An expression for the maximum section size seen so far. */
8598 static etree_type
*overlay_max
;
8600 /* A list of all the sections in this overlay. */
8602 struct overlay_list
{
8603 struct overlay_list
*next
;
8604 lang_output_section_statement_type
*os
;
8607 static struct overlay_list
*overlay_list
;
8609 /* Start handling an overlay. */
8612 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8614 /* The grammar should prevent nested overlays from occurring. */
8615 ASSERT (overlay_vma
== NULL
8616 && overlay_subalign
== NULL
8617 && overlay_max
== NULL
);
8619 overlay_vma
= vma_expr
;
8620 overlay_subalign
= subalign
;
8623 /* Start a section in an overlay. We handle this by calling
8624 lang_enter_output_section_statement with the correct VMA.
8625 lang_leave_overlay sets up the LMA and memory regions. */
8628 lang_enter_overlay_section (const char *name
)
8630 struct overlay_list
*n
;
8633 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8634 0, overlay_subalign
, 0, 0, 0);
8636 /* If this is the first section, then base the VMA of future
8637 sections on this one. This will work correctly even if `.' is
8638 used in the addresses. */
8639 if (overlay_list
== NULL
)
8640 overlay_vma
= exp_nameop (ADDR
, name
);
8642 /* Remember the section. */
8643 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8644 n
->os
= current_section
;
8645 n
->next
= overlay_list
;
8648 size
= exp_nameop (SIZEOF
, name
);
8650 /* Arrange to work out the maximum section end address. */
8651 if (overlay_max
== NULL
)
8654 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8657 /* Finish a section in an overlay. There isn't any special to do
8661 lang_leave_overlay_section (fill_type
*fill
,
8662 lang_output_section_phdr_list
*phdrs
)
8669 name
= current_section
->name
;
8671 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8672 region and that no load-time region has been specified. It doesn't
8673 really matter what we say here, since lang_leave_overlay will
8675 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8677 /* Define the magic symbols. */
8679 clean
= (char *) xmalloc (strlen (name
) + 1);
8681 for (s1
= name
; *s1
!= '\0'; s1
++)
8682 if (ISALNUM (*s1
) || *s1
== '_')
8686 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8687 sprintf (buf
, "__load_start_%s", clean
);
8688 lang_add_assignment (exp_provide (buf
,
8689 exp_nameop (LOADADDR
, name
),
8692 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8693 sprintf (buf
, "__load_stop_%s", clean
);
8694 lang_add_assignment (exp_provide (buf
,
8696 exp_nameop (LOADADDR
, name
),
8697 exp_nameop (SIZEOF
, name
)),
8703 /* Finish an overlay. If there are any overlay wide settings, this
8704 looks through all the sections in the overlay and sets them. */
8707 lang_leave_overlay (etree_type
*lma_expr
,
8710 const char *memspec
,
8711 lang_output_section_phdr_list
*phdrs
,
8712 const char *lma_memspec
)
8714 lang_memory_region_type
*region
;
8715 lang_memory_region_type
*lma_region
;
8716 struct overlay_list
*l
;
8717 lang_nocrossref_type
*nocrossref
;
8719 lang_get_regions (®ion
, &lma_region
,
8720 memspec
, lma_memspec
,
8721 lma_expr
!= NULL
, FALSE
);
8725 /* After setting the size of the last section, set '.' to end of the
8727 if (overlay_list
!= NULL
)
8729 overlay_list
->os
->update_dot
= 1;
8730 overlay_list
->os
->update_dot_tree
8731 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8737 struct overlay_list
*next
;
8739 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8742 l
->os
->region
= region
;
8743 l
->os
->lma_region
= lma_region
;
8745 /* The first section has the load address specified in the
8746 OVERLAY statement. The rest are worked out from that.
8747 The base address is not needed (and should be null) if
8748 an LMA region was specified. */
8751 l
->os
->load_base
= lma_expr
;
8752 l
->os
->sectype
= first_overlay_section
;
8754 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8755 l
->os
->phdrs
= phdrs
;
8759 lang_nocrossref_type
*nc
;
8761 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8762 nc
->name
= l
->os
->name
;
8763 nc
->next
= nocrossref
;
8772 if (nocrossref
!= NULL
)
8773 lang_add_nocrossref (nocrossref
);
8776 overlay_list
= NULL
;
8778 overlay_subalign
= NULL
;
8781 /* Version handling. This is only useful for ELF. */
8783 /* If PREV is NULL, return first version pattern matching particular symbol.
8784 If PREV is non-NULL, return first version pattern matching particular
8785 symbol after PREV (previously returned by lang_vers_match). */
8787 static struct bfd_elf_version_expr
*
8788 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8789 struct bfd_elf_version_expr
*prev
,
8793 const char *cxx_sym
= sym
;
8794 const char *java_sym
= sym
;
8795 struct bfd_elf_version_expr
*expr
= NULL
;
8796 enum demangling_styles curr_style
;
8798 curr_style
= CURRENT_DEMANGLING_STYLE
;
8799 cplus_demangle_set_style (no_demangling
);
8800 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8803 cplus_demangle_set_style (curr_style
);
8805 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8807 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8808 DMGL_PARAMS
| DMGL_ANSI
);
8812 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8814 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8819 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8821 struct bfd_elf_version_expr e
;
8823 switch (prev
? prev
->mask
: 0)
8826 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8829 expr
= (struct bfd_elf_version_expr
*)
8830 htab_find ((htab_t
) head
->htab
, &e
);
8831 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8832 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8838 case BFD_ELF_VERSION_C_TYPE
:
8839 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8841 e
.pattern
= cxx_sym
;
8842 expr
= (struct bfd_elf_version_expr
*)
8843 htab_find ((htab_t
) head
->htab
, &e
);
8844 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8845 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8851 case BFD_ELF_VERSION_CXX_TYPE
:
8852 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8854 e
.pattern
= java_sym
;
8855 expr
= (struct bfd_elf_version_expr
*)
8856 htab_find ((htab_t
) head
->htab
, &e
);
8857 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8858 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8869 /* Finally, try the wildcards. */
8870 if (prev
== NULL
|| prev
->literal
)
8871 expr
= head
->remaining
;
8874 for (; expr
; expr
= expr
->next
)
8881 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8884 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8886 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8890 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8896 free ((char *) c_sym
);
8898 free ((char *) cxx_sym
);
8899 if (java_sym
!= sym
)
8900 free ((char *) java_sym
);
8904 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8905 return a pointer to the symbol name with any backslash quotes removed. */
8908 realsymbol (const char *pattern
)
8911 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8912 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8914 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8916 /* It is a glob pattern only if there is no preceding
8920 /* Remove the preceding backslash. */
8927 if (*p
== '?' || *p
== '*' || *p
== '[')
8934 backslash
= *p
== '\\';
8950 /* This is called for each variable name or match expression. NEW_NAME is
8951 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8952 pattern to be matched against symbol names. */
8954 struct bfd_elf_version_expr
*
8955 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8956 const char *new_name
,
8958 bfd_boolean literal_p
)
8960 struct bfd_elf_version_expr
*ret
;
8962 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8966 ret
->literal
= TRUE
;
8967 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8968 if (ret
->pattern
== NULL
)
8970 ret
->pattern
= new_name
;
8971 ret
->literal
= FALSE
;
8974 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8975 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8976 else if (strcasecmp (lang
, "C++") == 0)
8977 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8978 else if (strcasecmp (lang
, "Java") == 0)
8979 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8982 einfo (_("%X%P: unknown language `%s' in version information\n"),
8984 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8987 return ldemul_new_vers_pattern (ret
);
8990 /* This is called for each set of variable names and match
8993 struct bfd_elf_version_tree
*
8994 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8995 struct bfd_elf_version_expr
*locals
)
8997 struct bfd_elf_version_tree
*ret
;
8999 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9000 ret
->globals
.list
= globals
;
9001 ret
->locals
.list
= locals
;
9002 ret
->match
= lang_vers_match
;
9003 ret
->name_indx
= (unsigned int) -1;
9007 /* This static variable keeps track of version indices. */
9009 static int version_index
;
9012 version_expr_head_hash (const void *p
)
9014 const struct bfd_elf_version_expr
*e
=
9015 (const struct bfd_elf_version_expr
*) p
;
9017 return htab_hash_string (e
->pattern
);
9021 version_expr_head_eq (const void *p1
, const void *p2
)
9023 const struct bfd_elf_version_expr
*e1
=
9024 (const struct bfd_elf_version_expr
*) p1
;
9025 const struct bfd_elf_version_expr
*e2
=
9026 (const struct bfd_elf_version_expr
*) p2
;
9028 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9032 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9035 struct bfd_elf_version_expr
*e
, *next
;
9036 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9038 for (e
= head
->list
; e
; e
= e
->next
)
9042 head
->mask
|= e
->mask
;
9047 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9048 version_expr_head_eq
, NULL
);
9049 list_loc
= &head
->list
;
9050 remaining_loc
= &head
->remaining
;
9051 for (e
= head
->list
; e
; e
= next
)
9057 remaining_loc
= &e
->next
;
9061 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9065 struct bfd_elf_version_expr
*e1
, *last
;
9067 e1
= (struct bfd_elf_version_expr
*) *loc
;
9071 if (e1
->mask
== e
->mask
)
9079 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9083 /* This is a duplicate. */
9084 /* FIXME: Memory leak. Sometimes pattern is not
9085 xmalloced alone, but in larger chunk of memory. */
9086 /* free (e->pattern); */
9091 e
->next
= last
->next
;
9099 list_loc
= &e
->next
;
9103 *remaining_loc
= NULL
;
9104 *list_loc
= head
->remaining
;
9107 head
->remaining
= head
->list
;
9110 /* This is called when we know the name and dependencies of the
9114 lang_register_vers_node (const char *name
,
9115 struct bfd_elf_version_tree
*version
,
9116 struct bfd_elf_version_deps
*deps
)
9118 struct bfd_elf_version_tree
*t
, **pp
;
9119 struct bfd_elf_version_expr
*e1
;
9124 if (link_info
.version_info
!= NULL
9125 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9127 einfo (_("%X%P: anonymous version tag cannot be combined"
9128 " with other version tags\n"));
9133 /* Make sure this node has a unique name. */
9134 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9135 if (strcmp (t
->name
, name
) == 0)
9136 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9138 lang_finalize_version_expr_head (&version
->globals
);
9139 lang_finalize_version_expr_head (&version
->locals
);
9141 /* Check the global and local match names, and make sure there
9142 aren't any duplicates. */
9144 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9146 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9148 struct bfd_elf_version_expr
*e2
;
9150 if (t
->locals
.htab
&& e1
->literal
)
9152 e2
= (struct bfd_elf_version_expr
*)
9153 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9154 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9156 if (e1
->mask
== e2
->mask
)
9157 einfo (_("%X%P: duplicate expression `%s'"
9158 " in version information\n"), e1
->pattern
);
9162 else if (!e1
->literal
)
9163 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9164 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9165 && e1
->mask
== e2
->mask
)
9166 einfo (_("%X%P: duplicate expression `%s'"
9167 " in version information\n"), e1
->pattern
);
9171 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9173 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9175 struct bfd_elf_version_expr
*e2
;
9177 if (t
->globals
.htab
&& e1
->literal
)
9179 e2
= (struct bfd_elf_version_expr
*)
9180 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9181 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9183 if (e1
->mask
== e2
->mask
)
9184 einfo (_("%X%P: duplicate expression `%s'"
9185 " in version information\n"),
9190 else if (!e1
->literal
)
9191 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9192 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9193 && e1
->mask
== e2
->mask
)
9194 einfo (_("%X%P: duplicate expression `%s'"
9195 " in version information\n"), e1
->pattern
);
9199 version
->deps
= deps
;
9200 version
->name
= name
;
9201 if (name
[0] != '\0')
9204 version
->vernum
= version_index
;
9207 version
->vernum
= 0;
9209 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9214 /* This is called when we see a version dependency. */
9216 struct bfd_elf_version_deps
*
9217 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9219 struct bfd_elf_version_deps
*ret
;
9220 struct bfd_elf_version_tree
*t
;
9222 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9225 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9227 if (strcmp (t
->name
, name
) == 0)
9229 ret
->version_needed
= t
;
9234 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9236 ret
->version_needed
= NULL
;
9241 lang_do_version_exports_section (void)
9243 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9245 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9247 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9255 contents
= (char *) xmalloc (len
);
9256 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9257 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9260 while (p
< contents
+ len
)
9262 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9263 p
= strchr (p
, '\0') + 1;
9266 /* Do not free the contents, as we used them creating the regex. */
9268 /* Do not include this section in the link. */
9269 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9272 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9273 lang_register_vers_node (command_line
.version_exports_section
,
9274 lang_new_vers_node (greg
, lreg
), NULL
);
9277 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9280 lang_do_memory_regions (void)
9282 lang_memory_region_type
*r
= lang_memory_region_list
;
9284 for (; r
!= NULL
; r
= r
->next
)
9288 exp_fold_tree_no_dot (r
->origin_exp
);
9289 if (expld
.result
.valid_p
)
9291 r
->origin
= expld
.result
.value
;
9292 r
->current
= r
->origin
;
9295 einfo (_("%F%P: invalid origin for memory region %s\n"),
9300 exp_fold_tree_no_dot (r
->length_exp
);
9301 if (expld
.result
.valid_p
)
9302 r
->length
= expld
.result
.value
;
9304 einfo (_("%F%P: invalid length for memory region %s\n"),
9311 lang_add_unique (const char *name
)
9313 struct unique_sections
*ent
;
9315 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9316 if (strcmp (ent
->name
, name
) == 0)
9319 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9320 ent
->name
= xstrdup (name
);
9321 ent
->next
= unique_section_list
;
9322 unique_section_list
= ent
;
9325 /* Append the list of dynamic symbols to the existing one. */
9328 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9329 struct bfd_elf_version_expr
*dynamic
)
9333 struct bfd_elf_version_expr
*tail
;
9334 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9336 tail
->next
= (*list_p
)->head
.list
;
9337 (*list_p
)->head
.list
= dynamic
;
9341 struct bfd_elf_dynamic_list
*d
;
9343 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9344 d
->head
.list
= dynamic
;
9345 d
->match
= lang_vers_match
;
9350 /* Append the list of C++ typeinfo dynamic symbols to the existing
9354 lang_append_dynamic_list_cpp_typeinfo (void)
9356 const char *symbols
[] =
9358 "typeinfo name for*",
9361 struct bfd_elf_version_expr
*dynamic
= NULL
;
9364 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9365 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9368 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9371 /* Append the list of C++ operator new and delete dynamic symbols to the
9375 lang_append_dynamic_list_cpp_new (void)
9377 const char *symbols
[] =
9382 struct bfd_elf_version_expr
*dynamic
= NULL
;
9385 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9386 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9389 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9392 /* Scan a space and/or comma separated string of features. */
9395 lang_ld_feature (char *str
)
9403 while (*p
== ',' || ISSPACE (*p
))
9408 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9412 if (strcasecmp (p
, "SANE_EXPR") == 0)
9413 config
.sane_expr
= TRUE
;
9415 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9421 /* Pretty print memory amount. */
9424 lang_print_memory_size (bfd_vma sz
)
9426 if ((sz
& 0x3fffffff) == 0)
9427 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9428 else if ((sz
& 0xfffff) == 0)
9429 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9430 else if ((sz
& 0x3ff) == 0)
9431 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9433 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9436 /* Implement --print-memory-usage: disply per region memory usage. */
9439 lang_print_memory_usage (void)
9441 lang_memory_region_type
*r
;
9443 printf ("Memory region Used Size Region Size %%age Used\n");
9444 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9446 bfd_vma used_length
= r
->current
- r
->origin
;
9448 printf ("%16s: ",r
->name_list
.name
);
9449 lang_print_memory_size (used_length
);
9450 lang_print_memory_size ((bfd_vma
) r
->length
);
9454 double percent
= used_length
* 100.0 / r
->length
;
9455 printf (" %6.2f%%", percent
);