/* X86-64 specific support for ELF
- Copyright (C) 2000-2014 Free Software Foundation, Inc.
+ Copyright (C) 2000-2015 Free Software Foundation, Inc.
Contributed by Jan Hubicka <jh@suse.cz>.
This file is part of BFD, the Binary File Descriptor library.
return elf_x86_64_rtype_to_howto (abfd,
x86_64_reloc_map[i].elf_reloc_val);
}
- return 0;
+ return NULL;
}
static reloc_howto_type *
(GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
unsigned char tls_type;
+ /* TRUE if a weak symbol with a real definition needs a copy reloc.
+ When there is a weak symbol with a real definition, the processor
+ independent code will have arranged for us to see the real
+ definition first. We need to copy the needs_copy bit from the
+ real definition and check it when allowing copy reloc in PIE. */
+ unsigned int needs_copy : 1;
+
/* TRUE if symbol has at least one BND relocation. */
- bfd_boolean has_bnd_reloc;
+ unsigned int has_bnd_reloc : 1;
+
+ /* Information about the GOT PLT entry. Filled when there are both
+ GOT and PLT relocations against the same function. */
+ union gotplt_union plt_got;
/* Information about the second PLT entry. Filled when has_bnd_reloc is
set. */
asection *srelbss;
asection *plt_eh_frame;
asection *plt_bnd;
+ asection *plt_got;
union
{
eh = (struct elf_x86_64_link_hash_entry *) entry;
eh->dyn_relocs = NULL;
eh->tls_type = GOT_UNKNOWN;
- eh->has_bnd_reloc = FALSE;
+ eh->needs_copy = 0;
+ eh->has_bnd_reloc = 0;
eh->plt_bnd.offset = (bfd_vma) -1;
+ eh->plt_got.offset = (bfd_vma) -1;
eh->tlsdesc_got = (bfd_vma) -1;
}
ret->elf.indx = sec->id;
ret->elf.dynstr_index = htab->r_sym (rel->r_info);
ret->elf.dynindx = -1;
+ ret->plt_got.offset = (bfd_vma) -1;
*slot = ret;
}
return &ret->elf;
return FALSE;
htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
- if (!info->shared)
- htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
-
- if (!htab->sdynbss
- || (!info->shared && !htab->srelbss))
+ if (!htab->sdynbss)
abort ();
+ if (info->executable)
+ {
+ /* Always allow copy relocs for building executables. */
+ asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
+ if (s == NULL)
+ {
+ const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
+ s = bfd_make_section_anyway_with_flags (dynobj,
+ ".rela.bss",
+ (bed->dynamic_sec_flags
+ | SEC_READONLY));
+ if (s == NULL
+ || ! bfd_set_section_alignment (dynobj, s,
+ bed->s->log_file_align))
+ return FALSE;
+ }
+ htab->srelbss = s;
+ }
+
if (!info->no_ld_generated_unwind_info
&& htab->plt_eh_frame == NULL
&& htab->elf.splt != NULL)
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
asection *sreloc;
+ bfd_boolean use_plt_got;
if (info->relocatable)
return TRUE;
if (htab == NULL)
return FALSE;
+ use_plt_got = get_elf_x86_64_backend_data (abfd) == &elf_x86_64_arch_bed;
+
symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
&& (get_elf_x86_64_backend_data (abfd)
== &elf_x86_64_arch_bed))
{
- elf_x86_64_hash_entry (h)->has_bnd_reloc = TRUE;
+ elf_x86_64_hash_entry (h)->has_bnd_reloc = 1;
/* Create the second PLT for Intel MPX support. */
if (htab->plt_bnd == NULL)
const struct elf_backend_data *bed;
bed = get_elf_backend_data (info->output_bfd);
- switch (sizeof (elf_x86_64_bnd_plt2_entry))
- {
- case 8:
- plt_bnd_align = 3;
- break;
- case 16:
- plt_bnd_align = 4;
- break;
- default:
- abort ();
- }
+ BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry) == 8
+ && (sizeof (elf_x86_64_bnd_plt2_entry)
+ == sizeof (elf_x86_64_legacy_plt2_entry)));
+ plt_bnd_align = 3;
if (htab->elf.dynobj == NULL)
htab->elf.dynobj = abfd;
default:
break;
}
+
+ if (use_plt_got
+ && h != NULL
+ && h->plt.refcount > 0
+ && h->got.refcount > 0
+ && htab->plt_got == NULL)
+ {
+ /* Create the GOT procedure linkage table. */
+ unsigned int plt_got_align;
+ const struct elf_backend_data *bed;
+
+ bed = get_elf_backend_data (info->output_bfd);
+ BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry) == 8
+ && (sizeof (elf_x86_64_bnd_plt2_entry)
+ == sizeof (elf_x86_64_legacy_plt2_entry)));
+ plt_got_align = 3;
+
+ if (htab->elf.dynobj == NULL)
+ htab->elf.dynobj = abfd;
+ htab->plt_got
+ = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
+ ".plt.got",
+ (bed->dynamic_sec_flags
+ | SEC_ALLOC
+ | SEC_CODE
+ | SEC_LOAD
+ | SEC_READONLY));
+ if (htab->plt_got == NULL
+ || !bfd_set_section_alignment (htab->elf.dynobj,
+ htab->plt_got,
+ plt_got_align))
+ return FALSE;
+ }
}
return TRUE;
h->root.u.def.section = h->u.weakdef->root.u.def.section;
h->root.u.def.value = h->u.weakdef->root.u.def.value;
if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
- h->non_got_ref = h->u.weakdef->non_got_ref;
+ {
+ eh = (struct elf_x86_64_link_hash_entry *) h;
+ h->non_got_ref = h->u.weakdef->non_got_ref;
+ eh->needs_copy = h->u.weakdef->needs_copy;
+ }
return TRUE;
}
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
- if (info->shared)
+ if (!info->executable)
return TRUE;
/* If there are no references to this symbol that do not use the
s = htab->sdynbss;
- return _bfd_elf_adjust_dynamic_copy (h, s);
+ return _bfd_elf_adjust_dynamic_copy (info, h, s);
}
/* Allocate space in .plt, .got and associated reloc sections for
bed = get_elf_backend_data (info->output_bfd);
plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
+ /* We can't use the GOT PLT if pointer equality is needed since
+ finish_dynamic_symbol won't clear symbol value and the dynamic
+ linker won't update the GOT slot. We will get into an infinite
+ loop at run-time. */
+ if (htab->plt_got != NULL
+ && h->type != STT_GNU_IFUNC
+ && !h->pointer_equality_needed
+ && h->plt.refcount > 0
+ && h->got.refcount > 0)
+ {
+ /* Don't use the regular PLT if there are both GOT and GOTPLT
+ reloctions. */
+ h->plt.offset = (bfd_vma) -1;
+
+ /* Use the GOT PLT. */
+ eh->plt_got.refcount = 1;
+ }
+
/* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
here if it is defined and referenced in a non-shared object. */
if (h->type == STT_GNU_IFUNC
return FALSE;
}
else if (htab->elf.dynamic_sections_created
- && h->plt.refcount > 0)
+ && (h->plt.refcount > 0 || eh->plt_got.refcount > 0))
{
+ bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
+
/* Make sure this symbol is output as a dynamic symbol.
Undefined weak syms won't yet be marked as dynamic. */
if (h->dynindx == -1
{
asection *s = htab->elf.splt;
asection *bnd_s = htab->plt_bnd;
+ asection *got_s = htab->plt_got;
/* If this is the first .plt entry, make room for the special
first entry. */
if (s->size == 0)
s->size = plt_entry_size;
- h->plt.offset = s->size;
- if (bnd_s)
- eh->plt_bnd.offset = bnd_s->size;
+ if (use_plt_got)
+ eh->plt_got.offset = got_s->size;
+ else
+ {
+ h->plt.offset = s->size;
+ if (bnd_s)
+ eh->plt_bnd.offset = bnd_s->size;
+ }
/* If this symbol is not defined in a regular file, and we are
not generating a shared library, then set the symbol to this
if (! info->shared
&& !h->def_regular)
{
- if (bnd_s)
+ if (use_plt_got)
{
- /* We need to make a call to the entry of the second
- PLT instead of regular PLT entry. */
- h->root.u.def.section = bnd_s;
- h->root.u.def.value = eh->plt_bnd.offset;
+ /* We need to make a call to the entry of the GOT PLT
+ instead of regular PLT entry. */
+ h->root.u.def.section = got_s;
+ h->root.u.def.value = eh->plt_got.offset;
}
else
{
- h->root.u.def.section = s;
- h->root.u.def.value = h->plt.offset;
+ if (bnd_s)
+ {
+ /* We need to make a call to the entry of the second
+ PLT instead of regular PLT entry. */
+ h->root.u.def.section = bnd_s;
+ h->root.u.def.value = eh->plt_bnd.offset;
+ }
+ else
+ {
+ h->root.u.def.section = s;
+ h->root.u.def.value = h->plt.offset;
+ }
}
}
/* Make room for this entry. */
- s->size += plt_entry_size;
- if (bnd_s)
+ if (use_plt_got)
+ got_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
+ else
{
- BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry)
- == sizeof (elf_x86_64_legacy_plt2_entry));
- bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
- }
+ s->size += plt_entry_size;
+ if (bnd_s)
+ bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
- /* We also need to make an entry in the .got.plt section, which
- will be placed in the .got section by the linker script. */
- htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
+ /* We also need to make an entry in the .got.plt section,
+ which will be placed in the .got section by the linker
+ script. */
+ htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
- /* We also need to make an entry in the .rela.plt section. */
- htab->elf.srelplt->size += bed->s->sizeof_rela;
- htab->elf.srelplt->reloc_count++;
+ /* We also need to make an entry in the .rela.plt
+ section. */
+ htab->elf.srelplt->size += bed->s->sizeof_rela;
+ htab->elf.srelplt->reloc_count++;
+ }
}
else
{
/* Also discard relocs on undefined weak syms with non-default
visibility. */
- if (eh->dyn_relocs != NULL
- && h->root.type == bfd_link_hash_undefweak)
+ if (eh->dyn_relocs != NULL)
{
- if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
+ if (h->root.type == bfd_link_hash_undefweak)
+ {
+ if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
+ eh->dyn_relocs = NULL;
+
+ /* Make sure undefined weak symbols are output as a dynamic
+ symbol in PIEs. */
+ else if (h->dynindx == -1
+ && ! h->forced_local
+ && ! bfd_elf_link_record_dynamic_symbol (info, h))
+ return FALSE;
+ }
+ /* For PIE, discard space for relocs against symbols which
+ turn out to need copy relocs. */
+ else if (info->executable
+ && (h->needs_copy || eh->needs_copy)
+ && h->def_dynamic
+ && !h->def_regular)
eh->dyn_relocs = NULL;
-
- /* Make sure undefined weak symbols are output as a dynamic
- symbol in PIEs. */
- else if (h->dynindx == -1
- && ! h->forced_local
- && ! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
}
-
}
else if (ELIMINATE_COPY_RELOCS)
{
|| s == htab->elf.iplt
|| s == htab->elf.igotplt
|| s == htab->plt_bnd
+ || s == htab->plt_got
|| s == htab->plt_eh_frame
|| s == htab->sdynbss)
{
if (h == NULL)
break;
- if (h->plt.offset == (bfd_vma) -1
+ if ((h->plt.offset == (bfd_vma) -1
+ && eh->plt_got.offset == (bfd_vma) -1)
|| htab->elf.splt == NULL)
{
/* We didn't make a PLT entry for this symbol. This
break;
}
- if (htab->plt_bnd != NULL)
+ if (h->plt.offset != (bfd_vma) -1)
{
- resolved_plt = htab->plt_bnd;
- plt_offset = eh->plt_bnd.offset;
+ if (htab->plt_bnd != NULL)
+ {
+ resolved_plt = htab->plt_bnd;
+ plt_offset = eh->plt_bnd.offset;
+ }
+ else
+ {
+ resolved_plt = htab->elf.splt;
+ plt_offset = h->plt.offset;
+ }
}
else
{
- resolved_plt = htab->elf.splt;
- plt_offset = h->plt.offset;
+ /* Use the GOT PLT. */
+ resolved_plt = htab->plt_got;
+ plt_offset = eh->plt_got.offset;
}
relocation = (resolved_plt->output_section->vma
defined locally or for a branch. */
fail = !h->def_regular && !branch;
}
- else
+ else if (!(info->executable
+ && (h->needs_copy || eh->needs_copy)))
{
- /* Symbol isn't referenced locally. We only allow
- branch to symbol with non-default visibility. */
+ /* Symbol doesn't need copy reloc and isn't referenced
+ locally. We only allow branch to symbol with
+ non-default visibility. */
fail = (!branch
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
}
if ((input_section->flags & SEC_ALLOC) == 0)
break;
+ /* Don't copy a pc-relative relocation into the output file
+ if the symbol needs copy reloc. */
if ((info->shared
+ && !(info->executable
+ && h != NULL
+ && (h->needs_copy || eh->needs_copy)
+ && IS_X86_64_PCREL_TYPE (r_type))
&& (h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
struct elf_x86_64_link_hash_table *htab;
const struct elf_x86_64_backend_data *abed;
bfd_boolean use_plt_bnd;
+ struct elf_x86_64_link_hash_entry *eh;
htab = elf_x86_64_hash_table (info);
if (htab == NULL)
? &elf_x86_64_bnd_arch_bed
: get_elf_x86_64_backend_data (output_bfd));
+ eh = (struct elf_x86_64_link_hash_entry *) h;
+
if (h->plt.offset != (bfd_vma) -1)
{
bfd_vma plt_index;
{
/* Use the second PLT with BND relocations. */
const bfd_byte *plt_entry, *plt2_entry;
- struct elf_x86_64_link_hash_entry *eh
- = (struct elf_x86_64_link_hash_entry *) h;
if (eh->has_bnd_reloc)
{
bed = get_elf_backend_data (output_bfd);
loc = relplt->contents + plt_index * bed->s->sizeof_rela;
bed->s->swap_reloca_out (output_bfd, &rela, loc);
+ }
+ else if (eh->plt_got.offset != (bfd_vma) -1)
+ {
+ bfd_vma got_offset, plt_offset, plt_got_offset, plt_got_insn_size;
+ asection *plt, *got;
+ bfd_boolean got_after_plt;
+ int32_t got_pcrel_offset;
+ const bfd_byte *got_plt_entry;
+
+ /* Set the entry in the GOT procedure linkage table. */
+ plt = htab->plt_got;
+ got = htab->elf.sgot;
+ got_offset = h->got.offset;
+
+ if (got_offset == (bfd_vma) -1
+ || h->type == STT_GNU_IFUNC
+ || plt == NULL
+ || got == NULL)
+ abort ();
- if (!h->def_regular)
+ /* Use the second PLT entry template for the GOT PLT since they
+ are the identical. */
+ plt_got_insn_size = elf_x86_64_bnd_arch_bed.plt_got_insn_size;
+ plt_got_offset = elf_x86_64_bnd_arch_bed.plt_got_offset;
+ if (eh->has_bnd_reloc)
+ got_plt_entry = elf_x86_64_bnd_plt2_entry;
+ else
{
- /* Mark the symbol as undefined, rather than as defined in
- the .plt section. Leave the value if there were any
- relocations where pointer equality matters (this is a clue
- for the dynamic linker, to make function pointer
- comparisons work between an application and shared
- library), otherwise set it to zero. If a function is only
- called from a binary, there is no need to slow down
- shared libraries because of that. */
- sym->st_shndx = SHN_UNDEF;
- if (!h->pointer_equality_needed)
- sym->st_value = 0;
+ got_plt_entry = elf_x86_64_legacy_plt2_entry;
+
+ /* Subtract 1 since there is no BND prefix. */
+ plt_got_insn_size -= 1;
+ plt_got_offset -= 1;
}
+
+ /* Fill in the entry in the GOT procedure linkage table. */
+ plt_offset = eh->plt_got.offset;
+ memcpy (plt->contents + plt_offset,
+ got_plt_entry, sizeof (elf_x86_64_legacy_plt2_entry));
+
+ /* Put offset the PC-relative instruction referring to the GOT
+ entry, subtracting the size of that instruction. */
+ got_pcrel_offset = (got->output_section->vma
+ + got->output_offset
+ + got_offset
+ - plt->output_section->vma
+ - plt->output_offset
+ - plt_offset
+ - plt_got_insn_size);
+
+ /* Check PC-relative offset overflow in GOT PLT entry. */
+ got_after_plt = got->output_section->vma > plt->output_section->vma;
+ if ((got_after_plt && got_pcrel_offset < 0)
+ || (!got_after_plt && got_pcrel_offset > 0))
+ info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
+ output_bfd, h->root.root.string);
+
+ bfd_put_32 (output_bfd, got_pcrel_offset,
+ plt->contents + plt_offset + plt_got_offset);
+ }
+
+ if (!h->def_regular
+ && (h->plt.offset != (bfd_vma) -1
+ || eh->plt_got.offset != (bfd_vma) -1))
+ {
+ /* Mark the symbol as undefined, rather than as defined in
+ the .plt section. Leave the value if there were any
+ relocations where pointer equality matters (this is a clue
+ for the dynamic linker, to make function pointer
+ comparisons work between an application and shared
+ library), otherwise set it to zero. If a function is only
+ called from a binary, there is no need to slow down
+ shared libraries because of that. */
+ sym->st_shndx = SHN_UNDEF;
+ if (!h->pointer_equality_needed)
+ sym->st_value = 0;
}
if (h->got.offset != (bfd_vma) -1
return TRUE;
}
-/* Return address in section PLT for the Ith GOTPLT relocation, for
- relocation REL or (bfd_vma) -1 if it should not be included. */
+/* Return an array of PLT entry symbol values. */
-static bfd_vma
-elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
- const arelent *rel)
+static bfd_vma *
+elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
+ asection *relplt)
{
- bfd *abfd;
- const struct elf_x86_64_backend_data *bed;
+ bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
+ arelent *p;
+ long count, i;
+ bfd_vma *plt_sym_val;
bfd_vma plt_offset;
+ bfd_byte *plt_contents;
+ const struct elf_x86_64_backend_data *bed;
+ Elf_Internal_Shdr *hdr;
+ asection *plt_bnd;
- /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE. */
- if (rel->howto->type != R_X86_64_JUMP_SLOT
- && rel->howto->type != R_X86_64_IRELATIVE)
- return (bfd_vma) -1;
-
- abfd = plt->owner;
- bed = get_elf_x86_64_backend_data (abfd);
- plt_offset = bed->plt_entry_size;
-
- if (elf_elfheader (abfd)->e_ident[EI_OSABI] != ELFOSABI_GNU)
- return plt->vma + (i + 1) * plt_offset;
+ /* Get the .plt section contents. PLT passed down may point to the
+ .plt.bnd section. Make sure that PLT always points to the .plt
+ section. */
+ plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
+ if (plt_bnd)
+ {
+ if (plt != plt_bnd)
+ abort ();
+ plt = bfd_get_section_by_name (abfd, ".plt");
+ if (plt == NULL)
+ abort ();
+ bed = &elf_x86_64_bnd_arch_bed;
+ }
+ else
+ bed = get_elf_x86_64_backend_data (abfd);
- while (plt_offset < plt->size)
+ plt_contents = (bfd_byte *) bfd_malloc (plt->size);
+ if (plt_contents == NULL)
+ return NULL;
+ if (!bfd_get_section_contents (abfd, (asection *) plt,
+ plt_contents, 0, plt->size))
{
- bfd_vma reloc_index;
- bfd_byte reloc_index_raw[4];
-
- if (!bfd_get_section_contents (abfd, (asection *) plt,
- reloc_index_raw,
- plt_offset + bed->plt_reloc_offset,
- sizeof (reloc_index_raw)))
- return (bfd_vma) -1;
-
- reloc_index = H_GET_32 (abfd, reloc_index_raw);
- if (reloc_index == i)
- return plt->vma + plt_offset;
- plt_offset += bed->plt_entry_size;
+bad_return:
+ free (plt_contents);
+ return NULL;
}
- abort ();
-}
+ slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
+ if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
+ goto bad_return;
-/* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
- PLT section, or (bfd_vma) -1 if it should not be included. */
+ hdr = &elf_section_data (relplt)->this_hdr;
+ count = relplt->size / hdr->sh_entsize;
-static bfd_vma
-elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i, const asection *plt)
-{
- const struct elf_x86_64_backend_data *bed = &elf_x86_64_bnd_arch_bed;
- bfd *abfd = plt->owner;
- bfd_vma plt_offset = bed->plt_entry_size;
+ plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
+ if (plt_sym_val == NULL)
+ goto bad_return;
- if (elf_elfheader (abfd)->e_ident[EI_OSABI] != ELFOSABI_GNU)
- return i * sizeof (elf_x86_64_legacy_plt2_entry);
+ for (i = 0; i < count; i++, p++)
+ plt_sym_val[i] = -1;
- while (plt_offset < plt->size)
+ plt_offset = bed->plt_entry_size;
+ p = relplt->relocation;
+ for (i = 0; i < count; i++, p++)
{
- bfd_vma reloc_index;
- bfd_byte reloc_index_raw[4];
+ long reloc_index;
- if (!bfd_get_section_contents (abfd, (asection *) plt,
- reloc_index_raw,
- plt_offset + bed->plt_reloc_offset,
- sizeof (reloc_index_raw)))
- return (bfd_vma) -1;
+ if (p->howto->type != R_X86_64_JUMP_SLOT
+ && p->howto->type != R_X86_64_IRELATIVE)
+ continue;
- reloc_index = H_GET_32 (abfd, reloc_index_raw);
- if (reloc_index == i)
+ reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
+ + bed->plt_reloc_offset));
+ if (reloc_index >= count)
+ abort ();
+ if (plt_bnd)
{
/* This is the index in .plt section. */
long plt_index = plt_offset / bed->plt_entry_size;
- /* Return the offset in .plt.bnd section. */
- return (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry);
+ /* Store VMA + the offset in .plt.bnd section. */
+ plt_sym_val[reloc_index] =
+ (plt_bnd->vma
+ + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
}
+ else
+ plt_sym_val[reloc_index] = plt->vma + plt_offset;
plt_offset += bed->plt_entry_size;
}
- abort ();
+ free (plt_contents);
+
+ return plt_sym_val;
}
/* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
asymbol **dynsyms,
asymbol **ret)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
- asection *relplt;
- asymbol *s;
- bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
- arelent *p;
- long count, i, n;
- size_t size;
- Elf_Internal_Shdr *hdr;
- char *names;
- asection *plt, *plt_push;
-
- plt_push = bfd_get_section_by_name (abfd, ".plt");
- if (plt_push == NULL)
- return 0;
-
- plt = bfd_get_section_by_name (abfd, ".plt.bnd");
- /* Use the generic ELF version if there is no .plt.bnd section. */
+ /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
+ as PLT if it exists. */
+ asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
if (plt == NULL)
- return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
- dynsymcount, dynsyms, ret);
-
- *ret = NULL;
-
- if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
- return 0;
-
- if (dynsymcount <= 0)
- return 0;
-
- relplt = bfd_get_section_by_name (abfd, ".rela.plt");
- if (relplt == NULL)
- return 0;
-
- hdr = &elf_section_data (relplt)->this_hdr;
- if (hdr->sh_link != elf_dynsymtab (abfd)
- || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
- return 0;
-
- slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
- if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
- return -1;
-
- count = relplt->size / hdr->sh_entsize;
- size = count * sizeof (asymbol);
- p = relplt->relocation;
- for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
- {
- size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
- if (p->addend != 0)
- size += sizeof ("+0x") - 1 + 8 + 8;
- }
-
- s = *ret = (asymbol *) bfd_malloc (size);
- if (s == NULL)
- return -1;
-
- names = (char *) (s + count);
- p = relplt->relocation;
- n = 0;
- for (i = 0; i < count; i++, p++)
- {
- bfd_vma offset;
- size_t len;
-
- if (p->howto->type != R_X86_64_JUMP_SLOT
- && p->howto->type != R_X86_64_IRELATIVE)
- continue;
-
- offset = elf_x86_64_plt_sym_val_offset_plt_bnd (i, plt_push);
-
- *s = **p->sym_ptr_ptr;
- /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
- we are defining a symbol, ensure one of them is set. */
- if ((s->flags & BSF_LOCAL) == 0)
- s->flags |= BSF_GLOBAL;
- s->flags |= BSF_SYNTHETIC;
- s->section = plt;
- s->value = offset;
- s->name = names;
- s->udata.p = NULL;
- len = strlen ((*p->sym_ptr_ptr)->name);
- memcpy (names, (*p->sym_ptr_ptr)->name, len);
- names += len;
- if (p->addend != 0)
- {
- char buf[30], *a;
-
- memcpy (names, "+0x", sizeof ("+0x") - 1);
- names += sizeof ("+0x") - 1;
- bfd_sprintf_vma (abfd, buf, p->addend);
- for (a = buf; *a == '0'; ++a)
- ;
- len = strlen (a);
- memcpy (names, a, len);
- names += len;
- }
- memcpy (names, "@plt", sizeof ("@plt"));
- names += sizeof ("@plt");
- ++s, ++n;
- }
-
- return n;
+ plt = bfd_get_section_by_name (abfd, ".plt");
+ return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
+ dynsymcount, dynsyms, ret,
+ plt,
+ elf_x86_64_get_plt_sym_val);
}
/* Handle an x86-64 specific section when reading an object file. This
#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
#define elf_backend_always_size_sections elf_x86_64_always_size_sections
#define elf_backend_init_index_section _bfd_elf_init_1_index_section
-#define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
#define elf_backend_object_p elf64_x86_64_elf_object_p
#define bfd_elf64_mkobject elf_x86_64_mkobject
#define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
#include "elf64-target.h"
-#undef bfd_elf64_get_synthetic_symtab
-
/* Native Client support. */
static bfd_boolean
elf_x86_64_reloc_name_lookup
#define bfd_elf32_mkobject \
elf_x86_64_mkobject
+#define bfd_elf32_get_synthetic_symtab \
+ elf_x86_64_get_synthetic_symtab
#undef elf_backend_object_p
#define elf_backend_object_p \
projects / deliverable / binutils-gdb.git / blobdiff