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");
2447 get_os_init_flag (lang_output_section_statement_type
* os
)
2450 switch (os
->sectype
)
2452 case readonly_section
: return SEC_READONLY
;
2453 case noload_section
: return SEC_NEVER_LOAD
;
2460 /* Make sure that all output sections mentioned in an expression are
2464 exp_init_os (etree_type
*exp
)
2466 switch (exp
->type
.node_class
)
2470 case etree_provided
:
2471 exp_init_os (exp
->assign
.src
);
2475 exp_init_os (exp
->binary
.lhs
);
2476 exp_init_os (exp
->binary
.rhs
);
2480 exp_init_os (exp
->trinary
.cond
);
2481 exp_init_os (exp
->trinary
.lhs
);
2482 exp_init_os (exp
->trinary
.rhs
);
2486 exp_init_os (exp
->assert_s
.child
);
2490 exp_init_os (exp
->unary
.child
);
2494 switch (exp
->type
.node_code
)
2499 lang_output_section_statement_type
*os
;
2501 os
= lang_output_section_find (exp
->name
.name
);
2502 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2503 init_os (os
, get_os_init_flag (os
));
2514 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2516 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2518 /* If we are only reading symbols from this object, then we want to
2519 discard all sections. */
2520 if (entry
->flags
.just_syms
)
2522 bfd_link_just_syms (abfd
, sec
, &link_info
);
2526 /* Deal with SHF_EXCLUDE ELF sections. */
2527 if (!bfd_link_relocatable (&link_info
)
2528 && (abfd
->flags
& BFD_PLUGIN
) == 0
2529 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2530 sec
->output_section
= bfd_abs_section_ptr
;
2532 if (!(abfd
->flags
& DYNAMIC
))
2533 bfd_section_already_linked (abfd
, sec
, &link_info
);
2537 /* Returns true if SECTION is one we know will be discarded based on its
2538 section flags, otherwise returns false. */
2541 lang_discard_section_p (asection
*section
)
2544 flagword flags
= section
->flags
;
2546 /* Discard sections marked with SEC_EXCLUDE. */
2547 discard
= (flags
& SEC_EXCLUDE
) != 0;
2549 /* Discard the group descriptor sections when we're finally placing the
2550 sections from within the group. */
2551 if ((flags
& SEC_GROUP
) != 0
2552 && link_info
.resolve_section_groups
)
2555 /* Discard debugging sections if we are stripping debugging
2557 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2558 && (flags
& SEC_DEBUGGING
) != 0)
2561 /* Discard non-alloc sections if we are stripping section headers. */
2562 else if (config
.no_section_header
&& (flags
& SEC_ALLOC
) == 0)
2568 /* Return TRUE if SECTION is never going to be added to output statement
2569 OUTPUT. lang_add_section() definitely won't do anything with SECTION
2570 if this returns TRUE. It may do something (or not) if this returns FALSE.
2572 Can be used as early-out to filter matches. This may set
2573 output_section of SECTION, if it was unset, to the abs section in case
2574 we discover SECTION to be always discarded. This may also give
2575 warning messages. */
2578 wont_add_section_p (asection
*section
,
2579 lang_output_section_statement_type
*output
)
2583 /* Is this section one we know should be discarded? */
2584 discard
= lang_discard_section_p (section
);
2586 /* Discard input sections which are assigned to a section named
2587 DISCARD_SECTION_NAME. */
2588 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2593 if (section
->output_section
== NULL
)
2595 /* This prevents future calls from assigning this section or
2596 warning about it again. */
2597 section
->output_section
= bfd_abs_section_ptr
;
2599 else if (bfd_is_abs_section (section
->output_section
))
2601 else if (link_info
.non_contiguous_regions_warnings
)
2602 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2603 "section `%pA' from `%pB' match /DISCARD/ clause.\n"),
2604 NULL
, section
, section
->owner
);
2609 if (section
->output_section
!= NULL
)
2611 if (!link_info
.non_contiguous_regions
)
2614 /* SECTION has already been handled in a special way
2615 (eg. LINK_ONCE): skip it. */
2616 if (bfd_is_abs_section (section
->output_section
))
2619 /* Already assigned to the same output section, do not process
2620 it again, to avoid creating loops between duplicate sections
2622 if (section
->output_section
== output
->bfd_section
)
2625 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2626 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2627 "change behaviour for section `%pA' from `%pB' (assigned to "
2628 "%pA, but additional match: %pA)\n"),
2629 NULL
, section
, section
->owner
, section
->output_section
,
2630 output
->bfd_section
);
2632 /* SECTION has already been assigned to an output section, but
2633 the user allows it to be mapped to another one in case it
2634 overflows. We'll later update the actual output section in
2635 size_input_section as appropriate. */
2641 /* The wild routines.
2643 These expand statements like *(.text) and foo.o to a list of
2644 explicit actions, like foo.o(.text), bar.o(.text) and
2645 foo.o(.text, .data). */
2647 /* Add SECTION to the output section OUTPUT. Do this by creating a
2648 lang_input_section statement which is placed at PTR. */
2651 lang_add_section (lang_statement_list_type
*ptr
,
2653 struct wildcard_list
*pattern
,
2654 struct flag_info
*sflag_info
,
2655 lang_output_section_statement_type
*output
)
2657 flagword flags
= section
->flags
;
2659 lang_input_section_type
*new_section
;
2660 bfd
*abfd
= link_info
.output_bfd
;
2662 if (wont_add_section_p (section
, output
))
2669 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2674 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2675 to an output section, because we want to be able to include a
2676 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2677 section (I don't know why we want to do this, but we do).
2678 build_link_order in ldwrite.c handles this case by turning
2679 the embedded SEC_NEVER_LOAD section into a fill. */
2680 flags
&= ~ SEC_NEVER_LOAD
;
2682 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2683 already been processed. One reason to do this is that on pe
2684 format targets, .text$foo sections go into .text and it's odd
2685 to see .text with SEC_LINK_ONCE set. */
2686 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2688 if (link_info
.resolve_section_groups
)
2689 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2691 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2693 else if (!bfd_link_relocatable (&link_info
))
2694 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2696 switch (output
->sectype
)
2698 case normal_section
:
2699 case overlay_section
:
2700 case first_overlay_section
:
2703 case noalloc_section
:
2704 flags
&= ~SEC_ALLOC
;
2706 case typed_readonly_section
:
2707 case readonly_section
:
2708 flags
|= SEC_READONLY
;
2710 case noload_section
:
2712 flags
|= SEC_NEVER_LOAD
;
2713 /* Unfortunately GNU ld has managed to evolve two different
2714 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2715 alloc, no contents section. All others get a noload, noalloc
2717 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2718 flags
&= ~SEC_HAS_CONTENTS
;
2720 flags
&= ~SEC_ALLOC
;
2724 if (output
->bfd_section
== NULL
)
2725 init_os (output
, flags
);
2727 /* If SEC_READONLY is not set in the input section, then clear
2728 it from the output section. */
2729 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2731 if (output
->bfd_section
->linker_has_input
)
2733 /* Only set SEC_READONLY flag on the first input section. */
2734 flags
&= ~ SEC_READONLY
;
2736 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2737 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2738 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2739 || ((flags
& SEC_MERGE
) != 0
2740 && output
->bfd_section
->entsize
!= section
->entsize
))
2742 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2743 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2746 output
->bfd_section
->flags
|= flags
;
2748 if (!output
->bfd_section
->linker_has_input
)
2750 output
->bfd_section
->linker_has_input
= 1;
2751 /* This must happen after flags have been updated. The output
2752 section may have been created before we saw its first input
2753 section, eg. for a data statement. */
2754 bfd_init_private_section_data (section
->owner
, section
,
2755 link_info
.output_bfd
,
2756 output
->bfd_section
,
2758 if ((flags
& SEC_MERGE
) != 0)
2759 output
->bfd_section
->entsize
= section
->entsize
;
2762 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2763 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2765 /* FIXME: This value should really be obtained from the bfd... */
2766 output
->block_value
= 128;
2769 /* When a .ctors section is placed in .init_array it must be copied
2770 in reverse order. Similarly for .dtors. Set that up. */
2771 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
2772 && ((startswith (section
->name
, ".ctors")
2773 && strcmp (output
->bfd_section
->name
, ".init_array") == 0)
2774 || (startswith (section
->name
, ".dtors")
2775 && strcmp (output
->bfd_section
->name
, ".fini_array") == 0))
2776 && (section
->name
[6] == 0 || section
->name
[6] == '.'))
2777 section
->flags
|= SEC_ELF_REVERSE_COPY
;
2779 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2780 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2782 section
->output_section
= output
->bfd_section
;
2784 if (!map_head_is_link_order
)
2786 asection
*s
= output
->bfd_section
->map_tail
.s
;
2787 output
->bfd_section
->map_tail
.s
= section
;
2788 section
->map_head
.s
= NULL
;
2789 section
->map_tail
.s
= s
;
2791 s
->map_head
.s
= section
;
2793 output
->bfd_section
->map_head
.s
= section
;
2796 /* Add a section reference to the list. */
2797 new_section
= new_stat (lang_input_section
, ptr
);
2798 new_section
->section
= section
;
2799 new_section
->pattern
= pattern
;
2802 /* Expand a wild statement for a particular FILE. SECTION may be
2803 NULL, in which case it is a wild card. This assumes that the
2804 wild statement doesn't need any sorting (of filenames or sections). */
2807 output_section_callback_nosort (lang_wild_statement_type
*ptr
,
2808 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2810 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2813 lang_output_section_statement_type
*os
;
2815 os
= (lang_output_section_statement_type
*) output
;
2817 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2818 if (unique_section_p (section
, os
))
2821 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2822 ptr
->section_flag_list
, os
);
2825 /* Check if all sections in a wild statement for a particular FILE
2829 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2830 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2832 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2835 lang_output_section_statement_type
*os
;
2837 os
= (lang_output_section_statement_type
*) output
;
2839 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2840 if (unique_section_p (section
, os
))
2843 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2844 os
->all_input_readonly
= false;
2847 /* This is passed a file name which must have been seen already and
2848 added to the statement tree. We will see if it has been opened
2849 already and had its symbols read. If not then we'll read it. */
2851 static lang_input_statement_type
*
2852 lookup_name (const char *name
)
2854 lang_input_statement_type
*search
;
2856 for (search
= (void *) input_file_chain
.head
;
2858 search
= search
->next_real_file
)
2860 /* Use the local_sym_name as the name of the file that has
2861 already been loaded as filename might have been transformed
2862 via the search directory lookup mechanism. */
2863 const char *filename
= search
->local_sym_name
;
2865 if (filename
!= NULL
2866 && filename_cmp (filename
, name
) == 0)
2872 /* Arrange to splice the input statement added by new_afile into
2873 statement_list after the current input_file_chain tail.
2874 We know input_file_chain is not an empty list, and that
2875 lookup_name was called via open_input_bfds. Later calls to
2876 lookup_name should always match an existing input_statement. */
2877 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2878 lang_statement_union_type
**after
2879 = (void *) ((char *) input_file_chain
.tail
2880 - offsetof (lang_input_statement_type
, next_real_file
)
2881 + offsetof (lang_input_statement_type
, header
.next
));
2882 lang_statement_union_type
*rest
= *after
;
2883 stat_ptr
->tail
= after
;
2884 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2885 default_target
, NULL
);
2886 *stat_ptr
->tail
= rest
;
2888 stat_ptr
->tail
= tail
;
2891 /* If we have already added this file, or this file is not real
2892 don't add this file. */
2893 if (search
->flags
.loaded
|| !search
->flags
.real
)
2896 if (!load_symbols (search
, NULL
))
2902 /* Save LIST as a list of libraries whose symbols should not be exported. */
2907 struct excluded_lib
*next
;
2909 static struct excluded_lib
*excluded_libs
;
2912 add_excluded_libs (const char *list
)
2914 const char *p
= list
, *end
;
2918 struct excluded_lib
*entry
;
2919 end
= strpbrk (p
, ",:");
2921 end
= p
+ strlen (p
);
2922 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2923 entry
->next
= excluded_libs
;
2924 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2925 memcpy (entry
->name
, p
, end
- p
);
2926 entry
->name
[end
- p
] = '\0';
2927 excluded_libs
= entry
;
2935 check_excluded_libs (bfd
*abfd
)
2937 struct excluded_lib
*lib
= excluded_libs
;
2941 int len
= strlen (lib
->name
);
2942 const char *filename
= lbasename (bfd_get_filename (abfd
));
2944 if (strcmp (lib
->name
, "ALL") == 0)
2946 abfd
->no_export
= true;
2950 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2951 && (filename
[len
] == '\0'
2952 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2953 && filename
[len
+ 2] == '\0')))
2955 abfd
->no_export
= true;
2963 /* Get the symbols for an input file. */
2966 load_symbols (lang_input_statement_type
*entry
,
2967 lang_statement_list_type
*place
)
2971 if (entry
->flags
.loaded
)
2974 ldfile_open_file (entry
);
2976 /* Do not process further if the file was missing. */
2977 if (entry
->flags
.missing_file
)
2980 if (trace_files
|| verbose
)
2981 info_msg ("%pI\n", entry
);
2983 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2984 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2987 struct lang_input_statement_flags save_flags
;
2990 err
= bfd_get_error ();
2992 /* See if the emulation has some special knowledge. */
2993 if (ldemul_unrecognized_file (entry
))
2995 if (err
== bfd_error_file_ambiguously_recognized
)
3000 if (err
== bfd_error_file_ambiguously_recognized
)
3004 einfo (_("%P: %pB: file not recognized: %E;"
3005 " matching formats:"), entry
->the_bfd
);
3006 for (p
= matching
; *p
!= NULL
; p
++)
3011 else if (err
!= bfd_error_file_not_recognized
3013 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3015 bfd_close (entry
->the_bfd
);
3016 entry
->the_bfd
= NULL
;
3018 /* Try to interpret the file as a linker script. */
3019 save_flags
= input_flags
;
3020 ldfile_open_command_file (entry
->filename
);
3022 push_stat_ptr (place
);
3023 input_flags
.add_DT_NEEDED_for_regular
3024 = entry
->flags
.add_DT_NEEDED_for_regular
;
3025 input_flags
.add_DT_NEEDED_for_dynamic
3026 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3027 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3028 input_flags
.dynamic
= entry
->flags
.dynamic
;
3030 ldfile_assumed_script
= true;
3031 parser_input
= input_script
;
3032 current_input_file
= entry
->filename
;
3034 current_input_file
= NULL
;
3035 ldfile_assumed_script
= false;
3037 /* missing_file is sticky. sysrooted will already have been
3038 restored when seeing EOF in yyparse, but no harm to restore
3040 save_flags
.missing_file
|= input_flags
.missing_file
;
3041 input_flags
= save_flags
;
3045 entry
->flags
.loaded
= true;
3050 if (ldemul_recognized_file (entry
))
3053 /* We don't call ldlang_add_file for an archive. Instead, the
3054 add_symbols entry point will call ldlang_add_file, via the
3055 add_archive_element callback, for each element of the archive
3057 switch (bfd_get_format (entry
->the_bfd
))
3063 if (!entry
->flags
.reload
)
3064 ldlang_add_file (entry
);
3068 check_excluded_libs (entry
->the_bfd
);
3070 bfd_set_usrdata (entry
->the_bfd
, entry
);
3071 if (entry
->flags
.whole_archive
)
3079 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3084 if (!bfd_check_format (member
, bfd_object
))
3086 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3087 entry
->the_bfd
, member
);
3092 if (!(*link_info
.callbacks
3093 ->add_archive_element
) (&link_info
, member
,
3094 "--whole-archive", &subsbfd
))
3097 /* Potentially, the add_archive_element hook may have set a
3098 substitute BFD for us. */
3099 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3101 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3106 entry
->flags
.loaded
= loaded
;
3112 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3113 entry
->flags
.loaded
= true;
3115 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3117 return entry
->flags
.loaded
;
3120 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3121 may be NULL, indicating that it is a wildcard. Separate
3122 lang_input_section statements are created for each part of the
3123 expansion; they are added after the wild statement S. OUTPUT is
3124 the output section. */
3127 wild (lang_wild_statement_type
*s
,
3128 const char *target ATTRIBUTE_UNUSED
,
3129 lang_output_section_statement_type
*output
)
3131 struct wildcard_list
*sec
;
3133 if (s
->filenames_sorted
|| s
->any_specs_sorted
)
3135 lang_section_bst_type
*tree
;
3137 walk_wild (s
, output_section_callback_sort
, output
);
3142 output_section_callback_tree_to_list (s
, tree
, output
);
3144 s
->rightmost
= &s
->tree
;
3148 walk_wild (s
, output_section_callback_nosort
, output
);
3150 if (default_common_section
== NULL
)
3151 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3152 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3154 /* Remember the section that common is going to in case we
3155 later get something which doesn't know where to put it. */
3156 default_common_section
= output
;
3161 /* Return TRUE iff target is the sought target. */
3164 get_target (const bfd_target
*target
, void *data
)
3166 const char *sought
= (const char *) data
;
3168 return strcmp (target
->name
, sought
) == 0;
3171 /* Like strcpy() but convert to lower case as well. */
3174 stricpy (char *dest
, const char *src
)
3178 while ((c
= *src
++) != 0)
3179 *dest
++ = TOLOWER (c
);
3184 /* Remove the first occurrence of needle (if any) in haystack
3188 strcut (char *haystack
, const char *needle
)
3190 haystack
= strstr (haystack
, needle
);
3196 for (src
= haystack
+ strlen (needle
); *src
;)
3197 *haystack
++ = *src
++;
3203 /* Compare two target format name strings.
3204 Return a value indicating how "similar" they are. */
3207 name_compare (const char *first
, const char *second
)
3213 copy1
= (char *) xmalloc (strlen (first
) + 1);
3214 copy2
= (char *) xmalloc (strlen (second
) + 1);
3216 /* Convert the names to lower case. */
3217 stricpy (copy1
, first
);
3218 stricpy (copy2
, second
);
3220 /* Remove size and endian strings from the name. */
3221 strcut (copy1
, "big");
3222 strcut (copy1
, "little");
3223 strcut (copy2
, "big");
3224 strcut (copy2
, "little");
3226 /* Return a value based on how many characters match,
3227 starting from the beginning. If both strings are
3228 the same then return 10 * their length. */
3229 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3230 if (copy1
[result
] == 0)
3242 /* Set by closest_target_match() below. */
3243 static const bfd_target
*winner
;
3245 /* Scan all the valid bfd targets looking for one that has the endianness
3246 requirement that was specified on the command line, and is the nearest
3247 match to the original output target. */
3250 closest_target_match (const bfd_target
*target
, void *data
)
3252 const bfd_target
*original
= (const bfd_target
*) data
;
3254 if (command_line
.endian
== ENDIAN_BIG
3255 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3258 if (command_line
.endian
== ENDIAN_LITTLE
3259 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3262 /* Must be the same flavour. */
3263 if (target
->flavour
!= original
->flavour
)
3266 /* Ignore generic big and little endian elf vectors. */
3267 if (strcmp (target
->name
, "elf32-big") == 0
3268 || strcmp (target
->name
, "elf64-big") == 0
3269 || strcmp (target
->name
, "elf32-little") == 0
3270 || strcmp (target
->name
, "elf64-little") == 0)
3273 /* If we have not found a potential winner yet, then record this one. */
3280 /* Oh dear, we now have two potential candidates for a successful match.
3281 Compare their names and choose the better one. */
3282 if (name_compare (target
->name
, original
->name
)
3283 > name_compare (winner
->name
, original
->name
))
3286 /* Keep on searching until wqe have checked them all. */
3290 /* Return the BFD target format of the first input file. */
3293 get_first_input_target (void)
3295 const char *target
= NULL
;
3297 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3299 if (s
->header
.type
== lang_input_statement_enum
3302 ldfile_open_file (s
);
3304 if (s
->the_bfd
!= NULL
3305 && bfd_check_format (s
->the_bfd
, bfd_object
))
3307 target
= bfd_get_target (s
->the_bfd
);
3319 lang_get_output_target (void)
3323 /* Has the user told us which output format to use? */
3324 if (output_target
!= NULL
)
3325 return output_target
;
3327 /* No - has the current target been set to something other than
3329 if (current_target
!= default_target
&& current_target
!= NULL
)
3330 return current_target
;
3332 /* No - can we determine the format of the first input file? */
3333 target
= get_first_input_target ();
3337 /* Failed - use the default output target. */
3338 return default_target
;
3341 /* Open the output file. */
3344 open_output (const char *name
)
3346 lang_input_statement_type
*f
;
3347 char *out
= lrealpath (name
);
3349 for (f
= (void *) input_file_chain
.head
;
3351 f
= f
->next_real_file
)
3354 char *in
= lrealpath (f
->local_sym_name
);
3355 if (filename_cmp (in
, out
) == 0)
3356 einfo (_("%F%P: input file '%s' is the same as output file\n"),
3362 output_target
= lang_get_output_target ();
3364 /* Has the user requested a particular endianness on the command
3366 if (command_line
.endian
!= ENDIAN_UNSET
)
3368 /* Get the chosen target. */
3369 const bfd_target
*target
3370 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3372 /* If the target is not supported, we cannot do anything. */
3375 enum bfd_endian desired_endian
;
3377 if (command_line
.endian
== ENDIAN_BIG
)
3378 desired_endian
= BFD_ENDIAN_BIG
;
3380 desired_endian
= BFD_ENDIAN_LITTLE
;
3382 /* See if the target has the wrong endianness. This should
3383 not happen if the linker script has provided big and
3384 little endian alternatives, but some scrips don't do
3386 if (target
->byteorder
!= desired_endian
)
3388 /* If it does, then see if the target provides
3389 an alternative with the correct endianness. */
3390 if (target
->alternative_target
!= NULL
3391 && (target
->alternative_target
->byteorder
== desired_endian
))
3392 output_target
= target
->alternative_target
->name
;
3395 /* Try to find a target as similar as possible to
3396 the default target, but which has the desired
3397 endian characteristic. */
3398 bfd_iterate_over_targets (closest_target_match
,
3401 /* Oh dear - we could not find any targets that
3402 satisfy our requirements. */
3404 einfo (_("%P: warning: could not find any targets"
3405 " that match endianness requirement\n"));
3407 output_target
= winner
->name
;
3413 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3415 if (link_info
.output_bfd
== NULL
)
3417 if (bfd_get_error () == bfd_error_invalid_target
)
3418 einfo (_("%F%P: target %s not found\n"), output_target
);
3420 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3423 delete_output_file_on_failure
= true;
3425 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3426 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3427 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3428 ldfile_output_architecture
,
3429 ldfile_output_machine
))
3430 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3432 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3433 if (link_info
.hash
== NULL
)
3434 einfo (_("%F%P: can not create hash table: %E\n"));
3436 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3440 ldlang_open_output (lang_statement_union_type
*statement
)
3442 switch (statement
->header
.type
)
3444 case lang_output_statement_enum
:
3445 ASSERT (link_info
.output_bfd
== NULL
);
3446 open_output (statement
->output_statement
.name
);
3447 ldemul_set_output_arch ();
3448 if (config
.magic_demand_paged
3449 && !bfd_link_relocatable (&link_info
))
3450 link_info
.output_bfd
->flags
|= D_PAGED
;
3452 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3453 if (config
.text_read_only
)
3454 link_info
.output_bfd
->flags
|= WP_TEXT
;
3456 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3457 if (link_info
.traditional_format
)
3458 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3460 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3461 if (config
.no_section_header
)
3462 link_info
.output_bfd
->flags
|= BFD_NO_SECTION_HEADER
;
3464 link_info
.output_bfd
->flags
&= ~BFD_NO_SECTION_HEADER
;
3467 case lang_target_statement_enum
:
3468 current_target
= statement
->target_statement
.target
;
3476 init_opb (asection
*s
)
3481 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3483 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3486 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3487 ldfile_output_machine
);
3489 while ((x
& 1) == 0)
3497 /* Open all the input files. */
3501 OPEN_BFD_NORMAL
= 0,
3505 #if BFD_SUPPORTS_PLUGINS
3506 static lang_input_statement_type
*plugin_insert
= NULL
;
3507 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3511 open_input_bfds (lang_statement_union_type
*s
,
3512 lang_output_section_statement_type
*os
,
3513 enum open_bfd_mode mode
)
3515 for (; s
!= NULL
; s
= s
->header
.next
)
3517 switch (s
->header
.type
)
3519 case lang_constructors_statement_enum
:
3520 open_input_bfds (constructor_list
.head
, os
, mode
);
3522 case lang_output_section_statement_enum
:
3523 os
= &s
->output_section_statement
;
3524 open_input_bfds (os
->children
.head
, os
, mode
);
3526 case lang_wild_statement_enum
:
3527 /* Maybe we should load the file's symbols. */
3528 if ((mode
& OPEN_BFD_RESCAN
) == 0
3529 && s
->wild_statement
.filename
3530 && !wildcardp (s
->wild_statement
.filename
)
3531 && !archive_path (s
->wild_statement
.filename
))
3532 lookup_name (s
->wild_statement
.filename
);
3533 open_input_bfds (s
->wild_statement
.children
.head
, os
, mode
);
3535 case lang_group_statement_enum
:
3537 struct bfd_link_hash_entry
*undefs
;
3538 #if BFD_SUPPORTS_PLUGINS
3539 lang_input_statement_type
*plugin_insert_save
;
3542 /* We must continually search the entries in the group
3543 until no new symbols are added to the list of undefined
3548 #if BFD_SUPPORTS_PLUGINS
3549 plugin_insert_save
= plugin_insert
;
3551 undefs
= link_info
.hash
->undefs_tail
;
3552 open_input_bfds (s
->group_statement
.children
.head
, os
,
3553 mode
| OPEN_BFD_FORCE
);
3555 while (undefs
!= link_info
.hash
->undefs_tail
3556 #if BFD_SUPPORTS_PLUGINS
3557 /* Objects inserted by a plugin, which are loaded
3558 before we hit this loop, may have added new
3560 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3565 case lang_target_statement_enum
:
3566 current_target
= s
->target_statement
.target
;
3568 case lang_input_statement_enum
:
3569 if (s
->input_statement
.flags
.real
)
3571 lang_statement_union_type
**os_tail
;
3572 lang_statement_list_type add
;
3575 s
->input_statement
.target
= current_target
;
3577 /* If we are being called from within a group, and this
3578 is an archive which has already been searched, then
3579 force it to be researched unless the whole archive
3580 has been loaded already. Do the same for a rescan.
3581 Likewise reload --as-needed shared libs. */
3582 if (mode
!= OPEN_BFD_NORMAL
3583 #if BFD_SUPPORTS_PLUGINS
3584 && ((mode
& OPEN_BFD_RESCAN
) == 0
3585 || plugin_insert
== NULL
)
3587 && s
->input_statement
.flags
.loaded
3588 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3589 && ((bfd_get_format (abfd
) == bfd_archive
3590 && !s
->input_statement
.flags
.whole_archive
)
3591 || (bfd_get_format (abfd
) == bfd_object
3592 && ((abfd
->flags
) & DYNAMIC
) != 0
3593 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3594 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3595 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3597 s
->input_statement
.flags
.loaded
= false;
3598 s
->input_statement
.flags
.reload
= true;
3601 os_tail
= lang_os_list
.tail
;
3602 lang_list_init (&add
);
3604 if (!load_symbols (&s
->input_statement
, &add
))
3605 config
.make_executable
= false;
3607 if (add
.head
!= NULL
)
3609 /* If this was a script with output sections then
3610 tack any added statements on to the end of the
3611 list. This avoids having to reorder the output
3612 section statement list. Very likely the user
3613 forgot -T, and whatever we do here will not meet
3614 naive user expectations. */
3615 if (os_tail
!= lang_os_list
.tail
)
3617 einfo (_("%P: warning: %s contains output sections;"
3618 " did you forget -T?\n"),
3619 s
->input_statement
.filename
);
3620 *stat_ptr
->tail
= add
.head
;
3621 stat_ptr
->tail
= add
.tail
;
3625 *add
.tail
= s
->header
.next
;
3626 s
->header
.next
= add
.head
;
3630 #if BFD_SUPPORTS_PLUGINS
3631 /* If we have found the point at which a plugin added new
3632 files, clear plugin_insert to enable archive rescan. */
3633 if (&s
->input_statement
== plugin_insert
)
3634 plugin_insert
= NULL
;
3637 case lang_assignment_statement_enum
:
3638 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3639 exp_fold_tree_no_dot (s
->assignment_statement
.exp
, os
);
3646 /* Exit if any of the files were missing. */
3647 if (input_flags
.missing_file
)
3651 #ifdef ENABLE_LIBCTF
3652 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3653 that happened specifically at CTF open time. */
3655 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3657 ctf_next_t
*i
= NULL
;
3662 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3664 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3668 if (err
!= ECTF_NEXT_END
)
3670 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3674 /* `err' returns errors from the error/warning iterator in particular.
3675 These never assert. But if we have an fp, that could have recorded
3676 an assertion failure: assert if it has done so. */
3677 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3680 /* Open the CTF sections in the input files with libctf: if any were opened,
3681 create a fake input file that we'll write the merged CTF data to later
3685 ldlang_open_ctf (void)
3690 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3694 /* Incoming files from the compiler have a single ctf_dict_t in them
3695 (which is presented to us by the libctf API in a ctf_archive_t
3696 wrapper): files derived from a previous relocatable link have a CTF
3697 archive containing possibly many CTF files. */
3699 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3701 if (err
!= ECTF_NOCTFDATA
)
3703 lang_ctf_errs_warnings (NULL
);
3704 einfo (_("%P: warning: CTF section in %pB not loaded; "
3705 "its types will be discarded: %s\n"), file
->the_bfd
,
3711 /* Prevent the contents of this section from being written, while
3712 requiring the section itself to be duplicated in the output, but only
3714 /* This section must exist if ctf_bfdopen() succeeded. */
3715 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3717 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3720 sect
->flags
|= SEC_EXCLUDE
;
3730 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3733 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3736 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3737 ctf_close (errfile
->the_ctf
);
3740 /* Merge together CTF sections. After this, only the symtab-dependent
3741 function and data object sections need adjustment. */
3744 lang_merge_ctf (void)
3746 asection
*output_sect
;
3752 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3754 /* If the section was discarded, don't waste time merging. */
3755 if (output_sect
== NULL
)
3757 ctf_dict_close (ctf_output
);
3760 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3762 ctf_close (file
->the_ctf
);
3763 file
->the_ctf
= NULL
;
3768 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3773 /* Takes ownership of file->the_ctf. */
3774 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3776 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3777 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3778 ctf_close (file
->the_ctf
);
3779 file
->the_ctf
= NULL
;
3784 if (!config
.ctf_share_duplicated
)
3785 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3787 flags
= CTF_LINK_SHARE_DUPLICATED
;
3788 if (!config
.ctf_variables
)
3789 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3790 if (bfd_link_relocatable (&link_info
))
3791 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3793 if (ctf_link (ctf_output
, flags
) < 0)
3795 lang_ctf_errs_warnings (ctf_output
);
3796 einfo (_("%P: warning: CTF linking failed; "
3797 "output will have no CTF section: %s\n"),
3798 ctf_errmsg (ctf_errno (ctf_output
)));
3801 output_sect
->size
= 0;
3802 output_sect
->flags
|= SEC_EXCLUDE
;
3805 /* Output any lingering errors that didn't come from ctf_link. */
3806 lang_ctf_errs_warnings (ctf_output
);
3809 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3810 the CTF, if supported. */
3813 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3815 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3818 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3820 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3822 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3825 /* Write out the CTF section. Called early, if the emulation isn't going to
3826 need to dedup against the strtab and symtab, then possibly called from the
3827 target linker code if the dedup has happened. */
3829 lang_write_ctf (int late
)
3832 asection
*output_sect
;
3839 /* Emit CTF late if this emulation says it can do so. */
3840 if (ldemul_emit_ctf_early ())
3845 if (!ldemul_emit_ctf_early ())
3849 /* Inform the emulation that all the symbols that will be received have
3852 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3856 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3859 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3860 CTF_COMPRESSION_THRESHOLD
);
3861 output_sect
->size
= output_size
;
3862 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3864 lang_ctf_errs_warnings (ctf_output
);
3865 if (!output_sect
->contents
)
3867 einfo (_("%P: warning: CTF section emission failed; "
3868 "output will have no CTF section: %s\n"),
3869 ctf_errmsg (ctf_errno (ctf_output
)));
3870 output_sect
->size
= 0;
3871 output_sect
->flags
|= SEC_EXCLUDE
;
3875 /* This also closes every CTF input file used in the link. */
3876 ctf_dict_close (ctf_output
);
3879 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3880 file
->the_ctf
= NULL
;
3883 /* Write out the CTF section late, if the emulation needs that. */
3886 ldlang_write_ctf_late (void)
3888 /* Trigger a "late call", if the emulation needs one. */
3894 ldlang_open_ctf (void)
3896 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3900 /* If built without CTF, warn and delete all CTF sections from the output.
3901 (The alternative would be to simply concatenate them, which does not
3902 yield a valid CTF section.) */
3904 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3906 einfo (_("%P: warning: CTF section in %pB not linkable: "
3907 "%P was built without support for CTF\n"), file
->the_bfd
);
3909 sect
->flags
|= SEC_EXCLUDE
;
3914 static void lang_merge_ctf (void) {}
3916 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3917 ATTRIBUTE_UNUSED
) {}
3919 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3920 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3921 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3922 void ldlang_write_ctf_late (void) {}
3925 /* Add the supplied name to the symbol table as an undefined reference.
3926 This is a two step process as the symbol table doesn't even exist at
3927 the time the ld command line is processed. First we put the name
3928 on a list, then, once the output file has been opened, transfer the
3929 name to the symbol table. */
3931 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3933 #define ldlang_undef_chain_list_head entry_symbol.next
3936 ldlang_add_undef (const char *const name
, bool cmdline ATTRIBUTE_UNUSED
)
3938 ldlang_undef_chain_list_type
*new_undef
;
3940 new_undef
= stat_alloc (sizeof (*new_undef
));
3941 new_undef
->next
= ldlang_undef_chain_list_head
;
3942 ldlang_undef_chain_list_head
= new_undef
;
3944 new_undef
->name
= xstrdup (name
);
3946 if (link_info
.output_bfd
!= NULL
)
3947 insert_undefined (new_undef
->name
);
3950 /* Insert NAME as undefined in the symbol table. */
3953 insert_undefined (const char *name
)
3955 struct bfd_link_hash_entry
*h
;
3957 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
3959 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3960 if (h
->type
== bfd_link_hash_new
)
3962 h
->type
= bfd_link_hash_undefined
;
3963 h
->u
.undef
.abfd
= NULL
;
3964 h
->non_ir_ref_regular
= true;
3965 bfd_link_add_undef (link_info
.hash
, h
);
3969 /* Run through the list of undefineds created above and place them
3970 into the linker hash table as undefined symbols belonging to the
3974 lang_place_undefineds (void)
3976 ldlang_undef_chain_list_type
*ptr
;
3978 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3979 insert_undefined (ptr
->name
);
3982 /* Mark -u symbols against garbage collection. */
3985 lang_mark_undefineds (void)
3987 ldlang_undef_chain_list_type
*ptr
;
3989 if (is_elf_hash_table (link_info
.hash
))
3990 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3992 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
3993 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, false, false, true);
3999 /* Structure used to build the list of symbols that the user has required
4002 struct require_defined_symbol
4005 struct require_defined_symbol
*next
;
4008 /* The list of symbols that the user has required be defined. */
4010 static struct require_defined_symbol
*require_defined_symbol_list
;
4012 /* Add a new symbol NAME to the list of symbols that are required to be
4016 ldlang_add_require_defined (const char *const name
)
4018 struct require_defined_symbol
*ptr
;
4020 ldlang_add_undef (name
, true);
4021 ptr
= stat_alloc (sizeof (*ptr
));
4022 ptr
->next
= require_defined_symbol_list
;
4023 ptr
->name
= strdup (name
);
4024 require_defined_symbol_list
= ptr
;
4027 /* Check that all symbols the user required to be defined, are defined,
4028 raise an error if we find a symbol that is not defined. */
4031 ldlang_check_require_defined_symbols (void)
4033 struct require_defined_symbol
*ptr
;
4035 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4037 struct bfd_link_hash_entry
*h
;
4039 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4040 false, false, true);
4042 || (h
->type
!= bfd_link_hash_defined
4043 && h
->type
!= bfd_link_hash_defweak
))
4044 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4048 /* Check for all readonly or some readwrite sections. */
4051 check_input_sections
4052 (lang_statement_union_type
*s
,
4053 lang_output_section_statement_type
*output_section_statement
)
4055 for (; s
!= NULL
; s
= s
->header
.next
)
4057 switch (s
->header
.type
)
4059 case lang_wild_statement_enum
:
4060 walk_wild (&s
->wild_statement
, check_section_callback
,
4061 output_section_statement
);
4062 if (!output_section_statement
->all_input_readonly
)
4065 case lang_constructors_statement_enum
:
4066 check_input_sections (constructor_list
.head
,
4067 output_section_statement
);
4068 if (!output_section_statement
->all_input_readonly
)
4071 case lang_group_statement_enum
:
4072 check_input_sections (s
->group_statement
.children
.head
,
4073 output_section_statement
);
4074 if (!output_section_statement
->all_input_readonly
)
4083 /* Update wildcard statements if needed. */
4086 update_wild_statements (lang_statement_union_type
*s
)
4088 struct wildcard_list
*sec
;
4090 switch (sort_section
)
4100 for (; s
!= NULL
; s
= s
->header
.next
)
4102 switch (s
->header
.type
)
4107 case lang_wild_statement_enum
:
4108 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4110 /* Don't sort .init/.fini sections. */
4111 if (strcmp (sec
->spec
.name
, ".init") != 0
4112 && strcmp (sec
->spec
.name
, ".fini") != 0)
4114 switch (sec
->spec
.sorted
)
4117 sec
->spec
.sorted
= sort_section
;
4120 if (sort_section
== by_alignment
)
4121 sec
->spec
.sorted
= by_name_alignment
;
4124 if (sort_section
== by_name
)
4125 sec
->spec
.sorted
= by_alignment_name
;
4130 s
->wild_statement
.any_specs_sorted
= true;
4134 case lang_constructors_statement_enum
:
4135 update_wild_statements (constructor_list
.head
);
4138 case lang_output_section_statement_enum
:
4139 update_wild_statements
4140 (s
->output_section_statement
.children
.head
);
4143 case lang_group_statement_enum
:
4144 update_wild_statements (s
->group_statement
.children
.head
);
4152 /* Open input files and attach to output sections. */
4155 map_input_to_output_sections
4156 (lang_statement_union_type
*s
, const char *target
,
4157 lang_output_section_statement_type
*os
)
4159 for (; s
!= NULL
; s
= s
->header
.next
)
4161 lang_output_section_statement_type
*tos
;
4163 unsigned int type
= 0;
4165 switch (s
->header
.type
)
4167 case lang_wild_statement_enum
:
4168 wild (&s
->wild_statement
, target
, os
);
4170 case lang_constructors_statement_enum
:
4171 map_input_to_output_sections (constructor_list
.head
,
4175 case lang_output_section_statement_enum
:
4176 tos
= &s
->output_section_statement
;
4177 if (tos
->constraint
== ONLY_IF_RW
4178 || tos
->constraint
== ONLY_IF_RO
)
4180 tos
->all_input_readonly
= true;
4181 check_input_sections (tos
->children
.head
, tos
);
4182 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4183 tos
->constraint
= -1;
4185 if (tos
->constraint
>= 0)
4186 map_input_to_output_sections (tos
->children
.head
,
4190 case lang_output_statement_enum
:
4192 case lang_target_statement_enum
:
4193 target
= s
->target_statement
.target
;
4195 case lang_group_statement_enum
:
4196 map_input_to_output_sections (s
->group_statement
.children
.head
,
4200 case lang_data_statement_enum
:
4201 /* Make sure that any sections mentioned in the expression
4203 exp_init_os (s
->data_statement
.exp
);
4204 /* The output section gets CONTENTS, ALLOC and LOAD, but
4205 these may be overridden by the script. */
4206 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4207 switch (os
->sectype
)
4209 case normal_section
:
4210 case overlay_section
:
4211 case first_overlay_section
:
4213 case noalloc_section
:
4214 flags
= SEC_HAS_CONTENTS
;
4216 case readonly_section
:
4217 flags
|= SEC_READONLY
;
4219 case typed_readonly_section
:
4220 flags
|= SEC_READONLY
;
4223 if (os
->sectype_value
->type
.node_class
== etree_name
4224 && os
->sectype_value
->type
.node_code
== NAME
)
4226 const char *name
= os
->sectype_value
->name
.name
;
4227 if (strcmp (name
, "SHT_PROGBITS") == 0)
4228 type
= SHT_PROGBITS
;
4229 else if (strcmp (name
, "SHT_STRTAB") == 0)
4231 else if (strcmp (name
, "SHT_NOTE") == 0)
4233 else if (strcmp (name
, "SHT_NOBITS") == 0)
4235 else if (strcmp (name
, "SHT_INIT_ARRAY") == 0)
4236 type
= SHT_INIT_ARRAY
;
4237 else if (strcmp (name
, "SHT_FINI_ARRAY") == 0)
4238 type
= SHT_FINI_ARRAY
;
4239 else if (strcmp (name
, "SHT_PREINIT_ARRAY") == 0)
4240 type
= SHT_PREINIT_ARRAY
;
4242 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4247 exp_fold_tree_no_dot (os
->sectype_value
, os
);
4248 if (expld
.result
.valid_p
)
4249 type
= expld
.result
.value
;
4251 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4255 case noload_section
:
4256 if (bfd_get_flavour (link_info
.output_bfd
)
4257 == bfd_target_elf_flavour
)
4258 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4260 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4263 if (os
->bfd_section
== NULL
)
4264 init_os (os
, flags
| SEC_READONLY
);
4266 os
->bfd_section
->flags
|= flags
;
4267 os
->bfd_section
->type
= type
;
4269 case lang_input_section_enum
:
4271 case lang_fill_statement_enum
:
4272 case lang_object_symbols_statement_enum
:
4273 case lang_reloc_statement_enum
:
4274 case lang_padding_statement_enum
:
4275 case lang_input_statement_enum
:
4276 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4280 case lang_assignment_statement_enum
:
4281 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4282 init_os (os
, get_os_init_flag (os
));
4284 /* Make sure that any sections mentioned in the assignment
4286 exp_init_os (s
->assignment_statement
.exp
);
4289 case lang_address_statement_enum
:
4290 /* Mark the specified section with the supplied address.
4291 If this section was actually a segment marker, then the
4292 directive is ignored if the linker script explicitly
4293 processed the segment marker. Originally, the linker
4294 treated segment directives (like -Ttext on the
4295 command-line) as section directives. We honor the
4296 section directive semantics for backwards compatibility;
4297 linker scripts that do not specifically check for
4298 SEGMENT_START automatically get the old semantics. */
4299 if (!s
->address_statement
.segment
4300 || !s
->address_statement
.segment
->used
)
4302 const char *name
= s
->address_statement
.section_name
;
4304 /* Create the output section statement here so that
4305 orphans with a set address will be placed after other
4306 script sections. If we let the orphan placement code
4307 place them in amongst other sections then the address
4308 will affect following script sections, which is
4309 likely to surprise naive users. */
4310 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4311 tos
->addr_tree
= s
->address_statement
.address
;
4312 if (tos
->bfd_section
== NULL
)
4316 case lang_insert_statement_enum
:
4318 case lang_input_matcher_enum
:
4324 /* An insert statement snips out all the linker statements from the
4325 start of the list and places them after the output section
4326 statement specified by the insert. This operation is complicated
4327 by the fact that we keep a doubly linked list of output section
4328 statements as well as the singly linked list of all statements.
4329 FIXME someday: Twiddling with the list not only moves statements
4330 from the user's script but also input and group statements that are
4331 built from command line object files and --start-group. We only
4332 get away with this because the list pointers used by file_chain
4333 and input_file_chain are not reordered, and processing via
4334 statement_list after this point mostly ignores input statements.
4335 One exception is the map file, where LOAD and START GROUP/END GROUP
4336 can end up looking odd. */
4339 process_insert_statements (lang_statement_union_type
**start
)
4341 lang_statement_union_type
**s
;
4342 lang_output_section_statement_type
*first_os
= NULL
;
4343 lang_output_section_statement_type
*last_os
= NULL
;
4344 lang_output_section_statement_type
*os
;
4349 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4351 /* Keep pointers to the first and last output section
4352 statement in the sequence we may be about to move. */
4353 os
= &(*s
)->output_section_statement
;
4355 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4358 /* Set constraint negative so that lang_output_section_find
4359 won't match this output section statement. At this
4360 stage in linking constraint has values in the range
4361 [-1, ONLY_IN_RW]. */
4362 last_os
->constraint
= -2 - last_os
->constraint
;
4363 if (first_os
== NULL
)
4366 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4368 /* A user might put -T between --start-group and
4369 --end-group. One way this odd construct might arise is
4370 from a wrapper around ld to change library search
4371 behaviour. For example:
4373 exec real_ld --start-group "$@" --end-group
4374 This isn't completely unreasonable so go looking inside a
4375 group statement for insert statements. */
4376 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4378 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4380 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4381 lang_output_section_statement_type
*where
;
4382 lang_statement_union_type
**ptr
;
4383 lang_statement_union_type
*first
;
4385 if (link_info
.non_contiguous_regions
)
4387 einfo (_("warning: INSERT statement in linker script is "
4388 "incompatible with --enable-non-contiguous-regions.\n"));
4391 where
= lang_output_section_find (i
->where
);
4392 if (where
!= NULL
&& i
->is_before
)
4395 where
= where
->prev
;
4396 while (where
!= NULL
&& where
->constraint
< 0);
4400 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4404 /* Deal with reordering the output section statement list. */
4405 if (last_os
!= NULL
)
4407 asection
*first_sec
, *last_sec
;
4408 struct lang_output_section_statement_struct
**next
;
4410 /* Snip out the output sections we are moving. */
4411 first_os
->prev
->next
= last_os
->next
;
4412 if (last_os
->next
== NULL
)
4414 next
= &first_os
->prev
->next
;
4415 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4418 last_os
->next
->prev
= first_os
->prev
;
4419 /* Add them in at the new position. */
4420 last_os
->next
= where
->next
;
4421 if (where
->next
== NULL
)
4423 next
= &last_os
->next
;
4424 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4427 where
->next
->prev
= last_os
;
4428 first_os
->prev
= where
;
4429 where
->next
= first_os
;
4431 /* Move the bfd sections in the same way. */
4434 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4436 os
->constraint
= -2 - os
->constraint
;
4437 if (os
->bfd_section
!= NULL
4438 && os
->bfd_section
->owner
!= NULL
)
4440 last_sec
= os
->bfd_section
;
4441 if (first_sec
== NULL
)
4442 first_sec
= last_sec
;
4447 if (last_sec
!= NULL
)
4449 asection
*sec
= where
->bfd_section
;
4451 sec
= output_prev_sec_find (where
);
4453 /* The place we want to insert must come after the
4454 sections we are moving. So if we find no
4455 section or if the section is the same as our
4456 last section, then no move is needed. */
4457 if (sec
!= NULL
&& sec
!= last_sec
)
4459 /* Trim them off. */
4460 if (first_sec
->prev
!= NULL
)
4461 first_sec
->prev
->next
= last_sec
->next
;
4463 link_info
.output_bfd
->sections
= last_sec
->next
;
4464 if (last_sec
->next
!= NULL
)
4465 last_sec
->next
->prev
= first_sec
->prev
;
4467 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4469 if (sec
->owner
== NULL
)
4470 /* SEC is the absolute section, from the
4471 first dummy output section statement. Add
4472 back the sections we trimmed off to the
4473 start of the bfd sections. */
4476 last_sec
->next
= sec
->next
;
4478 last_sec
->next
= link_info
.output_bfd
->sections
;
4479 if (last_sec
->next
!= NULL
)
4480 last_sec
->next
->prev
= last_sec
;
4482 link_info
.output_bfd
->section_last
= last_sec
;
4483 first_sec
->prev
= sec
;
4484 if (first_sec
->prev
!= NULL
)
4485 first_sec
->prev
->next
= first_sec
;
4487 link_info
.output_bfd
->sections
= first_sec
;
4492 lang_statement_union_type
*after
= (void *) where
;
4493 if (where
== &lang_os_list
.head
->output_section_statement
4494 && where
->next
== first_os
)
4496 /* PR30155. Handle a corner case where the statement
4497 list is something like the following:
4499 . .data 0x0000000000000000 0x0
4500 . [0x0000000000000000] b = .
4502 . .data 0x0000000000000000 0x0 t.o
4503 . 0x0000000000000000 0x4 LONG 0x0
4504 . INSERT BEFORE .text.start
4505 . [0x0000000000000004] a = .
4506 . .text.start 0x0000000000000000 0x0
4507 . [0x0000000000000000] c = .
4508 . OUTPUT(a.out elf64-x86-64)
4509 Here we do not want to allow insert_os_after to
4510 choose a point inside the list we are moving.
4511 That would lose the list. Instead, let
4512 insert_os_after work from the INSERT, which in this
4513 particular example will result in inserting after
4514 the assignment "a = .". */
4517 ptr
= insert_os_after (after
);
4518 /* Snip everything from the start of the list, up to and
4519 including the insert statement we are currently processing. */
4521 *start
= (*s
)->header
.next
;
4522 /* Add them back where they belong, minus the insert. */
4525 statement_list
.tail
= s
;
4532 s
= &(*s
)->header
.next
;
4535 /* Undo constraint twiddling. */
4536 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4538 os
->constraint
= -2 - os
->constraint
;
4544 /* An output section might have been removed after its statement was
4545 added. For example, ldemul_before_allocation can remove dynamic
4546 sections if they turn out to be not needed. Clean them up here. */
4549 strip_excluded_output_sections (void)
4551 lang_output_section_statement_type
*os
;
4553 /* Run lang_size_sections (if not already done). */
4554 if (expld
.phase
!= lang_mark_phase_enum
)
4556 expld
.phase
= lang_mark_phase_enum
;
4557 expld
.dataseg
.phase
= exp_seg_none
;
4558 one_lang_size_sections_pass (NULL
, false);
4559 lang_reset_memory_regions ();
4562 for (os
= (void *) lang_os_list
.head
;
4566 asection
*output_section
;
4569 if (os
->constraint
< 0)
4572 output_section
= os
->bfd_section
;
4573 if (output_section
== NULL
)
4576 exclude
= (output_section
->rawsize
== 0
4577 && (output_section
->flags
& SEC_KEEP
) == 0
4578 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4581 /* Some sections have not yet been sized, notably .gnu.version,
4582 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4583 input sections, so don't drop output sections that have such
4584 input sections unless they are also marked SEC_EXCLUDE. */
4585 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4589 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4590 if ((s
->flags
& SEC_EXCLUDE
) == 0
4591 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4592 || link_info
.emitrelocations
))
4601 /* We don't set bfd_section to NULL since bfd_section of the
4602 removed output section statement may still be used. */
4603 if (!os
->update_dot
)
4605 output_section
->flags
|= SEC_EXCLUDE
;
4606 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4607 link_info
.output_bfd
->section_count
--;
4612 /* Called from ldwrite to clear out asection.map_head and
4613 asection.map_tail for use as link_orders in ldwrite. */
4616 lang_clear_os_map (void)
4618 lang_output_section_statement_type
*os
;
4620 if (map_head_is_link_order
)
4623 for (os
= (void *) lang_os_list
.head
;
4627 asection
*output_section
;
4629 if (os
->constraint
< 0)
4632 output_section
= os
->bfd_section
;
4633 if (output_section
== NULL
)
4636 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4637 output_section
->map_head
.link_order
= NULL
;
4638 output_section
->map_tail
.link_order
= NULL
;
4641 /* Stop future calls to lang_add_section from messing with map_head
4642 and map_tail link_order fields. */
4643 map_head_is_link_order
= true;
4647 print_output_section_statement
4648 (lang_output_section_statement_type
*output_section_statement
)
4650 asection
*section
= output_section_statement
->bfd_section
;
4653 if (output_section_statement
!= abs_output_section
)
4655 minfo ("\n%s", output_section_statement
->name
);
4657 if (section
!= NULL
)
4659 print_dot
= section
->vma
;
4661 len
= strlen (output_section_statement
->name
);
4662 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4667 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4669 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4671 if (section
->vma
!= section
->lma
)
4672 minfo (_(" load address 0x%V"), section
->lma
);
4674 if (output_section_statement
->update_dot_tree
!= NULL
)
4675 exp_fold_tree (output_section_statement
->update_dot_tree
,
4676 output_section_statement
,
4677 bfd_abs_section_ptr
, &print_dot
);
4683 print_statement_list (output_section_statement
->children
.head
,
4684 output_section_statement
);
4688 print_assignment (lang_assignment_statement_type
*assignment
,
4689 lang_output_section_statement_type
*output_section
)
4695 print_spaces (SECTION_NAME_MAP_LENGTH
);
4697 if (assignment
->exp
->type
.node_class
== etree_assert
)
4700 tree
= assignment
->exp
->assert_s
.child
;
4704 const char *dst
= assignment
->exp
->assign
.dst
;
4706 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4707 tree
= assignment
->exp
;
4710 osec
= output_section
->bfd_section
;
4712 osec
= bfd_abs_section_ptr
;
4714 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4715 exp_fold_tree (tree
, output_section
, osec
, &print_dot
);
4717 expld
.result
.valid_p
= false;
4720 const char *str
= buf
;
4721 if (expld
.result
.valid_p
)
4725 if (assignment
->exp
->type
.node_class
== etree_assert
4727 || expld
.assign_name
!= NULL
)
4729 value
= expld
.result
.value
;
4731 if (expld
.result
.section
!= NULL
)
4732 value
+= expld
.result
.section
->vma
;
4736 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 2, value
);
4742 struct bfd_link_hash_entry
*h
;
4744 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4745 false, false, true);
4747 && (h
->type
== bfd_link_hash_defined
4748 || h
->type
== bfd_link_hash_defweak
))
4750 value
= h
->u
.def
.value
;
4751 value
+= h
->u
.def
.section
->output_section
->vma
;
4752 value
+= h
->u
.def
.section
->output_offset
;
4757 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 3, value
);
4761 str
= "[unresolved]";
4766 if (assignment
->exp
->type
.node_class
== etree_provide
)
4771 expld
.assign_name
= NULL
;
4773 fprintf (config
.map_file
, "%-34s", str
);
4774 exp_print_tree (assignment
->exp
);
4779 print_input_statement (lang_input_statement_type
*statm
)
4781 if (statm
->filename
!= NULL
)
4782 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4785 /* Print all symbols defined in a particular section. This is called
4786 via bfd_link_hash_traverse, or by print_all_symbols. */
4789 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4791 asection
*sec
= (asection
*) ptr
;
4793 if ((hash_entry
->type
== bfd_link_hash_defined
4794 || hash_entry
->type
== bfd_link_hash_defweak
)
4795 && sec
== hash_entry
->u
.def
.section
)
4797 print_spaces (SECTION_NAME_MAP_LENGTH
);
4799 (hash_entry
->u
.def
.value
4800 + hash_entry
->u
.def
.section
->output_offset
4801 + hash_entry
->u
.def
.section
->output_section
->vma
));
4803 minfo (" %pT\n", hash_entry
->root
.string
);
4810 hash_entry_addr_cmp (const void *a
, const void *b
)
4812 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4813 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4815 if (l
->u
.def
.value
< r
->u
.def
.value
)
4817 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4824 print_all_symbols (asection
*sec
)
4826 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4827 struct map_symbol_def
*def
;
4828 struct bfd_link_hash_entry
**entries
;
4834 *ud
->map_symbol_def_tail
= 0;
4836 /* Sort the symbols by address. */
4837 entries
= (struct bfd_link_hash_entry
**)
4838 obstack_alloc (&map_obstack
,
4839 ud
->map_symbol_def_count
* sizeof (*entries
));
4841 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4842 entries
[i
] = def
->entry
;
4844 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4845 hash_entry_addr_cmp
);
4847 /* Print the symbols. */
4848 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4849 ldemul_print_symbol (entries
[i
], sec
);
4851 obstack_free (&map_obstack
, entries
);
4854 /* Returns TRUE if SYM is a symbol suitable for printing
4855 in a linker map as a local symbol. */
4858 ld_is_local_symbol (asymbol
* sym
)
4860 const char * name
= bfd_asymbol_name (sym
);
4862 if (name
== NULL
|| *name
== 0)
4865 if (strcmp (name
, "(null)") == 0)
4868 /* Skip .Lxxx and such like. */
4869 if (bfd_is_local_label (link_info
.output_bfd
, sym
))
4872 /* FIXME: This is intended to skip ARM mapping symbols,
4873 which for some reason are not excluded by bfd_is_local_label,
4874 but maybe it is wrong for other architectures.
4875 It would be better to fix bfd_is_local_label. */
4879 /* Some local symbols, eg _GLOBAL_OFFSET_TABLE_, are present
4880 in the hash table, so do not print duplicates here. */
4881 struct bfd_link_hash_entry
* h
;
4882 h
= bfd_link_hash_lookup (link_info
.hash
, name
, false /* create */,
4883 false /* copy */, true /* follow */);
4887 /* Symbols from the plugin owned BFD will not get their own
4888 iteration of this function, but can be on the link_info
4889 list. So include them here. */
4890 if (h
->u
.def
.section
->owner
!= NULL
4891 && ((bfd_get_file_flags (h
->u
.def
.section
->owner
) & (BFD_LINKER_CREATED
| BFD_PLUGIN
))
4892 == (BFD_LINKER_CREATED
| BFD_PLUGIN
)))
4898 /* Print information about an input section to the map file. */
4901 print_input_section (asection
*i
, bool is_discarded
)
4903 bfd_size_type size
= i
->size
;
4909 minfo (" %s", i
->name
);
4911 len
= 1 + strlen (i
->name
);
4912 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4917 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4919 if (i
->output_section
!= NULL
4920 && i
->output_section
->owner
== link_info
.output_bfd
)
4921 addr
= i
->output_section
->vma
+ i
->output_offset
;
4930 bfd_sprintf_vma (link_info
.output_bfd
, buf
, addr
);
4931 minfo ("0x%s %W %pB\n", buf
, TO_ADDR (size
), i
->owner
);
4933 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4935 len
= SECTION_NAME_MAP_LENGTH
+ 3 + strlen (buf
);
4937 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4940 if (i
->output_section
!= NULL
4941 && i
->output_section
->owner
== link_info
.output_bfd
)
4943 if (link_info
.reduce_memory_overheads
)
4944 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4946 print_all_symbols (i
);
4948 /* Update print_dot, but make sure that we do not move it
4949 backwards - this could happen if we have overlays and a
4950 later overlay is shorter than an earier one. */
4951 if (addr
+ TO_ADDR (size
) > print_dot
)
4952 print_dot
= addr
+ TO_ADDR (size
);
4954 if (config
.print_map_locals
)
4956 long storage_needed
;
4958 /* FIXME: It would be better to cache this table, rather
4959 than recreating it for each output section. */
4960 /* FIXME: This call is not working for non-ELF based targets.
4962 storage_needed
= bfd_get_symtab_upper_bound (link_info
.output_bfd
);
4963 if (storage_needed
> 0)
4965 asymbol
** symbol_table
;
4966 long number_of_symbols
;
4969 symbol_table
= xmalloc (storage_needed
);
4970 number_of_symbols
= bfd_canonicalize_symtab (link_info
.output_bfd
, symbol_table
);
4972 for (j
= 0; j
< number_of_symbols
; j
++)
4974 asymbol
* sym
= symbol_table
[j
];
4975 bfd_vma sym_addr
= sym
->value
+ i
->output_section
->vma
;
4977 if (sym
->section
== i
->output_section
4978 && (sym
->flags
& BSF_LOCAL
) != 0
4980 && sym_addr
< print_dot
4981 && ld_is_local_symbol (sym
))
4983 print_spaces (SECTION_NAME_MAP_LENGTH
);
4984 minfo ("0x%V (local) %s\n", sym_addr
, bfd_asymbol_name (sym
));
4988 free (symbol_table
);
4995 print_fill_statement (lang_fill_statement_type
*fill
)
4999 fputs (" FILL mask 0x", config
.map_file
);
5000 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
5001 fprintf (config
.map_file
, "%02x", *p
);
5002 fputs ("\n", config
.map_file
);
5006 print_data_statement (lang_data_statement_type
*data
)
5012 init_opb (data
->output_section
);
5013 print_spaces (SECTION_NAME_MAP_LENGTH
);
5015 addr
= data
->output_offset
;
5016 if (data
->output_section
!= NULL
)
5017 addr
+= data
->output_section
->vma
;
5045 if (size
< TO_SIZE ((unsigned) 1))
5046 size
= TO_SIZE ((unsigned) 1);
5047 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
5049 if (data
->exp
->type
.node_class
!= etree_value
)
5052 exp_print_tree (data
->exp
);
5057 print_dot
= addr
+ TO_ADDR (size
);
5060 /* Print an address statement. These are generated by options like
5064 print_address_statement (lang_address_statement_type
*address
)
5066 minfo (_("Address of section %s set to "), address
->section_name
);
5067 exp_print_tree (address
->address
);
5071 /* Print a reloc statement. */
5074 print_reloc_statement (lang_reloc_statement_type
*reloc
)
5079 init_opb (reloc
->output_section
);
5080 print_spaces (SECTION_NAME_MAP_LENGTH
);
5082 addr
= reloc
->output_offset
;
5083 if (reloc
->output_section
!= NULL
)
5084 addr
+= reloc
->output_section
->vma
;
5086 size
= bfd_get_reloc_size (reloc
->howto
);
5088 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
5090 if (reloc
->name
!= NULL
)
5091 minfo ("%s+", reloc
->name
);
5093 minfo ("%s+", reloc
->section
->name
);
5095 exp_print_tree (reloc
->addend_exp
);
5099 print_dot
= addr
+ TO_ADDR (size
);
5103 print_padding_statement (lang_padding_statement_type
*s
)
5108 init_opb (s
->output_section
);
5111 len
= sizeof " *fill*" - 1;
5112 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
5114 addr
= s
->output_offset
;
5115 if (s
->output_section
!= NULL
)
5116 addr
+= s
->output_section
->vma
;
5117 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5119 if (s
->fill
->size
!= 0)
5123 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5124 fprintf (config
.map_file
, "%02x", *p
);
5129 print_dot
= addr
+ TO_ADDR (s
->size
);
5133 print_wild_statement (lang_wild_statement_type
*w
,
5134 lang_output_section_statement_type
*os
)
5136 struct wildcard_list
*sec
;
5140 if (w
->exclude_name_list
)
5143 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5144 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5145 minfo (" %s", tmp
->name
);
5149 if (w
->filenames_sorted
)
5150 minfo ("SORT_BY_NAME(");
5151 if (w
->filename
!= NULL
)
5152 minfo ("%s", w
->filename
);
5155 if (w
->filenames_sorted
)
5159 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5161 int closing_paren
= 0;
5163 switch (sec
->spec
.sorted
)
5169 minfo ("SORT_BY_NAME(");
5174 minfo ("SORT_BY_ALIGNMENT(");
5178 case by_name_alignment
:
5179 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5183 case by_alignment_name
:
5184 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5189 minfo ("SORT_NONE(");
5193 case by_init_priority
:
5194 minfo ("SORT_BY_INIT_PRIORITY(");
5199 if (sec
->spec
.exclude_name_list
!= NULL
)
5202 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5203 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5204 minfo (" %s", tmp
->name
);
5207 if (sec
->spec
.name
!= NULL
)
5208 minfo ("%s", sec
->spec
.name
);
5211 for (;closing_paren
> 0; closing_paren
--)
5220 print_statement_list (w
->children
.head
, os
);
5223 /* Print a group statement. */
5226 print_group (lang_group_statement_type
*s
,
5227 lang_output_section_statement_type
*os
)
5229 fprintf (config
.map_file
, "START GROUP\n");
5230 print_statement_list (s
->children
.head
, os
);
5231 fprintf (config
.map_file
, "END GROUP\n");
5234 /* Print the list of statements in S.
5235 This can be called for any statement type. */
5238 print_statement_list (lang_statement_union_type
*s
,
5239 lang_output_section_statement_type
*os
)
5243 print_statement (s
, os
);
5248 /* Print the first statement in statement list S.
5249 This can be called for any statement type. */
5252 print_statement (lang_statement_union_type
*s
,
5253 lang_output_section_statement_type
*os
)
5255 switch (s
->header
.type
)
5258 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5261 case lang_constructors_statement_enum
:
5262 if (constructor_list
.head
!= NULL
)
5264 if (constructors_sorted
)
5265 minfo (" SORT (CONSTRUCTORS)\n");
5267 minfo (" CONSTRUCTORS\n");
5268 print_statement_list (constructor_list
.head
, os
);
5271 case lang_wild_statement_enum
:
5272 print_wild_statement (&s
->wild_statement
, os
);
5274 case lang_address_statement_enum
:
5275 print_address_statement (&s
->address_statement
);
5277 case lang_object_symbols_statement_enum
:
5278 minfo (" CREATE_OBJECT_SYMBOLS\n");
5280 case lang_fill_statement_enum
:
5281 print_fill_statement (&s
->fill_statement
);
5283 case lang_data_statement_enum
:
5284 print_data_statement (&s
->data_statement
);
5286 case lang_reloc_statement_enum
:
5287 print_reloc_statement (&s
->reloc_statement
);
5289 case lang_input_section_enum
:
5290 print_input_section (s
->input_section
.section
, false);
5292 case lang_padding_statement_enum
:
5293 print_padding_statement (&s
->padding_statement
);
5295 case lang_output_section_statement_enum
:
5296 print_output_section_statement (&s
->output_section_statement
);
5298 case lang_assignment_statement_enum
:
5299 print_assignment (&s
->assignment_statement
, os
);
5301 case lang_target_statement_enum
:
5302 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5304 case lang_output_statement_enum
:
5305 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5306 if (output_target
!= NULL
)
5307 minfo (" %s", output_target
);
5310 case lang_input_statement_enum
:
5311 print_input_statement (&s
->input_statement
);
5313 case lang_group_statement_enum
:
5314 print_group (&s
->group_statement
, os
);
5316 case lang_insert_statement_enum
:
5317 minfo ("INSERT %s %s\n",
5318 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5319 s
->insert_statement
.where
);
5325 print_statements (void)
5327 print_statement_list (statement_list
.head
, abs_output_section
);
5330 /* Print the first N statements in statement list S to STDERR.
5331 If N == 0, nothing is printed.
5332 If N < 0, the entire list is printed.
5333 Intended to be called from GDB. */
5336 dprint_statement (lang_statement_union_type
*s
, int n
)
5338 FILE *map_save
= config
.map_file
;
5340 config
.map_file
= stderr
;
5343 print_statement_list (s
, abs_output_section
);
5346 while (s
&& --n
>= 0)
5348 print_statement (s
, abs_output_section
);
5353 config
.map_file
= map_save
;
5357 insert_pad (lang_statement_union_type
**ptr
,
5359 bfd_size_type alignment_needed
,
5360 asection
*output_section
,
5363 static fill_type zero_fill
;
5364 lang_statement_union_type
*pad
= NULL
;
5366 if (ptr
!= &statement_list
.head
)
5367 pad
= ((lang_statement_union_type
*)
5368 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5370 && pad
->header
.type
== lang_padding_statement_enum
5371 && pad
->padding_statement
.output_section
== output_section
)
5373 /* Use the existing pad statement. */
5375 else if ((pad
= *ptr
) != NULL
5376 && pad
->header
.type
== lang_padding_statement_enum
5377 && pad
->padding_statement
.output_section
== output_section
)
5379 /* Use the existing pad statement. */
5383 /* Make a new padding statement, linked into existing chain. */
5384 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5385 pad
->header
.next
= *ptr
;
5387 pad
->header
.type
= lang_padding_statement_enum
;
5388 pad
->padding_statement
.output_section
= output_section
;
5391 pad
->padding_statement
.fill
= fill
;
5393 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5394 pad
->padding_statement
.size
= alignment_needed
;
5395 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5396 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5397 - output_section
->vma
);
5400 /* Work out how much this section will move the dot point. */
5404 (lang_statement_union_type
**this_ptr
,
5405 lang_output_section_statement_type
*output_section_statement
,
5410 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5411 asection
*i
= is
->section
;
5412 asection
*o
= output_section_statement
->bfd_section
;
5415 if (link_info
.non_contiguous_regions
)
5417 /* If the input section I has already been successfully assigned
5418 to an output section other than O, don't bother with it and
5419 let the caller remove it from the list. Keep processing in
5420 case we have already handled O, because the repeated passes
5421 have reinitialized its size. */
5422 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5429 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5430 i
->output_offset
= i
->vma
- o
->vma
;
5431 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5432 || output_section_statement
->ignored
)
5433 i
->output_offset
= dot
- o
->vma
;
5436 bfd_size_type alignment_needed
;
5438 /* Align this section first to the input sections requirement,
5439 then to the output section's requirement. If this alignment
5440 is greater than any seen before, then record it too. Perform
5441 the alignment by inserting a magic 'padding' statement. */
5443 if (output_section_statement
->subsection_alignment
!= NULL
)
5445 = exp_get_power (output_section_statement
->subsection_alignment
,
5446 output_section_statement
,
5447 "subsection alignment");
5449 if (o
->alignment_power
< i
->alignment_power
)
5450 o
->alignment_power
= i
->alignment_power
;
5452 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5454 if (alignment_needed
!= 0)
5456 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5457 dot
+= alignment_needed
;
5460 if (link_info
.non_contiguous_regions
)
5462 /* If I would overflow O, let the caller remove I from the
5464 if (output_section_statement
->region
)
5466 bfd_vma end
= output_section_statement
->region
->origin
5467 + output_section_statement
->region
->length
;
5469 if (dot
+ TO_ADDR (i
->size
) > end
)
5471 if (i
->flags
& SEC_LINKER_CREATED
)
5472 einfo (_("%F%P: Output section `%pA' not large enough for "
5473 "the linker-created stubs section `%pA'.\n"),
5474 i
->output_section
, i
);
5476 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5477 einfo (_("%F%P: Relaxation not supported with "
5478 "--enable-non-contiguous-regions (section `%pA' "
5479 "would overflow `%pA' after it changed size).\n"),
5480 i
, i
->output_section
);
5484 i
->output_section
= NULL
;
5490 /* Remember where in the output section this input section goes. */
5491 i
->output_offset
= dot
- o
->vma
;
5493 /* Mark how big the output section must be to contain this now. */
5494 dot
+= TO_ADDR (i
->size
);
5495 if (!(o
->flags
& SEC_FIXED_SIZE
))
5496 o
->size
= TO_SIZE (dot
- o
->vma
);
5498 if (link_info
.non_contiguous_regions
)
5500 /* Record that I was successfully assigned to O, and update
5501 its actual output section too. */
5502 i
->already_assigned
= o
;
5503 i
->output_section
= o
;
5517 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5519 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5520 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5522 if (sec1
->lma
< sec2
->lma
)
5524 else if (sec1
->lma
> sec2
->lma
)
5526 else if (sec1
->id
< sec2
->id
)
5528 else if (sec1
->id
> sec2
->id
)
5535 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5537 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5538 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5540 if (sec1
->vma
< sec2
->vma
)
5542 else if (sec1
->vma
> sec2
->vma
)
5544 else if (sec1
->id
< sec2
->id
)
5546 else if (sec1
->id
> sec2
->id
)
5552 #define IS_TBSS(s) \
5553 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5555 #define IGNORE_SECTION(s) \
5556 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5558 /* Check to see if any allocated sections overlap with other allocated
5559 sections. This can happen if a linker script specifies the output
5560 section addresses of the two sections. Also check whether any memory
5561 region has overflowed. */
5564 lang_check_section_addresses (void)
5567 struct check_sec
*sections
;
5572 bfd_vma p_start
= 0;
5574 lang_memory_region_type
*m
;
5577 /* Detect address space overflow on allocated sections. */
5578 addr_mask
= ((bfd_vma
) 1 <<
5579 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5580 addr_mask
= (addr_mask
<< 1) + 1;
5581 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5582 if ((s
->flags
& SEC_ALLOC
) != 0)
5584 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5585 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5586 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5590 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5591 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5592 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5597 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5600 count
= bfd_count_sections (link_info
.output_bfd
);
5601 sections
= XNEWVEC (struct check_sec
, count
);
5603 /* Scan all sections in the output list. */
5605 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5607 if (IGNORE_SECTION (s
)
5611 sections
[count
].sec
= s
;
5612 sections
[count
].warned
= false;
5622 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5624 /* First check section LMAs. There should be no overlap of LMAs on
5625 loadable sections, even with overlays. */
5626 for (p
= NULL
, i
= 0; i
< count
; i
++)
5628 s
= sections
[i
].sec
;
5630 if ((s
->flags
& SEC_LOAD
) != 0)
5633 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5635 /* Look for an overlap. We have sorted sections by lma, so
5636 we know that s_start >= p_start. Besides the obvious
5637 case of overlap when the current section starts before
5638 the previous one ends, we also must have overlap if the
5639 previous section wraps around the address space. */
5641 && (s_start
<= p_end
5642 || p_end
< p_start
))
5644 einfo (_("%X%P: section %s LMA [%V,%V]"
5645 " overlaps section %s LMA [%V,%V]\n"),
5646 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5647 sections
[i
].warned
= true;
5655 /* If any non-zero size allocated section (excluding tbss) starts at
5656 exactly the same VMA as another such section, then we have
5657 overlays. Overlays generated by the OVERLAY keyword will have
5658 this property. It is possible to intentionally generate overlays
5659 that fail this test, but it would be unusual. */
5660 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5662 p_start
= sections
[0].sec
->vma
;
5663 for (i
= 1; i
< count
; i
++)
5665 s_start
= sections
[i
].sec
->vma
;
5666 if (p_start
== s_start
)
5674 /* Now check section VMAs if no overlays were detected. */
5677 for (p
= NULL
, i
= 0; i
< count
; i
++)
5679 s
= sections
[i
].sec
;
5682 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5685 && !sections
[i
].warned
5686 && (s_start
<= p_end
5687 || p_end
< p_start
))
5688 einfo (_("%X%P: section %s VMA [%V,%V]"
5689 " overlaps section %s VMA [%V,%V]\n"),
5690 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5699 /* If any memory region has overflowed, report by how much.
5700 We do not issue this diagnostic for regions that had sections
5701 explicitly placed outside their bounds; os_region_check's
5702 diagnostics are adequate for that case.
5704 FIXME: It is conceivable that m->current - (m->origin + m->length)
5705 might overflow a 32-bit integer. There is, alas, no way to print
5706 a bfd_vma quantity in decimal. */
5707 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5708 if (m
->had_full_message
)
5710 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5711 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5712 "%X%P: region `%s' overflowed by %lu bytes\n",
5714 m
->name_list
.name
, over
);
5718 /* Make sure the new address is within the region. We explicitly permit the
5719 current address to be at the exact end of the region when the address is
5720 non-zero, in case the region is at the end of addressable memory and the
5721 calculation wraps around. */
5724 os_region_check (lang_output_section_statement_type
*os
,
5725 lang_memory_region_type
*region
,
5729 if ((region
->current
< region
->origin
5730 || (region
->current
- region
->origin
> region
->length
))
5731 && ((region
->current
!= region
->origin
+ region
->length
)
5736 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5737 " is not within region `%s'\n"),
5739 os
->bfd_section
->owner
,
5740 os
->bfd_section
->name
,
5741 region
->name_list
.name
);
5743 else if (!region
->had_full_message
)
5745 region
->had_full_message
= true;
5747 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5748 os
->bfd_section
->owner
,
5749 os
->bfd_section
->name
,
5750 region
->name_list
.name
);
5756 ldlang_check_relro_region (lang_statement_union_type
*s
)
5758 seg_align_type
*seg
= &expld
.dataseg
;
5760 if (seg
->relro
== exp_seg_relro_start
)
5762 if (!seg
->relro_start_stat
)
5763 seg
->relro_start_stat
= s
;
5766 ASSERT (seg
->relro_start_stat
== s
);
5769 else if (seg
->relro
== exp_seg_relro_end
)
5771 if (!seg
->relro_end_stat
)
5772 seg
->relro_end_stat
= s
;
5775 ASSERT (seg
->relro_end_stat
== s
);
5780 /* Set the sizes for all the output sections. */
5783 lang_size_sections_1
5784 (lang_statement_union_type
**prev
,
5785 lang_output_section_statement_type
*current_os
,
5791 lang_statement_union_type
*s
;
5792 lang_statement_union_type
*prev_s
= NULL
;
5793 bool removed_prev_s
= false;
5794 lang_output_section_statement_type
*os
= current_os
;
5796 /* Size up the sections from their constituent parts. */
5797 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5799 bool removed
= false;
5801 switch (s
->header
.type
)
5803 case lang_output_section_statement_enum
:
5805 bfd_vma newdot
, after
, dotdelta
;
5806 lang_memory_region_type
*r
;
5807 int section_alignment
= 0;
5809 os
= &s
->output_section_statement
;
5810 init_opb (os
->bfd_section
);
5811 if (os
->constraint
== -1)
5814 /* FIXME: We shouldn't need to zero section vmas for ld -r
5815 here, in lang_insert_orphan, or in the default linker scripts.
5816 This is covering for coff backend linker bugs. See PR6945. */
5817 if (os
->addr_tree
== NULL
5818 && bfd_link_relocatable (&link_info
)
5819 && (bfd_get_flavour (link_info
.output_bfd
)
5820 == bfd_target_coff_flavour
))
5821 os
->addr_tree
= exp_intop (0);
5822 if (os
->addr_tree
!= NULL
)
5824 exp_fold_tree (os
->addr_tree
, os
, bfd_abs_section_ptr
, &dot
);
5826 if (expld
.result
.valid_p
)
5828 dot
= expld
.result
.value
;
5829 if (expld
.result
.section
!= NULL
)
5830 dot
+= expld
.result
.section
->vma
;
5832 else if (expld
.phase
!= lang_mark_phase_enum
)
5833 einfo (_("%F%P:%pS: non constant or forward reference"
5834 " address expression for section %s\n"),
5835 os
->addr_tree
, os
->name
);
5838 if (os
->bfd_section
== NULL
)
5839 /* This section was removed or never actually created. */
5842 /* If this is a COFF shared library section, use the size and
5843 address from the input section. FIXME: This is COFF
5844 specific; it would be cleaner if there were some other way
5845 to do this, but nothing simple comes to mind. */
5846 if (((bfd_get_flavour (link_info
.output_bfd
)
5847 == bfd_target_ecoff_flavour
)
5848 || (bfd_get_flavour (link_info
.output_bfd
)
5849 == bfd_target_coff_flavour
))
5850 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5854 if (os
->children
.head
== NULL
5855 || os
->children
.head
->header
.next
!= NULL
5856 || (os
->children
.head
->header
.type
5857 != lang_input_section_enum
))
5858 einfo (_("%X%P: internal error on COFF shared library"
5859 " section %s\n"), os
->name
);
5861 input
= os
->children
.head
->input_section
.section
;
5862 bfd_set_section_vma (os
->bfd_section
,
5863 bfd_section_vma (input
));
5864 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5865 os
->bfd_section
->size
= input
->size
;
5871 if (bfd_is_abs_section (os
->bfd_section
))
5873 /* No matter what happens, an abs section starts at zero. */
5874 ASSERT (os
->bfd_section
->vma
== 0);
5878 if (os
->addr_tree
== NULL
)
5880 /* No address specified for this section, get one
5881 from the region specification. */
5882 if (os
->region
== NULL
5883 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5884 && os
->region
->name_list
.name
[0] == '*'
5885 && strcmp (os
->region
->name_list
.name
,
5886 DEFAULT_MEMORY_REGION
) == 0))
5888 os
->region
= lang_memory_default (os
->bfd_section
);
5891 /* If a loadable section is using the default memory
5892 region, and some non default memory regions were
5893 defined, issue an error message. */
5895 && !IGNORE_SECTION (os
->bfd_section
)
5896 && !bfd_link_relocatable (&link_info
)
5898 && strcmp (os
->region
->name_list
.name
,
5899 DEFAULT_MEMORY_REGION
) == 0
5900 && lang_memory_region_list
!= NULL
5901 && (strcmp (lang_memory_region_list
->name_list
.name
,
5902 DEFAULT_MEMORY_REGION
) != 0
5903 || lang_memory_region_list
->next
!= NULL
)
5904 && lang_sizing_iteration
== 1)
5906 /* By default this is an error rather than just a
5907 warning because if we allocate the section to the
5908 default memory region we can end up creating an
5909 excessively large binary, or even seg faulting when
5910 attempting to perform a negative seek. See
5911 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5912 for an example of this. This behaviour can be
5913 overridden by the using the --no-check-sections
5915 if (command_line
.check_section_addresses
)
5916 einfo (_("%F%P: error: no memory region specified"
5917 " for loadable section `%s'\n"),
5918 bfd_section_name (os
->bfd_section
));
5920 einfo (_("%P: warning: no memory region specified"
5921 " for loadable section `%s'\n"),
5922 bfd_section_name (os
->bfd_section
));
5925 newdot
= os
->region
->current
;
5926 section_alignment
= os
->bfd_section
->alignment_power
;
5929 section_alignment
= exp_get_power (os
->section_alignment
, os
,
5930 "section alignment");
5932 /* Align to what the section needs. */
5933 if (section_alignment
> 0)
5935 bfd_vma savedot
= newdot
;
5938 newdot
= align_power (newdot
, section_alignment
);
5939 dotdelta
= newdot
- savedot
;
5941 if (lang_sizing_iteration
== 1)
5943 else if (lang_sizing_iteration
> 1)
5945 /* Only report adjustments that would change
5946 alignment from what we have already reported. */
5947 diff
= newdot
- os
->bfd_section
->vma
;
5948 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5952 && (config
.warn_section_align
5953 || os
->addr_tree
!= NULL
))
5954 einfo (_("%P: warning: "
5955 "start of section %s changed by %ld\n"),
5956 os
->name
, (long) diff
);
5959 bfd_set_section_vma (os
->bfd_section
, newdot
);
5961 os
->bfd_section
->output_offset
= 0;
5964 lang_size_sections_1 (&os
->children
.head
, os
,
5965 os
->fill
, newdot
, relax
, check_regions
);
5967 os
->processed_vma
= true;
5969 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5970 /* Except for some special linker created sections,
5971 no output section should change from zero size
5972 after strip_excluded_output_sections. A non-zero
5973 size on an ignored section indicates that some
5974 input section was not sized early enough. */
5975 ASSERT (os
->bfd_section
->size
== 0);
5978 dot
= os
->bfd_section
->vma
;
5980 /* Put the section within the requested block size, or
5981 align at the block boundary. */
5983 + TO_ADDR (os
->bfd_section
->size
)
5984 + os
->block_value
- 1)
5985 & - (bfd_vma
) os
->block_value
);
5987 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5988 os
->bfd_section
->size
= TO_SIZE (after
5989 - os
->bfd_section
->vma
);
5992 /* Set section lma. */
5995 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
5999 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
6000 os
->bfd_section
->lma
= lma
;
6002 else if (os
->lma_region
!= NULL
)
6004 bfd_vma lma
= os
->lma_region
->current
;
6006 if (os
->align_lma_with_input
)
6010 /* When LMA_REGION is the same as REGION, align the LMA
6011 as we did for the VMA, possibly including alignment
6012 from the bfd section. If a different region, then
6013 only align according to the value in the output
6015 if (os
->lma_region
!= os
->region
)
6016 section_alignment
= exp_get_power (os
->section_alignment
,
6018 "section alignment");
6019 if (section_alignment
> 0)
6020 lma
= align_power (lma
, section_alignment
);
6022 os
->bfd_section
->lma
= lma
;
6024 else if (r
->last_os
!= NULL
6025 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6030 last
= r
->last_os
->output_section_statement
.bfd_section
;
6032 /* A backwards move of dot should be accompanied by
6033 an explicit assignment to the section LMA (ie.
6034 os->load_base set) because backwards moves can
6035 create overlapping LMAs. */
6037 && os
->bfd_section
->size
!= 0
6038 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
6040 /* If dot moved backwards then leave lma equal to
6041 vma. This is the old default lma, which might
6042 just happen to work when the backwards move is
6043 sufficiently large. Nag if this changes anything,
6044 so people can fix their linker scripts. */
6046 if (last
->vma
!= last
->lma
)
6047 einfo (_("%P: warning: dot moved backwards "
6048 "before `%s'\n"), os
->name
);
6052 /* If this is an overlay, set the current lma to that
6053 at the end of the previous section. */
6054 if (os
->sectype
== overlay_section
)
6055 lma
= last
->lma
+ TO_ADDR (last
->size
);
6057 /* Otherwise, keep the same lma to vma relationship
6058 as the previous section. */
6060 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
6062 if (section_alignment
> 0)
6063 lma
= align_power (lma
, section_alignment
);
6064 os
->bfd_section
->lma
= lma
;
6067 os
->processed_lma
= true;
6069 /* Keep track of normal sections using the default
6070 lma region. We use this to set the lma for
6071 following sections. Overlays or other linker
6072 script assignment to lma might mean that the
6073 default lma == vma is incorrect.
6074 To avoid warnings about dot moving backwards when using
6075 -Ttext, don't start tracking sections until we find one
6076 of non-zero size or with lma set differently to vma.
6077 Do this tracking before we short-cut the loop so that we
6078 track changes for the case where the section size is zero,
6079 but the lma is set differently to the vma. This is
6080 important, if an orphan section is placed after an
6081 otherwise empty output section that has an explicit lma
6082 set, we want that lma reflected in the orphans lma. */
6083 if (((!IGNORE_SECTION (os
->bfd_section
)
6084 && (os
->bfd_section
->size
!= 0
6085 || (r
->last_os
== NULL
6086 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
6087 || (r
->last_os
!= NULL
6088 && dot
>= (r
->last_os
->output_section_statement
6089 .bfd_section
->vma
))))
6090 || os
->sectype
== first_overlay_section
)
6091 && os
->lma_region
== NULL
6092 && !bfd_link_relocatable (&link_info
))
6095 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
6098 /* .tbss sections effectively have zero size. */
6099 if (!IS_TBSS (os
->bfd_section
)
6100 || bfd_link_relocatable (&link_info
))
6101 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
6106 if (os
->update_dot_tree
!= 0)
6107 exp_fold_tree (os
->update_dot_tree
, os
, bfd_abs_section_ptr
, &dot
);
6109 /* Update dot in the region ?
6110 We only do this if the section is going to be allocated,
6111 since unallocated sections do not contribute to the region's
6112 overall size in memory. */
6113 if (os
->region
!= NULL
6114 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
6116 os
->region
->current
= dot
;
6119 /* Make sure the new address is within the region. */
6120 os_region_check (os
, os
->region
, os
->addr_tree
,
6121 os
->bfd_section
->vma
);
6123 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6124 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6125 || os
->align_lma_with_input
))
6127 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6130 os_region_check (os
, os
->lma_region
, NULL
,
6131 os
->bfd_section
->lma
);
6137 case lang_constructors_statement_enum
:
6138 dot
= lang_size_sections_1 (&constructor_list
.head
, current_os
,
6139 fill
, dot
, relax
, check_regions
);
6142 case lang_data_statement_enum
:
6144 unsigned int size
= 0;
6146 s
->data_statement
.output_offset
= dot
- current_os
->bfd_section
->vma
;
6147 s
->data_statement
.output_section
= current_os
->bfd_section
;
6149 /* We might refer to provided symbols in the expression, and
6150 need to mark them as needed. */
6151 exp_fold_tree (s
->data_statement
.exp
, os
,
6152 bfd_abs_section_ptr
, &dot
);
6154 switch (s
->data_statement
.type
)
6172 if (size
< TO_SIZE ((unsigned) 1))
6173 size
= TO_SIZE ((unsigned) 1);
6174 dot
+= TO_ADDR (size
);
6175 if (!(current_os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
6176 current_os
->bfd_section
->size
6177 = TO_SIZE (dot
- current_os
->bfd_section
->vma
);
6182 case lang_reloc_statement_enum
:
6186 s
->reloc_statement
.output_offset
6187 = dot
- current_os
->bfd_section
->vma
;
6188 s
->reloc_statement
.output_section
6189 = current_os
->bfd_section
;
6190 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6191 dot
+= TO_ADDR (size
);
6192 if (!(current_os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
6193 current_os
->bfd_section
->size
6194 = TO_SIZE (dot
- current_os
->bfd_section
->vma
);
6198 case lang_wild_statement_enum
:
6199 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6200 current_os
, fill
, dot
, relax
,
6204 case lang_object_symbols_statement_enum
:
6205 link_info
.create_object_symbols_section
= current_os
->bfd_section
;
6206 current_os
->bfd_section
->flags
|= SEC_KEEP
;
6209 case lang_output_statement_enum
:
6210 case lang_target_statement_enum
:
6213 case lang_input_section_enum
:
6217 i
= s
->input_section
.section
;
6222 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6223 einfo (_("%F%P: can't relax section: %E\n"));
6227 dot
= size_input_section (prev
, current_os
, fill
, &removed
, dot
);
6231 case lang_input_statement_enum
:
6234 case lang_fill_statement_enum
:
6235 s
->fill_statement
.output_section
= current_os
->bfd_section
;
6237 fill
= s
->fill_statement
.fill
;
6240 case lang_assignment_statement_enum
:
6242 bfd_vma newdot
= dot
;
6243 etree_type
*tree
= s
->assignment_statement
.exp
;
6245 expld
.dataseg
.relro
= exp_seg_relro_none
;
6247 exp_fold_tree (tree
, os
, current_os
->bfd_section
, &newdot
);
6249 ldlang_check_relro_region (s
);
6251 expld
.dataseg
.relro
= exp_seg_relro_none
;
6253 /* This symbol may be relative to this section. */
6254 if ((tree
->type
.node_class
== etree_provided
6255 || tree
->type
.node_class
== etree_assign
)
6256 && (tree
->assign
.dst
[0] != '.'
6257 || tree
->assign
.dst
[1] != '\0'))
6258 current_os
->update_dot
= 1;
6260 if (!current_os
->ignored
)
6262 if (current_os
== abs_output_section
)
6264 /* If we don't have an output section, then just adjust
6265 the default memory address. */
6266 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6267 false)->current
= newdot
;
6269 else if (newdot
!= dot
)
6271 /* Insert a pad after this statement. We can't
6272 put the pad before when relaxing, in case the
6273 assignment references dot. */
6274 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6275 current_os
->bfd_section
, dot
);
6277 /* Don't neuter the pad below when relaxing. */
6280 /* If dot is advanced, this implies that the section
6281 should have space allocated to it, unless the
6282 user has explicitly stated that the section
6283 should not be allocated. */
6284 if (current_os
->sectype
!= noalloc_section
6285 && (current_os
->sectype
!= noload_section
6286 || (bfd_get_flavour (link_info
.output_bfd
)
6287 == bfd_target_elf_flavour
)))
6288 current_os
->bfd_section
->flags
|= SEC_ALLOC
;
6295 case lang_padding_statement_enum
:
6296 /* If this is the first time lang_size_sections is called,
6297 we won't have any padding statements. If this is the
6298 second or later passes when relaxing, we should allow
6299 padding to shrink. If padding is needed on this pass, it
6300 will be added back in. */
6301 s
->padding_statement
.size
= 0;
6303 /* Make sure output_offset is valid. If relaxation shrinks
6304 the section and this pad isn't needed, it's possible to
6305 have output_offset larger than the final size of the
6306 section. bfd_set_section_contents will complain even for
6307 a pad size of zero. */
6308 s
->padding_statement
.output_offset
6309 = dot
- current_os
->bfd_section
->vma
;
6312 case lang_group_statement_enum
:
6313 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6314 current_os
, fill
, dot
, relax
,
6318 case lang_insert_statement_enum
:
6321 /* We can only get here when relaxing is turned on. */
6322 case lang_address_statement_enum
:
6330 /* If an input section doesn't fit in the current output
6331 section, remove it from the list. Handle the case where we
6332 have to remove an input_section statement here: there is a
6333 special case to remove the first element of the list. */
6334 if (link_info
.non_contiguous_regions
&& removed
)
6336 /* If we removed the first element during the previous
6337 iteration, override the loop assignment of prev_s. */
6343 /* If there was a real previous input section, just skip
6345 prev_s
->header
.next
=s
->header
.next
;
6347 removed_prev_s
= false;
6351 /* Remove the first input section of the list. */
6352 *prev
= s
->header
.next
;
6353 removed_prev_s
= true;
6356 /* Move to next element, unless we removed the head of the
6358 if (!removed_prev_s
)
6359 prev
= &s
->header
.next
;
6363 prev
= &s
->header
.next
;
6364 removed_prev_s
= false;
6370 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6371 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6372 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6373 segments. We are allowed an opportunity to override this decision. */
6376 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6377 bfd
*abfd ATTRIBUTE_UNUSED
,
6378 asection
*current_section
,
6379 asection
*previous_section
,
6382 lang_output_section_statement_type
*cur
;
6383 lang_output_section_statement_type
*prev
;
6385 /* The checks below are only necessary when the BFD library has decided
6386 that the two sections ought to be placed into the same segment. */
6390 /* Paranoia checks. */
6391 if (current_section
== NULL
|| previous_section
== NULL
)
6394 /* If this flag is set, the target never wants code and non-code
6395 sections comingled in the same segment. */
6396 if (config
.separate_code
6397 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6400 /* Find the memory regions associated with the two sections.
6401 We call lang_output_section_find() here rather than scanning the list
6402 of output sections looking for a matching section pointer because if
6403 we have a large number of sections then a hash lookup is faster. */
6404 cur
= lang_output_section_find (current_section
->name
);
6405 prev
= lang_output_section_find (previous_section
->name
);
6407 /* More paranoia. */
6408 if (cur
== NULL
|| prev
== NULL
)
6411 /* If the regions are different then force the sections to live in
6412 different segments. See the email thread starting at the following
6413 URL for the reasons why this is necessary:
6414 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6415 return cur
->region
!= prev
->region
;
6419 one_lang_size_sections_pass (bool *relax
, bool check_regions
)
6421 lang_statement_iteration
++;
6422 if (expld
.phase
!= lang_mark_phase_enum
)
6423 lang_sizing_iteration
++;
6424 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6425 0, 0, relax
, check_regions
);
6429 lang_size_segment (void)
6431 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6432 a page could be saved in the data segment. */
6433 seg_align_type
*seg
= &expld
.dataseg
;
6434 bfd_vma first
, last
;
6436 first
= -seg
->base
& (seg
->commonpagesize
- 1);
6437 last
= seg
->end
& (seg
->commonpagesize
- 1);
6439 && ((seg
->base
& ~(seg
->commonpagesize
- 1))
6440 != (seg
->end
& ~(seg
->commonpagesize
- 1)))
6441 && first
+ last
<= seg
->commonpagesize
)
6443 seg
->phase
= exp_seg_adjust
;
6447 seg
->phase
= exp_seg_done
;
6452 lang_size_relro_segment_1 (void)
6454 seg_align_type
*seg
= &expld
.dataseg
;
6455 bfd_vma relro_end
, desired_end
;
6458 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6459 relro_end
= (seg
->relro_end
+ seg
->relropagesize
- 1) & -seg
->relropagesize
;
6461 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6462 desired_end
= relro_end
- seg
->relro_offset
;
6464 /* For sections in the relro segment.. */
6465 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6466 if ((sec
->flags
& SEC_ALLOC
) != 0
6467 && sec
->vma
>= seg
->base
6468 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6470 /* Where do we want to put this section so that it ends as
6472 bfd_vma start
, end
, bump
;
6474 end
= start
= sec
->vma
;
6476 end
+= TO_ADDR (sec
->size
);
6477 bump
= desired_end
- end
;
6478 /* We'd like to increase START by BUMP, but we must heed
6479 alignment so the increase might be less than optimum. */
6481 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6482 /* This is now the desired end for the previous section. */
6483 desired_end
= start
;
6486 seg
->phase
= exp_seg_relro_adjust
;
6487 ASSERT (desired_end
>= seg
->base
);
6488 seg
->base
= desired_end
;
6493 lang_size_relro_segment (bool *relax
, bool check_regions
)
6495 bool do_reset
= false;
6497 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6499 bfd_vma data_initial_base
= expld
.dataseg
.base
;
6500 bfd_vma data_relro_end
= lang_size_relro_segment_1 ();
6502 lang_reset_memory_regions ();
6503 one_lang_size_sections_pass (relax
, check_regions
);
6505 /* Assignments to dot, or to output section address in a user
6506 script have increased padding over the original. Revert. */
6507 if (expld
.dataseg
.relro_end
> data_relro_end
)
6509 expld
.dataseg
.base
= data_initial_base
;
6513 else if (lang_size_segment ())
6520 lang_size_sections (bool *relax
, bool check_regions
)
6522 expld
.phase
= lang_allocating_phase_enum
;
6523 expld
.dataseg
.phase
= exp_seg_none
;
6525 one_lang_size_sections_pass (relax
, check_regions
);
6527 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6528 expld
.dataseg
.phase
= exp_seg_done
;
6530 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6533 = lang_size_relro_segment (relax
, check_regions
);
6537 lang_reset_memory_regions ();
6538 one_lang_size_sections_pass (relax
, check_regions
);
6541 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6543 link_info
.relro_start
= expld
.dataseg
.base
;
6544 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6549 static lang_output_section_statement_type
*current_section
;
6550 static lang_assignment_statement_type
*current_assign
;
6551 static bool prefer_next_section
;
6553 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6556 lang_do_assignments_1 (lang_statement_union_type
*s
,
6557 lang_output_section_statement_type
*current_os
,
6562 lang_output_section_statement_type
*os
= current_os
;
6564 for (; s
!= NULL
; s
= s
->header
.next
)
6566 switch (s
->header
.type
)
6568 case lang_constructors_statement_enum
:
6569 dot
= lang_do_assignments_1 (constructor_list
.head
,
6570 current_os
, fill
, dot
, found_end
);
6573 case lang_output_section_statement_enum
:
6577 os
= &s
->output_section_statement
;
6578 os
->after_end
= *found_end
;
6579 init_opb (os
->bfd_section
);
6581 if (os
->bfd_section
!= NULL
)
6583 if (!os
->ignored
&& (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6585 current_section
= os
;
6586 prefer_next_section
= false;
6588 newdot
= os
->bfd_section
->vma
;
6590 newdot
= lang_do_assignments_1 (os
->children
.head
,
6591 os
, os
->fill
, newdot
, found_end
);
6594 if (os
->bfd_section
!= NULL
)
6596 newdot
= os
->bfd_section
->vma
;
6598 /* .tbss sections effectively have zero size. */
6599 if (!IS_TBSS (os
->bfd_section
)
6600 || bfd_link_relocatable (&link_info
))
6601 newdot
+= TO_ADDR (os
->bfd_section
->size
);
6603 if (os
->update_dot_tree
!= NULL
)
6604 exp_fold_tree (os
->update_dot_tree
, os
,
6605 bfd_abs_section_ptr
, &newdot
);
6612 case lang_wild_statement_enum
:
6614 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6615 current_os
, fill
, dot
, found_end
);
6618 case lang_object_symbols_statement_enum
:
6619 case lang_output_statement_enum
:
6620 case lang_target_statement_enum
:
6623 case lang_data_statement_enum
:
6624 exp_fold_tree (s
->data_statement
.exp
, os
, bfd_abs_section_ptr
, &dot
);
6625 if (expld
.result
.valid_p
)
6627 s
->data_statement
.value
= expld
.result
.value
;
6628 if (expld
.result
.section
!= NULL
)
6629 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6631 else if (expld
.phase
== lang_final_phase_enum
)
6632 einfo (_("%F%P: invalid data statement\n"));
6635 switch (s
->data_statement
.type
)
6653 if (size
< TO_SIZE ((unsigned) 1))
6654 size
= TO_SIZE ((unsigned) 1);
6655 dot
+= TO_ADDR (size
);
6659 case lang_reloc_statement_enum
:
6660 exp_fold_tree (s
->reloc_statement
.addend_exp
, os
,
6661 bfd_abs_section_ptr
, &dot
);
6662 if (expld
.result
.valid_p
)
6663 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6664 else if (expld
.phase
== lang_final_phase_enum
)
6665 einfo (_("%F%P: invalid reloc statement\n"));
6666 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6669 case lang_input_section_enum
:
6671 asection
*in
= s
->input_section
.section
;
6673 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6674 dot
+= TO_ADDR (in
->size
);
6678 case lang_input_statement_enum
:
6681 case lang_fill_statement_enum
:
6682 fill
= s
->fill_statement
.fill
;
6685 case lang_assignment_statement_enum
:
6686 current_assign
= &s
->assignment_statement
;
6687 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6689 const char *p
= current_assign
->exp
->assign
.dst
;
6691 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6692 prefer_next_section
= true;
6696 if (strcmp (p
, "end") == 0)
6699 exp_fold_tree (s
->assignment_statement
.exp
, os
,
6700 (current_os
->bfd_section
!= NULL
6701 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6705 case lang_padding_statement_enum
:
6706 dot
+= TO_ADDR (s
->padding_statement
.size
);
6709 case lang_group_statement_enum
:
6710 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6711 current_os
, fill
, dot
, found_end
);
6714 case lang_insert_statement_enum
:
6717 case lang_address_statement_enum
:
6729 lang_do_assignments (lang_phase_type phase
)
6731 bool found_end
= false;
6733 current_section
= NULL
;
6734 prefer_next_section
= false;
6735 expld
.phase
= phase
;
6736 lang_statement_iteration
++;
6737 lang_do_assignments_1 (statement_list
.head
,
6738 abs_output_section
, NULL
, 0, &found_end
);
6741 /* For an assignment statement outside of an output section statement,
6742 choose the best of neighbouring output sections to use for values
6746 section_for_dot (void)
6750 /* Assignments belong to the previous output section, unless there
6751 has been an assignment to "dot", in which case following
6752 assignments belong to the next output section. (The assumption
6753 is that an assignment to "dot" is setting up the address for the
6754 next output section.) Except that past the assignment to "_end"
6755 we always associate with the previous section. This exception is
6756 for targets like SH that define an alloc .stack or other
6757 weirdness after non-alloc sections. */
6758 if (current_section
== NULL
|| prefer_next_section
)
6760 lang_statement_union_type
*stmt
;
6761 lang_output_section_statement_type
*os
;
6763 for (stmt
= (lang_statement_union_type
*) current_assign
;
6765 stmt
= stmt
->header
.next
)
6766 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6769 os
= stmt
? &stmt
->output_section_statement
: NULL
;
6772 && (os
->bfd_section
== NULL
6773 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6774 || bfd_section_removed_from_list (link_info
.output_bfd
,
6778 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6781 s
= os
->bfd_section
;
6783 s
= link_info
.output_bfd
->section_last
;
6785 && ((s
->flags
& SEC_ALLOC
) == 0
6786 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6791 return bfd_abs_section_ptr
;
6795 s
= current_section
->bfd_section
;
6797 /* The section may have been stripped. */
6799 && ((s
->flags
& SEC_EXCLUDE
) != 0
6800 || (s
->flags
& SEC_ALLOC
) == 0
6801 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6802 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6805 s
= link_info
.output_bfd
->sections
;
6807 && ((s
->flags
& SEC_ALLOC
) == 0
6808 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6813 return bfd_abs_section_ptr
;
6816 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6818 static struct bfd_link_hash_entry
**start_stop_syms
;
6819 static size_t start_stop_count
= 0;
6820 static size_t start_stop_alloc
= 0;
6822 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6823 to start_stop_syms. */
6826 lang_define_start_stop (const char *symbol
, asection
*sec
)
6828 struct bfd_link_hash_entry
*h
;
6830 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6833 if (start_stop_count
== start_stop_alloc
)
6835 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6837 = xrealloc (start_stop_syms
,
6838 start_stop_alloc
* sizeof (*start_stop_syms
));
6840 start_stop_syms
[start_stop_count
++] = h
;
6844 /* Check for input sections whose names match references to
6845 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6846 preliminary definitions. */
6849 lang_init_start_stop (void)
6853 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6855 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6856 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6859 const char *secname
= s
->name
;
6861 for (ps
= secname
; *ps
!= '\0'; ps
++)
6862 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6866 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6868 symbol
[0] = leading_char
;
6869 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6870 lang_define_start_stop (symbol
, s
);
6872 symbol
[1] = leading_char
;
6873 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6874 lang_define_start_stop (symbol
+ 1, s
);
6881 /* Iterate over start_stop_syms. */
6884 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6888 for (i
= 0; i
< start_stop_count
; ++i
)
6889 func (start_stop_syms
[i
]);
6892 /* __start and __stop symbols are only supposed to be defined by the
6893 linker for orphan sections, but we now extend that to sections that
6894 map to an output section of the same name. The symbols were
6895 defined early for --gc-sections, before we mapped input to output
6896 sections, so undo those that don't satisfy this rule. */
6899 undef_start_stop (struct bfd_link_hash_entry
*h
)
6901 if (h
->ldscript_def
)
6904 if (h
->u
.def
.section
->output_section
== NULL
6905 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6906 || strcmp (h
->u
.def
.section
->name
,
6907 h
->u
.def
.section
->output_section
->name
) != 0)
6909 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6910 h
->u
.def
.section
->name
);
6913 /* When there are more than one input sections with the same
6914 section name, SECNAME, linker picks the first one to define
6915 __start_SECNAME and __stop_SECNAME symbols. When the first
6916 input section is removed by comdat group, we need to check
6917 if there is still an output section with section name
6920 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6921 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6923 h
->u
.def
.section
= i
;
6927 h
->type
= bfd_link_hash_undefined
;
6928 h
->u
.undef
.abfd
= NULL
;
6929 if (is_elf_hash_table (link_info
.hash
))
6931 const struct elf_backend_data
*bed
;
6932 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6933 unsigned int was_forced
= eh
->forced_local
;
6935 bed
= get_elf_backend_data (link_info
.output_bfd
);
6936 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, true);
6937 if (!eh
->ref_regular_nonweak
)
6938 h
->type
= bfd_link_hash_undefweak
;
6939 eh
->def_regular
= 0;
6940 eh
->forced_local
= was_forced
;
6946 lang_undef_start_stop (void)
6948 foreach_start_stop (undef_start_stop
);
6951 /* Check for output sections whose names match references to
6952 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6953 preliminary definitions. */
6956 lang_init_startof_sizeof (void)
6960 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6962 const char *secname
= s
->name
;
6963 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6965 sprintf (symbol
, ".startof.%s", secname
);
6966 lang_define_start_stop (symbol
, s
);
6968 memcpy (symbol
+ 1, ".size", 5);
6969 lang_define_start_stop (symbol
+ 1, s
);
6974 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6977 set_start_stop (struct bfd_link_hash_entry
*h
)
6980 || h
->type
!= bfd_link_hash_defined
)
6983 if (h
->root
.string
[0] == '.')
6985 /* .startof. or .sizeof. symbol.
6986 .startof. already has final value. */
6987 if (h
->root
.string
[2] == 'i')
6990 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6991 h
->u
.def
.section
= bfd_abs_section_ptr
;
6996 /* __start or __stop symbol. */
6997 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6999 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
7000 if (h
->root
.string
[4 + has_lead
] == 'o')
7003 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
7009 lang_finalize_start_stop (void)
7011 foreach_start_stop (set_start_stop
);
7015 lang_symbol_tweaks (void)
7017 /* Give initial values for __start and __stop symbols, so that ELF
7018 gc_sections will keep sections referenced by these symbols. Must
7019 be done before lang_do_assignments. */
7020 if (config
.build_constructors
)
7021 lang_init_start_stop ();
7023 /* Make __ehdr_start hidden, and set def_regular even though it is
7024 likely undefined at this stage. For lang_check_relocs. */
7025 if (is_elf_hash_table (link_info
.hash
)
7026 && !bfd_link_relocatable (&link_info
))
7028 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
7029 bfd_link_hash_lookup (link_info
.hash
, "__ehdr_start",
7030 false, false, true);
7032 /* Only adjust the export class if the symbol was referenced
7033 and not defined, otherwise leave it alone. */
7035 && (h
->root
.type
== bfd_link_hash_new
7036 || h
->root
.type
== bfd_link_hash_undefined
7037 || h
->root
.type
== bfd_link_hash_undefweak
7038 || h
->root
.type
== bfd_link_hash_common
))
7040 const struct elf_backend_data
*bed
;
7041 bed
= get_elf_backend_data (link_info
.output_bfd
);
7042 (*bed
->elf_backend_hide_symbol
) (&link_info
, h
, true);
7043 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
7044 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
7046 h
->root
.linker_def
= 1;
7047 h
->root
.rel_from_abs
= 1;
7055 struct bfd_link_hash_entry
*h
;
7058 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
7059 || bfd_link_dll (&link_info
))
7060 warn
= entry_from_cmdline
;
7064 /* Force the user to specify a root when generating a relocatable with
7065 --gc-sections, unless --gc-keep-exported was also given. */
7066 if (bfd_link_relocatable (&link_info
)
7067 && link_info
.gc_sections
7068 && !link_info
.gc_keep_exported
)
7070 struct bfd_sym_chain
*sym
;
7072 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
7074 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
7075 false, false, false);
7077 && (h
->type
== bfd_link_hash_defined
7078 || h
->type
== bfd_link_hash_defweak
)
7079 && !bfd_is_const_section (h
->u
.def
.section
))
7083 einfo (_("%F%P: --gc-sections requires a defined symbol root "
7084 "specified by -e or -u\n"));
7087 if (entry_symbol
.name
== NULL
)
7089 /* No entry has been specified. Look for the default entry, but
7090 don't warn if we don't find it. */
7091 entry_symbol
.name
= entry_symbol_default
;
7095 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
7096 false, false, true);
7098 && (h
->type
== bfd_link_hash_defined
7099 || h
->type
== bfd_link_hash_defweak
)
7100 && h
->u
.def
.section
->output_section
!= NULL
)
7104 val
= (h
->u
.def
.value
7105 + bfd_section_vma (h
->u
.def
.section
->output_section
)
7106 + h
->u
.def
.section
->output_offset
);
7107 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7108 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
7115 /* We couldn't find the entry symbol. Try parsing it as a
7117 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
7120 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7121 einfo (_("%F%P: can't set start address\n"));
7123 /* BZ 2004952: Only use the start of the entry section for executables. */
7124 else if bfd_link_executable (&link_info
)
7128 /* Can't find the entry symbol, and it's not a number. Use
7129 the first address in the text section. */
7130 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
7134 einfo (_("%P: warning: cannot find entry symbol %s;"
7135 " defaulting to %V\n"),
7137 bfd_section_vma (ts
));
7138 if (!bfd_set_start_address (link_info
.output_bfd
,
7139 bfd_section_vma (ts
)))
7140 einfo (_("%F%P: can't set start address\n"));
7145 einfo (_("%P: warning: cannot find entry symbol %s;"
7146 " not setting start address\n"),
7153 einfo (_("%P: warning: cannot find entry symbol %s;"
7154 " not setting start address\n"),
7160 /* This is a small function used when we want to ignore errors from
7164 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7165 va_list ap ATTRIBUTE_UNUSED
)
7167 /* Don't do anything. */
7170 /* Check that the architecture of all the input files is compatible
7171 with the output file. Also call the backend to let it do any
7172 other checking that is needed. */
7177 lang_input_statement_type
*file
;
7179 const bfd_arch_info_type
*compatible
;
7181 for (file
= (void *) file_chain
.head
;
7185 #if BFD_SUPPORTS_PLUGINS
7186 /* Don't check format of files claimed by plugin. */
7187 if (file
->flags
.claimed
)
7189 #endif /* BFD_SUPPORTS_PLUGINS */
7190 input_bfd
= file
->the_bfd
;
7192 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7193 command_line
.accept_unknown_input_arch
);
7195 /* In general it is not possible to perform a relocatable
7196 link between differing object formats when the input
7197 file has relocations, because the relocations in the
7198 input format may not have equivalent representations in
7199 the output format (and besides BFD does not translate
7200 relocs for other link purposes than a final link). */
7201 if (!file
->flags
.just_syms
7202 && (bfd_link_relocatable (&link_info
)
7203 || link_info
.emitrelocations
)
7204 && (compatible
== NULL
7205 || (bfd_get_flavour (input_bfd
)
7206 != bfd_get_flavour (link_info
.output_bfd
)))
7207 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7209 einfo (_("%F%P: relocatable linking with relocations from"
7210 " format %s (%pB) to format %s (%pB) is not supported\n"),
7211 bfd_get_target (input_bfd
), input_bfd
,
7212 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7213 /* einfo with %F exits. */
7216 if (compatible
== NULL
)
7218 if (command_line
.warn_mismatch
)
7219 einfo (_("%X%P: %s architecture of input file `%pB'"
7220 " is incompatible with %s output\n"),
7221 bfd_printable_name (input_bfd
), input_bfd
,
7222 bfd_printable_name (link_info
.output_bfd
));
7225 /* If the input bfd has no contents, it shouldn't set the
7226 private data of the output bfd. */
7227 else if (!file
->flags
.just_syms
7228 && ((input_bfd
->flags
& DYNAMIC
) != 0
7229 || bfd_count_sections (input_bfd
) != 0))
7231 bfd_error_handler_type pfn
= NULL
;
7233 /* If we aren't supposed to warn about mismatched input
7234 files, temporarily set the BFD error handler to a
7235 function which will do nothing. We still want to call
7236 bfd_merge_private_bfd_data, since it may set up
7237 information which is needed in the output file. */
7238 if (!command_line
.warn_mismatch
)
7239 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7240 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7242 if (command_line
.warn_mismatch
)
7243 einfo (_("%X%P: failed to merge target specific data"
7244 " of file %pB\n"), input_bfd
);
7246 if (!command_line
.warn_mismatch
)
7247 bfd_set_error_handler (pfn
);
7252 /* Look through all the global common symbols and attach them to the
7253 correct section. The -sort-common command line switch may be used
7254 to roughly sort the entries by alignment. */
7259 if (link_info
.inhibit_common_definition
)
7261 if (bfd_link_relocatable (&link_info
)
7262 && !command_line
.force_common_definition
)
7265 if (!config
.sort_common
)
7266 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7271 if (config
.sort_common
== sort_descending
)
7273 for (power
= 4; power
> 0; power
--)
7274 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7277 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7281 for (power
= 0; power
<= 4; power
++)
7282 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7284 power
= (unsigned int) -1;
7285 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7290 /* Place one common symbol in the correct section. */
7293 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7295 unsigned int power_of_two
;
7299 if (h
->type
!= bfd_link_hash_common
)
7303 power_of_two
= h
->u
.c
.p
->alignment_power
;
7305 if (config
.sort_common
== sort_descending
7306 && power_of_two
< *(unsigned int *) info
)
7308 else if (config
.sort_common
== sort_ascending
7309 && power_of_two
> *(unsigned int *) info
)
7312 section
= h
->u
.c
.p
->section
;
7313 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7314 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7317 if (config
.map_file
!= NULL
)
7319 static bool header_printed
;
7324 if (!header_printed
)
7326 minfo (_("\nAllocating common symbols\n"));
7327 minfo (_("Common symbol size file\n\n"));
7328 header_printed
= true;
7331 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7332 DMGL_ANSI
| DMGL_PARAMS
);
7335 minfo ("%s", h
->root
.string
);
7336 len
= strlen (h
->root
.string
);
7341 len
= strlen (name
);
7351 sprintf (buf
, "%" PRIx64
, (uint64_t) size
);
7352 fprintf (config
.map_file
, "%*s0x%-16s", 20 - len
, "", buf
);
7354 minfo ("%pB\n", section
->owner
);
7360 /* Handle a single orphan section S, placing the orphan into an appropriate
7361 output section. The effects of the --orphan-handling command line
7362 option are handled here. */
7365 ldlang_place_orphan (asection
*s
)
7367 if (config
.orphan_handling
== orphan_handling_discard
)
7369 lang_output_section_statement_type
*os
;
7370 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7371 if (os
->addr_tree
== NULL
7372 && (bfd_link_relocatable (&link_info
)
7373 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7374 os
->addr_tree
= exp_intop (0);
7375 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7379 lang_output_section_statement_type
*os
;
7380 const char *name
= s
->name
;
7383 if (config
.orphan_handling
== orphan_handling_error
)
7384 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7387 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7388 constraint
= SPECIAL
;
7390 os
= ldemul_place_orphan (s
, name
, constraint
);
7393 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7394 if (os
->addr_tree
== NULL
7395 && (bfd_link_relocatable (&link_info
)
7396 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7397 os
->addr_tree
= exp_intop (0);
7398 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7401 if (config
.orphan_handling
== orphan_handling_warn
)
7402 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7403 "placed in section `%s'\n"),
7404 s
, s
->owner
, os
->name
);
7408 /* Run through the input files and ensure that every input section has
7409 somewhere to go. If one is found without a destination then create
7410 an input request and place it into the statement tree. */
7413 lang_place_orphans (void)
7415 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7419 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7421 if (s
->output_section
== NULL
)
7423 /* This section of the file is not attached, root
7424 around for a sensible place for it to go. */
7426 if (file
->flags
.just_syms
)
7427 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7428 else if (lang_discard_section_p (s
))
7429 s
->output_section
= bfd_abs_section_ptr
;
7430 else if (strcmp (s
->name
, "COMMON") == 0)
7432 /* This is a lonely common section which must have
7433 come from an archive. We attach to the section
7434 with the wildcard. */
7435 if (!bfd_link_relocatable (&link_info
)
7436 || command_line
.force_common_definition
)
7438 if (default_common_section
== NULL
)
7439 default_common_section
7440 = lang_output_section_statement_lookup (".bss", 0, 1);
7441 lang_add_section (&default_common_section
->children
, s
,
7442 NULL
, NULL
, default_common_section
);
7446 ldlang_place_orphan (s
);
7453 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7455 flagword
*ptr_flags
;
7457 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7463 /* PR 17900: An exclamation mark in the attributes reverses
7464 the sense of any of the attributes that follow. */
7467 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7471 *ptr_flags
|= SEC_ALLOC
;
7475 *ptr_flags
|= SEC_READONLY
;
7479 *ptr_flags
|= SEC_DATA
;
7483 *ptr_flags
|= SEC_CODE
;
7488 *ptr_flags
|= SEC_LOAD
;
7492 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7500 /* Call a function on each real input file. This function will be
7501 called on an archive, but not on the elements. */
7504 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7506 lang_input_statement_type
*f
;
7508 for (f
= (void *) input_file_chain
.head
;
7510 f
= f
->next_real_file
)
7515 /* Call a function on each real file. The function will be called on
7516 all the elements of an archive which are included in the link, but
7517 will not be called on the archive file itself. */
7520 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7522 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7530 ldlang_add_file (lang_input_statement_type
*entry
)
7532 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7534 /* The BFD linker needs to have a list of all input BFDs involved in
7536 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7537 && entry
->the_bfd
->link
.next
== NULL
);
7538 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7540 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7541 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7542 bfd_set_usrdata (entry
->the_bfd
, entry
);
7543 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7545 /* Look through the sections and check for any which should not be
7546 included in the link. We need to do this now, so that we can
7547 notice when the backend linker tries to report multiple
7548 definition errors for symbols which are in sections we aren't
7549 going to link. FIXME: It might be better to entirely ignore
7550 symbols which are defined in sections which are going to be
7551 discarded. This would require modifying the backend linker for
7552 each backend which might set the SEC_LINK_ONCE flag. If we do
7553 this, we should probably handle SEC_EXCLUDE in the same way. */
7555 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7559 lang_add_output (const char *name
, int from_script
)
7561 /* Make -o on command line override OUTPUT in script. */
7562 if (!had_output_filename
|| !from_script
)
7564 output_filename
= name
;
7565 had_output_filename
= true;
7569 lang_output_section_statement_type
*
7570 lang_enter_output_section_statement (const char *output_section_statement_name
,
7571 etree_type
*address_exp
,
7572 enum section_type sectype
,
7573 etree_type
*sectype_value
,
7575 etree_type
*subalign
,
7578 int align_with_input
)
7580 lang_output_section_statement_type
*os
;
7582 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7584 current_section
= os
;
7586 if (os
->addr_tree
== NULL
)
7588 os
->addr_tree
= address_exp
;
7590 os
->sectype
= sectype
;
7591 if (sectype
== type_section
|| sectype
== typed_readonly_section
)
7592 os
->sectype_value
= sectype_value
;
7593 else if (sectype
== noload_section
)
7594 os
->flags
= SEC_NEVER_LOAD
;
7596 os
->flags
= SEC_NO_FLAGS
;
7597 os
->block_value
= 1;
7599 /* Make next things chain into subchain of this. */
7600 push_stat_ptr (&os
->children
);
7602 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7603 if (os
->align_lma_with_input
&& align
!= NULL
)
7604 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7607 os
->subsection_alignment
= subalign
;
7608 os
->section_alignment
= align
;
7610 os
->load_base
= ebase
;
7617 lang_output_statement_type
*new_stmt
;
7619 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7620 new_stmt
->name
= output_filename
;
7623 /* Reset the current counters in the regions. */
7626 lang_reset_memory_regions (void)
7628 lang_memory_region_type
*p
= lang_memory_region_list
;
7630 lang_output_section_statement_type
*os
;
7632 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7634 p
->current
= p
->origin
;
7638 for (os
= (void *) lang_os_list
.head
;
7642 os
->processed_vma
= false;
7643 os
->processed_lma
= false;
7646 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7648 /* Save the last size for possible use by bfd_relax_section. */
7649 o
->rawsize
= o
->size
;
7650 if (!(o
->flags
& SEC_FIXED_SIZE
))
7655 /* Worker for lang_gc_sections_1. */
7658 gc_section_callback (lang_wild_statement_type
*ptr
,
7659 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7661 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7662 void *data ATTRIBUTE_UNUSED
)
7664 /* If the wild pattern was marked KEEP, the member sections
7665 should be as well. */
7666 if (ptr
->keep_sections
)
7667 section
->flags
|= SEC_KEEP
;
7670 /* Iterate over sections marking them against GC. */
7673 lang_gc_sections_1 (lang_statement_union_type
*s
)
7675 for (; s
!= NULL
; s
= s
->header
.next
)
7677 switch (s
->header
.type
)
7679 case lang_wild_statement_enum
:
7680 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7682 case lang_constructors_statement_enum
:
7683 lang_gc_sections_1 (constructor_list
.head
);
7685 case lang_output_section_statement_enum
:
7686 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7688 case lang_group_statement_enum
:
7689 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7698 lang_gc_sections (void)
7700 /* Keep all sections so marked in the link script. */
7701 lang_gc_sections_1 (statement_list
.head
);
7703 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7704 the special case of .stabstr debug info. (See bfd/stabs.c)
7705 Twiddle the flag here, to simplify later linker code. */
7706 if (bfd_link_relocatable (&link_info
))
7708 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7711 #if BFD_SUPPORTS_PLUGINS
7712 if (f
->flags
.claimed
)
7715 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7716 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7717 || strcmp (sec
->name
, ".stabstr") != 0)
7718 sec
->flags
&= ~SEC_EXCLUDE
;
7722 if (link_info
.gc_sections
)
7723 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7726 /* Worker for lang_find_relro_sections_1. */
7729 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7730 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7732 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7735 /* Discarded, excluded and ignored sections effectively have zero
7737 if (section
->output_section
!= NULL
7738 && section
->output_section
->owner
== link_info
.output_bfd
7739 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7740 && !IGNORE_SECTION (section
)
7741 && section
->size
!= 0)
7743 bool *has_relro_section
= (bool *) data
;
7744 *has_relro_section
= true;
7748 /* Iterate over sections for relro sections. */
7751 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7752 bool *has_relro_section
)
7754 if (*has_relro_section
)
7757 for (; s
!= NULL
; s
= s
->header
.next
)
7759 if (s
== expld
.dataseg
.relro_end_stat
)
7762 switch (s
->header
.type
)
7764 case lang_wild_statement_enum
:
7765 walk_wild (&s
->wild_statement
,
7766 find_relro_section_callback
,
7769 case lang_constructors_statement_enum
:
7770 lang_find_relro_sections_1 (constructor_list
.head
,
7773 case lang_output_section_statement_enum
:
7774 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7777 case lang_group_statement_enum
:
7778 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7788 lang_find_relro_sections (void)
7790 bool has_relro_section
= false;
7792 /* Check all sections in the link script. */
7794 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7795 &has_relro_section
);
7797 if (!has_relro_section
)
7798 link_info
.relro
= false;
7801 /* Relax all sections until bfd_relax_section gives up. */
7804 lang_relax_sections (bool need_layout
)
7806 /* NB: Also enable relaxation to layout sections for DT_RELR. */
7807 if (RELAXATION_ENABLED
|| link_info
.enable_dt_relr
)
7809 /* We may need more than one relaxation pass. */
7810 int i
= link_info
.relax_pass
;
7812 /* The backend can use it to determine the current pass. */
7813 link_info
.relax_pass
= 0;
7817 /* Keep relaxing until bfd_relax_section gives up. */
7820 link_info
.relax_trip
= -1;
7823 link_info
.relax_trip
++;
7825 /* Note: pe-dll.c does something like this also. If you find
7826 you need to change this code, you probably need to change
7827 pe-dll.c also. DJ */
7829 /* Do all the assignments with our current guesses as to
7831 lang_do_assignments (lang_assigning_phase_enum
);
7833 /* We must do this after lang_do_assignments, because it uses
7835 lang_reset_memory_regions ();
7837 /* Perform another relax pass - this time we know where the
7838 globals are, so can make a better guess. */
7839 relax_again
= false;
7840 lang_size_sections (&relax_again
, false);
7842 while (relax_again
);
7844 link_info
.relax_pass
++;
7851 /* Final extra sizing to report errors. */
7852 lang_do_assignments (lang_assigning_phase_enum
);
7853 lang_reset_memory_regions ();
7854 lang_size_sections (NULL
, true);
7858 #if BFD_SUPPORTS_PLUGINS
7859 /* Find the insert point for the plugin's replacement files. We
7860 place them after the first claimed real object file, or if the
7861 first claimed object is an archive member, after the last real
7862 object file immediately preceding the archive. In the event
7863 no objects have been claimed at all, we return the first dummy
7864 object file on the list as the insert point; that works, but
7865 the callee must be careful when relinking the file_chain as it
7866 is not actually on that chain, only the statement_list and the
7867 input_file list; in that case, the replacement files must be
7868 inserted at the head of the file_chain. */
7870 static lang_input_statement_type
*
7871 find_replacements_insert_point (bool *before
)
7873 lang_input_statement_type
*claim1
, *lastobject
;
7874 lastobject
= (void *) input_file_chain
.head
;
7875 for (claim1
= (void *) file_chain
.head
;
7877 claim1
= claim1
->next
)
7879 if (claim1
->flags
.claimed
)
7881 *before
= claim1
->flags
.claim_archive
;
7882 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7884 /* Update lastobject if this is a real object file. */
7885 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7886 lastobject
= claim1
;
7888 /* No files were claimed by the plugin. Choose the last object
7889 file found on the list (maybe the first, dummy entry) as the
7895 /* Find where to insert ADD, an archive element or shared library
7896 added during a rescan. */
7898 static lang_input_statement_type
**
7899 find_rescan_insertion (lang_input_statement_type
*add
)
7901 bfd
*add_bfd
= add
->the_bfd
;
7902 lang_input_statement_type
*f
;
7903 lang_input_statement_type
*last_loaded
= NULL
;
7904 lang_input_statement_type
*before
= NULL
;
7905 lang_input_statement_type
**iter
= NULL
;
7907 if (add_bfd
->my_archive
!= NULL
)
7908 add_bfd
= add_bfd
->my_archive
;
7910 /* First look through the input file chain, to find an object file
7911 before the one we've rescanned. Normal object files always
7912 appear on both the input file chain and the file chain, so this
7913 lets us get quickly to somewhere near the correct place on the
7914 file chain if it is full of archive elements. Archives don't
7915 appear on the file chain, but if an element has been extracted
7916 then their input_statement->next points at it. */
7917 for (f
= (void *) input_file_chain
.head
;
7919 f
= f
->next_real_file
)
7921 if (f
->the_bfd
== add_bfd
)
7923 before
= last_loaded
;
7924 if (f
->next
!= NULL
)
7925 return &f
->next
->next
;
7927 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7931 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7933 iter
= &(*iter
)->next
)
7934 if (!(*iter
)->flags
.claim_archive
7935 && (*iter
)->the_bfd
->my_archive
== NULL
)
7941 /* Insert SRCLIST into DESTLIST after given element by chaining
7942 on FIELD as the next-pointer. (Counterintuitively does not need
7943 a pointer to the actual after-node itself, just its chain field.) */
7946 lang_list_insert_after (lang_statement_list_type
*destlist
,
7947 lang_statement_list_type
*srclist
,
7948 lang_statement_union_type
**field
)
7950 *(srclist
->tail
) = *field
;
7951 *field
= srclist
->head
;
7952 if (destlist
->tail
== field
)
7953 destlist
->tail
= srclist
->tail
;
7956 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7957 was taken as a copy of it and leave them in ORIGLIST. */
7960 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7961 lang_statement_list_type
*origlist
)
7963 union lang_statement_union
**savetail
;
7964 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7965 ASSERT (origlist
->head
== destlist
->head
);
7966 savetail
= origlist
->tail
;
7967 origlist
->head
= *(savetail
);
7968 origlist
->tail
= destlist
->tail
;
7969 destlist
->tail
= savetail
;
7973 static lang_statement_union_type
**
7974 find_next_input_statement (lang_statement_union_type
**s
)
7976 for ( ; *s
; s
= &(*s
)->header
.next
)
7978 lang_statement_union_type
**t
;
7979 switch ((*s
)->header
.type
)
7981 case lang_input_statement_enum
:
7983 case lang_wild_statement_enum
:
7984 t
= &(*s
)->wild_statement
.children
.head
;
7986 case lang_group_statement_enum
:
7987 t
= &(*s
)->group_statement
.children
.head
;
7989 case lang_output_section_statement_enum
:
7990 t
= &(*s
)->output_section_statement
.children
.head
;
7995 t
= find_next_input_statement (t
);
8001 #endif /* BFD_SUPPORTS_PLUGINS */
8003 /* Add NAME to the list of garbage collection entry points. */
8006 lang_add_gc_name (const char *name
)
8008 struct bfd_sym_chain
*sym
;
8013 sym
= stat_alloc (sizeof (*sym
));
8015 sym
->next
= link_info
.gc_sym_list
;
8017 link_info
.gc_sym_list
= sym
;
8020 /* Check relocations. */
8023 lang_check_relocs (void)
8025 if (link_info
.check_relocs_after_open_input
)
8029 for (abfd
= link_info
.input_bfds
;
8030 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
8031 if (!bfd_link_check_relocs (abfd
, &link_info
))
8033 /* No object output, fail return. */
8034 config
.make_executable
= false;
8035 /* Note: we do not abort the loop, but rather
8036 continue the scan in case there are other
8037 bad relocations to report. */
8042 /* Look through all output sections looking for places where we can
8043 propagate forward the lma region. */
8046 lang_propagate_lma_regions (void)
8048 lang_output_section_statement_type
*os
;
8050 for (os
= (void *) lang_os_list
.head
;
8054 if (os
->prev
!= NULL
8055 && os
->lma_region
== NULL
8056 && os
->load_base
== NULL
8057 && os
->addr_tree
== NULL
8058 && os
->region
== os
->prev
->region
)
8059 os
->lma_region
= os
->prev
->lma_region
;
8064 warn_non_contiguous_discards (void)
8066 LANG_FOR_EACH_INPUT_STATEMENT (file
)
8068 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
8069 || file
->flags
.just_syms
)
8072 for (asection
*s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8073 if (s
->output_section
== NULL
8074 && (s
->flags
& SEC_LINKER_CREATED
) == 0)
8075 einfo (_("%P: warning: --enable-non-contiguous-regions "
8076 "discards section `%pA' from `%pB'\n"),
8082 reset_one_wild (lang_statement_union_type
*statement
)
8084 if (statement
->header
.type
== lang_wild_statement_enum
)
8086 lang_wild_statement_type
*stmt
= &statement
->wild_statement
;
8087 lang_list_init (&stmt
->matching_sections
);
8092 reset_resolved_wilds (void)
8094 lang_for_each_statement (reset_one_wild
);
8100 /* Finalize dynamic list. */
8101 if (link_info
.dynamic_list
)
8102 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
8104 current_target
= default_target
;
8106 /* Open the output file. */
8107 lang_for_each_statement (ldlang_open_output
);
8110 ldemul_create_output_section_statements ();
8112 /* Add to the hash table all undefineds on the command line. */
8113 lang_place_undefineds ();
8115 if (!bfd_section_already_linked_table_init ())
8116 einfo (_("%F%P: can not create hash table: %E\n"));
8118 /* A first pass through the memory regions ensures that if any region
8119 references a symbol for its origin or length then this symbol will be
8120 added to the symbol table. Having these symbols in the symbol table
8121 means that when we call open_input_bfds PROVIDE statements will
8122 trigger to provide any needed symbols. The regions origins and
8123 lengths are not assigned as a result of this call. */
8124 lang_do_memory_regions (false);
8126 /* Create a bfd for each input file. */
8127 current_target
= default_target
;
8128 lang_statement_iteration
++;
8129 open_input_bfds (statement_list
.head
, NULL
, OPEN_BFD_NORMAL
);
8131 /* Now that open_input_bfds has processed assignments and provide
8132 statements we can give values to symbolic origin/length now. */
8133 lang_do_memory_regions (true);
8135 ldemul_before_plugin_all_symbols_read ();
8137 #if BFD_SUPPORTS_PLUGINS
8138 if (link_info
.lto_plugin_active
)
8140 lang_statement_list_type added
;
8141 lang_statement_list_type files
, inputfiles
;
8143 /* Now all files are read, let the plugin(s) decide if there
8144 are any more to be added to the link before we call the
8145 emulation's after_open hook. We create a private list of
8146 input statements for this purpose, which we will eventually
8147 insert into the global statement list after the first claimed
8150 /* We need to manipulate all three chains in synchrony. */
8152 inputfiles
= input_file_chain
;
8153 if (plugin_call_all_symbols_read ())
8154 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
8155 plugin_error_plugin ());
8156 link_info
.lto_all_symbols_read
= true;
8157 /* Open any newly added files, updating the file chains. */
8158 plugin_undefs
= link_info
.hash
->undefs_tail
;
8159 lang_output_section_statement_type
*last_os
= NULL
;
8160 if (lang_os_list
.head
!= NULL
)
8161 last_os
= ((lang_output_section_statement_type
*)
8162 ((char *) lang_os_list
.tail
8163 - offsetof (lang_output_section_statement_type
, next
)));
8164 open_input_bfds (*added
.tail
, last_os
, OPEN_BFD_NORMAL
);
8165 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
8166 plugin_undefs
= NULL
;
8167 /* Restore the global list pointer now they have all been added. */
8168 lang_list_remove_tail (stat_ptr
, &added
);
8169 /* And detach the fresh ends of the file lists. */
8170 lang_list_remove_tail (&file_chain
, &files
);
8171 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
8172 /* Were any new files added? */
8173 if (added
.head
!= NULL
)
8175 /* If so, we will insert them into the statement list immediately
8176 after the first input file that was claimed by the plugin,
8177 unless that file was an archive in which case it is inserted
8178 immediately before. */
8180 lang_statement_union_type
**prev
;
8181 plugin_insert
= find_replacements_insert_point (&before
);
8182 /* If a plugin adds input files without having claimed any, we
8183 don't really have a good idea where to place them. Just putting
8184 them at the start or end of the list is liable to leave them
8185 outside the crtbegin...crtend range. */
8186 ASSERT (plugin_insert
!= NULL
);
8187 /* Splice the new statement list into the old one. */
8188 prev
= &plugin_insert
->header
.next
;
8191 prev
= find_next_input_statement (prev
);
8192 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8194 /* We didn't find the expected input statement.
8195 Fall back to adding after plugin_insert. */
8196 prev
= &plugin_insert
->header
.next
;
8199 lang_list_insert_after (stat_ptr
, &added
, prev
);
8200 /* Likewise for the file chains. */
8201 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8202 (void *) &plugin_insert
->next_real_file
);
8203 /* We must be careful when relinking file_chain; we may need to
8204 insert the new files at the head of the list if the insert
8205 point chosen is the dummy first input file. */
8206 if (plugin_insert
->filename
)
8207 lang_list_insert_after (&file_chain
, &files
,
8208 (void *) &plugin_insert
->next
);
8210 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8212 /* Rescan archives in case new undefined symbols have appeared. */
8214 lang_statement_iteration
++;
8215 open_input_bfds (statement_list
.head
, NULL
, OPEN_BFD_RESCAN
);
8216 lang_list_remove_tail (&file_chain
, &files
);
8217 while (files
.head
!= NULL
)
8219 lang_input_statement_type
**insert
;
8220 lang_input_statement_type
**iter
, *temp
;
8223 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8224 /* All elements from an archive can be added at once. */
8225 iter
= &files
.head
->input_statement
.next
;
8226 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8227 if (my_arch
!= NULL
)
8228 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8229 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8232 *insert
= &files
.head
->input_statement
;
8233 files
.head
= (lang_statement_union_type
*) *iter
;
8235 if (file_chain
.tail
== (lang_statement_union_type
**) insert
)
8236 file_chain
.tail
= (lang_statement_union_type
**) iter
;
8237 if (my_arch
!= NULL
)
8239 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8241 parent
->next
= (lang_input_statement_type
*)
8243 - offsetof (lang_input_statement_type
, next
));
8248 #endif /* BFD_SUPPORTS_PLUGINS */
8250 struct bfd_sym_chain
**sym
= &link_info
.gc_sym_list
;
8252 sym
= &(*sym
)->next
;
8254 *sym
= &entry_symbol
;
8256 if (entry_symbol
.name
== NULL
)
8258 *sym
= ldlang_undef_chain_list_head
;
8260 /* entry_symbol is normally initialised by an ENTRY definition in the
8261 linker script or the -e command line option. But if neither of
8262 these have been used, the target specific backend may still have
8263 provided an entry symbol via a call to lang_default_entry().
8264 Unfortunately this value will not be processed until lang_end()
8265 is called, long after this function has finished. So detect this
8266 case here and add the target's entry symbol to the list of starting
8267 points for garbage collection resolution. */
8268 lang_add_gc_name (entry_symbol_default
);
8271 lang_add_gc_name (link_info
.init_function
);
8272 lang_add_gc_name (link_info
.fini_function
);
8274 ldemul_after_open ();
8275 if (config
.map_file
!= NULL
)
8276 lang_print_asneeded ();
8280 bfd_section_already_linked_table_free ();
8282 /* Make sure that we're not mixing architectures. We call this
8283 after all the input files have been opened, but before we do any
8284 other processing, so that any operations merge_private_bfd_data
8285 does on the output file will be known during the rest of the
8289 /* Handle .exports instead of a version script if we're told to do so. */
8290 if (command_line
.version_exports_section
)
8291 lang_do_version_exports_section ();
8293 /* Build all sets based on the information gathered from the input
8295 ldctor_build_sets ();
8297 lang_symbol_tweaks ();
8299 /* PR 13683: We must rerun the assignments prior to running garbage
8300 collection in order to make sure that all symbol aliases are resolved. */
8301 lang_do_assignments (lang_mark_phase_enum
);
8302 expld
.phase
= lang_first_phase_enum
;
8304 /* Size up the common data. */
8308 debug_prefix_tree ();
8312 /* Remove unreferenced sections if asked to. */
8313 lang_gc_sections ();
8315 lang_mark_undefineds ();
8317 /* Check relocations. */
8318 lang_check_relocs ();
8320 ldemul_after_check_relocs ();
8322 /* There might have been new sections created (e.g. as result of
8323 checking relocs to need a .got, or suchlike), so to properly order
8324 them into our lists of matching sections reset them here. */
8325 reset_resolved_wilds ();
8328 /* Update wild statements in case the user gave --sort-section.
8329 Note how the option might have come after the linker script and
8330 so couldn't have been set when the wild statements were created. */
8331 update_wild_statements (statement_list
.head
);
8333 /* Run through the contours of the script and attach input sections
8334 to the correct output sections. */
8335 lang_statement_iteration
++;
8336 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8338 /* Start at the statement immediately after the special abs_section
8339 output statement, so that it isn't reordered. */
8340 process_insert_statements (&lang_os_list
.head
->header
.next
);
8342 ldemul_before_place_orphans ();
8344 /* Find any sections not attached explicitly and handle them. */
8345 lang_place_orphans ();
8347 if (!bfd_link_relocatable (&link_info
))
8351 /* Merge SEC_MERGE sections. This has to be done after GC of
8352 sections, so that GCed sections are not merged, but before
8353 assigning dynamic symbols, since removing whole input sections
8355 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8357 /* Look for a text section and set the readonly attribute in it. */
8358 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8362 if (config
.text_read_only
)
8363 found
->flags
|= SEC_READONLY
;
8365 found
->flags
&= ~SEC_READONLY
;
8369 /* Merge together CTF sections. After this, only the symtab-dependent
8370 function and data object sections need adjustment. */
8373 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8374 examining things laid out late, like the strtab. */
8377 /* Copy forward lma regions for output sections in same lma region. */
8378 lang_propagate_lma_regions ();
8380 /* Defining __start/__stop symbols early for --gc-sections to work
8381 around a glibc build problem can result in these symbols being
8382 defined when they should not be. Fix them now. */
8383 if (config
.build_constructors
)
8384 lang_undef_start_stop ();
8386 /* Define .startof./.sizeof. symbols with preliminary values before
8387 dynamic symbols are created. */
8388 if (!bfd_link_relocatable (&link_info
))
8389 lang_init_startof_sizeof ();
8391 /* Do anything special before sizing sections. This is where ELF
8392 and other back-ends size dynamic sections. */
8393 ldemul_before_allocation ();
8395 /* We must record the program headers before we try to fix the
8396 section positions, since they will affect SIZEOF_HEADERS. */
8397 lang_record_phdrs ();
8399 /* Check relro sections. */
8400 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8401 lang_find_relro_sections ();
8403 /* Size up the sections. */
8404 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8406 /* See if anything special should be done now we know how big
8407 everything is. This is where relaxation is done. */
8408 ldemul_after_allocation ();
8410 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8411 lang_finalize_start_stop ();
8413 /* Do all the assignments again, to report errors. Assignment
8414 statements are processed multiple times, updating symbols; In
8415 open_input_bfds, lang_do_assignments, and lang_size_sections.
8416 Since lang_relax_sections calls lang_do_assignments, symbols are
8417 also updated in ldemul_after_allocation. */
8418 lang_do_assignments (lang_final_phase_enum
);
8422 /* Convert absolute symbols to section relative. */
8423 ldexp_finalize_syms ();
8425 /* Make sure that the section addresses make sense. */
8426 if (command_line
.check_section_addresses
)
8427 lang_check_section_addresses ();
8429 if (link_info
.non_contiguous_regions
8430 && link_info
.non_contiguous_regions_warnings
)
8431 warn_non_contiguous_discards ();
8433 /* Check any required symbols are known. */
8434 ldlang_check_require_defined_symbols ();
8440 lang_add_version_string (void)
8442 if (! enable_linker_version
)
8445 const char * str
= "GNU ld ";
8446 int len
= strlen (str
);
8449 for (i
= 0 ; i
< len
; i
++)
8450 lang_add_data (BYTE
, exp_intop (str
[i
]));
8452 str
= BFD_VERSION_STRING
;
8455 for (i
= 0 ; i
< len
; i
++)
8456 lang_add_data (BYTE
, exp_intop (str
[i
]));
8458 lang_add_data (BYTE
, exp_intop ('\0'));
8461 /* EXPORTED TO YACC */
8464 lang_add_wild (struct wildcard_spec
*filespec
,
8465 struct wildcard_list
*section_list
,
8468 struct wildcard_list
*curr
, *next
;
8469 lang_wild_statement_type
*new_stmt
;
8470 bool any_specs_sorted
= false;
8472 /* Reverse the list as the parser puts it back to front. */
8473 for (curr
= section_list
, section_list
= NULL
;
8475 section_list
= curr
, curr
= next
)
8477 if (curr
->spec
.sorted
!= none
&& curr
->spec
.sorted
!= by_none
)
8478 any_specs_sorted
= true;
8480 curr
->next
= section_list
;
8483 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8485 if (strcmp (filespec
->name
, "*") == 0)
8486 filespec
->name
= NULL
;
8487 else if (!wildcardp (filespec
->name
))
8488 lang_has_input_file
= true;
8491 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8492 new_stmt
->filename
= NULL
;
8493 new_stmt
->filenames_sorted
= false;
8494 new_stmt
->any_specs_sorted
= any_specs_sorted
;
8495 new_stmt
->section_flag_list
= NULL
;
8496 new_stmt
->exclude_name_list
= NULL
;
8497 if (filespec
!= NULL
)
8499 new_stmt
->filename
= filespec
->name
;
8500 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8501 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8502 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8504 new_stmt
->section_list
= section_list
;
8505 new_stmt
->keep_sections
= keep_sections
;
8506 lang_list_init (&new_stmt
->children
);
8507 lang_list_init (&new_stmt
->matching_sections
);
8508 analyze_walk_wild_section_handler (new_stmt
);
8511 printf ("wild %s(", new_stmt
->filename
? new_stmt
->filename
: "*");
8512 for (curr
= new_stmt
->section_list
; curr
; curr
= curr
->next
)
8513 printf ("%s ", curr
->spec
.name
? curr
->spec
.name
: "*");
8519 lang_section_start (const char *name
, etree_type
*address
,
8520 const segment_type
*segment
)
8522 lang_address_statement_type
*ad
;
8524 ad
= new_stat (lang_address_statement
, stat_ptr
);
8525 ad
->section_name
= name
;
8526 ad
->address
= address
;
8527 ad
->segment
= segment
;
8530 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8531 because of a -e argument on the command line, or zero if this is
8532 called by ENTRY in a linker script. Command line arguments take
8536 lang_add_entry (const char *name
, bool cmdline
)
8538 if (entry_symbol
.name
== NULL
8540 || !entry_from_cmdline
)
8542 entry_symbol
.name
= name
;
8543 entry_from_cmdline
= cmdline
;
8547 /* Set the default start symbol to NAME. .em files should use this,
8548 not lang_add_entry, to override the use of "start" if neither the
8549 linker script nor the command line specifies an entry point. NAME
8550 must be permanently allocated. */
8552 lang_default_entry (const char *name
)
8554 entry_symbol_default
= name
;
8558 lang_add_target (const char *name
)
8560 lang_target_statement_type
*new_stmt
;
8562 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8563 new_stmt
->target
= name
;
8567 lang_add_map (const char *name
)
8574 map_option_f
= true;
8582 lang_add_fill (fill_type
*fill
)
8584 lang_fill_statement_type
*new_stmt
;
8586 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8587 new_stmt
->fill
= fill
;
8591 lang_add_data (int type
, union etree_union
*exp
)
8593 lang_data_statement_type
*new_stmt
;
8595 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8596 new_stmt
->exp
= exp
;
8597 new_stmt
->type
= type
;
8601 lang_add_string (const char *s
)
8603 bfd_vma len
= strlen (s
);
8605 bool escape
= false;
8607 /* Add byte expressions until end of string. */
8608 for (i
= 0 ; i
< len
; i
++)
8617 /* Ignore the escape. */
8620 case 'n': c
= '\n'; break;
8621 case 'r': c
= '\r'; break;
8622 case 't': c
= '\t'; break;
8632 /* We have an octal number. */
8634 unsigned int value
= c
- '0';
8637 if ((c
>= '0') && (c
<= '7'))
8645 if ((c
>= '0') && (c
<= '7'))
8656 /* octal: \777 is treated as '\077' + '7' */
8667 lang_add_data (BYTE
, exp_intop (c
));
8675 lang_add_data (BYTE
, exp_intop (c
));
8679 /* Remeber to terminate the string. */
8680 lang_add_data (BYTE
, exp_intop (0));
8683 /* Create a new reloc statement. RELOC is the BFD relocation type to
8684 generate. HOWTO is the corresponding howto structure (we could
8685 look this up, but the caller has already done so). SECTION is the
8686 section to generate a reloc against, or NAME is the name of the
8687 symbol to generate a reloc against. Exactly one of SECTION and
8688 NAME must be NULL. ADDEND is an expression for the addend. */
8691 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8692 reloc_howto_type
*howto
,
8695 union etree_union
*addend
)
8697 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8701 p
->section
= section
;
8703 p
->addend_exp
= addend
;
8705 p
->addend_value
= 0;
8706 p
->output_section
= NULL
;
8707 p
->output_offset
= 0;
8710 lang_assignment_statement_type
*
8711 lang_add_assignment (etree_type
*exp
)
8713 lang_assignment_statement_type
*new_stmt
;
8715 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8716 new_stmt
->exp
= exp
;
8721 lang_add_attribute (enum statement_enum attribute
)
8723 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8727 lang_startup (const char *name
)
8729 if (first_file
->filename
!= NULL
)
8731 einfo (_("%F%P: multiple STARTUP files\n"));
8733 first_file
->filename
= name
;
8734 first_file
->local_sym_name
= name
;
8735 first_file
->flags
.real
= true;
8739 lang_float (bool maybe
)
8741 lang_float_flag
= maybe
;
8745 /* Work out the load- and run-time regions from a script statement, and
8746 store them in *LMA_REGION and *REGION respectively.
8748 MEMSPEC is the name of the run-time region, or the value of
8749 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8750 LMA_MEMSPEC is the name of the load-time region, or null if the
8751 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8752 had an explicit load address.
8754 It is an error to specify both a load region and a load address. */
8757 lang_get_regions (lang_memory_region_type
**region
,
8758 lang_memory_region_type
**lma_region
,
8759 const char *memspec
,
8760 const char *lma_memspec
,
8764 *lma_region
= lang_memory_region_lookup (lma_memspec
, false);
8766 /* If no runtime region or VMA has been specified, but the load region
8767 has been specified, then use the load region for the runtime region
8769 if (lma_memspec
!= NULL
8771 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8772 *region
= *lma_region
;
8774 *region
= lang_memory_region_lookup (memspec
, false);
8776 if (have_lma
&& lma_memspec
!= 0)
8777 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8782 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8783 lang_output_section_phdr_list
*phdrs
,
8784 const char *lma_memspec
)
8786 lang_get_regions (¤t_section
->region
,
8787 ¤t_section
->lma_region
,
8788 memspec
, lma_memspec
,
8789 current_section
->load_base
!= NULL
,
8790 current_section
->addr_tree
!= NULL
);
8792 current_section
->fill
= fill
;
8793 current_section
->phdrs
= phdrs
;
8797 /* Set the output format type. -oformat overrides scripts. */
8800 lang_add_output_format (const char *format
,
8805 if (output_target
== NULL
|| !from_script
)
8807 if (command_line
.endian
== ENDIAN_BIG
8810 else if (command_line
.endian
== ENDIAN_LITTLE
8814 output_target
= format
;
8819 lang_add_insert (const char *where
, int is_before
)
8821 lang_insert_statement_type
*new_stmt
;
8823 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8824 new_stmt
->where
= where
;
8825 new_stmt
->is_before
= is_before
;
8826 saved_script_handle
= previous_script_handle
;
8829 /* Enter a group. This creates a new lang_group_statement, and sets
8830 stat_ptr to build new statements within the group. */
8833 lang_enter_group (void)
8835 lang_group_statement_type
*g
;
8837 g
= new_stat (lang_group_statement
, stat_ptr
);
8838 lang_list_init (&g
->children
);
8839 push_stat_ptr (&g
->children
);
8842 /* Leave a group. This just resets stat_ptr to start writing to the
8843 regular list of statements again. Note that this will not work if
8844 groups can occur inside anything else which can adjust stat_ptr,
8845 but currently they can't. */
8848 lang_leave_group (void)
8853 /* Add a new program header. This is called for each entry in a PHDRS
8854 command in a linker script. */
8857 lang_new_phdr (const char *name
,
8864 struct lang_phdr
*n
, **pp
;
8867 n
= stat_alloc (sizeof (struct lang_phdr
));
8870 n
->type
= exp_get_vma (type
, NULL
, 0, "program header type");
8871 n
->filehdr
= filehdr
;
8876 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8878 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8881 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8883 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8884 " when prior PT_LOAD headers lack them\n"), NULL
);
8891 /* Record the program header information in the output BFD. FIXME: We
8892 should not be calling an ELF specific function here. */
8895 lang_record_phdrs (void)
8899 lang_output_section_phdr_list
*last
;
8900 struct lang_phdr
*l
;
8901 lang_output_section_statement_type
*os
;
8904 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8907 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8914 for (os
= (void *) lang_os_list
.head
;
8918 lang_output_section_phdr_list
*pl
;
8920 if (os
->constraint
< 0)
8928 if (os
->sectype
== noload_section
8929 || os
->bfd_section
== NULL
8930 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8933 /* Don't add orphans to PT_INTERP header. */
8939 lang_output_section_statement_type
*tmp_os
;
8941 /* If we have not run across a section with a program
8942 header assigned to it yet, then scan forwards to find
8943 one. This prevents inconsistencies in the linker's
8944 behaviour when a script has specified just a single
8945 header and there are sections in that script which are
8946 not assigned to it, and which occur before the first
8947 use of that header. See here for more details:
8948 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8949 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8952 last
= tmp_os
->phdrs
;
8956 einfo (_("%F%P: no sections assigned to phdrs\n"));
8961 if (os
->bfd_section
== NULL
)
8964 for (; pl
!= NULL
; pl
= pl
->next
)
8966 if (strcmp (pl
->name
, l
->name
) == 0)
8971 secs
= (asection
**) xrealloc (secs
,
8972 alc
* sizeof (asection
*));
8974 secs
[c
] = os
->bfd_section
;
8981 if (l
->flags
== NULL
)
8984 flags
= exp_get_vma (l
->flags
, NULL
, 0, "phdr flags");
8989 at
= exp_get_vma (l
->at
, NULL
, 0, "phdr load address");
8991 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8992 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8993 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8994 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8999 /* Make sure all the phdr assignments succeeded. */
9000 for (os
= (void *) lang_os_list
.head
;
9004 lang_output_section_phdr_list
*pl
;
9006 if (os
->constraint
< 0
9007 || os
->bfd_section
== NULL
)
9010 for (pl
= os
->phdrs
;
9013 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
9014 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
9015 os
->name
, pl
->name
);
9019 /* Record a list of sections which may not be cross referenced. */
9022 lang_add_nocrossref (lang_nocrossref_type
*l
)
9024 struct lang_nocrossrefs
*n
;
9026 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
9027 n
->next
= nocrossref_list
;
9029 n
->onlyfirst
= false;
9030 nocrossref_list
= n
;
9032 /* Set notice_all so that we get informed about all symbols. */
9033 link_info
.notice_all
= true;
9036 /* Record a section that cannot be referenced from a list of sections. */
9039 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
9041 lang_add_nocrossref (l
);
9042 nocrossref_list
->onlyfirst
= true;
9045 /* Overlay handling. We handle overlays with some static variables. */
9047 /* The overlay virtual address. */
9048 static etree_type
*overlay_vma
;
9049 /* And subsection alignment. */
9050 static etree_type
*overlay_subalign
;
9052 /* An expression for the maximum section size seen so far. */
9053 static etree_type
*overlay_max
;
9055 /* A list of all the sections in this overlay. */
9057 struct overlay_list
{
9058 struct overlay_list
*next
;
9059 lang_output_section_statement_type
*os
;
9062 static struct overlay_list
*overlay_list
;
9064 /* Start handling an overlay. */
9067 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
9069 /* The grammar should prevent nested overlays from occurring. */
9070 ASSERT (overlay_vma
== NULL
9071 && overlay_subalign
== NULL
9072 && overlay_max
== NULL
);
9074 overlay_vma
= vma_expr
;
9075 overlay_subalign
= subalign
;
9078 /* Start a section in an overlay. We handle this by calling
9079 lang_enter_output_section_statement with the correct VMA.
9080 lang_leave_overlay sets up the LMA and memory regions. */
9083 lang_enter_overlay_section (const char *name
)
9085 struct overlay_list
*n
;
9088 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
9089 0, 0, overlay_subalign
, 0, 0, 0);
9091 /* If this is the first section, then base the VMA of future
9092 sections on this one. This will work correctly even if `.' is
9093 used in the addresses. */
9094 if (overlay_list
== NULL
)
9095 overlay_vma
= exp_nameop (ADDR
, name
);
9097 /* Remember the section. */
9098 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
9099 n
->os
= current_section
;
9100 n
->next
= overlay_list
;
9103 size
= exp_nameop (SIZEOF
, name
);
9105 /* Arrange to work out the maximum section end address. */
9106 if (overlay_max
== NULL
)
9109 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
9112 /* Finish a section in an overlay. There isn't any special to do
9116 lang_leave_overlay_section (fill_type
*fill
,
9117 lang_output_section_phdr_list
*phdrs
)
9124 name
= current_section
->name
;
9126 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
9127 region and that no load-time region has been specified. It doesn't
9128 really matter what we say here, since lang_leave_overlay will
9130 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
9132 /* Define the magic symbols. */
9134 clean
= (char *) xmalloc (strlen (name
) + 1);
9136 for (s1
= name
; *s1
!= '\0'; s1
++)
9137 if (ISALNUM (*s1
) || *s1
== '_')
9141 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
9142 sprintf (buf
, "__load_start_%s", clean
);
9143 lang_add_assignment (exp_provide (buf
,
9144 exp_nameop (LOADADDR
, name
),
9147 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
9148 sprintf (buf
, "__load_stop_%s", clean
);
9149 lang_add_assignment (exp_provide (buf
,
9151 exp_nameop (LOADADDR
, name
),
9152 exp_nameop (SIZEOF
, name
)),
9158 /* Finish an overlay. If there are any overlay wide settings, this
9159 looks through all the sections in the overlay and sets them. */
9162 lang_leave_overlay (etree_type
*lma_expr
,
9165 const char *memspec
,
9166 lang_output_section_phdr_list
*phdrs
,
9167 const char *lma_memspec
)
9169 lang_memory_region_type
*region
;
9170 lang_memory_region_type
*lma_region
;
9171 struct overlay_list
*l
;
9172 lang_nocrossref_type
*nocrossref
;
9174 lang_get_regions (®ion
, &lma_region
,
9175 memspec
, lma_memspec
,
9176 lma_expr
!= NULL
, false);
9180 /* After setting the size of the last section, set '.' to end of the
9182 if (overlay_list
!= NULL
)
9184 overlay_list
->os
->update_dot
= 1;
9185 overlay_list
->os
->update_dot_tree
9186 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), false);
9192 struct overlay_list
*next
;
9194 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
9197 l
->os
->region
= region
;
9198 l
->os
->lma_region
= lma_region
;
9200 /* The first section has the load address specified in the
9201 OVERLAY statement. The rest are worked out from that.
9202 The base address is not needed (and should be null) if
9203 an LMA region was specified. */
9206 l
->os
->load_base
= lma_expr
;
9207 l
->os
->sectype
= first_overlay_section
;
9209 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
9210 l
->os
->phdrs
= phdrs
;
9214 lang_nocrossref_type
*nc
;
9216 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
9217 nc
->name
= l
->os
->name
;
9218 nc
->next
= nocrossref
;
9227 if (nocrossref
!= NULL
)
9228 lang_add_nocrossref (nocrossref
);
9231 overlay_list
= NULL
;
9233 overlay_subalign
= NULL
;
9236 /* Version handling. This is only useful for ELF. */
9238 /* If PREV is NULL, return first version pattern matching particular symbol.
9239 If PREV is non-NULL, return first version pattern matching particular
9240 symbol after PREV (previously returned by lang_vers_match). */
9242 static struct bfd_elf_version_expr
*
9243 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
9244 struct bfd_elf_version_expr
*prev
,
9248 const char *cxx_sym
= sym
;
9249 const char *java_sym
= sym
;
9250 struct bfd_elf_version_expr
*expr
= NULL
;
9251 enum demangling_styles curr_style
;
9253 curr_style
= CURRENT_DEMANGLING_STYLE
;
9254 cplus_demangle_set_style (no_demangling
);
9255 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
9258 cplus_demangle_set_style (curr_style
);
9260 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9262 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
9263 DMGL_PARAMS
| DMGL_ANSI
);
9267 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9269 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
9274 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
9276 struct bfd_elf_version_expr e
;
9278 switch (prev
? prev
->mask
: 0)
9281 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
9284 expr
= (struct bfd_elf_version_expr
*)
9285 htab_find ((htab_t
) head
->htab
, &e
);
9286 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
9287 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
9293 case BFD_ELF_VERSION_C_TYPE
:
9294 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9296 e
.pattern
= cxx_sym
;
9297 expr
= (struct bfd_elf_version_expr
*)
9298 htab_find ((htab_t
) head
->htab
, &e
);
9299 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
9300 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9306 case BFD_ELF_VERSION_CXX_TYPE
:
9307 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9309 e
.pattern
= java_sym
;
9310 expr
= (struct bfd_elf_version_expr
*)
9311 htab_find ((htab_t
) head
->htab
, &e
);
9312 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9313 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9324 /* Finally, try the wildcards. */
9325 if (prev
== NULL
|| prev
->literal
)
9326 expr
= head
->remaining
;
9329 for (; expr
; expr
= expr
->next
)
9336 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9339 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9341 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9345 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9351 free ((char *) c_sym
);
9353 free ((char *) cxx_sym
);
9354 if (java_sym
!= sym
)
9355 free ((char *) java_sym
);
9359 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9360 return a pointer to the symbol name with any backslash quotes removed. */
9363 realsymbol (const char *pattern
)
9366 bool changed
= false, backslash
= false;
9367 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9369 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9371 /* It is a glob pattern only if there is no preceding
9375 /* Remove the preceding backslash. */
9382 if (*p
== '?' || *p
== '*' || *p
== '[')
9389 backslash
= *p
== '\\';
9405 /* This is called for each variable name or match expression. NEW_NAME is
9406 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9407 pattern to be matched against symbol names. */
9409 struct bfd_elf_version_expr
*
9410 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9411 const char *new_name
,
9415 struct bfd_elf_version_expr
*ret
;
9417 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9421 ret
->literal
= true;
9422 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9423 if (ret
->pattern
== NULL
)
9425 ret
->pattern
= new_name
;
9426 ret
->literal
= false;
9429 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9430 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9431 else if (strcasecmp (lang
, "C++") == 0)
9432 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9433 else if (strcasecmp (lang
, "Java") == 0)
9434 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9437 einfo (_("%X%P: unknown language `%s' in version information\n"),
9439 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9442 return ldemul_new_vers_pattern (ret
);
9445 /* This is called for each set of variable names and match
9448 struct bfd_elf_version_tree
*
9449 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9450 struct bfd_elf_version_expr
*locals
)
9452 struct bfd_elf_version_tree
*ret
;
9454 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9455 ret
->globals
.list
= globals
;
9456 ret
->locals
.list
= locals
;
9457 ret
->match
= lang_vers_match
;
9458 ret
->name_indx
= (unsigned int) -1;
9462 /* This static variable keeps track of version indices. */
9464 static int version_index
;
9467 version_expr_head_hash (const void *p
)
9469 const struct bfd_elf_version_expr
*e
=
9470 (const struct bfd_elf_version_expr
*) p
;
9472 return htab_hash_string (e
->pattern
);
9476 version_expr_head_eq (const void *p1
, const void *p2
)
9478 const struct bfd_elf_version_expr
*e1
=
9479 (const struct bfd_elf_version_expr
*) p1
;
9480 const struct bfd_elf_version_expr
*e2
=
9481 (const struct bfd_elf_version_expr
*) p2
;
9483 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9487 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9490 struct bfd_elf_version_expr
*e
, *next
;
9491 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9493 for (e
= head
->list
; e
; e
= e
->next
)
9497 head
->mask
|= e
->mask
;
9502 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9503 version_expr_head_eq
, NULL
);
9504 list_loc
= &head
->list
;
9505 remaining_loc
= &head
->remaining
;
9506 for (e
= head
->list
; e
; e
= next
)
9512 remaining_loc
= &e
->next
;
9516 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9520 struct bfd_elf_version_expr
*e1
, *last
;
9522 e1
= (struct bfd_elf_version_expr
*) *loc
;
9526 if (e1
->mask
== e
->mask
)
9534 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9538 /* This is a duplicate. */
9539 /* FIXME: Memory leak. Sometimes pattern is not
9540 xmalloced alone, but in larger chunk of memory. */
9541 /* free (e->pattern); */
9546 e
->next
= last
->next
;
9554 list_loc
= &e
->next
;
9558 *remaining_loc
= NULL
;
9559 *list_loc
= head
->remaining
;
9562 head
->remaining
= head
->list
;
9565 /* This is called when we know the name and dependencies of the
9569 lang_register_vers_node (const char *name
,
9570 struct bfd_elf_version_tree
*version
,
9571 struct bfd_elf_version_deps
*deps
)
9573 struct bfd_elf_version_tree
*t
, **pp
;
9574 struct bfd_elf_version_expr
*e1
;
9579 if (link_info
.version_info
!= NULL
9580 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9582 einfo (_("%X%P: anonymous version tag cannot be combined"
9583 " with other version tags\n"));
9588 /* Make sure this node has a unique name. */
9589 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9590 if (strcmp (t
->name
, name
) == 0)
9591 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9593 lang_finalize_version_expr_head (&version
->globals
);
9594 lang_finalize_version_expr_head (&version
->locals
);
9596 /* Check the global and local match names, and make sure there
9597 aren't any duplicates. */
9599 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9601 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9603 struct bfd_elf_version_expr
*e2
;
9605 if (t
->locals
.htab
&& e1
->literal
)
9607 e2
= (struct bfd_elf_version_expr
*)
9608 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9609 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9611 if (e1
->mask
== e2
->mask
)
9612 einfo (_("%X%P: duplicate expression `%s'"
9613 " in version information\n"), e1
->pattern
);
9617 else if (!e1
->literal
)
9618 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9619 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9620 && e1
->mask
== e2
->mask
)
9621 einfo (_("%X%P: duplicate expression `%s'"
9622 " in version information\n"), e1
->pattern
);
9626 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9628 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9630 struct bfd_elf_version_expr
*e2
;
9632 if (t
->globals
.htab
&& e1
->literal
)
9634 e2
= (struct bfd_elf_version_expr
*)
9635 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9636 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9638 if (e1
->mask
== e2
->mask
)
9639 einfo (_("%X%P: duplicate expression `%s'"
9640 " in version information\n"),
9645 else if (!e1
->literal
)
9646 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9647 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9648 && e1
->mask
== e2
->mask
)
9649 einfo (_("%X%P: duplicate expression `%s'"
9650 " in version information\n"), e1
->pattern
);
9654 version
->deps
= deps
;
9655 version
->name
= name
;
9656 if (name
[0] != '\0')
9659 version
->vernum
= version_index
;
9662 version
->vernum
= 0;
9664 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9669 /* This is called when we see a version dependency. */
9671 struct bfd_elf_version_deps
*
9672 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9674 struct bfd_elf_version_deps
*ret
;
9675 struct bfd_elf_version_tree
*t
;
9677 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9680 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9682 if (strcmp (t
->name
, name
) == 0)
9684 ret
->version_needed
= t
;
9689 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9691 ret
->version_needed
= NULL
;
9696 lang_do_version_exports_section (void)
9698 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9700 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9702 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9710 contents
= (char *) xmalloc (len
);
9711 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9712 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9715 while (p
< contents
+ len
)
9717 greg
= lang_new_vers_pattern (greg
, p
, NULL
, false);
9718 p
= strchr (p
, '\0') + 1;
9721 /* Do not free the contents, as we used them creating the regex. */
9723 /* Do not include this section in the link. */
9724 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9727 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, false);
9728 lang_register_vers_node (command_line
.version_exports_section
,
9729 lang_new_vers_node (greg
, lreg
), NULL
);
9732 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9733 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9734 thrown, however, references to symbols in the origin and length fields
9735 will be pushed into the symbol table, this allows PROVIDE statements to
9736 then provide these symbols. This function is called a second time with
9737 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9738 data structures, and throw errors if missing symbols are encountered. */
9741 lang_do_memory_regions (bool update_regions_p
)
9743 lang_memory_region_type
*r
= lang_memory_region_list
;
9745 for (; r
!= NULL
; r
= r
->next
)
9749 exp_fold_tree_no_dot (r
->origin_exp
, NULL
);
9750 if (update_regions_p
)
9752 if (expld
.result
.valid_p
)
9754 r
->origin
= expld
.result
.value
;
9755 r
->current
= r
->origin
;
9758 einfo (_("%P: invalid origin for memory region %s\n"),
9764 exp_fold_tree_no_dot (r
->length_exp
, NULL
);
9765 if (update_regions_p
)
9767 if (expld
.result
.valid_p
)
9768 r
->length
= expld
.result
.value
;
9770 einfo (_("%P: invalid length for memory region %s\n"),
9778 lang_add_unique (const char *name
)
9780 struct unique_sections
*ent
;
9782 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9783 if (strcmp (ent
->name
, name
) == 0)
9786 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9787 ent
->name
= xstrdup (name
);
9788 ent
->next
= unique_section_list
;
9789 unique_section_list
= ent
;
9792 /* Append the list of dynamic symbols to the existing one. */
9795 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9796 struct bfd_elf_version_expr
*dynamic
)
9800 struct bfd_elf_version_expr
*tail
;
9801 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9803 tail
->next
= (*list_p
)->head
.list
;
9804 (*list_p
)->head
.list
= dynamic
;
9808 struct bfd_elf_dynamic_list
*d
;
9810 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9811 d
->head
.list
= dynamic
;
9812 d
->match
= lang_vers_match
;
9817 /* Append the list of C++ typeinfo dynamic symbols to the existing
9821 lang_append_dynamic_list_cpp_typeinfo (void)
9823 const char *symbols
[] =
9825 "typeinfo name for*",
9828 struct bfd_elf_version_expr
*dynamic
= NULL
;
9831 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9832 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9835 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9838 /* Append the list of C++ operator new and delete dynamic symbols to the
9842 lang_append_dynamic_list_cpp_new (void)
9844 const char *symbols
[] =
9849 struct bfd_elf_version_expr
*dynamic
= NULL
;
9852 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9853 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9856 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9859 /* Scan a space and/or comma separated string of features. */
9862 lang_ld_feature (char *str
)
9870 while (*p
== ',' || ISSPACE (*p
))
9875 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9879 if (strcasecmp (p
, "SANE_EXPR") == 0)
9880 config
.sane_expr
= true;
9882 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9888 /* Pretty print memory amount. */
9891 lang_print_memory_size (uint64_t sz
)
9893 if ((sz
& 0x3fffffff) == 0)
9894 printf ("%10" PRIu64
" GB", sz
>> 30);
9895 else if ((sz
& 0xfffff) == 0)
9896 printf ("%10" PRIu64
" MB", sz
>> 20);
9897 else if ((sz
& 0x3ff) == 0)
9898 printf ("%10" PRIu64
" KB", sz
>> 10);
9900 printf (" %10" PRIu64
" B", sz
);
9903 /* Implement --print-memory-usage: disply per region memory usage. */
9906 lang_print_memory_usage (void)
9908 lang_memory_region_type
*r
;
9910 printf ("Memory region Used Size Region Size %%age Used\n");
9911 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9913 bfd_vma used_length
= r
->current
- r
->origin
;
9915 printf ("%16s: ",r
->name_list
.name
);
9916 lang_print_memory_size (used_length
);
9917 lang_print_memory_size (r
->length
);
9921 double percent
= used_length
* 100.0 / r
->length
;
9922 printf (" %6.2f%%", percent
);