#define SH64_ELF
#include "bfd.h"
#include "sysdep.h"
#include "elf-bfd.h"
#include "../opcodes/sh64-opc.h"
#include "elf32-sh64.h"
#define DATALABEL_SUFFIX " DL"
struct sh64_find_section_vma_data
{
asection *section;
bfd_vma addr;
};
static bfd_boolean sh64_elf_new_section_hook
(bfd *, asection *);
static bfd_boolean sh64_elf_copy_private_data
(bfd *, bfd *);
static bfd_boolean sh64_elf_merge_private_data
(bfd *, bfd *);
static bfd_boolean sh64_elf_fake_sections
(bfd *, Elf_Internal_Shdr *, asection *);
static bfd_boolean sh64_elf_set_private_flags
(bfd *, flagword);
static bfd_boolean sh64_elf_set_mach_from_flags
(bfd *);
static bfd_boolean shmedia_prepare_reloc
(struct bfd_link_info *, bfd *, asection *, bfd_byte *,
const Elf_Internal_Rela *, bfd_vma *);
static int sh64_elf_get_symbol_type
(Elf_Internal_Sym *, int);
static bfd_boolean sh64_elf_add_symbol_hook
(bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
flagword *, asection **, bfd_vma *);
static bfd_boolean sh64_elf_link_output_symbol_hook
(struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
struct elf_link_hash_entry *);
static bfd_boolean sh64_backend_section_from_shdr
(bfd *, Elf_Internal_Shdr *, const char *, int);
static void sh64_elf_final_write_processing
(bfd *, bfd_boolean);
static bfd_boolean sh64_bfd_elf_copy_private_section_data
(bfd *, asection *, bfd *, asection *);
static void sh64_find_section_for_address
(bfd *, asection *, void *);
#define sh_elf_copy_private_data sh64_elf_copy_private_data
#define sh_elf_merge_private_data sh64_elf_merge_private_data
#define sh_elf_set_private_flags sh64_elf_set_private_flags
#define bfd_elf32_bfd_set_private_flags sh64_elf_set_private_flags
#define sh_elf_set_mach_from_flags sh64_elf_set_mach_from_flags
#define elf_backend_sign_extend_vma 1
#define elf_backend_fake_sections sh64_elf_fake_sections
#define elf_backend_get_symbol_type sh64_elf_get_symbol_type
#define elf_backend_add_symbol_hook sh64_elf_add_symbol_hook
#define elf_backend_link_output_symbol_hook \
sh64_elf_link_output_symbol_hook
#define elf_backend_merge_symbol_attribute sh64_elf_merge_symbol_attribute
#define elf_backend_final_write_processing sh64_elf_final_write_processing
#define elf_backend_section_from_shdr sh64_backend_section_from_shdr
#define elf_backend_special_sections sh64_elf_special_sections
#define elf_backend_section_flags sh64_elf_section_flags
#define bfd_elf32_new_section_hook sh64_elf_new_section_hook
#define bfd_elf32_bfd_copy_private_section_data \
sh64_bfd_elf_copy_private_section_data
#define _bfd_sh_align_load_span(a,b,c,d,e,f,g,h,i,j) TRUE
#define GOT_BIAS (-((long)-32768))
#define INCLUDE_SHMEDIA
#define SH_TARGET_ALREADY_DEFINED
#include "elf32-sh.c"
static bfd_boolean
sh64_elf_new_section_hook (bfd *abfd, asection *sec)
{
if (!sec->used_by_bfd)
{
struct _sh64_elf_section_data *sdata;
bfd_size_type amt = sizeof (*sdata);
sdata = bfd_zalloc (abfd, amt);
if (sdata == NULL)
return FALSE;
sec->used_by_bfd = sdata;
}
return _bfd_elf_new_section_hook (abfd, sec);
}
bfd_boolean
sh64_elf_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
Elf_Internal_Shdr *elf_section_hdr,
asection *asect)
{
if (sh64_elf_section_data (asect)->sh64_info != NULL)
elf_section_hdr->sh_flags
|= sh64_elf_section_data (asect)->sh64_info->contents_flags;
if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0
&& strcmp (bfd_get_section_name (output_bfd, asect),
SH64_CRANGES_SECTION_NAME) == 0)
elf_section_hdr->sh_type = SHT_SH5_CR_SORTED;
return TRUE;
}
static bfd_boolean
sh64_elf_set_mach_from_flags (bfd *abfd)
{
flagword flags = elf_elfheader (abfd)->e_flags;
switch (flags & EF_SH_MACH_MASK)
{
case EF_SH5:
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
break;
default:
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
return TRUE;
}
static bfd_boolean
sh64_elf_section_flags (flagword *flags,
const Elf_Internal_Shdr *hdr)
{
if (hdr->bfd_section == NULL)
return FALSE;
if (strcmp (hdr->bfd_section->name, SH64_CRANGES_SECTION_NAME) == 0)
*flags |= SEC_DEBUGGING;
return TRUE;
}
static bfd_boolean
sh64_elf_copy_private_data (bfd * ibfd, bfd * obfd)
{
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return TRUE;
BFD_ASSERT (!elf_flags_init (obfd)
|| (elf_elfheader (obfd)->e_flags
== elf_elfheader (ibfd)->e_flags));
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
return TRUE;
}
static bfd_boolean
sh64_elf_merge_private_data (bfd *ibfd, bfd *obfd)
{
flagword old_flags, new_flags;
if (! _bfd_generic_verify_endian_match (ibfd, obfd))
return FALSE;
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return TRUE;
if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
{
const char *msg;
if (bfd_get_arch_size (ibfd) == 32
&& bfd_get_arch_size (obfd) == 64)
msg = _("%s: compiled as 32-bit object and %s is 64-bit");
else if (bfd_get_arch_size (ibfd) == 64
&& bfd_get_arch_size (obfd) == 32)
msg = _("%s: compiled as 64-bit object and %s is 32-bit");
else
msg = _("%s: object size does not match that of target %s");
(*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
old_flags = elf_elfheader (obfd)->e_flags;
new_flags = elf_elfheader (ibfd)->e_flags;
if (! elf_flags_init (obfd))
{
elf_flags_init (obfd) = TRUE;
elf_elfheader (obfd)->e_flags = old_flags = new_flags;
}
else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
{
(*_bfd_error_handler)
("%s: uses non-SH64 instructions while previous modules use SH64 instructions",
bfd_get_filename (ibfd));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
elf_elfheader (obfd)->e_flags = old_flags;
return sh64_elf_set_mach_from_flags (obfd);
}
bfd_boolean
sh64_backend_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
const char *name, int shindex)
{
flagword flags = 0;
switch (hdr->sh_type)
{
case SHT_SH5_CR_SORTED:
if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0)
return FALSE;
flags = SEC_DEBUGGING | SEC_SORT_ENTRIES;
break;
default:
return FALSE;
}
if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
return FALSE;
if (flags
&& ! bfd_set_section_flags (abfd, hdr->bfd_section,
bfd_get_section_flags (abfd,
hdr->bfd_section)
| flags))
return FALSE;
return TRUE;
}
bfd_boolean
sh64_bfd_elf_copy_private_section_data (bfd *ibfd, asection *isec,
bfd *obfd, asection *osec)
{
struct sh64_section_data *sh64_sec_data;
if (ibfd->xvec->flavour != bfd_target_elf_flavour
|| obfd->xvec->flavour != bfd_target_elf_flavour)
return TRUE;
if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec))
return FALSE;
sh64_sec_data = sh64_elf_section_data (isec)->sh64_info;
if (sh64_sec_data == NULL)
{
sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data));
if (sh64_sec_data == NULL)
return FALSE;
sh64_sec_data->contents_flags
= (elf_section_data (isec)->this_hdr.sh_flags
& (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
}
return TRUE;
}
static bfd_boolean
sh64_elf_set_private_flags (bfd *abfd, flagword flags)
{
BFD_ASSERT (! elf_flags_init (abfd)
|| elf_elfheader (abfd)->e_flags == flags);
elf_elfheader (abfd)->e_flags = flags;
elf_flags_init (abfd) = TRUE;
return sh64_elf_set_mach_from_flags (abfd);
}
static int
sh64_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
{
if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
return STT_DATALABEL;
return type;
}
static bfd_boolean
sh64_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
Elf_Internal_Sym *sym, const char **namep,
flagword *flagsp ATTRIBUTE_UNUSED,
asection **secp, bfd_vma *valp)
{
if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
&& is_elf_hash_table (info->hash))
{
struct elf_link_hash_entry *h;
flagword flags
= info->relocatable || info->emitrelocations
? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
char *dl_name
= bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
BFD_ASSERT (sym_hash != NULL);
if (dl_name == NULL)
return FALSE;
strcpy (dl_name, *namep);
strcat (dl_name, DATALABEL_SUFFIX);
h = (struct elf_link_hash_entry *)
bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
if (h == NULL)
{
struct bfd_link_hash_entry *bh = NULL;
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
flags, *secp, *valp,
*namep, FALSE,
bed->collect, &bh))
{
free (dl_name);
return FALSE;
}
h = (struct elf_link_hash_entry *) bh;
h->non_elf = 0;
h->type = STT_DATALABEL;
}
else
free (dl_name);
if (h->type != STT_DATALABEL
|| ((info->relocatable || info->emitrelocations)
&& h->root.type != bfd_link_hash_undefined)
|| (! info->relocatable && !info->emitrelocations
&& h->root.type != bfd_link_hash_indirect))
{
(*_bfd_error_handler)
(_("%s: encountered datalabel symbol in input"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
while (*sym_hash != NULL)
sym_hash++;
*sym_hash = h;
*namep = NULL;
}
return TRUE;
}
bfd_boolean
sh64_elf_link_output_symbol_hook (struct bfd_link_info *info,
const char *cname,
Elf_Internal_Sym *sym,
asection *input_sec ATTRIBUTE_UNUSED,
struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
{
char *name = (char *) cname;
if (info->relocatable || info->emitrelocations)
{
if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
}
return TRUE;
}
static bfd_boolean
shmedia_prepare_reloc (struct bfd_link_info *info, bfd *abfd,
asection *input_section, bfd_byte *contents,
const Elf_Internal_Rela *rel, bfd_vma *relocation)
{
bfd_vma disp, dropped;
switch (ELF32_R_TYPE (rel->r_info))
{
case R_SH_PT_16:
{
char *msg = NULL;
bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset);
if (insn & (1 << 10))
{
if ((insn & SHMEDIA_PTB_BIT) != 0
&& ((*relocation + rel->r_addend) & 1) != 0)
msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)");
else if ((insn & SHMEDIA_PTB_BIT) == 0
&& ((*relocation + rel->r_addend) & 1) == 0)
msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)");
if (msg != NULL
&& ! ((*info->callbacks->reloc_dangerous)
(info, msg, abfd, input_section,
rel->r_offset)))
return FALSE;
}
else
{
if ((insn & SHMEDIA_PTB_BIT) != 0)
{
(*_bfd_error_handler)
(_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
bfd_get_filename (input_section->owner));
return FALSE;
}
if (((*relocation + rel->r_addend) & 1) == 0)
bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT,
contents + rel->r_offset);
}
}
case R_SH_SHMEDIA_CODE:
case R_SH_DIR5U:
case R_SH_DIR6S:
case R_SH_DIR6U:
case R_SH_DIR10S:
case R_SH_DIR10SW:
case R_SH_DIR10SL:
case R_SH_DIR10SQ:
case R_SH_IMMS16:
case R_SH_IMMU16:
case R_SH_IMM_LOW16:
case R_SH_IMM_LOW16_PCREL:
case R_SH_IMM_MEDLOW16:
case R_SH_IMM_MEDLOW16_PCREL:
case R_SH_IMM_MEDHI16:
case R_SH_IMM_MEDHI16_PCREL:
case R_SH_IMM_HI16:
case R_SH_IMM_HI16_PCREL:
case R_SH_64:
case R_SH_64_PCREL:
break;
default:
return FALSE;
}
disp = (*relocation & 0xf);
dropped = 0;
switch (ELF32_R_TYPE (rel->r_info))
{
case R_SH_DIR10SW: dropped = disp & 1; break;
case R_SH_DIR10SL: dropped = disp & 3; break;
case R_SH_DIR10SQ: dropped = disp & 7; break;
}
if (dropped != 0)
{
(*_bfd_error_handler)
(_("%B: error: unaligned relocation type %d at %08x reloc %p\n"),
input_section->owner, ELF32_R_TYPE (rel->r_info),
(unsigned) rel->r_offset, relocation);
return FALSE;
}
return TRUE;
}
static void
sh64_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED,
asection *section, void *data)
{
bfd_vma vma;
bfd_size_type size;
struct sh64_find_section_vma_data *fsec_datap
= (struct sh64_find_section_vma_data *) data;
if (fsec_datap->section)
return;
if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
return;
vma = bfd_get_section_vma (abfd, section);
if (fsec_datap->addr < vma)
return;
size = section->size;
if (fsec_datap->addr >= vma + size)
return;
fsec_datap->section = section;
}
static void
sh64_elf_final_write_processing (bfd *abfd,
bfd_boolean linker ATTRIBUTE_UNUSED)
{
bfd_vma ld_generated_cranges_size;
asection *cranges
= bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);
if (linker
&& cranges != NULL
&& elf_elfheader (abfd)->e_type != ET_EXEC
&& (ld_generated_cranges_size
= sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0)
{
bfd_vma incoming_cranges_size
= cranges->size - ld_generated_cranges_size;
if (! bfd_set_section_contents (abfd, cranges,
cranges->contents
+ incoming_cranges_size,
cranges->output_offset
+ incoming_cranges_size,
ld_generated_cranges_size))
{
bfd_set_error (bfd_error_file_truncated);
(*_bfd_error_handler)
(_("%s: could not write out added .cranges entries"),
bfd_get_filename (abfd));
}
}
if (linker && elf_elfheader (abfd)->e_type == ET_EXEC)
{
struct sh64_find_section_vma_data fsec_data;
sh64_elf_crange dummy;
fsec_data.addr = elf_elfheader (abfd)->e_entry;
fsec_data.section = NULL;
bfd_map_over_sections (abfd, sh64_find_section_for_address,
&fsec_data);
if (fsec_data.section
&& (sh64_get_contents_type (fsec_data.section,
elf_elfheader (abfd)->e_entry,
&dummy) == CRT_SH5_ISA32))
elf_elfheader (abfd)->e_entry |= 1;
if (cranges != NULL)
{
bfd_size_type cranges_size = cranges->size;
BFD_ASSERT (cranges->contents != NULL);
if (elf_section_data (cranges)->this_hdr.sh_type
!= SHT_SH5_CR_SORTED)
{
qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE,
SH64_CRANGE_SIZE,
bfd_big_endian (cranges->owner)
? _bfd_sh64_crange_qsort_cmpb
: _bfd_sh64_crange_qsort_cmpl);
elf_section_data (cranges)->this_hdr.sh_type
= SHT_SH5_CR_SORTED;
}
if (! bfd_set_section_contents (abfd, cranges,
cranges->contents,
cranges->output_offset,
cranges_size))
{
bfd_set_error (bfd_error_file_truncated);
(*_bfd_error_handler)
(_("%s: could not write out sorted .cranges entries"),
bfd_get_filename (abfd));
}
}
}
}
static void
sh64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
const Elf_Internal_Sym *isym,
bfd_boolean definition,
bfd_boolean dynamic ATTRIBUTE_UNUSED)
{
if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
{
unsigned char other;
other = (definition ? isym->st_other : h->other);
other &= ~ ELF_ST_VISIBILITY (-1);
h->other = other | ELF_ST_VISIBILITY (h->other);
}
return;
}
static const struct bfd_elf_special_section sh64_elf_special_sections[] =
{
{ STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
{ NULL, 0, 0, 0, 0 }
};
#undef TARGET_BIG_SYM
#define TARGET_BIG_SYM bfd_elf32_sh64_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-sh64"
#undef TARGET_LITTLE_SYM
#define TARGET_LITTLE_SYM bfd_elf32_sh64l_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-sh64l"
#include "elf32-target.h"
#undef TARGET_BIG_SYM
#define TARGET_BIG_SYM bfd_elf32_sh64nbsd_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-sh64-nbsd"
#undef TARGET_LITTLE_SYM
#define TARGET_LITTLE_SYM bfd_elf32_sh64lnbsd_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-sh64l-nbsd"
#undef ELF_MAXPAGESIZE
#define ELF_MAXPAGESIZE 0x10000
#undef ELF_COMMONPAGESIZE
#undef elf_symbol_leading_char
#define elf_symbol_leading_char 0
#undef elf32_bed
#define elf32_bed elf32_sh64_nbsd_bed
#include "elf32-target.h"
#undef TARGET_BIG_SYM
#define TARGET_BIG_SYM bfd_elf32_sh64blin_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-sh64big-linux"
#undef TARGET_LITTLE_SYM
#define TARGET_LITTLE_SYM bfd_elf32_sh64lin_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-sh64-linux"
#undef elf32_bed
#define elf32_bed elf32_sh64_lin_bed
#undef ELF_COMMONPAGESIZE
#define ELF_COMMONPAGESIZE 0x1000
#include "elf32-target.h"