1 /* Emulation code used by all ELF targets.
2 Copyright (C) 1991-2021 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. */
32 #include "elf/internal.h"
35 /* Info attached to an output_section_statement about input sections,
36 used when sorting SHF_LINK_ORDER sections. */
40 /* Size allocated for isec. */
42 /* Used entries in isec. */
44 /* How many are SHF_LINK_ORDER. */
46 /* Input sections attached to this output section. */
47 struct os_sections_input
{
48 lang_input_section_type
*is
;
53 /* Add IS to data kept for OS. */
56 add_link_order_input_section (lang_input_section_type
*is
,
57 lang_output_section_statement_type
*os
)
59 struct os_sections
*os_info
= os
->data
;
64 os_info
= xmalloc (sizeof (*os_info
) + 63 * sizeof (*os_info
->isec
));
70 if (os_info
->count
== os_info
->alloc
)
74 want
= sizeof (*os_info
) + (os_info
->alloc
- 1) * sizeof (*os_info
->isec
);
75 os_info
= xrealloc (os_info
, want
);
78 os_info
->isec
[os_info
->count
].is
= is
;
79 os_info
->isec
[os_info
->count
].idx
= os_info
->count
;
82 if (bfd_get_flavour (s
->owner
) == bfd_target_elf_flavour
83 && (s
->flags
& SEC_LINKER_CREATED
) == 0
84 && elf_linked_to_section (s
) != NULL
)
89 /* Run over the linker's statement list, extracting info about input
90 sections attached to each output section. */
93 link_order_scan (lang_statement_union_type
*u
,
94 lang_output_section_statement_type
*os
)
99 for (; u
!= NULL
; u
= u
->header
.next
)
101 switch (u
->header
.type
)
103 case lang_wild_statement_enum
:
104 if (link_order_scan (u
->wild_statement
.children
.head
, os
))
107 case lang_constructors_statement_enum
:
108 if (link_order_scan (constructor_list
.head
, os
))
111 case lang_output_section_statement_enum
:
112 if (u
->output_section_statement
.constraint
!= -1
113 && link_order_scan (u
->output_section_statement
.children
.head
,
114 &u
->output_section_statement
))
117 case lang_group_statement_enum
:
118 if (link_order_scan (u
->group_statement
.children
.head
, os
))
121 case lang_input_section_enum
:
122 s
= u
->input_section
.section
;
123 if (s
->output_section
!= NULL
124 && s
->output_section
->owner
== link_info
.output_bfd
125 && (s
->output_section
->flags
& SEC_EXCLUDE
) == 0
126 && ((s
->output_section
->flags
& SEC_HAS_CONTENTS
) != 0
127 || ((s
->output_section
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
))
128 == (SEC_LOAD
| SEC_THREAD_LOCAL
))))
129 if (add_link_order_input_section (&u
->input_section
, os
))
139 /* Compare two sections based on the locations of the sections they are
140 linked to. Used by fixup_link_order. */
143 compare_link_order (const void *a
, const void *b
)
145 const struct os_sections_input
*ai
= a
;
146 const struct os_sections_input
*bi
= b
;
147 asection
*asec
= NULL
;
148 asection
*bsec
= NULL
;
151 if (bfd_get_flavour (ai
->is
->section
->owner
) == bfd_target_elf_flavour
)
152 asec
= elf_linked_to_section (ai
->is
->section
);
153 if (bfd_get_flavour (bi
->is
->section
->owner
) == bfd_target_elf_flavour
)
154 bsec
= elf_linked_to_section (bi
->is
->section
);
156 /* Place unordered sections before ordered sections. */
157 if (asec
== NULL
|| bsec
== NULL
)
161 else if (asec
!= NULL
)
163 return ai
->idx
- bi
->idx
;
166 apos
= asec
->output_section
->lma
+ asec
->output_offset
;
167 bpos
= bsec
->output_section
->lma
+ bsec
->output_offset
;
171 else if (apos
> bpos
)
174 if (! bfd_link_relocatable (&link_info
))
176 /* The only way we should get matching LMAs is when
177 the first of the two sections has zero size. */
178 if (asec
->size
< bsec
->size
)
180 else if (asec
->size
> bsec
->size
)
184 /* If they are both zero size then they almost certainly have the same
185 VMA and thus are not ordered with respect to each other. Test VMA
186 anyway, and fall back to id to make the result reproducible across
187 qsort implementations. */
188 apos
= asec
->output_section
->vma
+ asec
->output_offset
;
189 bpos
= bsec
->output_section
->vma
+ bsec
->output_offset
;
192 else if (apos
> bpos
)
195 return asec
->id
- bsec
->id
;
198 /* Rearrange sections with SHF_LINK_ORDER into the same order as their
202 fixup_link_order (lang_output_section_statement_type
*os
)
204 struct os_sections
*os_info
= os
->data
;
206 lang_input_section_type
**orig_is
;
209 for (i
= 0; i
< os_info
->count
; i
= j
)
211 /* Normally a linker script will select SHF_LINK_ORDER sections
212 with an input section wildcard something like the following:
213 *(.IA_64.unwind* .gnu.linkonce.ia64unw.*)
214 However if some other random sections are smashed into an
215 output section, or if SHF_LINK_ORDER are split up by the
216 linker script, then we only want to sort sections matching a
217 given wildcard. That's the purpose of the pattern test. */
218 for (j
= i
+ 1; j
< os_info
->count
; j
++)
219 if (os_info
->isec
[j
].is
->pattern
!= os_info
->isec
[i
].is
->pattern
)
222 qsort (&os_info
->isec
[i
], j
- i
, sizeof (*os_info
->isec
),
225 for (i
= 0; i
< os_info
->count
; i
++)
226 if (os_info
->isec
[i
].idx
!= i
)
228 if (i
== os_info
->count
)
231 /* Now reorder the linker input section statements to reflect the
232 proper sorting. The is done by rewriting the existing statements
233 rather than fiddling with lists, since the only thing we need to
234 change is the bfd section pointer. */
235 orig_is
= xmalloc (os_info
->count
* sizeof (*orig_is
));
236 save_s
= xmalloc (os_info
->count
* sizeof (*save_s
));
237 for (i
= 0; i
< os_info
->count
; i
++)
239 orig_is
[os_info
->isec
[i
].idx
] = os_info
->isec
[i
].is
;
240 save_s
[i
] = os_info
->isec
[i
].is
->section
;
242 for (i
= 0; i
< os_info
->count
; i
++)
243 if (os_info
->isec
[i
].idx
!= i
)
245 orig_is
[i
]->section
= save_s
[i
];
246 /* Restore os_info to pristine state before the qsort, for the
247 next pass over sections. */
248 os_info
->isec
[i
].is
= orig_is
[i
];
249 os_info
->isec
[i
].idx
= i
;
257 ldelf_map_segments (bool need_layout
)
260 static bool done_link_order_scan
= false;
264 lang_relax_sections (need_layout
);
267 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
269 lang_output_section_statement_type
*os
;
270 if (!done_link_order_scan
)
272 link_order_scan (statement_list
.head
, NULL
);
273 done_link_order_scan
= true;
275 for (os
= (void *) lang_os_list
.head
; os
!= NULL
; os
= os
->next
)
277 struct os_sections
*os_info
= os
->data
;
278 if (os_info
!= NULL
&& os_info
->ordered
!= 0)
280 if (os_info
->ordered
!= os_info
->count
281 && bfd_link_relocatable (&link_info
))
284 "%pA has both ordered and unordered sections"),
288 if (os_info
->count
> 1
289 && fixup_link_order (os
))
295 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
296 && !bfd_link_relocatable (&link_info
))
298 bfd_size_type phdr_size
;
300 phdr_size
= elf_program_header_size (link_info
.output_bfd
);
301 /* If we don't have user supplied phdrs, throw away any
302 previous linker generated program headers. */
303 if (lang_phdr_list
== NULL
)
304 elf_seg_map (link_info
.output_bfd
) = NULL
;
305 if (!_bfd_elf_map_sections_to_segments (link_info
.output_bfd
,
307 einfo (_("%F%P: map sections to segments failed: %E\n"));
309 if (phdr_size
!= elf_program_header_size (link_info
.output_bfd
))
312 /* The first few times we allow any change to
316 < elf_program_header_size (link_info
.output_bfd
))
317 /* After that we only allow the size to grow. */
320 elf_program_header_size (link_info
.output_bfd
) = phdr_size
;
324 while (need_layout
&& --tries
);
327 einfo (_("%F%P: looping in map_segments"));
329 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
330 && lang_phdr_list
== NULL
)
332 /* If we don't have user supplied phdrs, strip zero-sized dynamic
333 sections and regenerate program headers. */
334 const struct elf_backend_data
*bed
335 = get_elf_backend_data (link_info
.output_bfd
);
336 if (bed
->elf_backend_strip_zero_sized_dynamic_sections
337 && !bed
->elf_backend_strip_zero_sized_dynamic_sections
339 einfo (_("%F%P: failed to strip zero-sized dynamic sections"));
344 /* We want to emit CTF early if and only if we are not targetting ELF with this
348 ldelf_emit_ctf_early (void)
350 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
355 /* Callbacks used to map from bfd types to libctf types, under libctf's
358 struct ctf_strtab_iter_cb_arg
360 struct elf_strtab_hash
*strtab
;
365 /* Return strings from the strtab to libctf, one by one. Returns NULL when
366 iteration is complete. */
369 ldelf_ctf_strtab_iter_cb (uint32_t *offset
, void *arg_
)
374 struct ctf_strtab_iter_cb_arg
*arg
=
375 (struct ctf_strtab_iter_cb_arg
*) arg_
;
377 /* There is no zeroth string. */
378 if (arg
->next_i
== 0)
381 /* Hunt through strings until we fall off the end or find one with
382 a nonzero refcount. */
385 if (arg
->next_i
>= _bfd_elf_strtab_len (arg
->strtab
))
391 ret
= _bfd_elf_strtab_str (arg
->strtab
, arg
->next_i
++, &off
);
397 /* If we've overflowed, we cannot share any further strings: the CTF
398 format cannot encode strings with such high offsets. */
406 ldelf_acquire_strings_for_ctf
407 (struct ctf_dict
*ctf_output
, struct elf_strtab_hash
*strtab
)
409 struct ctf_strtab_iter_cb_arg args
= { strtab
, 0, 0 };
413 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
415 if (ctf_link_add_strtab (ctf_output
, ldelf_ctf_strtab_iter_cb
,
417 einfo (_("%F%P: warning: CTF strtab association failed; strings will "
418 "not be shared: %s\n"),
419 ctf_errmsg (ctf_errno (ctf_output
)));
424 ldelf_new_dynsym_for_ctf (struct ctf_dict
*ctf_output
, int symidx
,
425 struct elf_internal_sym
*sym
)
436 lsym
.st_nameidx
= sym
->st_name
;
437 lsym
.st_nameidx_set
= 1;
438 lsym
.st_symidx
= symidx
;
439 lsym
.st_shndx
= sym
->st_shndx
;
440 lsym
.st_type
= ELF_ST_TYPE (sym
->st_info
);
441 lsym
.st_value
= sym
->st_value
;
442 if (ctf_link_add_linker_symbol (ctf_output
, &lsym
) < 0)
444 einfo (_("%F%P: warning: CTF symbol addition failed; CTF will "
445 "not be tied to symbols: %s\n"),
446 ctf_errmsg (ctf_errno (ctf_output
)));
451 /* Shuffle all the symbols. */
453 if (ctf_link_shuffle_syms (ctf_output
) < 0)
454 einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will "
455 "not be tied to symbols: %s\n"),
456 ctf_errmsg (ctf_errno (ctf_output
)));
461 ldelf_emit_ctf_early (void)
467 ldelf_acquire_strings_for_ctf (struct ctf_dict
*ctf_output ATTRIBUTE_UNUSED
,
468 struct elf_strtab_hash
*strtab ATTRIBUTE_UNUSED
)
471 ldelf_new_dynsym_for_ctf (struct ctf_dict
*ctf_output ATTRIBUTE_UNUSED
,
472 int symidx ATTRIBUTE_UNUSED
,
473 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
)