/* SPARC-specific support for 64-bit ELF
|
/* SPARC-specific support for 64-bit ELF
|
Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
|
Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
|
2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
MA 02110-1301, USA. */
|
MA 02110-1301, USA. */
|
|
|
#include "sysdep.h"
|
#include "sysdep.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "libbfd.h"
|
#include "libbfd.h"
|
#include "elf-bfd.h"
|
#include "elf-bfd.h"
|
#include "elf/sparc.h"
|
#include "elf/sparc.h"
|
#include "opcode/sparc.h"
|
#include "opcode/sparc.h"
|
#include "elfxx-sparc.h"
|
#include "elfxx-sparc.h"
|
|
|
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
|
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
|
#define MINUS_ONE (~ (bfd_vma) 0)
|
#define MINUS_ONE (~ (bfd_vma) 0)
|
|
|
/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
|
/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
|
section can represent up to two relocs, we must tell the user to allocate
|
section can represent up to two relocs, we must tell the user to allocate
|
more space. */
|
more space. */
|
|
|
static long
|
static long
|
elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
|
elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
|
{
|
{
|
return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
|
return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
|
}
|
}
|
|
|
static long
|
static long
|
elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
|
elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
|
{
|
{
|
return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
|
return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
|
}
|
}
|
|
|
/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
|
/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
|
them. We cannot use generic elf routines for this, because R_SPARC_OLO10
|
them. We cannot use generic elf routines for this, because R_SPARC_OLO10
|
has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
|
has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
|
for the same location, R_SPARC_LO10 and R_SPARC_13. */
|
for the same location, R_SPARC_LO10 and R_SPARC_13. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
|
elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
|
Elf_Internal_Shdr *rel_hdr,
|
Elf_Internal_Shdr *rel_hdr,
|
asymbol **symbols, bfd_boolean dynamic)
|
asymbol **symbols, bfd_boolean dynamic)
|
{
|
{
|
PTR allocated = NULL;
|
PTR allocated = NULL;
|
bfd_byte *native_relocs;
|
bfd_byte *native_relocs;
|
arelent *relent;
|
arelent *relent;
|
unsigned int i;
|
unsigned int i;
|
int entsize;
|
int entsize;
|
bfd_size_type count;
|
bfd_size_type count;
|
arelent *relents;
|
arelent *relents;
|
|
|
allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
|
allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
|
if (allocated == NULL)
|
if (allocated == NULL)
|
goto error_return;
|
goto error_return;
|
|
|
if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
|
if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
|
|| bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
|
|| bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
|
goto error_return;
|
goto error_return;
|
|
|
native_relocs = (bfd_byte *) allocated;
|
native_relocs = (bfd_byte *) allocated;
|
|
|
relents = asect->relocation + canon_reloc_count (asect);
|
relents = asect->relocation + canon_reloc_count (asect);
|
|
|
entsize = rel_hdr->sh_entsize;
|
entsize = rel_hdr->sh_entsize;
|
BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
|
BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
|
|
|
count = rel_hdr->sh_size / entsize;
|
count = rel_hdr->sh_size / entsize;
|
|
|
for (i = 0, relent = relents; i < count;
|
for (i = 0, relent = relents; i < count;
|
i++, relent++, native_relocs += entsize)
|
i++, relent++, native_relocs += entsize)
|
{
|
{
|
Elf_Internal_Rela rela;
|
Elf_Internal_Rela rela;
|
unsigned int r_type;
|
unsigned int r_type;
|
|
|
bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
|
bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
|
|
|
/* The address of an ELF reloc is section relative for an object
|
/* The address of an ELF reloc is section relative for an object
|
file, and absolute for an executable file or shared library.
|
file, and absolute for an executable file or shared library.
|
The address of a normal BFD reloc is always section relative,
|
The address of a normal BFD reloc is always section relative,
|
and the address of a dynamic reloc is absolute.. */
|
and the address of a dynamic reloc is absolute.. */
|
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
|
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
|
relent->address = rela.r_offset;
|
relent->address = rela.r_offset;
|
else
|
else
|
relent->address = rela.r_offset - asect->vma;
|
relent->address = rela.r_offset - asect->vma;
|
|
|
if (ELF64_R_SYM (rela.r_info) == 0)
|
if (ELF64_R_SYM (rela.r_info) == 0)
|
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
|
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
|
else
|
else
|
{
|
{
|
asymbol **ps, *s;
|
asymbol **ps, *s;
|
|
|
ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
|
ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
|
s = *ps;
|
s = *ps;
|
|
|
/* Canonicalize ELF section symbols. FIXME: Why? */
|
/* Canonicalize ELF section symbols. FIXME: Why? */
|
if ((s->flags & BSF_SECTION_SYM) == 0)
|
if ((s->flags & BSF_SECTION_SYM) == 0)
|
relent->sym_ptr_ptr = ps;
|
relent->sym_ptr_ptr = ps;
|
else
|
else
|
relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
|
relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
|
}
|
}
|
|
|
relent->addend = rela.r_addend;
|
relent->addend = rela.r_addend;
|
|
|
r_type = ELF64_R_TYPE_ID (rela.r_info);
|
r_type = ELF64_R_TYPE_ID (rela.r_info);
|
if (r_type == R_SPARC_OLO10)
|
if (r_type == R_SPARC_OLO10)
|
{
|
{
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
|
relent[1].address = relent->address;
|
relent[1].address = relent->address;
|
relent++;
|
relent++;
|
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
|
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
|
relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
|
relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13);
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13);
|
}
|
}
|
else
|
else
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
|
relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
|
}
|
}
|
|
|
canon_reloc_count (asect) += relent - relents;
|
canon_reloc_count (asect) += relent - relents;
|
|
|
if (allocated != NULL)
|
if (allocated != NULL)
|
free (allocated);
|
free (allocated);
|
|
|
return TRUE;
|
return TRUE;
|
|
|
error_return:
|
error_return:
|
if (allocated != NULL)
|
if (allocated != NULL)
|
free (allocated);
|
free (allocated);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
/* Read in and swap the external relocs. */
|
/* Read in and swap the external relocs. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
|
elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
|
asymbol **symbols, bfd_boolean dynamic)
|
asymbol **symbols, bfd_boolean dynamic)
|
{
|
{
|
struct bfd_elf_section_data * const d = elf_section_data (asect);
|
struct bfd_elf_section_data * const d = elf_section_data (asect);
|
Elf_Internal_Shdr *rel_hdr;
|
Elf_Internal_Shdr *rel_hdr;
|
Elf_Internal_Shdr *rel_hdr2;
|
Elf_Internal_Shdr *rel_hdr2;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
|
|
if (asect->relocation != NULL)
|
if (asect->relocation != NULL)
|
return TRUE;
|
return TRUE;
|
|
|
if (! dynamic)
|
if (! dynamic)
|
{
|
{
|
if ((asect->flags & SEC_RELOC) == 0
|
if ((asect->flags & SEC_RELOC) == 0
|
|| asect->reloc_count == 0)
|
|| asect->reloc_count == 0)
|
return TRUE;
|
return TRUE;
|
|
|
rel_hdr = &d->rel_hdr;
|
rel_hdr = &d->rel_hdr;
|
rel_hdr2 = d->rel_hdr2;
|
rel_hdr2 = d->rel_hdr2;
|
|
|
BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
|
BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
|
|| (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
|
|| (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Note that ASECT->RELOC_COUNT tends not to be accurate in this
|
/* Note that ASECT->RELOC_COUNT tends not to be accurate in this
|
case because relocations against this section may use the
|
case because relocations against this section may use the
|
dynamic symbol table, and in that case bfd_section_from_shdr
|
dynamic symbol table, and in that case bfd_section_from_shdr
|
in elf.c does not update the RELOC_COUNT. */
|
in elf.c does not update the RELOC_COUNT. */
|
if (asect->size == 0)
|
if (asect->size == 0)
|
return TRUE;
|
return TRUE;
|
|
|
rel_hdr = &d->this_hdr;
|
rel_hdr = &d->this_hdr;
|
asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
|
asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
|
rel_hdr2 = NULL;
|
rel_hdr2 = NULL;
|
}
|
}
|
|
|
amt = asect->reloc_count;
|
amt = asect->reloc_count;
|
amt *= 2 * sizeof (arelent);
|
amt *= 2 * sizeof (arelent);
|
asect->relocation = (arelent *) bfd_alloc (abfd, amt);
|
asect->relocation = (arelent *) bfd_alloc (abfd, amt);
|
if (asect->relocation == NULL)
|
if (asect->relocation == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
/* The elf64_sparc_slurp_one_reloc_table routine increments
|
/* The elf64_sparc_slurp_one_reloc_table routine increments
|
canon_reloc_count. */
|
canon_reloc_count. */
|
canon_reloc_count (asect) = 0;
|
canon_reloc_count (asect) = 0;
|
|
|
if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
|
if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
|
dynamic))
|
dynamic))
|
return FALSE;
|
return FALSE;
|
|
|
if (rel_hdr2
|
if (rel_hdr2
|
&& !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
|
&& !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
|
dynamic))
|
dynamic))
|
return FALSE;
|
return FALSE;
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Canonicalize the relocs. */
|
/* Canonicalize the relocs. */
|
|
|
static long
|
static long
|
elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
|
elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
|
arelent **relptr, asymbol **symbols)
|
arelent **relptr, asymbol **symbols)
|
{
|
{
|
arelent *tblptr;
|
arelent *tblptr;
|
unsigned int i;
|
unsigned int i;
|
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
|
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
|
|
|
if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
|
if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
|
return -1;
|
return -1;
|
|
|
tblptr = section->relocation;
|
tblptr = section->relocation;
|
for (i = 0; i < canon_reloc_count (section); i++)
|
for (i = 0; i < canon_reloc_count (section); i++)
|
*relptr++ = tblptr++;
|
*relptr++ = tblptr++;
|
|
|
*relptr = NULL;
|
*relptr = NULL;
|
|
|
return canon_reloc_count (section);
|
return canon_reloc_count (section);
|
}
|
}
|
|
|
|
|
/* Canonicalize the dynamic relocation entries. Note that we return
|
/* Canonicalize the dynamic relocation entries. Note that we return
|
the dynamic relocations as a single block, although they are
|
the dynamic relocations as a single block, although they are
|
actually associated with particular sections; the interface, which
|
actually associated with particular sections; the interface, which
|
was designed for SunOS style shared libraries, expects that there
|
was designed for SunOS style shared libraries, expects that there
|
is only one set of dynamic relocs. Any section that was actually
|
is only one set of dynamic relocs. Any section that was actually
|
installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
|
installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
|
the dynamic symbol table, is considered to be a dynamic reloc
|
the dynamic symbol table, is considered to be a dynamic reloc
|
section. */
|
section. */
|
|
|
static long
|
static long
|
elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
|
elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
|
asymbol **syms)
|
asymbol **syms)
|
{
|
{
|
asection *s;
|
asection *s;
|
long ret;
|
long ret;
|
|
|
if (elf_dynsymtab (abfd) == 0)
|
if (elf_dynsymtab (abfd) == 0)
|
{
|
{
|
bfd_set_error (bfd_error_invalid_operation);
|
bfd_set_error (bfd_error_invalid_operation);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
ret = 0;
|
ret = 0;
|
for (s = abfd->sections; s != NULL; s = s->next)
|
for (s = abfd->sections; s != NULL; s = s->next)
|
{
|
{
|
if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
|
if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
|
&& (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
|
&& (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
|
{
|
{
|
arelent *p;
|
arelent *p;
|
long count, i;
|
long count, i;
|
|
|
if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
|
if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
|
return -1;
|
return -1;
|
count = canon_reloc_count (s);
|
count = canon_reloc_count (s);
|
p = s->relocation;
|
p = s->relocation;
|
for (i = 0; i < count; i++)
|
for (i = 0; i < count; i++)
|
*storage++ = p++;
|
*storage++ = p++;
|
ret += count;
|
ret += count;
|
}
|
}
|
}
|
}
|
|
|
*storage = NULL;
|
*storage = NULL;
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Write out the relocs. */
|
/* Write out the relocs. */
|
|
|
static void
|
static void
|
elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
|
elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
|
{
|
{
|
bfd_boolean *failedp = (bfd_boolean *) data;
|
bfd_boolean *failedp = (bfd_boolean *) data;
|
Elf_Internal_Shdr *rela_hdr;
|
Elf_Internal_Shdr *rela_hdr;
|
bfd_vma addr_offset;
|
bfd_vma addr_offset;
|
Elf64_External_Rela *outbound_relocas, *src_rela;
|
Elf64_External_Rela *outbound_relocas, *src_rela;
|
unsigned int idx, count;
|
unsigned int idx, count;
|
asymbol *last_sym = 0;
|
asymbol *last_sym = 0;
|
int last_sym_idx = 0;
|
int last_sym_idx = 0;
|
|
|
/* If we have already failed, don't do anything. */
|
/* If we have already failed, don't do anything. */
|
if (*failedp)
|
if (*failedp)
|
return;
|
return;
|
|
|
if ((sec->flags & SEC_RELOC) == 0)
|
if ((sec->flags & SEC_RELOC) == 0)
|
return;
|
return;
|
|
|
/* The linker backend writes the relocs out itself, and sets the
|
/* The linker backend writes the relocs out itself, and sets the
|
reloc_count field to zero to inhibit writing them here. Also,
|
reloc_count field to zero to inhibit writing them here. Also,
|
sometimes the SEC_RELOC flag gets set even when there aren't any
|
sometimes the SEC_RELOC flag gets set even when there aren't any
|
relocs. */
|
relocs. */
|
if (sec->reloc_count == 0)
|
if (sec->reloc_count == 0)
|
return;
|
return;
|
|
|
/* We can combine two relocs that refer to the same address
|
/* We can combine two relocs that refer to the same address
|
into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
|
into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
|
latter is R_SPARC_13 with no associated symbol. */
|
latter is R_SPARC_13 with no associated symbol. */
|
count = 0;
|
count = 0;
|
for (idx = 0; idx < sec->reloc_count; idx++)
|
for (idx = 0; idx < sec->reloc_count; idx++)
|
{
|
{
|
bfd_vma addr;
|
bfd_vma addr;
|
|
|
++count;
|
++count;
|
|
|
addr = sec->orelocation[idx]->address;
|
addr = sec->orelocation[idx]->address;
|
if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
|
if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
|
&& idx < sec->reloc_count - 1)
|
&& idx < sec->reloc_count - 1)
|
{
|
{
|
arelent *r = sec->orelocation[idx + 1];
|
arelent *r = sec->orelocation[idx + 1];
|
|
|
if (r->howto->type == R_SPARC_13
|
if (r->howto->type == R_SPARC_13
|
&& r->address == addr
|
&& r->address == addr
|
&& bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
|
&& bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
|
&& (*r->sym_ptr_ptr)->value == 0)
|
&& (*r->sym_ptr_ptr)->value == 0)
|
++idx;
|
++idx;
|
}
|
}
|
}
|
}
|
|
|
rela_hdr = &elf_section_data (sec)->rel_hdr;
|
rela_hdr = &elf_section_data (sec)->rel_hdr;
|
|
|
rela_hdr->sh_size = rela_hdr->sh_entsize * count;
|
rela_hdr->sh_size = rela_hdr->sh_entsize * count;
|
rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
|
rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
|
if (rela_hdr->contents == NULL)
|
if (rela_hdr->contents == NULL)
|
{
|
{
|
*failedp = TRUE;
|
*failedp = TRUE;
|
return;
|
return;
|
}
|
}
|
|
|
/* Figure out whether the relocations are RELA or REL relocations. */
|
/* Figure out whether the relocations are RELA or REL relocations. */
|
if (rela_hdr->sh_type != SHT_RELA)
|
if (rela_hdr->sh_type != SHT_RELA)
|
abort ();
|
abort ();
|
|
|
/* The address of an ELF reloc is section relative for an object
|
/* The address of an ELF reloc is section relative for an object
|
file, and absolute for an executable file or shared library.
|
file, and absolute for an executable file or shared library.
|
The address of a BFD reloc is always section relative. */
|
The address of a BFD reloc is always section relative. */
|
addr_offset = 0;
|
addr_offset = 0;
|
if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
|
if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
|
addr_offset = sec->vma;
|
addr_offset = sec->vma;
|
|
|
/* orelocation has the data, reloc_count has the count... */
|
/* orelocation has the data, reloc_count has the count... */
|
outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
|
outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
|
src_rela = outbound_relocas;
|
src_rela = outbound_relocas;
|
|
|
for (idx = 0; idx < sec->reloc_count; idx++)
|
for (idx = 0; idx < sec->reloc_count; idx++)
|
{
|
{
|
Elf_Internal_Rela dst_rela;
|
Elf_Internal_Rela dst_rela;
|
arelent *ptr;
|
arelent *ptr;
|
asymbol *sym;
|
asymbol *sym;
|
int n;
|
int n;
|
|
|
ptr = sec->orelocation[idx];
|
ptr = sec->orelocation[idx];
|
sym = *ptr->sym_ptr_ptr;
|
sym = *ptr->sym_ptr_ptr;
|
if (sym == last_sym)
|
if (sym == last_sym)
|
n = last_sym_idx;
|
n = last_sym_idx;
|
else if (bfd_is_abs_section (sym->section) && sym->value == 0)
|
else if (bfd_is_abs_section (sym->section) && sym->value == 0)
|
n = STN_UNDEF;
|
n = STN_UNDEF;
|
else
|
else
|
{
|
{
|
last_sym = sym;
|
last_sym = sym;
|
n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
|
n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
|
if (n < 0)
|
if (n < 0)
|
{
|
{
|
*failedp = TRUE;
|
*failedp = TRUE;
|
return;
|
return;
|
}
|
}
|
last_sym_idx = n;
|
last_sym_idx = n;
|
}
|
}
|
|
|
if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
|
if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
|
&& (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
|
&& (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
|
&& ! _bfd_elf_validate_reloc (abfd, ptr))
|
&& ! _bfd_elf_validate_reloc (abfd, ptr))
|
{
|
{
|
*failedp = TRUE;
|
*failedp = TRUE;
|
return;
|
return;
|
}
|
}
|
|
|
if (ptr->howto->type == R_SPARC_LO10
|
if (ptr->howto->type == R_SPARC_LO10
|
&& idx < sec->reloc_count - 1)
|
&& idx < sec->reloc_count - 1)
|
{
|
{
|
arelent *r = sec->orelocation[idx + 1];
|
arelent *r = sec->orelocation[idx + 1];
|
|
|
if (r->howto->type == R_SPARC_13
|
if (r->howto->type == R_SPARC_13
|
&& r->address == ptr->address
|
&& r->address == ptr->address
|
&& bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
|
&& bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
|
&& (*r->sym_ptr_ptr)->value == 0)
|
&& (*r->sym_ptr_ptr)->value == 0)
|
{
|
{
|
idx++;
|
idx++;
|
dst_rela.r_info
|
dst_rela.r_info
|
= ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
|
= ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
|
R_SPARC_OLO10));
|
R_SPARC_OLO10));
|
}
|
}
|
else
|
else
|
dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
|
dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
|
}
|
}
|
else
|
else
|
dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
|
dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
|
|
|
dst_rela.r_offset = ptr->address + addr_offset;
|
dst_rela.r_offset = ptr->address + addr_offset;
|
dst_rela.r_addend = ptr->addend;
|
dst_rela.r_addend = ptr->addend;
|
|
|
bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
|
bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
|
++src_rela;
|
++src_rela;
|
}
|
}
|
}
|
}
|
|
|
/* Hook called by the linker routine which adds symbols from an object
|
/* Hook called by the linker routine which adds symbols from an object
|
file. We use it for STT_REGISTER symbols. */
|
file. We use it for STT_REGISTER symbols. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
|
elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
|
Elf_Internal_Sym *sym, const char **namep,
|
Elf_Internal_Sym *sym, const char **namep,
|
flagword *flagsp ATTRIBUTE_UNUSED,
|
flagword *flagsp ATTRIBUTE_UNUSED,
|
asection **secp ATTRIBUTE_UNUSED,
|
asection **secp ATTRIBUTE_UNUSED,
|
bfd_vma *valp ATTRIBUTE_UNUSED)
|
bfd_vma *valp ATTRIBUTE_UNUSED)
|
{
|
{
|
static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
|
static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
|
|
|
if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
|
if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
|
{
|
{
|
int reg;
|
int reg;
|
struct _bfd_sparc_elf_app_reg *p;
|
struct _bfd_sparc_elf_app_reg *p;
|
|
|
reg = (int)sym->st_value;
|
reg = (int)sym->st_value;
|
switch (reg & ~1)
|
switch (reg & ~1)
|
{
|
{
|
case 2: reg -= 2; break;
|
case 2: reg -= 2; break;
|
case 6: reg -= 4; break;
|
case 6: reg -= 4; break;
|
default:
|
default:
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
|
(_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
|
abfd);
|
abfd);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (info->output_bfd->xvec != abfd->xvec
|
if (info->output_bfd->xvec != abfd->xvec
|
|| (abfd->flags & DYNAMIC) != 0)
|
|| (abfd->flags & DYNAMIC) != 0)
|
{
|
{
|
/* STT_REGISTER only works when linking an elf64_sparc object.
|
/* STT_REGISTER only works when linking an elf64_sparc object.
|
If STT_REGISTER comes from a dynamic object, don't put it into
|
If STT_REGISTER comes from a dynamic object, don't put it into
|
the output bfd. The dynamic linker will recheck it. */
|
the output bfd. The dynamic linker will recheck it. */
|
*namep = NULL;
|
*namep = NULL;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
|
p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
|
|
|
if (p->name != NULL && strcmp (p->name, *namep))
|
if (p->name != NULL && strcmp (p->name, *namep))
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
|
(_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
|
abfd, p->abfd, (int) sym->st_value,
|
abfd, p->abfd, (int) sym->st_value,
|
**namep ? *namep : "#scratch",
|
**namep ? *namep : "#scratch",
|
*p->name ? p->name : "#scratch");
|
*p->name ? p->name : "#scratch");
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (p->name == NULL)
|
if (p->name == NULL)
|
{
|
{
|
if (**namep)
|
if (**namep)
|
{
|
{
|
struct elf_link_hash_entry *h;
|
struct elf_link_hash_entry *h;
|
|
|
h = (struct elf_link_hash_entry *)
|
h = (struct elf_link_hash_entry *)
|
bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
|
bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
|
|
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
unsigned char type = h->type;
|
unsigned char type = h->type;
|
|
|
if (type > STT_FUNC)
|
if (type > STT_FUNC)
|
type = 0;
|
type = 0;
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
|
(_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
|
abfd, p->abfd, *namep, stt_types[type]);
|
abfd, p->abfd, *namep, stt_types[type]);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
p->name = bfd_hash_allocate (&info->hash->table,
|
p->name = bfd_hash_allocate (&info->hash->table,
|
strlen (*namep) + 1);
|
strlen (*namep) + 1);
|
if (!p->name)
|
if (!p->name)
|
return FALSE;
|
return FALSE;
|
|
|
strcpy (p->name, *namep);
|
strcpy (p->name, *namep);
|
}
|
}
|
else
|
else
|
p->name = "";
|
p->name = "";
|
p->bind = ELF_ST_BIND (sym->st_info);
|
p->bind = ELF_ST_BIND (sym->st_info);
|
p->abfd = abfd;
|
p->abfd = abfd;
|
p->shndx = sym->st_shndx;
|
p->shndx = sym->st_shndx;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (p->bind == STB_WEAK
|
if (p->bind == STB_WEAK
|
&& ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
|
&& ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
|
{
|
{
|
p->bind = STB_GLOBAL;
|
p->bind = STB_GLOBAL;
|
p->abfd = abfd;
|
p->abfd = abfd;
|
}
|
}
|
}
|
}
|
*namep = NULL;
|
*namep = NULL;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
else if (*namep && **namep
|
else if (*namep && **namep
|
&& info->output_bfd->xvec == abfd->xvec)
|
&& info->output_bfd->xvec == abfd->xvec)
|
{
|
{
|
int i;
|
int i;
|
struct _bfd_sparc_elf_app_reg *p;
|
struct _bfd_sparc_elf_app_reg *p;
|
|
|
p = _bfd_sparc_elf_hash_table(info)->app_regs;
|
p = _bfd_sparc_elf_hash_table(info)->app_regs;
|
for (i = 0; i < 4; i++, p++)
|
for (i = 0; i < 4; i++, p++)
|
if (p->name != NULL && ! strcmp (p->name, *namep))
|
if (p->name != NULL && ! strcmp (p->name, *namep))
|
{
|
{
|
unsigned char type = ELF_ST_TYPE (sym->st_info);
|
unsigned char type = ELF_ST_TYPE (sym->st_info);
|
|
|
if (type > STT_FUNC)
|
if (type > STT_FUNC)
|
type = 0;
|
type = 0;
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
|
(_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
|
abfd, p->abfd, *namep, stt_types[type]);
|
abfd, p->abfd, *namep, stt_types[type]);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* This function takes care of emitting STT_REGISTER symbols
|
/* This function takes care of emitting STT_REGISTER symbols
|
which we cannot easily keep in the symbol hash table. */
|
which we cannot easily keep in the symbol hash table. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
|
elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
|
struct bfd_link_info *info,
|
struct bfd_link_info *info,
|
PTR finfo,
|
PTR finfo,
|
int (*func) (PTR, const char *,
|
int (*func) (PTR, const char *,
|
Elf_Internal_Sym *,
|
Elf_Internal_Sym *,
|
asection *,
|
asection *,
|
struct elf_link_hash_entry *))
|
struct elf_link_hash_entry *))
|
{
|
{
|
int reg;
|
int reg;
|
struct _bfd_sparc_elf_app_reg *app_regs =
|
struct _bfd_sparc_elf_app_reg *app_regs =
|
_bfd_sparc_elf_hash_table(info)->app_regs;
|
_bfd_sparc_elf_hash_table(info)->app_regs;
|
Elf_Internal_Sym sym;
|
Elf_Internal_Sym sym;
|
|
|
/* We arranged in size_dynamic_sections to put the STT_REGISTER entries
|
/* We arranged in size_dynamic_sections to put the STT_REGISTER entries
|
at the end of the dynlocal list, so they came at the end of the local
|
at the end of the dynlocal list, so they came at the end of the local
|
symbols in the symtab. Except that they aren't STB_LOCAL, so we need
|
symbols in the symtab. Except that they aren't STB_LOCAL, so we need
|
to back up symtab->sh_info. */
|
to back up symtab->sh_info. */
|
if (elf_hash_table (info)->dynlocal)
|
if (elf_hash_table (info)->dynlocal)
|
{
|
{
|
bfd * dynobj = elf_hash_table (info)->dynobj;
|
bfd * dynobj = elf_hash_table (info)->dynobj;
|
asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
|
asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
|
struct elf_link_local_dynamic_entry *e;
|
struct elf_link_local_dynamic_entry *e;
|
|
|
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
|
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
|
if (e->input_indx == -1)
|
if (e->input_indx == -1)
|
break;
|
break;
|
if (e)
|
if (e)
|
{
|
{
|
elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
|
elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
|
= e->dynindx;
|
= e->dynindx;
|
}
|
}
|
}
|
}
|
|
|
if (info->strip == strip_all)
|
if (info->strip == strip_all)
|
return TRUE;
|
return TRUE;
|
|
|
for (reg = 0; reg < 4; reg++)
|
for (reg = 0; reg < 4; reg++)
|
if (app_regs [reg].name != NULL)
|
if (app_regs [reg].name != NULL)
|
{
|
{
|
if (info->strip == strip_some
|
if (info->strip == strip_some
|
&& bfd_hash_lookup (info->keep_hash,
|
&& bfd_hash_lookup (info->keep_hash,
|
app_regs [reg].name,
|
app_regs [reg].name,
|
FALSE, FALSE) == NULL)
|
FALSE, FALSE) == NULL)
|
continue;
|
continue;
|
|
|
sym.st_value = reg < 2 ? reg + 2 : reg + 4;
|
sym.st_value = reg < 2 ? reg + 2 : reg + 4;
|
sym.st_size = 0;
|
sym.st_size = 0;
|
sym.st_other = 0;
|
sym.st_other = 0;
|
sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
|
sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
|
sym.st_shndx = app_regs [reg].shndx;
|
sym.st_shndx = app_regs [reg].shndx;
|
if ((*func) (finfo, app_regs [reg].name, &sym,
|
if ((*func) (finfo, app_regs [reg].name, &sym,
|
sym.st_shndx == SHN_ABS
|
sym.st_shndx == SHN_ABS
|
? bfd_abs_section_ptr : bfd_und_section_ptr,
|
? bfd_abs_section_ptr : bfd_und_section_ptr,
|
NULL) != 1)
|
NULL) != 1)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static int
|
static int
|
elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
|
elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
|
{
|
{
|
if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
|
if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
|
return STT_REGISTER;
|
return STT_REGISTER;
|
else
|
else
|
return type;
|
return type;
|
}
|
}
|
|
|
/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
|
/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
|
even in SHN_UNDEF section. */
|
even in SHN_UNDEF section. */
|
|
|
static void
|
static void
|
elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
|
elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
|
{
|
{
|
elf_symbol_type *elfsym;
|
elf_symbol_type *elfsym;
|
|
|
elfsym = (elf_symbol_type *) asym;
|
elfsym = (elf_symbol_type *) asym;
|
if (elfsym->internal_elf_sym.st_info
|
if (elfsym->internal_elf_sym.st_info
|
== ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
|
== ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
|
{
|
{
|
asym->flags |= BSF_GLOBAL;
|
asym->flags |= BSF_GLOBAL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Functions for dealing with the e_flags field. */
|
/* Functions for dealing with the e_flags field. */
|
|
|
/* Merge backend specific data from an object file to the output
|
/* Merge backend specific data from an object file to the output
|
object file when linking. */
|
object file when linking. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
|
elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
|
{
|
{
|
bfd_boolean error;
|
bfd_boolean error;
|
flagword new_flags, old_flags;
|
flagword new_flags, old_flags;
|
int new_mm, old_mm;
|
int new_mm, old_mm;
|
|
|
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
return TRUE;
|
return TRUE;
|
|
|
new_flags = elf_elfheader (ibfd)->e_flags;
|
new_flags = elf_elfheader (ibfd)->e_flags;
|
old_flags = elf_elfheader (obfd)->e_flags;
|
old_flags = elf_elfheader (obfd)->e_flags;
|
|
|
if (!elf_flags_init (obfd)) /* First call, no flags set */
|
if (!elf_flags_init (obfd)) /* First call, no flags set */
|
{
|
{
|
elf_flags_init (obfd) = TRUE;
|
elf_flags_init (obfd) = TRUE;
|
elf_elfheader (obfd)->e_flags = new_flags;
|
elf_elfheader (obfd)->e_flags = new_flags;
|
}
|
}
|
|
|
else if (new_flags == old_flags) /* Compatible flags are ok */
|
else if (new_flags == old_flags) /* Compatible flags are ok */
|
;
|
;
|
|
|
else /* Incompatible flags */
|
else /* Incompatible flags */
|
{
|
{
|
error = FALSE;
|
error = FALSE;
|
|
|
#define EF_SPARC_ISA_EXTENSIONS \
|
#define EF_SPARC_ISA_EXTENSIONS \
|
(EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
|
(EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
|
|
|
if ((ibfd->flags & DYNAMIC) != 0)
|
if ((ibfd->flags & DYNAMIC) != 0)
|
{
|
{
|
/* We don't want dynamic objects memory ordering and
|
/* We don't want dynamic objects memory ordering and
|
architecture to have any role. That's what dynamic linker
|
architecture to have any role. That's what dynamic linker
|
should do. */
|
should do. */
|
new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
|
new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
|
new_flags |= (old_flags
|
new_flags |= (old_flags
|
& (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
|
& (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Choose the highest architecture requirements. */
|
/* Choose the highest architecture requirements. */
|
old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
|
old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
|
new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
|
new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
|
if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
|
if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
|
&& (old_flags & EF_SPARC_HAL_R1))
|
&& (old_flags & EF_SPARC_HAL_R1))
|
{
|
{
|
error = TRUE;
|
error = TRUE;
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: linking UltraSPARC specific with HAL specific code"),
|
(_("%B: linking UltraSPARC specific with HAL specific code"),
|
ibfd);
|
ibfd);
|
}
|
}
|
/* Choose the most restrictive memory ordering. */
|
/* Choose the most restrictive memory ordering. */
|
old_mm = (old_flags & EF_SPARCV9_MM);
|
old_mm = (old_flags & EF_SPARCV9_MM);
|
new_mm = (new_flags & EF_SPARCV9_MM);
|
new_mm = (new_flags & EF_SPARCV9_MM);
|
old_flags &= ~EF_SPARCV9_MM;
|
old_flags &= ~EF_SPARCV9_MM;
|
new_flags &= ~EF_SPARCV9_MM;
|
new_flags &= ~EF_SPARCV9_MM;
|
if (new_mm < old_mm)
|
if (new_mm < old_mm)
|
old_mm = new_mm;
|
old_mm = new_mm;
|
old_flags |= old_mm;
|
old_flags |= old_mm;
|
new_flags |= old_mm;
|
new_flags |= old_mm;
|
}
|
}
|
|
|
/* Warn about any other mismatches */
|
/* Warn about any other mismatches */
|
if (new_flags != old_flags)
|
if (new_flags != old_flags)
|
{
|
{
|
error = TRUE;
|
error = TRUE;
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
|
(_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
|
ibfd, (long) new_flags, (long) old_flags);
|
ibfd, (long) new_flags, (long) old_flags);
|
}
|
}
|
|
|
elf_elfheader (obfd)->e_flags = old_flags;
|
elf_elfheader (obfd)->e_flags = old_flags;
|
|
|
if (error)
|
if (error)
|
{
|
{
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* MARCO: Set the correct entry size for the .stab section. */
|
/* MARCO: Set the correct entry size for the .stab section. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
|
elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
|
Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
|
Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
|
asection *sec)
|
asection *sec)
|
{
|
{
|
const char *name;
|
const char *name;
|
|
|
name = bfd_get_section_name (abfd, sec);
|
name = bfd_get_section_name (abfd, sec);
|
|
|
if (strcmp (name, ".stab") == 0)
|
if (strcmp (name, ".stab") == 0)
|
{
|
{
|
/* Even in the 64bit case the stab entries are only 12 bytes long. */
|
/* Even in the 64bit case the stab entries are only 12 bytes long. */
|
elf_section_data (sec)->this_hdr.sh_entsize = 12;
|
elf_section_data (sec)->this_hdr.sh_entsize = 12;
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Print a STT_REGISTER symbol to file FILE. */
|
/* Print a STT_REGISTER symbol to file FILE. */
|
|
|
static const char *
|
static const char *
|
elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
|
elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
|
asymbol *symbol)
|
asymbol *symbol)
|
{
|
{
|
FILE *file = (FILE *) filep;
|
FILE *file = (FILE *) filep;
|
int reg, type;
|
int reg, type;
|
|
|
if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
|
if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
|
!= STT_REGISTER)
|
!= STT_REGISTER)
|
return NULL;
|
return NULL;
|
|
|
reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
|
reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
|
type = symbol->flags;
|
type = symbol->flags;
|
fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
|
fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
|
((type & BSF_LOCAL)
|
((type & BSF_LOCAL)
|
? (type & BSF_GLOBAL) ? '!' : 'l'
|
? (type & BSF_GLOBAL) ? '!' : 'l'
|
: (type & BSF_GLOBAL) ? 'g' : ' '),
|
: (type & BSF_GLOBAL) ? 'g' : ' '),
|
(type & BSF_WEAK) ? 'w' : ' ');
|
(type & BSF_WEAK) ? 'w' : ' ');
|
if (symbol->name == NULL || symbol->name [0] == '\0')
|
if (symbol->name == NULL || symbol->name [0] == '\0')
|
return "#scratch";
|
return "#scratch";
|
else
|
else
|
return symbol->name;
|
return symbol->name;
|
}
|
}
|
|
|
static enum elf_reloc_type_class
|
static enum elf_reloc_type_class
|
elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela)
|
elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela)
|
{
|
{
|
switch ((int) ELF64_R_TYPE (rela->r_info))
|
switch ((int) ELF64_R_TYPE (rela->r_info))
|
{
|
{
|
case R_SPARC_RELATIVE:
|
case R_SPARC_RELATIVE:
|
return reloc_class_relative;
|
return reloc_class_relative;
|
case R_SPARC_JMP_SLOT:
|
case R_SPARC_JMP_SLOT:
|
return reloc_class_plt;
|
return reloc_class_plt;
|
case R_SPARC_COPY:
|
case R_SPARC_COPY:
|
return reloc_class_copy;
|
return reloc_class_copy;
|
default:
|
default:
|
return reloc_class_normal;
|
return reloc_class_normal;
|
}
|
}
|
}
|
}
|
|
|
/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
|
/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
|
standard ELF, because R_SPARC_OLO10 has secondary addend in
|
standard ELF, because R_SPARC_OLO10 has secondary addend in
|
ELF64_R_TYPE_DATA field. This structure is used to redirect the
|
ELF64_R_TYPE_DATA field. This structure is used to redirect the
|
relocation handling routines. */
|
relocation handling routines. */
|
|
|
const struct elf_size_info elf64_sparc_size_info =
|
const struct elf_size_info elf64_sparc_size_info =
|
{
|
{
|
sizeof (Elf64_External_Ehdr),
|
sizeof (Elf64_External_Ehdr),
|
sizeof (Elf64_External_Phdr),
|
sizeof (Elf64_External_Phdr),
|
sizeof (Elf64_External_Shdr),
|
sizeof (Elf64_External_Shdr),
|
sizeof (Elf64_External_Rel),
|
sizeof (Elf64_External_Rel),
|
sizeof (Elf64_External_Rela),
|
sizeof (Elf64_External_Rela),
|
sizeof (Elf64_External_Sym),
|
sizeof (Elf64_External_Sym),
|
sizeof (Elf64_External_Dyn),
|
sizeof (Elf64_External_Dyn),
|
sizeof (Elf_External_Note),
|
sizeof (Elf_External_Note),
|
4, /* hash-table entry size. */
|
4, /* hash-table entry size. */
|
/* Internal relocations per external relocations.
|
/* Internal relocations per external relocations.
|
For link purposes we use just 1 internal per
|
For link purposes we use just 1 internal per
|
1 external, for assembly and slurp symbol table
|
1 external, for assembly and slurp symbol table
|
we use 2. */
|
we use 2. */
|
1,
|
1,
|
64, /* arch_size. */
|
64, /* arch_size. */
|
3, /* log_file_align. */
|
3, /* log_file_align. */
|
ELFCLASS64,
|
ELFCLASS64,
|
EV_CURRENT,
|
EV_CURRENT,
|
bfd_elf64_write_out_phdrs,
|
bfd_elf64_write_out_phdrs,
|
bfd_elf64_write_shdrs_and_ehdr,
|
bfd_elf64_write_shdrs_and_ehdr,
|
bfd_elf64_checksum_contents,
|
bfd_elf64_checksum_contents,
|
elf64_sparc_write_relocs,
|
elf64_sparc_write_relocs,
|
bfd_elf64_swap_symbol_in,
|
bfd_elf64_swap_symbol_in,
|
bfd_elf64_swap_symbol_out,
|
bfd_elf64_swap_symbol_out,
|
elf64_sparc_slurp_reloc_table,
|
elf64_sparc_slurp_reloc_table,
|
bfd_elf64_slurp_symbol_table,
|
bfd_elf64_slurp_symbol_table,
|
bfd_elf64_swap_dyn_in,
|
bfd_elf64_swap_dyn_in,
|
bfd_elf64_swap_dyn_out,
|
bfd_elf64_swap_dyn_out,
|
bfd_elf64_swap_reloc_in,
|
bfd_elf64_swap_reloc_in,
|
bfd_elf64_swap_reloc_out,
|
bfd_elf64_swap_reloc_out,
|
bfd_elf64_swap_reloca_in,
|
bfd_elf64_swap_reloca_in,
|
bfd_elf64_swap_reloca_out
|
bfd_elf64_swap_reloca_out
|
};
|
};
|
|
|
#define TARGET_BIG_SYM bfd_elf64_sparc_vec
|
#define TARGET_BIG_SYM bfd_elf64_sparc_vec
|
#define TARGET_BIG_NAME "elf64-sparc"
|
#define TARGET_BIG_NAME "elf64-sparc"
|
#define ELF_ARCH bfd_arch_sparc
|
#define ELF_ARCH bfd_arch_sparc
|
#define ELF_MAXPAGESIZE 0x100000
|
#define ELF_MAXPAGESIZE 0x100000
|
#define ELF_COMMONPAGESIZE 0x2000
|
#define ELF_COMMONPAGESIZE 0x2000
|
|
|
/* This is the official ABI value. */
|
/* This is the official ABI value. */
|
#define ELF_MACHINE_CODE EM_SPARCV9
|
#define ELF_MACHINE_CODE EM_SPARCV9
|
|
|
/* This is the value that we used before the ABI was released. */
|
/* This is the value that we used before the ABI was released. */
|
#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
|
#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
|
|
|
#define elf_backend_reloc_type_class \
|
#define elf_backend_reloc_type_class \
|
elf64_sparc_reloc_type_class
|
elf64_sparc_reloc_type_class
|
#define bfd_elf64_get_reloc_upper_bound \
|
#define bfd_elf64_get_reloc_upper_bound \
|
elf64_sparc_get_reloc_upper_bound
|
elf64_sparc_get_reloc_upper_bound
|
#define bfd_elf64_get_dynamic_reloc_upper_bound \
|
#define bfd_elf64_get_dynamic_reloc_upper_bound \
|
elf64_sparc_get_dynamic_reloc_upper_bound
|
elf64_sparc_get_dynamic_reloc_upper_bound
|
#define bfd_elf64_canonicalize_reloc \
|
#define bfd_elf64_canonicalize_reloc \
|
elf64_sparc_canonicalize_reloc
|
elf64_sparc_canonicalize_reloc
|
#define bfd_elf64_canonicalize_dynamic_reloc \
|
#define bfd_elf64_canonicalize_dynamic_reloc \
|
elf64_sparc_canonicalize_dynamic_reloc
|
elf64_sparc_canonicalize_dynamic_reloc
|
#define elf_backend_add_symbol_hook \
|
#define elf_backend_add_symbol_hook \
|
elf64_sparc_add_symbol_hook
|
elf64_sparc_add_symbol_hook
|
#define elf_backend_get_symbol_type \
|
#define elf_backend_get_symbol_type \
|
elf64_sparc_get_symbol_type
|
elf64_sparc_get_symbol_type
|
#define elf_backend_symbol_processing \
|
#define elf_backend_symbol_processing \
|
elf64_sparc_symbol_processing
|
elf64_sparc_symbol_processing
|
#define elf_backend_print_symbol_all \
|
#define elf_backend_print_symbol_all \
|
elf64_sparc_print_symbol_all
|
elf64_sparc_print_symbol_all
|
#define elf_backend_output_arch_syms \
|
#define elf_backend_output_arch_syms \
|
elf64_sparc_output_arch_syms
|
elf64_sparc_output_arch_syms
|
#define bfd_elf64_bfd_merge_private_bfd_data \
|
#define bfd_elf64_bfd_merge_private_bfd_data \
|
elf64_sparc_merge_private_bfd_data
|
elf64_sparc_merge_private_bfd_data
|
#define elf_backend_fake_sections \
|
#define elf_backend_fake_sections \
|
elf64_sparc_fake_sections
|
elf64_sparc_fake_sections
|
#define elf_backend_size_info \
|
#define elf_backend_size_info \
|
elf64_sparc_size_info
|
elf64_sparc_size_info
|
|
|
#define elf_backend_plt_sym_val \
|
#define elf_backend_plt_sym_val \
|
_bfd_sparc_elf_plt_sym_val
|
_bfd_sparc_elf_plt_sym_val
|
#define bfd_elf64_bfd_link_hash_table_create \
|
#define bfd_elf64_bfd_link_hash_table_create \
|
_bfd_sparc_elf_link_hash_table_create
|
_bfd_sparc_elf_link_hash_table_create
|
#define elf_info_to_howto \
|
#define elf_info_to_howto \
|
_bfd_sparc_elf_info_to_howto
|
_bfd_sparc_elf_info_to_howto
|
#define elf_backend_copy_indirect_symbol \
|
#define elf_backend_copy_indirect_symbol \
|
_bfd_sparc_elf_copy_indirect_symbol
|
_bfd_sparc_elf_copy_indirect_symbol
|
#define bfd_elf64_bfd_reloc_type_lookup \
|
#define bfd_elf64_bfd_reloc_type_lookup \
|
_bfd_sparc_elf_reloc_type_lookup
|
_bfd_sparc_elf_reloc_type_lookup
|
#define bfd_elf64_bfd_reloc_name_lookup \
|
#define bfd_elf64_bfd_reloc_name_lookup \
|
_bfd_sparc_elf_reloc_name_lookup
|
_bfd_sparc_elf_reloc_name_lookup
|
#define bfd_elf64_bfd_relax_section \
|
#define bfd_elf64_bfd_relax_section \
|
_bfd_sparc_elf_relax_section
|
_bfd_sparc_elf_relax_section
|
#define bfd_elf64_new_section_hook \
|
#define bfd_elf64_new_section_hook \
|
_bfd_sparc_elf_new_section_hook
|
_bfd_sparc_elf_new_section_hook
|
|
|
#define elf_backend_create_dynamic_sections \
|
#define elf_backend_create_dynamic_sections \
|
_bfd_sparc_elf_create_dynamic_sections
|
_bfd_sparc_elf_create_dynamic_sections
|
#define elf_backend_relocs_compatible \
|
#define elf_backend_relocs_compatible \
|
_bfd_elf_relocs_compatible
|
_bfd_elf_relocs_compatible
|
#define elf_backend_check_relocs \
|
#define elf_backend_check_relocs \
|
_bfd_sparc_elf_check_relocs
|
_bfd_sparc_elf_check_relocs
|
#define elf_backend_adjust_dynamic_symbol \
|
#define elf_backend_adjust_dynamic_symbol \
|
_bfd_sparc_elf_adjust_dynamic_symbol
|
_bfd_sparc_elf_adjust_dynamic_symbol
|
#define elf_backend_omit_section_dynsym \
|
#define elf_backend_omit_section_dynsym \
|
_bfd_sparc_elf_omit_section_dynsym
|
_bfd_sparc_elf_omit_section_dynsym
|
#define elf_backend_size_dynamic_sections \
|
#define elf_backend_size_dynamic_sections \
|
_bfd_sparc_elf_size_dynamic_sections
|
_bfd_sparc_elf_size_dynamic_sections
|
#define elf_backend_relocate_section \
|
#define elf_backend_relocate_section \
|
_bfd_sparc_elf_relocate_section
|
_bfd_sparc_elf_relocate_section
|
#define elf_backend_finish_dynamic_symbol \
|
#define elf_backend_finish_dynamic_symbol \
|
_bfd_sparc_elf_finish_dynamic_symbol
|
_bfd_sparc_elf_finish_dynamic_symbol
|
#define elf_backend_finish_dynamic_sections \
|
#define elf_backend_finish_dynamic_sections \
|
_bfd_sparc_elf_finish_dynamic_sections
|
_bfd_sparc_elf_finish_dynamic_sections
|
|
|
#define bfd_elf64_mkobject \
|
#define bfd_elf64_mkobject \
|
_bfd_sparc_elf_mkobject
|
_bfd_sparc_elf_mkobject
|
#define elf_backend_object_p \
|
#define elf_backend_object_p \
|
_bfd_sparc_elf_object_p
|
_bfd_sparc_elf_object_p
|
#define elf_backend_gc_mark_hook \
|
#define elf_backend_gc_mark_hook \
|
_bfd_sparc_elf_gc_mark_hook
|
_bfd_sparc_elf_gc_mark_hook
|
#define elf_backend_gc_sweep_hook \
|
#define elf_backend_gc_sweep_hook \
|
_bfd_sparc_elf_gc_sweep_hook
|
_bfd_sparc_elf_gc_sweep_hook
|
#define elf_backend_init_index_section \
|
#define elf_backend_init_index_section \
|
_bfd_elf_init_1_index_section
|
_bfd_elf_init_1_index_section
|
|
|
#define elf_backend_can_gc_sections 1
|
#define elf_backend_can_gc_sections 1
|
#define elf_backend_can_refcount 1
|
#define elf_backend_can_refcount 1
|
#define elf_backend_want_got_plt 0
|
#define elf_backend_want_got_plt 0
|
#define elf_backend_plt_readonly 0
|
#define elf_backend_plt_readonly 0
|
#define elf_backend_want_plt_sym 1
|
#define elf_backend_want_plt_sym 1
|
#define elf_backend_got_header_size 8
|
#define elf_backend_got_header_size 8
|
#define elf_backend_rela_normal 1
|
#define elf_backend_rela_normal 1
|
|
|
/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
|
/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
|
#define elf_backend_plt_alignment 8
|
#define elf_backend_plt_alignment 8
|
|
|
#include "elf64-target.h"
|
#include "elf64-target.h"
|
|
|
/* FreeBSD support */
|
/* FreeBSD support */
|
#undef TARGET_BIG_SYM
|
#undef TARGET_BIG_SYM
|
#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec
|
#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec
|
#undef TARGET_BIG_NAME
|
#undef TARGET_BIG_NAME
|
#define TARGET_BIG_NAME "elf64-sparc-freebsd"
|
#define TARGET_BIG_NAME "elf64-sparc-freebsd"
|
#undef ELF_OSABI
|
#undef ELF_OSABI
|
#define ELF_OSABI ELFOSABI_FREEBSD
|
#define ELF_OSABI ELFOSABI_FREEBSD
|
|
|
#undef elf_backend_post_process_headers
|
#undef elf_backend_post_process_headers
|
#define elf_backend_post_process_headers _bfd_elf_set_osabi
|
#define elf_backend_post_process_headers _bfd_elf_set_osabi
|
#undef elf64_bed
|
#undef elf64_bed
|
#define elf64_bed elf64_sparc_fbsd_bed
|
#define elf64_bed elf64_sparc_fbsd_bed
|
|
|
#include "elf64-target.h"
|
#include "elf64-target.h"
|
|
|
|
|
