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 name
= ldfile_possibly_remap_input (name
);
1143 p
= new_stat (lang_input_statement
, stat_ptr
);
1144 memset (&p
->the_bfd
, 0,
1145 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1146 p
->extra_search_path
= NULL
;
1148 p
->flags
.dynamic
= input_flags
.dynamic
;
1149 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1150 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1151 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1152 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1157 case lang_input_file_is_symbols_only_enum
:
1159 p
->local_sym_name
= name
;
1160 p
->flags
.real
= true;
1161 p
->flags
.just_syms
= true;
1163 case lang_input_file_is_fake_enum
:
1165 p
->local_sym_name
= name
;
1167 case lang_input_file_is_l_enum
:
1168 if (name
[0] == ':' && name
[1] != '\0')
1170 p
->filename
= name
+ 1;
1171 p
->flags
.full_name_provided
= true;
1175 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1176 p
->flags
.maybe_archive
= true;
1177 p
->flags
.real
= true;
1178 p
->flags
.search_dirs
= true;
1180 case lang_input_file_is_marker_enum
:
1182 p
->local_sym_name
= name
;
1183 p
->flags
.search_dirs
= true;
1185 case lang_input_file_is_search_file_enum
:
1187 p
->local_sym_name
= name
;
1188 /* If name is a relative path, search the directory of the current linker
1190 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1191 p
->extra_search_path
= ldirname (from_filename
);
1192 p
->flags
.real
= true;
1193 p
->flags
.search_dirs
= true;
1195 case lang_input_file_is_file_enum
:
1197 p
->local_sym_name
= name
;
1198 p
->flags
.real
= true;
1204 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1208 lang_input_statement_type
*
1209 lang_add_input_file (const char *name
,
1210 lang_input_file_enum_type file_type
,
1214 && (*name
== '=' || startswith (name
, "$SYSROOT")))
1216 lang_input_statement_type
*ret
;
1217 char *sysrooted_name
1218 = concat (ld_sysroot
,
1219 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1220 (const char *) NULL
);
1222 /* We've now forcibly prepended the sysroot, making the input
1223 file independent of the context. Therefore, temporarily
1224 force a non-sysrooted context for this statement, so it won't
1225 get the sysroot prepended again when opened. (N.B. if it's a
1226 script, any child nodes with input files starting with "/"
1227 will be handled as "sysrooted" as they'll be found to be
1228 within the sysroot subdirectory.) */
1229 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1230 input_flags
.sysrooted
= 0;
1231 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1232 input_flags
.sysrooted
= outer_sysrooted
;
1236 return new_afile (name
, file_type
, target
, current_input_file
);
1239 struct out_section_hash_entry
1241 struct bfd_hash_entry root
;
1242 lang_statement_union_type s
;
1245 /* The hash table. */
1247 static struct bfd_hash_table output_section_statement_table
;
1249 /* Support routines for the hash table used by lang_output_section_find,
1250 initialize the table, fill in an entry and remove the table. */
1252 static struct bfd_hash_entry
*
1253 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1254 struct bfd_hash_table
*table
,
1257 lang_output_section_statement_type
**nextp
;
1258 struct out_section_hash_entry
*ret
;
1262 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1268 entry
= bfd_hash_newfunc (entry
, table
, string
);
1272 ret
= (struct out_section_hash_entry
*) entry
;
1273 memset (&ret
->s
, 0, sizeof (ret
->s
));
1274 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1275 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1276 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1277 ret
->s
.output_section_statement
.block_value
= 1;
1278 lang_list_init (&ret
->s
.output_section_statement
.children
);
1279 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1281 /* For every output section statement added to the list, except the
1282 first one, lang_os_list.tail points to the "next"
1283 field of the last element of the list. */
1284 if (lang_os_list
.head
!= NULL
)
1285 ret
->s
.output_section_statement
.prev
1286 = ((lang_output_section_statement_type
*)
1287 ((char *) lang_os_list
.tail
1288 - offsetof (lang_output_section_statement_type
, next
)));
1290 /* GCC's strict aliasing rules prevent us from just casting the
1291 address, so we store the pointer in a variable and cast that
1293 nextp
= &ret
->s
.output_section_statement
.next
;
1294 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1299 output_section_statement_table_init (void)
1301 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1302 output_section_statement_newfunc
,
1303 sizeof (struct out_section_hash_entry
),
1305 einfo (_("%F%P: can not create hash table: %E\n"));
1309 output_section_statement_table_free (void)
1311 bfd_hash_table_free (&output_section_statement_table
);
1314 /* Build enough state so that the parser can build its tree. */
1319 obstack_begin (&stat_obstack
, 1000);
1320 obstack_init (&pt_obstack
);
1322 stat_ptr
= &statement_list
;
1324 output_section_statement_table_init ();
1326 lang_list_init (stat_ptr
);
1328 lang_list_init (&input_file_chain
);
1329 lang_list_init (&lang_os_list
);
1330 lang_list_init (&file_chain
);
1331 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1333 abs_output_section
=
1334 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, 1);
1336 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1338 asneeded_list_head
= NULL
;
1339 asneeded_list_tail
= &asneeded_list_head
;
1345 output_section_statement_table_free ();
1346 ldfile_remap_input_free ();
1349 /*----------------------------------------------------------------------
1350 A region is an area of memory declared with the
1351 MEMORY { name:org=exp, len=exp ... }
1354 We maintain a list of all the regions here.
1356 If no regions are specified in the script, then the default is used
1357 which is created when looked up to be the entire data space.
1359 If create is true we are creating a region inside a MEMORY block.
1360 In this case it is probably an error to create a region that has
1361 already been created. If we are not inside a MEMORY block it is
1362 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1363 and so we issue a warning.
1365 Each region has at least one name. The first name is either
1366 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1367 alias names to an existing region within a script with
1368 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1371 static lang_memory_region_type
*lang_memory_region_list
;
1372 static lang_memory_region_type
**lang_memory_region_list_tail
1373 = &lang_memory_region_list
;
1375 lang_memory_region_type
*
1376 lang_memory_region_lookup (const char *const name
, bool create
)
1378 lang_memory_region_name
*n
;
1379 lang_memory_region_type
*r
;
1380 lang_memory_region_type
*new_region
;
1382 /* NAME is NULL for LMA memspecs if no region was specified. */
1386 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1387 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1388 if (strcmp (n
->name
, name
) == 0)
1391 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1396 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1397 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1400 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1402 new_region
->name_list
.name
= xstrdup (name
);
1403 new_region
->name_list
.next
= NULL
;
1404 new_region
->next
= NULL
;
1405 new_region
->origin_exp
= NULL
;
1406 new_region
->origin
= 0;
1407 new_region
->length_exp
= NULL
;
1408 new_region
->length
= ~(bfd_size_type
) 0;
1409 new_region
->current
= 0;
1410 new_region
->last_os
= NULL
;
1411 new_region
->flags
= 0;
1412 new_region
->not_flags
= 0;
1413 new_region
->had_full_message
= false;
1415 *lang_memory_region_list_tail
= new_region
;
1416 lang_memory_region_list_tail
= &new_region
->next
;
1422 lang_memory_region_alias (const char *alias
, const char *region_name
)
1424 lang_memory_region_name
*n
;
1425 lang_memory_region_type
*r
;
1426 lang_memory_region_type
*region
;
1428 /* The default region must be unique. This ensures that it is not necessary
1429 to iterate through the name list if someone wants the check if a region is
1430 the default memory region. */
1431 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1432 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1433 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1435 /* Look for the target region and check if the alias is not already
1438 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1439 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1441 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1443 if (strcmp (n
->name
, alias
) == 0)
1444 einfo (_("%F%P:%pS: error: redefinition of memory region "
1449 /* Check if the target region exists. */
1451 einfo (_("%F%P:%pS: error: memory region `%s' "
1452 "for alias `%s' does not exist\n"),
1453 NULL
, region_name
, alias
);
1455 /* Add alias to region name list. */
1456 n
= stat_alloc (sizeof (lang_memory_region_name
));
1457 n
->name
= xstrdup (alias
);
1458 n
->next
= region
->name_list
.next
;
1459 region
->name_list
.next
= n
;
1462 static lang_memory_region_type
*
1463 lang_memory_default (asection
*section
)
1465 lang_memory_region_type
*p
;
1467 flagword sec_flags
= section
->flags
;
1469 /* Override SEC_DATA to mean a writable section. */
1470 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1471 sec_flags
|= SEC_DATA
;
1473 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1475 if ((p
->flags
& sec_flags
) != 0
1476 && (p
->not_flags
& sec_flags
) == 0)
1481 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
1484 /* Get the output section statement directly from the userdata. */
1486 lang_output_section_statement_type
*
1487 lang_output_section_get (const asection
*output_section
)
1489 return bfd_section_userdata (output_section
);
1492 /* Find or create an output_section_statement with the given NAME.
1493 If CONSTRAINT is non-zero match one with that constraint, otherwise
1494 match any non-negative constraint. If CREATE is 0 return NULL when
1495 no match exists. If CREATE is 1, create an output_section_statement
1496 when no match exists or if CONSTRAINT is SPECIAL. If CREATE is 2,
1497 always make a new output_section_statement. */
1499 lang_output_section_statement_type
*
1500 lang_output_section_statement_lookup (const char *name
,
1504 struct out_section_hash_entry
*entry
;
1506 entry
= ((struct out_section_hash_entry
*)
1507 bfd_hash_lookup (&output_section_statement_table
, name
,
1508 create
!= 0, false));
1512 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1516 if (entry
->s
.output_section_statement
.name
!= NULL
)
1518 /* We have a section of this name, but it might not have the correct
1520 struct out_section_hash_entry
*last_ent
;
1522 name
= entry
->s
.output_section_statement
.name
;
1526 && !(create
&& constraint
== SPECIAL
)
1527 && (constraint
== entry
->s
.output_section_statement
.constraint
1529 && entry
->s
.output_section_statement
.constraint
>= 0)))
1530 return &entry
->s
.output_section_statement
;
1532 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1534 while (entry
!= NULL
1535 && name
== entry
->s
.output_section_statement
.name
);
1541 = ((struct out_section_hash_entry
*)
1542 output_section_statement_newfunc (NULL
,
1543 &output_section_statement_table
,
1547 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1550 entry
->root
= last_ent
->root
;
1551 last_ent
->root
.next
= &entry
->root
;
1554 entry
->s
.output_section_statement
.name
= name
;
1555 entry
->s
.output_section_statement
.constraint
= constraint
;
1556 entry
->s
.output_section_statement
.dup_output
= (create
== 2
1557 || constraint
== SPECIAL
);
1558 return &entry
->s
.output_section_statement
;
1561 /* Find the next output_section_statement with the same name as OS.
1562 If CONSTRAINT is non-zero, find one with that constraint otherwise
1563 match any non-negative constraint. */
1565 lang_output_section_statement_type
*
1566 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1569 /* All output_section_statements are actually part of a
1570 struct out_section_hash_entry. */
1571 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1573 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1574 const char *name
= os
->name
;
1576 ASSERT (name
== entry
->root
.string
);
1579 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1581 || name
!= entry
->s
.output_section_statement
.name
)
1584 while (constraint
!= entry
->s
.output_section_statement
.constraint
1586 || entry
->s
.output_section_statement
.constraint
< 0));
1588 return &entry
->s
.output_section_statement
;
1591 /* A variant of lang_output_section_find used by place_orphan.
1592 Returns the output statement that should precede a new output
1593 statement for SEC. If an exact match is found on certain flags,
1596 lang_output_section_statement_type
*
1597 lang_output_section_find_by_flags (const asection
*sec
,
1599 lang_output_section_statement_type
**exact
,
1600 lang_match_sec_type_func match_type
)
1602 lang_output_section_statement_type
*first
, *look
, *found
;
1603 flagword look_flags
, differ
;
1605 /* We know the first statement on this list is *ABS*. May as well
1607 first
= (void *) lang_os_list
.head
;
1608 first
= first
->next
;
1610 /* First try for an exact match. */
1612 for (look
= first
; look
; look
= look
->next
)
1614 look_flags
= look
->flags
;
1615 if (look
->bfd_section
!= NULL
)
1617 look_flags
= look
->bfd_section
->flags
;
1618 if (match_type
&& !match_type (link_info
.output_bfd
,
1623 differ
= look_flags
^ sec_flags
;
1624 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1625 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1635 if ((sec_flags
& SEC_CODE
) != 0
1636 && (sec_flags
& SEC_ALLOC
) != 0)
1638 /* Try for a rw code section. */
1639 for (look
= first
; look
; look
= look
->next
)
1641 look_flags
= look
->flags
;
1642 if (look
->bfd_section
!= NULL
)
1644 look_flags
= look
->bfd_section
->flags
;
1645 if (match_type
&& !match_type (link_info
.output_bfd
,
1650 differ
= look_flags
^ sec_flags
;
1651 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1652 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1656 else if ((sec_flags
& SEC_READONLY
) != 0
1657 && (sec_flags
& SEC_ALLOC
) != 0)
1659 /* .rodata can go after .text, .sdata2 after .rodata. */
1660 for (look
= first
; look
; look
= look
->next
)
1662 look_flags
= look
->flags
;
1663 if (look
->bfd_section
!= NULL
)
1665 look_flags
= look
->bfd_section
->flags
;
1666 if (match_type
&& !match_type (link_info
.output_bfd
,
1671 differ
= look_flags
^ sec_flags
;
1672 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1673 | SEC_READONLY
| SEC_SMALL_DATA
))
1674 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1676 && !(look_flags
& SEC_SMALL_DATA
)))
1680 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1681 && (sec_flags
& SEC_ALLOC
) != 0)
1683 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1684 as if it were a loaded section, and don't use match_type. */
1685 bool seen_thread_local
= false;
1688 for (look
= first
; look
; look
= look
->next
)
1690 look_flags
= look
->flags
;
1691 if (look
->bfd_section
!= NULL
)
1692 look_flags
= look
->bfd_section
->flags
;
1694 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1695 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1697 /* .tdata and .tbss must be adjacent and in that order. */
1698 if (!(look_flags
& SEC_LOAD
)
1699 && (sec_flags
& SEC_LOAD
))
1700 /* ..so if we're at a .tbss section and we're placing
1701 a .tdata section stop looking and return the
1702 previous section. */
1705 seen_thread_local
= true;
1707 else if (seen_thread_local
)
1709 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1713 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1714 && (sec_flags
& SEC_ALLOC
) != 0)
1716 /* .sdata goes after .data, .sbss after .sdata. */
1717 for (look
= first
; look
; look
= look
->next
)
1719 look_flags
= look
->flags
;
1720 if (look
->bfd_section
!= NULL
)
1722 look_flags
= look
->bfd_section
->flags
;
1723 if (match_type
&& !match_type (link_info
.output_bfd
,
1728 differ
= look_flags
^ sec_flags
;
1729 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1730 | SEC_THREAD_LOCAL
))
1731 || ((look_flags
& SEC_SMALL_DATA
)
1732 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1736 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1737 && (sec_flags
& SEC_ALLOC
) != 0)
1739 /* .data goes after .rodata. */
1740 for (look
= first
; look
; look
= look
->next
)
1742 look_flags
= look
->flags
;
1743 if (look
->bfd_section
!= NULL
)
1745 look_flags
= look
->bfd_section
->flags
;
1746 if (match_type
&& !match_type (link_info
.output_bfd
,
1751 differ
= look_flags
^ sec_flags
;
1752 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1753 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1757 else if ((sec_flags
& SEC_ALLOC
) != 0)
1759 /* .bss goes after any other alloc section. */
1760 for (look
= first
; look
; look
= look
->next
)
1762 look_flags
= look
->flags
;
1763 if (look
->bfd_section
!= NULL
)
1765 look_flags
= look
->bfd_section
->flags
;
1766 if (match_type
&& !match_type (link_info
.output_bfd
,
1771 differ
= look_flags
^ sec_flags
;
1772 if (!(differ
& SEC_ALLOC
))
1778 /* non-alloc go last. */
1779 for (look
= first
; look
; look
= look
->next
)
1781 look_flags
= look
->flags
;
1782 if (look
->bfd_section
!= NULL
)
1783 look_flags
= look
->bfd_section
->flags
;
1784 differ
= look_flags
^ sec_flags
;
1785 if (!(differ
& SEC_DEBUGGING
))
1791 if (found
|| !match_type
)
1794 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1797 /* Find the last output section before given output statement.
1798 Used by place_orphan. */
1801 output_prev_sec_find (lang_output_section_statement_type
*os
)
1803 lang_output_section_statement_type
*lookup
;
1805 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1807 if (lookup
->constraint
< 0)
1810 if (lookup
->bfd_section
!= NULL
)
1811 return lookup
->bfd_section
;
1817 /* Look for a suitable place for a new output section statement. The
1818 idea is to skip over anything that might be inside a SECTIONS {}
1819 statement in a script, before we find another output section
1820 statement. Assignments to "dot" before an output section statement
1821 are assumed to belong to it, except in two cases; The first
1822 assignment to dot, and assignments before non-alloc sections.
1823 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1824 similar assignments that set the initial address, or we might
1825 insert non-alloc note sections among assignments setting end of
1828 static lang_statement_union_type
**
1829 insert_os_after (lang_statement_union_type
*after
)
1831 lang_statement_union_type
**where
;
1832 lang_statement_union_type
**assign
= NULL
;
1835 ignore_first
= after
== lang_os_list
.head
;
1837 for (where
= &after
->header
.next
;
1839 where
= &(*where
)->header
.next
)
1841 switch ((*where
)->header
.type
)
1843 case lang_assignment_statement_enum
:
1846 lang_assignment_statement_type
*ass
;
1848 ass
= &(*where
)->assignment_statement
;
1849 if (ass
->exp
->type
.node_class
!= etree_assert
1850 && ass
->exp
->assign
.dst
[0] == '.'
1851 && ass
->exp
->assign
.dst
[1] == 0)
1855 ignore_first
= false;
1859 case lang_wild_statement_enum
:
1860 case lang_input_section_enum
:
1861 case lang_object_symbols_statement_enum
:
1862 case lang_fill_statement_enum
:
1863 case lang_data_statement_enum
:
1864 case lang_reloc_statement_enum
:
1865 case lang_padding_statement_enum
:
1866 case lang_constructors_statement_enum
:
1868 ignore_first
= false;
1870 case lang_output_section_statement_enum
:
1873 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1876 || s
->map_head
.s
== NULL
1877 || (s
->flags
& SEC_ALLOC
) != 0)
1881 case lang_input_statement_enum
:
1882 case lang_address_statement_enum
:
1883 case lang_target_statement_enum
:
1884 case lang_output_statement_enum
:
1885 case lang_group_statement_enum
:
1886 case lang_insert_statement_enum
:
1888 case lang_input_matcher_enum
:
1897 lang_output_section_statement_type
*
1898 lang_insert_orphan (asection
*s
,
1899 const char *secname
,
1901 lang_output_section_statement_type
*after
,
1902 struct orphan_save
*place
,
1903 etree_type
*address
,
1904 lang_statement_list_type
*add_child
)
1906 lang_statement_list_type add
;
1907 lang_output_section_statement_type
*os
;
1908 lang_output_section_statement_type
**os_tail
;
1910 /* If we have found an appropriate place for the output section
1911 statements for this orphan, add them to our own private list,
1912 inserting them later into the global statement list. */
1915 lang_list_init (&add
);
1916 push_stat_ptr (&add
);
1919 if (bfd_link_relocatable (&link_info
)
1920 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1921 address
= exp_intop (0);
1923 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1924 os
= lang_enter_output_section_statement (
1925 secname
, address
, normal_section
, 0, NULL
, NULL
, NULL
, constraint
, 0);
1927 if (add_child
== NULL
)
1928 add_child
= &os
->children
;
1929 lang_add_section (add_child
, s
, NULL
, NULL
, os
);
1931 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1933 const char *region
= (after
->region
1934 ? after
->region
->name_list
.name
1935 : DEFAULT_MEMORY_REGION
);
1936 const char *lma_region
= (after
->lma_region
1937 ? after
->lma_region
->name_list
.name
1939 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1943 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1946 /* Restore the global list pointer. */
1950 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1952 asection
*snew
, *as
;
1953 bool place_after
= place
->stmt
== NULL
;
1954 bool insert_after
= true;
1956 snew
= os
->bfd_section
;
1958 /* Shuffle the bfd section list to make the output file look
1959 neater. This is really only cosmetic. */
1960 if (place
->section
== NULL
1961 && after
!= (void *) lang_os_list
.head
)
1963 asection
*bfd_section
= after
->bfd_section
;
1965 /* If the output statement hasn't been used to place any input
1966 sections (and thus doesn't have an output bfd_section),
1967 look for the closest prior output statement having an
1969 if (bfd_section
== NULL
)
1970 bfd_section
= output_prev_sec_find (after
);
1972 if (bfd_section
!= NULL
1973 && bfd_section
->owner
!= NULL
1974 && bfd_section
!= snew
)
1975 place
->section
= &bfd_section
->next
;
1978 if (place
->section
== NULL
)
1979 place
->section
= &link_info
.output_bfd
->sections
;
1981 as
= *place
->section
;
1985 /* Put the section at the end of the list. */
1987 /* Unlink the section. */
1988 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1990 /* Now tack it back on in the right place. */
1991 bfd_section_list_append (link_info
.output_bfd
, snew
);
1993 else if ((bfd_get_flavour (link_info
.output_bfd
)
1994 == bfd_target_elf_flavour
)
1995 && (bfd_get_flavour (s
->owner
)
1996 == bfd_target_elf_flavour
)
1997 && ((elf_section_type (s
) == SHT_NOTE
1998 && (s
->flags
& SEC_LOAD
) != 0)
1999 || (elf_section_type (as
) == SHT_NOTE
2000 && (as
->flags
& SEC_LOAD
) != 0)))
2002 /* Make sure that output note sections are grouped and sorted
2003 by alignments when inserting a note section or insert a
2004 section after a note section, */
2006 /* A specific section after which the output note section
2007 should be placed. */
2008 asection
*after_sec
;
2009 /* True if we need to insert the orphan section after a
2010 specific section to maintain output note section order. */
2011 bool after_sec_note
= false;
2013 static asection
*first_orphan_note
= NULL
;
2015 /* Group and sort output note section by alignments in
2018 if (elf_section_type (s
) == SHT_NOTE
2019 && (s
->flags
& SEC_LOAD
) != 0)
2021 /* Search from the beginning for the last output note
2022 section with equal or larger alignments. NB: Don't
2023 place orphan note section after non-note sections. */
2025 first_orphan_note
= NULL
;
2026 for (sec
= link_info
.output_bfd
->sections
;
2028 && !bfd_is_abs_section (sec
));
2031 && elf_section_type (sec
) == SHT_NOTE
2032 && (sec
->flags
& SEC_LOAD
) != 0)
2034 if (!first_orphan_note
)
2035 first_orphan_note
= sec
;
2036 if (sec
->alignment_power
>= s
->alignment_power
)
2039 else if (first_orphan_note
)
2041 /* Stop if there is non-note section after the first
2042 orphan note section. */
2046 /* If this will be the first orphan note section, it can
2047 be placed at the default location. */
2048 after_sec_note
= first_orphan_note
!= NULL
;
2049 if (after_sec
== NULL
&& after_sec_note
)
2051 /* If all output note sections have smaller
2052 alignments, place the section before all
2053 output orphan note sections. */
2054 after_sec
= first_orphan_note
;
2055 insert_after
= false;
2058 else if (first_orphan_note
)
2060 /* Don't place non-note sections in the middle of orphan
2062 after_sec_note
= true;
2064 for (sec
= as
->next
;
2066 && !bfd_is_abs_section (sec
));
2068 if (elf_section_type (sec
) == SHT_NOTE
2069 && (sec
->flags
& SEC_LOAD
) != 0)
2077 /* Search forward to insert OS after AFTER_SEC output
2079 lang_output_section_statement_type
*stmt
, *next
;
2081 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2086 if (stmt
->bfd_section
== after_sec
)
2096 /* If INSERT_AFTER is FALSE, place OS before
2097 AFTER_SEC output statement. */
2098 if (next
&& next
->bfd_section
== after_sec
)
2108 /* Search backward to insert OS after AFTER_SEC output
2111 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2115 if (stmt
->bfd_section
== after_sec
)
2124 /* If INSERT_AFTER is FALSE, place OS before
2125 AFTER_SEC output statement. */
2126 if (stmt
->next
->bfd_section
== after_sec
)
2136 if (after_sec
== NULL
2137 || (insert_after
&& after_sec
->next
!= snew
)
2138 || (!insert_after
&& after_sec
->prev
!= snew
))
2140 /* Unlink the section. */
2141 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2143 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2148 bfd_section_list_insert_after (link_info
.output_bfd
,
2151 bfd_section_list_insert_before (link_info
.output_bfd
,
2155 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2158 else if (as
!= snew
&& as
->prev
!= snew
)
2160 /* Unlink the section. */
2161 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2163 /* Now tack it back on in the right place. */
2164 bfd_section_list_insert_before (link_info
.output_bfd
,
2168 else if (as
!= snew
&& as
->prev
!= snew
)
2170 /* Unlink the section. */
2171 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2173 /* Now tack it back on in the right place. */
2174 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2177 /* Save the end of this list. Further ophans of this type will
2178 follow the one we've just added. */
2179 place
->section
= &snew
->next
;
2181 /* The following is non-cosmetic. We try to put the output
2182 statements in some sort of reasonable order here, because they
2183 determine the final load addresses of the orphan sections.
2184 In addition, placing output statements in the wrong order may
2185 require extra segments. For instance, given a typical
2186 situation of all read-only sections placed in one segment and
2187 following that a segment containing all the read-write
2188 sections, we wouldn't want to place an orphan read/write
2189 section before or amongst the read-only ones. */
2190 if (add
.head
!= NULL
)
2192 lang_output_section_statement_type
*newly_added_os
;
2194 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2197 lang_statement_union_type
**where
;
2199 where
= insert_os_after ((lang_statement_union_type
*) after
);
2203 place
->os_tail
= &after
->next
;
2207 /* Put it after the last orphan statement we added. */
2208 *add
.tail
= *place
->stmt
;
2209 *place
->stmt
= add
.head
;
2212 /* Fix the global list pointer if we happened to tack our
2213 new list at the tail. */
2214 if (*stat_ptr
->tail
== add
.head
)
2215 stat_ptr
->tail
= add
.tail
;
2217 /* Save the end of this list. */
2218 place
->stmt
= add
.tail
;
2220 /* Do the same for the list of output section statements. */
2221 newly_added_os
= *os_tail
;
2223 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2224 ((char *) place
->os_tail
2225 - offsetof (lang_output_section_statement_type
, next
));
2226 newly_added_os
->next
= *place
->os_tail
;
2227 if (newly_added_os
->next
!= NULL
)
2228 newly_added_os
->next
->prev
= newly_added_os
;
2229 *place
->os_tail
= newly_added_os
;
2230 place
->os_tail
= &newly_added_os
->next
;
2232 /* Fixing the global list pointer here is a little different.
2233 We added to the list in lang_enter_output_section_statement,
2234 trimmed off the new output_section_statment above when
2235 assigning *os_tail = NULL, but possibly added it back in
2236 the same place when assigning *place->os_tail. */
2237 if (*os_tail
== NULL
)
2238 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2245 lang_print_asneeded (void)
2247 struct asneeded_minfo
*m
;
2249 if (asneeded_list_head
== NULL
)
2252 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2254 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2258 minfo ("%s", m
->soname
);
2259 len
= strlen (m
->soname
);
2266 print_spaces (30 - len
);
2269 minfo ("%pB ", m
->ref
);
2270 minfo ("(%pT)\n", m
->name
);
2275 lang_map_flags (flagword flag
)
2277 if (flag
& SEC_ALLOC
)
2280 if (flag
& SEC_CODE
)
2283 if (flag
& SEC_READONLY
)
2286 if (flag
& SEC_DATA
)
2289 if (flag
& SEC_LOAD
)
2296 lang_memory_region_type
*m
;
2297 bool dis_header_printed
= false;
2299 ldfile_print_input_remaps ();
2301 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2305 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2306 || file
->flags
.just_syms
)
2309 if (config
.print_map_discarded
)
2310 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2311 if ((s
->output_section
== NULL
2312 || s
->output_section
->owner
!= link_info
.output_bfd
)
2313 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2315 if (! dis_header_printed
)
2317 minfo (_("\nDiscarded input sections\n\n"));
2318 dis_header_printed
= true;
2321 print_input_section (s
, true);
2324 if (config
.print_map_discarded
&& ! dis_header_printed
)
2325 minfo (_("\nThere are no discarded input sections\n"));
2327 minfo (_("\nMemory Configuration\n\n"));
2328 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2329 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2331 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2333 fprintf (config
.map_file
, "%-16s", m
->name_list
.name
);
2336 bfd_sprintf_vma (link_info
.output_bfd
, buf
, m
->origin
);
2337 fprintf (config
.map_file
, " 0x%-16s", buf
);
2338 bfd_sprintf_vma (link_info
.output_bfd
, buf
, m
->length
);
2339 fprintf (config
.map_file
,
2340 " 0x%*s", m
->flags
|| m
->not_flags
? -17 : 0, buf
);
2342 lang_map_flags (m
->flags
);
2347 lang_map_flags (m
->not_flags
);
2353 minfo (_("\nLinker script and memory map\n\n"));
2355 if (!link_info
.reduce_memory_overheads
)
2357 obstack_begin (&map_obstack
, 1000);
2358 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2360 expld
.phase
= lang_fixed_phase_enum
;
2361 lang_statement_iteration
++;
2362 print_statements ();
2364 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2369 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2370 void *info ATTRIBUTE_UNUSED
)
2372 if ((hash_entry
->type
== bfd_link_hash_defined
2373 || hash_entry
->type
== bfd_link_hash_defweak
)
2374 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2375 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2377 input_section_userdata_type
*ud
;
2378 struct map_symbol_def
*def
;
2380 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2383 ud
= stat_alloc (sizeof (*ud
));
2384 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2385 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2386 ud
->map_symbol_def_count
= 0;
2388 else if (!ud
->map_symbol_def_tail
)
2389 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2391 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2392 def
->entry
= hash_entry
;
2393 *(ud
->map_symbol_def_tail
) = def
;
2394 ud
->map_symbol_def_tail
= &def
->next
;
2395 ud
->map_symbol_def_count
++;
2400 /* Initialize an output section. */
2403 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2405 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2406 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2409 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2410 if (s
->bfd_section
== NULL
)
2411 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2413 if (s
->bfd_section
== NULL
)
2415 einfo (_("%F%P: output format %s cannot represent section"
2416 " called %s: %E\n"),
2417 link_info
.output_bfd
->xvec
->name
, s
->name
);
2419 s
->bfd_section
->output_section
= s
->bfd_section
;
2420 s
->bfd_section
->output_offset
= 0;
2422 /* Set the userdata of the output section to the output section
2423 statement to avoid lookup. */
2424 bfd_set_section_userdata (s
->bfd_section
, s
);
2426 /* If there is a base address, make sure that any sections it might
2427 mention are initialized. */
2428 if (s
->addr_tree
!= NULL
)
2429 exp_init_os (s
->addr_tree
);
2431 if (s
->load_base
!= NULL
)
2432 exp_init_os (s
->load_base
);
2434 /* If supplied an alignment, set it. */
2435 if (s
->section_alignment
!= NULL
)
2436 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2437 "section alignment");
2440 /* Make sure that all output sections mentioned in an expression are
2444 exp_init_os (etree_type
*exp
)
2446 switch (exp
->type
.node_class
)
2450 case etree_provided
:
2451 exp_init_os (exp
->assign
.src
);
2455 exp_init_os (exp
->binary
.lhs
);
2456 exp_init_os (exp
->binary
.rhs
);
2460 exp_init_os (exp
->trinary
.cond
);
2461 exp_init_os (exp
->trinary
.lhs
);
2462 exp_init_os (exp
->trinary
.rhs
);
2466 exp_init_os (exp
->assert_s
.child
);
2470 exp_init_os (exp
->unary
.child
);
2474 switch (exp
->type
.node_code
)
2479 lang_output_section_statement_type
*os
;
2481 os
= lang_output_section_find (exp
->name
.name
);
2482 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2494 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2496 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2498 /* If we are only reading symbols from this object, then we want to
2499 discard all sections. */
2500 if (entry
->flags
.just_syms
)
2502 bfd_link_just_syms (abfd
, sec
, &link_info
);
2506 /* Deal with SHF_EXCLUDE ELF sections. */
2507 if (!bfd_link_relocatable (&link_info
)
2508 && (abfd
->flags
& BFD_PLUGIN
) == 0
2509 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2510 sec
->output_section
= bfd_abs_section_ptr
;
2512 if (!(abfd
->flags
& DYNAMIC
))
2513 bfd_section_already_linked (abfd
, sec
, &link_info
);
2517 /* Returns true if SECTION is one we know will be discarded based on its
2518 section flags, otherwise returns false. */
2521 lang_discard_section_p (asection
*section
)
2524 flagword flags
= section
->flags
;
2526 /* Discard sections marked with SEC_EXCLUDE. */
2527 discard
= (flags
& SEC_EXCLUDE
) != 0;
2529 /* Discard the group descriptor sections when we're finally placing the
2530 sections from within the group. */
2531 if ((flags
& SEC_GROUP
) != 0
2532 && link_info
.resolve_section_groups
)
2535 /* Discard debugging sections if we are stripping debugging
2537 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2538 && (flags
& SEC_DEBUGGING
) != 0)
2544 /* Return TRUE if SECTION is never going to be added to output statement
2545 OUTPUT. lang_add_section() definitely won't do anything with SECTION
2546 if this returns TRUE. It may do something (or not) if this returns FALSE.
2548 Can be used as early-out to filter matches. This may set
2549 output_section of SECTION, if it was unset, to the abs section in case
2550 we discover SECTION to be always discarded. This may also give
2551 warning messages. */
2554 wont_add_section_p (asection
*section
,
2555 lang_output_section_statement_type
*output
)
2559 /* Is this section one we know should be discarded? */
2560 discard
= lang_discard_section_p (section
);
2562 /* Discard input sections which are assigned to a section named
2563 DISCARD_SECTION_NAME. */
2564 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2569 if (section
->output_section
== NULL
)
2571 /* This prevents future calls from assigning this section or
2572 warning about it again. */
2573 section
->output_section
= bfd_abs_section_ptr
;
2575 else if (bfd_is_abs_section (section
->output_section
))
2577 else if (link_info
.non_contiguous_regions_warnings
)
2578 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2579 "section `%pA' from `%pB' match /DISCARD/ clause.\n"),
2580 NULL
, section
, section
->owner
);
2585 if (section
->output_section
!= NULL
)
2587 if (!link_info
.non_contiguous_regions
)
2590 /* SECTION has already been handled in a special way
2591 (eg. LINK_ONCE): skip it. */
2592 if (bfd_is_abs_section (section
->output_section
))
2595 /* Already assigned to the same output section, do not process
2596 it again, to avoid creating loops between duplicate sections
2598 if (section
->output_section
== output
->bfd_section
)
2601 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2602 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2603 "change behaviour for section `%pA' from `%pB' (assigned to "
2604 "%pA, but additional match: %pA)\n"),
2605 NULL
, section
, section
->owner
, section
->output_section
,
2606 output
->bfd_section
);
2608 /* SECTION has already been assigned to an output section, but
2609 the user allows it to be mapped to another one in case it
2610 overflows. We'll later update the actual output section in
2611 size_input_section as appropriate. */
2617 /* The wild routines.
2619 These expand statements like *(.text) and foo.o to a list of
2620 explicit actions, like foo.o(.text), bar.o(.text) and
2621 foo.o(.text, .data). */
2623 /* Add SECTION to the output section OUTPUT. Do this by creating a
2624 lang_input_section statement which is placed at PTR. */
2627 lang_add_section (lang_statement_list_type
*ptr
,
2629 struct wildcard_list
*pattern
,
2630 struct flag_info
*sflag_info
,
2631 lang_output_section_statement_type
*output
)
2633 flagword flags
= section
->flags
;
2635 lang_input_section_type
*new_section
;
2636 bfd
*abfd
= link_info
.output_bfd
;
2638 if (wont_add_section_p (section
, output
))
2645 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2650 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2651 to an output section, because we want to be able to include a
2652 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2653 section (I don't know why we want to do this, but we do).
2654 build_link_order in ldwrite.c handles this case by turning
2655 the embedded SEC_NEVER_LOAD section into a fill. */
2656 flags
&= ~ SEC_NEVER_LOAD
;
2658 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2659 already been processed. One reason to do this is that on pe
2660 format targets, .text$foo sections go into .text and it's odd
2661 to see .text with SEC_LINK_ONCE set. */
2662 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2664 if (link_info
.resolve_section_groups
)
2665 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2667 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2669 else if (!bfd_link_relocatable (&link_info
))
2670 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2672 switch (output
->sectype
)
2674 case normal_section
:
2675 case overlay_section
:
2676 case first_overlay_section
:
2679 case noalloc_section
:
2680 flags
&= ~SEC_ALLOC
;
2682 case typed_readonly_section
:
2683 case readonly_section
:
2684 flags
|= SEC_READONLY
;
2686 case noload_section
:
2688 flags
|= SEC_NEVER_LOAD
;
2689 /* Unfortunately GNU ld has managed to evolve two different
2690 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2691 alloc, no contents section. All others get a noload, noalloc
2693 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2694 flags
&= ~SEC_HAS_CONTENTS
;
2696 flags
&= ~SEC_ALLOC
;
2700 if (output
->bfd_section
== NULL
)
2701 init_os (output
, flags
);
2703 /* If SEC_READONLY is not set in the input section, then clear
2704 it from the output section. */
2705 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2707 if (output
->bfd_section
->linker_has_input
)
2709 /* Only set SEC_READONLY flag on the first input section. */
2710 flags
&= ~ SEC_READONLY
;
2712 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2713 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2714 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2715 || ((flags
& SEC_MERGE
) != 0
2716 && output
->bfd_section
->entsize
!= section
->entsize
))
2718 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2719 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2722 output
->bfd_section
->flags
|= flags
;
2724 if (!output
->bfd_section
->linker_has_input
)
2726 output
->bfd_section
->linker_has_input
= 1;
2727 /* This must happen after flags have been updated. The output
2728 section may have been created before we saw its first input
2729 section, eg. for a data statement. */
2730 bfd_init_private_section_data (section
->owner
, section
,
2731 link_info
.output_bfd
,
2732 output
->bfd_section
,
2734 if ((flags
& SEC_MERGE
) != 0)
2735 output
->bfd_section
->entsize
= section
->entsize
;
2738 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2739 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2741 /* FIXME: This value should really be obtained from the bfd... */
2742 output
->block_value
= 128;
2745 /* When a .ctors section is placed in .init_array it must be copied
2746 in reverse order. Similarly for .dtors. Set that up. */
2747 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
2748 && ((startswith (section
->name
, ".ctors")
2749 && strcmp (output
->bfd_section
->name
, ".init_array") == 0)
2750 || (startswith (section
->name
, ".dtors")
2751 && strcmp (output
->bfd_section
->name
, ".fini_array") == 0))
2752 && (section
->name
[6] == 0 || section
->name
[6] == '.'))
2753 section
->flags
|= SEC_ELF_REVERSE_COPY
;
2755 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2756 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2758 section
->output_section
= output
->bfd_section
;
2760 if (!map_head_is_link_order
)
2762 asection
*s
= output
->bfd_section
->map_tail
.s
;
2763 output
->bfd_section
->map_tail
.s
= section
;
2764 section
->map_head
.s
= NULL
;
2765 section
->map_tail
.s
= s
;
2767 s
->map_head
.s
= section
;
2769 output
->bfd_section
->map_head
.s
= section
;
2772 /* Add a section reference to the list. */
2773 new_section
= new_stat (lang_input_section
, ptr
);
2774 new_section
->section
= section
;
2775 new_section
->pattern
= pattern
;
2778 /* Expand a wild statement for a particular FILE. SECTION may be
2779 NULL, in which case it is a wild card. This assumes that the
2780 wild statement doesn't need any sorting (of filenames or sections). */
2783 output_section_callback_nosort (lang_wild_statement_type
*ptr
,
2784 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2786 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2789 lang_output_section_statement_type
*os
;
2791 os
= (lang_output_section_statement_type
*) output
;
2793 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2794 if (unique_section_p (section
, os
))
2797 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2798 ptr
->section_flag_list
, os
);
2801 /* Check if all sections in a wild statement for a particular FILE
2805 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2806 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2808 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2811 lang_output_section_statement_type
*os
;
2813 os
= (lang_output_section_statement_type
*) output
;
2815 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2816 if (unique_section_p (section
, os
))
2819 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2820 os
->all_input_readonly
= false;
2823 /* This is passed a file name which must have been seen already and
2824 added to the statement tree. We will see if it has been opened
2825 already and had its symbols read. If not then we'll read it. */
2827 static lang_input_statement_type
*
2828 lookup_name (const char *name
)
2830 lang_input_statement_type
*search
;
2832 for (search
= (void *) input_file_chain
.head
;
2834 search
= search
->next_real_file
)
2836 /* Use the local_sym_name as the name of the file that has
2837 already been loaded as filename might have been transformed
2838 via the search directory lookup mechanism. */
2839 const char *filename
= search
->local_sym_name
;
2841 if (filename
!= NULL
2842 && filename_cmp (filename
, name
) == 0)
2848 /* Arrange to splice the input statement added by new_afile into
2849 statement_list after the current input_file_chain tail.
2850 We know input_file_chain is not an empty list, and that
2851 lookup_name was called via open_input_bfds. Later calls to
2852 lookup_name should always match an existing input_statement. */
2853 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2854 lang_statement_union_type
**after
2855 = (void *) ((char *) input_file_chain
.tail
2856 - offsetof (lang_input_statement_type
, next_real_file
)
2857 + offsetof (lang_input_statement_type
, header
.next
));
2858 lang_statement_union_type
*rest
= *after
;
2859 stat_ptr
->tail
= after
;
2860 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2861 default_target
, NULL
);
2862 *stat_ptr
->tail
= rest
;
2864 stat_ptr
->tail
= tail
;
2867 /* If we have already added this file, or this file is not real
2868 don't add this file. */
2869 if (search
->flags
.loaded
|| !search
->flags
.real
)
2872 if (!load_symbols (search
, NULL
))
2878 /* Save LIST as a list of libraries whose symbols should not be exported. */
2883 struct excluded_lib
*next
;
2885 static struct excluded_lib
*excluded_libs
;
2888 add_excluded_libs (const char *list
)
2890 const char *p
= list
, *end
;
2894 struct excluded_lib
*entry
;
2895 end
= strpbrk (p
, ",:");
2897 end
= p
+ strlen (p
);
2898 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2899 entry
->next
= excluded_libs
;
2900 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2901 memcpy (entry
->name
, p
, end
- p
);
2902 entry
->name
[end
- p
] = '\0';
2903 excluded_libs
= entry
;
2911 check_excluded_libs (bfd
*abfd
)
2913 struct excluded_lib
*lib
= excluded_libs
;
2917 int len
= strlen (lib
->name
);
2918 const char *filename
= lbasename (bfd_get_filename (abfd
));
2920 if (strcmp (lib
->name
, "ALL") == 0)
2922 abfd
->no_export
= true;
2926 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2927 && (filename
[len
] == '\0'
2928 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2929 && filename
[len
+ 2] == '\0')))
2931 abfd
->no_export
= true;
2939 /* Get the symbols for an input file. */
2942 load_symbols (lang_input_statement_type
*entry
,
2943 lang_statement_list_type
*place
)
2947 if (entry
->flags
.loaded
)
2950 ldfile_open_file (entry
);
2952 /* Do not process further if the file was missing. */
2953 if (entry
->flags
.missing_file
)
2956 if (trace_files
|| verbose
)
2957 info_msg ("%pI\n", entry
);
2959 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2960 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2963 struct lang_input_statement_flags save_flags
;
2966 err
= bfd_get_error ();
2968 /* See if the emulation has some special knowledge. */
2969 if (ldemul_unrecognized_file (entry
))
2971 if (err
== bfd_error_file_ambiguously_recognized
)
2976 if (err
== bfd_error_file_ambiguously_recognized
)
2980 einfo (_("%P: %pB: file not recognized: %E;"
2981 " matching formats:"), entry
->the_bfd
);
2982 for (p
= matching
; *p
!= NULL
; p
++)
2987 else if (err
!= bfd_error_file_not_recognized
2989 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2991 bfd_close (entry
->the_bfd
);
2992 entry
->the_bfd
= NULL
;
2994 /* Try to interpret the file as a linker script. */
2995 save_flags
= input_flags
;
2996 ldfile_open_command_file (entry
->filename
);
2998 push_stat_ptr (place
);
2999 input_flags
.add_DT_NEEDED_for_regular
3000 = entry
->flags
.add_DT_NEEDED_for_regular
;
3001 input_flags
.add_DT_NEEDED_for_dynamic
3002 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3003 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3004 input_flags
.dynamic
= entry
->flags
.dynamic
;
3006 ldfile_assumed_script
= true;
3007 parser_input
= input_script
;
3008 current_input_file
= entry
->filename
;
3010 current_input_file
= NULL
;
3011 ldfile_assumed_script
= false;
3013 /* missing_file is sticky. sysrooted will already have been
3014 restored when seeing EOF in yyparse, but no harm to restore
3016 save_flags
.missing_file
|= input_flags
.missing_file
;
3017 input_flags
= save_flags
;
3021 entry
->flags
.loaded
= true;
3026 if (ldemul_recognized_file (entry
))
3029 /* We don't call ldlang_add_file for an archive. Instead, the
3030 add_symbols entry point will call ldlang_add_file, via the
3031 add_archive_element callback, for each element of the archive
3033 switch (bfd_get_format (entry
->the_bfd
))
3039 if (!entry
->flags
.reload
)
3040 ldlang_add_file (entry
);
3044 check_excluded_libs (entry
->the_bfd
);
3046 bfd_set_usrdata (entry
->the_bfd
, entry
);
3047 if (entry
->flags
.whole_archive
)
3055 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3060 if (!bfd_check_format (member
, bfd_object
))
3062 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3063 entry
->the_bfd
, member
);
3068 if (!(*link_info
.callbacks
3069 ->add_archive_element
) (&link_info
, member
,
3070 "--whole-archive", &subsbfd
))
3073 /* Potentially, the add_archive_element hook may have set a
3074 substitute BFD for us. */
3075 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3077 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3082 entry
->flags
.loaded
= loaded
;
3088 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3089 entry
->flags
.loaded
= true;
3091 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3093 return entry
->flags
.loaded
;
3096 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3097 may be NULL, indicating that it is a wildcard. Separate
3098 lang_input_section statements are created for each part of the
3099 expansion; they are added after the wild statement S. OUTPUT is
3100 the output section. */
3103 wild (lang_wild_statement_type
*s
,
3104 const char *target ATTRIBUTE_UNUSED
,
3105 lang_output_section_statement_type
*output
)
3107 struct wildcard_list
*sec
;
3109 if (s
->filenames_sorted
|| s
->any_specs_sorted
)
3111 lang_section_bst_type
*tree
;
3113 walk_wild (s
, output_section_callback_sort
, output
);
3118 output_section_callback_tree_to_list (s
, tree
, output
);
3120 s
->rightmost
= &s
->tree
;
3124 walk_wild (s
, output_section_callback_nosort
, output
);
3126 if (default_common_section
== NULL
)
3127 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3128 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3130 /* Remember the section that common is going to in case we
3131 later get something which doesn't know where to put it. */
3132 default_common_section
= output
;
3137 /* Return TRUE iff target is the sought target. */
3140 get_target (const bfd_target
*target
, void *data
)
3142 const char *sought
= (const char *) data
;
3144 return strcmp (target
->name
, sought
) == 0;
3147 /* Like strcpy() but convert to lower case as well. */
3150 stricpy (char *dest
, const char *src
)
3154 while ((c
= *src
++) != 0)
3155 *dest
++ = TOLOWER (c
);
3160 /* Remove the first occurrence of needle (if any) in haystack
3164 strcut (char *haystack
, const char *needle
)
3166 haystack
= strstr (haystack
, needle
);
3172 for (src
= haystack
+ strlen (needle
); *src
;)
3173 *haystack
++ = *src
++;
3179 /* Compare two target format name strings.
3180 Return a value indicating how "similar" they are. */
3183 name_compare (const char *first
, const char *second
)
3189 copy1
= (char *) xmalloc (strlen (first
) + 1);
3190 copy2
= (char *) xmalloc (strlen (second
) + 1);
3192 /* Convert the names to lower case. */
3193 stricpy (copy1
, first
);
3194 stricpy (copy2
, second
);
3196 /* Remove size and endian strings from the name. */
3197 strcut (copy1
, "big");
3198 strcut (copy1
, "little");
3199 strcut (copy2
, "big");
3200 strcut (copy2
, "little");
3202 /* Return a value based on how many characters match,
3203 starting from the beginning. If both strings are
3204 the same then return 10 * their length. */
3205 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3206 if (copy1
[result
] == 0)
3218 /* Set by closest_target_match() below. */
3219 static const bfd_target
*winner
;
3221 /* Scan all the valid bfd targets looking for one that has the endianness
3222 requirement that was specified on the command line, and is the nearest
3223 match to the original output target. */
3226 closest_target_match (const bfd_target
*target
, void *data
)
3228 const bfd_target
*original
= (const bfd_target
*) data
;
3230 if (command_line
.endian
== ENDIAN_BIG
3231 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3234 if (command_line
.endian
== ENDIAN_LITTLE
3235 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3238 /* Must be the same flavour. */
3239 if (target
->flavour
!= original
->flavour
)
3242 /* Ignore generic big and little endian elf vectors. */
3243 if (strcmp (target
->name
, "elf32-big") == 0
3244 || strcmp (target
->name
, "elf64-big") == 0
3245 || strcmp (target
->name
, "elf32-little") == 0
3246 || strcmp (target
->name
, "elf64-little") == 0)
3249 /* If we have not found a potential winner yet, then record this one. */
3256 /* Oh dear, we now have two potential candidates for a successful match.
3257 Compare their names and choose the better one. */
3258 if (name_compare (target
->name
, original
->name
)
3259 > name_compare (winner
->name
, original
->name
))
3262 /* Keep on searching until wqe have checked them all. */
3266 /* Return the BFD target format of the first input file. */
3269 get_first_input_target (void)
3271 const char *target
= NULL
;
3273 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3275 if (s
->header
.type
== lang_input_statement_enum
3278 ldfile_open_file (s
);
3280 if (s
->the_bfd
!= NULL
3281 && bfd_check_format (s
->the_bfd
, bfd_object
))
3283 target
= bfd_get_target (s
->the_bfd
);
3295 lang_get_output_target (void)
3299 /* Has the user told us which output format to use? */
3300 if (output_target
!= NULL
)
3301 return output_target
;
3303 /* No - has the current target been set to something other than
3305 if (current_target
!= default_target
&& current_target
!= NULL
)
3306 return current_target
;
3308 /* No - can we determine the format of the first input file? */
3309 target
= get_first_input_target ();
3313 /* Failed - use the default output target. */
3314 return default_target
;
3317 /* Open the output file. */
3320 open_output (const char *name
)
3322 lang_input_statement_type
*f
;
3323 char *out
= lrealpath (name
);
3325 for (f
= (void *) input_file_chain
.head
;
3327 f
= f
->next_real_file
)
3330 char *in
= lrealpath (f
->local_sym_name
);
3331 if (filename_cmp (in
, out
) == 0)
3332 einfo (_("%F%P: input file '%s' is the same as output file\n"),
3338 output_target
= lang_get_output_target ();
3340 /* Has the user requested a particular endianness on the command
3342 if (command_line
.endian
!= ENDIAN_UNSET
)
3344 /* Get the chosen target. */
3345 const bfd_target
*target
3346 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3348 /* If the target is not supported, we cannot do anything. */
3351 enum bfd_endian desired_endian
;
3353 if (command_line
.endian
== ENDIAN_BIG
)
3354 desired_endian
= BFD_ENDIAN_BIG
;
3356 desired_endian
= BFD_ENDIAN_LITTLE
;
3358 /* See if the target has the wrong endianness. This should
3359 not happen if the linker script has provided big and
3360 little endian alternatives, but some scrips don't do
3362 if (target
->byteorder
!= desired_endian
)
3364 /* If it does, then see if the target provides
3365 an alternative with the correct endianness. */
3366 if (target
->alternative_target
!= NULL
3367 && (target
->alternative_target
->byteorder
== desired_endian
))
3368 output_target
= target
->alternative_target
->name
;
3371 /* Try to find a target as similar as possible to
3372 the default target, but which has the desired
3373 endian characteristic. */
3374 bfd_iterate_over_targets (closest_target_match
,
3377 /* Oh dear - we could not find any targets that
3378 satisfy our requirements. */
3380 einfo (_("%P: warning: could not find any targets"
3381 " that match endianness requirement\n"));
3383 output_target
= winner
->name
;
3389 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3391 if (link_info
.output_bfd
== NULL
)
3393 if (bfd_get_error () == bfd_error_invalid_target
)
3394 einfo (_("%F%P: target %s not found\n"), output_target
);
3396 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3399 delete_output_file_on_failure
= true;
3401 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3402 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3403 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3404 ldfile_output_architecture
,
3405 ldfile_output_machine
))
3406 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3408 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3409 if (link_info
.hash
== NULL
)
3410 einfo (_("%F%P: can not create hash table: %E\n"));
3412 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3416 ldlang_open_output (lang_statement_union_type
*statement
)
3418 switch (statement
->header
.type
)
3420 case lang_output_statement_enum
:
3421 ASSERT (link_info
.output_bfd
== NULL
);
3422 open_output (statement
->output_statement
.name
);
3423 ldemul_set_output_arch ();
3424 if (config
.magic_demand_paged
3425 && !bfd_link_relocatable (&link_info
))
3426 link_info
.output_bfd
->flags
|= D_PAGED
;
3428 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3429 if (config
.text_read_only
)
3430 link_info
.output_bfd
->flags
|= WP_TEXT
;
3432 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3433 if (link_info
.traditional_format
)
3434 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3436 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3439 case lang_target_statement_enum
:
3440 current_target
= statement
->target_statement
.target
;
3448 init_opb (asection
*s
)
3453 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3455 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3458 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3459 ldfile_output_machine
);
3461 while ((x
& 1) == 0)
3469 /* Open all the input files. */
3473 OPEN_BFD_NORMAL
= 0,
3477 #if BFD_SUPPORTS_PLUGINS
3478 static lang_input_statement_type
*plugin_insert
= NULL
;
3479 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3483 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3485 for (; s
!= NULL
; s
= s
->header
.next
)
3487 switch (s
->header
.type
)
3489 case lang_constructors_statement_enum
:
3490 open_input_bfds (constructor_list
.head
, mode
);
3492 case lang_output_section_statement_enum
:
3493 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3495 case lang_wild_statement_enum
:
3496 /* Maybe we should load the file's symbols. */
3497 if ((mode
& OPEN_BFD_RESCAN
) == 0
3498 && s
->wild_statement
.filename
3499 && !wildcardp (s
->wild_statement
.filename
)
3500 && !archive_path (s
->wild_statement
.filename
))
3501 lookup_name (s
->wild_statement
.filename
);
3502 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3504 case lang_group_statement_enum
:
3506 struct bfd_link_hash_entry
*undefs
;
3507 #if BFD_SUPPORTS_PLUGINS
3508 lang_input_statement_type
*plugin_insert_save
;
3511 /* We must continually search the entries in the group
3512 until no new symbols are added to the list of undefined
3517 #if BFD_SUPPORTS_PLUGINS
3518 plugin_insert_save
= plugin_insert
;
3520 undefs
= link_info
.hash
->undefs_tail
;
3521 open_input_bfds (s
->group_statement
.children
.head
,
3522 mode
| OPEN_BFD_FORCE
);
3524 while (undefs
!= link_info
.hash
->undefs_tail
3525 #if BFD_SUPPORTS_PLUGINS
3526 /* Objects inserted by a plugin, which are loaded
3527 before we hit this loop, may have added new
3529 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3534 case lang_target_statement_enum
:
3535 current_target
= s
->target_statement
.target
;
3537 case lang_input_statement_enum
:
3538 if (s
->input_statement
.flags
.real
)
3540 lang_statement_union_type
**os_tail
;
3541 lang_statement_list_type add
;
3544 s
->input_statement
.target
= current_target
;
3546 /* If we are being called from within a group, and this
3547 is an archive which has already been searched, then
3548 force it to be researched unless the whole archive
3549 has been loaded already. Do the same for a rescan.
3550 Likewise reload --as-needed shared libs. */
3551 if (mode
!= OPEN_BFD_NORMAL
3552 #if BFD_SUPPORTS_PLUGINS
3553 && ((mode
& OPEN_BFD_RESCAN
) == 0
3554 || plugin_insert
== NULL
)
3556 && s
->input_statement
.flags
.loaded
3557 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3558 && ((bfd_get_format (abfd
) == bfd_archive
3559 && !s
->input_statement
.flags
.whole_archive
)
3560 || (bfd_get_format (abfd
) == bfd_object
3561 && ((abfd
->flags
) & DYNAMIC
) != 0
3562 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3563 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3564 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3566 s
->input_statement
.flags
.loaded
= false;
3567 s
->input_statement
.flags
.reload
= true;
3570 os_tail
= lang_os_list
.tail
;
3571 lang_list_init (&add
);
3573 if (!load_symbols (&s
->input_statement
, &add
))
3574 config
.make_executable
= false;
3576 if (add
.head
!= NULL
)
3578 /* If this was a script with output sections then
3579 tack any added statements on to the end of the
3580 list. This avoids having to reorder the output
3581 section statement list. Very likely the user
3582 forgot -T, and whatever we do here will not meet
3583 naive user expectations. */
3584 if (os_tail
!= lang_os_list
.tail
)
3586 einfo (_("%P: warning: %s contains output sections;"
3587 " did you forget -T?\n"),
3588 s
->input_statement
.filename
);
3589 *stat_ptr
->tail
= add
.head
;
3590 stat_ptr
->tail
= add
.tail
;
3594 *add
.tail
= s
->header
.next
;
3595 s
->header
.next
= add
.head
;
3599 #if BFD_SUPPORTS_PLUGINS
3600 /* If we have found the point at which a plugin added new
3601 files, clear plugin_insert to enable archive rescan. */
3602 if (&s
->input_statement
== plugin_insert
)
3603 plugin_insert
= NULL
;
3606 case lang_assignment_statement_enum
:
3607 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3608 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3615 /* Exit if any of the files were missing. */
3616 if (input_flags
.missing_file
)
3620 #ifdef ENABLE_LIBCTF
3621 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3622 that happened specifically at CTF open time. */
3624 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3626 ctf_next_t
*i
= NULL
;
3631 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3633 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3637 if (err
!= ECTF_NEXT_END
)
3639 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3643 /* `err' returns errors from the error/warning iterator in particular.
3644 These never assert. But if we have an fp, that could have recorded
3645 an assertion failure: assert if it has done so. */
3646 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3649 /* Open the CTF sections in the input files with libctf: if any were opened,
3650 create a fake input file that we'll write the merged CTF data to later
3654 ldlang_open_ctf (void)
3659 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3663 /* Incoming files from the compiler have a single ctf_dict_t in them
3664 (which is presented to us by the libctf API in a ctf_archive_t
3665 wrapper): files derived from a previous relocatable link have a CTF
3666 archive containing possibly many CTF files. */
3668 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3670 if (err
!= ECTF_NOCTFDATA
)
3672 lang_ctf_errs_warnings (NULL
);
3673 einfo (_("%P: warning: CTF section in %pB not loaded; "
3674 "its types will be discarded: %s\n"), file
->the_bfd
,
3680 /* Prevent the contents of this section from being written, while
3681 requiring the section itself to be duplicated in the output, but only
3683 /* This section must exist if ctf_bfdopen() succeeded. */
3684 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3686 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3689 sect
->flags
|= SEC_EXCLUDE
;
3699 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3702 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3705 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3706 ctf_close (errfile
->the_ctf
);
3709 /* Merge together CTF sections. After this, only the symtab-dependent
3710 function and data object sections need adjustment. */
3713 lang_merge_ctf (void)
3715 asection
*output_sect
;
3721 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3723 /* If the section was discarded, don't waste time merging. */
3724 if (output_sect
== NULL
)
3726 ctf_dict_close (ctf_output
);
3729 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3731 ctf_close (file
->the_ctf
);
3732 file
->the_ctf
= NULL
;
3737 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3742 /* Takes ownership of file->the_ctf. */
3743 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3745 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3746 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3747 ctf_close (file
->the_ctf
);
3748 file
->the_ctf
= NULL
;
3753 if (!config
.ctf_share_duplicated
)
3754 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3756 flags
= CTF_LINK_SHARE_DUPLICATED
;
3757 if (!config
.ctf_variables
)
3758 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3759 if (bfd_link_relocatable (&link_info
))
3760 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3762 if (ctf_link (ctf_output
, flags
) < 0)
3764 lang_ctf_errs_warnings (ctf_output
);
3765 einfo (_("%P: warning: CTF linking failed; "
3766 "output will have no CTF section: %s\n"),
3767 ctf_errmsg (ctf_errno (ctf_output
)));
3770 output_sect
->size
= 0;
3771 output_sect
->flags
|= SEC_EXCLUDE
;
3774 /* Output any lingering errors that didn't come from ctf_link. */
3775 lang_ctf_errs_warnings (ctf_output
);
3778 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3779 the CTF, if supported. */
3782 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3784 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3787 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3789 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3791 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3794 /* Write out the CTF section. Called early, if the emulation isn't going to
3795 need to dedup against the strtab and symtab, then possibly called from the
3796 target linker code if the dedup has happened. */
3798 lang_write_ctf (int late
)
3801 asection
*output_sect
;
3808 /* Emit CTF late if this emulation says it can do so. */
3809 if (ldemul_emit_ctf_early ())
3814 if (!ldemul_emit_ctf_early ())
3818 /* Inform the emulation that all the symbols that will be received have
3821 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3825 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3828 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3829 CTF_COMPRESSION_THRESHOLD
);
3830 output_sect
->size
= output_size
;
3831 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3833 lang_ctf_errs_warnings (ctf_output
);
3834 if (!output_sect
->contents
)
3836 einfo (_("%P: warning: CTF section emission failed; "
3837 "output will have no CTF section: %s\n"),
3838 ctf_errmsg (ctf_errno (ctf_output
)));
3839 output_sect
->size
= 0;
3840 output_sect
->flags
|= SEC_EXCLUDE
;
3844 /* This also closes every CTF input file used in the link. */
3845 ctf_dict_close (ctf_output
);
3848 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3849 file
->the_ctf
= NULL
;
3852 /* Write out the CTF section late, if the emulation needs that. */
3855 ldlang_write_ctf_late (void)
3857 /* Trigger a "late call", if the emulation needs one. */
3863 ldlang_open_ctf (void)
3865 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3869 /* If built without CTF, warn and delete all CTF sections from the output.
3870 (The alternative would be to simply concatenate them, which does not
3871 yield a valid CTF section.) */
3873 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3875 einfo (_("%P: warning: CTF section in %pB not linkable: "
3876 "%P was built without support for CTF\n"), file
->the_bfd
);
3878 sect
->flags
|= SEC_EXCLUDE
;
3883 static void lang_merge_ctf (void) {}
3885 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3886 ATTRIBUTE_UNUSED
) {}
3888 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3889 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3890 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3891 void ldlang_write_ctf_late (void) {}
3894 /* Add the supplied name to the symbol table as an undefined reference.
3895 This is a two step process as the symbol table doesn't even exist at
3896 the time the ld command line is processed. First we put the name
3897 on a list, then, once the output file has been opened, transfer the
3898 name to the symbol table. */
3900 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3902 #define ldlang_undef_chain_list_head entry_symbol.next
3905 ldlang_add_undef (const char *const name
, bool cmdline ATTRIBUTE_UNUSED
)
3907 ldlang_undef_chain_list_type
*new_undef
;
3909 new_undef
= stat_alloc (sizeof (*new_undef
));
3910 new_undef
->next
= ldlang_undef_chain_list_head
;
3911 ldlang_undef_chain_list_head
= new_undef
;
3913 new_undef
->name
= xstrdup (name
);
3915 if (link_info
.output_bfd
!= NULL
)
3916 insert_undefined (new_undef
->name
);
3919 /* Insert NAME as undefined in the symbol table. */
3922 insert_undefined (const char *name
)
3924 struct bfd_link_hash_entry
*h
;
3926 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
3928 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3929 if (h
->type
== bfd_link_hash_new
)
3931 h
->type
= bfd_link_hash_undefined
;
3932 h
->u
.undef
.abfd
= NULL
;
3933 h
->non_ir_ref_regular
= true;
3934 bfd_link_add_undef (link_info
.hash
, h
);
3938 /* Run through the list of undefineds created above and place them
3939 into the linker hash table as undefined symbols belonging to the
3943 lang_place_undefineds (void)
3945 ldlang_undef_chain_list_type
*ptr
;
3947 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3948 insert_undefined (ptr
->name
);
3951 /* Mark -u symbols against garbage collection. */
3954 lang_mark_undefineds (void)
3956 ldlang_undef_chain_list_type
*ptr
;
3958 if (is_elf_hash_table (link_info
.hash
))
3959 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3961 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
3962 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, false, false, true);
3968 /* Structure used to build the list of symbols that the user has required
3971 struct require_defined_symbol
3974 struct require_defined_symbol
*next
;
3977 /* The list of symbols that the user has required be defined. */
3979 static struct require_defined_symbol
*require_defined_symbol_list
;
3981 /* Add a new symbol NAME to the list of symbols that are required to be
3985 ldlang_add_require_defined (const char *const name
)
3987 struct require_defined_symbol
*ptr
;
3989 ldlang_add_undef (name
, true);
3990 ptr
= stat_alloc (sizeof (*ptr
));
3991 ptr
->next
= require_defined_symbol_list
;
3992 ptr
->name
= strdup (name
);
3993 require_defined_symbol_list
= ptr
;
3996 /* Check that all symbols the user required to be defined, are defined,
3997 raise an error if we find a symbol that is not defined. */
4000 ldlang_check_require_defined_symbols (void)
4002 struct require_defined_symbol
*ptr
;
4004 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4006 struct bfd_link_hash_entry
*h
;
4008 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4009 false, false, true);
4011 || (h
->type
!= bfd_link_hash_defined
4012 && h
->type
!= bfd_link_hash_defweak
))
4013 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4017 /* Check for all readonly or some readwrite sections. */
4020 check_input_sections
4021 (lang_statement_union_type
*s
,
4022 lang_output_section_statement_type
*output_section_statement
)
4024 for (; s
!= NULL
; s
= s
->header
.next
)
4026 switch (s
->header
.type
)
4028 case lang_wild_statement_enum
:
4029 walk_wild (&s
->wild_statement
, check_section_callback
,
4030 output_section_statement
);
4031 if (!output_section_statement
->all_input_readonly
)
4034 case lang_constructors_statement_enum
:
4035 check_input_sections (constructor_list
.head
,
4036 output_section_statement
);
4037 if (!output_section_statement
->all_input_readonly
)
4040 case lang_group_statement_enum
:
4041 check_input_sections (s
->group_statement
.children
.head
,
4042 output_section_statement
);
4043 if (!output_section_statement
->all_input_readonly
)
4052 /* Update wildcard statements if needed. */
4055 update_wild_statements (lang_statement_union_type
*s
)
4057 struct wildcard_list
*sec
;
4059 switch (sort_section
)
4069 for (; s
!= NULL
; s
= s
->header
.next
)
4071 switch (s
->header
.type
)
4076 case lang_wild_statement_enum
:
4077 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4079 /* Don't sort .init/.fini sections. */
4080 if (strcmp (sec
->spec
.name
, ".init") != 0
4081 && strcmp (sec
->spec
.name
, ".fini") != 0)
4083 switch (sec
->spec
.sorted
)
4086 sec
->spec
.sorted
= sort_section
;
4089 if (sort_section
== by_alignment
)
4090 sec
->spec
.sorted
= by_name_alignment
;
4093 if (sort_section
== by_name
)
4094 sec
->spec
.sorted
= by_alignment_name
;
4099 s
->wild_statement
.any_specs_sorted
= true;
4103 case lang_constructors_statement_enum
:
4104 update_wild_statements (constructor_list
.head
);
4107 case lang_output_section_statement_enum
:
4108 update_wild_statements
4109 (s
->output_section_statement
.children
.head
);
4112 case lang_group_statement_enum
:
4113 update_wild_statements (s
->group_statement
.children
.head
);
4121 /* Open input files and attach to output sections. */
4124 map_input_to_output_sections
4125 (lang_statement_union_type
*s
, const char *target
,
4126 lang_output_section_statement_type
*os
)
4128 for (; s
!= NULL
; s
= s
->header
.next
)
4130 lang_output_section_statement_type
*tos
;
4132 unsigned int type
= 0;
4134 switch (s
->header
.type
)
4136 case lang_wild_statement_enum
:
4137 wild (&s
->wild_statement
, target
, os
);
4139 case lang_constructors_statement_enum
:
4140 map_input_to_output_sections (constructor_list
.head
,
4144 case lang_output_section_statement_enum
:
4145 tos
= &s
->output_section_statement
;
4146 if (tos
->constraint
== ONLY_IF_RW
4147 || tos
->constraint
== ONLY_IF_RO
)
4149 tos
->all_input_readonly
= true;
4150 check_input_sections (tos
->children
.head
, tos
);
4151 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4152 tos
->constraint
= -1;
4154 if (tos
->constraint
>= 0)
4155 map_input_to_output_sections (tos
->children
.head
,
4159 case lang_output_statement_enum
:
4161 case lang_target_statement_enum
:
4162 target
= s
->target_statement
.target
;
4164 case lang_group_statement_enum
:
4165 map_input_to_output_sections (s
->group_statement
.children
.head
,
4169 case lang_data_statement_enum
:
4170 /* Make sure that any sections mentioned in the expression
4172 exp_init_os (s
->data_statement
.exp
);
4173 /* The output section gets CONTENTS, ALLOC and LOAD, but
4174 these may be overridden by the script. */
4175 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4176 switch (os
->sectype
)
4178 case normal_section
:
4179 case overlay_section
:
4180 case first_overlay_section
:
4182 case noalloc_section
:
4183 flags
= SEC_HAS_CONTENTS
;
4185 case readonly_section
:
4186 flags
|= SEC_READONLY
;
4188 case typed_readonly_section
:
4189 flags
|= SEC_READONLY
;
4192 if (os
->sectype_value
->type
.node_class
== etree_name
4193 && os
->sectype_value
->type
.node_code
== NAME
)
4195 const char *name
= os
->sectype_value
->name
.name
;
4196 if (strcmp (name
, "SHT_PROGBITS") == 0)
4197 type
= SHT_PROGBITS
;
4198 else if (strcmp (name
, "SHT_STRTAB") == 0)
4200 else if (strcmp (name
, "SHT_NOTE") == 0)
4202 else if (strcmp (name
, "SHT_NOBITS") == 0)
4204 else if (strcmp (name
, "SHT_INIT_ARRAY") == 0)
4205 type
= SHT_INIT_ARRAY
;
4206 else if (strcmp (name
, "SHT_FINI_ARRAY") == 0)
4207 type
= SHT_FINI_ARRAY
;
4208 else if (strcmp (name
, "SHT_PREINIT_ARRAY") == 0)
4209 type
= SHT_PREINIT_ARRAY
;
4211 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4216 exp_fold_tree_no_dot (os
->sectype_value
);
4217 if (expld
.result
.valid_p
)
4218 type
= expld
.result
.value
;
4220 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4224 case noload_section
:
4225 if (bfd_get_flavour (link_info
.output_bfd
)
4226 == bfd_target_elf_flavour
)
4227 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4229 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4232 if (os
->bfd_section
== NULL
)
4233 init_os (os
, flags
| SEC_READONLY
);
4235 os
->bfd_section
->flags
|= flags
;
4236 os
->bfd_section
->type
= type
;
4238 case lang_input_section_enum
:
4240 case lang_fill_statement_enum
:
4241 case lang_object_symbols_statement_enum
:
4242 case lang_reloc_statement_enum
:
4243 case lang_padding_statement_enum
:
4244 case lang_input_statement_enum
:
4245 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4248 case lang_assignment_statement_enum
:
4249 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4252 /* Make sure that any sections mentioned in the assignment
4254 exp_init_os (s
->assignment_statement
.exp
);
4256 case lang_address_statement_enum
:
4257 /* Mark the specified section with the supplied address.
4258 If this section was actually a segment marker, then the
4259 directive is ignored if the linker script explicitly
4260 processed the segment marker. Originally, the linker
4261 treated segment directives (like -Ttext on the
4262 command-line) as section directives. We honor the
4263 section directive semantics for backwards compatibility;
4264 linker scripts that do not specifically check for
4265 SEGMENT_START automatically get the old semantics. */
4266 if (!s
->address_statement
.segment
4267 || !s
->address_statement
.segment
->used
)
4269 const char *name
= s
->address_statement
.section_name
;
4271 /* Create the output section statement here so that
4272 orphans with a set address will be placed after other
4273 script sections. If we let the orphan placement code
4274 place them in amongst other sections then the address
4275 will affect following script sections, which is
4276 likely to surprise naive users. */
4277 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4278 tos
->addr_tree
= s
->address_statement
.address
;
4279 if (tos
->bfd_section
== NULL
)
4283 case lang_insert_statement_enum
:
4285 case lang_input_matcher_enum
:
4291 /* An insert statement snips out all the linker statements from the
4292 start of the list and places them after the output section
4293 statement specified by the insert. This operation is complicated
4294 by the fact that we keep a doubly linked list of output section
4295 statements as well as the singly linked list of all statements.
4296 FIXME someday: Twiddling with the list not only moves statements
4297 from the user's script but also input and group statements that are
4298 built from command line object files and --start-group. We only
4299 get away with this because the list pointers used by file_chain
4300 and input_file_chain are not reordered, and processing via
4301 statement_list after this point mostly ignores input statements.
4302 One exception is the map file, where LOAD and START GROUP/END GROUP
4303 can end up looking odd. */
4306 process_insert_statements (lang_statement_union_type
**start
)
4308 lang_statement_union_type
**s
;
4309 lang_output_section_statement_type
*first_os
= NULL
;
4310 lang_output_section_statement_type
*last_os
= NULL
;
4311 lang_output_section_statement_type
*os
;
4316 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4318 /* Keep pointers to the first and last output section
4319 statement in the sequence we may be about to move. */
4320 os
= &(*s
)->output_section_statement
;
4322 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4325 /* Set constraint negative so that lang_output_section_find
4326 won't match this output section statement. At this
4327 stage in linking constraint has values in the range
4328 [-1, ONLY_IN_RW]. */
4329 last_os
->constraint
= -2 - last_os
->constraint
;
4330 if (first_os
== NULL
)
4333 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4335 /* A user might put -T between --start-group and
4336 --end-group. One way this odd construct might arise is
4337 from a wrapper around ld to change library search
4338 behaviour. For example:
4340 exec real_ld --start-group "$@" --end-group
4341 This isn't completely unreasonable so go looking inside a
4342 group statement for insert statements. */
4343 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4345 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4347 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4348 lang_output_section_statement_type
*where
;
4349 lang_statement_union_type
**ptr
;
4350 lang_statement_union_type
*first
;
4352 if (link_info
.non_contiguous_regions
)
4354 einfo (_("warning: INSERT statement in linker script is "
4355 "incompatible with --enable-non-contiguous-regions.\n"));
4358 where
= lang_output_section_find (i
->where
);
4359 if (where
!= NULL
&& i
->is_before
)
4362 where
= where
->prev
;
4363 while (where
!= NULL
&& where
->constraint
< 0);
4367 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4371 /* Deal with reordering the output section statement list. */
4372 if (last_os
!= NULL
)
4374 asection
*first_sec
, *last_sec
;
4375 struct lang_output_section_statement_struct
**next
;
4377 /* Snip out the output sections we are moving. */
4378 first_os
->prev
->next
= last_os
->next
;
4379 if (last_os
->next
== NULL
)
4381 next
= &first_os
->prev
->next
;
4382 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4385 last_os
->next
->prev
= first_os
->prev
;
4386 /* Add them in at the new position. */
4387 last_os
->next
= where
->next
;
4388 if (where
->next
== NULL
)
4390 next
= &last_os
->next
;
4391 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4394 where
->next
->prev
= last_os
;
4395 first_os
->prev
= where
;
4396 where
->next
= first_os
;
4398 /* Move the bfd sections in the same way. */
4401 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4403 os
->constraint
= -2 - os
->constraint
;
4404 if (os
->bfd_section
!= NULL
4405 && os
->bfd_section
->owner
!= NULL
)
4407 last_sec
= os
->bfd_section
;
4408 if (first_sec
== NULL
)
4409 first_sec
= last_sec
;
4414 if (last_sec
!= NULL
)
4416 asection
*sec
= where
->bfd_section
;
4418 sec
= output_prev_sec_find (where
);
4420 /* The place we want to insert must come after the
4421 sections we are moving. So if we find no
4422 section or if the section is the same as our
4423 last section, then no move is needed. */
4424 if (sec
!= NULL
&& sec
!= last_sec
)
4426 /* Trim them off. */
4427 if (first_sec
->prev
!= NULL
)
4428 first_sec
->prev
->next
= last_sec
->next
;
4430 link_info
.output_bfd
->sections
= last_sec
->next
;
4431 if (last_sec
->next
!= NULL
)
4432 last_sec
->next
->prev
= first_sec
->prev
;
4434 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4436 if (sec
->owner
== NULL
)
4437 /* SEC is the absolute section, from the
4438 first dummy output section statement. Add
4439 back the sections we trimmed off to the
4440 start of the bfd sections. */
4443 last_sec
->next
= sec
->next
;
4445 last_sec
->next
= link_info
.output_bfd
->sections
;
4446 if (last_sec
->next
!= NULL
)
4447 last_sec
->next
->prev
= last_sec
;
4449 link_info
.output_bfd
->section_last
= last_sec
;
4450 first_sec
->prev
= sec
;
4451 if (first_sec
->prev
!= NULL
)
4452 first_sec
->prev
->next
= first_sec
;
4454 link_info
.output_bfd
->sections
= first_sec
;
4459 lang_statement_union_type
*after
= (void *) where
;
4460 if (where
== &lang_os_list
.head
->output_section_statement
4461 && where
->next
== first_os
)
4463 /* PR30155. Handle a corner case where the statement
4464 list is something like the following:
4466 . .data 0x0000000000000000 0x0
4467 . [0x0000000000000000] b = .
4469 . .data 0x0000000000000000 0x0 t.o
4470 . 0x0000000000000000 0x4 LONG 0x0
4471 . INSERT BEFORE .text.start
4472 . [0x0000000000000004] a = .
4473 . .text.start 0x0000000000000000 0x0
4474 . [0x0000000000000000] c = .
4475 . OUTPUT(a.out elf64-x86-64)
4476 Here we do not want to allow insert_os_after to
4477 choose a point inside the list we are moving.
4478 That would lose the list. Instead, let
4479 insert_os_after work from the INSERT, which in this
4480 particular example will result in inserting after
4481 the assignment "a = .". */
4484 ptr
= insert_os_after (after
);
4485 /* Snip everything from the start of the list, up to and
4486 including the insert statement we are currently processing. */
4488 *start
= (*s
)->header
.next
;
4489 /* Add them back where they belong, minus the insert. */
4492 statement_list
.tail
= s
;
4499 s
= &(*s
)->header
.next
;
4502 /* Undo constraint twiddling. */
4503 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4505 os
->constraint
= -2 - os
->constraint
;
4511 /* An output section might have been removed after its statement was
4512 added. For example, ldemul_before_allocation can remove dynamic
4513 sections if they turn out to be not needed. Clean them up here. */
4516 strip_excluded_output_sections (void)
4518 lang_output_section_statement_type
*os
;
4520 /* Run lang_size_sections (if not already done). */
4521 if (expld
.phase
!= lang_mark_phase_enum
)
4523 expld
.phase
= lang_mark_phase_enum
;
4524 expld
.dataseg
.phase
= exp_seg_none
;
4525 one_lang_size_sections_pass (NULL
, false);
4526 lang_reset_memory_regions ();
4529 for (os
= (void *) lang_os_list
.head
;
4533 asection
*output_section
;
4536 if (os
->constraint
< 0)
4539 output_section
= os
->bfd_section
;
4540 if (output_section
== NULL
)
4543 exclude
= (output_section
->rawsize
== 0
4544 && (output_section
->flags
& SEC_KEEP
) == 0
4545 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4548 /* Some sections have not yet been sized, notably .gnu.version,
4549 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4550 input sections, so don't drop output sections that have such
4551 input sections unless they are also marked SEC_EXCLUDE. */
4552 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4556 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4557 if ((s
->flags
& SEC_EXCLUDE
) == 0
4558 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4559 || link_info
.emitrelocations
))
4568 /* We don't set bfd_section to NULL since bfd_section of the
4569 removed output section statement may still be used. */
4570 if (!os
->update_dot
)
4572 output_section
->flags
|= SEC_EXCLUDE
;
4573 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4574 link_info
.output_bfd
->section_count
--;
4579 /* Called from ldwrite to clear out asection.map_head and
4580 asection.map_tail for use as link_orders in ldwrite. */
4583 lang_clear_os_map (void)
4585 lang_output_section_statement_type
*os
;
4587 if (map_head_is_link_order
)
4590 for (os
= (void *) lang_os_list
.head
;
4594 asection
*output_section
;
4596 if (os
->constraint
< 0)
4599 output_section
= os
->bfd_section
;
4600 if (output_section
== NULL
)
4603 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4604 output_section
->map_head
.link_order
= NULL
;
4605 output_section
->map_tail
.link_order
= NULL
;
4608 /* Stop future calls to lang_add_section from messing with map_head
4609 and map_tail link_order fields. */
4610 map_head_is_link_order
= true;
4614 print_output_section_statement
4615 (lang_output_section_statement_type
*output_section_statement
)
4617 asection
*section
= output_section_statement
->bfd_section
;
4620 if (output_section_statement
!= abs_output_section
)
4622 minfo ("\n%s", output_section_statement
->name
);
4624 if (section
!= NULL
)
4626 print_dot
= section
->vma
;
4628 len
= strlen (output_section_statement
->name
);
4629 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4634 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4636 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4638 if (section
->vma
!= section
->lma
)
4639 minfo (_(" load address 0x%V"), section
->lma
);
4641 if (output_section_statement
->update_dot_tree
!= NULL
)
4642 exp_fold_tree (output_section_statement
->update_dot_tree
,
4643 bfd_abs_section_ptr
, &print_dot
);
4649 print_statement_list (output_section_statement
->children
.head
,
4650 output_section_statement
);
4654 print_assignment (lang_assignment_statement_type
*assignment
,
4655 lang_output_section_statement_type
*output_section
)
4661 print_spaces (SECTION_NAME_MAP_LENGTH
);
4663 if (assignment
->exp
->type
.node_class
== etree_assert
)
4666 tree
= assignment
->exp
->assert_s
.child
;
4670 const char *dst
= assignment
->exp
->assign
.dst
;
4672 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4673 tree
= assignment
->exp
;
4676 osec
= output_section
->bfd_section
;
4678 osec
= bfd_abs_section_ptr
;
4680 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4681 exp_fold_tree (tree
, osec
, &print_dot
);
4683 expld
.result
.valid_p
= false;
4686 const char *str
= buf
;
4687 if (expld
.result
.valid_p
)
4691 if (assignment
->exp
->type
.node_class
== etree_assert
4693 || expld
.assign_name
!= NULL
)
4695 value
= expld
.result
.value
;
4697 if (expld
.result
.section
!= NULL
)
4698 value
+= expld
.result
.section
->vma
;
4702 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 2, value
);
4708 struct bfd_link_hash_entry
*h
;
4710 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4711 false, false, true);
4713 && (h
->type
== bfd_link_hash_defined
4714 || h
->type
== bfd_link_hash_defweak
))
4716 value
= h
->u
.def
.value
;
4717 value
+= h
->u
.def
.section
->output_section
->vma
;
4718 value
+= h
->u
.def
.section
->output_offset
;
4723 bfd_sprintf_vma (link_info
.output_bfd
, buf
+ 3, value
);
4727 str
= "[unresolved]";
4732 if (assignment
->exp
->type
.node_class
== etree_provide
)
4737 expld
.assign_name
= NULL
;
4739 fprintf (config
.map_file
, "%-34s", str
);
4740 exp_print_tree (assignment
->exp
);
4745 print_input_statement (lang_input_statement_type
*statm
)
4747 if (statm
->filename
!= NULL
)
4748 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4751 /* Print all symbols defined in a particular section. This is called
4752 via bfd_link_hash_traverse, or by print_all_symbols. */
4755 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4757 asection
*sec
= (asection
*) ptr
;
4759 if ((hash_entry
->type
== bfd_link_hash_defined
4760 || hash_entry
->type
== bfd_link_hash_defweak
)
4761 && sec
== hash_entry
->u
.def
.section
)
4763 print_spaces (SECTION_NAME_MAP_LENGTH
);
4765 (hash_entry
->u
.def
.value
4766 + hash_entry
->u
.def
.section
->output_offset
4767 + hash_entry
->u
.def
.section
->output_section
->vma
));
4769 minfo (" %pT\n", hash_entry
->root
.string
);
4776 hash_entry_addr_cmp (const void *a
, const void *b
)
4778 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4779 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4781 if (l
->u
.def
.value
< r
->u
.def
.value
)
4783 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4790 print_all_symbols (asection
*sec
)
4792 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4793 struct map_symbol_def
*def
;
4794 struct bfd_link_hash_entry
**entries
;
4800 *ud
->map_symbol_def_tail
= 0;
4802 /* Sort the symbols by address. */
4803 entries
= (struct bfd_link_hash_entry
**)
4804 obstack_alloc (&map_obstack
,
4805 ud
->map_symbol_def_count
* sizeof (*entries
));
4807 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4808 entries
[i
] = def
->entry
;
4810 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4811 hash_entry_addr_cmp
);
4813 /* Print the symbols. */
4814 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4815 ldemul_print_symbol (entries
[i
], sec
);
4817 obstack_free (&map_obstack
, entries
);
4820 /* Returns TRUE if SYM is a symbol suitable for printing
4821 in a linker map as a local symbol. */
4824 ld_is_local_symbol (asymbol
* sym
)
4826 const char * name
= bfd_asymbol_name (sym
);
4828 if (name
== NULL
|| *name
== 0)
4831 if (strcmp (name
, "(null)") == 0)
4834 /* Skip .Lxxx and such like. */
4835 if (bfd_is_local_label (link_info
.output_bfd
, sym
))
4838 /* FIXME: This is intended to skip ARM mapping symbols,
4839 which for some reason are not excluded by bfd_is_local_label,
4840 but maybe it is wrong for other architectures.
4841 It would be better to fix bfd_is_local_label. */
4845 /* Some local symbols, eg _GLOBAL_OFFSET_TABLE_, are present
4846 in the hash table, so do not print duplicates here. */
4847 struct bfd_link_hash_entry
* h
;
4848 h
= bfd_link_hash_lookup (link_info
.hash
, name
, false /* create */,
4849 false /* copy */, true /* follow */);
4853 /* Symbols from the plugin owned BFD will not get their own
4854 iteration of this function, but can be on the link_info
4855 list. So include them here. */
4856 if (h
->u
.def
.section
->owner
!= NULL
4857 && ((bfd_get_file_flags (h
->u
.def
.section
->owner
) & (BFD_LINKER_CREATED
| BFD_PLUGIN
))
4858 == (BFD_LINKER_CREATED
| BFD_PLUGIN
)))
4864 /* Print information about an input section to the map file. */
4867 print_input_section (asection
*i
, bool is_discarded
)
4869 bfd_size_type size
= i
->size
;
4875 minfo (" %s", i
->name
);
4877 len
= 1 + strlen (i
->name
);
4878 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4883 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
4885 if (i
->output_section
!= NULL
4886 && i
->output_section
->owner
== link_info
.output_bfd
)
4887 addr
= i
->output_section
->vma
+ i
->output_offset
;
4896 bfd_sprintf_vma (link_info
.output_bfd
, buf
, addr
);
4897 minfo ("0x%s %W %pB\n", buf
, TO_ADDR (size
), i
->owner
);
4899 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4901 len
= SECTION_NAME_MAP_LENGTH
+ 3 + strlen (buf
);
4903 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4906 if (i
->output_section
!= NULL
4907 && i
->output_section
->owner
== link_info
.output_bfd
)
4909 if (link_info
.reduce_memory_overheads
)
4910 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4912 print_all_symbols (i
);
4914 /* Update print_dot, but make sure that we do not move it
4915 backwards - this could happen if we have overlays and a
4916 later overlay is shorter than an earier one. */
4917 if (addr
+ TO_ADDR (size
) > print_dot
)
4918 print_dot
= addr
+ TO_ADDR (size
);
4920 if (config
.print_map_locals
)
4922 long storage_needed
;
4924 /* FIXME: It would be better to cache this table, rather
4925 than recreating it for each output section. */
4926 /* FIXME: This call is not working for non-ELF based targets.
4928 storage_needed
= bfd_get_symtab_upper_bound (link_info
.output_bfd
);
4929 if (storage_needed
> 0)
4931 asymbol
** symbol_table
;
4932 long number_of_symbols
;
4935 symbol_table
= xmalloc (storage_needed
);
4936 number_of_symbols
= bfd_canonicalize_symtab (link_info
.output_bfd
, symbol_table
);
4938 for (j
= 0; j
< number_of_symbols
; j
++)
4940 asymbol
* sym
= symbol_table
[j
];
4941 bfd_vma sym_addr
= sym
->value
+ i
->output_section
->vma
;
4943 if (sym
->section
== i
->output_section
4944 && (sym
->flags
& BSF_LOCAL
) != 0
4946 && sym_addr
< print_dot
4947 && ld_is_local_symbol (sym
))
4949 print_spaces (SECTION_NAME_MAP_LENGTH
);
4950 minfo ("0x%V (local) %s\n", sym_addr
, bfd_asymbol_name (sym
));
4954 free (symbol_table
);
4961 print_fill_statement (lang_fill_statement_type
*fill
)
4965 fputs (" FILL mask 0x", config
.map_file
);
4966 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4967 fprintf (config
.map_file
, "%02x", *p
);
4968 fputs ("\n", config
.map_file
);
4972 print_data_statement (lang_data_statement_type
*data
)
4978 init_opb (data
->output_section
);
4979 print_spaces (SECTION_NAME_MAP_LENGTH
);
4981 addr
= data
->output_offset
;
4982 if (data
->output_section
!= NULL
)
4983 addr
+= data
->output_section
->vma
;
5011 if (size
< TO_SIZE ((unsigned) 1))
5012 size
= TO_SIZE ((unsigned) 1);
5013 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
5015 if (data
->exp
->type
.node_class
!= etree_value
)
5018 exp_print_tree (data
->exp
);
5023 print_dot
= addr
+ TO_ADDR (size
);
5026 /* Print an address statement. These are generated by options like
5030 print_address_statement (lang_address_statement_type
*address
)
5032 minfo (_("Address of section %s set to "), address
->section_name
);
5033 exp_print_tree (address
->address
);
5037 /* Print a reloc statement. */
5040 print_reloc_statement (lang_reloc_statement_type
*reloc
)
5045 init_opb (reloc
->output_section
);
5046 print_spaces (SECTION_NAME_MAP_LENGTH
);
5048 addr
= reloc
->output_offset
;
5049 if (reloc
->output_section
!= NULL
)
5050 addr
+= reloc
->output_section
->vma
;
5052 size
= bfd_get_reloc_size (reloc
->howto
);
5054 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
5056 if (reloc
->name
!= NULL
)
5057 minfo ("%s+", reloc
->name
);
5059 minfo ("%s+", reloc
->section
->name
);
5061 exp_print_tree (reloc
->addend_exp
);
5065 print_dot
= addr
+ TO_ADDR (size
);
5069 print_padding_statement (lang_padding_statement_type
*s
)
5074 init_opb (s
->output_section
);
5077 len
= sizeof " *fill*" - 1;
5078 print_spaces (SECTION_NAME_MAP_LENGTH
- len
);
5080 addr
= s
->output_offset
;
5081 if (s
->output_section
!= NULL
)
5082 addr
+= s
->output_section
->vma
;
5083 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5085 if (s
->fill
->size
!= 0)
5089 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5090 fprintf (config
.map_file
, "%02x", *p
);
5095 print_dot
= addr
+ TO_ADDR (s
->size
);
5099 print_wild_statement (lang_wild_statement_type
*w
,
5100 lang_output_section_statement_type
*os
)
5102 struct wildcard_list
*sec
;
5106 if (w
->exclude_name_list
)
5109 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5110 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5111 minfo (" %s", tmp
->name
);
5115 if (w
->filenames_sorted
)
5116 minfo ("SORT_BY_NAME(");
5117 if (w
->filename
!= NULL
)
5118 minfo ("%s", w
->filename
);
5121 if (w
->filenames_sorted
)
5125 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5127 int closing_paren
= 0;
5129 switch (sec
->spec
.sorted
)
5135 minfo ("SORT_BY_NAME(");
5140 minfo ("SORT_BY_ALIGNMENT(");
5144 case by_name_alignment
:
5145 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5149 case by_alignment_name
:
5150 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5155 minfo ("SORT_NONE(");
5159 case by_init_priority
:
5160 minfo ("SORT_BY_INIT_PRIORITY(");
5165 if (sec
->spec
.exclude_name_list
!= NULL
)
5168 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5169 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5170 minfo (" %s", tmp
->name
);
5173 if (sec
->spec
.name
!= NULL
)
5174 minfo ("%s", sec
->spec
.name
);
5177 for (;closing_paren
> 0; closing_paren
--)
5186 print_statement_list (w
->children
.head
, os
);
5189 /* Print a group statement. */
5192 print_group (lang_group_statement_type
*s
,
5193 lang_output_section_statement_type
*os
)
5195 fprintf (config
.map_file
, "START GROUP\n");
5196 print_statement_list (s
->children
.head
, os
);
5197 fprintf (config
.map_file
, "END GROUP\n");
5200 /* Print the list of statements in S.
5201 This can be called for any statement type. */
5204 print_statement_list (lang_statement_union_type
*s
,
5205 lang_output_section_statement_type
*os
)
5209 print_statement (s
, os
);
5214 /* Print the first statement in statement list S.
5215 This can be called for any statement type. */
5218 print_statement (lang_statement_union_type
*s
,
5219 lang_output_section_statement_type
*os
)
5221 switch (s
->header
.type
)
5224 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5227 case lang_constructors_statement_enum
:
5228 if (constructor_list
.head
!= NULL
)
5230 if (constructors_sorted
)
5231 minfo (" SORT (CONSTRUCTORS)\n");
5233 minfo (" CONSTRUCTORS\n");
5234 print_statement_list (constructor_list
.head
, os
);
5237 case lang_wild_statement_enum
:
5238 print_wild_statement (&s
->wild_statement
, os
);
5240 case lang_address_statement_enum
:
5241 print_address_statement (&s
->address_statement
);
5243 case lang_object_symbols_statement_enum
:
5244 minfo (" CREATE_OBJECT_SYMBOLS\n");
5246 case lang_fill_statement_enum
:
5247 print_fill_statement (&s
->fill_statement
);
5249 case lang_data_statement_enum
:
5250 print_data_statement (&s
->data_statement
);
5252 case lang_reloc_statement_enum
:
5253 print_reloc_statement (&s
->reloc_statement
);
5255 case lang_input_section_enum
:
5256 print_input_section (s
->input_section
.section
, false);
5258 case lang_padding_statement_enum
:
5259 print_padding_statement (&s
->padding_statement
);
5261 case lang_output_section_statement_enum
:
5262 print_output_section_statement (&s
->output_section_statement
);
5264 case lang_assignment_statement_enum
:
5265 print_assignment (&s
->assignment_statement
, os
);
5267 case lang_target_statement_enum
:
5268 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5270 case lang_output_statement_enum
:
5271 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5272 if (output_target
!= NULL
)
5273 minfo (" %s", output_target
);
5276 case lang_input_statement_enum
:
5277 print_input_statement (&s
->input_statement
);
5279 case lang_group_statement_enum
:
5280 print_group (&s
->group_statement
, os
);
5282 case lang_insert_statement_enum
:
5283 minfo ("INSERT %s %s\n",
5284 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5285 s
->insert_statement
.where
);
5291 print_statements (void)
5293 print_statement_list (statement_list
.head
, abs_output_section
);
5296 /* Print the first N statements in statement list S to STDERR.
5297 If N == 0, nothing is printed.
5298 If N < 0, the entire list is printed.
5299 Intended to be called from GDB. */
5302 dprint_statement (lang_statement_union_type
*s
, int n
)
5304 FILE *map_save
= config
.map_file
;
5306 config
.map_file
= stderr
;
5309 print_statement_list (s
, abs_output_section
);
5312 while (s
&& --n
>= 0)
5314 print_statement (s
, abs_output_section
);
5319 config
.map_file
= map_save
;
5323 insert_pad (lang_statement_union_type
**ptr
,
5325 bfd_size_type alignment_needed
,
5326 asection
*output_section
,
5329 static fill_type zero_fill
;
5330 lang_statement_union_type
*pad
= NULL
;
5332 if (ptr
!= &statement_list
.head
)
5333 pad
= ((lang_statement_union_type
*)
5334 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5336 && pad
->header
.type
== lang_padding_statement_enum
5337 && pad
->padding_statement
.output_section
== output_section
)
5339 /* Use the existing pad statement. */
5341 else if ((pad
= *ptr
) != NULL
5342 && pad
->header
.type
== lang_padding_statement_enum
5343 && pad
->padding_statement
.output_section
== output_section
)
5345 /* Use the existing pad statement. */
5349 /* Make a new padding statement, linked into existing chain. */
5350 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5351 pad
->header
.next
= *ptr
;
5353 pad
->header
.type
= lang_padding_statement_enum
;
5354 pad
->padding_statement
.output_section
= output_section
;
5357 pad
->padding_statement
.fill
= fill
;
5359 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5360 pad
->padding_statement
.size
= alignment_needed
;
5361 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5362 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5363 - output_section
->vma
);
5366 /* Work out how much this section will move the dot point. */
5370 (lang_statement_union_type
**this_ptr
,
5371 lang_output_section_statement_type
*output_section_statement
,
5376 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5377 asection
*i
= is
->section
;
5378 asection
*o
= output_section_statement
->bfd_section
;
5381 if (link_info
.non_contiguous_regions
)
5383 /* If the input section I has already been successfully assigned
5384 to an output section other than O, don't bother with it and
5385 let the caller remove it from the list. Keep processing in
5386 case we have already handled O, because the repeated passes
5387 have reinitialized its size. */
5388 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5395 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5396 i
->output_offset
= i
->vma
- o
->vma
;
5397 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5398 || output_section_statement
->ignored
)
5399 i
->output_offset
= dot
- o
->vma
;
5402 bfd_size_type alignment_needed
;
5404 /* Align this section first to the input sections requirement,
5405 then to the output section's requirement. If this alignment
5406 is greater than any seen before, then record it too. Perform
5407 the alignment by inserting a magic 'padding' statement. */
5409 if (output_section_statement
->subsection_alignment
!= NULL
)
5411 = exp_get_power (output_section_statement
->subsection_alignment
,
5412 "subsection alignment");
5414 if (o
->alignment_power
< i
->alignment_power
)
5415 o
->alignment_power
= i
->alignment_power
;
5417 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5419 if (alignment_needed
!= 0)
5421 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5422 dot
+= alignment_needed
;
5425 if (link_info
.non_contiguous_regions
)
5427 /* If I would overflow O, let the caller remove I from the
5429 if (output_section_statement
->region
)
5431 bfd_vma end
= output_section_statement
->region
->origin
5432 + output_section_statement
->region
->length
;
5434 if (dot
+ TO_ADDR (i
->size
) > end
)
5436 if (i
->flags
& SEC_LINKER_CREATED
)
5437 einfo (_("%F%P: Output section `%pA' not large enough for "
5438 "the linker-created stubs section `%pA'.\n"),
5439 i
->output_section
, i
);
5441 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5442 einfo (_("%F%P: Relaxation not supported with "
5443 "--enable-non-contiguous-regions (section `%pA' "
5444 "would overflow `%pA' after it changed size).\n"),
5445 i
, i
->output_section
);
5449 i
->output_section
= NULL
;
5455 /* Remember where in the output section this input section goes. */
5456 i
->output_offset
= dot
- o
->vma
;
5458 /* Mark how big the output section must be to contain this now. */
5459 dot
+= TO_ADDR (i
->size
);
5460 if (!(o
->flags
& SEC_FIXED_SIZE
))
5461 o
->size
= TO_SIZE (dot
- o
->vma
);
5463 if (link_info
.non_contiguous_regions
)
5465 /* Record that I was successfully assigned to O, and update
5466 its actual output section too. */
5467 i
->already_assigned
= o
;
5468 i
->output_section
= o
;
5482 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5484 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5485 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5487 if (sec1
->lma
< sec2
->lma
)
5489 else if (sec1
->lma
> sec2
->lma
)
5491 else if (sec1
->id
< sec2
->id
)
5493 else if (sec1
->id
> sec2
->id
)
5500 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5502 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5503 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5505 if (sec1
->vma
< sec2
->vma
)
5507 else if (sec1
->vma
> sec2
->vma
)
5509 else if (sec1
->id
< sec2
->id
)
5511 else if (sec1
->id
> sec2
->id
)
5517 #define IS_TBSS(s) \
5518 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5520 #define IGNORE_SECTION(s) \
5521 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5523 /* Check to see if any allocated sections overlap with other allocated
5524 sections. This can happen if a linker script specifies the output
5525 section addresses of the two sections. Also check whether any memory
5526 region has overflowed. */
5529 lang_check_section_addresses (void)
5532 struct check_sec
*sections
;
5537 bfd_vma p_start
= 0;
5539 lang_memory_region_type
*m
;
5542 /* Detect address space overflow on allocated sections. */
5543 addr_mask
= ((bfd_vma
) 1 <<
5544 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5545 addr_mask
= (addr_mask
<< 1) + 1;
5546 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5547 if ((s
->flags
& SEC_ALLOC
) != 0)
5549 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5550 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5551 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5555 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5556 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5557 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5562 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5565 count
= bfd_count_sections (link_info
.output_bfd
);
5566 sections
= XNEWVEC (struct check_sec
, count
);
5568 /* Scan all sections in the output list. */
5570 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5572 if (IGNORE_SECTION (s
)
5576 sections
[count
].sec
= s
;
5577 sections
[count
].warned
= false;
5587 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5589 /* First check section LMAs. There should be no overlap of LMAs on
5590 loadable sections, even with overlays. */
5591 for (p
= NULL
, i
= 0; i
< count
; i
++)
5593 s
= sections
[i
].sec
;
5595 if ((s
->flags
& SEC_LOAD
) != 0)
5598 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5600 /* Look for an overlap. We have sorted sections by lma, so
5601 we know that s_start >= p_start. Besides the obvious
5602 case of overlap when the current section starts before
5603 the previous one ends, we also must have overlap if the
5604 previous section wraps around the address space. */
5606 && (s_start
<= p_end
5607 || p_end
< p_start
))
5609 einfo (_("%X%P: section %s LMA [%V,%V]"
5610 " overlaps section %s LMA [%V,%V]\n"),
5611 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5612 sections
[i
].warned
= true;
5620 /* If any non-zero size allocated section (excluding tbss) starts at
5621 exactly the same VMA as another such section, then we have
5622 overlays. Overlays generated by the OVERLAY keyword will have
5623 this property. It is possible to intentionally generate overlays
5624 that fail this test, but it would be unusual. */
5625 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5627 p_start
= sections
[0].sec
->vma
;
5628 for (i
= 1; i
< count
; i
++)
5630 s_start
= sections
[i
].sec
->vma
;
5631 if (p_start
== s_start
)
5639 /* Now check section VMAs if no overlays were detected. */
5642 for (p
= NULL
, i
= 0; i
< count
; i
++)
5644 s
= sections
[i
].sec
;
5647 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5650 && !sections
[i
].warned
5651 && (s_start
<= p_end
5652 || p_end
< p_start
))
5653 einfo (_("%X%P: section %s VMA [%V,%V]"
5654 " overlaps section %s VMA [%V,%V]\n"),
5655 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5664 /* If any memory region has overflowed, report by how much.
5665 We do not issue this diagnostic for regions that had sections
5666 explicitly placed outside their bounds; os_region_check's
5667 diagnostics are adequate for that case.
5669 FIXME: It is conceivable that m->current - (m->origin + m->length)
5670 might overflow a 32-bit integer. There is, alas, no way to print
5671 a bfd_vma quantity in decimal. */
5672 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5673 if (m
->had_full_message
)
5675 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5676 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5677 "%X%P: region `%s' overflowed by %lu bytes\n",
5679 m
->name_list
.name
, over
);
5683 /* Make sure the new address is within the region. We explicitly permit the
5684 current address to be at the exact end of the region when the address is
5685 non-zero, in case the region is at the end of addressable memory and the
5686 calculation wraps around. */
5689 os_region_check (lang_output_section_statement_type
*os
,
5690 lang_memory_region_type
*region
,
5694 if ((region
->current
< region
->origin
5695 || (region
->current
- region
->origin
> region
->length
))
5696 && ((region
->current
!= region
->origin
+ region
->length
)
5701 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5702 " is not within region `%s'\n"),
5704 os
->bfd_section
->owner
,
5705 os
->bfd_section
->name
,
5706 region
->name_list
.name
);
5708 else if (!region
->had_full_message
)
5710 region
->had_full_message
= true;
5712 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5713 os
->bfd_section
->owner
,
5714 os
->bfd_section
->name
,
5715 region
->name_list
.name
);
5721 ldlang_check_relro_region (lang_statement_union_type
*s
)
5723 seg_align_type
*seg
= &expld
.dataseg
;
5725 if (seg
->relro
== exp_seg_relro_start
)
5727 if (!seg
->relro_start_stat
)
5728 seg
->relro_start_stat
= s
;
5731 ASSERT (seg
->relro_start_stat
== s
);
5734 else if (seg
->relro
== exp_seg_relro_end
)
5736 if (!seg
->relro_end_stat
)
5737 seg
->relro_end_stat
= s
;
5740 ASSERT (seg
->relro_end_stat
== s
);
5745 /* Set the sizes for all the output sections. */
5748 lang_size_sections_1
5749 (lang_statement_union_type
**prev
,
5750 lang_output_section_statement_type
*output_section_statement
,
5756 lang_statement_union_type
*s
;
5757 lang_statement_union_type
*prev_s
= NULL
;
5758 bool removed_prev_s
= false;
5760 /* Size up the sections from their constituent parts. */
5761 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5763 bool removed
= false;
5765 switch (s
->header
.type
)
5767 case lang_output_section_statement_enum
:
5769 bfd_vma newdot
, after
, dotdelta
;
5770 lang_output_section_statement_type
*os
;
5771 lang_memory_region_type
*r
;
5772 int section_alignment
= 0;
5774 os
= &s
->output_section_statement
;
5775 init_opb (os
->bfd_section
);
5776 if (os
->constraint
== -1)
5779 /* FIXME: We shouldn't need to zero section vmas for ld -r
5780 here, in lang_insert_orphan, or in the default linker scripts.
5781 This is covering for coff backend linker bugs. See PR6945. */
5782 if (os
->addr_tree
== NULL
5783 && bfd_link_relocatable (&link_info
)
5784 && (bfd_get_flavour (link_info
.output_bfd
)
5785 == bfd_target_coff_flavour
))
5786 os
->addr_tree
= exp_intop (0);
5787 if (os
->addr_tree
!= NULL
)
5789 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5791 if (expld
.result
.valid_p
)
5793 dot
= expld
.result
.value
;
5794 if (expld
.result
.section
!= NULL
)
5795 dot
+= expld
.result
.section
->vma
;
5797 else if (expld
.phase
!= lang_mark_phase_enum
)
5798 einfo (_("%F%P:%pS: non constant or forward reference"
5799 " address expression for section %s\n"),
5800 os
->addr_tree
, os
->name
);
5803 if (os
->bfd_section
== NULL
)
5804 /* This section was removed or never actually created. */
5807 /* If this is a COFF shared library section, use the size and
5808 address from the input section. FIXME: This is COFF
5809 specific; it would be cleaner if there were some other way
5810 to do this, but nothing simple comes to mind. */
5811 if (((bfd_get_flavour (link_info
.output_bfd
)
5812 == bfd_target_ecoff_flavour
)
5813 || (bfd_get_flavour (link_info
.output_bfd
)
5814 == bfd_target_coff_flavour
))
5815 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5819 if (os
->children
.head
== NULL
5820 || os
->children
.head
->header
.next
!= NULL
5821 || (os
->children
.head
->header
.type
5822 != lang_input_section_enum
))
5823 einfo (_("%X%P: internal error on COFF shared library"
5824 " section %s\n"), os
->name
);
5826 input
= os
->children
.head
->input_section
.section
;
5827 bfd_set_section_vma (os
->bfd_section
,
5828 bfd_section_vma (input
));
5829 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5830 os
->bfd_section
->size
= input
->size
;
5836 if (bfd_is_abs_section (os
->bfd_section
))
5838 /* No matter what happens, an abs section starts at zero. */
5839 ASSERT (os
->bfd_section
->vma
== 0);
5843 if (os
->addr_tree
== NULL
)
5845 /* No address specified for this section, get one
5846 from the region specification. */
5847 if (os
->region
== NULL
5848 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5849 && os
->region
->name_list
.name
[0] == '*'
5850 && strcmp (os
->region
->name_list
.name
,
5851 DEFAULT_MEMORY_REGION
) == 0))
5853 os
->region
= lang_memory_default (os
->bfd_section
);
5856 /* If a loadable section is using the default memory
5857 region, and some non default memory regions were
5858 defined, issue an error message. */
5860 && !IGNORE_SECTION (os
->bfd_section
)
5861 && !bfd_link_relocatable (&link_info
)
5863 && strcmp (os
->region
->name_list
.name
,
5864 DEFAULT_MEMORY_REGION
) == 0
5865 && lang_memory_region_list
!= NULL
5866 && (strcmp (lang_memory_region_list
->name_list
.name
,
5867 DEFAULT_MEMORY_REGION
) != 0
5868 || lang_memory_region_list
->next
!= NULL
)
5869 && lang_sizing_iteration
== 1)
5871 /* By default this is an error rather than just a
5872 warning because if we allocate the section to the
5873 default memory region we can end up creating an
5874 excessively large binary, or even seg faulting when
5875 attempting to perform a negative seek. See
5876 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5877 for an example of this. This behaviour can be
5878 overridden by the using the --no-check-sections
5880 if (command_line
.check_section_addresses
)
5881 einfo (_("%F%P: error: no memory region specified"
5882 " for loadable section `%s'\n"),
5883 bfd_section_name (os
->bfd_section
));
5885 einfo (_("%P: warning: no memory region specified"
5886 " for loadable section `%s'\n"),
5887 bfd_section_name (os
->bfd_section
));
5890 newdot
= os
->region
->current
;
5891 section_alignment
= os
->bfd_section
->alignment_power
;
5894 section_alignment
= exp_get_power (os
->section_alignment
,
5895 "section alignment");
5897 /* Align to what the section needs. */
5898 if (section_alignment
> 0)
5900 bfd_vma savedot
= newdot
;
5903 newdot
= align_power (newdot
, section_alignment
);
5904 dotdelta
= newdot
- savedot
;
5906 if (lang_sizing_iteration
== 1)
5908 else if (lang_sizing_iteration
> 1)
5910 /* Only report adjustments that would change
5911 alignment from what we have already reported. */
5912 diff
= newdot
- os
->bfd_section
->vma
;
5913 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5917 && (config
.warn_section_align
5918 || os
->addr_tree
!= NULL
))
5919 einfo (_("%P: warning: "
5920 "start of section %s changed by %ld\n"),
5921 os
->name
, (long) diff
);
5924 bfd_set_section_vma (os
->bfd_section
, newdot
);
5926 os
->bfd_section
->output_offset
= 0;
5929 lang_size_sections_1 (&os
->children
.head
, os
,
5930 os
->fill
, newdot
, relax
, check_regions
);
5932 os
->processed_vma
= true;
5934 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5935 /* Except for some special linker created sections,
5936 no output section should change from zero size
5937 after strip_excluded_output_sections. A non-zero
5938 size on an ignored section indicates that some
5939 input section was not sized early enough. */
5940 ASSERT (os
->bfd_section
->size
== 0);
5943 dot
= os
->bfd_section
->vma
;
5945 /* Put the section within the requested block size, or
5946 align at the block boundary. */
5948 + TO_ADDR (os
->bfd_section
->size
)
5949 + os
->block_value
- 1)
5950 & - (bfd_vma
) os
->block_value
);
5952 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5953 os
->bfd_section
->size
= TO_SIZE (after
5954 - os
->bfd_section
->vma
);
5957 /* Set section lma. */
5960 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
5964 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5965 os
->bfd_section
->lma
= lma
;
5967 else if (os
->lma_region
!= NULL
)
5969 bfd_vma lma
= os
->lma_region
->current
;
5971 if (os
->align_lma_with_input
)
5975 /* When LMA_REGION is the same as REGION, align the LMA
5976 as we did for the VMA, possibly including alignment
5977 from the bfd section. If a different region, then
5978 only align according to the value in the output
5980 if (os
->lma_region
!= os
->region
)
5981 section_alignment
= exp_get_power (os
->section_alignment
,
5982 "section alignment");
5983 if (section_alignment
> 0)
5984 lma
= align_power (lma
, section_alignment
);
5986 os
->bfd_section
->lma
= lma
;
5988 else if (r
->last_os
!= NULL
5989 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5994 last
= r
->last_os
->output_section_statement
.bfd_section
;
5996 /* A backwards move of dot should be accompanied by
5997 an explicit assignment to the section LMA (ie.
5998 os->load_base set) because backwards moves can
5999 create overlapping LMAs. */
6001 && os
->bfd_section
->size
!= 0
6002 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
6004 /* If dot moved backwards then leave lma equal to
6005 vma. This is the old default lma, which might
6006 just happen to work when the backwards move is
6007 sufficiently large. Nag if this changes anything,
6008 so people can fix their linker scripts. */
6010 if (last
->vma
!= last
->lma
)
6011 einfo (_("%P: warning: dot moved backwards "
6012 "before `%s'\n"), os
->name
);
6016 /* If this is an overlay, set the current lma to that
6017 at the end of the previous section. */
6018 if (os
->sectype
== overlay_section
)
6019 lma
= last
->lma
+ TO_ADDR (last
->size
);
6021 /* Otherwise, keep the same lma to vma relationship
6022 as the previous section. */
6024 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
6026 if (section_alignment
> 0)
6027 lma
= align_power (lma
, section_alignment
);
6028 os
->bfd_section
->lma
= lma
;
6031 os
->processed_lma
= true;
6033 /* Keep track of normal sections using the default
6034 lma region. We use this to set the lma for
6035 following sections. Overlays or other linker
6036 script assignment to lma might mean that the
6037 default lma == vma is incorrect.
6038 To avoid warnings about dot moving backwards when using
6039 -Ttext, don't start tracking sections until we find one
6040 of non-zero size or with lma set differently to vma.
6041 Do this tracking before we short-cut the loop so that we
6042 track changes for the case where the section size is zero,
6043 but the lma is set differently to the vma. This is
6044 important, if an orphan section is placed after an
6045 otherwise empty output section that has an explicit lma
6046 set, we want that lma reflected in the orphans lma. */
6047 if (((!IGNORE_SECTION (os
->bfd_section
)
6048 && (os
->bfd_section
->size
!= 0
6049 || (r
->last_os
== NULL
6050 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
6051 || (r
->last_os
!= NULL
6052 && dot
>= (r
->last_os
->output_section_statement
6053 .bfd_section
->vma
))))
6054 || os
->sectype
== first_overlay_section
)
6055 && os
->lma_region
== NULL
6056 && !bfd_link_relocatable (&link_info
))
6059 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
6062 /* .tbss sections effectively have zero size. */
6063 if (!IS_TBSS (os
->bfd_section
)
6064 || bfd_link_relocatable (&link_info
))
6065 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
6070 if (os
->update_dot_tree
!= 0)
6071 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
6073 /* Update dot in the region ?
6074 We only do this if the section is going to be allocated,
6075 since unallocated sections do not contribute to the region's
6076 overall size in memory. */
6077 if (os
->region
!= NULL
6078 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
6080 os
->region
->current
= dot
;
6083 /* Make sure the new address is within the region. */
6084 os_region_check (os
, os
->region
, os
->addr_tree
,
6085 os
->bfd_section
->vma
);
6087 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6088 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6089 || os
->align_lma_with_input
))
6091 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6094 os_region_check (os
, os
->lma_region
, NULL
,
6095 os
->bfd_section
->lma
);
6101 case lang_constructors_statement_enum
:
6102 dot
= lang_size_sections_1 (&constructor_list
.head
,
6103 output_section_statement
,
6104 fill
, dot
, relax
, check_regions
);
6107 case lang_data_statement_enum
:
6109 unsigned int size
= 0;
6111 s
->data_statement
.output_offset
=
6112 dot
- output_section_statement
->bfd_section
->vma
;
6113 s
->data_statement
.output_section
=
6114 output_section_statement
->bfd_section
;
6116 /* We might refer to provided symbols in the expression, and
6117 need to mark them as needed. */
6118 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6120 switch (s
->data_statement
.type
)
6138 if (size
< TO_SIZE ((unsigned) 1))
6139 size
= TO_SIZE ((unsigned) 1);
6140 dot
+= TO_ADDR (size
);
6141 if (!(output_section_statement
->bfd_section
->flags
6143 output_section_statement
->bfd_section
->size
6144 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6149 case lang_reloc_statement_enum
:
6153 s
->reloc_statement
.output_offset
=
6154 dot
- output_section_statement
->bfd_section
->vma
;
6155 s
->reloc_statement
.output_section
=
6156 output_section_statement
->bfd_section
;
6157 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6158 dot
+= TO_ADDR (size
);
6159 if (!(output_section_statement
->bfd_section
->flags
6161 output_section_statement
->bfd_section
->size
6162 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6166 case lang_wild_statement_enum
:
6167 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6168 output_section_statement
,
6169 fill
, dot
, relax
, check_regions
);
6172 case lang_object_symbols_statement_enum
:
6173 link_info
.create_object_symbols_section
6174 = output_section_statement
->bfd_section
;
6175 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6178 case lang_output_statement_enum
:
6179 case lang_target_statement_enum
:
6182 case lang_input_section_enum
:
6186 i
= s
->input_section
.section
;
6191 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6192 einfo (_("%F%P: can't relax section: %E\n"));
6196 dot
= size_input_section (prev
, output_section_statement
,
6197 fill
, &removed
, dot
);
6201 case lang_input_statement_enum
:
6204 case lang_fill_statement_enum
:
6205 s
->fill_statement
.output_section
=
6206 output_section_statement
->bfd_section
;
6208 fill
= s
->fill_statement
.fill
;
6211 case lang_assignment_statement_enum
:
6213 bfd_vma newdot
= dot
;
6214 etree_type
*tree
= s
->assignment_statement
.exp
;
6216 expld
.dataseg
.relro
= exp_seg_relro_none
;
6218 exp_fold_tree (tree
,
6219 output_section_statement
->bfd_section
,
6222 ldlang_check_relro_region (s
);
6224 expld
.dataseg
.relro
= exp_seg_relro_none
;
6226 /* This symbol may be relative to this section. */
6227 if ((tree
->type
.node_class
== etree_provided
6228 || tree
->type
.node_class
== etree_assign
)
6229 && (tree
->assign
.dst
[0] != '.'
6230 || tree
->assign
.dst
[1] != '\0'))
6231 output_section_statement
->update_dot
= 1;
6233 if (!output_section_statement
->ignored
)
6235 if (output_section_statement
== abs_output_section
)
6237 /* If we don't have an output section, then just adjust
6238 the default memory address. */
6239 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6240 false)->current
= newdot
;
6242 else if (newdot
!= dot
)
6244 /* Insert a pad after this statement. We can't
6245 put the pad before when relaxing, in case the
6246 assignment references dot. */
6247 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6248 output_section_statement
->bfd_section
, dot
);
6250 /* Don't neuter the pad below when relaxing. */
6253 /* If dot is advanced, this implies that the section
6254 should have space allocated to it, unless the
6255 user has explicitly stated that the section
6256 should not be allocated. */
6257 if (output_section_statement
->sectype
!= noalloc_section
6258 && (output_section_statement
->sectype
!= noload_section
6259 || (bfd_get_flavour (link_info
.output_bfd
)
6260 == bfd_target_elf_flavour
)))
6261 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6268 case lang_padding_statement_enum
:
6269 /* If this is the first time lang_size_sections is called,
6270 we won't have any padding statements. If this is the
6271 second or later passes when relaxing, we should allow
6272 padding to shrink. If padding is needed on this pass, it
6273 will be added back in. */
6274 s
->padding_statement
.size
= 0;
6276 /* Make sure output_offset is valid. If relaxation shrinks
6277 the section and this pad isn't needed, it's possible to
6278 have output_offset larger than the final size of the
6279 section. bfd_set_section_contents will complain even for
6280 a pad size of zero. */
6281 s
->padding_statement
.output_offset
6282 = dot
- output_section_statement
->bfd_section
->vma
;
6285 case lang_group_statement_enum
:
6286 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6287 output_section_statement
,
6288 fill
, dot
, relax
, check_regions
);
6291 case lang_insert_statement_enum
:
6294 /* We can only get here when relaxing is turned on. */
6295 case lang_address_statement_enum
:
6303 /* If an input section doesn't fit in the current output
6304 section, remove it from the list. Handle the case where we
6305 have to remove an input_section statement here: there is a
6306 special case to remove the first element of the list. */
6307 if (link_info
.non_contiguous_regions
&& removed
)
6309 /* If we removed the first element during the previous
6310 iteration, override the loop assignment of prev_s. */
6316 /* If there was a real previous input section, just skip
6318 prev_s
->header
.next
=s
->header
.next
;
6320 removed_prev_s
= false;
6324 /* Remove the first input section of the list. */
6325 *prev
= s
->header
.next
;
6326 removed_prev_s
= true;
6329 /* Move to next element, unless we removed the head of the
6331 if (!removed_prev_s
)
6332 prev
= &s
->header
.next
;
6336 prev
= &s
->header
.next
;
6337 removed_prev_s
= false;
6343 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6344 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6345 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6346 segments. We are allowed an opportunity to override this decision. */
6349 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6350 bfd
*abfd ATTRIBUTE_UNUSED
,
6351 asection
*current_section
,
6352 asection
*previous_section
,
6355 lang_output_section_statement_type
*cur
;
6356 lang_output_section_statement_type
*prev
;
6358 /* The checks below are only necessary when the BFD library has decided
6359 that the two sections ought to be placed into the same segment. */
6363 /* Paranoia checks. */
6364 if (current_section
== NULL
|| previous_section
== NULL
)
6367 /* If this flag is set, the target never wants code and non-code
6368 sections comingled in the same segment. */
6369 if (config
.separate_code
6370 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6373 /* Find the memory regions associated with the two sections.
6374 We call lang_output_section_find() here rather than scanning the list
6375 of output sections looking for a matching section pointer because if
6376 we have a large number of sections then a hash lookup is faster. */
6377 cur
= lang_output_section_find (current_section
->name
);
6378 prev
= lang_output_section_find (previous_section
->name
);
6380 /* More paranoia. */
6381 if (cur
== NULL
|| prev
== NULL
)
6384 /* If the regions are different then force the sections to live in
6385 different segments. See the email thread starting at the following
6386 URL for the reasons why this is necessary:
6387 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6388 return cur
->region
!= prev
->region
;
6392 one_lang_size_sections_pass (bool *relax
, bool check_regions
)
6394 lang_statement_iteration
++;
6395 if (expld
.phase
!= lang_mark_phase_enum
)
6396 lang_sizing_iteration
++;
6397 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6398 0, 0, relax
, check_regions
);
6402 lang_size_segment (void)
6404 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6405 a page could be saved in the data segment. */
6406 seg_align_type
*seg
= &expld
.dataseg
;
6407 bfd_vma first
, last
;
6409 first
= -seg
->base
& (seg
->commonpagesize
- 1);
6410 last
= seg
->end
& (seg
->commonpagesize
- 1);
6412 && ((seg
->base
& ~(seg
->commonpagesize
- 1))
6413 != (seg
->end
& ~(seg
->commonpagesize
- 1)))
6414 && first
+ last
<= seg
->commonpagesize
)
6416 seg
->phase
= exp_seg_adjust
;
6420 seg
->phase
= exp_seg_done
;
6425 lang_size_relro_segment_1 (void)
6427 seg_align_type
*seg
= &expld
.dataseg
;
6428 bfd_vma relro_end
, desired_end
;
6431 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6432 relro_end
= (seg
->relro_end
+ seg
->relropagesize
- 1) & -seg
->relropagesize
;
6434 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6435 desired_end
= relro_end
- seg
->relro_offset
;
6437 /* For sections in the relro segment.. */
6438 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6439 if ((sec
->flags
& SEC_ALLOC
) != 0
6440 && sec
->vma
>= seg
->base
6441 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6443 /* Where do we want to put this section so that it ends as
6445 bfd_vma start
, end
, bump
;
6447 end
= start
= sec
->vma
;
6449 end
+= TO_ADDR (sec
->size
);
6450 bump
= desired_end
- end
;
6451 /* We'd like to increase START by BUMP, but we must heed
6452 alignment so the increase might be less than optimum. */
6454 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6455 /* This is now the desired end for the previous section. */
6456 desired_end
= start
;
6459 seg
->phase
= exp_seg_relro_adjust
;
6460 ASSERT (desired_end
>= seg
->base
);
6461 seg
->base
= desired_end
;
6466 lang_size_relro_segment (bool *relax
, bool check_regions
)
6468 bool do_reset
= false;
6470 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6472 bfd_vma data_initial_base
= expld
.dataseg
.base
;
6473 bfd_vma data_relro_end
= lang_size_relro_segment_1 ();
6475 lang_reset_memory_regions ();
6476 one_lang_size_sections_pass (relax
, check_regions
);
6478 /* Assignments to dot, or to output section address in a user
6479 script have increased padding over the original. Revert. */
6480 if (expld
.dataseg
.relro_end
> data_relro_end
)
6482 expld
.dataseg
.base
= data_initial_base
;
6486 else if (lang_size_segment ())
6493 lang_size_sections (bool *relax
, bool check_regions
)
6495 expld
.phase
= lang_allocating_phase_enum
;
6496 expld
.dataseg
.phase
= exp_seg_none
;
6498 one_lang_size_sections_pass (relax
, check_regions
);
6500 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6501 expld
.dataseg
.phase
= exp_seg_done
;
6503 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6506 = lang_size_relro_segment (relax
, check_regions
);
6510 lang_reset_memory_regions ();
6511 one_lang_size_sections_pass (relax
, check_regions
);
6514 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6516 link_info
.relro_start
= expld
.dataseg
.base
;
6517 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6522 static lang_output_section_statement_type
*current_section
;
6523 static lang_assignment_statement_type
*current_assign
;
6524 static bool prefer_next_section
;
6526 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6529 lang_do_assignments_1 (lang_statement_union_type
*s
,
6530 lang_output_section_statement_type
*current_os
,
6535 for (; s
!= NULL
; s
= s
->header
.next
)
6537 switch (s
->header
.type
)
6539 case lang_constructors_statement_enum
:
6540 dot
= lang_do_assignments_1 (constructor_list
.head
,
6541 current_os
, fill
, dot
, found_end
);
6544 case lang_output_section_statement_enum
:
6546 lang_output_section_statement_type
*os
;
6549 os
= &(s
->output_section_statement
);
6550 os
->after_end
= *found_end
;
6551 init_opb (os
->bfd_section
);
6553 if (os
->bfd_section
!= NULL
)
6555 if (!os
->ignored
&& (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6557 current_section
= os
;
6558 prefer_next_section
= false;
6560 newdot
= os
->bfd_section
->vma
;
6562 newdot
= lang_do_assignments_1 (os
->children
.head
,
6563 os
, os
->fill
, newdot
, found_end
);
6566 if (os
->bfd_section
!= NULL
)
6568 newdot
= os
->bfd_section
->vma
;
6570 /* .tbss sections effectively have zero size. */
6571 if (!IS_TBSS (os
->bfd_section
)
6572 || bfd_link_relocatable (&link_info
))
6573 newdot
+= TO_ADDR (os
->bfd_section
->size
);
6575 if (os
->update_dot_tree
!= NULL
)
6576 exp_fold_tree (os
->update_dot_tree
,
6577 bfd_abs_section_ptr
, &newdot
);
6584 case lang_wild_statement_enum
:
6586 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6587 current_os
, fill
, dot
, found_end
);
6590 case lang_object_symbols_statement_enum
:
6591 case lang_output_statement_enum
:
6592 case lang_target_statement_enum
:
6595 case lang_data_statement_enum
:
6596 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6597 if (expld
.result
.valid_p
)
6599 s
->data_statement
.value
= expld
.result
.value
;
6600 if (expld
.result
.section
!= NULL
)
6601 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6603 else if (expld
.phase
== lang_final_phase_enum
)
6604 einfo (_("%F%P: invalid data statement\n"));
6607 switch (s
->data_statement
.type
)
6625 if (size
< TO_SIZE ((unsigned) 1))
6626 size
= TO_SIZE ((unsigned) 1);
6627 dot
+= TO_ADDR (size
);
6631 case lang_reloc_statement_enum
:
6632 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6633 bfd_abs_section_ptr
, &dot
);
6634 if (expld
.result
.valid_p
)
6635 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6636 else if (expld
.phase
== lang_final_phase_enum
)
6637 einfo (_("%F%P: invalid reloc statement\n"));
6638 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6641 case lang_input_section_enum
:
6643 asection
*in
= s
->input_section
.section
;
6645 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6646 dot
+= TO_ADDR (in
->size
);
6650 case lang_input_statement_enum
:
6653 case lang_fill_statement_enum
:
6654 fill
= s
->fill_statement
.fill
;
6657 case lang_assignment_statement_enum
:
6658 current_assign
= &s
->assignment_statement
;
6659 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6661 const char *p
= current_assign
->exp
->assign
.dst
;
6663 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6664 prefer_next_section
= true;
6668 if (strcmp (p
, "end") == 0)
6671 exp_fold_tree (s
->assignment_statement
.exp
,
6672 (current_os
->bfd_section
!= NULL
6673 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6677 case lang_padding_statement_enum
:
6678 dot
+= TO_ADDR (s
->padding_statement
.size
);
6681 case lang_group_statement_enum
:
6682 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6683 current_os
, fill
, dot
, found_end
);
6686 case lang_insert_statement_enum
:
6689 case lang_address_statement_enum
:
6701 lang_do_assignments (lang_phase_type phase
)
6703 bool found_end
= false;
6705 current_section
= NULL
;
6706 prefer_next_section
= false;
6707 expld
.phase
= phase
;
6708 lang_statement_iteration
++;
6709 lang_do_assignments_1 (statement_list
.head
,
6710 abs_output_section
, NULL
, 0, &found_end
);
6713 /* For an assignment statement outside of an output section statement,
6714 choose the best of neighbouring output sections to use for values
6718 section_for_dot (void)
6722 /* Assignments belong to the previous output section, unless there
6723 has been an assignment to "dot", in which case following
6724 assignments belong to the next output section. (The assumption
6725 is that an assignment to "dot" is setting up the address for the
6726 next output section.) Except that past the assignment to "_end"
6727 we always associate with the previous section. This exception is
6728 for targets like SH that define an alloc .stack or other
6729 weirdness after non-alloc sections. */
6730 if (current_section
== NULL
|| prefer_next_section
)
6732 lang_statement_union_type
*stmt
;
6733 lang_output_section_statement_type
*os
;
6735 for (stmt
= (lang_statement_union_type
*) current_assign
;
6737 stmt
= stmt
->header
.next
)
6738 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6741 os
= stmt
? &stmt
->output_section_statement
: NULL
;
6744 && (os
->bfd_section
== NULL
6745 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6746 || bfd_section_removed_from_list (link_info
.output_bfd
,
6750 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6753 s
= os
->bfd_section
;
6755 s
= link_info
.output_bfd
->section_last
;
6757 && ((s
->flags
& SEC_ALLOC
) == 0
6758 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6763 return bfd_abs_section_ptr
;
6767 s
= current_section
->bfd_section
;
6769 /* The section may have been stripped. */
6771 && ((s
->flags
& SEC_EXCLUDE
) != 0
6772 || (s
->flags
& SEC_ALLOC
) == 0
6773 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6774 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6777 s
= link_info
.output_bfd
->sections
;
6779 && ((s
->flags
& SEC_ALLOC
) == 0
6780 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6785 return bfd_abs_section_ptr
;
6788 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6790 static struct bfd_link_hash_entry
**start_stop_syms
;
6791 static size_t start_stop_count
= 0;
6792 static size_t start_stop_alloc
= 0;
6794 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6795 to start_stop_syms. */
6798 lang_define_start_stop (const char *symbol
, asection
*sec
)
6800 struct bfd_link_hash_entry
*h
;
6802 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6805 if (start_stop_count
== start_stop_alloc
)
6807 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6809 = xrealloc (start_stop_syms
,
6810 start_stop_alloc
* sizeof (*start_stop_syms
));
6812 start_stop_syms
[start_stop_count
++] = h
;
6816 /* Check for input sections whose names match references to
6817 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6818 preliminary definitions. */
6821 lang_init_start_stop (void)
6825 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6827 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6828 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6831 const char *secname
= s
->name
;
6833 for (ps
= secname
; *ps
!= '\0'; ps
++)
6834 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6838 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6840 symbol
[0] = leading_char
;
6841 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6842 lang_define_start_stop (symbol
, s
);
6844 symbol
[1] = leading_char
;
6845 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6846 lang_define_start_stop (symbol
+ 1, s
);
6853 /* Iterate over start_stop_syms. */
6856 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6860 for (i
= 0; i
< start_stop_count
; ++i
)
6861 func (start_stop_syms
[i
]);
6864 /* __start and __stop symbols are only supposed to be defined by the
6865 linker for orphan sections, but we now extend that to sections that
6866 map to an output section of the same name. The symbols were
6867 defined early for --gc-sections, before we mapped input to output
6868 sections, so undo those that don't satisfy this rule. */
6871 undef_start_stop (struct bfd_link_hash_entry
*h
)
6873 if (h
->ldscript_def
)
6876 if (h
->u
.def
.section
->output_section
== NULL
6877 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6878 || strcmp (h
->u
.def
.section
->name
,
6879 h
->u
.def
.section
->output_section
->name
) != 0)
6881 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6882 h
->u
.def
.section
->name
);
6885 /* When there are more than one input sections with the same
6886 section name, SECNAME, linker picks the first one to define
6887 __start_SECNAME and __stop_SECNAME symbols. When the first
6888 input section is removed by comdat group, we need to check
6889 if there is still an output section with section name
6892 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6893 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6895 h
->u
.def
.section
= i
;
6899 h
->type
= bfd_link_hash_undefined
;
6900 h
->u
.undef
.abfd
= NULL
;
6901 if (is_elf_hash_table (link_info
.hash
))
6903 const struct elf_backend_data
*bed
;
6904 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6905 unsigned int was_forced
= eh
->forced_local
;
6907 bed
= get_elf_backend_data (link_info
.output_bfd
);
6908 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, true);
6909 if (!eh
->ref_regular_nonweak
)
6910 h
->type
= bfd_link_hash_undefweak
;
6911 eh
->def_regular
= 0;
6912 eh
->forced_local
= was_forced
;
6918 lang_undef_start_stop (void)
6920 foreach_start_stop (undef_start_stop
);
6923 /* Check for output sections whose names match references to
6924 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6925 preliminary definitions. */
6928 lang_init_startof_sizeof (void)
6932 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6934 const char *secname
= s
->name
;
6935 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6937 sprintf (symbol
, ".startof.%s", secname
);
6938 lang_define_start_stop (symbol
, s
);
6940 memcpy (symbol
+ 1, ".size", 5);
6941 lang_define_start_stop (symbol
+ 1, s
);
6946 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6949 set_start_stop (struct bfd_link_hash_entry
*h
)
6952 || h
->type
!= bfd_link_hash_defined
)
6955 if (h
->root
.string
[0] == '.')
6957 /* .startof. or .sizeof. symbol.
6958 .startof. already has final value. */
6959 if (h
->root
.string
[2] == 'i')
6962 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6963 h
->u
.def
.section
= bfd_abs_section_ptr
;
6968 /* __start or __stop symbol. */
6969 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6971 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6972 if (h
->root
.string
[4 + has_lead
] == 'o')
6975 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6981 lang_finalize_start_stop (void)
6983 foreach_start_stop (set_start_stop
);
6987 lang_symbol_tweaks (void)
6989 /* Give initial values for __start and __stop symbols, so that ELF
6990 gc_sections will keep sections referenced by these symbols. Must
6991 be done before lang_do_assignments. */
6992 if (config
.build_constructors
)
6993 lang_init_start_stop ();
6995 /* Make __ehdr_start hidden, and set def_regular even though it is
6996 likely undefined at this stage. For lang_check_relocs. */
6997 if (is_elf_hash_table (link_info
.hash
)
6998 && !bfd_link_relocatable (&link_info
))
7000 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
7001 bfd_link_hash_lookup (link_info
.hash
, "__ehdr_start",
7002 false, false, true);
7004 /* Only adjust the export class if the symbol was referenced
7005 and not defined, otherwise leave it alone. */
7007 && (h
->root
.type
== bfd_link_hash_new
7008 || h
->root
.type
== bfd_link_hash_undefined
7009 || h
->root
.type
== bfd_link_hash_undefweak
7010 || h
->root
.type
== bfd_link_hash_common
))
7012 const struct elf_backend_data
*bed
;
7013 bed
= get_elf_backend_data (link_info
.output_bfd
);
7014 (*bed
->elf_backend_hide_symbol
) (&link_info
, h
, true);
7015 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
7016 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
7018 h
->root
.linker_def
= 1;
7019 h
->root
.rel_from_abs
= 1;
7027 struct bfd_link_hash_entry
*h
;
7030 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
7031 || bfd_link_dll (&link_info
))
7032 warn
= entry_from_cmdline
;
7036 /* Force the user to specify a root when generating a relocatable with
7037 --gc-sections, unless --gc-keep-exported was also given. */
7038 if (bfd_link_relocatable (&link_info
)
7039 && link_info
.gc_sections
7040 && !link_info
.gc_keep_exported
)
7042 struct bfd_sym_chain
*sym
;
7044 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
7046 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
7047 false, false, false);
7049 && (h
->type
== bfd_link_hash_defined
7050 || h
->type
== bfd_link_hash_defweak
)
7051 && !bfd_is_const_section (h
->u
.def
.section
))
7055 einfo (_("%F%P: --gc-sections requires a defined symbol root "
7056 "specified by -e or -u\n"));
7059 if (entry_symbol
.name
== NULL
)
7061 /* No entry has been specified. Look for the default entry, but
7062 don't warn if we don't find it. */
7063 entry_symbol
.name
= entry_symbol_default
;
7067 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
7068 false, false, true);
7070 && (h
->type
== bfd_link_hash_defined
7071 || h
->type
== bfd_link_hash_defweak
)
7072 && h
->u
.def
.section
->output_section
!= NULL
)
7076 val
= (h
->u
.def
.value
7077 + bfd_section_vma (h
->u
.def
.section
->output_section
)
7078 + h
->u
.def
.section
->output_offset
);
7079 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7080 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
7087 /* We couldn't find the entry symbol. Try parsing it as a
7089 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
7092 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7093 einfo (_("%F%P: can't set start address\n"));
7095 /* BZ 2004952: Only use the start of the entry section for executables. */
7096 else if bfd_link_executable (&link_info
)
7100 /* Can't find the entry symbol, and it's not a number. Use
7101 the first address in the text section. */
7102 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
7106 einfo (_("%P: warning: cannot find entry symbol %s;"
7107 " defaulting to %V\n"),
7109 bfd_section_vma (ts
));
7110 if (!bfd_set_start_address (link_info
.output_bfd
,
7111 bfd_section_vma (ts
)))
7112 einfo (_("%F%P: can't set start address\n"));
7117 einfo (_("%P: warning: cannot find entry symbol %s;"
7118 " not setting start address\n"),
7125 einfo (_("%P: warning: cannot find entry symbol %s;"
7126 " not setting start address\n"),
7132 /* This is a small function used when we want to ignore errors from
7136 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7137 va_list ap ATTRIBUTE_UNUSED
)
7139 /* Don't do anything. */
7142 /* Check that the architecture of all the input files is compatible
7143 with the output file. Also call the backend to let it do any
7144 other checking that is needed. */
7149 lang_input_statement_type
*file
;
7151 const bfd_arch_info_type
*compatible
;
7153 for (file
= (void *) file_chain
.head
;
7157 #if BFD_SUPPORTS_PLUGINS
7158 /* Don't check format of files claimed by plugin. */
7159 if (file
->flags
.claimed
)
7161 #endif /* BFD_SUPPORTS_PLUGINS */
7162 input_bfd
= file
->the_bfd
;
7164 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7165 command_line
.accept_unknown_input_arch
);
7167 /* In general it is not possible to perform a relocatable
7168 link between differing object formats when the input
7169 file has relocations, because the relocations in the
7170 input format may not have equivalent representations in
7171 the output format (and besides BFD does not translate
7172 relocs for other link purposes than a final link). */
7173 if (!file
->flags
.just_syms
7174 && (bfd_link_relocatable (&link_info
)
7175 || link_info
.emitrelocations
)
7176 && (compatible
== NULL
7177 || (bfd_get_flavour (input_bfd
)
7178 != bfd_get_flavour (link_info
.output_bfd
)))
7179 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7181 einfo (_("%F%P: relocatable linking with relocations from"
7182 " format %s (%pB) to format %s (%pB) is not supported\n"),
7183 bfd_get_target (input_bfd
), input_bfd
,
7184 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7185 /* einfo with %F exits. */
7188 if (compatible
== NULL
)
7190 if (command_line
.warn_mismatch
)
7191 einfo (_("%X%P: %s architecture of input file `%pB'"
7192 " is incompatible with %s output\n"),
7193 bfd_printable_name (input_bfd
), input_bfd
,
7194 bfd_printable_name (link_info
.output_bfd
));
7197 /* If the input bfd has no contents, it shouldn't set the
7198 private data of the output bfd. */
7199 else if (!file
->flags
.just_syms
7200 && ((input_bfd
->flags
& DYNAMIC
) != 0
7201 || bfd_count_sections (input_bfd
) != 0))
7203 bfd_error_handler_type pfn
= NULL
;
7205 /* If we aren't supposed to warn about mismatched input
7206 files, temporarily set the BFD error handler to a
7207 function which will do nothing. We still want to call
7208 bfd_merge_private_bfd_data, since it may set up
7209 information which is needed in the output file. */
7210 if (!command_line
.warn_mismatch
)
7211 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7212 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7214 if (command_line
.warn_mismatch
)
7215 einfo (_("%X%P: failed to merge target specific data"
7216 " of file %pB\n"), input_bfd
);
7218 if (!command_line
.warn_mismatch
)
7219 bfd_set_error_handler (pfn
);
7224 /* Look through all the global common symbols and attach them to the
7225 correct section. The -sort-common command line switch may be used
7226 to roughly sort the entries by alignment. */
7231 if (link_info
.inhibit_common_definition
)
7233 if (bfd_link_relocatable (&link_info
)
7234 && !command_line
.force_common_definition
)
7237 if (!config
.sort_common
)
7238 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7243 if (config
.sort_common
== sort_descending
)
7245 for (power
= 4; power
> 0; power
--)
7246 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7249 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7253 for (power
= 0; power
<= 4; power
++)
7254 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7256 power
= (unsigned int) -1;
7257 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7262 /* Place one common symbol in the correct section. */
7265 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7267 unsigned int power_of_two
;
7271 if (h
->type
!= bfd_link_hash_common
)
7275 power_of_two
= h
->u
.c
.p
->alignment_power
;
7277 if (config
.sort_common
== sort_descending
7278 && power_of_two
< *(unsigned int *) info
)
7280 else if (config
.sort_common
== sort_ascending
7281 && power_of_two
> *(unsigned int *) info
)
7284 section
= h
->u
.c
.p
->section
;
7285 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7286 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7289 if (config
.map_file
!= NULL
)
7291 static bool header_printed
;
7296 if (!header_printed
)
7298 minfo (_("\nAllocating common symbols\n"));
7299 minfo (_("Common symbol size file\n\n"));
7300 header_printed
= true;
7303 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7304 DMGL_ANSI
| DMGL_PARAMS
);
7307 minfo ("%s", h
->root
.string
);
7308 len
= strlen (h
->root
.string
);
7313 len
= strlen (name
);
7323 sprintf (buf
, "%" PRIx64
, (uint64_t) size
);
7324 fprintf (config
.map_file
, "%*s0x%-16s", 20 - len
, "", buf
);
7326 minfo ("%pB\n", section
->owner
);
7332 /* Handle a single orphan section S, placing the orphan into an appropriate
7333 output section. The effects of the --orphan-handling command line
7334 option are handled here. */
7337 ldlang_place_orphan (asection
*s
)
7339 if (config
.orphan_handling
== orphan_handling_discard
)
7341 lang_output_section_statement_type
*os
;
7342 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7343 if (os
->addr_tree
== NULL
7344 && (bfd_link_relocatable (&link_info
)
7345 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7346 os
->addr_tree
= exp_intop (0);
7347 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7351 lang_output_section_statement_type
*os
;
7352 const char *name
= s
->name
;
7355 if (config
.orphan_handling
== orphan_handling_error
)
7356 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7359 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7360 constraint
= SPECIAL
;
7362 os
= ldemul_place_orphan (s
, name
, constraint
);
7365 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7366 if (os
->addr_tree
== NULL
7367 && (bfd_link_relocatable (&link_info
)
7368 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7369 os
->addr_tree
= exp_intop (0);
7370 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7373 if (config
.orphan_handling
== orphan_handling_warn
)
7374 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7375 "placed in section `%s'\n"),
7376 s
, s
->owner
, os
->name
);
7380 /* Run through the input files and ensure that every input section has
7381 somewhere to go. If one is found without a destination then create
7382 an input request and place it into the statement tree. */
7385 lang_place_orphans (void)
7387 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7391 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7393 if (s
->output_section
== NULL
)
7395 /* This section of the file is not attached, root
7396 around for a sensible place for it to go. */
7398 if (file
->flags
.just_syms
)
7399 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7400 else if (lang_discard_section_p (s
))
7401 s
->output_section
= bfd_abs_section_ptr
;
7402 else if (strcmp (s
->name
, "COMMON") == 0)
7404 /* This is a lonely common section which must have
7405 come from an archive. We attach to the section
7406 with the wildcard. */
7407 if (!bfd_link_relocatable (&link_info
)
7408 || command_line
.force_common_definition
)
7410 if (default_common_section
== NULL
)
7411 default_common_section
7412 = lang_output_section_statement_lookup (".bss", 0, 1);
7413 lang_add_section (&default_common_section
->children
, s
,
7414 NULL
, NULL
, default_common_section
);
7418 ldlang_place_orphan (s
);
7425 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7427 flagword
*ptr_flags
;
7429 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7435 /* PR 17900: An exclamation mark in the attributes reverses
7436 the sense of any of the attributes that follow. */
7439 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7443 *ptr_flags
|= SEC_ALLOC
;
7447 *ptr_flags
|= SEC_READONLY
;
7451 *ptr_flags
|= SEC_DATA
;
7455 *ptr_flags
|= SEC_CODE
;
7460 *ptr_flags
|= SEC_LOAD
;
7464 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7472 /* Call a function on each real input file. This function will be
7473 called on an archive, but not on the elements. */
7476 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7478 lang_input_statement_type
*f
;
7480 for (f
= (void *) input_file_chain
.head
;
7482 f
= f
->next_real_file
)
7487 /* Call a function on each real file. The function will be called on
7488 all the elements of an archive which are included in the link, but
7489 will not be called on the archive file itself. */
7492 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7494 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7502 ldlang_add_file (lang_input_statement_type
*entry
)
7504 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7506 /* The BFD linker needs to have a list of all input BFDs involved in
7508 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7509 && entry
->the_bfd
->link
.next
== NULL
);
7510 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7512 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7513 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7514 bfd_set_usrdata (entry
->the_bfd
, entry
);
7515 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7517 /* Look through the sections and check for any which should not be
7518 included in the link. We need to do this now, so that we can
7519 notice when the backend linker tries to report multiple
7520 definition errors for symbols which are in sections we aren't
7521 going to link. FIXME: It might be better to entirely ignore
7522 symbols which are defined in sections which are going to be
7523 discarded. This would require modifying the backend linker for
7524 each backend which might set the SEC_LINK_ONCE flag. If we do
7525 this, we should probably handle SEC_EXCLUDE in the same way. */
7527 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7531 lang_add_output (const char *name
, int from_script
)
7533 /* Make -o on command line override OUTPUT in script. */
7534 if (!had_output_filename
|| !from_script
)
7536 output_filename
= name
;
7537 had_output_filename
= true;
7541 lang_output_section_statement_type
*
7542 lang_enter_output_section_statement (const char *output_section_statement_name
,
7543 etree_type
*address_exp
,
7544 enum section_type sectype
,
7545 etree_type
*sectype_value
,
7547 etree_type
*subalign
,
7550 int align_with_input
)
7552 lang_output_section_statement_type
*os
;
7554 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7556 current_section
= os
;
7558 if (os
->addr_tree
== NULL
)
7560 os
->addr_tree
= address_exp
;
7562 os
->sectype
= sectype
;
7563 if (sectype
== type_section
|| sectype
== typed_readonly_section
)
7564 os
->sectype_value
= sectype_value
;
7565 else if (sectype
== noload_section
)
7566 os
->flags
= SEC_NEVER_LOAD
;
7568 os
->flags
= SEC_NO_FLAGS
;
7569 os
->block_value
= 1;
7571 /* Make next things chain into subchain of this. */
7572 push_stat_ptr (&os
->children
);
7574 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7575 if (os
->align_lma_with_input
&& align
!= NULL
)
7576 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7579 os
->subsection_alignment
= subalign
;
7580 os
->section_alignment
= align
;
7582 os
->load_base
= ebase
;
7589 lang_output_statement_type
*new_stmt
;
7591 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7592 new_stmt
->name
= output_filename
;
7595 /* Reset the current counters in the regions. */
7598 lang_reset_memory_regions (void)
7600 lang_memory_region_type
*p
= lang_memory_region_list
;
7602 lang_output_section_statement_type
*os
;
7604 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7606 p
->current
= p
->origin
;
7610 for (os
= (void *) lang_os_list
.head
;
7614 os
->processed_vma
= false;
7615 os
->processed_lma
= false;
7618 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7620 /* Save the last size for possible use by bfd_relax_section. */
7621 o
->rawsize
= o
->size
;
7622 if (!(o
->flags
& SEC_FIXED_SIZE
))
7627 /* Worker for lang_gc_sections_1. */
7630 gc_section_callback (lang_wild_statement_type
*ptr
,
7631 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7633 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7634 void *data ATTRIBUTE_UNUSED
)
7636 /* If the wild pattern was marked KEEP, the member sections
7637 should be as well. */
7638 if (ptr
->keep_sections
)
7639 section
->flags
|= SEC_KEEP
;
7642 /* Iterate over sections marking them against GC. */
7645 lang_gc_sections_1 (lang_statement_union_type
*s
)
7647 for (; s
!= NULL
; s
= s
->header
.next
)
7649 switch (s
->header
.type
)
7651 case lang_wild_statement_enum
:
7652 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7654 case lang_constructors_statement_enum
:
7655 lang_gc_sections_1 (constructor_list
.head
);
7657 case lang_output_section_statement_enum
:
7658 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7660 case lang_group_statement_enum
:
7661 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7670 lang_gc_sections (void)
7672 /* Keep all sections so marked in the link script. */
7673 lang_gc_sections_1 (statement_list
.head
);
7675 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7676 the special case of .stabstr debug info. (See bfd/stabs.c)
7677 Twiddle the flag here, to simplify later linker code. */
7678 if (bfd_link_relocatable (&link_info
))
7680 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7683 #if BFD_SUPPORTS_PLUGINS
7684 if (f
->flags
.claimed
)
7687 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7688 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7689 || strcmp (sec
->name
, ".stabstr") != 0)
7690 sec
->flags
&= ~SEC_EXCLUDE
;
7694 if (link_info
.gc_sections
)
7695 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7698 /* Worker for lang_find_relro_sections_1. */
7701 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7702 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7704 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7707 /* Discarded, excluded and ignored sections effectively have zero
7709 if (section
->output_section
!= NULL
7710 && section
->output_section
->owner
== link_info
.output_bfd
7711 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7712 && !IGNORE_SECTION (section
)
7713 && section
->size
!= 0)
7715 bool *has_relro_section
= (bool *) data
;
7716 *has_relro_section
= true;
7720 /* Iterate over sections for relro sections. */
7723 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7724 bool *has_relro_section
)
7726 if (*has_relro_section
)
7729 for (; s
!= NULL
; s
= s
->header
.next
)
7731 if (s
== expld
.dataseg
.relro_end_stat
)
7734 switch (s
->header
.type
)
7736 case lang_wild_statement_enum
:
7737 walk_wild (&s
->wild_statement
,
7738 find_relro_section_callback
,
7741 case lang_constructors_statement_enum
:
7742 lang_find_relro_sections_1 (constructor_list
.head
,
7745 case lang_output_section_statement_enum
:
7746 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7749 case lang_group_statement_enum
:
7750 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7760 lang_find_relro_sections (void)
7762 bool has_relro_section
= false;
7764 /* Check all sections in the link script. */
7766 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7767 &has_relro_section
);
7769 if (!has_relro_section
)
7770 link_info
.relro
= false;
7773 /* Relax all sections until bfd_relax_section gives up. */
7776 lang_relax_sections (bool need_layout
)
7778 /* NB: Also enable relaxation to layout sections for DT_RELR. */
7779 if (RELAXATION_ENABLED
|| link_info
.enable_dt_relr
)
7781 /* We may need more than one relaxation pass. */
7782 int i
= link_info
.relax_pass
;
7784 /* The backend can use it to determine the current pass. */
7785 link_info
.relax_pass
= 0;
7789 /* Keep relaxing until bfd_relax_section gives up. */
7792 link_info
.relax_trip
= -1;
7795 link_info
.relax_trip
++;
7797 /* Note: pe-dll.c does something like this also. If you find
7798 you need to change this code, you probably need to change
7799 pe-dll.c also. DJ */
7801 /* Do all the assignments with our current guesses as to
7803 lang_do_assignments (lang_assigning_phase_enum
);
7805 /* We must do this after lang_do_assignments, because it uses
7807 lang_reset_memory_regions ();
7809 /* Perform another relax pass - this time we know where the
7810 globals are, so can make a better guess. */
7811 relax_again
= false;
7812 lang_size_sections (&relax_again
, false);
7814 while (relax_again
);
7816 link_info
.relax_pass
++;
7823 /* Final extra sizing to report errors. */
7824 lang_do_assignments (lang_assigning_phase_enum
);
7825 lang_reset_memory_regions ();
7826 lang_size_sections (NULL
, true);
7830 #if BFD_SUPPORTS_PLUGINS
7831 /* Find the insert point for the plugin's replacement files. We
7832 place them after the first claimed real object file, or if the
7833 first claimed object is an archive member, after the last real
7834 object file immediately preceding the archive. In the event
7835 no objects have been claimed at all, we return the first dummy
7836 object file on the list as the insert point; that works, but
7837 the callee must be careful when relinking the file_chain as it
7838 is not actually on that chain, only the statement_list and the
7839 input_file list; in that case, the replacement files must be
7840 inserted at the head of the file_chain. */
7842 static lang_input_statement_type
*
7843 find_replacements_insert_point (bool *before
)
7845 lang_input_statement_type
*claim1
, *lastobject
;
7846 lastobject
= (void *) input_file_chain
.head
;
7847 for (claim1
= (void *) file_chain
.head
;
7849 claim1
= claim1
->next
)
7851 if (claim1
->flags
.claimed
)
7853 *before
= claim1
->flags
.claim_archive
;
7854 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7856 /* Update lastobject if this is a real object file. */
7857 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7858 lastobject
= claim1
;
7860 /* No files were claimed by the plugin. Choose the last object
7861 file found on the list (maybe the first, dummy entry) as the
7867 /* Find where to insert ADD, an archive element or shared library
7868 added during a rescan. */
7870 static lang_input_statement_type
**
7871 find_rescan_insertion (lang_input_statement_type
*add
)
7873 bfd
*add_bfd
= add
->the_bfd
;
7874 lang_input_statement_type
*f
;
7875 lang_input_statement_type
*last_loaded
= NULL
;
7876 lang_input_statement_type
*before
= NULL
;
7877 lang_input_statement_type
**iter
= NULL
;
7879 if (add_bfd
->my_archive
!= NULL
)
7880 add_bfd
= add_bfd
->my_archive
;
7882 /* First look through the input file chain, to find an object file
7883 before the one we've rescanned. Normal object files always
7884 appear on both the input file chain and the file chain, so this
7885 lets us get quickly to somewhere near the correct place on the
7886 file chain if it is full of archive elements. Archives don't
7887 appear on the file chain, but if an element has been extracted
7888 then their input_statement->next points at it. */
7889 for (f
= (void *) input_file_chain
.head
;
7891 f
= f
->next_real_file
)
7893 if (f
->the_bfd
== add_bfd
)
7895 before
= last_loaded
;
7896 if (f
->next
!= NULL
)
7897 return &f
->next
->next
;
7899 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7903 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7905 iter
= &(*iter
)->next
)
7906 if (!(*iter
)->flags
.claim_archive
7907 && (*iter
)->the_bfd
->my_archive
== NULL
)
7913 /* Insert SRCLIST into DESTLIST after given element by chaining
7914 on FIELD as the next-pointer. (Counterintuitively does not need
7915 a pointer to the actual after-node itself, just its chain field.) */
7918 lang_list_insert_after (lang_statement_list_type
*destlist
,
7919 lang_statement_list_type
*srclist
,
7920 lang_statement_union_type
**field
)
7922 *(srclist
->tail
) = *field
;
7923 *field
= srclist
->head
;
7924 if (destlist
->tail
== field
)
7925 destlist
->tail
= srclist
->tail
;
7928 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7929 was taken as a copy of it and leave them in ORIGLIST. */
7932 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7933 lang_statement_list_type
*origlist
)
7935 union lang_statement_union
**savetail
;
7936 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7937 ASSERT (origlist
->head
== destlist
->head
);
7938 savetail
= origlist
->tail
;
7939 origlist
->head
= *(savetail
);
7940 origlist
->tail
= destlist
->tail
;
7941 destlist
->tail
= savetail
;
7945 static lang_statement_union_type
**
7946 find_next_input_statement (lang_statement_union_type
**s
)
7948 for ( ; *s
; s
= &(*s
)->header
.next
)
7950 lang_statement_union_type
**t
;
7951 switch ((*s
)->header
.type
)
7953 case lang_input_statement_enum
:
7955 case lang_wild_statement_enum
:
7956 t
= &(*s
)->wild_statement
.children
.head
;
7958 case lang_group_statement_enum
:
7959 t
= &(*s
)->group_statement
.children
.head
;
7961 case lang_output_section_statement_enum
:
7962 t
= &(*s
)->output_section_statement
.children
.head
;
7967 t
= find_next_input_statement (t
);
7973 #endif /* BFD_SUPPORTS_PLUGINS */
7975 /* Add NAME to the list of garbage collection entry points. */
7978 lang_add_gc_name (const char *name
)
7980 struct bfd_sym_chain
*sym
;
7985 sym
= stat_alloc (sizeof (*sym
));
7987 sym
->next
= link_info
.gc_sym_list
;
7989 link_info
.gc_sym_list
= sym
;
7992 /* Check relocations. */
7995 lang_check_relocs (void)
7997 if (link_info
.check_relocs_after_open_input
)
8001 for (abfd
= link_info
.input_bfds
;
8002 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
8003 if (!bfd_link_check_relocs (abfd
, &link_info
))
8005 /* No object output, fail return. */
8006 config
.make_executable
= false;
8007 /* Note: we do not abort the loop, but rather
8008 continue the scan in case there are other
8009 bad relocations to report. */
8014 /* Look through all output sections looking for places where we can
8015 propagate forward the lma region. */
8018 lang_propagate_lma_regions (void)
8020 lang_output_section_statement_type
*os
;
8022 for (os
= (void *) lang_os_list
.head
;
8026 if (os
->prev
!= NULL
8027 && os
->lma_region
== NULL
8028 && os
->load_base
== NULL
8029 && os
->addr_tree
== NULL
8030 && os
->region
== os
->prev
->region
)
8031 os
->lma_region
= os
->prev
->lma_region
;
8036 warn_non_contiguous_discards (void)
8038 LANG_FOR_EACH_INPUT_STATEMENT (file
)
8040 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
8041 || file
->flags
.just_syms
)
8044 for (asection
*s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8045 if (s
->output_section
== NULL
8046 && (s
->flags
& SEC_LINKER_CREATED
) == 0)
8047 einfo (_("%P: warning: --enable-non-contiguous-regions "
8048 "discards section `%pA' from `%pB'\n"),
8054 reset_one_wild (lang_statement_union_type
*statement
)
8056 if (statement
->header
.type
== lang_wild_statement_enum
)
8058 lang_wild_statement_type
*stmt
= &statement
->wild_statement
;
8059 lang_list_init (&stmt
->matching_sections
);
8064 reset_resolved_wilds (void)
8066 lang_for_each_statement (reset_one_wild
);
8072 /* Finalize dynamic list. */
8073 if (link_info
.dynamic_list
)
8074 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
8076 current_target
= default_target
;
8078 /* Open the output file. */
8079 lang_for_each_statement (ldlang_open_output
);
8082 ldemul_create_output_section_statements ();
8084 /* Add to the hash table all undefineds on the command line. */
8085 lang_place_undefineds ();
8087 if (!bfd_section_already_linked_table_init ())
8088 einfo (_("%F%P: can not create hash table: %E\n"));
8090 /* A first pass through the memory regions ensures that if any region
8091 references a symbol for its origin or length then this symbol will be
8092 added to the symbol table. Having these symbols in the symbol table
8093 means that when we call open_input_bfds PROVIDE statements will
8094 trigger to provide any needed symbols. The regions origins and
8095 lengths are not assigned as a result of this call. */
8096 lang_do_memory_regions (false);
8098 /* Create a bfd for each input file. */
8099 current_target
= default_target
;
8100 lang_statement_iteration
++;
8101 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
8103 /* Now that open_input_bfds has processed assignments and provide
8104 statements we can give values to symbolic origin/length now. */
8105 lang_do_memory_regions (true);
8107 ldemul_before_plugin_all_symbols_read ();
8109 #if BFD_SUPPORTS_PLUGINS
8110 if (link_info
.lto_plugin_active
)
8112 lang_statement_list_type added
;
8113 lang_statement_list_type files
, inputfiles
;
8115 /* Now all files are read, let the plugin(s) decide if there
8116 are any more to be added to the link before we call the
8117 emulation's after_open hook. We create a private list of
8118 input statements for this purpose, which we will eventually
8119 insert into the global statement list after the first claimed
8122 /* We need to manipulate all three chains in synchrony. */
8124 inputfiles
= input_file_chain
;
8125 if (plugin_call_all_symbols_read ())
8126 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
8127 plugin_error_plugin ());
8128 link_info
.lto_all_symbols_read
= true;
8129 /* Open any newly added files, updating the file chains. */
8130 plugin_undefs
= link_info
.hash
->undefs_tail
;
8131 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
8132 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
8133 plugin_undefs
= NULL
;
8134 /* Restore the global list pointer now they have all been added. */
8135 lang_list_remove_tail (stat_ptr
, &added
);
8136 /* And detach the fresh ends of the file lists. */
8137 lang_list_remove_tail (&file_chain
, &files
);
8138 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
8139 /* Were any new files added? */
8140 if (added
.head
!= NULL
)
8142 /* If so, we will insert them into the statement list immediately
8143 after the first input file that was claimed by the plugin,
8144 unless that file was an archive in which case it is inserted
8145 immediately before. */
8147 lang_statement_union_type
**prev
;
8148 plugin_insert
= find_replacements_insert_point (&before
);
8149 /* If a plugin adds input files without having claimed any, we
8150 don't really have a good idea where to place them. Just putting
8151 them at the start or end of the list is liable to leave them
8152 outside the crtbegin...crtend range. */
8153 ASSERT (plugin_insert
!= NULL
);
8154 /* Splice the new statement list into the old one. */
8155 prev
= &plugin_insert
->header
.next
;
8158 prev
= find_next_input_statement (prev
);
8159 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8161 /* We didn't find the expected input statement.
8162 Fall back to adding after plugin_insert. */
8163 prev
= &plugin_insert
->header
.next
;
8166 lang_list_insert_after (stat_ptr
, &added
, prev
);
8167 /* Likewise for the file chains. */
8168 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8169 (void *) &plugin_insert
->next_real_file
);
8170 /* We must be careful when relinking file_chain; we may need to
8171 insert the new files at the head of the list if the insert
8172 point chosen is the dummy first input file. */
8173 if (plugin_insert
->filename
)
8174 lang_list_insert_after (&file_chain
, &files
,
8175 (void *) &plugin_insert
->next
);
8177 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8179 /* Rescan archives in case new undefined symbols have appeared. */
8181 lang_statement_iteration
++;
8182 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8183 lang_list_remove_tail (&file_chain
, &files
);
8184 while (files
.head
!= NULL
)
8186 lang_input_statement_type
**insert
;
8187 lang_input_statement_type
**iter
, *temp
;
8190 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8191 /* All elements from an archive can be added at once. */
8192 iter
= &files
.head
->input_statement
.next
;
8193 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8194 if (my_arch
!= NULL
)
8195 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8196 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8199 *insert
= &files
.head
->input_statement
;
8200 files
.head
= (lang_statement_union_type
*) *iter
;
8202 if (file_chain
.tail
== (lang_statement_union_type
**) insert
)
8203 file_chain
.tail
= (lang_statement_union_type
**) iter
;
8204 if (my_arch
!= NULL
)
8206 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8208 parent
->next
= (lang_input_statement_type
*)
8210 - offsetof (lang_input_statement_type
, next
));
8215 #endif /* BFD_SUPPORTS_PLUGINS */
8217 struct bfd_sym_chain
**sym
= &link_info
.gc_sym_list
;
8219 sym
= &(*sym
)->next
;
8221 *sym
= &entry_symbol
;
8223 if (entry_symbol
.name
== NULL
)
8225 *sym
= ldlang_undef_chain_list_head
;
8227 /* entry_symbol is normally initialised by an ENTRY definition in the
8228 linker script or the -e command line option. But if neither of
8229 these have been used, the target specific backend may still have
8230 provided an entry symbol via a call to lang_default_entry().
8231 Unfortunately this value will not be processed until lang_end()
8232 is called, long after this function has finished. So detect this
8233 case here and add the target's entry symbol to the list of starting
8234 points for garbage collection resolution. */
8235 lang_add_gc_name (entry_symbol_default
);
8238 lang_add_gc_name (link_info
.init_function
);
8239 lang_add_gc_name (link_info
.fini_function
);
8241 ldemul_after_open ();
8242 if (config
.map_file
!= NULL
)
8243 lang_print_asneeded ();
8247 bfd_section_already_linked_table_free ();
8249 /* Make sure that we're not mixing architectures. We call this
8250 after all the input files have been opened, but before we do any
8251 other processing, so that any operations merge_private_bfd_data
8252 does on the output file will be known during the rest of the
8256 /* Handle .exports instead of a version script if we're told to do so. */
8257 if (command_line
.version_exports_section
)
8258 lang_do_version_exports_section ();
8260 /* Build all sets based on the information gathered from the input
8262 ldctor_build_sets ();
8264 lang_symbol_tweaks ();
8266 /* PR 13683: We must rerun the assignments prior to running garbage
8267 collection in order to make sure that all symbol aliases are resolved. */
8268 lang_do_assignments (lang_mark_phase_enum
);
8269 expld
.phase
= lang_first_phase_enum
;
8271 /* Size up the common data. */
8275 debug_prefix_tree ();
8279 /* Remove unreferenced sections if asked to. */
8280 lang_gc_sections ();
8282 lang_mark_undefineds ();
8284 /* Check relocations. */
8285 lang_check_relocs ();
8287 ldemul_after_check_relocs ();
8289 /* There might have been new sections created (e.g. as result of
8290 checking relocs to need a .got, or suchlike), so to properly order
8291 them into our lists of matching sections reset them here. */
8292 reset_resolved_wilds ();
8295 /* Update wild statements in case the user gave --sort-section.
8296 Note how the option might have come after the linker script and
8297 so couldn't have been set when the wild statements were created. */
8298 update_wild_statements (statement_list
.head
);
8300 /* Run through the contours of the script and attach input sections
8301 to the correct output sections. */
8302 lang_statement_iteration
++;
8303 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8305 /* Start at the statement immediately after the special abs_section
8306 output statement, so that it isn't reordered. */
8307 process_insert_statements (&lang_os_list
.head
->header
.next
);
8309 ldemul_before_place_orphans ();
8311 /* Find any sections not attached explicitly and handle them. */
8312 lang_place_orphans ();
8314 if (!bfd_link_relocatable (&link_info
))
8318 /* Merge SEC_MERGE sections. This has to be done after GC of
8319 sections, so that GCed sections are not merged, but before
8320 assigning dynamic symbols, since removing whole input sections
8322 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8324 /* Look for a text section and set the readonly attribute in it. */
8325 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8329 if (config
.text_read_only
)
8330 found
->flags
|= SEC_READONLY
;
8332 found
->flags
&= ~SEC_READONLY
;
8336 /* Merge together CTF sections. After this, only the symtab-dependent
8337 function and data object sections need adjustment. */
8340 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8341 examining things laid out late, like the strtab. */
8344 /* Copy forward lma regions for output sections in same lma region. */
8345 lang_propagate_lma_regions ();
8347 /* Defining __start/__stop symbols early for --gc-sections to work
8348 around a glibc build problem can result in these symbols being
8349 defined when they should not be. Fix them now. */
8350 if (config
.build_constructors
)
8351 lang_undef_start_stop ();
8353 /* Define .startof./.sizeof. symbols with preliminary values before
8354 dynamic symbols are created. */
8355 if (!bfd_link_relocatable (&link_info
))
8356 lang_init_startof_sizeof ();
8358 /* Do anything special before sizing sections. This is where ELF
8359 and other back-ends size dynamic sections. */
8360 ldemul_before_allocation ();
8362 /* We must record the program headers before we try to fix the
8363 section positions, since they will affect SIZEOF_HEADERS. */
8364 lang_record_phdrs ();
8366 /* Check relro sections. */
8367 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8368 lang_find_relro_sections ();
8370 /* Size up the sections. */
8371 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8373 /* See if anything special should be done now we know how big
8374 everything is. This is where relaxation is done. */
8375 ldemul_after_allocation ();
8377 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8378 lang_finalize_start_stop ();
8380 /* Do all the assignments again, to report errors. Assignment
8381 statements are processed multiple times, updating symbols; In
8382 open_input_bfds, lang_do_assignments, and lang_size_sections.
8383 Since lang_relax_sections calls lang_do_assignments, symbols are
8384 also updated in ldemul_after_allocation. */
8385 lang_do_assignments (lang_final_phase_enum
);
8389 /* Convert absolute symbols to section relative. */
8390 ldexp_finalize_syms ();
8392 /* Make sure that the section addresses make sense. */
8393 if (command_line
.check_section_addresses
)
8394 lang_check_section_addresses ();
8396 if (link_info
.non_contiguous_regions
8397 && link_info
.non_contiguous_regions_warnings
)
8398 warn_non_contiguous_discards ();
8400 /* Check any required symbols are known. */
8401 ldlang_check_require_defined_symbols ();
8407 lang_add_version_string (void)
8409 if (! enable_linker_version
)
8412 const char * str
= "GNU ld ";
8413 int len
= strlen (str
);
8416 for (i
= 0 ; i
< len
; i
++)
8417 lang_add_data (BYTE
, exp_intop (str
[i
]));
8419 str
= BFD_VERSION_STRING
;
8422 for (i
= 0 ; i
< len
; i
++)
8423 lang_add_data (BYTE
, exp_intop (str
[i
]));
8425 lang_add_data (BYTE
, exp_intop ('\0'));
8428 /* EXPORTED TO YACC */
8431 lang_add_wild (struct wildcard_spec
*filespec
,
8432 struct wildcard_list
*section_list
,
8435 struct wildcard_list
*curr
, *next
;
8436 lang_wild_statement_type
*new_stmt
;
8437 bool any_specs_sorted
= false;
8439 /* Reverse the list as the parser puts it back to front. */
8440 for (curr
= section_list
, section_list
= NULL
;
8442 section_list
= curr
, curr
= next
)
8444 if (curr
->spec
.sorted
!= none
&& curr
->spec
.sorted
!= by_none
)
8445 any_specs_sorted
= true;
8447 curr
->next
= section_list
;
8450 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8452 if (strcmp (filespec
->name
, "*") == 0)
8453 filespec
->name
= NULL
;
8454 else if (!wildcardp (filespec
->name
))
8455 lang_has_input_file
= true;
8458 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8459 new_stmt
->filename
= NULL
;
8460 new_stmt
->filenames_sorted
= false;
8461 new_stmt
->any_specs_sorted
= any_specs_sorted
;
8462 new_stmt
->section_flag_list
= NULL
;
8463 new_stmt
->exclude_name_list
= NULL
;
8464 if (filespec
!= NULL
)
8466 new_stmt
->filename
= filespec
->name
;
8467 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8468 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8469 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8471 new_stmt
->section_list
= section_list
;
8472 new_stmt
->keep_sections
= keep_sections
;
8473 lang_list_init (&new_stmt
->children
);
8474 lang_list_init (&new_stmt
->matching_sections
);
8475 analyze_walk_wild_section_handler (new_stmt
);
8478 printf ("wild %s(", new_stmt
->filename
? new_stmt
->filename
: "*");
8479 for (curr
= new_stmt
->section_list
; curr
; curr
= curr
->next
)
8480 printf ("%s ", curr
->spec
.name
? curr
->spec
.name
: "*");
8486 lang_section_start (const char *name
, etree_type
*address
,
8487 const segment_type
*segment
)
8489 lang_address_statement_type
*ad
;
8491 ad
= new_stat (lang_address_statement
, stat_ptr
);
8492 ad
->section_name
= name
;
8493 ad
->address
= address
;
8494 ad
->segment
= segment
;
8497 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8498 because of a -e argument on the command line, or zero if this is
8499 called by ENTRY in a linker script. Command line arguments take
8503 lang_add_entry (const char *name
, bool cmdline
)
8505 if (entry_symbol
.name
== NULL
8507 || !entry_from_cmdline
)
8509 entry_symbol
.name
= name
;
8510 entry_from_cmdline
= cmdline
;
8514 /* Set the default start symbol to NAME. .em files should use this,
8515 not lang_add_entry, to override the use of "start" if neither the
8516 linker script nor the command line specifies an entry point. NAME
8517 must be permanently allocated. */
8519 lang_default_entry (const char *name
)
8521 entry_symbol_default
= name
;
8525 lang_add_target (const char *name
)
8527 lang_target_statement_type
*new_stmt
;
8529 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8530 new_stmt
->target
= name
;
8534 lang_add_map (const char *name
)
8541 map_option_f
= true;
8549 lang_add_fill (fill_type
*fill
)
8551 lang_fill_statement_type
*new_stmt
;
8553 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8554 new_stmt
->fill
= fill
;
8558 lang_add_data (int type
, union etree_union
*exp
)
8560 lang_data_statement_type
*new_stmt
;
8562 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8563 new_stmt
->exp
= exp
;
8564 new_stmt
->type
= type
;
8568 lang_add_string (const char *s
)
8570 bfd_vma len
= strlen (s
);
8572 bool escape
= false;
8574 /* Add byte expressions until end of string. */
8575 for (i
= 0 ; i
< len
; i
++)
8584 /* Ignore the escape. */
8587 case 'n': c
= '\n'; break;
8588 case 'r': c
= '\r'; break;
8589 case 't': c
= '\t'; break;
8599 /* We have an octal number. */
8601 unsigned int value
= c
- '0';
8604 if ((c
>= '0') && (c
<= '7'))
8612 if ((c
>= '0') && (c
<= '7'))
8623 /* octal: \777 is treated as '\077' + '7' */
8634 lang_add_data (BYTE
, exp_intop (c
));
8642 lang_add_data (BYTE
, exp_intop (c
));
8646 /* Remeber to terminate the string. */
8647 lang_add_data (BYTE
, exp_intop (0));
8650 /* Create a new reloc statement. RELOC is the BFD relocation type to
8651 generate. HOWTO is the corresponding howto structure (we could
8652 look this up, but the caller has already done so). SECTION is the
8653 section to generate a reloc against, or NAME is the name of the
8654 symbol to generate a reloc against. Exactly one of SECTION and
8655 NAME must be NULL. ADDEND is an expression for the addend. */
8658 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8659 reloc_howto_type
*howto
,
8662 union etree_union
*addend
)
8664 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8668 p
->section
= section
;
8670 p
->addend_exp
= addend
;
8672 p
->addend_value
= 0;
8673 p
->output_section
= NULL
;
8674 p
->output_offset
= 0;
8677 lang_assignment_statement_type
*
8678 lang_add_assignment (etree_type
*exp
)
8680 lang_assignment_statement_type
*new_stmt
;
8682 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8683 new_stmt
->exp
= exp
;
8688 lang_add_attribute (enum statement_enum attribute
)
8690 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8694 lang_startup (const char *name
)
8696 if (first_file
->filename
!= NULL
)
8698 einfo (_("%F%P: multiple STARTUP files\n"));
8700 first_file
->filename
= name
;
8701 first_file
->local_sym_name
= name
;
8702 first_file
->flags
.real
= true;
8706 lang_float (bool maybe
)
8708 lang_float_flag
= maybe
;
8712 /* Work out the load- and run-time regions from a script statement, and
8713 store them in *LMA_REGION and *REGION respectively.
8715 MEMSPEC is the name of the run-time region, or the value of
8716 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8717 LMA_MEMSPEC is the name of the load-time region, or null if the
8718 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8719 had an explicit load address.
8721 It is an error to specify both a load region and a load address. */
8724 lang_get_regions (lang_memory_region_type
**region
,
8725 lang_memory_region_type
**lma_region
,
8726 const char *memspec
,
8727 const char *lma_memspec
,
8731 *lma_region
= lang_memory_region_lookup (lma_memspec
, false);
8733 /* If no runtime region or VMA has been specified, but the load region
8734 has been specified, then use the load region for the runtime region
8736 if (lma_memspec
!= NULL
8738 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8739 *region
= *lma_region
;
8741 *region
= lang_memory_region_lookup (memspec
, false);
8743 if (have_lma
&& lma_memspec
!= 0)
8744 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8749 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8750 lang_output_section_phdr_list
*phdrs
,
8751 const char *lma_memspec
)
8753 lang_get_regions (¤t_section
->region
,
8754 ¤t_section
->lma_region
,
8755 memspec
, lma_memspec
,
8756 current_section
->load_base
!= NULL
,
8757 current_section
->addr_tree
!= NULL
);
8759 current_section
->fill
= fill
;
8760 current_section
->phdrs
= phdrs
;
8764 /* Set the output format type. -oformat overrides scripts. */
8767 lang_add_output_format (const char *format
,
8772 if (output_target
== NULL
|| !from_script
)
8774 if (command_line
.endian
== ENDIAN_BIG
8777 else if (command_line
.endian
== ENDIAN_LITTLE
8781 output_target
= format
;
8786 lang_add_insert (const char *where
, int is_before
)
8788 lang_insert_statement_type
*new_stmt
;
8790 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8791 new_stmt
->where
= where
;
8792 new_stmt
->is_before
= is_before
;
8793 saved_script_handle
= previous_script_handle
;
8796 /* Enter a group. This creates a new lang_group_statement, and sets
8797 stat_ptr to build new statements within the group. */
8800 lang_enter_group (void)
8802 lang_group_statement_type
*g
;
8804 g
= new_stat (lang_group_statement
, stat_ptr
);
8805 lang_list_init (&g
->children
);
8806 push_stat_ptr (&g
->children
);
8809 /* Leave a group. This just resets stat_ptr to start writing to the
8810 regular list of statements again. Note that this will not work if
8811 groups can occur inside anything else which can adjust stat_ptr,
8812 but currently they can't. */
8815 lang_leave_group (void)
8820 /* Add a new program header. This is called for each entry in a PHDRS
8821 command in a linker script. */
8824 lang_new_phdr (const char *name
,
8831 struct lang_phdr
*n
, **pp
;
8834 n
= stat_alloc (sizeof (struct lang_phdr
));
8837 n
->type
= exp_get_vma (type
, 0, "program header type");
8838 n
->filehdr
= filehdr
;
8843 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8845 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8848 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8850 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8851 " when prior PT_LOAD headers lack them\n"), NULL
);
8858 /* Record the program header information in the output BFD. FIXME: We
8859 should not be calling an ELF specific function here. */
8862 lang_record_phdrs (void)
8866 lang_output_section_phdr_list
*last
;
8867 struct lang_phdr
*l
;
8868 lang_output_section_statement_type
*os
;
8871 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8874 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8881 for (os
= (void *) lang_os_list
.head
;
8885 lang_output_section_phdr_list
*pl
;
8887 if (os
->constraint
< 0)
8895 if (os
->sectype
== noload_section
8896 || os
->bfd_section
== NULL
8897 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8900 /* Don't add orphans to PT_INTERP header. */
8906 lang_output_section_statement_type
*tmp_os
;
8908 /* If we have not run across a section with a program
8909 header assigned to it yet, then scan forwards to find
8910 one. This prevents inconsistencies in the linker's
8911 behaviour when a script has specified just a single
8912 header and there are sections in that script which are
8913 not assigned to it, and which occur before the first
8914 use of that header. See here for more details:
8915 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8916 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8919 last
= tmp_os
->phdrs
;
8923 einfo (_("%F%P: no sections assigned to phdrs\n"));
8928 if (os
->bfd_section
== NULL
)
8931 for (; pl
!= NULL
; pl
= pl
->next
)
8933 if (strcmp (pl
->name
, l
->name
) == 0)
8938 secs
= (asection
**) xrealloc (secs
,
8939 alc
* sizeof (asection
*));
8941 secs
[c
] = os
->bfd_section
;
8948 if (l
->flags
== NULL
)
8951 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8956 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8958 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8959 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8960 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8961 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8966 /* Make sure all the phdr assignments succeeded. */
8967 for (os
= (void *) lang_os_list
.head
;
8971 lang_output_section_phdr_list
*pl
;
8973 if (os
->constraint
< 0
8974 || os
->bfd_section
== NULL
)
8977 for (pl
= os
->phdrs
;
8980 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8981 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8982 os
->name
, pl
->name
);
8986 /* Record a list of sections which may not be cross referenced. */
8989 lang_add_nocrossref (lang_nocrossref_type
*l
)
8991 struct lang_nocrossrefs
*n
;
8993 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8994 n
->next
= nocrossref_list
;
8996 n
->onlyfirst
= false;
8997 nocrossref_list
= n
;
8999 /* Set notice_all so that we get informed about all symbols. */
9000 link_info
.notice_all
= true;
9003 /* Record a section that cannot be referenced from a list of sections. */
9006 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
9008 lang_add_nocrossref (l
);
9009 nocrossref_list
->onlyfirst
= true;
9012 /* Overlay handling. We handle overlays with some static variables. */
9014 /* The overlay virtual address. */
9015 static etree_type
*overlay_vma
;
9016 /* And subsection alignment. */
9017 static etree_type
*overlay_subalign
;
9019 /* An expression for the maximum section size seen so far. */
9020 static etree_type
*overlay_max
;
9022 /* A list of all the sections in this overlay. */
9024 struct overlay_list
{
9025 struct overlay_list
*next
;
9026 lang_output_section_statement_type
*os
;
9029 static struct overlay_list
*overlay_list
;
9031 /* Start handling an overlay. */
9034 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
9036 /* The grammar should prevent nested overlays from occurring. */
9037 ASSERT (overlay_vma
== NULL
9038 && overlay_subalign
== NULL
9039 && overlay_max
== NULL
);
9041 overlay_vma
= vma_expr
;
9042 overlay_subalign
= subalign
;
9045 /* Start a section in an overlay. We handle this by calling
9046 lang_enter_output_section_statement with the correct VMA.
9047 lang_leave_overlay sets up the LMA and memory regions. */
9050 lang_enter_overlay_section (const char *name
)
9052 struct overlay_list
*n
;
9055 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
9056 0, 0, overlay_subalign
, 0, 0, 0);
9058 /* If this is the first section, then base the VMA of future
9059 sections on this one. This will work correctly even if `.' is
9060 used in the addresses. */
9061 if (overlay_list
== NULL
)
9062 overlay_vma
= exp_nameop (ADDR
, name
);
9064 /* Remember the section. */
9065 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
9066 n
->os
= current_section
;
9067 n
->next
= overlay_list
;
9070 size
= exp_nameop (SIZEOF
, name
);
9072 /* Arrange to work out the maximum section end address. */
9073 if (overlay_max
== NULL
)
9076 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
9079 /* Finish a section in an overlay. There isn't any special to do
9083 lang_leave_overlay_section (fill_type
*fill
,
9084 lang_output_section_phdr_list
*phdrs
)
9091 name
= current_section
->name
;
9093 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
9094 region and that no load-time region has been specified. It doesn't
9095 really matter what we say here, since lang_leave_overlay will
9097 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
9099 /* Define the magic symbols. */
9101 clean
= (char *) xmalloc (strlen (name
) + 1);
9103 for (s1
= name
; *s1
!= '\0'; s1
++)
9104 if (ISALNUM (*s1
) || *s1
== '_')
9108 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
9109 sprintf (buf
, "__load_start_%s", clean
);
9110 lang_add_assignment (exp_provide (buf
,
9111 exp_nameop (LOADADDR
, name
),
9114 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
9115 sprintf (buf
, "__load_stop_%s", clean
);
9116 lang_add_assignment (exp_provide (buf
,
9118 exp_nameop (LOADADDR
, name
),
9119 exp_nameop (SIZEOF
, name
)),
9125 /* Finish an overlay. If there are any overlay wide settings, this
9126 looks through all the sections in the overlay and sets them. */
9129 lang_leave_overlay (etree_type
*lma_expr
,
9132 const char *memspec
,
9133 lang_output_section_phdr_list
*phdrs
,
9134 const char *lma_memspec
)
9136 lang_memory_region_type
*region
;
9137 lang_memory_region_type
*lma_region
;
9138 struct overlay_list
*l
;
9139 lang_nocrossref_type
*nocrossref
;
9141 lang_get_regions (®ion
, &lma_region
,
9142 memspec
, lma_memspec
,
9143 lma_expr
!= NULL
, false);
9147 /* After setting the size of the last section, set '.' to end of the
9149 if (overlay_list
!= NULL
)
9151 overlay_list
->os
->update_dot
= 1;
9152 overlay_list
->os
->update_dot_tree
9153 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), false);
9159 struct overlay_list
*next
;
9161 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
9164 l
->os
->region
= region
;
9165 l
->os
->lma_region
= lma_region
;
9167 /* The first section has the load address specified in the
9168 OVERLAY statement. The rest are worked out from that.
9169 The base address is not needed (and should be null) if
9170 an LMA region was specified. */
9173 l
->os
->load_base
= lma_expr
;
9174 l
->os
->sectype
= first_overlay_section
;
9176 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
9177 l
->os
->phdrs
= phdrs
;
9181 lang_nocrossref_type
*nc
;
9183 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
9184 nc
->name
= l
->os
->name
;
9185 nc
->next
= nocrossref
;
9194 if (nocrossref
!= NULL
)
9195 lang_add_nocrossref (nocrossref
);
9198 overlay_list
= NULL
;
9200 overlay_subalign
= NULL
;
9203 /* Version handling. This is only useful for ELF. */
9205 /* If PREV is NULL, return first version pattern matching particular symbol.
9206 If PREV is non-NULL, return first version pattern matching particular
9207 symbol after PREV (previously returned by lang_vers_match). */
9209 static struct bfd_elf_version_expr
*
9210 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
9211 struct bfd_elf_version_expr
*prev
,
9215 const char *cxx_sym
= sym
;
9216 const char *java_sym
= sym
;
9217 struct bfd_elf_version_expr
*expr
= NULL
;
9218 enum demangling_styles curr_style
;
9220 curr_style
= CURRENT_DEMANGLING_STYLE
;
9221 cplus_demangle_set_style (no_demangling
);
9222 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
9225 cplus_demangle_set_style (curr_style
);
9227 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9229 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
9230 DMGL_PARAMS
| DMGL_ANSI
);
9234 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9236 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
9241 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
9243 struct bfd_elf_version_expr e
;
9245 switch (prev
? prev
->mask
: 0)
9248 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
9251 expr
= (struct bfd_elf_version_expr
*)
9252 htab_find ((htab_t
) head
->htab
, &e
);
9253 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
9254 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
9260 case BFD_ELF_VERSION_C_TYPE
:
9261 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9263 e
.pattern
= cxx_sym
;
9264 expr
= (struct bfd_elf_version_expr
*)
9265 htab_find ((htab_t
) head
->htab
, &e
);
9266 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
9267 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9273 case BFD_ELF_VERSION_CXX_TYPE
:
9274 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9276 e
.pattern
= java_sym
;
9277 expr
= (struct bfd_elf_version_expr
*)
9278 htab_find ((htab_t
) head
->htab
, &e
);
9279 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9280 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9291 /* Finally, try the wildcards. */
9292 if (prev
== NULL
|| prev
->literal
)
9293 expr
= head
->remaining
;
9296 for (; expr
; expr
= expr
->next
)
9303 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9306 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9308 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9312 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9318 free ((char *) c_sym
);
9320 free ((char *) cxx_sym
);
9321 if (java_sym
!= sym
)
9322 free ((char *) java_sym
);
9326 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9327 return a pointer to the symbol name with any backslash quotes removed. */
9330 realsymbol (const char *pattern
)
9333 bool changed
= false, backslash
= false;
9334 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9336 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9338 /* It is a glob pattern only if there is no preceding
9342 /* Remove the preceding backslash. */
9349 if (*p
== '?' || *p
== '*' || *p
== '[')
9356 backslash
= *p
== '\\';
9372 /* This is called for each variable name or match expression. NEW_NAME is
9373 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9374 pattern to be matched against symbol names. */
9376 struct bfd_elf_version_expr
*
9377 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9378 const char *new_name
,
9382 struct bfd_elf_version_expr
*ret
;
9384 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9388 ret
->literal
= true;
9389 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9390 if (ret
->pattern
== NULL
)
9392 ret
->pattern
= new_name
;
9393 ret
->literal
= false;
9396 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9397 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9398 else if (strcasecmp (lang
, "C++") == 0)
9399 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9400 else if (strcasecmp (lang
, "Java") == 0)
9401 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9404 einfo (_("%X%P: unknown language `%s' in version information\n"),
9406 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9409 return ldemul_new_vers_pattern (ret
);
9412 /* This is called for each set of variable names and match
9415 struct bfd_elf_version_tree
*
9416 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9417 struct bfd_elf_version_expr
*locals
)
9419 struct bfd_elf_version_tree
*ret
;
9421 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9422 ret
->globals
.list
= globals
;
9423 ret
->locals
.list
= locals
;
9424 ret
->match
= lang_vers_match
;
9425 ret
->name_indx
= (unsigned int) -1;
9429 /* This static variable keeps track of version indices. */
9431 static int version_index
;
9434 version_expr_head_hash (const void *p
)
9436 const struct bfd_elf_version_expr
*e
=
9437 (const struct bfd_elf_version_expr
*) p
;
9439 return htab_hash_string (e
->pattern
);
9443 version_expr_head_eq (const void *p1
, const void *p2
)
9445 const struct bfd_elf_version_expr
*e1
=
9446 (const struct bfd_elf_version_expr
*) p1
;
9447 const struct bfd_elf_version_expr
*e2
=
9448 (const struct bfd_elf_version_expr
*) p2
;
9450 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9454 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9457 struct bfd_elf_version_expr
*e
, *next
;
9458 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9460 for (e
= head
->list
; e
; e
= e
->next
)
9464 head
->mask
|= e
->mask
;
9469 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9470 version_expr_head_eq
, NULL
);
9471 list_loc
= &head
->list
;
9472 remaining_loc
= &head
->remaining
;
9473 for (e
= head
->list
; e
; e
= next
)
9479 remaining_loc
= &e
->next
;
9483 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9487 struct bfd_elf_version_expr
*e1
, *last
;
9489 e1
= (struct bfd_elf_version_expr
*) *loc
;
9493 if (e1
->mask
== e
->mask
)
9501 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9505 /* This is a duplicate. */
9506 /* FIXME: Memory leak. Sometimes pattern is not
9507 xmalloced alone, but in larger chunk of memory. */
9508 /* free (e->pattern); */
9513 e
->next
= last
->next
;
9521 list_loc
= &e
->next
;
9525 *remaining_loc
= NULL
;
9526 *list_loc
= head
->remaining
;
9529 head
->remaining
= head
->list
;
9532 /* This is called when we know the name and dependencies of the
9536 lang_register_vers_node (const char *name
,
9537 struct bfd_elf_version_tree
*version
,
9538 struct bfd_elf_version_deps
*deps
)
9540 struct bfd_elf_version_tree
*t
, **pp
;
9541 struct bfd_elf_version_expr
*e1
;
9546 if (link_info
.version_info
!= NULL
9547 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9549 einfo (_("%X%P: anonymous version tag cannot be combined"
9550 " with other version tags\n"));
9555 /* Make sure this node has a unique name. */
9556 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9557 if (strcmp (t
->name
, name
) == 0)
9558 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9560 lang_finalize_version_expr_head (&version
->globals
);
9561 lang_finalize_version_expr_head (&version
->locals
);
9563 /* Check the global and local match names, and make sure there
9564 aren't any duplicates. */
9566 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9568 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9570 struct bfd_elf_version_expr
*e2
;
9572 if (t
->locals
.htab
&& e1
->literal
)
9574 e2
= (struct bfd_elf_version_expr
*)
9575 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9576 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9578 if (e1
->mask
== e2
->mask
)
9579 einfo (_("%X%P: duplicate expression `%s'"
9580 " in version information\n"), e1
->pattern
);
9584 else if (!e1
->literal
)
9585 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9586 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9587 && e1
->mask
== e2
->mask
)
9588 einfo (_("%X%P: duplicate expression `%s'"
9589 " in version information\n"), e1
->pattern
);
9593 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9595 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9597 struct bfd_elf_version_expr
*e2
;
9599 if (t
->globals
.htab
&& e1
->literal
)
9601 e2
= (struct bfd_elf_version_expr
*)
9602 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9603 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9605 if (e1
->mask
== e2
->mask
)
9606 einfo (_("%X%P: duplicate expression `%s'"
9607 " in version information\n"),
9612 else if (!e1
->literal
)
9613 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9614 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9615 && e1
->mask
== e2
->mask
)
9616 einfo (_("%X%P: duplicate expression `%s'"
9617 " in version information\n"), e1
->pattern
);
9621 version
->deps
= deps
;
9622 version
->name
= name
;
9623 if (name
[0] != '\0')
9626 version
->vernum
= version_index
;
9629 version
->vernum
= 0;
9631 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9636 /* This is called when we see a version dependency. */
9638 struct bfd_elf_version_deps
*
9639 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9641 struct bfd_elf_version_deps
*ret
;
9642 struct bfd_elf_version_tree
*t
;
9644 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9647 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9649 if (strcmp (t
->name
, name
) == 0)
9651 ret
->version_needed
= t
;
9656 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9658 ret
->version_needed
= NULL
;
9663 lang_do_version_exports_section (void)
9665 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9667 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9669 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9677 contents
= (char *) xmalloc (len
);
9678 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9679 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9682 while (p
< contents
+ len
)
9684 greg
= lang_new_vers_pattern (greg
, p
, NULL
, false);
9685 p
= strchr (p
, '\0') + 1;
9688 /* Do not free the contents, as we used them creating the regex. */
9690 /* Do not include this section in the link. */
9691 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9694 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, false);
9695 lang_register_vers_node (command_line
.version_exports_section
,
9696 lang_new_vers_node (greg
, lreg
), NULL
);
9699 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9700 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9701 thrown, however, references to symbols in the origin and length fields
9702 will be pushed into the symbol table, this allows PROVIDE statements to
9703 then provide these symbols. This function is called a second time with
9704 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9705 data structures, and throw errors if missing symbols are encountered. */
9708 lang_do_memory_regions (bool update_regions_p
)
9710 lang_memory_region_type
*r
= lang_memory_region_list
;
9712 for (; r
!= NULL
; r
= r
->next
)
9716 exp_fold_tree_no_dot (r
->origin_exp
);
9717 if (update_regions_p
)
9719 if (expld
.result
.valid_p
)
9721 r
->origin
= expld
.result
.value
;
9722 r
->current
= r
->origin
;
9725 einfo (_("%P: invalid origin for memory region %s\n"),
9731 exp_fold_tree_no_dot (r
->length_exp
);
9732 if (update_regions_p
)
9734 if (expld
.result
.valid_p
)
9735 r
->length
= expld
.result
.value
;
9737 einfo (_("%P: invalid length for memory region %s\n"),
9745 lang_add_unique (const char *name
)
9747 struct unique_sections
*ent
;
9749 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9750 if (strcmp (ent
->name
, name
) == 0)
9753 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9754 ent
->name
= xstrdup (name
);
9755 ent
->next
= unique_section_list
;
9756 unique_section_list
= ent
;
9759 /* Append the list of dynamic symbols to the existing one. */
9762 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9763 struct bfd_elf_version_expr
*dynamic
)
9767 struct bfd_elf_version_expr
*tail
;
9768 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9770 tail
->next
= (*list_p
)->head
.list
;
9771 (*list_p
)->head
.list
= dynamic
;
9775 struct bfd_elf_dynamic_list
*d
;
9777 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9778 d
->head
.list
= dynamic
;
9779 d
->match
= lang_vers_match
;
9784 /* Append the list of C++ typeinfo dynamic symbols to the existing
9788 lang_append_dynamic_list_cpp_typeinfo (void)
9790 const char *symbols
[] =
9792 "typeinfo name for*",
9795 struct bfd_elf_version_expr
*dynamic
= NULL
;
9798 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9799 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9802 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9805 /* Append the list of C++ operator new and delete dynamic symbols to the
9809 lang_append_dynamic_list_cpp_new (void)
9811 const char *symbols
[] =
9816 struct bfd_elf_version_expr
*dynamic
= NULL
;
9819 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9820 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9823 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9826 /* Scan a space and/or comma separated string of features. */
9829 lang_ld_feature (char *str
)
9837 while (*p
== ',' || ISSPACE (*p
))
9842 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9846 if (strcasecmp (p
, "SANE_EXPR") == 0)
9847 config
.sane_expr
= true;
9849 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9855 /* Pretty print memory amount. */
9858 lang_print_memory_size (uint64_t sz
)
9860 if ((sz
& 0x3fffffff) == 0)
9861 printf ("%10" PRIu64
" GB", sz
>> 30);
9862 else if ((sz
& 0xfffff) == 0)
9863 printf ("%10" PRIu64
" MB", sz
>> 20);
9864 else if ((sz
& 0x3ff) == 0)
9865 printf ("%10" PRIu64
" KB", sz
>> 10);
9867 printf (" %10" PRIu64
" B", sz
);
9870 /* Implement --print-memory-usage: disply per region memory usage. */
9873 lang_print_memory_usage (void)
9875 lang_memory_region_type
*r
;
9877 printf ("Memory region Used Size Region Size %%age Used\n");
9878 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9880 bfd_vma used_length
= r
->current
- r
->origin
;
9882 printf ("%16s: ",r
->name_list
.name
);
9883 lang_print_memory_size (used_length
);
9884 lang_print_memory_size (r
->length
);
9888 double percent
= used_length
* 100.0 / r
->length
;
9889 printf (" %6.2f%%", percent
);