/* SPU specific support for 32-bit ELF
- Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
{
Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[j];
- if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (shdr, phdr))
+ if (ELF_SECTION_SIZE (shdr, phdr) != 0
+ && ELF_SECTION_IN_SEGMENT (shdr, phdr))
{
asection *sec = shdr->bfd_section;
spu_elf_section_data (sec)->u.o.ovl_index = num_ovl;
/* How much memory we have. */
unsigned int local_store;
- /* Local store --auto-overlay should reserve for non-overlay
- functions and data. */
- unsigned int overlay_fixed;
- /* Local store --auto-overlay should reserve for stack and heap. */
- unsigned int reserved;
- /* If reserved is not specified, stack analysis will calculate a value
- for the stack. This parameter adjusts that value to allow for
- negative sp access (the ABI says 2000 bytes below sp are valid,
- and the overlay manager uses some of this area). */
- int extra_stack_space;
+
/* Count of overlay stubs needed in non-overlay area. */
unsigned int non_ovly_stub;
};
#define spu_hash_table(p) \
- ((struct spu_link_hash_table *) ((p)->hash))
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == SPU_ELF_DATA ? ((struct spu_link_hash_table *) ((p)->hash)) : NULL)
struct call_info
{
if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
_bfd_elf_link_hash_newfunc,
- sizeof (struct elf_link_hash_entry)))
+ sizeof (struct elf_link_hash_entry),
+ SPU_ELF_DATA))
{
free (htab);
return NULL;
{
asection *s;
flagword flags;
- ibfd = info->input_bfds;
- flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY;
+
+ if (htab->elf.dynobj == NULL)
+ htab->elf.dynobj = ibfd;
+ ibfd = htab->elf.dynobj;
+ flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY | SEC_LINKER_CREATED);
s = bfd_make_section_anyway_with_flags (ibfd, ".fixup", flags);
if (s == NULL || !bfd_set_section_alignment (ibfd, s, 2))
return FALSE;
Elf_Internal_Sym *sym;
struct elf_link_hash_entry *h;
bfd_vma val;
- bfd_boolean reject, is_call;
+ bfd_boolean nonbranch, is_call;
struct function_info *caller;
struct call_info *callee;
- reject = FALSE;
r_type = ELF32_R_TYPE (irela->r_info);
- if (r_type != R_SPU_REL16
- && r_type != R_SPU_ADDR16)
- {
- reject = TRUE;
- if (!(call_tree && spu_hash_table (info)->params->auto_overlay))
- continue;
- }
+ nonbranch = r_type != R_SPU_REL16 && r_type != R_SPU_ADDR16;
r_indx = ELF32_R_SYM (irela->r_info);
if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
continue;
is_call = FALSE;
- if (!reject)
+ if (!nonbranch)
{
unsigned char insn[4];
}
else
{
- reject = TRUE;
- if (!(call_tree && spu_hash_table (info)->params->auto_overlay)
- || is_hint (insn))
+ nonbranch = TRUE;
+ if (is_hint (insn))
continue;
}
}
- if (reject)
+ if (nonbranch)
{
/* For --auto-overlay, count possible stubs we need for
function pointer references. */
else
sym_type = ELF_ST_TYPE (sym->st_info);
if (sym_type == STT_FUNC)
- spu_hash_table (info)->non_ovly_stub += 1;
- continue;
+ {
+ if (call_tree && spu_hash_table (info)->params->auto_overlay)
+ spu_hash_table (info)->non_ovly_stub += 1;
+ /* If the symbol type is STT_FUNC then this must be a
+ function pointer initialisation. */
+ continue;
+ }
+ /* Ignore data references. */
+ if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
+ != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
+ continue;
+ /* Otherwise we probably have a jump table reloc for
+ a switch statement or some other reference to a
+ code label. */
}
if (h)
callee->is_pasted = FALSE;
callee->broken_cycle = FALSE;
callee->priority = priority;
- callee->count = 1;
+ callee->count = nonbranch? 0 : 1;
if (callee->fun->last_caller != sec)
{
callee->fun->last_caller = sec;
bfd *const *abfd1 = a;
bfd *const *abfd2 = b;
- return strcmp ((*abfd1)->filename, (*abfd2)->filename);
+ return filename_cmp ((*abfd1)->filename, (*abfd2)->filename);
}
static unsigned int
bfd **bfd_arr;
struct elf_segment_map *m;
unsigned int fixed_size, lo, hi;
+ unsigned int reserved;
struct spu_link_hash_table *htab;
unsigned int base, i, count, bfd_count;
unsigned int region, ovlynum;
goto err_exit;
htab = spu_hash_table (info);
- if (htab->reserved == 0)
+ reserved = htab->params->auto_overlay_reserved;
+ if (reserved == 0)
{
struct _sum_stack_param sum_stack_param;
sum_stack_param.overall_stack = 0;
if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
goto err_exit;
- htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
+ reserved = (sum_stack_param.overall_stack
+ + htab->params->extra_stack_space);
}
/* No need for overlays if everything already fits. */
- if (fixed_size + htab->reserved <= htab->local_store
+ if (fixed_size + reserved <= htab->local_store
&& htab->params->ovly_flavour != ovly_soft_icache)
{
htab->params->auto_overlay = 0;
qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
for (i = 1; i < bfd_count; ++i)
- if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
+ if (filename_cmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
{
if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
{
}
free (bfd_arr);
- fixed_size += htab->reserved;
+ fixed_size += reserved;
fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
{
(bfd_vma) mos_param.max_overlay_size);
/* Now see if we should put some functions in the non-overlay area. */
- else if (fixed_size < htab->overlay_fixed)
+ else if (fixed_size < htab->params->auto_overlay_fixed)
{
unsigned int max_fixed, lib_size;
max_fixed = htab->local_store - mos_param.max_overlay_size;
- if (max_fixed > htab->overlay_fixed)
- max_fixed = htab->overlay_fixed;
+ if (max_fixed > htab->params->auto_overlay_fixed)
+ max_fixed = htab->params->auto_overlay_fixed;
lib_size = max_fixed - fixed_size;
lib_size = auto_ovl_lib_functions (info, lib_size);
if (lib_size == (unsigned int) -1)
struct call_info *call, *pasty;
struct _spu_elf_section_data *sec_data;
struct spu_elf_stack_info *sinfo;
- int k;
+ unsigned int k;
/* See whether we can add this section to the current
overlay without overflowing our overlay buffer. */
{
/* Pasted sections must stay together, so add their
sizes too. */
- struct call_info *pasty = find_pasted_call (sec);
+ pasty = find_pasted_call (sec);
while (pasty != NULL)
{
struct function_info *call_fun = pasty->fun;
pasty = NULL;
sec_data = spu_elf_section_data (sec);
sinfo = sec_data->u.i.stack_info;
- for (k = 0; k < sinfo->num_fun; ++k)
+ for (k = 0; k < (unsigned) sinfo->num_fun; ++k)
for (call = sinfo->fun[k].call_list; call; call = call->next)
if (call->is_pasted)
{
num_stubs = 0;
for (call = dummy_caller.call_list; call; call = call->next)
{
- unsigned int k;
unsigned int stub_delta = 1;
if (htab->params->ovly_flavour == ovly_soft_icache)
bfd_vma addend;
bfd_reloc_status_type r;
bfd_boolean unresolved_reloc;
- bfd_boolean warned;
enum _stub_type stub_type;
r_symndx = ELF32_R_SYM (rel->r_info);
r_type = ELF32_R_TYPE (rel->r_info);
howto = elf_howto_table + r_type;
unresolved_reloc = FALSE;
- warned = FALSE;
h = NULL;
sym = NULL;
sec = NULL;
input_section,
rel->r_offset, err))
return FALSE;
- warned = TRUE;
}
sym_name = h->root.root.string;
}
if (sec != NULL && elf_discarded_section (sec))
- {
- /* For relocs against symbols from removed linkonce sections,
- or sections discarded by a linker script, we just want the
- section contents zeroed. Avoid any special processing. */
- _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
- rel->r_info = 0;
- rel->r_addend = 0;
- continue;
- }
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rel, relend, howto, contents);
if (info->relocatable)
continue;
}
input_section->reloc_count = wrel - relocs;
/* Backflips for _bfd_elf_link_output_relocs. */
- rel_hdr = &elf_section_data (input_section)->rel_hdr;
+ rel_hdr = _bfd_elf_single_rel_hdr (input_section);
rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
ret = 2;
}
return ret;
}
+static bfd_boolean
+spu_elf_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info ATTRIBUTE_UNUSED)
+{
+ return TRUE;
+}
+
/* Adjust _SPUEAR_ syms to point at their overlay stubs. */
static int
if ((*p)->p_type == PT_LOAD && (*p)->count == 1
&& spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
{
- struct elf_segment_map *m = *p;
+ m = *p;
*p = m->next;
*p_overlay = m;
p_overlay = &m->next;
/* If there aren't any relocs, then there's nothing more
to do. */
- if ((isec->flags & SEC_RELOC) == 0
+ if ((isec->flags & SEC_ALLOC) == 0
+ || (isec->flags & SEC_RELOC) == 0
|| isec->reloc_count == 0)
continue;
#define TARGET_BIG_SYM bfd_elf32_spu_vec
#define TARGET_BIG_NAME "elf32-spu"
#define ELF_ARCH bfd_arch_spu
+#define ELF_TARGET_ID SPU_ELF_DATA
#define ELF_MACHINE_CODE EM_SPU
/* This matches the alignment need for DMA. */
#define ELF_MAXPAGESIZE 0x80
#define elf_info_to_howto spu_elf_info_to_howto
#define elf_backend_count_relocs spu_elf_count_relocs
#define elf_backend_relocate_section spu_elf_relocate_section
+#define elf_backend_finish_dynamic_sections spu_elf_finish_dynamic_sections
#define elf_backend_symbol_processing spu_elf_backend_symbol_processing
#define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
#define elf_backend_object_p spu_elf_object_p
projects / deliverable / binutils-gdb.git / blobdiff