#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/frv.h"
#include "elf/dwarf2.h"
#include "hashtab.h"
static bfd_reloc_status_type elf32_frv_relocate_lo16
PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_hi16
PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_label24
PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_gprel12
PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_gprelu12
PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_gprello
PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
bfd_byte *, bfd_vma));
static bfd_reloc_status_type elf32_frv_relocate_gprelhi
PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
bfd_byte *, bfd_vma));
static reloc_howto_type *frv_reloc_type_lookup
PARAMS ((bfd *, bfd_reloc_code_real_type));
static void frv_info_to_howto_rela
PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
static bfd_boolean elf32_frv_relocate_section
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
static bfd_boolean elf32_frv_add_symbol_hook
PARAMS (( bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
const char **, flagword *, asection **, bfd_vma *));
static bfd_reloc_status_type frv_final_link_relocate
PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
Elf_Internal_Rela *, bfd_vma));
static bfd_boolean elf32_frv_gc_sweep_hook
PARAMS ((bfd *, struct bfd_link_info *, asection *, const
Elf_Internal_Rela *));
static asection * elf32_frv_gc_mark_hook
PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
struct elf_link_hash_entry *, Elf_Internal_Sym *));
static bfd_boolean elf32_frv_check_relocs
PARAMS ((bfd *, struct bfd_link_info *, asection *,
const Elf_Internal_Rela *));
static int elf32_frv_machine
PARAMS ((bfd *));
static bfd_boolean elf32_frv_object_p
PARAMS ((bfd *));
static bfd_boolean frv_elf_set_private_flags
PARAMS ((bfd *, flagword));
static bfd_boolean frv_elf_copy_private_bfd_data
PARAMS ((bfd *, bfd *));
static bfd_boolean frv_elf_merge_private_bfd_data
PARAMS ((bfd *, bfd *));
static bfd_boolean frv_elf_print_private_bfd_data
PARAMS ((bfd *, PTR));
static reloc_howto_type elf32_frv_howto_table [] =
{
HOWTO (R_FRV_NONE,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_NONE",
FALSE,
0,
0,
FALSE),
HOWTO (R_FRV_32,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_32",
FALSE,
0xffffffff,
0xffffffff,
FALSE),
HOWTO (R_FRV_LABEL16,
2,
2,
16,
TRUE,
0,
complain_overflow_signed,
bfd_elf_generic_reloc,
"R_FRV_LABEL16",
FALSE,
0xffff,
0xffff,
TRUE),
HOWTO (R_FRV_LABEL24,
2,
2,
26,
TRUE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_LABEL24",
FALSE,
0x7e03ffff,
0x7e03ffff,
TRUE),
HOWTO (R_FRV_LO16,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_LO16",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_HI16,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_HI16",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GPREL12,
0,
2,
12,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GPREL12",
FALSE,
0xfff,
0xfff,
FALSE),
HOWTO (R_FRV_GPRELU12,
0,
2,
12,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GPRELU12",
FALSE,
0xfff,
0x3f03f,
FALSE),
HOWTO (R_FRV_GPREL32,
0,
2,
32,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GPREL32",
FALSE,
0xffffffff,
0xffffffff,
FALSE),
HOWTO (R_FRV_GPRELHI,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GPRELHI",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GPRELLO,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GPRELLO",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GOT12,
0,
2,
12,
FALSE,
0,
complain_overflow_signed,
bfd_elf_generic_reloc,
"R_FRV_GOT12",
FALSE,
0xfff,
0xfff,
FALSE),
HOWTO (R_FRV_GOTHI,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GOTHI",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GOTLO,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GOTLO",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_FUNCDESC,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC",
FALSE,
0xffffffff,
0xffffffff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOT12,
0,
2,
12,
FALSE,
0,
complain_overflow_signed,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOT12",
FALSE,
0xfff,
0xfff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOTHI,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOTHI",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOTLO,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOTLO",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_FUNCDESC_VALUE,
0,
2,
64,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_VALUE",
FALSE,
0xffffffff,
0xffffffff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOTOFF12,
0,
2,
12,
FALSE,
0,
complain_overflow_signed,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOTOFF12",
FALSE,
0xfff,
0xfff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOTOFFHI,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOTOFFHI",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_FUNCDESC_GOTOFFLO,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_GOTOFFLO",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GOTOFF12,
0,
2,
12,
FALSE,
0,
complain_overflow_signed,
bfd_elf_generic_reloc,
"R_FRV_GOTOFF12",
FALSE,
0xfff,
0xfff,
FALSE),
HOWTO (R_FRV_GOTOFFHI,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GOTOFFHI",
FALSE,
0xffff,
0xffff,
FALSE),
HOWTO (R_FRV_GOTOFFLO,
0,
2,
16,
FALSE,
0,
complain_overflow_dont,
bfd_elf_generic_reloc,
"R_FRV_GOTOFFLO",
FALSE,
0xffff,
0xffff,
FALSE),
};
static reloc_howto_type elf32_frv_vtinherit_howto =
HOWTO (R_FRV_GNU_VTINHERIT,
0,
2,
0,
FALSE,
0,
complain_overflow_dont,
NULL,
"R_FRV_GNU_VTINHERIT",
FALSE,
0,
0,
FALSE);
static reloc_howto_type elf32_frv_vtentry_howto =
HOWTO (R_FRV_GNU_VTENTRY,
0,
2,
0,
FALSE,
0,
complain_overflow_dont,
_bfd_elf_rel_vtable_reloc_fn,
"R_FRV_GNU_VTENTRY",
FALSE,
0,
0,
FALSE);
static reloc_howto_type elf32_frv_rel_32_howto =
HOWTO (R_FRV_32,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_32",
TRUE,
0xffffffff,
0xffffffff,
FALSE);
static reloc_howto_type elf32_frv_rel_funcdesc_howto =
HOWTO (R_FRV_FUNCDESC,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC",
TRUE,
0xffffffff,
0xffffffff,
FALSE);
static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
HOWTO (R_FRV_FUNCDESC_VALUE,
0,
2,
64,
FALSE,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_FRV_FUNCDESC_VALUE",
TRUE,
0xffffffff,
0xffffffff,
FALSE);
#if 0
struct frv_reloc_map
{
unsigned int bfd_reloc_val;
unsigned int frv_reloc_val;
};
static const struct frv_reloc_map frv_reloc_map [] =
{
{ BFD_RELOC_NONE, R_FRV_NONE },
{ BFD_RELOC_32, R_FRV_32 },
{ BFD_RELOC_FRV_LABEL16, R_FRV_LABEL16 },
{ BFD_RELOC_FRV_LABEL24, R_FRV_LABEL24 },
{ BFD_RELOC_FRV_LO16, R_FRV_LO16 },
{ BFD_RELOC_FRV_HI16, R_FRV_HI16 },
{ BFD_RELOC_FRV_GPREL12, R_FRV_GPREL12 },
{ BFD_RELOC_FRV_GPRELU12, R_FRV_GPRELU12 },
{ BFD_RELOC_FRV_GPREL32, R_FRV_GPREL32 },
{ BFD_RELOC_FRV_GPRELHI, R_FRV_GPRELHI },
{ BFD_RELOC_FRV_GPRELLO, R_FRV_GPRELLO },
{ BFD_RELOC_FRV_GOT12, R_FRV_GOT12 },
{ BFD_RELOC_FRV_GOTHI, R_FRV_GOTHI },
{ BFD_RELOC_FRV_GOTLO, R_FRV_GOTLO },
{ BFD_RELOC_FRV_FUNCDESC, R_FRV_FUNCDESC },
{ BFD_RELOC_FRV_FUNCDESC_GOT12, R_FRV_FUNCDESC_GOT12 },
{ BFD_RELOC_FRV_FUNCDESC_GOTHI, R_FRV_FUNCDESC_GOTHI },
{ BFD_RELOC_FRV_FUNCDESC_GOTLO, R_FRV_FUNCDESC_GOTLO },
{ BFD_RELOC_FRV_FUNCDESC_VALUE, R_FRV_FUNCDESC_VALUE },
{ BFD_RELOC_FRV_FUNCDESC_GOTOFF12, R_FRV_FUNCDESC_GOTOFF12 },
{ BFD_RELOC_FRV_FUNCDESC_GOTOFFHI, R_FRV_FUNCDESC_GOTOFFHI },
{ BFD_RELOC_FRV_FUNCDESC_GOTOFFLO, R_FRV_FUNCDESC_GOTOFFLO },
{ BFD_RELOC_FRV_GOTOFF12, R_FRV_GOTOFF12 },
{ BFD_RELOC_FRV_GOTOFFHI, R_FRV_GOTOFFHI },
{ BFD_RELOC_FRV_GOTOFFLO, R_FRV_GOTOFFLO },
{ BFD_RELOC_VTABLE_INHERIT, R_FRV_GNU_VTINHERIT },
{ BFD_RELOC_VTABLE_ENTRY, R_FRV_GNU_VTENTRY },
};
#endif
struct frv_elf_link_hash_table
{
struct elf_link_hash_table elf;
asection *sgot;
asection *sgotrel;
asection *sgotfixup;
asection *splt;
asection *spltrel;
bfd_vma got0;
bfd_vma plt0;
struct htab *relocs_info;
};
#define frv_hash_table(info) \
((struct frv_elf_link_hash_table *) ((info)->hash))
#define frv_got_section(info) \
(frv_hash_table (info)->sgot)
#define frv_gotrel_section(info) \
(frv_hash_table (info)->sgotrel)
#define frv_gotfixup_section(info) \
(frv_hash_table (info)->sgotfixup)
#define frv_plt_section(info) \
(frv_hash_table (info)->splt)
#define frv_pltrel_section(info) \
(frv_hash_table (info)->spltrel)
#define frv_relocs_info(info) \
(frv_hash_table (info)->relocs_info)
#define frv_got_initial_offset(info) \
(frv_hash_table (info)->got0)
#define frv_plt_initial_offset(info) \
(frv_hash_table (info)->plt0)
static struct bfd_link_hash_table *
frv_elf_link_hash_table_create (bfd *abfd)
{
struct frv_elf_link_hash_table *ret;
bfd_size_type amt = sizeof (struct frv_elf_link_hash_table);
ret = bfd_zalloc (abfd, amt);
if (ret == NULL)
return NULL;
if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
_bfd_elf_link_hash_newfunc))
{
free (ret);
return NULL;
}
return &ret->elf.root;
}
#define FRV_SYM_LOCAL(INFO, H) \
(_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
|| ! elf_hash_table (INFO)->dynamic_sections_created \
|| ( \
((H)->root.type == bfd_link_hash_defined \
|| (H)->root.type == bfd_link_hash_defweak) \
&& (H)->root.u.def.section->output_section \
&& ((H)->root.u.def.section->flags & SEC_LINKER_CREATED)))
#define FRV_FUNCDESC_LOCAL(INFO, H) \
((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
struct frv_pic_relocs_info
{
long symndx;
union
{
bfd *abfd;
struct elf_link_hash_entry *h;
} d;
bfd_vma addend;
unsigned got12:1;
unsigned gotlos:1;
unsigned gothilo:1;
unsigned fd:1;
unsigned fdgot12:1;
unsigned fdgotlos:1;
unsigned fdgothilo:1;
unsigned fdgoff12:1;
unsigned fdgofflos:1;
unsigned fdgoffhilo:1;
unsigned gotoff:1;
unsigned call:1;
unsigned sym:1;
unsigned plt:1;
unsigned privfd:1;
unsigned lazyplt:1;
unsigned done:1;
unsigned relocs32, relocsfd, relocsfdv;
unsigned fixups, dynrelocs;
bfd_signed_vma got_entry, fdgot_entry, fd_entry;
bfd_vma plt_entry, lzplt_entry;
};
static hashval_t
frv_pic_relocs_info_hash (const void *entry_)
{
const struct frv_pic_relocs_info *entry = entry_;
return (entry->symndx == -1
? entry->d.h->root.root.hash
: entry->symndx + entry->d.abfd->id * 257) + entry->addend;
}
static int
frv_pic_relocs_info_eq (const void *entry1, const void *entry2)
{
const struct frv_pic_relocs_info *e1 = entry1;
const struct frv_pic_relocs_info *e2 = entry2;
return e1->symndx == e2->symndx && e1->addend == e2->addend
&& (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
}
static struct frv_pic_relocs_info *
frv_pic_relocs_info_find (struct htab *ht,
bfd *abfd,
const struct frv_pic_relocs_info *entry,
enum insert_option insert)
{
struct frv_pic_relocs_info **loc =
(struct frv_pic_relocs_info **) htab_find_slot (ht, entry, insert);
if (! loc)
return NULL;
if (*loc)
return *loc;
*loc = bfd_zalloc (abfd, sizeof (**loc));
if (! *loc)
return *loc;
(*loc)->symndx = entry->symndx;
(*loc)->d = entry->d;
(*loc)->addend = entry->addend;
(*loc)->plt_entry = (bfd_vma)-1;
(*loc)->lzplt_entry = (bfd_vma)-1;
return *loc;
}
inline static struct frv_pic_relocs_info *
frv_pic_relocs_info_for_global (struct htab *ht,
bfd *abfd,
struct elf_link_hash_entry *h,
bfd_vma addend,
enum insert_option insert)
{
struct frv_pic_relocs_info entry;
entry.symndx = -1;
entry.d.h = h;
entry.addend = addend;
return frv_pic_relocs_info_find (ht, abfd, &entry, insert);
}
inline static struct frv_pic_relocs_info *
frv_pic_relocs_info_for_local (struct htab *ht,
bfd *abfd,
long symndx,
bfd_vma addend,
enum insert_option insert)
{
struct frv_pic_relocs_info entry;
entry.symndx = symndx;
entry.d.abfd = abfd;
entry.addend = addend;
return frv_pic_relocs_info_find (ht, abfd, &entry, insert);
}
inline static void
frv_pic_merge_early_relocs_info (struct frv_pic_relocs_info *e2,
struct frv_pic_relocs_info const *e1)
{
e2->got12 |= e1->got12;
e2->gotlos |= e1->gotlos;
e2->gothilo |= e1->gothilo;
e2->fd |= e1->fd;
e2->fdgot12 |= e1->fdgot12;
e2->fdgotlos |= e1->fdgotlos;
e2->fdgothilo |= e1->fdgothilo;
e2->fdgoff12 |= e1->fdgoff12;
e2->fdgofflos |= e1->fdgofflos;
e2->fdgoffhilo |= e1->fdgoffhilo;
e2->gotoff |= e1->gotoff;
e2->call |= e1->call;
e2->sym |= e1->sym;
#if 0
e2->plt |= e1->plt;
e2->privfd |= e1->privfd;
e2->lazyplt |= e1->lazyplt;
e2->done |= e1->done;
e2->relocs32 += e1->relocs32;
e2->relocsfd += e1->relocsfd;
e2->relocsfdv += e1->relocsfdv;
e2->fixups += e1->fixups;
e2->dynrelocs += e1->dynrelocs;
if (abs (e1->got_entry) < abs (e2->got_entry))
e2->got_entry = e1->got_entry;
if (abs (e1->fdgot_entry) < abs (e2->fdgot_entry))
e2->fdgot_entry = e1->fdgot_entry;
if (abs (e1->fd_entry) < abs (e2->fd_entry))
e2->fd_entry = e1->fd_entry;
if (e1->plt_entry < e2->plt_entry)
e2->plt_entry = e1->plt_entry;
if (e1->lzplt_entry < e2->lzplt_entry)
e2->lzplt_entry = e1->lzplt_entry;
#endif
}
#define FRV_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
#define FRV_LZPLT_RESOLV_LOC (8 * 32767)
inline static bfd_vma
_frv_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
int reloc_type, long dynindx, bfd_vma addend,
struct frv_pic_relocs_info *entry)
{
Elf_Internal_Rela outrel;
bfd_vma reloc_offset;
outrel.r_offset = offset;
outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
outrel.r_addend = addend;
reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
BFD_ASSERT (reloc_offset < sreloc->_raw_size);
bfd_elf32_swap_reloc_out (output_bfd, &outrel,
sreloc->contents + reloc_offset);
sreloc->reloc_count++;
BFD_ASSERT (entry->dynrelocs > 0);
entry->dynrelocs--;
return reloc_offset;
}
static bfd_vma
_frv_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
struct frv_pic_relocs_info *entry)
{
bfd_vma fixup_offset;
if (rofixup->flags & SEC_EXCLUDE)
return -1;
fixup_offset = rofixup->reloc_count * 4;
if (rofixup->contents)
{
BFD_ASSERT (fixup_offset < rofixup->_raw_size);
bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
}
rofixup->reloc_count++;
if (entry)
{
BFD_ASSERT (entry->fixups > 0);
entry->fixups--;
}
return fixup_offset;
}
static unsigned
_frv_osec_to_segment (bfd *output_bfd, asection *osec)
{
struct elf_segment_map *m;
Elf_Internal_Phdr *p;
for (m = elf_tdata (output_bfd)->segment_map,
p = elf_tdata (output_bfd)->phdr;
m != NULL;
m = m->next, p++)
{
int i;
for (i = m->count - 1; i >= 0; i--)
if (m->sections[i] == osec)
break;
if (i >= 0)
break;
}
return p - elf_tdata (output_bfd)->phdr;
}
inline static bfd_boolean
_frv_osec_readonly_p (bfd *output_bfd, asection *osec)
{
unsigned seg = _frv_osec_to_segment (output_bfd, osec);
return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
}
inline static bfd_boolean
_frv_emit_got_relocs_plt_entries (struct frv_pic_relocs_info *entry,
bfd *output_bfd,
struct bfd_link_info *info,
asection *sec,
Elf_Internal_Sym *sym,
bfd_vma addend)
{
bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
int dynindx = -1;
if (entry->done)
return TRUE;
entry->done = 1;
if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
{
if (entry->symndx == -1 && entry->d.h->dynindx != -1)
dynindx = entry->d.h->dynindx;
else
{
if (sec->output_section
&& ! bfd_is_abs_section (sec->output_section)
&& ! bfd_is_und_section (sec->output_section))
dynindx = elf_section_data (sec->output_section)->dynindx;
else
dynindx = 0;
}
}
if (entry->got_entry)
{
int idx = dynindx;
bfd_vma ad = addend;
if (sec && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
{
if (entry->symndx == -1)
ad += entry->d.h->root.u.def.value;
else
ad += sym->st_value;
ad += sec->output_offset;
if (sec->output_section && elf_section_data (sec->output_section))
idx = elf_section_data (sec->output_section)->dynindx;
else
idx = 0;
}
if (info->executable && !info->pie
&& (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
{
if (sec)
ad += sec->output_section->vma;
if (entry->symndx != -1
|| entry->d.h->root.type != bfd_link_hash_undefweak)
_frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info)
+ entry->got_entry, entry);
}
else
_frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
_bfd_elf_section_offset
(output_bfd, info,
frv_got_section (info),
frv_got_initial_offset (info)
+ entry->got_entry)
+ frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset,
R_FRV_32, idx, ad, entry);
bfd_put_32 (output_bfd, ad,
frv_got_section (info)->contents
+ frv_got_initial_offset (info)
+ entry->got_entry);
}
if (entry->fdgot_entry)
{
int reloc, idx;
bfd_vma ad = 0;
if (! (entry->symndx == -1
&& entry->d.h->root.type == bfd_link_hash_undefweak
&& FRV_SYM_LOCAL (info, entry->d.h)))
{
if (entry->symndx == -1 && ! FRV_FUNCDESC_LOCAL (info, entry->d.h)
&& FRV_SYM_LOCAL (info, entry->d.h)
&& !(info->executable && !info->pie))
{
reloc = R_FRV_FUNCDESC;
idx = elf_section_data (entry->d.h->root.u.def.section
->output_section)->dynindx;
ad = entry->d.h->root.u.def.section->output_offset
+ entry->d.h->root.u.def.value;
}
else if (entry->symndx == -1
&& ! FRV_FUNCDESC_LOCAL (info, entry->d.h))
{
reloc = R_FRV_FUNCDESC;
idx = dynindx;
ad = addend;
if (ad)
return FALSE;
}
else
{
if (elf_hash_table (info)->dynamic_sections_created)
BFD_ASSERT (entry->privfd);
reloc = R_FRV_32;
idx = elf_section_data (frv_got_section (info)
->output_section)->dynindx;
ad = frv_got_section (info)->output_offset
+ frv_got_initial_offset (info) + entry->fd_entry;
}
if (info->executable && !info->pie
&& (entry->symndx != -1
|| FRV_FUNCDESC_LOCAL (info, entry->d.h)))
{
ad += frv_got_section (info)->output_section->vma;
_frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info)
+ entry->fdgot_entry, entry);
}
else
_frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
_bfd_elf_section_offset
(output_bfd, info,
frv_got_section (info),
frv_got_initial_offset (info)
+ entry->fdgot_entry)
+ frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset,
reloc, idx, ad, entry);
}
bfd_put_32 (output_bfd, ad,
frv_got_section (info)->contents
+ frv_got_initial_offset (info)
+ entry->fdgot_entry);
}
if (entry->fd_entry)
{
int idx = dynindx;
bfd_vma ad = addend;
bfd_vma ofst;
long lowword, highword;
if (sec && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
{
if (entry->symndx == -1)
ad += entry->d.h->root.u.def.value;
else
ad += sym->st_value;
ad += sec->output_offset;
if (sec->output_section && elf_section_data (sec->output_section))
idx = elf_section_data (sec->output_section)->dynindx;
else
idx = 0;
}
if (info->executable && !info->pie
&& (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
{
if (sec)
ad += sec->output_section->vma;
ofst = 0;
if (entry->symndx != -1
|| entry->d.h->root.type != bfd_link_hash_undefweak)
{
_frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info)
+ entry->fd_entry, entry);
_frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info)
+ entry->fd_entry + 4, entry);
}
}
else
{
ofst =
_frv_add_dyn_reloc (output_bfd,
entry->lazyplt ? frv_pltrel_section (info)
: frv_gotrel_section (info),
_bfd_elf_section_offset
(output_bfd, info,
frv_got_section (info),
frv_got_initial_offset (info)
+ entry->fd_entry)
+ frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset,
R_FRV_FUNCDESC_VALUE, idx, ad, entry);
}
if (info->executable && !info->pie && sec && sec->output_section)
{
lowword = ad;
highword = frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info);
}
else if (entry->lazyplt)
{
if (ad)
return FALSE;
fd_lazy_rel_offset = ofst;
lowword = entry->lzplt_entry + 4
+ frv_plt_section (info)->output_offset
+ frv_plt_section (info)->output_section->vma;
highword = _frv_osec_to_segment
(output_bfd, frv_plt_section (info)->output_section);
}
else
{
lowword = ad;
if (entry->symndx == -1 && entry->d.h->dynindx != -1
&& entry->d.h->dynindx == idx)
highword = 0;
else
highword = _frv_osec_to_segment (output_bfd, sec->output_section);
}
bfd_put_32 (output_bfd, lowword,
frv_got_section (info)->contents
+ frv_got_initial_offset (info)
+ entry->fd_entry);
bfd_put_32 (output_bfd, highword,
frv_got_section (info)->contents
+ frv_got_initial_offset (info)
+ entry->fd_entry + 4);
}
if (entry->plt_entry != (bfd_vma) -1)
{
bfd_byte *plt_code = frv_plt_section (info)->contents + entry->plt_entry;
BFD_ASSERT (entry->fd_entry);
if (entry->fd_entry >= -(1 << (12 - 1))
&& entry->fd_entry < (1 << (12 - 1)))
{
bfd_put_32 (output_bfd,
0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
plt_code);
plt_code += 4;
}
else
{
if (entry->fd_entry >= -(1 << (16 - 1))
&& entry->fd_entry < (1 << (16 - 1)))
{
bfd_put_32 (output_bfd,
0x9cfc0000
| (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
plt_code);
plt_code += 4;
}
else
{
bfd_put_32 (output_bfd,
0x1cf80000
| ((entry->fd_entry >> 16)
& (((bfd_vma)1 << 16) - 1)),
plt_code);
bfd_put_32 (output_bfd,
0x9cf40000
| (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
plt_code);
plt_code += 8;
}
bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
plt_code += 4;
}
bfd_put_32 (output_bfd, 0x8030e000, plt_code);
}
if (entry->lzplt_entry != (bfd_vma) -1)
{
bfd_byte *lzplt_code = frv_plt_section (info)->contents
+ entry->lzplt_entry;
bfd_vma resolverStub_addr;
bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
lzplt_code += 4;
resolverStub_addr = entry->lzplt_entry / FRV_LZPLT_BLOCK_SIZE
* FRV_LZPLT_BLOCK_SIZE + FRV_LZPLT_RESOLV_LOC;
if (resolverStub_addr >= frv_plt_initial_offset (info))
resolverStub_addr = frv_plt_initial_offset (info) - 12;
if (entry->lzplt_entry == resolverStub_addr)
{
bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
}
else
{
bfd_put_32 (output_bfd,
0xc01a0000
| (((resolverStub_addr - entry->lzplt_entry)
/ 4) & (((bfd_vma)1 << 16) - 1)),
lzplt_code);
}
}
return TRUE;
}
static bfd_reloc_status_type
elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
contents, value)
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
Elf_Internal_Rela *relocation;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
bfd_vma gp;
struct bfd_link_hash_entry *h;
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
+ h->u.def.section->output_section->vma
+ h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
value += relocation->r_addend;
if ((long) value > 0x7ff || (long) value < -0x800)
return bfd_reloc_overflow;
bfd_put_32 (input_bfd,
(insn & 0xfffff000) | (value & 0xfff),
contents + relocation->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
contents, value)
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
Elf_Internal_Rela *relocation;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
bfd_vma gp;
struct bfd_link_hash_entry *h;
bfd_vma mask;
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
+ h->u.def.section->output_section->vma
+ h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
value += relocation->r_addend;
if ((long) value > 0x7ff || (long) value < -0x800)
return bfd_reloc_overflow;
mask = 0x3f03f;
insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
bfd *input_bfd;
Elf_Internal_Rela *relhi;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
value += relhi->r_addend;
value = ((value >> 16) & 0xffff);
insn = (insn & 0xffff0000) | value;
if ((long) value > 0xffff || (long) value < -0x10000)
return bfd_reloc_overflow;
bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
bfd *input_bfd;
Elf_Internal_Rela *rello;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
value += rello->r_addend;
value = value & 0xffff;
insn = (insn & 0xffff0000) | value;
if ((long) value > 0xffff || (long) value < -0x10000)
return bfd_reloc_overflow;
bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
bfd *input_bfd;
asection *input_section;
Elf_Internal_Rela *rello;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
bfd_vma label6;
bfd_vma label18;
insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
value -= input_section->output_section->vma + input_section->output_offset;
value -= rello->r_offset;
value += rello->r_addend;
value = value >> 2;
label6 = value & 0xfc0000;
label6 = label6 << 7;
label18 = value & 0x3ffff;
insn = insn & 0x803c0000;
insn = insn | label6;
insn = insn | label18;
bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
contents, value)
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
Elf_Internal_Rela *relocation;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
bfd_vma gp;
struct bfd_link_hash_entry *h;
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
+ h->u.def.section->output_section->vma
+ h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
value += relocation->r_addend;
value = ((value >> 16) & 0xffff);
if ((long) value > 0xffff || (long) value < -0x10000)
return bfd_reloc_overflow;
insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
insn = (insn & 0xffff0000) | value;
bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
return bfd_reloc_ok;
}
static bfd_reloc_status_type
elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
contents, value)
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
Elf_Internal_Rela *relocation;
bfd_byte *contents;
bfd_vma value;
{
bfd_vma insn;
bfd_vma gp;
struct bfd_link_hash_entry *h;
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
+ h->u.def.section->output_section->vma
+ h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
value += relocation->r_addend;
value = value & 0xffff;
if ((long) value > 0xffff || (long) value < -0x10000)
return bfd_reloc_overflow;
insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
insn = (insn & 0xffff0000) | value;
bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
return bfd_reloc_ok;
}
static reloc_howto_type *
frv_reloc_type_lookup (abfd, code)
bfd *abfd ATTRIBUTE_UNUSED;
bfd_reloc_code_real_type code;
{
switch (code)
{
default:
break;
case BFD_RELOC_NONE:
return &elf32_frv_howto_table[ (int) R_FRV_NONE];
case BFD_RELOC_32:
if (elf_elfheader (abfd)->e_type == ET_EXEC
|| elf_elfheader (abfd)->e_type == ET_DYN)
return &elf32_frv_rel_32_howto;
case BFD_RELOC_CTOR:
return &elf32_frv_howto_table[ (int) R_FRV_32];
case BFD_RELOC_FRV_LABEL16:
return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
case BFD_RELOC_FRV_LABEL24:
return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
case BFD_RELOC_FRV_LO16:
return &elf32_frv_howto_table[ (int) R_FRV_LO16];
case BFD_RELOC_FRV_HI16:
return &elf32_frv_howto_table[ (int) R_FRV_HI16];
case BFD_RELOC_FRV_GPREL12:
return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
case BFD_RELOC_FRV_GPRELU12:
return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
case BFD_RELOC_FRV_GPREL32:
return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
case BFD_RELOC_FRV_GPRELHI:
return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
case BFD_RELOC_FRV_GPRELLO:
return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
case BFD_RELOC_FRV_GOT12:
return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
case BFD_RELOC_FRV_GOTHI:
return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
case BFD_RELOC_FRV_GOTLO:
return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
case BFD_RELOC_FRV_FUNCDESC:
if (elf_elfheader (abfd)->e_type == ET_EXEC
|| elf_elfheader (abfd)->e_type == ET_DYN)
return &elf32_frv_rel_funcdesc_howto;
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
case BFD_RELOC_FRV_FUNCDESC_GOT12:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
case BFD_RELOC_FRV_FUNCDESC_GOTHI:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
case BFD_RELOC_FRV_FUNCDESC_GOTLO:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
case BFD_RELOC_FRV_FUNCDESC_VALUE:
if (elf_elfheader (abfd)->e_type == ET_EXEC
|| elf_elfheader (abfd)->e_type == ET_DYN)
return &elf32_frv_rel_funcdesc_value_howto;
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
case BFD_RELOC_FRV_GOTOFF12:
return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
case BFD_RELOC_FRV_GOTOFFHI:
return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
case BFD_RELOC_FRV_GOTOFFLO:
return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
case BFD_RELOC_VTABLE_INHERIT:
return &elf32_frv_vtinherit_howto;
case BFD_RELOC_VTABLE_ENTRY:
return &elf32_frv_vtentry_howto;
}
return NULL;
}
static void
frv_info_to_howto_rela (abfd, cache_ptr, dst)
bfd *abfd ATTRIBUTE_UNUSED;
arelent *cache_ptr;
Elf_Internal_Rela *dst;
{
unsigned int r_type;
r_type = ELF32_R_TYPE (dst->r_info);
switch (r_type)
{
case R_FRV_GNU_VTINHERIT:
cache_ptr->howto = &elf32_frv_vtinherit_howto;
break;
case R_FRV_GNU_VTENTRY:
cache_ptr->howto = &elf32_frv_vtentry_howto;
break;
default:
cache_ptr->howto = & elf32_frv_howto_table [r_type];
break;
}
}
static void
frv_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
arelent *cache_ptr, Elf_Internal_Rela *dst)
{
unsigned int r_type;
r_type = ELF32_R_TYPE (dst->r_info);
switch (r_type)
{
case R_FRV_32:
cache_ptr->howto = &elf32_frv_rel_32_howto;
break;
case R_FRV_FUNCDESC:
cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
break;
case R_FRV_FUNCDESC_VALUE:
cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
break;
default:
cache_ptr->howto = NULL;
break;
}
}
static bfd_reloc_status_type
frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
relocation)
reloc_howto_type *howto;
bfd *input_bfd;
asection *input_section;
bfd_byte *contents;
Elf_Internal_Rela *rel;
bfd_vma relocation;
{
return _bfd_final_link_relocate (howto, input_bfd, input_section,
contents, rel->r_offset, relocation,
rel->r_addend);
}
static bfd_boolean
elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
contents, relocs, local_syms, local_sections)
bfd *output_bfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
bfd_byte *contents;
Elf_Internal_Rela *relocs;
Elf_Internal_Sym *local_syms;
asection **local_sections;
{
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
unsigned isec_segment, got_segment, plt_segment, gprel_segment,
check_segment[2];
int silence_segment_error = !(info->shared || info->pie);
if (info->relocatable)
return TRUE;
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
isec_segment = _frv_osec_to_segment (output_bfd,
input_section->output_section);
if (frv_got_section (info))
got_segment = _frv_osec_to_segment (output_bfd,
frv_got_section (info)
->output_section);
else
got_segment = -1;
if (frv_gotfixup_section (info))
gprel_segment = _frv_osec_to_segment (output_bfd,
frv_gotfixup_section (info)
->output_section);
else
gprel_segment = -1;
if (elf_hash_table (info)->dynamic_sections_created)
plt_segment = _frv_osec_to_segment (output_bfd,
frv_plt_section (info)
->output_section);
else
plt_segment = -1;
for (rel = relocs; rel < relend; rel ++)
{
reloc_howto_type *howto;
unsigned long r_symndx;
Elf_Internal_Sym *sym;
asection *sec;
struct elf_link_hash_entry *h;
bfd_vma relocation;
bfd_reloc_status_type r;
const char * name = NULL;
int r_type;
asection *osec;
struct frv_pic_relocs_info *picrel;
bfd_vma orig_addend = rel->r_addend;
r_type = ELF32_R_TYPE (rel->r_info);
if ( r_type == R_FRV_GNU_VTINHERIT
|| r_type == R_FRV_GNU_VTENTRY)
continue;
r_symndx = ELF32_R_SYM (rel->r_info);
howto = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
h = NULL;
sym = NULL;
sec = NULL;
if (r_symndx < symtab_hdr->sh_info)
{
sym = local_syms + r_symndx;
osec = sec = local_sections [r_symndx];
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
name = bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name);
name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
}
else
{
h = sym_hashes [r_symndx - symtab_hdr->sh_info];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
name = h->root.root.string;
if ((h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
&& ! FRV_SYM_LOCAL (info, h))
{
sec = NULL;
relocation = 0;
}
else
if (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
{
sec = h->root.u.def.section;
relocation = (h->root.u.def.value
+ sec->output_section->vma
+ sec->output_offset);
}
else if (h->root.type == bfd_link_hash_undefweak)
{
relocation = 0;
}
else if ( ! info->executable
&& ! info->symbolic
&& info->unresolved_syms_in_objects == RM_IGNORE
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
relocation = 0;
else
{
if (! ((*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd,
input_section, rel->r_offset, TRUE)))
return FALSE;
relocation = 0;
}
osec = sec;
}
switch (r_type)
{
case R_FRV_LABEL24:
case R_FRV_32:
case R_FRV_GOT12:
case R_FRV_GOTHI:
case R_FRV_GOTLO:
case R_FRV_FUNCDESC_GOT12:
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTLO:
case R_FRV_GOTOFF12:
case R_FRV_GOTOFFHI:
case R_FRV_GOTOFFLO:
case R_FRV_FUNCDESC_GOTOFF12:
case R_FRV_FUNCDESC_GOTOFFHI:
case R_FRV_FUNCDESC_GOTOFFLO:
case R_FRV_FUNCDESC:
case R_FRV_FUNCDESC_VALUE:
if (h != NULL)
picrel = frv_pic_relocs_info_for_global (frv_relocs_info (info),
input_bfd, h,
orig_addend, INSERT);
else
picrel = frv_pic_relocs_info_for_local (frv_relocs_info (info),
input_bfd, r_symndx,
orig_addend, INSERT);
if (! picrel)
return FALSE;
if (!_frv_emit_got_relocs_plt_entries (picrel, output_bfd, info,
osec, sym, rel->r_addend))
{
info->callbacks->warning
(info, _("Dynamic relocation references symbol with nonzero addend"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
break;
default:
picrel = NULL;
if (h && ! FRV_SYM_LOCAL (info, h))
{
info->callbacks->warning
(info, _("relocation references symbol not defined in the module"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
break;
}
switch (r_type)
{
case R_FRV_LABEL24:
check_segment[0] = isec_segment;
if (picrel->plt)
{
relocation = frv_plt_section (info)->output_section->vma
+ frv_plt_section (info)->output_offset
+ picrel->plt_entry;
check_segment[1] = plt_segment;
}
else if (picrel->symndx == -1
&& picrel->d.h->root.type == bfd_link_hash_undefweak)
check_segment[1] = check_segment[0];
else
check_segment[1] = sec
? _frv_osec_to_segment (output_bfd, sec->output_section)
: (unsigned)-1;
break;
case R_FRV_GOT12:
case R_FRV_GOTHI:
case R_FRV_GOTLO:
relocation = picrel->got_entry;
check_segment[0] = check_segment[1] = got_segment;
break;
case R_FRV_FUNCDESC_GOT12:
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTLO:
relocation = picrel->fdgot_entry;
check_segment[0] = check_segment[1] = got_segment;
break;
case R_FRV_GOTOFFHI:
case R_FRV_GOTOFF12:
case R_FRV_GOTOFFLO:
relocation -= frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info);
check_segment[0] = got_segment;
check_segment[1] = sec
? _frv_osec_to_segment (output_bfd, sec->output_section)
: (unsigned)-1;
break;
case R_FRV_FUNCDESC_GOTOFF12:
case R_FRV_FUNCDESC_GOTOFFHI:
case R_FRV_FUNCDESC_GOTOFFLO:
relocation = picrel->fd_entry;
check_segment[0] = check_segment[1] = got_segment;
break;
case R_FRV_FUNCDESC:
{
int dynindx;
bfd_vma addend = rel->r_addend;
if (! (h && h->root.type == bfd_link_hash_undefweak
&& FRV_SYM_LOCAL (info, h)))
{
if (h && ! FRV_FUNCDESC_LOCAL (info, h)
&& FRV_SYM_LOCAL (info, h)
&& !(info->executable && !info->pie))
{
dynindx = elf_section_data (h->root.u.def.section
->output_section)->dynindx;
addend += h->root.u.def.section->output_offset
+ h->root.u.def.value;
}
else if (h && ! FRV_FUNCDESC_LOCAL (info, h))
{
if (addend)
{
info->callbacks->warning
(info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
dynindx = h->dynindx;
}
else
{
BFD_ASSERT (picrel->privfd);
r_type = R_FRV_32;
dynindx = elf_section_data (frv_got_section (info)
->output_section)->dynindx;
addend = frv_got_section (info)->output_offset
+ frv_got_initial_offset (info)
+ picrel->fd_entry;
}
if (info->executable && !info->pie
&& (!h || FRV_FUNCDESC_LOCAL (info, h)))
{
addend += frv_got_section (info)->output_section->vma;
if ((bfd_get_section_flags (output_bfd,
input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
if (_frv_osec_readonly_p (output_bfd,
input_section->output_section))
{
info->callbacks->warning
(info,
_("cannot emit fixups in read-only section"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
_frv_add_rofixup (output_bfd,
frv_gotfixup_section (info),
_bfd_elf_section_offset
(output_bfd, info,
input_section, rel->r_offset)
+ input_section->output_section->vma
+ input_section->output_offset,
picrel);
}
}
else if ((bfd_get_section_flags (output_bfd,
input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
if (_frv_osec_readonly_p (output_bfd,
input_section->output_section))
{
info->callbacks->warning
(info,
_("cannot emit dynamic relocations in read-only section"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
_frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
_bfd_elf_section_offset
(output_bfd, info,
input_section, rel->r_offset)
+ input_section->output_section->vma
+ input_section->output_offset,
r_type, dynindx, addend, picrel);
}
}
relocation = addend - rel->r_addend;
}
check_segment[0] = check_segment[1] = got_segment;
break;
case R_FRV_32:
case R_FRV_FUNCDESC_VALUE:
{
int dynindx;
bfd_vma addend = rel->r_addend;
if (h && ! FRV_SYM_LOCAL (info, h))
{
if (addend && r_type == R_FRV_FUNCDESC_VALUE)
{
info->callbacks->warning
(info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
dynindx = h->dynindx;
}
else
{
if (h)
addend += h->root.u.def.value;
else
addend += sym->st_value;
if (osec)
addend += osec->output_offset;
if (osec && osec->output_section
&& ! bfd_is_abs_section (osec->output_section)
&& ! bfd_is_und_section (osec->output_section))
dynindx = elf_section_data (osec->output_section)->dynindx;
else
dynindx = 0;
}
if (info->executable && !info->pie
&& (!h || FRV_SYM_LOCAL (info, h)))
{
if (osec)
addend += osec->output_section->vma;
if ((elf_elfheader (input_bfd)->e_flags & EF_FRV_FDPIC)
&& (bfd_get_section_flags (output_bfd,
input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
if (_frv_osec_readonly_p (output_bfd,
input_section->output_section))
{
info->callbacks->warning
(info,
_("cannot emit fixups in read-only section"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
if (!h || h->root.type != bfd_link_hash_undefweak)
{
_frv_add_rofixup (output_bfd,
frv_gotfixup_section (info),
_bfd_elf_section_offset
(output_bfd, info,
input_section, rel->r_offset)
+ input_section->output_section->vma
+ input_section->output_offset,
picrel);
if (r_type == R_FRV_FUNCDESC_VALUE)
_frv_add_rofixup
(output_bfd,
frv_gotfixup_section (info),
_bfd_elf_section_offset
(output_bfd, info,
input_section, rel->r_offset)
+ input_section->output_section->vma
+ input_section->output_offset + 4, picrel);
}
}
}
else
{
if ((bfd_get_section_flags (output_bfd,
input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
if (_frv_osec_readonly_p (output_bfd,
input_section->output_section))
{
info->callbacks->warning
(info,
_("cannot emit dynamic relocations in read-only section"),
name, input_bfd, input_section, rel->r_offset);
return FALSE;
}
_frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
_bfd_elf_section_offset
(output_bfd, info,
input_section, rel->r_offset)
+ input_section->output_section->vma
+ input_section->output_offset,
r_type, dynindx, addend, picrel);
}
relocation = addend - rel->r_addend;
}
if (r_type == R_FRV_FUNCDESC_VALUE)
{
if (info->executable && !info->pie
&& (!h || FRV_SYM_LOCAL (info, h)))
bfd_put_32 (output_bfd,
frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info),
contents + rel->r_offset + 4);
else
bfd_put_32 (output_bfd,
h && ! FRV_SYM_LOCAL (info, h)
? 0
: _frv_osec_to_segment (output_bfd,
sec->output_section),
contents + rel->r_offset + 4);
}
}
check_segment[0] = check_segment[1] = got_segment;
break;
case R_FRV_GPREL12:
case R_FRV_GPRELU12:
case R_FRV_GPREL32:
case R_FRV_GPRELHI:
case R_FRV_GPRELLO:
check_segment[0] = gprel_segment;
check_segment[1] = sec
? _frv_osec_to_segment (output_bfd, sec->output_section)
: (unsigned)-1;
break;
default:
check_segment[0] = isec_segment;
check_segment[1] = sec
? _frv_osec_to_segment (output_bfd, sec->output_section)
: (unsigned)-1;
break;
}
if (check_segment[0] != check_segment[1]
&& (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC))
{
#if 1
if (silence_segment_error == 1)
silence_segment_error =
(strlen (input_bfd->filename) == 6
&& strcmp (input_bfd->filename, "crt0.o") == 0)
|| (strlen (input_bfd->filename) > 6
&& strcmp (input_bfd->filename
+ strlen (input_bfd->filename) - 7,
"/crt0.o") == 0)
? -1 : 0;
#endif
if (!silence_segment_error
&& !(picrel && picrel->symndx == -1
&& picrel->d.h->root.type == bfd_link_hash_undefined))
info->callbacks->warning
(info,
(info->shared || info->pie)
? _("relocations between different segments are not supported")
: _("warning: relocation references a different segment"),
name, input_bfd, input_section, rel->r_offset);
if (!silence_segment_error && (info->shared || info->pie))
return FALSE;
elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
}
switch (r_type)
{
case R_FRV_GOTOFFHI:
relocation += rel->r_addend;
case R_FRV_GOTHI:
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTOFFHI:
relocation >>= 16;
case R_FRV_GOTLO:
case R_FRV_FUNCDESC_GOTLO:
case R_FRV_GOTOFFLO:
case R_FRV_FUNCDESC_GOTOFFLO:
relocation &= 0xffff;
break;
default:
break;
}
switch (r_type)
{
case R_FRV_LABEL24:
if (! picrel->plt)
break;
case R_FRV_GOT12:
case R_FRV_GOTHI:
case R_FRV_GOTLO:
case R_FRV_FUNCDESC_GOT12:
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTLO:
case R_FRV_FUNCDESC_GOTOFF12:
case R_FRV_FUNCDESC_GOTOFFHI:
case R_FRV_FUNCDESC_GOTOFFLO:
case R_FRV_GOTOFFHI:
relocation -= rel->r_addend;
break;
default:
break;
}
if (r_type == R_FRV_HI16)
r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
else if (r_type == R_FRV_LO16)
r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
else if (r_type == R_FRV_LABEL24)
r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
contents, relocation);
else if (r_type == R_FRV_GPREL12)
r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
contents, relocation);
else if (r_type == R_FRV_GPRELU12)
r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
contents, relocation);
else if (r_type == R_FRV_GPRELLO)
r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
contents, relocation);
else if (r_type == R_FRV_GPRELHI)
r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
contents, relocation);
else
r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
rel, relocation);
if (r != bfd_reloc_ok)
{
const char * msg = (const char *) NULL;
switch (r)
{
case bfd_reloc_overflow:
r = info->callbacks->reloc_overflow
(info, name, howto->name, (bfd_vma) 0,
input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
r = info->callbacks->undefined_symbol
(info, name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_outofrange:
msg = _("internal error: out of range error");
break;
case bfd_reloc_notsupported:
msg = _("internal error: unsupported relocation error");
break;
case bfd_reloc_dangerous:
msg = _("internal error: dangerous relocation");
break;
default:
msg = _("internal error: unknown error");
break;
}
if (msg)
r = info->callbacks->warning
(info, msg, name, input_bfd, input_section, rel->r_offset);
if (! r)
return FALSE;
}
}
return TRUE;
}
static asection *
elf32_frv_gc_mark_hook (sec, info, rel, h, sym)
asection *sec;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
Elf_Internal_Rela *rel;
struct elf_link_hash_entry *h;
Elf_Internal_Sym *sym;
{
if (h != NULL)
{
switch (ELF32_R_TYPE (rel->r_info))
{
case R_FRV_GNU_VTINHERIT:
case R_FRV_GNU_VTENTRY:
break;
default:
switch (h->root.type)
{
default:
break;
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
return h->root.u.def.section;
case bfd_link_hash_common:
return h->root.u.c.p->section;
}
}
}
else
return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
return NULL;
}
static bfd_boolean
elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
asection *sec ATTRIBUTE_UNUSED;
const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
{
return TRUE;
}
static bfd_boolean
elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd *abfd;
struct bfd_link_info *info;
const Elf_Internal_Sym *sym;
const char **namep ATTRIBUTE_UNUSED;
flagword *flagsp ATTRIBUTE_UNUSED;
asection **secp;
bfd_vma *valp;
{
if (sym->st_shndx == SHN_COMMON
&& !info->relocatable
&& (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
{
asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
if (scomm == NULL)
{
scomm = bfd_make_section (abfd, ".scommon");
if (scomm == NULL
|| !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
| SEC_IS_COMMON
| SEC_LINKER_CREATED)))
return FALSE;
}
*secp = scomm;
*valp = sym->st_size;
}
return TRUE;
}
static bfd_boolean
_frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
{
flagword flags;
asection *s;
struct elf_link_hash_entry *h;
struct bfd_link_hash_entry *bh;
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign;
s = bfd_get_section_by_name (abfd, ".got");
if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
return TRUE;
ptralign = 3;
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
| SEC_LINKER_CREATED);
s = bfd_make_section (abfd, ".got");
if (s == NULL
|| !bfd_set_section_flags (abfd, s, flags)
|| !bfd_set_section_alignment (abfd, s, ptralign))
return FALSE;
if (bed->want_got_plt)
{
s = bfd_make_section (abfd, ".got.plt");
if (s == NULL
|| !bfd_set_section_flags (abfd, s, flags)
|| !bfd_set_section_alignment (abfd, s, ptralign))
return FALSE;
}
if (bed->want_got_sym)
{
bh = NULL;
if (!(_bfd_generic_link_add_one_symbol
(info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
bed->got_symbol_offset, (const char *) NULL, FALSE,
bed->collect, &bh)))
return FALSE;
h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT;
if (! _bfd_elf_link_record_dynamic_symbol (info, h))
return FALSE;
elf_hash_table (info)->hgot = h;
}
s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
frv_got_section (info) = s;
frv_relocs_info (info) = htab_try_create (1, frv_pic_relocs_info_hash,
frv_pic_relocs_info_eq,
(htab_del) NULL);
if (! frv_relocs_info (info))
return FALSE;
s = bfd_make_section (abfd, ".rel.got");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
|| ! bfd_set_section_alignment (abfd, s, 2))
return FALSE;
frv_gotrel_section (info) = s;
s = bfd_make_section (abfd, ".rofixup");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
|| ! bfd_set_section_alignment (abfd, s, 2))
return FALSE;
frv_gotfixup_section (info) = s;
bh = NULL;
if (!(_bfd_generic_link_add_one_symbol
(info, abfd, "_gp", BSF_GLOBAL, s, -2048, (const char *) NULL, FALSE,
bed->collect, &bh)))
return FALSE;
h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT;
if (! _bfd_elf_link_record_dynamic_symbol (info, h))
return FALSE;
return TRUE;
}
static bfd_boolean
elf32_frv_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
{
flagword flags, pltflags;
asection *s;
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
| SEC_LINKER_CREATED);
pltflags = flags;
pltflags |= SEC_CODE;
if (bed->plt_not_loaded)
pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
if (bed->plt_readonly)
pltflags |= SEC_READONLY;
s = bfd_make_section (abfd, ".plt");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, pltflags)
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
return FALSE;
frv_plt_section (info) = s;
if (bed->want_plt_sym)
{
struct elf_link_hash_entry *h;
struct bfd_link_hash_entry *bh = NULL;
if (! (_bfd_generic_link_add_one_symbol
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
FALSE, get_elf_backend_data (abfd)->collect, &bh)))
return FALSE;
h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT;
if (! info->executable
&& ! _bfd_elf_link_record_dynamic_symbol (info, h))
return FALSE;
}
s = bfd_make_section (abfd, ".rel.plt");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
return FALSE;
frv_pltrel_section (info) = s;
if (! _frv_create_got_section (abfd, info))
return FALSE;
BFD_ASSERT (frv_got_section (info) && frv_gotrel_section (info)
&& frv_gotfixup_section (info)
&& frv_plt_section (info) && frv_pltrel_section (info));
if (bed->want_dynbss)
{
s = bfd_make_section (abfd, ".dynbss");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
return FALSE;
if (! info->shared)
{
s = bfd_make_section (abfd,
(bed->default_use_rela_p
? ".rela.bss" : ".rel.bss"));
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
return FALSE;
}
}
return TRUE;
}
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
#define DEFAULT_STACK_SIZE 0x20000
struct _frv_dynamic_got_info
{
struct bfd_link_info *info;
bfd_vma got12, gotlos, gothilo;
bfd_vma fd12, fdlos, fdhilo;
bfd_vma fdplt;
bfd_vma lzplt;
unsigned long relocs;
unsigned long fixups;
};
static int
_frv_count_got_plt_entries (void **entryp, void *dinfo_)
{
struct frv_pic_relocs_info *entry = *entryp;
struct _frv_dynamic_got_info *dinfo = dinfo_;
unsigned relocs = 0, fixups = 0;
if (entry->got12)
dinfo->got12 += 4;
else if (entry->gotlos)
dinfo->gotlos += 4;
else if (entry->gothilo)
dinfo->gothilo += 4;
else
entry->relocs32--;
entry->relocs32++;
if (entry->fdgot12)
dinfo->got12 += 4;
else if (entry->fdgotlos)
dinfo->gotlos += 4;
else if (entry->fdgothilo)
dinfo->gothilo += 4;
else
entry->relocsfd--;
entry->relocsfd++;
entry->plt = entry->call
&& entry->symndx == -1 && ! FRV_SYM_LOCAL (dinfo->info, entry->d.h)
&& elf_hash_table (dinfo->info)->dynamic_sections_created;
entry->privfd = entry->plt
|| entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
|| ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
&& (entry->symndx != -1
|| FRV_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
entry->lazyplt = entry->privfd
&& entry->symndx == -1 && ! FRV_SYM_LOCAL (dinfo->info, entry->d.h)
&& ! (dinfo->info->flags & DF_BIND_NOW)
&& elf_hash_table (dinfo->info)->dynamic_sections_created;
if (entry->fdgoff12)
dinfo->fd12 += 8;
else if (entry->fdgofflos)
dinfo->fdlos += 8;
else if (entry->privfd && entry->plt)
dinfo->fdplt += 8;
else if (entry->privfd)
dinfo->fdhilo += 8;
else
entry->relocsfdv--;
entry->relocsfdv++;
if (entry->lazyplt)
dinfo->lzplt += 8;
if (!dinfo->info->executable || dinfo->info->pie)
relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
else
{
if (entry->symndx != -1 || FRV_SYM_LOCAL (dinfo->info, entry->d.h))
{
if (entry->symndx != -1
|| entry->d.h->root.type != bfd_link_hash_undefweak)
fixups += entry->relocs32 + 2 * entry->relocsfdv;
}
else
relocs += entry->relocs32 + entry->relocsfdv;
if (entry->symndx != -1 || FRV_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
{
if (entry->symndx != -1
|| entry->d.h->root.type != bfd_link_hash_undefweak)
fixups += entry->relocsfd;
}
else
relocs += entry->relocsfd;
}
entry->dynrelocs += relocs;
entry->fixups += fixups;
dinfo->relocs += relocs;
dinfo->fixups += fixups;
return 1;
}
struct _frv_dynamic_got_plt_info
{
struct _frv_dynamic_got_info g;
struct _frv_dynamic_got_alloc_data
{
bfd_signed_vma max, cur, odd, fdcur, min;
bfd_vma fdplt;
} got12, gotlos, gothilo;
};
inline static bfd_signed_vma
_frv_compute_got_alloc_data (struct _frv_dynamic_got_alloc_data *gad,
bfd_signed_vma fdcur,
bfd_signed_vma odd,
bfd_signed_vma cur,
bfd_vma got,
bfd_vma fd,
bfd_vma fdplt,
bfd_vma wrap)
{
bfd_signed_vma wrapmin = -wrap;
gad->fdcur = fdcur;
gad->cur = cur;
if (odd && got)
{
gad->odd = odd;
got -= 4;
odd = 0;
}
else
gad->odd = 0;
if (got & 4)
{
odd = cur + got;
got += 4;
}
gad->max = cur + got;
gad->min = fdcur - fd;
gad->fdplt = 0;
if (gad->min < wrapmin)
{
gad->max += wrapmin - gad->min;
gad->min = wrapmin;
}
else if (fdplt && gad->min > wrapmin)
{
bfd_vma fds;
if ((bfd_vma) (gad->min - wrapmin) < fdplt)
fds = gad->min - wrapmin;
else
fds = fdplt;
fdplt -= fds;
gad->min -= fds;
gad->fdplt += fds;
}
if ((bfd_vma) gad->max > wrap)
{
gad->min -= gad->max - wrap;
gad->max = wrap;
}
else if (fdplt && (bfd_vma) gad->max < wrap)
{
bfd_vma fds;
if ((bfd_vma) (wrap - gad->max) < fdplt)
fds = wrap - gad->max;
else
fds = fdplt;
fdplt -= fds;
gad->max += fds;
gad->fdplt += fds;
}
if (odd > gad->max)
odd = gad->min + odd - gad->max;
if (gad->cur == gad->max)
gad->cur = gad->min;
return odd;
}
inline static bfd_signed_vma
_frv_get_got_entry (struct _frv_dynamic_got_alloc_data *gad)
{
bfd_signed_vma ret;
if (gad->odd)
{
ret = gad->odd;
gad->odd = 0;
}
else
{
ret = gad->cur;
gad->odd = gad->cur + 4;
gad->cur += 8;
if (gad->cur == gad->max)
gad->cur = gad->min;
}
return ret;
}
inline static bfd_signed_vma
_frv_get_fd_entry (struct _frv_dynamic_got_alloc_data *gad)
{
if (gad->fdcur == gad->min)
gad->fdcur = gad->max;
return gad->fdcur -= 8;
}
static int
_frv_assign_got_entries (void **entryp, void *info_)
{
struct frv_pic_relocs_info *entry = *entryp;
struct _frv_dynamic_got_plt_info *dinfo = info_;
if (entry->got12)
entry->got_entry = _frv_get_got_entry (&dinfo->got12);
else if (entry->gotlos)
entry->got_entry = _frv_get_got_entry (&dinfo->gotlos);
else if (entry->gothilo)
entry->got_entry = _frv_get_got_entry (&dinfo->gothilo);
if (entry->fdgot12)
entry->fdgot_entry = _frv_get_got_entry (&dinfo->got12);
else if (entry->fdgotlos)
entry->fdgot_entry = _frv_get_got_entry (&dinfo->gotlos);
else if (entry->fdgothilo)
entry->fdgot_entry = _frv_get_got_entry (&dinfo->gothilo);
if (entry->fdgoff12)
entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
else if (entry->plt && dinfo->got12.fdplt)
{
dinfo->got12.fdplt -= 8;
entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
}
else if (entry->fdgofflos)
entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
else if (entry->plt && dinfo->gotlos.fdplt)
{
dinfo->gotlos.fdplt -= 8;
entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
}
else if (entry->plt)
{
dinfo->gothilo.fdplt -= 8;
entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
}
else if (entry->privfd)
entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
return 1;
}
static int
_frv_assign_plt_entries (void **entryp, void *info_)
{
struct frv_pic_relocs_info *entry = *entryp;
struct _frv_dynamic_got_plt_info *dinfo = info_;
if (entry->privfd && entry->fd_entry == 0)
{
if (dinfo->got12.fdplt)
{
entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
dinfo->got12.fdplt -= 8;
}
else if (dinfo->gotlos.fdplt)
{
entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
dinfo->gotlos.fdplt -= 8;
}
else
{
BFD_ASSERT (dinfo->gothilo.fdplt)
entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
dinfo->gothilo.fdplt -= 8;
}
}
if (entry->plt)
{
int size;
entry->plt_entry = frv_plt_section (dinfo->g.info)->_raw_size;
BFD_ASSERT (entry->fd_entry);
if (entry->fd_entry >= -(1 << (12 - 1))
&& entry->fd_entry < (1 << (12 - 1)))
size = 8;
else if (entry->fd_entry >= -(1 << (16 - 1))
&& entry->fd_entry < (1 << (16 - 1)))
size = 12;
else
size = 16;
frv_plt_section (dinfo->g.info)->_raw_size += size;
}
if (entry->lazyplt)
{
entry->lzplt_entry = dinfo->g.lzplt;
dinfo->g.lzplt += 8;
if (entry->lzplt_entry % FRV_LZPLT_BLOCK_SIZE == FRV_LZPLT_RESOLV_LOC)
dinfo->g.lzplt += 4;
}
return 1;
}
static int
_frv_resolve_final_relocs_info (void **entryp, void *p)
{
struct frv_pic_relocs_info *entry = *entryp;
htab_t *htab = p;
if (entry->symndx == -1)
{
struct elf_link_hash_entry *h = entry->d.h;
struct frv_pic_relocs_info *oentry;
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *)h->root.u.i.link;
if (entry->d.h == h)
return 1;
oentry = frv_pic_relocs_info_for_global (*htab, 0, h, entry->addend,
NO_INSERT);
if (oentry)
{
frv_pic_merge_early_relocs_info (oentry, entry);
htab_clear_slot (*htab, entryp);
return 1;
}
entry->d.h = h;
if (! htab_find (*htab, entry))
{
htab_clear_slot (*htab, entryp);
entryp = htab_find_slot (*htab, entry, INSERT);
if (! *entryp)
*entryp = entry;
*(htab_t *)p = NULL;
return 0;
}
}
return 1;
}
static bfd_boolean
elf32_frv_size_dynamic_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
bfd *dynobj;
asection *s;
struct _frv_dynamic_got_plt_info gpinfo;
bfd_signed_vma odd;
bfd_vma limit;
dynobj = elf_hash_table (info)->dynobj;
BFD_ASSERT (dynobj != NULL);
if (elf_hash_table (info)->dynamic_sections_created)
{
if (info->executable)
{
s = bfd_get_section_by_name (dynobj, ".interp");
BFD_ASSERT (s != NULL);
s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
}
}
memset (&gpinfo, 0, sizeof (gpinfo));
gpinfo.g.info = info;
for (;;)
{
htab_t relocs = frv_relocs_info (info);
htab_traverse (relocs, _frv_resolve_final_relocs_info, &relocs);
if (relocs == frv_relocs_info (info))
break;
}
htab_traverse (frv_relocs_info (info), _frv_count_got_plt_entries,
&gpinfo.g);
odd = 12;
limit = odd + gpinfo.g.got12 + gpinfo.g.gotlos
+ gpinfo.g.fd12 + gpinfo.g.fdlos;
if (limit < (bfd_vma)1 << 16)
limit = ((bfd_vma)1 << 16) - limit;
else
limit = 0;
if (gpinfo.g.fdplt < limit)
limit = gpinfo.g.fdplt;
odd = _frv_compute_got_alloc_data (&gpinfo.got12,
0,
odd,
16,
gpinfo.g.got12,
gpinfo.g.fd12,
limit,
(bfd_vma)1 << (12-1));
odd = _frv_compute_got_alloc_data (&gpinfo.gotlos,
gpinfo.got12.min,
odd,
gpinfo.got12.max,
gpinfo.g.gotlos,
gpinfo.g.fdlos,
gpinfo.g.fdplt - gpinfo.got12.fdplt,
(bfd_vma)1 << (16-1));
odd = _frv_compute_got_alloc_data (&gpinfo.gothilo,
gpinfo.gotlos.min,
odd,
gpinfo.gotlos.max,
gpinfo.g.gothilo,
gpinfo.g.fdhilo,
gpinfo.g.fdplt - gpinfo.got12.fdplt
- gpinfo.gotlos.fdplt,
(bfd_vma)1 << (32-1));
htab_traverse (frv_relocs_info (info), _frv_assign_got_entries, &gpinfo);
frv_got_section (info)->_raw_size = gpinfo.gothilo.max - gpinfo.gothilo.min
- (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
if (frv_got_section (info)->_raw_size == 0)
frv_got_section (info)->flags |= SEC_EXCLUDE;
else if (frv_got_section (info)->_raw_size == 12
&& ! elf_hash_table (info)->dynamic_sections_created)
{
frv_got_section (info)->flags |= SEC_EXCLUDE;
frv_got_section (info)->_raw_size = 0;
}
else
{
frv_got_section (info)->contents =
(bfd_byte *) bfd_zalloc (dynobj, frv_got_section (info)->_raw_size);
if (frv_got_section (info)->contents == NULL)
return FALSE;
}
if (elf_hash_table (info)->dynamic_sections_created)
frv_gotrel_section (info)->_raw_size =
(gpinfo.g.relocs - gpinfo.g.lzplt / 8)
* get_elf_backend_data (output_bfd)->s->sizeof_rel;
else
BFD_ASSERT (gpinfo.g.relocs == 0);
if (frv_gotrel_section (info)->_raw_size == 0)
frv_gotrel_section (info)->flags |= SEC_EXCLUDE;
else
{
frv_gotrel_section (info)->contents =
(bfd_byte *) bfd_zalloc (dynobj, frv_gotrel_section (info)->_raw_size);
if (frv_gotrel_section (info)->contents == NULL)
return FALSE;
}
if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
frv_gotfixup_section (info)->_raw_size = (gpinfo.g.fixups + 1) * 4;
if (frv_gotfixup_section (info)->_raw_size == 0)
frv_gotfixup_section (info)->flags |= SEC_EXCLUDE;
else
{
frv_gotfixup_section (info)->contents =
(bfd_byte *) bfd_zalloc (dynobj,
frv_gotfixup_section (info)->_raw_size);
if (frv_gotfixup_section (info)->contents == NULL)
return FALSE;
}
if (elf_hash_table (info)->dynamic_sections_created)
{
frv_pltrel_section (info)->_raw_size =
gpinfo.g.lzplt / 8 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
if (frv_pltrel_section (info)->_raw_size == 0)
frv_pltrel_section (info)->flags |= SEC_EXCLUDE;
else
{
frv_pltrel_section (info)->contents =
(bfd_byte *) bfd_zalloc (dynobj,
frv_pltrel_section (info)->_raw_size);
if (frv_pltrel_section (info)->contents == NULL)
return FALSE;
}
}
if (elf_hash_table (info)->dynamic_sections_created)
{
frv_plt_section (info)->_raw_size = gpinfo.g.lzplt
+ ((gpinfo.g.lzplt + (FRV_LZPLT_BLOCK_SIZE - 4) - 8)
/ (FRV_LZPLT_BLOCK_SIZE - 4) * 4);
}
gpinfo.g.lzplt = 0;
frv_got_initial_offset (info) = -gpinfo.gothilo.min;
if (get_elf_backend_data (output_bfd)->want_got_sym)
elf_hash_table (info)->hgot->root.u.def.value
+= frv_got_initial_offset (info);
if (elf_hash_table (info)->dynamic_sections_created)
frv_plt_initial_offset (info) = frv_plt_section (info)->_raw_size;
htab_traverse (frv_relocs_info (info), _frv_assign_plt_entries, &gpinfo);
if (elf_hash_table (info)->dynamic_sections_created)
{
if (frv_plt_section (info)->_raw_size == 0)
frv_plt_section (info)->flags |= SEC_EXCLUDE;
else
{
frv_plt_section (info)->contents =
(bfd_byte *) bfd_zalloc (dynobj, frv_plt_section (info)->_raw_size);
if (frv_plt_section (info)->contents == NULL)
return FALSE;
}
}
if (elf_hash_table (info)->dynamic_sections_created)
{
if (frv_got_section (info)->_raw_size)
if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
return FALSE;
if (frv_pltrel_section (info)->_raw_size)
if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
|| ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
|| ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
return FALSE;
if (frv_gotrel_section (info)->_raw_size)
if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
|| ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
|| ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
sizeof (Elf32_External_Rel)))
return FALSE;
}
return TRUE;
}
static bfd_boolean
elf32_frv_always_size_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
if (!info->relocatable
&& elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
{
struct elf_link_hash_entry *h;
asection *sec;
if (! elf_tdata (output_bfd)->stack_flags)
elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
FALSE, FALSE, FALSE);
if (! h || h->root.type != bfd_link_hash_defined
|| h->type != STT_OBJECT
|| !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
{
struct bfd_link_hash_entry *bh = NULL;
if (!(_bfd_generic_link_add_one_symbol
(info, output_bfd, "__stacksize",
BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
(const char *) NULL, FALSE,
get_elf_backend_data (output_bfd)->collect, &bh)))
return FALSE;
h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT;
}
sec = bfd_make_section (output_bfd, ".stack");
if (sec == NULL
|| ! bfd_set_section_alignment (output_bfd, sec, 3))
return FALSE;
}
return TRUE;
}
static bfd_boolean
elf32_frv_modify_segment_map (bfd *output_bfd,
struct bfd_link_info *info)
{
if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
{
struct elf_segment_map *m;
for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
if (m->p_type == PT_GNU_STACK)
break;
if (m)
{
asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
struct elf_link_hash_entry *h;
if (sec)
{
h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
FALSE, FALSE, FALSE);
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *)h->root.u.i.link;
BFD_ASSERT (h->root.type == bfd_link_hash_defined);
if (h->root.type == bfd_link_hash_defined)
sec->_raw_size = h->root.u.def.value;
else
sec->_raw_size = DEFAULT_STACK_SIZE;
m->sections[m->count] = sec;
m->count++;
}
}
}
return TRUE;
}
static bfd_boolean
elf32_frv_finish_dynamic_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
bfd *dynobj;
asection *sdyn;
dynobj = elf_hash_table (info)->dynobj;
if (frv_got_section (info))
{
BFD_ASSERT (frv_gotrel_section (info)->_raw_size
== (frv_gotrel_section (info)->reloc_count
* sizeof (Elf32_External_Rel)));
if (frv_gotfixup_section (info))
{
if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
{
struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
bfd_vma got_value = hgot->root.u.def.value
+ hgot->root.u.def.section->output_section->vma
+ hgot->root.u.def.section->output_offset;
_frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
got_value, 0);
}
if (frv_gotfixup_section (info)->_raw_size
!= (frv_gotfixup_section (info)->reloc_count * 4))
{
if (frv_gotfixup_section (info)->_raw_size
< frv_gotfixup_section (info)->reloc_count * 4)
{
info->callbacks->warning
(info, "LINKER BUG: .rofixup section size mismatch",
".rofixup", NULL, NULL, 0);
abort ();
return FALSE;
}
else if (!elf_hash_table (info)->dynamic_sections_created)
{
info->callbacks->warning
(info, "no dynamic sections, missing -melf32frvfd?",
".rofixup", NULL, NULL, 0);
return FALSE;
}
BFD_ASSERT (0);
}
}
}
if (elf_hash_table (info)->dynamic_sections_created)
{
BFD_ASSERT (frv_pltrel_section (info)->_raw_size
== (frv_pltrel_section (info)->reloc_count
* sizeof (Elf32_External_Rel)));
}
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
if (elf_hash_table (info)->dynamic_sections_created)
{
Elf32_External_Dyn * dyncon;
Elf32_External_Dyn * dynconend;
BFD_ASSERT (sdyn != NULL);
dyncon = (Elf32_External_Dyn *) sdyn->contents;
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
for (; dyncon < dynconend; dyncon++)
{
Elf_Internal_Dyn dyn;
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
switch (dyn.d_tag)
{
default:
break;
case DT_PLTGOT:
dyn.d_un.d_ptr = frv_got_section (info)->output_section->vma
+ frv_got_section (info)->output_offset
+ frv_got_initial_offset (info);
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_JMPREL:
dyn.d_un.d_ptr = frv_pltrel_section (info)->output_section->vma
+ frv_pltrel_section (info)->output_offset;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_PLTRELSZ:
if (frv_pltrel_section (info)->_cooked_size != 0)
dyn.d_un.d_val = frv_pltrel_section (info)->_cooked_size;
else
dyn.d_un.d_val = frv_pltrel_section (info)->_raw_size;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
}
}
}
return TRUE;
}
static bfd_boolean
elf32_frv_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
{
bfd * dynobj;
dynobj = elf_hash_table (info)->dynobj;
BFD_ASSERT (dynobj != NULL
&& (h->weakdef != NULL
|| ((h->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC) != 0
&& (h->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR) != 0
&& (h->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0)));
if (h->weakdef != NULL)
{
BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
|| h->weakdef->root.type == bfd_link_hash_defweak);
h->root.u.def.section = h->weakdef->root.u.def.section;
h->root.u.def.value = h->weakdef->root.u.def.value;
}
return TRUE;
}
static bfd_boolean
elf32_frv_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info ATTRIBUTE_UNUSED,
struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
{
return TRUE;
}
static bfd_boolean
frv_elf_use_relative_eh_frame (bfd *input_bfd,
struct bfd_link_info *info ATTRIBUTE_UNUSED,
asection *eh_frame_section ATTRIBUTE_UNUSED)
{
if (elf_elfheader (input_bfd)->e_flags & EF_FRV_FDPIC)
return FALSE;
return TRUE;
}
static bfd_byte
frv_elf_encode_eh_address (bfd *abfd,
struct bfd_link_info *info,
asection *osec, bfd_vma offset,
asection *loc_sec, bfd_vma loc_offset,
bfd_vma *encoded)
{
struct elf_link_hash_entry *h;
if (! (elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC))
return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
loc_sec, loc_offset, encoded);
h = elf_hash_table (info)->hgot;
BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
if (! h || (_frv_osec_to_segment (abfd, osec)
== _frv_osec_to_segment (abfd, loc_sec->output_section)))
return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
loc_sec, loc_offset, encoded);
BFD_ASSERT (_frv_osec_to_segment (abfd, osec)
== _frv_osec_to_segment (abfd,
h->root.u.def.section->output_section));
*encoded = osec->vma + offset
- (h->root.u.def.value
+ h->root.u.def.section->output_section->vma
+ h->root.u.def.section->output_offset);
return DW_EH_PE_datarel | DW_EH_PE_sdata4;
}
static bfd_boolean
elf32_frv_check_relocs (abfd, info, sec, relocs)
bfd *abfd;
struct bfd_link_info *info;
asection *sec;
const Elf_Internal_Rela *relocs;
{
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
bfd *dynobj;
struct frv_pic_relocs_info *picrel;
if (info->relocatable)
return TRUE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
if (!elf_bad_symtab (abfd))
sym_hashes_end -= symtab_hdr->sh_info;
dynobj = elf_hash_table (info)->dynobj;
rel_end = relocs + sec->reloc_count;
for (rel = relocs; rel < rel_end; rel++)
{
struct elf_link_hash_entry *h;
unsigned long r_symndx;
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
else
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
switch (ELF32_R_TYPE (rel->r_info))
{
case R_FRV_LABEL24:
case R_FRV_32:
case R_FRV_GOT12:
case R_FRV_GOTHI:
case R_FRV_GOTLO:
case R_FRV_FUNCDESC_GOT12:
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTLO:
case R_FRV_GOTOFF12:
case R_FRV_GOTOFFHI:
case R_FRV_GOTOFFLO:
case R_FRV_FUNCDESC_GOTOFF12:
case R_FRV_FUNCDESC_GOTOFFHI:
case R_FRV_FUNCDESC_GOTOFFLO:
case R_FRV_FUNCDESC:
case R_FRV_FUNCDESC_VALUE:
if (! dynobj)
{
elf_hash_table (info)->dynobj = dynobj = abfd;
if (! _frv_create_got_section (abfd, info))
return FALSE;
}
if (h != NULL)
{
if (h->dynindx == -1)
switch (ELF_ST_VISIBILITY (h->other))
{
case STV_INTERNAL:
case STV_HIDDEN:
break;
default:
bfd_elf32_link_record_dynamic_symbol (info, h);
break;
}
picrel
= frv_pic_relocs_info_for_global (frv_relocs_info (info),
abfd, h,
rel->r_addend, INSERT);
}
else
picrel = frv_pic_relocs_info_for_local (frv_relocs_info (info),
abfd, r_symndx,
rel->r_addend, INSERT);
if (! picrel)
return FALSE;
break;
default:
picrel = NULL;
break;
}
switch (ELF32_R_TYPE (rel->r_info))
{
case R_FRV_LABEL24:
picrel->call = 1;
break;
case R_FRV_FUNCDESC_VALUE:
picrel->relocsfdv++;
if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
picrel->relocs32--;
case R_FRV_32:
picrel->sym = 1;
if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
picrel->relocs32++;
break;
case R_FRV_GOT12:
picrel->got12 = 1;
break;
case R_FRV_GOTHI:
case R_FRV_GOTLO:
picrel->gothilo = 1;
break;
case R_FRV_FUNCDESC_GOT12:
picrel->fdgot12 = 1;
break;
case R_FRV_FUNCDESC_GOTHI:
case R_FRV_FUNCDESC_GOTLO:
picrel->fdgothilo = 1;
break;
case R_FRV_GOTOFF12:
case R_FRV_GOTOFFHI:
case R_FRV_GOTOFFLO:
picrel->gotoff = 1;
break;
case R_FRV_FUNCDESC_GOTOFF12:
picrel->fdgoff12 = 1;
break;
case R_FRV_FUNCDESC_GOTOFFHI:
case R_FRV_FUNCDESC_GOTOFFLO:
picrel->fdgoffhilo = 1;
break;
case R_FRV_FUNCDESC:
picrel->fd = 1;
picrel->relocsfd++;
break;
case R_FRV_GNU_VTINHERIT:
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
return FALSE;
break;
case R_FRV_GNU_VTENTRY:
if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
return FALSE;
break;
}
}
return TRUE;
}
static int
elf32_frv_machine (abfd)
bfd *abfd;
{
switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
{
default: break;
case EF_FRV_CPU_FR550: return bfd_mach_fr550;
case EF_FRV_CPU_FR500: return bfd_mach_fr500;
case EF_FRV_CPU_FR450: return bfd_mach_fr450;
case EF_FRV_CPU_FR405: return bfd_mach_fr400;
case EF_FRV_CPU_FR400: return bfd_mach_fr400;
case EF_FRV_CPU_FR300: return bfd_mach_fr300;
case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
}
return bfd_mach_frv;
}
static bfd_boolean
elf32_frv_object_p (abfd)
bfd *abfd;
{
bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
return TRUE;
}
static bfd_boolean
frv_elf_set_private_flags (abfd, flags)
bfd *abfd;
flagword flags;
{
elf_elfheader (abfd)->e_flags = flags;
elf_flags_init (abfd) = TRUE;
return TRUE;
}
static bfd_boolean
frv_elf_copy_private_bfd_data (ibfd, obfd)
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;
elf_flags_init (obfd) = TRUE;
return TRUE;
}
static bfd_boolean
frv_elf_arch_extension_p (flagword base, flagword extension)
{
if (base == extension)
return TRUE;
if (base == EF_FRV_CPU_GENERIC)
return TRUE;
if (extension == EF_FRV_CPU_FR450)
if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
return TRUE;
if (extension == EF_FRV_CPU_FR405)
if (base == EF_FRV_CPU_FR400)
return TRUE;
return FALSE;
}
static bfd_boolean
frv_elf_merge_private_bfd_data (ibfd, obfd)
bfd *ibfd;
bfd *obfd;
{
flagword old_flags, old_partial;
flagword new_flags, new_partial;
bfd_boolean error = FALSE;
char new_opt[80];
char old_opt[80];
new_opt[0] = old_opt[0] = '\0';
new_flags = elf_elfheader (ibfd)->e_flags;
old_flags = elf_elfheader (obfd)->e_flags;
if (new_flags & EF_FRV_FDPIC)
new_flags &= ~EF_FRV_PIC;
#ifdef DEBUG
(*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
bfd_get_filename (ibfd));
#endif
if (!elf_flags_init (obfd))
{
elf_flags_init (obfd) = TRUE;
old_flags = new_flags;
}
else if (new_flags == old_flags)
;
else
{
new_partial = (new_flags & EF_FRV_GPR_MASK);
old_partial = (old_flags & EF_FRV_GPR_MASK);
if (new_partial == old_partial)
;
else if (new_partial == 0)
;
else if (old_partial == 0)
old_flags |= new_partial;
else
{
switch (new_partial)
{
default: strcat (new_opt, " -mgpr-??"); break;
case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
}
switch (old_partial)
{
default: strcat (old_opt, " -mgpr-??"); break;
case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
}
}
new_partial = (new_flags & EF_FRV_FPR_MASK);
old_partial = (old_flags & EF_FRV_FPR_MASK);
if (new_partial == old_partial)
;
else if (new_partial == 0)
;
else if (old_partial == 0)
old_flags |= new_partial;
else
{
switch (new_partial)
{
default: strcat (new_opt, " -mfpr-?"); break;
case EF_FRV_FPR_32: strcat (new_opt, " -mfpr-32"); break;
case EF_FRV_FPR_64: strcat (new_opt, " -mfpr-64"); break;
case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
}
switch (old_partial)
{
default: strcat (old_opt, " -mfpr-?"); break;
case EF_FRV_FPR_32: strcat (old_opt, " -mfpr-32"); break;
case EF_FRV_FPR_64: strcat (old_opt, " -mfpr-64"); break;
case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
}
}
new_partial = (new_flags & EF_FRV_DWORD_MASK);
old_partial = (old_flags & EF_FRV_DWORD_MASK);
if (new_partial == old_partial)
;
else if (new_partial == 0)
;
else if (old_partial == 0)
old_flags |= new_partial;
else
{
switch (new_partial)
{
default: strcat (new_opt, " -mdword-?"); break;
case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword"); break;
case EF_FRV_DWORD_NO: strcat (new_opt, " -mno-dword"); break;
}
switch (old_partial)
{
default: strcat (old_opt, " -mdword-?"); break;
case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword"); break;
case EF_FRV_DWORD_NO: strcat (old_opt, " -mno-dword"); break;
}
}
old_flags |= new_flags & (EF_FRV_DOUBLE
| EF_FRV_MEDIA
| EF_FRV_MULADD
| EF_FRV_NON_PIC_RELOCS);
old_flags = ((old_flags & ~ EF_FRV_G0)
| (old_flags & new_flags & EF_FRV_G0));
old_flags = ((old_flags & ~ EF_FRV_NOPACK)
| (old_flags & new_flags & EF_FRV_NOPACK));
new_partial = (new_flags & EF_FRV_PIC_FLAGS);
old_partial = (old_flags & EF_FRV_PIC_FLAGS);
if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
;
else if ((old_partial & EF_FRV_LIBPIC) != 0)
old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
else if (new_partial != 0 && old_partial != 0)
old_flags |= new_partial;
else
{
if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
old_flags |= new_partial;
else
{
old_flags &= ~ EF_FRV_PIC_FLAGS;
#ifndef FRV_NO_PIC_ERROR
error = TRUE;
(*_bfd_error_handler)
(_("%s: compiled with %s and linked with modules that use non-pic relocations"),
bfd_get_filename (ibfd),
(new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
#endif
}
}
new_partial = (new_flags & EF_FRV_CPU_MASK);
old_partial = (old_flags & EF_FRV_CPU_MASK);
if (frv_elf_arch_extension_p (new_partial, old_partial))
;
else if (frv_elf_arch_extension_p (old_partial, new_partial))
old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
else
{
switch (new_partial)
{
default: strcat (new_opt, " -mcpu=?"); break;
case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv"); break;
case EF_FRV_CPU_SIMPLE: strcat (new_opt, " -mcpu=simple"); break;
case EF_FRV_CPU_FR550: strcat (new_opt, " -mcpu=fr550"); break;
case EF_FRV_CPU_FR500: strcat (new_opt, " -mcpu=fr500"); break;
case EF_FRV_CPU_FR450: strcat (new_opt, " -mcpu=fr450"); break;
case EF_FRV_CPU_FR405: strcat (new_opt, " -mcpu=fr405"); break;
case EF_FRV_CPU_FR400: strcat (new_opt, " -mcpu=fr400"); break;
case EF_FRV_CPU_FR300: strcat (new_opt, " -mcpu=fr300"); break;
case EF_FRV_CPU_TOMCAT: strcat (new_opt, " -mcpu=tomcat"); break;
}
switch (old_partial)
{
default: strcat (old_opt, " -mcpu=?"); break;
case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv"); break;
case EF_FRV_CPU_SIMPLE: strcat (old_opt, " -mcpu=simple"); break;
case EF_FRV_CPU_FR550: strcat (old_opt, " -mcpu=fr550"); break;
case EF_FRV_CPU_FR500: strcat (old_opt, " -mcpu=fr500"); break;
case EF_FRV_CPU_FR450: strcat (old_opt, " -mcpu=fr450"); break;
case EF_FRV_CPU_FR405: strcat (old_opt, " -mcpu=fr405"); break;
case EF_FRV_CPU_FR400: strcat (old_opt, " -mcpu=fr400"); break;
case EF_FRV_CPU_FR300: strcat (old_opt, " -mcpu=fr300"); break;
case EF_FRV_CPU_TOMCAT: strcat (old_opt, " -mcpu=tomcat"); break;
}
}
if (new_opt[0])
{
error = TRUE;
(*_bfd_error_handler)
(_("%s: compiled with %s and linked with modules compiled with %s"),
bfd_get_filename (ibfd), new_opt, old_opt);
}
new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
if (new_partial != old_partial)
{
old_flags |= new_partial;
error = TRUE;
(*_bfd_error_handler)
(_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
}
}
if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
old_flags |= EF_FRV_NOPACK;
old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
elf_elfheader (obfd)->e_flags = old_flags;
if (old_partial != (old_flags & EF_FRV_CPU_MASK))
bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
if (error)
bfd_set_error (bfd_error_bad_value);
return !error;
}
bfd_boolean
frv_elf_print_private_bfd_data (abfd, ptr)
bfd *abfd;
PTR ptr;
{
FILE *file = (FILE *) ptr;
flagword flags;
BFD_ASSERT (abfd != NULL && ptr != NULL);
_bfd_elf_print_private_bfd_data (abfd, ptr);
flags = elf_elfheader (abfd)->e_flags;
fprintf (file, _("private flags = 0x%lx:"), (long)flags);
switch (flags & EF_FRV_CPU_MASK)
{
default: break;
case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple"); break;
case EF_FRV_CPU_FR550: fprintf (file, " -mcpu=fr550"); break;
case EF_FRV_CPU_FR500: fprintf (file, " -mcpu=fr500"); break;
case EF_FRV_CPU_FR450: fprintf (file, " -mcpu=fr450"); break;
case EF_FRV_CPU_FR405: fprintf (file, " -mcpu=fr405"); break;
case EF_FRV_CPU_FR400: fprintf (file, " -mcpu=fr400"); break;
case EF_FRV_CPU_FR300: fprintf (file, " -mcpu=fr300"); break;
case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat"); break;
}
switch (flags & EF_FRV_GPR_MASK)
{
default: break;
case EF_FRV_GPR_32: fprintf (file, " -mgpr-32"); break;
case EF_FRV_GPR_64: fprintf (file, " -mgpr-64"); break;
}
switch (flags & EF_FRV_FPR_MASK)
{
default: break;
case EF_FRV_FPR_32: fprintf (file, " -mfpr-32"); break;
case EF_FRV_FPR_64: fprintf (file, " -mfpr-64"); break;
case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float"); break;
}
switch (flags & EF_FRV_DWORD_MASK)
{
default: break;
case EF_FRV_DWORD_YES: fprintf (file, " -mdword"); break;
case EF_FRV_DWORD_NO: fprintf (file, " -mno-dword"); break;
}
if (flags & EF_FRV_DOUBLE)
fprintf (file, " -mdouble");
if (flags & EF_FRV_MEDIA)
fprintf (file, " -mmedia");
if (flags & EF_FRV_MULADD)
fprintf (file, " -mmuladd");
if (flags & EF_FRV_PIC)
fprintf (file, " -fpic");
if (flags & EF_FRV_BIGPIC)
fprintf (file, " -fPIC");
if (flags & EF_FRV_LIBPIC)
fprintf (file, " -mlibrary-pic");
if (flags & EF_FRV_FDPIC)
fprintf (file, " -mfdpic");
if (flags & EF_FRV_NON_PIC_RELOCS)
fprintf (file, " non-pic relocations");
if (flags & EF_FRV_G0)
fprintf (file, " -G0");
fputc ('\n', file);
return TRUE;
}
#define ELF_ARCH bfd_arch_frv
#define ELF_MACHINE_CODE EM_CYGNUS_FRV
#define ELF_MAXPAGESIZE 0x1000
#define TARGET_BIG_SYM bfd_elf32_frv_vec
#define TARGET_BIG_NAME "elf32-frv"
#define elf_info_to_howto_rel frv_info_to_howto_rel
#define elf_info_to_howto frv_info_to_howto_rela
#define elf_backend_relocate_section elf32_frv_relocate_section
#define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook
#define elf_backend_gc_sweep_hook elf32_frv_gc_sweep_hook
#define elf_backend_check_relocs elf32_frv_check_relocs
#define elf_backend_object_p elf32_frv_object_p
#define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
#define elf_backend_can_gc_sections 1
#define elf_backend_rela_normal 1
#define bfd_elf32_bfd_reloc_type_lookup frv_reloc_type_lookup
#define bfd_elf32_bfd_set_private_flags frv_elf_set_private_flags
#define bfd_elf32_bfd_copy_private_bfd_data frv_elf_copy_private_bfd_data
#define bfd_elf32_bfd_merge_private_bfd_data frv_elf_merge_private_bfd_data
#define bfd_elf32_bfd_print_private_bfd_data frv_elf_print_private_bfd_data
#define bfd_elf32_bfd_link_hash_table_create frv_elf_link_hash_table_create
#define elf_backend_always_size_sections \
elf32_frv_always_size_sections
#define elf_backend_modify_segment_map \
elf32_frv_modify_segment_map
#define elf_backend_create_dynamic_sections \
elf32_frv_create_dynamic_sections
#define elf_backend_adjust_dynamic_symbol \
elf32_frv_adjust_dynamic_symbol
#define elf_backend_size_dynamic_sections \
elf32_frv_size_dynamic_sections
#define elf_backend_finish_dynamic_symbol \
elf32_frv_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections \
elf32_frv_finish_dynamic_sections
#define elf_backend_want_got_sym 1
#define elf_backend_got_header_size 0
#define elf_backend_want_got_plt 0
#define elf_backend_plt_readonly 1
#define elf_backend_want_plt_sym 0
#define elf_backend_plt_header_size 0
#define elf_backend_can_make_relative_eh_frame \
frv_elf_use_relative_eh_frame
#define elf_backend_can_make_lsda_relative_eh_frame \
frv_elf_use_relative_eh_frame
#define elf_backend_encode_eh_address frv_elf_encode_eh_address
#define elf_backend_may_use_rel_p 1
#define elf_backend_may_use_rela_p 1
#define elf_backend_default_use_rela_p 1
#include "elf32-target.h"