/* SPARC-specific support for 64-bit ELF
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1993-2017 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/sparc.h"
Elf_Internal_Shdr *rel_hdr,
asymbol **symbols, bfd_boolean dynamic)
{
- PTR allocated = NULL;
+ void * allocated = NULL;
bfd_byte *native_relocs;
arelent *relent;
unsigned int i;
bfd_size_type count;
arelent *relents;
- allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
+ allocated = bfd_malloc (rel_hdr->sh_size);
if (allocated == NULL)
goto error_return;
else
relent->address = rela.r_offset - asect->vma;
- if (ELF64_R_SYM (rela.r_info) == 0)
+ if (ELF64_R_SYM (rela.r_info) == STN_UNDEF
+ /* PR 17512: file: 996185f8. */
+ || (!dynamic && ELF64_R_SYM(rela.r_info) > bfd_get_symcount(abfd))
+ || (dynamic
+ && ELF64_R_SYM(rela.r_info) > bfd_get_dynamic_symcount(abfd)))
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
else
{
|| asect->reloc_count == 0)
return TRUE;
- rel_hdr = &d->rel_hdr;
- rel_hdr2 = d->rel_hdr2;
+ rel_hdr = d->rel.hdr;
+ rel_hdr2 = d->rela.hdr;
- BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
+ BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
|| (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
}
else
canon_reloc_count. */
canon_reloc_count (asect) = 0;
- if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
- dynamic))
+ if (rel_hdr
+ && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
+ dynamic))
return FALSE;
if (rel_hdr2
return ret;
}
+/* Install a new set of internal relocs. */
+
+static void
+elf64_sparc_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *asect,
+ arelent **location,
+ unsigned int count)
+{
+ asect->orelocation = location;
+ canon_reloc_count (asect) = count;
+}
+
/* Write out the relocs. */
static void
-elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
+elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)
{
bfd_boolean *failedp = (bfd_boolean *) data;
Elf_Internal_Shdr *rela_hdr;
reloc_count field to zero to inhibit writing them here. Also,
sometimes the SEC_RELOC flag gets set even when there aren't any
relocs. */
- if (sec->reloc_count == 0)
+ if (canon_reloc_count (sec) == 0)
return;
/* We can combine two relocs that refer to the same address
into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
latter is R_SPARC_13 with no associated symbol. */
count = 0;
- for (idx = 0; idx < sec->reloc_count; idx++)
+ for (idx = 0; idx < canon_reloc_count (sec); idx++)
{
bfd_vma addr;
addr = sec->orelocation[idx]->address;
if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
- && idx < sec->reloc_count - 1)
+ && idx < canon_reloc_count (sec) - 1)
{
arelent *r = sec->orelocation[idx + 1];
}
}
- rela_hdr = &elf_section_data (sec)->rel_hdr;
+ rela_hdr = elf_section_data (sec)->rela.hdr;
rela_hdr->sh_size = rela_hdr->sh_entsize * count;
- rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
+ rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
if (rela_hdr->contents == NULL)
{
*failedp = TRUE;
outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
src_rela = outbound_relocas;
- for (idx = 0; idx < sec->reloc_count; idx++)
+ for (idx = 0; idx < canon_reloc_count (sec); idx++)
{
Elf_Internal_Rela dst_rela;
arelent *ptr;
}
if (ptr->howto->type == R_SPARC_LO10
- && idx < sec->reloc_count - 1)
+ && idx < canon_reloc_count (sec) - 1)
{
arelent *r = sec->orelocation[idx + 1];
{
static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
+ if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
+ && (abfd->flags & DYNAMIC) == 0
+ && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
+ elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
+
if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
{
int reg;
case 2: reg -= 2; break;
case 6: reg -= 4; break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
abfd);
return FALSE;
}
- if (info->hash->creator != abfd->xvec
+ if (info->output_bfd->xvec != abfd->xvec
|| (abfd->flags & DYNAMIC) != 0)
{
/* STT_REGISTER only works when linking an elf64_sparc object.
if (p->name != NULL && strcmp (p->name, *namep))
{
- (*_bfd_error_handler)
- (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
- abfd, p->abfd, (int) sym->st_value,
- **namep ? *namep : "#scratch",
- *p->name ? p->name : "#scratch");
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("Register %%g%d used incompatibly: %s in %B,"
+ " previously %s in %B"),
+ (int) sym->st_value, **namep ? *namep : "#scratch", abfd,
+ *p->name ? p->name : "#scratch", p->abfd);
return FALSE;
}
if (type > STT_FUNC)
type = 0;
- (*_bfd_error_handler)
- (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
- abfd, p->abfd, *namep, stt_types[type]);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("Symbol `%s' has differing types: REGISTER in %B,"
+ " previously %s in %B"),
+ *namep, abfd, stt_types[type], p->abfd);
return FALSE;
}
return TRUE;
}
else if (*namep && **namep
- && info->hash->creator == abfd->xvec)
+ && info->output_bfd->xvec == abfd->xvec)
{
int i;
struct _bfd_sparc_elf_app_reg *p;
if (type > STT_FUNC)
type = 0;
- (*_bfd_error_handler)
- (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
- abfd, p->abfd, *namep, stt_types[type]);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("Symbol `%s' has differing types: %s in %B,"
+ " previously REGISTER in %B"),
+ *namep, stt_types[type], abfd, p->abfd);
return FALSE;
}
}
static bfd_boolean
elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info,
- PTR finfo, bfd_boolean (*func) (PTR, const char *,
- Elf_Internal_Sym *,
- asection *,
- struct elf_link_hash_entry *))
+ void * flaginfo,
+ int (*func) (void *, const char *,
+ Elf_Internal_Sym *,
+ asection *,
+ struct elf_link_hash_entry *))
{
int reg;
struct _bfd_sparc_elf_app_reg *app_regs =
if (elf_hash_table (info)->dynlocal)
{
bfd * dynobj = elf_hash_table (info)->dynobj;
- asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
+ asection *dynsymsec = bfd_get_linker_section (dynobj, ".dynsym");
struct elf_link_local_dynamic_entry *e;
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
sym.st_other = 0;
sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
sym.st_shndx = app_regs [reg].shndx;
- if (! (*func) (finfo, app_regs [reg].name, &sym,
- sym.st_shndx == SHN_ABS
- ? bfd_abs_section_ptr : bfd_und_section_ptr,
- NULL))
+ sym.st_target_internal = 0;
+ if ((*func) (flaginfo, app_regs [reg].name, &sym,
+ sym.st_shndx == SHN_ABS
+ ? bfd_abs_section_ptr : bfd_und_section_ptr,
+ NULL) != 1)
return FALSE;
}
object file when linking. */
static bfd_boolean
-elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
bfd_boolean error;
flagword new_flags, old_flags;
int new_mm, old_mm;
&& (old_flags & EF_SPARC_HAL_R1))
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking UltraSPARC specific with HAL specific code"),
ibfd);
}
if (new_flags != old_flags)
{
error = TRUE;
- (*_bfd_error_handler)
- (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
- ibfd, (long) new_flags, (long) old_flags);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ ibfd, new_flags, old_flags);
}
elf_elfheader (obfd)->e_flags = old_flags;
return FALSE;
}
}
- return TRUE;
+ return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info);
}
/* MARCO: Set the correct entry size for the .stab section. */
/* Print a STT_REGISTER symbol to file FILE. */
static const char *
-elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
+elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
asymbol *symbol)
{
FILE *file = (FILE *) filep;
}
\f
static enum elf_reloc_type_class
-elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela)
+elf64_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
switch ((int) ELF64_R_TYPE (rela->r_info))
{
EV_CURRENT,
bfd_elf64_write_out_phdrs,
bfd_elf64_write_shdrs_and_ehdr,
+ bfd_elf64_checksum_contents,
elf64_sparc_write_relocs,
bfd_elf64_swap_symbol_in,
bfd_elf64_swap_symbol_out,
bfd_elf64_swap_reloca_out
};
-#define TARGET_BIG_SYM bfd_elf64_sparc_vec
+#define TARGET_BIG_SYM sparc_elf64_vec
#define TARGET_BIG_NAME "elf64-sparc"
#define ELF_ARCH bfd_arch_sparc
#define ELF_MAXPAGESIZE 0x100000
elf64_sparc_canonicalize_reloc
#define bfd_elf64_canonicalize_dynamic_reloc \
elf64_sparc_canonicalize_dynamic_reloc
+#define bfd_elf64_set_reloc \
+ elf64_sparc_set_reloc
#define elf_backend_add_symbol_hook \
elf64_sparc_add_symbol_hook
#define elf_backend_get_symbol_type \
_bfd_sparc_elf_copy_indirect_symbol
#define bfd_elf64_bfd_reloc_type_lookup \
_bfd_sparc_elf_reloc_type_lookup
+#define bfd_elf64_bfd_reloc_name_lookup \
+ _bfd_sparc_elf_reloc_name_lookup
#define bfd_elf64_bfd_relax_section \
_bfd_sparc_elf_relax_section
#define bfd_elf64_new_section_hook \
#define elf_backend_create_dynamic_sections \
_bfd_sparc_elf_create_dynamic_sections
+#define elf_backend_relocs_compatible \
+ _bfd_elf_relocs_compatible
#define elf_backend_check_relocs \
_bfd_sparc_elf_check_relocs
#define elf_backend_adjust_dynamic_symbol \
_bfd_sparc_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections \
_bfd_sparc_elf_finish_dynamic_sections
+#define elf_backend_fixup_symbol \
+ _bfd_sparc_elf_fixup_symbol
#define bfd_elf64_mkobject \
_bfd_sparc_elf_mkobject
_bfd_sparc_elf_object_p
#define elf_backend_gc_mark_hook \
_bfd_sparc_elf_gc_mark_hook
-#define elf_backend_gc_sweep_hook \
- _bfd_sparc_elf_gc_sweep_hook
#define elf_backend_init_index_section \
_bfd_elf_init_1_index_section
#define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 1
#define elf_backend_got_header_size 8
+#define elf_backend_want_dynrelro 1
#define elf_backend_rela_normal 1
/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
#define elf_backend_plt_alignment 8
#include "elf64-target.h"
+
+/* FreeBSD support */
+#undef TARGET_BIG_SYM
+#define TARGET_BIG_SYM sparc_elf64_fbsd_vec
+#undef TARGET_BIG_NAME
+#define TARGET_BIG_NAME "elf64-sparc-freebsd"
+#undef ELF_OSABI
+#define ELF_OSABI ELFOSABI_FREEBSD
+
+#undef elf64_bed
+#define elf64_bed elf64_sparc_fbsd_bed
+
+#include "elf64-target.h"
+
+/* Solaris 2. */
+
+#undef TARGET_BIG_SYM
+#define TARGET_BIG_SYM sparc_elf64_sol2_vec
+#undef TARGET_BIG_NAME
+#define TARGET_BIG_NAME "elf64-sparc-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_sparc_sol2_bed
+
+/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
+ boundary. */
+#undef elf_backend_static_tls_alignment
+#define elf_backend_static_tls_alignment 16
+
+#include "elf64-target.h"