projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / bfd / elfxx-x86.c
CommitLineData
0afcef53 1/* x86 specific support for ELF
219d1afa 2 Copyright (C) 2017-2018 Free Software Foundation, Inc.
0afcef53
L		 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"
a6798bab 22#include "elf-vxworks.h"
765e526c
L		 23#include "objalloc.h"
24#include "elf/i386.h"
25#include "elf/x86-64.h"
26
27/* The name of the dynamic interpreter. This is put in the .interp
28 section. */
29
30#define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
31#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
32#define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
0afcef53 33
39946cc2
L		 34bfd_boolean
35_bfd_x86_elf_mkobject (bfd *abfd)
36{
37 return bfd_elf_allocate_object (abfd,
38 sizeof (struct elf_x86_obj_tdata),
39 get_elf_backend_data (abfd)->target_id);
40}
41
0afcef53
L		 42/* _TLS_MODULE_BASE_ needs to be treated especially when linking
43 executables. Rather than setting it to the beginning of the TLS
44 section, we have to set it to the end. This function may be called
45 multiple times, it is idempotent. */
46
47void
48_bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
49{
50 struct elf_x86_link_hash_table *htab;
51 struct bfd_link_hash_entry *base;
52 const struct elf_backend_data *bed;
53
54 if (!bfd_link_executable (info))
55 return;
56
57 bed = get_elf_backend_data (info->output_bfd);
58 htab = elf_x86_hash_table (info, bed->target_id);
59 if (htab == NULL)
60 return;
61
62 base = htab->tls_module_base;
63 if (base == NULL)
64 return;
65
66 base->u.def.value = htab->elf.tls_size;
67}
68
69/* Return the base VMA address which should be subtracted from real addresses
70 when resolving @dtpoff relocation.
71 This is PT_TLS segment p_vaddr. */
72
73bfd_vma
74_bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
75{
76 /* If tls_sec is NULL, we should have signalled an error already. */
77 if (elf_hash_table (info)->tls_sec == NULL)
78 return 0;
79 return elf_hash_table (info)->tls_sec->vma;
80}
81
b9ce864c
L		 82/* Allocate space in .plt, .got and associated reloc sections for
83 dynamic relocs. */
84
5e2ac45d 85static bfd_boolean
70090aa5 86elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
b9ce864c
L		 87{
88 struct bfd_link_info *info;
89 struct elf_x86_link_hash_table *htab;
90 struct elf_x86_link_hash_entry *eh;
91 struct elf_dyn_relocs *p;
92 unsigned int plt_entry_size;
93 bfd_boolean resolved_to_zero;
94 const struct elf_backend_data *bed;
95
96 if (h->root.type == bfd_link_hash_indirect)
97 return TRUE;
98
99 eh = (struct elf_x86_link_hash_entry *) h;
100
101 info = (struct bfd_link_info *) inf;
102 bed = get_elf_backend_data (info->output_bfd);
103 htab = elf_x86_hash_table (info, bed->target_id);
104 if (htab == NULL)
105 return FALSE;
106
107 plt_entry_size = htab->plt.plt_entry_size;
108
c5bce5c6 109 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
b9ce864c 110
b9ce864c
L		 111 /* We can't use the GOT PLT if pointer equality is needed since
112 finish_dynamic_symbol won't clear symbol value and the dynamic
113 linker won't update the GOT slot. We will get into an infinite
114 loop at run-time. */
115 if (htab->plt_got != NULL
116 && h->type != STT_GNU_IFUNC
117 && !h->pointer_equality_needed
118 && h->plt.refcount > 0
119 && h->got.refcount > 0)
120 {
121 /* Don't use the regular PLT if there are both GOT and GOTPLT
07d6d2b8 122 reloctions. */
b9ce864c
L		 123 h->plt.offset = (bfd_vma) -1;
124
125 /* Use the GOT PLT. */
126 eh->plt_got.refcount = 1;
127 }
128
129 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
130 here if it is defined and referenced in a non-shared object. */
131 if (h->type == STT_GNU_IFUNC
132 && h->def_regular)
133 {
134 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
135 &htab->readonly_dynrelocs_against_ifunc,
136 plt_entry_size,
137 (htab->plt.has_plt0
138 * plt_entry_size),
139 htab->got_entry_size,
140 TRUE))
141 {
142 asection *s = htab->plt_second;
143 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
144 {
145 /* Use the second PLT section if it is created. */
146 eh->plt_second.offset = s->size;
147
148 /* Make room for this entry in the second PLT section. */
149 s->size += htab->non_lazy_plt->plt_entry_size;
150 }
151
152 return TRUE;
153 }
154 else
155 return FALSE;
156 }
157 /* Don't create the PLT entry if there are only function pointer
158 relocations which can be resolved at run-time. */
159 else if (htab->elf.dynamic_sections_created
79b0c981 160 && (h->plt.refcount > 0
b9ce864c
L		 161 || eh->plt_got.refcount > 0))
162 {
163 bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
164
b9ce864c
L		 165 /* Make sure this symbol is output as a dynamic symbol.
166 Undefined weak syms won't yet be marked as dynamic. */
167 if (h->dynindx == -1
168 && !h->forced_local
169 && !resolved_to_zero
170 && h->root.type == bfd_link_hash_undefweak)
171 {
172 if (! bfd_elf_link_record_dynamic_symbol (info, h))
173 return FALSE;
174 }
175
176 if (bfd_link_pic (info)
177 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
178 {
179 asection *s = htab->elf.splt;
180 asection *second_s = htab->plt_second;
181 asection *got_s = htab->plt_got;
451875b4 182 bfd_boolean use_plt;
b9ce864c
L		 183
184 /* If this is the first .plt entry, make room for the special
185 first entry. The .plt section is used by prelink to undo
186 prelinking for dynamic relocations. */
187 if (s->size == 0)
188 s->size = htab->plt.has_plt0 * plt_entry_size;
189
190 if (use_plt_got)
191 eh->plt_got.offset = got_s->size;
192 else
193 {
194 h->plt.offset = s->size;
195 if (second_s)
196 eh->plt_second.offset = second_s->size;
197 }
198
199 /* If this symbol is not defined in a regular file, and we are
451875b4
L		 200 generating PDE, then set the symbol to this location in the
201 .plt. This is required to make function pointers compare
202 as equal between PDE and the shared library.
203
204 NB: If PLT is PC-relative, we can use the .plt in PIE for
205 function address. */
206 if (h->def_regular)
207 use_plt = FALSE;
208 else if (htab->pcrel_plt)
209 use_plt = ! bfd_link_dll (info);
210 else
211 use_plt = bfd_link_pde (info);
212 if (use_plt)
b9ce864c
L		 213 {
214 if (use_plt_got)
215 {
216 /* We need to make a call to the entry of the GOT PLT
217 instead of regular PLT entry. */
218 h->root.u.def.section = got_s;
219 h->root.u.def.value = eh->plt_got.offset;
220 }
221 else
222 {
223 if (second_s)
224 {
225 /* We need to make a call to the entry of the
226 second PLT instead of regular PLT entry. */
227 h->root.u.def.section = second_s;
228 h->root.u.def.value = eh->plt_second.offset;
229 }
230 else
231 {
232 h->root.u.def.section = s;
233 h->root.u.def.value = h->plt.offset;
234 }
235 }
236 }
237
238 /* Make room for this entry. */
239 if (use_plt_got)
240 got_s->size += htab->non_lazy_plt->plt_entry_size;
241 else
242 {
243 s->size += plt_entry_size;
244 if (second_s)
245 second_s->size += htab->non_lazy_plt->plt_entry_size;
246
247 /* We also need to make an entry in the .got.plt section,
248 which will be placed in the .got section by the linker
249 script. */
250 htab->elf.sgotplt->size += htab->got_entry_size;
251
252 /* There should be no PLT relocation against resolved
253 undefined weak symbol in executable. */
254 if (!resolved_to_zero)
255 {
256 /* We also need to make an entry in the .rel.plt
257 section. */
258 htab->elf.srelplt->size += htab->sizeof_reloc;
259 htab->elf.srelplt->reloc_count++;
260 }
261 }
262
851b6fa1 263 if (htab->target_os == is_vxworks && !bfd_link_pic (info))
b9ce864c
L		 264 {
265 /* VxWorks has a second set of relocations for each PLT entry
266 in executables. They go in a separate relocation section,
267 which is processed by the kernel loader. */
268
269 /* There are two relocations for the initial PLT entry: an
270 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
272
273 asection *srelplt2 = htab->srelplt2;
274 if (h->plt.offset == plt_entry_size)
275 srelplt2->size += (htab->sizeof_reloc * 2);
276
277 /* There are two extra relocations for each subsequent PLT entry:
278 an R_386_32 relocation for the GOT entry, and an R_386_32
279 relocation for the PLT entry. */
280
281 srelplt2->size += (htab->sizeof_reloc * 2);
282 }
283 }
284 else
285 {
286 eh->plt_got.offset = (bfd_vma) -1;
287 h->plt.offset = (bfd_vma) -1;
288 h->needs_plt = 0;
289 }
290 }
291 else
292 {
293 eh->plt_got.offset = (bfd_vma) -1;
294 h->plt.offset = (bfd_vma) -1;
295 h->needs_plt = 0;
296 }
297
298 eh->tlsdesc_got = (bfd_vma) -1;
299
300 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
301 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
302 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
303 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
304 if (h->got.refcount > 0
305 && bfd_link_executable (info)
306 && h->dynindx == -1
307 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
308 h->got.offset = (bfd_vma) -1;
309 else if (h->got.refcount > 0)
310 {
311 asection *s;
312 bfd_boolean dyn;
313 int tls_type = elf_x86_hash_entry (h)->tls_type;
314
315 /* Make sure this symbol is output as a dynamic symbol.
316 Undefined weak syms won't yet be marked as dynamic. */
317 if (h->dynindx == -1
318 && !h->forced_local
319 && !resolved_to_zero
320 && h->root.type == bfd_link_hash_undefweak)
321 {
322 if (! bfd_elf_link_record_dynamic_symbol (info, h))
323 return FALSE;
324 }
325
326 s = htab->elf.sgot;
327 if (GOT_TLS_GDESC_P (tls_type))
328 {
329 eh->tlsdesc_got = htab->elf.sgotplt->size
330 - elf_x86_compute_jump_table_size (htab);
331 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
332 h->got.offset = (bfd_vma) -2;
333 }
334 if (! GOT_TLS_GDESC_P (tls_type)
335 || GOT_TLS_GD_P (tls_type))
336 {
337 h->got.offset = s->size;
338 s->size += htab->got_entry_size;
339 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
340 slots. */
341 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
342 s->size += htab->got_entry_size;
343 }
344 dyn = htab->elf.dynamic_sections_created;
345 /* R_386_TLS_IE_32 needs one dynamic relocation,
346 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
347 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
348 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
349 symbol and two if global. No dynamic relocation against
350 resolved undefined weak symbol in executable. */
351 if (tls_type == GOT_TLS_IE_BOTH)
352 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
353 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
354 || (tls_type & GOT_TLS_IE))
355 htab->elf.srelgot->size += htab->sizeof_reloc;
356 else if (GOT_TLS_GD_P (tls_type))
357 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
358 else if (! GOT_TLS_GDESC_P (tls_type)
359 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
360 && !resolved_to_zero)
361 || h->root.type != bfd_link_hash_undefweak)
362 && (bfd_link_pic (info)
363 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
364 htab->elf.srelgot->size += htab->sizeof_reloc;
365 if (GOT_TLS_GDESC_P (tls_type))
0e30d991
L		 366 {
367 htab->elf.srelplt->size += htab->sizeof_reloc;
368 if (bed->target_id == X86_64_ELF_DATA)
369 htab->tlsdesc_plt = (bfd_vma) -1;
370 }
b9ce864c
L		 371 }
372 else
373 h->got.offset = (bfd_vma) -1;
374
375 if (eh->dyn_relocs == NULL)
376 return TRUE;
377
378 /* In the shared -Bsymbolic case, discard space allocated for
379 dynamic pc-relative relocs against symbols which turn out to be
380 defined in regular objects. For the normal shared case, discard
381 space for pc-relative relocs that have become local due to symbol
382 visibility changes. */
383
384 if (bfd_link_pic (info))
385 {
386 /* Relocs that use pc_count are those that appear on a call
387 insn, or certain REL relocs that can generated via assembly.
388 We want calls to protected symbols to resolve directly to the
389 function rather than going via the plt. If people want
390 function pointer comparisons to work as expected then they
391 should avoid writing weird assembly. */
392 if (SYMBOL_CALLS_LOCAL (info, h))
393 {
394 struct elf_dyn_relocs **pp;
395
396 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
397 {
398 p->count -= p->pc_count;
399 p->pc_count = 0;
400 if (p->count == 0)
401 *pp = p->next;
402 else
403 pp = &p->next;
404 }
405 }
406
851b6fa1 407 if (htab->target_os == is_vxworks)
b9ce864c
L		 408 {
409 struct elf_dyn_relocs **pp;
410 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
411 {
412 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
413 *pp = p->next;
414 else
415 pp = &p->next;
416 }
417 }
418
419 /* Also discard relocs on undefined weak syms with non-default
420 visibility or in PIE. */
421 if (eh->dyn_relocs != NULL)
422 {
423 if (h->root.type == bfd_link_hash_undefweak)
424 {
425 /* Undefined weak symbol is never bound locally in shared
426 library. */
427 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
428 || resolved_to_zero)
429 {
430 if (bed->target_id == I386_ELF_DATA
431 && h->non_got_ref)
432 {
433 /* Keep dynamic non-GOT/non-PLT relocation so
434 that we can branch to 0 without PLT. */
435 struct elf_dyn_relocs **pp;
436
437 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
438 if (p->pc_count == 0)
439 *pp = p->next;
440 else
441 {
442 /* Remove non-R_386_PC32 relocation. */
443 p->count = p->pc_count;
444 pp = &p->next;
445 }
446
447 /* Make sure undefined weak symbols are output
448 as dynamic symbols in PIEs for dynamic non-GOT
449 non-PLT reloations. */
450 if (eh->dyn_relocs != NULL
451 && !bfd_elf_link_record_dynamic_symbol (info, h))
452 return FALSE;
453 }
454 else
455 eh->dyn_relocs = NULL;
456 }
457 else if (h->dynindx == -1
458 && !h->forced_local
459 && !bfd_elf_link_record_dynamic_symbol (info, h))
460 return FALSE;
461 }
462 else if (bfd_link_executable (info)
463 && (h->needs_copy || eh->needs_copy)
464 && h->def_dynamic
465 && !h->def_regular)
466 {
467 /* NB: needs_copy is set only for x86-64. For PIE,
468 discard space for pc-relative relocs against symbols
469 which turn out to need copy relocs. */
470 struct elf_dyn_relocs **pp;
471
472 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
473 {
474 if (p->pc_count != 0)
475 *pp = p->next;
476 else
477 pp = &p->next;
478 }
479 }
480 }
481 }
482 else if (ELIMINATE_COPY_RELOCS)
483 {
484 /* For the non-shared case, discard space for relocs against
485 symbols which turn out to need copy relocs or are not
486 dynamic. Keep dynamic relocations for run-time function
487 pointer initialization. */
488
489 if ((!h->non_got_ref
b9ce864c
L		 490 || (h->root.type == bfd_link_hash_undefweak
491 && !resolved_to_zero))
492 && ((h->def_dynamic
493 && !h->def_regular)
494 || (htab->elf.dynamic_sections_created
495 && (h->root.type == bfd_link_hash_undefweak
496 || h->root.type == bfd_link_hash_undefined))))
497 {
498 /* Make sure this symbol is output as a dynamic symbol.
499 Undefined weak syms won't yet be marked as dynamic. */
500 if (h->dynindx == -1
501 && !h->forced_local
502 && !resolved_to_zero
503 && h->root.type == bfd_link_hash_undefweak
504 && ! bfd_elf_link_record_dynamic_symbol (info, h))
505 return FALSE;
506
507 /* If that succeeded, we know we'll be keeping all the
508 relocs. */
509 if (h->dynindx != -1)
510 goto keep;
511 }
512
513 eh->dyn_relocs = NULL;
b9ce864c
L		 514
515 keep: ;
516 }
517
518 /* Finally, allocate space. */
519 for (p = eh->dyn_relocs; p != NULL; p = p->next)
520 {
521 asection *sreloc;
522
523 sreloc = elf_section_data (p->sec)->sreloc;
524
525 BFD_ASSERT (sreloc != NULL);
526 sreloc->size += p->count * htab->sizeof_reloc;
527 }
528
529 return TRUE;
530}
531
826c3f1e 532/* Find dynamic relocs for H that apply to read-only sections. */
0afcef53 533
826c3f1e
AM		 534static asection *
535readonly_dynrelocs (struct elf_link_hash_entry *h)
0afcef53 536{
0afcef53
L		 537 struct elf_dyn_relocs *p;
538
826c3f1e 539 for (p = elf_x86_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
0afcef53
L		 540 {
541 asection *s = p->sec->output_section;
542
543 if (s != NULL && (s->flags & SEC_READONLY) != 0)
826c3f1e
AM		 544 return p->sec;
545 }
546 return NULL;
547}
0afcef53 548
826c3f1e
AM		 549/* Set DF_TEXTREL if we find any dynamic relocs that apply to
550 read-only sections. */
0afcef53 551
826c3f1e
AM		 552static bfd_boolean
553maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
554{
555 asection *sec;
0afcef53 556
826c3f1e
AM		 557 if (h->root.type == bfd_link_hash_indirect)
558 return TRUE;
559
560 /* Skip local IFUNC symbols. */
561 if (h->forced_local && h->type == STT_GNU_IFUNC)
562 return TRUE;
563
564 sec = readonly_dynrelocs (h);
565 if (sec != NULL)
566 {
567 struct bfd_link_info *info = (struct bfd_link_info *) inf;
568
569 info->flags |= DF_TEXTREL;
570 /* xgettext:c-format */
c1c8c1ef 571 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' "
871b3ab2 572 "in read-only section `%pA'\n"),
826c3f1e
AM		 573 sec->owner, h->root.root.string, sec);
574
575 if ((info->warn_shared_textrel && bfd_link_pic (info))
576 || info->error_textrel)
577 /* xgettext:c-format */
871b3ab2
AM		 578 info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' "
579 "in read-only section `%pA'\n"),
826c3f1e
AM		 580 sec->owner, h->root.root.string, sec);
581
582 /* Not an error, just cut short the traversal. */
583 return FALSE;
0afcef53
L		 584 }
585 return TRUE;
586}
587
b9ce864c
L		 588/* Allocate space in .plt, .got and associated reloc sections for
589 local dynamic relocs. */
590
5e2ac45d
L		 591static bfd_boolean
592elf_x86_allocate_local_dynreloc (void **slot, void *inf)
b9ce864c
L		 593{
594 struct elf_link_hash_entry *h
595 = (struct elf_link_hash_entry *) *slot;
596
597 if (h->type != STT_GNU_IFUNC
598 || !h->def_regular
599 || !h->ref_regular
600 || !h->forced_local
601 || h->root.type != bfd_link_hash_defined)
602 abort ();
603
5e2ac45d 604 return elf_x86_allocate_dynrelocs (h, inf);
b9ce864c
L		 605}
606
0afcef53
L		 607/* Find and/or create a hash entry for local symbol. */
608
609struct elf_link_hash_entry *
610_bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
611 bfd *abfd, const Elf_Internal_Rela *rel,
612 bfd_boolean create)
613{
614 struct elf_x86_link_hash_entry e, *ret;
615 asection *sec = abfd->sections;
616 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
617 htab->r_sym (rel->r_info));
618 void **slot;
619
620 e.elf.indx = sec->id;
621 e.elf.dynstr_index = htab->r_sym (rel->r_info);
622 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
623 create ? INSERT : NO_INSERT);
624
625 if (!slot)
626 return NULL;
627
628 if (*slot)
629 {
630 ret = (struct elf_x86_link_hash_entry *) *slot;
631 return &ret->elf;
632 }
633
634 ret = (struct elf_x86_link_hash_entry *)
635 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
636 sizeof (struct elf_x86_link_hash_entry));
637 if (ret)
638 {
639 memset (ret, 0, sizeof (*ret));
640 ret->elf.indx = sec->id;
641 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
642 ret->elf.dynindx = -1;
643 ret->plt_got.offset = (bfd_vma) -1;
644 *slot = ret;
645 }
646 return &ret->elf;
647}
648
649/* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
650 SYNC WITH _bfd_elf_link_hash_newfunc. */
651
652struct bfd_hash_entry *
653_bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
654 struct bfd_hash_table *table,
655 const char *string)
656{
657 /* Allocate the structure if it has not already been allocated by a
658 subclass. */
659 if (entry == NULL)
660 {
661 entry = (struct bfd_hash_entry *)
662 bfd_hash_allocate (table,
663 sizeof (struct elf_x86_link_hash_entry));
664 if (entry == NULL)
665 return entry;
666 }
667
668 /* Call the allocation method of the superclass. */
669 entry = _bfd_link_hash_newfunc (entry, table, string);
670 if (entry != NULL)
671 {
672 struct elf_x86_link_hash_entry *eh
673 = (struct elf_x86_link_hash_entry *) entry;
674 struct elf_link_hash_table *htab
675 = (struct elf_link_hash_table *) table;
676
677 memset (&eh->elf.size, 0,
678 (sizeof (struct elf_x86_link_hash_entry)
679 - offsetof (struct elf_link_hash_entry, size)));
680 /* Set local fields. */
681 eh->elf.indx = -1;
682 eh->elf.dynindx = -1;
683 eh->elf.got = htab->init_got_refcount;
684 eh->elf.plt = htab->init_plt_refcount;
685 /* Assume that we have been called by a non-ELF symbol reader.
686 This flag is then reset by the code which reads an ELF input
687 file. This ensures that a symbol created by a non-ELF symbol
688 reader will have the flag set correctly. */
689 eh->elf.non_elf = 1;
690 eh->plt_second.offset = (bfd_vma) -1;
691 eh->plt_got.offset = (bfd_vma) -1;
692 eh->tlsdesc_got = (bfd_vma) -1;
98b273dc 693 eh->zero_undefweak = 1;
0afcef53
L		 694 }
695
696 return entry;
697}
698
699/* Compute a hash of a local hash entry. We use elf_link_hash_entry
700 for local symbol so that we can handle local STT_GNU_IFUNC symbols
701 as global symbol. We reuse indx and dynstr_index for local symbol
702 hash since they aren't used by global symbols in this backend. */
703
704hashval_t
705_bfd_x86_elf_local_htab_hash (const void *ptr)
706{
707 struct elf_link_hash_entry *h
708 = (struct elf_link_hash_entry *) ptr;
709 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
710}
711
712/* Compare local hash entries. */
713
714int
715_bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
716{
717 struct elf_link_hash_entry *h1
718 = (struct elf_link_hash_entry *) ptr1;
719 struct elf_link_hash_entry *h2
720 = (struct elf_link_hash_entry *) ptr2;
721
722 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
723}
724
725/* Destroy an x86 ELF linker hash table. */
726
765e526c
L		 727static void
728elf_x86_link_hash_table_free (bfd *obfd)
0afcef53
L		 729{
730 struct elf_x86_link_hash_table *htab
731 = (struct elf_x86_link_hash_table *) obfd->link.hash;
732
733 if (htab->loc_hash_table)
734 htab_delete (htab->loc_hash_table);
735 if (htab->loc_hash_memory)
736 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
737 _bfd_elf_link_hash_table_free (obfd);
738}
739
5e2ac45d
L		 740static bfd_boolean
741elf_i386_is_reloc_section (const char *secname)
742{
743 return CONST_STRNEQ (secname, ".rel");
744}
745
5e2ac45d
L		 746static bfd_boolean
747elf_x86_64_is_reloc_section (const char *secname)
748{
749 return CONST_STRNEQ (secname, ".rela");
750}
5e2ac45d 751
765e526c
L		 752/* Create an x86 ELF linker hash table. */
753
754struct bfd_link_hash_table *
755_bfd_x86_elf_link_hash_table_create (bfd *abfd)
756{
757 struct elf_x86_link_hash_table *ret;
758 const struct elf_backend_data *bed;
759 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
760
761 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
762 if (ret == NULL)
763 return NULL;
764
765 bed = get_elf_backend_data (abfd);
766 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
767 _bfd_x86_elf_link_hash_newfunc,
768 sizeof (struct elf_x86_link_hash_entry),
769 bed->target_id))
770 {
771 free (ret);
772 return NULL;
773 }
774
5e2ac45d
L		 775 if (bed->target_id == X86_64_ELF_DATA)
776 {
5e2ac45d
L		 777 ret->is_reloc_section = elf_x86_64_is_reloc_section;
778 ret->dt_reloc = DT_RELA;
779 ret->dt_reloc_sz = DT_RELASZ;
780 ret->dt_reloc_ent = DT_RELAENT;
781 ret->got_entry_size = 8;
451875b4 782 ret->pcrel_plt = TRUE;
f04bdfa7 783 ret->tls_get_addr = "__tls_get_addr";
5e2ac45d 784 }
765e526c
L		 785 if (ABI_64_P (abfd))
786 {
503294e7 787 ret->sizeof_reloc = sizeof (Elf64_External_Rela);
765e526c
L		 788 ret->pointer_r_type = R_X86_64_64;
789 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
790 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
765e526c
L		 791 }
792 else
765e526c 793 {
5b86dbf4 794 if (bed->target_id == X86_64_ELF_DATA)
765e526c 795 {
503294e7 796 ret->sizeof_reloc = sizeof (Elf32_External_Rela);
765e526c
L		 797 ret->pointer_r_type = R_X86_64_32;
798 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
799 ret->dynamic_interpreter_size
800 = sizeof ELFX32_DYNAMIC_INTERPRETER;
765e526c
L		 801 }
802 else
803 {
5e2ac45d
L		 804 ret->is_reloc_section = elf_i386_is_reloc_section;
805 ret->dt_reloc = DT_REL;
806 ret->dt_reloc_sz = DT_RELSZ;
807 ret->dt_reloc_ent = DT_RELENT;
503294e7 808 ret->sizeof_reloc = sizeof (Elf32_External_Rel);
9ff114ca 809 ret->got_entry_size = 4;
451875b4 810 ret->pcrel_plt = FALSE;
765e526c
L		 811 ret->pointer_r_type = R_386_32;
812 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
813 ret->dynamic_interpreter_size
814 = sizeof ELF32_DYNAMIC_INTERPRETER;
815 ret->tls_get_addr = "___tls_get_addr";
816 }
817 }
fe53b4a4 818 ret->target_id = bed->target_id;
851b6fa1 819 ret->target_os = get_elf_x86_backend_data (abfd)->target_os;
765e526c
L		 820
821 ret->loc_hash_table = htab_try_create (1024,
822 _bfd_x86_elf_local_htab_hash,
823 _bfd_x86_elf_local_htab_eq,
824 NULL);
825 ret->loc_hash_memory = objalloc_create ();
826 if (!ret->loc_hash_table || !ret->loc_hash_memory)
827 {
828 elf_x86_link_hash_table_free (abfd);
829 return NULL;
830 }
831 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
832
833 return &ret->elf.root;
834}
835
0afcef53
L		 836/* Sort relocs into address order. */
837
838int
839_bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
840{
841 const arelent *a = * (const arelent **) ap;
842 const arelent *b = * (const arelent **) bp;
843
844 if (a->address > b->address)
845 return 1;
846 else if (a->address < b->address)
847 return -1;
848 else
849 return 0;
850}
851
852bfd_boolean
853_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
854{
855 if (!bfd_link_relocatable (info))
856 {
857 /* Check for __tls_get_addr reference. */
858 struct elf_x86_link_hash_table *htab;
859 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
860 htab = elf_x86_hash_table (info, bed->target_id);
861 if (htab)
862 {
0a27fed7
L		 863 struct elf_link_hash_entry *h;
864
865 h = elf_link_hash_lookup (elf_hash_table (info),
0afcef53
L		 866 htab->tls_get_addr,
867 FALSE, FALSE, FALSE);
868 if (h != NULL)
8a1b824a
L		 869 {
870 elf_x86_hash_entry (h)->tls_get_addr = 1;
871
872 /* Check the versioned __tls_get_addr symbol. */
873 while (h->root.type == bfd_link_hash_indirect)
874 {
875 h = (struct elf_link_hash_entry *) h->root.u.i.link;
876 elf_x86_hash_entry (h)->tls_get_addr = 1;
877 }
878 }
0a27fed7
L		 879
880 /* "__ehdr_start" will be defined by linker as a hidden symbol
881 later if it is referenced and not defined. */
882 h = elf_link_hash_lookup (elf_hash_table (info),
883 "__ehdr_start",
884 FALSE, FALSE, FALSE);
885 if (h != NULL
886 && (h->root.type == bfd_link_hash_new
887 || h->root.type == bfd_link_hash_undefined
888 || h->root.type == bfd_link_hash_undefweak
889 || h->root.type == bfd_link_hash_common))
890 {
891 elf_x86_hash_entry (h)->local_ref = 2;
892 elf_x86_hash_entry (h)->linker_def = 1;
893 }
0afcef53
L		 894 }
895 }
896
897 /* Invoke the regular ELF backend linker to do all the work. */
898 return _bfd_elf_link_check_relocs (abfd, info);
899}
900
5e2ac45d
L		 901/* Set the sizes of the dynamic sections. */
902
903bfd_boolean
904_bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
905 struct bfd_link_info *info)
906{
907 struct elf_x86_link_hash_table *htab;
908 bfd *dynobj;
909 asection *s;
910 bfd_boolean relocs;
911 bfd *ibfd;
912 const struct elf_backend_data *bed
913 = get_elf_backend_data (output_bfd);
914
915 htab = elf_x86_hash_table (info, bed->target_id);
916 if (htab == NULL)
917 return FALSE;
918 dynobj = htab->elf.dynobj;
919 if (dynobj == NULL)
920 abort ();
921
922 /* Set up .got offsets for local syms, and space for local dynamic
923 relocs. */
924 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
925 {
926 bfd_signed_vma *local_got;
927 bfd_signed_vma *end_local_got;
928 char *local_tls_type;
929 bfd_vma *local_tlsdesc_gotent;
930 bfd_size_type locsymcount;
931 Elf_Internal_Shdr *symtab_hdr;
932 asection *srel;
933
934 if (! is_x86_elf (ibfd, htab))
935 continue;
936
937 for (s = ibfd->sections; s != NULL; s = s->next)
938 {
939 struct elf_dyn_relocs *p;
940
5e2ac45d
L		 941 for (p = ((struct elf_dyn_relocs *)
942 elf_section_data (s)->local_dynrel);
943 p != NULL;
944 p = p->next)
945 {
946 if (!bfd_is_abs_section (p->sec)
947 && bfd_is_abs_section (p->sec->output_section))
948 {
949 /* Input section has been discarded, either because
950 it is a copy of a linkonce section or due to
951 linker script /DISCARD/, so we'll be discarding
952 the relocs too. */
953 }
851b6fa1 954 else if (htab->target_os == is_vxworks
5e2ac45d
L		 955 && strcmp (p->sec->output_section->name,
956 ".tls_vars") == 0)
957 {
958 /* Relocations in vxworks .tls_vars sections are
959 handled specially by the loader. */
960 }
961 else if (p->count != 0)
962 {
963 srel = elf_section_data (p->sec)->sreloc;
964 srel->size += p->count * htab->sizeof_reloc;
965 if ((p->sec->output_section->flags & SEC_READONLY) != 0
966 && (info->flags & DF_TEXTREL) == 0)
967 {
968 info->flags |= DF_TEXTREL;
969 if ((info->warn_shared_textrel && bfd_link_pic (info))
970 || info->error_textrel)
971 /* xgettext:c-format */
826c3f1e 972 info->callbacks->einfo
871b3ab2
AM		 973 (_("%P: %pB: warning: relocation "
974 "in read-only section `%pA'\n"),
826c3f1e 975 p->sec->owner, p->sec);
5e2ac45d
L		 976 }
977 }
978 }
979 }
980
981 local_got = elf_local_got_refcounts (ibfd);
982 if (!local_got)
983 continue;
984
985 symtab_hdr = &elf_symtab_hdr (ibfd);
986 locsymcount = symtab_hdr->sh_info;
987 end_local_got = local_got + locsymcount;
988 local_tls_type = elf_x86_local_got_tls_type (ibfd);
989 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
990 s = htab->elf.sgot;
991 srel = htab->elf.srelgot;
992 for (; local_got < end_local_got;
993 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
994 {
995 *local_tlsdesc_gotent = (bfd_vma) -1;
996 if (*local_got > 0)
997 {
998 if (GOT_TLS_GDESC_P (*local_tls_type))
999 {
1000 *local_tlsdesc_gotent = htab->elf.sgotplt->size
1001 - elf_x86_compute_jump_table_size (htab);
1002 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
1003 *local_got = (bfd_vma) -2;
1004 }
1005 if (! GOT_TLS_GDESC_P (*local_tls_type)
1006 || GOT_TLS_GD_P (*local_tls_type))
1007 {
1008 *local_got = s->size;
1009 s->size += htab->got_entry_size;
1010 if (GOT_TLS_GD_P (*local_tls_type)
1011 || *local_tls_type == GOT_TLS_IE_BOTH)
1012 s->size += htab->got_entry_size;
1013 }
1014 if (bfd_link_pic (info)
1015 || GOT_TLS_GD_ANY_P (*local_tls_type)
1016 || (*local_tls_type & GOT_TLS_IE))
1017 {
1018 if (*local_tls_type == GOT_TLS_IE_BOTH)
1019 srel->size += 2 * htab->sizeof_reloc;
1020 else if (GOT_TLS_GD_P (*local_tls_type)
1021 || ! GOT_TLS_GDESC_P (*local_tls_type))
1022 srel->size += htab->sizeof_reloc;
1023 if (GOT_TLS_GDESC_P (*local_tls_type))
1024 {
1025 htab->elf.srelplt->size += htab->sizeof_reloc;
1026 if (bed->target_id == X86_64_ELF_DATA)
1027 htab->tlsdesc_plt = (bfd_vma) -1;
1028 }
1029 }
1030 }
1031 else
1032 *local_got = (bfd_vma) -1;
1033 }
1034 }
1035
1036 if (htab->tls_ld_or_ldm_got.refcount > 0)
1037 {
1038 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
07d6d2b8 1039 or R_X86_64_TLSLD relocs. */
5e2ac45d
L		 1040 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1041 htab->elf.sgot->size += 2 * htab->got_entry_size;
1042 htab->elf.srelgot->size += htab->sizeof_reloc;
1043 }
1044 else
1045 htab->tls_ld_or_ldm_got.offset = -1;
1046
1047 /* Allocate global sym .plt and .got entries, and space for global
1048 sym dynamic relocs. */
1049 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1050 info);
1051
1052 /* Allocate .plt and .got entries, and space for local symbols. */
1053 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1054 info);
1055
1056 /* For every jump slot reserved in the sgotplt, reloc_count is
1057 incremented. However, when we reserve space for TLS descriptors,
1058 it's not incremented, so in order to compute the space reserved
1059 for them, it suffices to multiply the reloc count by the jump
1060 slot size.
1061
1062 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1063 so that R_{386,X86_64}_IRELATIVE entries come last. */
1064 if (htab->elf.srelplt)
1065 {
1066 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1067 htab->sgotplt_jump_table_size
1068 = elf_x86_compute_jump_table_size (htab);
1069 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1070 }
1071 else if (htab->elf.irelplt)
1072 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1073
1074 if (htab->tlsdesc_plt)
1075 {
1076 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1077 lazy TLS relocations, don't generate the PLT and GOT entries
1078 they require. */
1079 if ((info->flags & DF_BIND_NOW))
1080 htab->tlsdesc_plt = 0;
1081 else
1082 {
1083 htab->tlsdesc_got = htab->elf.sgot->size;
1084 htab->elf.sgot->size += htab->got_entry_size;
1085 /* Reserve room for the initial entry.
1086 FIXME: we could probably do away with it in this case. */
1087 if (htab->elf.splt->size == 0)
1088 htab->elf.splt->size = htab->plt.plt_entry_size;
1089 htab->tlsdesc_plt = htab->elf.splt->size;
1090 htab->elf.splt->size += htab->plt.plt_entry_size;
1091 }
1092 }
1093
1094 if (htab->elf.sgotplt)
1095 {
1096 /* Don't allocate .got.plt section if there are no GOT nor PLT
1097 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1098 if ((htab->elf.hgot == NULL
cd048363 1099 || !htab->got_referenced)
5e2ac45d
L		 1100 && (htab->elf.sgotplt->size == bed->got_header_size)
1101 && (htab->elf.splt == NULL
1102 || htab->elf.splt->size == 0)
1103 && (htab->elf.sgot == NULL
1104 || htab->elf.sgot->size == 0)
1105 && (htab->elf.iplt == NULL
1106 || htab->elf.iplt->size == 0)
1107 && (htab->elf.igotplt == NULL
1108 || htab->elf.igotplt->size == 0))
cd048363
L		 1109 {
1110 htab->elf.sgotplt->size = 0;
3b4c3844
L		 1111 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1112 isn't used. */
1113 if (htab->elf.hgot != NULL && htab->target_os != is_solaris)
cd048363
L		 1114 {
1115 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1116 table. */
1117 htab->elf.hgot->root.type = bfd_link_hash_undefined;
1118 htab->elf.hgot->root.u.undef.abfd
1119 = htab->elf.hgot->root.u.def.section->owner;
1120 htab->elf.hgot->root.linker_def = 0;
1121 htab->elf.hgot->ref_regular = 0;
1122 htab->elf.hgot->def_regular = 0;
1123 }
1124 }
5e2ac45d
L		 1125 }
1126
1127 if (_bfd_elf_eh_frame_present (info))
1128 {
1129 if (htab->plt_eh_frame != NULL
1130 && htab->elf.splt != NULL
1131 && htab->elf.splt->size != 0
1132 && !bfd_is_abs_section (htab->elf.splt->output_section))
1133 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1134
1135 if (htab->plt_got_eh_frame != NULL
1136 && htab->plt_got != NULL
1137 && htab->plt_got->size != 0
1138 && !bfd_is_abs_section (htab->plt_got->output_section))
1139 htab->plt_got_eh_frame->size
1140 = htab->non_lazy_plt->eh_frame_plt_size;
1141
1142 /* Unwind info for the second PLT and .plt.got sections are
1143 identical. */
1144 if (htab->plt_second_eh_frame != NULL
1145 && htab->plt_second != NULL
1146 && htab->plt_second->size != 0
1147 && !bfd_is_abs_section (htab->plt_second->output_section))
1148 htab->plt_second_eh_frame->size
1149 = htab->non_lazy_plt->eh_frame_plt_size;
1150 }
1151
1152 /* We now have determined the sizes of the various dynamic sections.
1153 Allocate memory for them. */
1154 relocs = FALSE;
1155 for (s = dynobj->sections; s != NULL; s = s->next)
1156 {
1157 bfd_boolean strip_section = TRUE;
1158
1159 if ((s->flags & SEC_LINKER_CREATED) == 0)
1160 continue;
1161
1162 if (s == htab->elf.splt
1163 || s == htab->elf.sgot)
1164 {
1165 /* Strip this section if we don't need it; see the
1166 comment below. */
1167 /* We'd like to strip these sections if they aren't needed, but if
1168 we've exported dynamic symbols from them we must leave them.
1169 It's too late to tell BFD to get rid of the symbols. */
1170
1171 if (htab->elf.hplt != NULL)
1172 strip_section = FALSE;
1173 }
1174 else if (s == htab->elf.sgotplt
1175 || s == htab->elf.iplt
1176 || s == htab->elf.igotplt
1177 || s == htab->plt_second
1178 || s == htab->plt_got
1179 || s == htab->plt_eh_frame
1180 || s == htab->plt_got_eh_frame
1181 || s == htab->plt_second_eh_frame
1182 || s == htab->elf.sdynbss
1183 || s == htab->elf.sdynrelro)
1184 {
1185 /* Strip these too. */
1186 }
1187 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1188 {
1189 if (s->size != 0
1190 && s != htab->elf.srelplt
1191 && s != htab->srelplt2)
1192 relocs = TRUE;
1193
1194 /* We use the reloc_count field as a counter if we need
1195 to copy relocs into the output file. */
1196 if (s != htab->elf.srelplt)
1197 s->reloc_count = 0;
1198 }
1199 else
1200 {
1201 /* It's not one of our sections, so don't allocate space. */
1202 continue;
1203 }
1204
1205 if (s->size == 0)
1206 {
1207 /* If we don't need this section, strip it from the
1208 output file. This is mostly to handle .rel.bss and
1209 .rel.plt. We must create both sections in
1210 create_dynamic_sections, because they must be created
1211 before the linker maps input sections to output
1212 sections. The linker does that before
1213 adjust_dynamic_symbol is called, and it is that
1214 function which decides whether anything needs to go
1215 into these sections. */
1216 if (strip_section)
1217 s->flags |= SEC_EXCLUDE;
1218 continue;
1219 }
1220
1221 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1222 continue;
1223
1224 /* Allocate memory for the section contents. We use bfd_zalloc
1225 here in case unused entries are not reclaimed before the
1226 section's contents are written out. This should not happen,
1227 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1228 reloc instead of garbage. */
1229 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1230 if (s->contents == NULL)
1231 return FALSE;
1232 }
1233
1234 if (htab->plt_eh_frame != NULL
1235 && htab->plt_eh_frame->contents != NULL)
1236 {
1237 memcpy (htab->plt_eh_frame->contents,
1238 htab->plt.eh_frame_plt,
1239 htab->plt_eh_frame->size);
1240 bfd_put_32 (dynobj, htab->elf.splt->size,
1241 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1242 }
1243
1244 if (htab->plt_got_eh_frame != NULL
1245 && htab->plt_got_eh_frame->contents != NULL)
1246 {
1247 memcpy (htab->plt_got_eh_frame->contents,
1248 htab->non_lazy_plt->eh_frame_plt,
1249 htab->plt_got_eh_frame->size);
1250 bfd_put_32 (dynobj, htab->plt_got->size,
1251 (htab->plt_got_eh_frame->contents
1252 + PLT_FDE_LEN_OFFSET));
1253 }
1254
1255 if (htab->plt_second_eh_frame != NULL
1256 && htab->plt_second_eh_frame->contents != NULL)
1257 {
1258 memcpy (htab->plt_second_eh_frame->contents,
1259 htab->non_lazy_plt->eh_frame_plt,
1260 htab->plt_second_eh_frame->size);
1261 bfd_put_32 (dynobj, htab->plt_second->size,
1262 (htab->plt_second_eh_frame->contents
1263 + PLT_FDE_LEN_OFFSET));
1264 }
1265
1266 if (htab->elf.dynamic_sections_created)
1267 {
1268 /* Add some entries to the .dynamic section. We fill in the
1269 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1270 but we must add the entries now so that we get the correct
1271 size for the .dynamic section. The DT_DEBUG entry is filled
1272 in by the dynamic linker and used by the debugger. */
1273#define add_dynamic_entry(TAG, VAL) \
1274 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1275
1276 if (bfd_link_executable (info))
1277 {
1278 if (!add_dynamic_entry (DT_DEBUG, 0))
1279 return FALSE;
1280 }
1281
1282 if (htab->elf.splt->size != 0)
1283 {
1284 /* DT_PLTGOT is used by prelink even if there is no PLT
1285 relocation. */
1286 if (!add_dynamic_entry (DT_PLTGOT, 0))
1287 return FALSE;
1288 }
1289
1290 if (htab->elf.srelplt->size != 0)
1291 {
1292 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1293 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1294 || !add_dynamic_entry (DT_JMPREL, 0))
1295 return FALSE;
1296 }
1297
1298 if (htab->tlsdesc_plt
1299 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1300 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1301 return FALSE;
1302
1303 if (relocs)
1304 {
1305 if (!add_dynamic_entry (htab->dt_reloc, 0)
1306 || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1307 || !add_dynamic_entry (htab->dt_reloc_ent,
1308 htab->sizeof_reloc))
1309 return FALSE;
1310
1311 /* If any dynamic relocs apply to a read-only section,
1312 then we need a DT_TEXTREL entry. */
1313 if ((info->flags & DF_TEXTREL) == 0)
826c3f1e 1314 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5e2ac45d
L		 1315
1316 if ((info->flags & DF_TEXTREL) != 0)
1317 {
1318 if (htab->readonly_dynrelocs_against_ifunc)
1319 {
1320 info->callbacks->einfo
826c3f1e
AM		 1321 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1322 " recompile with -fPIC\n"));
5e2ac45d
L		 1323 bfd_set_error (bfd_error_bad_value);
1324 return FALSE;
1325 }
1326
1327 if (!add_dynamic_entry (DT_TEXTREL, 0))
1328 return FALSE;
1329 }
1330 }
851b6fa1 1331 if (htab->target_os == is_vxworks
5e2ac45d
L		 1332 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1333 return FALSE;
1334 }
1335#undef add_dynamic_entry
1336
1337 return TRUE;
1338}
1339
9577f60b
L		 1340/* Finish up the x86 dynamic sections. */
1341
1342struct elf_x86_link_hash_table *
1343_bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1344 struct bfd_link_info *info)
1345{
1346 struct elf_x86_link_hash_table *htab;
1347 const struct elf_backend_data *bed;
1348 bfd *dynobj;
1349 asection *sdyn;
1350 bfd_byte *dyncon, *dynconend;
1351 bfd_size_type sizeof_dyn;
1352
1353 bed = get_elf_backend_data (output_bfd);
1354 htab = elf_x86_hash_table (info, bed->target_id);
1355 if (htab == NULL)
1356 return htab;
1357
1358 dynobj = htab->elf.dynobj;
1359 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1360
1361 /* GOT is always created in setup_gnu_properties. But it may not be
1362 needed. .got.plt section may be needed for static IFUNC. */
1363 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1364 {
1365 bfd_vma dynamic_addr;
1366
1367 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1368 {
1369 _bfd_error_handler
871b3ab2 1370 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
9577f60b
L		 1371 return NULL;
1372 }
1373
1374 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1375 = htab->got_entry_size;
1376
1377 dynamic_addr = (sdyn == NULL
1378 ? (bfd_vma) 0
1379 : sdyn->output_section->vma + sdyn->output_offset);
1380
1381 /* Set the first entry in the global offset table to the address
07d6d2b8 1382 of the dynamic section. Write GOT[1] and GOT[2], needed for
9577f60b
L		 1383 the dynamic linker. */
1384 if (htab->got_entry_size == 8)
1385 {
1386 bfd_put_64 (output_bfd, dynamic_addr,
1387 htab->elf.sgotplt->contents);
1388 bfd_put_64 (output_bfd, (bfd_vma) 0,
1389 htab->elf.sgotplt->contents + 8);
1390 bfd_put_64 (output_bfd, (bfd_vma) 0,
1391 htab->elf.sgotplt->contents + 8*2);
1392 }
1393 else
1394 {
1395 bfd_put_32 (output_bfd, dynamic_addr,
1396 htab->elf.sgotplt->contents);
1397 bfd_put_32 (output_bfd, 0,
1398 htab->elf.sgotplt->contents + 4);
1399 bfd_put_32 (output_bfd, 0,
1400 htab->elf.sgotplt->contents + 4*2);
1401 }
1402 }
1403
1404 if (!htab->elf.dynamic_sections_created)
1405 return htab;
1406
1407 if (sdyn == NULL || htab->elf.sgot == NULL)
1408 abort ();
1409
1410 sizeof_dyn = bed->s->sizeof_dyn;
1411 dyncon = sdyn->contents;
1412 dynconend = sdyn->contents + sdyn->size;
1413 for (; dyncon < dynconend; dyncon += sizeof_dyn)
1414 {
1415 Elf_Internal_Dyn dyn;
1416 asection *s;
1417
1418 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1419
1420 switch (dyn.d_tag)
1421 {
1422 default:
851b6fa1 1423 if (htab->target_os == is_vxworks
9577f60b
L		 1424 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1425 break;
1426 continue;
1427
1428 case DT_PLTGOT:
1429 s = htab->elf.sgotplt;
1430 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1431 break;
1432
1433 case DT_JMPREL:
1434 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1435 break;
1436
1437 case DT_PLTRELSZ:
1438 s = htab->elf.srelplt->output_section;
1439 dyn.d_un.d_val = s->size;
1440 break;
1441
1442 case DT_TLSDESC_PLT:
1443 s = htab->elf.splt;
1444 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1445 + htab->tlsdesc_plt;
1446 break;
1447
1448 case DT_TLSDESC_GOT:
1449 s = htab->elf.sgot;
1450 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1451 + htab->tlsdesc_got;
1452 break;
1453 }
1454
1455 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1456 }
1457
1458 if (htab->plt_got != NULL && htab->plt_got->size > 0)
1459 elf_section_data (htab->plt_got->output_section)
1460 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1461
1462 if (htab->plt_second != NULL && htab->plt_second->size > 0)
1463 elf_section_data (htab->plt_second->output_section)
1464 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1465
1466 /* Adjust .eh_frame for .plt section. */
1467 if (htab->plt_eh_frame != NULL
1468 && htab->plt_eh_frame->contents != NULL)
1469 {
1470 if (htab->elf.splt != NULL
1471 && htab->elf.splt->size != 0
1472 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1473 && htab->elf.splt->output_section != NULL
1474 && htab->plt_eh_frame->output_section != NULL)
1475 {
1476 bfd_vma plt_start = htab->elf.splt->output_section->vma;
1477 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1478 + htab->plt_eh_frame->output_offset
1479 + PLT_FDE_START_OFFSET;
1480 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1481 htab->plt_eh_frame->contents
1482 + PLT_FDE_START_OFFSET);
1483 }
1484
1485 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1486 {
1487 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1488 htab->plt_eh_frame,
1489 htab->plt_eh_frame->contents))
1490 return NULL;
1491 }
1492 }
1493
1494 /* Adjust .eh_frame for .plt.got section. */
1495 if (htab->plt_got_eh_frame != NULL
1496 && htab->plt_got_eh_frame->contents != NULL)
1497 {
1498 if (htab->plt_got != NULL
1499 && htab->plt_got->size != 0
1500 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1501 && htab->plt_got->output_section != NULL
1502 && htab->plt_got_eh_frame->output_section != NULL)
1503 {
1504 bfd_vma plt_start = htab->plt_got->output_section->vma;
1505 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1506 + htab->plt_got_eh_frame->output_offset
1507 + PLT_FDE_START_OFFSET;
1508 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1509 htab->plt_got_eh_frame->contents
1510 + PLT_FDE_START_OFFSET);
1511 }
1512 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1513 {
1514 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1515 htab->plt_got_eh_frame,
1516 htab->plt_got_eh_frame->contents))
1517 return NULL;
1518 }
1519 }
1520
1521 /* Adjust .eh_frame for the second PLT section. */
1522 if (htab->plt_second_eh_frame != NULL
1523 && htab->plt_second_eh_frame->contents != NULL)
1524 {
1525 if (htab->plt_second != NULL
1526 && htab->plt_second->size != 0
1527 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1528 && htab->plt_second->output_section != NULL
1529 && htab->plt_second_eh_frame->output_section != NULL)
1530 {
1531 bfd_vma plt_start = htab->plt_second->output_section->vma;
1532 bfd_vma eh_frame_start
1533 = (htab->plt_second_eh_frame->output_section->vma
1534 + htab->plt_second_eh_frame->output_offset
1535 + PLT_FDE_START_OFFSET);
1536 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1537 htab->plt_second_eh_frame->contents
1538 + PLT_FDE_START_OFFSET);
1539 }
1540 if (htab->plt_second_eh_frame->sec_info_type
1541 == SEC_INFO_TYPE_EH_FRAME)
1542 {
1543 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1544 htab->plt_second_eh_frame,
1545 htab->plt_second_eh_frame->contents))
1546 return NULL;
1547 }
1548 }
1549
1550 if (htab->elf.sgot && htab->elf.sgot->size > 0)
1551 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1552 = htab->got_entry_size;
1553
1554 return htab;
1555}
1556
1557
0afcef53
L		 1558bfd_boolean
1559_bfd_x86_elf_always_size_sections (bfd *output_bfd,
1560 struct bfd_link_info *info)
1561{
1562 asection *tls_sec = elf_hash_table (info)->tls_sec;
1563
1564 if (tls_sec)
1565 {
1566 struct elf_link_hash_entry *tlsbase;
1567
1568 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1569 "_TLS_MODULE_BASE_",
1570 FALSE, FALSE, FALSE);
1571
1572 if (tlsbase && tlsbase->type == STT_TLS)
1573 {
1574 struct elf_x86_link_hash_table *htab;
1575 struct bfd_link_hash_entry *bh = NULL;
1576 const struct elf_backend_data *bed
1577 = get_elf_backend_data (output_bfd);
1578
1579 htab = elf_x86_hash_table (info, bed->target_id);
1580 if (htab == NULL)
1581 return FALSE;
1582
1583 if (!(_bfd_generic_link_add_one_symbol
1584 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1585 tls_sec, 0, NULL, FALSE,
1586 bed->collect, &bh)))
1587 return FALSE;
1588
1589 htab->tls_module_base = bh;
1590
1591 tlsbase = (struct elf_link_hash_entry *)bh;
1592 tlsbase->def_regular = 1;
1593 tlsbase->other = STV_HIDDEN;
1594 tlsbase->root.linker_def = 1;
1595 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1596 }
1597 }
1598
1599 return TRUE;
1600}
1601
1602void
1603_bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1604 const Elf_Internal_Sym *isym,
1605 bfd_boolean definition,
1606 bfd_boolean dynamic ATTRIBUTE_UNUSED)
1607{
1608 if (definition)
1609 {
1610 struct elf_x86_link_hash_entry *eh
1611 = (struct elf_x86_link_hash_entry *) h;
1612 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1613 == STV_PROTECTED);
1614 }
1615}
1616
1617/* Copy the extra info we tack onto an elf_link_hash_entry. */
1618
1619void
1620_bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1621 struct elf_link_hash_entry *dir,
1622 struct elf_link_hash_entry *ind)
1623{
1624 struct elf_x86_link_hash_entry *edir, *eind;
1625
1626 edir = (struct elf_x86_link_hash_entry *) dir;
1627 eind = (struct elf_x86_link_hash_entry *) ind;
1628
1629 if (eind->dyn_relocs != NULL)
1630 {
1631 if (edir->dyn_relocs != NULL)
1632 {
1633 struct elf_dyn_relocs **pp;
1634 struct elf_dyn_relocs *p;
1635
1636 /* Add reloc counts against the indirect sym to the direct sym
1637 list. Merge any entries against the same section. */
1638 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1639 {
1640 struct elf_dyn_relocs *q;
1641
1642 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1643 if (q->sec == p->sec)
1644 {
1645 q->pc_count += p->pc_count;
1646 q->count += p->count;
1647 *pp = p->next;
1648 break;
1649 }
1650 if (q == NULL)
1651 pp = &p->next;
1652 }
1653 *pp = edir->dyn_relocs;
1654 }
1655
1656 edir->dyn_relocs = eind->dyn_relocs;
1657 eind->dyn_relocs = NULL;
1658 }
1659
1660 if (ind->root.type == bfd_link_hash_indirect
1661 && dir->got.refcount <= 0)
1662 {
1663 edir->tls_type = eind->tls_type;
1664 eind->tls_type = GOT_UNKNOWN;
1665 }
1666
1667 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1668 generate a R_386_COPY reloc. */
1669 edir->gotoff_ref |= eind->gotoff_ref;
1670
98b273dc 1671 edir->zero_undefweak |= eind->zero_undefweak;
0afcef53
L		 1672
1673 if (ELIMINATE_COPY_RELOCS
1674 && ind->root.type != bfd_link_hash_indirect
1675 && dir->dynamic_adjusted)
1676 {
1677 /* If called to transfer flags for a weakdef during processing
1678 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1679 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1680 if (dir->versioned != versioned_hidden)
1681 dir->ref_dynamic |= ind->ref_dynamic;
1682 dir->ref_regular |= ind->ref_regular;
1683 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1684 dir->needs_plt |= ind->needs_plt;
1685 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1686 }
1687 else
79b0c981 1688 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
0afcef53
L		 1689}
1690
1691/* Remove undefined weak symbol from the dynamic symbol table if it
1692 is resolved to 0. */
1693
1694bfd_boolean
1695_bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1696 struct elf_link_hash_entry *h)
1697{
c5bce5c6
L		 1698 if (h->dynindx != -1
1699 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
0afcef53 1700 {
c5bce5c6
L		 1701 h->dynindx = -1;
1702 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1703 h->dynstr_index);
0afcef53
L		 1704 }
1705 return TRUE;
1706}
1707
1708/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1709
1710bfd_boolean
1711_bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1712{
1713 if (h->plt.offset != (bfd_vma) -1
1714 && !h->def_regular
1715 && !h->pointer_equality_needed)
1716 return FALSE;
1717
1718 return _bfd_elf_hash_symbol (h);
1719}
1720
eeb2f20a
L		 1721/* Adjust a symbol defined by a dynamic object and referenced by a
1722 regular object. The current definition is in some section of the
1723 dynamic object, but we're not including those sections. We have to
1724 change the definition to something the rest of the link can
1725 understand. */
1726
1727bfd_boolean
1728_bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1729 struct elf_link_hash_entry *h)
1730{
1731 struct elf_x86_link_hash_table *htab;
1732 asection *s, *srel;
1733 struct elf_x86_link_hash_entry *eh;
1734 struct elf_dyn_relocs *p;
1735 const struct elf_backend_data *bed
1736 = get_elf_backend_data (info->output_bfd);
1737
1738 /* STT_GNU_IFUNC symbol must go through PLT. */
1739 if (h->type == STT_GNU_IFUNC)
1740 {
1741 /* All local STT_GNU_IFUNC references must be treate as local
1742 calls via local PLT. */
1743 if (h->ref_regular
1744 && SYMBOL_CALLS_LOCAL (info, h))
1745 {
1746 bfd_size_type pc_count = 0, count = 0;
1747 struct elf_dyn_relocs **pp;
1748
1749 eh = (struct elf_x86_link_hash_entry *) h;
1750 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1751 {
1752 pc_count += p->pc_count;
1753 p->count -= p->pc_count;
1754 p->pc_count = 0;
1755 count += p->count;
1756 if (p->count == 0)
1757 *pp = p->next;
1758 else
1759 pp = &p->next;
1760 }
1761
1762 if (pc_count || count)
1763 {
1764 h->non_got_ref = 1;
1765 if (pc_count)
1766 {
1767 /* Increment PLT reference count only for PC-relative
1768 references. */
1769 h->needs_plt = 1;
1770 if (h->plt.refcount <= 0)
1771 h->plt.refcount = 1;
1772 else
1773 h->plt.refcount += 1;
1774 }
1775 }
1776 }
1777
1778 if (h->plt.refcount <= 0)
1779 {
1780 h->plt.offset = (bfd_vma) -1;
1781 h->needs_plt = 0;
1782 }
1783 return TRUE;
1784 }
1785
1786 /* If this is a function, put it in the procedure linkage table. We
1787 will fill in the contents of the procedure linkage table later,
1788 when we know the address of the .got section. */
1789 if (h->type == STT_FUNC
1790 || h->needs_plt)
1791 {
1792 if (h->plt.refcount <= 0
1793 || SYMBOL_CALLS_LOCAL (info, h)
1794 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1795 && h->root.type == bfd_link_hash_undefweak))
1796 {
1797 /* This case can occur if we saw a PLT32 reloc in an input
1798 file, but the symbol was never referred to by a dynamic
1799 object, or if all references were garbage collected. In
1800 such a case, we don't actually need to build a procedure
1801 linkage table, and we can just do a PC32 reloc instead. */
1802 h->plt.offset = (bfd_vma) -1;
1803 h->needs_plt = 0;
1804 }
1805
1806 return TRUE;
1807 }
1808 else
1809 /* It's possible that we incorrectly decided a .plt reloc was needed
1810 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1811 check_relocs. We can't decide accurately between function and
1812 non-function syms in check-relocs; Objects loaded later in
1813 the link may change h->type. So fix it now. */
1814 h->plt.offset = (bfd_vma) -1;
1815
1816 eh = (struct elf_x86_link_hash_entry *) h;
1817
1818 /* If this is a weak symbol, and there is a real definition, the
1819 processor independent code will have arranged for us to see the
1820 real definition first, and we can just use the same value. */
60d67dc8 1821 if (h->is_weakalias)
eeb2f20a 1822 {
60d67dc8
AM		 1823 struct elf_link_hash_entry *def = weakdef (h);
1824 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1825 h->root.u.def.section = def->root.u.def.section;
1826 h->root.u.def.value = def->root.u.def.value;
eeb2f20a
L		 1827 if (ELIMINATE_COPY_RELOCS
1828 || info->nocopyreloc
1829 || SYMBOL_NO_COPYRELOC (info, eh))
1830 {
1831 /* NB: needs_copy is always 0 for i386. */
60d67dc8
AM		 1832 h->non_got_ref = def->non_got_ref;
1833 eh->needs_copy = def->needs_copy;
eeb2f20a
L		 1834 }
1835 return TRUE;
1836 }
1837
1838 /* This is a reference to a symbol defined by a dynamic object which
1839 is not a function. */
1840
1841 /* If we are creating a shared library, we must presume that the
1842 only references to the symbol are via the global offset table.
1843 For such cases we need not do anything here; the relocations will
1844 be handled correctly by relocate_section. */
1845 if (!bfd_link_executable (info))
1846 return TRUE;
1847
1848 /* If there are no references to this symbol that do not use the
1849 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1850 reloc. NB: gotoff_ref is always 0 for x86-64. */
1851 if (!h->non_got_ref && !eh->gotoff_ref)
1852 return TRUE;
1853
1854 /* If -z nocopyreloc was given, we won't generate them either. */
1855 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1856 {
1857 h->non_got_ref = 0;
1858 return TRUE;
1859 }
1860
1861 htab = elf_x86_hash_table (info, bed->target_id);
1862 if (htab == NULL)
1863 return FALSE;
1864
1865 /* If there aren't any dynamic relocs in read-only sections nor
1866 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1867 avoid the copy reloc. This doesn't work on VxWorks, where we can
1868 not have dynamic relocations (other than copy and jump slot
1869 relocations) in an executable. */
1870 if (ELIMINATE_COPY_RELOCS
1871 && (bed->target_id == X86_64_ELF_DATA
1872 || (!eh->gotoff_ref
851b6fa1 1873 && htab->target_os != is_vxworks)))
eeb2f20a 1874 {
826c3f1e 1875 /* If we don't find any dynamic relocs in read-only sections,
eeb2f20a
L		 1876 then we'll be keeping the dynamic relocs and avoiding the copy
1877 reloc. */
826c3f1e 1878 if (!readonly_dynrelocs (h))
eeb2f20a
L		 1879 {
1880 h->non_got_ref = 0;
1881 return TRUE;
1882 }
1883 }
1884
1885 /* We must allocate the symbol in our .dynbss section, which will
1886 become part of the .bss section of the executable. There will be
1887 an entry for this symbol in the .dynsym section. The dynamic
1888 object will contain position independent code, so all references
1889 from the dynamic object to this symbol will go through the global
1890 offset table. The dynamic linker will use the .dynsym entry to
1891 determine the address it must put in the global offset table, so
1892 both the dynamic object and the regular object will refer to the
1893 same memory location for the variable. */
1894
1895 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1896 dynamic linker to copy the initial value out of the dynamic object
1897 and into the runtime process image. */
1898 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1899 {
1900 s = htab->elf.sdynrelro;
1901 srel = htab->elf.sreldynrelro;
1902 }
1903 else
1904 {
1905 s = htab->elf.sdynbss;
1906 srel = htab->elf.srelbss;
1907 }
1908 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1909 {
503294e7 1910 srel->size += htab->sizeof_reloc;
eeb2f20a
L		 1911 h->needs_copy = 1;
1912 }
1913
1914 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1915}
1916
9f857535
L		 1917void
1918_bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
1919 struct elf_link_hash_entry *h,
1920 bfd_boolean force_local)
1921{
1922 if (h->root.type == bfd_link_hash_undefweak
1923 && info->nointerp
1924 && bfd_link_pie (info))
1925 {
1926 /* When there is no dynamic interpreter in PIE, make the undefined
1927 weak symbol dynamic so that PC relative branch to the undefined
1928 weak symbol will land to address 0. */
1929 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
79b0c981 1930 if (h->plt.refcount > 0
9f857535
L		 1931 || eh->plt_got.refcount > 0)
1932 return;
1933 }
1934
1935 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1936}
1937
6999821f
L		 1938/* Return TRUE if a symbol is referenced locally. It is similar to
1939 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1940 works in check_relocs. */
1941
1942bfd_boolean
1943_bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
1944 struct elf_link_hash_entry *h)
1945{
0a27fed7
L		 1946 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
1947 struct elf_x86_link_hash_table *htab
1948 = (struct elf_x86_link_hash_table *) info->hash;
6999821f
L		 1949
1950 if (eh->local_ref > 1)
1951 return TRUE;
1952
1953 if (eh->local_ref == 1)
1954 return FALSE;
1955
1956 /* Unversioned symbols defined in regular objects can be forced local
0a27fed7
L		 1957 by linker version script. A weak undefined symbol is forced local
1958 if
1959 1. It has non-default visibility. Or
8fbf0ba1 1960 2. When building executable, there is no dynamic linker. Or
0a27fed7
L		 1961 3. or "-z nodynamic-undefined-weak" is used.
1962 */
6999821f 1963 if (SYMBOL_REFERENCES_LOCAL (info, h)
0a27fed7
L		 1964 || (h->root.type == bfd_link_hash_undefweak
1965 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1966 || (bfd_link_executable (info)
8fbf0ba1 1967 && htab->interp == NULL)
0a27fed7 1968 || info->dynamic_undefined_weak == 0))
6999821f
L		 1969 || ((h->def_regular || ELF_COMMON_DEF_P (h))
1970 && h->versioned == unversioned
1971 && info->version_info != NULL
1972 && bfd_hide_sym_by_version (info->version_info,
1973 h->root.root.string)))
1974 {
1975 eh->local_ref = 2;
1976 return TRUE;
1977 }
1978
1979 eh->local_ref = 1;
1980 return FALSE;
1981}
1982
4f501a24
L		 1983/* Return the section that should be marked against GC for a given
1984 relocation. */
1985
1986asection *
1987_bfd_x86_elf_gc_mark_hook (asection *sec,
1988 struct bfd_link_info *info,
1989 Elf_Internal_Rela *rel,
1990 struct elf_link_hash_entry *h,
1991 Elf_Internal_Sym *sym)
1992{
1993 /* Compiler should optimize this out. */
1994 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1995 != (unsigned int) R_386_GNU_VTINHERIT)
1996 || ((unsigned int) R_X86_64_GNU_VTENTRY
1997 != (unsigned int) R_386_GNU_VTENTRY))
1998 abort ();
1999
2000 if (h != NULL)
2001 switch (ELF32_R_TYPE (rel->r_info))
2002 {
2003 case R_X86_64_GNU_VTINHERIT:
2004 case R_X86_64_GNU_VTENTRY:
2005 return NULL;
2006 }
2007
2008 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2009}
2010
f493882d
L		 2011static bfd_vma
2012elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2013 bfd_vma off,
2014 bfd_vma offset ATTRIBUTE_UNUSED,
2015 bfd_vma got_addr)
2016{
2017 return got_addr + off;
2018}
2019
2020static bfd_vma
2021elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2022 bfd_vma off,
2023 bfd_vma offset,
2024 bfd_vma got_addr ATTRIBUTE_UNUSED)
2025{
2026 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2027}
2028
2029static bfd_boolean
2030elf_i386_valid_plt_reloc_p (unsigned int type)
2031{
2032 return (type == R_386_JUMP_SLOT
2033 || type == R_386_GLOB_DAT
2034 || type == R_386_IRELATIVE);
2035}
2036
2037static bfd_boolean
2038elf_x86_64_valid_plt_reloc_p (unsigned int type)
2039{
2040 return (type == R_X86_64_JUMP_SLOT
2041 || type == R_X86_64_GLOB_DAT
2042 || type == R_X86_64_IRELATIVE);
2043}
2044
2045long
2046_bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2047 long count,
2048 long relsize,
2049 bfd_vma got_addr,
2050 struct elf_x86_plt plts[],
2051 asymbol **dynsyms,
2052 asymbol **ret)
2053{
2054 long size, i, n, len;
2055 int j;
2056 unsigned int plt_got_offset, plt_entry_size;
2057 asymbol *s;
2058 bfd_byte *plt_contents;
2059 long dynrelcount;
2060 arelent **dynrelbuf, *p;
2061 char *names;
2062 const struct elf_backend_data *bed;
2063 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2064 bfd_vma);
2065 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2066
2067 if (count == 0)
2068 return -1;
2069
2070 dynrelbuf = (arelent **) bfd_malloc (relsize);
2071 if (dynrelbuf == NULL)
2072 return -1;
2073
2074 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2075 dynsyms);
b69e9267 2076 if (dynrelcount <= 0)
94670f6c 2077 return -1;
f493882d
L		 2078
2079 /* Sort the relocs by address. */
2080 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2081 _bfd_x86_elf_compare_relocs);
2082
2083 size = count * sizeof (asymbol);
2084
2085 /* Allocate space for @plt suffixes. */
2086 n = 0;
2087 for (i = 0; i < dynrelcount; i++)
2088 {
2089 p = dynrelbuf[i];
2090 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2091 if (p->addend != 0)
2092 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2093 }
2094
2095 s = *ret = (asymbol *) bfd_zmalloc (size);
2096 if (s == NULL)
2097 goto bad_return;
2098
2099 bed = get_elf_backend_data (abfd);
2100
2101 if (bed->target_id == X86_64_ELF_DATA)
2102 {
2103 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2104 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2105 }
2106 else
2107 {
2108 get_plt_got_vma = elf_i386_get_plt_got_vma;
2109 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2110 if (got_addr)
2111 {
2112 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2113 address. */
2114 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2115 if (sec != NULL)
2116 got_addr = sec->vma;
2117 else
2118 {
2119 sec = bfd_get_section_by_name (abfd, ".got");
2120 if (sec != NULL)
2121 got_addr = sec->vma;
2122 }
2123
2124 if (got_addr == (bfd_vma) -1)
2125 goto bad_return;
2126 }
2127 }
2128
2129 /* Check for each PLT section. */
2130 names = (char *) (s + count);
2131 size = 0;
2132 n = 0;
2133 for (j = 0; plts[j].name != NULL; j++)
2134 if ((plt_contents = plts[j].contents) != NULL)
2135 {
2136 long k;
2137 bfd_vma offset;
2138 asection *plt;
2139 struct elf_x86_plt *plt_p = &plts[j];
2140
2141 plt_got_offset = plt_p->plt_got_offset;
2142 plt_entry_size = plt_p->plt_entry_size;
2143
2144 plt = plt_p->sec;
2145
2146 if ((plt_p->type & plt_lazy))
2147 {
2148 /* Skip PLT0 in lazy PLT. */
2149 k = 1;
2150 offset = plt_entry_size;
2151 }
2152 else
2153 {
2154 k = 0;
2155 offset = 0;
2156 }
2157
2158 /* Check each PLT entry against dynamic relocations. */
2159 for (; k < plt_p->count; k++)
2160 {
2161 int off;
2162 bfd_vma got_vma;
2163 long min, max, mid;
2164
2165 /* Get the GOT offset for i386 or the PC-relative offset
2166 for x86-64, a signed 32-bit integer. */
2167 off = H_GET_32 (abfd, (plt_contents + offset
2168 + plt_got_offset));
2169 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2170
2171 /* Binary search. */
2172 p = dynrelbuf[0];
2173 min = 0;
2174 max = dynrelcount;
2175 while ((min + 1) < max)
2176 {
2177 arelent *r;
2178
2179 mid = (min + max) / 2;
2180 r = dynrelbuf[mid];
2181 if (got_vma > r->address)
2182 min = mid;
2183 else if (got_vma < r->address)
2184 max = mid;
2185 else
2186 {
2187 p = r;
2188 break;
2189 }
2190 }
2191
2192 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2193 if (got_vma == p->address
2194 && p->howto != NULL
2195 && valid_plt_reloc_p (p->howto->type))
2196 {
2197 *s = **p->sym_ptr_ptr;
2198 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2199 set. Since we are defining a symbol, ensure one
2200 of them is set. */
2201 if ((s->flags & BSF_LOCAL) == 0)
2202 s->flags |= BSF_GLOBAL;
2203 s->flags |= BSF_SYNTHETIC;
2204 /* This is no longer a section symbol. */
2205 s->flags &= ~BSF_SECTION_SYM;
2206 s->section = plt;
2207 s->the_bfd = plt->owner;
2208 s->value = offset;
2209 s->udata.p = NULL;
2210 s->name = names;
2211 len = strlen ((*p->sym_ptr_ptr)->name);
2212 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2213 names += len;
2214 if (p->addend != 0)
2215 {
2216 char buf[30], *a;
2217
2218 memcpy (names, "+0x", sizeof ("+0x") - 1);
2219 names += sizeof ("+0x") - 1;
2220 bfd_sprintf_vma (abfd, buf, p->addend);
2221 for (a = buf; *a == '0'; ++a)
2222 ;
2223 size = strlen (a);
2224 memcpy (names, a, size);
2225 names += size;
2226 }
2227 memcpy (names, "@plt", sizeof ("@plt"));
2228 names += sizeof ("@plt");
2229 n++;
2230 s++;
61e3bf5f
L		 2231 /* There should be only one entry in PLT for a given
2232 symbol. Set howto to NULL after processing a PLT
2233 entry to guard against corrupted PLT. */
2234 p->howto = NULL;
f493882d
L		 2235 }
2236 offset += plt_entry_size;
2237 }
2238 }
2239
2240 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2241 if (n == 0)
2242 {
2243bad_return:
2244 count = -1;
2245 }
2246 else
2247 count = n;
2248
2249 for (j = 0; plts[j].name != NULL; j++)
2250 if (plts[j].contents != NULL)
2251 free (plts[j].contents);
2252
2253 free (dynrelbuf);
2254
2255 return count;
2256}
2257
0afcef53
L		 2258/* Parse x86 GNU properties. */
2259
2260enum elf_property_kind
2261_bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2262 bfd_byte *ptr, unsigned int datasz)
2263{
2264 elf_property *prop;
2265
2266 switch (type)
2267 {
2268 case GNU_PROPERTY_X86_ISA_1_USED:
2269 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2270 case GNU_PROPERTY_X86_FEATURE_1_AND:
2271 if (datasz != 4)
2272 {
2273 _bfd_error_handler
2274 ((type == GNU_PROPERTY_X86_ISA_1_USED
871b3ab2 2275 ? _("error: %pB: <corrupt x86 ISA used size: 0x%x>")
0afcef53 2276 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
871b3ab2
AM		 2277 ? _("error: %pB: <corrupt x86 ISA needed size: 0x%x>")
2278 : _("error: %pB: <corrupt x86 feature size: 0x%x>"))),
0afcef53
L		 2279 abfd, datasz);
2280 return property_corrupt;
2281 }
2282 prop = _bfd_elf_get_property (abfd, type, datasz);
2283 /* Combine properties of the same type. */
2284 prop->u.number |= bfd_h_get_32 (abfd, ptr);
2285 prop->pr_kind = property_number;
2286 break;
2287
2288 default:
2289 return property_ignored;
2290 }
2291
2292 return property_number;
2293}
2294
2295/* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2296 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2297 should be merged with ABFD. */
2298
2299bfd_boolean
2300_bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2301 bfd *abfd ATTRIBUTE_UNUSED,
2302 elf_property *aprop,
2303 elf_property *bprop)
2304{
2305 unsigned int number, features;
2306 bfd_boolean updated = FALSE;
2307 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2308
2309 switch (pr_type)
2310 {
2311 case GNU_PROPERTY_X86_ISA_1_USED:
2312 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2313 if (aprop != NULL && bprop != NULL)
2314 {
2315 number = aprop->u.number;
2316 aprop->u.number = number | bprop->u.number;
2317 updated = number != (unsigned int) aprop->u.number;
2318 }
2319 else
2320 {
2321 /* Return TRUE if APROP is NULL to indicate that BPROP should
2322 be added to ABFD. */
2323 updated = aprop == NULL;
2324 }
2325 break;
2326
2327 case GNU_PROPERTY_X86_FEATURE_1_AND:
2328 /* Only one of APROP and BPROP can be NULL:
2329 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2330 2. If APROP is NULL, remove x86 feature.
2331 3. Otherwise, do nothing.
2332 */
2333 if (aprop != NULL && bprop != NULL)
2334 {
2335 features = 0;
2336 if (info->ibt)
2337 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2338 if (info->shstk)
2339 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2340 number = aprop->u.number;
2341 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2342 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2343 aprop->u.number = (number & bprop->u.number) | features;
2344 updated = number != (unsigned int) aprop->u.number;
2345 /* Remove the property if all feature bits are cleared. */
2346 if (aprop->u.number == 0)
2347 aprop->pr_kind = property_remove;
2348 }
2349 else
2350 {
2351 features = 0;
2352 if (info->ibt)
2353 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2354 if (info->shstk)
2355 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2356 if (features)
2357 {
2358 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2359 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2360 if (aprop != NULL)
2361 {
2362 number = aprop->u.number;
2363 aprop->u.number = number | features;
2364 updated = number != (unsigned int) aprop->u.number;
2365 }
2366 else
2367 {
2368 bprop->u.number |= features;
2369 updated = TRUE;
2370 }
2371 }
2372 else if (aprop != NULL)
2373 {
2374 aprop->pr_kind = property_remove;
2375 updated = TRUE;
2376 }
2377 }
2378 break;
2379
2380 default:
2381 /* Never should happen. */
2382 abort ();
2383 }
2384
2385 return updated;
2386}
a6798bab
L		 2387
2388/* Set up x86 GNU properties. Return the first relocatable ELF input
2389 with GNU properties if found. Otherwise, return NULL. */
2390
2391bfd *
2392_bfd_x86_elf_link_setup_gnu_properties
1de031c8 2393 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
a6798bab
L		 2394{
2395 bfd_boolean normal_target;
2396 bfd_boolean lazy_plt;
2397 asection *sec, *pltsec;
2398 bfd *dynobj;
2399 bfd_boolean use_ibt_plt;
2400 unsigned int plt_alignment, features;
2401 struct elf_x86_link_hash_table *htab;
2402 bfd *pbfd;
2403 bfd *ebfd = NULL;
2404 elf_property *prop;
2405 const struct elf_backend_data *bed;
2406 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2407 unsigned int got_align;
2408
2409 features = 0;
2410 if (info->ibt)
2411 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2412 if (info->shstk)
2413 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2414
2415 /* Find a normal input file with GNU property note. */
2416 for (pbfd = info->input_bfds;
2417 pbfd != NULL;
2418 pbfd = pbfd->link.next)
2419 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2420 && bfd_count_sections (pbfd) != 0)
2421 {
2422 ebfd = pbfd;
2423
2424 if (elf_properties (pbfd) != NULL)
2425 break;
2426 }
2427
2428 if (ebfd != NULL && features)
2429 {
2430 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2431 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2432 prop = _bfd_elf_get_property (ebfd,
2433 GNU_PROPERTY_X86_FEATURE_1_AND,
2434 4);
2435 prop->u.number |= features;
2436 prop->pr_kind = property_number;
2437
2438 /* Create the GNU property note section if needed. */
2439 if (pbfd == NULL)
2440 {
2441 sec = bfd_make_section_with_flags (ebfd,
2442 NOTE_GNU_PROPERTY_SECTION_NAME,
2443 (SEC_ALLOC
2444 | SEC_LOAD
2445 | SEC_IN_MEMORY
2446 | SEC_READONLY
2447 | SEC_HAS_CONTENTS
2448 | SEC_DATA));
2449 if (sec == NULL)
2c244f9b 2450 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
a6798bab
L		 2451
2452 if (!bfd_set_section_alignment (ebfd, sec, class_align))
2453 {
2454error_alignment:
871b3ab2 2455 info->callbacks->einfo (_("%F%pA: failed to align section\n"),
a6798bab
L		 2456 sec);
2457 }
2458
2459 elf_section_type (sec) = SHT_NOTE;
2460 }
2461 }
2462
2463 pbfd = _bfd_elf_link_setup_gnu_properties (info);
2464
a6798bab
L		 2465 bed = get_elf_backend_data (info->output_bfd);
2466
2467 htab = elf_x86_hash_table (info, bed->target_id);
2468 if (htab == NULL)
2469 return pbfd;
2470
1de031c8
L		 2471 htab->r_info = init_table->r_info;
2472 htab->r_sym = init_table->r_sym;
7a382c1c
L		 2473
2474 if (bfd_link_relocatable (info))
2475 return pbfd;
eeb2f20a 2476
851b6fa1
L		 2477 htab->plt0_pad_byte = init_table->plt0_pad_byte;
2478
a6798bab
L		 2479 use_ibt_plt = info->ibtplt || info->ibt;
2480 if (!use_ibt_plt && pbfd != NULL)
2481 {
2482 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2483 elf_property_list *p;
2484
2485 /* The property list is sorted in order of type. */
2486 for (p = elf_properties (pbfd); p; p = p->next)
2487 {
2488 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2489 {
2490 use_ibt_plt = !!(p->property.u.number
2491 & GNU_PROPERTY_X86_FEATURE_1_IBT);
2492 break;
2493 }
2494 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2495 break;
2496 }
2497 }
2498
2499 dynobj = htab->elf.dynobj;
2500
2501 /* Set htab->elf.dynobj here so that there is no need to check and
2502 set it in check_relocs. */
2503 if (dynobj == NULL)
2504 {
2505 if (pbfd != NULL)
2506 {
2507 htab->elf.dynobj = pbfd;
2508 dynobj = pbfd;
2509 }
2510 else
2511 {
2512 bfd *abfd;
2513
2514 /* Find a normal input file to hold linker created
2515 sections. */
2516 for (abfd = info->input_bfds;
2517 abfd != NULL;
2518 abfd = abfd->link.next)
2519 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2520 && (abfd->flags
e4e6a73d
L		 2521 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2522 && bed->relocs_compatible (abfd->xvec,
2523 info->output_bfd->xvec))
a6798bab
L		 2524 {
2525 htab->elf.dynobj = abfd;
2526 dynobj = abfd;
2527 break;
2528 }
2529 }
2530 }
2531
851b6fa1
L		 2532 /* Return if there are no normal input files. */
2533 if (dynobj == NULL)
2534 return pbfd;
2535
a6798bab
L		 2536 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2537 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2538 canonical function address. */
2539 htab->plt.has_plt0 = 1;
851b6fa1 2540 normal_target = htab->target_os == is_normal;
a6798bab
L		 2541
2542 if (normal_target)
2543 {
2544 if (use_ibt_plt)
2545 {
1de031c8
L		 2546 htab->lazy_plt = init_table->lazy_ibt_plt;
2547 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
a6798bab
L		 2548 }
2549 else
2550 {
1de031c8
L		 2551 htab->lazy_plt = init_table->lazy_plt;
2552 htab->non_lazy_plt = init_table->non_lazy_plt;
a6798bab
L		 2553 }
2554 }
2555 else
2556 {
1de031c8 2557 htab->lazy_plt = init_table->lazy_plt;
a6798bab
L		 2558 htab->non_lazy_plt = NULL;
2559 }
2560
2561 pltsec = htab->elf.splt;
2562
2563 /* If the non-lazy PLT is available, use it for all PLT entries if
2564 there are no PLT0 or no .plt section. */
2565 if (htab->non_lazy_plt != NULL
2566 && (!htab->plt.has_plt0 || pltsec == NULL))
2567 {
2568 lazy_plt = FALSE;
2569 if (bfd_link_pic (info))
2570 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2571 else
2572 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2573 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2574 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2575 htab->plt.plt_got_insn_size
2576 = htab->non_lazy_plt->plt_got_insn_size;
2577 htab->plt.eh_frame_plt_size
2578 = htab->non_lazy_plt->eh_frame_plt_size;
2579 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2580 }
2581 else
2582 {
2583 lazy_plt = TRUE;
2584 if (bfd_link_pic (info))
2585 {
2586 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2587 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2588 }
2589 else
2590 {
2591 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2592 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2593 }
2594 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2595 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2596 htab->plt.plt_got_insn_size
2597 = htab->lazy_plt->plt_got_insn_size;
2598 htab->plt.eh_frame_plt_size
2599 = htab->lazy_plt->eh_frame_plt_size;
2600 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2601 }
2602
851b6fa1 2603 if (htab->target_os == is_vxworks
a6798bab
L		 2604 && !elf_vxworks_create_dynamic_sections (dynobj, info,
2605 &htab->srelplt2))
2606 {
2c244f9b 2607 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
a6798bab
L		 2608 return pbfd;
2609 }
2610
2611 /* Since create_dynamic_sections isn't always called, but GOT
2612 relocations need GOT relocations, create them here so that we
2613 don't need to do it in check_relocs. */
2614 if (htab->elf.sgot == NULL
2615 && !_bfd_elf_create_got_section (dynobj, info))
2c244f9b 2616 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
a6798bab
L		 2617
2618 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2619
2620 /* Align .got and .got.plt sections to their entry size. Do it here
2621 instead of in create_dynamic_sections so that they are always
2622 properly aligned even if create_dynamic_sections isn't called. */
2623 sec = htab->elf.sgot;
2624 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2625 goto error_alignment;
2626
2627 sec = htab->elf.sgotplt;
2628 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2629 goto error_alignment;
2630
2631 /* Create the ifunc sections here so that check_relocs can be
2632 simplified. */
2633 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2c244f9b 2634 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
a6798bab
L		 2635
2636 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2637
2638 if (pltsec != NULL)
2639 {
2640 /* Whe creating executable, set the contents of the .interp
2641 section to the interpreter. */
2642 if (bfd_link_executable (info) && !info->nointerp)
2643 {
2644 asection *s = bfd_get_linker_section (dynobj, ".interp");
2645 if (s == NULL)
2646 abort ();
2647 s->size = htab->dynamic_interpreter_size;
2648 s->contents = (unsigned char *) htab->dynamic_interpreter;
2649 htab->interp = s;
2650 }
2651
2652 /* Don't change PLT section alignment for NaCl since it uses
2653 64-byte PLT entry and sets PLT section alignment to 32
2654 bytes. Don't create additional PLT sections for NaCl. */
2655 if (normal_target)
2656 {
2657 flagword pltflags = (bed->dynamic_sec_flags
2658 | SEC_ALLOC
2659 | SEC_CODE
2660 | SEC_LOAD
2661 | SEC_READONLY);
2662 unsigned int non_lazy_plt_alignment
2663 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2664
2665 sec = pltsec;
2666 if (!bfd_set_section_alignment (sec->owner, sec,
2667 plt_alignment))
2668 goto error_alignment;
2669
2670 /* Create the GOT procedure linkage table. */
2671 sec = bfd_make_section_anyway_with_flags (dynobj,
2672 ".plt.got",
2673 pltflags);
2674 if (sec == NULL)
2c244f9b 2675 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
a6798bab
L		 2676
2677 if (!bfd_set_section_alignment (dynobj, sec,
2678 non_lazy_plt_alignment))
2679 goto error_alignment;
2680
2681 htab->plt_got = sec;
2682
2683 if (lazy_plt)
2684 {
2685 sec = NULL;
2686
2687 if (use_ibt_plt)
2688 {
2689 /* Create the second PLT for Intel IBT support. IBT
2690 PLT is supported only for non-NaCl target and is
2691 is needed only for lazy binding. */
2692 sec = bfd_make_section_anyway_with_flags (dynobj,
2693 ".plt.sec",
2694 pltflags);
2695 if (sec == NULL)
2c244f9b 2696 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
a6798bab
L		 2697
2698 if (!bfd_set_section_alignment (dynobj, sec,
2699 plt_alignment))
2700 goto error_alignment;
2701 }
2702 else if (info->bndplt && ABI_64_P (dynobj))
2703 {
2704 /* Create the second PLT for Intel MPX support. MPX
2705 PLT is supported only for non-NaCl target in 64-bit
2706 mode and is needed only for lazy binding. */
2707 sec = bfd_make_section_anyway_with_flags (dynobj,
2708 ".plt.sec",
2709 pltflags);
2710 if (sec == NULL)
2c244f9b 2711 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
a6798bab
L		 2712
2713 if (!bfd_set_section_alignment (dynobj, sec,
2714 non_lazy_plt_alignment))
2715 goto error_alignment;
2716 }
2717
2718 htab->plt_second = sec;
2719 }
2720 }
2721
2722 if (!info->no_ld_generated_unwind_info)
2723 {
2724 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2725 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2726 | SEC_LINKER_CREATED);
2727
2728 sec = bfd_make_section_anyway_with_flags (dynobj,
2729 ".eh_frame",
2730 flags);
2731 if (sec == NULL)
2c244f9b 2732 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
a6798bab
L		 2733
2734 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2735 goto error_alignment;
2736
2737 htab->plt_eh_frame = sec;
2738
2739 if (htab->plt_got != NULL)
2740 {
2741 sec = bfd_make_section_anyway_with_flags (dynobj,
2742 ".eh_frame",
2743 flags);
2744 if (sec == NULL)
2c244f9b 2745 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
a6798bab
L		 2746
2747 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2748 goto error_alignment;
2749
2750 htab->plt_got_eh_frame = sec;
2751 }
2752
2753 if (htab->plt_second != NULL)
2754 {
2755 sec = bfd_make_section_anyway_with_flags (dynobj,
2756 ".eh_frame",
2757 flags);
2758 if (sec == NULL)
2c244f9b 2759 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
a6798bab
L		 2760
2761 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2762 goto error_alignment;
2763
2764 htab->plt_second_eh_frame = sec;
2765 }
2766 }
2767 }
2768
2769 if (normal_target)
2770 {
2771 /* The .iplt section is used for IFUNC symbols in static
2772 executables. */
2773 sec = htab->elf.iplt;
2774 if (sec != NULL
2775 && !bfd_set_section_alignment (sec->owner, sec,
2776 plt_alignment))
2777 goto error_alignment;
2778 }
2779
2780 return pbfd;
2781}
GDB Binutils - Deliverables
This page took 0.184934 seconds and 4 git commands to generate.