Commit | Line | Data |
---|---|---|
d871d478 | 1 | /* Emulation code used by all ELF targets. |
250d07de | 2 | Copyright (C) 1991-2021 Free Software Foundation, Inc. |
d871d478 AM |
3 | |
4 | This file is part of the GNU Binutils. | |
5 | ||
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. | |
10 | ||
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. | |
15 | ||
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. */ | |
20 | ||
21 | #include "sysdep.h" | |
22 | #include "bfd.h" | |
0b4453c7 | 23 | #include "bfdlink.h" |
1ff6de03 | 24 | #include "ctf-api.h" |
d871d478 AM |
25 | #include "ld.h" |
26 | #include "ldmain.h" | |
27 | #include "ldmisc.h" | |
28 | #include "ldexp.h" | |
29 | #include "ldlang.h" | |
b209b5a6 | 30 | #include "ldctor.h" |
d871d478 | 31 | #include "elf-bfd.h" |
3d16b64e | 32 | #include "elf/internal.h" |
d871d478 AM |
33 | #include "ldelfgen.h" |
34 | ||
b209b5a6 AM |
35 | /* Info attached to an output_section_statement about input sections, |
36 | used when sorting SHF_LINK_ORDER sections. */ | |
37 | ||
38 | struct os_sections | |
39 | { | |
40 | /* Size allocated for isec. */ | |
41 | unsigned int alloc; | |
42 | /* Used entries in isec. */ | |
43 | unsigned int count; | |
44 | /* How many are SHF_LINK_ORDER. */ | |
45 | unsigned int ordered; | |
46 | /* Input sections attached to this output section. */ | |
47 | struct os_sections_input { | |
48 | lang_input_section_type *is; | |
49 | unsigned int idx; | |
50 | } isec[1]; | |
51 | }; | |
52 | ||
53 | /* Add IS to data kept for OS. */ | |
54 | ||
55 | static bfd_boolean | |
56 | add_link_order_input_section (lang_input_section_type *is, | |
57 | lang_output_section_statement_type *os) | |
58 | { | |
59 | struct os_sections *os_info = os->data; | |
60 | asection *s; | |
61 | ||
62 | if (os_info == NULL) | |
63 | { | |
64 | os_info = xmalloc (sizeof (*os_info) + 63 * sizeof (*os_info->isec)); | |
65 | os_info->alloc = 64; | |
66 | os_info->count = 0; | |
67 | os_info->ordered = 0; | |
68 | os->data = os_info; | |
69 | } | |
70 | if (os_info->count == os_info->alloc) | |
71 | { | |
72 | size_t want; | |
73 | os_info->alloc *= 2; | |
74 | want = sizeof (*os_info) + (os_info->alloc - 1) * sizeof (*os_info->isec); | |
75 | os_info = xrealloc (os_info, want); | |
76 | os->data = os_info; | |
77 | } | |
78 | os_info->isec[os_info->count].is = is; | |
79 | os_info->isec[os_info->count].idx = os_info->count; | |
80 | os_info->count++; | |
81 | s = is->section; | |
4120e488 | 82 | if (bfd_get_flavour (s->owner) == bfd_target_elf_flavour |
b634d11d | 83 | && (s->flags & SEC_LINKER_CREATED) == 0 |
b209b5a6 AM |
84 | && elf_linked_to_section (s) != NULL) |
85 | os_info->ordered++; | |
86 | return FALSE; | |
87 | } | |
88 | ||
89 | /* Run over the linker's statement list, extracting info about input | |
90 | sections attached to each output section. */ | |
91 | ||
92 | static bfd_boolean | |
93 | link_order_scan (lang_statement_union_type *u, | |
94 | lang_output_section_statement_type *os) | |
95 | { | |
96 | asection *s; | |
97 | bfd_boolean ret = FALSE; | |
98 | ||
99 | for (; u != NULL; u = u->header.next) | |
100 | { | |
101 | switch (u->header.type) | |
102 | { | |
103 | case lang_wild_statement_enum: | |
104 | if (link_order_scan (u->wild_statement.children.head, os)) | |
105 | ret = TRUE; | |
106 | break; | |
107 | case lang_constructors_statement_enum: | |
108 | if (link_order_scan (constructor_list.head, os)) | |
109 | ret = TRUE; | |
110 | break; | |
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)) | |
115 | ret = TRUE; | |
116 | break; | |
117 | case lang_group_statement_enum: | |
118 | if (link_order_scan (u->group_statement.children.head, os)) | |
119 | ret = TRUE; | |
120 | break; | |
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)) | |
130 | ret = TRUE; | |
131 | break; | |
132 | default: | |
133 | break; | |
134 | } | |
135 | } | |
136 | return ret; | |
137 | } | |
138 | ||
139 | /* Compare two sections based on the locations of the sections they are | |
140 | linked to. Used by fixup_link_order. */ | |
141 | ||
142 | static int | |
143 | compare_link_order (const void *a, const void *b) | |
144 | { | |
145 | const struct os_sections_input *ai = a; | |
146 | const struct os_sections_input *bi = b; | |
4120e488 AM |
147 | asection *asec = NULL; |
148 | asection *bsec = NULL; | |
b209b5a6 AM |
149 | bfd_vma apos, bpos; |
150 | ||
4120e488 AM |
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); | |
155 | ||
b209b5a6 AM |
156 | /* Place unordered sections before ordered sections. */ |
157 | if (asec == NULL || bsec == NULL) | |
158 | { | |
159 | if (bsec != NULL) | |
160 | return -1; | |
161 | else if (asec != NULL) | |
162 | return 1; | |
163 | return ai->idx - bi->idx; | |
164 | } | |
165 | ||
166 | apos = asec->output_section->lma + asec->output_offset; | |
167 | bpos = bsec->output_section->lma + bsec->output_offset; | |
168 | ||
169 | if (apos < bpos) | |
170 | return -1; | |
171 | else if (apos > bpos) | |
172 | return 1; | |
173 | ||
174 | /* The only way we should get matching LMAs is when the first of two | |
175 | sections has zero size. */ | |
176 | if (asec->size < bsec->size) | |
177 | return -1; | |
178 | else if (asec->size > bsec->size) | |
179 | return 1; | |
180 | ||
181 | /* If they are both zero size then they almost certainly have the same | |
182 | VMA and thus are not ordered with respect to each other. Test VMA | |
183 | anyway, and fall back to id to make the result reproducible across | |
184 | qsort implementations. */ | |
185 | apos = asec->output_section->vma + asec->output_offset; | |
186 | bpos = bsec->output_section->vma + bsec->output_offset; | |
187 | if (apos < bpos) | |
188 | return -1; | |
189 | else if (apos > bpos) | |
190 | return 1; | |
191 | ||
192 | return asec->id - bsec->id; | |
193 | } | |
194 | ||
195 | /* Rearrange sections with SHF_LINK_ORDER into the same order as their | |
196 | linked sections. */ | |
197 | ||
198 | static bfd_boolean | |
199 | fixup_link_order (lang_output_section_statement_type *os) | |
200 | { | |
201 | struct os_sections *os_info = os->data; | |
202 | unsigned int i, j; | |
203 | lang_input_section_type **orig_is; | |
204 | asection **save_s; | |
205 | ||
206 | for (i = 0; i < os_info->count; i = j) | |
207 | { | |
208 | /* Normally a linker script will select SHF_LINK_ORDER sections | |
209 | with an input section wildcard something like the following: | |
210 | *(.IA_64.unwind* .gnu.linkonce.ia64unw.*) | |
211 | However if some other random sections are smashed into an | |
212 | output section, or if SHF_LINK_ORDER are split up by the | |
213 | linker script, then we only want to sort sections matching a | |
214 | given wildcard. That's the purpose of the pattern test. */ | |
215 | for (j = i + 1; j < os_info->count; j++) | |
216 | if (os_info->isec[j].is->pattern != os_info->isec[i].is->pattern) | |
217 | break; | |
218 | if (j - i > 1) | |
219 | qsort (&os_info->isec[i], j - i, sizeof (*os_info->isec), | |
220 | compare_link_order); | |
221 | } | |
222 | for (i = 0; i < os_info->count; i++) | |
223 | if (os_info->isec[i].idx != i) | |
224 | break; | |
225 | if (i == os_info->count) | |
226 | return FALSE; | |
227 | ||
228 | /* Now reorder the linker input section statements to reflect the | |
229 | proper sorting. The is done by rewriting the existing statements | |
230 | rather than fiddling with lists, since the only thing we need to | |
231 | change is the bfd section pointer. */ | |
232 | orig_is = xmalloc (os_info->count * sizeof (*orig_is)); | |
233 | save_s = xmalloc (os_info->count * sizeof (*save_s)); | |
234 | for (i = 0; i < os_info->count; i++) | |
235 | { | |
236 | orig_is[os_info->isec[i].idx] = os_info->isec[i].is; | |
237 | save_s[i] = os_info->isec[i].is->section; | |
238 | } | |
239 | for (i = 0; i < os_info->count; i++) | |
240 | if (os_info->isec[i].idx != i) | |
241 | { | |
242 | orig_is[i]->section = save_s[i]; | |
243 | /* Restore os_info to pristine state before the qsort, for the | |
244 | next pass over sections. */ | |
245 | os_info->isec[i].is = orig_is[i]; | |
246 | os_info->isec[i].idx = i; | |
247 | } | |
248 | free (save_s); | |
249 | free (orig_is); | |
250 | return TRUE; | |
251 | } | |
252 | ||
d871d478 AM |
253 | void |
254 | ldelf_map_segments (bfd_boolean need_layout) | |
255 | { | |
256 | int tries = 10; | |
b209b5a6 | 257 | static bfd_boolean done_link_order_scan = FALSE; |
d871d478 AM |
258 | |
259 | do | |
260 | { | |
261 | lang_relax_sections (need_layout); | |
262 | need_layout = FALSE; | |
263 | ||
4120e488 | 264 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) |
b209b5a6 AM |
265 | { |
266 | lang_output_section_statement_type *os; | |
267 | if (!done_link_order_scan) | |
268 | { | |
269 | link_order_scan (statement_list.head, NULL); | |
270 | done_link_order_scan = TRUE; | |
271 | } | |
272 | for (os = (void *) lang_os_list.head; os != NULL; os = os->next) | |
273 | { | |
274 | struct os_sections *os_info = os->data; | |
275 | if (os_info != NULL && os_info->ordered != 0) | |
276 | { | |
277 | if (os_info->ordered != os_info->count | |
278 | && bfd_link_relocatable (&link_info)) | |
279 | { | |
280 | einfo (_("%F%P: " | |
281 | "%pA has both ordered and unordered sections"), | |
282 | os->bfd_section); | |
283 | return; | |
284 | } | |
285 | if (os_info->count > 1 | |
286 | && fixup_link_order (os)) | |
287 | need_layout = TRUE; | |
288 | } | |
289 | } | |
290 | } | |
291 | ||
4120e488 | 292 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour |
d871d478 AM |
293 | && !bfd_link_relocatable (&link_info)) |
294 | { | |
295 | bfd_size_type phdr_size; | |
296 | ||
297 | phdr_size = elf_program_header_size (link_info.output_bfd); | |
298 | /* If we don't have user supplied phdrs, throw away any | |
299 | previous linker generated program headers. */ | |
300 | if (lang_phdr_list == NULL) | |
301 | elf_seg_map (link_info.output_bfd) = NULL; | |
302 | if (!_bfd_elf_map_sections_to_segments (link_info.output_bfd, | |
303 | &link_info)) | |
304 | einfo (_("%F%P: map sections to segments failed: %E\n")); | |
305 | ||
306 | if (phdr_size != elf_program_header_size (link_info.output_bfd)) | |
307 | { | |
308 | if (tries > 6) | |
309 | /* The first few times we allow any change to | |
310 | phdr_size . */ | |
311 | need_layout = TRUE; | |
312 | else if (phdr_size | |
313 | < elf_program_header_size (link_info.output_bfd)) | |
314 | /* After that we only allow the size to grow. */ | |
315 | need_layout = TRUE; | |
316 | else | |
317 | elf_program_header_size (link_info.output_bfd) = phdr_size; | |
318 | } | |
319 | } | |
320 | } | |
321 | while (need_layout && --tries); | |
322 | ||
323 | if (tries == 0) | |
324 | einfo (_("%F%P: looping in map_segments")); | |
6f6fd151 | 325 | |
4120e488 | 326 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour |
6f6fd151 L |
327 | && lang_phdr_list == NULL) |
328 | { | |
329 | /* If we don't have user supplied phdrs, strip zero-sized dynamic | |
330 | sections and regenerate program headers. */ | |
331 | const struct elf_backend_data *bed | |
332 | = get_elf_backend_data (link_info.output_bfd); | |
333 | if (bed->elf_backend_strip_zero_sized_dynamic_sections | |
334 | && !bed->elf_backend_strip_zero_sized_dynamic_sections | |
335 | (&link_info)) | |
336 | einfo (_("%F%P: failed to strip zero-sized dynamic sections")); | |
337 | } | |
d871d478 | 338 | } |
1ff6de03 | 339 | |
094e34f2 | 340 | #ifdef ENABLE_LIBCTF |
1ff6de03 NA |
341 | /* We want to emit CTF early if and only if we are not targetting ELF with this |
342 | invocation. */ | |
343 | ||
344 | int | |
345 | ldelf_emit_ctf_early (void) | |
346 | { | |
347 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) | |
348 | return 0; | |
349 | return 1; | |
350 | } | |
351 | ||
352 | /* Callbacks used to map from bfd types to libctf types, under libctf's | |
353 | control. */ | |
354 | ||
3d16b64e | 355 | struct ctf_strtab_iter_cb_arg |
1ff6de03 | 356 | { |
3d16b64e | 357 | struct elf_strtab_hash *strtab; |
1ff6de03 NA |
358 | size_t next_i; |
359 | size_t next_idx; | |
360 | }; | |
361 | ||
362 | /* Return strings from the strtab to libctf, one by one. Returns NULL when | |
363 | iteration is complete. */ | |
364 | ||
365 | static const char * | |
366 | ldelf_ctf_strtab_iter_cb (uint32_t *offset, void *arg_) | |
367 | { | |
368 | bfd_size_type off; | |
369 | const char *ret; | |
370 | ||
3d16b64e NA |
371 | struct ctf_strtab_iter_cb_arg *arg = |
372 | (struct ctf_strtab_iter_cb_arg *) arg_; | |
1ff6de03 NA |
373 | |
374 | /* There is no zeroth string. */ | |
375 | if (arg->next_i == 0) | |
376 | arg->next_i = 1; | |
377 | ||
211bcd01 NA |
378 | /* Hunt through strings until we fall off the end or find one with |
379 | a nonzero refcount. */ | |
380 | do | |
1ff6de03 | 381 | { |
211bcd01 NA |
382 | if (arg->next_i >= _bfd_elf_strtab_len (arg->strtab)) |
383 | { | |
384 | arg->next_i = 0; | |
385 | return NULL; | |
386 | } | |
387 | ||
388 | ret = _bfd_elf_strtab_str (arg->strtab, arg->next_i++, &off); | |
1ff6de03 | 389 | } |
211bcd01 | 390 | while (ret == NULL); |
1ff6de03 | 391 | |
1ff6de03 NA |
392 | *offset = off; |
393 | ||
394 | /* If we've overflowed, we cannot share any further strings: the CTF | |
395 | format cannot encode strings with such high offsets. */ | |
396 | if (*offset != off) | |
397 | return NULL; | |
398 | ||
399 | return ret; | |
400 | } | |
401 | ||
3d16b64e NA |
402 | void |
403 | ldelf_acquire_strings_for_ctf | |
404 | (struct ctf_dict *ctf_output, struct elf_strtab_hash *strtab) | |
1ff6de03 | 405 | { |
3d16b64e NA |
406 | struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 }; |
407 | if (!ctf_output) | |
408 | return; | |
1ff6de03 | 409 | |
3d16b64e | 410 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) |
1ff6de03 | 411 | { |
3d16b64e NA |
412 | if (ctf_link_add_strtab (ctf_output, ldelf_ctf_strtab_iter_cb, |
413 | &args) < 0) | |
414 | einfo (_("%F%P: warning: CTF strtab association failed; strings will " | |
415 | "not be shared: %s\n"), | |
416 | ctf_errmsg (ctf_errno (ctf_output))); | |
1ff6de03 | 417 | } |
1ff6de03 NA |
418 | } |
419 | ||
420 | void | |
3d16b64e NA |
421 | ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx, |
422 | struct elf_internal_sym *sym) | |
1ff6de03 | 423 | { |
3d16b64e NA |
424 | ctf_link_sym_t lsym; |
425 | ||
426 | if (!ctf_output) | |
1ff6de03 NA |
427 | return; |
428 | ||
3d16b64e NA |
429 | /* New symbol. */ |
430 | if (sym != NULL) | |
1ff6de03 | 431 | { |
3d16b64e NA |
432 | lsym.st_name = NULL; |
433 | lsym.st_nameidx = sym->st_name; | |
434 | lsym.st_nameidx_set = 1; | |
435 | lsym.st_symidx = symidx; | |
436 | lsym.st_shndx = sym->st_shndx; | |
437 | lsym.st_type = ELF_ST_TYPE (sym->st_info); | |
438 | lsym.st_value = sym->st_value; | |
439 | if (ctf_link_add_linker_symbol (ctf_output, &lsym) < 0) | |
440 | { | |
441 | einfo (_("%F%P: warning: CTF symbol addition failed; CTF will " | |
442 | "not be tied to symbols: %s\n"), | |
443 | ctf_errmsg (ctf_errno (ctf_output))); | |
444 | } | |
445 | } | |
446 | else | |
447 | { | |
448 | /* Shuffle all the symbols. */ | |
1ff6de03 | 449 | |
3d16b64e NA |
450 | if (ctf_link_shuffle_syms (ctf_output) < 0) |
451 | einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will " | |
452 | "not be tied to symbols: %s\n"), | |
453 | ctf_errmsg (ctf_errno (ctf_output))); | |
1ff6de03 NA |
454 | } |
455 | } | |
094e34f2 | 456 | #else |
3d16b64e NA |
457 | int |
458 | ldelf_emit_ctf_early (void) | |
094e34f2 NA |
459 | { |
460 | return 0; | |
461 | } | |
462 | ||
3d16b64e NA |
463 | void |
464 | ldelf_acquire_strings_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED, | |
465 | struct elf_strtab_hash *strtab ATTRIBUTE_UNUSED) | |
466 | {} | |
467 | void | |
468 | ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED, | |
469 | int symidx ATTRIBUTE_UNUSED, | |
470 | struct elf_internal_sym *sym ATTRIBUTE_UNUSED) | |
094e34f2 NA |
471 | {} |
472 | #endif |