projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Rename remaining members of buildsym_compunit to start with "m_"
[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
9bc935ef
L		 852/* Mark symbol, NAME, as locally defined by linker if it is referenced
853 and not defined in a relocatable object file. */
854
855static void
856elf_x86_linker_defined (struct bfd_link_info *info, const char *name)
857{
858 struct elf_link_hash_entry *h;
859
860 h = elf_link_hash_lookup (elf_hash_table (info), name,
861 FALSE, FALSE, FALSE);
862 if (h == NULL)
863 return;
864
865 while (h->root.type == bfd_link_hash_indirect)
866 h = (struct elf_link_hash_entry *) h->root.u.i.link;
867
868 if (h->root.type == bfd_link_hash_new
869 || h->root.type == bfd_link_hash_undefined
870 || h->root.type == bfd_link_hash_undefweak
871 || h->root.type == bfd_link_hash_common
872 || (!h->def_regular && h->def_dynamic))
873 {
874 elf_x86_hash_entry (h)->local_ref = 2;
875 elf_x86_hash_entry (h)->linker_def = 1;
876 }
877}
878
ecf99cc0
L		 879/* Hide a linker-defined symbol, NAME, with hidden visibility. */
880
881static void
882elf_x86_hide_linker_defined (struct bfd_link_info *info,
883 const char *name)
884{
885 struct elf_link_hash_entry *h;
886
887 h = elf_link_hash_lookup (elf_hash_table (info), name,
888 FALSE, FALSE, FALSE);
889 if (h == NULL)
890 return;
891
892 while (h->root.type == bfd_link_hash_indirect)
893 h = (struct elf_link_hash_entry *) h->root.u.i.link;
894
895 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
896 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
897 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
898}
899
0afcef53
L		 900bfd_boolean
901_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
902{
903 if (!bfd_link_relocatable (info))
904 {
905 /* Check for __tls_get_addr reference. */
906 struct elf_x86_link_hash_table *htab;
907 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
908 htab = elf_x86_hash_table (info, bed->target_id);
909 if (htab)
910 {
0a27fed7
L		 911 struct elf_link_hash_entry *h;
912
913 h = elf_link_hash_lookup (elf_hash_table (info),
0afcef53
L		 914 htab->tls_get_addr,
915 FALSE, FALSE, FALSE);
916 if (h != NULL)
8a1b824a
L		 917 {
918 elf_x86_hash_entry (h)->tls_get_addr = 1;
919
920 /* Check the versioned __tls_get_addr symbol. */
921 while (h->root.type == bfd_link_hash_indirect)
922 {
923 h = (struct elf_link_hash_entry *) h->root.u.i.link;
924 elf_x86_hash_entry (h)->tls_get_addr = 1;
925 }
926 }
0a27fed7
L		 927
928 /* "__ehdr_start" will be defined by linker as a hidden symbol
929 later if it is referenced and not defined. */
9bc935ef
L		 930 elf_x86_linker_defined (info, "__ehdr_start");
931
932 if (bfd_link_executable (info))
0a27fed7 933 {
9bc935ef
L		 934 /* References to __bss_start, _end and _edata should be
935 locally resolved within executables. */
936 elf_x86_linker_defined (info, "__bss_start");
937 elf_x86_linker_defined (info, "_end");
938 elf_x86_linker_defined (info, "_edata");
ecf99cc0
L		 939 }
940 else
941 {
942 /* Hide hidden __bss_start, _end and _edata in shared
943 libraries. */
944 elf_x86_hide_linker_defined (info, "__bss_start");
945 elf_x86_hide_linker_defined (info, "_end");
946 elf_x86_hide_linker_defined (info, "_edata");
0a27fed7 947 }
0afcef53
L		 948 }
949 }
950
951 /* Invoke the regular ELF backend linker to do all the work. */
952 return _bfd_elf_link_check_relocs (abfd, info);
953}
954
5e2ac45d
L		 955/* Set the sizes of the dynamic sections. */
956
957bfd_boolean
958_bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
959 struct bfd_link_info *info)
960{
961 struct elf_x86_link_hash_table *htab;
962 bfd *dynobj;
963 asection *s;
964 bfd_boolean relocs;
965 bfd *ibfd;
966 const struct elf_backend_data *bed
967 = get_elf_backend_data (output_bfd);
968
969 htab = elf_x86_hash_table (info, bed->target_id);
970 if (htab == NULL)
971 return FALSE;
972 dynobj = htab->elf.dynobj;
973 if (dynobj == NULL)
974 abort ();
975
976 /* Set up .got offsets for local syms, and space for local dynamic
977 relocs. */
978 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
979 {
980 bfd_signed_vma *local_got;
981 bfd_signed_vma *end_local_got;
982 char *local_tls_type;
983 bfd_vma *local_tlsdesc_gotent;
984 bfd_size_type locsymcount;
985 Elf_Internal_Shdr *symtab_hdr;
986 asection *srel;
987
988 if (! is_x86_elf (ibfd, htab))
989 continue;
990
991 for (s = ibfd->sections; s != NULL; s = s->next)
992 {
993 struct elf_dyn_relocs *p;
994
5e2ac45d
L		 995 for (p = ((struct elf_dyn_relocs *)
996 elf_section_data (s)->local_dynrel);
997 p != NULL;
998 p = p->next)
999 {
1000 if (!bfd_is_abs_section (p->sec)
1001 && bfd_is_abs_section (p->sec->output_section))
1002 {
1003 /* Input section has been discarded, either because
1004 it is a copy of a linkonce section or due to
1005 linker script /DISCARD/, so we'll be discarding
1006 the relocs too. */
1007 }
851b6fa1 1008 else if (htab->target_os == is_vxworks
5e2ac45d
L		 1009 && strcmp (p->sec->output_section->name,
1010 ".tls_vars") == 0)
1011 {
1012 /* Relocations in vxworks .tls_vars sections are
1013 handled specially by the loader. */
1014 }
1015 else if (p->count != 0)
1016 {
1017 srel = elf_section_data (p->sec)->sreloc;
1018 srel->size += p->count * htab->sizeof_reloc;
1019 if ((p->sec->output_section->flags & SEC_READONLY) != 0
1020 && (info->flags & DF_TEXTREL) == 0)
1021 {
1022 info->flags |= DF_TEXTREL;
1023 if ((info->warn_shared_textrel && bfd_link_pic (info))
1024 || info->error_textrel)
1025 /* xgettext:c-format */
826c3f1e 1026 info->callbacks->einfo
871b3ab2
AM		 1027 (_("%P: %pB: warning: relocation "
1028 "in read-only section `%pA'\n"),
826c3f1e 1029 p->sec->owner, p->sec);
5e2ac45d
L		 1030 }
1031 }
1032 }
1033 }
1034
1035 local_got = elf_local_got_refcounts (ibfd);
1036 if (!local_got)
1037 continue;
1038
1039 symtab_hdr = &elf_symtab_hdr (ibfd);
1040 locsymcount = symtab_hdr->sh_info;
1041 end_local_got = local_got + locsymcount;
1042 local_tls_type = elf_x86_local_got_tls_type (ibfd);
1043 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
1044 s = htab->elf.sgot;
1045 srel = htab->elf.srelgot;
1046 for (; local_got < end_local_got;
1047 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1048 {
1049 *local_tlsdesc_gotent = (bfd_vma) -1;
1050 if (*local_got > 0)
1051 {
1052 if (GOT_TLS_GDESC_P (*local_tls_type))
1053 {
1054 *local_tlsdesc_gotent = htab->elf.sgotplt->size
1055 - elf_x86_compute_jump_table_size (htab);
1056 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
1057 *local_got = (bfd_vma) -2;
1058 }
1059 if (! GOT_TLS_GDESC_P (*local_tls_type)
1060 || GOT_TLS_GD_P (*local_tls_type))
1061 {
1062 *local_got = s->size;
1063 s->size += htab->got_entry_size;
1064 if (GOT_TLS_GD_P (*local_tls_type)
1065 || *local_tls_type == GOT_TLS_IE_BOTH)
1066 s->size += htab->got_entry_size;
1067 }
1068 if (bfd_link_pic (info)
1069 || GOT_TLS_GD_ANY_P (*local_tls_type)
1070 || (*local_tls_type & GOT_TLS_IE))
1071 {
1072 if (*local_tls_type == GOT_TLS_IE_BOTH)
1073 srel->size += 2 * htab->sizeof_reloc;
1074 else if (GOT_TLS_GD_P (*local_tls_type)
1075 || ! GOT_TLS_GDESC_P (*local_tls_type))
1076 srel->size += htab->sizeof_reloc;
1077 if (GOT_TLS_GDESC_P (*local_tls_type))
1078 {
1079 htab->elf.srelplt->size += htab->sizeof_reloc;
1080 if (bed->target_id == X86_64_ELF_DATA)
1081 htab->tlsdesc_plt = (bfd_vma) -1;
1082 }
1083 }
1084 }
1085 else
1086 *local_got = (bfd_vma) -1;
1087 }
1088 }
1089
1090 if (htab->tls_ld_or_ldm_got.refcount > 0)
1091 {
1092 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
07d6d2b8 1093 or R_X86_64_TLSLD relocs. */
5e2ac45d
L		 1094 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1095 htab->elf.sgot->size += 2 * htab->got_entry_size;
1096 htab->elf.srelgot->size += htab->sizeof_reloc;
1097 }
1098 else
1099 htab->tls_ld_or_ldm_got.offset = -1;
1100
1101 /* Allocate global sym .plt and .got entries, and space for global
1102 sym dynamic relocs. */
1103 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1104 info);
1105
1106 /* Allocate .plt and .got entries, and space for local symbols. */
1107 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1108 info);
1109
1110 /* For every jump slot reserved in the sgotplt, reloc_count is
1111 incremented. However, when we reserve space for TLS descriptors,
1112 it's not incremented, so in order to compute the space reserved
1113 for them, it suffices to multiply the reloc count by the jump
1114 slot size.
1115
1116 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1117 so that R_{386,X86_64}_IRELATIVE entries come last. */
1118 if (htab->elf.srelplt)
1119 {
1120 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1121 htab->sgotplt_jump_table_size
1122 = elf_x86_compute_jump_table_size (htab);
1123 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1124 }
1125 else if (htab->elf.irelplt)
1126 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1127
1128 if (htab->tlsdesc_plt)
1129 {
1130 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1131 lazy TLS relocations, don't generate the PLT and GOT entries
1132 they require. */
1133 if ((info->flags & DF_BIND_NOW))
1134 htab->tlsdesc_plt = 0;
1135 else
1136 {
1137 htab->tlsdesc_got = htab->elf.sgot->size;
1138 htab->elf.sgot->size += htab->got_entry_size;
1139 /* Reserve room for the initial entry.
1140 FIXME: we could probably do away with it in this case. */
1141 if (htab->elf.splt->size == 0)
1142 htab->elf.splt->size = htab->plt.plt_entry_size;
1143 htab->tlsdesc_plt = htab->elf.splt->size;
1144 htab->elf.splt->size += htab->plt.plt_entry_size;
1145 }
1146 }
1147
1148 if (htab->elf.sgotplt)
1149 {
1150 /* Don't allocate .got.plt section if there are no GOT nor PLT
1151 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1152 if ((htab->elf.hgot == NULL
cd048363 1153 || !htab->got_referenced)
5e2ac45d
L		 1154 && (htab->elf.sgotplt->size == bed->got_header_size)
1155 && (htab->elf.splt == NULL
1156 || htab->elf.splt->size == 0)
1157 && (htab->elf.sgot == NULL
1158 || htab->elf.sgot->size == 0)
1159 && (htab->elf.iplt == NULL
1160 || htab->elf.iplt->size == 0)
1161 && (htab->elf.igotplt == NULL
1162 || htab->elf.igotplt->size == 0))
cd048363
L		 1163 {
1164 htab->elf.sgotplt->size = 0;
3b4c3844
L		 1165 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1166 isn't used. */
1167 if (htab->elf.hgot != NULL && htab->target_os != is_solaris)
cd048363
L		 1168 {
1169 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1170 table. */
1171 htab->elf.hgot->root.type = bfd_link_hash_undefined;
1172 htab->elf.hgot->root.u.undef.abfd
1173 = htab->elf.hgot->root.u.def.section->owner;
1174 htab->elf.hgot->root.linker_def = 0;
1175 htab->elf.hgot->ref_regular = 0;
1176 htab->elf.hgot->def_regular = 0;
1177 }
1178 }
5e2ac45d
L		 1179 }
1180
1181 if (_bfd_elf_eh_frame_present (info))
1182 {
1183 if (htab->plt_eh_frame != NULL
1184 && htab->elf.splt != NULL
1185 && htab->elf.splt->size != 0
1186 && !bfd_is_abs_section (htab->elf.splt->output_section))
1187 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1188
1189 if (htab->plt_got_eh_frame != NULL
1190 && htab->plt_got != NULL
1191 && htab->plt_got->size != 0
1192 && !bfd_is_abs_section (htab->plt_got->output_section))
1193 htab->plt_got_eh_frame->size
1194 = htab->non_lazy_plt->eh_frame_plt_size;
1195
1196 /* Unwind info for the second PLT and .plt.got sections are
1197 identical. */
1198 if (htab->plt_second_eh_frame != NULL
1199 && htab->plt_second != NULL
1200 && htab->plt_second->size != 0
1201 && !bfd_is_abs_section (htab->plt_second->output_section))
1202 htab->plt_second_eh_frame->size
1203 = htab->non_lazy_plt->eh_frame_plt_size;
1204 }
1205
1206 /* We now have determined the sizes of the various dynamic sections.
1207 Allocate memory for them. */
1208 relocs = FALSE;
1209 for (s = dynobj->sections; s != NULL; s = s->next)
1210 {
1211 bfd_boolean strip_section = TRUE;
1212
1213 if ((s->flags & SEC_LINKER_CREATED) == 0)
1214 continue;
1215
1216 if (s == htab->elf.splt
1217 || s == htab->elf.sgot)
1218 {
1219 /* Strip this section if we don't need it; see the
1220 comment below. */
1221 /* We'd like to strip these sections if they aren't needed, but if
1222 we've exported dynamic symbols from them we must leave them.
1223 It's too late to tell BFD to get rid of the symbols. */
1224
1225 if (htab->elf.hplt != NULL)
1226 strip_section = FALSE;
1227 }
1228 else if (s == htab->elf.sgotplt
1229 || s == htab->elf.iplt
1230 || s == htab->elf.igotplt
1231 || s == htab->plt_second
1232 || s == htab->plt_got
1233 || s == htab->plt_eh_frame
1234 || s == htab->plt_got_eh_frame
1235 || s == htab->plt_second_eh_frame
1236 || s == htab->elf.sdynbss
1237 || s == htab->elf.sdynrelro)
1238 {
1239 /* Strip these too. */
1240 }
1241 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1242 {
1243 if (s->size != 0
1244 && s != htab->elf.srelplt
1245 && s != htab->srelplt2)
1246 relocs = TRUE;
1247
1248 /* We use the reloc_count field as a counter if we need
1249 to copy relocs into the output file. */
1250 if (s != htab->elf.srelplt)
1251 s->reloc_count = 0;
1252 }
1253 else
1254 {
1255 /* It's not one of our sections, so don't allocate space. */
1256 continue;
1257 }
1258
1259 if (s->size == 0)
1260 {
1261 /* If we don't need this section, strip it from the
1262 output file. This is mostly to handle .rel.bss and
1263 .rel.plt. We must create both sections in
1264 create_dynamic_sections, because they must be created
1265 before the linker maps input sections to output
1266 sections. The linker does that before
1267 adjust_dynamic_symbol is called, and it is that
1268 function which decides whether anything needs to go
1269 into these sections. */
1270 if (strip_section)
1271 s->flags |= SEC_EXCLUDE;
1272 continue;
1273 }
1274
1275 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1276 continue;
1277
1278 /* Allocate memory for the section contents. We use bfd_zalloc
1279 here in case unused entries are not reclaimed before the
1280 section's contents are written out. This should not happen,
1281 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1282 reloc instead of garbage. */
1283 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1284 if (s->contents == NULL)
1285 return FALSE;
1286 }
1287
1288 if (htab->plt_eh_frame != NULL
1289 && htab->plt_eh_frame->contents != NULL)
1290 {
1291 memcpy (htab->plt_eh_frame->contents,
1292 htab->plt.eh_frame_plt,
1293 htab->plt_eh_frame->size);
1294 bfd_put_32 (dynobj, htab->elf.splt->size,
1295 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1296 }
1297
1298 if (htab->plt_got_eh_frame != NULL
1299 && htab->plt_got_eh_frame->contents != NULL)
1300 {
1301 memcpy (htab->plt_got_eh_frame->contents,
1302 htab->non_lazy_plt->eh_frame_plt,
1303 htab->plt_got_eh_frame->size);
1304 bfd_put_32 (dynobj, htab->plt_got->size,
1305 (htab->plt_got_eh_frame->contents
1306 + PLT_FDE_LEN_OFFSET));
1307 }
1308
1309 if (htab->plt_second_eh_frame != NULL
1310 && htab->plt_second_eh_frame->contents != NULL)
1311 {
1312 memcpy (htab->plt_second_eh_frame->contents,
1313 htab->non_lazy_plt->eh_frame_plt,
1314 htab->plt_second_eh_frame->size);
1315 bfd_put_32 (dynobj, htab->plt_second->size,
1316 (htab->plt_second_eh_frame->contents
1317 + PLT_FDE_LEN_OFFSET));
1318 }
1319
1320 if (htab->elf.dynamic_sections_created)
1321 {
1322 /* Add some entries to the .dynamic section. We fill in the
1323 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1324 but we must add the entries now so that we get the correct
1325 size for the .dynamic section. The DT_DEBUG entry is filled
1326 in by the dynamic linker and used by the debugger. */
1327#define add_dynamic_entry(TAG, VAL) \
1328 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1329
1330 if (bfd_link_executable (info))
1331 {
1332 if (!add_dynamic_entry (DT_DEBUG, 0))
1333 return FALSE;
1334 }
1335
1336 if (htab->elf.splt->size != 0)
1337 {
1338 /* DT_PLTGOT is used by prelink even if there is no PLT
1339 relocation. */
1340 if (!add_dynamic_entry (DT_PLTGOT, 0))
1341 return FALSE;
1342 }
1343
1344 if (htab->elf.srelplt->size != 0)
1345 {
1346 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1347 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1348 || !add_dynamic_entry (DT_JMPREL, 0))
1349 return FALSE;
1350 }
1351
1352 if (htab->tlsdesc_plt
1353 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1354 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1355 return FALSE;
1356
1357 if (relocs)
1358 {
1359 if (!add_dynamic_entry (htab->dt_reloc, 0)
1360 || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1361 || !add_dynamic_entry (htab->dt_reloc_ent,
1362 htab->sizeof_reloc))
1363 return FALSE;
1364
1365 /* If any dynamic relocs apply to a read-only section,
1366 then we need a DT_TEXTREL entry. */
1367 if ((info->flags & DF_TEXTREL) == 0)
826c3f1e 1368 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5e2ac45d
L		 1369
1370 if ((info->flags & DF_TEXTREL) != 0)
1371 {
1372 if (htab->readonly_dynrelocs_against_ifunc)
1373 {
1374 info->callbacks->einfo
826c3f1e
AM		 1375 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1376 " recompile with -fPIC\n"));
5e2ac45d
L		 1377 bfd_set_error (bfd_error_bad_value);
1378 return FALSE;
1379 }
1380
1381 if (!add_dynamic_entry (DT_TEXTREL, 0))
1382 return FALSE;
1383 }
1384 }
851b6fa1 1385 if (htab->target_os == is_vxworks
5e2ac45d
L		 1386 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1387 return FALSE;
1388 }
1389#undef add_dynamic_entry
1390
1391 return TRUE;
1392}
1393
9577f60b
L		 1394/* Finish up the x86 dynamic sections. */
1395
1396struct elf_x86_link_hash_table *
1397_bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1398 struct bfd_link_info *info)
1399{
1400 struct elf_x86_link_hash_table *htab;
1401 const struct elf_backend_data *bed;
1402 bfd *dynobj;
1403 asection *sdyn;
1404 bfd_byte *dyncon, *dynconend;
1405 bfd_size_type sizeof_dyn;
1406
1407 bed = get_elf_backend_data (output_bfd);
1408 htab = elf_x86_hash_table (info, bed->target_id);
1409 if (htab == NULL)
1410 return htab;
1411
1412 dynobj = htab->elf.dynobj;
1413 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1414
1415 /* GOT is always created in setup_gnu_properties. But it may not be
1416 needed. .got.plt section may be needed for static IFUNC. */
1417 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1418 {
1419 bfd_vma dynamic_addr;
1420
1421 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1422 {
1423 _bfd_error_handler
871b3ab2 1424 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
9577f60b
L		 1425 return NULL;
1426 }
1427
1428 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1429 = htab->got_entry_size;
1430
1431 dynamic_addr = (sdyn == NULL
1432 ? (bfd_vma) 0
1433 : sdyn->output_section->vma + sdyn->output_offset);
1434
1435 /* Set the first entry in the global offset table to the address
07d6d2b8 1436 of the dynamic section. Write GOT[1] and GOT[2], needed for
9577f60b
L		 1437 the dynamic linker. */
1438 if (htab->got_entry_size == 8)
1439 {
1440 bfd_put_64 (output_bfd, dynamic_addr,
1441 htab->elf.sgotplt->contents);
1442 bfd_put_64 (output_bfd, (bfd_vma) 0,
1443 htab->elf.sgotplt->contents + 8);
1444 bfd_put_64 (output_bfd, (bfd_vma) 0,
1445 htab->elf.sgotplt->contents + 8*2);
1446 }
1447 else
1448 {
1449 bfd_put_32 (output_bfd, dynamic_addr,
1450 htab->elf.sgotplt->contents);
1451 bfd_put_32 (output_bfd, 0,
1452 htab->elf.sgotplt->contents + 4);
1453 bfd_put_32 (output_bfd, 0,
1454 htab->elf.sgotplt->contents + 4*2);
1455 }
1456 }
1457
1458 if (!htab->elf.dynamic_sections_created)
1459 return htab;
1460
1461 if (sdyn == NULL || htab->elf.sgot == NULL)
1462 abort ();
1463
1464 sizeof_dyn = bed->s->sizeof_dyn;
1465 dyncon = sdyn->contents;
1466 dynconend = sdyn->contents + sdyn->size;
1467 for (; dyncon < dynconend; dyncon += sizeof_dyn)
1468 {
1469 Elf_Internal_Dyn dyn;
1470 asection *s;
1471
1472 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1473
1474 switch (dyn.d_tag)
1475 {
1476 default:
851b6fa1 1477 if (htab->target_os == is_vxworks
9577f60b
L		 1478 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1479 break;
1480 continue;
1481
1482 case DT_PLTGOT:
1483 s = htab->elf.sgotplt;
1484 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1485 break;
1486
1487 case DT_JMPREL:
1488 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1489 break;
1490
1491 case DT_PLTRELSZ:
1492 s = htab->elf.srelplt->output_section;
1493 dyn.d_un.d_val = s->size;
1494 break;
1495
1496 case DT_TLSDESC_PLT:
1497 s = htab->elf.splt;
1498 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1499 + htab->tlsdesc_plt;
1500 break;
1501
1502 case DT_TLSDESC_GOT:
1503 s = htab->elf.sgot;
1504 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1505 + htab->tlsdesc_got;
1506 break;
1507 }
1508
1509 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1510 }
1511
1512 if (htab->plt_got != NULL && htab->plt_got->size > 0)
1513 elf_section_data (htab->plt_got->output_section)
1514 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1515
1516 if (htab->plt_second != NULL && htab->plt_second->size > 0)
1517 elf_section_data (htab->plt_second->output_section)
1518 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1519
1520 /* Adjust .eh_frame for .plt section. */
1521 if (htab->plt_eh_frame != NULL
1522 && htab->plt_eh_frame->contents != NULL)
1523 {
1524 if (htab->elf.splt != NULL
1525 && htab->elf.splt->size != 0
1526 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1527 && htab->elf.splt->output_section != NULL
1528 && htab->plt_eh_frame->output_section != NULL)
1529 {
1530 bfd_vma plt_start = htab->elf.splt->output_section->vma;
1531 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1532 + htab->plt_eh_frame->output_offset
1533 + PLT_FDE_START_OFFSET;
1534 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1535 htab->plt_eh_frame->contents
1536 + PLT_FDE_START_OFFSET);
1537 }
1538
1539 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1540 {
1541 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1542 htab->plt_eh_frame,
1543 htab->plt_eh_frame->contents))
1544 return NULL;
1545 }
1546 }
1547
1548 /* Adjust .eh_frame for .plt.got section. */
1549 if (htab->plt_got_eh_frame != NULL
1550 && htab->plt_got_eh_frame->contents != NULL)
1551 {
1552 if (htab->plt_got != NULL
1553 && htab->plt_got->size != 0
1554 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1555 && htab->plt_got->output_section != NULL
1556 && htab->plt_got_eh_frame->output_section != NULL)
1557 {
1558 bfd_vma plt_start = htab->plt_got->output_section->vma;
1559 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1560 + htab->plt_got_eh_frame->output_offset
1561 + PLT_FDE_START_OFFSET;
1562 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1563 htab->plt_got_eh_frame->contents
1564 + PLT_FDE_START_OFFSET);
1565 }
1566 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1567 {
1568 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1569 htab->plt_got_eh_frame,
1570 htab->plt_got_eh_frame->contents))
1571 return NULL;
1572 }
1573 }
1574
1575 /* Adjust .eh_frame for the second PLT section. */
1576 if (htab->plt_second_eh_frame != NULL
1577 && htab->plt_second_eh_frame->contents != NULL)
1578 {
1579 if (htab->plt_second != NULL
1580 && htab->plt_second->size != 0
1581 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1582 && htab->plt_second->output_section != NULL
1583 && htab->plt_second_eh_frame->output_section != NULL)
1584 {
1585 bfd_vma plt_start = htab->plt_second->output_section->vma;
1586 bfd_vma eh_frame_start
1587 = (htab->plt_second_eh_frame->output_section->vma
1588 + htab->plt_second_eh_frame->output_offset
1589 + PLT_FDE_START_OFFSET);
1590 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1591 htab->plt_second_eh_frame->contents
1592 + PLT_FDE_START_OFFSET);
1593 }
1594 if (htab->plt_second_eh_frame->sec_info_type
1595 == SEC_INFO_TYPE_EH_FRAME)
1596 {
1597 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1598 htab->plt_second_eh_frame,
1599 htab->plt_second_eh_frame->contents))
1600 return NULL;
1601 }
1602 }
1603
1604 if (htab->elf.sgot && htab->elf.sgot->size > 0)
1605 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1606 = htab->got_entry_size;
1607
1608 return htab;
1609}
1610
1611
0afcef53
L		 1612bfd_boolean
1613_bfd_x86_elf_always_size_sections (bfd *output_bfd,
1614 struct bfd_link_info *info)
1615{
1616 asection *tls_sec = elf_hash_table (info)->tls_sec;
1617
1618 if (tls_sec)
1619 {
1620 struct elf_link_hash_entry *tlsbase;
1621
1622 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1623 "_TLS_MODULE_BASE_",
1624 FALSE, FALSE, FALSE);
1625
1626 if (tlsbase && tlsbase->type == STT_TLS)
1627 {
1628 struct elf_x86_link_hash_table *htab;
1629 struct bfd_link_hash_entry *bh = NULL;
1630 const struct elf_backend_data *bed
1631 = get_elf_backend_data (output_bfd);
1632
1633 htab = elf_x86_hash_table (info, bed->target_id);
1634 if (htab == NULL)
1635 return FALSE;
1636
1637 if (!(_bfd_generic_link_add_one_symbol
1638 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1639 tls_sec, 0, NULL, FALSE,
1640 bed->collect, &bh)))
1641 return FALSE;
1642
1643 htab->tls_module_base = bh;
1644
1645 tlsbase = (struct elf_link_hash_entry *)bh;
1646 tlsbase->def_regular = 1;
1647 tlsbase->other = STV_HIDDEN;
1648 tlsbase->root.linker_def = 1;
1649 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1650 }
1651 }
1652
1653 return TRUE;
1654}
1655
1656void
1657_bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1658 const Elf_Internal_Sym *isym,
1659 bfd_boolean definition,
1660 bfd_boolean dynamic ATTRIBUTE_UNUSED)
1661{
1662 if (definition)
1663 {
1664 struct elf_x86_link_hash_entry *eh
1665 = (struct elf_x86_link_hash_entry *) h;
1666 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1667 == STV_PROTECTED);
1668 }
1669}
1670
1671/* Copy the extra info we tack onto an elf_link_hash_entry. */
1672
1673void
1674_bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1675 struct elf_link_hash_entry *dir,
1676 struct elf_link_hash_entry *ind)
1677{
1678 struct elf_x86_link_hash_entry *edir, *eind;
1679
1680 edir = (struct elf_x86_link_hash_entry *) dir;
1681 eind = (struct elf_x86_link_hash_entry *) ind;
1682
1683 if (eind->dyn_relocs != NULL)
1684 {
1685 if (edir->dyn_relocs != NULL)
1686 {
1687 struct elf_dyn_relocs **pp;
1688 struct elf_dyn_relocs *p;
1689
1690 /* Add reloc counts against the indirect sym to the direct sym
1691 list. Merge any entries against the same section. */
1692 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1693 {
1694 struct elf_dyn_relocs *q;
1695
1696 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1697 if (q->sec == p->sec)
1698 {
1699 q->pc_count += p->pc_count;
1700 q->count += p->count;
1701 *pp = p->next;
1702 break;
1703 }
1704 if (q == NULL)
1705 pp = &p->next;
1706 }
1707 *pp = edir->dyn_relocs;
1708 }
1709
1710 edir->dyn_relocs = eind->dyn_relocs;
1711 eind->dyn_relocs = NULL;
1712 }
1713
1714 if (ind->root.type == bfd_link_hash_indirect
1715 && dir->got.refcount <= 0)
1716 {
1717 edir->tls_type = eind->tls_type;
1718 eind->tls_type = GOT_UNKNOWN;
1719 }
1720
1721 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1722 generate a R_386_COPY reloc. */
1723 edir->gotoff_ref |= eind->gotoff_ref;
1724
98b273dc 1725 edir->zero_undefweak |= eind->zero_undefweak;
0afcef53
L		 1726
1727 if (ELIMINATE_COPY_RELOCS
1728 && ind->root.type != bfd_link_hash_indirect
1729 && dir->dynamic_adjusted)
1730 {
1731 /* If called to transfer flags for a weakdef during processing
1732 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1733 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1734 if (dir->versioned != versioned_hidden)
1735 dir->ref_dynamic |= ind->ref_dynamic;
1736 dir->ref_regular |= ind->ref_regular;
1737 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1738 dir->needs_plt |= ind->needs_plt;
1739 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1740 }
1741 else
79b0c981 1742 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
0afcef53
L		 1743}
1744
1745/* Remove undefined weak symbol from the dynamic symbol table if it
1746 is resolved to 0. */
1747
1748bfd_boolean
1749_bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1750 struct elf_link_hash_entry *h)
1751{
c5bce5c6
L		 1752 if (h->dynindx != -1
1753 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
0afcef53 1754 {
c5bce5c6
L		 1755 h->dynindx = -1;
1756 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1757 h->dynstr_index);
0afcef53
L		 1758 }
1759 return TRUE;
1760}
1761
4ec09950
L		 1762/* Change the STT_GNU_IFUNC symbol defined in position-dependent
1763 executable into the normal function symbol and set its address
1764 to its PLT entry, which should be resolved by R_*_IRELATIVE at
1765 run-time. */
1766
1767void
1768_bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
1769 struct elf_x86_link_hash_table *htab,
1770 struct elf_link_hash_entry *h,
1771 Elf_Internal_Sym *sym)
1772{
1773 if (bfd_link_pde (info)
1774 && h->def_regular
1775 && h->dynindx != -1
1776 && h->plt.offset != (bfd_vma) -1
1777 && h->type == STT_GNU_IFUNC
1778 && h->pointer_equality_needed)
1779 {
1780 asection *plt_s;
1781 bfd_vma plt_offset;
1782 bfd *output_bfd = info->output_bfd;
1783
1784 if (htab->plt_second)
1785 {
1786 struct elf_x86_link_hash_entry *eh
1787 = (struct elf_x86_link_hash_entry *) h;
1788
1789 plt_s = htab->plt_second;
1790 plt_offset = eh->plt_second.offset;
1791 }
1792 else
1793 {
1794 plt_s = htab->elf.splt;
1795 plt_offset = h->plt.offset;
1796 }
1797
1798 sym->st_size = 0;
1799 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
1800 sym->st_shndx
1801 = _bfd_elf_section_from_bfd_section (output_bfd,
1802 plt_s->output_section);
1803 sym->st_value = (plt_s->output_section->vma
1804 + plt_s->output_offset + plt_offset);
1805 }
1806}
1807
0afcef53
L		 1808/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1809
1810bfd_boolean
1811_bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1812{
1813 if (h->plt.offset != (bfd_vma) -1
1814 && !h->def_regular
1815 && !h->pointer_equality_needed)
1816 return FALSE;
1817
1818 return _bfd_elf_hash_symbol (h);
1819}
1820
eeb2f20a
L		 1821/* Adjust a symbol defined by a dynamic object and referenced by a
1822 regular object. The current definition is in some section of the
1823 dynamic object, but we're not including those sections. We have to
1824 change the definition to something the rest of the link can
1825 understand. */
1826
1827bfd_boolean
1828_bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1829 struct elf_link_hash_entry *h)
1830{
1831 struct elf_x86_link_hash_table *htab;
1832 asection *s, *srel;
1833 struct elf_x86_link_hash_entry *eh;
1834 struct elf_dyn_relocs *p;
1835 const struct elf_backend_data *bed
1836 = get_elf_backend_data (info->output_bfd);
1837
1838 /* STT_GNU_IFUNC symbol must go through PLT. */
1839 if (h->type == STT_GNU_IFUNC)
1840 {
1841 /* All local STT_GNU_IFUNC references must be treate as local
1842 calls via local PLT. */
1843 if (h->ref_regular
1844 && SYMBOL_CALLS_LOCAL (info, h))
1845 {
1846 bfd_size_type pc_count = 0, count = 0;
1847 struct elf_dyn_relocs **pp;
1848
1849 eh = (struct elf_x86_link_hash_entry *) h;
1850 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1851 {
1852 pc_count += p->pc_count;
1853 p->count -= p->pc_count;
1854 p->pc_count = 0;
1855 count += p->count;
1856 if (p->count == 0)
1857 *pp = p->next;
1858 else
1859 pp = &p->next;
1860 }
1861
1862 if (pc_count || count)
1863 {
1864 h->non_got_ref = 1;
1865 if (pc_count)
1866 {
1867 /* Increment PLT reference count only for PC-relative
1868 references. */
1869 h->needs_plt = 1;
1870 if (h->plt.refcount <= 0)
1871 h->plt.refcount = 1;
1872 else
1873 h->plt.refcount += 1;
1874 }
1875 }
1876 }
1877
1878 if (h->plt.refcount <= 0)
1879 {
1880 h->plt.offset = (bfd_vma) -1;
1881 h->needs_plt = 0;
1882 }
1883 return TRUE;
1884 }
1885
1886 /* If this is a function, put it in the procedure linkage table. We
1887 will fill in the contents of the procedure linkage table later,
1888 when we know the address of the .got section. */
1889 if (h->type == STT_FUNC
1890 || h->needs_plt)
1891 {
1892 if (h->plt.refcount <= 0
1893 || SYMBOL_CALLS_LOCAL (info, h)
1894 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1895 && h->root.type == bfd_link_hash_undefweak))
1896 {
1897 /* This case can occur if we saw a PLT32 reloc in an input
1898 file, but the symbol was never referred to by a dynamic
1899 object, or if all references were garbage collected. In
1900 such a case, we don't actually need to build a procedure
1901 linkage table, and we can just do a PC32 reloc instead. */
1902 h->plt.offset = (bfd_vma) -1;
1903 h->needs_plt = 0;
1904 }
1905
1906 return TRUE;
1907 }
1908 else
1909 /* It's possible that we incorrectly decided a .plt reloc was needed
1910 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1911 check_relocs. We can't decide accurately between function and
1912 non-function syms in check-relocs; Objects loaded later in
1913 the link may change h->type. So fix it now. */
1914 h->plt.offset = (bfd_vma) -1;
1915
1916 eh = (struct elf_x86_link_hash_entry *) h;
1917
1918 /* If this is a weak symbol, and there is a real definition, the
1919 processor independent code will have arranged for us to see the
1920 real definition first, and we can just use the same value. */
60d67dc8 1921 if (h->is_weakalias)
eeb2f20a 1922 {
60d67dc8
AM		 1923 struct elf_link_hash_entry *def = weakdef (h);
1924 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1925 h->root.u.def.section = def->root.u.def.section;
1926 h->root.u.def.value = def->root.u.def.value;
eeb2f20a
L		 1927 if (ELIMINATE_COPY_RELOCS
1928 || info->nocopyreloc
1929 || SYMBOL_NO_COPYRELOC (info, eh))
1930 {
1931 /* NB: needs_copy is always 0 for i386. */
60d67dc8
AM		 1932 h->non_got_ref = def->non_got_ref;
1933 eh->needs_copy = def->needs_copy;
eeb2f20a
L		 1934 }
1935 return TRUE;
1936 }
1937
1938 /* This is a reference to a symbol defined by a dynamic object which
1939 is not a function. */
1940
1941 /* If we are creating a shared library, we must presume that the
1942 only references to the symbol are via the global offset table.
1943 For such cases we need not do anything here; the relocations will
1944 be handled correctly by relocate_section. */
1945 if (!bfd_link_executable (info))
1946 return TRUE;
1947
1948 /* If there are no references to this symbol that do not use the
1949 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1950 reloc. NB: gotoff_ref is always 0 for x86-64. */
1951 if (!h->non_got_ref && !eh->gotoff_ref)
1952 return TRUE;
1953
1954 /* If -z nocopyreloc was given, we won't generate them either. */
1955 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1956 {
1957 h->non_got_ref = 0;
1958 return TRUE;
1959 }
1960
1961 htab = elf_x86_hash_table (info, bed->target_id);
1962 if (htab == NULL)
1963 return FALSE;
1964
1965 /* If there aren't any dynamic relocs in read-only sections nor
1966 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1967 avoid the copy reloc. This doesn't work on VxWorks, where we can
1968 not have dynamic relocations (other than copy and jump slot
1969 relocations) in an executable. */
1970 if (ELIMINATE_COPY_RELOCS
1971 && (bed->target_id == X86_64_ELF_DATA
1972 || (!eh->gotoff_ref
851b6fa1 1973 && htab->target_os != is_vxworks)))
eeb2f20a 1974 {
826c3f1e 1975 /* If we don't find any dynamic relocs in read-only sections,
eeb2f20a
L		 1976 then we'll be keeping the dynamic relocs and avoiding the copy
1977 reloc. */
826c3f1e 1978 if (!readonly_dynrelocs (h))
eeb2f20a
L		 1979 {
1980 h->non_got_ref = 0;
1981 return TRUE;
1982 }
1983 }
1984
1985 /* We must allocate the symbol in our .dynbss section, which will
1986 become part of the .bss section of the executable. There will be
1987 an entry for this symbol in the .dynsym section. The dynamic
1988 object will contain position independent code, so all references
1989 from the dynamic object to this symbol will go through the global
1990 offset table. The dynamic linker will use the .dynsym entry to
1991 determine the address it must put in the global offset table, so
1992 both the dynamic object and the regular object will refer to the
1993 same memory location for the variable. */
1994
1995 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1996 dynamic linker to copy the initial value out of the dynamic object
1997 and into the runtime process image. */
1998 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1999 {
2000 s = htab->elf.sdynrelro;
2001 srel = htab->elf.sreldynrelro;
2002 }
2003 else
2004 {
2005 s = htab->elf.sdynbss;
2006 srel = htab->elf.srelbss;
2007 }
2008 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2009 {
503294e7 2010 srel->size += htab->sizeof_reloc;
eeb2f20a
L		 2011 h->needs_copy = 1;
2012 }
2013
2014 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2015}
2016
9f857535
L		 2017void
2018_bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
2019 struct elf_link_hash_entry *h,
2020 bfd_boolean force_local)
2021{
2022 if (h->root.type == bfd_link_hash_undefweak
2023 && info->nointerp
2024 && bfd_link_pie (info))
2025 {
2026 /* When there is no dynamic interpreter in PIE, make the undefined
2027 weak symbol dynamic so that PC relative branch to the undefined
2028 weak symbol will land to address 0. */
2029 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
79b0c981 2030 if (h->plt.refcount > 0
9f857535
L		 2031 || eh->plt_got.refcount > 0)
2032 return;
2033 }
2034
2035 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2036}
2037
6999821f
L		 2038/* Return TRUE if a symbol is referenced locally. It is similar to
2039 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
2040 works in check_relocs. */
2041
2042bfd_boolean
2043_bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
2044 struct elf_link_hash_entry *h)
2045{
0a27fed7
L		 2046 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2047 struct elf_x86_link_hash_table *htab
2048 = (struct elf_x86_link_hash_table *) info->hash;
6999821f
L		 2049
2050 if (eh->local_ref > 1)
2051 return TRUE;
2052
2053 if (eh->local_ref == 1)
2054 return FALSE;
2055
2056 /* Unversioned symbols defined in regular objects can be forced local
0a27fed7
L		 2057 by linker version script. A weak undefined symbol is forced local
2058 if
2059 1. It has non-default visibility. Or
8fbf0ba1 2060 2. When building executable, there is no dynamic linker. Or
0a27fed7
L		 2061 3. or "-z nodynamic-undefined-weak" is used.
2062 */
6999821f 2063 if (SYMBOL_REFERENCES_LOCAL (info, h)
0a27fed7
L		 2064 || (h->root.type == bfd_link_hash_undefweak
2065 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2066 || (bfd_link_executable (info)
8fbf0ba1 2067 && htab->interp == NULL)
0a27fed7 2068 || info->dynamic_undefined_weak == 0))
6999821f 2069 || ((h->def_regular || ELF_COMMON_DEF_P (h))
6999821f 2070 && info->version_info != NULL
099bb8fb 2071 && _bfd_elf_link_hide_sym_by_version (info, h)))
6999821f
L		 2072 {
2073 eh->local_ref = 2;
2074 return TRUE;
2075 }
2076
099bb8fb 2077 eh->local_ref = 1;
6999821f
L		 2078 return FALSE;
2079}
2080
4f501a24
L		 2081/* Return the section that should be marked against GC for a given
2082 relocation. */
2083
2084asection *
2085_bfd_x86_elf_gc_mark_hook (asection *sec,
2086 struct bfd_link_info *info,
2087 Elf_Internal_Rela *rel,
2088 struct elf_link_hash_entry *h,
2089 Elf_Internal_Sym *sym)
2090{
2091 /* Compiler should optimize this out. */
2092 if (((unsigned int) R_X86_64_GNU_VTINHERIT
2093 != (unsigned int) R_386_GNU_VTINHERIT)
2094 || ((unsigned int) R_X86_64_GNU_VTENTRY
2095 != (unsigned int) R_386_GNU_VTENTRY))
2096 abort ();
2097
2098 if (h != NULL)
2099 switch (ELF32_R_TYPE (rel->r_info))
2100 {
2101 case R_X86_64_GNU_VTINHERIT:
2102 case R_X86_64_GNU_VTENTRY:
2103 return NULL;
2104 }
2105
2106 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2107}
2108
f493882d
L		 2109static bfd_vma
2110elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2111 bfd_vma off,
2112 bfd_vma offset ATTRIBUTE_UNUSED,
2113 bfd_vma got_addr)
2114{
2115 return got_addr + off;
2116}
2117
2118static bfd_vma
2119elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2120 bfd_vma off,
2121 bfd_vma offset,
2122 bfd_vma got_addr ATTRIBUTE_UNUSED)
2123{
2124 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2125}
2126
2127static bfd_boolean
2128elf_i386_valid_plt_reloc_p (unsigned int type)
2129{
2130 return (type == R_386_JUMP_SLOT
2131 || type == R_386_GLOB_DAT
2132 || type == R_386_IRELATIVE);
2133}
2134
2135static bfd_boolean
2136elf_x86_64_valid_plt_reloc_p (unsigned int type)
2137{
2138 return (type == R_X86_64_JUMP_SLOT
2139 || type == R_X86_64_GLOB_DAT
2140 || type == R_X86_64_IRELATIVE);
2141}
2142
2143long
2144_bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2145 long count,
2146 long relsize,
2147 bfd_vma got_addr,
2148 struct elf_x86_plt plts[],
2149 asymbol **dynsyms,
2150 asymbol **ret)
2151{
2152 long size, i, n, len;
2153 int j;
2154 unsigned int plt_got_offset, plt_entry_size;
2155 asymbol *s;
2156 bfd_byte *plt_contents;
2157 long dynrelcount;
2158 arelent **dynrelbuf, *p;
2159 char *names;
2160 const struct elf_backend_data *bed;
2161 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2162 bfd_vma);
2163 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2164
2165 if (count == 0)
2166 return -1;
2167
2168 dynrelbuf = (arelent **) bfd_malloc (relsize);
2169 if (dynrelbuf == NULL)
2170 return -1;
2171
2172 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2173 dynsyms);
b69e9267 2174 if (dynrelcount <= 0)
94670f6c 2175 return -1;
f493882d
L		 2176
2177 /* Sort the relocs by address. */
2178 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2179 _bfd_x86_elf_compare_relocs);
2180
2181 size = count * sizeof (asymbol);
2182
2183 /* Allocate space for @plt suffixes. */
2184 n = 0;
2185 for (i = 0; i < dynrelcount; i++)
2186 {
2187 p = dynrelbuf[i];
2188 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2189 if (p->addend != 0)
2190 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2191 }
2192
2193 s = *ret = (asymbol *) bfd_zmalloc (size);
2194 if (s == NULL)
2195 goto bad_return;
2196
2197 bed = get_elf_backend_data (abfd);
2198
2199 if (bed->target_id == X86_64_ELF_DATA)
2200 {
2201 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2202 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2203 }
2204 else
2205 {
2206 get_plt_got_vma = elf_i386_get_plt_got_vma;
2207 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2208 if (got_addr)
2209 {
2210 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2211 address. */
2212 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2213 if (sec != NULL)
2214 got_addr = sec->vma;
2215 else
2216 {
2217 sec = bfd_get_section_by_name (abfd, ".got");
2218 if (sec != NULL)
2219 got_addr = sec->vma;
2220 }
2221
2222 if (got_addr == (bfd_vma) -1)
2223 goto bad_return;
2224 }
2225 }
2226
2227 /* Check for each PLT section. */
2228 names = (char *) (s + count);
2229 size = 0;
2230 n = 0;
2231 for (j = 0; plts[j].name != NULL; j++)
2232 if ((plt_contents = plts[j].contents) != NULL)
2233 {
2234 long k;
2235 bfd_vma offset;
2236 asection *plt;
2237 struct elf_x86_plt *plt_p = &plts[j];
2238
2239 plt_got_offset = plt_p->plt_got_offset;
2240 plt_entry_size = plt_p->plt_entry_size;
2241
2242 plt = plt_p->sec;
2243
2244 if ((plt_p->type & plt_lazy))
2245 {
2246 /* Skip PLT0 in lazy PLT. */
2247 k = 1;
2248 offset = plt_entry_size;
2249 }
2250 else
2251 {
2252 k = 0;
2253 offset = 0;
2254 }
2255
2256 /* Check each PLT entry against dynamic relocations. */
2257 for (; k < plt_p->count; k++)
2258 {
2259 int off;
2260 bfd_vma got_vma;
2261 long min, max, mid;
2262
2263 /* Get the GOT offset for i386 or the PC-relative offset
2264 for x86-64, a signed 32-bit integer. */
2265 off = H_GET_32 (abfd, (plt_contents + offset
2266 + plt_got_offset));
2267 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2268
2269 /* Binary search. */
2270 p = dynrelbuf[0];
2271 min = 0;
2272 max = dynrelcount;
2273 while ((min + 1) < max)
2274 {
2275 arelent *r;
2276
2277 mid = (min + max) / 2;
2278 r = dynrelbuf[mid];
2279 if (got_vma > r->address)
2280 min = mid;
2281 else if (got_vma < r->address)
2282 max = mid;
2283 else
2284 {
2285 p = r;
2286 break;
2287 }
2288 }
2289
2290 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2291 if (got_vma == p->address
2292 && p->howto != NULL
2293 && valid_plt_reloc_p (p->howto->type))
2294 {
2295 *s = **p->sym_ptr_ptr;
2296 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2297 set. Since we are defining a symbol, ensure one
2298 of them is set. */
2299 if ((s->flags & BSF_LOCAL) == 0)
2300 s->flags |= BSF_GLOBAL;
2301 s->flags |= BSF_SYNTHETIC;
2302 /* This is no longer a section symbol. */
2303 s->flags &= ~BSF_SECTION_SYM;
2304 s->section = plt;
2305 s->the_bfd = plt->owner;
2306 s->value = offset;
2307 s->udata.p = NULL;
2308 s->name = names;
2309 len = strlen ((*p->sym_ptr_ptr)->name);
2310 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2311 names += len;
2312 if (p->addend != 0)
2313 {
2314 char buf[30], *a;
2315
2316 memcpy (names, "+0x", sizeof ("+0x") - 1);
2317 names += sizeof ("+0x") - 1;
2318 bfd_sprintf_vma (abfd, buf, p->addend);
2319 for (a = buf; *a == '0'; ++a)
2320 ;
2321 size = strlen (a);
2322 memcpy (names, a, size);
2323 names += size;
2324 }
2325 memcpy (names, "@plt", sizeof ("@plt"));
2326 names += sizeof ("@plt");
2327 n++;
2328 s++;
61e3bf5f
L		 2329 /* There should be only one entry in PLT for a given
2330 symbol. Set howto to NULL after processing a PLT
2331 entry to guard against corrupted PLT. */
2332 p->howto = NULL;
f493882d
L		 2333 }
2334 offset += plt_entry_size;
2335 }
2336 }
2337
2338 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2339 if (n == 0)
2340 {
2341bad_return:
2342 count = -1;
2343 }
2344 else
2345 count = n;
2346
2347 for (j = 0; plts[j].name != NULL; j++)
2348 if (plts[j].contents != NULL)
2349 free (plts[j].contents);
2350
2351 free (dynrelbuf);
2352
2353 return count;
2354}
2355
0afcef53
L		 2356/* Parse x86 GNU properties. */
2357
2358enum elf_property_kind
2359_bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2360 bfd_byte *ptr, unsigned int datasz)
2361{
2362 elf_property *prop;
2363
2364 switch (type)
2365 {
2366 case GNU_PROPERTY_X86_ISA_1_USED:
2367 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2368 case GNU_PROPERTY_X86_FEATURE_1_AND:
2369 if (datasz != 4)
2370 {
2371 _bfd_error_handler
2372 ((type == GNU_PROPERTY_X86_ISA_1_USED
871b3ab2 2373 ? _("error: %pB: <corrupt x86 ISA used size: 0x%x>")
0afcef53 2374 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
871b3ab2
AM		 2375 ? _("error: %pB: <corrupt x86 ISA needed size: 0x%x>")
2376 : _("error: %pB: <corrupt x86 feature size: 0x%x>"))),
0afcef53
L		 2377 abfd, datasz);
2378 return property_corrupt;
2379 }
2380 prop = _bfd_elf_get_property (abfd, type, datasz);
2381 /* Combine properties of the same type. */
2382 prop->u.number |= bfd_h_get_32 (abfd, ptr);
2383 prop->pr_kind = property_number;
2384 break;
2385
2386 default:
2387 return property_ignored;
2388 }
2389
2390 return property_number;
2391}
2392
2393/* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2394 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2395 should be merged with ABFD. */
2396
2397bfd_boolean
2398_bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2399 bfd *abfd ATTRIBUTE_UNUSED,
2400 elf_property *aprop,
2401 elf_property *bprop)
2402{
2403 unsigned int number, features;
2404 bfd_boolean updated = FALSE;
2405 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2406
2407 switch (pr_type)
2408 {
2409 case GNU_PROPERTY_X86_ISA_1_USED:
2410 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2411 if (aprop != NULL && bprop != NULL)
2412 {
2413 number = aprop->u.number;
2414 aprop->u.number = number | bprop->u.number;
56ad703d
L		 2415 /* Remove the property if ISA bits are empty. */
2416 if (aprop->u.number == 0)
2417 {
2418 aprop->pr_kind = property_remove;
2419 updated = TRUE;
2420 }
2421 else
2422 updated = number != (unsigned int) aprop->u.number;
0afcef53
L		 2423 }
2424 else
2425 {
56ad703d
L		 2426 /* Only one of APROP and BPROP can be NULL. */
2427 if (aprop != NULL)
2428 {
2429 if (aprop->u.number == 0)
2430 {
2431 /* Remove APROP if ISA bits are empty. */
2432 aprop->pr_kind = property_remove;
2433 updated = TRUE;
2434 }
2435 }
2436 else
2437 {
2438 /* Return TRUE if APROP is NULL and ISA bits of BPROP
2439 aren't empty to indicate that BPROP should be added
2440 to ABFD. */
2441 updated = bprop->u.number != 0;
2442 }
0afcef53
L		 2443 }
2444 break;
2445
2446 case GNU_PROPERTY_X86_FEATURE_1_AND:
2447 /* Only one of APROP and BPROP can be NULL:
2448 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2449 2. If APROP is NULL, remove x86 feature.
2450 3. Otherwise, do nothing.
2451 */
2452 if (aprop != NULL && bprop != NULL)
2453 {
2454 features = 0;
2455 if (info->ibt)
2456 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2457 if (info->shstk)
2458 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2459 number = aprop->u.number;
2460 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2461 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2462 aprop->u.number = (number & bprop->u.number) | features;
2463 updated = number != (unsigned int) aprop->u.number;
2464 /* Remove the property if all feature bits are cleared. */
2465 if (aprop->u.number == 0)
2466 aprop->pr_kind = property_remove;
2467 }
2468 else
2469 {
2470 features = 0;
2471 if (info->ibt)
2472 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2473 if (info->shstk)
2474 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2475 if (features)
2476 {
2477 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2478 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2479 if (aprop != NULL)
2480 {
2481 number = aprop->u.number;
2482 aprop->u.number = number | features;
2483 updated = number != (unsigned int) aprop->u.number;
2484 }
2485 else
2486 {
2487 bprop->u.number |= features;
2488 updated = TRUE;
2489 }
2490 }
2491 else if (aprop != NULL)
2492 {
2493 aprop->pr_kind = property_remove;
2494 updated = TRUE;
2495 }
2496 }
2497 break;
2498
2499 default:
2500 /* Never should happen. */
2501 abort ();
2502 }
2503
2504 return updated;
2505}
a6798bab
L		 2506
2507/* Set up x86 GNU properties. Return the first relocatable ELF input
2508 with GNU properties if found. Otherwise, return NULL. */
2509
2510bfd *
2511_bfd_x86_elf_link_setup_gnu_properties
1de031c8 2512 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
a6798bab
L		 2513{
2514 bfd_boolean normal_target;
2515 bfd_boolean lazy_plt;
2516 asection *sec, *pltsec;
2517 bfd *dynobj;
2518 bfd_boolean use_ibt_plt;
2519 unsigned int plt_alignment, features;
2520 struct elf_x86_link_hash_table *htab;
2521 bfd *pbfd;
2522 bfd *ebfd = NULL;
2523 elf_property *prop;
2524 const struct elf_backend_data *bed;
2525 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2526 unsigned int got_align;
2527
2528 features = 0;
2529 if (info->ibt)
2530 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2531 if (info->shstk)
2532 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2533
2534 /* Find a normal input file with GNU property note. */
2535 for (pbfd = info->input_bfds;
2536 pbfd != NULL;
2537 pbfd = pbfd->link.next)
2538 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2539 && bfd_count_sections (pbfd) != 0)
2540 {
2541 ebfd = pbfd;
2542
2543 if (elf_properties (pbfd) != NULL)
2544 break;
2545 }
2546
2547 if (ebfd != NULL && features)
2548 {
2549 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2550 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2551 prop = _bfd_elf_get_property (ebfd,
2552 GNU_PROPERTY_X86_FEATURE_1_AND,
2553 4);
2554 prop->u.number |= features;
2555 prop->pr_kind = property_number;
2556
2557 /* Create the GNU property note section if needed. */
2558 if (pbfd == NULL)
2559 {
2560 sec = bfd_make_section_with_flags (ebfd,
2561 NOTE_GNU_PROPERTY_SECTION_NAME,
2562 (SEC_ALLOC
2563 | SEC_LOAD
2564 | SEC_IN_MEMORY
2565 | SEC_READONLY
2566 | SEC_HAS_CONTENTS
2567 | SEC_DATA));
2568 if (sec == NULL)
2c244f9b 2569 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
a6798bab
L		 2570
2571 if (!bfd_set_section_alignment (ebfd, sec, class_align))
2572 {
2573error_alignment:
871b3ab2 2574 info->callbacks->einfo (_("%F%pA: failed to align section\n"),
a6798bab
L		 2575 sec);
2576 }
2577
2578 elf_section_type (sec) = SHT_NOTE;
2579 }
2580 }
2581
2582 pbfd = _bfd_elf_link_setup_gnu_properties (info);
2583
a6798bab
L		 2584 bed = get_elf_backend_data (info->output_bfd);
2585
2586 htab = elf_x86_hash_table (info, bed->target_id);
2587 if (htab == NULL)
2588 return pbfd;
2589
1de031c8
L		 2590 htab->r_info = init_table->r_info;
2591 htab->r_sym = init_table->r_sym;
7a382c1c
L		 2592
2593 if (bfd_link_relocatable (info))
2594 return pbfd;
eeb2f20a 2595
851b6fa1
L		 2596 htab->plt0_pad_byte = init_table->plt0_pad_byte;
2597
a6798bab
L		 2598 use_ibt_plt = info->ibtplt || info->ibt;
2599 if (!use_ibt_plt && pbfd != NULL)
2600 {
2601 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2602 elf_property_list *p;
2603
2604 /* The property list is sorted in order of type. */
2605 for (p = elf_properties (pbfd); p; p = p->next)
2606 {
2607 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2608 {
2609 use_ibt_plt = !!(p->property.u.number
2610 & GNU_PROPERTY_X86_FEATURE_1_IBT);
2611 break;
2612 }
2613 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2614 break;
2615 }
2616 }
2617
2618 dynobj = htab->elf.dynobj;
2619
2620 /* Set htab->elf.dynobj here so that there is no need to check and
2621 set it in check_relocs. */
2622 if (dynobj == NULL)
2623 {
2624 if (pbfd != NULL)
2625 {
2626 htab->elf.dynobj = pbfd;
2627 dynobj = pbfd;
2628 }
2629 else
2630 {
2631 bfd *abfd;
2632
2633 /* Find a normal input file to hold linker created
2634 sections. */
2635 for (abfd = info->input_bfds;
2636 abfd != NULL;
2637 abfd = abfd->link.next)
2638 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2639 && (abfd->flags
e4e6a73d
L		 2640 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2641 && bed->relocs_compatible (abfd->xvec,
2642 info->output_bfd->xvec))
a6798bab
L		 2643 {
2644 htab->elf.dynobj = abfd;
2645 dynobj = abfd;
2646 break;
2647 }
2648 }
2649 }
2650
851b6fa1
L		 2651 /* Return if there are no normal input files. */
2652 if (dynobj == NULL)
2653 return pbfd;
2654
a6798bab
L		 2655 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2656 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2657 canonical function address. */
2658 htab->plt.has_plt0 = 1;
851b6fa1 2659 normal_target = htab->target_os == is_normal;
a6798bab
L		 2660
2661 if (normal_target)
2662 {
2663 if (use_ibt_plt)
2664 {
1de031c8
L		 2665 htab->lazy_plt = init_table->lazy_ibt_plt;
2666 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
a6798bab
L		 2667 }
2668 else
2669 {
1de031c8
L		 2670 htab->lazy_plt = init_table->lazy_plt;
2671 htab->non_lazy_plt = init_table->non_lazy_plt;
a6798bab
L		 2672 }
2673 }
2674 else
2675 {
1de031c8 2676 htab->lazy_plt = init_table->lazy_plt;
a6798bab
L		 2677 htab->non_lazy_plt = NULL;
2678 }
2679
2680 pltsec = htab->elf.splt;
2681
2682 /* If the non-lazy PLT is available, use it for all PLT entries if
2683 there are no PLT0 or no .plt section. */
2684 if (htab->non_lazy_plt != NULL
2685 && (!htab->plt.has_plt0 || pltsec == NULL))
2686 {
2687 lazy_plt = FALSE;
2688 if (bfd_link_pic (info))
2689 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2690 else
2691 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2692 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2693 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2694 htab->plt.plt_got_insn_size
2695 = htab->non_lazy_plt->plt_got_insn_size;
2696 htab->plt.eh_frame_plt_size
2697 = htab->non_lazy_plt->eh_frame_plt_size;
2698 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2699 }
2700 else
2701 {
2702 lazy_plt = TRUE;
2703 if (bfd_link_pic (info))
2704 {
2705 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2706 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2707 }
2708 else
2709 {
2710 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2711 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2712 }
2713 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2714 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2715 htab->plt.plt_got_insn_size
2716 = htab->lazy_plt->plt_got_insn_size;
2717 htab->plt.eh_frame_plt_size
2718 = htab->lazy_plt->eh_frame_plt_size;
2719 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2720 }
2721
851b6fa1 2722 if (htab->target_os == is_vxworks
a6798bab
L		 2723 && !elf_vxworks_create_dynamic_sections (dynobj, info,
2724 &htab->srelplt2))
2725 {
2c244f9b 2726 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
a6798bab
L		 2727 return pbfd;
2728 }
2729
2730 /* Since create_dynamic_sections isn't always called, but GOT
2731 relocations need GOT relocations, create them here so that we
2732 don't need to do it in check_relocs. */
2733 if (htab->elf.sgot == NULL
2734 && !_bfd_elf_create_got_section (dynobj, info))
2c244f9b 2735 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
a6798bab
L		 2736
2737 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2738
2739 /* Align .got and .got.plt sections to their entry size. Do it here
2740 instead of in create_dynamic_sections so that they are always
2741 properly aligned even if create_dynamic_sections isn't called. */
2742 sec = htab->elf.sgot;
2743 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2744 goto error_alignment;
2745
2746 sec = htab->elf.sgotplt;
2747 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2748 goto error_alignment;
2749
2750 /* Create the ifunc sections here so that check_relocs can be
2751 simplified. */
2752 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2c244f9b 2753 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
a6798bab
L		 2754
2755 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2756
2757 if (pltsec != NULL)
2758 {
2759 /* Whe creating executable, set the contents of the .interp
2760 section to the interpreter. */
2761 if (bfd_link_executable (info) && !info->nointerp)
2762 {
2763 asection *s = bfd_get_linker_section (dynobj, ".interp");
2764 if (s == NULL)
2765 abort ();
2766 s->size = htab->dynamic_interpreter_size;
2767 s->contents = (unsigned char *) htab->dynamic_interpreter;
2768 htab->interp = s;
2769 }
2770
2771 /* Don't change PLT section alignment for NaCl since it uses
2772 64-byte PLT entry and sets PLT section alignment to 32
2773 bytes. Don't create additional PLT sections for NaCl. */
2774 if (normal_target)
2775 {
2776 flagword pltflags = (bed->dynamic_sec_flags
2777 | SEC_ALLOC
2778 | SEC_CODE
2779 | SEC_LOAD
2780 | SEC_READONLY);
2781 unsigned int non_lazy_plt_alignment
2782 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2783
2784 sec = pltsec;
2785 if (!bfd_set_section_alignment (sec->owner, sec,
2786 plt_alignment))
2787 goto error_alignment;
2788
2789 /* Create the GOT procedure linkage table. */
2790 sec = bfd_make_section_anyway_with_flags (dynobj,
2791 ".plt.got",
2792 pltflags);
2793 if (sec == NULL)
2c244f9b 2794 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
a6798bab
L		 2795
2796 if (!bfd_set_section_alignment (dynobj, sec,
2797 non_lazy_plt_alignment))
2798 goto error_alignment;
2799
2800 htab->plt_got = sec;
2801
2802 if (lazy_plt)
2803 {
2804 sec = NULL;
2805
2806 if (use_ibt_plt)
2807 {
2808 /* Create the second PLT for Intel IBT support. IBT
2809 PLT is supported only for non-NaCl target and is
2810 is needed only for lazy binding. */
2811 sec = bfd_make_section_anyway_with_flags (dynobj,
2812 ".plt.sec",
2813 pltflags);
2814 if (sec == NULL)
2c244f9b 2815 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
a6798bab
L		 2816
2817 if (!bfd_set_section_alignment (dynobj, sec,
2818 plt_alignment))
2819 goto error_alignment;
2820 }
2821 else if (info->bndplt && ABI_64_P (dynobj))
2822 {
2823 /* Create the second PLT for Intel MPX support. MPX
2824 PLT is supported only for non-NaCl target in 64-bit
2825 mode and is needed only for lazy binding. */
2826 sec = bfd_make_section_anyway_with_flags (dynobj,
2827 ".plt.sec",
2828 pltflags);
2829 if (sec == NULL)
2c244f9b 2830 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
a6798bab
L		 2831
2832 if (!bfd_set_section_alignment (dynobj, sec,
2833 non_lazy_plt_alignment))
2834 goto error_alignment;
2835 }
2836
2837 htab->plt_second = sec;
2838 }
2839 }
2840
2841 if (!info->no_ld_generated_unwind_info)
2842 {
2843 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2844 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2845 | SEC_LINKER_CREATED);
2846
2847 sec = bfd_make_section_anyway_with_flags (dynobj,
2848 ".eh_frame",
2849 flags);
2850 if (sec == NULL)
2c244f9b 2851 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
a6798bab
L		 2852
2853 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2854 goto error_alignment;
2855
2856 htab->plt_eh_frame = sec;
2857
2858 if (htab->plt_got != NULL)
2859 {
2860 sec = bfd_make_section_anyway_with_flags (dynobj,
2861 ".eh_frame",
2862 flags);
2863 if (sec == NULL)
2c244f9b 2864 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
a6798bab
L		 2865
2866 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2867 goto error_alignment;
2868
2869 htab->plt_got_eh_frame = sec;
2870 }
2871
2872 if (htab->plt_second != NULL)
2873 {
2874 sec = bfd_make_section_anyway_with_flags (dynobj,
2875 ".eh_frame",
2876 flags);
2877 if (sec == NULL)
2c244f9b 2878 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
a6798bab
L		 2879
2880 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2881 goto error_alignment;
2882
2883 htab->plt_second_eh_frame = sec;
2884 }
2885 }
2886 }
2887
2888 if (normal_target)
2889 {
2890 /* The .iplt section is used for IFUNC symbols in static
2891 executables. */
2892 sec = htab->elf.iplt;
2893 if (sec != NULL
2894 && !bfd_set_section_alignment (sec->owner, sec,
2895 plt_alignment))
2896 goto error_alignment;
2897 }
2898
2899 return pbfd;
2900}
GDB Binutils - Deliverables
This page took 0.199274 seconds and 4 git commands to generate.