/* SPU specific support for 32-bit ELF
- Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
- Free Software Foundation, Inc.
+ Copyright (C) 2006-2016 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
array, so it must be declared in the order of that type. */
static reloc_howto_type elf_howto_table[] = {
- HOWTO (R_SPU_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
+ HOWTO (R_SPU_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
bfd_elf_generic_reloc, "SPU_NONE",
FALSE, 0, 0x00000000, FALSE),
HOWTO (R_SPU_ADDR10, 4, 2, 10, FALSE, 14, complain_overflow_bitfield,
switch (code)
{
default:
+ return (enum elf_spu_reloc_type) -1;
+ case BFD_RELOC_NONE:
return R_SPU_NONE;
case BFD_RELOC_SPU_IMM10W:
return R_SPU_ADDR10;
enum elf_spu_reloc_type r_type;
r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
- BFD_ASSERT (r_type < R_SPU_max);
+ /* PR 17512: file: 90c2a92e. */
+ if (r_type >= R_SPU_max)
+ {
+ (*_bfd_error_handler) (_("%B: unrecognised SPU reloc number: %d"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ r_type = R_SPU_NONE;
+ }
cache_ptr->howto = &elf_howto_table[(int) r_type];
}
{
enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
- if (r_type == R_SPU_NONE)
+ if (r_type == (enum elf_spu_reloc_type) -1)
return NULL;
return elf_howto_table + r_type;
{
struct spu_link_hash_table *htab;
- htab = bfd_malloc (sizeof (*htab));
+ htab = bfd_zmalloc (sizeof (*htab));
if (htab == NULL)
return NULL;
return NULL;
}
- memset (&htab->ovtab, 0,
- sizeof (*htab) - offsetof (struct spu_link_hash_table, ovtab));
-
htab->elf.init_got_refcount.refcount = 0;
htab->elf.init_got_refcount.glist = NULL;
htab->elf.init_got_offset.offset = 0;
struct spu_link_hash_table *htab = spu_hash_table (info);
bfd *ibfd;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
break;
}
/* Support two sizes of overlay stubs, a slower more compact stub of two
- intructions, and a faster stub of four instructions.
+ instructions, and a faster stub of four instructions.
Soft-icache stubs are four or eight words. */
static unsigned int
struct spu_link_hash_table *htab = spu_hash_table (info);
bfd *ibfd;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
Elf_Internal_Shdr *symtab_hdr;
asection *isec;
Elf_Internal_Sym *local_syms = NULL;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
/* We'll need the symbol table in a second. */
return count;
}
+static int
+ovl_mgr_stat (struct bfd *abfd ATTRIBUTE_UNUSED,
+ void *stream,
+ struct stat *sb)
+{
+ struct _ovl_stream *os = (struct _ovl_stream *) stream;
+
+ memset (sb, 0, sizeof (*sb));
+ sb->st_size = (const char *) os->end - (const char *) os->start;
+ return 0;
+}
+
bfd_boolean
spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
{
(void *) stream,
ovl_mgr_pread,
NULL,
- NULL);
+ ovl_mgr_stat);
return *ovl_bfd != NULL;
}
htab->local_store = hi + 1 - lo;
- for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
+ for (m = elf_seg_map (abfd); m != NULL; m = m->next)
if (m->p_type == PT_LOAD)
for (i = 0; i < m->count; i++)
if (m->sections[i]->size != 0
bfd_boolean gaps = FALSE;
bfd_idx = 0;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
bfd_idx++;
psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
for (ibfd = info->input_bfds, bfd_idx = 0;
ibfd != NULL;
- ibfd = ibfd->link_next, bfd_idx++)
+ ibfd = ibfd->link.next, bfd_idx++)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
Elf_Internal_Shdr *symtab_hdr;
asection *sec;
size_t symcount;
Elf_Internal_Sym *syms, *sy, **psyms, **psy;
asection **psecs, **p;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
/* Read all the symbols. */
relocations. */
for (ibfd = info->input_bfds, bfd_idx = 0;
ibfd != NULL;
- ibfd = ibfd->link_next, bfd_idx++)
+ ibfd = ibfd->link.next, bfd_idx++)
{
asection *sec;
for (ibfd = info->input_bfds, bfd_idx = 0;
ibfd != NULL;
- ibfd = ibfd->link_next, bfd_idx++)
+ ibfd = ibfd->link.next, bfd_idx++)
{
Elf_Internal_Shdr *symtab_hdr;
asection *sec;
}
}
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
asection *sec;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
/* Some of the symbols we've installed as marking the
for (ibfd = info->input_bfds, bfd_idx = 0;
ibfd != NULL;
- ibfd = ibfd->link_next, bfd_idx++)
+ ibfd = ibfd->link.next, bfd_idx++)
{
if (psym_arr[bfd_idx] == NULL)
continue;
{
bfd *ibfd;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
asection *sec;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
bfd *ibfd;
unsigned int depth;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
asection *sec;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
memset (&dummy_caller, 0, sizeof (dummy_caller));
lib_count = 0;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
asection *sec;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
/* Find the extents of our loadable image. */
lo = (unsigned int) -1;
hi = 0;
- for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
+ for (m = elf_seg_map (info->output_bfd); m != NULL; m = m->next)
if (m->p_type == PT_LOAD)
for (i = 0; i < m->count; i++)
if (m->sections[i]->size != 0)
goto err_exit;
bfd_count = 0;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
++bfd_count;
bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
if (bfd_arr == NULL)
count = 0;
bfd_count = 0;
total_overlay_size = 0;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
- extern const bfd_target bfd_elf32_spu_vec;
+ extern const bfd_target spu_elf32_vec;
asection *sec;
unsigned int old_count;
- if (ibfd->xvec != &bfd_elf32_spu_vec)
+ if (ibfd->xvec != &spu_elf32_vec)
continue;
old_count = count;
return bfd_elf_final_link (output_bfd, info);
}
-/* Called when not normally emitting relocs, ie. !info->relocatable
+/* Called when not normally emitting relocs, ie. !bfd_link_relocatable (info)
and !info->emitrelocations. Returns a count of special relocs
that need to be emitted. */
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ if (info->wrap_hash != NULL
+ && (input_section->flags & SEC_DEBUGGING) != 0)
+ h = ((struct elf_link_hash_entry *)
+ unwrap_hash_lookup (info, input_bfd, &h->root));
+
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;
else if (info->unresolved_syms_in_objects == RM_IGNORE
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
;
- else if (!info->relocatable
+ else if (!bfd_link_relocatable (info)
&& !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
{
bfd_boolean err;
err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
|| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
- if (!info->callbacks->undefined_symbol (info,
- h->root.root.string,
- input_bfd,
- input_section,
- rel->r_offset, err))
- return FALSE;
+ (*info->callbacks->undefined_symbol) (info,
+ h->root.root.string,
+ input_bfd,
+ input_section,
+ rel->r_offset, err);
}
sym_name = h->root.root.string;
}
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
/* Change "a rt,ra,rb" to "ai rt,ra,0". */
}
}
- if (htab->params->emit_fixups && !info->relocatable
+ if (htab->params->emit_fixups && !bfd_link_relocatable (info)
&& (input_section->flags & SEC_ALLOC) != 0
&& r_type == R_SPU_ADDR32)
{
switch (r)
{
case bfd_reloc_overflow:
- if (!((*info->callbacks->reloc_overflow)
- (info, (h ? &h->root : NULL), sym_name, howto->name,
- (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
- return FALSE;
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root : NULL), sym_name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- if (!((*info->callbacks->undefined_symbol)
- (info, sym_name, input_bfd, input_section,
- rel->r_offset, TRUE)))
- return FALSE;
+ (*info->callbacks->undefined_symbol)
+ (info, sym_name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_outofrange:
common_error:
ret = FALSE;
- if (!((*info->callbacks->warning)
- (info, msg, sym_name, input_bfd, input_section,
- rel->r_offset)))
- return FALSE;
+ (*info->callbacks->warning) (info, msg, sym_name, input_bfd,
+ input_section, rel->r_offset);
break;
}
}
{
struct spu_link_hash_table *htab = spu_hash_table (info);
- if (!info->relocatable
+ if (!bfd_link_relocatable (info)
&& htab->stub_sec != NULL
&& h != NULL
&& (h->root.type == bfd_link_hash_defined
/* Set ELF header e_type for plugins. */
static void
-spu_elf_post_process_headers (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED)
+spu_elf_post_process_headers (bfd *abfd, struct bfd_link_info *info)
{
if (spu_plugin)
{
i_ehdrp->e_type = ET_DYN;
}
+
+ _bfd_elf_post_process_headers (abfd, info);
}
/* We may add an extra PT_LOAD segment for .toe. We also need extra
return TRUE;
toe = bfd_get_section_by_name (abfd, ".toe");
- for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
+ for (m = elf_seg_map (abfd); m != NULL; m = m->next)
if (m->p_type == PT_LOAD && m->count > 1)
for (i = 0; i < m->count; i++)
if ((s = m->sections[i]) == toe
as PF_OVERLAY) will be placed into SPU local store on startup. */
/* Move all overlay segments onto a separate list. */
- p = &elf_tdata (abfd)->segment_map;
+ p = &elf_seg_map (abfd);
p_overlay = &m_overlay;
while (*p != NULL)
{
}
/* Re-insert overlay segments at the head of the segment map. */
- *p_overlay = elf_tdata (abfd)->segment_map;
- elf_tdata (abfd)->segment_map = m_overlay;
+ *p_overlay = elf_seg_map (abfd);
+ elf_seg_map (abfd) = m_overlay;
return TRUE;
}
bed = get_elf_backend_data (abfd);
tdata = elf_tdata (abfd);
phdr = tdata->phdr;
- count = tdata->program_header_size / bed->s->sizeof_phdr;
+ count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
htab = spu_hash_table (info);
if (htab->num_overlays != 0)
{
struct elf_segment_map *m;
unsigned int o;
- for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
+ for (i = 0, m = elf_seg_map (abfd); m; ++i, m = m->next)
if (m->count != 0
&& (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
{
bfd *ibfd;
size_t size;
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
asection *isec;
return TRUE;
}
-#define TARGET_BIG_SYM bfd_elf32_spu_vec
+#define TARGET_BIG_SYM spu_elf32_vec
#define TARGET_BIG_NAME "elf32-spu"
#define ELF_ARCH bfd_arch_spu
#define ELF_TARGET_ID SPU_ELF_DATA