/* X86-64 specific support for 64-bit ELF
- Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+ 2010 Free Software Foundation, Inc.
Contributed by Jan Hubicka <jh@suse.cz>.
This file is part of BFD, the Binary File Descriptor library.
0, 0, 0, 0 /* replaced with offset to start of .plt0. */
};
-/* The x86-64 linker needs to keep track of the number of relocs that
- it decides to copy as dynamic relocs in check_relocs for each symbol.
- This is so that it can later discard them if they are found to be
- unnecessary. We store the information in a field extending the
- regular ELF linker hash table. */
-
-struct elf64_x86_64_dyn_relocs
-{
- /* Next section. */
- struct elf64_x86_64_dyn_relocs *next;
-
- /* The input section of the reloc. */
- asection *sec;
-
- /* Total number of relocs copied for the input section. */
- bfd_size_type count;
-
- /* Number of pc-relative relocs copied for the input section. */
- bfd_size_type pc_count;
-};
-
/* x86-64 ELF linker hash entry. */
struct elf64_x86_64_link_hash_entry
struct elf_link_hash_entry elf;
/* Track dynamic relocs copied for this symbol. */
- struct elf64_x86_64_dyn_relocs *dyn_relocs;
+ struct elf_dyn_relocs *dyn_relocs;
#define GOT_UNKNOWN 0
#define GOT_NORMAL 1
#define is_x86_64_elf(bfd) \
(bfd_get_flavour (bfd) == bfd_target_elf_flavour \
&& elf_tdata (bfd) != NULL \
- && elf_object_id (bfd) == X86_64_ELF_TDATA)
+ && elf_object_id (bfd) == X86_64_ELF_DATA)
static bfd_boolean
elf64_x86_64_mkobject (bfd *abfd)
{
return bfd_elf_allocate_object (abfd, sizeof (struct elf64_x86_64_obj_tdata),
- X86_64_ELF_TDATA);
+ X86_64_ELF_DATA);
}
/* x86-64 ELF linker hash table. */
struct elf_link_hash_table elf;
/* Short-cuts to get to dynamic linker sections. */
- asection *sgot;
- asection *sgotplt;
- asection *srelgot;
- asection *splt;
- asection *srelplt;
asection *sdynbss;
asection *srelbss;
- asection *igotplt;
- asection *iplt;
- asection *irelplt;
- asection *irelifunc;
- /* The offset into splt of the PLT entry for the TLS descriptor
- resolver. Special values are 0, if not necessary (or not found
- to be necessary yet), and -1 if needed but not determined
- yet. */
- bfd_vma tlsdesc_plt;
- /* The offset into sgot of the GOT entry used by the PLT entry
- above. */
- bfd_vma tlsdesc_got;
-
- union {
+ union
+ {
bfd_signed_vma refcount;
bfd_vma offset;
} tls_ld_got;
/* The amount of space used by the jump slots in the GOT. */
bfd_vma sgotplt_jump_table_size;
- /* Small local sym to section mapping cache. */
- struct sym_sec_cache sym_sec;
+ /* Small local sym cache. */
+ struct sym_cache sym_cache;
/* _TLS_MODULE_BASE_ symbol. */
struct bfd_link_hash_entry *tls_module_base;
/* Used by local STT_GNU_IFUNC symbols. */
htab_t loc_hash_table;
- void *loc_hash_memory;
+ void * loc_hash_memory;
+
+ /* The offset into splt of the PLT entry for the TLS descriptor
+ resolver. Special values are 0, if not necessary (or not found
+ to be necessary yet), and -1 if needed but not determined
+ yet. */
+ bfd_vma tlsdesc_plt;
+ /* The offset into sgot of the GOT entry used by the PLT entry
+ above. */
+ bfd_vma tlsdesc_got;
};
/* Get the x86-64 ELF linker hash table from a link_info structure. */
#define elf64_x86_64_hash_table(p) \
- ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == X86_64_ELF_DATA ? ((struct elf64_x86_64_link_hash_table *) ((p)->hash)) : NULL)
#define elf64_x86_64_compute_jump_table_size(htab) \
- ((htab)->srelplt->reloc_count * GOT_ENTRY_SIZE)
+ ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
/* Create an entry in an x86-64 ELF linker hash table. */
subclass. */
if (entry == NULL)
{
- entry = bfd_hash_allocate (table,
- sizeof (struct elf64_x86_64_link_hash_entry));
+ entry = (struct bfd_hash_entry *)
+ bfd_hash_allocate (table,
+ sizeof (struct elf64_x86_64_link_hash_entry));
if (entry == NULL)
return entry;
}
return entry;
}
-static hashval_t
-elf64_x86_64_local_hash (int id, int r_sym)
-{
- return ((((id & 0xff) << 24) | ((id & 0xff00) << 8))
- ^ r_sym ^ (id >> 16));
-}
-
/* Compute a hash of a local hash entry. We use elf_link_hash_entry
for local symbol so that we can handle local STT_GNU_IFUNC symbols
as global symbol. We reuse indx and dynstr_index for local symbol
{
struct elf_link_hash_entry *h
= (struct elf_link_hash_entry *) ptr;
- return elf64_x86_64_local_hash (h->indx, h->dynstr_index);
+ return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
}
/* Compare local hash entries. */
{
struct elf64_x86_64_link_hash_entry e, *ret;
asection *sec = abfd->sections;
- hashval_t h = elf64_x86_64_local_hash (sec->id,
- ELF64_R_SYM (rel->r_info));
+ hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
+ ELF64_R_SYM (rel->r_info));
void **slot;
e.elf.indx = sec->id;
if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
elf64_x86_64_link_hash_newfunc,
- sizeof (struct elf64_x86_64_link_hash_entry)))
+ sizeof (struct elf64_x86_64_link_hash_entry),
+ X86_64_ELF_DATA))
{
free (ret);
return NULL;
}
- ret->sgot = NULL;
- ret->sgotplt = NULL;
- ret->srelgot = NULL;
- ret->splt = NULL;
- ret->srelplt = NULL;
ret->sdynbss = NULL;
ret->srelbss = NULL;
- ret->igotplt= NULL;
- ret->iplt = NULL;
- ret->irelplt= NULL;
- ret->irelifunc = NULL;
- ret->sym_sec.abfd = NULL;
+ ret->sym_cache.abfd = NULL;
ret->tlsdesc_plt = 0;
ret->tlsdesc_got = 0;
ret->tls_ld_got.refcount = 0;
_bfd_generic_link_hash_table_free (hash);
}
-/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
- shortcuts to them in our hash table. */
-
-static bfd_boolean
-elf64_x86_64_create_got_section (bfd *dynobj, struct bfd_link_info *info)
-{
- struct elf64_x86_64_link_hash_table *htab;
-
- if (! _bfd_elf_create_got_section (dynobj, info))
- return FALSE;
-
- htab = elf64_x86_64_hash_table (info);
- htab->sgot = bfd_get_section_by_name (dynobj, ".got");
- htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
- if (!htab->sgot || !htab->sgotplt)
- abort ();
-
- htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
- (SEC_ALLOC | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
- if (htab->srelgot == NULL
- || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
- return FALSE;
- return TRUE;
-}
-
/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
.rela.bss sections in DYNOBJ, and set up shortcuts to them in our
hash table. */
{
struct elf64_x86_64_link_hash_table *htab;
- htab = elf64_x86_64_hash_table (info);
- if (!htab->sgot && !elf64_x86_64_create_got_section (dynobj, info))
+ if (!_bfd_elf_create_dynamic_sections (dynobj, info))
return FALSE;
- if (!_bfd_elf_create_dynamic_sections (dynobj, info))
+ htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
return FALSE;
- htab->splt = bfd_get_section_by_name (dynobj, ".plt");
- htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
if (!info->shared)
htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
- if (!htab->splt || !htab->srelplt || !htab->sdynbss
+ if (!htab->sdynbss
|| (!info->shared && !htab->srelbss))
abort ();
{
if (edir->dyn_relocs != NULL)
{
- struct elf64_x86_64_dyn_relocs **pp;
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs **pp;
+ struct elf_dyn_relocs *p;
/* Add reloc counts against the indirect sym to the direct sym
list. Merge any entries against the same section. */
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
{
- struct elf64_x86_64_dyn_relocs *q;
+ struct elf_dyn_relocs *q;
for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec)
unsigned int *r_type, int tls_type,
const Elf_Internal_Rela *rel,
const Elf_Internal_Rela *relend,
- struct elf_link_hash_entry *h)
+ struct elf_link_hash_entry *h,
+ unsigned long r_symndx)
{
unsigned int from_type = *r_type;
unsigned int to_type = from_type;
case R_X86_64_GOTPC32_TLSDESC:
case R_X86_64_TLSDESC_CALL:
case R_X86_64_GOTTPOFF:
- if (!info->shared)
+ if (info->executable)
{
if (h == NULL)
to_type = R_X86_64_TPOFF32;
{
unsigned int new_to_type = to_type;
- if (!info->shared
+ if (info->executable
&& h != NULL
&& h->dynindx == -1
&& tls_type == GOT_TLS_IE)
break;
case R_X86_64_TLSLD:
- if (!info->shared)
+ if (info->executable)
to_type = R_X86_64_TPOFF32;
break;
from_type, rel, relend))
{
reloc_howto_type *from, *to;
+ const char *name;
from = elf64_x86_64_rtype_to_howto (abfd, from_type);
to = elf64_x86_64_rtype_to_howto (abfd, to_type);
+ if (h)
+ name = h->root.root.string;
+ else
+ {
+ struct elf64_x86_64_link_hash_table *htab;
+
+ htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ name = "*unknown*";
+ else
+ {
+ Elf_Internal_Sym *isym;
+
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ abfd, r_symndx);
+ name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
+ }
+ }
+
(*_bfd_error_handler)
(_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
"in section `%A' failed"),
- abfd, sec, from->name, to->name,
- h ? h->root.root.string : "a local symbol",
+ abfd, sec, from->name, to->name, name,
(unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
asection *sreloc;
- Elf_Internal_Sym *isymbuf;
if (info->relocatable)
return TRUE;
BFD_ASSERT (is_x86_64_elf (abfd));
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
symtab_hdr = &elf_symtab_hdr (abfd);
- isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
unsigned int r_type;
unsigned long r_symndx;
struct elf_link_hash_entry *h;
+ Elf_Internal_Sym *isym;
+ const char *name;
r_symndx = ELF64_R_SYM (rel->r_info);
r_type = ELF64_R_TYPE (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
{
/* A local symbol. */
- Elf_Internal_Sym *isym;
-
- /* Read this BFD's local symbols. */
- if (isymbuf == NULL)
- {
- if (isymbuf == NULL)
- isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
- symtab_hdr->sh_info, 0,
- NULL, NULL, NULL);
- if (isymbuf == NULL)
- return FALSE;
- }
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ abfd, r_symndx);
+ if (isym == NULL)
+ return FALSE;
/* Check relocation against local STT_GNU_IFUNC symbol. */
- isym = isymbuf + r_symndx;
if (ELF64_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
{
h = elf64_x86_64_get_local_sym_hash (htab, abfd, rel,
TRUE);
if (h == NULL)
return FALSE;
-
+
/* Fake a STT_GNU_IFUNC symbol. */
h->type = STT_GNU_IFUNC;
h->def_regular = 1;
}
else
{
+ isym = NULL;
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
case R_X86_64_PLT32:
case R_X86_64_GOTPCREL:
case R_X86_64_GOTPCREL64:
- if (htab->irelifunc == NULL && htab->iplt == NULL)
- {
- if (!_bfd_elf_create_ifunc_sections (abfd, info))
- return FALSE;
-
- if (info->shared)
- {
- htab->irelifunc = bfd_get_section_by_name (abfd,
- ".rela.ifunc");
- if (!htab->irelifunc)
- abort ();
- }
- else
- {
- htab->iplt = bfd_get_section_by_name (abfd, ".iplt");
- htab->irelplt = bfd_get_section_by_name (abfd,
- ".rela.iplt");
- htab->igotplt = bfd_get_section_by_name (abfd,
- ".igot.plt");
- if (!htab->iplt
- || !htab->irelplt
- || !htab->igotplt)
- abort ();
- }
- }
+ if (!_bfd_elf_create_ifunc_sections (abfd, info))
+ return FALSE;
break;
}
{
/* It is referenced by a non-shared object. */
h->ref_regular = 1;
-
+ h->needs_plt = 1;
+
/* STT_GNU_IFUNC symbol must go through PLT. */
h->plt.refcount += 1;
switch (r_type)
{
- default:
- (*_bfd_error_handler)
- (_("%B: relocation %s against STT_GNU_IFUNC "
- "symbol `%s' isn't handled by %s"), abfd,
- x86_64_elf_howto_table[r_type].name,
- (h->root.root.string
- ? h->root.root.string : "a local symbol"),
- __FUNCTION__);
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ default:
+ if (h->root.root.string)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
+ NULL);
+ (*_bfd_error_handler)
+ (_("%B: relocation %s against STT_GNU_IFUNC "
+ "symbol `%s' isn't handled by %s"), abfd,
+ x86_64_elf_howto_table[r_type].name,
+ name, __FUNCTION__);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
case R_X86_64_64:
h->non_got_ref = 1;
h->pointer_equality_needed = 1;
if (info->shared)
{
- struct elf64_x86_64_dyn_relocs *p;
- struct elf64_x86_64_dyn_relocs **head;
-
/* We must copy these reloc types into the output
file. Create a reloc section in dynobj and
make room for this reloc. */
+ sreloc = _bfd_elf_create_ifunc_dyn_reloc
+ (abfd, info, sec, sreloc,
+ &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs);
if (sreloc == NULL)
- {
- if (htab->elf.dynobj == NULL)
- htab->elf.dynobj = abfd;
-
- sreloc = _bfd_elf_make_dynamic_reloc_section
- (sec, htab->elf.dynobj, 3, abfd, TRUE);
-
- if (sreloc == NULL)
- return FALSE;
- }
-
- head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
- p = *head;
- if (p == NULL || p->sec != sec)
- {
- bfd_size_type amt = sizeof *p;
-
- p = ((struct elf64_x86_64_dyn_relocs *)
- bfd_alloc (htab->elf.dynobj, amt));
- if (p == NULL)
- return FALSE;
- p->next = *head;
- *head = p;
- p->sec = sec;
- p->count = 0;
- p->pc_count = 0;
- }
- p->count += 1;
+ return FALSE;
}
break;
case R_X86_64_GOTPCREL:
case R_X86_64_GOTPCREL64:
h->got.refcount += 1;
- if (htab->sgot == NULL
- && !elf64_x86_64_create_got_section (htab->elf.dynobj,
- info))
+ if (htab->elf.sgot == NULL
+ && !_bfd_elf_create_got_section (htab->elf.dynobj,
+ info))
return FALSE;
break;
}
if (! elf64_x86_64_tls_transition (info, abfd, sec, NULL,
symtab_hdr, sym_hashes,
&r_type, GOT_UNKNOWN,
- rel, rel_end, h))
+ rel, rel_end, h, r_symndx))
return FALSE;
switch (r_type)
goto create_got;
case R_X86_64_TPOFF32:
- if (info->shared)
+ if (!info->executable)
{
+ if (h)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
+ NULL);
(*_bfd_error_handler)
(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd,
- x86_64_elf_howto_table[r_type].name,
- (h) ? h->root.root.string : "a local symbol");
+ x86_64_elf_howto_table[r_type].name, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
break;
case R_X86_64_GOTTPOFF:
- if (info->shared)
+ if (!info->executable)
info->flags |= DF_STATIC_TLS;
/* Fall through */
tls_type |= old_tls_type;
else
{
+ if (h)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (abfd, symtab_hdr,
+ isym, NULL);
(*_bfd_error_handler)
(_("%B: '%s' accessed both as normal and thread local symbol"),
- abfd, h ? h->root.root.string : "<local>");
+ abfd, name);
return FALSE;
}
}
case R_X86_64_GOTPC32:
case R_X86_64_GOTPC64:
create_got:
- if (htab->sgot == NULL)
+ if (htab->elf.sgot == NULL)
{
if (htab->elf.dynobj == NULL)
htab->elf.dynobj = abfd;
- if (!elf64_x86_64_create_got_section (htab->elf.dynobj,
- info))
+ if (!_bfd_elf_create_got_section (htab->elf.dynobj,
+ info))
return FALSE;
}
break;
&& (sec->flags & SEC_ALLOC) != 0
&& (sec->flags & SEC_READONLY) != 0)
{
+ if (h)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
(*_bfd_error_handler)
(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
- abfd,
- x86_64_elf_howto_table[r_type].name,
- (h) ? h->root.root.string : "a local symbol");
+ abfd, x86_64_elf_howto_table[r_type].name, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
&& (h->root.type == bfd_link_hash_defweak
|| !h->def_regular)))
{
- struct elf64_x86_64_dyn_relocs *p;
- struct elf64_x86_64_dyn_relocs **head;
+ struct elf_dyn_relocs *p;
+ struct elf_dyn_relocs **head;
/* We must copy these reloc types into the output file.
Create a reloc section in dynobj and make room for
}
else
{
- void **vpp;
/* Track dynamic relocs needed for local syms too.
We really need local syms available to do this
easily. Oh well. */
-
asection *s;
- s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
- sec, r_symndx);
- if (s == NULL)
+ void **vpp;
+
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ abfd, r_symndx);
+ if (isym == NULL)
return FALSE;
+ s = bfd_section_from_elf_index (abfd, isym->st_shndx);
+ if (s == NULL)
+ s = sec;
+
/* Beware of type punned pointers vs strict aliasing
rules. */
vpp = &(elf_section_data (s)->local_dynrel);
- head = (struct elf64_x86_64_dyn_relocs **)vpp;
+ head = (struct elf_dyn_relocs **)vpp;
}
p = *head;
{
bfd_size_type amt = sizeof *p;
- p = ((struct elf64_x86_64_dyn_relocs *)
+ p = ((struct elf_dyn_relocs *)
bfd_alloc (htab->elf.dynobj, amt));
if (p == NULL)
return FALSE;
asection *sec,
const Elf_Internal_Rela *relocs)
{
+ struct elf64_x86_64_link_hash_table *htab;
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
bfd_signed_vma *local_got_refcounts;
if (info->relocatable)
return TRUE;
+ htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
elf_section_data (sec)->local_dynrel = NULL;
symtab_hdr = &elf_symtab_hdr (abfd);
if (r_symndx >= symtab_hdr->sh_info)
{
struct elf64_x86_64_link_hash_entry *eh;
- struct elf64_x86_64_dyn_relocs **pp;
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs **pp;
+ struct elf_dyn_relocs *p;
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
while (h->root.type == bfd_link_hash_indirect
if (! elf64_x86_64_tls_transition (info, abfd, sec, NULL,
symtab_hdr, sym_hashes,
&r_type, GOT_UNKNOWN,
- rel, relend, h))
+ rel, relend, h, r_symndx))
return FALSE;
switch (r_type)
{
case R_X86_64_TLSLD:
- if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
- elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
+ if (htab->tls_ld_got.refcount > 0)
+ htab->tls_ld_got.refcount -= 1;
break;
case R_X86_64_TLSGD:
if (ELIMINATE_COPY_RELOCS)
{
struct elf64_x86_64_link_hash_entry * eh;
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
eh = (struct elf64_x86_64_link_hash_entry *) h;
for (p = eh->dyn_relocs; p != NULL; p = p->next)
same memory location for the variable. */
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
/* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
to copy the initial value out of the dynamic object and into the
struct bfd_link_info *info;
struct elf64_x86_64_link_hash_table *htab;
struct elf64_x86_64_link_hash_entry *eh;
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
info = (struct bfd_link_info *) inf;
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
/* 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
&& h->def_regular)
- {
- asection *plt, *gotplt, *relplt;
-
- /* Return and discard space for dynamic relocations against it if
- it is never referenced in a non-shared object. */
- if (!h->ref_regular)
- {
- if (h->plt.refcount > 0
- || h->got.refcount > 0)
- abort ();
- h->got.offset = (bfd_vma) -1;
- eh->dyn_relocs = NULL;
- return TRUE;
- }
-
- /* When building a static executable, use .iplt, .igot.plt and
- .rela.iplt sections for STT_GNU_IFUNC symbols. */
- if (htab->splt != NULL)
- {
- plt = htab->splt;
- gotplt = htab->sgotplt;
- relplt = htab->srelplt;
-
- /* If this is the first .plt entry, make room for the special
- first entry. */
- if (plt->size == 0)
- plt->size += PLT_ENTRY_SIZE;
- }
- else
- {
- plt = htab->iplt;
- gotplt = htab->igotplt;
- relplt = htab->irelplt;
- }
-
- /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
- the original value for R_X86_64_IRELATIVE. */
- h->plt.offset = plt->size;
-
- /* Make room for this entry in the .plt/.iplt section. */
- plt->size += PLT_ENTRY_SIZE;
-
- /* We also need to make an entry in the .got.plt/.got.iplt
- section, which will be placed in the .got section by the
- linker script. */
- gotplt->size += GOT_ENTRY_SIZE;
-
- /* We also need to make an entry in the .rela.plt/.rela.iplt
- section. */
- relplt->size += sizeof (Elf64_External_Rela);
- relplt->reloc_count++;
-
- /* We need dynamic relocation for STT_GNU_IFUNC symbol only
- when there is a non-GOT reference in a shared object. */
- if (!info->shared
- || !h->non_got_ref)
- eh->dyn_relocs = NULL;
-
- /* Finally, allocate space. */
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- htab->irelifunc->size += p->count * sizeof (Elf64_External_Rela);
-
- /* For STT_GNU_IFUNC symbol, .got.plt has the real function
- addres and .got has the PLT entry adddress. We will load
- the GOT entry with the PLT entry in finish_dynamic_symbol if
- it is used. For branch, it uses .got.plt. For symbol value,
- 1. Use .got.plt in a shared object if it is forced local or
- not dynamic.
- 2. Use .got.plt in a non-shared object if pointer equality
- isn't needed.
- 3. Use .got.plt if .got isn't used.
- 4. Otherwise use .got so that it can be shared among different
- objects at run-time.
- We only need to relocate .got entry in shared object. */
- if ((info->shared
- && (h->dynindx == -1
- || h->forced_local))
- || (!info->shared
- && !h->pointer_equality_needed)
- || htab->sgot == NULL)
- {
- /* Use .got.plt. */
- h->got.offset = (bfd_vma) -1;
- }
- else
- {
- h->got.offset = htab->sgot->size;
- htab->sgot->size += GOT_ENTRY_SIZE;
- if (info->shared)
- htab->srelgot->size += sizeof (Elf64_External_Rela);
- }
-
- return TRUE;
- }
+ return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
+ &eh->dyn_relocs,
+ PLT_ENTRY_SIZE,
+ GOT_ENTRY_SIZE);
else if (htab->elf.dynamic_sections_created
&& h->plt.refcount > 0)
{
if (info->shared
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
{
- asection *s = htab->splt;
+ asection *s = htab->elf.splt;
/* If this is the first .plt entry, make room for the special
first 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->sgotplt->size += GOT_ENTRY_SIZE;
+ htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
/* We also need to make an entry in the .rela.plt section. */
- htab->srelplt->size += sizeof (Elf64_External_Rela);
- htab->srelplt->reloc_count++;
+ htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
+ htab->elf.srelplt->reloc_count++;
}
else
{
/* If R_X86_64_GOTTPOFF symbol is now local to the binary,
make it a R_X86_64_TPOFF32 requiring no GOT entry. */
if (h->got.refcount > 0
- && !info->shared
+ && info->executable
&& h->dynindx == -1
&& elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
{
if (GOT_TLS_GDESC_P (tls_type))
{
- eh->tlsdesc_got = htab->sgotplt->size
+ eh->tlsdesc_got = htab->elf.sgotplt->size
- elf64_x86_64_compute_jump_table_size (htab);
- htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
+ htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
h->got.offset = (bfd_vma) -2;
}
if (! GOT_TLS_GDESC_P (tls_type)
|| GOT_TLS_GD_P (tls_type))
{
- s = htab->sgot;
+ s = htab->elf.sgot;
h->got.offset = s->size;
s->size += GOT_ENTRY_SIZE;
if (GOT_TLS_GD_P (tls_type))
R_X86_64_GOTTPOFF needs one dynamic relocation. */
if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
|| tls_type == GOT_TLS_IE)
- htab->srelgot->size += sizeof (Elf64_External_Rela);
+ htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
else if (GOT_TLS_GD_P (tls_type))
- htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
+ htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela);
else if (! GOT_TLS_GDESC_P (tls_type)
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
&& (info->shared
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
- htab->srelgot->size += sizeof (Elf64_External_Rela);
+ htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
if (GOT_TLS_GDESC_P (tls_type))
{
- htab->srelplt->size += sizeof (Elf64_External_Rela);
+ htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
htab->tlsdesc_plt = (bfd_vma) -1;
}
}
should avoid writing weird assembly. */
if (SYMBOL_CALLS_LOCAL (info, h))
{
- struct elf64_x86_64_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
{
elf64_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
{
struct elf64_x86_64_link_hash_entry *eh;
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
bfd *ibfd;
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
dynobj = htab->elf.dynobj;
if (dynobj == NULL)
abort ();
for (s = ibfd->sections; s != NULL; s = s->next)
{
- struct elf64_x86_64_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
- for (p = (struct elf64_x86_64_dyn_relocs *)
+ for (p = (struct elf_dyn_relocs *)
(elf_section_data (s)->local_dynrel);
p != NULL;
p = p->next)
end_local_got = local_got + locsymcount;
local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
local_tlsdesc_gotent = elf64_x86_64_local_tlsdesc_gotent (ibfd);
- s = htab->sgot;
- srel = htab->srelgot;
+ s = htab->elf.sgot;
+ srel = htab->elf.srelgot;
for (; local_got < end_local_got;
++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
{
{
if (GOT_TLS_GDESC_P (*local_tls_type))
{
- *local_tlsdesc_gotent = htab->sgotplt->size
+ *local_tlsdesc_gotent = htab->elf.sgotplt->size
- elf64_x86_64_compute_jump_table_size (htab);
- htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
+ htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
*local_got = (bfd_vma) -2;
}
if (! GOT_TLS_GDESC_P (*local_tls_type)
{
if (GOT_TLS_GDESC_P (*local_tls_type))
{
- htab->srelplt->size += sizeof (Elf64_External_Rela);
+ htab->elf.srelplt->size
+ += sizeof (Elf64_External_Rela);
htab->tlsdesc_plt = (bfd_vma) -1;
}
if (! GOT_TLS_GDESC_P (*local_tls_type)
{
/* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
relocs. */
- htab->tls_ld_got.offset = htab->sgot->size;
- htab->sgot->size += 2 * GOT_ENTRY_SIZE;
- htab->srelgot->size += sizeof (Elf64_External_Rela);
+ htab->tls_ld_got.offset = htab->elf.sgot->size;
+ htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
+ htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
}
else
htab->tls_ld_got.offset = -1;
it's not incremented, so in order to compute the space reserved
for them, it suffices to multiply the reloc count by the jump
slot size. */
- if (htab->srelplt)
+ if (htab->elf.srelplt)
htab->sgotplt_jump_table_size
= elf64_x86_64_compute_jump_table_size (htab);
htab->tlsdesc_plt = 0;
else
{
- htab->tlsdesc_got = htab->sgot->size;
- htab->sgot->size += GOT_ENTRY_SIZE;
+ htab->tlsdesc_got = htab->elf.sgot->size;
+ htab->elf.sgot->size += GOT_ENTRY_SIZE;
/* Reserve room for the initial entry.
FIXME: we could probably do away with it in this case. */
- if (htab->splt->size == 0)
- htab->splt->size += PLT_ENTRY_SIZE;
- htab->tlsdesc_plt = htab->splt->size;
- htab->splt->size += PLT_ENTRY_SIZE;
+ if (htab->elf.splt->size == 0)
+ htab->elf.splt->size += PLT_ENTRY_SIZE;
+ htab->tlsdesc_plt = htab->elf.splt->size;
+ htab->elf.splt->size += PLT_ENTRY_SIZE;
}
}
if ((s->flags & SEC_LINKER_CREATED) == 0)
continue;
- if (s == htab->splt
- || s == htab->sgot
- || s == htab->sgotplt
- || s == htab->iplt
- || s == htab->igotplt
+ if (s == htab->elf.splt
+ || s == htab->elf.sgot
+ || s == htab->elf.sgotplt
+ || s == htab->elf.iplt
+ || s == htab->elf.igotplt
|| s == htab->sdynbss)
{
/* Strip this section if we don't need it; see the
}
else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
{
- if (s->size != 0 && s != htab->srelplt)
+ if (s->size != 0 && s != htab->elf.srelplt)
relocs = TRUE;
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
- if (s != htab->srelplt)
+ if (s != htab->elf.srelplt)
s->reloc_count = 0;
}
else
return FALSE;
}
- if (htab->splt->size != 0)
+ if (htab->elf.splt->size != 0)
{
if (!add_dynamic_entry (DT_PLTGOT, 0)
|| !add_dynamic_entry (DT_PLTRELSZ, 0)
if (tlsbase && tlsbase->type == STT_TLS)
{
+ struct elf64_x86_64_link_hash_table *htab;
struct bfd_link_hash_entry *bh = NULL;
const struct elf_backend_data *bed
= get_elf_backend_data (output_bfd);
+ htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
if (!(_bfd_generic_link_add_one_symbol
(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
tls_sec, 0, NULL, FALSE,
bed->collect, &bh)))
return FALSE;
- elf64_x86_64_hash_table (info)->tls_module_base = bh;
+ htab->tls_module_base = bh;
tlsbase = (struct elf_link_hash_entry *)bh;
tlsbase->def_regular = 1;
static void
elf64_x86_64_set_tls_module_base (struct bfd_link_info *info)
{
+ struct elf64_x86_64_link_hash_table *htab;
struct bfd_link_hash_entry *base;
if (!info->executable)
return;
- base = elf64_x86_64_hash_table (info)->tls_module_base;
+ htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return;
- if (!base)
+ base = htab->tls_module_base;
+ if (base == NULL)
return;
- base->u.def.value = elf_hash_table (info)->tls_size;
+ base->u.def.value = htab->elf.tls_size;
}
/* Return the base VMA address which should be subtracted from real addresses
&& (contents [offset - 1] & 0xf0) == 0x80));
}
+static void
+elf64_x86_64_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
+{
+ bfd_byte *loc = s->contents;
+ loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
+ BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
+ <= s->contents + s->size);
+ bfd_elf64_swap_reloca_out (abfd, rel, loc);
+}
+
/* Relocate an x86_64 ELF section. */
static bfd_boolean
BFD_ASSERT (is_x86_64_elf (input_bfd));
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
local_got_offsets = elf_local_got_offsets (input_bfd);
&sec, rel);
/* Relocate against local STT_GNU_IFUNC symbol. */
- if (ELF64_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
+ if (!info->relocatable
+ && ELF64_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
{
h = elf64_x86_64_get_local_sym_hash (htab, input_bfd,
rel, FALSE);
}
else
{
- bfd_boolean warned;
+ bfd_boolean warned ATTRIBUTE_UNUSED;
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
r_symndx, symtab_hdr, sym_hashes,
{
asection *plt;
bfd_vma plt_index;
+ const char *name;
if ((input_section->flags & SEC_ALLOC) == 0
|| h->plt.offset == (bfd_vma) -1)
abort ();
/* STT_GNU_IFUNC symbol must go through PLT. */
- plt = htab->splt ? htab->splt : htab->iplt;
+ plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
relocation = (plt->output_section->vma
+ plt->output_offset + h->plt.offset);
switch (r_type)
{
default:
+ if (h->root.root.string)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
+ NULL);
(*_bfd_error_handler)
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't handled by %s"), input_bfd,
x86_64_elf_howto_table[r_type].name,
- h->root.root.string, __FUNCTION__);
+ name, __FUNCTION__);
bfd_set_error (bfd_error_bad_value);
return FALSE;
case R_X86_64_64:
if (rel->r_addend != 0)
{
+ if (h->root.root.string)
+ name = h->root.root.string;
+ else
+ name = bfd_elf_sym_name (input_bfd, symtab_hdr,
+ sym, NULL);
(*_bfd_error_handler)
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' has non-zero addend: %d"),
input_bfd, x86_64_elf_howto_table[r_type].name,
- h->root.root.string, rel->r_addend);
+ name, rel->r_addend);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (info->shared && h->non_got_ref)
{
Elf_Internal_Rela outrel;
- bfd_byte *loc;
asection *sreloc;
/* Need a dynamic relocation to get the real function
+ input_section->output_offset);
if (h->dynindx == -1
- || h->forced_local)
+ || h->forced_local
+ || info->executable)
{
/* This symbol is resolved locally. */
outrel.r_info = ELF64_R_INFO (0, R_X86_64_IRELATIVE);
outrel.r_addend = 0;
}
- sreloc = htab->irelifunc;
- loc = sreloc->contents;
- loc += (sreloc->reloc_count++
- * sizeof (Elf64_External_Rela));
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ sreloc = htab->elf.irelifunc;
+ elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
/* If this reloc is against an external symbol, we
do not want to fiddle with the addend. Otherwise,
case R_X86_64_GOTPCREL:
case R_X86_64_GOTPCREL64:
- base_got = htab->sgot;
+ base_got = htab->elf.sgot;
off = h->got.offset;
if (base_got == NULL)
even just remember the offset, as finish_dynamic_symbol
would use that as offset into .got. */
- if (htab->splt != NULL)
+ if (htab->elf.splt != NULL)
{
plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
off = (plt_index + 3) * GOT_ENTRY_SIZE;
- base_got = htab->sgotplt;
+ base_got = htab->elf.sgotplt;
}
else
{
plt_index = h->plt.offset / PLT_ENTRY_SIZE;
off = plt_index * GOT_ENTRY_SIZE;
- base_got = htab->igotplt;
+ base_got = htab->elf.igotplt;
}
if (h->dynindx == -1
&& r_type != R_X86_64_GOTPCREL64)
{
asection *gotplt;
- if (htab->splt != NULL)
- gotplt = htab->sgotplt;
+ if (htab->elf.splt != NULL)
+ gotplt = htab->elf.sgotplt;
else
- gotplt = htab->igotplt;
+ gotplt = htab->elf.igotplt;
relocation -= (gotplt->output_section->vma
- gotplt->output_offset);
}
offset, if this symbol got a PLT entry (it was global).
Additionally if it's computed from the PLT entry, then that
GOT offset is relative to .got.plt, not to .got. */
- base_got = htab->sgot;
+ base_got = htab->elf.sgot;
- if (htab->sgot == NULL)
+ if (htab->elf.sgot == NULL)
abort ();
if (h != NULL)
.got. */
bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
off = (plt_index + 3) * GOT_ENTRY_SIZE;
- base_got = htab->sgotplt;
+ base_got = htab->elf.sgotplt;
}
dyn = htab->elf.dynamic_sections_created;
{
asection *s;
Elf_Internal_Rela outrel;
- bfd_byte *loc;
/* We need to generate a R_X86_64_RELATIVE reloc
for the dynamic linker. */
- s = htab->srelgot;
+ s = htab->elf.srelgot;
if (s == NULL)
abort ();
+ off);
outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
outrel.r_addend = relocation;
- loc = s->contents;
- loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, s, &outrel);
}
local_got_offsets[r_symndx] |= 1;
relocation = base_got->output_section->vma
+ base_got->output_offset + off;
if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
- relocation -= htab->sgotplt->output_section->vma
- - htab->sgotplt->output_offset;
+ relocation -= htab->elf.sgotplt->output_section->vma
+ - htab->elf.sgotplt->output_offset;
break;
defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
permitted by the ABI, we might have to change this
calculation. */
- relocation -= htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset;
+ relocation -= htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset;
break;
case R_X86_64_GOTPC32:
case R_X86_64_GOTPC64:
/* Use global offset table as symbol value. */
- relocation = htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset;
+ relocation = htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset;
unresolved_reloc = FALSE;
break;
if (h != NULL
/* See PLT32 handling. */
&& h->plt.offset != (bfd_vma) -1
- && htab->splt != NULL)
+ && htab->elf.splt != NULL)
{
- relocation = (htab->splt->output_section->vma
- + htab->splt->output_offset
+ relocation = (htab->elf.splt->output_section->vma
+ + htab->elf.splt->output_offset
+ h->plt.offset);
unresolved_reloc = FALSE;
}
- relocation -= htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset;
+ relocation -= htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset;
break;
case R_X86_64_PLT32:
break;
if (h->plt.offset == (bfd_vma) -1
- || htab->splt == NULL)
+ || htab->elf.splt == NULL)
{
/* We didn't make a PLT entry for this symbol. This
happens when statically linking PIC code, or when
break;
}
- relocation = (htab->splt->output_section->vma
- + htab->splt->output_offset
+ relocation = (htab->elf.splt->output_section->vma
+ + htab->elf.splt->output_offset
+ h->plt.offset);
unresolved_reloc = FALSE;
break;
|| h->root.type == bfd_link_hash_undefined)))
{
Elf_Internal_Rela outrel;
- bfd_byte *loc;
bfd_boolean skip, relocate;
asection *sreloc;
BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
- loc = sreloc->contents;
- loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
/* If this reloc is against an external symbol, we do
not want to fiddle with the addend. Otherwise, we
input_section, contents,
symtab_hdr, sym_hashes,
&r_type, tls_type, rel,
- relend, h))
+ relend, h, r_symndx))
return FALSE;
if (r_type == R_X86_64_TPOFF32)
leaq x@tlsdesc(%rip), %rax
Change it to:
- movl $x@tpoff, %rax
- */
+ movl $x@tpoff, %rax. */
- unsigned int val, type, type2;
+ unsigned int val, type;
type = bfd_get_8 (input_bfd, contents + roff - 3);
- type2 = bfd_get_8 (input_bfd, contents + roff - 2);
val = bfd_get_8 (input_bfd, contents + roff - 1);
bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
contents + roff - 3);
BFD_ASSERT (FALSE);
}
- if (htab->sgot == NULL)
+ if (htab->elf.sgot == NULL)
abort ();
if (h != NULL)
else
{
Elf_Internal_Rela outrel;
- bfd_byte *loc;
int dr_type, indx;
asection *sreloc;
- if (htab->srelgot == NULL)
+ if (htab->elf.srelgot == NULL)
abort ();
indx = h && h->dynindx != -1 ? h->dynindx : 0;
{
outrel.r_info = ELF64_R_INFO (indx, R_X86_64_TLSDESC);
BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
- + 2 * GOT_ENTRY_SIZE <= htab->sgotplt->size);
- outrel.r_offset = (htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
+ + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
+ outrel.r_offset = (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ offplt
+ htab->sgotplt_jump_table_size);
- sreloc = htab->srelplt;
- loc = sreloc->contents;
- loc += sreloc->reloc_count++
- * sizeof (Elf64_External_Rela);
- BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
- <= sreloc->contents + sreloc->size);
+ sreloc = htab->elf.srelplt;
if (indx == 0)
outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
else
outrel.r_addend = 0;
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
}
- sreloc = htab->srelgot;
+ sreloc = htab->elf.srelgot;
- outrel.r_offset = (htab->sgot->output_section->vma
- + htab->sgot->output_offset + off);
+ outrel.r_offset = (htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off);
if (GOT_TLS_GD_P (tls_type))
dr_type = R_X86_64_DTPMOD64;
else
dr_type = R_X86_64_TPOFF64;
- bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
+ bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
outrel.r_addend = 0;
if ((dr_type == R_X86_64_TPOFF64
|| dr_type == R_X86_64_TLSDESC) && indx == 0)
outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
outrel.r_info = ELF64_R_INFO (indx, dr_type);
- loc = sreloc->contents;
- loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
- BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
- <= sreloc->contents + sreloc->size);
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
if (GOT_TLS_GD_P (tls_type))
{
BFD_ASSERT (! unresolved_reloc);
bfd_put_64 (output_bfd,
relocation - elf64_x86_64_dtpoff_base (info),
- htab->sgot->contents + off + GOT_ENTRY_SIZE);
+ htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
}
else
{
bfd_put_64 (output_bfd, 0,
- htab->sgot->contents + off + GOT_ENTRY_SIZE);
+ htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
outrel.r_info = ELF64_R_INFO (indx,
R_X86_64_DTPOFF64);
outrel.r_offset += GOT_ENTRY_SIZE;
- sreloc->reloc_count++;
- loc += sizeof (Elf64_External_Rela);
- BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
- <= sreloc->contents + sreloc->size);
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, sreloc,
+ &outrel);
}
}
{
if (r_type == R_X86_64_GOTPC32_TLSDESC
|| r_type == R_X86_64_TLSDESC_CALL)
- relocation = htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
+ relocation = htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ offplt + htab->sgotplt_jump_table_size;
else
- relocation = htab->sgot->output_section->vma
- + htab->sgot->output_offset + off;
+ relocation = htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off;
unresolved_reloc = FALSE;
}
else
"\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
16);
- relocation = (htab->sgot->output_section->vma
- + htab->sgot->output_offset + off
+ relocation = (htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off
- roff
- input_section->output_section->vma
- input_section->output_offset
leaq x@tlsdesc(%rip), %rax
Change it to:
- movq x@gottpoff(%rip), %rax # before xchg %ax,%ax
- */
-
- unsigned int val, type, type2;
-
- type = bfd_get_8 (input_bfd, contents + roff - 3);
- type2 = bfd_get_8 (input_bfd, contents + roff - 2);
- val = bfd_get_8 (input_bfd, contents + roff - 1);
+ movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
/* Now modify the instruction as appropriate. To
turn a leaq into a movq in the form we use it, it
bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
bfd_put_32 (output_bfd,
- htab->sgot->output_section->vma
- + htab->sgot->output_offset + off
+ htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off
- rel->r_offset
- input_section->output_section->vma
- input_section->output_offset
call *(%rax)
Change it to:
- xchg %ax,%ax. */
+ xchg %ax, %ax. */
- unsigned int val, type;
-
- type = bfd_get_8 (input_bfd, contents + roff);
- val = bfd_get_8 (input_bfd, contents + roff + 1);
bfd_put_8 (output_bfd, 0x66, contents + roff);
bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
continue;
input_section, contents,
symtab_hdr, sym_hashes,
&r_type, GOT_UNKNOWN,
- rel, relend, h))
+ rel, relend, h, r_symndx))
return FALSE;
if (r_type != R_X86_64_TLSLD)
continue;
}
- if (htab->sgot == NULL)
+ if (htab->elf.sgot == NULL)
abort ();
off = htab->tls_ld_got.offset;
else
{
Elf_Internal_Rela outrel;
- bfd_byte *loc;
- if (htab->srelgot == NULL)
+ if (htab->elf.srelgot == NULL)
abort ();
- outrel.r_offset = (htab->sgot->output_section->vma
- + htab->sgot->output_offset + off);
+ outrel.r_offset = (htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off);
bfd_put_64 (output_bfd, 0,
- htab->sgot->contents + off);
+ htab->elf.sgot->contents + off);
bfd_put_64 (output_bfd, 0,
- htab->sgot->contents + off + GOT_ENTRY_SIZE);
+ htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
outrel.r_addend = 0;
- loc = htab->srelgot->contents;
- loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
- bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+ elf64_x86_64_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
htab->tls_ld_got.offset |= 1;
}
- relocation = htab->sgot->output_section->vma
- + htab->sgot->output_offset + off;
+ relocation = htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset + off;
unresolved_reloc = FALSE;
break;
case R_X86_64_DTPOFF32:
- if (info->shared || (input_section->flags & SEC_CODE) == 0)
+ if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
relocation -= elf64_x86_64_dtpoff_base (info);
else
relocation = elf64_x86_64_tpoff (info, relocation);
break;
case R_X86_64_TPOFF32:
- BFD_ASSERT (! info->shared);
+ BFD_ASSERT (info->executable);
relocation = elf64_x86_64_tpoff (info, relocation);
break;
struct elf64_x86_64_link_hash_table *htab;
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
if (h->plt.offset != (bfd_vma) -1)
{
/* When building a static executable, use .iplt, .igot.plt and
.rela.iplt sections for STT_GNU_IFUNC symbols. */
- if (htab->splt != NULL)
+ if (htab->elf.splt != NULL)
{
- plt = htab->splt;
- gotplt = htab->sgotplt;
- relplt = htab->srelplt;
+ plt = htab->elf.splt;
+ gotplt = htab->elf.sgotplt;
+ relplt = htab->elf.srelplt;
}
else
{
- plt = htab->iplt;
- gotplt = htab->igotplt;
- relplt = htab->irelplt;
+ plt = htab->elf.iplt;
+ gotplt = htab->elf.igotplt;
+ relplt = htab->elf.irelplt;
}
/* This symbol has an entry in the procedure linkage table. Set
corresponds to this symbol. This is the index of this symbol
in all the symbols for which we are making plt entries. The
first entry in the procedure linkage table is reserved.
-
+
Get the offset into the .got table of the entry that
corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
bytes. The first three are reserved for the dynamic linker.
For static executables, we don't reserve anything. */
- if (plt == htab->splt)
+ if (plt == htab->elf.splt)
{
plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
plt->contents + h->plt.offset + 2);
/* Don't fill PLT entry for static executables. */
- if (plt == htab->splt)
+ if (plt == htab->elf.splt)
{
/* Put relocation index. */
bfd_put_32 (output_bfd, plt_index,
&& elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
{
Elf_Internal_Rela rela;
- bfd_byte *loc;
/* This symbol has an entry in the global offset table. Set it
up. */
- if (htab->sgot == NULL || htab->srelgot == NULL)
+ if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
abort ();
- rela.r_offset = (htab->sgot->output_section->vma
- + htab->sgot->output_offset
+ rela.r_offset = (htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset
+ (h->got.offset &~ (bfd_vma) 1));
/* If this is a static link, or it is a -Bsymbolic link and the
}
else
{
+ asection *plt;
+
if (!h->pointer_equality_needed)
abort ();
/* For non-shared object, we can't use .got.plt, which
contains the real function addres if we need pointer
equality. We load the GOT entry with the PLT entry. */
- asection *plt = htab->splt ? htab->splt : htab->iplt;
+ plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
bfd_put_64 (output_bfd, (plt->output_section->vma
+ plt->output_offset
+ h->plt.offset),
- htab->sgot->contents + h->got.offset);
+ htab->elf.sgot->contents + h->got.offset);
return TRUE;
}
}
BFD_ASSERT((h->got.offset & 1) == 0);
do_glob_dat:
bfd_put_64 (output_bfd, (bfd_vma) 0,
- htab->sgot->contents + h->got.offset);
+ htab->elf.sgot->contents + h->got.offset);
rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
rela.r_addend = 0;
}
- loc = htab->srelgot->contents;
- loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
- bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+ elf64_x86_64_append_rela (output_bfd, htab->elf.srelgot, &rela);
}
if (h->needs_copy)
{
Elf_Internal_Rela rela;
- bfd_byte *loc;
/* This symbol needs a copy reloc. Set it up. */
+ h->root.u.def.section->output_offset);
rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
rela.r_addend = 0;
- loc = htab->srelbss->contents;
- loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
- bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+ elf64_x86_64_append_rela (output_bfd, htab->srelbss, &rela);
}
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
asection *sdyn;
htab = elf64_x86_64_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
dynobj = htab->elf.dynobj;
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
{
Elf64_External_Dyn *dyncon, *dynconend;
- if (sdyn == NULL || htab->sgot == NULL)
+ if (sdyn == NULL || htab->elf.sgot == NULL)
abort ();
dyncon = (Elf64_External_Dyn *) sdyn->contents;
continue;
case DT_PLTGOT:
- s = htab->sgotplt;
+ s = htab->elf.sgotplt;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
break;
case DT_JMPREL:
- dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
+ dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
break;
case DT_PLTRELSZ:
- s = htab->srelplt->output_section;
+ s = htab->elf.srelplt->output_section;
dyn.d_un.d_val = s->size;
break;
linker script arranges for .rela.plt to follow all
other relocation sections, we don't have to worry
about changing the DT_RELA entry. */
- if (htab->srelplt != NULL)
+ if (htab->elf.srelplt != NULL)
{
- s = htab->srelplt->output_section;
+ s = htab->elf.srelplt->output_section;
dyn.d_un.d_val -= s->size;
}
break;
case DT_TLSDESC_PLT:
- s = htab->splt;
+ s = htab->elf.splt;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
+ htab->tlsdesc_plt;
break;
case DT_TLSDESC_GOT:
- s = htab->sgot;
+ s = htab->elf.sgot;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
+ htab->tlsdesc_got;
break;
}
/* Fill in the special first entry in the procedure linkage table. */
- if (htab->splt && htab->splt->size > 0)
+ if (htab->elf.splt && htab->elf.splt->size > 0)
{
/* Fill in the first entry in the procedure linkage table. */
- memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
+ memcpy (htab->elf.splt->contents, elf64_x86_64_plt0_entry,
PLT_ENTRY_SIZE);
/* Add offset for pushq GOT+8(%rip), since the instruction
uses 6 bytes subtract this value. */
bfd_put_32 (output_bfd,
- (htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
+ (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ 8
- - htab->splt->output_section->vma
- - htab->splt->output_offset
+ - htab->elf.splt->output_section->vma
+ - htab->elf.splt->output_offset
- 6),
- htab->splt->contents + 2);
+ htab->elf.splt->contents + 2);
/* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
the end of the instruction. */
bfd_put_32 (output_bfd,
- (htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
+ (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ 16
- - htab->splt->output_section->vma
- - htab->splt->output_offset
+ - htab->elf.splt->output_section->vma
+ - htab->elf.splt->output_offset
- 12),
- htab->splt->contents + 8);
+ htab->elf.splt->contents + 8);
- elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
+ elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize =
PLT_ENTRY_SIZE;
if (htab->tlsdesc_plt)
{
bfd_put_64 (output_bfd, (bfd_vma) 0,
- htab->sgot->contents + htab->tlsdesc_got);
+ htab->elf.sgot->contents + htab->tlsdesc_got);
- memcpy (htab->splt->contents + htab->tlsdesc_plt,
+ memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
elf64_x86_64_plt0_entry,
PLT_ENTRY_SIZE);
/* Add offset for pushq GOT+8(%rip), since the
instruction uses 6 bytes subtract this value. */
bfd_put_32 (output_bfd,
- (htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
+ (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ 8
- - htab->splt->output_section->vma
- - htab->splt->output_offset
+ - htab->elf.splt->output_section->vma
+ - htab->elf.splt->output_offset
- htab->tlsdesc_plt
- 6),
- htab->splt->contents + htab->tlsdesc_plt + 2);
+ htab->elf.splt->contents + htab->tlsdesc_plt + 2);
/* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
htab->tlsdesc_got. The 12 is the offset to the end of
the instruction. */
bfd_put_32 (output_bfd,
- (htab->sgot->output_section->vma
- + htab->sgot->output_offset
+ (htab->elf.sgot->output_section->vma
+ + htab->elf.sgot->output_offset
+ htab->tlsdesc_got
- - htab->splt->output_section->vma
- - htab->splt->output_offset
+ - htab->elf.splt->output_section->vma
+ - htab->elf.splt->output_offset
- htab->tlsdesc_plt
- 12),
- htab->splt->contents + htab->tlsdesc_plt + 8);
+ htab->elf.splt->contents + htab->tlsdesc_plt + 8);
}
}
}
- if (htab->sgotplt)
+ if (htab->elf.sgotplt)
{
/* Fill in the first three entries in the global offset table. */
- if (htab->sgotplt->size > 0)
+ if (htab->elf.sgotplt->size > 0)
{
/* Set the first entry in the global offset table to the address of
the dynamic section. */
if (sdyn == NULL)
- bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
+ bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
else
bfd_put_64 (output_bfd,
sdyn->output_section->vma + sdyn->output_offset,
- htab->sgotplt->contents);
+ htab->elf.sgotplt->contents);
/* Write GOT[1] and GOT[2], needed for the dynamic linker. */
- bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
- bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
+ bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
+ bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
}
- elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
+ elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
GOT_ENTRY_SIZE;
}
- if (htab->sgot && htab->sgot->size > 0)
- elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
+ if (htab->elf.sgot && htab->elf.sgot->size > 0)
+ elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
= GOT_ENTRY_SIZE;
/* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
}
*secp = lcomm;
*valp = sym->st_size;
- break;
+ return TRUE;
}
- if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
+ if ((abfd->flags & DYNAMIC) == 0
+ && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
return TRUE;
static bfd_boolean
elf64_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
- asection *sec, int *index)
+ asection *sec, int *index_return)
{
if (sec == &_bfd_elf_large_com_section)
{
- *index = SHN_X86_64_LCOMMON;
+ *index_return = SHN_X86_64_LCOMMON;
return TRUE;
}
return FALSE;
#define elf64_bed elf64_x86_64_fbsd_bed
#include "elf64-target.h"
+
+/* Solaris 2 support. */
+
+#undef TARGET_LITTLE_SYM
+#define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
+#undef TARGET_LITTLE_NAME
+#define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
+
+/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
+ objects won't be recognized. */
+#undef ELF_OSABI
+
+#undef elf64_bed
+#define elf64_bed elf64_x86_64_sol2_bed
+
+/* The Solaris 2 ABI requires a plt symbol on all platforms.
+
+ Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
+ File, p.63. */
+#undef elf_backend_want_plt_sym
+#define elf_backend_want_plt_sym 1
+
+#include "elf64-target.h"
+
+/* Intel L1OM support. */
+
+static bfd_boolean
+elf64_l1om_elf_object_p (bfd *abfd)
+{
+ /* Set the right machine number for an L1OM elf64 file. */
+ bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
+ return TRUE;
+}
+
+#undef TARGET_LITTLE_SYM
+#define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
+#undef TARGET_LITTLE_NAME
+#define TARGET_LITTLE_NAME "elf64-l1om"
+#undef ELF_ARCH
+#define ELF_ARCH bfd_arch_l1om
+
+#undef ELF_MACHINE_CODE
+#define ELF_MACHINE_CODE EM_L1OM
+
+#undef ELF_OSABI
+
+#undef elf64_bed
+#define elf64_bed elf64_l1om_bed
+
+#undef elf_backend_object_p
+#define elf_backend_object_p elf64_l1om_elf_object_p
+
+#undef elf_backend_post_process_headers
+
+#include "elf64-target.h"
+
+/* FreeBSD L1OM support. */
+
+#undef TARGET_LITTLE_SYM
+#define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
+#undef TARGET_LITTLE_NAME
+#define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
+
+#undef ELF_OSABI
+#define ELF_OSABI ELFOSABI_FREEBSD
+
+#undef elf64_bed
+#define elf64_bed elf64_l1om_fbsd_bed
+
+#undef elf_backend_post_process_headers
+#define elf_backend_post_process_headers _bfd_elf_set_osabi
+
+#include "elf64-target.h"
projects / deliverable / binutils-gdb.git / blobdiff