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
;
135 static ctf_file_t
*ctf_output
;
138 /* Functions that traverse the linker script and might evaluate
139 DEFINED() need to increment this at the start of the traversal. */
140 int lang_statement_iteration
= 0;
142 /* Count times through one_lang_size_sections_pass after mark phase. */
143 static int lang_sizing_iteration
= 0;
145 /* Return TRUE if the PATTERN argument is a wildcard pattern.
146 Although backslashes are treated specially if a pattern contains
147 wildcards, we do not consider the mere presence of a backslash to
148 be enough to cause the pattern to be treated as a wildcard.
149 That lets us handle DOS filenames more naturally. */
150 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
152 #define new_stat(x, y) \
153 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
155 #define outside_section_address(q) \
156 ((q)->output_offset + (q)->output_section->vma)
158 #define outside_symbol_address(q) \
159 ((q)->value + outside_section_address (q->section))
161 /* CTF sections smaller than this are not compressed: compression of
162 dictionaries this small doesn't gain much, and this lets consumers mmap the
163 sections directly out of the ELF file and use them with no decompression
164 overhead if they want to. */
165 #define CTF_COMPRESSION_THRESHOLD 4096
168 stat_alloc (size_t size
)
170 return obstack_alloc (&stat_obstack
, size
);
174 name_match (const char *pattern
, const char *name
)
176 if (wildcardp (pattern
))
177 return fnmatch (pattern
, name
, 0);
178 return strcmp (pattern
, name
);
182 ldirname (const char *name
)
184 const char *base
= lbasename (name
);
187 while (base
> name
&& IS_DIR_SEPARATOR (base
[-1]))
191 dirname
= strdup (name
);
192 dirname
[base
- name
] = '\0';
196 /* If PATTERN is of the form archive:file, return a pointer to the
197 separator. If not, return NULL. */
200 archive_path (const char *pattern
)
204 if (link_info
.path_separator
== 0)
207 p
= strchr (pattern
, link_info
.path_separator
);
208 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
209 if (p
== NULL
|| link_info
.path_separator
!= ':')
212 /* Assume a match on the second char is part of drive specifier,
213 as in "c:\silly.dos". */
214 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
215 p
= strchr (p
+ 1, link_info
.path_separator
);
220 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
221 return whether F matches FILE_SPEC. */
224 input_statement_is_archive_path (const char *file_spec
, char *sep
,
225 lang_input_statement_type
*f
)
227 bfd_boolean match
= FALSE
;
230 || name_match (sep
+ 1, f
->filename
) == 0)
231 && ((sep
!= file_spec
)
232 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
236 if (sep
!= file_spec
)
238 const char *aname
= bfd_get_filename (f
->the_bfd
->my_archive
);
240 match
= name_match (file_spec
, aname
) == 0;
241 *sep
= link_info
.path_separator
;
248 unique_section_p (const asection
*sec
,
249 const lang_output_section_statement_type
*os
)
251 struct unique_sections
*unam
;
254 if (!link_info
.resolve_section_groups
255 && sec
->owner
!= NULL
256 && bfd_is_group_section (sec
->owner
, sec
))
258 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
261 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
262 if (name_match (unam
->name
, secnam
) == 0)
268 /* Generic traversal routines for finding matching sections. */
270 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
274 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
275 lang_input_statement_type
*file
)
277 struct name_list
*list_tmp
;
279 for (list_tmp
= exclude_list
;
281 list_tmp
= list_tmp
->next
)
283 char *p
= archive_path (list_tmp
->name
);
287 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
291 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
294 /* FIXME: Perhaps remove the following at some stage? Matching
295 unadorned archives like this was never documented and has
296 been superceded by the archive:path syntax. */
297 else if (file
->the_bfd
!= NULL
298 && file
->the_bfd
->my_archive
!= NULL
299 && name_match (list_tmp
->name
,
300 bfd_get_filename (file
->the_bfd
->my_archive
)) == 0)
307 /* Try processing a section against a wildcard. This just calls
308 the callback unless the filename exclusion list is present
309 and excludes the file. It's hardly ever present so this
310 function is very fast. */
313 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
314 lang_input_statement_type
*file
,
316 struct wildcard_list
*sec
,
320 /* Don't process sections from files which were excluded. */
321 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
324 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
327 /* Lowest common denominator routine that can handle everything correctly,
331 walk_wild_section_general (lang_wild_statement_type
*ptr
,
332 lang_input_statement_type
*file
,
337 struct wildcard_list
*sec
;
339 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
341 sec
= ptr
->section_list
;
343 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
347 bfd_boolean skip
= FALSE
;
349 if (sec
->spec
.name
!= NULL
)
351 const char *sname
= bfd_section_name (s
);
353 skip
= name_match (sec
->spec
.name
, sname
) != 0;
357 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
364 /* Routines to find a single section given its name. If there's more
365 than one section with that name, we report that. */
369 asection
*found_section
;
370 bfd_boolean multiple_sections_found
;
371 } section_iterator_callback_data
;
374 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
376 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
378 if (d
->found_section
!= NULL
)
380 d
->multiple_sections_found
= TRUE
;
384 d
->found_section
= s
;
389 find_section (lang_input_statement_type
*file
,
390 struct wildcard_list
*sec
,
391 bfd_boolean
*multiple_sections_found
)
393 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
395 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
396 section_iterator_callback
, &cb_data
);
397 *multiple_sections_found
= cb_data
.multiple_sections_found
;
398 return cb_data
.found_section
;
401 /* Code for handling simple wildcards without going through fnmatch,
402 which can be expensive because of charset translations etc. */
404 /* A simple wild is a literal string followed by a single '*',
405 where the literal part is at least 4 characters long. */
408 is_simple_wild (const char *name
)
410 size_t len
= strcspn (name
, "*?[");
411 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
415 match_simple_wild (const char *pattern
, const char *name
)
417 /* The first four characters of the pattern are guaranteed valid
418 non-wildcard characters. So we can go faster. */
419 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
420 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
425 while (*pattern
!= '*')
426 if (*name
++ != *pattern
++)
432 /* Return the numerical value of the init_priority attribute from
433 section name NAME. */
436 get_init_priority (const asection
*sec
)
438 const char *name
= bfd_section_name (sec
);
441 /* GCC uses the following section names for the init_priority
442 attribute with numerical values 101 to 65535 inclusive. A
443 lower value means a higher priority.
445 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
446 decimal numerical value of the init_priority attribute.
447 The order of execution in .init_array is forward and
448 .fini_array is backward.
449 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
450 decimal numerical value of the init_priority attribute.
451 The order of execution in .ctors is backward and .dtors
454 .init_array.NNNNN sections would normally be placed in an output
455 .init_array section, .fini_array.NNNNN in .fini_array,
456 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
457 we should sort by increasing number (and could just use
458 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
459 being placed in .init_array (which may also contain
460 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
461 placed in .fini_array then we need to extract the init_priority
462 attribute and sort on that. */
463 dot
= strrchr (name
, '.');
464 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
467 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
471 && (strncmp (name
, ".ctors", 6) == 0
472 || strncmp (name
, ".dtors", 6) == 0))
473 init_priority
= 65535 - init_priority
;
474 if (init_priority
<= INT_MAX
)
475 return init_priority
;
481 /* Compare sections ASEC and BSEC according to SORT. */
484 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
487 int a_priority
, b_priority
;
494 case by_init_priority
:
495 a_priority
= get_init_priority (asec
);
496 b_priority
= get_init_priority (bsec
);
497 if (a_priority
< 0 || b_priority
< 0)
499 ret
= a_priority
- b_priority
;
505 case by_alignment_name
:
506 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
513 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
516 case by_name_alignment
:
517 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
523 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
530 /* Build a Binary Search Tree to sort sections, unlike insertion sort
531 used in wild_sort(). BST is considerably faster if the number of
532 of sections are large. */
534 static lang_section_bst_type
**
535 wild_sort_fast (lang_wild_statement_type
*wild
,
536 struct wildcard_list
*sec
,
537 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
540 lang_section_bst_type
**tree
;
543 if (!wild
->filenames_sorted
544 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
546 /* Append at the right end of tree. */
548 tree
= &((*tree
)->right
);
554 /* Find the correct node to append this section. */
555 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
556 tree
= &((*tree
)->left
);
558 tree
= &((*tree
)->right
);
564 /* Use wild_sort_fast to build a BST to sort sections. */
567 output_section_callback_fast (lang_wild_statement_type
*ptr
,
568 struct wildcard_list
*sec
,
570 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
571 lang_input_statement_type
*file
,
574 lang_section_bst_type
*node
;
575 lang_section_bst_type
**tree
;
576 lang_output_section_statement_type
*os
;
578 os
= (lang_output_section_statement_type
*) output
;
580 if (unique_section_p (section
, os
))
583 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
586 node
->section
= section
;
588 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
593 /* Convert a sorted sections' BST back to list form. */
596 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
597 lang_section_bst_type
*tree
,
601 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
603 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
604 (lang_output_section_statement_type
*) output
);
607 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
612 /* Specialized, optimized routines for handling different kinds of
616 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
617 lang_input_statement_type
*file
,
621 /* We can just do a hash lookup for the section with the right name.
622 But if that lookup discovers more than one section with the name
623 (should be rare), we fall back to the general algorithm because
624 we would otherwise have to sort the sections to make sure they
625 get processed in the bfd's order. */
626 bfd_boolean multiple_sections_found
;
627 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
628 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
630 if (multiple_sections_found
)
631 walk_wild_section_general (ptr
, file
, callback
, data
);
633 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
637 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
638 lang_input_statement_type
*file
,
643 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
645 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
647 const char *sname
= bfd_section_name (s
);
648 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
651 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
656 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
657 lang_input_statement_type
*file
,
662 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
663 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
664 bfd_boolean multiple_sections_found
;
665 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
667 if (multiple_sections_found
)
669 walk_wild_section_general (ptr
, file
, callback
, data
);
673 /* Note that if the section was not found, s0 is NULL and
674 we'll simply never succeed the s == s0 test below. */
675 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
677 /* Recall that in this code path, a section cannot satisfy more
678 than one spec, so if s == s0 then it cannot match
681 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
684 const char *sname
= bfd_section_name (s
);
685 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
688 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
695 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
696 lang_input_statement_type
*file
,
701 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
702 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
703 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
704 bfd_boolean multiple_sections_found
;
705 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
707 if (multiple_sections_found
)
709 walk_wild_section_general (ptr
, file
, callback
, data
);
713 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
716 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
719 const char *sname
= bfd_section_name (s
);
720 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
723 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
726 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
728 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
736 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
737 lang_input_statement_type
*file
,
742 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
743 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
744 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
745 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
746 bfd_boolean multiple_sections_found
;
747 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
749 if (multiple_sections_found
)
751 walk_wild_section_general (ptr
, file
, callback
, data
);
755 s1
= find_section (file
, sec1
, &multiple_sections_found
);
756 if (multiple_sections_found
)
758 walk_wild_section_general (ptr
, file
, callback
, data
);
762 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
765 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
768 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
771 const char *sname
= bfd_section_name (s
);
772 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
776 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
780 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
782 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
790 walk_wild_section (lang_wild_statement_type
*ptr
,
791 lang_input_statement_type
*file
,
795 if (file
->flags
.just_syms
)
798 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
801 /* Returns TRUE when name1 is a wildcard spec that might match
802 something name2 can match. We're conservative: we return FALSE
803 only if the prefixes of name1 and name2 are different up to the
804 first wildcard character. */
807 wild_spec_can_overlap (const char *name1
, const char *name2
)
809 size_t prefix1_len
= strcspn (name1
, "?*[");
810 size_t prefix2_len
= strcspn (name2
, "?*[");
811 size_t min_prefix_len
;
813 /* Note that if there is no wildcard character, then we treat the
814 terminating 0 as part of the prefix. Thus ".text" won't match
815 ".text." or ".text.*", for example. */
816 if (name1
[prefix1_len
] == '\0')
818 if (name2
[prefix2_len
] == '\0')
821 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
823 return memcmp (name1
, name2
, min_prefix_len
) == 0;
826 /* Select specialized code to handle various kinds of wildcard
830 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
833 int wild_name_count
= 0;
834 struct wildcard_list
*sec
;
838 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
839 ptr
->handler_data
[0] = NULL
;
840 ptr
->handler_data
[1] = NULL
;
841 ptr
->handler_data
[2] = NULL
;
842 ptr
->handler_data
[3] = NULL
;
845 /* Count how many wildcard_specs there are, and how many of those
846 actually use wildcards in the name. Also, bail out if any of the
847 wildcard names are NULL. (Can this actually happen?
848 walk_wild_section used to test for it.) And bail out if any
849 of the wildcards are more complex than a simple string
850 ending in a single '*'. */
851 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
854 if (sec
->spec
.name
== NULL
)
856 if (wildcardp (sec
->spec
.name
))
859 if (!is_simple_wild (sec
->spec
.name
))
864 /* The zero-spec case would be easy to optimize but it doesn't
865 happen in practice. Likewise, more than 4 specs doesn't
866 happen in practice. */
867 if (sec_count
== 0 || sec_count
> 4)
870 /* Check that no two specs can match the same section. */
871 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
873 struct wildcard_list
*sec2
;
874 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
876 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
881 signature
= (sec_count
<< 8) + wild_name_count
;
885 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
888 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
891 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
894 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
897 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
903 /* Now fill the data array with pointers to the specs, first the
904 specs with non-wildcard names, then the specs with wildcard
905 names. It's OK to process the specs in different order from the
906 given order, because we've already determined that no section
907 will match more than one spec. */
909 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
910 if (!wildcardp (sec
->spec
.name
))
911 ptr
->handler_data
[data_counter
++] = sec
;
912 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
913 if (wildcardp (sec
->spec
.name
))
914 ptr
->handler_data
[data_counter
++] = sec
;
917 /* Handle a wild statement for a single file F. */
920 walk_wild_file (lang_wild_statement_type
*s
,
921 lang_input_statement_type
*f
,
925 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
928 if (f
->the_bfd
== NULL
929 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
930 walk_wild_section (s
, f
, callback
, data
);
935 /* This is an archive file. We must map each member of the
936 archive separately. */
937 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
938 while (member
!= NULL
)
940 /* When lookup_name is called, it will call the add_symbols
941 entry point for the archive. For each element of the
942 archive which is included, BFD will call ldlang_add_file,
943 which will set the usrdata field of the member to the
944 lang_input_statement. */
945 if (bfd_usrdata (member
) != NULL
)
946 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
948 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
954 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
956 const char *file_spec
= s
->filename
;
959 if (file_spec
== NULL
)
961 /* Perform the iteration over all files in the list. */
962 LANG_FOR_EACH_INPUT_STATEMENT (f
)
964 walk_wild_file (s
, f
, callback
, data
);
967 else if ((p
= archive_path (file_spec
)) != NULL
)
969 LANG_FOR_EACH_INPUT_STATEMENT (f
)
971 if (input_statement_is_archive_path (file_spec
, p
, f
))
972 walk_wild_file (s
, f
, callback
, data
);
975 else if (wildcardp (file_spec
))
977 LANG_FOR_EACH_INPUT_STATEMENT (f
)
979 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
980 walk_wild_file (s
, f
, callback
, data
);
985 lang_input_statement_type
*f
;
987 /* Perform the iteration over a single file. */
988 f
= lookup_name (file_spec
);
990 walk_wild_file (s
, f
, callback
, data
);
994 /* lang_for_each_statement walks the parse tree and calls the provided
995 function for each node, except those inside output section statements
996 with constraint set to -1. */
999 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
1000 lang_statement_union_type
*s
)
1002 for (; s
!= NULL
; s
= s
->header
.next
)
1006 switch (s
->header
.type
)
1008 case lang_constructors_statement_enum
:
1009 lang_for_each_statement_worker (func
, constructor_list
.head
);
1011 case lang_output_section_statement_enum
:
1012 if (s
->output_section_statement
.constraint
!= -1)
1013 lang_for_each_statement_worker
1014 (func
, s
->output_section_statement
.children
.head
);
1016 case lang_wild_statement_enum
:
1017 lang_for_each_statement_worker (func
,
1018 s
->wild_statement
.children
.head
);
1020 case lang_group_statement_enum
:
1021 lang_for_each_statement_worker (func
,
1022 s
->group_statement
.children
.head
);
1024 case lang_data_statement_enum
:
1025 case lang_reloc_statement_enum
:
1026 case lang_object_symbols_statement_enum
:
1027 case lang_output_statement_enum
:
1028 case lang_target_statement_enum
:
1029 case lang_input_section_enum
:
1030 case lang_input_statement_enum
:
1031 case lang_assignment_statement_enum
:
1032 case lang_padding_statement_enum
:
1033 case lang_address_statement_enum
:
1034 case lang_fill_statement_enum
:
1035 case lang_insert_statement_enum
:
1045 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1047 lang_for_each_statement_worker (func
, statement_list
.head
);
1050 /*----------------------------------------------------------------------*/
1053 lang_list_init (lang_statement_list_type
*list
)
1056 list
->tail
= &list
->head
;
1060 lang_statement_append (lang_statement_list_type
*list
,
1064 *(list
->tail
) = element
;
1069 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1071 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1073 *stat_save_ptr
++ = stat_ptr
;
1080 if (stat_save_ptr
<= stat_save
)
1082 stat_ptr
= *--stat_save_ptr
;
1085 /* Build a new statement node for the parse tree. */
1087 static lang_statement_union_type
*
1088 new_statement (enum statement_enum type
,
1090 lang_statement_list_type
*list
)
1092 lang_statement_union_type
*new_stmt
;
1094 new_stmt
= stat_alloc (size
);
1095 new_stmt
->header
.type
= type
;
1096 new_stmt
->header
.next
= NULL
;
1097 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1101 /* Build a new input file node for the language. There are several
1102 ways in which we treat an input file, eg, we only look at symbols,
1103 or prefix it with a -l etc.
1105 We can be supplied with requests for input files more than once;
1106 they may, for example be split over several lines like foo.o(.text)
1107 foo.o(.data) etc, so when asked for a file we check that we haven't
1108 got it already so we don't duplicate the bfd. */
1110 static lang_input_statement_type
*
1111 new_afile (const char *name
,
1112 lang_input_file_enum_type file_type
,
1114 const char *from_filename
)
1116 lang_input_statement_type
*p
;
1118 lang_has_input_file
= TRUE
;
1120 p
= new_stat (lang_input_statement
, stat_ptr
);
1121 memset (&p
->the_bfd
, 0,
1122 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1123 p
->extra_search_path
= NULL
;
1125 p
->flags
.dynamic
= input_flags
.dynamic
;
1126 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1127 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1128 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1129 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1133 case lang_input_file_is_symbols_only_enum
:
1135 p
->local_sym_name
= name
;
1136 p
->flags
.real
= TRUE
;
1137 p
->flags
.just_syms
= TRUE
;
1139 case lang_input_file_is_fake_enum
:
1141 p
->local_sym_name
= name
;
1143 case lang_input_file_is_l_enum
:
1144 if (name
[0] == ':' && name
[1] != '\0')
1146 p
->filename
= name
+ 1;
1147 p
->flags
.full_name_provided
= TRUE
;
1151 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1152 p
->flags
.maybe_archive
= TRUE
;
1153 p
->flags
.real
= TRUE
;
1154 p
->flags
.search_dirs
= TRUE
;
1156 case lang_input_file_is_marker_enum
:
1158 p
->local_sym_name
= name
;
1159 p
->flags
.search_dirs
= TRUE
;
1161 case lang_input_file_is_search_file_enum
:
1163 p
->local_sym_name
= name
;
1164 /* If name is a relative path, search the directory of the current linker
1166 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1167 p
->extra_search_path
= ldirname (from_filename
);
1168 p
->flags
.real
= TRUE
;
1169 p
->flags
.search_dirs
= TRUE
;
1171 case lang_input_file_is_file_enum
:
1173 p
->local_sym_name
= name
;
1174 p
->flags
.real
= TRUE
;
1180 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1184 lang_input_statement_type
*
1185 lang_add_input_file (const char *name
,
1186 lang_input_file_enum_type file_type
,
1190 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1192 lang_input_statement_type
*ret
;
1193 char *sysrooted_name
1194 = concat (ld_sysroot
,
1195 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1196 (const char *) NULL
);
1198 /* We've now forcibly prepended the sysroot, making the input
1199 file independent of the context. Therefore, temporarily
1200 force a non-sysrooted context for this statement, so it won't
1201 get the sysroot prepended again when opened. (N.B. if it's a
1202 script, any child nodes with input files starting with "/"
1203 will be handled as "sysrooted" as they'll be found to be
1204 within the sysroot subdirectory.) */
1205 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1206 input_flags
.sysrooted
= 0;
1207 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1208 input_flags
.sysrooted
= outer_sysrooted
;
1212 return new_afile (name
, file_type
, target
, current_input_file
);
1215 struct out_section_hash_entry
1217 struct bfd_hash_entry root
;
1218 lang_statement_union_type s
;
1221 /* The hash table. */
1223 static struct bfd_hash_table output_section_statement_table
;
1225 /* Support routines for the hash table used by lang_output_section_find,
1226 initialize the table, fill in an entry and remove the table. */
1228 static struct bfd_hash_entry
*
1229 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1230 struct bfd_hash_table
*table
,
1233 lang_output_section_statement_type
**nextp
;
1234 struct out_section_hash_entry
*ret
;
1238 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1244 entry
= bfd_hash_newfunc (entry
, table
, string
);
1248 ret
= (struct out_section_hash_entry
*) entry
;
1249 memset (&ret
->s
, 0, sizeof (ret
->s
));
1250 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1251 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1252 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1253 ret
->s
.output_section_statement
.block_value
= 1;
1254 lang_list_init (&ret
->s
.output_section_statement
.children
);
1255 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1257 /* For every output section statement added to the list, except the
1258 first one, lang_os_list.tail points to the "next"
1259 field of the last element of the list. */
1260 if (lang_os_list
.head
!= NULL
)
1261 ret
->s
.output_section_statement
.prev
1262 = ((lang_output_section_statement_type
*)
1263 ((char *) lang_os_list
.tail
1264 - offsetof (lang_output_section_statement_type
, next
)));
1266 /* GCC's strict aliasing rules prevent us from just casting the
1267 address, so we store the pointer in a variable and cast that
1269 nextp
= &ret
->s
.output_section_statement
.next
;
1270 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1275 output_section_statement_table_init (void)
1277 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1278 output_section_statement_newfunc
,
1279 sizeof (struct out_section_hash_entry
),
1281 einfo (_("%F%P: can not create hash table: %E\n"));
1285 output_section_statement_table_free (void)
1287 bfd_hash_table_free (&output_section_statement_table
);
1290 /* Build enough state so that the parser can build its tree. */
1295 obstack_begin (&stat_obstack
, 1000);
1297 stat_ptr
= &statement_list
;
1299 output_section_statement_table_init ();
1301 lang_list_init (stat_ptr
);
1303 lang_list_init (&input_file_chain
);
1304 lang_list_init (&lang_os_list
);
1305 lang_list_init (&file_chain
);
1306 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1308 abs_output_section
=
1309 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1311 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1313 asneeded_list_head
= NULL
;
1314 asneeded_list_tail
= &asneeded_list_head
;
1320 output_section_statement_table_free ();
1323 /*----------------------------------------------------------------------
1324 A region is an area of memory declared with the
1325 MEMORY { name:org=exp, len=exp ... }
1328 We maintain a list of all the regions here.
1330 If no regions are specified in the script, then the default is used
1331 which is created when looked up to be the entire data space.
1333 If create is true we are creating a region inside a MEMORY block.
1334 In this case it is probably an error to create a region that has
1335 already been created. If we are not inside a MEMORY block it is
1336 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1337 and so we issue a warning.
1339 Each region has at least one name. The first name is either
1340 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1341 alias names to an existing region within a script with
1342 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1345 static lang_memory_region_type
*lang_memory_region_list
;
1346 static lang_memory_region_type
**lang_memory_region_list_tail
1347 = &lang_memory_region_list
;
1349 lang_memory_region_type
*
1350 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1352 lang_memory_region_name
*n
;
1353 lang_memory_region_type
*r
;
1354 lang_memory_region_type
*new_region
;
1356 /* NAME is NULL for LMA memspecs if no region was specified. */
1360 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1361 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1362 if (strcmp (n
->name
, name
) == 0)
1365 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1370 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1371 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1374 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1376 new_region
->name_list
.name
= xstrdup (name
);
1377 new_region
->name_list
.next
= NULL
;
1378 new_region
->next
= NULL
;
1379 new_region
->origin_exp
= NULL
;
1380 new_region
->origin
= 0;
1381 new_region
->length_exp
= NULL
;
1382 new_region
->length
= ~(bfd_size_type
) 0;
1383 new_region
->current
= 0;
1384 new_region
->last_os
= NULL
;
1385 new_region
->flags
= 0;
1386 new_region
->not_flags
= 0;
1387 new_region
->had_full_message
= FALSE
;
1389 *lang_memory_region_list_tail
= new_region
;
1390 lang_memory_region_list_tail
= &new_region
->next
;
1396 lang_memory_region_alias (const char *alias
, const char *region_name
)
1398 lang_memory_region_name
*n
;
1399 lang_memory_region_type
*r
;
1400 lang_memory_region_type
*region
;
1402 /* The default region must be unique. This ensures that it is not necessary
1403 to iterate through the name list if someone wants the check if a region is
1404 the default memory region. */
1405 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1406 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1407 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1409 /* Look for the target region and check if the alias is not already
1412 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1413 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1415 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1417 if (strcmp (n
->name
, alias
) == 0)
1418 einfo (_("%F%P:%pS: error: redefinition of memory region "
1423 /* Check if the target region exists. */
1425 einfo (_("%F%P:%pS: error: memory region `%s' "
1426 "for alias `%s' does not exist\n"),
1427 NULL
, region_name
, alias
);
1429 /* Add alias to region name list. */
1430 n
= stat_alloc (sizeof (lang_memory_region_name
));
1431 n
->name
= xstrdup (alias
);
1432 n
->next
= region
->name_list
.next
;
1433 region
->name_list
.next
= n
;
1436 static lang_memory_region_type
*
1437 lang_memory_default (asection
*section
)
1439 lang_memory_region_type
*p
;
1441 flagword sec_flags
= section
->flags
;
1443 /* Override SEC_DATA to mean a writable section. */
1444 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1445 sec_flags
|= SEC_DATA
;
1447 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1449 if ((p
->flags
& sec_flags
) != 0
1450 && (p
->not_flags
& sec_flags
) == 0)
1455 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1458 /* Get the output section statement directly from the userdata. */
1460 lang_output_section_statement_type
*
1461 lang_output_section_get (const asection
*output_section
)
1463 return bfd_section_userdata (output_section
);
1466 /* Find or create an output_section_statement with the given NAME.
1467 If CONSTRAINT is non-zero match one with that constraint, otherwise
1468 match any non-negative constraint. If CREATE, always make a
1469 new output_section_statement for SPECIAL CONSTRAINT. */
1471 lang_output_section_statement_type
*
1472 lang_output_section_statement_lookup (const char *name
,
1476 struct out_section_hash_entry
*entry
;
1478 entry
= ((struct out_section_hash_entry
*)
1479 bfd_hash_lookup (&output_section_statement_table
, name
,
1484 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1488 if (entry
->s
.output_section_statement
.name
!= NULL
)
1490 /* We have a section of this name, but it might not have the correct
1492 struct out_section_hash_entry
*last_ent
;
1494 name
= entry
->s
.output_section_statement
.name
;
1495 if (create
&& constraint
== SPECIAL
)
1496 /* Not traversing to the end reverses the order of the second
1497 and subsequent SPECIAL sections in the hash table chain,
1498 but that shouldn't matter. */
1503 if (constraint
== entry
->s
.output_section_statement
.constraint
1505 && entry
->s
.output_section_statement
.constraint
>= 0))
1506 return &entry
->s
.output_section_statement
;
1508 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1510 while (entry
!= NULL
1511 && name
== entry
->s
.output_section_statement
.name
);
1517 = ((struct out_section_hash_entry
*)
1518 output_section_statement_newfunc (NULL
,
1519 &output_section_statement_table
,
1523 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1526 entry
->root
= last_ent
->root
;
1527 last_ent
->root
.next
= &entry
->root
;
1530 entry
->s
.output_section_statement
.name
= name
;
1531 entry
->s
.output_section_statement
.constraint
= constraint
;
1532 return &entry
->s
.output_section_statement
;
1535 /* Find the next output_section_statement with the same name as OS.
1536 If CONSTRAINT is non-zero, find one with that constraint otherwise
1537 match any non-negative constraint. */
1539 lang_output_section_statement_type
*
1540 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1543 /* All output_section_statements are actually part of a
1544 struct out_section_hash_entry. */
1545 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1547 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1548 const char *name
= os
->name
;
1550 ASSERT (name
== entry
->root
.string
);
1553 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1555 || name
!= entry
->s
.output_section_statement
.name
)
1558 while (constraint
!= entry
->s
.output_section_statement
.constraint
1560 || entry
->s
.output_section_statement
.constraint
< 0));
1562 return &entry
->s
.output_section_statement
;
1565 /* A variant of lang_output_section_find used by place_orphan.
1566 Returns the output statement that should precede a new output
1567 statement for SEC. If an exact match is found on certain flags,
1570 lang_output_section_statement_type
*
1571 lang_output_section_find_by_flags (const asection
*sec
,
1573 lang_output_section_statement_type
**exact
,
1574 lang_match_sec_type_func match_type
)
1576 lang_output_section_statement_type
*first
, *look
, *found
;
1577 flagword look_flags
, differ
;
1579 /* We know the first statement on this list is *ABS*. May as well
1581 first
= (void *) lang_os_list
.head
;
1582 first
= first
->next
;
1584 /* First try for an exact match. */
1586 for (look
= first
; look
; look
= look
->next
)
1588 look_flags
= look
->flags
;
1589 if (look
->bfd_section
!= NULL
)
1591 look_flags
= look
->bfd_section
->flags
;
1592 if (match_type
&& !match_type (link_info
.output_bfd
,
1597 differ
= look_flags
^ sec_flags
;
1598 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1599 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1609 if ((sec_flags
& SEC_CODE
) != 0
1610 && (sec_flags
& SEC_ALLOC
) != 0)
1612 /* Try for a rw code section. */
1613 for (look
= first
; look
; look
= look
->next
)
1615 look_flags
= look
->flags
;
1616 if (look
->bfd_section
!= NULL
)
1618 look_flags
= look
->bfd_section
->flags
;
1619 if (match_type
&& !match_type (link_info
.output_bfd
,
1624 differ
= look_flags
^ sec_flags
;
1625 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1626 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1630 else if ((sec_flags
& SEC_READONLY
) != 0
1631 && (sec_flags
& SEC_ALLOC
) != 0)
1633 /* .rodata can go after .text, .sdata2 after .rodata. */
1634 for (look
= first
; look
; look
= look
->next
)
1636 look_flags
= look
->flags
;
1637 if (look
->bfd_section
!= NULL
)
1639 look_flags
= look
->bfd_section
->flags
;
1640 if (match_type
&& !match_type (link_info
.output_bfd
,
1645 differ
= look_flags
^ sec_flags
;
1646 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1647 | SEC_READONLY
| SEC_SMALL_DATA
))
1648 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1650 && !(look_flags
& SEC_SMALL_DATA
)))
1654 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1655 && (sec_flags
& SEC_ALLOC
) != 0)
1657 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1658 as if it were a loaded section, and don't use match_type. */
1659 bfd_boolean seen_thread_local
= FALSE
;
1662 for (look
= first
; look
; look
= look
->next
)
1664 look_flags
= look
->flags
;
1665 if (look
->bfd_section
!= NULL
)
1666 look_flags
= look
->bfd_section
->flags
;
1668 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1669 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1671 /* .tdata and .tbss must be adjacent and in that order. */
1672 if (!(look_flags
& SEC_LOAD
)
1673 && (sec_flags
& SEC_LOAD
))
1674 /* ..so if we're at a .tbss section and we're placing
1675 a .tdata section stop looking and return the
1676 previous section. */
1679 seen_thread_local
= TRUE
;
1681 else if (seen_thread_local
)
1683 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1687 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1688 && (sec_flags
& SEC_ALLOC
) != 0)
1690 /* .sdata goes after .data, .sbss after .sdata. */
1691 for (look
= first
; look
; look
= look
->next
)
1693 look_flags
= look
->flags
;
1694 if (look
->bfd_section
!= NULL
)
1696 look_flags
= look
->bfd_section
->flags
;
1697 if (match_type
&& !match_type (link_info
.output_bfd
,
1702 differ
= look_flags
^ sec_flags
;
1703 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1704 | SEC_THREAD_LOCAL
))
1705 || ((look_flags
& SEC_SMALL_DATA
)
1706 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1710 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1711 && (sec_flags
& SEC_ALLOC
) != 0)
1713 /* .data goes after .rodata. */
1714 for (look
= first
; look
; look
= look
->next
)
1716 look_flags
= look
->flags
;
1717 if (look
->bfd_section
!= NULL
)
1719 look_flags
= look
->bfd_section
->flags
;
1720 if (match_type
&& !match_type (link_info
.output_bfd
,
1725 differ
= look_flags
^ sec_flags
;
1726 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1727 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1731 else if ((sec_flags
& SEC_ALLOC
) != 0)
1733 /* .bss goes after any other alloc section. */
1734 for (look
= first
; look
; look
= look
->next
)
1736 look_flags
= look
->flags
;
1737 if (look
->bfd_section
!= NULL
)
1739 look_flags
= look
->bfd_section
->flags
;
1740 if (match_type
&& !match_type (link_info
.output_bfd
,
1745 differ
= look_flags
^ sec_flags
;
1746 if (!(differ
& SEC_ALLOC
))
1752 /* non-alloc go last. */
1753 for (look
= first
; look
; look
= look
->next
)
1755 look_flags
= look
->flags
;
1756 if (look
->bfd_section
!= NULL
)
1757 look_flags
= look
->bfd_section
->flags
;
1758 differ
= look_flags
^ sec_flags
;
1759 if (!(differ
& SEC_DEBUGGING
))
1765 if (found
|| !match_type
)
1768 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1771 /* Find the last output section before given output statement.
1772 Used by place_orphan. */
1775 output_prev_sec_find (lang_output_section_statement_type
*os
)
1777 lang_output_section_statement_type
*lookup
;
1779 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1781 if (lookup
->constraint
< 0)
1784 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1785 return lookup
->bfd_section
;
1791 /* Look for a suitable place for a new output section statement. The
1792 idea is to skip over anything that might be inside a SECTIONS {}
1793 statement in a script, before we find another output section
1794 statement. Assignments to "dot" before an output section statement
1795 are assumed to belong to it, except in two cases; The first
1796 assignment to dot, and assignments before non-alloc sections.
1797 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1798 similar assignments that set the initial address, or we might
1799 insert non-alloc note sections among assignments setting end of
1802 static lang_statement_union_type
**
1803 insert_os_after (lang_output_section_statement_type
*after
)
1805 lang_statement_union_type
**where
;
1806 lang_statement_union_type
**assign
= NULL
;
1807 bfd_boolean ignore_first
;
1809 ignore_first
= after
== (void *) lang_os_list
.head
;
1811 for (where
= &after
->header
.next
;
1813 where
= &(*where
)->header
.next
)
1815 switch ((*where
)->header
.type
)
1817 case lang_assignment_statement_enum
:
1820 lang_assignment_statement_type
*ass
;
1822 ass
= &(*where
)->assignment_statement
;
1823 if (ass
->exp
->type
.node_class
!= etree_assert
1824 && ass
->exp
->assign
.dst
[0] == '.'
1825 && ass
->exp
->assign
.dst
[1] == 0)
1829 ignore_first
= FALSE
;
1833 case lang_wild_statement_enum
:
1834 case lang_input_section_enum
:
1835 case lang_object_symbols_statement_enum
:
1836 case lang_fill_statement_enum
:
1837 case lang_data_statement_enum
:
1838 case lang_reloc_statement_enum
:
1839 case lang_padding_statement_enum
:
1840 case lang_constructors_statement_enum
:
1842 ignore_first
= FALSE
;
1844 case lang_output_section_statement_enum
:
1847 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1850 || s
->map_head
.s
== NULL
1851 || (s
->flags
& SEC_ALLOC
) != 0)
1855 case lang_input_statement_enum
:
1856 case lang_address_statement_enum
:
1857 case lang_target_statement_enum
:
1858 case lang_output_statement_enum
:
1859 case lang_group_statement_enum
:
1860 case lang_insert_statement_enum
:
1869 lang_output_section_statement_type
*
1870 lang_insert_orphan (asection
*s
,
1871 const char *secname
,
1873 lang_output_section_statement_type
*after
,
1874 struct orphan_save
*place
,
1875 etree_type
*address
,
1876 lang_statement_list_type
*add_child
)
1878 lang_statement_list_type add
;
1879 lang_output_section_statement_type
*os
;
1880 lang_output_section_statement_type
**os_tail
;
1882 /* If we have found an appropriate place for the output section
1883 statements for this orphan, add them to our own private list,
1884 inserting them later into the global statement list. */
1887 lang_list_init (&add
);
1888 push_stat_ptr (&add
);
1891 if (bfd_link_relocatable (&link_info
)
1892 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1893 address
= exp_intop (0);
1895 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1896 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1897 NULL
, NULL
, NULL
, constraint
, 0);
1899 if (add_child
== NULL
)
1900 add_child
= &os
->children
;
1901 lang_add_section (add_child
, s
, NULL
, os
);
1903 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1905 const char *region
= (after
->region
1906 ? after
->region
->name_list
.name
1907 : DEFAULT_MEMORY_REGION
);
1908 const char *lma_region
= (after
->lma_region
1909 ? after
->lma_region
->name_list
.name
1911 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1915 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1918 /* Restore the global list pointer. */
1922 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1924 asection
*snew
, *as
;
1925 bfd_boolean place_after
= place
->stmt
== NULL
;
1926 bfd_boolean insert_after
= TRUE
;
1928 snew
= os
->bfd_section
;
1930 /* Shuffle the bfd section list to make the output file look
1931 neater. This is really only cosmetic. */
1932 if (place
->section
== NULL
1933 && after
!= (void *) lang_os_list
.head
)
1935 asection
*bfd_section
= after
->bfd_section
;
1937 /* If the output statement hasn't been used to place any input
1938 sections (and thus doesn't have an output bfd_section),
1939 look for the closest prior output statement having an
1941 if (bfd_section
== NULL
)
1942 bfd_section
= output_prev_sec_find (after
);
1944 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1945 place
->section
= &bfd_section
->next
;
1948 if (place
->section
== NULL
)
1949 place
->section
= &link_info
.output_bfd
->sections
;
1951 as
= *place
->section
;
1955 /* Put the section at the end of the list. */
1957 /* Unlink the section. */
1958 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1960 /* Now tack it back on in the right place. */
1961 bfd_section_list_append (link_info
.output_bfd
, snew
);
1963 else if ((bfd_get_flavour (link_info
.output_bfd
)
1964 == bfd_target_elf_flavour
)
1965 && (bfd_get_flavour (s
->owner
)
1966 == bfd_target_elf_flavour
)
1967 && ((elf_section_type (s
) == SHT_NOTE
1968 && (s
->flags
& SEC_LOAD
) != 0)
1969 || (elf_section_type (as
) == SHT_NOTE
1970 && (as
->flags
& SEC_LOAD
) != 0)))
1972 /* Make sure that output note sections are grouped and sorted
1973 by alignments when inserting a note section or insert a
1974 section after a note section, */
1976 /* A specific section after which the output note section
1977 should be placed. */
1978 asection
*after_sec
;
1979 /* True if we need to insert the orphan section after a
1980 specific section to maintain output note section order. */
1981 bfd_boolean after_sec_note
= FALSE
;
1983 static asection
*first_orphan_note
= NULL
;
1985 /* Group and sort output note section by alignments in
1988 if (elf_section_type (s
) == SHT_NOTE
1989 && (s
->flags
& SEC_LOAD
) != 0)
1991 /* Search from the beginning for the last output note
1992 section with equal or larger alignments. NB: Don't
1993 place orphan note section after non-note sections. */
1995 first_orphan_note
= NULL
;
1996 for (sec
= link_info
.output_bfd
->sections
;
1998 && !bfd_is_abs_section (sec
));
2001 && elf_section_type (sec
) == SHT_NOTE
2002 && (sec
->flags
& SEC_LOAD
) != 0)
2004 if (!first_orphan_note
)
2005 first_orphan_note
= sec
;
2006 if (sec
->alignment_power
>= s
->alignment_power
)
2009 else if (first_orphan_note
)
2011 /* Stop if there is non-note section after the first
2012 orphan note section. */
2016 /* If this will be the first orphan note section, it can
2017 be placed at the default location. */
2018 after_sec_note
= first_orphan_note
!= NULL
;
2019 if (after_sec
== NULL
&& after_sec_note
)
2021 /* If all output note sections have smaller
2022 alignments, place the section before all
2023 output orphan note sections. */
2024 after_sec
= first_orphan_note
;
2025 insert_after
= FALSE
;
2028 else if (first_orphan_note
)
2030 /* Don't place non-note sections in the middle of orphan
2032 after_sec_note
= TRUE
;
2034 for (sec
= as
->next
;
2036 && !bfd_is_abs_section (sec
));
2038 if (elf_section_type (sec
) == SHT_NOTE
2039 && (sec
->flags
& SEC_LOAD
) != 0)
2047 /* Search forward to insert OS after AFTER_SEC output
2049 lang_output_section_statement_type
*stmt
, *next
;
2050 bfd_boolean found
= FALSE
;
2051 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2056 if (stmt
->bfd_section
== after_sec
)
2066 /* If INSERT_AFTER is FALSE, place OS before
2067 AFTER_SEC output statement. */
2068 if (next
&& next
->bfd_section
== after_sec
)
2078 /* Search backward to insert OS after AFTER_SEC output
2081 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2085 if (stmt
->bfd_section
== after_sec
)
2094 /* If INSERT_AFTER is FALSE, place OS before
2095 AFTER_SEC output statement. */
2096 if (stmt
->next
->bfd_section
== after_sec
)
2106 if (after_sec
== NULL
2107 || (insert_after
&& after_sec
->next
!= snew
)
2108 || (!insert_after
&& after_sec
->prev
!= snew
))
2110 /* Unlink the section. */
2111 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2113 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2118 bfd_section_list_insert_after (link_info
.output_bfd
,
2121 bfd_section_list_insert_before (link_info
.output_bfd
,
2125 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2128 else if (as
!= snew
&& as
->prev
!= snew
)
2130 /* Unlink the section. */
2131 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2133 /* Now tack it back on in the right place. */
2134 bfd_section_list_insert_before (link_info
.output_bfd
,
2138 else if (as
!= snew
&& as
->prev
!= snew
)
2140 /* Unlink the section. */
2141 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2143 /* Now tack it back on in the right place. */
2144 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2147 /* Save the end of this list. Further ophans of this type will
2148 follow the one we've just added. */
2149 place
->section
= &snew
->next
;
2151 /* The following is non-cosmetic. We try to put the output
2152 statements in some sort of reasonable order here, because they
2153 determine the final load addresses of the orphan sections.
2154 In addition, placing output statements in the wrong order may
2155 require extra segments. For instance, given a typical
2156 situation of all read-only sections placed in one segment and
2157 following that a segment containing all the read-write
2158 sections, we wouldn't want to place an orphan read/write
2159 section before or amongst the read-only ones. */
2160 if (add
.head
!= NULL
)
2162 lang_output_section_statement_type
*newly_added_os
;
2164 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2167 lang_statement_union_type
**where
= insert_os_after (after
);
2172 place
->os_tail
= &after
->next
;
2176 /* Put it after the last orphan statement we added. */
2177 *add
.tail
= *place
->stmt
;
2178 *place
->stmt
= add
.head
;
2181 /* Fix the global list pointer if we happened to tack our
2182 new list at the tail. */
2183 if (*stat_ptr
->tail
== add
.head
)
2184 stat_ptr
->tail
= add
.tail
;
2186 /* Save the end of this list. */
2187 place
->stmt
= add
.tail
;
2189 /* Do the same for the list of output section statements. */
2190 newly_added_os
= *os_tail
;
2192 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2193 ((char *) place
->os_tail
2194 - offsetof (lang_output_section_statement_type
, next
));
2195 newly_added_os
->next
= *place
->os_tail
;
2196 if (newly_added_os
->next
!= NULL
)
2197 newly_added_os
->next
->prev
= newly_added_os
;
2198 *place
->os_tail
= newly_added_os
;
2199 place
->os_tail
= &newly_added_os
->next
;
2201 /* Fixing the global list pointer here is a little different.
2202 We added to the list in lang_enter_output_section_statement,
2203 trimmed off the new output_section_statment above when
2204 assigning *os_tail = NULL, but possibly added it back in
2205 the same place when assigning *place->os_tail. */
2206 if (*os_tail
== NULL
)
2207 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2214 lang_print_asneeded (void)
2216 struct asneeded_minfo
*m
;
2218 if (asneeded_list_head
== NULL
)
2221 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2223 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2227 minfo ("%s", m
->soname
);
2228 len
= strlen (m
->soname
);
2242 minfo ("%pB ", m
->ref
);
2243 minfo ("(%pT)\n", m
->name
);
2248 lang_map_flags (flagword flag
)
2250 if (flag
& SEC_ALLOC
)
2253 if (flag
& SEC_CODE
)
2256 if (flag
& SEC_READONLY
)
2259 if (flag
& SEC_DATA
)
2262 if (flag
& SEC_LOAD
)
2269 lang_memory_region_type
*m
;
2270 bfd_boolean dis_header_printed
= FALSE
;
2272 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2276 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2277 || file
->flags
.just_syms
)
2280 if (config
.print_map_discarded
)
2281 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2282 if ((s
->output_section
== NULL
2283 || s
->output_section
->owner
!= link_info
.output_bfd
)
2284 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2286 if (! dis_header_printed
)
2288 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2289 dis_header_printed
= TRUE
;
2292 print_input_section (s
, TRUE
);
2296 minfo (_("\nMemory Configuration\n\n"));
2297 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2298 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2300 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2305 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2307 sprintf_vma (buf
, m
->origin
);
2308 minfo ("0x%s ", buf
);
2316 minfo ("0x%V", m
->length
);
2317 if (m
->flags
|| m
->not_flags
)
2325 lang_map_flags (m
->flags
);
2331 lang_map_flags (m
->not_flags
);
2338 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2340 if (!link_info
.reduce_memory_overheads
)
2342 obstack_begin (&map_obstack
, 1000);
2343 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2345 expld
.phase
= lang_fixed_phase_enum
;
2346 lang_statement_iteration
++;
2347 print_statements ();
2349 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2354 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2355 void *info ATTRIBUTE_UNUSED
)
2357 if ((hash_entry
->type
== bfd_link_hash_defined
2358 || hash_entry
->type
== bfd_link_hash_defweak
)
2359 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2360 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2362 input_section_userdata_type
*ud
;
2363 struct map_symbol_def
*def
;
2365 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2368 ud
= stat_alloc (sizeof (*ud
));
2369 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2370 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2371 ud
->map_symbol_def_count
= 0;
2373 else if (!ud
->map_symbol_def_tail
)
2374 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2376 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2377 def
->entry
= hash_entry
;
2378 *(ud
->map_symbol_def_tail
) = def
;
2379 ud
->map_symbol_def_tail
= &def
->next
;
2380 ud
->map_symbol_def_count
++;
2385 /* Initialize an output section. */
2388 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2390 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2391 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2393 if (s
->constraint
!= SPECIAL
)
2394 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2395 if (s
->bfd_section
== NULL
)
2396 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2398 if (s
->bfd_section
== NULL
)
2400 einfo (_("%F%P: output format %s cannot represent section"
2401 " called %s: %E\n"),
2402 link_info
.output_bfd
->xvec
->name
, s
->name
);
2404 s
->bfd_section
->output_section
= s
->bfd_section
;
2405 s
->bfd_section
->output_offset
= 0;
2407 /* Set the userdata of the output section to the output section
2408 statement to avoid lookup. */
2409 bfd_set_section_userdata (s
->bfd_section
, s
);
2411 /* If there is a base address, make sure that any sections it might
2412 mention are initialized. */
2413 if (s
->addr_tree
!= NULL
)
2414 exp_init_os (s
->addr_tree
);
2416 if (s
->load_base
!= NULL
)
2417 exp_init_os (s
->load_base
);
2419 /* If supplied an alignment, set it. */
2420 if (s
->section_alignment
!= NULL
)
2421 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2422 "section alignment");
2425 /* Make sure that all output sections mentioned in an expression are
2429 exp_init_os (etree_type
*exp
)
2431 switch (exp
->type
.node_class
)
2435 case etree_provided
:
2436 exp_init_os (exp
->assign
.src
);
2440 exp_init_os (exp
->binary
.lhs
);
2441 exp_init_os (exp
->binary
.rhs
);
2445 exp_init_os (exp
->trinary
.cond
);
2446 exp_init_os (exp
->trinary
.lhs
);
2447 exp_init_os (exp
->trinary
.rhs
);
2451 exp_init_os (exp
->assert_s
.child
);
2455 exp_init_os (exp
->unary
.child
);
2459 switch (exp
->type
.node_code
)
2465 lang_output_section_statement_type
*os
;
2467 os
= lang_output_section_find (exp
->name
.name
);
2468 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2480 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2482 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2484 /* If we are only reading symbols from this object, then we want to
2485 discard all sections. */
2486 if (entry
->flags
.just_syms
)
2488 bfd_link_just_syms (abfd
, sec
, &link_info
);
2492 /* Deal with SHF_EXCLUDE ELF sections. */
2493 if (!bfd_link_relocatable (&link_info
)
2494 && (abfd
->flags
& BFD_PLUGIN
) == 0
2495 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2496 sec
->output_section
= bfd_abs_section_ptr
;
2498 if (!(abfd
->flags
& DYNAMIC
))
2499 bfd_section_already_linked (abfd
, sec
, &link_info
);
2503 /* Returns true if SECTION is one we know will be discarded based on its
2504 section flags, otherwise returns false. */
2507 lang_discard_section_p (asection
*section
)
2509 bfd_boolean discard
;
2510 flagword flags
= section
->flags
;
2512 /* Discard sections marked with SEC_EXCLUDE. */
2513 discard
= (flags
& SEC_EXCLUDE
) != 0;
2515 /* Discard the group descriptor sections when we're finally placing the
2516 sections from within the group. */
2517 if ((flags
& SEC_GROUP
) != 0
2518 && link_info
.resolve_section_groups
)
2521 /* Discard debugging sections if we are stripping debugging
2523 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2524 && (flags
& SEC_DEBUGGING
) != 0)
2530 /* The wild routines.
2532 These expand statements like *(.text) and foo.o to a list of
2533 explicit actions, like foo.o(.text), bar.o(.text) and
2534 foo.o(.text, .data). */
2536 /* Add SECTION to the output section OUTPUT. Do this by creating a
2537 lang_input_section statement which is placed at PTR. */
2540 lang_add_section (lang_statement_list_type
*ptr
,
2542 struct flag_info
*sflag_info
,
2543 lang_output_section_statement_type
*output
)
2545 flagword flags
= section
->flags
;
2547 bfd_boolean discard
;
2548 lang_input_section_type
*new_section
;
2549 bfd
*abfd
= link_info
.output_bfd
;
2551 /* Is this section one we know should be discarded? */
2552 discard
= lang_discard_section_p (section
);
2554 /* Discard input sections which are assigned to a section named
2555 DISCARD_SECTION_NAME. */
2556 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2561 if (section
->output_section
== NULL
)
2563 /* This prevents future calls from assigning this section. */
2564 section
->output_section
= bfd_abs_section_ptr
;
2566 else if (link_info
.non_contiguous_regions_warnings
)
2567 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2568 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2569 NULL
, section
, section
->owner
);
2578 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2583 if (section
->output_section
!= NULL
)
2585 if (!link_info
.non_contiguous_regions
)
2588 /* SECTION has already been handled in a special way
2589 (eg. LINK_ONCE): skip it. */
2590 if (bfd_is_abs_section (section
->output_section
))
2593 /* Already assigned to the same output section, do not process
2594 it again, to avoid creating loops between duplicate sections
2596 if (section
->output_section
== output
->bfd_section
)
2599 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2600 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2601 "change behaviour for section `%pA' from '%pB' (assigned to "
2602 "%pA, but additional match: %pA)\n"),
2603 NULL
, section
, section
->owner
, section
->output_section
,
2604 output
->bfd_section
);
2606 /* SECTION has already been assigned to an output section, but
2607 the user allows it to be mapped to another one in case it
2608 overflows. We'll later update the actual output section in
2609 size_input_section as appropriate. */
2612 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2613 to an output section, because we want to be able to include a
2614 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2615 section (I don't know why we want to do this, but we do).
2616 build_link_order in ldwrite.c handles this case by turning
2617 the embedded SEC_NEVER_LOAD section into a fill. */
2618 flags
&= ~ SEC_NEVER_LOAD
;
2620 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2621 already been processed. One reason to do this is that on pe
2622 format targets, .text$foo sections go into .text and it's odd
2623 to see .text with SEC_LINK_ONCE set. */
2624 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2626 if (link_info
.resolve_section_groups
)
2627 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2629 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2631 else if (!bfd_link_relocatable (&link_info
))
2632 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2634 switch (output
->sectype
)
2636 case normal_section
:
2637 case overlay_section
:
2638 case first_overlay_section
:
2640 case noalloc_section
:
2641 flags
&= ~SEC_ALLOC
;
2643 case noload_section
:
2645 flags
|= SEC_NEVER_LOAD
;
2646 /* Unfortunately GNU ld has managed to evolve two different
2647 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2648 alloc, no contents section. All others get a noload, noalloc
2650 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2651 flags
&= ~SEC_HAS_CONTENTS
;
2653 flags
&= ~SEC_ALLOC
;
2657 if (output
->bfd_section
== NULL
)
2658 init_os (output
, flags
);
2660 /* If SEC_READONLY is not set in the input section, then clear
2661 it from the output section. */
2662 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2664 if (output
->bfd_section
->linker_has_input
)
2666 /* Only set SEC_READONLY flag on the first input section. */
2667 flags
&= ~ SEC_READONLY
;
2669 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2670 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2671 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2672 || ((flags
& SEC_MERGE
) != 0
2673 && output
->bfd_section
->entsize
!= section
->entsize
))
2675 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2676 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2679 output
->bfd_section
->flags
|= flags
;
2681 if (!output
->bfd_section
->linker_has_input
)
2683 output
->bfd_section
->linker_has_input
= 1;
2684 /* This must happen after flags have been updated. The output
2685 section may have been created before we saw its first input
2686 section, eg. for a data statement. */
2687 bfd_init_private_section_data (section
->owner
, section
,
2688 link_info
.output_bfd
,
2689 output
->bfd_section
,
2691 if ((flags
& SEC_MERGE
) != 0)
2692 output
->bfd_section
->entsize
= section
->entsize
;
2695 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2696 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2698 /* FIXME: This value should really be obtained from the bfd... */
2699 output
->block_value
= 128;
2702 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2703 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2705 section
->output_section
= output
->bfd_section
;
2707 if (!map_head_is_link_order
)
2709 asection
*s
= output
->bfd_section
->map_tail
.s
;
2710 output
->bfd_section
->map_tail
.s
= section
;
2711 section
->map_head
.s
= NULL
;
2712 section
->map_tail
.s
= s
;
2714 s
->map_head
.s
= section
;
2716 output
->bfd_section
->map_head
.s
= section
;
2719 /* Add a section reference to the list. */
2720 new_section
= new_stat (lang_input_section
, ptr
);
2721 new_section
->section
= section
;
2724 /* Handle wildcard sorting. This returns the lang_input_section which
2725 should follow the one we are going to create for SECTION and FILE,
2726 based on the sorting requirements of WILD. It returns NULL if the
2727 new section should just go at the end of the current list. */
2729 static lang_statement_union_type
*
2730 wild_sort (lang_wild_statement_type
*wild
,
2731 struct wildcard_list
*sec
,
2732 lang_input_statement_type
*file
,
2735 lang_statement_union_type
*l
;
2737 if (!wild
->filenames_sorted
2738 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2741 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2743 lang_input_section_type
*ls
;
2745 if (l
->header
.type
!= lang_input_section_enum
)
2747 ls
= &l
->input_section
;
2749 /* Sorting by filename takes precedence over sorting by section
2752 if (wild
->filenames_sorted
)
2754 const char *fn
, *ln
;
2758 /* The PE support for the .idata section as generated by
2759 dlltool assumes that files will be sorted by the name of
2760 the archive and then the name of the file within the
2763 if (file
->the_bfd
!= NULL
2764 && file
->the_bfd
->my_archive
!= NULL
)
2766 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2771 fn
= file
->filename
;
2775 if (ls
->section
->owner
->my_archive
!= NULL
)
2777 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2782 ln
= bfd_get_filename (ls
->section
->owner
);
2786 i
= filename_cmp (fn
, ln
);
2795 fn
= file
->filename
;
2797 ln
= bfd_get_filename (ls
->section
->owner
);
2799 i
= filename_cmp (fn
, ln
);
2807 /* Here either the files are not sorted by name, or we are
2808 looking at the sections for this file. */
2811 && sec
->spec
.sorted
!= none
2812 && sec
->spec
.sorted
!= by_none
)
2813 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2820 /* Expand a wild statement for a particular FILE. SECTION may be
2821 NULL, in which case it is a wild card. */
2824 output_section_callback (lang_wild_statement_type
*ptr
,
2825 struct wildcard_list
*sec
,
2827 struct flag_info
*sflag_info
,
2828 lang_input_statement_type
*file
,
2831 lang_statement_union_type
*before
;
2832 lang_output_section_statement_type
*os
;
2834 os
= (lang_output_section_statement_type
*) output
;
2836 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2837 if (unique_section_p (section
, os
))
2840 before
= wild_sort (ptr
, sec
, file
, section
);
2842 /* Here BEFORE points to the lang_input_section which
2843 should follow the one we are about to add. If BEFORE
2844 is NULL, then the section should just go at the end
2845 of the current list. */
2848 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2851 lang_statement_list_type list
;
2852 lang_statement_union_type
**pp
;
2854 lang_list_init (&list
);
2855 lang_add_section (&list
, section
, sflag_info
, os
);
2857 /* If we are discarding the section, LIST.HEAD will
2859 if (list
.head
!= NULL
)
2861 ASSERT (list
.head
->header
.next
== NULL
);
2863 for (pp
= &ptr
->children
.head
;
2865 pp
= &(*pp
)->header
.next
)
2866 ASSERT (*pp
!= NULL
);
2868 list
.head
->header
.next
= *pp
;
2874 /* Check if all sections in a wild statement for a particular FILE
2878 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2879 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2881 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2882 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2885 lang_output_section_statement_type
*os
;
2887 os
= (lang_output_section_statement_type
*) output
;
2889 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2890 if (unique_section_p (section
, os
))
2893 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2894 os
->all_input_readonly
= FALSE
;
2897 /* This is passed a file name which must have been seen already and
2898 added to the statement tree. We will see if it has been opened
2899 already and had its symbols read. If not then we'll read it. */
2901 static lang_input_statement_type
*
2902 lookup_name (const char *name
)
2904 lang_input_statement_type
*search
;
2906 for (search
= (void *) input_file_chain
.head
;
2908 search
= search
->next_real_file
)
2910 /* Use the local_sym_name as the name of the file that has
2911 already been loaded as filename might have been transformed
2912 via the search directory lookup mechanism. */
2913 const char *filename
= search
->local_sym_name
;
2915 if (filename
!= NULL
2916 && filename_cmp (filename
, name
) == 0)
2922 /* Arrange to splice the input statement added by new_afile into
2923 statement_list after the current input_file_chain tail.
2924 We know input_file_chain is not an empty list, and that
2925 lookup_name was called via open_input_bfds. Later calls to
2926 lookup_name should always match an existing input_statement. */
2927 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2928 lang_statement_union_type
**after
2929 = (void *) ((char *) input_file_chain
.tail
2930 - offsetof (lang_input_statement_type
, next_real_file
)
2931 + offsetof (lang_input_statement_type
, header
.next
));
2932 lang_statement_union_type
*rest
= *after
;
2933 stat_ptr
->tail
= after
;
2934 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2935 default_target
, NULL
);
2936 *stat_ptr
->tail
= rest
;
2938 stat_ptr
->tail
= tail
;
2941 /* If we have already added this file, or this file is not real
2942 don't add this file. */
2943 if (search
->flags
.loaded
|| !search
->flags
.real
)
2946 if (!load_symbols (search
, NULL
))
2952 /* Save LIST as a list of libraries whose symbols should not be exported. */
2957 struct excluded_lib
*next
;
2959 static struct excluded_lib
*excluded_libs
;
2962 add_excluded_libs (const char *list
)
2964 const char *p
= list
, *end
;
2968 struct excluded_lib
*entry
;
2969 end
= strpbrk (p
, ",:");
2971 end
= p
+ strlen (p
);
2972 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2973 entry
->next
= excluded_libs
;
2974 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2975 memcpy (entry
->name
, p
, end
- p
);
2976 entry
->name
[end
- p
] = '\0';
2977 excluded_libs
= entry
;
2985 check_excluded_libs (bfd
*abfd
)
2987 struct excluded_lib
*lib
= excluded_libs
;
2991 int len
= strlen (lib
->name
);
2992 const char *filename
= lbasename (bfd_get_filename (abfd
));
2994 if (strcmp (lib
->name
, "ALL") == 0)
2996 abfd
->no_export
= TRUE
;
3000 if (filename_ncmp (lib
->name
, filename
, len
) == 0
3001 && (filename
[len
] == '\0'
3002 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3003 && filename
[len
+ 2] == '\0')))
3005 abfd
->no_export
= TRUE
;
3013 /* Get the symbols for an input file. */
3016 load_symbols (lang_input_statement_type
*entry
,
3017 lang_statement_list_type
*place
)
3021 if (entry
->flags
.loaded
)
3024 ldfile_open_file (entry
);
3026 /* Do not process further if the file was missing. */
3027 if (entry
->flags
.missing_file
)
3030 if (trace_files
|| verbose
)
3031 info_msg ("%pI\n", entry
);
3033 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3034 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3037 struct lang_input_statement_flags save_flags
;
3040 err
= bfd_get_error ();
3042 /* See if the emulation has some special knowledge. */
3043 if (ldemul_unrecognized_file (entry
))
3046 if (err
== bfd_error_file_ambiguously_recognized
)
3050 einfo (_("%P: %pB: file not recognized: %E;"
3051 " matching formats:"), entry
->the_bfd
);
3052 for (p
= matching
; *p
!= NULL
; p
++)
3056 else if (err
!= bfd_error_file_not_recognized
3058 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3060 bfd_close (entry
->the_bfd
);
3061 entry
->the_bfd
= NULL
;
3063 /* Try to interpret the file as a linker script. */
3064 save_flags
= input_flags
;
3065 ldfile_open_command_file (entry
->filename
);
3067 push_stat_ptr (place
);
3068 input_flags
.add_DT_NEEDED_for_regular
3069 = entry
->flags
.add_DT_NEEDED_for_regular
;
3070 input_flags
.add_DT_NEEDED_for_dynamic
3071 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3072 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3073 input_flags
.dynamic
= entry
->flags
.dynamic
;
3075 ldfile_assumed_script
= TRUE
;
3076 parser_input
= input_script
;
3077 current_input_file
= entry
->filename
;
3079 current_input_file
= NULL
;
3080 ldfile_assumed_script
= FALSE
;
3082 /* missing_file is sticky. sysrooted will already have been
3083 restored when seeing EOF in yyparse, but no harm to restore
3085 save_flags
.missing_file
|= input_flags
.missing_file
;
3086 input_flags
= save_flags
;
3090 entry
->flags
.loaded
= TRUE
;
3095 if (ldemul_recognized_file (entry
))
3098 /* We don't call ldlang_add_file for an archive. Instead, the
3099 add_symbols entry point will call ldlang_add_file, via the
3100 add_archive_element callback, for each element of the archive
3102 switch (bfd_get_format (entry
->the_bfd
))
3108 if (!entry
->flags
.reload
)
3109 ldlang_add_file (entry
);
3113 check_excluded_libs (entry
->the_bfd
);
3115 bfd_set_usrdata (entry
->the_bfd
, entry
);
3116 if (entry
->flags
.whole_archive
)
3119 bfd_boolean loaded
= TRUE
;
3124 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3129 if (!bfd_check_format (member
, bfd_object
))
3131 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3132 entry
->the_bfd
, member
);
3137 if (!(*link_info
.callbacks
3138 ->add_archive_element
) (&link_info
, member
,
3139 "--whole-archive", &subsbfd
))
3142 /* Potentially, the add_archive_element hook may have set a
3143 substitute BFD for us. */
3144 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3146 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3151 entry
->flags
.loaded
= loaded
;
3157 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3158 entry
->flags
.loaded
= TRUE
;
3160 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3162 return entry
->flags
.loaded
;
3165 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3166 may be NULL, indicating that it is a wildcard. Separate
3167 lang_input_section statements are created for each part of the
3168 expansion; they are added after the wild statement S. OUTPUT is
3169 the output section. */
3172 wild (lang_wild_statement_type
*s
,
3173 const char *target ATTRIBUTE_UNUSED
,
3174 lang_output_section_statement_type
*output
)
3176 struct wildcard_list
*sec
;
3178 if (s
->handler_data
[0]
3179 && s
->handler_data
[0]->spec
.sorted
== by_name
3180 && !s
->filenames_sorted
)
3182 lang_section_bst_type
*tree
;
3184 walk_wild (s
, output_section_callback_fast
, output
);
3189 output_section_callback_tree_to_list (s
, tree
, output
);
3194 walk_wild (s
, output_section_callback
, output
);
3196 if (default_common_section
== NULL
)
3197 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3198 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3200 /* Remember the section that common is going to in case we
3201 later get something which doesn't know where to put it. */
3202 default_common_section
= output
;
3207 /* Return TRUE iff target is the sought target. */
3210 get_target (const bfd_target
*target
, void *data
)
3212 const char *sought
= (const char *) data
;
3214 return strcmp (target
->name
, sought
) == 0;
3217 /* Like strcpy() but convert to lower case as well. */
3220 stricpy (char *dest
, const char *src
)
3224 while ((c
= *src
++) != 0)
3225 *dest
++ = TOLOWER (c
);
3230 /* Remove the first occurrence of needle (if any) in haystack
3234 strcut (char *haystack
, const char *needle
)
3236 haystack
= strstr (haystack
, needle
);
3242 for (src
= haystack
+ strlen (needle
); *src
;)
3243 *haystack
++ = *src
++;
3249 /* Compare two target format name strings.
3250 Return a value indicating how "similar" they are. */
3253 name_compare (const char *first
, const char *second
)
3259 copy1
= (char *) xmalloc (strlen (first
) + 1);
3260 copy2
= (char *) xmalloc (strlen (second
) + 1);
3262 /* Convert the names to lower case. */
3263 stricpy (copy1
, first
);
3264 stricpy (copy2
, second
);
3266 /* Remove size and endian strings from the name. */
3267 strcut (copy1
, "big");
3268 strcut (copy1
, "little");
3269 strcut (copy2
, "big");
3270 strcut (copy2
, "little");
3272 /* Return a value based on how many characters match,
3273 starting from the beginning. If both strings are
3274 the same then return 10 * their length. */
3275 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3276 if (copy1
[result
] == 0)
3288 /* Set by closest_target_match() below. */
3289 static const bfd_target
*winner
;
3291 /* Scan all the valid bfd targets looking for one that has the endianness
3292 requirement that was specified on the command line, and is the nearest
3293 match to the original output target. */
3296 closest_target_match (const bfd_target
*target
, void *data
)
3298 const bfd_target
*original
= (const bfd_target
*) data
;
3300 if (command_line
.endian
== ENDIAN_BIG
3301 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3304 if (command_line
.endian
== ENDIAN_LITTLE
3305 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3308 /* Must be the same flavour. */
3309 if (target
->flavour
!= original
->flavour
)
3312 /* Ignore generic big and little endian elf vectors. */
3313 if (strcmp (target
->name
, "elf32-big") == 0
3314 || strcmp (target
->name
, "elf64-big") == 0
3315 || strcmp (target
->name
, "elf32-little") == 0
3316 || strcmp (target
->name
, "elf64-little") == 0)
3319 /* If we have not found a potential winner yet, then record this one. */
3326 /* Oh dear, we now have two potential candidates for a successful match.
3327 Compare their names and choose the better one. */
3328 if (name_compare (target
->name
, original
->name
)
3329 > name_compare (winner
->name
, original
->name
))
3332 /* Keep on searching until wqe have checked them all. */
3336 /* Return the BFD target format of the first input file. */
3339 get_first_input_target (void)
3341 const char *target
= NULL
;
3343 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3345 if (s
->header
.type
== lang_input_statement_enum
3348 ldfile_open_file (s
);
3350 if (s
->the_bfd
!= NULL
3351 && bfd_check_format (s
->the_bfd
, bfd_object
))
3353 target
= bfd_get_target (s
->the_bfd
);
3365 lang_get_output_target (void)
3369 /* Has the user told us which output format to use? */
3370 if (output_target
!= NULL
)
3371 return output_target
;
3373 /* No - has the current target been set to something other than
3375 if (current_target
!= default_target
&& current_target
!= NULL
)
3376 return current_target
;
3378 /* No - can we determine the format of the first input file? */
3379 target
= get_first_input_target ();
3383 /* Failed - use the default output target. */
3384 return default_target
;
3387 /* Open the output file. */
3390 open_output (const char *name
)
3392 output_target
= lang_get_output_target ();
3394 /* Has the user requested a particular endianness on the command
3396 if (command_line
.endian
!= ENDIAN_UNSET
)
3398 /* Get the chosen target. */
3399 const bfd_target
*target
3400 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3402 /* If the target is not supported, we cannot do anything. */
3405 enum bfd_endian desired_endian
;
3407 if (command_line
.endian
== ENDIAN_BIG
)
3408 desired_endian
= BFD_ENDIAN_BIG
;
3410 desired_endian
= BFD_ENDIAN_LITTLE
;
3412 /* See if the target has the wrong endianness. This should
3413 not happen if the linker script has provided big and
3414 little endian alternatives, but some scrips don't do
3416 if (target
->byteorder
!= desired_endian
)
3418 /* If it does, then see if the target provides
3419 an alternative with the correct endianness. */
3420 if (target
->alternative_target
!= NULL
3421 && (target
->alternative_target
->byteorder
== desired_endian
))
3422 output_target
= target
->alternative_target
->name
;
3425 /* Try to find a target as similar as possible to
3426 the default target, but which has the desired
3427 endian characteristic. */
3428 bfd_iterate_over_targets (closest_target_match
,
3431 /* Oh dear - we could not find any targets that
3432 satisfy our requirements. */
3434 einfo (_("%P: warning: could not find any targets"
3435 " that match endianness requirement\n"));
3437 output_target
= winner
->name
;
3443 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3445 if (link_info
.output_bfd
== NULL
)
3447 if (bfd_get_error () == bfd_error_invalid_target
)
3448 einfo (_("%F%P: target %s not found\n"), output_target
);
3450 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3453 delete_output_file_on_failure
= TRUE
;
3455 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3456 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3457 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3458 ldfile_output_architecture
,
3459 ldfile_output_machine
))
3460 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3462 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3463 if (link_info
.hash
== NULL
)
3464 einfo (_("%F%P: can not create hash table: %E\n"));
3466 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3470 ldlang_open_output (lang_statement_union_type
*statement
)
3472 switch (statement
->header
.type
)
3474 case lang_output_statement_enum
:
3475 ASSERT (link_info
.output_bfd
== NULL
);
3476 open_output (statement
->output_statement
.name
);
3477 ldemul_set_output_arch ();
3478 if (config
.magic_demand_paged
3479 && !bfd_link_relocatable (&link_info
))
3480 link_info
.output_bfd
->flags
|= D_PAGED
;
3482 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3483 if (config
.text_read_only
)
3484 link_info
.output_bfd
->flags
|= WP_TEXT
;
3486 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3487 if (link_info
.traditional_format
)
3488 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3490 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3493 case lang_target_statement_enum
:
3494 current_target
= statement
->target_statement
.target
;
3502 init_opb (asection
*s
)
3507 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3509 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3512 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3513 ldfile_output_machine
);
3515 while ((x
& 1) == 0)
3523 /* Open all the input files. */
3527 OPEN_BFD_NORMAL
= 0,
3531 #if BFD_SUPPORTS_PLUGINS
3532 static lang_input_statement_type
*plugin_insert
= NULL
;
3533 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3537 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3539 for (; s
!= NULL
; s
= s
->header
.next
)
3541 switch (s
->header
.type
)
3543 case lang_constructors_statement_enum
:
3544 open_input_bfds (constructor_list
.head
, mode
);
3546 case lang_output_section_statement_enum
:
3547 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3549 case lang_wild_statement_enum
:
3550 /* Maybe we should load the file's symbols. */
3551 if ((mode
& OPEN_BFD_RESCAN
) == 0
3552 && s
->wild_statement
.filename
3553 && !wildcardp (s
->wild_statement
.filename
)
3554 && !archive_path (s
->wild_statement
.filename
))
3555 lookup_name (s
->wild_statement
.filename
);
3556 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3558 case lang_group_statement_enum
:
3560 struct bfd_link_hash_entry
*undefs
;
3561 #if BFD_SUPPORTS_PLUGINS
3562 lang_input_statement_type
*plugin_insert_save
;
3565 /* We must continually search the entries in the group
3566 until no new symbols are added to the list of undefined
3571 #if BFD_SUPPORTS_PLUGINS
3572 plugin_insert_save
= plugin_insert
;
3574 undefs
= link_info
.hash
->undefs_tail
;
3575 open_input_bfds (s
->group_statement
.children
.head
,
3576 mode
| OPEN_BFD_FORCE
);
3578 while (undefs
!= link_info
.hash
->undefs_tail
3579 #if BFD_SUPPORTS_PLUGINS
3580 /* Objects inserted by a plugin, which are loaded
3581 before we hit this loop, may have added new
3583 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3588 case lang_target_statement_enum
:
3589 current_target
= s
->target_statement
.target
;
3591 case lang_input_statement_enum
:
3592 if (s
->input_statement
.flags
.real
)
3594 lang_statement_union_type
**os_tail
;
3595 lang_statement_list_type add
;
3598 s
->input_statement
.target
= current_target
;
3600 /* If we are being called from within a group, and this
3601 is an archive which has already been searched, then
3602 force it to be researched unless the whole archive
3603 has been loaded already. Do the same for a rescan.
3604 Likewise reload --as-needed shared libs. */
3605 if (mode
!= OPEN_BFD_NORMAL
3606 #if BFD_SUPPORTS_PLUGINS
3607 && ((mode
& OPEN_BFD_RESCAN
) == 0
3608 || plugin_insert
== NULL
)
3610 && s
->input_statement
.flags
.loaded
3611 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3612 && ((bfd_get_format (abfd
) == bfd_archive
3613 && !s
->input_statement
.flags
.whole_archive
)
3614 || (bfd_get_format (abfd
) == bfd_object
3615 && ((abfd
->flags
) & DYNAMIC
) != 0
3616 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3617 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3618 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3620 s
->input_statement
.flags
.loaded
= FALSE
;
3621 s
->input_statement
.flags
.reload
= TRUE
;
3624 os_tail
= lang_os_list
.tail
;
3625 lang_list_init (&add
);
3627 if (!load_symbols (&s
->input_statement
, &add
))
3628 config
.make_executable
= FALSE
;
3630 if (add
.head
!= NULL
)
3632 /* If this was a script with output sections then
3633 tack any added statements on to the end of the
3634 list. This avoids having to reorder the output
3635 section statement list. Very likely the user
3636 forgot -T, and whatever we do here will not meet
3637 naive user expectations. */
3638 if (os_tail
!= lang_os_list
.tail
)
3640 einfo (_("%P: warning: %s contains output sections;"
3641 " did you forget -T?\n"),
3642 s
->input_statement
.filename
);
3643 *stat_ptr
->tail
= add
.head
;
3644 stat_ptr
->tail
= add
.tail
;
3648 *add
.tail
= s
->header
.next
;
3649 s
->header
.next
= add
.head
;
3653 #if BFD_SUPPORTS_PLUGINS
3654 /* If we have found the point at which a plugin added new
3655 files, clear plugin_insert to enable archive rescan. */
3656 if (&s
->input_statement
== plugin_insert
)
3657 plugin_insert
= NULL
;
3660 case lang_assignment_statement_enum
:
3661 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3662 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3669 /* Exit if any of the files were missing. */
3670 if (input_flags
.missing_file
)
3674 #ifdef ENABLE_LIBCTF
3675 /* Open the CTF sections in the input files with libctf: if any were opened,
3676 create a fake input file that we'll write the merged CTF data to later
3680 ldlang_open_ctf (void)
3685 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3689 /* Incoming files from the compiler have a single ctf_file_t in them
3690 (which is presented to us by the libctf API in a ctf_archive_t
3691 wrapper): files derived from a previous relocatable link have a CTF
3692 archive containing possibly many CTF files. */
3694 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3696 if (err
!= ECTF_NOCTFDATA
)
3697 einfo (_("%P: warning: CTF section in `%pI' not loaded: "
3698 "its types will be discarded: `%s'\n"), file
,
3703 /* Prevent the contents of this section from being written, while
3704 requiring the section itself to be duplicated in the output. */
3705 /* This section must exist if ctf_bfdopen() succeeded. */
3706 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3708 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3719 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3722 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3725 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3726 ctf_close (errfile
->the_ctf
);
3729 /* Merge together CTF sections. After this, only the symtab-dependent
3730 function and data object sections need adjustment. */
3733 lang_merge_ctf (void)
3735 asection
*output_sect
;
3740 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3742 /* If the section was discarded, don't waste time merging. */
3743 if (output_sect
== NULL
)
3745 ctf_file_close (ctf_output
);
3748 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3750 ctf_close (file
->the_ctf
);
3751 file
->the_ctf
= NULL
;
3756 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3761 /* Takes ownership of file->u.the_ctfa. */
3762 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3764 einfo (_("%F%P: cannot link with CTF in %pB: %s\n"), file
->the_bfd
,
3765 ctf_errmsg (ctf_errno (ctf_output
)));
3766 ctf_close (file
->the_ctf
);
3767 file
->the_ctf
= NULL
;
3772 if (ctf_link (ctf_output
, CTF_LINK_SHARE_UNCONFLICTED
) < 0)
3774 einfo (_("%F%P: CTF linking failed; output will have no CTF section: %s\n"),
3775 ctf_errmsg (ctf_errno (ctf_output
)));
3778 output_sect
->size
= 0;
3779 output_sect
->flags
|= SEC_EXCLUDE
;
3784 /* Let the emulation examine the symbol table and strtab to help it optimize the
3785 CTF, if supported. */
3788 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms
, bfd_size_type symcount
,
3789 struct elf_strtab_hash
*symstrtab
)
3791 ldemul_examine_strtab_for_ctf (ctf_output
, syms
, symcount
, symstrtab
);
3794 /* Write out the CTF section. Called early, if the emulation isn't going to
3795 need to dedup against the strtab and symtab, then possibly called from the
3796 target linker code if the dedup has happened. */
3798 lang_write_ctf (int late
)
3801 asection
*output_sect
;
3808 /* Emit CTF late if this emulation says it can do so. */
3809 if (ldemul_emit_ctf_early ())
3814 if (!ldemul_emit_ctf_early ())
3820 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3823 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3824 CTF_COMPRESSION_THRESHOLD
);
3825 output_sect
->size
= output_size
;
3826 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3828 if (!output_sect
->contents
)
3830 einfo (_("%F%P: CTF section emission failed; output will have no "
3831 "CTF section: %s\n"), ctf_errmsg (ctf_errno (ctf_output
)));
3832 output_sect
->size
= 0;
3833 output_sect
->flags
|= SEC_EXCLUDE
;
3837 /* This also closes every CTF input file used in the link. */
3838 ctf_file_close (ctf_output
);
3841 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3842 file
->the_ctf
= NULL
;
3845 /* Write out the CTF section late, if the emulation needs that. */
3848 ldlang_write_ctf_late (void)
3850 /* Trigger a "late call", if the emulation needs one. */
3856 ldlang_open_ctf (void)
3858 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3862 /* If built without CTF, warn and delete all CTF sections from the output.
3863 (The alternative would be to simply concatenate them, which does not
3864 yield a valid CTF section.) */
3866 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3868 einfo (_("%P: warning: CTF section in `%pI' not linkable: "
3869 "%P was built without support for CTF\n"), file
);
3871 sect
->flags
|= SEC_EXCLUDE
;
3876 static void lang_merge_ctf (void) {}
3878 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms ATTRIBUTE_UNUSED
,
3879 bfd_size_type symcount ATTRIBUTE_UNUSED
,
3880 struct elf_strtab_hash
*symstrtab ATTRIBUTE_UNUSED
)
3883 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3884 void ldlang_write_ctf_late (void) {}
3887 /* Add the supplied name to the symbol table as an undefined reference.
3888 This is a two step process as the symbol table doesn't even exist at
3889 the time the ld command line is processed. First we put the name
3890 on a list, then, once the output file has been opened, transfer the
3891 name to the symbol table. */
3893 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3895 #define ldlang_undef_chain_list_head entry_symbol.next
3898 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3900 ldlang_undef_chain_list_type
*new_undef
;
3902 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3903 new_undef
= stat_alloc (sizeof (*new_undef
));
3904 new_undef
->next
= ldlang_undef_chain_list_head
;
3905 ldlang_undef_chain_list_head
= new_undef
;
3907 new_undef
->name
= xstrdup (name
);
3909 if (link_info
.output_bfd
!= NULL
)
3910 insert_undefined (new_undef
->name
);
3913 /* Insert NAME as undefined in the symbol table. */
3916 insert_undefined (const char *name
)
3918 struct bfd_link_hash_entry
*h
;
3920 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3922 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3923 if (h
->type
== bfd_link_hash_new
)
3925 h
->type
= bfd_link_hash_undefined
;
3926 h
->u
.undef
.abfd
= NULL
;
3927 h
->non_ir_ref_regular
= TRUE
;
3928 if (is_elf_hash_table (link_info
.hash
))
3929 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3930 bfd_link_add_undef (link_info
.hash
, h
);
3934 /* Run through the list of undefineds created above and place them
3935 into the linker hash table as undefined symbols belonging to the
3939 lang_place_undefineds (void)
3941 ldlang_undef_chain_list_type
*ptr
;
3943 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3944 insert_undefined (ptr
->name
);
3947 /* Structure used to build the list of symbols that the user has required
3950 struct require_defined_symbol
3953 struct require_defined_symbol
*next
;
3956 /* The list of symbols that the user has required be defined. */
3958 static struct require_defined_symbol
*require_defined_symbol_list
;
3960 /* Add a new symbol NAME to the list of symbols that are required to be
3964 ldlang_add_require_defined (const char *const name
)
3966 struct require_defined_symbol
*ptr
;
3968 ldlang_add_undef (name
, TRUE
);
3969 ptr
= stat_alloc (sizeof (*ptr
));
3970 ptr
->next
= require_defined_symbol_list
;
3971 ptr
->name
= strdup (name
);
3972 require_defined_symbol_list
= ptr
;
3975 /* Check that all symbols the user required to be defined, are defined,
3976 raise an error if we find a symbol that is not defined. */
3979 ldlang_check_require_defined_symbols (void)
3981 struct require_defined_symbol
*ptr
;
3983 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3985 struct bfd_link_hash_entry
*h
;
3987 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3988 FALSE
, FALSE
, TRUE
);
3990 || (h
->type
!= bfd_link_hash_defined
3991 && h
->type
!= bfd_link_hash_defweak
))
3992 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3996 /* Check for all readonly or some readwrite sections. */
3999 check_input_sections
4000 (lang_statement_union_type
*s
,
4001 lang_output_section_statement_type
*output_section_statement
)
4003 for (; s
!= NULL
; s
= s
->header
.next
)
4005 switch (s
->header
.type
)
4007 case lang_wild_statement_enum
:
4008 walk_wild (&s
->wild_statement
, check_section_callback
,
4009 output_section_statement
);
4010 if (!output_section_statement
->all_input_readonly
)
4013 case lang_constructors_statement_enum
:
4014 check_input_sections (constructor_list
.head
,
4015 output_section_statement
);
4016 if (!output_section_statement
->all_input_readonly
)
4019 case lang_group_statement_enum
:
4020 check_input_sections (s
->group_statement
.children
.head
,
4021 output_section_statement
);
4022 if (!output_section_statement
->all_input_readonly
)
4031 /* Update wildcard statements if needed. */
4034 update_wild_statements (lang_statement_union_type
*s
)
4036 struct wildcard_list
*sec
;
4038 switch (sort_section
)
4048 for (; s
!= NULL
; s
= s
->header
.next
)
4050 switch (s
->header
.type
)
4055 case lang_wild_statement_enum
:
4056 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4058 /* Don't sort .init/.fini sections. */
4059 if (strcmp (sec
->spec
.name
, ".init") != 0
4060 && strcmp (sec
->spec
.name
, ".fini") != 0)
4061 switch (sec
->spec
.sorted
)
4064 sec
->spec
.sorted
= sort_section
;
4067 if (sort_section
== by_alignment
)
4068 sec
->spec
.sorted
= by_name_alignment
;
4071 if (sort_section
== by_name
)
4072 sec
->spec
.sorted
= by_alignment_name
;
4079 case lang_constructors_statement_enum
:
4080 update_wild_statements (constructor_list
.head
);
4083 case lang_output_section_statement_enum
:
4084 update_wild_statements
4085 (s
->output_section_statement
.children
.head
);
4088 case lang_group_statement_enum
:
4089 update_wild_statements (s
->group_statement
.children
.head
);
4097 /* Open input files and attach to output sections. */
4100 map_input_to_output_sections
4101 (lang_statement_union_type
*s
, const char *target
,
4102 lang_output_section_statement_type
*os
)
4104 for (; s
!= NULL
; s
= s
->header
.next
)
4106 lang_output_section_statement_type
*tos
;
4109 switch (s
->header
.type
)
4111 case lang_wild_statement_enum
:
4112 wild (&s
->wild_statement
, target
, os
);
4114 case lang_constructors_statement_enum
:
4115 map_input_to_output_sections (constructor_list
.head
,
4119 case lang_output_section_statement_enum
:
4120 tos
= &s
->output_section_statement
;
4121 if (tos
->constraint
!= 0)
4123 if (tos
->constraint
!= ONLY_IF_RW
4124 && tos
->constraint
!= ONLY_IF_RO
)
4126 tos
->all_input_readonly
= TRUE
;
4127 check_input_sections (tos
->children
.head
, tos
);
4128 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4130 tos
->constraint
= -1;
4134 map_input_to_output_sections (tos
->children
.head
,
4138 case lang_output_statement_enum
:
4140 case lang_target_statement_enum
:
4141 target
= s
->target_statement
.target
;
4143 case lang_group_statement_enum
:
4144 map_input_to_output_sections (s
->group_statement
.children
.head
,
4148 case lang_data_statement_enum
:
4149 /* Make sure that any sections mentioned in the expression
4151 exp_init_os (s
->data_statement
.exp
);
4152 /* The output section gets CONTENTS, ALLOC and LOAD, but
4153 these may be overridden by the script. */
4154 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4155 switch (os
->sectype
)
4157 case normal_section
:
4158 case overlay_section
:
4159 case first_overlay_section
:
4161 case noalloc_section
:
4162 flags
= SEC_HAS_CONTENTS
;
4164 case noload_section
:
4165 if (bfd_get_flavour (link_info
.output_bfd
)
4166 == bfd_target_elf_flavour
)
4167 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4169 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4172 if (os
->bfd_section
== NULL
)
4173 init_os (os
, flags
);
4175 os
->bfd_section
->flags
|= flags
;
4177 case lang_input_section_enum
:
4179 case lang_fill_statement_enum
:
4180 case lang_object_symbols_statement_enum
:
4181 case lang_reloc_statement_enum
:
4182 case lang_padding_statement_enum
:
4183 case lang_input_statement_enum
:
4184 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4187 case lang_assignment_statement_enum
:
4188 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4191 /* Make sure that any sections mentioned in the assignment
4193 exp_init_os (s
->assignment_statement
.exp
);
4195 case lang_address_statement_enum
:
4196 /* Mark the specified section with the supplied address.
4197 If this section was actually a segment marker, then the
4198 directive is ignored if the linker script explicitly
4199 processed the segment marker. Originally, the linker
4200 treated segment directives (like -Ttext on the
4201 command-line) as section directives. We honor the
4202 section directive semantics for backwards compatibility;
4203 linker scripts that do not specifically check for
4204 SEGMENT_START automatically get the old semantics. */
4205 if (!s
->address_statement
.segment
4206 || !s
->address_statement
.segment
->used
)
4208 const char *name
= s
->address_statement
.section_name
;
4210 /* Create the output section statement here so that
4211 orphans with a set address will be placed after other
4212 script sections. If we let the orphan placement code
4213 place them in amongst other sections then the address
4214 will affect following script sections, which is
4215 likely to surprise naive users. */
4216 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
4217 tos
->addr_tree
= s
->address_statement
.address
;
4218 if (tos
->bfd_section
== NULL
)
4222 case lang_insert_statement_enum
:
4228 /* An insert statement snips out all the linker statements from the
4229 start of the list and places them after the output section
4230 statement specified by the insert. This operation is complicated
4231 by the fact that we keep a doubly linked list of output section
4232 statements as well as the singly linked list of all statements.
4233 FIXME someday: Twiddling with the list not only moves statements
4234 from the user's script but also input and group statements that are
4235 built from command line object files and --start-group. We only
4236 get away with this because the list pointers used by file_chain
4237 and input_file_chain are not reordered, and processing via
4238 statement_list after this point mostly ignores input statements.
4239 One exception is the map file, where LOAD and START GROUP/END GROUP
4240 can end up looking odd. */
4243 process_insert_statements (lang_statement_union_type
**start
)
4245 lang_statement_union_type
**s
;
4246 lang_output_section_statement_type
*first_os
= NULL
;
4247 lang_output_section_statement_type
*last_os
= NULL
;
4248 lang_output_section_statement_type
*os
;
4253 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4255 /* Keep pointers to the first and last output section
4256 statement in the sequence we may be about to move. */
4257 os
= &(*s
)->output_section_statement
;
4259 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4262 /* Set constraint negative so that lang_output_section_find
4263 won't match this output section statement. At this
4264 stage in linking constraint has values in the range
4265 [-1, ONLY_IN_RW]. */
4266 last_os
->constraint
= -2 - last_os
->constraint
;
4267 if (first_os
== NULL
)
4270 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4272 /* A user might put -T between --start-group and
4273 --end-group. One way this odd construct might arise is
4274 from a wrapper around ld to change library search
4275 behaviour. For example:
4277 exec real_ld --start-group "$@" --end-group
4278 This isn't completely unreasonable so go looking inside a
4279 group statement for insert statements. */
4280 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4282 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4284 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4285 lang_output_section_statement_type
*where
;
4286 lang_statement_union_type
**ptr
;
4287 lang_statement_union_type
*first
;
4289 if (link_info
.non_contiguous_regions
)
4291 einfo (_("warning: INSERT statement in linker script is "
4292 "incompatible with --enable-non-contiguous-regions.\n"));
4295 where
= lang_output_section_find (i
->where
);
4296 if (where
!= NULL
&& i
->is_before
)
4299 where
= where
->prev
;
4300 while (where
!= NULL
&& where
->constraint
< 0);
4304 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4308 /* Deal with reordering the output section statement list. */
4309 if (last_os
!= NULL
)
4311 asection
*first_sec
, *last_sec
;
4312 struct lang_output_section_statement_struct
**next
;
4314 /* Snip out the output sections we are moving. */
4315 first_os
->prev
->next
= last_os
->next
;
4316 if (last_os
->next
== NULL
)
4318 next
= &first_os
->prev
->next
;
4319 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4322 last_os
->next
->prev
= first_os
->prev
;
4323 /* Add them in at the new position. */
4324 last_os
->next
= where
->next
;
4325 if (where
->next
== NULL
)
4327 next
= &last_os
->next
;
4328 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4331 where
->next
->prev
= last_os
;
4332 first_os
->prev
= where
;
4333 where
->next
= first_os
;
4335 /* Move the bfd sections in the same way. */
4338 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4340 os
->constraint
= -2 - os
->constraint
;
4341 if (os
->bfd_section
!= NULL
4342 && os
->bfd_section
->owner
!= NULL
)
4344 last_sec
= os
->bfd_section
;
4345 if (first_sec
== NULL
)
4346 first_sec
= last_sec
;
4351 if (last_sec
!= NULL
)
4353 asection
*sec
= where
->bfd_section
;
4355 sec
= output_prev_sec_find (where
);
4357 /* The place we want to insert must come after the
4358 sections we are moving. So if we find no
4359 section or if the section is the same as our
4360 last section, then no move is needed. */
4361 if (sec
!= NULL
&& sec
!= last_sec
)
4363 /* Trim them off. */
4364 if (first_sec
->prev
!= NULL
)
4365 first_sec
->prev
->next
= last_sec
->next
;
4367 link_info
.output_bfd
->sections
= last_sec
->next
;
4368 if (last_sec
->next
!= NULL
)
4369 last_sec
->next
->prev
= first_sec
->prev
;
4371 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4373 last_sec
->next
= sec
->next
;
4374 if (sec
->next
!= NULL
)
4375 sec
->next
->prev
= last_sec
;
4377 link_info
.output_bfd
->section_last
= last_sec
;
4378 first_sec
->prev
= sec
;
4379 sec
->next
= first_sec
;
4387 ptr
= insert_os_after (where
);
4388 /* Snip everything from the start of the list, up to and
4389 including the insert statement we are currently processing. */
4391 *start
= (*s
)->header
.next
;
4392 /* Add them back where they belong, minus the insert. */
4395 statement_list
.tail
= s
;
4400 s
= &(*s
)->header
.next
;
4403 /* Undo constraint twiddling. */
4404 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4406 os
->constraint
= -2 - os
->constraint
;
4412 /* An output section might have been removed after its statement was
4413 added. For example, ldemul_before_allocation can remove dynamic
4414 sections if they turn out to be not needed. Clean them up here. */
4417 strip_excluded_output_sections (void)
4419 lang_output_section_statement_type
*os
;
4421 /* Run lang_size_sections (if not already done). */
4422 if (expld
.phase
!= lang_mark_phase_enum
)
4424 expld
.phase
= lang_mark_phase_enum
;
4425 expld
.dataseg
.phase
= exp_seg_none
;
4426 one_lang_size_sections_pass (NULL
, FALSE
);
4427 lang_reset_memory_regions ();
4430 for (os
= (void *) lang_os_list
.head
;
4434 asection
*output_section
;
4435 bfd_boolean exclude
;
4437 if (os
->constraint
< 0)
4440 output_section
= os
->bfd_section
;
4441 if (output_section
== NULL
)
4444 exclude
= (output_section
->rawsize
== 0
4445 && (output_section
->flags
& SEC_KEEP
) == 0
4446 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4449 /* Some sections have not yet been sized, notably .gnu.version,
4450 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4451 input sections, so don't drop output sections that have such
4452 input sections unless they are also marked SEC_EXCLUDE. */
4453 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4457 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4458 if ((s
->flags
& SEC_EXCLUDE
) == 0
4459 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4460 || link_info
.emitrelocations
))
4469 /* We don't set bfd_section to NULL since bfd_section of the
4470 removed output section statement may still be used. */
4471 if (!os
->update_dot
)
4473 output_section
->flags
|= SEC_EXCLUDE
;
4474 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4475 link_info
.output_bfd
->section_count
--;
4480 /* Called from ldwrite to clear out asection.map_head and
4481 asection.map_tail for use as link_orders in ldwrite. */
4484 lang_clear_os_map (void)
4486 lang_output_section_statement_type
*os
;
4488 if (map_head_is_link_order
)
4491 for (os
= (void *) lang_os_list
.head
;
4495 asection
*output_section
;
4497 if (os
->constraint
< 0)
4500 output_section
= os
->bfd_section
;
4501 if (output_section
== NULL
)
4504 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4505 output_section
->map_head
.link_order
= NULL
;
4506 output_section
->map_tail
.link_order
= NULL
;
4509 /* Stop future calls to lang_add_section from messing with map_head
4510 and map_tail link_order fields. */
4511 map_head_is_link_order
= TRUE
;
4515 print_output_section_statement
4516 (lang_output_section_statement_type
*output_section_statement
)
4518 asection
*section
= output_section_statement
->bfd_section
;
4521 if (output_section_statement
!= abs_output_section
)
4523 minfo ("\n%s", output_section_statement
->name
);
4525 if (section
!= NULL
)
4527 print_dot
= section
->vma
;
4529 len
= strlen (output_section_statement
->name
);
4530 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4535 while (len
< SECTION_NAME_MAP_LENGTH
)
4541 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4543 if (section
->vma
!= section
->lma
)
4544 minfo (_(" load address 0x%V"), section
->lma
);
4546 if (output_section_statement
->update_dot_tree
!= NULL
)
4547 exp_fold_tree (output_section_statement
->update_dot_tree
,
4548 bfd_abs_section_ptr
, &print_dot
);
4554 print_statement_list (output_section_statement
->children
.head
,
4555 output_section_statement
);
4559 print_assignment (lang_assignment_statement_type
*assignment
,
4560 lang_output_section_statement_type
*output_section
)
4567 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4570 if (assignment
->exp
->type
.node_class
== etree_assert
)
4573 tree
= assignment
->exp
->assert_s
.child
;
4577 const char *dst
= assignment
->exp
->assign
.dst
;
4579 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4580 tree
= assignment
->exp
;
4583 osec
= output_section
->bfd_section
;
4585 osec
= bfd_abs_section_ptr
;
4587 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4588 exp_fold_tree (tree
, osec
, &print_dot
);
4590 expld
.result
.valid_p
= FALSE
;
4592 if (expld
.result
.valid_p
)
4596 if (assignment
->exp
->type
.node_class
== etree_assert
4598 || expld
.assign_name
!= NULL
)
4600 value
= expld
.result
.value
;
4602 if (expld
.result
.section
!= NULL
)
4603 value
+= expld
.result
.section
->vma
;
4605 minfo ("0x%V", value
);
4611 struct bfd_link_hash_entry
*h
;
4613 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4614 FALSE
, FALSE
, TRUE
);
4616 && (h
->type
== bfd_link_hash_defined
4617 || h
->type
== bfd_link_hash_defweak
))
4619 value
= h
->u
.def
.value
;
4620 value
+= h
->u
.def
.section
->output_section
->vma
;
4621 value
+= h
->u
.def
.section
->output_offset
;
4623 minfo ("[0x%V]", value
);
4626 minfo ("[unresolved]");
4631 if (assignment
->exp
->type
.node_class
== etree_provide
)
4632 minfo ("[!provide]");
4639 expld
.assign_name
= NULL
;
4642 exp_print_tree (assignment
->exp
);
4647 print_input_statement (lang_input_statement_type
*statm
)
4649 if (statm
->filename
!= NULL
)
4650 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4653 /* Print all symbols defined in a particular section. This is called
4654 via bfd_link_hash_traverse, or by print_all_symbols. */
4657 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4659 asection
*sec
= (asection
*) ptr
;
4661 if ((hash_entry
->type
== bfd_link_hash_defined
4662 || hash_entry
->type
== bfd_link_hash_defweak
)
4663 && sec
== hash_entry
->u
.def
.section
)
4667 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4670 (hash_entry
->u
.def
.value
4671 + hash_entry
->u
.def
.section
->output_offset
4672 + hash_entry
->u
.def
.section
->output_section
->vma
));
4674 minfo (" %pT\n", hash_entry
->root
.string
);
4681 hash_entry_addr_cmp (const void *a
, const void *b
)
4683 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4684 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4686 if (l
->u
.def
.value
< r
->u
.def
.value
)
4688 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4695 print_all_symbols (asection
*sec
)
4697 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4698 struct map_symbol_def
*def
;
4699 struct bfd_link_hash_entry
**entries
;
4705 *ud
->map_symbol_def_tail
= 0;
4707 /* Sort the symbols by address. */
4708 entries
= (struct bfd_link_hash_entry
**)
4709 obstack_alloc (&map_obstack
,
4710 ud
->map_symbol_def_count
* sizeof (*entries
));
4712 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4713 entries
[i
] = def
->entry
;
4715 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4716 hash_entry_addr_cmp
);
4718 /* Print the symbols. */
4719 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4720 ldemul_print_symbol (entries
[i
], sec
);
4722 obstack_free (&map_obstack
, entries
);
4725 /* Print information about an input section to the map file. */
4728 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4730 bfd_size_type size
= i
->size
;
4737 minfo ("%s", i
->name
);
4739 len
= 1 + strlen (i
->name
);
4740 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4745 while (len
< SECTION_NAME_MAP_LENGTH
)
4751 if (i
->output_section
!= NULL
4752 && i
->output_section
->owner
== link_info
.output_bfd
)
4753 addr
= i
->output_section
->vma
+ i
->output_offset
;
4761 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4763 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4765 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4777 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4780 if (i
->output_section
!= NULL
4781 && i
->output_section
->owner
== link_info
.output_bfd
)
4783 if (link_info
.reduce_memory_overheads
)
4784 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4786 print_all_symbols (i
);
4788 /* Update print_dot, but make sure that we do not move it
4789 backwards - this could happen if we have overlays and a
4790 later overlay is shorter than an earier one. */
4791 if (addr
+ TO_ADDR (size
) > print_dot
)
4792 print_dot
= addr
+ TO_ADDR (size
);
4797 print_fill_statement (lang_fill_statement_type
*fill
)
4801 fputs (" FILL mask 0x", config
.map_file
);
4802 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4803 fprintf (config
.map_file
, "%02x", *p
);
4804 fputs ("\n", config
.map_file
);
4808 print_data_statement (lang_data_statement_type
*data
)
4815 init_opb (data
->output_section
);
4816 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4819 addr
= data
->output_offset
;
4820 if (data
->output_section
!= NULL
)
4821 addr
+= data
->output_section
->vma
;
4849 if (size
< TO_SIZE ((unsigned) 1))
4850 size
= TO_SIZE ((unsigned) 1);
4851 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4853 if (data
->exp
->type
.node_class
!= etree_value
)
4856 exp_print_tree (data
->exp
);
4861 print_dot
= addr
+ TO_ADDR (size
);
4864 /* Print an address statement. These are generated by options like
4868 print_address_statement (lang_address_statement_type
*address
)
4870 minfo (_("Address of section %s set to "), address
->section_name
);
4871 exp_print_tree (address
->address
);
4875 /* Print a reloc statement. */
4878 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4884 init_opb (reloc
->output_section
);
4885 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4888 addr
= reloc
->output_offset
;
4889 if (reloc
->output_section
!= NULL
)
4890 addr
+= reloc
->output_section
->vma
;
4892 size
= bfd_get_reloc_size (reloc
->howto
);
4894 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4896 if (reloc
->name
!= NULL
)
4897 minfo ("%s+", reloc
->name
);
4899 minfo ("%s+", reloc
->section
->name
);
4901 exp_print_tree (reloc
->addend_exp
);
4905 print_dot
= addr
+ TO_ADDR (size
);
4909 print_padding_statement (lang_padding_statement_type
*s
)
4914 init_opb (s
->output_section
);
4917 len
= sizeof " *fill*" - 1;
4918 while (len
< SECTION_NAME_MAP_LENGTH
)
4924 addr
= s
->output_offset
;
4925 if (s
->output_section
!= NULL
)
4926 addr
+= s
->output_section
->vma
;
4927 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4929 if (s
->fill
->size
!= 0)
4933 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4934 fprintf (config
.map_file
, "%02x", *p
);
4939 print_dot
= addr
+ TO_ADDR (s
->size
);
4943 print_wild_statement (lang_wild_statement_type
*w
,
4944 lang_output_section_statement_type
*os
)
4946 struct wildcard_list
*sec
;
4950 if (w
->exclude_name_list
)
4953 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4954 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4955 minfo (" %s", tmp
->name
);
4959 if (w
->filenames_sorted
)
4960 minfo ("SORT_BY_NAME(");
4961 if (w
->filename
!= NULL
)
4962 minfo ("%s", w
->filename
);
4965 if (w
->filenames_sorted
)
4969 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4971 int closing_paren
= 0;
4973 switch (sec
->spec
.sorted
)
4979 minfo ("SORT_BY_NAME(");
4984 minfo ("SORT_BY_ALIGNMENT(");
4988 case by_name_alignment
:
4989 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4993 case by_alignment_name
:
4994 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4999 minfo ("SORT_NONE(");
5003 case by_init_priority
:
5004 minfo ("SORT_BY_INIT_PRIORITY(");
5009 if (sec
->spec
.exclude_name_list
!= NULL
)
5012 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5013 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5014 minfo (" %s", tmp
->name
);
5017 if (sec
->spec
.name
!= NULL
)
5018 minfo ("%s", sec
->spec
.name
);
5021 for (;closing_paren
> 0; closing_paren
--)
5030 print_statement_list (w
->children
.head
, os
);
5033 /* Print a group statement. */
5036 print_group (lang_group_statement_type
*s
,
5037 lang_output_section_statement_type
*os
)
5039 fprintf (config
.map_file
, "START GROUP\n");
5040 print_statement_list (s
->children
.head
, os
);
5041 fprintf (config
.map_file
, "END GROUP\n");
5044 /* Print the list of statements in S.
5045 This can be called for any statement type. */
5048 print_statement_list (lang_statement_union_type
*s
,
5049 lang_output_section_statement_type
*os
)
5053 print_statement (s
, os
);
5058 /* Print the first statement in statement list S.
5059 This can be called for any statement type. */
5062 print_statement (lang_statement_union_type
*s
,
5063 lang_output_section_statement_type
*os
)
5065 switch (s
->header
.type
)
5068 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5071 case lang_constructors_statement_enum
:
5072 if (constructor_list
.head
!= NULL
)
5074 if (constructors_sorted
)
5075 minfo (" SORT (CONSTRUCTORS)\n");
5077 minfo (" CONSTRUCTORS\n");
5078 print_statement_list (constructor_list
.head
, os
);
5081 case lang_wild_statement_enum
:
5082 print_wild_statement (&s
->wild_statement
, os
);
5084 case lang_address_statement_enum
:
5085 print_address_statement (&s
->address_statement
);
5087 case lang_object_symbols_statement_enum
:
5088 minfo (" CREATE_OBJECT_SYMBOLS\n");
5090 case lang_fill_statement_enum
:
5091 print_fill_statement (&s
->fill_statement
);
5093 case lang_data_statement_enum
:
5094 print_data_statement (&s
->data_statement
);
5096 case lang_reloc_statement_enum
:
5097 print_reloc_statement (&s
->reloc_statement
);
5099 case lang_input_section_enum
:
5100 print_input_section (s
->input_section
.section
, FALSE
);
5102 case lang_padding_statement_enum
:
5103 print_padding_statement (&s
->padding_statement
);
5105 case lang_output_section_statement_enum
:
5106 print_output_section_statement (&s
->output_section_statement
);
5108 case lang_assignment_statement_enum
:
5109 print_assignment (&s
->assignment_statement
, os
);
5111 case lang_target_statement_enum
:
5112 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5114 case lang_output_statement_enum
:
5115 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5116 if (output_target
!= NULL
)
5117 minfo (" %s", output_target
);
5120 case lang_input_statement_enum
:
5121 print_input_statement (&s
->input_statement
);
5123 case lang_group_statement_enum
:
5124 print_group (&s
->group_statement
, os
);
5126 case lang_insert_statement_enum
:
5127 minfo ("INSERT %s %s\n",
5128 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5129 s
->insert_statement
.where
);
5135 print_statements (void)
5137 print_statement_list (statement_list
.head
, abs_output_section
);
5140 /* Print the first N statements in statement list S to STDERR.
5141 If N == 0, nothing is printed.
5142 If N < 0, the entire list is printed.
5143 Intended to be called from GDB. */
5146 dprint_statement (lang_statement_union_type
*s
, int n
)
5148 FILE *map_save
= config
.map_file
;
5150 config
.map_file
= stderr
;
5153 print_statement_list (s
, abs_output_section
);
5156 while (s
&& --n
>= 0)
5158 print_statement (s
, abs_output_section
);
5163 config
.map_file
= map_save
;
5167 insert_pad (lang_statement_union_type
**ptr
,
5169 bfd_size_type alignment_needed
,
5170 asection
*output_section
,
5173 static fill_type zero_fill
;
5174 lang_statement_union_type
*pad
= NULL
;
5176 if (ptr
!= &statement_list
.head
)
5177 pad
= ((lang_statement_union_type
*)
5178 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5180 && pad
->header
.type
== lang_padding_statement_enum
5181 && pad
->padding_statement
.output_section
== output_section
)
5183 /* Use the existing pad statement. */
5185 else if ((pad
= *ptr
) != NULL
5186 && pad
->header
.type
== lang_padding_statement_enum
5187 && pad
->padding_statement
.output_section
== output_section
)
5189 /* Use the existing pad statement. */
5193 /* Make a new padding statement, linked into existing chain. */
5194 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5195 pad
->header
.next
= *ptr
;
5197 pad
->header
.type
= lang_padding_statement_enum
;
5198 pad
->padding_statement
.output_section
= output_section
;
5201 pad
->padding_statement
.fill
= fill
;
5203 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5204 pad
->padding_statement
.size
= alignment_needed
;
5205 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5206 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5207 - output_section
->vma
);
5210 /* Work out how much this section will move the dot point. */
5214 (lang_statement_union_type
**this_ptr
,
5215 lang_output_section_statement_type
*output_section_statement
,
5217 bfd_boolean
*removed
,
5220 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5221 asection
*i
= is
->section
;
5222 asection
*o
= output_section_statement
->bfd_section
;
5225 if (link_info
.non_contiguous_regions
)
5227 /* If the input section I has already been successfully assigned
5228 to an output section other than O, don't bother with it and
5229 let the caller remove it from the list. Keep processing in
5230 case we have already handled O, because the repeated passes
5231 have reinitialized its size. */
5232 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5239 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5240 i
->output_offset
= i
->vma
- o
->vma
;
5241 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5242 || output_section_statement
->ignored
)
5243 i
->output_offset
= dot
- o
->vma
;
5246 bfd_size_type alignment_needed
;
5248 /* Align this section first to the input sections requirement,
5249 then to the output section's requirement. If this alignment
5250 is greater than any seen before, then record it too. Perform
5251 the alignment by inserting a magic 'padding' statement. */
5253 if (output_section_statement
->subsection_alignment
!= NULL
)
5255 = exp_get_power (output_section_statement
->subsection_alignment
,
5256 "subsection alignment");
5258 if (o
->alignment_power
< i
->alignment_power
)
5259 o
->alignment_power
= i
->alignment_power
;
5261 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5263 if (alignment_needed
!= 0)
5265 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5266 dot
+= alignment_needed
;
5269 if (link_info
.non_contiguous_regions
)
5271 /* If I would overflow O, let the caller remove I from the
5273 if (output_section_statement
->region
)
5275 bfd_vma end
= output_section_statement
->region
->origin
5276 + output_section_statement
->region
->length
;
5278 if (dot
+ TO_ADDR (i
->size
) > end
)
5280 if (i
->flags
& SEC_LINKER_CREATED
)
5281 einfo (_("%F%P: Output section '%s' not large enough for the "
5282 "linker-created stubs section '%s'.\n"),
5283 i
->output_section
->name
, i
->name
);
5285 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5286 einfo (_("%F%P: Relaxation not supported with "
5287 "--enable-non-contiguous-regions (section '%s' "
5288 "would overflow '%s' after it changed size).\n"),
5289 i
->name
, i
->output_section
->name
);
5293 i
->output_section
= NULL
;
5299 /* Remember where in the output section this input section goes. */
5300 i
->output_offset
= dot
- o
->vma
;
5302 /* Mark how big the output section must be to contain this now. */
5303 dot
+= TO_ADDR (i
->size
);
5304 if (!(o
->flags
& SEC_FIXED_SIZE
))
5305 o
->size
= TO_SIZE (dot
- o
->vma
);
5307 if (link_info
.non_contiguous_regions
)
5309 /* Record that I was successfully assigned to O, and update
5310 its actual output section too. */
5311 i
->already_assigned
= o
;
5312 i
->output_section
= o
;
5326 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5328 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5329 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5331 if (sec1
->lma
< sec2
->lma
)
5333 else if (sec1
->lma
> sec2
->lma
)
5335 else if (sec1
->id
< sec2
->id
)
5337 else if (sec1
->id
> sec2
->id
)
5344 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5346 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5347 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5349 if (sec1
->vma
< sec2
->vma
)
5351 else if (sec1
->vma
> sec2
->vma
)
5353 else if (sec1
->id
< sec2
->id
)
5355 else if (sec1
->id
> sec2
->id
)
5361 #define IS_TBSS(s) \
5362 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5364 #define IGNORE_SECTION(s) \
5365 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5367 /* Check to see if any allocated sections overlap with other allocated
5368 sections. This can happen if a linker script specifies the output
5369 section addresses of the two sections. Also check whether any memory
5370 region has overflowed. */
5373 lang_check_section_addresses (void)
5376 struct check_sec
*sections
;
5381 bfd_vma p_start
= 0;
5383 lang_memory_region_type
*m
;
5384 bfd_boolean overlays
;
5386 /* Detect address space overflow on allocated sections. */
5387 addr_mask
= ((bfd_vma
) 1 <<
5388 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5389 addr_mask
= (addr_mask
<< 1) + 1;
5390 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5391 if ((s
->flags
& SEC_ALLOC
) != 0)
5393 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5394 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5395 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5399 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5400 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5401 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5406 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5409 count
= bfd_count_sections (link_info
.output_bfd
);
5410 sections
= XNEWVEC (struct check_sec
, count
);
5412 /* Scan all sections in the output list. */
5414 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5416 if (IGNORE_SECTION (s
)
5420 sections
[count
].sec
= s
;
5421 sections
[count
].warned
= FALSE
;
5431 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5433 /* First check section LMAs. There should be no overlap of LMAs on
5434 loadable sections, even with overlays. */
5435 for (p
= NULL
, i
= 0; i
< count
; i
++)
5437 s
= sections
[i
].sec
;
5439 if ((s
->flags
& SEC_LOAD
) != 0)
5442 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5444 /* Look for an overlap. We have sorted sections by lma, so
5445 we know that s_start >= p_start. Besides the obvious
5446 case of overlap when the current section starts before
5447 the previous one ends, we also must have overlap if the
5448 previous section wraps around the address space. */
5450 && (s_start
<= p_end
5451 || p_end
< p_start
))
5453 einfo (_("%X%P: section %s LMA [%V,%V]"
5454 " overlaps section %s LMA [%V,%V]\n"),
5455 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5456 sections
[i
].warned
= TRUE
;
5464 /* If any non-zero size allocated section (excluding tbss) starts at
5465 exactly the same VMA as another such section, then we have
5466 overlays. Overlays generated by the OVERLAY keyword will have
5467 this property. It is possible to intentionally generate overlays
5468 that fail this test, but it would be unusual. */
5469 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5471 p_start
= sections
[0].sec
->vma
;
5472 for (i
= 1; i
< count
; i
++)
5474 s_start
= sections
[i
].sec
->vma
;
5475 if (p_start
== s_start
)
5483 /* Now check section VMAs if no overlays were detected. */
5486 for (p
= NULL
, i
= 0; i
< count
; i
++)
5488 s
= sections
[i
].sec
;
5491 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5494 && !sections
[i
].warned
5495 && (s_start
<= p_end
5496 || p_end
< p_start
))
5497 einfo (_("%X%P: section %s VMA [%V,%V]"
5498 " overlaps section %s VMA [%V,%V]\n"),
5499 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5508 /* If any memory region has overflowed, report by how much.
5509 We do not issue this diagnostic for regions that had sections
5510 explicitly placed outside their bounds; os_region_check's
5511 diagnostics are adequate for that case.
5513 FIXME: It is conceivable that m->current - (m->origin + m->length)
5514 might overflow a 32-bit integer. There is, alas, no way to print
5515 a bfd_vma quantity in decimal. */
5516 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5517 if (m
->had_full_message
)
5519 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5520 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5521 "%X%P: region `%s' overflowed by %lu bytes\n",
5523 m
->name_list
.name
, over
);
5527 /* Make sure the new address is within the region. We explicitly permit the
5528 current address to be at the exact end of the region when the address is
5529 non-zero, in case the region is at the end of addressable memory and the
5530 calculation wraps around. */
5533 os_region_check (lang_output_section_statement_type
*os
,
5534 lang_memory_region_type
*region
,
5538 if ((region
->current
< region
->origin
5539 || (region
->current
- region
->origin
> region
->length
))
5540 && ((region
->current
!= region
->origin
+ region
->length
)
5545 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5546 " is not within region `%s'\n"),
5548 os
->bfd_section
->owner
,
5549 os
->bfd_section
->name
,
5550 region
->name_list
.name
);
5552 else if (!region
->had_full_message
)
5554 region
->had_full_message
= TRUE
;
5556 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5557 os
->bfd_section
->owner
,
5558 os
->bfd_section
->name
,
5559 region
->name_list
.name
);
5565 ldlang_check_relro_region (lang_statement_union_type
*s
,
5566 seg_align_type
*seg
)
5568 if (seg
->relro
== exp_seg_relro_start
)
5570 if (!seg
->relro_start_stat
)
5571 seg
->relro_start_stat
= s
;
5574 ASSERT (seg
->relro_start_stat
== s
);
5577 else if (seg
->relro
== exp_seg_relro_end
)
5579 if (!seg
->relro_end_stat
)
5580 seg
->relro_end_stat
= s
;
5583 ASSERT (seg
->relro_end_stat
== s
);
5588 /* Set the sizes for all the output sections. */
5591 lang_size_sections_1
5592 (lang_statement_union_type
**prev
,
5593 lang_output_section_statement_type
*output_section_statement
,
5597 bfd_boolean check_regions
)
5599 lang_statement_union_type
*s
;
5600 lang_statement_union_type
*prev_s
= NULL
;
5601 bfd_boolean removed_prev_s
= FALSE
;
5603 /* Size up the sections from their constituent parts. */
5604 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5606 bfd_boolean removed
=FALSE
;
5608 switch (s
->header
.type
)
5610 case lang_output_section_statement_enum
:
5612 bfd_vma newdot
, after
, dotdelta
;
5613 lang_output_section_statement_type
*os
;
5614 lang_memory_region_type
*r
;
5615 int section_alignment
= 0;
5617 os
= &s
->output_section_statement
;
5618 init_opb (os
->bfd_section
);
5619 if (os
->constraint
== -1)
5622 /* FIXME: We shouldn't need to zero section vmas for ld -r
5623 here, in lang_insert_orphan, or in the default linker scripts.
5624 This is covering for coff backend linker bugs. See PR6945. */
5625 if (os
->addr_tree
== NULL
5626 && bfd_link_relocatable (&link_info
)
5627 && (bfd_get_flavour (link_info
.output_bfd
)
5628 == bfd_target_coff_flavour
))
5629 os
->addr_tree
= exp_intop (0);
5630 if (os
->addr_tree
!= NULL
)
5632 os
->processed_vma
= FALSE
;
5633 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5635 if (expld
.result
.valid_p
)
5637 dot
= expld
.result
.value
;
5638 if (expld
.result
.section
!= NULL
)
5639 dot
+= expld
.result
.section
->vma
;
5641 else if (expld
.phase
!= lang_mark_phase_enum
)
5642 einfo (_("%F%P:%pS: non constant or forward reference"
5643 " address expression for section %s\n"),
5644 os
->addr_tree
, os
->name
);
5647 if (os
->bfd_section
== NULL
)
5648 /* This section was removed or never actually created. */
5651 /* If this is a COFF shared library section, use the size and
5652 address from the input section. FIXME: This is COFF
5653 specific; it would be cleaner if there were some other way
5654 to do this, but nothing simple comes to mind. */
5655 if (((bfd_get_flavour (link_info
.output_bfd
)
5656 == bfd_target_ecoff_flavour
)
5657 || (bfd_get_flavour (link_info
.output_bfd
)
5658 == bfd_target_coff_flavour
))
5659 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5663 if (os
->children
.head
== NULL
5664 || os
->children
.head
->header
.next
!= NULL
5665 || (os
->children
.head
->header
.type
5666 != lang_input_section_enum
))
5667 einfo (_("%X%P: internal error on COFF shared library"
5668 " section %s\n"), os
->name
);
5670 input
= os
->children
.head
->input_section
.section
;
5671 bfd_set_section_vma (os
->bfd_section
,
5672 bfd_section_vma (input
));
5673 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5674 os
->bfd_section
->size
= input
->size
;
5680 if (bfd_is_abs_section (os
->bfd_section
))
5682 /* No matter what happens, an abs section starts at zero. */
5683 ASSERT (os
->bfd_section
->vma
== 0);
5687 if (os
->addr_tree
== NULL
)
5689 /* No address specified for this section, get one
5690 from the region specification. */
5691 if (os
->region
== NULL
5692 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5693 && os
->region
->name_list
.name
[0] == '*'
5694 && strcmp (os
->region
->name_list
.name
,
5695 DEFAULT_MEMORY_REGION
) == 0))
5697 os
->region
= lang_memory_default (os
->bfd_section
);
5700 /* If a loadable section is using the default memory
5701 region, and some non default memory regions were
5702 defined, issue an error message. */
5704 && !IGNORE_SECTION (os
->bfd_section
)
5705 && !bfd_link_relocatable (&link_info
)
5707 && strcmp (os
->region
->name_list
.name
,
5708 DEFAULT_MEMORY_REGION
) == 0
5709 && lang_memory_region_list
!= NULL
5710 && (strcmp (lang_memory_region_list
->name_list
.name
,
5711 DEFAULT_MEMORY_REGION
) != 0
5712 || lang_memory_region_list
->next
!= NULL
)
5713 && lang_sizing_iteration
== 1)
5715 /* By default this is an error rather than just a
5716 warning because if we allocate the section to the
5717 default memory region we can end up creating an
5718 excessively large binary, or even seg faulting when
5719 attempting to perform a negative seek. See
5720 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5721 for an example of this. This behaviour can be
5722 overridden by the using the --no-check-sections
5724 if (command_line
.check_section_addresses
)
5725 einfo (_("%F%P: error: no memory region specified"
5726 " for loadable section `%s'\n"),
5727 bfd_section_name (os
->bfd_section
));
5729 einfo (_("%P: warning: no memory region specified"
5730 " for loadable section `%s'\n"),
5731 bfd_section_name (os
->bfd_section
));
5734 newdot
= os
->region
->current
;
5735 section_alignment
= os
->bfd_section
->alignment_power
;
5738 section_alignment
= exp_get_power (os
->section_alignment
,
5739 "section alignment");
5741 /* Align to what the section needs. */
5742 if (section_alignment
> 0)
5744 bfd_vma savedot
= newdot
;
5747 newdot
= align_power (newdot
, section_alignment
);
5748 dotdelta
= newdot
- savedot
;
5750 if (lang_sizing_iteration
== 1)
5752 else if (lang_sizing_iteration
> 1)
5754 /* Only report adjustments that would change
5755 alignment from what we have already reported. */
5756 diff
= newdot
- os
->bfd_section
->vma
;
5757 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5761 && (config
.warn_section_align
5762 || os
->addr_tree
!= NULL
))
5763 einfo (_("%P: warning: "
5764 "start of section %s changed by %ld\n"),
5765 os
->name
, (long) diff
);
5768 bfd_set_section_vma (os
->bfd_section
, newdot
);
5770 os
->bfd_section
->output_offset
= 0;
5773 lang_size_sections_1 (&os
->children
.head
, os
,
5774 os
->fill
, newdot
, relax
, check_regions
);
5776 os
->processed_vma
= TRUE
;
5778 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5779 /* Except for some special linker created sections,
5780 no output section should change from zero size
5781 after strip_excluded_output_sections. A non-zero
5782 size on an ignored section indicates that some
5783 input section was not sized early enough. */
5784 ASSERT (os
->bfd_section
->size
== 0);
5787 dot
= os
->bfd_section
->vma
;
5789 /* Put the section within the requested block size, or
5790 align at the block boundary. */
5792 + TO_ADDR (os
->bfd_section
->size
)
5793 + os
->block_value
- 1)
5794 & - (bfd_vma
) os
->block_value
);
5796 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5797 os
->bfd_section
->size
= TO_SIZE (after
5798 - os
->bfd_section
->vma
);
5801 /* Set section lma. */
5804 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5808 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5809 os
->bfd_section
->lma
= lma
;
5811 else if (os
->lma_region
!= NULL
)
5813 bfd_vma lma
= os
->lma_region
->current
;
5815 if (os
->align_lma_with_input
)
5819 /* When LMA_REGION is the same as REGION, align the LMA
5820 as we did for the VMA, possibly including alignment
5821 from the bfd section. If a different region, then
5822 only align according to the value in the output
5824 if (os
->lma_region
!= os
->region
)
5825 section_alignment
= exp_get_power (os
->section_alignment
,
5826 "section alignment");
5827 if (section_alignment
> 0)
5828 lma
= align_power (lma
, section_alignment
);
5830 os
->bfd_section
->lma
= lma
;
5832 else if (r
->last_os
!= NULL
5833 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5838 last
= r
->last_os
->output_section_statement
.bfd_section
;
5840 /* A backwards move of dot should be accompanied by
5841 an explicit assignment to the section LMA (ie.
5842 os->load_base set) because backwards moves can
5843 create overlapping LMAs. */
5845 && os
->bfd_section
->size
!= 0
5846 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5848 /* If dot moved backwards then leave lma equal to
5849 vma. This is the old default lma, which might
5850 just happen to work when the backwards move is
5851 sufficiently large. Nag if this changes anything,
5852 so people can fix their linker scripts. */
5854 if (last
->vma
!= last
->lma
)
5855 einfo (_("%P: warning: dot moved backwards "
5856 "before `%s'\n"), os
->name
);
5860 /* If this is an overlay, set the current lma to that
5861 at the end of the previous section. */
5862 if (os
->sectype
== overlay_section
)
5863 lma
= last
->lma
+ TO_ADDR (last
->size
);
5865 /* Otherwise, keep the same lma to vma relationship
5866 as the previous section. */
5868 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5870 if (section_alignment
> 0)
5871 lma
= align_power (lma
, section_alignment
);
5872 os
->bfd_section
->lma
= lma
;
5875 os
->processed_lma
= TRUE
;
5877 /* Keep track of normal sections using the default
5878 lma region. We use this to set the lma for
5879 following sections. Overlays or other linker
5880 script assignment to lma might mean that the
5881 default lma == vma is incorrect.
5882 To avoid warnings about dot moving backwards when using
5883 -Ttext, don't start tracking sections until we find one
5884 of non-zero size or with lma set differently to vma.
5885 Do this tracking before we short-cut the loop so that we
5886 track changes for the case where the section size is zero,
5887 but the lma is set differently to the vma. This is
5888 important, if an orphan section is placed after an
5889 otherwise empty output section that has an explicit lma
5890 set, we want that lma reflected in the orphans lma. */
5891 if (((!IGNORE_SECTION (os
->bfd_section
)
5892 && (os
->bfd_section
->size
!= 0
5893 || (r
->last_os
== NULL
5894 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5895 || (r
->last_os
!= NULL
5896 && dot
>= (r
->last_os
->output_section_statement
5897 .bfd_section
->vma
))))
5898 || os
->sectype
== first_overlay_section
)
5899 && os
->lma_region
== NULL
5900 && !bfd_link_relocatable (&link_info
))
5903 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5906 /* .tbss sections effectively have zero size. */
5907 if (!IS_TBSS (os
->bfd_section
)
5908 || bfd_link_relocatable (&link_info
))
5909 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5914 if (os
->update_dot_tree
!= 0)
5915 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5917 /* Update dot in the region ?
5918 We only do this if the section is going to be allocated,
5919 since unallocated sections do not contribute to the region's
5920 overall size in memory. */
5921 if (os
->region
!= NULL
5922 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5924 os
->region
->current
= dot
;
5927 /* Make sure the new address is within the region. */
5928 os_region_check (os
, os
->region
, os
->addr_tree
,
5929 os
->bfd_section
->vma
);
5931 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5932 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5933 || os
->align_lma_with_input
))
5935 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5938 os_region_check (os
, os
->lma_region
, NULL
,
5939 os
->bfd_section
->lma
);
5945 case lang_constructors_statement_enum
:
5946 dot
= lang_size_sections_1 (&constructor_list
.head
,
5947 output_section_statement
,
5948 fill
, dot
, relax
, check_regions
);
5951 case lang_data_statement_enum
:
5953 unsigned int size
= 0;
5955 s
->data_statement
.output_offset
=
5956 dot
- output_section_statement
->bfd_section
->vma
;
5957 s
->data_statement
.output_section
=
5958 output_section_statement
->bfd_section
;
5960 /* We might refer to provided symbols in the expression, and
5961 need to mark them as needed. */
5962 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5964 switch (s
->data_statement
.type
)
5982 if (size
< TO_SIZE ((unsigned) 1))
5983 size
= TO_SIZE ((unsigned) 1);
5984 dot
+= TO_ADDR (size
);
5985 if (!(output_section_statement
->bfd_section
->flags
5987 output_section_statement
->bfd_section
->size
5988 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5993 case lang_reloc_statement_enum
:
5997 s
->reloc_statement
.output_offset
=
5998 dot
- output_section_statement
->bfd_section
->vma
;
5999 s
->reloc_statement
.output_section
=
6000 output_section_statement
->bfd_section
;
6001 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6002 dot
+= TO_ADDR (size
);
6003 if (!(output_section_statement
->bfd_section
->flags
6005 output_section_statement
->bfd_section
->size
6006 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6010 case lang_wild_statement_enum
:
6011 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6012 output_section_statement
,
6013 fill
, dot
, relax
, check_regions
);
6016 case lang_object_symbols_statement_enum
:
6017 link_info
.create_object_symbols_section
6018 = output_section_statement
->bfd_section
;
6019 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6022 case lang_output_statement_enum
:
6023 case lang_target_statement_enum
:
6026 case lang_input_section_enum
:
6030 i
= s
->input_section
.section
;
6035 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6036 einfo (_("%F%P: can't relax section: %E\n"));
6040 dot
= size_input_section (prev
, output_section_statement
,
6041 fill
, &removed
, dot
);
6045 case lang_input_statement_enum
:
6048 case lang_fill_statement_enum
:
6049 s
->fill_statement
.output_section
=
6050 output_section_statement
->bfd_section
;
6052 fill
= s
->fill_statement
.fill
;
6055 case lang_assignment_statement_enum
:
6057 bfd_vma newdot
= dot
;
6058 etree_type
*tree
= s
->assignment_statement
.exp
;
6060 expld
.dataseg
.relro
= exp_seg_relro_none
;
6062 exp_fold_tree (tree
,
6063 output_section_statement
->bfd_section
,
6066 ldlang_check_relro_region (s
, &expld
.dataseg
);
6068 expld
.dataseg
.relro
= exp_seg_relro_none
;
6070 /* This symbol may be relative to this section. */
6071 if ((tree
->type
.node_class
== etree_provided
6072 || tree
->type
.node_class
== etree_assign
)
6073 && (tree
->assign
.dst
[0] != '.'
6074 || tree
->assign
.dst
[1] != '\0'))
6075 output_section_statement
->update_dot
= 1;
6077 if (!output_section_statement
->ignored
)
6079 if (output_section_statement
== abs_output_section
)
6081 /* If we don't have an output section, then just adjust
6082 the default memory address. */
6083 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6084 FALSE
)->current
= newdot
;
6086 else if (newdot
!= dot
)
6088 /* Insert a pad after this statement. We can't
6089 put the pad before when relaxing, in case the
6090 assignment references dot. */
6091 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6092 output_section_statement
->bfd_section
, dot
);
6094 /* Don't neuter the pad below when relaxing. */
6097 /* If dot is advanced, this implies that the section
6098 should have space allocated to it, unless the
6099 user has explicitly stated that the section
6100 should not be allocated. */
6101 if (output_section_statement
->sectype
!= noalloc_section
6102 && (output_section_statement
->sectype
!= noload_section
6103 || (bfd_get_flavour (link_info
.output_bfd
)
6104 == bfd_target_elf_flavour
)))
6105 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6112 case lang_padding_statement_enum
:
6113 /* If this is the first time lang_size_sections is called,
6114 we won't have any padding statements. If this is the
6115 second or later passes when relaxing, we should allow
6116 padding to shrink. If padding is needed on this pass, it
6117 will be added back in. */
6118 s
->padding_statement
.size
= 0;
6120 /* Make sure output_offset is valid. If relaxation shrinks
6121 the section and this pad isn't needed, it's possible to
6122 have output_offset larger than the final size of the
6123 section. bfd_set_section_contents will complain even for
6124 a pad size of zero. */
6125 s
->padding_statement
.output_offset
6126 = dot
- output_section_statement
->bfd_section
->vma
;
6129 case lang_group_statement_enum
:
6130 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6131 output_section_statement
,
6132 fill
, dot
, relax
, check_regions
);
6135 case lang_insert_statement_enum
:
6138 /* We can only get here when relaxing is turned on. */
6139 case lang_address_statement_enum
:
6147 /* If an input section doesn't fit in the current output
6148 section, remove it from the list. Handle the case where we
6149 have to remove an input_section statement here: there is a
6150 special case to remove the first element of the list. */
6151 if (link_info
.non_contiguous_regions
&& removed
)
6153 /* If we removed the first element during the previous
6154 iteration, override the loop assignment of prev_s. */
6160 /* If there was a real previous input section, just skip
6162 prev_s
->header
.next
=s
->header
.next
;
6164 removed_prev_s
= FALSE
;
6168 /* Remove the first input section of the list. */
6169 *prev
= s
->header
.next
;
6170 removed_prev_s
= TRUE
;
6173 /* Move to next element, unless we removed the head of the
6175 if (!removed_prev_s
)
6176 prev
= &s
->header
.next
;
6180 prev
= &s
->header
.next
;
6181 removed_prev_s
= FALSE
;
6187 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6188 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6189 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6190 segments. We are allowed an opportunity to override this decision. */
6193 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6194 bfd
*abfd ATTRIBUTE_UNUSED
,
6195 asection
*current_section
,
6196 asection
*previous_section
,
6197 bfd_boolean new_segment
)
6199 lang_output_section_statement_type
*cur
;
6200 lang_output_section_statement_type
*prev
;
6202 /* The checks below are only necessary when the BFD library has decided
6203 that the two sections ought to be placed into the same segment. */
6207 /* Paranoia checks. */
6208 if (current_section
== NULL
|| previous_section
== NULL
)
6211 /* If this flag is set, the target never wants code and non-code
6212 sections comingled in the same segment. */
6213 if (config
.separate_code
6214 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6217 /* Find the memory regions associated with the two sections.
6218 We call lang_output_section_find() here rather than scanning the list
6219 of output sections looking for a matching section pointer because if
6220 we have a large number of sections then a hash lookup is faster. */
6221 cur
= lang_output_section_find (current_section
->name
);
6222 prev
= lang_output_section_find (previous_section
->name
);
6224 /* More paranoia. */
6225 if (cur
== NULL
|| prev
== NULL
)
6228 /* If the regions are different then force the sections to live in
6229 different segments. See the email thread starting at the following
6230 URL for the reasons why this is necessary:
6231 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6232 return cur
->region
!= prev
->region
;
6236 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6238 lang_statement_iteration
++;
6239 if (expld
.phase
!= lang_mark_phase_enum
)
6240 lang_sizing_iteration
++;
6241 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6242 0, 0, relax
, check_regions
);
6246 lang_size_segment (seg_align_type
*seg
)
6248 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6249 a page could be saved in the data segment. */
6250 bfd_vma first
, last
;
6252 first
= -seg
->base
& (seg
->pagesize
- 1);
6253 last
= seg
->end
& (seg
->pagesize
- 1);
6255 && ((seg
->base
& ~(seg
->pagesize
- 1))
6256 != (seg
->end
& ~(seg
->pagesize
- 1)))
6257 && first
+ last
<= seg
->pagesize
)
6259 seg
->phase
= exp_seg_adjust
;
6263 seg
->phase
= exp_seg_done
;
6268 lang_size_relro_segment_1 (seg_align_type
*seg
)
6270 bfd_vma relro_end
, desired_end
;
6273 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6274 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6275 & ~(seg
->pagesize
- 1));
6277 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6278 desired_end
= relro_end
- seg
->relro_offset
;
6280 /* For sections in the relro segment.. */
6281 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6282 if ((sec
->flags
& SEC_ALLOC
) != 0
6283 && sec
->vma
>= seg
->base
6284 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6286 /* Where do we want to put this section so that it ends as
6288 bfd_vma start
, end
, bump
;
6290 end
= start
= sec
->vma
;
6292 end
+= TO_ADDR (sec
->size
);
6293 bump
= desired_end
- end
;
6294 /* We'd like to increase START by BUMP, but we must heed
6295 alignment so the increase might be less than optimum. */
6297 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6298 /* This is now the desired end for the previous section. */
6299 desired_end
= start
;
6302 seg
->phase
= exp_seg_relro_adjust
;
6303 ASSERT (desired_end
>= seg
->base
);
6304 seg
->base
= desired_end
;
6309 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6311 bfd_boolean do_reset
= FALSE
;
6312 bfd_boolean do_data_relro
;
6313 bfd_vma data_initial_base
, data_relro_end
;
6315 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6317 do_data_relro
= TRUE
;
6318 data_initial_base
= expld
.dataseg
.base
;
6319 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6323 do_data_relro
= FALSE
;
6324 data_initial_base
= data_relro_end
= 0;
6329 lang_reset_memory_regions ();
6330 one_lang_size_sections_pass (relax
, check_regions
);
6332 /* Assignments to dot, or to output section address in a user
6333 script have increased padding over the original. Revert. */
6334 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6336 expld
.dataseg
.base
= data_initial_base
;;
6341 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6348 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6350 expld
.phase
= lang_allocating_phase_enum
;
6351 expld
.dataseg
.phase
= exp_seg_none
;
6353 one_lang_size_sections_pass (relax
, check_regions
);
6355 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6356 expld
.dataseg
.phase
= exp_seg_done
;
6358 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6360 bfd_boolean do_reset
6361 = lang_size_relro_segment (relax
, check_regions
);
6365 lang_reset_memory_regions ();
6366 one_lang_size_sections_pass (relax
, check_regions
);
6369 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6371 link_info
.relro_start
= expld
.dataseg
.base
;
6372 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6377 static lang_output_section_statement_type
*current_section
;
6378 static lang_assignment_statement_type
*current_assign
;
6379 static bfd_boolean prefer_next_section
;
6381 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6384 lang_do_assignments_1 (lang_statement_union_type
*s
,
6385 lang_output_section_statement_type
*current_os
,
6388 bfd_boolean
*found_end
)
6390 for (; s
!= NULL
; s
= s
->header
.next
)
6392 switch (s
->header
.type
)
6394 case lang_constructors_statement_enum
:
6395 dot
= lang_do_assignments_1 (constructor_list
.head
,
6396 current_os
, fill
, dot
, found_end
);
6399 case lang_output_section_statement_enum
:
6401 lang_output_section_statement_type
*os
;
6404 os
= &(s
->output_section_statement
);
6405 os
->after_end
= *found_end
;
6406 init_opb (os
->bfd_section
);
6407 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6409 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6411 current_section
= os
;
6412 prefer_next_section
= FALSE
;
6414 dot
= os
->bfd_section
->vma
;
6416 newdot
= lang_do_assignments_1 (os
->children
.head
,
6417 os
, os
->fill
, dot
, found_end
);
6420 if (os
->bfd_section
!= NULL
)
6422 /* .tbss sections effectively have zero size. */
6423 if (!IS_TBSS (os
->bfd_section
)
6424 || bfd_link_relocatable (&link_info
))
6425 dot
+= TO_ADDR (os
->bfd_section
->size
);
6427 if (os
->update_dot_tree
!= NULL
)
6428 exp_fold_tree (os
->update_dot_tree
,
6429 bfd_abs_section_ptr
, &dot
);
6437 case lang_wild_statement_enum
:
6439 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6440 current_os
, fill
, dot
, found_end
);
6443 case lang_object_symbols_statement_enum
:
6444 case lang_output_statement_enum
:
6445 case lang_target_statement_enum
:
6448 case lang_data_statement_enum
:
6449 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6450 if (expld
.result
.valid_p
)
6452 s
->data_statement
.value
= expld
.result
.value
;
6453 if (expld
.result
.section
!= NULL
)
6454 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6456 else if (expld
.phase
== lang_final_phase_enum
)
6457 einfo (_("%F%P: invalid data statement\n"));
6460 switch (s
->data_statement
.type
)
6478 if (size
< TO_SIZE ((unsigned) 1))
6479 size
= TO_SIZE ((unsigned) 1);
6480 dot
+= TO_ADDR (size
);
6484 case lang_reloc_statement_enum
:
6485 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6486 bfd_abs_section_ptr
, &dot
);
6487 if (expld
.result
.valid_p
)
6488 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6489 else if (expld
.phase
== lang_final_phase_enum
)
6490 einfo (_("%F%P: invalid reloc statement\n"));
6491 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6494 case lang_input_section_enum
:
6496 asection
*in
= s
->input_section
.section
;
6498 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6499 dot
+= TO_ADDR (in
->size
);
6503 case lang_input_statement_enum
:
6506 case lang_fill_statement_enum
:
6507 fill
= s
->fill_statement
.fill
;
6510 case lang_assignment_statement_enum
:
6511 current_assign
= &s
->assignment_statement
;
6512 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6514 const char *p
= current_assign
->exp
->assign
.dst
;
6516 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6517 prefer_next_section
= TRUE
;
6521 if (strcmp (p
, "end") == 0)
6524 exp_fold_tree (s
->assignment_statement
.exp
,
6525 (current_os
->bfd_section
!= NULL
6526 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6530 case lang_padding_statement_enum
:
6531 dot
+= TO_ADDR (s
->padding_statement
.size
);
6534 case lang_group_statement_enum
:
6535 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6536 current_os
, fill
, dot
, found_end
);
6539 case lang_insert_statement_enum
:
6542 case lang_address_statement_enum
:
6554 lang_do_assignments (lang_phase_type phase
)
6556 bfd_boolean found_end
= FALSE
;
6558 current_section
= NULL
;
6559 prefer_next_section
= FALSE
;
6560 expld
.phase
= phase
;
6561 lang_statement_iteration
++;
6562 lang_do_assignments_1 (statement_list
.head
,
6563 abs_output_section
, NULL
, 0, &found_end
);
6566 /* For an assignment statement outside of an output section statement,
6567 choose the best of neighbouring output sections to use for values
6571 section_for_dot (void)
6575 /* Assignments belong to the previous output section, unless there
6576 has been an assignment to "dot", in which case following
6577 assignments belong to the next output section. (The assumption
6578 is that an assignment to "dot" is setting up the address for the
6579 next output section.) Except that past the assignment to "_end"
6580 we always associate with the previous section. This exception is
6581 for targets like SH that define an alloc .stack or other
6582 weirdness after non-alloc sections. */
6583 if (current_section
== NULL
|| prefer_next_section
)
6585 lang_statement_union_type
*stmt
;
6586 lang_output_section_statement_type
*os
;
6588 for (stmt
= (lang_statement_union_type
*) current_assign
;
6590 stmt
= stmt
->header
.next
)
6591 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6594 os
= &stmt
->output_section_statement
;
6597 && (os
->bfd_section
== NULL
6598 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6599 || bfd_section_removed_from_list (link_info
.output_bfd
,
6603 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6606 s
= os
->bfd_section
;
6608 s
= link_info
.output_bfd
->section_last
;
6610 && ((s
->flags
& SEC_ALLOC
) == 0
6611 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6616 return bfd_abs_section_ptr
;
6620 s
= current_section
->bfd_section
;
6622 /* The section may have been stripped. */
6624 && ((s
->flags
& SEC_EXCLUDE
) != 0
6625 || (s
->flags
& SEC_ALLOC
) == 0
6626 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6627 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6630 s
= link_info
.output_bfd
->sections
;
6632 && ((s
->flags
& SEC_ALLOC
) == 0
6633 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6638 return bfd_abs_section_ptr
;
6641 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6643 static struct bfd_link_hash_entry
**start_stop_syms
;
6644 static size_t start_stop_count
= 0;
6645 static size_t start_stop_alloc
= 0;
6647 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6648 to start_stop_syms. */
6651 lang_define_start_stop (const char *symbol
, asection
*sec
)
6653 struct bfd_link_hash_entry
*h
;
6655 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6658 if (start_stop_count
== start_stop_alloc
)
6660 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6662 = xrealloc (start_stop_syms
,
6663 start_stop_alloc
* sizeof (*start_stop_syms
));
6665 start_stop_syms
[start_stop_count
++] = h
;
6669 /* Check for input sections whose names match references to
6670 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6671 preliminary definitions. */
6674 lang_init_start_stop (void)
6678 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6680 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6681 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6684 const char *secname
= s
->name
;
6686 for (ps
= secname
; *ps
!= '\0'; ps
++)
6687 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6691 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6693 symbol
[0] = leading_char
;
6694 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6695 lang_define_start_stop (symbol
, s
);
6697 symbol
[1] = leading_char
;
6698 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6699 lang_define_start_stop (symbol
+ 1, s
);
6706 /* Iterate over start_stop_syms. */
6709 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6713 for (i
= 0; i
< start_stop_count
; ++i
)
6714 func (start_stop_syms
[i
]);
6717 /* __start and __stop symbols are only supposed to be defined by the
6718 linker for orphan sections, but we now extend that to sections that
6719 map to an output section of the same name. The symbols were
6720 defined early for --gc-sections, before we mapped input to output
6721 sections, so undo those that don't satisfy this rule. */
6724 undef_start_stop (struct bfd_link_hash_entry
*h
)
6726 if (h
->ldscript_def
)
6729 if (h
->u
.def
.section
->output_section
== NULL
6730 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6731 || strcmp (h
->u
.def
.section
->name
,
6732 h
->u
.def
.section
->output_section
->name
) != 0)
6734 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6735 h
->u
.def
.section
->name
);
6738 /* When there are more than one input sections with the same
6739 section name, SECNAME, linker picks the first one to define
6740 __start_SECNAME and __stop_SECNAME symbols. When the first
6741 input section is removed by comdat group, we need to check
6742 if there is still an output section with section name
6745 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6746 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6748 h
->u
.def
.section
= i
;
6752 h
->type
= bfd_link_hash_undefined
;
6753 h
->u
.undef
.abfd
= NULL
;
6758 lang_undef_start_stop (void)
6760 foreach_start_stop (undef_start_stop
);
6763 /* Check for output sections whose names match references to
6764 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6765 preliminary definitions. */
6768 lang_init_startof_sizeof (void)
6772 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6774 const char *secname
= s
->name
;
6775 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6777 sprintf (symbol
, ".startof.%s", secname
);
6778 lang_define_start_stop (symbol
, s
);
6780 memcpy (symbol
+ 1, ".size", 5);
6781 lang_define_start_stop (symbol
+ 1, s
);
6786 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6789 set_start_stop (struct bfd_link_hash_entry
*h
)
6792 || h
->type
!= bfd_link_hash_defined
)
6795 if (h
->root
.string
[0] == '.')
6797 /* .startof. or .sizeof. symbol.
6798 .startof. already has final value. */
6799 if (h
->root
.string
[2] == 'i')
6802 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6803 h
->u
.def
.section
= bfd_abs_section_ptr
;
6808 /* __start or __stop symbol. */
6809 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6811 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6812 if (h
->root
.string
[4 + has_lead
] == 'o')
6815 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6821 lang_finalize_start_stop (void)
6823 foreach_start_stop (set_start_stop
);
6829 struct bfd_link_hash_entry
*h
;
6832 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6833 || bfd_link_dll (&link_info
))
6834 warn
= entry_from_cmdline
;
6838 /* Force the user to specify a root when generating a relocatable with
6839 --gc-sections, unless --gc-keep-exported was also given. */
6840 if (bfd_link_relocatable (&link_info
)
6841 && link_info
.gc_sections
6842 && !link_info
.gc_keep_exported
6843 && !(entry_from_cmdline
|| undef_from_cmdline
))
6844 einfo (_("%F%P: gc-sections requires either an entry or "
6845 "an undefined symbol\n"));
6847 if (entry_symbol
.name
== NULL
)
6849 /* No entry has been specified. Look for the default entry, but
6850 don't warn if we don't find it. */
6851 entry_symbol
.name
= entry_symbol_default
;
6855 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6856 FALSE
, FALSE
, TRUE
);
6858 && (h
->type
== bfd_link_hash_defined
6859 || h
->type
== bfd_link_hash_defweak
)
6860 && h
->u
.def
.section
->output_section
!= NULL
)
6864 val
= (h
->u
.def
.value
6865 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6866 + h
->u
.def
.section
->output_offset
);
6867 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6868 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6875 /* We couldn't find the entry symbol. Try parsing it as a
6877 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6880 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6881 einfo (_("%F%P: can't set start address\n"));
6887 /* Can't find the entry symbol, and it's not a number. Use
6888 the first address in the text section. */
6889 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6893 einfo (_("%P: warning: cannot find entry symbol %s;"
6894 " defaulting to %V\n"),
6896 bfd_section_vma (ts
));
6897 if (!bfd_set_start_address (link_info
.output_bfd
,
6898 bfd_section_vma (ts
)))
6899 einfo (_("%F%P: can't set start address\n"));
6904 einfo (_("%P: warning: cannot find entry symbol %s;"
6905 " not setting start address\n"),
6912 /* This is a small function used when we want to ignore errors from
6916 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6917 va_list ap ATTRIBUTE_UNUSED
)
6919 /* Don't do anything. */
6922 /* Check that the architecture of all the input files is compatible
6923 with the output file. Also call the backend to let it do any
6924 other checking that is needed. */
6929 lang_input_statement_type
*file
;
6931 const bfd_arch_info_type
*compatible
;
6933 for (file
= (void *) file_chain
.head
;
6937 #if BFD_SUPPORTS_PLUGINS
6938 /* Don't check format of files claimed by plugin. */
6939 if (file
->flags
.claimed
)
6941 #endif /* BFD_SUPPORTS_PLUGINS */
6942 input_bfd
= file
->the_bfd
;
6944 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6945 command_line
.accept_unknown_input_arch
);
6947 /* In general it is not possible to perform a relocatable
6948 link between differing object formats when the input
6949 file has relocations, because the relocations in the
6950 input format may not have equivalent representations in
6951 the output format (and besides BFD does not translate
6952 relocs for other link purposes than a final link). */
6953 if ((bfd_link_relocatable (&link_info
)
6954 || link_info
.emitrelocations
)
6955 && (compatible
== NULL
6956 || (bfd_get_flavour (input_bfd
)
6957 != bfd_get_flavour (link_info
.output_bfd
)))
6958 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6960 einfo (_("%F%P: relocatable linking with relocations from"
6961 " format %s (%pB) to format %s (%pB) is not supported\n"),
6962 bfd_get_target (input_bfd
), input_bfd
,
6963 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6964 /* einfo with %F exits. */
6967 if (compatible
== NULL
)
6969 if (command_line
.warn_mismatch
)
6970 einfo (_("%X%P: %s architecture of input file `%pB'"
6971 " is incompatible with %s output\n"),
6972 bfd_printable_name (input_bfd
), input_bfd
,
6973 bfd_printable_name (link_info
.output_bfd
));
6976 /* If the input bfd has no contents, it shouldn't set the
6977 private data of the output bfd. */
6978 else if ((input_bfd
->flags
& DYNAMIC
) != 0
6979 || bfd_count_sections (input_bfd
) != 0)
6981 bfd_error_handler_type pfn
= NULL
;
6983 /* If we aren't supposed to warn about mismatched input
6984 files, temporarily set the BFD error handler to a
6985 function which will do nothing. We still want to call
6986 bfd_merge_private_bfd_data, since it may set up
6987 information which is needed in the output file. */
6988 if (!command_line
.warn_mismatch
)
6989 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6990 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6992 if (command_line
.warn_mismatch
)
6993 einfo (_("%X%P: failed to merge target specific data"
6994 " of file %pB\n"), input_bfd
);
6996 if (!command_line
.warn_mismatch
)
6997 bfd_set_error_handler (pfn
);
7002 /* Look through all the global common symbols and attach them to the
7003 correct section. The -sort-common command line switch may be used
7004 to roughly sort the entries by alignment. */
7009 if (link_info
.inhibit_common_definition
)
7011 if (bfd_link_relocatable (&link_info
)
7012 && !command_line
.force_common_definition
)
7015 if (!config
.sort_common
)
7016 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7021 if (config
.sort_common
== sort_descending
)
7023 for (power
= 4; power
> 0; power
--)
7024 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7027 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7031 for (power
= 0; power
<= 4; power
++)
7032 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7034 power
= (unsigned int) -1;
7035 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7040 /* Place one common symbol in the correct section. */
7043 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7045 unsigned int power_of_two
;
7049 if (h
->type
!= bfd_link_hash_common
)
7053 power_of_two
= h
->u
.c
.p
->alignment_power
;
7055 if (config
.sort_common
== sort_descending
7056 && power_of_two
< *(unsigned int *) info
)
7058 else if (config
.sort_common
== sort_ascending
7059 && power_of_two
> *(unsigned int *) info
)
7062 section
= h
->u
.c
.p
->section
;
7063 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7064 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7067 if (config
.map_file
!= NULL
)
7069 static bfd_boolean header_printed
;
7074 if (!header_printed
)
7076 minfo (_("\nAllocating common symbols\n"));
7077 minfo (_("Common symbol size file\n\n"));
7078 header_printed
= TRUE
;
7081 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7082 DMGL_ANSI
| DMGL_PARAMS
);
7085 minfo ("%s", h
->root
.string
);
7086 len
= strlen (h
->root
.string
);
7091 len
= strlen (name
);
7107 if (size
<= 0xffffffff)
7108 sprintf (buf
, "%lx", (unsigned long) size
);
7110 sprintf_vma (buf
, size
);
7120 minfo ("%pB\n", section
->owner
);
7126 /* Handle a single orphan section S, placing the orphan into an appropriate
7127 output section. The effects of the --orphan-handling command line
7128 option are handled here. */
7131 ldlang_place_orphan (asection
*s
)
7133 if (config
.orphan_handling
== orphan_handling_discard
)
7135 lang_output_section_statement_type
*os
;
7136 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
7138 if (os
->addr_tree
== NULL
7139 && (bfd_link_relocatable (&link_info
)
7140 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7141 os
->addr_tree
= exp_intop (0);
7142 lang_add_section (&os
->children
, s
, NULL
, os
);
7146 lang_output_section_statement_type
*os
;
7147 const char *name
= s
->name
;
7150 if (config
.orphan_handling
== orphan_handling_error
)
7151 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7154 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7155 constraint
= SPECIAL
;
7157 os
= ldemul_place_orphan (s
, name
, constraint
);
7160 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
7161 if (os
->addr_tree
== NULL
7162 && (bfd_link_relocatable (&link_info
)
7163 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7164 os
->addr_tree
= exp_intop (0);
7165 lang_add_section (&os
->children
, s
, NULL
, os
);
7168 if (config
.orphan_handling
== orphan_handling_warn
)
7169 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7170 "placed in section `%s'\n"),
7171 s
, s
->owner
, os
->name
);
7175 /* Run through the input files and ensure that every input section has
7176 somewhere to go. If one is found without a destination then create
7177 an input request and place it into the statement tree. */
7180 lang_place_orphans (void)
7182 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7186 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7188 if (s
->output_section
== NULL
)
7190 /* This section of the file is not attached, root
7191 around for a sensible place for it to go. */
7193 if (file
->flags
.just_syms
)
7194 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7195 else if (lang_discard_section_p (s
))
7196 s
->output_section
= bfd_abs_section_ptr
;
7197 else if (strcmp (s
->name
, "COMMON") == 0)
7199 /* This is a lonely common section which must have
7200 come from an archive. We attach to the section
7201 with the wildcard. */
7202 if (!bfd_link_relocatable (&link_info
)
7203 || command_line
.force_common_definition
)
7205 if (default_common_section
== NULL
)
7206 default_common_section
7207 = lang_output_section_statement_lookup (".bss", 0,
7209 lang_add_section (&default_common_section
->children
, s
,
7210 NULL
, default_common_section
);
7214 ldlang_place_orphan (s
);
7221 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7223 flagword
*ptr_flags
;
7225 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7231 /* PR 17900: An exclamation mark in the attributes reverses
7232 the sense of any of the attributes that follow. */
7235 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7239 *ptr_flags
|= SEC_ALLOC
;
7243 *ptr_flags
|= SEC_READONLY
;
7247 *ptr_flags
|= SEC_DATA
;
7251 *ptr_flags
|= SEC_CODE
;
7256 *ptr_flags
|= SEC_LOAD
;
7260 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7268 /* Call a function on each real input file. This function will be
7269 called on an archive, but not on the elements. */
7272 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7274 lang_input_statement_type
*f
;
7276 for (f
= (void *) input_file_chain
.head
;
7278 f
= f
->next_real_file
)
7283 /* Call a function on each real file. The function will be called on
7284 all the elements of an archive which are included in the link, but
7285 will not be called on the archive file itself. */
7288 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7290 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7298 ldlang_add_file (lang_input_statement_type
*entry
)
7300 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7302 /* The BFD linker needs to have a list of all input BFDs involved in
7304 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7305 && entry
->the_bfd
->link
.next
== NULL
);
7306 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7308 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7309 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7310 bfd_set_usrdata (entry
->the_bfd
, entry
);
7311 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7313 /* Look through the sections and check for any which should not be
7314 included in the link. We need to do this now, so that we can
7315 notice when the backend linker tries to report multiple
7316 definition errors for symbols which are in sections we aren't
7317 going to link. FIXME: It might be better to entirely ignore
7318 symbols which are defined in sections which are going to be
7319 discarded. This would require modifying the backend linker for
7320 each backend which might set the SEC_LINK_ONCE flag. If we do
7321 this, we should probably handle SEC_EXCLUDE in the same way. */
7323 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7327 lang_add_output (const char *name
, int from_script
)
7329 /* Make -o on command line override OUTPUT in script. */
7330 if (!had_output_filename
|| !from_script
)
7332 output_filename
= name
;
7333 had_output_filename
= TRUE
;
7337 lang_output_section_statement_type
*
7338 lang_enter_output_section_statement (const char *output_section_statement_name
,
7339 etree_type
*address_exp
,
7340 enum section_type sectype
,
7342 etree_type
*subalign
,
7345 int align_with_input
)
7347 lang_output_section_statement_type
*os
;
7349 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7351 current_section
= os
;
7353 if (os
->addr_tree
== NULL
)
7355 os
->addr_tree
= address_exp
;
7357 os
->sectype
= sectype
;
7358 if (sectype
!= noload_section
)
7359 os
->flags
= SEC_NO_FLAGS
;
7361 os
->flags
= SEC_NEVER_LOAD
;
7362 os
->block_value
= 1;
7364 /* Make next things chain into subchain of this. */
7365 push_stat_ptr (&os
->children
);
7367 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7368 if (os
->align_lma_with_input
&& align
!= NULL
)
7369 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7372 os
->subsection_alignment
= subalign
;
7373 os
->section_alignment
= align
;
7375 os
->load_base
= ebase
;
7382 lang_output_statement_type
*new_stmt
;
7384 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7385 new_stmt
->name
= output_filename
;
7388 /* Reset the current counters in the regions. */
7391 lang_reset_memory_regions (void)
7393 lang_memory_region_type
*p
= lang_memory_region_list
;
7395 lang_output_section_statement_type
*os
;
7397 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7399 p
->current
= p
->origin
;
7403 for (os
= (void *) lang_os_list
.head
;
7407 os
->processed_vma
= FALSE
;
7408 os
->processed_lma
= FALSE
;
7411 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7413 /* Save the last size for possible use by bfd_relax_section. */
7414 o
->rawsize
= o
->size
;
7415 if (!(o
->flags
& SEC_FIXED_SIZE
))
7420 /* Worker for lang_gc_sections_1. */
7423 gc_section_callback (lang_wild_statement_type
*ptr
,
7424 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7426 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7427 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7428 void *data ATTRIBUTE_UNUSED
)
7430 /* If the wild pattern was marked KEEP, the member sections
7431 should be as well. */
7432 if (ptr
->keep_sections
)
7433 section
->flags
|= SEC_KEEP
;
7436 /* Iterate over sections marking them against GC. */
7439 lang_gc_sections_1 (lang_statement_union_type
*s
)
7441 for (; s
!= NULL
; s
= s
->header
.next
)
7443 switch (s
->header
.type
)
7445 case lang_wild_statement_enum
:
7446 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7448 case lang_constructors_statement_enum
:
7449 lang_gc_sections_1 (constructor_list
.head
);
7451 case lang_output_section_statement_enum
:
7452 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7454 case lang_group_statement_enum
:
7455 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7464 lang_gc_sections (void)
7466 /* Keep all sections so marked in the link script. */
7467 lang_gc_sections_1 (statement_list
.head
);
7469 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7470 the special case of debug info. (See bfd/stabs.c)
7471 Twiddle the flag here, to simplify later linker code. */
7472 if (bfd_link_relocatable (&link_info
))
7474 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7477 #if BFD_SUPPORTS_PLUGINS
7478 if (f
->flags
.claimed
)
7481 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7482 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7483 sec
->flags
&= ~SEC_EXCLUDE
;
7487 if (link_info
.gc_sections
)
7488 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7491 /* Worker for lang_find_relro_sections_1. */
7494 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7495 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7497 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7498 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7501 /* Discarded, excluded and ignored sections effectively have zero
7503 if (section
->output_section
!= NULL
7504 && section
->output_section
->owner
== link_info
.output_bfd
7505 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7506 && !IGNORE_SECTION (section
)
7507 && section
->size
!= 0)
7509 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7510 *has_relro_section
= TRUE
;
7514 /* Iterate over sections for relro sections. */
7517 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7518 seg_align_type
*seg
,
7519 bfd_boolean
*has_relro_section
)
7521 if (*has_relro_section
)
7524 for (; s
!= NULL
; s
= s
->header
.next
)
7526 if (s
== seg
->relro_end_stat
)
7529 switch (s
->header
.type
)
7531 case lang_wild_statement_enum
:
7532 walk_wild (&s
->wild_statement
,
7533 find_relro_section_callback
,
7536 case lang_constructors_statement_enum
:
7537 lang_find_relro_sections_1 (constructor_list
.head
,
7538 seg
, has_relro_section
);
7540 case lang_output_section_statement_enum
:
7541 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7542 seg
, has_relro_section
);
7544 case lang_group_statement_enum
:
7545 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7546 seg
, has_relro_section
);
7555 lang_find_relro_sections (void)
7557 bfd_boolean has_relro_section
= FALSE
;
7559 /* Check all sections in the link script. */
7561 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7562 &expld
.dataseg
, &has_relro_section
);
7564 if (!has_relro_section
)
7565 link_info
.relro
= FALSE
;
7568 /* Relax all sections until bfd_relax_section gives up. */
7571 lang_relax_sections (bfd_boolean need_layout
)
7573 if (RELAXATION_ENABLED
)
7575 /* We may need more than one relaxation pass. */
7576 int i
= link_info
.relax_pass
;
7578 /* The backend can use it to determine the current pass. */
7579 link_info
.relax_pass
= 0;
7583 /* Keep relaxing until bfd_relax_section gives up. */
7584 bfd_boolean relax_again
;
7586 link_info
.relax_trip
= -1;
7589 link_info
.relax_trip
++;
7591 /* Note: pe-dll.c does something like this also. If you find
7592 you need to change this code, you probably need to change
7593 pe-dll.c also. DJ */
7595 /* Do all the assignments with our current guesses as to
7597 lang_do_assignments (lang_assigning_phase_enum
);
7599 /* We must do this after lang_do_assignments, because it uses
7601 lang_reset_memory_regions ();
7603 /* Perform another relax pass - this time we know where the
7604 globals are, so can make a better guess. */
7605 relax_again
= FALSE
;
7606 lang_size_sections (&relax_again
, FALSE
);
7608 while (relax_again
);
7610 link_info
.relax_pass
++;
7617 /* Final extra sizing to report errors. */
7618 lang_do_assignments (lang_assigning_phase_enum
);
7619 lang_reset_memory_regions ();
7620 lang_size_sections (NULL
, TRUE
);
7624 #if BFD_SUPPORTS_PLUGINS
7625 /* Find the insert point for the plugin's replacement files. We
7626 place them after the first claimed real object file, or if the
7627 first claimed object is an archive member, after the last real
7628 object file immediately preceding the archive. In the event
7629 no objects have been claimed at all, we return the first dummy
7630 object file on the list as the insert point; that works, but
7631 the callee must be careful when relinking the file_chain as it
7632 is not actually on that chain, only the statement_list and the
7633 input_file list; in that case, the replacement files must be
7634 inserted at the head of the file_chain. */
7636 static lang_input_statement_type
*
7637 find_replacements_insert_point (bfd_boolean
*before
)
7639 lang_input_statement_type
*claim1
, *lastobject
;
7640 lastobject
= (void *) input_file_chain
.head
;
7641 for (claim1
= (void *) file_chain
.head
;
7643 claim1
= claim1
->next
)
7645 if (claim1
->flags
.claimed
)
7647 *before
= claim1
->flags
.claim_archive
;
7648 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7650 /* Update lastobject if this is a real object file. */
7651 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7652 lastobject
= claim1
;
7654 /* No files were claimed by the plugin. Choose the last object
7655 file found on the list (maybe the first, dummy entry) as the
7661 /* Find where to insert ADD, an archive element or shared library
7662 added during a rescan. */
7664 static lang_input_statement_type
**
7665 find_rescan_insertion (lang_input_statement_type
*add
)
7667 bfd
*add_bfd
= add
->the_bfd
;
7668 lang_input_statement_type
*f
;
7669 lang_input_statement_type
*last_loaded
= NULL
;
7670 lang_input_statement_type
*before
= NULL
;
7671 lang_input_statement_type
**iter
= NULL
;
7673 if (add_bfd
->my_archive
!= NULL
)
7674 add_bfd
= add_bfd
->my_archive
;
7676 /* First look through the input file chain, to find an object file
7677 before the one we've rescanned. Normal object files always
7678 appear on both the input file chain and the file chain, so this
7679 lets us get quickly to somewhere near the correct place on the
7680 file chain if it is full of archive elements. Archives don't
7681 appear on the file chain, but if an element has been extracted
7682 then their input_statement->next points at it. */
7683 for (f
= (void *) input_file_chain
.head
;
7685 f
= f
->next_real_file
)
7687 if (f
->the_bfd
== add_bfd
)
7689 before
= last_loaded
;
7690 if (f
->next
!= NULL
)
7691 return &f
->next
->next
;
7693 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7697 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7699 iter
= &(*iter
)->next
)
7700 if (!(*iter
)->flags
.claim_archive
7701 && (*iter
)->the_bfd
->my_archive
== NULL
)
7707 /* Insert SRCLIST into DESTLIST after given element by chaining
7708 on FIELD as the next-pointer. (Counterintuitively does not need
7709 a pointer to the actual after-node itself, just its chain field.) */
7712 lang_list_insert_after (lang_statement_list_type
*destlist
,
7713 lang_statement_list_type
*srclist
,
7714 lang_statement_union_type
**field
)
7716 *(srclist
->tail
) = *field
;
7717 *field
= srclist
->head
;
7718 if (destlist
->tail
== field
)
7719 destlist
->tail
= srclist
->tail
;
7722 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7723 was taken as a copy of it and leave them in ORIGLIST. */
7726 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7727 lang_statement_list_type
*origlist
)
7729 union lang_statement_union
**savetail
;
7730 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7731 ASSERT (origlist
->head
== destlist
->head
);
7732 savetail
= origlist
->tail
;
7733 origlist
->head
= *(savetail
);
7734 origlist
->tail
= destlist
->tail
;
7735 destlist
->tail
= savetail
;
7739 static lang_statement_union_type
**
7740 find_next_input_statement (lang_statement_union_type
**s
)
7742 for ( ; *s
; s
= &(*s
)->header
.next
)
7744 lang_statement_union_type
**t
;
7745 switch ((*s
)->header
.type
)
7747 case lang_input_statement_enum
:
7749 case lang_wild_statement_enum
:
7750 t
= &(*s
)->wild_statement
.children
.head
;
7752 case lang_group_statement_enum
:
7753 t
= &(*s
)->group_statement
.children
.head
;
7755 case lang_output_section_statement_enum
:
7756 t
= &(*s
)->output_section_statement
.children
.head
;
7761 t
= find_next_input_statement (t
);
7767 #endif /* BFD_SUPPORTS_PLUGINS */
7769 /* Add NAME to the list of garbage collection entry points. */
7772 lang_add_gc_name (const char *name
)
7774 struct bfd_sym_chain
*sym
;
7779 sym
= stat_alloc (sizeof (*sym
));
7781 sym
->next
= link_info
.gc_sym_list
;
7783 link_info
.gc_sym_list
= sym
;
7786 /* Check relocations. */
7789 lang_check_relocs (void)
7791 if (link_info
.check_relocs_after_open_input
)
7795 for (abfd
= link_info
.input_bfds
;
7796 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7797 if (!bfd_link_check_relocs (abfd
, &link_info
))
7799 /* No object output, fail return. */
7800 config
.make_executable
= FALSE
;
7801 /* Note: we do not abort the loop, but rather
7802 continue the scan in case there are other
7803 bad relocations to report. */
7808 /* Look through all output sections looking for places where we can
7809 propagate forward the lma region. */
7812 lang_propagate_lma_regions (void)
7814 lang_output_section_statement_type
*os
;
7816 for (os
= (void *) lang_os_list
.head
;
7820 if (os
->prev
!= NULL
7821 && os
->lma_region
== NULL
7822 && os
->load_base
== NULL
7823 && os
->addr_tree
== NULL
7824 && os
->region
== os
->prev
->region
)
7825 os
->lma_region
= os
->prev
->lma_region
;
7832 /* Finalize dynamic list. */
7833 if (link_info
.dynamic_list
)
7834 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7836 current_target
= default_target
;
7838 /* Open the output file. */
7839 lang_for_each_statement (ldlang_open_output
);
7842 ldemul_create_output_section_statements ();
7844 /* Add to the hash table all undefineds on the command line. */
7845 lang_place_undefineds ();
7847 if (!bfd_section_already_linked_table_init ())
7848 einfo (_("%F%P: can not create hash table: %E\n"));
7850 /* Create a bfd for each input file. */
7851 current_target
= default_target
;
7852 lang_statement_iteration
++;
7853 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7854 /* open_input_bfds also handles assignments, so we can give values
7855 to symbolic origin/length now. */
7856 lang_do_memory_regions ();
7858 #if BFD_SUPPORTS_PLUGINS
7859 if (link_info
.lto_plugin_active
)
7861 lang_statement_list_type added
;
7862 lang_statement_list_type files
, inputfiles
;
7864 /* Now all files are read, let the plugin(s) decide if there
7865 are any more to be added to the link before we call the
7866 emulation's after_open hook. We create a private list of
7867 input statements for this purpose, which we will eventually
7868 insert into the global statement list after the first claimed
7871 /* We need to manipulate all three chains in synchrony. */
7873 inputfiles
= input_file_chain
;
7874 if (plugin_call_all_symbols_read ())
7875 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7876 plugin_error_plugin ());
7877 /* Open any newly added files, updating the file chains. */
7878 plugin_undefs
= link_info
.hash
->undefs_tail
;
7879 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7880 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7881 plugin_undefs
= NULL
;
7882 /* Restore the global list pointer now they have all been added. */
7883 lang_list_remove_tail (stat_ptr
, &added
);
7884 /* And detach the fresh ends of the file lists. */
7885 lang_list_remove_tail (&file_chain
, &files
);
7886 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7887 /* Were any new files added? */
7888 if (added
.head
!= NULL
)
7890 /* If so, we will insert them into the statement list immediately
7891 after the first input file that was claimed by the plugin,
7892 unless that file was an archive in which case it is inserted
7893 immediately before. */
7895 lang_statement_union_type
**prev
;
7896 plugin_insert
= find_replacements_insert_point (&before
);
7897 /* If a plugin adds input files without having claimed any, we
7898 don't really have a good idea where to place them. Just putting
7899 them at the start or end of the list is liable to leave them
7900 outside the crtbegin...crtend range. */
7901 ASSERT (plugin_insert
!= NULL
);
7902 /* Splice the new statement list into the old one. */
7903 prev
= &plugin_insert
->header
.next
;
7906 prev
= find_next_input_statement (prev
);
7907 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7909 /* We didn't find the expected input statement.
7910 Fall back to adding after plugin_insert. */
7911 prev
= &plugin_insert
->header
.next
;
7914 lang_list_insert_after (stat_ptr
, &added
, prev
);
7915 /* Likewise for the file chains. */
7916 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7917 (void *) &plugin_insert
->next_real_file
);
7918 /* We must be careful when relinking file_chain; we may need to
7919 insert the new files at the head of the list if the insert
7920 point chosen is the dummy first input file. */
7921 if (plugin_insert
->filename
)
7922 lang_list_insert_after (&file_chain
, &files
,
7923 (void *) &plugin_insert
->next
);
7925 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7927 /* Rescan archives in case new undefined symbols have appeared. */
7929 lang_statement_iteration
++;
7930 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7931 lang_list_remove_tail (&file_chain
, &files
);
7932 while (files
.head
!= NULL
)
7934 lang_input_statement_type
**insert
;
7935 lang_input_statement_type
**iter
, *temp
;
7938 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7939 /* All elements from an archive can be added at once. */
7940 iter
= &files
.head
->input_statement
.next
;
7941 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7942 if (my_arch
!= NULL
)
7943 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7944 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7947 *insert
= &files
.head
->input_statement
;
7948 files
.head
= (lang_statement_union_type
*) *iter
;
7950 if (my_arch
!= NULL
)
7952 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7954 parent
->next
= (lang_input_statement_type
*)
7956 - offsetof (lang_input_statement_type
, next
));
7961 #endif /* BFD_SUPPORTS_PLUGINS */
7963 /* Make sure that nobody has tried to add a symbol to this list
7965 ASSERT (link_info
.gc_sym_list
== NULL
);
7967 link_info
.gc_sym_list
= &entry_symbol
;
7969 if (entry_symbol
.name
== NULL
)
7971 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7973 /* entry_symbol is normally initialied by a ENTRY definition in the
7974 linker script or the -e command line option. But if neither of
7975 these have been used, the target specific backend may still have
7976 provided an entry symbol via a call to lang_default_entry().
7977 Unfortunately this value will not be processed until lang_end()
7978 is called, long after this function has finished. So detect this
7979 case here and add the target's entry symbol to the list of starting
7980 points for garbage collection resolution. */
7981 lang_add_gc_name (entry_symbol_default
);
7984 lang_add_gc_name (link_info
.init_function
);
7985 lang_add_gc_name (link_info
.fini_function
);
7987 ldemul_after_open ();
7988 if (config
.map_file
!= NULL
)
7989 lang_print_asneeded ();
7993 bfd_section_already_linked_table_free ();
7995 /* Make sure that we're not mixing architectures. We call this
7996 after all the input files have been opened, but before we do any
7997 other processing, so that any operations merge_private_bfd_data
7998 does on the output file will be known during the rest of the
8002 /* Handle .exports instead of a version script if we're told to do so. */
8003 if (command_line
.version_exports_section
)
8004 lang_do_version_exports_section ();
8006 /* Build all sets based on the information gathered from the input
8008 ldctor_build_sets ();
8010 /* Give initial values for __start and __stop symbols, so that ELF
8011 gc_sections will keep sections referenced by these symbols. Must
8012 be done before lang_do_assignments below. */
8013 if (config
.build_constructors
)
8014 lang_init_start_stop ();
8016 /* PR 13683: We must rerun the assignments prior to running garbage
8017 collection in order to make sure that all symbol aliases are resolved. */
8018 lang_do_assignments (lang_mark_phase_enum
);
8019 expld
.phase
= lang_first_phase_enum
;
8021 /* Size up the common data. */
8024 /* Remove unreferenced sections if asked to. */
8025 lang_gc_sections ();
8027 /* Check relocations. */
8028 lang_check_relocs ();
8030 ldemul_after_check_relocs ();
8032 /* Update wild statements. */
8033 update_wild_statements (statement_list
.head
);
8035 /* Run through the contours of the script and attach input sections
8036 to the correct output sections. */
8037 lang_statement_iteration
++;
8038 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8040 /* Start at the statement immediately after the special abs_section
8041 output statement, so that it isn't reordered. */
8042 process_insert_statements (&lang_os_list
.head
->header
.next
);
8044 ldemul_before_place_orphans ();
8046 /* Find any sections not attached explicitly and handle them. */
8047 lang_place_orphans ();
8049 if (!bfd_link_relocatable (&link_info
))
8053 /* Merge SEC_MERGE sections. This has to be done after GC of
8054 sections, so that GCed sections are not merged, but before
8055 assigning dynamic symbols, since removing whole input sections
8057 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8059 /* Look for a text section and set the readonly attribute in it. */
8060 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8064 if (config
.text_read_only
)
8065 found
->flags
|= SEC_READONLY
;
8067 found
->flags
&= ~SEC_READONLY
;
8071 /* Merge together CTF sections. After this, only the symtab-dependent
8072 function and data object sections need adjustment. */
8075 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8076 examining things laid out late, like the strtab. */
8079 /* Copy forward lma regions for output sections in same lma region. */
8080 lang_propagate_lma_regions ();
8082 /* Defining __start/__stop symbols early for --gc-sections to work
8083 around a glibc build problem can result in these symbols being
8084 defined when they should not be. Fix them now. */
8085 if (config
.build_constructors
)
8086 lang_undef_start_stop ();
8088 /* Define .startof./.sizeof. symbols with preliminary values before
8089 dynamic symbols are created. */
8090 if (!bfd_link_relocatable (&link_info
))
8091 lang_init_startof_sizeof ();
8093 /* Do anything special before sizing sections. This is where ELF
8094 and other back-ends size dynamic sections. */
8095 ldemul_before_allocation ();
8097 /* We must record the program headers before we try to fix the
8098 section positions, since they will affect SIZEOF_HEADERS. */
8099 lang_record_phdrs ();
8101 /* Check relro sections. */
8102 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8103 lang_find_relro_sections ();
8105 /* Size up the sections. */
8106 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8108 /* See if anything special should be done now we know how big
8109 everything is. This is where relaxation is done. */
8110 ldemul_after_allocation ();
8112 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8113 lang_finalize_start_stop ();
8115 /* Do all the assignments again, to report errors. Assignment
8116 statements are processed multiple times, updating symbols; In
8117 open_input_bfds, lang_do_assignments, and lang_size_sections.
8118 Since lang_relax_sections calls lang_do_assignments, symbols are
8119 also updated in ldemul_after_allocation. */
8120 lang_do_assignments (lang_final_phase_enum
);
8124 /* Convert absolute symbols to section relative. */
8125 ldexp_finalize_syms ();
8127 /* Make sure that the section addresses make sense. */
8128 if (command_line
.check_section_addresses
)
8129 lang_check_section_addresses ();
8131 /* Check any required symbols are known. */
8132 ldlang_check_require_defined_symbols ();
8137 /* EXPORTED TO YACC */
8140 lang_add_wild (struct wildcard_spec
*filespec
,
8141 struct wildcard_list
*section_list
,
8142 bfd_boolean keep_sections
)
8144 struct wildcard_list
*curr
, *next
;
8145 lang_wild_statement_type
*new_stmt
;
8147 /* Reverse the list as the parser puts it back to front. */
8148 for (curr
= section_list
, section_list
= NULL
;
8150 section_list
= curr
, curr
= next
)
8153 curr
->next
= section_list
;
8156 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8158 if (strcmp (filespec
->name
, "*") == 0)
8159 filespec
->name
= NULL
;
8160 else if (!wildcardp (filespec
->name
))
8161 lang_has_input_file
= TRUE
;
8164 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8165 new_stmt
->filename
= NULL
;
8166 new_stmt
->filenames_sorted
= FALSE
;
8167 new_stmt
->section_flag_list
= NULL
;
8168 new_stmt
->exclude_name_list
= NULL
;
8169 if (filespec
!= NULL
)
8171 new_stmt
->filename
= filespec
->name
;
8172 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8173 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8174 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8176 new_stmt
->section_list
= section_list
;
8177 new_stmt
->keep_sections
= keep_sections
;
8178 lang_list_init (&new_stmt
->children
);
8179 analyze_walk_wild_section_handler (new_stmt
);
8183 lang_section_start (const char *name
, etree_type
*address
,
8184 const segment_type
*segment
)
8186 lang_address_statement_type
*ad
;
8188 ad
= new_stat (lang_address_statement
, stat_ptr
);
8189 ad
->section_name
= name
;
8190 ad
->address
= address
;
8191 ad
->segment
= segment
;
8194 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8195 because of a -e argument on the command line, or zero if this is
8196 called by ENTRY in a linker script. Command line arguments take
8200 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8202 if (entry_symbol
.name
== NULL
8204 || !entry_from_cmdline
)
8206 entry_symbol
.name
= name
;
8207 entry_from_cmdline
= cmdline
;
8211 /* Set the default start symbol to NAME. .em files should use this,
8212 not lang_add_entry, to override the use of "start" if neither the
8213 linker script nor the command line specifies an entry point. NAME
8214 must be permanently allocated. */
8216 lang_default_entry (const char *name
)
8218 entry_symbol_default
= name
;
8222 lang_add_target (const char *name
)
8224 lang_target_statement_type
*new_stmt
;
8226 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8227 new_stmt
->target
= name
;
8231 lang_add_map (const char *name
)
8238 map_option_f
= TRUE
;
8246 lang_add_fill (fill_type
*fill
)
8248 lang_fill_statement_type
*new_stmt
;
8250 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8251 new_stmt
->fill
= fill
;
8255 lang_add_data (int type
, union etree_union
*exp
)
8257 lang_data_statement_type
*new_stmt
;
8259 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8260 new_stmt
->exp
= exp
;
8261 new_stmt
->type
= type
;
8264 /* Create a new reloc statement. RELOC is the BFD relocation type to
8265 generate. HOWTO is the corresponding howto structure (we could
8266 look this up, but the caller has already done so). SECTION is the
8267 section to generate a reloc against, or NAME is the name of the
8268 symbol to generate a reloc against. Exactly one of SECTION and
8269 NAME must be NULL. ADDEND is an expression for the addend. */
8272 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8273 reloc_howto_type
*howto
,
8276 union etree_union
*addend
)
8278 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8282 p
->section
= section
;
8284 p
->addend_exp
= addend
;
8286 p
->addend_value
= 0;
8287 p
->output_section
= NULL
;
8288 p
->output_offset
= 0;
8291 lang_assignment_statement_type
*
8292 lang_add_assignment (etree_type
*exp
)
8294 lang_assignment_statement_type
*new_stmt
;
8296 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8297 new_stmt
->exp
= exp
;
8302 lang_add_attribute (enum statement_enum attribute
)
8304 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8308 lang_startup (const char *name
)
8310 if (first_file
->filename
!= NULL
)
8312 einfo (_("%F%P: multiple STARTUP files\n"));
8314 first_file
->filename
= name
;
8315 first_file
->local_sym_name
= name
;
8316 first_file
->flags
.real
= TRUE
;
8320 lang_float (bfd_boolean maybe
)
8322 lang_float_flag
= maybe
;
8326 /* Work out the load- and run-time regions from a script statement, and
8327 store them in *LMA_REGION and *REGION respectively.
8329 MEMSPEC is the name of the run-time region, or the value of
8330 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8331 LMA_MEMSPEC is the name of the load-time region, or null if the
8332 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8333 had an explicit load address.
8335 It is an error to specify both a load region and a load address. */
8338 lang_get_regions (lang_memory_region_type
**region
,
8339 lang_memory_region_type
**lma_region
,
8340 const char *memspec
,
8341 const char *lma_memspec
,
8342 bfd_boolean have_lma
,
8343 bfd_boolean have_vma
)
8345 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8347 /* If no runtime region or VMA has been specified, but the load region
8348 has been specified, then use the load region for the runtime region
8350 if (lma_memspec
!= NULL
8352 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8353 *region
= *lma_region
;
8355 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8357 if (have_lma
&& lma_memspec
!= 0)
8358 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8363 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8364 lang_output_section_phdr_list
*phdrs
,
8365 const char *lma_memspec
)
8367 lang_get_regions (¤t_section
->region
,
8368 ¤t_section
->lma_region
,
8369 memspec
, lma_memspec
,
8370 current_section
->load_base
!= NULL
,
8371 current_section
->addr_tree
!= NULL
);
8373 current_section
->fill
= fill
;
8374 current_section
->phdrs
= phdrs
;
8378 /* Set the output format type. -oformat overrides scripts. */
8381 lang_add_output_format (const char *format
,
8386 if (output_target
== NULL
|| !from_script
)
8388 if (command_line
.endian
== ENDIAN_BIG
8391 else if (command_line
.endian
== ENDIAN_LITTLE
8395 output_target
= format
;
8400 lang_add_insert (const char *where
, int is_before
)
8402 lang_insert_statement_type
*new_stmt
;
8404 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8405 new_stmt
->where
= where
;
8406 new_stmt
->is_before
= is_before
;
8407 saved_script_handle
= previous_script_handle
;
8410 /* Enter a group. This creates a new lang_group_statement, and sets
8411 stat_ptr to build new statements within the group. */
8414 lang_enter_group (void)
8416 lang_group_statement_type
*g
;
8418 g
= new_stat (lang_group_statement
, stat_ptr
);
8419 lang_list_init (&g
->children
);
8420 push_stat_ptr (&g
->children
);
8423 /* Leave a group. This just resets stat_ptr to start writing to the
8424 regular list of statements again. Note that this will not work if
8425 groups can occur inside anything else which can adjust stat_ptr,
8426 but currently they can't. */
8429 lang_leave_group (void)
8434 /* Add a new program header. This is called for each entry in a PHDRS
8435 command in a linker script. */
8438 lang_new_phdr (const char *name
,
8440 bfd_boolean filehdr
,
8445 struct lang_phdr
*n
, **pp
;
8448 n
= stat_alloc (sizeof (struct lang_phdr
));
8451 n
->type
= exp_get_vma (type
, 0, "program header type");
8452 n
->filehdr
= filehdr
;
8457 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8459 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8462 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8464 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8465 " when prior PT_LOAD headers lack them\n"), NULL
);
8472 /* Record the program header information in the output BFD. FIXME: We
8473 should not be calling an ELF specific function here. */
8476 lang_record_phdrs (void)
8480 lang_output_section_phdr_list
*last
;
8481 struct lang_phdr
*l
;
8482 lang_output_section_statement_type
*os
;
8485 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8488 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8495 for (os
= (void *) lang_os_list
.head
;
8499 lang_output_section_phdr_list
*pl
;
8501 if (os
->constraint
< 0)
8509 if (os
->sectype
== noload_section
8510 || os
->bfd_section
== NULL
8511 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8514 /* Don't add orphans to PT_INTERP header. */
8520 lang_output_section_statement_type
*tmp_os
;
8522 /* If we have not run across a section with a program
8523 header assigned to it yet, then scan forwards to find
8524 one. This prevents inconsistencies in the linker's
8525 behaviour when a script has specified just a single
8526 header and there are sections in that script which are
8527 not assigned to it, and which occur before the first
8528 use of that header. See here for more details:
8529 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8530 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8533 last
= tmp_os
->phdrs
;
8537 einfo (_("%F%P: no sections assigned to phdrs\n"));
8542 if (os
->bfd_section
== NULL
)
8545 for (; pl
!= NULL
; pl
= pl
->next
)
8547 if (strcmp (pl
->name
, l
->name
) == 0)
8552 secs
= (asection
**) xrealloc (secs
,
8553 alc
* sizeof (asection
*));
8555 secs
[c
] = os
->bfd_section
;
8562 if (l
->flags
== NULL
)
8565 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8570 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8572 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8573 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8574 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8575 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8580 /* Make sure all the phdr assignments succeeded. */
8581 for (os
= (void *) lang_os_list
.head
;
8585 lang_output_section_phdr_list
*pl
;
8587 if (os
->constraint
< 0
8588 || os
->bfd_section
== NULL
)
8591 for (pl
= os
->phdrs
;
8594 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8595 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8596 os
->name
, pl
->name
);
8600 /* Record a list of sections which may not be cross referenced. */
8603 lang_add_nocrossref (lang_nocrossref_type
*l
)
8605 struct lang_nocrossrefs
*n
;
8607 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8608 n
->next
= nocrossref_list
;
8610 n
->onlyfirst
= FALSE
;
8611 nocrossref_list
= n
;
8613 /* Set notice_all so that we get informed about all symbols. */
8614 link_info
.notice_all
= TRUE
;
8617 /* Record a section that cannot be referenced from a list of sections. */
8620 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8622 lang_add_nocrossref (l
);
8623 nocrossref_list
->onlyfirst
= TRUE
;
8626 /* Overlay handling. We handle overlays with some static variables. */
8628 /* The overlay virtual address. */
8629 static etree_type
*overlay_vma
;
8630 /* And subsection alignment. */
8631 static etree_type
*overlay_subalign
;
8633 /* An expression for the maximum section size seen so far. */
8634 static etree_type
*overlay_max
;
8636 /* A list of all the sections in this overlay. */
8638 struct overlay_list
{
8639 struct overlay_list
*next
;
8640 lang_output_section_statement_type
*os
;
8643 static struct overlay_list
*overlay_list
;
8645 /* Start handling an overlay. */
8648 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8650 /* The grammar should prevent nested overlays from occurring. */
8651 ASSERT (overlay_vma
== NULL
8652 && overlay_subalign
== NULL
8653 && overlay_max
== NULL
);
8655 overlay_vma
= vma_expr
;
8656 overlay_subalign
= subalign
;
8659 /* Start a section in an overlay. We handle this by calling
8660 lang_enter_output_section_statement with the correct VMA.
8661 lang_leave_overlay sets up the LMA and memory regions. */
8664 lang_enter_overlay_section (const char *name
)
8666 struct overlay_list
*n
;
8669 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8670 0, overlay_subalign
, 0, 0, 0);
8672 /* If this is the first section, then base the VMA of future
8673 sections on this one. This will work correctly even if `.' is
8674 used in the addresses. */
8675 if (overlay_list
== NULL
)
8676 overlay_vma
= exp_nameop (ADDR
, name
);
8678 /* Remember the section. */
8679 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8680 n
->os
= current_section
;
8681 n
->next
= overlay_list
;
8684 size
= exp_nameop (SIZEOF
, name
);
8686 /* Arrange to work out the maximum section end address. */
8687 if (overlay_max
== NULL
)
8690 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8693 /* Finish a section in an overlay. There isn't any special to do
8697 lang_leave_overlay_section (fill_type
*fill
,
8698 lang_output_section_phdr_list
*phdrs
)
8705 name
= current_section
->name
;
8707 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8708 region and that no load-time region has been specified. It doesn't
8709 really matter what we say here, since lang_leave_overlay will
8711 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8713 /* Define the magic symbols. */
8715 clean
= (char *) xmalloc (strlen (name
) + 1);
8717 for (s1
= name
; *s1
!= '\0'; s1
++)
8718 if (ISALNUM (*s1
) || *s1
== '_')
8722 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8723 sprintf (buf
, "__load_start_%s", clean
);
8724 lang_add_assignment (exp_provide (buf
,
8725 exp_nameop (LOADADDR
, name
),
8728 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8729 sprintf (buf
, "__load_stop_%s", clean
);
8730 lang_add_assignment (exp_provide (buf
,
8732 exp_nameop (LOADADDR
, name
),
8733 exp_nameop (SIZEOF
, name
)),
8739 /* Finish an overlay. If there are any overlay wide settings, this
8740 looks through all the sections in the overlay and sets them. */
8743 lang_leave_overlay (etree_type
*lma_expr
,
8746 const char *memspec
,
8747 lang_output_section_phdr_list
*phdrs
,
8748 const char *lma_memspec
)
8750 lang_memory_region_type
*region
;
8751 lang_memory_region_type
*lma_region
;
8752 struct overlay_list
*l
;
8753 lang_nocrossref_type
*nocrossref
;
8755 lang_get_regions (®ion
, &lma_region
,
8756 memspec
, lma_memspec
,
8757 lma_expr
!= NULL
, FALSE
);
8761 /* After setting the size of the last section, set '.' to end of the
8763 if (overlay_list
!= NULL
)
8765 overlay_list
->os
->update_dot
= 1;
8766 overlay_list
->os
->update_dot_tree
8767 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8773 struct overlay_list
*next
;
8775 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8778 l
->os
->region
= region
;
8779 l
->os
->lma_region
= lma_region
;
8781 /* The first section has the load address specified in the
8782 OVERLAY statement. The rest are worked out from that.
8783 The base address is not needed (and should be null) if
8784 an LMA region was specified. */
8787 l
->os
->load_base
= lma_expr
;
8788 l
->os
->sectype
= first_overlay_section
;
8790 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8791 l
->os
->phdrs
= phdrs
;
8795 lang_nocrossref_type
*nc
;
8797 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8798 nc
->name
= l
->os
->name
;
8799 nc
->next
= nocrossref
;
8808 if (nocrossref
!= NULL
)
8809 lang_add_nocrossref (nocrossref
);
8812 overlay_list
= NULL
;
8814 overlay_subalign
= NULL
;
8817 /* Version handling. This is only useful for ELF. */
8819 /* If PREV is NULL, return first version pattern matching particular symbol.
8820 If PREV is non-NULL, return first version pattern matching particular
8821 symbol after PREV (previously returned by lang_vers_match). */
8823 static struct bfd_elf_version_expr
*
8824 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8825 struct bfd_elf_version_expr
*prev
,
8829 const char *cxx_sym
= sym
;
8830 const char *java_sym
= sym
;
8831 struct bfd_elf_version_expr
*expr
= NULL
;
8832 enum demangling_styles curr_style
;
8834 curr_style
= CURRENT_DEMANGLING_STYLE
;
8835 cplus_demangle_set_style (no_demangling
);
8836 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8839 cplus_demangle_set_style (curr_style
);
8841 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8843 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8844 DMGL_PARAMS
| DMGL_ANSI
);
8848 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8850 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8855 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8857 struct bfd_elf_version_expr e
;
8859 switch (prev
? prev
->mask
: 0)
8862 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8865 expr
= (struct bfd_elf_version_expr
*)
8866 htab_find ((htab_t
) head
->htab
, &e
);
8867 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8868 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8874 case BFD_ELF_VERSION_C_TYPE
:
8875 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8877 e
.pattern
= cxx_sym
;
8878 expr
= (struct bfd_elf_version_expr
*)
8879 htab_find ((htab_t
) head
->htab
, &e
);
8880 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8881 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8887 case BFD_ELF_VERSION_CXX_TYPE
:
8888 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8890 e
.pattern
= java_sym
;
8891 expr
= (struct bfd_elf_version_expr
*)
8892 htab_find ((htab_t
) head
->htab
, &e
);
8893 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8894 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8905 /* Finally, try the wildcards. */
8906 if (prev
== NULL
|| prev
->literal
)
8907 expr
= head
->remaining
;
8910 for (; expr
; expr
= expr
->next
)
8917 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8920 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8922 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8926 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8932 free ((char *) c_sym
);
8934 free ((char *) cxx_sym
);
8935 if (java_sym
!= sym
)
8936 free ((char *) java_sym
);
8940 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8941 return a pointer to the symbol name with any backslash quotes removed. */
8944 realsymbol (const char *pattern
)
8947 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8948 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8950 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8952 /* It is a glob pattern only if there is no preceding
8956 /* Remove the preceding backslash. */
8963 if (*p
== '?' || *p
== '*' || *p
== '[')
8970 backslash
= *p
== '\\';
8986 /* This is called for each variable name or match expression. NEW_NAME is
8987 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8988 pattern to be matched against symbol names. */
8990 struct bfd_elf_version_expr
*
8991 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8992 const char *new_name
,
8994 bfd_boolean literal_p
)
8996 struct bfd_elf_version_expr
*ret
;
8998 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9002 ret
->literal
= TRUE
;
9003 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9004 if (ret
->pattern
== NULL
)
9006 ret
->pattern
= new_name
;
9007 ret
->literal
= FALSE
;
9010 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9011 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9012 else if (strcasecmp (lang
, "C++") == 0)
9013 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9014 else if (strcasecmp (lang
, "Java") == 0)
9015 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9018 einfo (_("%X%P: unknown language `%s' in version information\n"),
9020 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9023 return ldemul_new_vers_pattern (ret
);
9026 /* This is called for each set of variable names and match
9029 struct bfd_elf_version_tree
*
9030 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9031 struct bfd_elf_version_expr
*locals
)
9033 struct bfd_elf_version_tree
*ret
;
9035 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9036 ret
->globals
.list
= globals
;
9037 ret
->locals
.list
= locals
;
9038 ret
->match
= lang_vers_match
;
9039 ret
->name_indx
= (unsigned int) -1;
9043 /* This static variable keeps track of version indices. */
9045 static int version_index
;
9048 version_expr_head_hash (const void *p
)
9050 const struct bfd_elf_version_expr
*e
=
9051 (const struct bfd_elf_version_expr
*) p
;
9053 return htab_hash_string (e
->pattern
);
9057 version_expr_head_eq (const void *p1
, const void *p2
)
9059 const struct bfd_elf_version_expr
*e1
=
9060 (const struct bfd_elf_version_expr
*) p1
;
9061 const struct bfd_elf_version_expr
*e2
=
9062 (const struct bfd_elf_version_expr
*) p2
;
9064 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9068 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9071 struct bfd_elf_version_expr
*e
, *next
;
9072 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9074 for (e
= head
->list
; e
; e
= e
->next
)
9078 head
->mask
|= e
->mask
;
9083 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9084 version_expr_head_eq
, NULL
);
9085 list_loc
= &head
->list
;
9086 remaining_loc
= &head
->remaining
;
9087 for (e
= head
->list
; e
; e
= next
)
9093 remaining_loc
= &e
->next
;
9097 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9101 struct bfd_elf_version_expr
*e1
, *last
;
9103 e1
= (struct bfd_elf_version_expr
*) *loc
;
9107 if (e1
->mask
== e
->mask
)
9115 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9119 /* This is a duplicate. */
9120 /* FIXME: Memory leak. Sometimes pattern is not
9121 xmalloced alone, but in larger chunk of memory. */
9122 /* free (e->pattern); */
9127 e
->next
= last
->next
;
9135 list_loc
= &e
->next
;
9139 *remaining_loc
= NULL
;
9140 *list_loc
= head
->remaining
;
9143 head
->remaining
= head
->list
;
9146 /* This is called when we know the name and dependencies of the
9150 lang_register_vers_node (const char *name
,
9151 struct bfd_elf_version_tree
*version
,
9152 struct bfd_elf_version_deps
*deps
)
9154 struct bfd_elf_version_tree
*t
, **pp
;
9155 struct bfd_elf_version_expr
*e1
;
9160 if (link_info
.version_info
!= NULL
9161 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9163 einfo (_("%X%P: anonymous version tag cannot be combined"
9164 " with other version tags\n"));
9169 /* Make sure this node has a unique name. */
9170 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9171 if (strcmp (t
->name
, name
) == 0)
9172 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9174 lang_finalize_version_expr_head (&version
->globals
);
9175 lang_finalize_version_expr_head (&version
->locals
);
9177 /* Check the global and local match names, and make sure there
9178 aren't any duplicates. */
9180 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9182 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9184 struct bfd_elf_version_expr
*e2
;
9186 if (t
->locals
.htab
&& e1
->literal
)
9188 e2
= (struct bfd_elf_version_expr
*)
9189 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9190 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9192 if (e1
->mask
== e2
->mask
)
9193 einfo (_("%X%P: duplicate expression `%s'"
9194 " in version information\n"), e1
->pattern
);
9198 else if (!e1
->literal
)
9199 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9200 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9201 && e1
->mask
== e2
->mask
)
9202 einfo (_("%X%P: duplicate expression `%s'"
9203 " in version information\n"), e1
->pattern
);
9207 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9209 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9211 struct bfd_elf_version_expr
*e2
;
9213 if (t
->globals
.htab
&& e1
->literal
)
9215 e2
= (struct bfd_elf_version_expr
*)
9216 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9217 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9219 if (e1
->mask
== e2
->mask
)
9220 einfo (_("%X%P: duplicate expression `%s'"
9221 " in version information\n"),
9226 else if (!e1
->literal
)
9227 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9228 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9229 && e1
->mask
== e2
->mask
)
9230 einfo (_("%X%P: duplicate expression `%s'"
9231 " in version information\n"), e1
->pattern
);
9235 version
->deps
= deps
;
9236 version
->name
= name
;
9237 if (name
[0] != '\0')
9240 version
->vernum
= version_index
;
9243 version
->vernum
= 0;
9245 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9250 /* This is called when we see a version dependency. */
9252 struct bfd_elf_version_deps
*
9253 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9255 struct bfd_elf_version_deps
*ret
;
9256 struct bfd_elf_version_tree
*t
;
9258 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9261 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9263 if (strcmp (t
->name
, name
) == 0)
9265 ret
->version_needed
= t
;
9270 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9272 ret
->version_needed
= NULL
;
9277 lang_do_version_exports_section (void)
9279 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9281 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9283 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9291 contents
= (char *) xmalloc (len
);
9292 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9293 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9296 while (p
< contents
+ len
)
9298 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9299 p
= strchr (p
, '\0') + 1;
9302 /* Do not free the contents, as we used them creating the regex. */
9304 /* Do not include this section in the link. */
9305 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9308 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9309 lang_register_vers_node (command_line
.version_exports_section
,
9310 lang_new_vers_node (greg
, lreg
), NULL
);
9313 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9316 lang_do_memory_regions (void)
9318 lang_memory_region_type
*r
= lang_memory_region_list
;
9320 for (; r
!= NULL
; r
= r
->next
)
9324 exp_fold_tree_no_dot (r
->origin_exp
);
9325 if (expld
.result
.valid_p
)
9327 r
->origin
= expld
.result
.value
;
9328 r
->current
= r
->origin
;
9331 einfo (_("%F%P: invalid origin for memory region %s\n"),
9336 exp_fold_tree_no_dot (r
->length_exp
);
9337 if (expld
.result
.valid_p
)
9338 r
->length
= expld
.result
.value
;
9340 einfo (_("%F%P: invalid length for memory region %s\n"),
9347 lang_add_unique (const char *name
)
9349 struct unique_sections
*ent
;
9351 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9352 if (strcmp (ent
->name
, name
) == 0)
9355 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9356 ent
->name
= xstrdup (name
);
9357 ent
->next
= unique_section_list
;
9358 unique_section_list
= ent
;
9361 /* Append the list of dynamic symbols to the existing one. */
9364 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9365 struct bfd_elf_version_expr
*dynamic
)
9369 struct bfd_elf_version_expr
*tail
;
9370 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9372 tail
->next
= (*list_p
)->head
.list
;
9373 (*list_p
)->head
.list
= dynamic
;
9377 struct bfd_elf_dynamic_list
*d
;
9379 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9380 d
->head
.list
= dynamic
;
9381 d
->match
= lang_vers_match
;
9386 /* Append the list of C++ typeinfo dynamic symbols to the existing
9390 lang_append_dynamic_list_cpp_typeinfo (void)
9392 const char *symbols
[] =
9394 "typeinfo name for*",
9397 struct bfd_elf_version_expr
*dynamic
= NULL
;
9400 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9401 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9404 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9407 /* Append the list of C++ operator new and delete dynamic symbols to the
9411 lang_append_dynamic_list_cpp_new (void)
9413 const char *symbols
[] =
9418 struct bfd_elf_version_expr
*dynamic
= NULL
;
9421 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9422 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9425 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9428 /* Scan a space and/or comma separated string of features. */
9431 lang_ld_feature (char *str
)
9439 while (*p
== ',' || ISSPACE (*p
))
9444 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9448 if (strcasecmp (p
, "SANE_EXPR") == 0)
9449 config
.sane_expr
= TRUE
;
9451 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9457 /* Pretty print memory amount. */
9460 lang_print_memory_size (bfd_vma sz
)
9462 if ((sz
& 0x3fffffff) == 0)
9463 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9464 else if ((sz
& 0xfffff) == 0)
9465 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9466 else if ((sz
& 0x3ff) == 0)
9467 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9469 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9472 /* Implement --print-memory-usage: disply per region memory usage. */
9475 lang_print_memory_usage (void)
9477 lang_memory_region_type
*r
;
9479 printf ("Memory region Used Size Region Size %%age Used\n");
9480 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9482 bfd_vma used_length
= r
->current
- r
->origin
;
9484 printf ("%16s: ",r
->name_list
.name
);
9485 lang_print_memory_size (used_length
);
9486 lang_print_memory_size ((bfd_vma
) r
->length
);
9490 double percent
= used_length
* 100.0 / r
->length
;
9491 printf (" %6.2f%%", percent
);