1 /* x86 specific support for ELF
2 Copyright (C) 2017-2024 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
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 "elfxx-x86.h"
22 #include "elf-vxworks.h"
23 #include "objalloc.h"
24
25 /* The name of the dynamic interpreter. This is put in the .interp
26 section. */
27
28 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
29 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
30 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
31
32 bool
_bfd_x86_elf_mkobject(bfd * abfd)33 _bfd_x86_elf_mkobject (bfd *abfd)
34 {
35 return bfd_elf_allocate_object (abfd,
36 sizeof (struct elf_x86_obj_tdata),
37 get_elf_backend_data (abfd)->target_id);
38 }
39
40 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
41 executables. Rather than setting it to the beginning of the TLS
42 section, we have to set it to the end. This function may be called
43 multiple times, it is idempotent. */
44
45 void
_bfd_x86_elf_set_tls_module_base(struct bfd_link_info * info)46 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
47 {
48 struct elf_x86_link_hash_table *htab;
49 struct bfd_link_hash_entry *base;
50 const struct elf_backend_data *bed;
51
52 if (!bfd_link_executable (info))
53 return;
54
55 bed = get_elf_backend_data (info->output_bfd);
56 htab = elf_x86_hash_table (info, bed->target_id);
57 if (htab == NULL)
58 return;
59
60 base = htab->tls_module_base;
61 if (base == NULL)
62 return;
63
64 base->u.def.value = htab->elf.tls_size;
65 }
66
67 /* Return the base VMA address which should be subtracted from real addresses
68 when resolving @dtpoff relocation.
69 This is PT_TLS segment p_vaddr. */
70
71 bfd_vma
_bfd_x86_elf_dtpoff_base(struct bfd_link_info * info)72 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
73 {
74 /* If tls_sec is NULL, we should have signalled an error already. */
75 if (elf_hash_table (info)->tls_sec == NULL)
76 return 0;
77 return elf_hash_table (info)->tls_sec->vma;
78 }
79
80 /* Allocate space in .plt, .got and associated reloc sections for
81 dynamic relocs. */
82
83 static bool
elf_x86_allocate_dynrelocs(struct elf_link_hash_entry * h,void * inf)84 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
85 {
86 struct bfd_link_info *info;
87 struct elf_x86_link_hash_table *htab;
88 struct elf_x86_link_hash_entry *eh;
89 struct elf_dyn_relocs *p;
90 unsigned int plt_entry_size;
91 bool resolved_to_zero;
92 const struct elf_backend_data *bed;
93
94 if (h->root.type == bfd_link_hash_indirect)
95 return true;
96
97 eh = (struct elf_x86_link_hash_entry *) h;
98
99 info = (struct bfd_link_info *) inf;
100 bed = get_elf_backend_data (info->output_bfd);
101 htab = elf_x86_hash_table (info, bed->target_id);
102 if (htab == NULL)
103 return false;
104
105 plt_entry_size = htab->plt.plt_entry_size;
106
107 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
108
109 /* We can't use the GOT PLT if pointer equality is needed since
110 finish_dynamic_symbol won't clear symbol value and the dynamic
111 linker won't update the GOT slot. We will get into an infinite
112 loop at run-time. */
113 if (htab->plt_got != NULL
114 && h->type != STT_GNU_IFUNC
115 && !h->pointer_equality_needed
116 && h->plt.refcount > 0
117 && h->got.refcount > 0)
118 {
119 /* Don't use the regular PLT if there are both GOT and GOTPLT
120 reloctions. */
121 h->plt.offset = (bfd_vma) -1;
122
123 /* Use the GOT PLT. */
124 eh->plt_got.refcount = 1;
125 }
126
127 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
128 here if it is defined and referenced in a non-shared object. */
129 if (h->type == STT_GNU_IFUNC
130 && h->def_regular)
131 {
132 /* GOTOFF relocation needs PLT. */
133 if (eh->gotoff_ref)
134 h->plt.refcount = 1;
135
136 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &h->dyn_relocs,
137 plt_entry_size,
138 (htab->plt.has_plt0
139 * plt_entry_size),
140 htab->got_entry_size,
141 true))
142 {
143 asection *s = htab->plt_second;
144 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
145 {
146 /* Use the second PLT section if it is created. */
147 eh->plt_second.offset = s->size;
148
149 /* Make room for this entry in the second PLT section. */
150 s->size += htab->non_lazy_plt->plt_entry_size;
151 }
152
153 return true;
154 }
155 else
156 return false;
157 }
158 /* Don't create the PLT entry if there are only function pointer
159 relocations which can be resolved at run-time. */
160 else if (htab->elf.dynamic_sections_created
161 && (h->plt.refcount > 0
162 || eh->plt_got.refcount > 0))
163 {
164 bool use_plt_got = eh->plt_got.refcount > 0;
165
166 /* Make sure this symbol is output as a dynamic symbol.
167 Undefined weak syms won't yet be marked as dynamic. */
168 if (h->dynindx == -1
169 && !h->forced_local
170 && !resolved_to_zero
171 && h->root.type == bfd_link_hash_undefweak)
172 {
173 if (! bfd_elf_link_record_dynamic_symbol (info, h))
174 return false;
175 }
176
177 if (bfd_link_pic (info)
178 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
179 {
180 asection *s = htab->elf.splt;
181 asection *second_s = htab->plt_second;
182 asection *got_s = htab->plt_got;
183 bool use_plt;
184
185 /* If this is the first .plt entry, make room for the special
186 first entry. The .plt section is used by prelink to undo
187 prelinking for dynamic relocations. */
188 if (s->size == 0)
189 s->size = htab->plt.has_plt0 * plt_entry_size;
190
191 if (use_plt_got)
192 eh->plt_got.offset = got_s->size;
193 else
194 {
195 h->plt.offset = s->size;
196 if (second_s)
197 eh->plt_second.offset = second_s->size;
198 }
199
200 /* If this symbol is not defined in a regular file, and we are
201 generating PDE, then set the symbol to this location in the
202 .plt. This is required to make function pointers compare
203 as equal between PDE and the shared library.
204
205 NB: If PLT is PC-relative, we can use the .plt in PIE for
206 function address. */
207 if (h->def_regular)
208 use_plt = false;
209 else if (htab->pcrel_plt)
210 use_plt = ! bfd_link_dll (info);
211 else
212 use_plt = bfd_link_pde (info);
213 if (use_plt)
214 {
215 if (use_plt_got)
216 {
217 /* We need to make a call to the entry of the GOT PLT
218 instead of regular PLT entry. */
219 h->root.u.def.section = got_s;
220 h->root.u.def.value = eh->plt_got.offset;
221 }
222 else
223 {
224 if (second_s)
225 {
226 /* We need to make a call to the entry of the
227 second PLT instead of regular PLT entry. */
228 h->root.u.def.section = second_s;
229 h->root.u.def.value = eh->plt_second.offset;
230 }
231 else
232 {
233 h->root.u.def.section = s;
234 h->root.u.def.value = h->plt.offset;
235 }
236 }
237 }
238
239 /* Make room for this entry. */
240 if (use_plt_got)
241 got_s->size += htab->non_lazy_plt->plt_entry_size;
242 else
243 {
244 s->size += plt_entry_size;
245 if (second_s)
246 second_s->size += htab->non_lazy_plt->plt_entry_size;
247
248 /* We also need to make an entry in the .got.plt section,
249 which will be placed in the .got section by the linker
250 script. */
251 htab->elf.sgotplt->size += htab->got_entry_size;
252
253 /* There should be no PLT relocation against resolved
254 undefined weak symbol in executable. */
255 if (!resolved_to_zero)
256 {
257 /* We also need to make an entry in the .rel.plt
258 section. */
259 htab->elf.srelplt->size += htab->sizeof_reloc;
260 htab->elf.srelplt->reloc_count++;
261 }
262 }
263
264 if (htab->elf.target_os == is_vxworks && !bfd_link_pic (info))
265 {
266 /* VxWorks has a second set of relocations for each PLT entry
267 in executables. They go in a separate relocation section,
268 which is processed by the kernel loader. */
269
270 /* There are two relocations for the initial PLT entry: an
271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
272 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
273
274 asection *srelplt2 = htab->srelplt2;
275 if (h->plt.offset == plt_entry_size)
276 srelplt2->size += (htab->sizeof_reloc * 2);
277
278 /* There are two extra relocations for each subsequent PLT entry:
279 an R_386_32 relocation for the GOT entry, and an R_386_32
280 relocation for the PLT entry. */
281
282 srelplt2->size += (htab->sizeof_reloc * 2);
283 }
284 }
285 else
286 {
287 eh->plt_got.offset = (bfd_vma) -1;
288 h->plt.offset = (bfd_vma) -1;
289 h->needs_plt = 0;
290 }
291 }
292 else
293 {
294 eh->plt_got.offset = (bfd_vma) -1;
295 h->plt.offset = (bfd_vma) -1;
296 h->needs_plt = 0;
297 }
298
299 eh->tlsdesc_got = (bfd_vma) -1;
300
301 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
302 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
303 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
304 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
305 if (h->got.refcount > 0
306 && bfd_link_executable (info)
307 && h->dynindx == -1
308 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
309 h->got.offset = (bfd_vma) -1;
310 else if (h->got.refcount > 0)
311 {
312 asection *s;
313 bool dyn;
314 int tls_type = elf_x86_hash_entry (h)->tls_type;
315
316 /* Make sure this symbol is output as a dynamic symbol.
317 Undefined weak syms won't yet be marked as dynamic. */
318 if (h->dynindx == -1
319 && !h->forced_local
320 && !resolved_to_zero
321 && h->root.type == bfd_link_hash_undefweak)
322 {
323 if (! bfd_elf_link_record_dynamic_symbol (info, h))
324 return false;
325 }
326
327 s = htab->elf.sgot;
328 if (GOT_TLS_GDESC_P (tls_type))
329 {
330 eh->tlsdesc_got = htab->elf.sgotplt->size
331 - elf_x86_compute_jump_table_size (htab);
332 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
333 h->got.offset = (bfd_vma) -2;
334 }
335 if (! GOT_TLS_GDESC_P (tls_type)
336 || GOT_TLS_GD_P (tls_type))
337 {
338 h->got.offset = s->size;
339 s->size += htab->got_entry_size;
340 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
341 slots. */
342 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
343 s->size += htab->got_entry_size;
344 }
345 dyn = htab->elf.dynamic_sections_created;
346 /* R_386_TLS_IE_32 needs one dynamic relocation,
347 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
348 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
349 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
350 symbol and two if global. No dynamic relocation against
351 resolved undefined weak symbol in executable. No dynamic
352 relocation against non-preemptible absolute symbol. */
353 if (tls_type == GOT_TLS_IE_BOTH)
354 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
355 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
356 || (tls_type & GOT_TLS_IE))
357 htab->elf.srelgot->size += htab->sizeof_reloc;
358 else if (GOT_TLS_GD_P (tls_type))
359 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
360 else if (! GOT_TLS_GDESC_P (tls_type)
361 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
362 && !resolved_to_zero)
363 || h->root.type != bfd_link_hash_undefweak)
364 && ((bfd_link_pic (info)
365 && !(h->dynindx == -1
366 && ABS_SYMBOL_P (h)))
367 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
368 htab->elf.srelgot->size += htab->sizeof_reloc;
369 if (GOT_TLS_GDESC_P (tls_type))
370 {
371 htab->elf.srelplt->size += htab->sizeof_reloc;
372 if (bed->target_id == X86_64_ELF_DATA)
373 htab->elf.tlsdesc_plt = (bfd_vma) -1;
374 }
375 }
376 else
377 h->got.offset = (bfd_vma) -1;
378
379 if (h->dyn_relocs == NULL)
380 return true;
381
382 /* In the shared -Bsymbolic case, discard space allocated for
383 dynamic pc-relative relocs against symbols which turn out to be
384 defined in regular objects. For the normal shared case, discard
385 space for pc-relative relocs that have become local due to symbol
386 visibility changes. */
387
388 if (bfd_link_pic (info))
389 {
390 /* Relocs that use pc_count are those that appear on a call
391 insn, or certain REL relocs that can generated via assembly.
392 We want calls to protected symbols to resolve directly to the
393 function rather than going via the plt. If people want
394 function pointer comparisons to work as expected then they
395 should avoid writing weird assembly. */
396 if (SYMBOL_CALLS_LOCAL (info, h))
397 {
398 struct elf_dyn_relocs **pp;
399
400 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
401 {
402 p->count -= p->pc_count;
403 p->pc_count = 0;
404 if (p->count == 0)
405 *pp = p->next;
406 else
407 pp = &p->next;
408 }
409 }
410
411 if (htab->elf.target_os == is_vxworks)
412 {
413 struct elf_dyn_relocs **pp;
414 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
415 {
416 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
417 *pp = p->next;
418 else
419 pp = &p->next;
420 }
421 }
422
423 /* Also discard relocs on undefined weak syms with non-default
424 visibility or in PIE. */
425 if (h->dyn_relocs != NULL)
426 {
427 if (h->root.type == bfd_link_hash_undefweak)
428 {
429 /* Undefined weak symbol is never bound locally in shared
430 library. */
431 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
432 || resolved_to_zero)
433 {
434 if (bed->target_id == I386_ELF_DATA
435 && h->non_got_ref)
436 {
437 /* Keep dynamic non-GOT/non-PLT relocation so
438 that we can branch to 0 without PLT. */
439 struct elf_dyn_relocs **pp;
440
441 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
442 if (p->pc_count == 0)
443 *pp = p->next;
444 else
445 {
446 /* Remove non-R_386_PC32 relocation. */
447 p->count = p->pc_count;
448 pp = &p->next;
449 }
450
451 /* Make sure undefined weak symbols are output
452 as dynamic symbols in PIEs for dynamic non-GOT
453 non-PLT reloations. */
454 if (h->dyn_relocs != NULL
455 && !bfd_elf_link_record_dynamic_symbol (info, h))
456 return false;
457 }
458 else
459 h->dyn_relocs = NULL;
460 }
461 else if (h->dynindx == -1
462 && !h->forced_local
463 && !bfd_elf_link_record_dynamic_symbol (info, h))
464 return false;
465 }
466 else if (bfd_link_executable (info)
467 && (h->needs_copy || eh->needs_copy)
468 && h->def_dynamic
469 && !h->def_regular)
470 {
471 /* NB: needs_copy is set only for x86-64. For PIE,
472 discard space for pc-relative relocs against symbols
473 which turn out to need copy relocs. */
474 struct elf_dyn_relocs **pp;
475
476 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
477 {
478 if (p->pc_count != 0)
479 *pp = p->next;
480 else
481 pp = &p->next;
482 }
483 }
484 }
485 }
486 else if (ELIMINATE_COPY_RELOCS)
487 {
488 /* For the non-shared case, discard space for relocs against
489 symbols which turn out to need copy relocs or are not
490 dynamic. Keep dynamic relocations for run-time function
491 pointer initialization. */
492
493 if ((!h->non_got_ref
494 || (h->root.type == bfd_link_hash_undefweak
495 && !resolved_to_zero))
496 && ((h->def_dynamic
497 && !h->def_regular)
498 || (htab->elf.dynamic_sections_created
499 && (h->root.type == bfd_link_hash_undefweak
500 || h->root.type == bfd_link_hash_undefined))))
501 {
502 /* Make sure this symbol is output as a dynamic symbol.
503 Undefined weak syms won't yet be marked as dynamic. */
504 if (h->dynindx == -1
505 && !h->forced_local
506 && !resolved_to_zero
507 && h->root.type == bfd_link_hash_undefweak
508 && ! bfd_elf_link_record_dynamic_symbol (info, h))
509 return false;
510
511 /* If that succeeded, we know we'll be keeping all the
512 relocs. */
513 if (h->dynindx != -1)
514 goto keep;
515 }
516
517 h->dyn_relocs = NULL;
518
519 keep: ;
520 }
521
522 /* Finally, allocate space. */
523 for (p = h->dyn_relocs; p != NULL; p = p->next)
524 {
525 asection *sreloc;
526
527 if (eh->def_protected && bfd_link_executable (info))
528 {
529 /* Disallow copy relocation against non-copyable protected
530 symbol. */
531 asection *s = p->sec->output_section;
532 if (s != NULL && (s->flags & SEC_READONLY) != 0)
533 {
534 info->callbacks->einfo
535 /* xgettext:c-format */
536 (_("%F%P: %pB: copy relocation against non-copyable "
537 "protected symbol `%s' in %pB\n"),
538 p->sec->owner, h->root.root.string,
539 h->root.u.def.section->owner);
540 return false;
541 }
542 }
543
544 sreloc = elf_section_data (p->sec)->sreloc;
545
546 BFD_ASSERT (sreloc != NULL);
547 sreloc->size += p->count * htab->sizeof_reloc;
548 }
549
550 return true;
551 }
552
553 /* Allocate space in .plt, .got and associated reloc sections for
554 local dynamic relocs. */
555
556 static int
elf_x86_allocate_local_dynreloc(void ** slot,void * inf)557 elf_x86_allocate_local_dynreloc (void **slot, void *inf)
558 {
559 struct elf_link_hash_entry *h
560 = (struct elf_link_hash_entry *) *slot;
561
562 if (h->type != STT_GNU_IFUNC
563 || !h->def_regular
564 || !h->ref_regular
565 || !h->forced_local
566 || h->root.type != bfd_link_hash_defined)
567 abort ();
568
569 return elf_x86_allocate_dynrelocs (h, inf);
570 }
571
572 /* Find and/or create a hash entry for local symbol. */
573
574 struct elf_link_hash_entry *
_bfd_elf_x86_get_local_sym_hash(struct elf_x86_link_hash_table * htab,bfd * abfd,const Elf_Internal_Rela * rel,bool create)575 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
576 bfd *abfd, const Elf_Internal_Rela *rel,
577 bool create)
578 {
579 struct elf_x86_link_hash_entry e, *ret;
580 asection *sec = abfd->sections;
581 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
582 htab->r_sym (rel->r_info));
583 void **slot;
584
585 e.elf.indx = sec->id;
586 e.elf.dynstr_index = htab->r_sym (rel->r_info);
587 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
588 create ? INSERT : NO_INSERT);
589
590 if (!slot)
591 return NULL;
592
593 if (*slot)
594 {
595 ret = (struct elf_x86_link_hash_entry *) *slot;
596 return &ret->elf;
597 }
598
599 ret = (struct elf_x86_link_hash_entry *)
600 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
601 sizeof (struct elf_x86_link_hash_entry));
602 if (ret)
603 {
604 memset (ret, 0, sizeof (*ret));
605 ret->elf.indx = sec->id;
606 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
607 ret->elf.dynindx = -1;
608 ret->plt_got.offset = (bfd_vma) -1;
609 *slot = ret;
610 }
611 return &ret->elf;
612 }
613
614 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
615 SYNC WITH _bfd_elf_link_hash_newfunc. */
616
617 struct bfd_hash_entry *
_bfd_x86_elf_link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)618 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
619 struct bfd_hash_table *table,
620 const char *string)
621 {
622 /* Allocate the structure if it has not already been allocated by a
623 subclass. */
624 if (entry == NULL)
625 {
626 entry = (struct bfd_hash_entry *)
627 bfd_hash_allocate (table,
628 sizeof (struct elf_x86_link_hash_entry));
629 if (entry == NULL)
630 return entry;
631 }
632
633 /* Call the allocation method of the superclass. */
634 entry = _bfd_link_hash_newfunc (entry, table, string);
635 if (entry != NULL)
636 {
637 struct elf_x86_link_hash_entry *eh
638 = (struct elf_x86_link_hash_entry *) entry;
639 struct elf_link_hash_table *htab
640 = (struct elf_link_hash_table *) table;
641
642 memset (&eh->elf.size, 0,
643 (sizeof (struct elf_x86_link_hash_entry)
644 - offsetof (struct elf_link_hash_entry, size)));
645 /* Set local fields. */
646 eh->elf.indx = -1;
647 eh->elf.dynindx = -1;
648 eh->elf.got = htab->init_got_refcount;
649 eh->elf.plt = htab->init_plt_refcount;
650 /* Assume that we have been called by a non-ELF symbol reader.
651 This flag is then reset by the code which reads an ELF input
652 file. This ensures that a symbol created by a non-ELF symbol
653 reader will have the flag set correctly. */
654 eh->elf.non_elf = 1;
655 eh->plt_second.offset = (bfd_vma) -1;
656 eh->plt_got.offset = (bfd_vma) -1;
657 eh->tlsdesc_got = (bfd_vma) -1;
658 eh->zero_undefweak = 1;
659 }
660
661 return entry;
662 }
663
664 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
665 for local symbol so that we can handle local STT_GNU_IFUNC symbols
666 as global symbol. We reuse indx and dynstr_index for local symbol
667 hash since they aren't used by global symbols in this backend. */
668
669 hashval_t
_bfd_x86_elf_local_htab_hash(const void * ptr)670 _bfd_x86_elf_local_htab_hash (const void *ptr)
671 {
672 struct elf_link_hash_entry *h
673 = (struct elf_link_hash_entry *) ptr;
674 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
675 }
676
677 /* Compare local hash entries. */
678
679 int
_bfd_x86_elf_local_htab_eq(const void * ptr1,const void * ptr2)680 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
681 {
682 struct elf_link_hash_entry *h1
683 = (struct elf_link_hash_entry *) ptr1;
684 struct elf_link_hash_entry *h2
685 = (struct elf_link_hash_entry *) ptr2;
686
687 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
688 }
689
690 /* Destroy an x86 ELF linker hash table. */
691
692 static void
elf_x86_link_hash_table_free(bfd * obfd)693 elf_x86_link_hash_table_free (bfd *obfd)
694 {
695 struct elf_x86_link_hash_table *htab
696 = (struct elf_x86_link_hash_table *) obfd->link.hash;
697
698 if (htab->loc_hash_table)
699 htab_delete (htab->loc_hash_table);
700 if (htab->loc_hash_memory)
701 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
702 _bfd_elf_link_hash_table_free (obfd);
703 }
704
705 static bool
elf_i386_is_reloc_section(const char * secname)706 elf_i386_is_reloc_section (const char *secname)
707 {
708 return startswith (secname, ".rel");
709 }
710
711 static bool
elf_x86_64_is_reloc_section(const char * secname)712 elf_x86_64_is_reloc_section (const char *secname)
713 {
714 return startswith (secname, ".rela");
715 }
716
717 /* Create an x86 ELF linker hash table. */
718
719 struct bfd_link_hash_table *
_bfd_x86_elf_link_hash_table_create(bfd * abfd)720 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
721 {
722 struct elf_x86_link_hash_table *ret;
723 const struct elf_backend_data *bed;
724 size_t amt = sizeof (struct elf_x86_link_hash_table);
725
726 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
727 if (ret == NULL)
728 return NULL;
729
730 bed = get_elf_backend_data (abfd);
731 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
732 _bfd_x86_elf_link_hash_newfunc,
733 sizeof (struct elf_x86_link_hash_entry),
734 bed->target_id))
735 {
736 free (ret);
737 return NULL;
738 }
739
740 if (bed->target_id == X86_64_ELF_DATA)
741 {
742 ret->is_reloc_section = elf_x86_64_is_reloc_section;
743 ret->got_entry_size = 8;
744 ret->pcrel_plt = true;
745 ret->tls_get_addr = "__tls_get_addr";
746 ret->relative_r_type = R_X86_64_RELATIVE;
747 ret->relative_r_name = "R_X86_64_RELATIVE";
748 ret->elf_append_reloc = elf_append_rela;
749 ret->elf_write_addend_in_got = _bfd_elf64_write_addend;
750 }
751 if (ABI_64_P (abfd))
752 {
753 ret->sizeof_reloc = sizeof (Elf64_External_Rela);
754 ret->pointer_r_type = R_X86_64_64;
755 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
756 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
757 ret->elf_write_addend = _bfd_elf64_write_addend;
758 }
759 else
760 {
761 if (bed->target_id == X86_64_ELF_DATA)
762 {
763 ret->sizeof_reloc = sizeof (Elf32_External_Rela);
764 ret->pointer_r_type = R_X86_64_32;
765 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
766 ret->dynamic_interpreter_size
767 = sizeof ELFX32_DYNAMIC_INTERPRETER;
768 ret->elf_write_addend = _bfd_elf32_write_addend;
769 }
770 else
771 {
772 ret->is_reloc_section = elf_i386_is_reloc_section;
773 ret->sizeof_reloc = sizeof (Elf32_External_Rel);
774 ret->got_entry_size = 4;
775 ret->pcrel_plt = false;
776 ret->pointer_r_type = R_386_32;
777 ret->relative_r_type = R_386_RELATIVE;
778 ret->relative_r_name = "R_386_RELATIVE";
779 ret->elf_append_reloc = elf_append_rel;
780 ret->elf_write_addend = _bfd_elf32_write_addend;
781 ret->elf_write_addend_in_got = _bfd_elf32_write_addend;
782 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
783 ret->dynamic_interpreter_size
784 = sizeof ELF32_DYNAMIC_INTERPRETER;
785 ret->tls_get_addr = "___tls_get_addr";
786 }
787 }
788
789 ret->loc_hash_table = htab_try_create (1024,
790 _bfd_x86_elf_local_htab_hash,
791 _bfd_x86_elf_local_htab_eq,
792 NULL);
793 ret->loc_hash_memory = objalloc_create ();
794 if (!ret->loc_hash_table || !ret->loc_hash_memory)
795 {
796 elf_x86_link_hash_table_free (abfd);
797 return NULL;
798 }
799 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
800
801 return &ret->elf.root;
802 }
803
804 /* Sort relocs into address order. */
805
806 int
_bfd_x86_elf_compare_relocs(const void * ap,const void * bp)807 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
808 {
809 const arelent *a = * (const arelent **) ap;
810 const arelent *b = * (const arelent **) bp;
811
812 if (a->address > b->address)
813 return 1;
814 else if (a->address < b->address)
815 return -1;
816 else
817 return 0;
818 }
819
820 /* Mark symbol, NAME, as locally defined by linker if it is referenced
821 and not defined in a relocatable object file. */
822
823 static void
elf_x86_linker_defined(struct bfd_link_info * info,const char * name)824 elf_x86_linker_defined (struct bfd_link_info *info, const char *name)
825 {
826 struct elf_link_hash_entry *h;
827
828 h = elf_link_hash_lookup (elf_hash_table (info), name,
829 false, false, false);
830 if (h == NULL)
831 return;
832
833 while (h->root.type == bfd_link_hash_indirect)
834 h = (struct elf_link_hash_entry *) h->root.u.i.link;
835
836 if (h->root.type == bfd_link_hash_new
837 || h->root.type == bfd_link_hash_undefined
838 || h->root.type == bfd_link_hash_undefweak
839 || h->root.type == bfd_link_hash_common
840 || (!h->def_regular && h->def_dynamic))
841 {
842 elf_x86_hash_entry (h)->local_ref = 2;
843 elf_x86_hash_entry (h)->linker_def = 1;
844 }
845 }
846
847 /* Hide a linker-defined symbol, NAME, with hidden visibility. */
848
849 static void
elf_x86_hide_linker_defined(struct bfd_link_info * info,const char * name)850 elf_x86_hide_linker_defined (struct bfd_link_info *info,
851 const char *name)
852 {
853 struct elf_link_hash_entry *h;
854
855 h = elf_link_hash_lookup (elf_hash_table (info), name,
856 false, false, false);
857 if (h == NULL)
858 return;
859
860 while (h->root.type == bfd_link_hash_indirect)
861 h = (struct elf_link_hash_entry *) h->root.u.i.link;
862
863 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
864 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
865 _bfd_elf_link_hash_hide_symbol (info, h, true);
866 }
867
868 bool
_bfd_x86_elf_link_check_relocs(bfd * abfd,struct bfd_link_info * info)869 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
870 {
871 if (!bfd_link_relocatable (info))
872 {
873 /* Check for __tls_get_addr reference. */
874 struct elf_x86_link_hash_table *htab;
875 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
876 htab = elf_x86_hash_table (info, bed->target_id);
877 if (htab)
878 {
879 struct elf_link_hash_entry *h;
880
881 h = elf_link_hash_lookup (elf_hash_table (info),
882 htab->tls_get_addr,
883 false, false, false);
884 if (h != NULL)
885 {
886 elf_x86_hash_entry (h)->tls_get_addr = 1;
887
888 /* Check the versioned __tls_get_addr symbol. */
889 while (h->root.type == bfd_link_hash_indirect)
890 {
891 h = (struct elf_link_hash_entry *) h->root.u.i.link;
892 elf_x86_hash_entry (h)->tls_get_addr = 1;
893 }
894 }
895
896 /* "__ehdr_start" will be defined by linker as a hidden symbol
897 later if it is referenced and not defined. */
898 elf_x86_linker_defined (info, "__ehdr_start");
899
900 if (bfd_link_executable (info))
901 {
902 /* References to __bss_start, _end and _edata should be
903 locally resolved within executables. */
904 elf_x86_linker_defined (info, "__bss_start");
905 elf_x86_linker_defined (info, "_end");
906 elf_x86_linker_defined (info, "_edata");
907 }
908 else
909 {
910 /* Hide hidden __bss_start, _end and _edata in shared
911 libraries. */
912 elf_x86_hide_linker_defined (info, "__bss_start");
913 elf_x86_hide_linker_defined (info, "_end");
914 elf_x86_hide_linker_defined (info, "_edata");
915 }
916 }
917 }
918
919 /* Invoke the regular ELF backend linker to do all the work. */
920 return _bfd_elf_link_check_relocs (abfd, info);
921 }
922
923 /* Look through the relocs for a section before allocation to make the
924 dynamic reloc section. */
925
926 bool
_bfd_x86_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)927 _bfd_x86_elf_check_relocs (bfd *abfd,
928 struct bfd_link_info *info,
929 asection *sec,
930 const Elf_Internal_Rela *relocs)
931 {
932 struct elf_x86_link_hash_table *htab;
933 Elf_Internal_Shdr *symtab_hdr;
934 struct elf_link_hash_entry **sym_hashes;
935 const Elf_Internal_Rela *rel;
936 const Elf_Internal_Rela *rel_end;
937 asection *sreloc;
938 const struct elf_backend_data *bed;
939 bool is_x86_64;
940
941 if (bfd_link_relocatable (info))
942 return true;
943
944 bed = get_elf_backend_data (abfd);
945 htab = elf_x86_hash_table (info, bed->target_id);
946 if (htab == NULL)
947 {
948 sec->check_relocs_failed = 1;
949 return false;
950 }
951
952 is_x86_64 = bed->target_id == X86_64_ELF_DATA;
953
954 symtab_hdr = &elf_symtab_hdr (abfd);
955 sym_hashes = elf_sym_hashes (abfd);
956
957 rel_end = relocs + sec->reloc_count;
958 for (rel = relocs; rel < rel_end; rel++)
959 {
960 unsigned int r_type;
961 unsigned int r_symndx;
962 struct elf_link_hash_entry *h;
963
964 r_symndx = htab->r_sym (rel->r_info);
965 r_type = ELF32_R_TYPE (rel->r_info);
966
967 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
968 {
969 /* xgettext:c-format */
970 _bfd_error_handler (_("%pB: bad symbol index: %d"),
971 abfd, r_symndx);
972 goto error_return;
973 }
974
975 if (r_symndx < symtab_hdr->sh_info)
976 h = NULL;
977 else
978 {
979 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
980 while (h->root.type == bfd_link_hash_indirect
981 || h->root.type == bfd_link_hash_warning)
982 h = (struct elf_link_hash_entry *) h->root.u.i.link;
983 }
984
985 if (X86_NEED_DYNAMIC_RELOC_TYPE_P (is_x86_64, r_type)
986 && NEED_DYNAMIC_RELOCATION_P (is_x86_64, info, true, h, sec,
987 r_type, htab->pointer_r_type))
988 {
989 /* We may copy these reloc types into the output file.
990 Create a reloc section in dynobj and make room for
991 this reloc. */
992 sreloc = _bfd_elf_make_dynamic_reloc_section
993 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
994 abfd, sec->use_rela_p);
995
996 if (sreloc != NULL)
997 return true;
998
999 error_return:
1000 sec->check_relocs_failed = 1;
1001 return false;
1002 }
1003 }
1004
1005 return true;
1006 }
1007
1008 /* Add an entry to the relative reloc record. */
1009
1010 static bool
elf_x86_relative_reloc_record_add(struct bfd_link_info * info,struct elf_x86_relative_reloc_data * relative_reloc,Elf_Internal_Rela * rel,asection * sec,asection * sym_sec,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym,bfd_vma offset,bool * keep_symbuf_p)1011 elf_x86_relative_reloc_record_add
1012 (struct bfd_link_info *info,
1013 struct elf_x86_relative_reloc_data *relative_reloc,
1014 Elf_Internal_Rela *rel, asection *sec,
1015 asection *sym_sec, struct elf_link_hash_entry *h,
1016 Elf_Internal_Sym *sym, bfd_vma offset, bool *keep_symbuf_p)
1017 {
1018 bfd_size_type newidx;
1019
1020 if (relative_reloc->data == NULL)
1021 {
1022 relative_reloc->data = bfd_malloc
1023 (sizeof (struct elf_x86_relative_reloc_record));
1024 relative_reloc->count = 0;
1025 relative_reloc->size = 1;
1026 }
1027
1028 newidx = relative_reloc->count++;
1029
1030 if (relative_reloc->count > relative_reloc->size)
1031 {
1032 relative_reloc->size <<= 1;
1033 relative_reloc->data = bfd_realloc
1034 (relative_reloc->data,
1035 (relative_reloc->size
1036 * sizeof (struct elf_x86_relative_reloc_record)));
1037 }
1038
1039 if (relative_reloc->data == NULL)
1040 {
1041 info->callbacks->einfo
1042 /* xgettext:c-format */
1043 (_("%F%P: %pB: failed to allocate relative reloc record\n"),
1044 info->output_bfd);
1045 return false;
1046 }
1047
1048 relative_reloc->data[newidx].rel = *rel;
1049 relative_reloc->data[newidx].sec = sec;
1050 if (h != NULL)
1051 {
1052 /* Set SYM to NULL to indicate a global symbol. */
1053 relative_reloc->data[newidx].sym = NULL;
1054 relative_reloc->data[newidx].u.h = h;
1055 }
1056 else
1057 {
1058 relative_reloc->data[newidx].sym = sym;
1059 relative_reloc->data[newidx].u.sym_sec = sym_sec;
1060 /* We must keep the symbol buffer since SYM will be used later. */
1061 *keep_symbuf_p = true;
1062 }
1063 relative_reloc->data[newidx].offset = offset;
1064 relative_reloc->data[newidx].address = 0;
1065 return true;
1066 }
1067
1068 /* After input sections have been mapped to output sections and
1069 addresses of output sections are set initiallly, scan input
1070 relocations with the same logic in relocate_section to determine
1071 if a relative relocation should be generated. Save the relative
1072 relocation candidate information for sizing the DT_RELR section
1073 later after all symbols addresses can be determined. */
1074
1075 bool
_bfd_x86_elf_link_relax_section(bfd * abfd ATTRIBUTE_UNUSED,asection * input_section,struct bfd_link_info * info,bool * again)1076 _bfd_x86_elf_link_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
1077 asection *input_section,
1078 struct bfd_link_info *info,
1079 bool *again)
1080 {
1081 Elf_Internal_Shdr *symtab_hdr;
1082 Elf_Internal_Rela *internal_relocs;
1083 Elf_Internal_Rela *irel, *irelend;
1084 Elf_Internal_Sym *isymbuf = NULL;
1085 struct elf_link_hash_entry **sym_hashes;
1086 const struct elf_backend_data *bed;
1087 struct elf_x86_link_hash_table *htab;
1088 bfd_vma *local_got_offsets;
1089 bool is_x86_64;
1090 bool unaligned_section;
1091 bool return_status = false;
1092 bool keep_symbuf = false;
1093
1094 if (bfd_link_relocatable (info))
1095 return true;
1096
1097 /* Assume we're not going to change any sizes, and we'll only need
1098 one pass. */
1099 *again = false;
1100
1101 bed = get_elf_backend_data (abfd);
1102 htab = elf_x86_hash_table (info, bed->target_id);
1103 if (htab == NULL)
1104 return true;
1105
1106 /* Nothing to do if there are no relocations or relative relocations
1107 have been packed. */
1108 if (input_section == htab->elf.srelrdyn
1109 || input_section->relative_reloc_packed
1110 || ((input_section->flags & (SEC_RELOC | SEC_ALLOC))
1111 != (SEC_RELOC | SEC_ALLOC))
1112 || (input_section->flags & SEC_DEBUGGING) != 0
1113 || input_section->reloc_count == 0)
1114 return true;
1115
1116 /* Skip if the section isn't aligned. */
1117 unaligned_section = input_section->alignment_power == 0;
1118
1119 is_x86_64 = bed->target_id == X86_64_ELF_DATA;
1120
1121 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1122 sym_hashes = elf_sym_hashes (abfd);
1123 local_got_offsets = elf_local_got_offsets (abfd);
1124
1125 /* Load the relocations for this section. */
1126 internal_relocs =
1127 _bfd_elf_link_info_read_relocs (abfd, info, input_section, NULL,
1128 (Elf_Internal_Rela *) NULL,
1129 info->keep_memory);
1130 if (internal_relocs == NULL)
1131 return false;
1132
1133 irelend = internal_relocs + input_section->reloc_count;
1134 for (irel = internal_relocs; irel < irelend; irel++)
1135 {
1136 unsigned int r_type;
1137 unsigned int r_symndx;
1138 Elf_Internal_Sym *isym;
1139 struct elf_link_hash_entry *h;
1140 struct elf_x86_link_hash_entry *eh;
1141 bfd_vma offset;
1142 bool resolved_to_zero;
1143 bool need_copy_reloc_in_pie;
1144 bool pc32_reloc;
1145 asection *sec;
1146 /* Offset must be a multiple of 2. */
1147 bool unaligned_offset = (irel->r_offset & 1) != 0;
1148 /* True if there is a relative relocation against a dynamic
1149 symbol. */
1150 bool dynamic_relative_reloc_p;
1151
1152 /* Get the value of the symbol referred to by the reloc. */
1153 r_symndx = htab->r_sym (irel->r_info);
1154
1155 r_type = ELF32_R_TYPE (irel->r_info);
1156 /* Clear the R_X86_64_converted_reloc_bit bit. */
1157 r_type &= ~R_X86_64_converted_reloc_bit;
1158
1159 sec = NULL;
1160 h = NULL;
1161 dynamic_relative_reloc_p = false;
1162
1163 if (r_symndx < symtab_hdr->sh_info)
1164 {
1165 /* Read this BFD's local symbols. */
1166 if (isymbuf == NULL)
1167 {
1168 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1169 if (isymbuf == NULL)
1170 {
1171 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1172 symtab_hdr->sh_info,
1173 0, NULL, NULL, NULL);
1174 if (isymbuf == NULL)
1175 goto error_return;
1176 }
1177 }
1178
1179 isym = isymbuf + r_symndx;
1180 switch (isym->st_shndx)
1181 {
1182 case SHN_ABS:
1183 sec = bfd_abs_section_ptr;
1184 break;
1185 case SHN_COMMON:
1186 sec = bfd_com_section_ptr;
1187 break;
1188 case SHN_X86_64_LCOMMON:
1189 if (!is_x86_64)
1190 abort ();
1191 sec = &_bfd_elf_large_com_section;
1192 break;
1193 default:
1194 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1195 break;
1196 }
1197
1198 /* Skip relocation against local STT_GNU_IFUNC symbol. */
1199 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1200 continue;
1201
1202 eh = (struct elf_x86_link_hash_entry *) h;
1203 resolved_to_zero = false;
1204 }
1205 else
1206 {
1207 /* Get H and SEC for GENERATE_DYNAMIC_RELOCATION_P below. */
1208 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1209 while (h->root.type == bfd_link_hash_indirect
1210 || h->root.type == bfd_link_hash_warning)
1211 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1212
1213 if (h->root.type == bfd_link_hash_defined
1214 || h->root.type == bfd_link_hash_defweak)
1215 sec = h->root.u.def.section;
1216
1217 /* Skip relocation against STT_GNU_IFUNC symbol. */
1218 if (h->type == STT_GNU_IFUNC)
1219 continue;
1220
1221 eh = (struct elf_x86_link_hash_entry *) h;
1222 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
1223
1224 /* NB: See how elf_backend_finish_dynamic_symbol is called
1225 from elf_link_output_extsym. */
1226 if ((h->dynindx != -1 || h->forced_local)
1227 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1228 || h->root.type != bfd_link_hash_undefweak)
1229 || !h->forced_local)
1230 && h->got.offset != (bfd_vma) -1
1231 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h)->tls_type)
1232 && elf_x86_hash_entry (h)->tls_type != GOT_TLS_IE
1233 && !resolved_to_zero
1234 && SYMBOL_REFERENCES_LOCAL_P (info, h)
1235 && SYMBOL_DEFINED_NON_SHARED_P (h))
1236 dynamic_relative_reloc_p = true;
1237
1238 isym = NULL;
1239 }
1240
1241 if (X86_GOT_TYPE_P (is_x86_64, r_type))
1242 {
1243 /* Pack GOT relative relocations. There should be only a
1244 single R_*_RELATIVE relocation in GOT. */
1245 if (eh != NULL)
1246 {
1247 if (eh->got_relative_reloc_done)
1248 continue;
1249
1250 if (!(dynamic_relative_reloc_p
1251 || (RESOLVED_LOCALLY_P (info, h, htab)
1252 && GENERATE_RELATIVE_RELOC_P (info, h))))
1253 continue;
1254
1255 if (!dynamic_relative_reloc_p)
1256 eh->no_finish_dynamic_symbol = 1;
1257 eh->got_relative_reloc_done = 1;
1258 offset = h->got.offset;
1259 }
1260 else
1261 {
1262 if (elf_x86_relative_reloc_done (abfd)[r_symndx])
1263 continue;
1264
1265 if (!X86_LOCAL_GOT_RELATIVE_RELOC_P (is_x86_64, info,
1266 isym))
1267 continue;
1268
1269 elf_x86_relative_reloc_done (abfd)[r_symndx] = 1;
1270 offset = local_got_offsets[r_symndx];
1271 }
1272
1273 if (!elf_x86_relative_reloc_record_add (info,
1274 &htab->relative_reloc,
1275 irel, htab->elf.sgot,
1276 sec, h, isym, offset,
1277 &keep_symbuf))
1278 goto error_return;
1279
1280 continue;
1281 }
1282
1283 if (is_x86_64
1284 && irel->r_addend == 0
1285 && !ABI_64_P (info->output_bfd))
1286 {
1287 /* For x32, if addend is zero, treat R_X86_64_64 like
1288 R_X86_64_32 and R_X86_64_SIZE64 like R_X86_64_SIZE32. */
1289 if (r_type == R_X86_64_64)
1290 r_type = R_X86_64_32;
1291 else if (r_type == R_X86_64_SIZE64)
1292 r_type = R_X86_64_SIZE32;
1293 }
1294
1295 if (!X86_RELATIVE_RELOC_TYPE_P (is_x86_64, r_type))
1296 continue;
1297
1298 /* Pack non-GOT relative relocations. */
1299 if (is_x86_64)
1300 {
1301 need_copy_reloc_in_pie =
1302 (bfd_link_pie (info)
1303 && h != NULL
1304 && (h->needs_copy
1305 || eh->needs_copy
1306 || (h->root.type == bfd_link_hash_undefined))
1307 && (X86_PCREL_TYPE_P (true, r_type)
1308 || X86_SIZE_TYPE_P (true, r_type)));
1309 pc32_reloc = false;
1310 }
1311 else
1312 {
1313 need_copy_reloc_in_pie = false;
1314 pc32_reloc = r_type == R_386_PC32;
1315 }
1316
1317 if (GENERATE_DYNAMIC_RELOCATION_P (is_x86_64, info, eh, r_type,
1318 sec, need_copy_reloc_in_pie,
1319 resolved_to_zero, pc32_reloc))
1320 {
1321 /* When generating a shared object, these relocations
1322 are copied into the output file to be resolved at run
1323 time. */
1324 offset = _bfd_elf_section_offset (info->output_bfd, info,
1325 input_section,
1326 irel->r_offset);
1327 if (offset == (bfd_vma) -1
1328 || offset == (bfd_vma) -2
1329 || COPY_INPUT_RELOC_P (is_x86_64, info, h, r_type))
1330 continue;
1331
1332 /* This symbol is local, or marked to become local. When
1333 relocation overflow check is disabled, we convert
1334 R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
1335 if (is_x86_64
1336 && !(r_type == htab->pointer_r_type
1337 || (r_type == R_X86_64_32
1338 && htab->params->no_reloc_overflow_check)))
1339 continue;
1340
1341 if (!elf_x86_relative_reloc_record_add
1342 (info,
1343 ((unaligned_section || unaligned_offset)
1344 ? &htab->unaligned_relative_reloc
1345 : &htab->relative_reloc),
1346 irel, input_section, sec, h, isym, offset,
1347 &keep_symbuf))
1348 goto error_return;
1349 }
1350 }
1351
1352 input_section->relative_reloc_packed = 1;
1353
1354 return_status = true;
1355
1356 error_return:
1357 if ((unsigned char *) isymbuf != symtab_hdr->contents)
1358 {
1359 /* Cache the symbol buffer if it must be kept. */
1360 if (keep_symbuf)
1361 symtab_hdr->contents = (unsigned char *) isymbuf;
1362 else
1363 free (isymbuf);
1364 }
1365 if (elf_section_data (input_section)->relocs != internal_relocs)
1366 free (internal_relocs);
1367 return return_status;
1368 }
1369
1370 /* Add an entry to the 64-bit DT_RELR bitmap. */
1371
1372 static void
elf64_dt_relr_bitmap_add(struct bfd_link_info * info,struct elf_dt_relr_bitmap * bitmap,uint64_t entry)1373 elf64_dt_relr_bitmap_add
1374 (struct bfd_link_info *info, struct elf_dt_relr_bitmap *bitmap,
1375 uint64_t entry)
1376 {
1377 bfd_size_type newidx;
1378
1379 if (bitmap->u.elf64 == NULL)
1380 {
1381 bitmap->u.elf64 = bfd_malloc (sizeof (uint64_t));
1382 bitmap->count = 0;
1383 bitmap->size = 1;
1384 }
1385
1386 newidx = bitmap->count++;
1387
1388 if (bitmap->count > bitmap->size)
1389 {
1390 bitmap->size <<= 1;
1391 bitmap->u.elf64 = bfd_realloc (bitmap->u.elf64,
1392 (bitmap->size * sizeof (uint64_t)));
1393 }
1394
1395 if (bitmap->u.elf64 == NULL)
1396 {
1397 info->callbacks->einfo
1398 /* xgettext:c-format */
1399 (_("%F%P: %pB: failed to allocate 64-bit DT_RELR bitmap\n"),
1400 info->output_bfd);
1401 }
1402
1403 bitmap->u.elf64[newidx] = entry;
1404 }
1405
1406 /* Add an entry to the 32-bit DT_RELR bitmap. */
1407
1408 static void
elf32_dt_relr_bitmap_add(struct bfd_link_info * info,struct elf_dt_relr_bitmap * bitmap,uint32_t entry)1409 elf32_dt_relr_bitmap_add
1410 (struct bfd_link_info *info, struct elf_dt_relr_bitmap *bitmap,
1411 uint32_t entry)
1412 {
1413 bfd_size_type newidx;
1414
1415 if (bitmap->u.elf32 == NULL)
1416 {
1417 bitmap->u.elf32 = bfd_malloc (sizeof (uint32_t));
1418 bitmap->count = 0;
1419 bitmap->size = 1;
1420 }
1421
1422 newidx = bitmap->count++;
1423
1424 if (bitmap->count > bitmap->size)
1425 {
1426 bitmap->size <<= 1;
1427 bitmap->u.elf32 = bfd_realloc (bitmap->u.elf32,
1428 (bitmap->size * sizeof (uint32_t)));
1429 }
1430
1431 if (bitmap->u.elf32 == NULL)
1432 {
1433 info->callbacks->einfo
1434 /* xgettext:c-format */
1435 (_("%F%P: %pB: failed to allocate 32-bit DT_RELR bitmap\n"),
1436 info->output_bfd);
1437 }
1438
1439 bitmap->u.elf32[newidx] = entry;
1440 }
1441
1442 void
_bfd_elf32_write_addend(bfd * abfd,uint64_t value,void * addr)1443 _bfd_elf32_write_addend (bfd *abfd, uint64_t value, void *addr)
1444 {
1445 bfd_put_32 (abfd, value, addr);
1446 }
1447
1448 void
_bfd_elf64_write_addend(bfd * abfd,uint64_t value,void * addr)1449 _bfd_elf64_write_addend (bfd *abfd, uint64_t value, void *addr)
1450 {
1451 bfd_put_64 (abfd, value, addr);
1452 }
1453
1454 /* Size or finish relative relocations to determine the run-time
1455 addresses for DT_RELR bitmap computation later. OUTREL is set
1456 to NULL in the sizing phase and non-NULL in the finising phase
1457 where the regular relative relocations will be written out. */
1458
1459 static void
elf_x86_size_or_finish_relative_reloc(bool is_x86_64,struct bfd_link_info * info,struct elf_x86_link_hash_table * htab,bool unaligned,Elf_Internal_Rela * outrel)1460 elf_x86_size_or_finish_relative_reloc
1461 (bool is_x86_64, struct bfd_link_info *info,
1462 struct elf_x86_link_hash_table *htab, bool unaligned,
1463 Elf_Internal_Rela *outrel)
1464 {
1465 unsigned int align_mask;
1466 bfd_size_type i, count;
1467 asection *sec, *srel;
1468 struct elf_link_hash_entry *h;
1469 bfd_vma offset;
1470 Elf_Internal_Sym *sym;
1471 asection *sym_sec;
1472 asection *sgot = htab->elf.sgot;
1473 asection *srelgot = htab->elf.srelgot;
1474 struct elf_x86_relative_reloc_data *relative_reloc;
1475
1476 if (unaligned)
1477 {
1478 align_mask = 0;
1479 relative_reloc = &htab->unaligned_relative_reloc;
1480 }
1481 else
1482 {
1483 align_mask = 1;
1484 relative_reloc = &htab->relative_reloc;
1485 }
1486
1487 count = relative_reloc->count;
1488 for (i = 0; i < count; i++)
1489 {
1490 sec = relative_reloc->data[i].sec;
1491 sym = relative_reloc->data[i].sym;
1492
1493 /* If SYM is NULL, it must be a global symbol. */
1494 if (sym == NULL)
1495 h = relative_reloc->data[i].u.h;
1496 else
1497 h = NULL;
1498
1499 if (is_x86_64)
1500 {
1501 bfd_vma relocation;
1502 /* This function may be called more than once and REL may be
1503 updated by _bfd_elf_rela_local_sym below. */
1504 Elf_Internal_Rela rel = relative_reloc->data[i].rel;
1505
1506 if (h != NULL)
1507 {
1508 if (h->root.type == bfd_link_hash_defined
1509 || h->root.type == bfd_link_hash_defweak)
1510 {
1511 sym_sec = h->root.u.def.section;
1512 relocation = (h->root.u.def.value
1513 + sym_sec->output_section->vma
1514 + sym_sec->output_offset);
1515 }
1516 else
1517 {
1518 /* Allow undefined symbol only at the sizing phase.
1519 Otherwise skip undefined symbol here. Undefined
1520 symbol will be reported by relocate_section. */
1521 if (outrel == NULL)
1522 relocation = 0;
1523 else
1524 continue;
1525 }
1526 }
1527 else
1528 {
1529 sym_sec = relative_reloc->data[i].u.sym_sec;
1530 relocation = _bfd_elf_rela_local_sym
1531 (info->output_bfd, sym, &sym_sec, &rel);
1532 }
1533
1534 if (outrel != NULL)
1535 {
1536 outrel->r_addend = relocation;
1537 if (sec == sgot)
1538 {
1539 if (h != NULL && h->needs_plt)
1540 abort ();
1541 }
1542 else
1543 outrel->r_addend += rel.r_addend;
1544
1545 /* Write the implicit addend if ALIGN_MASK isn't 0. */
1546 if (align_mask)
1547 {
1548 if (sec == sgot)
1549 {
1550 if (relative_reloc->data[i].offset >= sec->size)
1551 abort ();
1552 htab->elf_write_addend_in_got
1553 (info->output_bfd, outrel->r_addend,
1554 sec->contents + relative_reloc->data[i].offset);
1555 }
1556 else
1557 {
1558 bfd_byte *contents;
1559
1560 if (rel.r_offset >= sec->size)
1561 abort ();
1562
1563 if (elf_section_data (sec)->this_hdr.contents
1564 != NULL)
1565 contents
1566 = elf_section_data (sec)->this_hdr.contents;
1567 else
1568 {
1569 if (!_bfd_elf_mmap_section_contents (sec->owner,
1570 sec,
1571 &contents))
1572 info->callbacks->einfo
1573 /* xgettext:c-format */
1574 (_("%F%P: %pB: failed to allocate memory for section `%pA'\n"),
1575 info->output_bfd, sec);
1576
1577 /* Cache the section contents for
1578 elf_link_input_bfd. */
1579 elf_section_data (sec)->this_hdr.contents
1580 = contents;
1581 }
1582 htab->elf_write_addend
1583 (info->output_bfd, outrel->r_addend,
1584 contents + rel.r_offset);
1585 }
1586 }
1587 }
1588 }
1589
1590 if (sec == sgot)
1591 srel = srelgot;
1592 else
1593 srel = elf_section_data (sec)->sreloc;
1594 offset = (sec->output_section->vma + sec->output_offset
1595 + relative_reloc->data[i].offset);
1596 relative_reloc->data[i].address = offset;
1597 if (outrel != NULL)
1598 {
1599 outrel->r_offset = offset;
1600
1601 if ((outrel->r_offset & align_mask) != 0)
1602 abort ();
1603
1604 if (htab->params->report_relative_reloc)
1605 _bfd_x86_elf_link_report_relative_reloc
1606 (info, sec, h, sym, htab->relative_r_name, outrel);
1607
1608 /* Generate regular relative relocation if ALIGN_MASK is 0. */
1609 if (align_mask == 0)
1610 htab->elf_append_reloc (info->output_bfd, srel, outrel);
1611 }
1612 }
1613 }
1614
1615 /* Compute the DT_RELR section size. Set NEED_PLAYOUT to true if
1616 the DT_RELR section size has been increased. */
1617
1618 static void
elf_x86_compute_dl_relr_bitmap(struct bfd_link_info * info,struct elf_x86_link_hash_table * htab,bool * need_layout)1619 elf_x86_compute_dl_relr_bitmap
1620 (struct bfd_link_info *info, struct elf_x86_link_hash_table *htab,
1621 bool *need_layout)
1622 {
1623 bfd_vma base;
1624 bfd_size_type i, count, new_count;
1625 struct elf_x86_relative_reloc_data *relative_reloc =
1626 &htab->relative_reloc;
1627 /* Save the old DT_RELR bitmap count. Don't shrink the DT_RELR bitmap
1628 if the new DT_RELR bitmap count is smaller than the old one. Pad
1629 with trailing 1s which won't be decoded to more relocations. */
1630 bfd_size_type dt_relr_bitmap_count = htab->dt_relr_bitmap.count;
1631
1632 /* Clear the DT_RELR bitmap count. */
1633 htab->dt_relr_bitmap.count = 0;
1634
1635 count = relative_reloc->count;
1636
1637 if (ABI_64_P (info->output_bfd))
1638 {
1639 /* Compute the 64-bit DT_RELR bitmap. */
1640 i = 0;
1641 while (i < count)
1642 {
1643 if ((relative_reloc->data[i].address % 1) != 0)
1644 abort ();
1645
1646 elf64_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1647 relative_reloc->data[i].address);
1648
1649 base = relative_reloc->data[i].address + 8;
1650 i++;
1651
1652 while (i < count)
1653 {
1654 uint64_t bitmap = 0;
1655 for (; i < count; i++)
1656 {
1657 bfd_vma delta = (relative_reloc->data[i].address
1658 - base);
1659 /* Stop if it is too far from base. */
1660 if (delta >= 63 * 8)
1661 break;
1662 /* Stop if it isn't a multiple of 8. */
1663 if ((delta % 8) != 0)
1664 break;
1665 bitmap |= 1ULL << (delta / 8);
1666 }
1667
1668 if (bitmap == 0)
1669 break;
1670
1671 elf64_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1672 (bitmap << 1) | 1);
1673
1674 base += 63 * 8;
1675 }
1676 }
1677
1678 new_count = htab->dt_relr_bitmap.count;
1679 if (dt_relr_bitmap_count > new_count)
1680 {
1681 /* Don't shrink the DT_RELR section size to avoid section
1682 layout oscillation. Instead, pad the DT_RELR bitmap with
1683 1s which do not decode to more relocations. */
1684
1685 htab->dt_relr_bitmap.count = dt_relr_bitmap_count;
1686 count = dt_relr_bitmap_count - new_count;
1687 for (i = 0; i < count; i++)
1688 htab->dt_relr_bitmap.u.elf64[new_count + i] = 1;
1689 }
1690 }
1691 else
1692 {
1693 /* Compute the 32-bit DT_RELR bitmap. */
1694 i = 0;
1695 while (i < count)
1696 {
1697 if ((relative_reloc->data[i].address % 1) != 0)
1698 abort ();
1699
1700 elf32_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1701 relative_reloc->data[i].address);
1702
1703 base = relative_reloc->data[i].address + 4;
1704 i++;
1705
1706 while (i < count)
1707 {
1708 uint32_t bitmap = 0;
1709 for (; i < count; i++)
1710 {
1711 bfd_vma delta = (relative_reloc->data[i].address
1712 - base);
1713 /* Stop if it is too far from base. */
1714 if (delta >= 31 * 4)
1715 break;
1716 /* Stop if it isn't a multiple of 4. */
1717 if ((delta % 4) != 0)
1718 break;
1719 bitmap |= 1ULL << (delta / 4);
1720 }
1721
1722 if (bitmap == 0)
1723 break;
1724
1725 elf32_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1726 (bitmap << 1) | 1);
1727
1728 base += 31 * 4;
1729 }
1730 }
1731
1732 new_count = htab->dt_relr_bitmap.count;
1733 if (dt_relr_bitmap_count > new_count)
1734 {
1735 /* Don't shrink the DT_RELR section size to avoid section
1736 layout oscillation. Instead, pad the DT_RELR bitmap with
1737 1s which do not decode to more relocations. */
1738
1739 htab->dt_relr_bitmap.count = dt_relr_bitmap_count;
1740 count = dt_relr_bitmap_count - new_count;
1741 for (i = 0; i < count; i++)
1742 htab->dt_relr_bitmap.u.elf32[new_count + i] = 1;
1743 }
1744 }
1745
1746 if (htab->dt_relr_bitmap.count != dt_relr_bitmap_count)
1747 {
1748 if (need_layout)
1749 {
1750 /* The .relr.dyn section size is changed. Update the section
1751 size and tell linker to layout sections again. */
1752 htab->elf.srelrdyn->size =
1753 (htab->dt_relr_bitmap.count
1754 * (ABI_64_P (info->output_bfd) ? 8 : 4));
1755
1756 *need_layout = true;
1757 }
1758 else
1759 info->callbacks->einfo
1760 /* xgettext:c-format */
1761 (_("%F%P: %pB: size of compact relative reloc section is "
1762 "changed: new (%lu) != old (%lu)\n"),
1763 info->output_bfd, htab->dt_relr_bitmap.count,
1764 dt_relr_bitmap_count);
1765 }
1766 }
1767
1768 /* Write out the DT_RELR section. */
1769
1770 static void
elf_x86_write_dl_relr_bitmap(struct bfd_link_info * info,struct elf_x86_link_hash_table * htab)1771 elf_x86_write_dl_relr_bitmap (struct bfd_link_info *info,
1772 struct elf_x86_link_hash_table *htab)
1773 {
1774 asection *sec = htab->elf.srelrdyn;
1775 bfd_size_type size = sec->size;
1776 bfd_size_type i;
1777 unsigned char *contents;
1778
1779 contents = (unsigned char *) bfd_alloc (sec->owner, size);
1780 if (contents == NULL)
1781 info->callbacks->einfo
1782 /* xgettext:c-format */
1783 (_("%F%P: %pB: failed to allocate compact relative reloc section\n"),
1784 info->output_bfd);
1785
1786 /* Cache the section contents for elf_link_input_bfd. */
1787 sec->contents = contents;
1788
1789 if (ABI_64_P (info->output_bfd))
1790 for (i = 0; i < htab->dt_relr_bitmap.count; i++, contents += 8)
1791 bfd_put_64 (info->output_bfd, htab->dt_relr_bitmap.u.elf64[i],
1792 contents);
1793 else
1794 for (i = 0; i < htab->dt_relr_bitmap.count; i++, contents += 4)
1795 bfd_put_32 (info->output_bfd, htab->dt_relr_bitmap.u.elf32[i],
1796 contents);
1797 }
1798
1799 /* Sort relative relocations by address. */
1800
1801 static int
elf_x86_relative_reloc_compare(const void * pa,const void * pb)1802 elf_x86_relative_reloc_compare (const void *pa, const void *pb)
1803 {
1804 struct elf_x86_relative_reloc_record *a =
1805 (struct elf_x86_relative_reloc_record *) pa;
1806 struct elf_x86_relative_reloc_record *b =
1807 (struct elf_x86_relative_reloc_record *) pb;
1808 if (a->address < b->address)
1809 return -1;
1810 if (a->address > b->address)
1811 return 1;
1812 return 0;
1813 }
1814
1815 enum dynobj_sframe_plt_type
1816 {
1817 SFRAME_PLT = 1,
1818 SFRAME_PLT_SEC = 2
1819 };
1820
1821 /* Create SFrame stack trace info for the plt entries in the .plt section
1822 of type PLT_SEC_TYPE. */
1823
1824 static bool
_bfd_x86_elf_create_sframe_plt(bfd * output_bfd,struct bfd_link_info * info,unsigned int plt_sec_type)1825 _bfd_x86_elf_create_sframe_plt (bfd *output_bfd,
1826 struct bfd_link_info *info,
1827 unsigned int plt_sec_type)
1828 {
1829 struct elf_x86_link_hash_table *htab;
1830 const struct elf_backend_data *bed;
1831
1832 bool plt0_generated_p;
1833 unsigned int plt0_entry_size;
1834 unsigned char func_info;
1835 uint32_t fre_type;
1836 /* The dynamic plt section for which .sframe stack trace information is being
1837 created. */
1838 asection *dpltsec;
1839
1840 int err = 0;
1841
1842 sframe_encoder_ctx **ectx = NULL;
1843 unsigned plt_entry_size = 0;
1844 unsigned int num_pltn_fres = 0;
1845 unsigned int num_pltn_entries = 0;
1846
1847 bed = get_elf_backend_data (output_bfd);
1848 htab = elf_x86_hash_table (info, bed->target_id);
1849 /* Whether SFrame stack trace info for plt0 is to be generated. */
1850 plt0_generated_p = htab->plt.has_plt0;
1851 plt0_entry_size
1852 = (plt0_generated_p) ? htab->sframe_plt->plt0_entry_size : 0;
1853
1854 switch (plt_sec_type)
1855 {
1856 case SFRAME_PLT:
1857 {
1858 ectx = &htab->plt_cfe_ctx;
1859 dpltsec = htab->elf.splt;
1860
1861 plt_entry_size = htab->plt.plt_entry_size;
1862 num_pltn_fres = htab->sframe_plt->pltn_num_fres;
1863 num_pltn_entries
1864 = (dpltsec->size - plt0_entry_size) / plt_entry_size;
1865
1866 break;
1867 }
1868 case SFRAME_PLT_SEC:
1869 {
1870 ectx = &htab->plt_second_cfe_ctx;
1871 /* FIXME - this or htab->plt_second_sframe ? */
1872 dpltsec = htab->plt_second_eh_frame;
1873
1874 plt_entry_size = htab->sframe_plt->sec_pltn_entry_size;
1875 num_pltn_fres = htab->sframe_plt->sec_pltn_num_fres;
1876 num_pltn_entries = dpltsec->size / plt_entry_size;
1877 break;
1878 }
1879 default:
1880 /* No other value is possible. */
1881 return false;
1882 break;
1883 }
1884
1885 *ectx = sframe_encode (SFRAME_VERSION_2,
1886 0,
1887 SFRAME_ABI_AMD64_ENDIAN_LITTLE,
1888 SFRAME_CFA_FIXED_FP_INVALID,
1889 -8, /* Fixed RA offset. */
1890 &err);
1891
1892 /* FRE type is dependent on the size of the function. */
1893 fre_type = sframe_calc_fre_type (dpltsec->size);
1894 func_info = sframe_fde_create_func_info (fre_type, SFRAME_FDE_TYPE_PCINC);
1895
1896 /* Add SFrame FDE and the associated FREs for plt0 if plt0 has been
1897 generated. */
1898 if (plt0_generated_p)
1899 {
1900 /* Add SFrame FDE for plt0, the function start address is updated later
1901 at _bfd_elf_merge_section_sframe time. */
1902 sframe_encoder_add_funcdesc_v2 (*ectx,
1903 0, /* func start addr. */
1904 plt0_entry_size,
1905 func_info,
1906 16,
1907 0 /* Num FREs. */);
1908 sframe_frame_row_entry plt0_fre;
1909 unsigned int num_plt0_fres = htab->sframe_plt->plt0_num_fres;
1910 for (unsigned int j = 0; j < num_plt0_fres; j++)
1911 {
1912 plt0_fre = *(htab->sframe_plt->plt0_fres[j]);
1913 sframe_encoder_add_fre (*ectx, 0, &plt0_fre);
1914 }
1915 }
1916
1917
1918 if (num_pltn_entries)
1919 {
1920 /* pltn entries use an SFrame FDE of type
1921 SFRAME_FDE_TYPE_PCMASK to exploit the repetitive
1922 pattern of the instructions in these entries. Using this SFrame FDE
1923 type helps in keeping the SFrame stack trace info for pltn entries
1924 compact. */
1925 func_info = sframe_fde_create_func_info (fre_type,
1926 SFRAME_FDE_TYPE_PCMASK);
1927 /* Add the SFrame FDE for all PCs starting at the first pltn entry (hence,
1928 function start address = plt0_entry_size. As usual, this will be
1929 updated later at _bfd_elf_merge_section_sframe, by when the
1930 sections are relocated. */
1931 sframe_encoder_add_funcdesc_v2 (*ectx,
1932 plt0_entry_size, /* func start addr. */
1933 dpltsec->size - plt0_entry_size,
1934 func_info,
1935 16,
1936 0 /* Num FREs. */);
1937
1938 sframe_frame_row_entry pltn_fre;
1939 /* Now add the FREs for pltn. Simply adding the two FREs suffices due
1940 to the usage of SFRAME_FDE_TYPE_PCMASK above. */
1941 for (unsigned int j = 0; j < num_pltn_fres; j++)
1942 {
1943 pltn_fre = *(htab->sframe_plt->pltn_fres[j]);
1944 sframe_encoder_add_fre (*ectx, 1, &pltn_fre);
1945 }
1946 }
1947
1948 return true;
1949 }
1950
1951 /* Put contents of the .sframe section corresponding to the specified
1952 PLT_SEC_TYPE. */
1953
1954 static bool
_bfd_x86_elf_write_sframe_plt(bfd * output_bfd,struct bfd_link_info * info,unsigned int plt_sec_type)1955 _bfd_x86_elf_write_sframe_plt (bfd *output_bfd,
1956 struct bfd_link_info *info,
1957 unsigned int plt_sec_type)
1958 {
1959 struct elf_x86_link_hash_table *htab;
1960 const struct elf_backend_data *bed;
1961 sframe_encoder_ctx *ectx;
1962 size_t sec_size;
1963 asection *sec;
1964 bfd *dynobj;
1965
1966 int err = 0;
1967
1968 bed = get_elf_backend_data (output_bfd);
1969 htab = elf_x86_hash_table (info, bed->target_id);
1970 dynobj = htab->elf.dynobj;
1971
1972 switch (plt_sec_type)
1973 {
1974 case SFRAME_PLT:
1975 ectx = htab->plt_cfe_ctx;
1976 sec = htab->plt_sframe;
1977 break;
1978 case SFRAME_PLT_SEC:
1979 ectx = htab->plt_second_cfe_ctx;
1980 sec = htab->plt_second_sframe;
1981 break;
1982 default:
1983 /* No other value is possible. */
1984 return false;
1985 break;
1986 }
1987
1988 BFD_ASSERT (ectx);
1989
1990 void *contents = sframe_encoder_write (ectx, &sec_size, &err);
1991
1992 sec->size = (bfd_size_type) sec_size;
1993 sec->contents = (unsigned char *) bfd_zalloc (dynobj, sec->size);
1994 memcpy (sec->contents, contents, sec_size);
1995
1996 sframe_encoder_free (&ectx);
1997
1998 return true;
1999 }
2000
2001 bool
_bfd_elf_x86_size_relative_relocs(struct bfd_link_info * info,bool * need_layout)2002 _bfd_elf_x86_size_relative_relocs (struct bfd_link_info *info,
2003 bool *need_layout)
2004 {
2005 struct elf_x86_link_hash_table *htab;
2006 const struct elf_backend_data *bed;
2007 bool is_x86_64;
2008 bfd_size_type i, count, unaligned_count;
2009 asection *sec, *srel;
2010
2011 /* Do nothing for ld -r. */
2012 if (bfd_link_relocatable (info))
2013 return true;
2014
2015 bed = get_elf_backend_data (info->output_bfd);
2016 htab = elf_x86_hash_table (info, bed->target_id);
2017 if (htab == NULL)
2018 return false;
2019
2020 count = htab->relative_reloc.count;
2021 unaligned_count = htab->unaligned_relative_reloc.count;
2022 if (count == 0)
2023 {
2024 if (htab->generate_relative_reloc_pass == 0
2025 && htab->elf.srelrdyn != NULL)
2026 {
2027 /* Remove the empty .relr.dyn sections now. */
2028 if (!bfd_is_abs_section (htab->elf.srelrdyn->output_section))
2029 {
2030 bfd_section_list_remove
2031 (info->output_bfd, htab->elf.srelrdyn->output_section);
2032 info->output_bfd->section_count--;
2033 }
2034 bfd_section_list_remove (htab->elf.srelrdyn->owner,
2035 htab->elf.srelrdyn);
2036 htab->elf.srelrdyn->owner->section_count--;
2037 }
2038 if (unaligned_count == 0)
2039 {
2040 htab->generate_relative_reloc_pass++;
2041 return true;
2042 }
2043 }
2044
2045 is_x86_64 = bed->target_id == X86_64_ELF_DATA;
2046
2047 /* Size relative relocations. */
2048 if (htab->generate_relative_reloc_pass)
2049 {
2050 /* Reset the regular relative relocation count. */
2051 for (i = 0; i < unaligned_count; i++)
2052 {
2053 sec = htab->unaligned_relative_reloc.data[i].sec;
2054 srel = elf_section_data (sec)->sreloc;
2055 srel->reloc_count = 0;
2056 }
2057 }
2058 else
2059 {
2060 /* Remove the reserved space for compact relative relocations. */
2061 if (count)
2062 {
2063 asection *sgot = htab->elf.sgot;
2064 asection *srelgot = htab->elf.srelgot;
2065
2066 for (i = 0; i < count; i++)
2067 {
2068 sec = htab->relative_reloc.data[i].sec;
2069 if (sec == sgot)
2070 srel = srelgot;
2071 else
2072 srel = elf_section_data (sec)->sreloc;
2073 srel->size -= htab->sizeof_reloc;
2074 }
2075 }
2076 }
2077
2078 /* Size unaligned relative relocations. */
2079 if (unaligned_count)
2080 elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2081 true, NULL);
2082
2083 if (count)
2084 {
2085 elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2086 false, NULL);
2087
2088 /* Sort relative relocations by addresses. We only need to
2089 sort them in the first pass since the relative positions
2090 won't change. */
2091 if (htab->generate_relative_reloc_pass == 0)
2092 qsort (htab->relative_reloc.data, count,
2093 sizeof (struct elf_x86_relative_reloc_record),
2094 elf_x86_relative_reloc_compare);
2095
2096 elf_x86_compute_dl_relr_bitmap (info, htab, need_layout);
2097 }
2098
2099 htab->generate_relative_reloc_pass++;
2100
2101 return true;
2102 }
2103
2104 bool
_bfd_elf_x86_finish_relative_relocs(struct bfd_link_info * info)2105 _bfd_elf_x86_finish_relative_relocs (struct bfd_link_info *info)
2106 {
2107 struct elf_x86_link_hash_table *htab;
2108 const struct elf_backend_data *bed;
2109 Elf_Internal_Rela outrel;
2110 bool is_x86_64;
2111 bfd_size_type count;
2112
2113 /* Do nothing for ld -r. */
2114 if (bfd_link_relocatable (info))
2115 return true;
2116
2117 bed = get_elf_backend_data (info->output_bfd);
2118 htab = elf_x86_hash_table (info, bed->target_id);
2119 if (htab == NULL)
2120 return false;
2121
2122 is_x86_64 = bed->target_id == X86_64_ELF_DATA;
2123
2124 outrel.r_info = htab->r_info (0, htab->relative_r_type);
2125
2126 if (htab->unaligned_relative_reloc.count)
2127 elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2128 true, &outrel);
2129
2130 count = htab->relative_reloc.count;
2131 if (count)
2132 {
2133 elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2134 false, &outrel);
2135
2136 elf_x86_compute_dl_relr_bitmap (info, htab, NULL);
2137
2138 elf_x86_write_dl_relr_bitmap (info, htab);
2139 }
2140
2141 return true;
2142 }
2143
2144 bool
_bfd_elf_x86_valid_reloc_p(asection * input_section,struct bfd_link_info * info,struct elf_x86_link_hash_table * htab,const Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym,Elf_Internal_Shdr * symtab_hdr,bool * no_dynreloc_p)2145 _bfd_elf_x86_valid_reloc_p (asection *input_section,
2146 struct bfd_link_info *info,
2147 struct elf_x86_link_hash_table *htab,
2148 const Elf_Internal_Rela *rel,
2149 struct elf_link_hash_entry *h,
2150 Elf_Internal_Sym *sym,
2151 Elf_Internal_Shdr *symtab_hdr,
2152 bool *no_dynreloc_p)
2153 {
2154 bool valid_p = true;
2155
2156 *no_dynreloc_p = false;
2157
2158 /* Check If relocation against non-preemptible absolute symbol is
2159 valid in PIC. FIXME: Can't use SYMBOL_REFERENCES_LOCAL_P since
2160 it may call _bfd_elf_link_hide_sym_by_version and result in
2161 ld-elfvers/ vers21 test failure. */
2162 if (bfd_link_pic (info)
2163 && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
2164 {
2165 const struct elf_backend_data *bed;
2166 unsigned int r_type;
2167 Elf_Internal_Rela irel;
2168
2169 /* Skip non-absolute symbol. */
2170 if (h)
2171 {
2172 if (!ABS_SYMBOL_P (h))
2173 return valid_p;
2174 }
2175 else if (sym->st_shndx != SHN_ABS)
2176 return valid_p;
2177
2178 bed = get_elf_backend_data (input_section->owner);
2179 r_type = ELF32_R_TYPE (rel->r_info);
2180 irel = *rel;
2181
2182 /* Only allow relocations against absolute symbol, which can be
2183 resolved as absolute value + addend. GOTPCREL and GOT32
2184 relocations are allowed since absolute value + addend is
2185 stored in the GOT slot. */
2186 if (bed->target_id == X86_64_ELF_DATA)
2187 {
2188 r_type &= ~R_X86_64_converted_reloc_bit;
2189 valid_p = (r_type == R_X86_64_64
2190 || r_type == R_X86_64_32
2191 || r_type == R_X86_64_32S
2192 || r_type == R_X86_64_16
2193 || r_type == R_X86_64_8
2194 || r_type == R_X86_64_GOTPCREL
2195 || r_type == R_X86_64_GOTPCRELX
2196 || r_type == R_X86_64_REX_GOTPCRELX);
2197 if (!valid_p)
2198 {
2199 unsigned int r_symndx = htab->r_sym (rel->r_info);
2200 irel.r_info = htab->r_info (r_symndx, r_type);
2201 }
2202 }
2203 else
2204 valid_p = (r_type == R_386_32
2205 || r_type == R_386_16
2206 || r_type == R_386_8
2207 || r_type == R_386_GOT32
2208 || r_type == R_386_GOT32X);
2209
2210 if (valid_p)
2211 *no_dynreloc_p = true;
2212 else
2213 {
2214 const char *name;
2215 arelent internal_reloc;
2216
2217 if (!bed->elf_info_to_howto (input_section->owner,
2218 &internal_reloc, &irel)
2219 || internal_reloc.howto == NULL)
2220 abort ();
2221
2222 if (h)
2223 name = h->root.root.string;
2224 else
2225 name = bfd_elf_sym_name (input_section->owner, symtab_hdr,
2226 sym, NULL);
2227 info->callbacks->einfo
2228 /* xgettext:c-format */
2229 (_("%F%P: %pB: relocation %s against absolute symbol "
2230 "`%s' in section `%pA' is disallowed\n"),
2231 input_section->owner, internal_reloc.howto->name, name,
2232 input_section);
2233 bfd_set_error (bfd_error_bad_value);
2234 }
2235 }
2236
2237 return valid_p;
2238 }
2239
2240 /* Set the sizes of the dynamic sections. */
2241
2242 bool
_bfd_x86_elf_late_size_sections(bfd * output_bfd,struct bfd_link_info * info)2243 _bfd_x86_elf_late_size_sections (bfd *output_bfd,
2244 struct bfd_link_info *info)
2245 {
2246 struct elf_x86_link_hash_table *htab;
2247 bfd *dynobj;
2248 asection *s;
2249 bool relocs;
2250 bfd *ibfd;
2251 const struct elf_backend_data *bed
2252 = get_elf_backend_data (output_bfd);
2253
2254 htab = elf_x86_hash_table (info, bed->target_id);
2255 if (htab == NULL)
2256 return false;
2257 dynobj = htab->elf.dynobj;
2258 if (dynobj == NULL)
2259 return true;
2260
2261 /* Set up .got offsets for local syms, and space for local dynamic
2262 relocs. */
2263 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2264 {
2265 bfd_signed_vma *local_got;
2266 bfd_signed_vma *end_local_got;
2267 char *local_tls_type;
2268 bfd_vma *local_tlsdesc_gotent;
2269 bfd_size_type locsymcount;
2270 Elf_Internal_Shdr *symtab_hdr;
2271 asection *srel;
2272
2273 if (! is_x86_elf (ibfd, htab))
2274 continue;
2275
2276 for (s = ibfd->sections; s != NULL; s = s->next)
2277 {
2278 struct elf_dyn_relocs *p;
2279
2280 for (p = ((struct elf_dyn_relocs *)
2281 elf_section_data (s)->local_dynrel);
2282 p != NULL;
2283 p = p->next)
2284 {
2285 if (!bfd_is_abs_section (p->sec)
2286 && bfd_is_abs_section (p->sec->output_section))
2287 {
2288 /* Input section has been discarded, either because
2289 it is a copy of a linkonce section or due to
2290 linker script /DISCARD/, so we'll be discarding
2291 the relocs too. */
2292 }
2293 else if (htab->elf.target_os == is_vxworks
2294 && strcmp (p->sec->output_section->name,
2295 ".tls_vars") == 0)
2296 {
2297 /* Relocations in vxworks .tls_vars sections are
2298 handled specially by the loader. */
2299 }
2300 else if (p->count != 0)
2301 {
2302 srel = elf_section_data (p->sec)->sreloc;
2303 srel->size += p->count * htab->sizeof_reloc;
2304 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2305 && (info->flags & DF_TEXTREL) == 0)
2306 {
2307 info->flags |= DF_TEXTREL;
2308 if (bfd_link_textrel_check (info))
2309 /* xgettext:c-format */
2310 info->callbacks->einfo
2311 (_("%P: %pB: warning: relocation "
2312 "in read-only section `%pA'\n"),
2313 p->sec->owner, p->sec);
2314 }
2315 }
2316 }
2317 }
2318
2319 local_got = elf_local_got_refcounts (ibfd);
2320 if (!local_got)
2321 continue;
2322
2323 symtab_hdr = &elf_symtab_hdr (ibfd);
2324 locsymcount = symtab_hdr->sh_info;
2325 end_local_got = local_got + locsymcount;
2326 local_tls_type = elf_x86_local_got_tls_type (ibfd);
2327 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
2328 s = htab->elf.sgot;
2329 srel = htab->elf.srelgot;
2330 for (; local_got < end_local_got;
2331 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2332 {
2333 *local_tlsdesc_gotent = (bfd_vma) -1;
2334 if (*local_got > 0)
2335 {
2336 if (GOT_TLS_GDESC_P (*local_tls_type))
2337 {
2338 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2339 - elf_x86_compute_jump_table_size (htab);
2340 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
2341 *local_got = (bfd_vma) -2;
2342 }
2343 if (! GOT_TLS_GDESC_P (*local_tls_type)
2344 || GOT_TLS_GD_P (*local_tls_type))
2345 {
2346 *local_got = s->size;
2347 s->size += htab->got_entry_size;
2348 if (GOT_TLS_GD_P (*local_tls_type)
2349 || *local_tls_type == GOT_TLS_IE_BOTH)
2350 s->size += htab->got_entry_size;
2351 }
2352 if ((bfd_link_pic (info) && *local_tls_type != GOT_ABS)
2353 || GOT_TLS_GD_ANY_P (*local_tls_type)
2354 || (*local_tls_type & GOT_TLS_IE))
2355 {
2356 if (*local_tls_type == GOT_TLS_IE_BOTH)
2357 srel->size += 2 * htab->sizeof_reloc;
2358 else if (GOT_TLS_GD_P (*local_tls_type)
2359 || ! GOT_TLS_GDESC_P (*local_tls_type))
2360 srel->size += htab->sizeof_reloc;
2361 if (GOT_TLS_GDESC_P (*local_tls_type))
2362 {
2363 htab->elf.srelplt->size += htab->sizeof_reloc;
2364 if (bed->target_id == X86_64_ELF_DATA)
2365 htab->elf.tlsdesc_plt = (bfd_vma) -1;
2366 }
2367 }
2368 }
2369 else
2370 *local_got = (bfd_vma) -1;
2371 }
2372 }
2373
2374 if (htab->tls_ld_or_ldm_got.refcount > 0)
2375 {
2376 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2377 or R_X86_64_TLSLD relocs. */
2378 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
2379 htab->elf.sgot->size += 2 * htab->got_entry_size;
2380 htab->elf.srelgot->size += htab->sizeof_reloc;
2381 }
2382 else
2383 htab->tls_ld_or_ldm_got.offset = -1;
2384
2385 /* Allocate global sym .plt and .got entries, and space for global
2386 sym dynamic relocs. */
2387 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
2388 info);
2389
2390 /* Allocate .plt and .got entries, and space for local symbols. */
2391 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
2392 info);
2393
2394 /* For every jump slot reserved in the sgotplt, reloc_count is
2395 incremented. However, when we reserve space for TLS descriptors,
2396 it's not incremented, so in order to compute the space reserved
2397 for them, it suffices to multiply the reloc count by the jump
2398 slot size.
2399
2400 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2401 so that R_{386,X86_64}_IRELATIVE entries come last. */
2402 if (htab->elf.srelplt)
2403 {
2404 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2405 htab->sgotplt_jump_table_size
2406 = elf_x86_compute_jump_table_size (htab);
2407 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2408 }
2409 else if (htab->elf.irelplt)
2410 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2411
2412 if (htab->elf.tlsdesc_plt)
2413 {
2414 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
2415 lazy TLS relocations, don't generate the PLT and GOT entries
2416 they require. */
2417 if ((info->flags & DF_BIND_NOW))
2418 htab->elf.tlsdesc_plt = 0;
2419 else
2420 {
2421 htab->elf.tlsdesc_got = htab->elf.sgot->size;
2422 htab->elf.sgot->size += htab->got_entry_size;
2423 /* Reserve room for the initial entry.
2424 FIXME: we could probably do away with it in this case. */
2425 if (htab->elf.splt->size == 0)
2426 htab->elf.splt->size = htab->plt.plt_entry_size;
2427 htab->elf.tlsdesc_plt = htab->elf.splt->size;
2428 htab->elf.splt->size += htab->plt.plt_entry_size;
2429 }
2430 }
2431
2432 if (htab->elf.sgotplt)
2433 {
2434 /* Don't allocate .got.plt section if there are no GOT nor PLT
2435 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
2436 if ((htab->elf.hgot == NULL
2437 || !htab->got_referenced)
2438 && (htab->elf.sgotplt->size == bed->got_header_size)
2439 && (htab->elf.splt == NULL
2440 || htab->elf.splt->size == 0)
2441 && (htab->elf.sgot == NULL
2442 || htab->elf.sgot->size == 0)
2443 && (htab->elf.iplt == NULL
2444 || htab->elf.iplt->size == 0)
2445 && (htab->elf.igotplt == NULL
2446 || htab->elf.igotplt->size == 0))
2447 {
2448 htab->elf.sgotplt->size = 0;
2449 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
2450 isn't used. */
2451 if (htab->elf.hgot != NULL
2452 && htab->elf.target_os != is_solaris)
2453 {
2454 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
2455 table. */
2456 htab->elf.hgot->root.type = bfd_link_hash_undefined;
2457 htab->elf.hgot->root.u.undef.abfd
2458 = htab->elf.hgot->root.u.def.section->owner;
2459 htab->elf.hgot->root.linker_def = 0;
2460 htab->elf.hgot->ref_regular = 0;
2461 htab->elf.hgot->def_regular = 0;
2462 }
2463 }
2464 }
2465
2466 if (_bfd_elf_eh_frame_present (info))
2467 {
2468 if (htab->plt_eh_frame != NULL
2469 && htab->elf.splt != NULL
2470 && htab->elf.splt->size != 0
2471 && !bfd_is_abs_section (htab->elf.splt->output_section))
2472 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
2473
2474 if (htab->plt_got_eh_frame != NULL
2475 && htab->plt_got != NULL
2476 && htab->plt_got->size != 0
2477 && !bfd_is_abs_section (htab->plt_got->output_section))
2478 htab->plt_got_eh_frame->size
2479 = htab->non_lazy_plt->eh_frame_plt_size;
2480
2481 /* Unwind info for the second PLT and .plt.got sections are
2482 identical. */
2483 if (htab->plt_second_eh_frame != NULL
2484 && htab->plt_second != NULL
2485 && htab->plt_second->size != 0
2486 && !bfd_is_abs_section (htab->plt_second->output_section))
2487 htab->plt_second_eh_frame->size
2488 = htab->non_lazy_plt->eh_frame_plt_size;
2489 }
2490
2491 /* No need to size the .sframe section explicitly because the write-out
2492 mechanism is different. Simply prep up the FDE/FRE for the
2493 .plt section. */
2494 if (_bfd_elf_sframe_present (info))
2495 {
2496 if (htab->plt_sframe != NULL
2497 && htab->elf.splt != NULL
2498 && htab->elf.splt->size != 0
2499 && !bfd_is_abs_section (htab->elf.splt->output_section))
2500 {
2501 _bfd_x86_elf_create_sframe_plt (output_bfd, info, SFRAME_PLT);
2502 /* FIXME - Dirty Hack. Set the size to something non-zero for now,
2503 so that the section does not get stripped out below. The precise
2504 size of this section is known only when the contents are
2505 serialized in _bfd_x86_elf_write_sframe_plt. */
2506 htab->plt_sframe->size = sizeof (sframe_header) + 1;
2507 }
2508
2509 /* FIXME - generate for .plt.got ? */
2510
2511 if (htab->plt_second_sframe != NULL
2512 && htab->plt_second != NULL
2513 && htab->plt_second->size != 0
2514 && !bfd_is_abs_section (htab->plt_second->output_section))
2515 {
2516 /* SFrame stack trace info for the second PLT. */
2517 _bfd_x86_elf_create_sframe_plt (output_bfd, info, SFRAME_PLT_SEC);
2518 /* FIXME - Dirty Hack. Set the size to something non-zero for now,
2519 so that the section does not get stripped out below. The precise
2520 size of this section is known only when the contents are
2521 serialized in _bfd_x86_elf_write_sframe_plt. */
2522 htab->plt_second_sframe->size = sizeof (sframe_header) + 1;
2523 }
2524 }
2525
2526 asection *resolved_plt = NULL;
2527
2528 if (htab->params->mark_plt && htab->elf.dynamic_sections_created)
2529 {
2530 if (htab->plt_second != NULL)
2531 resolved_plt = htab->plt_second;
2532 else
2533 resolved_plt = htab->elf.splt;
2534
2535 if (resolved_plt != NULL && resolved_plt->size == 0)
2536 resolved_plt = NULL;
2537 }
2538
2539 /* We now have determined the sizes of the various dynamic sections.
2540 Allocate memory for them. */
2541 relocs = false;
2542 for (s = dynobj->sections; s != NULL; s = s->next)
2543 {
2544 bool strip_section = true;
2545
2546 if ((s->flags & SEC_LINKER_CREATED) == 0)
2547 continue;
2548
2549 /* The .relr.dyn section for compact relative relocation will
2550 be filled later. */
2551 if (s == htab->elf.srelrdyn)
2552 continue;
2553
2554 if (s == htab->elf.splt
2555 || s == htab->elf.sgot)
2556 {
2557 /* Strip this section if we don't need it; see the
2558 comment below. */
2559 /* We'd like to strip these sections if they aren't needed, but if
2560 we've exported dynamic symbols from them we must leave them.
2561 It's too late to tell BFD to get rid of the symbols. */
2562
2563 if (htab->elf.hplt != NULL)
2564 strip_section = false;
2565 }
2566 else if (s == htab->elf.sgotplt
2567 || s == htab->elf.iplt
2568 || s == htab->elf.igotplt
2569 || s == htab->plt_second
2570 || s == htab->plt_got
2571 || s == htab->plt_eh_frame
2572 || s == htab->plt_got_eh_frame
2573 || s == htab->plt_second_eh_frame
2574 || s == htab->plt_sframe
2575 || s == htab->plt_second_sframe
2576 || s == htab->elf.sdynbss
2577 || s == htab->elf.sdynrelro)
2578 {
2579 /* Strip these too. */
2580 }
2581 else if (htab->is_reloc_section (bfd_section_name (s)))
2582 {
2583 if (s->size != 0
2584 && s != htab->elf.srelplt
2585 && s != htab->srelplt2)
2586 relocs = true;
2587
2588 /* We use the reloc_count field as a counter if we need
2589 to copy relocs into the output file. */
2590 if (s != htab->elf.srelplt)
2591 s->reloc_count = 0;
2592 }
2593 else
2594 {
2595 /* It's not one of our sections, so don't allocate space. */
2596 continue;
2597 }
2598
2599 if (s->size == 0)
2600 {
2601 /* If we don't need this section, strip it from the
2602 output file. This is mostly to handle .rel.bss and
2603 .rel.plt. We must create both sections in
2604 create_dynamic_sections, because they must be created
2605 before the linker maps input sections to output
2606 sections. The linker does that before
2607 adjust_dynamic_symbol is called, and it is that
2608 function which decides whether anything needs to go
2609 into these sections. */
2610 if (strip_section)
2611 s->flags |= SEC_EXCLUDE;
2612 continue;
2613 }
2614
2615 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2616 continue;
2617
2618 /* Skip allocating contents for .sframe section as it is written
2619 out differently. See below. */
2620 if ((s == htab->plt_sframe) || (s == htab->plt_second_sframe))
2621 continue;
2622
2623 /* NB: Initially, the iplt section has minimal alignment to
2624 avoid moving dot of the following section backwards when
2625 it is empty. Update its section alignment now since it
2626 is non-empty. */
2627 if (s == htab->elf.iplt)
2628 bfd_set_section_alignment (s, htab->plt.iplt_alignment);
2629
2630 /* Allocate memory for the section contents. We use bfd_zalloc
2631 here in case unused entries are not reclaimed before the
2632 section's contents are written out. This should not happen,
2633 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
2634 reloc instead of garbage. */
2635 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2636 if (s->contents == NULL)
2637 return false;
2638 }
2639
2640 if (htab->plt_eh_frame != NULL
2641 && htab->plt_eh_frame->contents != NULL)
2642 {
2643 memcpy (htab->plt_eh_frame->contents,
2644 htab->plt.eh_frame_plt,
2645 htab->plt_eh_frame->size);
2646 bfd_put_32 (dynobj, htab->elf.splt->size,
2647 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2648 }
2649
2650 if (htab->plt_got_eh_frame != NULL
2651 && htab->plt_got_eh_frame->contents != NULL)
2652 {
2653 memcpy (htab->plt_got_eh_frame->contents,
2654 htab->non_lazy_plt->eh_frame_plt,
2655 htab->plt_got_eh_frame->size);
2656 bfd_put_32 (dynobj, htab->plt_got->size,
2657 (htab->plt_got_eh_frame->contents
2658 + PLT_FDE_LEN_OFFSET));
2659 }
2660
2661 if (htab->plt_second_eh_frame != NULL
2662 && htab->plt_second_eh_frame->contents != NULL)
2663 {
2664 memcpy (htab->plt_second_eh_frame->contents,
2665 htab->non_lazy_plt->eh_frame_plt,
2666 htab->plt_second_eh_frame->size);
2667 bfd_put_32 (dynobj, htab->plt_second->size,
2668 (htab->plt_second_eh_frame->contents
2669 + PLT_FDE_LEN_OFFSET));
2670 }
2671
2672 if (_bfd_elf_sframe_present (info))
2673 {
2674 if (htab->plt_sframe != NULL
2675 && htab->elf.splt != NULL
2676 && htab->elf.splt->size != 0
2677 && htab->plt_sframe->contents == NULL)
2678 _bfd_x86_elf_write_sframe_plt (output_bfd, info, SFRAME_PLT);
2679
2680 if (htab->plt_second_sframe != NULL
2681 && htab->elf.splt != NULL
2682 && htab->elf.splt->size != 0
2683 && htab->plt_second_sframe->contents == NULL)
2684 _bfd_x86_elf_write_sframe_plt (output_bfd, info, SFRAME_PLT_SEC);
2685 }
2686
2687 if (resolved_plt != NULL
2688 && (!_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLT, 0)
2689 || !_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLTSZ, 0)
2690 || !_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLTENT, 0)))
2691 return false;
2692
2693 return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd, info,
2694 relocs);
2695 }
2696
2697 /* Finish up the x86 dynamic sections. */
2698
2699 struct elf_x86_link_hash_table *
_bfd_x86_elf_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)2700 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
2701 struct bfd_link_info *info)
2702 {
2703 struct elf_x86_link_hash_table *htab;
2704 const struct elf_backend_data *bed;
2705 bfd *dynobj;
2706 asection *sdyn;
2707 bfd_byte *dyncon, *dynconend;
2708 bfd_size_type sizeof_dyn;
2709
2710 bed = get_elf_backend_data (output_bfd);
2711 htab = elf_x86_hash_table (info, bed->target_id);
2712 if (htab == NULL)
2713 return htab;
2714
2715 dynobj = htab->elf.dynobj;
2716 sdyn = htab->elf.dynamic;
2717
2718 /* GOT is always created in setup_gnu_properties. But it may not be
2719 needed. .got.plt section may be needed for static IFUNC. */
2720 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
2721 {
2722 bfd_vma dynamic_addr;
2723
2724 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
2725 {
2726 _bfd_error_handler
2727 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
2728 return NULL;
2729 }
2730
2731 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
2732 = htab->got_entry_size;
2733
2734 dynamic_addr = (sdyn == NULL
2735 ? (bfd_vma) 0
2736 : sdyn->output_section->vma + sdyn->output_offset);
2737
2738 /* Set the first entry in the global offset table to the address
2739 of the dynamic section. Write GOT[1] and GOT[2], needed for
2740 the dynamic linker. */
2741 if (htab->got_entry_size == 8)
2742 {
2743 bfd_put_64 (output_bfd, dynamic_addr,
2744 htab->elf.sgotplt->contents);
2745 bfd_put_64 (output_bfd, (bfd_vma) 0,
2746 htab->elf.sgotplt->contents + 8);
2747 bfd_put_64 (output_bfd, (bfd_vma) 0,
2748 htab->elf.sgotplt->contents + 8*2);
2749 }
2750 else
2751 {
2752 bfd_put_32 (output_bfd, dynamic_addr,
2753 htab->elf.sgotplt->contents);
2754 bfd_put_32 (output_bfd, 0,
2755 htab->elf.sgotplt->contents + 4);
2756 bfd_put_32 (output_bfd, 0,
2757 htab->elf.sgotplt->contents + 4*2);
2758 }
2759 }
2760
2761 if (!htab->elf.dynamic_sections_created)
2762 return htab;
2763
2764 if (sdyn == NULL || htab->elf.sgot == NULL)
2765 abort ();
2766
2767 asection *resolved_plt;
2768 if (htab->plt_second != NULL)
2769 resolved_plt = htab->plt_second;
2770 else
2771 resolved_plt = htab->elf.splt;
2772
2773 sizeof_dyn = bed->s->sizeof_dyn;
2774 dyncon = sdyn->contents;
2775 dynconend = sdyn->contents + sdyn->size;
2776 for (; dyncon < dynconend; dyncon += sizeof_dyn)
2777 {
2778 Elf_Internal_Dyn dyn;
2779 asection *s;
2780
2781 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
2782
2783 switch (dyn.d_tag)
2784 {
2785 default:
2786 if (htab->elf.target_os == is_vxworks
2787 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
2788 break;
2789 continue;
2790
2791 case DT_PLTGOT:
2792 s = htab->elf.sgotplt;
2793 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2794 break;
2795
2796 case DT_JMPREL:
2797 s = htab->elf.srelplt;
2798 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2799 break;
2800
2801 case DT_PLTRELSZ:
2802 s = htab->elf.srelplt;
2803 dyn.d_un.d_val = s->size;
2804 break;
2805
2806 case DT_TLSDESC_PLT:
2807 s = htab->elf.splt;
2808 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
2809 + htab->elf.tlsdesc_plt;
2810 break;
2811
2812 case DT_TLSDESC_GOT:
2813 s = htab->elf.sgot;
2814 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
2815 + htab->elf.tlsdesc_got;
2816 break;
2817
2818 case DT_X86_64_PLT:
2819 s = resolved_plt->output_section;
2820 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2821 break;
2822
2823 case DT_X86_64_PLTSZ:
2824 dyn.d_un.d_val = resolved_plt->size;
2825 break;
2826
2827 case DT_X86_64_PLTENT:
2828 dyn.d_un.d_ptr = htab->plt.plt_entry_size;
2829 break;
2830 }
2831
2832 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
2833 }
2834
2835 if (htab->plt_got != NULL && htab->plt_got->size > 0)
2836 elf_section_data (htab->plt_got->output_section)
2837 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
2838
2839 if (htab->plt_second != NULL && htab->plt_second->size > 0)
2840 elf_section_data (htab->plt_second->output_section)
2841 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
2842
2843 /* Adjust .eh_frame for .plt section. */
2844 if (htab->plt_eh_frame != NULL
2845 && htab->plt_eh_frame->contents != NULL)
2846 {
2847 if (htab->elf.splt != NULL
2848 && htab->elf.splt->size != 0
2849 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
2850 && htab->elf.splt->output_section != NULL
2851 && htab->plt_eh_frame->output_section != NULL)
2852 {
2853 bfd_vma plt_start = htab->elf.splt->output_section->vma;
2854 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
2855 + htab->plt_eh_frame->output_offset
2856 + PLT_FDE_START_OFFSET;
2857 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2858 htab->plt_eh_frame->contents
2859 + PLT_FDE_START_OFFSET);
2860 }
2861
2862 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
2863 {
2864 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2865 htab->plt_eh_frame,
2866 htab->plt_eh_frame->contents))
2867 return NULL;
2868 }
2869 }
2870
2871 /* Adjust .eh_frame for .plt.got section. */
2872 if (htab->plt_got_eh_frame != NULL
2873 && htab->plt_got_eh_frame->contents != NULL)
2874 {
2875 if (htab->plt_got != NULL
2876 && htab->plt_got->size != 0
2877 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
2878 && htab->plt_got->output_section != NULL
2879 && htab->plt_got_eh_frame->output_section != NULL)
2880 {
2881 bfd_vma plt_start = htab->plt_got->output_section->vma;
2882 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
2883 + htab->plt_got_eh_frame->output_offset
2884 + PLT_FDE_START_OFFSET;
2885 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2886 htab->plt_got_eh_frame->contents
2887 + PLT_FDE_START_OFFSET);
2888 }
2889 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
2890 {
2891 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2892 htab->plt_got_eh_frame,
2893 htab->plt_got_eh_frame->contents))
2894 return NULL;
2895 }
2896 }
2897
2898 /* Adjust .eh_frame for the second PLT section. */
2899 if (htab->plt_second_eh_frame != NULL
2900 && htab->plt_second_eh_frame->contents != NULL)
2901 {
2902 if (htab->plt_second != NULL
2903 && htab->plt_second->size != 0
2904 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
2905 && htab->plt_second->output_section != NULL
2906 && htab->plt_second_eh_frame->output_section != NULL)
2907 {
2908 bfd_vma plt_start = htab->plt_second->output_section->vma;
2909 bfd_vma eh_frame_start
2910 = (htab->plt_second_eh_frame->output_section->vma
2911 + htab->plt_second_eh_frame->output_offset
2912 + PLT_FDE_START_OFFSET);
2913 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2914 htab->plt_second_eh_frame->contents
2915 + PLT_FDE_START_OFFSET);
2916 }
2917 if (htab->plt_second_eh_frame->sec_info_type
2918 == SEC_INFO_TYPE_EH_FRAME)
2919 {
2920 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2921 htab->plt_second_eh_frame,
2922 htab->plt_second_eh_frame->contents))
2923 return NULL;
2924 }
2925 }
2926
2927 /* Make any adjustment if necessary and merge .sframe section to
2928 create the final .sframe section for output_bfd. */
2929 if (htab->plt_sframe != NULL
2930 && htab->plt_sframe->contents != NULL)
2931 {
2932 if (htab->elf.splt != NULL
2933 && htab->elf.splt->size != 0
2934 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
2935 && htab->elf.splt->output_section != NULL
2936 && htab->plt_sframe->output_section != NULL)
2937 {
2938 bfd_vma plt_start = htab->elf.splt->output_section->vma;
2939 bfd_vma sframe_start = htab->plt_sframe->output_section->vma
2940 + htab->plt_sframe->output_offset
2941 + PLT_SFRAME_FDE_START_OFFSET;
2942 #if 0 /* FIXME Testing only. Remove before review. */
2943 bfd_vma test_value = (plt_start - sframe_start)
2944 + htab->plt_sframe->output_section->vma
2945 + htab->plt_sframe->output_offset
2946 + PLT_SFRAME_FDE_START_OFFSET;
2947 bfd_put_signed_32 (dynobj, test_value,
2948 #endif
2949 bfd_put_signed_32 (dynobj, plt_start - sframe_start,
2950 htab->plt_sframe->contents
2951 + PLT_SFRAME_FDE_START_OFFSET);
2952 }
2953 if (htab->plt_sframe->sec_info_type == SEC_INFO_TYPE_SFRAME)
2954 {
2955 if (! _bfd_elf_merge_section_sframe (output_bfd, info,
2956 htab->plt_sframe,
2957 htab->plt_sframe->contents))
2958 return NULL;
2959 }
2960 }
2961
2962 if (htab->plt_second_sframe != NULL
2963 && htab->plt_second_sframe->contents != NULL)
2964 {
2965 if (htab->plt_second != NULL
2966 && htab->plt_second->size != 0
2967 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
2968 && htab->plt_second->output_section != NULL
2969 && htab->plt_second_sframe->output_section != NULL)
2970 {
2971 bfd_vma plt_start = htab->plt_second->output_section->vma;
2972 bfd_vma sframe_start
2973 = (htab->plt_second_sframe->output_section->vma
2974 + htab->plt_second_sframe->output_offset
2975 + PLT_SFRAME_FDE_START_OFFSET);
2976 #if 0 /* FIXME Testing only. Remove before review. */
2977 bfd_vma test_value = (plt_start - sframe_start)
2978 + htab->plt_second_sframe->output_section->vma
2979 + htab->plt_second_sframe->output_offset
2980 + PLT_SFRAME_FDE_START_OFFSET;
2981 bfd_put_signed_32 (dynobj, test_value,
2982 #endif
2983 bfd_put_signed_32 (dynobj, plt_start - sframe_start,
2984 htab->plt_second_sframe->contents
2985 + PLT_SFRAME_FDE_START_OFFSET);
2986 }
2987 if (htab->plt_second_sframe->sec_info_type == SEC_INFO_TYPE_SFRAME)
2988 {
2989 if (! _bfd_elf_merge_section_sframe (output_bfd, info,
2990 htab->plt_second_sframe,
2991 htab->plt_second_sframe->contents))
2992 return NULL;
2993 }
2994 }
2995 if (htab->elf.sgot && htab->elf.sgot->size > 0)
2996 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
2997 = htab->got_entry_size;
2998
2999 return htab;
3000 }
3001
3002
3003 bool
_bfd_x86_elf_early_size_sections(bfd * output_bfd,struct bfd_link_info * info)3004 _bfd_x86_elf_early_size_sections (bfd *output_bfd,
3005 struct bfd_link_info *info)
3006 {
3007 asection *tls_sec = elf_hash_table (info)->tls_sec;
3008
3009 if (tls_sec && !bfd_link_relocatable (info))
3010 {
3011 struct elf_link_hash_entry *tlsbase;
3012
3013 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3014 "_TLS_MODULE_BASE_",
3015 false, false, false);
3016
3017 if (tlsbase && tlsbase->type == STT_TLS)
3018 {
3019 struct elf_x86_link_hash_table *htab;
3020 struct bfd_link_hash_entry *bh = NULL;
3021 const struct elf_backend_data *bed
3022 = get_elf_backend_data (output_bfd);
3023
3024 htab = elf_x86_hash_table (info, bed->target_id);
3025 if (htab == NULL)
3026 return false;
3027
3028 if (!(_bfd_generic_link_add_one_symbol
3029 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3030 tls_sec, 0, NULL, false,
3031 bed->collect, &bh)))
3032 return false;
3033
3034 htab->tls_module_base = bh;
3035
3036 tlsbase = (struct elf_link_hash_entry *)bh;
3037 tlsbase->def_regular = 1;
3038 tlsbase->other = STV_HIDDEN;
3039 tlsbase->root.linker_def = 1;
3040 (*bed->elf_backend_hide_symbol) (info, tlsbase, true);
3041 }
3042 }
3043
3044 return true;
3045 }
3046
3047 void
_bfd_x86_elf_merge_symbol_attribute(struct elf_link_hash_entry * h,unsigned int st_other,bool definition,bool dynamic ATTRIBUTE_UNUSED)3048 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
3049 unsigned int st_other,
3050 bool definition,
3051 bool dynamic ATTRIBUTE_UNUSED)
3052 {
3053 if (definition)
3054 {
3055 struct elf_x86_link_hash_entry *eh
3056 = (struct elf_x86_link_hash_entry *) h;
3057 eh->def_protected = ELF_ST_VISIBILITY (st_other) == STV_PROTECTED;
3058 }
3059 }
3060
3061 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3062
3063 void
_bfd_x86_elf_copy_indirect_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)3064 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
3065 struct elf_link_hash_entry *dir,
3066 struct elf_link_hash_entry *ind)
3067 {
3068 struct elf_x86_link_hash_entry *edir, *eind;
3069
3070 edir = (struct elf_x86_link_hash_entry *) dir;
3071 eind = (struct elf_x86_link_hash_entry *) ind;
3072
3073 if (ind->root.type == bfd_link_hash_indirect
3074 && dir->got.refcount <= 0)
3075 {
3076 edir->tls_type = eind->tls_type;
3077 eind->tls_type = GOT_UNKNOWN;
3078 }
3079
3080 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
3081 generate a R_386_COPY reloc. */
3082 edir->gotoff_ref |= eind->gotoff_ref;
3083
3084 edir->zero_undefweak |= eind->zero_undefweak;
3085
3086 if (ELIMINATE_COPY_RELOCS
3087 && ind->root.type != bfd_link_hash_indirect
3088 && dir->dynamic_adjusted)
3089 {
3090 /* If called to transfer flags for a weakdef during processing
3091 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
3092 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
3093 if (dir->versioned != versioned_hidden)
3094 dir->ref_dynamic |= ind->ref_dynamic;
3095 dir->ref_regular |= ind->ref_regular;
3096 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
3097 dir->needs_plt |= ind->needs_plt;
3098 dir->pointer_equality_needed |= ind->pointer_equality_needed;
3099 }
3100 else
3101 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3102 }
3103
3104 /* Remove undefined weak symbol from the dynamic symbol table if it
3105 is resolved to 0. */
3106
3107 bool
_bfd_x86_elf_fixup_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)3108 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
3109 struct elf_link_hash_entry *h)
3110 {
3111 if (h->dynindx != -1
3112 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
3113 {
3114 h->dynindx = -1;
3115 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3116 h->dynstr_index);
3117 }
3118 return true;
3119 }
3120
3121 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
3122 executable into the normal function symbol and set its address
3123 to its PLT entry, which should be resolved by R_*_IRELATIVE at
3124 run-time. */
3125
3126 void
_bfd_x86_elf_link_fixup_ifunc_symbol(struct bfd_link_info * info,struct elf_x86_link_hash_table * htab,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)3127 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
3128 struct elf_x86_link_hash_table *htab,
3129 struct elf_link_hash_entry *h,
3130 Elf_Internal_Sym *sym)
3131 {
3132 if (bfd_link_pde (info)
3133 && h->def_regular
3134 && h->dynindx != -1
3135 && h->plt.offset != (bfd_vma) -1
3136 && h->type == STT_GNU_IFUNC)
3137 {
3138 asection *plt_s;
3139 bfd_vma plt_offset;
3140 bfd *output_bfd = info->output_bfd;
3141
3142 if (htab->plt_second)
3143 {
3144 struct elf_x86_link_hash_entry *eh
3145 = (struct elf_x86_link_hash_entry *) h;
3146
3147 plt_s = htab->plt_second;
3148 plt_offset = eh->plt_second.offset;
3149 }
3150 else
3151 {
3152 plt_s = htab->elf.splt;
3153 plt_offset = h->plt.offset;
3154 }
3155
3156 sym->st_size = 0;
3157 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
3158 sym->st_shndx
3159 = _bfd_elf_section_from_bfd_section (output_bfd,
3160 plt_s->output_section);
3161 sym->st_value = (plt_s->output_section->vma
3162 + plt_s->output_offset + plt_offset);
3163 }
3164 }
3165
3166 /* Report relative relocation. */
3167
3168 void
_bfd_x86_elf_link_report_relative_reloc(struct bfd_link_info * info,asection * asect,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym,const char * reloc_name,const void * reloc)3169 _bfd_x86_elf_link_report_relative_reloc
3170 (struct bfd_link_info *info, asection *asect,
3171 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym,
3172 const char *reloc_name, const void *reloc)
3173 {
3174 const char *name;
3175 bfd *abfd;
3176 const Elf_Internal_Rela *rel = (const Elf_Internal_Rela *) reloc;
3177
3178 /* Use the output BFD for linker created sections. */
3179 if ((asect->flags & SEC_LINKER_CREATED) != 0)
3180 abfd = info->output_bfd;
3181 else
3182 abfd = asect->owner;
3183
3184 if (h != NULL && h->root.root.string != NULL)
3185 name = h->root.root.string;
3186 else
3187 name = bfd_elf_sym_name (abfd, &elf_symtab_hdr (abfd), sym, NULL);
3188
3189 if (asect->use_rela_p)
3190 info->callbacks->einfo
3191 (_("%pB: %s (offset: 0x%v, info: 0x%v, addend: 0x%v) against "
3192 "'%s' " "for section '%pA' in %pB\n"),
3193 info->output_bfd, reloc_name, rel->r_offset, rel->r_info,
3194 rel->r_addend, name, asect, abfd);
3195 else
3196 info->callbacks->einfo
3197 (_("%pB: %s (offset: 0x%v, info: 0x%v) against '%s' for section "
3198 "'%pA' in %pB\n"),
3199 info->output_bfd, reloc_name, rel->r_offset, rel->r_info, name,
3200 asect, abfd);
3201 }
3202
3203 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
3204
3205 bool
_bfd_x86_elf_hash_symbol(struct elf_link_hash_entry * h)3206 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
3207 {
3208 if (h->plt.offset != (bfd_vma) -1
3209 && !h->def_regular
3210 && !h->pointer_equality_needed)
3211 return false;
3212
3213 return _bfd_elf_hash_symbol (h);
3214 }
3215
3216 /* Adjust a symbol defined by a dynamic object and referenced by a
3217 regular object. The current definition is in some section of the
3218 dynamic object, but we're not including those sections. We have to
3219 change the definition to something the rest of the link can
3220 understand. */
3221
3222 bool
_bfd_x86_elf_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)3223 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3224 struct elf_link_hash_entry *h)
3225 {
3226 struct elf_x86_link_hash_table *htab;
3227 asection *s, *srel;
3228 struct elf_x86_link_hash_entry *eh;
3229 struct elf_dyn_relocs *p;
3230 const struct elf_backend_data *bed
3231 = get_elf_backend_data (info->output_bfd);
3232
3233 eh = (struct elf_x86_link_hash_entry *) h;
3234
3235 /* Clear GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS if it is turned
3236 on by an input relocatable file and there is a non-GOT/non-PLT
3237 reference from another relocatable file without it.
3238 NB: There can be non-GOT reference in data sections in input with
3239 GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS. */
3240 if (eh->non_got_ref_without_indirect_extern_access
3241 && info->indirect_extern_access == 1
3242 && bfd_link_executable (info))
3243 {
3244 unsigned int needed_1;
3245 info->indirect_extern_access = 0;
3246 /* Turn off nocopyreloc if implied by indirect_extern_access. */
3247 if (info->nocopyreloc == 2)
3248 info->nocopyreloc = 0;
3249 needed_1 = bfd_h_get_32 (info->output_bfd, info->needed_1_p);
3250 needed_1 &= ~GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS;
3251 bfd_h_put_32 (info->output_bfd, needed_1, info->needed_1_p);
3252 }
3253
3254 /* STT_GNU_IFUNC symbol must go through PLT. */
3255 if (h->type == STT_GNU_IFUNC)
3256 {
3257 /* All local STT_GNU_IFUNC references must be treate as local
3258 calls via local PLT. */
3259 if (h->ref_regular
3260 && SYMBOL_CALLS_LOCAL (info, h))
3261 {
3262 bfd_size_type pc_count = 0, count = 0;
3263 struct elf_dyn_relocs **pp;
3264
3265 eh = (struct elf_x86_link_hash_entry *) h;
3266 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
3267 {
3268 pc_count += p->pc_count;
3269 p->count -= p->pc_count;
3270 p->pc_count = 0;
3271 count += p->count;
3272 if (p->count == 0)
3273 *pp = p->next;
3274 else
3275 pp = &p->next;
3276 }
3277
3278 if (pc_count || count)
3279 {
3280 h->non_got_ref = 1;
3281 if (pc_count)
3282 {
3283 /* Increment PLT reference count only for PC-relative
3284 references. */
3285 h->needs_plt = 1;
3286 if (h->plt.refcount <= 0)
3287 h->plt.refcount = 1;
3288 else
3289 h->plt.refcount += 1;
3290 }
3291 }
3292
3293 /* GOTOFF relocation needs PLT. */
3294 if (eh->gotoff_ref)
3295 h->plt.refcount = 1;
3296 }
3297
3298 if (h->plt.refcount <= 0)
3299 {
3300 h->plt.offset = (bfd_vma) -1;
3301 h->needs_plt = 0;
3302 }
3303 return true;
3304 }
3305
3306 /* If this is a function, put it in the procedure linkage table. We
3307 will fill in the contents of the procedure linkage table later,
3308 when we know the address of the .got section. */
3309 if (h->type == STT_FUNC
3310 || h->needs_plt)
3311 {
3312 if (h->plt.refcount <= 0
3313 || SYMBOL_CALLS_LOCAL (info, h)
3314 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3315 && h->root.type == bfd_link_hash_undefweak))
3316 {
3317 /* This case can occur if we saw a PLT32 reloc in an input
3318 file, but the symbol was never referred to by a dynamic
3319 object, or if all references were garbage collected. In
3320 such a case, we don't actually need to build a procedure
3321 linkage table, and we can just do a PC32 reloc instead. */
3322 h->plt.offset = (bfd_vma) -1;
3323 h->needs_plt = 0;
3324 }
3325
3326 return true;
3327 }
3328 else
3329 /* It's possible that we incorrectly decided a .plt reloc was needed
3330 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
3331 check_relocs. We can't decide accurately between function and
3332 non-function syms in check-relocs; Objects loaded later in
3333 the link may change h->type. So fix it now. */
3334 h->plt.offset = (bfd_vma) -1;
3335
3336 /* If this is a weak symbol, and there is a real definition, the
3337 processor independent code will have arranged for us to see the
3338 real definition first, and we can just use the same value. */
3339 if (h->is_weakalias)
3340 {
3341 struct elf_link_hash_entry *def = weakdef (h);
3342 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3343 h->root.u.def.section = def->root.u.def.section;
3344 h->root.u.def.value = def->root.u.def.value;
3345 if (ELIMINATE_COPY_RELOCS
3346 || info->nocopyreloc
3347 || SYMBOL_NO_COPYRELOC (info, eh))
3348 {
3349 /* NB: needs_copy is always 0 for i386. */
3350 h->non_got_ref = def->non_got_ref;
3351 eh->needs_copy = def->needs_copy;
3352 }
3353 return true;
3354 }
3355
3356 /* This is a reference to a symbol defined by a dynamic object which
3357 is not a function. */
3358
3359 /* If we are creating a shared library, we must presume that the
3360 only references to the symbol are via the global offset table.
3361 For such cases we need not do anything here; the relocations will
3362 be handled correctly by relocate_section. */
3363 if (!bfd_link_executable (info))
3364 return true;
3365
3366 /* If there are no references to this symbol that do not use the
3367 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
3368 reloc. NB: gotoff_ref is always 0 for x86-64. */
3369 if (!h->non_got_ref && !eh->gotoff_ref)
3370 return true;
3371
3372 /* If -z nocopyreloc was given, we won't generate them either. */
3373 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
3374 {
3375 h->non_got_ref = 0;
3376 return true;
3377 }
3378
3379 htab = elf_x86_hash_table (info, bed->target_id);
3380 if (htab == NULL)
3381 return false;
3382
3383 /* If there aren't any dynamic relocs in read-only sections nor
3384 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
3385 avoid the copy reloc. This doesn't work on VxWorks, where we can
3386 not have dynamic relocations (other than copy and jump slot
3387 relocations) in an executable. */
3388 if (ELIMINATE_COPY_RELOCS
3389 && (bed->target_id == X86_64_ELF_DATA
3390 || (!eh->gotoff_ref
3391 && htab->elf.target_os != is_vxworks)))
3392 {
3393 /* If we don't find any dynamic relocs in read-only sections,
3394 then we'll be keeping the dynamic relocs and avoiding the copy
3395 reloc. */
3396 if (!_bfd_elf_readonly_dynrelocs (h))
3397 {
3398 h->non_got_ref = 0;
3399 return true;
3400 }
3401 }
3402
3403 /* We must allocate the symbol in our .dynbss section, which will
3404 become part of the .bss section of the executable. There will be
3405 an entry for this symbol in the .dynsym section. The dynamic
3406 object will contain position independent code, so all references
3407 from the dynamic object to this symbol will go through the global
3408 offset table. The dynamic linker will use the .dynsym entry to
3409 determine the address it must put in the global offset table, so
3410 both the dynamic object and the regular object will refer to the
3411 same memory location for the variable. */
3412
3413 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
3414 dynamic linker to copy the initial value out of the dynamic object
3415 and into the runtime process image. */
3416 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
3417 {
3418 s = htab->elf.sdynrelro;
3419 srel = htab->elf.sreldynrelro;
3420 }
3421 else
3422 {
3423 s = htab->elf.sdynbss;
3424 srel = htab->elf.srelbss;
3425 }
3426 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3427 {
3428 if (eh->def_protected && bfd_link_executable (info))
3429 for (p = h->dyn_relocs; p != NULL; p = p->next)
3430 {
3431 /* Disallow copy relocation against non-copyable protected
3432 symbol. */
3433 s = p->sec->output_section;
3434 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3435 {
3436 info->callbacks->einfo
3437 /* xgettext:c-format */
3438 (_("%F%P: %pB: copy relocation against non-copyable "
3439 "protected symbol `%s' in %pB\n"),
3440 p->sec->owner, h->root.root.string,
3441 h->root.u.def.section->owner);
3442 return false;
3443 }
3444 }
3445
3446 srel->size += htab->sizeof_reloc;
3447 h->needs_copy = 1;
3448 }
3449
3450 return _bfd_elf_adjust_dynamic_copy (info, h, s);
3451 }
3452
3453 void
_bfd_x86_elf_hide_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h,bool force_local)3454 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
3455 struct elf_link_hash_entry *h,
3456 bool force_local)
3457 {
3458 if (h->root.type == bfd_link_hash_undefweak
3459 && info->nointerp
3460 && bfd_link_pie (info))
3461 {
3462 /* When there is no dynamic interpreter in PIE, make the undefined
3463 weak symbol dynamic so that PC relative branch to the undefined
3464 weak symbol will land to address 0. */
3465 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
3466 if (h->plt.refcount > 0
3467 || eh->plt_got.refcount > 0)
3468 return;
3469 }
3470
3471 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3472 }
3473
3474 /* Return TRUE if a symbol is referenced locally. It is similar to
3475 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
3476 works in check_relocs. */
3477
3478 bool
_bfd_x86_elf_link_symbol_references_local(struct bfd_link_info * info,struct elf_link_hash_entry * h)3479 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
3480 struct elf_link_hash_entry *h)
3481 {
3482 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
3483 struct elf_x86_link_hash_table *htab
3484 = (struct elf_x86_link_hash_table *) info->hash;
3485
3486 if (eh->local_ref > 1)
3487 return true;
3488
3489 if (eh->local_ref == 1)
3490 return false;
3491
3492 /* Unversioned symbols defined in regular objects can be forced local
3493 by linker version script. A weak undefined symbol is forced local
3494 if
3495 1. It has non-default visibility. Or
3496 2. When building executable, there is no dynamic linker. Or
3497 3. or "-z nodynamic-undefined-weak" is used.
3498 */
3499 if (_bfd_elf_symbol_refs_local_p (h, info, 1)
3500 || (h->root.type == bfd_link_hash_undefweak
3501 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3502 || (bfd_link_executable (info)
3503 && htab->interp == NULL)
3504 || info->dynamic_undefined_weak == 0))
3505 || ((h->def_regular || ELF_COMMON_DEF_P (h))
3506 && info->version_info != NULL
3507 && _bfd_elf_link_hide_sym_by_version (info, h)))
3508 {
3509 eh->local_ref = 2;
3510 return true;
3511 }
3512
3513 eh->local_ref = 1;
3514 return false;
3515 }
3516
3517 /* Return the section that should be marked against GC for a given
3518 relocation. */
3519
3520 asection *
_bfd_x86_elf_gc_mark_hook(asection * sec,struct bfd_link_info * info,Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)3521 _bfd_x86_elf_gc_mark_hook (asection *sec,
3522 struct bfd_link_info *info,
3523 Elf_Internal_Rela *rel,
3524 struct elf_link_hash_entry *h,
3525 Elf_Internal_Sym *sym)
3526 {
3527 /* Compiler should optimize this out. */
3528 if (((unsigned int) R_X86_64_GNU_VTINHERIT
3529 != (unsigned int) R_386_GNU_VTINHERIT)
3530 || ((unsigned int) R_X86_64_GNU_VTENTRY
3531 != (unsigned int) R_386_GNU_VTENTRY))
3532 abort ();
3533
3534 if (h != NULL)
3535 switch (ELF32_R_TYPE (rel->r_info))
3536 {
3537 case R_X86_64_GNU_VTINHERIT:
3538 case R_X86_64_GNU_VTENTRY:
3539 return NULL;
3540 }
3541
3542 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3543 }
3544
3545 static bfd_vma
elf_i386_get_plt_got_vma(struct elf_x86_plt * plt_p ATTRIBUTE_UNUSED,bfd_vma off,bfd_vma offset ATTRIBUTE_UNUSED,bfd_vma got_addr)3546 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
3547 bfd_vma off,
3548 bfd_vma offset ATTRIBUTE_UNUSED,
3549 bfd_vma got_addr)
3550 {
3551 return got_addr + off;
3552 }
3553
3554 static bfd_vma
elf_x86_64_get_plt_got_vma(struct elf_x86_plt * plt_p,bfd_vma off,bfd_vma offset,bfd_vma got_addr ATTRIBUTE_UNUSED)3555 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
3556 bfd_vma off,
3557 bfd_vma offset,
3558 bfd_vma got_addr ATTRIBUTE_UNUSED)
3559 {
3560 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
3561 }
3562
3563 static bool
elf_i386_valid_plt_reloc_p(unsigned int type)3564 elf_i386_valid_plt_reloc_p (unsigned int type)
3565 {
3566 return (type == R_386_JUMP_SLOT
3567 || type == R_386_GLOB_DAT
3568 || type == R_386_IRELATIVE);
3569 }
3570
3571 static bool
elf_x86_64_valid_plt_reloc_p(unsigned int type)3572 elf_x86_64_valid_plt_reloc_p (unsigned int type)
3573 {
3574 return (type == R_X86_64_JUMP_SLOT
3575 || type == R_X86_64_GLOB_DAT
3576 || type == R_X86_64_IRELATIVE);
3577 }
3578
3579 long
_bfd_x86_elf_get_synthetic_symtab(bfd * abfd,long count,long relsize,bfd_vma got_addr,struct elf_x86_plt plts[],asymbol ** dynsyms,asymbol ** ret)3580 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
3581 long count,
3582 long relsize,
3583 bfd_vma got_addr,
3584 struct elf_x86_plt plts[],
3585 asymbol **dynsyms,
3586 asymbol **ret)
3587 {
3588 long size, i, n, len;
3589 int j;
3590 unsigned int plt_got_offset, plt_entry_size;
3591 asymbol *s;
3592 bfd_byte *plt_contents;
3593 long dynrelcount;
3594 arelent **dynrelbuf, *p;
3595 char *names;
3596 const struct elf_backend_data *bed;
3597 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
3598 bfd_vma);
3599 bool (*valid_plt_reloc_p) (unsigned int);
3600 unsigned int jump_slot_reloc;
3601
3602 dynrelbuf = NULL;
3603 if (count == 0)
3604 goto bad_return;
3605
3606 dynrelbuf = (arelent **) bfd_malloc (relsize);
3607 if (dynrelbuf == NULL)
3608 goto bad_return;
3609
3610 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
3611 dynsyms);
3612 if (dynrelcount <= 0)
3613 goto bad_return;
3614
3615 /* Sort the relocs by address. */
3616 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
3617 _bfd_x86_elf_compare_relocs);
3618
3619 size = count * sizeof (asymbol);
3620
3621 /* Allocate space for @plt suffixes. */
3622 n = 0;
3623 for (i = 0; i < dynrelcount; i++)
3624 {
3625 p = dynrelbuf[i];
3626 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3627 if (p->addend != 0)
3628 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
3629 }
3630
3631 s = *ret = (asymbol *) bfd_zmalloc (size);
3632 if (s == NULL)
3633 goto bad_return;
3634
3635 bed = get_elf_backend_data (abfd);
3636
3637 if (bed->target_id == X86_64_ELF_DATA)
3638 {
3639 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
3640 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
3641 jump_slot_reloc = R_X86_64_JUMP_SLOT;
3642 }
3643 else
3644 {
3645 get_plt_got_vma = elf_i386_get_plt_got_vma;
3646 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
3647 jump_slot_reloc = R_386_JUMP_SLOT;
3648 if (got_addr)
3649 {
3650 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
3651 address. */
3652 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
3653 if (sec != NULL)
3654 got_addr = sec->vma;
3655 else
3656 {
3657 sec = bfd_get_section_by_name (abfd, ".got");
3658 if (sec != NULL)
3659 got_addr = sec->vma;
3660 }
3661
3662 if (got_addr == (bfd_vma) -1)
3663 goto bad_return;
3664 }
3665 }
3666
3667 /* Check for each PLT section. */
3668 names = (char *) (s + count);
3669 size = 0;
3670 n = 0;
3671 for (j = 0; plts[j].name != NULL; j++)
3672 if ((plt_contents = plts[j].contents) != NULL)
3673 {
3674 long k;
3675 bfd_vma offset;
3676 asection *plt;
3677 struct elf_x86_plt *plt_p = &plts[j];
3678
3679 plt_got_offset = plt_p->plt_got_offset;
3680 plt_entry_size = plt_p->plt_entry_size;
3681
3682 plt = plt_p->sec;
3683
3684 if ((plt_p->type & plt_lazy))
3685 {
3686 /* Skip PLT0 in lazy PLT. */
3687 k = 1;
3688 offset = plt_entry_size;
3689 }
3690 else
3691 {
3692 k = 0;
3693 offset = 0;
3694 }
3695
3696 /* Check each PLT entry against dynamic relocations. */
3697 for (; k < plt_p->count; k++)
3698 {
3699 int off;
3700 bfd_vma got_vma;
3701 long min, max, mid;
3702
3703 /* Get the GOT offset for i386 or the PC-relative offset
3704 for x86-64, a signed 32-bit integer. */
3705 off = H_GET_32 (abfd, (plt_contents + offset
3706 + plt_got_offset));
3707 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
3708
3709 /* Binary search. */
3710 p = dynrelbuf[0];
3711 min = 0;
3712 max = dynrelcount;
3713 while ((min + 1) < max)
3714 {
3715 arelent *r;
3716
3717 mid = (min + max) / 2;
3718 r = dynrelbuf[mid];
3719 if (got_vma > r->address)
3720 min = mid;
3721 else if (got_vma < r->address)
3722 max = mid;
3723 else
3724 {
3725 p = r;
3726 break;
3727 }
3728 }
3729
3730 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
3731 if (got_vma == p->address
3732 && p->howto != NULL
3733 && valid_plt_reloc_p (p->howto->type))
3734 {
3735 *s = **p->sym_ptr_ptr;
3736 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
3737 set. Since we are defining a symbol, ensure one
3738 of them is set. */
3739 if ((s->flags & BSF_LOCAL) == 0)
3740 s->flags |= BSF_GLOBAL;
3741 s->flags |= BSF_SYNTHETIC;
3742 /* This is no longer a section symbol. */
3743 s->flags &= ~BSF_SECTION_SYM;
3744 s->section = plt;
3745 s->the_bfd = plt->owner;
3746 s->value = offset;
3747 s->udata.p = NULL;
3748 s->name = names;
3749 len = strlen ((*p->sym_ptr_ptr)->name);
3750 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3751 names += len;
3752 /* There may be JUMP_SLOT and IRELATIVE relocations.
3753 JUMP_SLOT r_addend should be ignored. */
3754 if (p->addend != 0 && p->howto->type != jump_slot_reloc)
3755 {
3756 char buf[30], *a;
3757
3758 memcpy (names, "+0x", sizeof ("+0x") - 1);
3759 names += sizeof ("+0x") - 1;
3760 bfd_sprintf_vma (abfd, buf, p->addend);
3761 for (a = buf; *a == '0'; ++a)
3762 ;
3763 size = strlen (a);
3764 memcpy (names, a, size);
3765 names += size;
3766 }
3767 memcpy (names, "@plt", sizeof ("@plt"));
3768 names += sizeof ("@plt");
3769 n++;
3770 s++;
3771 /* There should be only one entry in PLT for a given
3772 symbol. Set howto to NULL after processing a PLT
3773 entry to guard against corrupted PLT. */
3774 p->howto = NULL;
3775 }
3776 offset += plt_entry_size;
3777 }
3778 }
3779
3780 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
3781 if (n == 0)
3782 {
3783 bad_return:
3784 count = -1;
3785 }
3786 else
3787 count = n;
3788
3789 for (j = 0; plts[j].name != NULL; j++)
3790 _bfd_elf_munmap_section_contents (plts[j].sec, plts[j].contents);
3791
3792 free (dynrelbuf);
3793
3794 return count;
3795 }
3796
3797 /* Parse x86 GNU properties. */
3798
3799 enum elf_property_kind
_bfd_x86_elf_parse_gnu_properties(bfd * abfd,unsigned int type,bfd_byte * ptr,unsigned int datasz)3800 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
3801 bfd_byte *ptr, unsigned int datasz)
3802 {
3803 elf_property *prop;
3804
3805 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3806 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3807 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
3808 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3809 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
3810 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
3811 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3812 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
3813 {
3814 if (datasz != 4)
3815 {
3816 _bfd_error_handler
3817 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
3818 abfd, type, datasz);
3819 return property_corrupt;
3820 }
3821 prop = _bfd_elf_get_property (abfd, type, datasz);
3822 prop->u.number |= bfd_h_get_32 (abfd, ptr);
3823 prop->pr_kind = property_number;
3824 return property_number;
3825 }
3826
3827 return property_ignored;
3828 }
3829
3830 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
3831 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
3832 should be merged with ABFD. */
3833
3834 bool
_bfd_x86_elf_merge_gnu_properties(struct bfd_link_info * info,bfd * abfd ATTRIBUTE_UNUSED,bfd * bbfd ATTRIBUTE_UNUSED,elf_property * aprop,elf_property * bprop)3835 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
3836 bfd *abfd ATTRIBUTE_UNUSED,
3837 bfd *bbfd ATTRIBUTE_UNUSED,
3838 elf_property *aprop,
3839 elf_property *bprop)
3840 {
3841 unsigned int number, features;
3842 bool updated = false;
3843 const struct elf_backend_data *bed;
3844 struct elf_x86_link_hash_table *htab;
3845 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
3846
3847 if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3848 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3849 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
3850 {
3851 if (aprop == NULL || bprop == NULL)
3852 {
3853 /* Only one of APROP and BPROP can be NULL. */
3854 if (aprop != NULL)
3855 {
3856 /* Remove this property since the other input file doesn't
3857 have it. */
3858 aprop->pr_kind = property_remove;
3859 updated = true;
3860 }
3861 }
3862 else
3863 {
3864 number = aprop->u.number;
3865 aprop->u.number = number | bprop->u.number;
3866 updated = number != (unsigned int) aprop->u.number;
3867 }
3868 return updated;
3869 }
3870 else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3871 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO
3872 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI))
3873 {
3874 features = 0;
3875 if (pr_type == GNU_PROPERTY_X86_ISA_1_NEEDED)
3876 {
3877 bed = get_elf_backend_data (info->output_bfd);
3878 htab = elf_x86_hash_table (info, bed->target_id);
3879 switch (htab->params->isa_level)
3880 {
3881 case 0:
3882 break;
3883 case 2:
3884 features = GNU_PROPERTY_X86_ISA_1_V2;
3885 break;
3886 case 3:
3887 features = GNU_PROPERTY_X86_ISA_1_V3;
3888 break;
3889 case 4:
3890 features = GNU_PROPERTY_X86_ISA_1_V4;
3891 break;
3892 default:
3893 abort ();
3894 }
3895 }
3896 if (aprop != NULL && bprop != NULL)
3897 {
3898 number = aprop->u.number;
3899 aprop->u.number = number | bprop->u.number | features;
3900 /* Remove the property if all bits are empty. */
3901 if (aprop->u.number == 0)
3902 {
3903 aprop->pr_kind = property_remove;
3904 updated = true;
3905 }
3906 else
3907 updated = number != (unsigned int) aprop->u.number;
3908 }
3909 else
3910 {
3911 /* Only one of APROP and BPROP can be NULL. */
3912 if (aprop != NULL)
3913 {
3914 aprop->u.number |= features;
3915 if (aprop->u.number == 0)
3916 {
3917 /* Remove APROP if all bits are empty. */
3918 aprop->pr_kind = property_remove;
3919 updated = true;
3920 }
3921 }
3922 else
3923 {
3924 /* Return TRUE if APROP is NULL and all bits of BPROP
3925 aren't empty to indicate that BPROP should be added
3926 to ABFD. */
3927 bprop->u.number |= features;
3928 updated = bprop->u.number != 0;
3929 }
3930 }
3931 return updated;
3932 }
3933 else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO
3934 && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3935 {
3936 /* Only one of APROP and BPROP can be NULL:
3937 1. APROP & BPROP when both APROP and BPROP aren't NULL.
3938 2. If APROP is NULL, remove x86 feature.
3939 3. Otherwise, do nothing.
3940 */
3941 bed = get_elf_backend_data (info->output_bfd);
3942 htab = elf_x86_hash_table (info, bed->target_id);
3943 if (!htab)
3944 abort ();
3945 if (aprop != NULL && bprop != NULL)
3946 {
3947 number = aprop->u.number;
3948 aprop->u.number = number & bprop->u.number;
3949 if (pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
3950 {
3951 features = 0;
3952 if (htab->params->ibt)
3953 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
3954 if (htab->params->shstk)
3955 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
3956 if (htab->params->lam_u48)
3957 features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
3958 | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
3959 else if (htab->params->lam_u57)
3960 features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
3961 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT,
3962 GNU_PROPERTY_X86_FEATURE_1_SHSTK,
3963 GNU_PROPERTY_X86_FEATURE_1_LAM_U48 and
3964 GNU_PROPERTY_X86_FEATURE_1_LAM_U57. */
3965 aprop->u.number |= features;
3966 }
3967 updated = number != (unsigned int) aprop->u.number;
3968 /* Remove the property if all feature bits are cleared. */
3969 if (aprop->u.number == 0)
3970 aprop->pr_kind = property_remove;
3971 }
3972 else
3973 {
3974 /* There should be no AND properties since some input doesn't
3975 have them. Set IBT and SHSTK properties for -z ibt and -z
3976 shstk if needed. */
3977 features = 0;
3978 if (pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
3979 {
3980 if (htab->params->ibt)
3981 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
3982 if (htab->params->shstk)
3983 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
3984 if (htab->params->lam_u48)
3985 features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
3986 | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
3987 else if (htab->params->lam_u57)
3988 features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
3989 }
3990 if (features)
3991 {
3992 if (aprop != NULL)
3993 {
3994 updated = features != (unsigned int) aprop->u.number;
3995 aprop->u.number = features;
3996 }
3997 else
3998 {
3999 updated = true;
4000 bprop->u.number = features;
4001 }
4002 }
4003 else if (aprop != NULL)
4004 {
4005 aprop->pr_kind = property_remove;
4006 updated = true;
4007 }
4008 }
4009 return updated;
4010 }
4011 else
4012 {
4013 /* Never should happen. */
4014 abort ();
4015 }
4016
4017 return updated;
4018 }
4019
4020 /* Set up x86 GNU properties. Return the first relocatable ELF input
4021 with GNU properties if found. Otherwise, return NULL. */
4022
4023 bfd *
_bfd_x86_elf_link_setup_gnu_properties(struct bfd_link_info * info,struct elf_x86_init_table * init_table)4024 _bfd_x86_elf_link_setup_gnu_properties
4025 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
4026 {
4027 bool normal_target;
4028 bool lazy_plt;
4029 asection *sec, *pltsec;
4030 bfd *dynobj;
4031 bool use_ibt_plt;
4032 unsigned int plt_alignment, features, isa_level;
4033 struct elf_x86_link_hash_table *htab;
4034 bfd *pbfd;
4035 bfd *ebfd = NULL;
4036 elf_property *prop;
4037 const struct elf_backend_data *bed;
4038 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
4039 unsigned int got_align;
4040
4041 /* Find a normal input file with GNU property note. */
4042 for (pbfd = info->input_bfds;
4043 pbfd != NULL;
4044 pbfd = pbfd->link.next)
4045 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
4046 && bfd_count_sections (pbfd) != 0)
4047 {
4048 ebfd = pbfd;
4049
4050 if (elf_properties (pbfd) != NULL)
4051 break;
4052 }
4053
4054 bed = get_elf_backend_data (info->output_bfd);
4055
4056 htab = elf_x86_hash_table (info, bed->target_id);
4057 if (htab == NULL)
4058 return pbfd;
4059
4060 features = 0;
4061 if (htab->params->ibt)
4062 {
4063 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
4064 htab->params->cet_report &= ~prop_report_ibt;
4065 }
4066 if (htab->params->shstk)
4067 {
4068 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
4069 htab->params->cet_report &= ~prop_report_shstk;
4070 }
4071 if (!(htab->params->cet_report & (prop_report_ibt | prop_report_shstk)))
4072 htab->params->cet_report = prop_report_none;
4073 if (htab->params->lam_u48)
4074 {
4075 features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
4076 | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4077 htab->params->lam_u48_report = prop_report_none;
4078 htab->params->lam_u57_report = prop_report_none;
4079 }
4080 else if (htab->params->lam_u57)
4081 {
4082 features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
4083 htab->params->lam_u57_report = prop_report_none;
4084 }
4085
4086 switch (htab->params->isa_level)
4087 {
4088 case 0:
4089 isa_level = 0;
4090 break;
4091 case 1:
4092 isa_level = GNU_PROPERTY_X86_ISA_1_BASELINE;
4093 break;
4094 case 2:
4095 isa_level = GNU_PROPERTY_X86_ISA_1_V2;
4096 break;
4097 case 3:
4098 isa_level = GNU_PROPERTY_X86_ISA_1_V3;
4099 break;
4100 case 4:
4101 isa_level = GNU_PROPERTY_X86_ISA_1_V4;
4102 break;
4103 default:
4104 abort ();
4105 }
4106
4107 if (ebfd != NULL)
4108 {
4109 prop = NULL;
4110 if (features)
4111 {
4112 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT,
4113 GNU_PROPERTY_X86_FEATURE_1_SHSTK,
4114 GNU_PROPERTY_X86_FEATURE_1_LAM_U48 and
4115 GNU_PROPERTY_X86_FEATURE_1_LAM_U57. */
4116 prop = _bfd_elf_get_property (ebfd,
4117 GNU_PROPERTY_X86_FEATURE_1_AND,
4118 4);
4119 prop->u.number |= features;
4120 prop->pr_kind = property_number;
4121 }
4122
4123 if (isa_level)
4124 {
4125 /* If ISA level is set, add GNU_PROPERTY_X86_ISA_1_NEEDED. */
4126 prop = _bfd_elf_get_property (ebfd,
4127 GNU_PROPERTY_X86_ISA_1_NEEDED,
4128 4);
4129 prop->u.number |= isa_level;
4130 prop->pr_kind = property_number;
4131 }
4132
4133 /* Create the GNU property note section if needed. */
4134 if (prop != NULL && pbfd == NULL)
4135 {
4136 sec = bfd_make_section_with_flags (ebfd,
4137 NOTE_GNU_PROPERTY_SECTION_NAME,
4138 (SEC_ALLOC
4139 | SEC_LOAD
4140 | SEC_IN_MEMORY
4141 | SEC_READONLY
4142 | SEC_HAS_CONTENTS
4143 | SEC_DATA));
4144 if (sec == NULL)
4145 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
4146
4147 if (!bfd_set_section_alignment (sec, class_align))
4148 {
4149 error_alignment:
4150 info->callbacks->einfo (_("%F%pA: failed to align section\n"),
4151 sec);
4152 }
4153
4154 elf_section_type (sec) = SHT_NOTE;
4155 }
4156 }
4157
4158 if (htab->params->cet_report
4159 || htab->params->lam_u48_report
4160 || htab->params->lam_u57_report)
4161 {
4162 /* Report missing IBT, SHSTK and LAM properties. */
4163 bfd *abfd;
4164 const char *warning_msg = _("%P: %pB: warning: missing %s\n");
4165 const char *error_msg = _("%X%P: %pB: error: missing %s\n");
4166 const char *cet_msg = NULL;
4167 const char *lam_u48_msg = NULL;
4168 const char *lam_u57_msg = NULL;
4169 const char *missing;
4170 elf_property_list *p;
4171 bool missing_ibt, missing_shstk;
4172 bool missing_lam_u48, missing_lam_u57;
4173 bool check_ibt
4174 = (htab->params->cet_report
4175 && (htab->params->cet_report & prop_report_ibt));
4176 bool check_shstk
4177 = (htab->params->cet_report
4178 && (htab->params->cet_report & prop_report_shstk));
4179
4180 if (htab->params->cet_report)
4181 {
4182 if ((htab->params->cet_report & prop_report_warning))
4183 cet_msg = warning_msg;
4184 else
4185 cet_msg = error_msg;
4186 }
4187 if (htab->params->lam_u48_report)
4188 {
4189 if ((htab->params->lam_u48_report & prop_report_warning))
4190 lam_u48_msg = warning_msg;
4191 else
4192 lam_u48_msg = error_msg;
4193 }
4194 if (htab->params->lam_u57_report)
4195 {
4196 if ((htab->params->lam_u57_report & prop_report_warning))
4197 lam_u57_msg = warning_msg;
4198 else
4199 lam_u57_msg = error_msg;
4200 }
4201
4202 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
4203 if (!(abfd->flags & (DYNAMIC | BFD_PLUGIN | BFD_LINKER_CREATED))
4204 && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
4205 {
4206 for (p = elf_properties (abfd); p; p = p->next)
4207 if (p->property.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
4208 break;
4209
4210 missing_ibt = check_ibt;
4211 missing_shstk = check_shstk;
4212 missing_lam_u48 = !!lam_u48_msg;
4213 missing_lam_u57 = !!lam_u57_msg;
4214 if (p)
4215 {
4216 missing_ibt &= !(p->property.u.number
4217 & GNU_PROPERTY_X86_FEATURE_1_IBT);
4218 missing_shstk &= !(p->property.u.number
4219 & GNU_PROPERTY_X86_FEATURE_1_SHSTK);
4220 missing_lam_u48 &= !(p->property.u.number
4221 & GNU_PROPERTY_X86_FEATURE_1_LAM_U48);
4222 missing_lam_u57 &= !(p->property.u.number
4223 & GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4224 }
4225 if (missing_ibt || missing_shstk)
4226 {
4227 if (missing_ibt && missing_shstk)
4228 missing = _("IBT and SHSTK properties");
4229 else if (missing_ibt)
4230 missing = _("IBT property");
4231 else
4232 missing = _("SHSTK property");
4233 info->callbacks->einfo (cet_msg, abfd, missing);
4234 }
4235 if (missing_lam_u48)
4236 {
4237 missing = _("LAM_U48 property");
4238 info->callbacks->einfo (lam_u48_msg, abfd, missing);
4239 }
4240 if (missing_lam_u57)
4241 {
4242 missing = _("LAM_U57 property");
4243 info->callbacks->einfo (lam_u57_msg, abfd, missing);
4244 }
4245 }
4246 }
4247
4248 pbfd = _bfd_elf_link_setup_gnu_properties (info);
4249
4250 htab->r_info = init_table->r_info;
4251 htab->r_sym = init_table->r_sym;
4252
4253 if (bfd_link_relocatable (info))
4254 return pbfd;
4255
4256 htab->plt0_pad_byte = init_table->plt0_pad_byte;
4257
4258 use_ibt_plt = htab->params->ibtplt || htab->params->ibt;
4259 if (!use_ibt_plt && pbfd != NULL)
4260 {
4261 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
4262 elf_property_list *p;
4263
4264 /* The property list is sorted in order of type. */
4265 for (p = elf_properties (pbfd); p; p = p->next)
4266 {
4267 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
4268 {
4269 use_ibt_plt = !!(p->property.u.number
4270 & GNU_PROPERTY_X86_FEATURE_1_IBT);
4271 break;
4272 }
4273 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
4274 break;
4275 }
4276 }
4277
4278 dynobj = htab->elf.dynobj;
4279
4280 /* Set htab->elf.dynobj here so that there is no need to check and
4281 set it in check_relocs. */
4282 if (dynobj == NULL)
4283 {
4284 if (pbfd != NULL)
4285 {
4286 htab->elf.dynobj = pbfd;
4287 dynobj = pbfd;
4288 }
4289 else
4290 {
4291 bfd *abfd;
4292
4293 /* Find a normal input file to hold linker created
4294 sections. */
4295 for (abfd = info->input_bfds;
4296 abfd != NULL;
4297 abfd = abfd->link.next)
4298 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
4299 && (abfd->flags
4300 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
4301 && bed->relocs_compatible (abfd->xvec,
4302 info->output_bfd->xvec))
4303 {
4304 htab->elf.dynobj = abfd;
4305 dynobj = abfd;
4306 break;
4307 }
4308 }
4309 }
4310
4311 /* Return if there are no normal input files. */
4312 if (dynobj == NULL)
4313 return pbfd;
4314
4315 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
4316 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
4317 canonical function address. */
4318 htab->plt.has_plt0 = 1;
4319 htab->plt.plt_indirect_branch_offset = 0;
4320 normal_target = htab->elf.target_os == is_normal;
4321
4322 if (normal_target)
4323 {
4324 if (use_ibt_plt)
4325 {
4326 htab->lazy_plt = init_table->lazy_ibt_plt;
4327 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
4328 htab->plt.plt_indirect_branch_offset = 4;
4329 }
4330 else
4331 {
4332 htab->lazy_plt = init_table->lazy_plt;
4333 htab->non_lazy_plt = init_table->non_lazy_plt;
4334 }
4335 }
4336 else
4337 {
4338 htab->lazy_plt = init_table->lazy_plt;
4339 htab->non_lazy_plt = NULL;
4340 }
4341
4342 pltsec = htab->elf.splt;
4343
4344 if (htab->non_lazy_plt != NULL
4345 && (!htab->plt.has_plt0 || pltsec == NULL))
4346 lazy_plt = false;
4347 else
4348 lazy_plt = true;
4349
4350 if (normal_target)
4351 {
4352 if (use_ibt_plt)
4353 {
4354 if (lazy_plt)
4355 htab->sframe_plt = init_table->sframe_lazy_ibt_plt;
4356 else
4357 htab->sframe_plt = init_table->sframe_non_lazy_ibt_plt;
4358 }
4359 else
4360 {
4361 if (lazy_plt)
4362 htab->sframe_plt = init_table->sframe_lazy_plt;
4363 else
4364 htab->sframe_plt = init_table->sframe_non_lazy_plt;
4365 }
4366 }
4367 else
4368 htab->sframe_plt = NULL;
4369
4370 /* If the non-lazy PLT is available, use it for all PLT entries if
4371 there are no PLT0 or no .plt section. */
4372 if (!lazy_plt)
4373 {
4374 if (bfd_link_pic (info))
4375 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
4376 else
4377 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
4378 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
4379 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
4380 htab->plt.plt_got_insn_size
4381 = htab->non_lazy_plt->plt_got_insn_size;
4382 htab->plt.eh_frame_plt_size
4383 = htab->non_lazy_plt->eh_frame_plt_size;
4384 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
4385 }
4386 else
4387 {
4388 if (bfd_link_pic (info))
4389 {
4390 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
4391 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
4392 }
4393 else
4394 {
4395 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
4396 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
4397 }
4398 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
4399 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
4400 htab->plt.plt_got_insn_size
4401 = htab->lazy_plt->plt_got_insn_size;
4402 htab->plt.eh_frame_plt_size
4403 = htab->lazy_plt->eh_frame_plt_size;
4404 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
4405 }
4406
4407 if (htab->elf.target_os == is_vxworks
4408 && !elf_vxworks_create_dynamic_sections (dynobj, info,
4409 &htab->srelplt2))
4410 {
4411 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
4412 return pbfd;
4413 }
4414
4415 /* Since create_dynamic_sections isn't always called, but GOT
4416 relocations need GOT relocations, create them here so that we
4417 don't need to do it in check_relocs. */
4418 if (htab->elf.sgot == NULL
4419 && !_bfd_elf_create_got_section (dynobj, info))
4420 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
4421
4422 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
4423
4424 /* Align .got and .got.plt sections to their entry size. Do it here
4425 instead of in create_dynamic_sections so that they are always
4426 properly aligned even if create_dynamic_sections isn't called. */
4427 sec = htab->elf.sgot;
4428 if (!bfd_set_section_alignment (sec, got_align))
4429 goto error_alignment;
4430
4431 sec = htab->elf.sgotplt;
4432 if (!bfd_set_section_alignment (sec, got_align))
4433 goto error_alignment;
4434
4435 /* Create the ifunc sections here so that check_relocs can be
4436 simplified. */
4437 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
4438 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
4439
4440 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
4441
4442 if (pltsec != NULL)
4443 {
4444 /* Whe creating executable, set the contents of the .interp
4445 section to the interpreter. */
4446 if (bfd_link_executable (info) && !info->nointerp)
4447 {
4448 asection *s = bfd_get_linker_section (dynobj, ".interp");
4449 if (s == NULL)
4450 abort ();
4451 s->size = htab->dynamic_interpreter_size;
4452 s->contents = (unsigned char *) htab->dynamic_interpreter;
4453 htab->interp = s;
4454 }
4455
4456 if (normal_target)
4457 {
4458 flagword pltflags = (bed->dynamic_sec_flags
4459 | SEC_ALLOC
4460 | SEC_CODE
4461 | SEC_LOAD
4462 | SEC_READONLY);
4463 unsigned int non_lazy_plt_alignment
4464 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
4465
4466 sec = pltsec;
4467 if (!bfd_set_section_alignment (sec, plt_alignment))
4468 goto error_alignment;
4469
4470 /* Create the GOT procedure linkage table. */
4471 sec = bfd_make_section_anyway_with_flags (dynobj,
4472 ".plt.got",
4473 pltflags);
4474 if (sec == NULL)
4475 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
4476
4477 if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment))
4478 goto error_alignment;
4479
4480 htab->plt_got = sec;
4481
4482 if (lazy_plt)
4483 {
4484 sec = NULL;
4485
4486 if (use_ibt_plt)
4487 {
4488 /* Create the second PLT for Intel IBT support. IBT
4489 PLT is needed only for lazy binding. */
4490 sec = bfd_make_section_anyway_with_flags (dynobj,
4491 ".plt.sec",
4492 pltflags);
4493 if (sec == NULL)
4494 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
4495
4496 if (!bfd_set_section_alignment (sec, plt_alignment))
4497 goto error_alignment;
4498 }
4499
4500 htab->plt_second = sec;
4501 }
4502 }
4503
4504 if (!info->no_ld_generated_unwind_info)
4505 {
4506 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4507 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4508 | SEC_LINKER_CREATED);
4509
4510 sec = bfd_make_section_anyway_with_flags (dynobj,
4511 ".eh_frame",
4512 flags);
4513 if (sec == NULL)
4514 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
4515
4516 if (!bfd_set_section_alignment (sec, class_align))
4517 goto error_alignment;
4518
4519 htab->plt_eh_frame = sec;
4520
4521 if (htab->plt_got != NULL)
4522 {
4523 sec = bfd_make_section_anyway_with_flags (dynobj,
4524 ".eh_frame",
4525 flags);
4526 if (sec == NULL)
4527 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
4528
4529 if (!bfd_set_section_alignment (sec, class_align))
4530 goto error_alignment;
4531
4532 htab->plt_got_eh_frame = sec;
4533 }
4534
4535 if (htab->plt_second != NULL)
4536 {
4537 sec = bfd_make_section_anyway_with_flags (dynobj,
4538 ".eh_frame",
4539 flags);
4540 if (sec == NULL)
4541 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
4542
4543 if (!bfd_set_section_alignment (sec, class_align))
4544 goto error_alignment;
4545
4546 htab->plt_second_eh_frame = sec;
4547 }
4548 }
4549
4550 /* .sframe sections are emitted for AMD64 ABI only. */
4551 if (ABI_64_P (info->output_bfd) && !info->no_ld_generated_unwind_info)
4552 {
4553 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4554 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4555 | SEC_LINKER_CREATED);
4556
4557 sec = bfd_make_section_anyway_with_flags (dynobj,
4558 ".sframe",
4559 flags);
4560 if (sec == NULL)
4561 info->callbacks->einfo (_("%F%P: failed to create PLT .sframe section\n"));
4562
4563 // FIXME check this
4564 // if (!bfd_set_section_alignment (sec, class_align))
4565 // goto error_alignment;
4566
4567 htab->plt_sframe = sec;
4568
4569 /* Second PLT is generated for Intel IBT + lazy plt. */
4570 if (htab->plt_second != NULL)
4571 {
4572 sec = bfd_make_section_anyway_with_flags (dynobj,
4573 ".sframe",
4574 flags);
4575 if (sec == NULL)
4576 info->callbacks->einfo (_("%F%P: failed to create second PLT .sframe section\n"));
4577
4578 htab->plt_second_sframe = sec;
4579 }
4580 /* FIXME - add later for plt_got. */
4581 }
4582 }
4583
4584 /* The .iplt section is used for IFUNC symbols in static
4585 executables. */
4586 sec = htab->elf.iplt;
4587 if (sec != NULL)
4588 {
4589 /* NB: Delay setting its alignment until we know it is non-empty.
4590 Otherwise an empty iplt section may change vma and lma of the
4591 following sections, which triggers moving dot of the following
4592 section backwards, resulting in a warning and section lma not
4593 being set properly. It later leads to a "File truncated"
4594 error. */
4595 if (!bfd_set_section_alignment (sec, 0))
4596 goto error_alignment;
4597
4598 htab->plt.iplt_alignment = (normal_target
4599 ? plt_alignment
4600 : bed->plt_alignment);
4601 }
4602
4603 if (bfd_link_executable (info)
4604 && !info->nointerp
4605 && !htab->params->has_dynamic_linker
4606 && htab->params->static_before_all_inputs)
4607 {
4608 /* Report error for dynamic input objects if -static is passed at
4609 command-line before all input files without --dynamic-linker
4610 unless --no-dynamic-linker is used. */
4611 bfd *abfd;
4612
4613 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
4614 if ((abfd->flags & DYNAMIC))
4615 info->callbacks->einfo
4616 (_("%X%P: attempted static link of dynamic object `%pB'\n"),
4617 abfd);
4618 }
4619
4620 return pbfd;
4621 }
4622
4623 /* Fix up x86 GNU properties. */
4624
4625 void
_bfd_x86_elf_link_fixup_gnu_properties(struct bfd_link_info * info,elf_property_list ** listp)4626 _bfd_x86_elf_link_fixup_gnu_properties
4627 (struct bfd_link_info *info, elf_property_list **listp)
4628 {
4629 elf_property_list *p;
4630
4631 for (p = *listp; p; p = p->next)
4632 {
4633 unsigned int type = p->property.pr_type;
4634 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
4635 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
4636 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
4637 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
4638 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
4639 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
4640 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
4641 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
4642 {
4643 if (p->property.u.number == 0
4644 && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
4645 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
4646 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
4647 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
4648 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)))
4649 {
4650 /* Remove empty property. */
4651 *listp = p->next;
4652 continue;
4653 }
4654
4655 /* Keep LAM features only for 64-bit output. */
4656 if (type == GNU_PROPERTY_X86_FEATURE_1_AND
4657 && !ABI_64_P (info->output_bfd))
4658 p->property.u.number &= ~(GNU_PROPERTY_X86_FEATURE_1_LAM_U48
4659 | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4660
4661 listp = &p->next;
4662 }
4663 else if (type > GNU_PROPERTY_HIPROC)
4664 {
4665 /* The property list is sorted in order of type. */
4666 break;
4667 }
4668 }
4669 }
4670
4671 void
_bfd_elf_linker_x86_set_options(struct bfd_link_info * info,struct elf_linker_x86_params * params)4672 _bfd_elf_linker_x86_set_options (struct bfd_link_info * info,
4673 struct elf_linker_x86_params *params)
4674 {
4675 const struct elf_backend_data *bed
4676 = get_elf_backend_data (info->output_bfd);
4677 struct elf_x86_link_hash_table *htab
4678 = elf_x86_hash_table (info, bed->target_id);
4679 if (htab != NULL)
4680 htab->params = params;
4681 }
4682