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