1 /* Linker command language support.
2 Copyright (C) 1991-2023 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"
46 #if BFD_SUPPORTS_PLUGINS
51 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
54 /* Convert between addresses in bytes and sizes in octets.
55 For currently supported targets, octets_per_byte is always a power
56 of two, so we can use shifts. */
57 #define TO_ADDR(X) ((X) >> opb_shift)
58 #define TO_SIZE(X) ((X) << opb_shift)
60 /* Local variables. */
61 static struct obstack stat_obstack
;
62 static struct obstack map_obstack
;
63 static struct obstack pt_obstack
;
65 #define obstack_chunk_alloc xmalloc
66 #define obstack_chunk_free free
67 static const char *entry_symbol_default
= "start";
68 static bool map_head_is_link_order
= false;
69 static lang_output_section_statement_type
*default_common_section
;
70 static bool map_option_f
;
71 static bfd_vma print_dot
;
72 static lang_input_statement_type
*first_file
;
73 static const char *current_target
;
74 static lang_statement_list_type
*stat_save
[10];
75 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
76 static struct unique_sections
*unique_section_list
;
77 static struct asneeded_minfo
*asneeded_list_head
;
78 static unsigned int opb_shift
= 0;
80 /* Forward declarations. */
81 static void exp_init_os (etree_type
*);
82 static lang_input_statement_type
*lookup_name (const char *);
83 static bool wont_add_section_p (asection
*,
84 lang_output_section_statement_type
*);
85 static void insert_undefined (const char *);
86 static bool sort_def_symbol (struct bfd_link_hash_entry
*, void *);
87 static lang_statement_union_type
*new_statement (enum statement_enum type
,
89 lang_statement_list_type
*list
);
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
*, bool);
96 static bool 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 (bool);
103 /* Exported variables. */
104 const char *output_target
;
105 lang_output_section_statement_type
*abs_output_section
;
106 /* Header for list of statements corresponding to any files involved in the
107 link, either specified from the command-line or added implicitely (eg.
108 archive member used to resolved undefined symbol, wildcard statement from
109 linker script, etc.). Next pointer is in next field of a
110 lang_statement_header_type (reached via header field in a
111 lang_statement_union). */
112 lang_statement_list_type statement_list
;
113 lang_statement_list_type lang_os_list
;
114 lang_statement_list_type
*stat_ptr
= &statement_list
;
115 /* Header for list of statements corresponding to files used in the final
116 executable. This can be either object file specified on the command-line
117 or library member resolving an undefined reference. Next pointer is in next
118 field of a lang_input_statement_type (reached via input_statement field in a
119 lang_statement_union). */
120 lang_statement_list_type file_chain
= { NULL
, NULL
};
121 /* Header for list of statements corresponding to files specified on the
122 command-line for linking. It thus contains real object files and archive
123 but not archive members. Next pointer is in next_real_file field of a
124 lang_input_statement_type statement (reached via input_statement field in a
125 lang_statement_union). */
126 lang_statement_list_type input_file_chain
;
127 static const char *current_input_file
;
128 struct bfd_elf_dynamic_list
**current_dynamic_list_p
;
129 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
130 const char *entry_section
= ".text";
131 struct lang_input_statement_flags input_flags
;
132 bool entry_from_cmdline
;
133 bool lang_has_input_file
= false;
134 bool had_output_filename
= false;
135 bool lang_float_flag
= false;
136 bool delete_output_file_on_failure
= false;
137 bool enable_linker_version
= false;
138 struct lang_phdr
*lang_phdr_list
;
139 struct lang_nocrossrefs
*nocrossref_list
;
140 struct asneeded_minfo
**asneeded_list_tail
;
142 static ctf_dict_t
*ctf_output
;
145 /* Functions that traverse the linker script and might evaluate
146 DEFINED() need to increment this at the start of the traversal. */
147 int lang_statement_iteration
= 0;
149 /* Count times through one_lang_size_sections_pass after mark phase. */
150 static int lang_sizing_iteration
= 0;
152 /* Return TRUE if the PATTERN argument is a wildcard pattern.
153 Although backslashes are treated specially if a pattern contains
154 wildcards, we do not consider the mere presence of a backslash to
155 be enough to cause the pattern to be treated as a wildcard.
156 That lets us handle DOS filenames more naturally. */
157 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
159 #define new_stat(x, y) \
160 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
162 #define outside_section_address(q) \
163 ((q)->output_offset + (q)->output_section->vma)
165 #define outside_symbol_address(q) \
166 ((q)->value + outside_section_address (q->section))
168 /* CTF sections smaller than this are not compressed: compression of
169 dictionaries this small doesn't gain much, and this lets consumers mmap the
170 sections directly out of the ELF file and use them with no decompression
171 overhead if they want to. */
172 #define CTF_COMPRESSION_THRESHOLD 4096
175 stat_alloc (size_t size
)
177 return obstack_alloc (&stat_obstack
, size
);
180 /* Code for handling simple wildcards without going through fnmatch,
181 which can be expensive because of charset translations etc. */
183 /* A simple wild is a literal string followed by a single '*',
184 where the literal part is at least 4 characters long. */
187 is_simple_wild (const char *name
)
189 size_t len
= strcspn (name
, "*?[");
190 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
194 match_simple_wild (const char *pattern
, const char *name
)
196 /* The first four characters of the pattern are guaranteed valid
197 non-wildcard characters. So we can go faster. */
198 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
199 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
204 while (*pattern
!= '*')
205 if (*name
++ != *pattern
++)
212 name_match (const char *pattern
, const char *name
)
214 if (is_simple_wild (pattern
))
215 return !match_simple_wild (pattern
, name
);
216 if (wildcardp (pattern
))
217 return fnmatch (pattern
, name
, 0);
218 return strcmp (pattern
, name
);
221 /* Given an analyzed wildcard_spec SPEC, match it against NAME,
222 returns zero on a match, non-zero if there's no match. */
225 spec_match (const struct wildcard_spec
*spec
, const char *name
)
227 size_t nl
= spec
->namelen
;
228 size_t pl
= spec
->prefixlen
;
229 size_t sl
= spec
->suffixlen
;
230 size_t inputlen
= strlen (name
);
238 r
= memcmp (spec
->name
, name
, pl
);
248 r
= memcmp (spec
->name
+ nl
- sl
, name
+ inputlen
- sl
, sl
);
253 if (nl
== pl
+ sl
+ 1 && spec
->name
[pl
] == '*')
257 return fnmatch (spec
->name
+ pl
, name
+ pl
, 0);
266 ldirname (const char *name
)
268 const char *base
= lbasename (name
);
271 while (base
> name
&& IS_DIR_SEPARATOR (base
[-1]))
275 dirname
= strdup (name
);
276 dirname
[base
- name
] = '\0';
280 /* If PATTERN is of the form archive:file, return a pointer to the
281 separator. If not, return NULL. */
284 archive_path (const char *pattern
)
288 if (link_info
.path_separator
== 0)
291 p
= strchr (pattern
, link_info
.path_separator
);
292 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
293 if (p
== NULL
|| link_info
.path_separator
!= ':')
296 /* Assume a match on the second char is part of drive specifier,
297 as in "c:\silly.dos". */
298 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
299 p
= strchr (p
+ 1, link_info
.path_separator
);
304 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
305 return whether F matches FILE_SPEC. */
308 input_statement_is_archive_path (const char *file_spec
, char *sep
,
309 lang_input_statement_type
*f
)
314 || name_match (sep
+ 1, f
->filename
) == 0)
315 && ((sep
!= file_spec
)
316 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
320 if (sep
!= file_spec
)
322 const char *aname
= bfd_get_filename (f
->the_bfd
->my_archive
);
324 match
= name_match (file_spec
, aname
) == 0;
325 *sep
= link_info
.path_separator
;
332 unique_section_p (const asection
*sec
,
333 const lang_output_section_statement_type
*os
)
335 struct unique_sections
*unam
;
338 if (!link_info
.resolve_section_groups
339 && sec
->owner
!= NULL
340 && bfd_is_group_section (sec
->owner
, sec
))
342 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
345 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
346 if (name_match (unam
->name
, secnam
) == 0)
352 /* Generic traversal routines for finding matching sections. */
354 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
358 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
359 lang_input_statement_type
*file
)
361 struct name_list
*list_tmp
;
363 for (list_tmp
= exclude_list
;
365 list_tmp
= list_tmp
->next
)
367 char *p
= archive_path (list_tmp
->name
);
371 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
375 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
378 /* FIXME: Perhaps remove the following at some stage? Matching
379 unadorned archives like this was never documented and has
380 been superceded by the archive:path syntax. */
381 else if (file
->the_bfd
!= NULL
382 && file
->the_bfd
->my_archive
!= NULL
383 && name_match (list_tmp
->name
,
384 bfd_get_filename (file
->the_bfd
->my_archive
)) == 0)
391 /* Add SECTION (from input FILE) to the list of matching sections
392 within PTR (the matching wildcard is SEC). */
395 add_matching_section (lang_wild_statement_type
*ptr
,
396 struct wildcard_list
*sec
,
398 lang_input_statement_type
*file
)
400 lang_input_matcher_type
*new_section
;
401 /* Add a section reference to the list. */
402 new_section
= new_stat (lang_input_matcher
, &ptr
->matching_sections
);
403 new_section
->section
= section
;
404 new_section
->pattern
= sec
;
405 new_section
->input_stmt
= file
;
408 /* Process section S (from input file FILE) in relation to wildcard
409 statement PTR. We already know that a prefix of the name of S matches
410 some wildcard in PTR's wildcard list. Here we check if the filename
411 matches as well (if it's specified) and if any of the wildcards in fact
415 walk_wild_section_match (lang_wild_statement_type
*ptr
,
416 lang_input_statement_type
*file
,
419 struct wildcard_list
*sec
;
420 const char *file_spec
= ptr
->filename
;
423 /* Check if filenames match. */
424 if (file_spec
== NULL
)
426 else if ((p
= archive_path (file_spec
)) != NULL
)
428 if (!input_statement_is_archive_path (file_spec
, p
, file
))
431 else if (wildcardp (file_spec
))
433 if (fnmatch (file_spec
, file
->filename
, 0) != 0)
438 /* XXX Matching against non-wildcard filename in wild statements
439 was done by going through lookup_name, which uses
440 ->local_sym_name to compare against, not ->filename. We retain
441 this behaviour even though the above code paths use filename.
442 It would be more logical to use it here as well, in which
443 case the above wildcard() arm could be folded into this by using
444 name_match. This would also solve the worry of what to do
445 about unset local_sym_name (in which case lookup_name simply adds
446 the input file again). */
447 const char *filename
= file
->local_sym_name
;
448 lang_input_statement_type
*arch_is
;
449 if (filename
&& filename_cmp (filename
, file_spec
) == 0)
451 /* FIXME: see also walk_wild_file_in_exclude_list for why we
452 also check parents BFD (local_sym_)name to match input statements
453 with unadorned archive names. */
454 else if (file
->the_bfd
455 && file
->the_bfd
->my_archive
456 && (arch_is
= bfd_usrdata (file
->the_bfd
->my_archive
))
457 && arch_is
->local_sym_name
458 && filename_cmp (arch_is
->local_sym_name
, file_spec
) == 0)
464 /* If filename is excluded we're done. */
465 if (walk_wild_file_in_exclude_list (ptr
->exclude_name_list
, file
))
468 /* Check section name against each wildcard spec. If there's no
469 wildcard all sections match. */
470 sec
= ptr
->section_list
;
472 add_matching_section (ptr
, sec
, s
, file
);
475 const char *sname
= bfd_section_name (s
);
476 for (; sec
!= NULL
; sec
= sec
->next
)
478 if (sec
->spec
.name
!= NULL
479 && spec_match (&sec
->spec
, sname
) != 0)
482 /* Don't process sections from files which were excluded. */
483 if (!walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
,
485 add_matching_section (ptr
, sec
, s
, file
);
490 /* Return the numerical value of the init_priority attribute from
491 section name NAME. */
494 get_init_priority (const asection
*sec
)
496 const char *name
= bfd_section_name (sec
);
499 /* GCC uses the following section names for the init_priority
500 attribute with numerical values 101 to 65535 inclusive. A
501 lower value means a higher priority.
503 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
504 decimal numerical value of the init_priority attribute.
505 The order of execution in .init_array is forward and
506 .fini_array is backward.
507 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
508 decimal numerical value of the init_priority attribute.
509 The order of execution in .ctors is backward and .dtors
512 .init_array.NNNNN sections would normally be placed in an output
513 .init_array section, .fini_array.NNNNN in .fini_array,
514 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
515 we should sort by increasing number (and could just use
516 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
517 being placed in .init_array (which may also contain
518 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
519 placed in .fini_array then we need to extract the init_priority
520 attribute and sort on that. */
521 dot
= strrchr (name
, '.');
522 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
525 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
529 && (strncmp (name
, ".ctors", 6) == 0
530 || strncmp (name
, ".dtors", 6) == 0))
531 init_priority
= 65535 - init_priority
;
532 if (init_priority
<= INT_MAX
)
533 return init_priority
;
539 /* Compare sections ASEC and BSEC according to SORT. */
542 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
545 int a_priority
, b_priority
;
552 case by_init_priority
:
553 a_priority
= get_init_priority (asec
);
554 b_priority
= get_init_priority (bsec
);
555 if (a_priority
< 0 || b_priority
< 0)
557 ret
= a_priority
- b_priority
;
563 case by_alignment_name
:
564 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
571 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
574 case by_name_alignment
:
575 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
581 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
588 /* PE puts the sort key in the input statement. */
591 sort_filename (bfd
*abfd
)
593 lang_input_statement_type
*is
= bfd_usrdata (abfd
);
596 return bfd_get_filename (abfd
);
599 /* Handle wildcard sorting. This returns the place in a binary search tree
600 where this FILE:SECTION should be inserted for wild statement WILD where
601 the spec SEC was the matching one. The tree is later linearized. */
603 static lang_section_bst_type
**
604 wild_sort (lang_wild_statement_type
*wild
,
605 struct wildcard_list
*sec
,
606 lang_input_statement_type
*file
,
609 lang_section_bst_type
**tree
;
611 if (!wild
->filenames_sorted
612 && (sec
== NULL
|| sec
->spec
.sorted
== none
613 || sec
->spec
.sorted
== by_none
))
615 /* We might be called even if _this_ spec doesn't need sorting,
616 in which case we simply append at the right end of tree. */
617 return wild
->rightmost
;
623 /* Sorting by filename takes precedence over sorting by section
626 if (wild
->filenames_sorted
)
631 asection
*lsec
= (*tree
)->section
;
633 /* The PE support for the .idata section as generated by
634 dlltool assumes that files will be sorted by the name of
635 the archive and then the name of the file within the
638 fa
= file
->the_bfd
->my_archive
!= NULL
;
640 fn
= sort_filename (file
->the_bfd
->my_archive
);
642 fn
= sort_filename (file
->the_bfd
);
644 la
= lsec
->owner
->my_archive
!= NULL
;
646 ln
= sort_filename (lsec
->owner
->my_archive
);
648 ln
= sort_filename (lsec
->owner
);
650 i
= filename_cmp (fn
, ln
);
652 { tree
= &((*tree
)->right
); continue; }
654 { tree
= &((*tree
)->left
); continue; }
659 fn
= sort_filename (file
->the_bfd
);
661 ln
= sort_filename (lsec
->owner
);
663 i
= filename_cmp (fn
, ln
);
665 { tree
= &((*tree
)->right
); continue; }
667 { tree
= &((*tree
)->left
); continue; }
671 /* Here either the files are not sorted by name, or we are
672 looking at the sections for this file. */
674 /* Find the correct node to append this section. */
675 if (sec
&& sec
->spec
.sorted
!= none
&& sec
->spec
.sorted
!= by_none
676 && compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
677 tree
= &((*tree
)->left
);
679 tree
= &((*tree
)->right
);
685 /* Use wild_sort to build a BST to sort sections. */
688 output_section_callback_sort (lang_wild_statement_type
*ptr
,
689 struct wildcard_list
*sec
,
691 lang_input_statement_type
*file
,
694 lang_section_bst_type
*node
;
695 lang_section_bst_type
**tree
;
696 lang_output_section_statement_type
*os
;
698 os
= (lang_output_section_statement_type
*) output
;
700 if (unique_section_p (section
, os
))
703 /* Don't add sections to the tree when we already know that
704 lang_add_section won't do anything with it. */
705 if (wont_add_section_p (section
, os
))
708 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
711 node
->section
= section
;
712 node
->pattern
= ptr
->section_list
;
714 tree
= wild_sort (ptr
, sec
, file
, section
);
718 if (tree
== ptr
->rightmost
)
719 ptr
->rightmost
= &node
->right
;
723 /* Convert a sorted sections' BST back to list form. */
726 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
727 lang_section_bst_type
*tree
,
731 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
733 lang_add_section (&ptr
->children
, tree
->section
, tree
->pattern
,
734 ptr
->section_flag_list
,
735 (lang_output_section_statement_type
*) output
);
738 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
744 /* Sections are matched against wildcard statements via a prefix tree.
745 The prefix tree holds prefixes of all matching patterns (up to the first
746 wildcard character), and the wild statement from which those patterns
747 came. When matching a section name against the tree we're walking through
748 the tree character by character. Each statement we hit is one that
749 potentially matches. This is checked by actually going through the
750 (glob) matching routines.
752 When the section name turns out to actually match we record that section
753 in the wild statements list of matching sections. */
755 /* A prefix can be matched by multiple statement, so we need a list of them. */
756 struct wild_stmt_list
758 lang_wild_statement_type
*stmt
;
759 struct wild_stmt_list
*next
;
762 /* The prefix tree itself. */
765 /* The list of all children (linked via .next). */
766 struct prefixtree
*child
;
767 struct prefixtree
*next
;
768 /* This tree node is responsible for the prefix of parent plus 'c'. */
770 /* The statements that potentially can match this prefix. */
771 struct wild_stmt_list
*stmt
;
774 /* We always have a root node in the prefix tree. It corresponds to the
775 empty prefix. E.g. a glob like "*" would sit in this root. */
776 static struct prefixtree the_root
, *ptroot
= &the_root
;
778 /* Given a prefix tree in *TREE, corresponding to prefix P, find or
779 INSERT the tree node corresponding to prefix P+C. */
781 static struct prefixtree
*
782 get_prefix_tree (struct prefixtree
**tree
, char c
, bool insert
)
784 struct prefixtree
*t
;
785 for (t
= *tree
; t
; t
= t
->next
)
790 t
= (struct prefixtree
*) obstack_alloc (&pt_obstack
, sizeof *t
);
799 /* Add STMT to the set of statements that can be matched by the prefix
800 corresponding to prefix tree T. */
803 pt_add_stmt (struct prefixtree
*t
, lang_wild_statement_type
*stmt
)
805 struct wild_stmt_list
*sl
, **psl
;
806 sl
= (struct wild_stmt_list
*) obstack_alloc (&pt_obstack
, sizeof *sl
);
815 /* Insert STMT into the global prefix tree. */
818 insert_prefix_tree (lang_wild_statement_type
*stmt
)
820 struct wildcard_list
*sec
;
821 struct prefixtree
*t
;
823 if (!stmt
->section_list
)
825 /* If we have no section_list (no wildcards in the wild STMT),
826 then every section name will match, so add this to the root. */
827 pt_add_stmt (ptroot
, stmt
);
831 for (sec
= stmt
->section_list
; sec
; sec
= sec
->next
)
833 const char *name
= sec
->spec
.name
? sec
->spec
.name
: "*";
836 for (; (c
= *name
); name
++)
838 if (c
== '*' || c
== '[' || c
== '?')
840 t
= get_prefix_tree (&t
->child
, c
, true);
842 /* If we hit a glob character, the matching prefix is what we saw
843 until now. If we hit the end of pattern (hence it's no glob) then
844 we can do better: we only need to record a match when a section name
845 completely matches, not merely a prefix, so record the trailing 0
848 t
= get_prefix_tree (&t
->child
, 0, true);
849 pt_add_stmt (t
, stmt
);
853 /* Dump T indented by INDENT spaces. */
856 debug_prefix_tree_rec (struct prefixtree
*t
, int indent
)
858 for (; t
; t
= t
->next
)
860 struct wild_stmt_list
*sl
;
861 printf ("%*s %c", indent
, "", t
->c
);
862 for (sl
= t
->stmt
; sl
; sl
= sl
->next
)
864 struct wildcard_list
*curr
;
865 printf (" %p ", sl
->stmt
);
866 for (curr
= sl
->stmt
->section_list
; curr
; curr
= curr
->next
)
867 printf ("%s ", curr
->spec
.name
? curr
->spec
.name
: "*");
870 debug_prefix_tree_rec (t
->child
, indent
+ 2);
874 /* Dump the global prefix tree. */
877 debug_prefix_tree (void)
879 debug_prefix_tree_rec (ptroot
, 2);
882 /* Like strcspn() but start to look from the end to beginning of
883 S. Returns the length of the suffix of S consisting entirely
884 of characters not in REJECT. */
887 rstrcspn (const char *s
, const char *reject
)
889 size_t len
= strlen (s
), sufflen
= 0;
893 if (strchr (reject
, c
) != 0)
900 /* Analyze the wildcards in wild statement PTR to setup various
901 things for quick matching. */
904 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
906 struct wildcard_list
*sec
;
909 ptr
->rightmost
= &ptr
->tree
;
911 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
915 sec
->spec
.namelen
= strlen (sec
->spec
.name
);
916 sec
->spec
.prefixlen
= strcspn (sec
->spec
.name
, "?*[");
917 sec
->spec
.suffixlen
= rstrcspn (sec
->spec
.name
+ sec
->spec
.prefixlen
,
921 sec
->spec
.namelen
= sec
->spec
.prefixlen
= sec
->spec
.suffixlen
= 0;
924 insert_prefix_tree (ptr
);
927 /* Match all sections from FILE against the global prefix tree,
928 and record them into each wild statement that has a match. */
931 resolve_wild_sections (lang_input_statement_type
*file
)
935 if (file
->flags
.just_syms
)
938 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
940 const char *sname
= bfd_section_name (s
);
942 struct prefixtree
*t
= ptroot
;
943 //printf (" YYY consider %s of %s\n", sname, file->the_bfd->filename);
948 struct wild_stmt_list
*sl
;
949 for (sl
= t
->stmt
; sl
; sl
= sl
->next
)
951 walk_wild_section_match (sl
->stmt
, file
, s
);
952 //printf (" ZZZ maybe place into %p\n", sl->stmt);
958 t
= get_prefix_tree (&t
->child
, c
, false);
964 /* Match all sections from all input files against the global prefix tree. */
969 LANG_FOR_EACH_INPUT_STATEMENT (f
)
971 //printf("XXX %s\n", f->filename);
972 if (f
->the_bfd
== NULL
973 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
974 resolve_wild_sections (f
);
979 /* This is an archive file. We must map each member of the
980 archive separately. */
981 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
982 while (member
!= NULL
)
984 /* When lookup_name is called, it will call the add_symbols
985 entry point for the archive. For each element of the
986 archive which is included, BFD will call ldlang_add_file,
987 which will set the usrdata field of the member to the
988 lang_input_statement. */
989 if (bfd_usrdata (member
) != NULL
)
990 resolve_wild_sections (bfd_usrdata (member
));
992 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
998 /* For each input section that matches wild statement S calls
999 CALLBACK with DATA. */
1002 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
1004 lang_statement_union_type
*l
;
1006 for (l
= s
->matching_sections
.head
; l
; l
= l
->header
.next
)
1008 (*callback
) (s
, l
->input_matcher
.pattern
, l
->input_matcher
.section
,
1009 l
->input_matcher
.input_stmt
, data
);
1013 /* lang_for_each_statement walks the parse tree and calls the provided
1014 function for each node, except those inside output section statements
1015 with constraint set to -1. */
1018 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
1019 lang_statement_union_type
*s
)
1021 for (; s
!= NULL
; s
= s
->header
.next
)
1025 switch (s
->header
.type
)
1027 case lang_constructors_statement_enum
:
1028 lang_for_each_statement_worker (func
, constructor_list
.head
);
1030 case lang_output_section_statement_enum
:
1031 if (s
->output_section_statement
.constraint
!= -1)
1032 lang_for_each_statement_worker
1033 (func
, s
->output_section_statement
.children
.head
);
1035 case lang_wild_statement_enum
:
1036 lang_for_each_statement_worker (func
,
1037 s
->wild_statement
.children
.head
);
1039 case lang_group_statement_enum
:
1040 lang_for_each_statement_worker (func
,
1041 s
->group_statement
.children
.head
);
1043 case lang_data_statement_enum
:
1044 case lang_reloc_statement_enum
:
1045 case lang_object_symbols_statement_enum
:
1046 case lang_output_statement_enum
:
1047 case lang_target_statement_enum
:
1048 case lang_input_section_enum
:
1049 case lang_input_statement_enum
:
1050 case lang_assignment_statement_enum
:
1051 case lang_padding_statement_enum
:
1052 case lang_address_statement_enum
:
1053 case lang_fill_statement_enum
:
1054 case lang_insert_statement_enum
:
1064 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1066 lang_for_each_statement_worker (func
, statement_list
.head
);
1069 /*----------------------------------------------------------------------*/
1072 lang_list_init (lang_statement_list_type
*list
)
1075 list
->tail
= &list
->head
;
1079 lang_statement_append (lang_statement_list_type
*list
,
1083 *(list
->tail
) = element
;
1088 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1090 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1092 *stat_save_ptr
++ = stat_ptr
;
1099 if (stat_save_ptr
<= stat_save
)
1101 stat_ptr
= *--stat_save_ptr
;
1104 /* Build a new statement node for the parse tree. */
1106 static lang_statement_union_type
*
1107 new_statement (enum statement_enum type
,
1109 lang_statement_list_type
*list
)
1111 lang_statement_union_type
*new_stmt
;
1113 new_stmt
= stat_alloc (size
);
1114 new_stmt
->header
.type
= type
;
1115 new_stmt
->header
.next
= NULL
;
1116 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1120 /* Build a new input file node for the language. There are several
1121 ways in which we treat an input file, eg, we only look at symbols,
1122 or prefix it with a -l etc.
1124 We can be supplied with requests for input files more than once;
1125 they may, for example be split over several lines like foo.o(.text)
1126 foo.o(.data) etc, so when asked for a file we check that we haven't
1127 got it already so we don't duplicate the bfd. */
1129 static lang_input_statement_type
*
1130 new_afile (const char *name
,
1131 lang_input_file_enum_type file_type
,
1133 const char *from_filename
)
1135 lang_input_statement_type
*p
;
1137 lang_has_input_file
= true;
1139 /* PR 30632: It is OK for name to be NULL. For example
1140 see the initialization of first_file in lang_init(). */
1143 name
= ldfile_possibly_remap_input (name
);
1144 /* But if a name is remapped to NULL, it should be ignored. */
1149 p
= new_stat (lang_input_statement
, stat_ptr
);
1150 memset (&p
->the_bfd
, 0,
1151 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1152 p
->extra_search_path
= NULL
;
1154 p
->flags
.dynamic
= input_flags
.dynamic
;
1155 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1156 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1157 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1158 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1163 case lang_input_file_is_symbols_only_enum
:
1165 p
->local_sym_name
= name
;
1166 p
->flags
.real
= true;
1167 p
->flags
.just_syms
= true;
1169 case lang_input_file_is_fake_enum
:
1171 p
->local_sym_name
= name
;
1173 case lang_input_file_is_l_enum
:
1174 if (name
[0] == ':' && name
[1] != '\0')
1176 p
->filename
= name
+ 1;
1177 p
->flags
.full_name_provided
= true;
1181 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1182 p
->flags
.maybe_archive
= true;
1183 p
->flags
.real
= true;
1184 p
->flags
.search_dirs
= true;
1186 case lang_input_file_is_marker_enum
:
1188 p
->local_sym_name
= name
;
1189 p
->flags
.search_dirs
= true;
1191 case lang_input_file_is_search_file_enum
:
1193 p
->local_sym_name
= name
;
1194 /* If name is a relative path, search the directory of the current linker
1196 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1197 p
->extra_search_path
= ldirname (from_filename
);
1198 p
->flags
.real
= true;
1199 p
->flags
.search_dirs
= true;
1201 case lang_input_file_is_file_enum
:
1203 p
->local_sym_name
= name
;
1204 p
->flags
.real
= true;
1210 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1214 lang_input_statement_type
*
1215 lang_add_input_file (const char *name
,
1216 lang_input_file_enum_type file_type
,
1220 && (*name
== '=' || startswith (name
, "$SYSROOT")))
1222 lang_input_statement_type
*ret
;
1223 char *sysrooted_name
1224 = concat (ld_sysroot
,
1225 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1226 (const char *) NULL
);
1228 /* We've now forcibly prepended the sysroot, making the input
1229 file independent of the context. Therefore, temporarily
1230 force a non-sysrooted context for this statement, so it won't
1231 get the sysroot prepended again when opened. (N.B. if it's a
1232 script, any child nodes with input files starting with "/"
1233 will be handled as "sysrooted" as they'll be found to be
1234 within the sysroot subdirectory.) */
1235 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1236 input_flags
.sysrooted
= 0;
1237 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1238 input_flags
.sysrooted
= outer_sysrooted
;
1242 return new_afile (name
, file_type
, target
, current_input_file
);
1245 struct out_section_hash_entry
1247 struct bfd_hash_entry root
;
1248 lang_statement_union_type s
;
1251 /* The hash table. */
1253 static struct bfd_hash_table output_section_statement_table
;
1255 /* Support routines for the hash table used by lang_output_section_find,
1256 initialize the table, fill in an entry and remove the table. */
1258 static struct bfd_hash_entry
*
1259 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1260 struct bfd_hash_table
*table
,
1263 lang_output_section_statement_type
**nextp
;
1264 struct out_section_hash_entry
*ret
;
1268 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1274 entry
= bfd_hash_newfunc (entry
, table
, string
);
1278 ret
= (struct out_section_hash_entry
*) entry
;
1279 memset (&ret
->s
, 0, sizeof (ret
->s
));
1280 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1281 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1282 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1283 ret
->s
.output_section_statement
.block_value
= 1;
1284 lang_list_init (&ret
->s
.output_section_statement
.children
);
1285 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1287 /* For every output section statement added to the list, except the
1288 first one, lang_os_list.tail points to the "next"
1289 field of the last element of the list. */
1290 if (lang_os_list
.head
!= NULL
)
1291 ret
->s
.output_section_statement
.prev
1292 = ((lang_output_section_statement_type
*)
1293 ((char *) lang_os_list
.tail
1294 - offsetof (lang_output_section_statement_type
, next
)));
1296 /* GCC's strict aliasing rules prevent us from just casting the
1297 address, so we store the pointer in a variable and cast that
1299 nextp
= &ret
->s
.output_section_statement
.next
;
1300 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1305 output_section_statement_table_init (void)
1307 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1308 output_section_statement_newfunc
,
1309 sizeof (struct out_section_hash_entry
),
1311 einfo (_("%F%P: can not create hash table: %E\n"));
1315 output_section_statement_table_free (void)
1317 bfd_hash_table_free (&output_section_statement_table
);
1320 /* Build enough state so that the parser can build its tree. */
1325 obstack_begin (&stat_obstack
, 1000);
1326 obstack_init (&pt_obstack
);
1328 stat_ptr
= &statement_list
;
1330 output_section_statement_table_init ();
1332 lang_list_init (stat_ptr
);
1334 lang_list_init (&input_file_chain
);
1335 lang_list_init (&lang_os_list
);
1336 lang_list_init (&file_chain
);
1337 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1339 abs_output_section
=
1340 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, 1);
1342 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1344 asneeded_list_head
= NULL
;
1345 asneeded_list_tail
= &asneeded_list_head
;
1351 output_section_statement_table_free ();
1352 ldfile_remap_input_free ();
1355 /*----------------------------------------------------------------------
1356 A region is an area of memory declared with the
1357 MEMORY { name:org=exp, len=exp ... }
1360 We maintain a list of all the regions here.
1362 If no regions are specified in the script, then the default is used
1363 which is created when looked up to be the entire data space.
1365 If create is true we are creating a region inside a MEMORY block.
1366 In this case it is probably an error to create a region that has
1367 already been created. If we are not inside a MEMORY block it is
1368 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1369 and so we issue a warning.
1371 Each region has at least one name. The first name is either
1372 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1373 alias names to an existing region within a script with
1374 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1377 static lang_memory_region_type
*lang_memory_region_list
;
1378 static lang_memory_region_type
**lang_memory_region_list_tail
1379 = &lang_memory_region_list
;
1381 lang_memory_region_type
*
1382 lang_memory_region_lookup (const char *const name
, bool create
)
1384 lang_memory_region_name
*n
;
1385 lang_memory_region_type
*r
;
1386 lang_memory_region_type
*new_region
;
1388 /* NAME is NULL for LMA memspecs if no region was specified. */
1392 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1393 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1394 if (strcmp (n
->name
, name
) == 0)
1397 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1402 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1403 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1406 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1408 new_region
->name_list
.name
= xstrdup (name
);
1409 new_region
->name_list
.next
= NULL
;
1410 new_region
->next
= NULL
;
1411 new_region
->origin_exp
= NULL
;
1412 new_region
->origin
= 0;
1413 new_region
->length_exp
= NULL
;
1414 new_region
->length
= ~(bfd_size_type
) 0;
1415 new_region
->current
= 0;
1416 new_region
->last_os
= NULL
;
1417 new_region
->flags
= 0;
1418 new_region
->not_flags
= 0;
1419 new_region
->had_full_message
= false;
1421 *lang_memory_region_list_tail
= new_region
;
1422 lang_memory_region_list_tail
= &new_region
->next
;
1428 lang_memory_region_alias (const char *alias
, const char *region_name
)
1430 lang_memory_region_name
*n
;
1431 lang_memory_region_type
*r
;
1432 lang_memory_region_type
*region
;
1434 /* The default region must be unique. This ensures that it is not necessary
1435 to iterate through the name list if someone wants the check if a region is
1436 the default memory region. */
1437 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1438 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1439 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1441 /* Look for the target region and check if the alias is not already
1444 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1445 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1447 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1449 if (strcmp (n
->name
, alias
) == 0)
1450 einfo (_("%F%P:%pS: error: redefinition of memory region "
1455 /* Check if the target region exists. */
1457 einfo (_("%F%P:%pS: error: memory region `%s' "
1458 "for alias `%s' does not exist\n"),
1459 NULL
, region_name
, alias
);
1461 /* Add alias to region name list. */
1462 n
= stat_alloc (sizeof (lang_memory_region_name
));
1463 n
->name
= xstrdup (alias
);
1464 n
->next
= region
->name_list
.next
;
1465 region
->name_list
.next
= n
;
1468 static lang_memory_region_type
*
1469 lang_memory_default (asection
*section
)
1471 lang_memory_region_type
*p
;
1473 flagword sec_flags
= section
->flags
;
1475 /* Override SEC_DATA to mean a writable section. */
1476 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1477 sec_flags
|= SEC_DATA
;
1479 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1481 if ((p
->flags
& sec_flags
) != 0
1482 && (p
->not_flags
& sec_flags
) == 0)
1487 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
1490 /* Get the output section statement directly from the userdata. */
1492 lang_output_section_statement_type
*
1493 lang_output_section_get (const asection
*output_section
)
1495 return bfd_section_userdata (output_section
);
1498 /* Find or create an output_section_statement with the given NAME.
1499 If CONSTRAINT is non-zero match one with that constraint, otherwise
1500 match any non-negative constraint. If CREATE is 0 return NULL when
1501 no match exists. If CREATE is 1, create an output_section_statement
1502 when no match exists or if CONSTRAINT is SPECIAL. If CREATE is 2,
1503 always make a new output_section_statement. */
1505 lang_output_section_statement_type
*
1506 lang_output_section_statement_lookup (const char *name
,
1510 struct out_section_hash_entry
*entry
;
1512 entry
= ((struct out_section_hash_entry
*)
1513 bfd_hash_lookup (&output_section_statement_table
, name
,
1514 create
!= 0, false));
1518 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1522 if (entry
->s
.output_section_statement
.name
!= NULL
)
1524 /* We have a section of this name, but it might not have the correct
1526 struct out_section_hash_entry
*last_ent
;
1528 name
= entry
->s
.output_section_statement
.name
;
1532 && !(create
&& constraint
== SPECIAL
)
1533 && (constraint
== entry
->s
.output_section_statement
.constraint
1535 && entry
->s
.output_section_statement
.constraint
>= 0)))
1536 return &entry
->s
.output_section_statement
;
1538 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1540 while (entry
!= NULL
1541 && name
== entry
->s
.output_section_statement
.name
);
1547 = ((struct out_section_hash_entry
*)
1548 output_section_statement_newfunc (NULL
,
1549 &output_section_statement_table
,
1553 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1556 entry
->root
= last_ent
->root
;
1557 last_ent
->root
.next
= &entry
->root
;
1560 entry
->s
.output_section_statement
.name
= name
;
1561 entry
->s
.output_section_statement
.constraint
= constraint
;
1562 entry
->s
.output_section_statement
.dup_output
= (create
== 2
1563 || constraint
== SPECIAL
);
1564 return &entry
->s
.output_section_statement
;
1567 /* Find the next output_section_statement with the same name as OS.
1568 If CONSTRAINT is non-zero, find one with that constraint otherwise
1569 match any non-negative constraint. */
1571 lang_output_section_statement_type
*
1572 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1575 /* All output_section_statements are actually part of a
1576 struct out_section_hash_entry. */
1577 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1579 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1580 const char *name
= os
->name
;
1582 ASSERT (name
== entry
->root
.string
);
1585 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1587 || name
!= entry
->s
.output_section_statement
.name
)
1590 while (constraint
!= entry
->s
.output_section_statement
.constraint
1592 || entry
->s
.output_section_statement
.constraint
< 0));
1594 return &entry
->s
.output_section_statement
;
1597 /* A variant of lang_output_section_find used by place_orphan.
1598 Returns the output statement that should precede a new output
1599 statement for SEC. If an exact match is found on certain flags,
1602 lang_output_section_statement_type
*
1603 lang_output_section_find_by_flags (const asection
*sec
,
1605 lang_output_section_statement_type
**exact
,
1606 lang_match_sec_type_func match_type
)
1608 lang_output_section_statement_type
*first
, *look
, *found
;
1609 flagword look_flags
, differ
;
1611 /* We know the first statement on this list is *ABS*. May as well
1613 first
= (void *) lang_os_list
.head
;
1614 first
= first
->next
;
1616 /* First try for an exact match. */
1618 for (look
= first
; look
; look
= look
->next
)
1620 look_flags
= look
->flags
;
1621 if (look
->bfd_section
!= NULL
)
1623 look_flags
= look
->bfd_section
->flags
;
1624 if (match_type
&& !match_type (link_info
.output_bfd
,
1629 differ
= look_flags
^ sec_flags
;
1630 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1631 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1641 if ((sec_flags
& SEC_CODE
) != 0
1642 && (sec_flags
& SEC_ALLOC
) != 0)
1644 /* Try for a rw code section. */
1645 for (look
= first
; look
; look
= look
->next
)
1647 look_flags
= look
->flags
;
1648 if (look
->bfd_section
!= NULL
)
1650 look_flags
= look
->bfd_section
->flags
;
1651 if (match_type
&& !match_type (link_info
.output_bfd
,
1656 differ
= look_flags
^ sec_flags
;
1657 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1658 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1662 else if ((sec_flags
& SEC_READONLY
) != 0
1663 && (sec_flags
& SEC_ALLOC
) != 0)
1665 /* .rodata can go after .text, .sdata2 after .rodata. */
1666 for (look
= first
; look
; look
= look
->next
)
1668 look_flags
= look
->flags
;
1669 if (look
->bfd_section
!= NULL
)
1671 look_flags
= look
->bfd_section
->flags
;
1672 if (match_type
&& !match_type (link_info
.output_bfd
,
1677 differ
= look_flags
^ sec_flags
;
1678 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1679 | SEC_READONLY
| SEC_SMALL_DATA
))
1680 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1682 && !(look_flags
& SEC_SMALL_DATA
)))
1686 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1687 && (sec_flags
& SEC_ALLOC
) != 0)
1689 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1690 as if it were a loaded section, and don't use match_type. */
1691 bool seen_thread_local
= false;
1694 for (look
= first
; look
; look
= look
->next
)
1696 look_flags
= look
->flags
;
1697 if (look
->bfd_section
!= NULL
)
1698 look_flags
= look
->bfd_section
->flags
;
1700 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1701 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1703 /* .tdata and .tbss must be adjacent and in that order. */
1704 if (!(look_flags
& SEC_LOAD
)
1705 && (sec_flags
& SEC_LOAD
))
1706 /* ..so if we're at a .tbss section and we're placing
1707 a .tdata section stop looking and return the
1708 previous section. */
1711 seen_thread_local
= true;
1713 else if (seen_thread_local
)
1715 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1719 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1720 && (sec_flags
& SEC_ALLOC
) != 0)
1722 /* .sdata goes after .data, .sbss after .sdata. */
1723 for (look
= first
; look
; look
= look
->next
)
1725 look_flags
= look
->flags
;
1726 if (look
->bfd_section
!= NULL
)
1728 look_flags
= look
->bfd_section
->flags
;
1729 if (match_type
&& !match_type (link_info
.output_bfd
,
1734 differ
= look_flags
^ sec_flags
;
1735 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1736 | SEC_THREAD_LOCAL
))
1737 || ((look_flags
& SEC_SMALL_DATA
)
1738 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1742 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1743 && (sec_flags
& SEC_ALLOC
) != 0)
1745 /* .data goes after .rodata. */
1746 for (look
= first
; look
; look
= look
->next
)
1748 look_flags
= look
->flags
;
1749 if (look
->bfd_section
!= NULL
)
1751 look_flags
= look
->bfd_section
->flags
;
1752 if (match_type
&& !match_type (link_info
.output_bfd
,
1757 differ
= look_flags
^ sec_flags
;
1758 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1759 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1763 else if ((sec_flags
& SEC_ALLOC
) != 0)
1765 /* .bss goes after any other alloc section. */
1766 for (look
= first
; look
; look
= look
->next
)
1768 look_flags
= look
->flags
;
1769 if (look
->bfd_section
!= NULL
)
1771 look_flags
= look
->bfd_section
->flags
;
1772 if (match_type
&& !match_type (link_info
.output_bfd
,
1777 differ
= look_flags
^ sec_flags
;
1778 if (!(differ
& SEC_ALLOC
))
1784 /* non-alloc go last. */
1785 for (look
= first
; look
; look
= look
->next
)
1787 look_flags
= look
->flags
;
1788 if (look
->bfd_section
!= NULL
)
1789 look_flags
= look
->bfd_section
->flags
;
1790 differ
= look_flags
^ sec_flags
;
1791 if (!(differ
& SEC_DEBUGGING
))
1797 if (found
|| !match_type
)
1800 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1803 /* Find the last output section before given output statement.
1804 Used by place_orphan. */
1807 output_prev_sec_find (lang_output_section_statement_type
*os
)
1809 lang_output_section_statement_type
*lookup
;
1811 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1813 if (lookup
->constraint
< 0)
1816 if (lookup
->bfd_section
!= NULL
)
1817 return lookup
->bfd_section
;
1823 /* Look for a suitable place for a new output section statement. The
1824 idea is to skip over anything that might be inside a SECTIONS {}
1825 statement in a script, before we find another output section
1826 statement. Assignments to "dot" before an output section statement
1827 are assumed to belong to it, except in two cases; The first
1828 assignment to dot, and assignments before non-alloc sections.
1829 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1830 similar assignments that set the initial address, or we might
1831 insert non-alloc note sections among assignments setting end of
1834 static lang_statement_union_type
**
1835 insert_os_after (lang_statement_union_type
*after
)
1837 lang_statement_union_type
**where
;
1838 lang_statement_union_type
**assign
= NULL
;
1841 ignore_first
= after
== lang_os_list
.head
;
1843 for (where
= &after
->header
.next
;
1845 where
= &(*where
)->header
.next
)
1847 switch ((*where
)->header
.type
)
1849 case lang_assignment_statement_enum
:
1852 lang_assignment_statement_type
*ass
;
1854 ass
= &(*where
)->assignment_statement
;
1855 if (ass
->exp
->type
.node_class
!= etree_assert
1856 && ass
->exp
->assign
.dst
[0] == '.'
1857 && ass
->exp
->assign
.dst
[1] == 0)
1861 ignore_first
= false;
1865 case lang_wild_statement_enum
:
1866 case lang_input_section_enum
:
1867 case lang_object_symbols_statement_enum
:
1868 case lang_fill_statement_enum
:
1869 case lang_data_statement_enum
:
1870 case lang_reloc_statement_enum
:
1871 case lang_padding_statement_enum
:
1872 case lang_constructors_statement_enum
:
1874 ignore_first
= false;
1876 case lang_output_section_statement_enum
:
1879 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1882 || s
->map_head
.s
== NULL
1883 || (s
->flags
& SEC_ALLOC
) != 0)
1887 case lang_input_statement_enum
:
1888 case lang_address_statement_enum
:
1889 case lang_target_statement_enum
:
1890 case lang_output_statement_enum
:
1891 case lang_group_statement_enum
:
1892 case lang_insert_statement_enum
:
1894 case lang_input_matcher_enum
:
1903 lang_output_section_statement_type
*
1904 lang_insert_orphan (asection
*s
,
1905 const char *secname
,
1907 lang_output_section_statement_type
*after
,
1908 struct orphan_save
*place
,
1909 etree_type
*address
,
1910 lang_statement_list_type
*add_child
)
1912 lang_statement_list_type add
;
1913 lang_output_section_statement_type
*os
;
1914 lang_output_section_statement_type
**os_tail
;
1916 /* If we have found an appropriate place for the output section
1917 statements for this orphan, add them to our own private list,
1918 inserting them later into the global statement list. */
1921 lang_list_init (&add
);
1922 push_stat_ptr (&add
);
1925 if (bfd_link_relocatable (&link_info
)
1926 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1927 address
= exp_intop (0);
1929 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1930 os
= lang_enter_output_section_statement (
1931 secname
, address
, normal_section
, 0, NULL
, NULL
, NULL
, constraint
, 0);
1933 if (add_child
== NULL
)
1934 add_child
= &os
->children
;
1935 lang_add_section (add_child
, s
, NULL
, NULL
, os
);
1937 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1939 const char *region
= (after
->region
1940 ? after
->region
->name_list
.name
1941 : DEFAULT_MEMORY_REGION
);
1942 const char *lma_region
= (after
->lma_region
1943 ? after
->lma_region
->name_list
.name
1945 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1949 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1952 /* Restore the global list pointer. */
1956 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1958 asection
*snew
, *as
;
1959 bool place_after
= place
->stmt
== NULL
;
1960 bool insert_after
= true;
1962 snew
= os
->bfd_section
;
1964 /* Shuffle the bfd section list to make the output file look
1965 neater. This is really only cosmetic. */
1966 if (place
->section
== NULL
1967 && after
!= (void *) lang_os_list
.head
)
1969 asection
*bfd_section
= after
->bfd_section
;
1971 /* If the output statement hasn't been used to place any input
1972 sections (and thus doesn't have an output bfd_section),
1973 look for the closest prior output statement having an
1975 if (bfd_section
== NULL
)
1976 bfd_section
= output_prev_sec_find (after
);
1978 if (bfd_section
!= NULL
1979 && bfd_section
->owner
!= NULL
1980 && bfd_section
!= snew
)
1981 place
->section
= &bfd_section
->next
;
1984 if (place
->section
== NULL
)
1985 place
->section
= &link_info
.output_bfd
->sections
;
1987 as
= *place
->section
;
1991 /* Put the section at the end of the list. */
1993 /* Unlink the section. */
1994 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1996 /* Now tack it back on in the right place. */
1997 bfd_section_list_append (link_info
.output_bfd
, snew
);
1999 else if ((bfd_get_flavour (link_info
.output_bfd
)
2000 == bfd_target_elf_flavour
)
2001 && (bfd_get_flavour (s
->owner
)
2002 == bfd_target_elf_flavour
)
2003 && ((elf_section_type (s
) == SHT_NOTE
2004 && (s
->flags
& SEC_LOAD
) != 0)
2005 || (elf_section_type (as
) == SHT_NOTE
2006 && (as
->flags
& SEC_LOAD
) != 0)))
2008 /* Make sure that output note sections are grouped and sorted
2009 by alignments when inserting a note section or insert a
2010 section after a note section, */
2012 /* A specific section after which the output note section
2013 should be placed. */
2014 asection
*after_sec
;
2015 /* True if we need to insert the orphan section after a
2016 specific section to maintain output note section order. */
2017 bool after_sec_note
= false;
2019 static asection
*first_orphan_note
= NULL
;
2021 /* Group and sort output note section by alignments in
2024 if (elf_section_type (s
) == SHT_NOTE
2025 && (s
->flags
& SEC_LOAD
) != 0)
2027 /* Search from the beginning for the last output note
2028 section with equal or larger alignments. NB: Don't
2029 place orphan note section after non-note sections. */
2031 first_orphan_note
= NULL
;
2032 for (sec
= link_info
.output_bfd
->sections
;
2034 && !bfd_is_abs_section (sec
));
2037 && elf_section_type (sec
) == SHT_NOTE
2038 && (sec
->flags
& SEC_LOAD
) != 0)
2040 if (!first_orphan_note
)
2041 first_orphan_note
= sec
;
2042 if (sec
->alignment_power
>= s
->alignment_power
)
2045 else if (first_orphan_note
)
2047 /* Stop if there is non-note section after the first
2048 orphan note section. */
2052 /* If this will be the first orphan note section, it can
2053 be placed at the default location. */
2054 after_sec_note
= first_orphan_note
!= NULL
;
2055 if (after_sec
== NULL
&& after_sec_note
)
2057 /* If all output note sections have smaller
2058 alignments, place the section before all
2059 output orphan note sections. */
2060 after_sec
= first_orphan_note
;
2061 insert_after
= false;
2064 else if (first_orphan_note
)
2066 /* Don't place non-note sections in the middle of orphan
2068 after_sec_note
= true;
2070 for (sec
= as
->next
;
2072 && !bfd_is_abs_section (sec
));
2074 if (elf_section_type (sec
) == SHT_NOTE
2075 && (sec
->flags
& SEC_LOAD
) != 0)
2083 /* Search forward to insert OS after AFTER_SEC output
2085 lang_output_section_statement_type
*stmt
, *next
;
2087 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2092 if (stmt
->bfd_section
== after_sec
)
2102 /* If INSERT_AFTER is FALSE, place OS before
2103 AFTER_SEC output statement. */
2104 if (next
&& next
->bfd_section
== after_sec
)
2114 /* Search backward to insert OS after AFTER_SEC output
2117 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2121 if (stmt
->bfd_section
== after_sec
)
2130 /* If INSERT_AFTER is FALSE, place OS before
2131 AFTER_SEC output statement. */
2132 if (stmt
->next
->bfd_section
== after_sec
)
2142 if (after_sec
== NULL
2143 || (insert_after
&& after_sec
->next
!= snew
)
2144 || (!insert_after
&& after_sec
->prev
!= snew
))
2146 /* Unlink the section. */
2147 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2149 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2154 bfd_section_list_insert_after (link_info
.output_bfd
,
2157 bfd_section_list_insert_before (link_info
.output_bfd
,
2161 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2164 else if (as
!= snew
&& as
->prev
!= snew
)
2166 /* Unlink the section. */
2167 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2169 /* Now tack it back on in the right place. */
2170 bfd_section_list_insert_before (link_info
.output_bfd
,
2174 else if (as
!= snew
&& as
->prev
!= snew
)
2176 /* Unlink the section. */
2177 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2179 /* Now tack it back on in the right place. */
2180 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2183 /* Save the end of this list. Further ophans of this type will
2184 follow the one we've just added. */
2185 place
->section
= &snew
->next
;
2187 /* The following is non-cosmetic. We try to put the output
2188 statements in some sort of reasonable order here, because they
2189 determine the final load addresses of the orphan sections.
2190 In addition, placing output statements in the wrong order may
2191 require extra segments. For instance, given a typical
2192 situation of all read-only sections placed in one segment and
2193 following that a segment containing all the read-write
2194 sections, we wouldn't want to place an orphan read/write
2195 section before or amongst the read-only ones. */
2196 if (add
.head
!= NULL
)
2198 lang_output_section_statement_type
*newly_added_os
;
2200 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2203 lang_statement_union_type
**where
;
2205 where
= insert_os_after ((lang_statement_union_type
*) after
);
2209 place
->os_tail
= &after
->next
;
2213 /* Put it after the last orphan statement we added. */
2214 *add
.tail
= *place
->stmt
;
2215 *place
->stmt
= add
.head
;
2218 /* Fix the global list pointer if we happened to tack our
2219 new list at the tail. */
2220 if (*stat_ptr
->tail
== add
.head
)
2221 stat_ptr
->tail
= add
.tail
;
2223 /* Save the end of this list. */
2224 place
->stmt
= add
.tail
;
2226 /* Do the same for the list of output section statements. */
2227 newly_added_os
= *os_tail
;
2229 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2230 ((char *) place
->os_tail
2231 - offsetof (lang_output_section_statement_type
, next
));
2232 newly_added_os
->next
= *place
->os_tail
;
2233 if (newly_added_os
->next
!= NULL
)
2234 newly_added_os
->next
->prev
= newly_added_os
;
2235 *place
->os_tail
= newly_added_os
;
2236 place
->os_tail
= &newly_added_os
->next
;
2238 /* Fixing the global list pointer here is a little different.
2239 We added to the list in lang_enter_output_section_statement,
2240 trimmed off the new output_section_statment above when
2241 assigning *os_tail = NULL, but possibly added it back in
2242 the same place when assigning *place->os_tail. */
2243 if (*os_tail
== NULL
)
2244 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2251 lang_print_asneeded (void)
2253 struct asneeded_minfo
*m
;
2255 if (asneeded_list_head
== NULL
)
2258 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2260 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2264 minfo ("%s", m
->soname
);
2265 len
= strlen (m
->soname
);
2272 print_spaces (30 - len
);
2275 minfo ("%pB ", m
->ref
);
2276 minfo ("(%pT)\n", m
->name
);
2281 lang_map_flags (flagword flag
)
2283 if (flag
& SEC_ALLOC
)
2286 if (flag
& SEC_CODE
)
2289 if (flag
& SEC_READONLY
)
2292 if (flag
& SEC_DATA
)
2295 if (flag
& SEC_LOAD
)
2302 lang_memory_region_type
*m
;
2303 bool dis_header_printed
= false;
2305 ldfile_print_input_remaps ();
2307 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2311 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2312 || file
->flags
.just_syms
)
2315 if (config
.print_map_discarded
)
2316 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2317 if ((s
->output_section
== NULL
2318 || s
->output_section
->owner
!= link_info
.output_bfd
)
2319 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2321 if (! dis_header_printed
)
2323 minfo (_("\nDiscarded input sections\n\n"));
2324 dis_header_printed
= true;
2327 print_input_section (s
, true);
2330 if (config
.print_map_discarded
&& ! dis_header_printed
)
2331 minfo (_("\nThere are no discarded input sections\n"));
2333 minfo (_("\nMemory Configuration\n\n"));
2334 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2335 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2337 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2339 fprintf (config
.map_file
, "%-16s", m
->name_list
.name
);
2342 bfd_sprintf_vma (link_info
.output_bfd
, buf
, m
->origin
);
2343 fprintf (config
.map_file
, " 0x%-16s", buf
);
2344 bfd_sprintf_vma (link_info
.output_bfd
, buf
, m
->length
);
2345 fprintf (config
.map_file
,
2346 " 0x%*s", m
->flags
|| m
->not_flags
? -17 : 0, buf
);
2348 lang_map_flags (m
->flags
);
2353 lang_map_flags (m
->not_flags
);
2359 minfo (_("\nLinker script and memory map\n\n"));
2361 if (!link_info
.reduce_memory_overheads
)
2363 obstack_begin (&map_obstack
, 1000);
2364 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2366 expld
.phase
= lang_fixed_phase_enum
;
2367 lang_statement_iteration
++;
2368 print_statements ();
2370 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2375 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2376 void *info ATTRIBUTE_UNUSED
)
2378 if ((hash_entry
->type
== bfd_link_hash_defined
2379 || hash_entry
->type
== bfd_link_hash_defweak
)
2380 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2381 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2383 input_section_userdata_type
*ud
;
2384 struct map_symbol_def
*def
;
2386 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2389 ud
= stat_alloc (sizeof (*ud
));
2390 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2391 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2392 ud
->map_symbol_def_count
= 0;
2394 else if (!ud
->map_symbol_def_tail
)
2395 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2397 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2398 def
->entry
= hash_entry
;
2399 *(ud
->map_symbol_def_tail
) = def
;
2400 ud
->map_symbol_def_tail
= &def
->next
;
2401 ud
->map_symbol_def_count
++;
2406 /* Initialize an output section. */
2409 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2411 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2412 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2415 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2416 if (s
->bfd_section
== NULL
)
2417 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2419 if (s
->bfd_section
== NULL
)
2421 einfo (_("%F%P: output format %s cannot represent section"
2422 " called %s: %E\n"),
2423 link_info
.output_bfd
->xvec
->name
, s
->name
);
2425 s
->bfd_section
->output_section
= s
->bfd_section
;
2426 s
->bfd_section
->output_offset
= 0;
2428 /* Set the userdata of the output section to the output section
2429 statement to avoid lookup. */
2430 bfd_set_section_userdata (s
->bfd_section
, s
);
2432 /* If there is a base address, make sure that any sections it might
2433 mention are initialized. */
2434 if (s
->addr_tree
!= NULL
)
2435 exp_init_os (s
->addr_tree
);
2437 if (s
->load_base
!= NULL
)
2438 exp_init_os (s
->load_base
);
2440 /* If supplied an alignment, set it. */
2441 if (s
->section_alignment
!= NULL
)
2442 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
, s
,
2443 "section alignment");
2446 /* Make sure that all output sections mentioned in an expression are
2450 exp_init_os (etree_type
*exp
)
2452 switch (exp
->type
.node_class
)
2456 case etree_provided
:
2457 exp_init_os (exp
->assign
.src
);
2461 exp_init_os (exp
->binary
.lhs
);
2462 exp_init_os (exp
->binary
.rhs
);
2466 exp_init_os (exp
->trinary
.cond
);
2467 exp_init_os (exp
->trinary
.lhs
);
2468 exp_init_os (exp
->trinary
.rhs
);
2472 exp_init_os (exp
->assert_s
.child
);
2476 exp_init_os (exp
->unary
.child
);
2480 switch (exp
->type
.node_code
)
2485 lang_output_section_statement_type
*os
;
2487 os
= lang_output_section_find (exp
->name
.name
);
2488 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2500 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2502 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2504 /* If we are only reading symbols from this object, then we want to
2505 discard all sections. */
2506 if (entry
->flags
.just_syms
)
2508 bfd_link_just_syms (abfd
, sec
, &link_info
);
2512 /* Deal with SHF_EXCLUDE ELF sections. */
2513 if (!bfd_link_relocatable (&link_info
)
2514 && (abfd
->flags
& BFD_PLUGIN
) == 0
2515 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2516 sec
->output_section
= bfd_abs_section_ptr
;
2518 if (!(abfd
->flags
& DYNAMIC
))
2519 bfd_section_already_linked (abfd
, sec
, &link_info
);
2523 /* Returns true if SECTION is one we know will be discarded based on its
2524 section flags, otherwise returns false. */
2527 lang_discard_section_p (asection
*section
)
2530 flagword flags
= section
->flags
;
2532 /* Discard sections marked with SEC_EXCLUDE. */
2533 discard
= (flags
& SEC_EXCLUDE
) != 0;
2535 /* Discard the group descriptor sections when we're finally placing the
2536 sections from within the group. */
2537 if ((flags
& SEC_GROUP
) != 0
2538 && link_info
.resolve_section_groups
)
2541 /* Discard debugging sections if we are stripping debugging
2543 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2544 && (flags
& SEC_DEBUGGING
) != 0)
2547 /* Discard non-alloc sections if we are stripping section headers. */
2548 else if (config
.no_section_header
&& (flags
& SEC_ALLOC
) == 0)
2554 /* Return TRUE if SECTION is never going to be added to output statement
2555 OUTPUT. lang_add_section() definitely won't do anything with SECTION
2556 if this returns TRUE. It may do something (or not) if this returns FALSE.
2558 Can be used as early-out to filter matches. This may set
2559 output_section of SECTION, if it was unset, to the abs section in case
2560 we discover SECTION to be always discarded. This may also give
2561 warning messages. */
2564 wont_add_section_p (asection
*section
,
2565 lang_output_section_statement_type
*output
)
2569 /* Is this section one we know should be discarded? */
2570 discard
= lang_discard_section_p (section
);
2572 /* Discard input sections which are assigned to a section named
2573 DISCARD_SECTION_NAME. */
2574 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2579 if (section
->output_section
== NULL
)
2581 /* This prevents future calls from assigning this section or
2582 warning about it again. */
2583 section
->output_section
= bfd_abs_section_ptr
;
2585 else if (bfd_is_abs_section (section
->output_section
))
2587 else if (link_info
.non_contiguous_regions_warnings
)
2588 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2589 "section `%pA' from `%pB' match /DISCARD/ clause.\n"),
2590 NULL
, section
, section
->owner
);
2595 if (section
->output_section
!= NULL
)
2597 if (!link_info
.non_contiguous_regions
)
2600 /* SECTION has already been handled in a special way
2601 (eg. LINK_ONCE): skip it. */
2602 if (bfd_is_abs_section (section
->output_section
))
2605 /* Already assigned to the same output section, do not process
2606 it again, to avoid creating loops between duplicate sections
2608 if (section
->output_section
== output
->bfd_section
)
2611 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2612 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2613 "change behaviour for section `%pA' from `%pB' (assigned to "
2614 "%pA, but additional match: %pA)\n"),
2615 NULL
, section
, section
->owner
, section
->output_section
,
2616 output
->bfd_section
);
2618 /* SECTION has already been assigned to an output section, but
2619 the user allows it to be mapped to another one in case it
2620 overflows. We'll later update the actual output section in
2621 size_input_section as appropriate. */
2627 /* The wild routines.
2629 These expand statements like *(.text) and foo.o to a list of
2630 explicit actions, like foo.o(.text), bar.o(.text) and
2631 foo.o(.text, .data). */
2633 /* Add SECTION to the output section OUTPUT. Do this by creating a
2634 lang_input_section statement which is placed at PTR. */
2637 lang_add_section (lang_statement_list_type
*ptr
,
2639 struct wildcard_list
*pattern
,
2640 struct flag_info
*sflag_info
,
2641 lang_output_section_statement_type
*output
)
2643 flagword flags
= section
->flags
;
2645 lang_input_section_type
*new_section
;
2646 bfd
*abfd
= link_info
.output_bfd
;
2648 if (wont_add_section_p (section
, output
))
2655 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2660 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2661 to an output section, because we want to be able to include a
2662 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2663 section (I don't know why we want to do this, but we do).
2664 build_link_order in ldwrite.c handles this case by turning
2665 the embedded SEC_NEVER_LOAD section into a fill. */
2666 flags
&= ~ SEC_NEVER_LOAD
;
2668 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2669 already been processed. One reason to do this is that on pe
2670 format targets, .text$foo sections go into .text and it's odd
2671 to see .text with SEC_LINK_ONCE set. */
2672 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2674 if (link_info
.resolve_section_groups
)
2675 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2677 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2679 else if (!bfd_link_relocatable (&link_info
))
2680 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2682 switch (output
->sectype
)
2684 case normal_section
:
2685 case overlay_section
:
2686 case first_overlay_section
:
2689 case noalloc_section
:
2690 flags
&= ~SEC_ALLOC
;
2692 case typed_readonly_section
:
2693 case readonly_section
:
2694 flags
|= SEC_READONLY
;
2696 case noload_section
:
2698 flags
|= SEC_NEVER_LOAD
;
2699 /* Unfortunately GNU ld has managed to evolve two different
2700 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2701 alloc, no contents section. All others get a noload, noalloc
2703 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2704 flags
&= ~SEC_HAS_CONTENTS
;
2706 flags
&= ~SEC_ALLOC
;
2710 if (output
->bfd_section
== NULL
)
2711 init_os (output
, flags
);
2713 /* If SEC_READONLY is not set in the input section, then clear
2714 it from the output section. */
2715 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2717 if (output
->bfd_section
->linker_has_input
)
2719 /* Only set SEC_READONLY flag on the first input section. */
2720 flags
&= ~ SEC_READONLY
;
2722 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2723 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2724 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2725 || ((flags
& SEC_MERGE
) != 0
2726 && output
->bfd_section
->entsize
!= section
->entsize
))
2728 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2729 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2732 output
->bfd_section
->flags
|= flags
;
2734 if (!output
->bfd_section
->linker_has_input
)
2736 output
->bfd_section
->linker_has_input
= 1;
2737 /* This must happen after flags have been updated. The output
2738 section may have been created before we saw its first input
2739 section, eg. for a data statement. */
2740 bfd_init_private_section_data (section
->owner
, section
,
2741 link_info
.output_bfd
,
2742 output
->bfd_section
,
2744 if ((flags
& SEC_MERGE
) != 0)
2745 output
->bfd_section
->entsize
= section
->entsize
;
2748 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2749 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2751 /* FIXME: This value should really be obtained from the bfd... */
2752 output
->block_value
= 128;
2755 /* When a .ctors section is placed in .init_array it must be copied
2756 in reverse order. Similarly for .dtors. Set that up. */
2757 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
2758 && ((startswith (section
->name
, ".ctors")
2759 && strcmp (output
->bfd_section
->name
, ".init_array") == 0)
2760 || (startswith (section
->name
, ".dtors")
2761 && strcmp (output
->bfd_section
->name
, ".fini_array") == 0))
2762 && (section
->name
[6] == 0 || section
->name
[6] == '.'))
2763 section
->flags
|= SEC_ELF_REVERSE_COPY
;
2765 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2766 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2768 section
->output_section
= output
->bfd_section
;
2770 if (!map_head_is_link_order
)
2772 asection
*s
= output
->bfd_section
->map_tail
.s
;
2773 output
->bfd_section
->map_tail
.s
= section
;
2774 section
->map_head
.s
= NULL
;
2775 section
->map_tail
.s
= s
;
2777 s
->map_head
.s
= section
;
2779 output
->bfd_section
->map_head
.s
= section
;
2782 /* Add a section reference to the list. */
2783 new_section
= new_stat (lang_input_section
, ptr
);
2784 new_section
->section
= section
;
2785 new_section
->pattern
= pattern
;
2788 /* Expand a wild statement for a particular FILE. SECTION may be
2789 NULL, in which case it is a wild card. This assumes that the
2790 wild statement doesn't need any sorting (of filenames or sections). */
2793 output_section_callback_nosort (lang_wild_statement_type
*ptr
,
2794 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2796 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2799 lang_output_section_statement_type
*os
;
2801 os
= (lang_output_section_statement_type
*) output
;
2803 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2804 if (unique_section_p (section
, os
))
2807 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2808 ptr
->section_flag_list
, os
);
2811 /* Check if all sections in a wild statement for a particular FILE
2815 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2816 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2818 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2821 lang_output_section_statement_type
*os
;
2823 os
= (lang_output_section_statement_type
*) output
;
2825 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2826 if (unique_section_p (section
, os
))
2829 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2830 os
->all_input_readonly
= false;
2833 /* This is passed a file name which must have been seen already and
2834 added to the statement tree. We will see if it has been opened
2835 already and had its symbols read. If not then we'll read it. */
2837 static lang_input_statement_type
*
2838 lookup_name (const char *name
)
2840 lang_input_statement_type
*search
;
2842 for (search
= (void *) input_file_chain
.head
;
2844 search
= search
->next_real_file
)
2846 /* Use the local_sym_name as the name of the file that has
2847 already been loaded as filename might have been transformed
2848 via the search directory lookup mechanism. */
2849 const char *filename
= search
->local_sym_name
;
2851 if (filename
!= NULL
2852 && filename_cmp (filename
, name
) == 0)
2858 /* Arrange to splice the input statement added by new_afile into
2859 statement_list after the current input_file_chain tail.
2860 We know input_file_chain is not an empty list, and that
2861 lookup_name was called via open_input_bfds. Later calls to
2862 lookup_name should always match an existing input_statement. */
2863 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2864 lang_statement_union_type
**after
2865 = (void *) ((char *) input_file_chain
.tail
2866 - offsetof (lang_input_statement_type
, next_real_file
)
2867 + offsetof (lang_input_statement_type
, header
.next
));
2868 lang_statement_union_type
*rest
= *after
;
2869 stat_ptr
->tail
= after
;
2870 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2871 default_target
, NULL
);
2872 *stat_ptr
->tail
= rest
;
2874 stat_ptr
->tail
= tail
;
2877 /* If we have already added this file, or this file is not real
2878 don't add this file. */
2879 if (search
->flags
.loaded
|| !search
->flags
.real
)
2882 if (!load_symbols (search
, NULL
))
2888 /* Save LIST as a list of libraries whose symbols should not be exported. */
2893 struct excluded_lib
*next
;
2895 static struct excluded_lib
*excluded_libs
;
2898 add_excluded_libs (const char *list
)
2900 const char *p
= list
, *end
;
2904 struct excluded_lib
*entry
;
2905 end
= strpbrk (p
, ",:");
2907 end
= p
+ strlen (p
);
2908 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2909 entry
->next
= excluded_libs
;
2910 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2911 memcpy (entry
->name
, p
, end
- p
);
2912 entry
->name
[end
- p
] = '\0';
2913 excluded_libs
= entry
;
2921 check_excluded_libs (bfd
*abfd
)
2923 struct excluded_lib
*lib
= excluded_libs
;
2927 int len
= strlen (lib
->name
);
2928 const char *filename
= lbasename (bfd_get_filename (abfd
));
2930 if (strcmp (lib
->name
, "ALL") == 0)
2932 abfd
->no_export
= true;
2936 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2937 && (filename
[len
] == '\0'
2938 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2939 && filename
[len
+ 2] == '\0')))
2941 abfd
->no_export
= true;
2949 /* Get the symbols for an input file. */
2952 load_symbols (lang_input_statement_type
*entry
,
2953 lang_statement_list_type
*place
)
2957 if (entry
->flags
.loaded
)
2960 ldfile_open_file (entry
);
2962 /* Do not process further if the file was missing. */
2963 if (entry
->flags
.missing_file
)
2966 if (trace_files
|| verbose
)
2967 info_msg ("%pI\n", entry
);
2969 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2970 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2973 struct lang_input_statement_flags save_flags
;
2976 err
= bfd_get_error ();
2978 /* See if the emulation has some special knowledge. */
2979 if (ldemul_unrecognized_file (entry
))
2981 if (err
== bfd_error_file_ambiguously_recognized
)
2986 if (err
== bfd_error_file_ambiguously_recognized
)
2990 einfo (_("%P: %pB: file not recognized: %E;"
2991 " matching formats:"), entry
->the_bfd
);
2992 for (p
= matching
; *p
!= NULL
; p
++)
2997 else if (err
!= bfd_error_file_not_recognized
2999 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3001 bfd_close (entry
->the_bfd
);
3002 entry
->the_bfd
= NULL
;
3004 /* Try to interpret the file as a linker script. */
3005 save_flags
= input_flags
;
3006 ldfile_open_command_file (entry
->filename
);
3008 push_stat_ptr (place
);
3009 input_flags
.add_DT_NEEDED_for_regular
3010 = entry
->flags
.add_DT_NEEDED_for_regular
;
3011 input_flags
.add_DT_NEEDED_for_dynamic
3012 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3013 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3014 input_flags
.dynamic
= entry
->flags
.dynamic
;
3016 ldfile_assumed_script
= true;
3017 parser_input
= input_script
;
3018 current_input_file
= entry
->filename
;
3020 current_input_file
= NULL
;
3021 ldfile_assumed_script
= false;
3023 /* missing_file is sticky. sysrooted will already have been
3024 restored when seeing EOF in yyparse, but no harm to restore
3026 save_flags
.missing_file
|= input_flags
.missing_file
;
3027 input_flags
= save_flags
;
3031 entry
->flags
.loaded
= true;
3036 if (ldemul_recognized_file (entry
))
3039 /* We don't call ldlang_add_file for an archive. Instead, the
3040 add_symbols entry point will call ldlang_add_file, via the
3041 add_archive_element callback, for each element of the archive
3043 switch (bfd_get_format (entry
->the_bfd
))
3049 if (!entry
->flags
.reload
)
3050 ldlang_add_file (entry
);
3054 check_excluded_libs (entry
->the_bfd
);
3056 bfd_set_usrdata (entry
->the_bfd
, entry
);
3057 if (entry
->flags
.whole_archive
)
3065 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3070 if (!bfd_check_format (member
, bfd_object
))
3072 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3073 entry
->the_bfd
, member
);
3078 if (!(*link_info
.callbacks
3079 ->add_archive_element
) (&link_info
, member
,
3080 "--whole-archive", &subsbfd
))
3083 /* Potentially, the add_archive_element hook may have set a
3084 substitute BFD for us. */
3085 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3087 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3092 entry
->flags
.loaded
= loaded
;
3098 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3099 entry
->flags
.loaded
= true;
3101 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3103 return entry
->flags
.loaded
;
3106 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3107 may be NULL, indicating that it is a wildcard. Separate
3108 lang_input_section statements are created for each part of the
3109 expansion; they are added after the wild statement S. OUTPUT is
3110 the output section. */
3113 wild (lang_wild_statement_type
*s
,
3114 const char *target ATTRIBUTE_UNUSED
,
3115 lang_output_section_statement_type
*output
)
3117 struct wildcard_list
*sec
;
3119 if (s
->filenames_sorted
|| s
->any_specs_sorted
)
3121 lang_section_bst_type
*tree
;
3123 walk_wild (s
, output_section_callback_sort
, output
);
3128 output_section_callback_tree_to_list (s
, tree
, output
);
3130 s
->rightmost
= &s
->tree
;
3134 walk_wild (s
, output_section_callback_nosort
, output
);
3136 if (default_common_section
== NULL
)
3137 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3138 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3140 /* Remember the section that common is going to in case we
3141 later get something which doesn't know where to put it. */
3142 default_common_section
= output
;
3147 /* Return TRUE iff target is the sought target. */
3150 get_target (const bfd_target
*target
, void *data
)
3152 const char *sought
= (const char *) data
;
3154 return strcmp (target
->name
, sought
) == 0;
3157 /* Like strcpy() but convert to lower case as well. */
3160 stricpy (char *dest
, const char *src
)
3164 while ((c
= *src
++) != 0)
3165 *dest
++ = TOLOWER (c
);
3170 /* Remove the first occurrence of needle (if any) in haystack
3174 strcut (char *haystack
, const char *needle
)
3176 haystack
= strstr (haystack
, needle
);
3182 for (src
= haystack
+ strlen (needle
); *src
;)
3183 *haystack
++ = *src
++;
3189 /* Compare two target format name strings.
3190 Return a value indicating how "similar" they are. */
3193 name_compare (const char *first
, const char *second
)
3199 copy1
= (char *) xmalloc (strlen (first
) + 1);
3200 copy2
= (char *) xmalloc (strlen (second
) + 1);
3202 /* Convert the names to lower case. */
3203 stricpy (copy1
, first
);
3204 stricpy (copy2
, second
);
3206 /* Remove size and endian strings from the name. */
3207 strcut (copy1
, "big");
3208 strcut (copy1
, "little");
3209 strcut (copy2
, "big");
3210 strcut (copy2
, "little");
3212 /* Return a value based on how many characters match,
3213 starting from the beginning. If both strings are
3214 the same then return 10 * their length. */
3215 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3216 if (copy1
[result
] == 0)
3228 /* Set by closest_target_match() below. */
3229 static const bfd_target
*winner
;
3231 /* Scan all the valid bfd targets looking for one that has the endianness
3232 requirement that was specified on the command line, and is the nearest
3233 match to the original output target. */
3236 closest_target_match (const bfd_target
*target
, void *data
)
3238 const bfd_target
*original
= (const bfd_target
*) data
;
3240 if (command_line
.endian
== ENDIAN_BIG
3241 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3244 if (command_line
.endian
== ENDIAN_LITTLE
3245 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3248 /* Must be the same flavour. */
3249 if (target
->flavour
!= original
->flavour
)
3252 /* Ignore generic big and little endian elf vectors. */
3253 if (strcmp (target
->name
, "elf32-big") == 0
3254 || strcmp (target
->name
, "elf64-big") == 0
3255 || strcmp (target
->name
, "elf32-little") == 0
3256 || strcmp (target
->name
, "elf64-little") == 0)
3259 /* If we have not found a potential winner yet, then record this one. */
3266 /* Oh dear, we now have two potential candidates for a successful match.
3267 Compare their names and choose the better one. */
3268 if (name_compare (target
->name
, original
->name
)
3269 > name_compare (winner
->name
, original
->name
))
3272 /* Keep on searching until wqe have checked them all. */
3276 /* Return the BFD target format of the first input file. */
3279 get_first_input_target (void)
3281 const char *target
= NULL
;
3283 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3285 if (s
->header
.type
== lang_input_statement_enum
3288 ldfile_open_file (s
);
3290 if (s
->the_bfd
!= NULL
3291 && bfd_check_format (s
->the_bfd
, bfd_object
))
3293 target
= bfd_get_target (s
->the_bfd
);
3305 lang_get_output_target (void)
3309 /* Has the user told us which output format to use? */
3310 if (output_target
!= NULL
)
3311 return output_target
;
3313 /* No - has the current target been set to something other than
3315 if (current_target
!= default_target
&& current_target
!= NULL
)
3316 return current_target
;
3318 /* No - can we determine the format of the first input file? */
3319 target
= get_first_input_target ();
3323 /* Failed - use the default output target. */
3324 return default_target
;
3327 /* Open the output file. */
3330 open_output (const char *name
)
3332 lang_input_statement_type
*f
;
3333 char *out
= lrealpath (name
);
3335 for (f
= (void *) input_file_chain
.head
;
3337 f
= f
->next_real_file
)
3340 char *in
= lrealpath (f
->local_sym_name
);
3341 if (filename_cmp (in
, out
) == 0)
3342 einfo (_("%F%P: input file '%s' is the same as output file\n"),
3348 output_target
= lang_get_output_target ();
3350 /* Has the user requested a particular endianness on the command
3352 if (command_line
.endian
!= ENDIAN_UNSET
)
3354 /* Get the chosen target. */
3355 const bfd_target
*target
3356 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3358 /* If the target is not supported, we cannot do anything. */
3361 enum bfd_endian desired_endian
;
3363 if (command_line
.endian
== ENDIAN_BIG
)
3364 desired_endian
= BFD_ENDIAN_BIG
;
3366 desired_endian
= BFD_ENDIAN_LITTLE
;
3368 /* See if the target has the wrong endianness. This should
3369 not happen if the linker script has provided big and
3370 little endian alternatives, but some scrips don't do
3372 if (target
->byteorder
!= desired_endian
)
3374 /* If it does, then see if the target provides
3375 an alternative with the correct endianness. */
3376 if (target
->alternative_target
!= NULL
3377 && (target
->alternative_target
->byteorder
== desired_endian
))
3378 output_target
= target
->alternative_target
->name
;
3381 /* Try to find a target as similar as possible to
3382 the default target, but which has the desired
3383 endian characteristic. */
3384 bfd_iterate_over_targets (closest_target_match
,
3387 /* Oh dear - we could not find any targets that
3388 satisfy our requirements. */
3390 einfo (_("%P: warning: could not find any targets"
3391 " that match endianness requirement\n"));
3393 output_target
= winner
->name
;
3399 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3401 if (link_info
.output_bfd
== NULL
)
3403 if (bfd_get_error () == bfd_error_invalid_target
)
3404 einfo (_("%F%P: target %s not found\n"), output_target
);
3406 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3409 delete_output_file_on_failure
= true;
3411 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3412 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3413 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3414 ldfile_output_architecture
,
3415 ldfile_output_machine
))
3416 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3418 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3419 if (link_info
.hash
== NULL
)
3420 einfo (_("%F%P: can not create hash table: %E\n"));
3422 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3426 ldlang_open_output (lang_statement_union_type
*statement
)
3428 switch (statement
->header
.type
)
3430 case lang_output_statement_enum
:
3431 ASSERT (link_info
.output_bfd
== NULL
);
3432 open_output (statement
->output_statement
.name
);
3433 ldemul_set_output_arch ();
3434 if (config
.magic_demand_paged
3435 && !bfd_link_relocatable (&link_info
))
3436 link_info
.output_bfd
->flags
|= D_PAGED
;
3438 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3439 if (config
.text_read_only
)
3440 link_info
.output_bfd
->flags
|= WP_TEXT
;
3442 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3443 if (link_info
.traditional_format
)
3444 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3446 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3447 if (config
.no_section_header
)
3448 link_info
.output_bfd
->flags
|= BFD_NO_SECTION_HEADER
;
3450 link_info
.output_bfd
->flags
&= ~BFD_NO_SECTION_HEADER
;
3453 case lang_target_statement_enum
:
3454 current_target
= statement
->target_statement
.target
;
3462 init_opb (asection
*s
)
3467 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3469 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3472 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3473 ldfile_output_machine
);
3475 while ((x
& 1) == 0)
3483 /* Open all the input files. */
3487 OPEN_BFD_NORMAL
= 0,
3491 #if BFD_SUPPORTS_PLUGINS
3492 static lang_input_statement_type
*plugin_insert
= NULL
;
3493 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3497 open_input_bfds (lang_statement_union_type
*s
,
3498 lang_output_section_statement_type
*os
,
3499 enum open_bfd_mode mode
)
3501 for (; s
!= NULL
; s
= s
->header
.next
)
3503 switch (s
->header
.type
)
3505 case lang_constructors_statement_enum
:
3506 open_input_bfds (constructor_list
.head
, os
, mode
);
3508 case lang_output_section_statement_enum
:
3509 os
= &s
->output_section_statement
;
3510 open_input_bfds (os
->children
.head
, os
, mode
);
3512 case lang_wild_statement_enum
:
3513 /* Maybe we should load the file's symbols. */
3514 if ((mode
& OPEN_BFD_RESCAN
) == 0
3515 && s
->wild_statement
.filename
3516 && !wildcardp (s
->wild_statement
.filename
)
3517 && !archive_path (s
->wild_statement
.filename
))
3518 lookup_name (s
->wild_statement
.filename
);
3519 open_input_bfds (s
->wild_statement
.children
.head
, os
, mode
);
3521 case lang_group_statement_enum
:
3523 struct bfd_link_hash_entry
*undefs
;
3524 #if BFD_SUPPORTS_PLUGINS
3525 lang_input_statement_type
*plugin_insert_save
;
3528 /* We must continually search the entries in the group
3529 until no new symbols are added to the list of undefined
3534 #if BFD_SUPPORTS_PLUGINS
3535 plugin_insert_save
= plugin_insert
;
3537 undefs
= link_info
.hash
->undefs_tail
;
3538 open_input_bfds (s
->group_statement
.children
.head
, os
,
3539 mode
| OPEN_BFD_FORCE
);
3541 while (undefs
!= link_info
.hash
->undefs_tail
3542 #if BFD_SUPPORTS_PLUGINS
3543 /* Objects inserted by a plugin, which are loaded
3544 before we hit this loop, may have added new
3546 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3551 case lang_target_statement_enum
:
3552 current_target
= s
->target_statement
.target
;
3554 case lang_input_statement_enum
:
3555 if (s
->input_statement
.flags
.real
)
3557 lang_statement_union_type
**os_tail
;
3558 lang_statement_list_type add
;
3561 s
->input_statement
.target
= current_target
;
3563 /* If we are being called from within a group, and this
3564 is an archive which has already been searched, then
3565 force it to be researched unless the whole archive
3566 has been loaded already. Do the same for a rescan.
3567 Likewise reload --as-needed shared libs. */
3568 if (mode
!= OPEN_BFD_NORMAL
3569 #if BFD_SUPPORTS_PLUGINS
3570 && ((mode
& OPEN_BFD_RESCAN
) == 0
3571 || plugin_insert
== NULL
)
3573 && s
->input_statement
.flags
.loaded
3574 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3575 && ((bfd_get_format (abfd
) == bfd_archive
3576 && !s
->input_statement
.flags
.whole_archive
)
3577 || (bfd_get_format (abfd
) == bfd_object
3578 && ((abfd
->flags
) & DYNAMIC
) != 0
3579 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3580 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3581 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3583 s
->input_statement
.flags
.loaded
= false;
3584 s
->input_statement
.flags
.reload
= true;
3587 os_tail
= lang_os_list
.tail
;
3588 lang_list_init (&add
);
3590 if (!load_symbols (&s
->input_statement
, &add
))
3591 config
.make_executable
= false;
3593 if (add
.head
!= NULL
)
3595 /* If this was a script with output sections then
3596 tack any added statements on to the end of the
3597 list. This avoids having to reorder the output
3598 section statement list. Very likely the user
3599 forgot -T, and whatever we do here will not meet
3600 naive user expectations. */
3601 if (os_tail
!= lang_os_list
.tail
)
3603 einfo (_("%P: warning: %s contains output sections;"
3604 " did you forget -T?\n"),
3605 s
->input_statement
.filename
);
3606 *stat_ptr
->tail
= add
.head
;
3607 stat_ptr
->tail
= add
.tail
;
3611 *add
.tail
= s
->header
.next
;
3612 s
->header
.next
= add
.head
;
3616 #if BFD_SUPPORTS_PLUGINS
3617 /* If we have found the point at which a plugin added new
3618 files, clear plugin_insert to enable archive rescan. */
3619 if (&s
->input_statement
== plugin_insert
)
3620 plugin_insert
= NULL
;
3623 case lang_assignment_statement_enum
:
3624 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3625 exp_fold_tree_no_dot (s
->assignment_statement
.exp
, os
);
3632 /* Exit if any of the files were missing. */
3633 if (input_flags
.missing_file
)
3637 #ifdef ENABLE_LIBCTF
3638 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3639 that happened specifically at CTF open time. */
3641 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3643 ctf_next_t
*i
= NULL
;
3648 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3650 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3654 if (err
!= ECTF_NEXT_END
)
3656 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3660 /* `err' returns errors from the error/warning iterator in particular.
3661 These never assert. But if we have an fp, that could have recorded
3662 an assertion failure: assert if it has done so. */
3663 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3666 /* Open the CTF sections in the input files with libctf: if any were opened,
3667 create a fake input file that we'll write the merged CTF data to later
3671 ldlang_open_ctf (void)
3676 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3680 /* Incoming files from the compiler have a single ctf_dict_t in them
3681 (which is presented to us by the libctf API in a ctf_archive_t
3682 wrapper): files derived from a previous relocatable link have a CTF
3683 archive containing possibly many CTF files. */
3685 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3687 if (err
!= ECTF_NOCTFDATA
)
3689 lang_ctf_errs_warnings (NULL
);
3690 einfo (_("%P: warning: CTF section in %pB not loaded; "
3691 "its types will be discarded: %s\n"), file
->the_bfd
,
3697 /* Prevent the contents of this section from being written, while
3698 requiring the section itself to be duplicated in the output, but only
3700 /* This section must exist if ctf_bfdopen() succeeded. */
3701 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3703 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3706 sect
->flags
|= SEC_EXCLUDE
;
3716 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3719 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3722 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3723 ctf_close (errfile
->the_ctf
);
3726 /* Merge together CTF sections. After this, only the symtab-dependent
3727 function and data object sections need adjustment. */
3730 lang_merge_ctf (void)
3732 asection
*output_sect
;
3738 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3740 /* If the section was discarded, don't waste time merging. */
3741 if (output_sect
== NULL
)
3743 ctf_dict_close (ctf_output
);
3746 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3748 ctf_close (file
->the_ctf
);
3749 file
->the_ctf
= NULL
;
3754 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3759 /* Takes ownership of file->the_ctf. */
3760 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3762 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3763 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3764 ctf_close (file
->the_ctf
);
3765 file
->the_ctf
= NULL
;
3770 if (!config
.ctf_share_duplicated
)
3771 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3773 flags
= CTF_LINK_SHARE_DUPLICATED
;
3774 if (!config
.ctf_variables
)
3775 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3776 if (bfd_link_relocatable (&link_info
))
3777 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3779 if (ctf_link (ctf_output
, flags
) < 0)
3781 lang_ctf_errs_warnings (ctf_output
);
3782 einfo (_("%P: warning: CTF linking failed; "
3783 "output will have no CTF section: %s\n"),
3784 ctf_errmsg (ctf_errno (ctf_output
)));
3787 output_sect
->size
= 0;
3788 output_sect
->flags
|= SEC_EXCLUDE
;
3791 /* Output any lingering errors that didn't come from ctf_link. */
3792 lang_ctf_errs_warnings (ctf_output
);
3795 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3796 the CTF, if supported. */
3799 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3801 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3804 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3806 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3808 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3811 /* Write out the CTF section. Called early, if the emulation isn't going to
3812 need to dedup against the strtab and symtab, then possibly called from the
3813 target linker code if the dedup has happened. */
3815 lang_write_ctf (int late
)
3818 asection
*output_sect
;
3825 /* Emit CTF late if this emulation says it can do so. */
3826 if (ldemul_emit_ctf_early ())
3831 if (!ldemul_emit_ctf_early ())
3835 /* Inform the emulation that all the symbols that will be received have
3838 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3842 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3845 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3846 CTF_COMPRESSION_THRESHOLD
);
3847 output_sect
->size
= output_size
;
3848 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3850 lang_ctf_errs_warnings (ctf_output
);
3851 if (!output_sect
->contents
)
3853 einfo (_("%P: warning: CTF section emission failed; "
3854 "output will have no CTF section: %s\n"),
3855 ctf_errmsg (ctf_errno (ctf_output
)));
3856 output_sect
->size
= 0;
3857 output_sect
->flags
|= SEC_EXCLUDE
;
3861 /* This also closes every CTF input file used in the link. */
3862 ctf_dict_close (ctf_output
);
3865 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3866 file
->the_ctf
= NULL
;
3869 /* Write out the CTF section late, if the emulation needs that. */
3872 ldlang_write_ctf_late (void)
3874 /* Trigger a "late call", if the emulation needs one. */
3880 ldlang_open_ctf (void)
3882 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3886 /* If built without CTF, warn and delete all CTF sections from the output.
3887 (The alternative would be to simply concatenate them, which does not
3888 yield a valid CTF section.) */
3890 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3892 einfo (_("%P: warning: CTF section in %pB not linkable: "
3893 "%P was built without support for CTF\n"), file
->the_bfd
);
3895 sect
->flags
|= SEC_EXCLUDE
;
3900 static void lang_merge_ctf (void) {}
3902 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3903 ATTRIBUTE_UNUSED
) {}
3905 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3906 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3907 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3908 void ldlang_write_ctf_late (void) {}
3911 /* Add the supplied name to the symbol table as an undefined reference.
3912 This is a two step process as the symbol table doesn't even exist at
3913 the time the ld command line is processed. First we put the name
3914 on a list, then, once the output file has been opened, transfer the
3915 name to the symbol table. */
3917 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3919 #define ldlang_undef_chain_list_head entry_symbol.next
3922 ldlang_add_undef (const char *const name
, bool cmdline ATTRIBUTE_UNUSED
)
3924 ldlang_undef_chain_list_type
*new_undef
;
3926 new_undef
= stat_alloc (sizeof (*new_undef
));
3927 new_undef
->next
= ldlang_undef_chain_list_head
;
3928 ldlang_undef_chain_list_head
= new_undef
;
3930 new_undef
->name
= xstrdup (name
);
3932 if (link_info
.output_bfd
!= NULL
)
3933 insert_undefined (new_undef
->name
);
3936 /* Insert NAME as undefined in the symbol table. */
3939 insert_undefined (const char *name
)
3941 struct bfd_link_hash_entry
*h
;
3943 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
3945 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3946 if (h
->type
== bfd_link_hash_new
)
3948 h
->type
= bfd_link_hash_undefined
;
3949 h
->u
.undef
.abfd
= NULL
;
3950 h
->non_ir_ref_regular
= true;
3951 bfd_link_add_undef (link_info
.hash
, h
);
3955 /* Run through the list of undefineds created above and place them
3956 into the linker hash table as undefined symbols belonging to the
3960 lang_place_undefineds (void)
3962 ldlang_undef_chain_list_type
*ptr
;
3964 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3965 insert_undefined (ptr
->name
);
3968 /* Mark -u symbols against garbage collection. */
3971 lang_mark_undefineds (void)
3973 ldlang_undef_chain_list_type
*ptr
;
3975 if (is_elf_hash_table (link_info
.hash
))
3976 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3978 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
3979 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, false, false, true);
3985 /* Structure used to build the list of symbols that the user has required
3988 struct require_defined_symbol
3991 struct require_defined_symbol
*next
;
3994 /* The list of symbols that the user has required be defined. */
3996 static struct require_defined_symbol
*require_defined_symbol_list
;
3998 /* Add a new symbol NAME to the list of symbols that are required to be
4002 ldlang_add_require_defined (const char *const name
)
4004 struct require_defined_symbol
*ptr
;
4006 ldlang_add_undef (name
, true);
4007 ptr
= stat_alloc (sizeof (*ptr
));
4008 ptr
->next
= require_defined_symbol_list
;
4009 ptr
->name
= strdup (name
);
4010 require_defined_symbol_list
= ptr
;
4013 /* Check that all symbols the user required to be defined, are defined,
4014 raise an error if we find a symbol that is not defined. */
4017 ldlang_check_require_defined_symbols (void)
4019 struct require_defined_symbol
*ptr
;
4021 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4023 struct bfd_link_hash_entry
*h
;
4025 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4026 false, false, true);
4028 || (h
->type
!= bfd_link_hash_defined
4029 && h
->type
!= bfd_link_hash_defweak
))
4030 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4034 /* Check for all readonly or some readwrite sections. */
4037 check_input_sections
4038 (lang_statement_union_type
*s
,
4039 lang_output_section_statement_type
*output_section_statement
)
4041 for (; s
!= NULL
; s
= s
->header
.next
)
4043 switch (s
->header
.type
)
4045 case lang_wild_statement_enum
:
4046 walk_wild (&s
->wild_statement
, check_section_callback
,
4047 output_section_statement
);
4048 if (!output_section_statement
->all_input_readonly
)
4051 case lang_constructors_statement_enum
:
4052 check_input_sections (constructor_list
.head
,
4053 output_section_statement
);
4054 if (!output_section_statement
->all_input_readonly
)
4057 case lang_group_statement_enum
:
4058 check_input_sections (s
->group_statement
.children
.head
,
4059 output_section_statement
);
4060 if (!output_section_statement
->all_input_readonly
)
4069 /* Update wildcard statements if needed. */
4072 update_wild_statements (lang_statement_union_type
*s
)
4074 struct wildcard_list
*sec
;
4076 switch (sort_section
)
4086 for (; s
!= NULL
; s
= s
->header
.next
)
4088 switch (s
->header
.type
)
4093 case lang_wild_statement_enum
:
4094 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4096 /* Don't sort .init/.fini sections. */
4097 if (strcmp (sec
->spec
.name
, ".init") != 0
4098 && strcmp (sec
->spec
.name
, ".fini") != 0)
4100 switch (sec
->spec
.sorted
)
4103 sec
->spec
.sorted
= sort_section
;
4106 if (sort_section
== by_alignment
)
4107 sec
->spec
.sorted
= by_name_alignment
;
4110 if (sort_section
== by_name
)
4111 sec
->spec
.sorted
= by_alignment_name
;
4116 s
->wild_statement
.any_specs_sorted
= true;
4120 case lang_constructors_statement_enum
:
4121 update_wild_statements (constructor_list
.head
);
4124 case lang_output_section_statement_enum
:
4125 update_wild_statements
4126 (s
->output_section_statement
.children
.head
);
4129 case lang_group_statement_enum
:
4130 update_wild_statements (s
->group_statement
.children
.head
);
4138 /* Open input files and attach to output sections. */
4141 map_input_to_output_sections
4142 (lang_statement_union_type
*s
, const char *target
,
4143 lang_output_section_statement_type
*os
)
4145 for (; s
!= NULL
; s
= s
->header
.next
)
4147 lang_output_section_statement_type
*tos
;
4149 unsigned int type
= 0;
4151 switch (s
->header
.type
)
4153 case lang_wild_statement_enum
:
4154 wild (&s
->wild_statement
, target
, os
);
4156 case lang_constructors_statement_enum
:
4157 map_input_to_output_sections (constructor_list
.head
,
4161 case lang_output_section_statement_enum
:
4162 tos
= &s
->output_section_statement
;
4163 if (tos
->constraint
== ONLY_IF_RW
4164 || tos
->constraint
== ONLY_IF_RO
)
4166 tos
->all_input_readonly
= true;
4167 check_input_sections (tos
->children
.head
, tos
);
4168 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4169 tos
->constraint
= -1;
4171 if (tos
->constraint
>= 0)
4172 map_input_to_output_sections (tos
->children
.head
,
4176 case lang_output_statement_enum
:
4178 case lang_target_statement_enum
:
4179 target
= s
->target_statement
.target
;
4181 case lang_group_statement_enum
:
4182 map_input_to_output_sections (s
->group_statement
.children
.head
,
4186 case lang_data_statement_enum
:
4187 /* Make sure that any sections mentioned in the expression
4189 exp_init_os (s
->data_statement
.exp
);
4190 /* The output section gets CONTENTS, ALLOC and LOAD, but
4191 these may be overridden by the script. */
4192 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4193 switch (os
->sectype
)
4195 case normal_section
:
4196 case overlay_section
:
4197 case first_overlay_section
:
4199 case noalloc_section
:
4200 flags
= SEC_HAS_CONTENTS
;
4202 case readonly_section
:
4203 flags
|= SEC_READONLY
;
4205 case typed_readonly_section
:
4206 flags
|= SEC_READONLY
;
4209 if (os
->sectype_value
->type
.node_class
== etree_name
4210 && os
->sectype_value
->type
.node_code
== NAME
)
4212 const char *name
= os
->sectype_value
->name
.name
;
4213 if (strcmp (name
, "SHT_PROGBITS") == 0)
4214 type
= SHT_PROGBITS
;
4215 else if (strcmp (name
, "SHT_STRTAB") == 0)
4217 else if (strcmp (name
, "SHT_NOTE") == 0)
4219 else if (strcmp (name
, "SHT_NOBITS") == 0)
4221 else if (strcmp (name
, "SHT_INIT_ARRAY") == 0)
4222 type
= SHT_INIT_ARRAY
;
4223 else if (strcmp (name
, "SHT_FINI_ARRAY") == 0)
4224 type
= SHT_FINI_ARRAY
;
4225 else if (strcmp (name
, "SHT_PREINIT_ARRAY") == 0)
4226 type
= SHT_PREINIT_ARRAY
;
4228 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4233 exp_fold_tree_no_dot (os
->sectype_value
, os
);
4234 if (expld
.result
.valid_p
)
4235 type
= expld
.result
.value
;
4237 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4241 case noload_section
:
4242 if (bfd_get_flavour (link_info
.output_bfd
)
4243 == bfd_target_elf_flavour
)
4244 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4246 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4249 if (os
->bfd_section
== NULL
)
4250 init_os (os
, flags
| SEC_READONLY
);
4252 os
->bfd_section
->flags
|= flags
;
4253 os
->bfd_section
->type
= type
;
4255 case lang_input_section_enum
:
4257 case lang_fill_statement_enum
:
4258 case lang_object_symbols_statement_enum
:
4259 case lang_reloc_statement_enum
:
4260 case lang_padding_statement_enum
:
4261 case lang_input_statement_enum
:
4262 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4265 case lang_assignment_statement_enum
:
4266 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4269 /* Make sure that any sections mentioned in the assignment
4271 exp_init_os (s
->assignment_statement
.exp
);
4273 case lang_address_statement_enum
:
4274 /* Mark the specified section with the supplied address.
4275 If this section was actually a segment marker, then the
4276 directive is ignored if the linker script explicitly
4277 processed the segment marker. Originally, the linker
4278 treated segment directives (like -Ttext on the
4279 command-line) as section directives. We honor the
4280 section directive semantics for backwards compatibility;
4281 linker scripts that do not specifically check for
4282 SEGMENT_START automatically get the old semantics. */
4283 if (!s
->address_statement
.segment
4284 || !s
->address_statement
.segment
->used
)
4286 const char *name
= s
->address_statement
.section_name
;
4288 /* Create the output section statement here so that
4289 orphans with a set address will be placed after other
4290 script sections. If we let the orphan placement code
4291 place them in amongst other sections then the address
4292 will affect following script sections, which is
4293 likely to surprise naive users. */
4294 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4295 tos
->addr_tree
= s
->address_statement
.address
;
4296 if (tos
->bfd_section
== NULL
)
4300 case lang_insert_statement_enum
:
4302 case lang_input_matcher_enum
:
4308 /* An insert statement snips out all the linker statements from the
4309 start of the list and places them after the output section
4310 statement specified by the insert. This operation is complicated
4311 by the fact that we keep a doubly linked list of output section
4312 statements as well as the singly linked list of all statements.
4313 FIXME someday: Twiddling with the list not only moves statements
4314 from the user's script but also input and group statements that are
4315 built from command line object files and --start-group. We only
4316 get away with this because the list pointers used by file_chain
4317 and input_file_chain are not reordered, and processing via
4318 statement_list after this point mostly ignores input statements.
4319 One exception is the map file, where LOAD and START GROUP/END GROUP
4320 can end up looking odd. */
4323 process_insert_statements (lang_statement_union_type
**start
)
4325 lang_statement_union_type
**s
;
4326 lang_output_section_statement_type
*first_os
= NULL
;
4327 lang_output_section_statement_type
*last_os
= NULL
;
4328 lang_output_section_statement_type
*os
;
4333 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4335 /* Keep pointers to the first and last output section
4336 statement in the sequence we may be about to move. */
4337 os
= &(*s
)->output_section_statement
;
4339 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4342 /* Set constraint negative so that lang_output_section_find
4343 won't match this output section statement. At this
4344 stage in linking constraint has values in the range
4345 [-1, ONLY_IN_RW]. */
4346 last_os
->constraint
= -2 - last_os
->constraint
;
4347 if (first_os
== NULL
)
4350 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4352 /* A user might put -T between --start-group and
4353 --end-group. One way this odd construct might arise is
4354 from a wrapper around ld to change library search
4355 behaviour. For example:
4357 exec real_ld --start-group "$@" --end-group
4358 This isn't completely unreasonable so go looking inside a
4359 group statement for insert statements. */
4360 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4362 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4364 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4365 lang_output_section_statement_type
*where
;
4366 lang_statement_union_type
**ptr
;
4367 lang_statement_union_type
*first
;
4369 if (link_info
.non_contiguous_regions
)
4371 einfo (_("warning: INSERT statement in linker script is "
4372 "incompatible with --enable-non-contiguous-regions.\n"));
4375 where
= lang_output_section_find (i
->where
);
4376 if (where
!= NULL
&& i
->is_before
)
4379 where
= where
->prev
;
4380 while (where
!= NULL
&& where
->constraint
< 0);
4384 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4388 /* Deal with reordering the output section statement list. */
4389 if (last_os
!= NULL
)
4391 asection
*first_sec
, *last_sec
;
4392 struct lang_output_section_statement_struct
**next
;
4394 /* Snip out the output sections we are moving. */
4395 first_os
->prev
->next
= last_os
->next
;
4396 if (last_os
->next
== NULL
)
4398 next
= &first_os
->prev
->next
;
4399 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4402 last_os
->next
->prev
= first_os
->prev
;
4403 /* Add them in at the new position. */
4404 last_os
->next
= where
->next
;
4405 if (where
->next
== NULL
)
4407 next
= &last_os
->next
;
4408 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4411 where
->next
->prev
= last_os
;
4412 first_os
->prev
= where
;
4413 where
->next
= first_os
;
4415 /* Move the bfd sections in the same way. */
4418 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4420 os
->constraint
= -2 - os
->constraint
;
4421 if (os
->bfd_section
!= NULL
4422 && os
->bfd_section
->owner
!= NULL
)
4424 last_sec
= os
->bfd_section
;
4425 if (first_sec
== NULL
)
4426 first_sec
= last_sec
;
4431 if (last_sec
!= NULL
)
4433 asection
*sec
= where
->bfd_section
;
4435 sec
= output_prev_sec_find (where
);
4437 /* The place we want to insert must come after the
4438 sections we are moving. So if we find no
4439 section or if the section is the same as our
4440 last section, then no move is needed. */
4441 if (sec
!= NULL
&& sec
!= last_sec
)
4443 /* Trim them off. */
4444 if (first_sec
->prev
!= NULL
)
4445 first_sec
->prev
->next
= last_sec
->next
;
4447 link_info
.output_bfd
->sections
= last_sec
->next
;
4448 if (last_sec
->next
!= NULL
)
4449 last_sec
->next
->prev
= first_sec
->prev
;
4451 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4453 if (sec
->owner
== NULL
)
4454 /* SEC is the absolute section, from the
4455 first dummy output section statement. Add
4456 back the sections we trimmed off to the
4457 start of the bfd sections. */
4460 last_sec
->next
= sec
->next
;
4462 last_sec
->next
= link_info
.output_bfd
->sections
;
4463 if (last_sec
->next
!= NULL
)
4464 last_sec
->next
->prev
= last_sec
;
4466 link_info
.output_bfd
->section_last
= last_sec
;
4467 first_sec
->prev
= sec
;
4468 if (first_sec
->prev
!= NULL
)
4469 first_sec
->prev
->next
= first_sec
;
4471 link_info
.output_bfd
->sections
= first_sec
;
4476 lang_statement_union_type
*after
= (void *) where
;
4477 if (where
== &lang_os_list
.head
->output_section_statement
4478 && where
->next
== first_os
)
4480 /* PR30155. Handle a corner case where the statement
4481 list is something like the following:
4483 . .data 0x0000000000000000 0x0
4484 . [0x0000000000000000] b = .
4486 . .data 0x0000000000000000 0x0 t.o
4487 . 0x0000000000000000 0x4 LONG 0x0
4488 . INSERT BEFORE .text.start
4489 . [0x0000000000000004] a = .
4490 . .text.start 0x0000000000000000 0x0
4491 . [0x0000000000000000] c = .
4492 . OUTPUT(a.out elf64-x86-64)
4493 Here we do not want to allow insert_os_after to
4494 choose a point inside the list we are moving.
4495 That would lose the list. Instead, let
4496 insert_os_after work from the INSERT, which in this
4497 particular example will result in inserting after
4498 the assignment "a = .". */
4501 ptr
= insert_os_after (after
);
4502 /* Snip everything from the start of the list, up to and
4503 including the insert statement we are currently processing. */
4505 *start
= (*s
)->header
.next
;
4506 /* Add them back where they belong, minus the insert. */
4509 statement_list
.tail
= s
;
4516 s
= &(*s
)->header
.next
;
4519 /* Undo constraint twiddling. */
4520 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4522 os
->constraint
= -2 - os
->constraint
;
4528 /* An output section might have been removed after its statement was
4529 added. For example, ldemul_before_allocation can remove dynamic
4530 sections if they turn out to be not needed. Clean them up here. */
4533 strip_excluded_output_sections (void)
4535 lang_output_section_statement_type
*os
;
4537 /* Run lang_size_sections (if not already done). */
4538 if (expld
.phase
!= lang_mark_phase_enum
)
4540 expld
.phase
= lang_mark_phase_enum
;
4541 expld
.dataseg
.phase
= exp_seg_none
;
4542 one_lang_size_sections_pass (NULL
, false);
4543 lang_reset_memory_regions ();
4546 for (os
= (void *) lang_os_list
.head
;
4550 asection
*output_section
;
4553 if (os
->constraint
< 0)
4556 output_section
= os
->bfd_section
;
4557 if (output_section
== NULL
)
4560 exclude
= (output_section
->rawsize
== 0
4561 && (output_section
->flags
& SEC_KEEP
) == 0
4562 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4565 /* Some sections have not yet been sized, notably .gnu.version,
4566 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4567 input sections, so don't drop output sections that have such
4568 input sections unless they are also marked SEC_EXCLUDE. */
4569 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4573 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4574 if ((s
->flags
& SEC_EXCLUDE
) == 0
4575 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4576 || link_info
.emitrelocations
))
4585 /* We don't set bfd_section to NULL since bfd_section of the
4586 removed output section statement may still be used. */
4587 if (!os
->update_dot
)
4589 output_section
->flags
|= SEC_EXCLUDE
;
4590 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4591 link_info
.output_bfd
->section_count
--;
4596 /* Called from ldwrite to clear out asection.map_head and
4597 asection.map_tail for use as link_orders in ldwrite. */
4600 lang_clear_os_map (void)
4602 lang_output_section_statement_type
*os
;
4604 if (map_head_is_link_order
)
4607 for (os
= (void *) lang_os_list
.head
;
4611 asection
*output_section
;
4613 if (os
->constraint
< 0)
4616 output_section
= os
->bfd_section
;
4617 if (output_section
== NULL
)
4620 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4621 output_section
->map_head
.link_order
= NULL
;
4622 output_section
->map_tail
.link_order
= NULL
;
4625 /* Stop future calls to lang_add_section from messing with map_head
4626 and map_tail link_order fields. */
4627 map_head_is_link_order
= true;
4631 print_output_section_statement
4632 (lang_output_section_statement_type
*output_section_statement
)
4634 asection
*section
= output_section_statement
->bfd_section
;
4637 if (output_section_statement
!= abs_output_section
)
4639 minfo ("\n%s", output_section_statement
->name
);
4641 if (section
!= NULL
)
4643 print_dot
= section
->vma
;
4645 len
= strlen (output_section_statement
->name
);
4646 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4651 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4653 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4655 if (section
->vma
!= section
->lma
)
4656 minfo (_(" load address 0x%V"), section
->lma
);
4658 if (output_section_statement
->update_dot_tree
!= NULL
)
4659 exp_fold_tree (output_section_statement
->update_dot_tree
,
4660 output_section_statement
,
4661 bfd_abs_section_ptr
, &print_dot
);
4667 print_statement_list (output_section_statement
->children
.head
,
4668 output_section_statement
);
4672 print_assignment (lang_assignment_statement_type
*assignment
,
4673 lang_output_section_statement_type
*output_section
)
4679 print_spaces (SECTION_NAME_MAP_LENGTH
);
4681 if (assignment
->exp
->type
.node_class
== etree_assert
)
4684 tree
= assignment
->exp
->assert_s
.child
;
4688 const char *dst
= assignment
->exp
->assign
.dst
;
4690 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4691 tree
= assignment
->exp
;
4694 osec
= output_section
->bfd_section
;
4696 osec
= bfd_abs_section_ptr
;
4698 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4699 exp_fold_tree (tree
, output_section
, osec
, &print_dot
);
4701 expld
.result
.valid_p
= false;
4704 const char *str
= buf
;
4705 if (expld
.result
.valid_p
)
4709 if (assignment
->exp
->type
.node_class
== etree_assert
4711 || expld
.assign_name
!= NULL
)
4713 value
= expld
.result
.value
;
4715 if (expld
.result
.section
!= NULL
)
4716 value
+= expld
.result
.section
->vma
;
4720 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 2, value
);
4726 struct bfd_link_hash_entry
*h
;
4728 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4729 false, false, true);
4731 && (h
->type
== bfd_link_hash_defined
4732 || h
->type
== bfd_link_hash_defweak
))
4734 value
= h
->u
.def
.value
;
4735 value
+= h
->u
.def
.section
->output_section
->vma
;
4736 value
+= h
->u
.def
.section
->output_offset
;
4741 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 3, value
);
4745 str
= "[unresolved]";
4750 if (assignment
->exp
->type
.node_class
== etree_provide
)
4755 expld
.assign_name
= NULL
;
4757 fprintf (config
.map_file
, "%-34s", str
);
4758 exp_print_tree (assignment
->exp
);
4763 print_input_statement (lang_input_statement_type
*statm
)
4765 if (statm
->filename
!= NULL
)
4766 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4769 /* Print all symbols defined in a particular section. This is called
4770 via bfd_link_hash_traverse, or by print_all_symbols. */
4773 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4775 asection
*sec
= (asection
*) ptr
;
4777 if ((hash_entry
->type
== bfd_link_hash_defined
4778 || hash_entry
->type
== bfd_link_hash_defweak
)
4779 && sec
== hash_entry
->u
.def
.section
)
4781 print_spaces (SECTION_NAME_MAP_LENGTH
);
4783 (hash_entry
->u
.def
.value
4784 + hash_entry
->u
.def
.section
->output_offset
4785 + hash_entry
->u
.def
.section
->output_section
->vma
));
4787 minfo (" %pT\n", hash_entry
->root
.string
);
4794 hash_entry_addr_cmp (const void *a
, const void *b
)
4796 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4797 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4799 if (l
->u
.def
.value
< r
->u
.def
.value
)
4801 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4808 print_all_symbols (asection
*sec
)
4810 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4811 struct map_symbol_def
*def
;
4812 struct bfd_link_hash_entry
**entries
;
4818 *ud
->map_symbol_def_tail
= 0;
4820 /* Sort the symbols by address. */
4821 entries
= (struct bfd_link_hash_entry
**)
4822 obstack_alloc (&map_obstack
,
4823 ud
->map_symbol_def_count
* sizeof (*entries
));
4825 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4826 entries
[i
] = def
->entry
;
4828 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4829 hash_entry_addr_cmp
);
4831 /* Print the symbols. */
4832 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4833 ldemul_print_symbol (entries
[i
], sec
);
4835 obstack_free (&map_obstack
, entries
);
4838 /* Returns TRUE if SYM is a symbol suitable for printing
4839 in a linker map as a local symbol. */
4842 ld_is_local_symbol (asymbol
* sym
)
4844 const char * name
= bfd_asymbol_name (sym
);
4846 if (name
== NULL
|| *name
== 0)
4849 if (strcmp (name
, "(null)") == 0)
4852 /* Skip .Lxxx and such like. */
4853 if (bfd_is_local_label (link_info
.output_bfd
, sym
))
4856 /* FIXME: This is intended to skip ARM mapping symbols,
4857 which for some reason are not excluded by bfd_is_local_label,
4858 but maybe it is wrong for other architectures.
4859 It would be better to fix bfd_is_local_label. */
4863 /* Some local symbols, eg _GLOBAL_OFFSET_TABLE_, are present
4864 in the hash table, so do not print duplicates here. */
4865 struct bfd_link_hash_entry
* h
;
4866 h
= bfd_link_hash_lookup (link_info
.hash
, name
, false /* create */,
4867 false /* copy */, true /* follow */);
4871 /* Symbols from the plugin owned BFD will not get their own
4872 iteration of this function, but can be on the link_info
4873 list. So include them here. */
4874 if (h
->u
.def
.section
->owner
!= NULL
4875 && ((bfd_get_file_flags (h
->u
.def
.section
->owner
) & (BFD_LINKER_CREATED
| BFD_PLUGIN
))
4876 == (BFD_LINKER_CREATED
| BFD_PLUGIN
)))
4882 /* Print information about an input section to the map file. */
4885 print_input_section (asection
*i
, bool is_discarded
)
4887 bfd_size_type size
= i
->size
;
4893 minfo (" %s", i
->name
);
4895 len
= 1 + strlen (i
->name
);
4896 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4901 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4903 if (i
->output_section
!= NULL
4904 && i
->output_section
->owner
== link_info
.output_bfd
)
4905 addr
= i
->output_section
->vma
+ i
->output_offset
;
4914 bfd_sprintf_vma (link_info
.output_bfd
, buf
, addr
);
4915 minfo ("0x%s %W %pB\n", buf
, TO_ADDR (size
), i
->owner
);
4917 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4919 len
= SECTION_NAME_MAP_LENGTH
+ 3 + strlen (buf
);
4921 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4924 if (i
->output_section
!= NULL
4925 && i
->output_section
->owner
== link_info
.output_bfd
)
4927 if (link_info
.reduce_memory_overheads
)
4928 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4930 print_all_symbols (i
);
4932 /* Update print_dot, but make sure that we do not move it
4933 backwards - this could happen if we have overlays and a
4934 later overlay is shorter than an earier one. */
4935 if (addr
+ TO_ADDR (size
) > print_dot
)
4936 print_dot
= addr
+ TO_ADDR (size
);
4938 if (config
.print_map_locals
)
4940 long storage_needed
;
4942 /* FIXME: It would be better to cache this table, rather
4943 than recreating it for each output section. */
4944 /* FIXME: This call is not working for non-ELF based targets.
4946 storage_needed
= bfd_get_symtab_upper_bound (link_info
.output_bfd
);
4947 if (storage_needed
> 0)
4949 asymbol
** symbol_table
;
4950 long number_of_symbols
;
4953 symbol_table
= xmalloc (storage_needed
);
4954 number_of_symbols
= bfd_canonicalize_symtab (link_info
.output_bfd
, symbol_table
);
4956 for (j
= 0; j
< number_of_symbols
; j
++)
4958 asymbol
* sym
= symbol_table
[j
];
4959 bfd_vma sym_addr
= sym
->value
+ i
->output_section
->vma
;
4961 if (sym
->section
== i
->output_section
4962 && (sym
->flags
& BSF_LOCAL
) != 0
4964 && sym_addr
< print_dot
4965 && ld_is_local_symbol (sym
))
4967 print_spaces (SECTION_NAME_MAP_LENGTH
);
4968 minfo ("0x%V (local) %s\n", sym_addr
, bfd_asymbol_name (sym
));
4972 free (symbol_table
);
4979 print_fill_statement (lang_fill_statement_type
*fill
)
4983 fputs (" FILL mask 0x", config
.map_file
);
4984 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4985 fprintf (config
.map_file
, "%02x", *p
);
4986 fputs ("\n", config
.map_file
);
4990 print_data_statement (lang_data_statement_type
*data
)
4996 init_opb (data
->output_section
);
4997 print_spaces (SECTION_NAME_MAP_LENGTH
);
4999 addr
= data
->output_offset
;
5000 if (data
->output_section
!= NULL
)
5001 addr
+= data
->output_section
->vma
;
5029 if (size
< TO_SIZE ((unsigned) 1))
5030 size
= TO_SIZE ((unsigned) 1);
5031 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
5033 if (data
->exp
->type
.node_class
!= etree_value
)
5036 exp_print_tree (data
->exp
);
5041 print_dot
= addr
+ TO_ADDR (size
);
5044 /* Print an address statement. These are generated by options like
5048 print_address_statement (lang_address_statement_type
*address
)
5050 minfo (_("Address of section %s set to "), address
->section_name
);
5051 exp_print_tree (address
->address
);
5055 /* Print a reloc statement. */
5058 print_reloc_statement (lang_reloc_statement_type
*reloc
)
5063 init_opb (reloc
->output_section
);
5064 print_spaces (SECTION_NAME_MAP_LENGTH
);
5066 addr
= reloc
->output_offset
;
5067 if (reloc
->output_section
!= NULL
)
5068 addr
+= reloc
->output_section
->vma
;
5070 size
= bfd_get_reloc_size (reloc
->howto
);
5072 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
5074 if (reloc
->name
!= NULL
)
5075 minfo ("%s+", reloc
->name
);
5077 minfo ("%s+", reloc
->section
->name
);
5079 exp_print_tree (reloc
->addend_exp
);
5083 print_dot
= addr
+ TO_ADDR (size
);
5087 print_padding_statement (lang_padding_statement_type
*s
)
5092 init_opb (s
->output_section
);
5095 len
= sizeof " *fill*" - 1;
5096 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
5098 addr
= s
->output_offset
;
5099 if (s
->output_section
!= NULL
)
5100 addr
+= s
->output_section
->vma
;
5101 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5103 if (s
->fill
->size
!= 0)
5107 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5108 fprintf (config
.map_file
, "%02x", *p
);
5113 print_dot
= addr
+ TO_ADDR (s
->size
);
5117 print_wild_statement (lang_wild_statement_type
*w
,
5118 lang_output_section_statement_type
*os
)
5120 struct wildcard_list
*sec
;
5124 if (w
->exclude_name_list
)
5127 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5128 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5129 minfo (" %s", tmp
->name
);
5133 if (w
->filenames_sorted
)
5134 minfo ("SORT_BY_NAME(");
5135 if (w
->filename
!= NULL
)
5136 minfo ("%s", w
->filename
);
5139 if (w
->filenames_sorted
)
5143 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5145 int closing_paren
= 0;
5147 switch (sec
->spec
.sorted
)
5153 minfo ("SORT_BY_NAME(");
5158 minfo ("SORT_BY_ALIGNMENT(");
5162 case by_name_alignment
:
5163 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5167 case by_alignment_name
:
5168 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5173 minfo ("SORT_NONE(");
5177 case by_init_priority
:
5178 minfo ("SORT_BY_INIT_PRIORITY(");
5183 if (sec
->spec
.exclude_name_list
!= NULL
)
5186 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5187 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5188 minfo (" %s", tmp
->name
);
5191 if (sec
->spec
.name
!= NULL
)
5192 minfo ("%s", sec
->spec
.name
);
5195 for (;closing_paren
> 0; closing_paren
--)
5204 print_statement_list (w
->children
.head
, os
);
5207 /* Print a group statement. */
5210 print_group (lang_group_statement_type
*s
,
5211 lang_output_section_statement_type
*os
)
5213 fprintf (config
.map_file
, "START GROUP\n");
5214 print_statement_list (s
->children
.head
, os
);
5215 fprintf (config
.map_file
, "END GROUP\n");
5218 /* Print the list of statements in S.
5219 This can be called for any statement type. */
5222 print_statement_list (lang_statement_union_type
*s
,
5223 lang_output_section_statement_type
*os
)
5227 print_statement (s
, os
);
5232 /* Print the first statement in statement list S.
5233 This can be called for any statement type. */
5236 print_statement (lang_statement_union_type
*s
,
5237 lang_output_section_statement_type
*os
)
5239 switch (s
->header
.type
)
5242 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5245 case lang_constructors_statement_enum
:
5246 if (constructor_list
.head
!= NULL
)
5248 if (constructors_sorted
)
5249 minfo (" SORT (CONSTRUCTORS)\n");
5251 minfo (" CONSTRUCTORS\n");
5252 print_statement_list (constructor_list
.head
, os
);
5255 case lang_wild_statement_enum
:
5256 print_wild_statement (&s
->wild_statement
, os
);
5258 case lang_address_statement_enum
:
5259 print_address_statement (&s
->address_statement
);
5261 case lang_object_symbols_statement_enum
:
5262 minfo (" CREATE_OBJECT_SYMBOLS\n");
5264 case lang_fill_statement_enum
:
5265 print_fill_statement (&s
->fill_statement
);
5267 case lang_data_statement_enum
:
5268 print_data_statement (&s
->data_statement
);
5270 case lang_reloc_statement_enum
:
5271 print_reloc_statement (&s
->reloc_statement
);
5273 case lang_input_section_enum
:
5274 print_input_section (s
->input_section
.section
, false);
5276 case lang_padding_statement_enum
:
5277 print_padding_statement (&s
->padding_statement
);
5279 case lang_output_section_statement_enum
:
5280 print_output_section_statement (&s
->output_section_statement
);
5282 case lang_assignment_statement_enum
:
5283 print_assignment (&s
->assignment_statement
, os
);
5285 case lang_target_statement_enum
:
5286 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5288 case lang_output_statement_enum
:
5289 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5290 if (output_target
!= NULL
)
5291 minfo (" %s", output_target
);
5294 case lang_input_statement_enum
:
5295 print_input_statement (&s
->input_statement
);
5297 case lang_group_statement_enum
:
5298 print_group (&s
->group_statement
, os
);
5300 case lang_insert_statement_enum
:
5301 minfo ("INSERT %s %s\n",
5302 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5303 s
->insert_statement
.where
);
5309 print_statements (void)
5311 print_statement_list (statement_list
.head
, abs_output_section
);
5314 /* Print the first N statements in statement list S to STDERR.
5315 If N == 0, nothing is printed.
5316 If N < 0, the entire list is printed.
5317 Intended to be called from GDB. */
5320 dprint_statement (lang_statement_union_type
*s
, int n
)
5322 FILE *map_save
= config
.map_file
;
5324 config
.map_file
= stderr
;
5327 print_statement_list (s
, abs_output_section
);
5330 while (s
&& --n
>= 0)
5332 print_statement (s
, abs_output_section
);
5337 config
.map_file
= map_save
;
5341 insert_pad (lang_statement_union_type
**ptr
,
5343 bfd_size_type alignment_needed
,
5344 asection
*output_section
,
5347 static fill_type zero_fill
;
5348 lang_statement_union_type
*pad
= NULL
;
5350 if (ptr
!= &statement_list
.head
)
5351 pad
= ((lang_statement_union_type
*)
5352 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5354 && pad
->header
.type
== lang_padding_statement_enum
5355 && pad
->padding_statement
.output_section
== output_section
)
5357 /* Use the existing pad statement. */
5359 else if ((pad
= *ptr
) != NULL
5360 && pad
->header
.type
== lang_padding_statement_enum
5361 && pad
->padding_statement
.output_section
== output_section
)
5363 /* Use the existing pad statement. */
5367 /* Make a new padding statement, linked into existing chain. */
5368 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5369 pad
->header
.next
= *ptr
;
5371 pad
->header
.type
= lang_padding_statement_enum
;
5372 pad
->padding_statement
.output_section
= output_section
;
5375 pad
->padding_statement
.fill
= fill
;
5377 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5378 pad
->padding_statement
.size
= alignment_needed
;
5379 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5380 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5381 - output_section
->vma
);
5384 /* Work out how much this section will move the dot point. */
5388 (lang_statement_union_type
**this_ptr
,
5389 lang_output_section_statement_type
*output_section_statement
,
5394 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5395 asection
*i
= is
->section
;
5396 asection
*o
= output_section_statement
->bfd_section
;
5399 if (link_info
.non_contiguous_regions
)
5401 /* If the input section I has already been successfully assigned
5402 to an output section other than O, don't bother with it and
5403 let the caller remove it from the list. Keep processing in
5404 case we have already handled O, because the repeated passes
5405 have reinitialized its size. */
5406 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5413 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5414 i
->output_offset
= i
->vma
- o
->vma
;
5415 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5416 || output_section_statement
->ignored
)
5417 i
->output_offset
= dot
- o
->vma
;
5420 bfd_size_type alignment_needed
;
5422 /* Align this section first to the input sections requirement,
5423 then to the output section's requirement. If this alignment
5424 is greater than any seen before, then record it too. Perform
5425 the alignment by inserting a magic 'padding' statement. */
5427 if (output_section_statement
->subsection_alignment
!= NULL
)
5429 = exp_get_power (output_section_statement
->subsection_alignment
,
5430 output_section_statement
,
5431 "subsection alignment");
5433 if (o
->alignment_power
< i
->alignment_power
)
5434 o
->alignment_power
= i
->alignment_power
;
5436 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5438 if (alignment_needed
!= 0)
5440 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5441 dot
+= alignment_needed
;
5444 if (link_info
.non_contiguous_regions
)
5446 /* If I would overflow O, let the caller remove I from the
5448 if (output_section_statement
->region
)
5450 bfd_vma end
= output_section_statement
->region
->origin
5451 + output_section_statement
->region
->length
;
5453 if (dot
+ TO_ADDR (i
->size
) > end
)
5455 if (i
->flags
& SEC_LINKER_CREATED
)
5456 einfo (_("%F%P: Output section `%pA' not large enough for "
5457 "the linker-created stubs section `%pA'.\n"),
5458 i
->output_section
, i
);
5460 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5461 einfo (_("%F%P: Relaxation not supported with "
5462 "--enable-non-contiguous-regions (section `%pA' "
5463 "would overflow `%pA' after it changed size).\n"),
5464 i
, i
->output_section
);
5468 i
->output_section
= NULL
;
5474 /* Remember where in the output section this input section goes. */
5475 i
->output_offset
= dot
- o
->vma
;
5477 /* Mark how big the output section must be to contain this now. */
5478 dot
+= TO_ADDR (i
->size
);
5479 if (!(o
->flags
& SEC_FIXED_SIZE
))
5480 o
->size
= TO_SIZE (dot
- o
->vma
);
5482 if (link_info
.non_contiguous_regions
)
5484 /* Record that I was successfully assigned to O, and update
5485 its actual output section too. */
5486 i
->already_assigned
= o
;
5487 i
->output_section
= o
;
5501 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5503 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5504 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5506 if (sec1
->lma
< sec2
->lma
)
5508 else if (sec1
->lma
> sec2
->lma
)
5510 else if (sec1
->id
< sec2
->id
)
5512 else if (sec1
->id
> sec2
->id
)
5519 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5521 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5522 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5524 if (sec1
->vma
< sec2
->vma
)
5526 else if (sec1
->vma
> sec2
->vma
)
5528 else if (sec1
->id
< sec2
->id
)
5530 else if (sec1
->id
> sec2
->id
)
5536 #define IS_TBSS(s) \
5537 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5539 #define IGNORE_SECTION(s) \
5540 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5542 /* Check to see if any allocated sections overlap with other allocated
5543 sections. This can happen if a linker script specifies the output
5544 section addresses of the two sections. Also check whether any memory
5545 region has overflowed. */
5548 lang_check_section_addresses (void)
5551 struct check_sec
*sections
;
5556 bfd_vma p_start
= 0;
5558 lang_memory_region_type
*m
;
5561 /* Detect address space overflow on allocated sections. */
5562 addr_mask
= ((bfd_vma
) 1 <<
5563 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5564 addr_mask
= (addr_mask
<< 1) + 1;
5565 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5566 if ((s
->flags
& SEC_ALLOC
) != 0)
5568 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5569 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5570 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5574 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5575 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5576 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5581 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5584 count
= bfd_count_sections (link_info
.output_bfd
);
5585 sections
= XNEWVEC (struct check_sec
, count
);
5587 /* Scan all sections in the output list. */
5589 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5591 if (IGNORE_SECTION (s
)
5595 sections
[count
].sec
= s
;
5596 sections
[count
].warned
= false;
5606 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5608 /* First check section LMAs. There should be no overlap of LMAs on
5609 loadable sections, even with overlays. */
5610 for (p
= NULL
, i
= 0; i
< count
; i
++)
5612 s
= sections
[i
].sec
;
5614 if ((s
->flags
& SEC_LOAD
) != 0)
5617 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5619 /* Look for an overlap. We have sorted sections by lma, so
5620 we know that s_start >= p_start. Besides the obvious
5621 case of overlap when the current section starts before
5622 the previous one ends, we also must have overlap if the
5623 previous section wraps around the address space. */
5625 && (s_start
<= p_end
5626 || p_end
< p_start
))
5628 einfo (_("%X%P: section %s LMA [%V,%V]"
5629 " overlaps section %s LMA [%V,%V]\n"),
5630 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5631 sections
[i
].warned
= true;
5639 /* If any non-zero size allocated section (excluding tbss) starts at
5640 exactly the same VMA as another such section, then we have
5641 overlays. Overlays generated by the OVERLAY keyword will have
5642 this property. It is possible to intentionally generate overlays
5643 that fail this test, but it would be unusual. */
5644 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5646 p_start
= sections
[0].sec
->vma
;
5647 for (i
= 1; i
< count
; i
++)
5649 s_start
= sections
[i
].sec
->vma
;
5650 if (p_start
== s_start
)
5658 /* Now check section VMAs if no overlays were detected. */
5661 for (p
= NULL
, i
= 0; i
< count
; i
++)
5663 s
= sections
[i
].sec
;
5666 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5669 && !sections
[i
].warned
5670 && (s_start
<= p_end
5671 || p_end
< p_start
))
5672 einfo (_("%X%P: section %s VMA [%V,%V]"
5673 " overlaps section %s VMA [%V,%V]\n"),
5674 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5683 /* If any memory region has overflowed, report by how much.
5684 We do not issue this diagnostic for regions that had sections
5685 explicitly placed outside their bounds; os_region_check's
5686 diagnostics are adequate for that case.
5688 FIXME: It is conceivable that m->current - (m->origin + m->length)
5689 might overflow a 32-bit integer. There is, alas, no way to print
5690 a bfd_vma quantity in decimal. */
5691 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5692 if (m
->had_full_message
)
5694 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5695 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5696 "%X%P: region `%s' overflowed by %lu bytes\n",
5698 m
->name_list
.name
, over
);
5702 /* Make sure the new address is within the region. We explicitly permit the
5703 current address to be at the exact end of the region when the address is
5704 non-zero, in case the region is at the end of addressable memory and the
5705 calculation wraps around. */
5708 os_region_check (lang_output_section_statement_type
*os
,
5709 lang_memory_region_type
*region
,
5713 if ((region
->current
< region
->origin
5714 || (region
->current
- region
->origin
> region
->length
))
5715 && ((region
->current
!= region
->origin
+ region
->length
)
5720 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5721 " is not within region `%s'\n"),
5723 os
->bfd_section
->owner
,
5724 os
->bfd_section
->name
,
5725 region
->name_list
.name
);
5727 else if (!region
->had_full_message
)
5729 region
->had_full_message
= true;
5731 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5732 os
->bfd_section
->owner
,
5733 os
->bfd_section
->name
,
5734 region
->name_list
.name
);
5740 ldlang_check_relro_region (lang_statement_union_type
*s
)
5742 seg_align_type
*seg
= &expld
.dataseg
;
5744 if (seg
->relro
== exp_seg_relro_start
)
5746 if (!seg
->relro_start_stat
)
5747 seg
->relro_start_stat
= s
;
5750 ASSERT (seg
->relro_start_stat
== s
);
5753 else if (seg
->relro
== exp_seg_relro_end
)
5755 if (!seg
->relro_end_stat
)
5756 seg
->relro_end_stat
= s
;
5759 ASSERT (seg
->relro_end_stat
== s
);
5764 /* Set the sizes for all the output sections. */
5767 lang_size_sections_1
5768 (lang_statement_union_type
**prev
,
5769 lang_output_section_statement_type
*current_os
,
5775 lang_statement_union_type
*s
;
5776 lang_statement_union_type
*prev_s
= NULL
;
5777 bool removed_prev_s
= false;
5778 lang_output_section_statement_type
*os
= current_os
;
5780 /* Size up the sections from their constituent parts. */
5781 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5783 bool removed
= false;
5785 switch (s
->header
.type
)
5787 case lang_output_section_statement_enum
:
5789 bfd_vma newdot
, after
, dotdelta
;
5790 lang_memory_region_type
*r
;
5791 int section_alignment
= 0;
5793 os
= &s
->output_section_statement
;
5794 init_opb (os
->bfd_section
);
5795 if (os
->constraint
== -1)
5798 /* FIXME: We shouldn't need to zero section vmas for ld -r
5799 here, in lang_insert_orphan, or in the default linker scripts.
5800 This is covering for coff backend linker bugs. See PR6945. */
5801 if (os
->addr_tree
== NULL
5802 && bfd_link_relocatable (&link_info
)
5803 && (bfd_get_flavour (link_info
.output_bfd
)
5804 == bfd_target_coff_flavour
))
5805 os
->addr_tree
= exp_intop (0);
5806 if (os
->addr_tree
!= NULL
)
5808 exp_fold_tree (os
->addr_tree
, os
, bfd_abs_section_ptr
, &dot
);
5810 if (expld
.result
.valid_p
)
5812 dot
= expld
.result
.value
;
5813 if (expld
.result
.section
!= NULL
)
5814 dot
+= expld
.result
.section
->vma
;
5816 else if (expld
.phase
!= lang_mark_phase_enum
)
5817 einfo (_("%F%P:%pS: non constant or forward reference"
5818 " address expression for section %s\n"),
5819 os
->addr_tree
, os
->name
);
5822 if (os
->bfd_section
== NULL
)
5823 /* This section was removed or never actually created. */
5826 /* If this is a COFF shared library section, use the size and
5827 address from the input section. FIXME: This is COFF
5828 specific; it would be cleaner if there were some other way
5829 to do this, but nothing simple comes to mind. */
5830 if (((bfd_get_flavour (link_info
.output_bfd
)
5831 == bfd_target_ecoff_flavour
)
5832 || (bfd_get_flavour (link_info
.output_bfd
)
5833 == bfd_target_coff_flavour
))
5834 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5838 if (os
->children
.head
== NULL
5839 || os
->children
.head
->header
.next
!= NULL
5840 || (os
->children
.head
->header
.type
5841 != lang_input_section_enum
))
5842 einfo (_("%X%P: internal error on COFF shared library"
5843 " section %s\n"), os
->name
);
5845 input
= os
->children
.head
->input_section
.section
;
5846 bfd_set_section_vma (os
->bfd_section
,
5847 bfd_section_vma (input
));
5848 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5849 os
->bfd_section
->size
= input
->size
;
5855 if (bfd_is_abs_section (os
->bfd_section
))
5857 /* No matter what happens, an abs section starts at zero. */
5858 ASSERT (os
->bfd_section
->vma
== 0);
5862 if (os
->addr_tree
== NULL
)
5864 /* No address specified for this section, get one
5865 from the region specification. */
5866 if (os
->region
== NULL
5867 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5868 && os
->region
->name_list
.name
[0] == '*'
5869 && strcmp (os
->region
->name_list
.name
,
5870 DEFAULT_MEMORY_REGION
) == 0))
5872 os
->region
= lang_memory_default (os
->bfd_section
);
5875 /* If a loadable section is using the default memory
5876 region, and some non default memory regions were
5877 defined, issue an error message. */
5879 && !IGNORE_SECTION (os
->bfd_section
)
5880 && !bfd_link_relocatable (&link_info
)
5882 && strcmp (os
->region
->name_list
.name
,
5883 DEFAULT_MEMORY_REGION
) == 0
5884 && lang_memory_region_list
!= NULL
5885 && (strcmp (lang_memory_region_list
->name_list
.name
,
5886 DEFAULT_MEMORY_REGION
) != 0
5887 || lang_memory_region_list
->next
!= NULL
)
5888 && lang_sizing_iteration
== 1)
5890 /* By default this is an error rather than just a
5891 warning because if we allocate the section to the
5892 default memory region we can end up creating an
5893 excessively large binary, or even seg faulting when
5894 attempting to perform a negative seek. See
5895 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5896 for an example of this. This behaviour can be
5897 overridden by the using the --no-check-sections
5899 if (command_line
.check_section_addresses
)
5900 einfo (_("%F%P: error: no memory region specified"
5901 " for loadable section `%s'\n"),
5902 bfd_section_name (os
->bfd_section
));
5904 einfo (_("%P: warning: no memory region specified"
5905 " for loadable section `%s'\n"),
5906 bfd_section_name (os
->bfd_section
));
5909 newdot
= os
->region
->current
;
5910 section_alignment
= os
->bfd_section
->alignment_power
;
5913 section_alignment
= exp_get_power (os
->section_alignment
, os
,
5914 "section alignment");
5916 /* Align to what the section needs. */
5917 if (section_alignment
> 0)
5919 bfd_vma savedot
= newdot
;
5922 newdot
= align_power (newdot
, section_alignment
);
5923 dotdelta
= newdot
- savedot
;
5925 if (lang_sizing_iteration
== 1)
5927 else if (lang_sizing_iteration
> 1)
5929 /* Only report adjustments that would change
5930 alignment from what we have already reported. */
5931 diff
= newdot
- os
->bfd_section
->vma
;
5932 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5936 && (config
.warn_section_align
5937 || os
->addr_tree
!= NULL
))
5938 einfo (_("%P: warning: "
5939 "start of section %s changed by %ld\n"),
5940 os
->name
, (long) diff
);
5943 bfd_set_section_vma (os
->bfd_section
, newdot
);
5945 os
->bfd_section
->output_offset
= 0;
5948 lang_size_sections_1 (&os
->children
.head
, os
,
5949 os
->fill
, newdot
, relax
, check_regions
);
5951 os
->processed_vma
= true;
5953 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5954 /* Except for some special linker created sections,
5955 no output section should change from zero size
5956 after strip_excluded_output_sections. A non-zero
5957 size on an ignored section indicates that some
5958 input section was not sized early enough. */
5959 ASSERT (os
->bfd_section
->size
== 0);
5962 dot
= os
->bfd_section
->vma
;
5964 /* Put the section within the requested block size, or
5965 align at the block boundary. */
5967 + TO_ADDR (os
->bfd_section
->size
)
5968 + os
->block_value
- 1)
5969 & - (bfd_vma
) os
->block_value
);
5971 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5972 os
->bfd_section
->size
= TO_SIZE (after
5973 - os
->bfd_section
->vma
);
5976 /* Set section lma. */
5979 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
5983 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5984 os
->bfd_section
->lma
= lma
;
5986 else if (os
->lma_region
!= NULL
)
5988 bfd_vma lma
= os
->lma_region
->current
;
5990 if (os
->align_lma_with_input
)
5994 /* When LMA_REGION is the same as REGION, align the LMA
5995 as we did for the VMA, possibly including alignment
5996 from the bfd section. If a different region, then
5997 only align according to the value in the output
5999 if (os
->lma_region
!= os
->region
)
6000 section_alignment
= exp_get_power (os
->section_alignment
,
6002 "section alignment");
6003 if (section_alignment
> 0)
6004 lma
= align_power (lma
, section_alignment
);
6006 os
->bfd_section
->lma
= lma
;
6008 else if (r
->last_os
!= NULL
6009 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6014 last
= r
->last_os
->output_section_statement
.bfd_section
;
6016 /* A backwards move of dot should be accompanied by
6017 an explicit assignment to the section LMA (ie.
6018 os->load_base set) because backwards moves can
6019 create overlapping LMAs. */
6021 && os
->bfd_section
->size
!= 0
6022 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
6024 /* If dot moved backwards then leave lma equal to
6025 vma. This is the old default lma, which might
6026 just happen to work when the backwards move is
6027 sufficiently large. Nag if this changes anything,
6028 so people can fix their linker scripts. */
6030 if (last
->vma
!= last
->lma
)
6031 einfo (_("%P: warning: dot moved backwards "
6032 "before `%s'\n"), os
->name
);
6036 /* If this is an overlay, set the current lma to that
6037 at the end of the previous section. */
6038 if (os
->sectype
== overlay_section
)
6039 lma
= last
->lma
+ TO_ADDR (last
->size
);
6041 /* Otherwise, keep the same lma to vma relationship
6042 as the previous section. */
6044 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
6046 if (section_alignment
> 0)
6047 lma
= align_power (lma
, section_alignment
);
6048 os
->bfd_section
->lma
= lma
;
6051 os
->processed_lma
= true;
6053 /* Keep track of normal sections using the default
6054 lma region. We use this to set the lma for
6055 following sections. Overlays or other linker
6056 script assignment to lma might mean that the
6057 default lma == vma is incorrect.
6058 To avoid warnings about dot moving backwards when using
6059 -Ttext, don't start tracking sections until we find one
6060 of non-zero size or with lma set differently to vma.
6061 Do this tracking before we short-cut the loop so that we
6062 track changes for the case where the section size is zero,
6063 but the lma is set differently to the vma. This is
6064 important, if an orphan section is placed after an
6065 otherwise empty output section that has an explicit lma
6066 set, we want that lma reflected in the orphans lma. */
6067 if (((!IGNORE_SECTION (os
->bfd_section
)
6068 && (os
->bfd_section
->size
!= 0
6069 || (r
->last_os
== NULL
6070 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
6071 || (r
->last_os
!= NULL
6072 && dot
>= (r
->last_os
->output_section_statement
6073 .bfd_section
->vma
))))
6074 || os
->sectype
== first_overlay_section
)
6075 && os
->lma_region
== NULL
6076 && !bfd_link_relocatable (&link_info
))
6079 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
6082 /* .tbss sections effectively have zero size. */
6083 if (!IS_TBSS (os
->bfd_section
)
6084 || bfd_link_relocatable (&link_info
))
6085 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
6090 if (os
->update_dot_tree
!= 0)
6091 exp_fold_tree (os
->update_dot_tree
, os
, bfd_abs_section_ptr
, &dot
);
6093 /* Update dot in the region ?
6094 We only do this if the section is going to be allocated,
6095 since unallocated sections do not contribute to the region's
6096 overall size in memory. */
6097 if (os
->region
!= NULL
6098 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
6100 os
->region
->current
= dot
;
6103 /* Make sure the new address is within the region. */
6104 os_region_check (os
, os
->region
, os
->addr_tree
,
6105 os
->bfd_section
->vma
);
6107 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6108 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6109 || os
->align_lma_with_input
))
6111 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6114 os_region_check (os
, os
->lma_region
, NULL
,
6115 os
->bfd_section
->lma
);
6121 case lang_constructors_statement_enum
:
6122 dot
= lang_size_sections_1 (&constructor_list
.head
, current_os
,
6123 fill
, dot
, relax
, check_regions
);
6126 case lang_data_statement_enum
:
6128 unsigned int size
= 0;
6130 s
->data_statement
.output_offset
= dot
- current_os
->bfd_section
->vma
;
6131 s
->data_statement
.output_section
= current_os
->bfd_section
;
6133 /* We might refer to provided symbols in the expression, and
6134 need to mark them as needed. */
6135 exp_fold_tree (s
->data_statement
.exp
, os
,
6136 bfd_abs_section_ptr
, &dot
);
6138 switch (s
->data_statement
.type
)
6156 if (size
< TO_SIZE ((unsigned) 1))
6157 size
= TO_SIZE ((unsigned) 1);
6158 dot
+= TO_ADDR (size
);
6159 if (!(current_os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
6160 current_os
->bfd_section
->size
6161 = TO_SIZE (dot
- current_os
->bfd_section
->vma
);
6166 case lang_reloc_statement_enum
:
6170 s
->reloc_statement
.output_offset
6171 = dot
- current_os
->bfd_section
->vma
;
6172 s
->reloc_statement
.output_section
6173 = current_os
->bfd_section
;
6174 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6175 dot
+= TO_ADDR (size
);
6176 if (!(current_os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
6177 current_os
->bfd_section
->size
6178 = TO_SIZE (dot
- current_os
->bfd_section
->vma
);
6182 case lang_wild_statement_enum
:
6183 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6184 current_os
, fill
, dot
, relax
,
6188 case lang_object_symbols_statement_enum
:
6189 link_info
.create_object_symbols_section
= current_os
->bfd_section
;
6190 current_os
->bfd_section
->flags
|= SEC_KEEP
;
6193 case lang_output_statement_enum
:
6194 case lang_target_statement_enum
:
6197 case lang_input_section_enum
:
6201 i
= s
->input_section
.section
;
6206 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6207 einfo (_("%F%P: can't relax section: %E\n"));
6211 dot
= size_input_section (prev
, current_os
, fill
, &removed
, dot
);
6215 case lang_input_statement_enum
:
6218 case lang_fill_statement_enum
:
6219 s
->fill_statement
.output_section
= current_os
->bfd_section
;
6221 fill
= s
->fill_statement
.fill
;
6224 case lang_assignment_statement_enum
:
6226 bfd_vma newdot
= dot
;
6227 etree_type
*tree
= s
->assignment_statement
.exp
;
6229 expld
.dataseg
.relro
= exp_seg_relro_none
;
6231 exp_fold_tree (tree
, os
, current_os
->bfd_section
, &newdot
);
6233 ldlang_check_relro_region (s
);
6235 expld
.dataseg
.relro
= exp_seg_relro_none
;
6237 /* This symbol may be relative to this section. */
6238 if ((tree
->type
.node_class
== etree_provided
6239 || tree
->type
.node_class
== etree_assign
)
6240 && (tree
->assign
.dst
[0] != '.'
6241 || tree
->assign
.dst
[1] != '\0'))
6242 current_os
->update_dot
= 1;
6244 if (!current_os
->ignored
)
6246 if (current_os
== abs_output_section
)
6248 /* If we don't have an output section, then just adjust
6249 the default memory address. */
6250 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6251 false)->current
= newdot
;
6253 else if (newdot
!= dot
)
6255 /* Insert a pad after this statement. We can't
6256 put the pad before when relaxing, in case the
6257 assignment references dot. */
6258 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6259 current_os
->bfd_section
, dot
);
6261 /* Don't neuter the pad below when relaxing. */
6264 /* If dot is advanced, this implies that the section
6265 should have space allocated to it, unless the
6266 user has explicitly stated that the section
6267 should not be allocated. */
6268 if (current_os
->sectype
!= noalloc_section
6269 && (current_os
->sectype
!= noload_section
6270 || (bfd_get_flavour (link_info
.output_bfd
)
6271 == bfd_target_elf_flavour
)))
6272 current_os
->bfd_section
->flags
|= SEC_ALLOC
;
6279 case lang_padding_statement_enum
:
6280 /* If this is the first time lang_size_sections is called,
6281 we won't have any padding statements. If this is the
6282 second or later passes when relaxing, we should allow
6283 padding to shrink. If padding is needed on this pass, it
6284 will be added back in. */
6285 s
->padding_statement
.size
= 0;
6287 /* Make sure output_offset is valid. If relaxation shrinks
6288 the section and this pad isn't needed, it's possible to
6289 have output_offset larger than the final size of the
6290 section. bfd_set_section_contents will complain even for
6291 a pad size of zero. */
6292 s
->padding_statement
.output_offset
6293 = dot
- current_os
->bfd_section
->vma
;
6296 case lang_group_statement_enum
:
6297 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6298 current_os
, fill
, dot
, relax
,
6302 case lang_insert_statement_enum
:
6305 /* We can only get here when relaxing is turned on. */
6306 case lang_address_statement_enum
:
6314 /* If an input section doesn't fit in the current output
6315 section, remove it from the list. Handle the case where we
6316 have to remove an input_section statement here: there is a
6317 special case to remove the first element of the list. */
6318 if (link_info
.non_contiguous_regions
&& removed
)
6320 /* If we removed the first element during the previous
6321 iteration, override the loop assignment of prev_s. */
6327 /* If there was a real previous input section, just skip
6329 prev_s
->header
.next
=s
->header
.next
;
6331 removed_prev_s
= false;
6335 /* Remove the first input section of the list. */
6336 *prev
= s
->header
.next
;
6337 removed_prev_s
= true;
6340 /* Move to next element, unless we removed the head of the
6342 if (!removed_prev_s
)
6343 prev
= &s
->header
.next
;
6347 prev
= &s
->header
.next
;
6348 removed_prev_s
= false;
6354 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6355 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6356 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6357 segments. We are allowed an opportunity to override this decision. */
6360 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6361 bfd
*abfd ATTRIBUTE_UNUSED
,
6362 asection
*current_section
,
6363 asection
*previous_section
,
6366 lang_output_section_statement_type
*cur
;
6367 lang_output_section_statement_type
*prev
;
6369 /* The checks below are only necessary when the BFD library has decided
6370 that the two sections ought to be placed into the same segment. */
6374 /* Paranoia checks. */
6375 if (current_section
== NULL
|| previous_section
== NULL
)
6378 /* If this flag is set, the target never wants code and non-code
6379 sections comingled in the same segment. */
6380 if (config
.separate_code
6381 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6384 /* Find the memory regions associated with the two sections.
6385 We call lang_output_section_find() here rather than scanning the list
6386 of output sections looking for a matching section pointer because if
6387 we have a large number of sections then a hash lookup is faster. */
6388 cur
= lang_output_section_find (current_section
->name
);
6389 prev
= lang_output_section_find (previous_section
->name
);
6391 /* More paranoia. */
6392 if (cur
== NULL
|| prev
== NULL
)
6395 /* If the regions are different then force the sections to live in
6396 different segments. See the email thread starting at the following
6397 URL for the reasons why this is necessary:
6398 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6399 return cur
->region
!= prev
->region
;
6403 one_lang_size_sections_pass (bool *relax
, bool check_regions
)
6405 lang_statement_iteration
++;
6406 if (expld
.phase
!= lang_mark_phase_enum
)
6407 lang_sizing_iteration
++;
6408 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6409 0, 0, relax
, check_regions
);
6413 lang_size_segment (void)
6415 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6416 a page could be saved in the data segment. */
6417 seg_align_type
*seg
= &expld
.dataseg
;
6418 bfd_vma first
, last
;
6420 first
= -seg
->base
& (seg
->commonpagesize
- 1);
6421 last
= seg
->end
& (seg
->commonpagesize
- 1);
6423 && ((seg
->base
& ~(seg
->commonpagesize
- 1))
6424 != (seg
->end
& ~(seg
->commonpagesize
- 1)))
6425 && first
+ last
<= seg
->commonpagesize
)
6427 seg
->phase
= exp_seg_adjust
;
6431 seg
->phase
= exp_seg_done
;
6436 lang_size_relro_segment_1 (void)
6438 seg_align_type
*seg
= &expld
.dataseg
;
6439 bfd_vma relro_end
, desired_end
;
6442 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6443 relro_end
= (seg
->relro_end
+ seg
->relropagesize
- 1) & -seg
->relropagesize
;
6445 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6446 desired_end
= relro_end
- seg
->relro_offset
;
6448 /* For sections in the relro segment.. */
6449 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6450 if ((sec
->flags
& SEC_ALLOC
) != 0
6451 && sec
->vma
>= seg
->base
6452 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6454 /* Where do we want to put this section so that it ends as
6456 bfd_vma start
, end
, bump
;
6458 end
= start
= sec
->vma
;
6460 end
+= TO_ADDR (sec
->size
);
6461 bump
= desired_end
- end
;
6462 /* We'd like to increase START by BUMP, but we must heed
6463 alignment so the increase might be less than optimum. */
6465 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6466 /* This is now the desired end for the previous section. */
6467 desired_end
= start
;
6470 seg
->phase
= exp_seg_relro_adjust
;
6471 ASSERT (desired_end
>= seg
->base
);
6472 seg
->base
= desired_end
;
6477 lang_size_relro_segment (bool *relax
, bool check_regions
)
6479 bool do_reset
= false;
6481 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6483 bfd_vma data_initial_base
= expld
.dataseg
.base
;
6484 bfd_vma data_relro_end
= lang_size_relro_segment_1 ();
6486 lang_reset_memory_regions ();
6487 one_lang_size_sections_pass (relax
, check_regions
);
6489 /* Assignments to dot, or to output section address in a user
6490 script have increased padding over the original. Revert. */
6491 if (expld
.dataseg
.relro_end
> data_relro_end
)
6493 expld
.dataseg
.base
= data_initial_base
;
6497 else if (lang_size_segment ())
6504 lang_size_sections (bool *relax
, bool check_regions
)
6506 expld
.phase
= lang_allocating_phase_enum
;
6507 expld
.dataseg
.phase
= exp_seg_none
;
6509 one_lang_size_sections_pass (relax
, check_regions
);
6511 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6512 expld
.dataseg
.phase
= exp_seg_done
;
6514 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6517 = lang_size_relro_segment (relax
, check_regions
);
6521 lang_reset_memory_regions ();
6522 one_lang_size_sections_pass (relax
, check_regions
);
6525 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6527 link_info
.relro_start
= expld
.dataseg
.base
;
6528 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6533 static lang_output_section_statement_type
*current_section
;
6534 static lang_assignment_statement_type
*current_assign
;
6535 static bool prefer_next_section
;
6537 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6540 lang_do_assignments_1 (lang_statement_union_type
*s
,
6541 lang_output_section_statement_type
*current_os
,
6546 lang_output_section_statement_type
*os
= current_os
;
6548 for (; s
!= NULL
; s
= s
->header
.next
)
6550 switch (s
->header
.type
)
6552 case lang_constructors_statement_enum
:
6553 dot
= lang_do_assignments_1 (constructor_list
.head
,
6554 current_os
, fill
, dot
, found_end
);
6557 case lang_output_section_statement_enum
:
6561 os
= &s
->output_section_statement
;
6562 os
->after_end
= *found_end
;
6563 init_opb (os
->bfd_section
);
6565 if (os
->bfd_section
!= NULL
)
6567 if (!os
->ignored
&& (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6569 current_section
= os
;
6570 prefer_next_section
= false;
6572 newdot
= os
->bfd_section
->vma
;
6574 newdot
= lang_do_assignments_1 (os
->children
.head
,
6575 os
, os
->fill
, newdot
, found_end
);
6578 if (os
->bfd_section
!= NULL
)
6580 newdot
= os
->bfd_section
->vma
;
6582 /* .tbss sections effectively have zero size. */
6583 if (!IS_TBSS (os
->bfd_section
)
6584 || bfd_link_relocatable (&link_info
))
6585 newdot
+= TO_ADDR (os
->bfd_section
->size
);
6587 if (os
->update_dot_tree
!= NULL
)
6588 exp_fold_tree (os
->update_dot_tree
, os
,
6589 bfd_abs_section_ptr
, &newdot
);
6596 case lang_wild_statement_enum
:
6598 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6599 current_os
, fill
, dot
, found_end
);
6602 case lang_object_symbols_statement_enum
:
6603 case lang_output_statement_enum
:
6604 case lang_target_statement_enum
:
6607 case lang_data_statement_enum
:
6608 exp_fold_tree (s
->data_statement
.exp
, os
, bfd_abs_section_ptr
, &dot
);
6609 if (expld
.result
.valid_p
)
6611 s
->data_statement
.value
= expld
.result
.value
;
6612 if (expld
.result
.section
!= NULL
)
6613 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6615 else if (expld
.phase
== lang_final_phase_enum
)
6616 einfo (_("%F%P: invalid data statement\n"));
6619 switch (s
->data_statement
.type
)
6637 if (size
< TO_SIZE ((unsigned) 1))
6638 size
= TO_SIZE ((unsigned) 1);
6639 dot
+= TO_ADDR (size
);
6643 case lang_reloc_statement_enum
:
6644 exp_fold_tree (s
->reloc_statement
.addend_exp
, os
,
6645 bfd_abs_section_ptr
, &dot
);
6646 if (expld
.result
.valid_p
)
6647 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6648 else if (expld
.phase
== lang_final_phase_enum
)
6649 einfo (_("%F%P: invalid reloc statement\n"));
6650 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6653 case lang_input_section_enum
:
6655 asection
*in
= s
->input_section
.section
;
6657 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6658 dot
+= TO_ADDR (in
->size
);
6662 case lang_input_statement_enum
:
6665 case lang_fill_statement_enum
:
6666 fill
= s
->fill_statement
.fill
;
6669 case lang_assignment_statement_enum
:
6670 current_assign
= &s
->assignment_statement
;
6671 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6673 const char *p
= current_assign
->exp
->assign
.dst
;
6675 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6676 prefer_next_section
= true;
6680 if (strcmp (p
, "end") == 0)
6683 exp_fold_tree (s
->assignment_statement
.exp
, os
,
6684 (current_os
->bfd_section
!= NULL
6685 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6689 case lang_padding_statement_enum
:
6690 dot
+= TO_ADDR (s
->padding_statement
.size
);
6693 case lang_group_statement_enum
:
6694 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6695 current_os
, fill
, dot
, found_end
);
6698 case lang_insert_statement_enum
:
6701 case lang_address_statement_enum
:
6713 lang_do_assignments (lang_phase_type phase
)
6715 bool found_end
= false;
6717 current_section
= NULL
;
6718 prefer_next_section
= false;
6719 expld
.phase
= phase
;
6720 lang_statement_iteration
++;
6721 lang_do_assignments_1 (statement_list
.head
,
6722 abs_output_section
, NULL
, 0, &found_end
);
6725 /* For an assignment statement outside of an output section statement,
6726 choose the best of neighbouring output sections to use for values
6730 section_for_dot (void)
6734 /* Assignments belong to the previous output section, unless there
6735 has been an assignment to "dot", in which case following
6736 assignments belong to the next output section. (The assumption
6737 is that an assignment to "dot" is setting up the address for the
6738 next output section.) Except that past the assignment to "_end"
6739 we always associate with the previous section. This exception is
6740 for targets like SH that define an alloc .stack or other
6741 weirdness after non-alloc sections. */
6742 if (current_section
== NULL
|| prefer_next_section
)
6744 lang_statement_union_type
*stmt
;
6745 lang_output_section_statement_type
*os
;
6747 for (stmt
= (lang_statement_union_type
*) current_assign
;
6749 stmt
= stmt
->header
.next
)
6750 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6753 os
= stmt
? &stmt
->output_section_statement
: NULL
;
6756 && (os
->bfd_section
== NULL
6757 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6758 || bfd_section_removed_from_list (link_info
.output_bfd
,
6762 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6765 s
= os
->bfd_section
;
6767 s
= link_info
.output_bfd
->section_last
;
6769 && ((s
->flags
& SEC_ALLOC
) == 0
6770 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6775 return bfd_abs_section_ptr
;
6779 s
= current_section
->bfd_section
;
6781 /* The section may have been stripped. */
6783 && ((s
->flags
& SEC_EXCLUDE
) != 0
6784 || (s
->flags
& SEC_ALLOC
) == 0
6785 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6786 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6789 s
= link_info
.output_bfd
->sections
;
6791 && ((s
->flags
& SEC_ALLOC
) == 0
6792 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6797 return bfd_abs_section_ptr
;
6800 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6802 static struct bfd_link_hash_entry
**start_stop_syms
;
6803 static size_t start_stop_count
= 0;
6804 static size_t start_stop_alloc
= 0;
6806 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6807 to start_stop_syms. */
6810 lang_define_start_stop (const char *symbol
, asection
*sec
)
6812 struct bfd_link_hash_entry
*h
;
6814 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6817 if (start_stop_count
== start_stop_alloc
)
6819 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6821 = xrealloc (start_stop_syms
,
6822 start_stop_alloc
* sizeof (*start_stop_syms
));
6824 start_stop_syms
[start_stop_count
++] = h
;
6828 /* Check for input sections whose names match references to
6829 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6830 preliminary definitions. */
6833 lang_init_start_stop (void)
6837 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6839 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6840 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6843 const char *secname
= s
->name
;
6845 for (ps
= secname
; *ps
!= '\0'; ps
++)
6846 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6850 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6852 symbol
[0] = leading_char
;
6853 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6854 lang_define_start_stop (symbol
, s
);
6856 symbol
[1] = leading_char
;
6857 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6858 lang_define_start_stop (symbol
+ 1, s
);
6865 /* Iterate over start_stop_syms. */
6868 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6872 for (i
= 0; i
< start_stop_count
; ++i
)
6873 func (start_stop_syms
[i
]);
6876 /* __start and __stop symbols are only supposed to be defined by the
6877 linker for orphan sections, but we now extend that to sections that
6878 map to an output section of the same name. The symbols were
6879 defined early for --gc-sections, before we mapped input to output
6880 sections, so undo those that don't satisfy this rule. */
6883 undef_start_stop (struct bfd_link_hash_entry
*h
)
6885 if (h
->ldscript_def
)
6888 if (h
->u
.def
.section
->output_section
== NULL
6889 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6890 || strcmp (h
->u
.def
.section
->name
,
6891 h
->u
.def
.section
->output_section
->name
) != 0)
6893 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6894 h
->u
.def
.section
->name
);
6897 /* When there are more than one input sections with the same
6898 section name, SECNAME, linker picks the first one to define
6899 __start_SECNAME and __stop_SECNAME symbols. When the first
6900 input section is removed by comdat group, we need to check
6901 if there is still an output section with section name
6904 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6905 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6907 h
->u
.def
.section
= i
;
6911 h
->type
= bfd_link_hash_undefined
;
6912 h
->u
.undef
.abfd
= NULL
;
6913 if (is_elf_hash_table (link_info
.hash
))
6915 const struct elf_backend_data
*bed
;
6916 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6917 unsigned int was_forced
= eh
->forced_local
;
6919 bed
= get_elf_backend_data (link_info
.output_bfd
);
6920 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, true);
6921 if (!eh
->ref_regular_nonweak
)
6922 h
->type
= bfd_link_hash_undefweak
;
6923 eh
->def_regular
= 0;
6924 eh
->forced_local
= was_forced
;
6930 lang_undef_start_stop (void)
6932 foreach_start_stop (undef_start_stop
);
6935 /* Check for output sections whose names match references to
6936 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6937 preliminary definitions. */
6940 lang_init_startof_sizeof (void)
6944 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6946 const char *secname
= s
->name
;
6947 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6949 sprintf (symbol
, ".startof.%s", secname
);
6950 lang_define_start_stop (symbol
, s
);
6952 memcpy (symbol
+ 1, ".size", 5);
6953 lang_define_start_stop (symbol
+ 1, s
);
6958 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6961 set_start_stop (struct bfd_link_hash_entry
*h
)
6964 || h
->type
!= bfd_link_hash_defined
)
6967 if (h
->root
.string
[0] == '.')
6969 /* .startof. or .sizeof. symbol.
6970 .startof. already has final value. */
6971 if (h
->root
.string
[2] == 'i')
6974 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6975 h
->u
.def
.section
= bfd_abs_section_ptr
;
6980 /* __start or __stop symbol. */
6981 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6983 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6984 if (h
->root
.string
[4 + has_lead
] == 'o')
6987 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6993 lang_finalize_start_stop (void)
6995 foreach_start_stop (set_start_stop
);
6999 lang_symbol_tweaks (void)
7001 /* Give initial values for __start and __stop symbols, so that ELF
7002 gc_sections will keep sections referenced by these symbols. Must
7003 be done before lang_do_assignments. */
7004 if (config
.build_constructors
)
7005 lang_init_start_stop ();
7007 /* Make __ehdr_start hidden, and set def_regular even though it is
7008 likely undefined at this stage. For lang_check_relocs. */
7009 if (is_elf_hash_table (link_info
.hash
)
7010 && !bfd_link_relocatable (&link_info
))
7012 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
7013 bfd_link_hash_lookup (link_info
.hash
, "__ehdr_start",
7014 false, false, true);
7016 /* Only adjust the export class if the symbol was referenced
7017 and not defined, otherwise leave it alone. */
7019 && (h
->root
.type
== bfd_link_hash_new
7020 || h
->root
.type
== bfd_link_hash_undefined
7021 || h
->root
.type
== bfd_link_hash_undefweak
7022 || h
->root
.type
== bfd_link_hash_common
))
7024 const struct elf_backend_data
*bed
;
7025 bed
= get_elf_backend_data (link_info
.output_bfd
);
7026 (*bed
->elf_backend_hide_symbol
) (&link_info
, h
, true);
7027 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
7028 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
7030 h
->root
.linker_def
= 1;
7031 h
->root
.rel_from_abs
= 1;
7039 struct bfd_link_hash_entry
*h
;
7042 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
7043 || bfd_link_dll (&link_info
))
7044 warn
= entry_from_cmdline
;
7048 /* Force the user to specify a root when generating a relocatable with
7049 --gc-sections, unless --gc-keep-exported was also given. */
7050 if (bfd_link_relocatable (&link_info
)
7051 && link_info
.gc_sections
7052 && !link_info
.gc_keep_exported
)
7054 struct bfd_sym_chain
*sym
;
7056 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
7058 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
7059 false, false, false);
7061 && (h
->type
== bfd_link_hash_defined
7062 || h
->type
== bfd_link_hash_defweak
)
7063 && !bfd_is_const_section (h
->u
.def
.section
))
7067 einfo (_("%F%P: --gc-sections requires a defined symbol root "
7068 "specified by -e or -u\n"));
7071 if (entry_symbol
.name
== NULL
)
7073 /* No entry has been specified. Look for the default entry, but
7074 don't warn if we don't find it. */
7075 entry_symbol
.name
= entry_symbol_default
;
7079 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
7080 false, false, true);
7082 && (h
->type
== bfd_link_hash_defined
7083 || h
->type
== bfd_link_hash_defweak
)
7084 && h
->u
.def
.section
->output_section
!= NULL
)
7088 val
= (h
->u
.def
.value
7089 + bfd_section_vma (h
->u
.def
.section
->output_section
)
7090 + h
->u
.def
.section
->output_offset
);
7091 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7092 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
7099 /* We couldn't find the entry symbol. Try parsing it as a
7101 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
7104 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7105 einfo (_("%F%P: can't set start address\n"));
7107 /* BZ 2004952: Only use the start of the entry section for executables. */
7108 else if bfd_link_executable (&link_info
)
7112 /* Can't find the entry symbol, and it's not a number. Use
7113 the first address in the text section. */
7114 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
7118 einfo (_("%P: warning: cannot find entry symbol %s;"
7119 " defaulting to %V\n"),
7121 bfd_section_vma (ts
));
7122 if (!bfd_set_start_address (link_info
.output_bfd
,
7123 bfd_section_vma (ts
)))
7124 einfo (_("%F%P: can't set start address\n"));
7129 einfo (_("%P: warning: cannot find entry symbol %s;"
7130 " not setting start address\n"),
7137 einfo (_("%P: warning: cannot find entry symbol %s;"
7138 " not setting start address\n"),
7144 /* This is a small function used when we want to ignore errors from
7148 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7149 va_list ap ATTRIBUTE_UNUSED
)
7151 /* Don't do anything. */
7154 /* Check that the architecture of all the input files is compatible
7155 with the output file. Also call the backend to let it do any
7156 other checking that is needed. */
7161 lang_input_statement_type
*file
;
7163 const bfd_arch_info_type
*compatible
;
7165 for (file
= (void *) file_chain
.head
;
7169 #if BFD_SUPPORTS_PLUGINS
7170 /* Don't check format of files claimed by plugin. */
7171 if (file
->flags
.claimed
)
7173 #endif /* BFD_SUPPORTS_PLUGINS */
7174 input_bfd
= file
->the_bfd
;
7176 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7177 command_line
.accept_unknown_input_arch
);
7179 /* In general it is not possible to perform a relocatable
7180 link between differing object formats when the input
7181 file has relocations, because the relocations in the
7182 input format may not have equivalent representations in
7183 the output format (and besides BFD does not translate
7184 relocs for other link purposes than a final link). */
7185 if (!file
->flags
.just_syms
7186 && (bfd_link_relocatable (&link_info
)
7187 || link_info
.emitrelocations
)
7188 && (compatible
== NULL
7189 || (bfd_get_flavour (input_bfd
)
7190 != bfd_get_flavour (link_info
.output_bfd
)))
7191 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7193 einfo (_("%F%P: relocatable linking with relocations from"
7194 " format %s (%pB) to format %s (%pB) is not supported\n"),
7195 bfd_get_target (input_bfd
), input_bfd
,
7196 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7197 /* einfo with %F exits. */
7200 if (compatible
== NULL
)
7202 if (command_line
.warn_mismatch
)
7203 einfo (_("%X%P: %s architecture of input file `%pB'"
7204 " is incompatible with %s output\n"),
7205 bfd_printable_name (input_bfd
), input_bfd
,
7206 bfd_printable_name (link_info
.output_bfd
));
7209 /* If the input bfd has no contents, it shouldn't set the
7210 private data of the output bfd. */
7211 else if (!file
->flags
.just_syms
7212 && ((input_bfd
->flags
& DYNAMIC
) != 0
7213 || bfd_count_sections (input_bfd
) != 0))
7215 bfd_error_handler_type pfn
= NULL
;
7217 /* If we aren't supposed to warn about mismatched input
7218 files, temporarily set the BFD error handler to a
7219 function which will do nothing. We still want to call
7220 bfd_merge_private_bfd_data, since it may set up
7221 information which is needed in the output file. */
7222 if (!command_line
.warn_mismatch
)
7223 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7224 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7226 if (command_line
.warn_mismatch
)
7227 einfo (_("%X%P: failed to merge target specific data"
7228 " of file %pB\n"), input_bfd
);
7230 if (!command_line
.warn_mismatch
)
7231 bfd_set_error_handler (pfn
);
7236 /* Look through all the global common symbols and attach them to the
7237 correct section. The -sort-common command line switch may be used
7238 to roughly sort the entries by alignment. */
7243 if (link_info
.inhibit_common_definition
)
7245 if (bfd_link_relocatable (&link_info
)
7246 && !command_line
.force_common_definition
)
7249 if (!config
.sort_common
)
7250 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7255 if (config
.sort_common
== sort_descending
)
7257 for (power
= 4; power
> 0; power
--)
7258 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7261 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7265 for (power
= 0; power
<= 4; power
++)
7266 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7268 power
= (unsigned int) -1;
7269 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7274 /* Place one common symbol in the correct section. */
7277 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7279 unsigned int power_of_two
;
7283 if (h
->type
!= bfd_link_hash_common
)
7287 power_of_two
= h
->u
.c
.p
->alignment_power
;
7289 if (config
.sort_common
== sort_descending
7290 && power_of_two
< *(unsigned int *) info
)
7292 else if (config
.sort_common
== sort_ascending
7293 && power_of_two
> *(unsigned int *) info
)
7296 section
= h
->u
.c
.p
->section
;
7297 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7298 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7301 if (config
.map_file
!= NULL
)
7303 static bool header_printed
;
7308 if (!header_printed
)
7310 minfo (_("\nAllocating common symbols\n"));
7311 minfo (_("Common symbol size file\n\n"));
7312 header_printed
= true;
7315 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7316 DMGL_ANSI
| DMGL_PARAMS
);
7319 minfo ("%s", h
->root
.string
);
7320 len
= strlen (h
->root
.string
);
7325 len
= strlen (name
);
7335 sprintf (buf
, "%" PRIx64
, (uint64_t) size
);
7336 fprintf (config
.map_file
, "%*s0x%-16s", 20 - len
, "", buf
);
7338 minfo ("%pB\n", section
->owner
);
7344 /* Handle a single orphan section S, placing the orphan into an appropriate
7345 output section. The effects of the --orphan-handling command line
7346 option are handled here. */
7349 ldlang_place_orphan (asection
*s
)
7351 if (config
.orphan_handling
== orphan_handling_discard
)
7353 lang_output_section_statement_type
*os
;
7354 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7355 if (os
->addr_tree
== NULL
7356 && (bfd_link_relocatable (&link_info
)
7357 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7358 os
->addr_tree
= exp_intop (0);
7359 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7363 lang_output_section_statement_type
*os
;
7364 const char *name
= s
->name
;
7367 if (config
.orphan_handling
== orphan_handling_error
)
7368 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7371 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7372 constraint
= SPECIAL
;
7374 os
= ldemul_place_orphan (s
, name
, constraint
);
7377 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7378 if (os
->addr_tree
== NULL
7379 && (bfd_link_relocatable (&link_info
)
7380 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7381 os
->addr_tree
= exp_intop (0);
7382 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7385 if (config
.orphan_handling
== orphan_handling_warn
)
7386 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7387 "placed in section `%s'\n"),
7388 s
, s
->owner
, os
->name
);
7392 /* Run through the input files and ensure that every input section has
7393 somewhere to go. If one is found without a destination then create
7394 an input request and place it into the statement tree. */
7397 lang_place_orphans (void)
7399 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7403 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7405 if (s
->output_section
== NULL
)
7407 /* This section of the file is not attached, root
7408 around for a sensible place for it to go. */
7410 if (file
->flags
.just_syms
)
7411 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7412 else if (lang_discard_section_p (s
))
7413 s
->output_section
= bfd_abs_section_ptr
;
7414 else if (strcmp (s
->name
, "COMMON") == 0)
7416 /* This is a lonely common section which must have
7417 come from an archive. We attach to the section
7418 with the wildcard. */
7419 if (!bfd_link_relocatable (&link_info
)
7420 || command_line
.force_common_definition
)
7422 if (default_common_section
== NULL
)
7423 default_common_section
7424 = lang_output_section_statement_lookup (".bss", 0, 1);
7425 lang_add_section (&default_common_section
->children
, s
,
7426 NULL
, NULL
, default_common_section
);
7430 ldlang_place_orphan (s
);
7437 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7439 flagword
*ptr_flags
;
7441 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7447 /* PR 17900: An exclamation mark in the attributes reverses
7448 the sense of any of the attributes that follow. */
7451 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7455 *ptr_flags
|= SEC_ALLOC
;
7459 *ptr_flags
|= SEC_READONLY
;
7463 *ptr_flags
|= SEC_DATA
;
7467 *ptr_flags
|= SEC_CODE
;
7472 *ptr_flags
|= SEC_LOAD
;
7476 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7484 /* Call a function on each real input file. This function will be
7485 called on an archive, but not on the elements. */
7488 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7490 lang_input_statement_type
*f
;
7492 for (f
= (void *) input_file_chain
.head
;
7494 f
= f
->next_real_file
)
7499 /* Call a function on each real file. The function will be called on
7500 all the elements of an archive which are included in the link, but
7501 will not be called on the archive file itself. */
7504 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7506 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7514 ldlang_add_file (lang_input_statement_type
*entry
)
7516 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7518 /* The BFD linker needs to have a list of all input BFDs involved in
7520 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7521 && entry
->the_bfd
->link
.next
== NULL
);
7522 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7524 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7525 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7526 bfd_set_usrdata (entry
->the_bfd
, entry
);
7527 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7529 /* Look through the sections and check for any which should not be
7530 included in the link. We need to do this now, so that we can
7531 notice when the backend linker tries to report multiple
7532 definition errors for symbols which are in sections we aren't
7533 going to link. FIXME: It might be better to entirely ignore
7534 symbols which are defined in sections which are going to be
7535 discarded. This would require modifying the backend linker for
7536 each backend which might set the SEC_LINK_ONCE flag. If we do
7537 this, we should probably handle SEC_EXCLUDE in the same way. */
7539 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7543 lang_add_output (const char *name
, int from_script
)
7545 /* Make -o on command line override OUTPUT in script. */
7546 if (!had_output_filename
|| !from_script
)
7548 output_filename
= name
;
7549 had_output_filename
= true;
7553 lang_output_section_statement_type
*
7554 lang_enter_output_section_statement (const char *output_section_statement_name
,
7555 etree_type
*address_exp
,
7556 enum section_type sectype
,
7557 etree_type
*sectype_value
,
7559 etree_type
*subalign
,
7562 int align_with_input
)
7564 lang_output_section_statement_type
*os
;
7566 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7568 current_section
= os
;
7570 if (os
->addr_tree
== NULL
)
7572 os
->addr_tree
= address_exp
;
7574 os
->sectype
= sectype
;
7575 if (sectype
== type_section
|| sectype
== typed_readonly_section
)
7576 os
->sectype_value
= sectype_value
;
7577 else if (sectype
== noload_section
)
7578 os
->flags
= SEC_NEVER_LOAD
;
7580 os
->flags
= SEC_NO_FLAGS
;
7581 os
->block_value
= 1;
7583 /* Make next things chain into subchain of this. */
7584 push_stat_ptr (&os
->children
);
7586 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7587 if (os
->align_lma_with_input
&& align
!= NULL
)
7588 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7591 os
->subsection_alignment
= subalign
;
7592 os
->section_alignment
= align
;
7594 os
->load_base
= ebase
;
7601 lang_output_statement_type
*new_stmt
;
7603 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7604 new_stmt
->name
= output_filename
;
7607 /* Reset the current counters in the regions. */
7610 lang_reset_memory_regions (void)
7612 lang_memory_region_type
*p
= lang_memory_region_list
;
7614 lang_output_section_statement_type
*os
;
7616 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7618 p
->current
= p
->origin
;
7622 for (os
= (void *) lang_os_list
.head
;
7626 os
->processed_vma
= false;
7627 os
->processed_lma
= false;
7630 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7632 /* Save the last size for possible use by bfd_relax_section. */
7633 o
->rawsize
= o
->size
;
7634 if (!(o
->flags
& SEC_FIXED_SIZE
))
7639 /* Worker for lang_gc_sections_1. */
7642 gc_section_callback (lang_wild_statement_type
*ptr
,
7643 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7645 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7646 void *data ATTRIBUTE_UNUSED
)
7648 /* If the wild pattern was marked KEEP, the member sections
7649 should be as well. */
7650 if (ptr
->keep_sections
)
7651 section
->flags
|= SEC_KEEP
;
7654 /* Iterate over sections marking them against GC. */
7657 lang_gc_sections_1 (lang_statement_union_type
*s
)
7659 for (; s
!= NULL
; s
= s
->header
.next
)
7661 switch (s
->header
.type
)
7663 case lang_wild_statement_enum
:
7664 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7666 case lang_constructors_statement_enum
:
7667 lang_gc_sections_1 (constructor_list
.head
);
7669 case lang_output_section_statement_enum
:
7670 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7672 case lang_group_statement_enum
:
7673 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7682 lang_gc_sections (void)
7684 /* Keep all sections so marked in the link script. */
7685 lang_gc_sections_1 (statement_list
.head
);
7687 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7688 the special case of .stabstr debug info. (See bfd/stabs.c)
7689 Twiddle the flag here, to simplify later linker code. */
7690 if (bfd_link_relocatable (&link_info
))
7692 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7695 #if BFD_SUPPORTS_PLUGINS
7696 if (f
->flags
.claimed
)
7699 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7700 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7701 || strcmp (sec
->name
, ".stabstr") != 0)
7702 sec
->flags
&= ~SEC_EXCLUDE
;
7706 if (link_info
.gc_sections
)
7707 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7710 /* Worker for lang_find_relro_sections_1. */
7713 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7714 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7716 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7719 /* Discarded, excluded and ignored sections effectively have zero
7721 if (section
->output_section
!= NULL
7722 && section
->output_section
->owner
== link_info
.output_bfd
7723 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7724 && !IGNORE_SECTION (section
)
7725 && section
->size
!= 0)
7727 bool *has_relro_section
= (bool *) data
;
7728 *has_relro_section
= true;
7732 /* Iterate over sections for relro sections. */
7735 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7736 bool *has_relro_section
)
7738 if (*has_relro_section
)
7741 for (; s
!= NULL
; s
= s
->header
.next
)
7743 if (s
== expld
.dataseg
.relro_end_stat
)
7746 switch (s
->header
.type
)
7748 case lang_wild_statement_enum
:
7749 walk_wild (&s
->wild_statement
,
7750 find_relro_section_callback
,
7753 case lang_constructors_statement_enum
:
7754 lang_find_relro_sections_1 (constructor_list
.head
,
7757 case lang_output_section_statement_enum
:
7758 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7761 case lang_group_statement_enum
:
7762 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7772 lang_find_relro_sections (void)
7774 bool has_relro_section
= false;
7776 /* Check all sections in the link script. */
7778 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7779 &has_relro_section
);
7781 if (!has_relro_section
)
7782 link_info
.relro
= false;
7785 /* Relax all sections until bfd_relax_section gives up. */
7788 lang_relax_sections (bool need_layout
)
7790 /* NB: Also enable relaxation to layout sections for DT_RELR. */
7791 if (RELAXATION_ENABLED
|| link_info
.enable_dt_relr
)
7793 /* We may need more than one relaxation pass. */
7794 int i
= link_info
.relax_pass
;
7796 /* The backend can use it to determine the current pass. */
7797 link_info
.relax_pass
= 0;
7801 /* Keep relaxing until bfd_relax_section gives up. */
7804 link_info
.relax_trip
= -1;
7807 link_info
.relax_trip
++;
7809 /* Note: pe-dll.c does something like this also. If you find
7810 you need to change this code, you probably need to change
7811 pe-dll.c also. DJ */
7813 /* Do all the assignments with our current guesses as to
7815 lang_do_assignments (lang_assigning_phase_enum
);
7817 /* We must do this after lang_do_assignments, because it uses
7819 lang_reset_memory_regions ();
7821 /* Perform another relax pass - this time we know where the
7822 globals are, so can make a better guess. */
7823 relax_again
= false;
7824 lang_size_sections (&relax_again
, false);
7826 while (relax_again
);
7828 link_info
.relax_pass
++;
7835 /* Final extra sizing to report errors. */
7836 lang_do_assignments (lang_assigning_phase_enum
);
7837 lang_reset_memory_regions ();
7838 lang_size_sections (NULL
, true);
7842 #if BFD_SUPPORTS_PLUGINS
7843 /* Find the insert point for the plugin's replacement files. We
7844 place them after the first claimed real object file, or if the
7845 first claimed object is an archive member, after the last real
7846 object file immediately preceding the archive. In the event
7847 no objects have been claimed at all, we return the first dummy
7848 object file on the list as the insert point; that works, but
7849 the callee must be careful when relinking the file_chain as it
7850 is not actually on that chain, only the statement_list and the
7851 input_file list; in that case, the replacement files must be
7852 inserted at the head of the file_chain. */
7854 static lang_input_statement_type
*
7855 find_replacements_insert_point (bool *before
)
7857 lang_input_statement_type
*claim1
, *lastobject
;
7858 lastobject
= (void *) input_file_chain
.head
;
7859 for (claim1
= (void *) file_chain
.head
;
7861 claim1
= claim1
->next
)
7863 if (claim1
->flags
.claimed
)
7865 *before
= claim1
->flags
.claim_archive
;
7866 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7868 /* Update lastobject if this is a real object file. */
7869 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7870 lastobject
= claim1
;
7872 /* No files were claimed by the plugin. Choose the last object
7873 file found on the list (maybe the first, dummy entry) as the
7879 /* Find where to insert ADD, an archive element or shared library
7880 added during a rescan. */
7882 static lang_input_statement_type
**
7883 find_rescan_insertion (lang_input_statement_type
*add
)
7885 bfd
*add_bfd
= add
->the_bfd
;
7886 lang_input_statement_type
*f
;
7887 lang_input_statement_type
*last_loaded
= NULL
;
7888 lang_input_statement_type
*before
= NULL
;
7889 lang_input_statement_type
**iter
= NULL
;
7891 if (add_bfd
->my_archive
!= NULL
)
7892 add_bfd
= add_bfd
->my_archive
;
7894 /* First look through the input file chain, to find an object file
7895 before the one we've rescanned. Normal object files always
7896 appear on both the input file chain and the file chain, so this
7897 lets us get quickly to somewhere near the correct place on the
7898 file chain if it is full of archive elements. Archives don't
7899 appear on the file chain, but if an element has been extracted
7900 then their input_statement->next points at it. */
7901 for (f
= (void *) input_file_chain
.head
;
7903 f
= f
->next_real_file
)
7905 if (f
->the_bfd
== add_bfd
)
7907 before
= last_loaded
;
7908 if (f
->next
!= NULL
)
7909 return &f
->next
->next
;
7911 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7915 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7917 iter
= &(*iter
)->next
)
7918 if (!(*iter
)->flags
.claim_archive
7919 && (*iter
)->the_bfd
->my_archive
== NULL
)
7925 /* Insert SRCLIST into DESTLIST after given element by chaining
7926 on FIELD as the next-pointer. (Counterintuitively does not need
7927 a pointer to the actual after-node itself, just its chain field.) */
7930 lang_list_insert_after (lang_statement_list_type
*destlist
,
7931 lang_statement_list_type
*srclist
,
7932 lang_statement_union_type
**field
)
7934 *(srclist
->tail
) = *field
;
7935 *field
= srclist
->head
;
7936 if (destlist
->tail
== field
)
7937 destlist
->tail
= srclist
->tail
;
7940 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7941 was taken as a copy of it and leave them in ORIGLIST. */
7944 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7945 lang_statement_list_type
*origlist
)
7947 union lang_statement_union
**savetail
;
7948 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7949 ASSERT (origlist
->head
== destlist
->head
);
7950 savetail
= origlist
->tail
;
7951 origlist
->head
= *(savetail
);
7952 origlist
->tail
= destlist
->tail
;
7953 destlist
->tail
= savetail
;
7957 static lang_statement_union_type
**
7958 find_next_input_statement (lang_statement_union_type
**s
)
7960 for ( ; *s
; s
= &(*s
)->header
.next
)
7962 lang_statement_union_type
**t
;
7963 switch ((*s
)->header
.type
)
7965 case lang_input_statement_enum
:
7967 case lang_wild_statement_enum
:
7968 t
= &(*s
)->wild_statement
.children
.head
;
7970 case lang_group_statement_enum
:
7971 t
= &(*s
)->group_statement
.children
.head
;
7973 case lang_output_section_statement_enum
:
7974 t
= &(*s
)->output_section_statement
.children
.head
;
7979 t
= find_next_input_statement (t
);
7985 #endif /* BFD_SUPPORTS_PLUGINS */
7987 /* Add NAME to the list of garbage collection entry points. */
7990 lang_add_gc_name (const char *name
)
7992 struct bfd_sym_chain
*sym
;
7997 sym
= stat_alloc (sizeof (*sym
));
7999 sym
->next
= link_info
.gc_sym_list
;
8001 link_info
.gc_sym_list
= sym
;
8004 /* Check relocations. */
8007 lang_check_relocs (void)
8009 if (link_info
.check_relocs_after_open_input
)
8013 for (abfd
= link_info
.input_bfds
;
8014 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
8015 if (!bfd_link_check_relocs (abfd
, &link_info
))
8017 /* No object output, fail return. */
8018 config
.make_executable
= false;
8019 /* Note: we do not abort the loop, but rather
8020 continue the scan in case there are other
8021 bad relocations to report. */
8026 /* Look through all output sections looking for places where we can
8027 propagate forward the lma region. */
8030 lang_propagate_lma_regions (void)
8032 lang_output_section_statement_type
*os
;
8034 for (os
= (void *) lang_os_list
.head
;
8038 if (os
->prev
!= NULL
8039 && os
->lma_region
== NULL
8040 && os
->load_base
== NULL
8041 && os
->addr_tree
== NULL
8042 && os
->region
== os
->prev
->region
)
8043 os
->lma_region
= os
->prev
->lma_region
;
8048 warn_non_contiguous_discards (void)
8050 LANG_FOR_EACH_INPUT_STATEMENT (file
)
8052 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
8053 || file
->flags
.just_syms
)
8056 for (asection
*s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8057 if (s
->output_section
== NULL
8058 && (s
->flags
& SEC_LINKER_CREATED
) == 0)
8059 einfo (_("%P: warning: --enable-non-contiguous-regions "
8060 "discards section `%pA' from `%pB'\n"),
8066 reset_one_wild (lang_statement_union_type
*statement
)
8068 if (statement
->header
.type
== lang_wild_statement_enum
)
8070 lang_wild_statement_type
*stmt
= &statement
->wild_statement
;
8071 lang_list_init (&stmt
->matching_sections
);
8076 reset_resolved_wilds (void)
8078 lang_for_each_statement (reset_one_wild
);
8084 /* Finalize dynamic list. */
8085 if (link_info
.dynamic_list
)
8086 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
8088 current_target
= default_target
;
8090 /* Open the output file. */
8091 lang_for_each_statement (ldlang_open_output
);
8094 ldemul_create_output_section_statements ();
8096 /* Add to the hash table all undefineds on the command line. */
8097 lang_place_undefineds ();
8099 if (!bfd_section_already_linked_table_init ())
8100 einfo (_("%F%P: can not create hash table: %E\n"));
8102 /* A first pass through the memory regions ensures that if any region
8103 references a symbol for its origin or length then this symbol will be
8104 added to the symbol table. Having these symbols in the symbol table
8105 means that when we call open_input_bfds PROVIDE statements will
8106 trigger to provide any needed symbols. The regions origins and
8107 lengths are not assigned as a result of this call. */
8108 lang_do_memory_regions (false);
8110 /* Create a bfd for each input file. */
8111 current_target
= default_target
;
8112 lang_statement_iteration
++;
8113 open_input_bfds (statement_list
.head
, NULL
, OPEN_BFD_NORMAL
);
8115 /* Now that open_input_bfds has processed assignments and provide
8116 statements we can give values to symbolic origin/length now. */
8117 lang_do_memory_regions (true);
8119 ldemul_before_plugin_all_symbols_read ();
8121 #if BFD_SUPPORTS_PLUGINS
8122 if (link_info
.lto_plugin_active
)
8124 lang_statement_list_type added
;
8125 lang_statement_list_type files
, inputfiles
;
8127 /* Now all files are read, let the plugin(s) decide if there
8128 are any more to be added to the link before we call the
8129 emulation's after_open hook. We create a private list of
8130 input statements for this purpose, which we will eventually
8131 insert into the global statement list after the first claimed
8134 /* We need to manipulate all three chains in synchrony. */
8136 inputfiles
= input_file_chain
;
8137 if (plugin_call_all_symbols_read ())
8138 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
8139 plugin_error_plugin ());
8140 link_info
.lto_all_symbols_read
= true;
8141 /* Open any newly added files, updating the file chains. */
8142 plugin_undefs
= link_info
.hash
->undefs_tail
;
8143 lang_output_section_statement_type
*last_os
= NULL
;
8144 if (lang_os_list
.head
!= NULL
)
8145 last_os
= ((lang_output_section_statement_type
*)
8146 ((char *) lang_os_list
.tail
8147 - offsetof (lang_output_section_statement_type
, next
)));
8148 open_input_bfds (*added
.tail
, last_os
, OPEN_BFD_NORMAL
);
8149 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
8150 plugin_undefs
= NULL
;
8151 /* Restore the global list pointer now they have all been added. */
8152 lang_list_remove_tail (stat_ptr
, &added
);
8153 /* And detach the fresh ends of the file lists. */
8154 lang_list_remove_tail (&file_chain
, &files
);
8155 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
8156 /* Were any new files added? */
8157 if (added
.head
!= NULL
)
8159 /* If so, we will insert them into the statement list immediately
8160 after the first input file that was claimed by the plugin,
8161 unless that file was an archive in which case it is inserted
8162 immediately before. */
8164 lang_statement_union_type
**prev
;
8165 plugin_insert
= find_replacements_insert_point (&before
);
8166 /* If a plugin adds input files without having claimed any, we
8167 don't really have a good idea where to place them. Just putting
8168 them at the start or end of the list is liable to leave them
8169 outside the crtbegin...crtend range. */
8170 ASSERT (plugin_insert
!= NULL
);
8171 /* Splice the new statement list into the old one. */
8172 prev
= &plugin_insert
->header
.next
;
8175 prev
= find_next_input_statement (prev
);
8176 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8178 /* We didn't find the expected input statement.
8179 Fall back to adding after plugin_insert. */
8180 prev
= &plugin_insert
->header
.next
;
8183 lang_list_insert_after (stat_ptr
, &added
, prev
);
8184 /* Likewise for the file chains. */
8185 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8186 (void *) &plugin_insert
->next_real_file
);
8187 /* We must be careful when relinking file_chain; we may need to
8188 insert the new files at the head of the list if the insert
8189 point chosen is the dummy first input file. */
8190 if (plugin_insert
->filename
)
8191 lang_list_insert_after (&file_chain
, &files
,
8192 (void *) &plugin_insert
->next
);
8194 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8196 /* Rescan archives in case new undefined symbols have appeared. */
8198 lang_statement_iteration
++;
8199 open_input_bfds (statement_list
.head
, NULL
, OPEN_BFD_RESCAN
);
8200 lang_list_remove_tail (&file_chain
, &files
);
8201 while (files
.head
!= NULL
)
8203 lang_input_statement_type
**insert
;
8204 lang_input_statement_type
**iter
, *temp
;
8207 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8208 /* All elements from an archive can be added at once. */
8209 iter
= &files
.head
->input_statement
.next
;
8210 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8211 if (my_arch
!= NULL
)
8212 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8213 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8216 *insert
= &files
.head
->input_statement
;
8217 files
.head
= (lang_statement_union_type
*) *iter
;
8219 if (file_chain
.tail
== (lang_statement_union_type
**) insert
)
8220 file_chain
.tail
= (lang_statement_union_type
**) iter
;
8221 if (my_arch
!= NULL
)
8223 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8225 parent
->next
= (lang_input_statement_type
*)
8227 - offsetof (lang_input_statement_type
, next
));
8232 #endif /* BFD_SUPPORTS_PLUGINS */
8234 struct bfd_sym_chain
**sym
= &link_info
.gc_sym_list
;
8236 sym
= &(*sym
)->next
;
8238 *sym
= &entry_symbol
;
8240 if (entry_symbol
.name
== NULL
)
8242 *sym
= ldlang_undef_chain_list_head
;
8244 /* entry_symbol is normally initialised by an ENTRY definition in the
8245 linker script or the -e command line option. But if neither of
8246 these have been used, the target specific backend may still have
8247 provided an entry symbol via a call to lang_default_entry().
8248 Unfortunately this value will not be processed until lang_end()
8249 is called, long after this function has finished. So detect this
8250 case here and add the target's entry symbol to the list of starting
8251 points for garbage collection resolution. */
8252 lang_add_gc_name (entry_symbol_default
);
8255 lang_add_gc_name (link_info
.init_function
);
8256 lang_add_gc_name (link_info
.fini_function
);
8258 ldemul_after_open ();
8259 if (config
.map_file
!= NULL
)
8260 lang_print_asneeded ();
8264 bfd_section_already_linked_table_free ();
8266 /* Make sure that we're not mixing architectures. We call this
8267 after all the input files have been opened, but before we do any
8268 other processing, so that any operations merge_private_bfd_data
8269 does on the output file will be known during the rest of the
8273 /* Handle .exports instead of a version script if we're told to do so. */
8274 if (command_line
.version_exports_section
)
8275 lang_do_version_exports_section ();
8277 /* Build all sets based on the information gathered from the input
8279 ldctor_build_sets ();
8281 lang_symbol_tweaks ();
8283 /* PR 13683: We must rerun the assignments prior to running garbage
8284 collection in order to make sure that all symbol aliases are resolved. */
8285 lang_do_assignments (lang_mark_phase_enum
);
8286 expld
.phase
= lang_first_phase_enum
;
8288 /* Size up the common data. */
8292 debug_prefix_tree ();
8296 /* Remove unreferenced sections if asked to. */
8297 lang_gc_sections ();
8299 lang_mark_undefineds ();
8301 /* Check relocations. */
8302 lang_check_relocs ();
8304 ldemul_after_check_relocs ();
8306 /* There might have been new sections created (e.g. as result of
8307 checking relocs to need a .got, or suchlike), so to properly order
8308 them into our lists of matching sections reset them here. */
8309 reset_resolved_wilds ();
8312 /* Update wild statements in case the user gave --sort-section.
8313 Note how the option might have come after the linker script and
8314 so couldn't have been set when the wild statements were created. */
8315 update_wild_statements (statement_list
.head
);
8317 /* Run through the contours of the script and attach input sections
8318 to the correct output sections. */
8319 lang_statement_iteration
++;
8320 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8322 /* Start at the statement immediately after the special abs_section
8323 output statement, so that it isn't reordered. */
8324 process_insert_statements (&lang_os_list
.head
->header
.next
);
8326 ldemul_before_place_orphans ();
8328 /* Find any sections not attached explicitly and handle them. */
8329 lang_place_orphans ();
8331 if (!bfd_link_relocatable (&link_info
))
8335 /* Merge SEC_MERGE sections. This has to be done after GC of
8336 sections, so that GCed sections are not merged, but before
8337 assigning dynamic symbols, since removing whole input sections
8339 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8341 /* Look for a text section and set the readonly attribute in it. */
8342 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8346 if (config
.text_read_only
)
8347 found
->flags
|= SEC_READONLY
;
8349 found
->flags
&= ~SEC_READONLY
;
8353 /* Merge together CTF sections. After this, only the symtab-dependent
8354 function and data object sections need adjustment. */
8357 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8358 examining things laid out late, like the strtab. */
8361 /* Copy forward lma regions for output sections in same lma region. */
8362 lang_propagate_lma_regions ();
8364 /* Defining __start/__stop symbols early for --gc-sections to work
8365 around a glibc build problem can result in these symbols being
8366 defined when they should not be. Fix them now. */
8367 if (config
.build_constructors
)
8368 lang_undef_start_stop ();
8370 /* Define .startof./.sizeof. symbols with preliminary values before
8371 dynamic symbols are created. */
8372 if (!bfd_link_relocatable (&link_info
))
8373 lang_init_startof_sizeof ();
8375 /* Do anything special before sizing sections. This is where ELF
8376 and other back-ends size dynamic sections. */
8377 ldemul_before_allocation ();
8379 /* We must record the program headers before we try to fix the
8380 section positions, since they will affect SIZEOF_HEADERS. */
8381 lang_record_phdrs ();
8383 /* Check relro sections. */
8384 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8385 lang_find_relro_sections ();
8387 /* Size up the sections. */
8388 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8390 /* See if anything special should be done now we know how big
8391 everything is. This is where relaxation is done. */
8392 ldemul_after_allocation ();
8394 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8395 lang_finalize_start_stop ();
8397 /* Do all the assignments again, to report errors. Assignment
8398 statements are processed multiple times, updating symbols; In
8399 open_input_bfds, lang_do_assignments, and lang_size_sections.
8400 Since lang_relax_sections calls lang_do_assignments, symbols are
8401 also updated in ldemul_after_allocation. */
8402 lang_do_assignments (lang_final_phase_enum
);
8406 /* Convert absolute symbols to section relative. */
8407 ldexp_finalize_syms ();
8409 /* Make sure that the section addresses make sense. */
8410 if (command_line
.check_section_addresses
)
8411 lang_check_section_addresses ();
8413 if (link_info
.non_contiguous_regions
8414 && link_info
.non_contiguous_regions_warnings
)
8415 warn_non_contiguous_discards ();
8417 /* Check any required symbols are known. */
8418 ldlang_check_require_defined_symbols ();
8424 lang_add_version_string (void)
8426 if (! enable_linker_version
)
8429 const char * str
= "GNU ld ";
8430 int len
= strlen (str
);
8433 for (i
= 0 ; i
< len
; i
++)
8434 lang_add_data (BYTE
, exp_intop (str
[i
]));
8436 str
= BFD_VERSION_STRING
;
8439 for (i
= 0 ; i
< len
; i
++)
8440 lang_add_data (BYTE
, exp_intop (str
[i
]));
8442 lang_add_data (BYTE
, exp_intop ('\0'));
8445 /* EXPORTED TO YACC */
8448 lang_add_wild (struct wildcard_spec
*filespec
,
8449 struct wildcard_list
*section_list
,
8452 struct wildcard_list
*curr
, *next
;
8453 lang_wild_statement_type
*new_stmt
;
8454 bool any_specs_sorted
= false;
8456 /* Reverse the list as the parser puts it back to front. */
8457 for (curr
= section_list
, section_list
= NULL
;
8459 section_list
= curr
, curr
= next
)
8461 if (curr
->spec
.sorted
!= none
&& curr
->spec
.sorted
!= by_none
)
8462 any_specs_sorted
= true;
8464 curr
->next
= section_list
;
8467 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8469 if (strcmp (filespec
->name
, "*") == 0)
8470 filespec
->name
= NULL
;
8471 else if (!wildcardp (filespec
->name
))
8472 lang_has_input_file
= true;
8475 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8476 new_stmt
->filename
= NULL
;
8477 new_stmt
->filenames_sorted
= false;
8478 new_stmt
->any_specs_sorted
= any_specs_sorted
;
8479 new_stmt
->section_flag_list
= NULL
;
8480 new_stmt
->exclude_name_list
= NULL
;
8481 if (filespec
!= NULL
)
8483 new_stmt
->filename
= filespec
->name
;
8484 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8485 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8486 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8488 new_stmt
->section_list
= section_list
;
8489 new_stmt
->keep_sections
= keep_sections
;
8490 lang_list_init (&new_stmt
->children
);
8491 lang_list_init (&new_stmt
->matching_sections
);
8492 analyze_walk_wild_section_handler (new_stmt
);
8495 printf ("wild %s(", new_stmt
->filename
? new_stmt
->filename
: "*");
8496 for (curr
= new_stmt
->section_list
; curr
; curr
= curr
->next
)
8497 printf ("%s ", curr
->spec
.name
? curr
->spec
.name
: "*");
8503 lang_section_start (const char *name
, etree_type
*address
,
8504 const segment_type
*segment
)
8506 lang_address_statement_type
*ad
;
8508 ad
= new_stat (lang_address_statement
, stat_ptr
);
8509 ad
->section_name
= name
;
8510 ad
->address
= address
;
8511 ad
->segment
= segment
;
8514 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8515 because of a -e argument on the command line, or zero if this is
8516 called by ENTRY in a linker script. Command line arguments take
8520 lang_add_entry (const char *name
, bool cmdline
)
8522 if (entry_symbol
.name
== NULL
8524 || !entry_from_cmdline
)
8526 entry_symbol
.name
= name
;
8527 entry_from_cmdline
= cmdline
;
8531 /* Set the default start symbol to NAME. .em files should use this,
8532 not lang_add_entry, to override the use of "start" if neither the
8533 linker script nor the command line specifies an entry point. NAME
8534 must be permanently allocated. */
8536 lang_default_entry (const char *name
)
8538 entry_symbol_default
= name
;
8542 lang_add_target (const char *name
)
8544 lang_target_statement_type
*new_stmt
;
8546 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8547 new_stmt
->target
= name
;
8551 lang_add_map (const char *name
)
8558 map_option_f
= true;
8566 lang_add_fill (fill_type
*fill
)
8568 lang_fill_statement_type
*new_stmt
;
8570 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8571 new_stmt
->fill
= fill
;
8575 lang_add_data (int type
, union etree_union
*exp
)
8577 lang_data_statement_type
*new_stmt
;
8579 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8580 new_stmt
->exp
= exp
;
8581 new_stmt
->type
= type
;
8585 lang_add_string (const char *s
)
8587 bfd_vma len
= strlen (s
);
8589 bool escape
= false;
8591 /* Add byte expressions until end of string. */
8592 for (i
= 0 ; i
< len
; i
++)
8601 /* Ignore the escape. */
8604 case 'n': c
= '\n'; break;
8605 case 'r': c
= '\r'; break;
8606 case 't': c
= '\t'; break;
8616 /* We have an octal number. */
8618 unsigned int value
= c
- '0';
8621 if ((c
>= '0') && (c
<= '7'))
8629 if ((c
>= '0') && (c
<= '7'))
8640 /* octal: \777 is treated as '\077' + '7' */
8651 lang_add_data (BYTE
, exp_intop (c
));
8659 lang_add_data (BYTE
, exp_intop (c
));
8663 /* Remeber to terminate the string. */
8664 lang_add_data (BYTE
, exp_intop (0));
8667 /* Create a new reloc statement. RELOC is the BFD relocation type to
8668 generate. HOWTO is the corresponding howto structure (we could
8669 look this up, but the caller has already done so). SECTION is the
8670 section to generate a reloc against, or NAME is the name of the
8671 symbol to generate a reloc against. Exactly one of SECTION and
8672 NAME must be NULL. ADDEND is an expression for the addend. */
8675 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8676 reloc_howto_type
*howto
,
8679 union etree_union
*addend
)
8681 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8685 p
->section
= section
;
8687 p
->addend_exp
= addend
;
8689 p
->addend_value
= 0;
8690 p
->output_section
= NULL
;
8691 p
->output_offset
= 0;
8694 lang_assignment_statement_type
*
8695 lang_add_assignment (etree_type
*exp
)
8697 lang_assignment_statement_type
*new_stmt
;
8699 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8700 new_stmt
->exp
= exp
;
8705 lang_add_attribute (enum statement_enum attribute
)
8707 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8711 lang_startup (const char *name
)
8713 if (first_file
->filename
!= NULL
)
8715 einfo (_("%F%P: multiple STARTUP files\n"));
8717 first_file
->filename
= name
;
8718 first_file
->local_sym_name
= name
;
8719 first_file
->flags
.real
= true;
8723 lang_float (bool maybe
)
8725 lang_float_flag
= maybe
;
8729 /* Work out the load- and run-time regions from a script statement, and
8730 store them in *LMA_REGION and *REGION respectively.
8732 MEMSPEC is the name of the run-time region, or the value of
8733 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8734 LMA_MEMSPEC is the name of the load-time region, or null if the
8735 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8736 had an explicit load address.
8738 It is an error to specify both a load region and a load address. */
8741 lang_get_regions (lang_memory_region_type
**region
,
8742 lang_memory_region_type
**lma_region
,
8743 const char *memspec
,
8744 const char *lma_memspec
,
8748 *lma_region
= lang_memory_region_lookup (lma_memspec
, false);
8750 /* If no runtime region or VMA has been specified, but the load region
8751 has been specified, then use the load region for the runtime region
8753 if (lma_memspec
!= NULL
8755 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8756 *region
= *lma_region
;
8758 *region
= lang_memory_region_lookup (memspec
, false);
8760 if (have_lma
&& lma_memspec
!= 0)
8761 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8766 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8767 lang_output_section_phdr_list
*phdrs
,
8768 const char *lma_memspec
)
8770 lang_get_regions (¤t_section
->region
,
8771 ¤t_section
->lma_region
,
8772 memspec
, lma_memspec
,
8773 current_section
->load_base
!= NULL
,
8774 current_section
->addr_tree
!= NULL
);
8776 current_section
->fill
= fill
;
8777 current_section
->phdrs
= phdrs
;
8781 /* Set the output format type. -oformat overrides scripts. */
8784 lang_add_output_format (const char *format
,
8789 if (output_target
== NULL
|| !from_script
)
8791 if (command_line
.endian
== ENDIAN_BIG
8794 else if (command_line
.endian
== ENDIAN_LITTLE
8798 output_target
= format
;
8803 lang_add_insert (const char *where
, int is_before
)
8805 lang_insert_statement_type
*new_stmt
;
8807 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8808 new_stmt
->where
= where
;
8809 new_stmt
->is_before
= is_before
;
8810 saved_script_handle
= previous_script_handle
;
8813 /* Enter a group. This creates a new lang_group_statement, and sets
8814 stat_ptr to build new statements within the group. */
8817 lang_enter_group (void)
8819 lang_group_statement_type
*g
;
8821 g
= new_stat (lang_group_statement
, stat_ptr
);
8822 lang_list_init (&g
->children
);
8823 push_stat_ptr (&g
->children
);
8826 /* Leave a group. This just resets stat_ptr to start writing to the
8827 regular list of statements again. Note that this will not work if
8828 groups can occur inside anything else which can adjust stat_ptr,
8829 but currently they can't. */
8832 lang_leave_group (void)
8837 /* Add a new program header. This is called for each entry in a PHDRS
8838 command in a linker script. */
8841 lang_new_phdr (const char *name
,
8848 struct lang_phdr
*n
, **pp
;
8851 n
= stat_alloc (sizeof (struct lang_phdr
));
8854 n
->type
= exp_get_vma (type
, NULL
, 0, "program header type");
8855 n
->filehdr
= filehdr
;
8860 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8862 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8865 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8867 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8868 " when prior PT_LOAD headers lack them\n"), NULL
);
8875 /* Record the program header information in the output BFD. FIXME: We
8876 should not be calling an ELF specific function here. */
8879 lang_record_phdrs (void)
8883 lang_output_section_phdr_list
*last
;
8884 struct lang_phdr
*l
;
8885 lang_output_section_statement_type
*os
;
8888 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8891 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8898 for (os
= (void *) lang_os_list
.head
;
8902 lang_output_section_phdr_list
*pl
;
8904 if (os
->constraint
< 0)
8912 if (os
->sectype
== noload_section
8913 || os
->bfd_section
== NULL
8914 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8917 /* Don't add orphans to PT_INTERP header. */
8923 lang_output_section_statement_type
*tmp_os
;
8925 /* If we have not run across a section with a program
8926 header assigned to it yet, then scan forwards to find
8927 one. This prevents inconsistencies in the linker's
8928 behaviour when a script has specified just a single
8929 header and there are sections in that script which are
8930 not assigned to it, and which occur before the first
8931 use of that header. See here for more details:
8932 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8933 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8936 last
= tmp_os
->phdrs
;
8940 einfo (_("%F%P: no sections assigned to phdrs\n"));
8945 if (os
->bfd_section
== NULL
)
8948 for (; pl
!= NULL
; pl
= pl
->next
)
8950 if (strcmp (pl
->name
, l
->name
) == 0)
8955 secs
= (asection
**) xrealloc (secs
,
8956 alc
* sizeof (asection
*));
8958 secs
[c
] = os
->bfd_section
;
8965 if (l
->flags
== NULL
)
8968 flags
= exp_get_vma (l
->flags
, NULL
, 0, "phdr flags");
8973 at
= exp_get_vma (l
->at
, NULL
, 0, "phdr load address");
8975 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8976 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8977 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8978 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8983 /* Make sure all the phdr assignments succeeded. */
8984 for (os
= (void *) lang_os_list
.head
;
8988 lang_output_section_phdr_list
*pl
;
8990 if (os
->constraint
< 0
8991 || os
->bfd_section
== NULL
)
8994 for (pl
= os
->phdrs
;
8997 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8998 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8999 os
->name
, pl
->name
);
9003 /* Record a list of sections which may not be cross referenced. */
9006 lang_add_nocrossref (lang_nocrossref_type
*l
)
9008 struct lang_nocrossrefs
*n
;
9010 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
9011 n
->next
= nocrossref_list
;
9013 n
->onlyfirst
= false;
9014 nocrossref_list
= n
;
9016 /* Set notice_all so that we get informed about all symbols. */
9017 link_info
.notice_all
= true;
9020 /* Record a section that cannot be referenced from a list of sections. */
9023 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
9025 lang_add_nocrossref (l
);
9026 nocrossref_list
->onlyfirst
= true;
9029 /* Overlay handling. We handle overlays with some static variables. */
9031 /* The overlay virtual address. */
9032 static etree_type
*overlay_vma
;
9033 /* And subsection alignment. */
9034 static etree_type
*overlay_subalign
;
9036 /* An expression for the maximum section size seen so far. */
9037 static etree_type
*overlay_max
;
9039 /* A list of all the sections in this overlay. */
9041 struct overlay_list
{
9042 struct overlay_list
*next
;
9043 lang_output_section_statement_type
*os
;
9046 static struct overlay_list
*overlay_list
;
9048 /* Start handling an overlay. */
9051 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
9053 /* The grammar should prevent nested overlays from occurring. */
9054 ASSERT (overlay_vma
== NULL
9055 && overlay_subalign
== NULL
9056 && overlay_max
== NULL
);
9058 overlay_vma
= vma_expr
;
9059 overlay_subalign
= subalign
;
9062 /* Start a section in an overlay. We handle this by calling
9063 lang_enter_output_section_statement with the correct VMA.
9064 lang_leave_overlay sets up the LMA and memory regions. */
9067 lang_enter_overlay_section (const char *name
)
9069 struct overlay_list
*n
;
9072 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
9073 0, 0, overlay_subalign
, 0, 0, 0);
9075 /* If this is the first section, then base the VMA of future
9076 sections on this one. This will work correctly even if `.' is
9077 used in the addresses. */
9078 if (overlay_list
== NULL
)
9079 overlay_vma
= exp_nameop (ADDR
, name
);
9081 /* Remember the section. */
9082 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
9083 n
->os
= current_section
;
9084 n
->next
= overlay_list
;
9087 size
= exp_nameop (SIZEOF
, name
);
9089 /* Arrange to work out the maximum section end address. */
9090 if (overlay_max
== NULL
)
9093 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
9096 /* Finish a section in an overlay. There isn't any special to do
9100 lang_leave_overlay_section (fill_type
*fill
,
9101 lang_output_section_phdr_list
*phdrs
)
9108 name
= current_section
->name
;
9110 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
9111 region and that no load-time region has been specified. It doesn't
9112 really matter what we say here, since lang_leave_overlay will
9114 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
9116 /* Define the magic symbols. */
9118 clean
= (char *) xmalloc (strlen (name
) + 1);
9120 for (s1
= name
; *s1
!= '\0'; s1
++)
9121 if (ISALNUM (*s1
) || *s1
== '_')
9125 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
9126 sprintf (buf
, "__load_start_%s", clean
);
9127 lang_add_assignment (exp_provide (buf
,
9128 exp_nameop (LOADADDR
, name
),
9131 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
9132 sprintf (buf
, "__load_stop_%s", clean
);
9133 lang_add_assignment (exp_provide (buf
,
9135 exp_nameop (LOADADDR
, name
),
9136 exp_nameop (SIZEOF
, name
)),
9142 /* Finish an overlay. If there are any overlay wide settings, this
9143 looks through all the sections in the overlay and sets them. */
9146 lang_leave_overlay (etree_type
*lma_expr
,
9149 const char *memspec
,
9150 lang_output_section_phdr_list
*phdrs
,
9151 const char *lma_memspec
)
9153 lang_memory_region_type
*region
;
9154 lang_memory_region_type
*lma_region
;
9155 struct overlay_list
*l
;
9156 lang_nocrossref_type
*nocrossref
;
9158 lang_get_regions (®ion
, &lma_region
,
9159 memspec
, lma_memspec
,
9160 lma_expr
!= NULL
, false);
9164 /* After setting the size of the last section, set '.' to end of the
9166 if (overlay_list
!= NULL
)
9168 overlay_list
->os
->update_dot
= 1;
9169 overlay_list
->os
->update_dot_tree
9170 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), false);
9176 struct overlay_list
*next
;
9178 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
9181 l
->os
->region
= region
;
9182 l
->os
->lma_region
= lma_region
;
9184 /* The first section has the load address specified in the
9185 OVERLAY statement. The rest are worked out from that.
9186 The base address is not needed (and should be null) if
9187 an LMA region was specified. */
9190 l
->os
->load_base
= lma_expr
;
9191 l
->os
->sectype
= first_overlay_section
;
9193 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
9194 l
->os
->phdrs
= phdrs
;
9198 lang_nocrossref_type
*nc
;
9200 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
9201 nc
->name
= l
->os
->name
;
9202 nc
->next
= nocrossref
;
9211 if (nocrossref
!= NULL
)
9212 lang_add_nocrossref (nocrossref
);
9215 overlay_list
= NULL
;
9217 overlay_subalign
= NULL
;
9220 /* Version handling. This is only useful for ELF. */
9222 /* If PREV is NULL, return first version pattern matching particular symbol.
9223 If PREV is non-NULL, return first version pattern matching particular
9224 symbol after PREV (previously returned by lang_vers_match). */
9226 static struct bfd_elf_version_expr
*
9227 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
9228 struct bfd_elf_version_expr
*prev
,
9232 const char *cxx_sym
= sym
;
9233 const char *java_sym
= sym
;
9234 struct bfd_elf_version_expr
*expr
= NULL
;
9235 enum demangling_styles curr_style
;
9237 curr_style
= CURRENT_DEMANGLING_STYLE
;
9238 cplus_demangle_set_style (no_demangling
);
9239 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
9242 cplus_demangle_set_style (curr_style
);
9244 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9246 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
9247 DMGL_PARAMS
| DMGL_ANSI
);
9251 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9253 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
9258 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
9260 struct bfd_elf_version_expr e
;
9262 switch (prev
? prev
->mask
: 0)
9265 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
9268 expr
= (struct bfd_elf_version_expr
*)
9269 htab_find ((htab_t
) head
->htab
, &e
);
9270 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
9271 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
9277 case BFD_ELF_VERSION_C_TYPE
:
9278 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9280 e
.pattern
= cxx_sym
;
9281 expr
= (struct bfd_elf_version_expr
*)
9282 htab_find ((htab_t
) head
->htab
, &e
);
9283 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
9284 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9290 case BFD_ELF_VERSION_CXX_TYPE
:
9291 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9293 e
.pattern
= java_sym
;
9294 expr
= (struct bfd_elf_version_expr
*)
9295 htab_find ((htab_t
) head
->htab
, &e
);
9296 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9297 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9308 /* Finally, try the wildcards. */
9309 if (prev
== NULL
|| prev
->literal
)
9310 expr
= head
->remaining
;
9313 for (; expr
; expr
= expr
->next
)
9320 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9323 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9325 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9329 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9335 free ((char *) c_sym
);
9337 free ((char *) cxx_sym
);
9338 if (java_sym
!= sym
)
9339 free ((char *) java_sym
);
9343 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9344 return a pointer to the symbol name with any backslash quotes removed. */
9347 realsymbol (const char *pattern
)
9350 bool changed
= false, backslash
= false;
9351 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9353 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9355 /* It is a glob pattern only if there is no preceding
9359 /* Remove the preceding backslash. */
9366 if (*p
== '?' || *p
== '*' || *p
== '[')
9373 backslash
= *p
== '\\';
9389 /* This is called for each variable name or match expression. NEW_NAME is
9390 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9391 pattern to be matched against symbol names. */
9393 struct bfd_elf_version_expr
*
9394 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9395 const char *new_name
,
9399 struct bfd_elf_version_expr
*ret
;
9401 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9405 ret
->literal
= true;
9406 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9407 if (ret
->pattern
== NULL
)
9409 ret
->pattern
= new_name
;
9410 ret
->literal
= false;
9413 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9414 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9415 else if (strcasecmp (lang
, "C++") == 0)
9416 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9417 else if (strcasecmp (lang
, "Java") == 0)
9418 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9421 einfo (_("%X%P: unknown language `%s' in version information\n"),
9423 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9426 return ldemul_new_vers_pattern (ret
);
9429 /* This is called for each set of variable names and match
9432 struct bfd_elf_version_tree
*
9433 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9434 struct bfd_elf_version_expr
*locals
)
9436 struct bfd_elf_version_tree
*ret
;
9438 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9439 ret
->globals
.list
= globals
;
9440 ret
->locals
.list
= locals
;
9441 ret
->match
= lang_vers_match
;
9442 ret
->name_indx
= (unsigned int) -1;
9446 /* This static variable keeps track of version indices. */
9448 static int version_index
;
9451 version_expr_head_hash (const void *p
)
9453 const struct bfd_elf_version_expr
*e
=
9454 (const struct bfd_elf_version_expr
*) p
;
9456 return htab_hash_string (e
->pattern
);
9460 version_expr_head_eq (const void *p1
, const void *p2
)
9462 const struct bfd_elf_version_expr
*e1
=
9463 (const struct bfd_elf_version_expr
*) p1
;
9464 const struct bfd_elf_version_expr
*e2
=
9465 (const struct bfd_elf_version_expr
*) p2
;
9467 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9471 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9474 struct bfd_elf_version_expr
*e
, *next
;
9475 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9477 for (e
= head
->list
; e
; e
= e
->next
)
9481 head
->mask
|= e
->mask
;
9486 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9487 version_expr_head_eq
, NULL
);
9488 list_loc
= &head
->list
;
9489 remaining_loc
= &head
->remaining
;
9490 for (e
= head
->list
; e
; e
= next
)
9496 remaining_loc
= &e
->next
;
9500 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9504 struct bfd_elf_version_expr
*e1
, *last
;
9506 e1
= (struct bfd_elf_version_expr
*) *loc
;
9510 if (e1
->mask
== e
->mask
)
9518 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9522 /* This is a duplicate. */
9523 /* FIXME: Memory leak. Sometimes pattern is not
9524 xmalloced alone, but in larger chunk of memory. */
9525 /* free (e->pattern); */
9530 e
->next
= last
->next
;
9538 list_loc
= &e
->next
;
9542 *remaining_loc
= NULL
;
9543 *list_loc
= head
->remaining
;
9546 head
->remaining
= head
->list
;
9549 /* This is called when we know the name and dependencies of the
9553 lang_register_vers_node (const char *name
,
9554 struct bfd_elf_version_tree
*version
,
9555 struct bfd_elf_version_deps
*deps
)
9557 struct bfd_elf_version_tree
*t
, **pp
;
9558 struct bfd_elf_version_expr
*e1
;
9563 if (link_info
.version_info
!= NULL
9564 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9566 einfo (_("%X%P: anonymous version tag cannot be combined"
9567 " with other version tags\n"));
9572 /* Make sure this node has a unique name. */
9573 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9574 if (strcmp (t
->name
, name
) == 0)
9575 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9577 lang_finalize_version_expr_head (&version
->globals
);
9578 lang_finalize_version_expr_head (&version
->locals
);
9580 /* Check the global and local match names, and make sure there
9581 aren't any duplicates. */
9583 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9585 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9587 struct bfd_elf_version_expr
*e2
;
9589 if (t
->locals
.htab
&& e1
->literal
)
9591 e2
= (struct bfd_elf_version_expr
*)
9592 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9593 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9595 if (e1
->mask
== e2
->mask
)
9596 einfo (_("%X%P: duplicate expression `%s'"
9597 " in version information\n"), e1
->pattern
);
9601 else if (!e1
->literal
)
9602 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9603 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9604 && e1
->mask
== e2
->mask
)
9605 einfo (_("%X%P: duplicate expression `%s'"
9606 " in version information\n"), e1
->pattern
);
9610 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9612 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9614 struct bfd_elf_version_expr
*e2
;
9616 if (t
->globals
.htab
&& e1
->literal
)
9618 e2
= (struct bfd_elf_version_expr
*)
9619 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9620 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9622 if (e1
->mask
== e2
->mask
)
9623 einfo (_("%X%P: duplicate expression `%s'"
9624 " in version information\n"),
9629 else if (!e1
->literal
)
9630 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9631 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9632 && e1
->mask
== e2
->mask
)
9633 einfo (_("%X%P: duplicate expression `%s'"
9634 " in version information\n"), e1
->pattern
);
9638 version
->deps
= deps
;
9639 version
->name
= name
;
9640 if (name
[0] != '\0')
9643 version
->vernum
= version_index
;
9646 version
->vernum
= 0;
9648 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9653 /* This is called when we see a version dependency. */
9655 struct bfd_elf_version_deps
*
9656 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9658 struct bfd_elf_version_deps
*ret
;
9659 struct bfd_elf_version_tree
*t
;
9661 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9664 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9666 if (strcmp (t
->name
, name
) == 0)
9668 ret
->version_needed
= t
;
9673 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9675 ret
->version_needed
= NULL
;
9680 lang_do_version_exports_section (void)
9682 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9684 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9686 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9694 contents
= (char *) xmalloc (len
);
9695 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9696 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9699 while (p
< contents
+ len
)
9701 greg
= lang_new_vers_pattern (greg
, p
, NULL
, false);
9702 p
= strchr (p
, '\0') + 1;
9705 /* Do not free the contents, as we used them creating the regex. */
9707 /* Do not include this section in the link. */
9708 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9711 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, false);
9712 lang_register_vers_node (command_line
.version_exports_section
,
9713 lang_new_vers_node (greg
, lreg
), NULL
);
9716 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9717 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9718 thrown, however, references to symbols in the origin and length fields
9719 will be pushed into the symbol table, this allows PROVIDE statements to
9720 then provide these symbols. This function is called a second time with
9721 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9722 data structures, and throw errors if missing symbols are encountered. */
9725 lang_do_memory_regions (bool update_regions_p
)
9727 lang_memory_region_type
*r
= lang_memory_region_list
;
9729 for (; r
!= NULL
; r
= r
->next
)
9733 exp_fold_tree_no_dot (r
->origin_exp
, NULL
);
9734 if (update_regions_p
)
9736 if (expld
.result
.valid_p
)
9738 r
->origin
= expld
.result
.value
;
9739 r
->current
= r
->origin
;
9742 einfo (_("%P: invalid origin for memory region %s\n"),
9748 exp_fold_tree_no_dot (r
->length_exp
, NULL
);
9749 if (update_regions_p
)
9751 if (expld
.result
.valid_p
)
9752 r
->length
= expld
.result
.value
;
9754 einfo (_("%P: invalid length for memory region %s\n"),
9762 lang_add_unique (const char *name
)
9764 struct unique_sections
*ent
;
9766 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9767 if (strcmp (ent
->name
, name
) == 0)
9770 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9771 ent
->name
= xstrdup (name
);
9772 ent
->next
= unique_section_list
;
9773 unique_section_list
= ent
;
9776 /* Append the list of dynamic symbols to the existing one. */
9779 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9780 struct bfd_elf_version_expr
*dynamic
)
9784 struct bfd_elf_version_expr
*tail
;
9785 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9787 tail
->next
= (*list_p
)->head
.list
;
9788 (*list_p
)->head
.list
= dynamic
;
9792 struct bfd_elf_dynamic_list
*d
;
9794 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9795 d
->head
.list
= dynamic
;
9796 d
->match
= lang_vers_match
;
9801 /* Append the list of C++ typeinfo dynamic symbols to the existing
9805 lang_append_dynamic_list_cpp_typeinfo (void)
9807 const char *symbols
[] =
9809 "typeinfo name for*",
9812 struct bfd_elf_version_expr
*dynamic
= NULL
;
9815 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9816 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9819 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9822 /* Append the list of C++ operator new and delete dynamic symbols to the
9826 lang_append_dynamic_list_cpp_new (void)
9828 const char *symbols
[] =
9833 struct bfd_elf_version_expr
*dynamic
= NULL
;
9836 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9837 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9840 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9843 /* Scan a space and/or comma separated string of features. */
9846 lang_ld_feature (char *str
)
9854 while (*p
== ',' || ISSPACE (*p
))
9859 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9863 if (strcasecmp (p
, "SANE_EXPR") == 0)
9864 config
.sane_expr
= true;
9866 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9872 /* Pretty print memory amount. */
9875 lang_print_memory_size (uint64_t sz
)
9877 if ((sz
& 0x3fffffff) == 0)
9878 printf ("%10" PRIu64
" GB", sz
>> 30);
9879 else if ((sz
& 0xfffff) == 0)
9880 printf ("%10" PRIu64
" MB", sz
>> 20);
9881 else if ((sz
& 0x3ff) == 0)
9882 printf ("%10" PRIu64
" KB", sz
>> 10);
9884 printf (" %10" PRIu64
" B", sz
);
9887 /* Implement --print-memory-usage: disply per region memory usage. */
9890 lang_print_memory_usage (void)
9892 lang_memory_region_type
*r
;
9894 printf ("Memory region Used Size Region Size %%age Used\n");
9895 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9897 bfd_vma used_length
= r
->current
- r
->origin
;
9899 printf ("%16s: ",r
->name_list
.name
);
9900 lang_print_memory_size (used_length
);
9901 lang_print_memory_size (r
->length
);
9905 double percent
= used_length
* 100.0 / r
->length
;
9906 printf (" %6.2f%%", percent
);