projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
x86: Add _bfd_x86_elf_adjust_dynamic_symbol
[deliverable/binutils-gdb.git] / bfd / elfxx-x86.c
CommitLineData
0afcef53
L		 1/* x86 specific support for ELF
2 Copyright (C) 2017 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21#include "elfxx-x86.h"
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
82/* Find any dynamic relocs that apply to read-only sections. */
83
84bfd_boolean
85_bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h,
86 void *inf)
87{
88 struct elf_x86_link_hash_entry *eh;
89 struct elf_dyn_relocs *p;
90
91 /* Skip local IFUNC symbols. */
92 if (h->forced_local && h->type == STT_GNU_IFUNC)
93 return TRUE;
94
95 eh = (struct elf_x86_link_hash_entry *) h;
96 for (p = eh->dyn_relocs; p != NULL; p = p->next)
97 {
98 asection *s = p->sec->output_section;
99
100 if (s != NULL && (s->flags & SEC_READONLY) != 0)
101 {
102 struct bfd_link_info *info = (struct bfd_link_info *) inf;
103
104 info->flags |= DF_TEXTREL;
105
106 if ((info->warn_shared_textrel && bfd_link_pic (info))
107 || info->error_textrel)
108 /* xgettext:c-format */
109 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
110 p->sec->owner, h->root.root.string,
111 p->sec);
112
113 /* Not an error, just cut short the traversal. */
114 return FALSE;
115 }
116 }
117 return TRUE;
118}
119
120/* Find and/or create a hash entry for local symbol. */
121
122struct elf_link_hash_entry *
123_bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
124 bfd *abfd, const Elf_Internal_Rela *rel,
125 bfd_boolean create)
126{
127 struct elf_x86_link_hash_entry e, *ret;
128 asection *sec = abfd->sections;
129 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
130 htab->r_sym (rel->r_info));
131 void **slot;
132
133 e.elf.indx = sec->id;
134 e.elf.dynstr_index = htab->r_sym (rel->r_info);
135 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
136 create ? INSERT : NO_INSERT);
137
138 if (!slot)
139 return NULL;
140
141 if (*slot)
142 {
143 ret = (struct elf_x86_link_hash_entry *) *slot;
144 return &ret->elf;
145 }
146
147 ret = (struct elf_x86_link_hash_entry *)
148 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
149 sizeof (struct elf_x86_link_hash_entry));
150 if (ret)
151 {
152 memset (ret, 0, sizeof (*ret));
153 ret->elf.indx = sec->id;
154 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
155 ret->elf.dynindx = -1;
156 ret->plt_got.offset = (bfd_vma) -1;
157 *slot = ret;
158 }
159 return &ret->elf;
160}
161
162/* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
163 SYNC WITH _bfd_elf_link_hash_newfunc. */
164
165struct bfd_hash_entry *
166_bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
167 struct bfd_hash_table *table,
168 const char *string)
169{
170 /* Allocate the structure if it has not already been allocated by a
171 subclass. */
172 if (entry == NULL)
173 {
174 entry = (struct bfd_hash_entry *)
175 bfd_hash_allocate (table,
176 sizeof (struct elf_x86_link_hash_entry));
177 if (entry == NULL)
178 return entry;
179 }
180
181 /* Call the allocation method of the superclass. */
182 entry = _bfd_link_hash_newfunc (entry, table, string);
183 if (entry != NULL)
184 {
185 struct elf_x86_link_hash_entry *eh
186 = (struct elf_x86_link_hash_entry *) entry;
187 struct elf_link_hash_table *htab
188 = (struct elf_link_hash_table *) table;
189
190 memset (&eh->elf.size, 0,
191 (sizeof (struct elf_x86_link_hash_entry)
192 - offsetof (struct elf_link_hash_entry, size)));
193 /* Set local fields. */
194 eh->elf.indx = -1;
195 eh->elf.dynindx = -1;
196 eh->elf.got = htab->init_got_refcount;
197 eh->elf.plt = htab->init_plt_refcount;
198 /* Assume that we have been called by a non-ELF symbol reader.
199 This flag is then reset by the code which reads an ELF input
200 file. This ensures that a symbol created by a non-ELF symbol
201 reader will have the flag set correctly. */
202 eh->elf.non_elf = 1;
203 eh->plt_second.offset = (bfd_vma) -1;
204 eh->plt_got.offset = (bfd_vma) -1;
205 eh->tlsdesc_got = (bfd_vma) -1;
206 }
207
208 return entry;
209}
210
211/* Compute a hash of a local hash entry. We use elf_link_hash_entry
212 for local symbol so that we can handle local STT_GNU_IFUNC symbols
213 as global symbol. We reuse indx and dynstr_index for local symbol
214 hash since they aren't used by global symbols in this backend. */
215
216hashval_t
217_bfd_x86_elf_local_htab_hash (const void *ptr)
218{
219 struct elf_link_hash_entry *h
220 = (struct elf_link_hash_entry *) ptr;
221 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
222}
223
224/* Compare local hash entries. */
225
226int
227_bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
228{
229 struct elf_link_hash_entry *h1
230 = (struct elf_link_hash_entry *) ptr1;
231 struct elf_link_hash_entry *h2
232 = (struct elf_link_hash_entry *) ptr2;
233
234 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
235}
236
237/* Destroy an x86 ELF linker hash table. */
238
765e526c
L		 239static void
240elf_x86_link_hash_table_free (bfd *obfd)
0afcef53
L		 241{
242 struct elf_x86_link_hash_table *htab
243 = (struct elf_x86_link_hash_table *) obfd->link.hash;
244
245 if (htab->loc_hash_table)
246 htab_delete (htab->loc_hash_table);
247 if (htab->loc_hash_memory)
248 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
249 _bfd_elf_link_hash_table_free (obfd);
250}
251
765e526c
L		 252/* Create an x86 ELF linker hash table. */
253
254struct bfd_link_hash_table *
255_bfd_x86_elf_link_hash_table_create (bfd *abfd)
256{
257 struct elf_x86_link_hash_table *ret;
258 const struct elf_backend_data *bed;
259 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
260
261 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
262 if (ret == NULL)
263 return NULL;
264
265 bed = get_elf_backend_data (abfd);
266 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
267 _bfd_x86_elf_link_hash_newfunc,
268 sizeof (struct elf_x86_link_hash_entry),
269 bed->target_id))
270 {
271 free (ret);
272 return NULL;
273 }
274
275#ifdef BFD64
276 if (ABI_64_P (abfd))
277 {
278 ret->r_info = elf64_r_info;
279 ret->r_sym = elf64_r_sym;
280 ret->pointer_r_type = R_X86_64_64;
281 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
282 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
283 ret->tls_get_addr = "__tls_get_addr";
284 }
285 else
286#endif
287 {
288 ret->r_info = elf32_r_info;
289 ret->r_sym = elf32_r_sym;
5b86dbf4 290 if (bed->target_id == X86_64_ELF_DATA)
765e526c
L		 291 {
292 ret->pointer_r_type = R_X86_64_32;
293 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
294 ret->dynamic_interpreter_size
295 = sizeof ELFX32_DYNAMIC_INTERPRETER;
296 ret->tls_get_addr = "__tls_get_addr";
297 }
298 else
299 {
300 ret->pointer_r_type = R_386_32;
301 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
302 ret->dynamic_interpreter_size
303 = sizeof ELF32_DYNAMIC_INTERPRETER;
304 ret->tls_get_addr = "___tls_get_addr";
305 }
306 }
307
308 ret->loc_hash_table = htab_try_create (1024,
309 _bfd_x86_elf_local_htab_hash,
310 _bfd_x86_elf_local_htab_eq,
311 NULL);
312 ret->loc_hash_memory = objalloc_create ();
313 if (!ret->loc_hash_table || !ret->loc_hash_memory)
314 {
315 elf_x86_link_hash_table_free (abfd);
316 return NULL;
317 }
318 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
319
320 return &ret->elf.root;
321}
322
0afcef53
L		 323/* Sort relocs into address order. */
324
325int
326_bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
327{
328 const arelent *a = * (const arelent **) ap;
329 const arelent *b = * (const arelent **) bp;
330
331 if (a->address > b->address)
332 return 1;
333 else if (a->address < b->address)
334 return -1;
335 else
336 return 0;
337}
338
339bfd_boolean
340_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
341{
342 if (!bfd_link_relocatable (info))
343 {
344 /* Check for __tls_get_addr reference. */
345 struct elf_x86_link_hash_table *htab;
346 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
347 htab = elf_x86_hash_table (info, bed->target_id);
348 if (htab)
349 {
350 struct elf_link_hash_entry *h
351 = elf_link_hash_lookup (elf_hash_table (info),
352 htab->tls_get_addr,
353 FALSE, FALSE, FALSE);
354 if (h != NULL)
355 ((struct elf_x86_link_hash_entry *) h)->tls_get_addr = 1;
356 }
357 }
358
359 /* Invoke the regular ELF backend linker to do all the work. */
360 return _bfd_elf_link_check_relocs (abfd, info);
361}
362
363bfd_boolean
364_bfd_x86_elf_always_size_sections (bfd *output_bfd,
365 struct bfd_link_info *info)
366{
367 asection *tls_sec = elf_hash_table (info)->tls_sec;
368
369 if (tls_sec)
370 {
371 struct elf_link_hash_entry *tlsbase;
372
373 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
374 "_TLS_MODULE_BASE_",
375 FALSE, FALSE, FALSE);
376
377 if (tlsbase && tlsbase->type == STT_TLS)
378 {
379 struct elf_x86_link_hash_table *htab;
380 struct bfd_link_hash_entry *bh = NULL;
381 const struct elf_backend_data *bed
382 = get_elf_backend_data (output_bfd);
383
384 htab = elf_x86_hash_table (info, bed->target_id);
385 if (htab == NULL)
386 return FALSE;
387
388 if (!(_bfd_generic_link_add_one_symbol
389 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
390 tls_sec, 0, NULL, FALSE,
391 bed->collect, &bh)))
392 return FALSE;
393
394 htab->tls_module_base = bh;
395
396 tlsbase = (struct elf_link_hash_entry *)bh;
397 tlsbase->def_regular = 1;
398 tlsbase->other = STV_HIDDEN;
399 tlsbase->root.linker_def = 1;
400 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
401 }
402 }
403
404 return TRUE;
405}
406
407void
408_bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
409 const Elf_Internal_Sym *isym,
410 bfd_boolean definition,
411 bfd_boolean dynamic ATTRIBUTE_UNUSED)
412{
413 if (definition)
414 {
415 struct elf_x86_link_hash_entry *eh
416 = (struct elf_x86_link_hash_entry *) h;
417 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
418 == STV_PROTECTED);
419 }
420}
421
422/* Copy the extra info we tack onto an elf_link_hash_entry. */
423
424void
425_bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
426 struct elf_link_hash_entry *dir,
427 struct elf_link_hash_entry *ind)
428{
429 struct elf_x86_link_hash_entry *edir, *eind;
430
431 edir = (struct elf_x86_link_hash_entry *) dir;
432 eind = (struct elf_x86_link_hash_entry *) ind;
433
434 if (eind->dyn_relocs != NULL)
435 {
436 if (edir->dyn_relocs != NULL)
437 {
438 struct elf_dyn_relocs **pp;
439 struct elf_dyn_relocs *p;
440
441 /* Add reloc counts against the indirect sym to the direct sym
442 list. Merge any entries against the same section. */
443 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
444 {
445 struct elf_dyn_relocs *q;
446
447 for (q = edir->dyn_relocs; q != NULL; q = q->next)
448 if (q->sec == p->sec)
449 {
450 q->pc_count += p->pc_count;
451 q->count += p->count;
452 *pp = p->next;
453 break;
454 }
455 if (q == NULL)
456 pp = &p->next;
457 }
458 *pp = edir->dyn_relocs;
459 }
460
461 edir->dyn_relocs = eind->dyn_relocs;
462 eind->dyn_relocs = NULL;
463 }
464
465 if (ind->root.type == bfd_link_hash_indirect
466 && dir->got.refcount <= 0)
467 {
468 edir->tls_type = eind->tls_type;
469 eind->tls_type = GOT_UNKNOWN;
470 }
471
472 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
473 generate a R_386_COPY reloc. */
474 edir->gotoff_ref |= eind->gotoff_ref;
475
476 edir->has_got_reloc |= eind->has_got_reloc;
477 edir->has_non_got_reloc |= eind->has_non_got_reloc;
478
479 if (ELIMINATE_COPY_RELOCS
480 && ind->root.type != bfd_link_hash_indirect
481 && dir->dynamic_adjusted)
482 {
483 /* If called to transfer flags for a weakdef during processing
484 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
485 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
486 if (dir->versioned != versioned_hidden)
487 dir->ref_dynamic |= ind->ref_dynamic;
488 dir->ref_regular |= ind->ref_regular;
489 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
490 dir->needs_plt |= ind->needs_plt;
491 dir->pointer_equality_needed |= ind->pointer_equality_needed;
492 }
493 else
494 {
495 if (eind->func_pointer_refcount > 0)
496 {
497 edir->func_pointer_refcount += eind->func_pointer_refcount;
498 eind->func_pointer_refcount = 0;
499 }
500
501 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
502 }
503}
504
505/* Remove undefined weak symbol from the dynamic symbol table if it
506 is resolved to 0. */
507
508bfd_boolean
509_bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
510 struct elf_link_hash_entry *h)
511{
512 if (h->dynindx != -1)
513 {
514 const struct elf_backend_data *bed
515 = get_elf_backend_data (info->output_bfd);
516 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
517 bed->target_id,
518 elf_x86_hash_entry (h)->has_got_reloc,
519 elf_x86_hash_entry (h)))
520 {
521 h->dynindx = -1;
522 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
523 h->dynstr_index);
524 }
525 }
526 return TRUE;
527}
528
529/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
530
531bfd_boolean
532_bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
533{
534 if (h->plt.offset != (bfd_vma) -1
535 && !h->def_regular
536 && !h->pointer_equality_needed)
537 return FALSE;
538
539 return _bfd_elf_hash_symbol (h);
540}
541
eeb2f20a
L		 542/* Adjust a symbol defined by a dynamic object and referenced by a
543 regular object. The current definition is in some section of the
544 dynamic object, but we're not including those sections. We have to
545 change the definition to something the rest of the link can
546 understand. */
547
548bfd_boolean
549_bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
550 struct elf_link_hash_entry *h)
551{
552 struct elf_x86_link_hash_table *htab;
553 asection *s, *srel;
554 struct elf_x86_link_hash_entry *eh;
555 struct elf_dyn_relocs *p;
556 const struct elf_backend_data *bed
557 = get_elf_backend_data (info->output_bfd);
558
559 /* STT_GNU_IFUNC symbol must go through PLT. */
560 if (h->type == STT_GNU_IFUNC)
561 {
562 /* All local STT_GNU_IFUNC references must be treate as local
563 calls via local PLT. */
564 if (h->ref_regular
565 && SYMBOL_CALLS_LOCAL (info, h))
566 {
567 bfd_size_type pc_count = 0, count = 0;
568 struct elf_dyn_relocs **pp;
569
570 eh = (struct elf_x86_link_hash_entry *) h;
571 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
572 {
573 pc_count += p->pc_count;
574 p->count -= p->pc_count;
575 p->pc_count = 0;
576 count += p->count;
577 if (p->count == 0)
578 *pp = p->next;
579 else
580 pp = &p->next;
581 }
582
583 if (pc_count || count)
584 {
585 h->non_got_ref = 1;
586 if (pc_count)
587 {
588 /* Increment PLT reference count only for PC-relative
589 references. */
590 h->needs_plt = 1;
591 if (h->plt.refcount <= 0)
592 h->plt.refcount = 1;
593 else
594 h->plt.refcount += 1;
595 }
596 }
597 }
598
599 if (h->plt.refcount <= 0)
600 {
601 h->plt.offset = (bfd_vma) -1;
602 h->needs_plt = 0;
603 }
604 return TRUE;
605 }
606
607 /* If this is a function, put it in the procedure linkage table. We
608 will fill in the contents of the procedure linkage table later,
609 when we know the address of the .got section. */
610 if (h->type == STT_FUNC
611 || h->needs_plt)
612 {
613 if (h->plt.refcount <= 0
614 || SYMBOL_CALLS_LOCAL (info, h)
615 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
616 && h->root.type == bfd_link_hash_undefweak))
617 {
618 /* This case can occur if we saw a PLT32 reloc in an input
619 file, but the symbol was never referred to by a dynamic
620 object, or if all references were garbage collected. In
621 such a case, we don't actually need to build a procedure
622 linkage table, and we can just do a PC32 reloc instead. */
623 h->plt.offset = (bfd_vma) -1;
624 h->needs_plt = 0;
625 }
626
627 return TRUE;
628 }
629 else
630 /* It's possible that we incorrectly decided a .plt reloc was needed
631 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
632 check_relocs. We can't decide accurately between function and
633 non-function syms in check-relocs; Objects loaded later in
634 the link may change h->type. So fix it now. */
635 h->plt.offset = (bfd_vma) -1;
636
637 eh = (struct elf_x86_link_hash_entry *) h;
638
639 /* If this is a weak symbol, and there is a real definition, the
640 processor independent code will have arranged for us to see the
641 real definition first, and we can just use the same value. */
642 if (h->u.weakdef != NULL)
643 {
644 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
645 || h->u.weakdef->root.type == bfd_link_hash_defweak);
646 h->root.u.def.section = h->u.weakdef->root.u.def.section;
647 h->root.u.def.value = h->u.weakdef->root.u.def.value;
648 if (ELIMINATE_COPY_RELOCS
649 || info->nocopyreloc
650 || SYMBOL_NO_COPYRELOC (info, eh))
651 {
652 /* NB: needs_copy is always 0 for i386. */
653 h->non_got_ref = h->u.weakdef->non_got_ref;
654 eh->needs_copy = h->u.weakdef->needs_copy;
655 }
656 return TRUE;
657 }
658
659 /* This is a reference to a symbol defined by a dynamic object which
660 is not a function. */
661
662 /* If we are creating a shared library, we must presume that the
663 only references to the symbol are via the global offset table.
664 For such cases we need not do anything here; the relocations will
665 be handled correctly by relocate_section. */
666 if (!bfd_link_executable (info))
667 return TRUE;
668
669 /* If there are no references to this symbol that do not use the
670 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
671 reloc. NB: gotoff_ref is always 0 for x86-64. */
672 if (!h->non_got_ref && !eh->gotoff_ref)
673 return TRUE;
674
675 /* If -z nocopyreloc was given, we won't generate them either. */
676 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
677 {
678 h->non_got_ref = 0;
679 return TRUE;
680 }
681
682 htab = elf_x86_hash_table (info, bed->target_id);
683 if (htab == NULL)
684 return FALSE;
685
686 /* If there aren't any dynamic relocs in read-only sections nor
687 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
688 avoid the copy reloc. This doesn't work on VxWorks, where we can
689 not have dynamic relocations (other than copy and jump slot
690 relocations) in an executable. */
691 if (ELIMINATE_COPY_RELOCS
692 && (bed->target_id == X86_64_ELF_DATA
693 || (!eh->gotoff_ref
694 && !htab->is_vxworks)))
695 {
696 for (p = eh->dyn_relocs; p != NULL; p = p->next)
697 {
698 s = p->sec->output_section;
699 if (s != NULL && (s->flags & SEC_READONLY) != 0)
700 break;
701 }
702
703 /* If we didn't find any dynamic relocs in read-only sections,
704 then we'll be keeping the dynamic relocs and avoiding the copy
705 reloc. */
706 if (p == NULL)
707 {
708 h->non_got_ref = 0;
709 return TRUE;
710 }
711 }
712
713 /* We must allocate the symbol in our .dynbss section, which will
714 become part of the .bss section of the executable. There will be
715 an entry for this symbol in the .dynsym section. The dynamic
716 object will contain position independent code, so all references
717 from the dynamic object to this symbol will go through the global
718 offset table. The dynamic linker will use the .dynsym entry to
719 determine the address it must put in the global offset table, so
720 both the dynamic object and the regular object will refer to the
721 same memory location for the variable. */
722
723 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
724 dynamic linker to copy the initial value out of the dynamic object
725 and into the runtime process image. */
726 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
727 {
728 s = htab->elf.sdynrelro;
729 srel = htab->elf.sreldynrelro;
730 }
731 else
732 {
733 s = htab->elf.sdynbss;
734 srel = htab->elf.srelbss;
735 }
736 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
737 {
738 srel->size += ((bed->target_id == I386_ELF_DATA)
739 ? sizeof (Elf32_External_Rel)
740 : bed->s->sizeof_rela);
741 h->needs_copy = 1;
742 }
743
744 return _bfd_elf_adjust_dynamic_copy (info, h, s);
745}
746
f493882d
L		 747static bfd_vma
748elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
749 bfd_vma off,
750 bfd_vma offset ATTRIBUTE_UNUSED,
751 bfd_vma got_addr)
752{
753 return got_addr + off;
754}
755
756static bfd_vma
757elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
758 bfd_vma off,
759 bfd_vma offset,
760 bfd_vma got_addr ATTRIBUTE_UNUSED)
761{
762 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
763}
764
765static bfd_boolean
766elf_i386_valid_plt_reloc_p (unsigned int type)
767{
768 return (type == R_386_JUMP_SLOT
769 || type == R_386_GLOB_DAT
770 || type == R_386_IRELATIVE);
771}
772
773static bfd_boolean
774elf_x86_64_valid_plt_reloc_p (unsigned int type)
775{
776 return (type == R_X86_64_JUMP_SLOT
777 || type == R_X86_64_GLOB_DAT
778 || type == R_X86_64_IRELATIVE);
779}
780
781long
782_bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
783 long count,
784 long relsize,
785 bfd_vma got_addr,
786 struct elf_x86_plt plts[],
787 asymbol **dynsyms,
788 asymbol **ret)
789{
790 long size, i, n, len;
791 int j;
792 unsigned int plt_got_offset, plt_entry_size;
793 asymbol *s;
794 bfd_byte *plt_contents;
795 long dynrelcount;
796 arelent **dynrelbuf, *p;
797 char *names;
798 const struct elf_backend_data *bed;
799 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
800 bfd_vma);
801 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
802
803 if (count == 0)
804 return -1;
805
806 dynrelbuf = (arelent **) bfd_malloc (relsize);
807 if (dynrelbuf == NULL)
808 return -1;
809
810 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
811 dynsyms);
812
813 /* Sort the relocs by address. */
814 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
815 _bfd_x86_elf_compare_relocs);
816
817 size = count * sizeof (asymbol);
818
819 /* Allocate space for @plt suffixes. */
820 n = 0;
821 for (i = 0; i < dynrelcount; i++)
822 {
823 p = dynrelbuf[i];
824 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
825 if (p->addend != 0)
826 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
827 }
828
829 s = *ret = (asymbol *) bfd_zmalloc (size);
830 if (s == NULL)
831 goto bad_return;
832
833 bed = get_elf_backend_data (abfd);
834
835 if (bed->target_id == X86_64_ELF_DATA)
836 {
837 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
838 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
839 }
840 else
841 {
842 get_plt_got_vma = elf_i386_get_plt_got_vma;
843 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
844 if (got_addr)
845 {
846 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
847 address. */
848 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
849 if (sec != NULL)
850 got_addr = sec->vma;
851 else
852 {
853 sec = bfd_get_section_by_name (abfd, ".got");
854 if (sec != NULL)
855 got_addr = sec->vma;
856 }
857
858 if (got_addr == (bfd_vma) -1)
859 goto bad_return;
860 }
861 }
862
863 /* Check for each PLT section. */
864 names = (char *) (s + count);
865 size = 0;
866 n = 0;
867 for (j = 0; plts[j].name != NULL; j++)
868 if ((plt_contents = plts[j].contents) != NULL)
869 {
870 long k;
871 bfd_vma offset;
872 asection *plt;
873 struct elf_x86_plt *plt_p = &plts[j];
874
875 plt_got_offset = plt_p->plt_got_offset;
876 plt_entry_size = plt_p->plt_entry_size;
877
878 plt = plt_p->sec;
879
880 if ((plt_p->type & plt_lazy))
881 {
882 /* Skip PLT0 in lazy PLT. */
883 k = 1;
884 offset = plt_entry_size;
885 }
886 else
887 {
888 k = 0;
889 offset = 0;
890 }
891
892 /* Check each PLT entry against dynamic relocations. */
893 for (; k < plt_p->count; k++)
894 {
895 int off;
896 bfd_vma got_vma;
897 long min, max, mid;
898
899 /* Get the GOT offset for i386 or the PC-relative offset
900 for x86-64, a signed 32-bit integer. */
901 off = H_GET_32 (abfd, (plt_contents + offset
902 + plt_got_offset));
903 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
904
905 /* Binary search. */
906 p = dynrelbuf[0];
907 min = 0;
908 max = dynrelcount;
909 while ((min + 1) < max)
910 {
911 arelent *r;
912
913 mid = (min + max) / 2;
914 r = dynrelbuf[mid];
915 if (got_vma > r->address)
916 min = mid;
917 else if (got_vma < r->address)
918 max = mid;
919 else
920 {
921 p = r;
922 break;
923 }
924 }
925
926 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
927 if (got_vma == p->address
928 && p->howto != NULL
929 && valid_plt_reloc_p (p->howto->type))
930 {
931 *s = **p->sym_ptr_ptr;
932 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
933 set. Since we are defining a symbol, ensure one
934 of them is set. */
935 if ((s->flags & BSF_LOCAL) == 0)
936 s->flags |= BSF_GLOBAL;
937 s->flags |= BSF_SYNTHETIC;
938 /* This is no longer a section symbol. */
939 s->flags &= ~BSF_SECTION_SYM;
940 s->section = plt;
941 s->the_bfd = plt->owner;
942 s->value = offset;
943 s->udata.p = NULL;
944 s->name = names;
945 len = strlen ((*p->sym_ptr_ptr)->name);
946 memcpy (names, (*p->sym_ptr_ptr)->name, len);
947 names += len;
948 if (p->addend != 0)
949 {
950 char buf[30], *a;
951
952 memcpy (names, "+0x", sizeof ("+0x") - 1);
953 names += sizeof ("+0x") - 1;
954 bfd_sprintf_vma (abfd, buf, p->addend);
955 for (a = buf; *a == '0'; ++a)
956 ;
957 size = strlen (a);
958 memcpy (names, a, size);
959 names += size;
960 }
961 memcpy (names, "@plt", sizeof ("@plt"));
962 names += sizeof ("@plt");
963 n++;
964 s++;
965 }
966 offset += plt_entry_size;
967 }
968 }
969
970 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
971 if (n == 0)
972 {
973bad_return:
974 count = -1;
975 }
976 else
977 count = n;
978
979 for (j = 0; plts[j].name != NULL; j++)
980 if (plts[j].contents != NULL)
981 free (plts[j].contents);
982
983 free (dynrelbuf);
984
985 return count;
986}
987
0afcef53
L		 988/* Parse x86 GNU properties. */
989
990enum elf_property_kind
991_bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
992 bfd_byte *ptr, unsigned int datasz)
993{
994 elf_property *prop;
995
996 switch (type)
997 {
998 case GNU_PROPERTY_X86_ISA_1_USED:
999 case GNU_PROPERTY_X86_ISA_1_NEEDED:
1000 case GNU_PROPERTY_X86_FEATURE_1_AND:
1001 if (datasz != 4)
1002 {
1003 _bfd_error_handler
1004 ((type == GNU_PROPERTY_X86_ISA_1_USED
1005 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1006 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
1007 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1008 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1009 abfd, datasz);
1010 return property_corrupt;
1011 }
1012 prop = _bfd_elf_get_property (abfd, type, datasz);
1013 /* Combine properties of the same type. */
1014 prop->u.number |= bfd_h_get_32 (abfd, ptr);
1015 prop->pr_kind = property_number;
1016 break;
1017
1018 default:
1019 return property_ignored;
1020 }
1021
1022 return property_number;
1023}
1024
1025/* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1026 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1027 should be merged with ABFD. */
1028
1029bfd_boolean
1030_bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
1031 bfd *abfd ATTRIBUTE_UNUSED,
1032 elf_property *aprop,
1033 elf_property *bprop)
1034{
1035 unsigned int number, features;
1036 bfd_boolean updated = FALSE;
1037 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
1038
1039 switch (pr_type)
1040 {
1041 case GNU_PROPERTY_X86_ISA_1_USED:
1042 case GNU_PROPERTY_X86_ISA_1_NEEDED:
1043 if (aprop != NULL && bprop != NULL)
1044 {
1045 number = aprop->u.number;
1046 aprop->u.number = number | bprop->u.number;
1047 updated = number != (unsigned int) aprop->u.number;
1048 }
1049 else
1050 {
1051 /* Return TRUE if APROP is NULL to indicate that BPROP should
1052 be added to ABFD. */
1053 updated = aprop == NULL;
1054 }
1055 break;
1056
1057 case GNU_PROPERTY_X86_FEATURE_1_AND:
1058 /* Only one of APROP and BPROP can be NULL:
1059 1. APROP & BPROP when both APROP and BPROP aren't NULL.
1060 2. If APROP is NULL, remove x86 feature.
1061 3. Otherwise, do nothing.
1062 */
1063 if (aprop != NULL && bprop != NULL)
1064 {
1065 features = 0;
1066 if (info->ibt)
1067 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1068 if (info->shstk)
1069 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1070 number = aprop->u.number;
1071 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1072 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1073 aprop->u.number = (number & bprop->u.number) | features;
1074 updated = number != (unsigned int) aprop->u.number;
1075 /* Remove the property if all feature bits are cleared. */
1076 if (aprop->u.number == 0)
1077 aprop->pr_kind = property_remove;
1078 }
1079 else
1080 {
1081 features = 0;
1082 if (info->ibt)
1083 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1084 if (info->shstk)
1085 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1086 if (features)
1087 {
1088 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1089 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1090 if (aprop != NULL)
1091 {
1092 number = aprop->u.number;
1093 aprop->u.number = number | features;
1094 updated = number != (unsigned int) aprop->u.number;
1095 }
1096 else
1097 {
1098 bprop->u.number |= features;
1099 updated = TRUE;
1100 }
1101 }
1102 else if (aprop != NULL)
1103 {
1104 aprop->pr_kind = property_remove;
1105 updated = TRUE;
1106 }
1107 }
1108 break;
1109
1110 default:
1111 /* Never should happen. */
1112 abort ();
1113 }
1114
1115 return updated;
1116}
a6798bab
L		 1117
1118/* Set up x86 GNU properties. Return the first relocatable ELF input
1119 with GNU properties if found. Otherwise, return NULL. */
1120
1121bfd *
1122_bfd_x86_elf_link_setup_gnu_properties
1123 (struct bfd_link_info *info,
1124 struct elf_x86_plt_layout_table *plt_layout)
1125{
1126 bfd_boolean normal_target;
1127 bfd_boolean lazy_plt;
1128 asection *sec, *pltsec;
1129 bfd *dynobj;
1130 bfd_boolean use_ibt_plt;
1131 unsigned int plt_alignment, features;
1132 struct elf_x86_link_hash_table *htab;
1133 bfd *pbfd;
1134 bfd *ebfd = NULL;
1135 elf_property *prop;
1136 const struct elf_backend_data *bed;
1137 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
1138 unsigned int got_align;
1139
1140 features = 0;
1141 if (info->ibt)
1142 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1143 if (info->shstk)
1144 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1145
1146 /* Find a normal input file with GNU property note. */
1147 for (pbfd = info->input_bfds;
1148 pbfd != NULL;
1149 pbfd = pbfd->link.next)
1150 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
1151 && bfd_count_sections (pbfd) != 0)
1152 {
1153 ebfd = pbfd;
1154
1155 if (elf_properties (pbfd) != NULL)
1156 break;
1157 }
1158
1159 if (ebfd != NULL && features)
1160 {
1161 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1162 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1163 prop = _bfd_elf_get_property (ebfd,
1164 GNU_PROPERTY_X86_FEATURE_1_AND,
1165 4);
1166 prop->u.number |= features;
1167 prop->pr_kind = property_number;
1168
1169 /* Create the GNU property note section if needed. */
1170 if (pbfd == NULL)
1171 {
1172 sec = bfd_make_section_with_flags (ebfd,
1173 NOTE_GNU_PROPERTY_SECTION_NAME,
1174 (SEC_ALLOC
1175 | SEC_LOAD
1176 | SEC_IN_MEMORY
1177 | SEC_READONLY
1178 | SEC_HAS_CONTENTS
1179 | SEC_DATA));
1180 if (sec == NULL)
1181 info->callbacks->einfo (_("%F: failed to create GNU property section\n"));
1182
1183 if (!bfd_set_section_alignment (ebfd, sec, class_align))
1184 {
1185error_alignment:
1186 info->callbacks->einfo (_("%F%A: failed to align section\n"),
1187 sec);
1188 }
1189
1190 elf_section_type (sec) = SHT_NOTE;
1191 }
1192 }
1193
1194 pbfd = _bfd_elf_link_setup_gnu_properties (info);
1195
1196 if (bfd_link_relocatable (info))
1197 return pbfd;
1198
1199 bed = get_elf_backend_data (info->output_bfd);
1200
1201 htab = elf_x86_hash_table (info, bed->target_id);
1202 if (htab == NULL)
1203 return pbfd;
1204
eeb2f20a
L		 1205 htab->is_vxworks = plt_layout->is_vxworks;
1206
a6798bab
L		 1207 use_ibt_plt = info->ibtplt || info->ibt;
1208 if (!use_ibt_plt && pbfd != NULL)
1209 {
1210 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
1211 elf_property_list *p;
1212
1213 /* The property list is sorted in order of type. */
1214 for (p = elf_properties (pbfd); p; p = p->next)
1215 {
1216 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
1217 {
1218 use_ibt_plt = !!(p->property.u.number
1219 & GNU_PROPERTY_X86_FEATURE_1_IBT);
1220 break;
1221 }
1222 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
1223 break;
1224 }
1225 }
1226
1227 dynobj = htab->elf.dynobj;
1228
1229 /* Set htab->elf.dynobj here so that there is no need to check and
1230 set it in check_relocs. */
1231 if (dynobj == NULL)
1232 {
1233 if (pbfd != NULL)
1234 {
1235 htab->elf.dynobj = pbfd;
1236 dynobj = pbfd;
1237 }
1238 else
1239 {
1240 bfd *abfd;
1241
1242 /* Find a normal input file to hold linker created
1243 sections. */
1244 for (abfd = info->input_bfds;
1245 abfd != NULL;
1246 abfd = abfd->link.next)
1247 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1248 && (abfd->flags
1249 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
1250 {
1251 htab->elf.dynobj = abfd;
1252 dynobj = abfd;
1253 break;
1254 }
1255 }
1256 }
1257
1258 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1259 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1260 canonical function address. */
1261 htab->plt.has_plt0 = 1;
1262 normal_target = plt_layout->normal_target;
1263
1264 if (normal_target)
1265 {
1266 if (use_ibt_plt)
1267 {
1268 htab->lazy_plt = plt_layout->lazy_ibt_plt;
1269 htab->non_lazy_plt = plt_layout->non_lazy_ibt_plt;
1270 }
1271 else
1272 {
1273 htab->lazy_plt = plt_layout->lazy_plt;
1274 htab->non_lazy_plt = plt_layout->non_lazy_plt;
1275 }
1276 }
1277 else
1278 {
1279 htab->lazy_plt = plt_layout->lazy_plt;
1280 htab->non_lazy_plt = NULL;
1281 }
1282
1283 pltsec = htab->elf.splt;
1284
1285 /* If the non-lazy PLT is available, use it for all PLT entries if
1286 there are no PLT0 or no .plt section. */
1287 if (htab->non_lazy_plt != NULL
1288 && (!htab->plt.has_plt0 || pltsec == NULL))
1289 {
1290 lazy_plt = FALSE;
1291 if (bfd_link_pic (info))
1292 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
1293 else
1294 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
1295 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
1296 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
1297 htab->plt.plt_got_insn_size
1298 = htab->non_lazy_plt->plt_got_insn_size;
1299 htab->plt.eh_frame_plt_size
1300 = htab->non_lazy_plt->eh_frame_plt_size;
1301 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
1302 }
1303 else
1304 {
1305 lazy_plt = TRUE;
1306 if (bfd_link_pic (info))
1307 {
1308 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
1309 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
1310 }
1311 else
1312 {
1313 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
1314 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
1315 }
1316 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
1317 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
1318 htab->plt.plt_got_insn_size
1319 = htab->lazy_plt->plt_got_insn_size;
1320 htab->plt.eh_frame_plt_size
1321 = htab->lazy_plt->eh_frame_plt_size;
1322 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
1323 }
1324
1325 /* Return if there are no normal input files. */
1326 if (dynobj == NULL)
1327 return pbfd;
1328
eeb2f20a 1329 if (htab->is_vxworks
a6798bab
L		 1330 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1331 &htab->srelplt2))
1332 {
1333 info->callbacks->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1334 return pbfd;
1335 }
1336
1337 /* Since create_dynamic_sections isn't always called, but GOT
1338 relocations need GOT relocations, create them here so that we
1339 don't need to do it in check_relocs. */
1340 if (htab->elf.sgot == NULL
1341 && !_bfd_elf_create_got_section (dynobj, info))
1342 info->callbacks->einfo (_("%F: failed to create GOT sections\n"));
1343
1344 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
1345
1346 /* Align .got and .got.plt sections to their entry size. Do it here
1347 instead of in create_dynamic_sections so that they are always
1348 properly aligned even if create_dynamic_sections isn't called. */
1349 sec = htab->elf.sgot;
1350 if (!bfd_set_section_alignment (dynobj, sec, got_align))
1351 goto error_alignment;
1352
1353 sec = htab->elf.sgotplt;
1354 if (!bfd_set_section_alignment (dynobj, sec, got_align))
1355 goto error_alignment;
1356
1357 /* Create the ifunc sections here so that check_relocs can be
1358 simplified. */
1359 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
1360 info->callbacks->einfo (_("%F: failed to create ifunc sections\n"));
1361
1362 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
1363
1364 if (pltsec != NULL)
1365 {
1366 /* Whe creating executable, set the contents of the .interp
1367 section to the interpreter. */
1368 if (bfd_link_executable (info) && !info->nointerp)
1369 {
1370 asection *s = bfd_get_linker_section (dynobj, ".interp");
1371 if (s == NULL)
1372 abort ();
1373 s->size = htab->dynamic_interpreter_size;
1374 s->contents = (unsigned char *) htab->dynamic_interpreter;
1375 htab->interp = s;
1376 }
1377
1378 /* Don't change PLT section alignment for NaCl since it uses
1379 64-byte PLT entry and sets PLT section alignment to 32
1380 bytes. Don't create additional PLT sections for NaCl. */
1381 if (normal_target)
1382 {
1383 flagword pltflags = (bed->dynamic_sec_flags
1384 | SEC_ALLOC
1385 | SEC_CODE
1386 | SEC_LOAD
1387 | SEC_READONLY);
1388 unsigned int non_lazy_plt_alignment
1389 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
1390
1391 sec = pltsec;
1392 if (!bfd_set_section_alignment (sec->owner, sec,
1393 plt_alignment))
1394 goto error_alignment;
1395
1396 /* Create the GOT procedure linkage table. */
1397 sec = bfd_make_section_anyway_with_flags (dynobj,
1398 ".plt.got",
1399 pltflags);
1400 if (sec == NULL)
1401 info->callbacks->einfo (_("%F: failed to create GOT PLT section\n"));
1402
1403 if (!bfd_set_section_alignment (dynobj, sec,
1404 non_lazy_plt_alignment))
1405 goto error_alignment;
1406
1407 htab->plt_got = sec;
1408
1409 if (lazy_plt)
1410 {
1411 sec = NULL;
1412
1413 if (use_ibt_plt)
1414 {
1415 /* Create the second PLT for Intel IBT support. IBT
1416 PLT is supported only for non-NaCl target and is
1417 is needed only for lazy binding. */
1418 sec = bfd_make_section_anyway_with_flags (dynobj,
1419 ".plt.sec",
1420 pltflags);
1421 if (sec == NULL)
1422 info->callbacks->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1423
1424 if (!bfd_set_section_alignment (dynobj, sec,
1425 plt_alignment))
1426 goto error_alignment;
1427 }
1428 else if (info->bndplt && ABI_64_P (dynobj))
1429 {
1430 /* Create the second PLT for Intel MPX support. MPX
1431 PLT is supported only for non-NaCl target in 64-bit
1432 mode and is needed only for lazy binding. */
1433 sec = bfd_make_section_anyway_with_flags (dynobj,
1434 ".plt.sec",
1435 pltflags);
1436 if (sec == NULL)
1437 info->callbacks->einfo (_("%F: failed to create BND PLT section\n"));
1438
1439 if (!bfd_set_section_alignment (dynobj, sec,
1440 non_lazy_plt_alignment))
1441 goto error_alignment;
1442 }
1443
1444 htab->plt_second = sec;
1445 }
1446 }
1447
1448 if (!info->no_ld_generated_unwind_info)
1449 {
1450 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1451 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1452 | SEC_LINKER_CREATED);
1453
1454 sec = bfd_make_section_anyway_with_flags (dynobj,
1455 ".eh_frame",
1456 flags);
1457 if (sec == NULL)
1458 info->callbacks->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1459
1460 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1461 goto error_alignment;
1462
1463 htab->plt_eh_frame = sec;
1464
1465 if (htab->plt_got != NULL)
1466 {
1467 sec = bfd_make_section_anyway_with_flags (dynobj,
1468 ".eh_frame",
1469 flags);
1470 if (sec == NULL)
1471 info->callbacks->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1472
1473 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1474 goto error_alignment;
1475
1476 htab->plt_got_eh_frame = sec;
1477 }
1478
1479 if (htab->plt_second != NULL)
1480 {
1481 sec = bfd_make_section_anyway_with_flags (dynobj,
1482 ".eh_frame",
1483 flags);
1484 if (sec == NULL)
1485 info->callbacks->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1486
1487 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1488 goto error_alignment;
1489
1490 htab->plt_second_eh_frame = sec;
1491 }
1492 }
1493 }
1494
1495 if (normal_target)
1496 {
1497 /* The .iplt section is used for IFUNC symbols in static
1498 executables. */
1499 sec = htab->elf.iplt;
1500 if (sec != NULL
1501 && !bfd_set_section_alignment (sec->owner, sec,
1502 plt_alignment))
1503 goto error_alignment;
1504 }
1505
1506 return pbfd;
1507}
GDB Binutils - Deliverables
This page took 0.14446 seconds and 4 git commands to generate.