/* 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.
special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
static reloc_howto_type x86_64_elf_howto_table[] =
{
- HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
+ HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
FALSE),
HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
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. */
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;
if (info->executable)
{
/* Always allow copy relocs for building executables. */
- asection *s;
- s = bfd_get_linker_section (dynobj, ".rela.bss");
+ asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
if (s == NULL)
{
const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
return TRUE;
}
+/* Rename some of the generic section flags to better document how they
+ are used here. */
+#define need_convert_mov_to_lea sec_flg0
+
/* Look through the relocs for a section during the first phase, and
calculate needed space in the global offset table, procedure
linkage table, and dynamic reloc sections. */
&& (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)
plt_got_align))
return FALSE;
}
+
+ if (r_type == R_X86_64_GOTPCREL
+ && (h == NULL || h->type != STT_GNU_IFUNC))
+ sec->need_convert_mov_to_lea = 1;
}
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;
}
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
&& ! 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. */
+ /* For PIE, discard space for pc-relative relocs against
+ symbols which turn out to need copy relocs. */
else if (info->executable
- && h->needs_copy
+ && (h->needs_copy || eh->needs_copy)
&& h->def_dynamic
&& !h->def_regular)
- eh->dyn_relocs = NULL;
+ {
+ struct elf_dyn_relocs **pp;
+
+ for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+ {
+ if (p->pc_count != 0)
+ *pp = p->next;
+ else
+ pp = &p->next;
+ }
+ }
}
}
else if (ELIMINATE_COPY_RELOCS)
info->flags |= DF_TEXTREL;
- if (info->warn_shared_textrel && info->shared)
- info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
+ if ((info->warn_shared_textrel && info->shared)
+ || info->error_textrel)
+ info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
p->sec->owner, h->root.root.string,
p->sec);
if (!is_elf_hash_table (link_info->hash))
return FALSE;
- /* Nothing to do if there are no codes, no relocations or no output. */
+ /* Nothing to do if there is no need or no output. */
if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
- || sec->reloc_count == 0
+ || sec->need_convert_mov_to_lea == 0
|| bfd_is_abs_section (sec->output_section))
return TRUE;
&& (info->flags & DF_TEXTREL) == 0)
{
info->flags |= DF_TEXTREL;
- if (info->warn_shared_textrel && info->shared)
- info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
+ if ((info->warn_shared_textrel && info->shared)
+ || info->error_textrel)
+ info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
p->sec->owner, p->sec);
}
}
tlsbase = (struct elf_link_hash_entry *)bh;
tlsbase->def_regular = 1;
tlsbase->other = STV_HIDDEN;
+ tlsbase->root.linker_def = 1;
(*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
}
}
case R_X86_64_PC16:
case R_X86_64_PC32:
case R_X86_64_PC32_BND:
+ /* Don't complain about -fPIC if the symbol is undefined when
+ building executable. */
if (info->shared
&& (input_section->flags & SEC_ALLOC) != 0
&& (input_section->flags & SEC_READONLY) != 0
- && h != NULL)
+ && h != NULL
+ && !(info->executable
+ && h->root.type == bfd_link_hash_undefined))
{
bfd_boolean fail = FALSE;
bfd_boolean branch
defined locally or for a branch. */
fail = !h->def_regular && !branch;
}
- else if (!h->needs_copy)
+ else if (!(info->executable
+ && (h->needs_copy || eh->needs_copy)))
{
/* Symbol doesn't need copy reloc and isn't referenced
locally. We only allow branch to symbol with
break;
/* Don't copy a pc-relative relocation into the output file
- if the symbol needs copy reloc. */
+ if the symbol needs copy reloc or the symbol is undefined
+ when building executable. */
if ((info->shared
- && !(h != NULL
- && h->needs_copy
+ && !(info->executable
+ && h != NULL
+ && (h->needs_copy
+ || eh->needs_copy
+ || h->root.type == bfd_link_hash_undefined)
&& IS_X86_64_PCREL_TYPE (r_type))
&& (h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
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++)
+ 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;
+ /* Skip unknown relocation. */
+ if (p->howto == NULL)
+ continue;
- reloc_index = H_GET_32 (abfd, reloc_index_raw);
- if (reloc_index == i)
+ if (p->howto->type != R_X86_64_JUMP_SLOT
+ && p->howto->type != R_X86_64_IRELATIVE)
+ continue;
+
+ 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_got_header_size (GOT_ENTRY_SIZE*3)
#define elf_backend_rela_normal 1
#define elf_backend_plt_alignment 4
+#define elf_backend_extern_protected_data 1
#define elf_info_to_howto elf_x86_64_info_to_howto
#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 \