1
/* SPU specific support for 32-bit ELF
3
Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
4
Free Software Foundation, Inc.
6
This file is part of BFD, the Binary File Descriptor library.
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 3 of the License, or
11
(at your option) any later version.
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
18
You should have received a copy of the GNU General Public License along
19
with this program; if not, write to the Free Software Foundation, Inc.,
20
51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
#include "libiberty.h"
29
#include "elf32-spu.h"
31
/* We use RELA style relocs. Don't define USE_REL. */
33
static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
37
/* Values of type 'enum elf_spu_reloc_type' are used to index this
38
array, so it must be declared in the order of that type. */
40
static reloc_howto_type elf_howto_table[] = {
41
HOWTO (R_SPU_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
42
bfd_elf_generic_reloc, "SPU_NONE",
43
FALSE, 0, 0x00000000, FALSE),
44
HOWTO (R_SPU_ADDR10, 4, 2, 10, FALSE, 14, complain_overflow_bitfield,
45
bfd_elf_generic_reloc, "SPU_ADDR10",
46
FALSE, 0, 0x00ffc000, FALSE),
47
HOWTO (R_SPU_ADDR16, 2, 2, 16, FALSE, 7, complain_overflow_bitfield,
48
bfd_elf_generic_reloc, "SPU_ADDR16",
49
FALSE, 0, 0x007fff80, FALSE),
50
HOWTO (R_SPU_ADDR16_HI, 16, 2, 16, FALSE, 7, complain_overflow_bitfield,
51
bfd_elf_generic_reloc, "SPU_ADDR16_HI",
52
FALSE, 0, 0x007fff80, FALSE),
53
HOWTO (R_SPU_ADDR16_LO, 0, 2, 16, FALSE, 7, complain_overflow_dont,
54
bfd_elf_generic_reloc, "SPU_ADDR16_LO",
55
FALSE, 0, 0x007fff80, FALSE),
56
HOWTO (R_SPU_ADDR18, 0, 2, 18, FALSE, 7, complain_overflow_bitfield,
57
bfd_elf_generic_reloc, "SPU_ADDR18",
58
FALSE, 0, 0x01ffff80, FALSE),
59
HOWTO (R_SPU_ADDR32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
60
bfd_elf_generic_reloc, "SPU_ADDR32",
61
FALSE, 0, 0xffffffff, FALSE),
62
HOWTO (R_SPU_REL16, 2, 2, 16, TRUE, 7, complain_overflow_bitfield,
63
bfd_elf_generic_reloc, "SPU_REL16",
64
FALSE, 0, 0x007fff80, TRUE),
65
HOWTO (R_SPU_ADDR7, 0, 2, 7, FALSE, 14, complain_overflow_dont,
66
bfd_elf_generic_reloc, "SPU_ADDR7",
67
FALSE, 0, 0x001fc000, FALSE),
68
HOWTO (R_SPU_REL9, 2, 2, 9, TRUE, 0, complain_overflow_signed,
69
spu_elf_rel9, "SPU_REL9",
70
FALSE, 0, 0x0180007f, TRUE),
71
HOWTO (R_SPU_REL9I, 2, 2, 9, TRUE, 0, complain_overflow_signed,
72
spu_elf_rel9, "SPU_REL9I",
73
FALSE, 0, 0x0000c07f, TRUE),
74
HOWTO (R_SPU_ADDR10I, 0, 2, 10, FALSE, 14, complain_overflow_signed,
75
bfd_elf_generic_reloc, "SPU_ADDR10I",
76
FALSE, 0, 0x00ffc000, FALSE),
77
HOWTO (R_SPU_ADDR16I, 0, 2, 16, FALSE, 7, complain_overflow_signed,
78
bfd_elf_generic_reloc, "SPU_ADDR16I",
79
FALSE, 0, 0x007fff80, FALSE),
80
HOWTO (R_SPU_REL32, 0, 2, 32, TRUE, 0, complain_overflow_dont,
81
bfd_elf_generic_reloc, "SPU_REL32",
82
FALSE, 0, 0xffffffff, TRUE),
83
HOWTO (R_SPU_ADDR16X, 0, 2, 16, FALSE, 7, complain_overflow_bitfield,
84
bfd_elf_generic_reloc, "SPU_ADDR16X",
85
FALSE, 0, 0x007fff80, FALSE),
86
HOWTO (R_SPU_PPU32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
87
bfd_elf_generic_reloc, "SPU_PPU32",
88
FALSE, 0, 0xffffffff, FALSE),
89
HOWTO (R_SPU_PPU64, 0, 4, 64, FALSE, 0, complain_overflow_dont,
90
bfd_elf_generic_reloc, "SPU_PPU64",
92
HOWTO (R_SPU_ADD_PIC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
93
bfd_elf_generic_reloc, "SPU_ADD_PIC",
94
FALSE, 0, 0x00000000, FALSE),
97
static struct bfd_elf_special_section const spu_elf_special_sections[] = {
98
{ "._ea", 4, 0, SHT_PROGBITS, SHF_WRITE },
99
{ ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
103
static enum elf_spu_reloc_type
104
spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
110
case BFD_RELOC_SPU_IMM10W:
112
case BFD_RELOC_SPU_IMM16W:
114
case BFD_RELOC_SPU_LO16:
115
return R_SPU_ADDR16_LO;
116
case BFD_RELOC_SPU_HI16:
117
return R_SPU_ADDR16_HI;
118
case BFD_RELOC_SPU_IMM18:
120
case BFD_RELOC_SPU_PCREL16:
122
case BFD_RELOC_SPU_IMM7:
124
case BFD_RELOC_SPU_IMM8:
126
case BFD_RELOC_SPU_PCREL9a:
128
case BFD_RELOC_SPU_PCREL9b:
130
case BFD_RELOC_SPU_IMM10:
131
return R_SPU_ADDR10I;
132
case BFD_RELOC_SPU_IMM16:
133
return R_SPU_ADDR16I;
136
case BFD_RELOC_32_PCREL:
138
case BFD_RELOC_SPU_PPU32:
140
case BFD_RELOC_SPU_PPU64:
142
case BFD_RELOC_SPU_ADD_PIC:
143
return R_SPU_ADD_PIC;
148
spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
150
Elf_Internal_Rela *dst)
152
enum elf_spu_reloc_type r_type;
154
r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
155
BFD_ASSERT (r_type < R_SPU_max);
156
cache_ptr->howto = &elf_howto_table[(int) r_type];
159
static reloc_howto_type *
160
spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
161
bfd_reloc_code_real_type code)
163
enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
165
if (r_type == R_SPU_NONE)
168
return elf_howto_table + r_type;
171
static reloc_howto_type *
172
spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
177
for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
178
if (elf_howto_table[i].name != NULL
179
&& strcasecmp (elf_howto_table[i].name, r_name) == 0)
180
return &elf_howto_table[i];
185
/* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
187
static bfd_reloc_status_type
188
spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
189
void *data, asection *input_section,
190
bfd *output_bfd, char **error_message)
192
bfd_size_type octets;
196
/* If this is a relocatable link (output_bfd test tells us), just
197
call the generic function. Any adjustment will be done at final
199
if (output_bfd != NULL)
200
return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
201
input_section, output_bfd, error_message);
203
if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
204
return bfd_reloc_outofrange;
205
octets = reloc_entry->address * bfd_octets_per_byte (abfd);
207
/* Get symbol value. */
209
if (!bfd_is_com_section (symbol->section))
211
if (symbol->section->output_section)
212
val += symbol->section->output_section->vma;
214
val += reloc_entry->addend;
216
/* Make it pc-relative. */
217
val -= input_section->output_section->vma + input_section->output_offset;
220
if (val + 256 >= 512)
221
return bfd_reloc_overflow;
223
insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
225
/* Move two high bits of value to REL9I and REL9 position.
226
The mask will take care of selecting the right field. */
227
val = (val & 0x7f) | ((val & 0x180) << 7) | ((val & 0x180) << 16);
228
insn &= ~reloc_entry->howto->dst_mask;
229
insn |= val & reloc_entry->howto->dst_mask;
230
bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
235
spu_elf_new_section_hook (bfd *abfd, asection *sec)
237
if (!sec->used_by_bfd)
239
struct _spu_elf_section_data *sdata;
241
sdata = bfd_zalloc (abfd, sizeof (*sdata));
244
sec->used_by_bfd = sdata;
247
return _bfd_elf_new_section_hook (abfd, sec);
250
/* Set up overlay info for executables. */
253
spu_elf_object_p (bfd *abfd)
255
if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
257
unsigned int i, num_ovl, num_buf;
258
Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
259
Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
260
Elf_Internal_Phdr *last_phdr = NULL;
262
for (num_buf = 0, num_ovl = 0, i = 0; i < ehdr->e_phnum; i++, phdr++)
263
if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_OVERLAY) != 0)
268
if (last_phdr == NULL
269
|| ((last_phdr->p_vaddr ^ phdr->p_vaddr) & 0x3ffff) != 0)
272
for (j = 1; j < elf_numsections (abfd); j++)
274
Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[j];
276
if (ELF_SECTION_SIZE (shdr, phdr) != 0
277
&& ELF_SECTION_IN_SEGMENT (shdr, phdr))
279
asection *sec = shdr->bfd_section;
280
spu_elf_section_data (sec)->u.o.ovl_index = num_ovl;
281
spu_elf_section_data (sec)->u.o.ovl_buf = num_buf;
289
/* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
290
strip --strip-unneeded will not remove them. */
293
spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
295
if (sym->name != NULL
296
&& sym->section != bfd_abs_section_ptr
297
&& strncmp (sym->name, "_EAR_", 5) == 0)
298
sym->flags |= BSF_KEEP;
301
/* SPU ELF linker hash table. */
303
struct spu_link_hash_table
305
struct elf_link_hash_table elf;
307
struct spu_elf_params *params;
309
/* Shortcuts to overlay sections. */
315
/* Count of stubs in each overlay section. */
316
unsigned int *stub_count;
318
/* The stub section for each overlay section. */
321
struct elf_link_hash_entry *ovly_entry[2];
323
/* Number of overlay buffers. */
324
unsigned int num_buf;
326
/* Total number of overlays. */
327
unsigned int num_overlays;
329
/* For soft icache. */
330
unsigned int line_size_log2;
331
unsigned int num_lines_log2;
332
unsigned int fromelem_size_log2;
334
/* How much memory we have. */
335
unsigned int local_store;
337
/* Count of overlay stubs needed in non-overlay area. */
338
unsigned int non_ovly_stub;
340
/* Pointer to the fixup section */
344
unsigned int stub_err : 1;
347
/* Hijack the generic got fields for overlay stub accounting. */
351
struct got_entry *next;
360
#define spu_hash_table(p) \
361
(elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
362
== SPU_ELF_DATA ? ((struct spu_link_hash_table *) ((p)->hash)) : NULL)
366
struct function_info *fun;
367
struct call_info *next;
369
unsigned int max_depth;
370
unsigned int is_tail : 1;
371
unsigned int is_pasted : 1;
372
unsigned int broken_cycle : 1;
373
unsigned int priority : 13;
378
/* List of functions called. Also branches to hot/cold part of
380
struct call_info *call_list;
381
/* For hot/cold part of function, point to owner. */
382
struct function_info *start;
383
/* Symbol at start of function. */
385
Elf_Internal_Sym *sym;
386
struct elf_link_hash_entry *h;
388
/* Function section. */
391
/* Where last called from, and number of sections called from. */
392
asection *last_caller;
393
unsigned int call_count;
394
/* Address range of (this part of) function. */
396
/* Offset where we found a store of lr, or -1 if none found. */
398
/* Offset where we found the stack adjustment insn. */
402
/* Distance from root of call tree. Tail and hot/cold branches
403
count as one deeper. We aren't counting stack frames here. */
405
/* Set if global symbol. */
406
unsigned int global : 1;
407
/* Set if known to be start of function (as distinct from a hunk
408
in hot/cold section. */
409
unsigned int is_func : 1;
410
/* Set if not a root node. */
411
unsigned int non_root : 1;
412
/* Flags used during call tree traversal. It's cheaper to replicate
413
the visit flags than have one which needs clearing after a traversal. */
414
unsigned int visit1 : 1;
415
unsigned int visit2 : 1;
416
unsigned int marking : 1;
417
unsigned int visit3 : 1;
418
unsigned int visit4 : 1;
419
unsigned int visit5 : 1;
420
unsigned int visit6 : 1;
421
unsigned int visit7 : 1;
424
struct spu_elf_stack_info
428
/* Variable size array describing functions, one per contiguous
429
address range belonging to a function. */
430
struct function_info fun[1];
433
static struct function_info *find_function (asection *, bfd_vma,
434
struct bfd_link_info *);
436
/* Create a spu ELF linker hash table. */
438
static struct bfd_link_hash_table *
439
spu_elf_link_hash_table_create (bfd *abfd)
441
struct spu_link_hash_table *htab;
443
htab = bfd_zmalloc (sizeof (*htab));
447
if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
448
_bfd_elf_link_hash_newfunc,
449
sizeof (struct elf_link_hash_entry),
456
htab->elf.init_got_refcount.refcount = 0;
457
htab->elf.init_got_refcount.glist = NULL;
458
htab->elf.init_got_offset.offset = 0;
459
htab->elf.init_got_offset.glist = NULL;
460
return &htab->elf.root;
464
spu_elf_setup (struct bfd_link_info *info, struct spu_elf_params *params)
466
bfd_vma max_branch_log2;
468
struct spu_link_hash_table *htab = spu_hash_table (info);
469
htab->params = params;
470
htab->line_size_log2 = bfd_log2 (htab->params->line_size);
471
htab->num_lines_log2 = bfd_log2 (htab->params->num_lines);
473
/* For the software i-cache, we provide a "from" list whose size
474
is a power-of-two number of quadwords, big enough to hold one
475
byte per outgoing branch. Compute this number here. */
476
max_branch_log2 = bfd_log2 (htab->params->max_branch);
477
htab->fromelem_size_log2 = max_branch_log2 > 4 ? max_branch_log2 - 4 : 0;
480
/* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
481
to (hash, NULL) for global symbols, and (NULL, sym) for locals. Set
482
*SYMSECP to the symbol's section. *LOCSYMSP caches local syms. */
485
get_sym_h (struct elf_link_hash_entry **hp,
486
Elf_Internal_Sym **symp,
488
Elf_Internal_Sym **locsymsp,
489
unsigned long r_symndx,
492
Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
494
if (r_symndx >= symtab_hdr->sh_info)
496
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
497
struct elf_link_hash_entry *h;
499
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
500
while (h->root.type == bfd_link_hash_indirect
501
|| h->root.type == bfd_link_hash_warning)
502
h = (struct elf_link_hash_entry *) h->root.u.i.link;
512
asection *symsec = NULL;
513
if (h->root.type == bfd_link_hash_defined
514
|| h->root.type == bfd_link_hash_defweak)
515
symsec = h->root.u.def.section;
521
Elf_Internal_Sym *sym;
522
Elf_Internal_Sym *locsyms = *locsymsp;
526
locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
528
locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
530
0, NULL, NULL, NULL);
535
sym = locsyms + r_symndx;
544
*symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
550
/* Create the note section if not already present. This is done early so
551
that the linker maps the sections to the right place in the output. */
554
spu_elf_create_sections (struct bfd_link_info *info)
556
struct spu_link_hash_table *htab = spu_hash_table (info);
559
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
560
if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
565
/* Make SPU_PTNOTE_SPUNAME section. */
572
ibfd = info->input_bfds;
573
flags = SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
574
s = bfd_make_section_anyway_with_flags (ibfd, SPU_PTNOTE_SPUNAME, flags);
576
|| !bfd_set_section_alignment (ibfd, s, 4))
579
name_len = strlen (bfd_get_filename (info->output_bfd)) + 1;
580
size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
581
size += (name_len + 3) & -4;
583
if (!bfd_set_section_size (ibfd, s, size))
586
data = bfd_zalloc (ibfd, size);
590
bfd_put_32 (ibfd, sizeof (SPU_PLUGIN_NAME), data + 0);
591
bfd_put_32 (ibfd, name_len, data + 4);
592
bfd_put_32 (ibfd, 1, data + 8);
593
memcpy (data + 12, SPU_PLUGIN_NAME, sizeof (SPU_PLUGIN_NAME));
594
memcpy (data + 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4),
595
bfd_get_filename (info->output_bfd), name_len);
599
if (htab->params->emit_fixups)
604
if (htab->elf.dynobj == NULL)
605
htab->elf.dynobj = ibfd;
606
ibfd = htab->elf.dynobj;
607
flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY | SEC_HAS_CONTENTS
608
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
609
s = bfd_make_section_anyway_with_flags (ibfd, ".fixup", flags);
610
if (s == NULL || !bfd_set_section_alignment (ibfd, s, 2))
618
/* qsort predicate to sort sections by vma. */
621
sort_sections (const void *a, const void *b)
623
const asection *const *s1 = a;
624
const asection *const *s2 = b;
625
bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
628
return delta < 0 ? -1 : 1;
630
return (*s1)->index - (*s2)->index;
633
/* Identify overlays in the output bfd, and number them.
634
Returns 0 on error, 1 if no overlays, 2 if overlays. */
637
spu_elf_find_overlays (struct bfd_link_info *info)
639
struct spu_link_hash_table *htab = spu_hash_table (info);
640
asection **alloc_sec;
641
unsigned int i, n, ovl_index, num_buf;
644
static const char *const entry_names[2][2] = {
645
{ "__ovly_load", "__icache_br_handler" },
646
{ "__ovly_return", "__icache_call_handler" }
649
if (info->output_bfd->section_count < 2)
653
= bfd_malloc (info->output_bfd->section_count * sizeof (*alloc_sec));
654
if (alloc_sec == NULL)
657
/* Pick out all the alloced sections. */
658
for (n = 0, s = info->output_bfd->sections; s != NULL; s = s->next)
659
if ((s->flags & SEC_ALLOC) != 0
660
&& (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
670
/* Sort them by vma. */
671
qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
673
ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
674
if (htab->params->ovly_flavour == ovly_soft_icache)
676
unsigned int prev_buf = 0, set_id = 0;
678
/* Look for an overlapping vma to find the first overlay section. */
679
bfd_vma vma_start = 0;
681
for (i = 1; i < n; i++)
684
if (s->vma < ovl_end)
686
asection *s0 = alloc_sec[i - 1];
690
<< (htab->num_lines_log2 + htab->line_size_log2)));
695
ovl_end = s->vma + s->size;
698
/* Now find any sections within the cache area. */
699
for (ovl_index = 0, num_buf = 0; i < n; i++)
702
if (s->vma >= ovl_end)
705
/* A section in an overlay area called .ovl.init is not
706
an overlay, in the sense that it might be loaded in
707
by the overlay manager, but rather the initial
708
section contents for the overlay buffer. */
709
if (strncmp (s->name, ".ovl.init", 9) != 0)
711
num_buf = ((s->vma - vma_start) >> htab->line_size_log2) + 1;
712
set_id = (num_buf == prev_buf)? set_id + 1 : 0;
715
if ((s->vma - vma_start) & (htab->params->line_size - 1))
717
info->callbacks->einfo (_("%X%P: overlay section %A "
718
"does not start on a cache line.\n"),
720
bfd_set_error (bfd_error_bad_value);
723
else if (s->size > htab->params->line_size)
725
info->callbacks->einfo (_("%X%P: overlay section %A "
726
"is larger than a cache line.\n"),
728
bfd_set_error (bfd_error_bad_value);
732
alloc_sec[ovl_index++] = s;
733
spu_elf_section_data (s)->u.o.ovl_index
734
= (set_id << htab->num_lines_log2) + num_buf;
735
spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
739
/* Ensure there are no more overlay sections. */
743
if (s->vma < ovl_end)
745
info->callbacks->einfo (_("%X%P: overlay section %A "
746
"is not in cache area.\n"),
748
bfd_set_error (bfd_error_bad_value);
752
ovl_end = s->vma + s->size;
757
/* Look for overlapping vmas. Any with overlap must be overlays.
758
Count them. Also count the number of overlay regions. */
759
for (ovl_index = 0, num_buf = 0, i = 1; i < n; i++)
762
if (s->vma < ovl_end)
764
asection *s0 = alloc_sec[i - 1];
766
if (spu_elf_section_data (s0)->u.o.ovl_index == 0)
769
if (strncmp (s0->name, ".ovl.init", 9) != 0)
771
alloc_sec[ovl_index] = s0;
772
spu_elf_section_data (s0)->u.o.ovl_index = ++ovl_index;
773
spu_elf_section_data (s0)->u.o.ovl_buf = num_buf;
776
ovl_end = s->vma + s->size;
778
if (strncmp (s->name, ".ovl.init", 9) != 0)
780
alloc_sec[ovl_index] = s;
781
spu_elf_section_data (s)->u.o.ovl_index = ++ovl_index;
782
spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
783
if (s0->vma != s->vma)
785
info->callbacks->einfo (_("%X%P: overlay sections %A "
786
"and %A do not start at the "
789
bfd_set_error (bfd_error_bad_value);
792
if (ovl_end < s->vma + s->size)
793
ovl_end = s->vma + s->size;
797
ovl_end = s->vma + s->size;
801
htab->num_overlays = ovl_index;
802
htab->num_buf = num_buf;
803
htab->ovl_sec = alloc_sec;
808
for (i = 0; i < 2; i++)
811
struct elf_link_hash_entry *h;
813
name = entry_names[i][htab->params->ovly_flavour];
814
h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
818
if (h->root.type == bfd_link_hash_new)
820
h->root.type = bfd_link_hash_undefined;
822
h->ref_regular_nonweak = 1;
825
htab->ovly_entry[i] = h;
831
/* Non-zero to use bra in overlay stubs rather than br. */
834
#define BRA 0x30000000
835
#define BRASL 0x31000000
836
#define BR 0x32000000
837
#define BRSL 0x33000000
838
#define NOP 0x40200000
839
#define LNOP 0x00200000
840
#define ILA 0x42000000
842
/* Return true for all relative and absolute branch instructions.
850
brhnz 00100011 0.. */
853
is_branch (const unsigned char *insn)
855
return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
858
/* Return true for all indirect branch instructions.
866
bihnz 00100101 011 */
869
is_indirect_branch (const unsigned char *insn)
871
return (insn[0] & 0xef) == 0x25 && (insn[1] & 0x80) == 0;
874
/* Return true for branch hint instructions.
879
is_hint (const unsigned char *insn)
881
return (insn[0] & 0xfc) == 0x10;
884
/* True if INPUT_SECTION might need overlay stubs. */
887
maybe_needs_stubs (asection *input_section)
889
/* No stubs for debug sections and suchlike. */
890
if ((input_section->flags & SEC_ALLOC) == 0)
893
/* No stubs for link-once sections that will be discarded. */
894
if (input_section->output_section == bfd_abs_section_ptr)
897
/* Don't create stubs for .eh_frame references. */
898
if (strcmp (input_section->name, ".eh_frame") == 0)
920
/* Return non-zero if this reloc symbol should go via an overlay stub.
921
Return 2 if the stub must be in non-overlay area. */
923
static enum _stub_type
924
needs_ovl_stub (struct elf_link_hash_entry *h,
925
Elf_Internal_Sym *sym,
927
asection *input_section,
928
Elf_Internal_Rela *irela,
930
struct bfd_link_info *info)
932
struct spu_link_hash_table *htab = spu_hash_table (info);
933
enum elf_spu_reloc_type r_type;
934
unsigned int sym_type;
935
bfd_boolean branch, hint, call;
936
enum _stub_type ret = no_stub;
940
|| sym_sec->output_section == bfd_abs_section_ptr
941
|| spu_elf_section_data (sym_sec->output_section) == NULL)
946
/* Ensure no stubs for user supplied overlay manager syms. */
947
if (h == htab->ovly_entry[0] || h == htab->ovly_entry[1])
950
/* setjmp always goes via an overlay stub, because then the return
951
and hence the longjmp goes via __ovly_return. That magically
952
makes setjmp/longjmp between overlays work. */
953
if (strncmp (h->root.root.string, "setjmp", 6) == 0
954
&& (h->root.root.string[6] == '\0' || h->root.root.string[6] == '@'))
961
sym_type = ELF_ST_TYPE (sym->st_info);
963
r_type = ELF32_R_TYPE (irela->r_info);
967
if (r_type == R_SPU_REL16 || r_type == R_SPU_ADDR16)
969
if (contents == NULL)
972
if (!bfd_get_section_contents (input_section->owner,
979
contents += irela->r_offset;
981
branch = is_branch (contents);
982
hint = is_hint (contents);
985
call = (contents[0] & 0xfd) == 0x31;
987
&& sym_type != STT_FUNC
990
/* It's common for people to write assembly and forget
991
to give function symbols the right type. Handle
992
calls to such symbols, but warn so that (hopefully)
993
people will fix their code. We need the symbol
994
type to be correct to distinguish function pointer
995
initialisation from other pointer initialisations. */
996
const char *sym_name;
999
sym_name = h->root.root.string;
1002
Elf_Internal_Shdr *symtab_hdr;
1003
symtab_hdr = &elf_tdata (input_section->owner)->symtab_hdr;
1004
sym_name = bfd_elf_sym_name (input_section->owner,
1009
(*_bfd_error_handler) (_("warning: call to non-function"
1010
" symbol %s defined in %B"),
1011
sym_sec->owner, sym_name);
1017
if ((!branch && htab->params->ovly_flavour == ovly_soft_icache)
1018
|| (sym_type != STT_FUNC
1019
&& !(branch || hint)
1020
&& (sym_sec->flags & SEC_CODE) == 0))
1023
/* Usually, symbols in non-overlay sections don't need stubs. */
1024
if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index == 0
1025
&& !htab->params->non_overlay_stubs)
1028
/* A reference from some other section to a symbol in an overlay
1029
section needs a stub. */
1030
if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index
1031
!= spu_elf_section_data (input_section->output_section)->u.o.ovl_index)
1033
unsigned int lrlive = 0;
1035
lrlive = (contents[1] & 0x70) >> 4;
1037
if (!lrlive && (call || sym_type == STT_FUNC))
1038
ret = call_ovl_stub;
1040
ret = br000_ovl_stub + lrlive;
1043
/* If this insn isn't a branch then we are possibly taking the
1044
address of a function and passing it out somehow. Soft-icache code
1045
always generates inline code to do indirect branches. */
1046
if (!(branch || hint)
1047
&& sym_type == STT_FUNC
1048
&& htab->params->ovly_flavour != ovly_soft_icache)
1055
count_stub (struct spu_link_hash_table *htab,
1058
enum _stub_type stub_type,
1059
struct elf_link_hash_entry *h,
1060
const Elf_Internal_Rela *irela)
1062
unsigned int ovl = 0;
1063
struct got_entry *g, **head;
1066
/* If this instruction is a branch or call, we need a stub
1067
for it. One stub per function per overlay.
1068
If it isn't a branch, then we are taking the address of
1069
this function so need a stub in the non-overlay area
1070
for it. One stub per function. */
1071
if (stub_type != nonovl_stub)
1072
ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1075
head = &h->got.glist;
1078
if (elf_local_got_ents (ibfd) == NULL)
1080
bfd_size_type amt = (elf_tdata (ibfd)->symtab_hdr.sh_info
1081
* sizeof (*elf_local_got_ents (ibfd)));
1082
elf_local_got_ents (ibfd) = bfd_zmalloc (amt);
1083
if (elf_local_got_ents (ibfd) == NULL)
1086
head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1089
if (htab->params->ovly_flavour == ovly_soft_icache)
1091
htab->stub_count[ovl] += 1;
1097
addend = irela->r_addend;
1101
struct got_entry *gnext;
1103
for (g = *head; g != NULL; g = g->next)
1104
if (g->addend == addend && g->ovl == 0)
1109
/* Need a new non-overlay area stub. Zap other stubs. */
1110
for (g = *head; g != NULL; g = gnext)
1113
if (g->addend == addend)
1115
htab->stub_count[g->ovl] -= 1;
1123
for (g = *head; g != NULL; g = g->next)
1124
if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1130
g = bfd_malloc (sizeof *g);
1135
g->stub_addr = (bfd_vma) -1;
1139
htab->stub_count[ovl] += 1;
1145
/* Support two sizes of overlay stubs, a slower more compact stub of two
1146
intructions, and a faster stub of four instructions.
1147
Soft-icache stubs are four or eight words. */
1150
ovl_stub_size (struct spu_elf_params *params)
1152
return 16 << params->ovly_flavour >> params->compact_stub;
1156
ovl_stub_size_log2 (struct spu_elf_params *params)
1158
return 4 + params->ovly_flavour - params->compact_stub;
1161
/* Two instruction overlay stubs look like:
1163
brsl $75,__ovly_load
1164
.word target_ovl_and_address
1166
ovl_and_address is a word with the overlay number in the top 14 bits
1167
and local store address in the bottom 18 bits.
1169
Four instruction overlay stubs look like:
1173
ila $79,target_address
1176
Software icache stubs are:
1180
.word lrlive_branchlocalstoreaddr;
1181
brasl $75,__icache_br_handler
1186
build_stub (struct bfd_link_info *info,
1189
enum _stub_type stub_type,
1190
struct elf_link_hash_entry *h,
1191
const Elf_Internal_Rela *irela,
1195
struct spu_link_hash_table *htab = spu_hash_table (info);
1196
unsigned int ovl, dest_ovl, set_id;
1197
struct got_entry *g, **head;
1199
bfd_vma addend, from, to, br_dest, patt;
1200
unsigned int lrlive;
1203
if (stub_type != nonovl_stub)
1204
ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1207
head = &h->got.glist;
1209
head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1213
addend = irela->r_addend;
1215
if (htab->params->ovly_flavour == ovly_soft_icache)
1217
g = bfd_malloc (sizeof *g);
1223
g->br_addr = (irela->r_offset
1224
+ isec->output_offset
1225
+ isec->output_section->vma);
1231
for (g = *head; g != NULL; g = g->next)
1232
if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1237
if (g->ovl == 0 && ovl != 0)
1240
if (g->stub_addr != (bfd_vma) -1)
1244
sec = htab->stub_sec[ovl];
1245
dest += dest_sec->output_offset + dest_sec->output_section->vma;
1246
from = sec->size + sec->output_offset + sec->output_section->vma;
1247
g->stub_addr = from;
1248
to = (htab->ovly_entry[0]->root.u.def.value
1249
+ htab->ovly_entry[0]->root.u.def.section->output_offset
1250
+ htab->ovly_entry[0]->root.u.def.section->output_section->vma);
1252
if (((dest | to | from) & 3) != 0)
1257
dest_ovl = spu_elf_section_data (dest_sec->output_section)->u.o.ovl_index;
1259
if (htab->params->ovly_flavour == ovly_normal
1260
&& !htab->params->compact_stub)
1262
bfd_put_32 (sec->owner, ILA + ((dest_ovl << 7) & 0x01ffff80) + 78,
1263
sec->contents + sec->size);
1264
bfd_put_32 (sec->owner, LNOP,
1265
sec->contents + sec->size + 4);
1266
bfd_put_32 (sec->owner, ILA + ((dest << 7) & 0x01ffff80) + 79,
1267
sec->contents + sec->size + 8);
1269
bfd_put_32 (sec->owner, BR + (((to - (from + 12)) << 5) & 0x007fff80),
1270
sec->contents + sec->size + 12);
1272
bfd_put_32 (sec->owner, BRA + ((to << 5) & 0x007fff80),
1273
sec->contents + sec->size + 12);
1275
else if (htab->params->ovly_flavour == ovly_normal
1276
&& htab->params->compact_stub)
1279
bfd_put_32 (sec->owner, BRSL + (((to - from) << 5) & 0x007fff80) + 75,
1280
sec->contents + sec->size);
1282
bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1283
sec->contents + sec->size);
1284
bfd_put_32 (sec->owner, (dest & 0x3ffff) | (dest_ovl << 18),
1285
sec->contents + sec->size + 4);
1287
else if (htab->params->ovly_flavour == ovly_soft_icache
1288
&& htab->params->compact_stub)
1291
if (stub_type == nonovl_stub)
1293
else if (stub_type == call_ovl_stub)
1294
/* A brsl makes lr live and *(*sp+16) is live.
1295
Tail calls have the same liveness. */
1297
else if (!htab->params->lrlive_analysis)
1298
/* Assume stack frame and lr save. */
1300
else if (irela != NULL)
1302
/* Analyse branch instructions. */
1303
struct function_info *caller;
1306
caller = find_function (isec, irela->r_offset, info);
1307
if (caller->start == NULL)
1308
off = irela->r_offset;
1311
struct function_info *found = NULL;
1313
/* Find the earliest piece of this function that
1314
has frame adjusting instructions. We might
1315
see dynamic frame adjustment (eg. for alloca)
1316
in some later piece, but functions using
1317
alloca always set up a frame earlier. Frame
1318
setup instructions are always in one piece. */
1319
if (caller->lr_store != (bfd_vma) -1
1320
|| caller->sp_adjust != (bfd_vma) -1)
1322
while (caller->start != NULL)
1324
caller = caller->start;
1325
if (caller->lr_store != (bfd_vma) -1
1326
|| caller->sp_adjust != (bfd_vma) -1)
1334
if (off > caller->sp_adjust)
1336
if (off > caller->lr_store)
1337
/* Only *(*sp+16) is live. */
1340
/* If no lr save, then we must be in a
1341
leaf function with a frame.
1342
lr is still live. */
1345
else if (off > caller->lr_store)
1347
/* Between lr save and stack adjust. */
1349
/* This should never happen since prologues won't
1354
/* On entry to function. */
1357
if (stub_type != br000_ovl_stub
1358
&& lrlive != stub_type - br000_ovl_stub)
1359
info->callbacks->einfo (_("%A:0x%v lrlive .brinfo (%u) differs "
1360
"from analysis (%u)\n"),
1361
isec, irela->r_offset, lrlive,
1362
stub_type - br000_ovl_stub);
1365
/* If given lrlive info via .brinfo, use it. */
1366
if (stub_type > br000_ovl_stub)
1367
lrlive = stub_type - br000_ovl_stub;
1370
to = (htab->ovly_entry[1]->root.u.def.value
1371
+ htab->ovly_entry[1]->root.u.def.section->output_offset
1372
+ htab->ovly_entry[1]->root.u.def.section->output_section->vma);
1374
/* The branch that uses this stub goes to stub_addr + 4. We'll
1375
set up an xor pattern that can be used by the icache manager
1376
to modify this branch to go directly to its destination. */
1378
br_dest = g->stub_addr;
1381
/* Except in the case of _SPUEAR_ stubs, the branch in
1382
question is the one in the stub itself. */
1383
BFD_ASSERT (stub_type == nonovl_stub);
1384
g->br_addr = g->stub_addr;
1388
set_id = ((dest_ovl - 1) >> htab->num_lines_log2) + 1;
1389
bfd_put_32 (sec->owner, (set_id << 18) | (dest & 0x3ffff),
1390
sec->contents + sec->size);
1391
bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1392
sec->contents + sec->size + 4);
1393
bfd_put_32 (sec->owner, (lrlive << 29) | (g->br_addr & 0x3ffff),
1394
sec->contents + sec->size + 8);
1395
patt = dest ^ br_dest;
1396
if (irela != NULL && ELF32_R_TYPE (irela->r_info) == R_SPU_REL16)
1397
patt = (dest - g->br_addr) ^ (br_dest - g->br_addr);
1398
bfd_put_32 (sec->owner, (patt << 5) & 0x007fff80,
1399
sec->contents + sec->size + 12);
1402
/* Extra space for linked list entries. */
1408
sec->size += ovl_stub_size (htab->params);
1410
if (htab->params->emit_stub_syms)
1416
len = 8 + sizeof (".ovl_call.") - 1;
1418
len += strlen (h->root.root.string);
1423
add = (int) irela->r_addend & 0xffffffff;
1426
name = bfd_malloc (len + 1);
1430
sprintf (name, "%08x.ovl_call.", g->ovl);
1432
strcpy (name + 8 + sizeof (".ovl_call.") - 1, h->root.root.string);
1434
sprintf (name + 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1435
dest_sec->id & 0xffffffff,
1436
(int) ELF32_R_SYM (irela->r_info) & 0xffffffff);
1438
sprintf (name + len - 9, "+%x", add);
1440
h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1444
if (h->root.type == bfd_link_hash_new)
1446
h->root.type = bfd_link_hash_defined;
1447
h->root.u.def.section = sec;
1448
h->size = ovl_stub_size (htab->params);
1449
h->root.u.def.value = sec->size - h->size;
1453
h->ref_regular_nonweak = 1;
1454
h->forced_local = 1;
1462
/* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1466
allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1468
/* Symbols starting with _SPUEAR_ need a stub because they may be
1469
invoked by the PPU. */
1470
struct bfd_link_info *info = inf;
1471
struct spu_link_hash_table *htab = spu_hash_table (info);
1474
if ((h->root.type == bfd_link_hash_defined
1475
|| h->root.type == bfd_link_hash_defweak)
1477
&& strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1478
&& (sym_sec = h->root.u.def.section) != NULL
1479
&& sym_sec->output_section != bfd_abs_section_ptr
1480
&& spu_elf_section_data (sym_sec->output_section) != NULL
1481
&& (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1482
|| htab->params->non_overlay_stubs))
1484
return count_stub (htab, NULL, NULL, nonovl_stub, h, NULL);
1491
build_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1493
/* Symbols starting with _SPUEAR_ need a stub because they may be
1494
invoked by the PPU. */
1495
struct bfd_link_info *info = inf;
1496
struct spu_link_hash_table *htab = spu_hash_table (info);
1499
if ((h->root.type == bfd_link_hash_defined
1500
|| h->root.type == bfd_link_hash_defweak)
1502
&& strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1503
&& (sym_sec = h->root.u.def.section) != NULL
1504
&& sym_sec->output_section != bfd_abs_section_ptr
1505
&& spu_elf_section_data (sym_sec->output_section) != NULL
1506
&& (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1507
|| htab->params->non_overlay_stubs))
1509
return build_stub (info, NULL, NULL, nonovl_stub, h, NULL,
1510
h->root.u.def.value, sym_sec);
1516
/* Size or build stubs. */
1519
process_stubs (struct bfd_link_info *info, bfd_boolean build)
1521
struct spu_link_hash_table *htab = spu_hash_table (info);
1524
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1526
extern const bfd_target bfd_elf32_spu_vec;
1527
Elf_Internal_Shdr *symtab_hdr;
1529
Elf_Internal_Sym *local_syms = NULL;
1531
if (ibfd->xvec != &bfd_elf32_spu_vec)
1534
/* We'll need the symbol table in a second. */
1535
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1536
if (symtab_hdr->sh_info == 0)
1539
/* Walk over each section attached to the input bfd. */
1540
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
1542
Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1544
/* If there aren't any relocs, then there's nothing more to do. */
1545
if ((isec->flags & SEC_RELOC) == 0
1546
|| isec->reloc_count == 0)
1549
if (!maybe_needs_stubs (isec))
1552
/* Get the relocs. */
1553
internal_relocs = _bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
1555
if (internal_relocs == NULL)
1556
goto error_ret_free_local;
1558
/* Now examine each relocation. */
1559
irela = internal_relocs;
1560
irelaend = irela + isec->reloc_count;
1561
for (; irela < irelaend; irela++)
1563
enum elf_spu_reloc_type r_type;
1564
unsigned int r_indx;
1566
Elf_Internal_Sym *sym;
1567
struct elf_link_hash_entry *h;
1568
enum _stub_type stub_type;
1570
r_type = ELF32_R_TYPE (irela->r_info);
1571
r_indx = ELF32_R_SYM (irela->r_info);
1573
if (r_type >= R_SPU_max)
1575
bfd_set_error (bfd_error_bad_value);
1576
error_ret_free_internal:
1577
if (elf_section_data (isec)->relocs != internal_relocs)
1578
free (internal_relocs);
1579
error_ret_free_local:
1580
if (local_syms != NULL
1581
&& (symtab_hdr->contents
1582
!= (unsigned char *) local_syms))
1587
/* Determine the reloc target section. */
1588
if (!get_sym_h (&h, &sym, &sym_sec, &local_syms, r_indx, ibfd))
1589
goto error_ret_free_internal;
1591
stub_type = needs_ovl_stub (h, sym, sym_sec, isec, irela,
1593
if (stub_type == no_stub)
1595
else if (stub_type == stub_error)
1596
goto error_ret_free_internal;
1598
if (htab->stub_count == NULL)
1601
amt = (htab->num_overlays + 1) * sizeof (*htab->stub_count);
1602
htab->stub_count = bfd_zmalloc (amt);
1603
if (htab->stub_count == NULL)
1604
goto error_ret_free_internal;
1609
if (!count_stub (htab, ibfd, isec, stub_type, h, irela))
1610
goto error_ret_free_internal;
1617
dest = h->root.u.def.value;
1619
dest = sym->st_value;
1620
dest += irela->r_addend;
1621
if (!build_stub (info, ibfd, isec, stub_type, h, irela,
1623
goto error_ret_free_internal;
1627
/* We're done with the internal relocs, free them. */
1628
if (elf_section_data (isec)->relocs != internal_relocs)
1629
free (internal_relocs);
1632
if (local_syms != NULL
1633
&& symtab_hdr->contents != (unsigned char *) local_syms)
1635
if (!info->keep_memory)
1638
symtab_hdr->contents = (unsigned char *) local_syms;
1645
/* Allocate space for overlay call and return stubs.
1646
Return 0 on error, 1 if no overlays, 2 otherwise. */
1649
spu_elf_size_stubs (struct bfd_link_info *info)
1651
struct spu_link_hash_table *htab;
1658
if (!process_stubs (info, FALSE))
1661
htab = spu_hash_table (info);
1662
elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, info);
1666
ibfd = info->input_bfds;
1667
if (htab->stub_count != NULL)
1669
amt = (htab->num_overlays + 1) * sizeof (*htab->stub_sec);
1670
htab->stub_sec = bfd_zmalloc (amt);
1671
if (htab->stub_sec == NULL)
1674
flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
1675
| SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1676
stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1677
htab->stub_sec[0] = stub;
1679
|| !bfd_set_section_alignment (ibfd, stub,
1680
ovl_stub_size_log2 (htab->params)))
1682
stub->size = htab->stub_count[0] * ovl_stub_size (htab->params);
1683
if (htab->params->ovly_flavour == ovly_soft_icache)
1684
/* Extra space for linked list entries. */
1685
stub->size += htab->stub_count[0] * 16;
1687
for (i = 0; i < htab->num_overlays; ++i)
1689
asection *osec = htab->ovl_sec[i];
1690
unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1691
stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1692
htab->stub_sec[ovl] = stub;
1694
|| !bfd_set_section_alignment (ibfd, stub,
1695
ovl_stub_size_log2 (htab->params)))
1697
stub->size = htab->stub_count[ovl] * ovl_stub_size (htab->params);
1701
if (htab->params->ovly_flavour == ovly_soft_icache)
1703
/* Space for icache manager tables.
1704
a) Tag array, one quadword per cache line.
1705
b) Rewrite "to" list, one quadword per cache line.
1706
c) Rewrite "from" list, one byte per outgoing branch (rounded up to
1707
a power-of-two number of full quadwords) per cache line. */
1710
htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1711
if (htab->ovtab == NULL
1712
|| !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1715
htab->ovtab->size = (16 + 16 + (16 << htab->fromelem_size_log2))
1716
<< htab->num_lines_log2;
1718
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1719
htab->init = bfd_make_section_anyway_with_flags (ibfd, ".ovini", flags);
1720
if (htab->init == NULL
1721
|| !bfd_set_section_alignment (ibfd, htab->init, 4))
1724
htab->init->size = 16;
1726
else if (htab->stub_count == NULL)
1730
/* htab->ovtab consists of two arrays.
1740
. } _ovly_buf_table[];
1743
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1744
htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1745
if (htab->ovtab == NULL
1746
|| !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1749
htab->ovtab->size = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
1752
htab->toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1753
if (htab->toe == NULL
1754
|| !bfd_set_section_alignment (ibfd, htab->toe, 4))
1756
htab->toe->size = 16;
1761
/* Called from ld to place overlay manager data sections. This is done
1762
after the overlay manager itself is loaded, mainly so that the
1763
linker's htab->init section is placed after any other .ovl.init
1767
spu_elf_place_overlay_data (struct bfd_link_info *info)
1769
struct spu_link_hash_table *htab = spu_hash_table (info);
1772
if (htab->stub_sec != NULL)
1774
(*htab->params->place_spu_section) (htab->stub_sec[0], NULL, ".text");
1776
for (i = 0; i < htab->num_overlays; ++i)
1778
asection *osec = htab->ovl_sec[i];
1779
unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1780
(*htab->params->place_spu_section) (htab->stub_sec[ovl], osec, NULL);
1784
if (htab->params->ovly_flavour == ovly_soft_icache)
1785
(*htab->params->place_spu_section) (htab->init, NULL, ".ovl.init");
1787
if (htab->ovtab != NULL)
1789
const char *ovout = ".data";
1790
if (htab->params->ovly_flavour == ovly_soft_icache)
1792
(*htab->params->place_spu_section) (htab->ovtab, NULL, ovout);
1795
if (htab->toe != NULL)
1796
(*htab->params->place_spu_section) (htab->toe, NULL, ".toe");
1799
/* Functions to handle embedded spu_ovl.o object. */
1802
ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1808
ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1814
struct _ovl_stream *os;
1818
os = (struct _ovl_stream *) stream;
1819
max = (const char *) os->end - (const char *) os->start;
1821
if ((ufile_ptr) offset >= max)
1825
if (count > max - offset)
1826
count = max - offset;
1828
memcpy (buf, (const char *) os->start + offset, count);
1833
spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1835
*ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1842
return *ovl_bfd != NULL;
1846
overlay_index (asection *sec)
1849
|| sec->output_section == bfd_abs_section_ptr)
1851
return spu_elf_section_data (sec->output_section)->u.o.ovl_index;
1854
/* Define an STT_OBJECT symbol. */
1856
static struct elf_link_hash_entry *
1857
define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1859
struct elf_link_hash_entry *h;
1861
h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1865
if (h->root.type != bfd_link_hash_defined
1868
h->root.type = bfd_link_hash_defined;
1869
h->root.u.def.section = htab->ovtab;
1870
h->type = STT_OBJECT;
1873
h->ref_regular_nonweak = 1;
1876
else if (h->root.u.def.section->owner != NULL)
1878
(*_bfd_error_handler) (_("%B is not allowed to define %s"),
1879
h->root.u.def.section->owner,
1880
h->root.root.string);
1881
bfd_set_error (bfd_error_bad_value);
1886
(*_bfd_error_handler) (_("you are not allowed to define %s in a script"),
1887
h->root.root.string);
1888
bfd_set_error (bfd_error_bad_value);
1895
/* Fill in all stubs and the overlay tables. */
1898
spu_elf_build_stubs (struct bfd_link_info *info)
1900
struct spu_link_hash_table *htab = spu_hash_table (info);
1901
struct elf_link_hash_entry *h;
1907
if (htab->num_overlays != 0)
1909
for (i = 0; i < 2; i++)
1911
h = htab->ovly_entry[i];
1913
&& (h->root.type == bfd_link_hash_defined
1914
|| h->root.type == bfd_link_hash_defweak)
1917
s = h->root.u.def.section->output_section;
1918
if (spu_elf_section_data (s)->u.o.ovl_index)
1920
(*_bfd_error_handler) (_("%s in overlay section"),
1921
h->root.root.string);
1922
bfd_set_error (bfd_error_bad_value);
1929
if (htab->stub_sec != NULL)
1931
for (i = 0; i <= htab->num_overlays; i++)
1932
if (htab->stub_sec[i]->size != 0)
1934
htab->stub_sec[i]->contents = bfd_zalloc (htab->stub_sec[i]->owner,
1935
htab->stub_sec[i]->size);
1936
if (htab->stub_sec[i]->contents == NULL)
1938
htab->stub_sec[i]->rawsize = htab->stub_sec[i]->size;
1939
htab->stub_sec[i]->size = 0;
1942
/* Fill in all the stubs. */
1943
process_stubs (info, TRUE);
1944
if (!htab->stub_err)
1945
elf_link_hash_traverse (&htab->elf, build_spuear_stubs, info);
1949
(*_bfd_error_handler) (_("overlay stub relocation overflow"));
1950
bfd_set_error (bfd_error_bad_value);
1954
for (i = 0; i <= htab->num_overlays; i++)
1956
if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
1958
(*_bfd_error_handler) (_("stubs don't match calculated size"));
1959
bfd_set_error (bfd_error_bad_value);
1962
htab->stub_sec[i]->rawsize = 0;
1966
if (htab->ovtab == NULL || htab->ovtab->size == 0)
1969
htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1970
if (htab->ovtab->contents == NULL)
1973
p = htab->ovtab->contents;
1974
if (htab->params->ovly_flavour == ovly_soft_icache)
1978
h = define_ovtab_symbol (htab, "__icache_tag_array");
1981
h->root.u.def.value = 0;
1982
h->size = 16 << htab->num_lines_log2;
1985
h = define_ovtab_symbol (htab, "__icache_tag_array_size");
1988
h->root.u.def.value = 16 << htab->num_lines_log2;
1989
h->root.u.def.section = bfd_abs_section_ptr;
1991
h = define_ovtab_symbol (htab, "__icache_rewrite_to");
1994
h->root.u.def.value = off;
1995
h->size = 16 << htab->num_lines_log2;
1998
h = define_ovtab_symbol (htab, "__icache_rewrite_to_size");
2001
h->root.u.def.value = 16 << htab->num_lines_log2;
2002
h->root.u.def.section = bfd_abs_section_ptr;
2004
h = define_ovtab_symbol (htab, "__icache_rewrite_from");
2007
h->root.u.def.value = off;
2008
h->size = 16 << (htab->fromelem_size_log2 + htab->num_lines_log2);
2011
h = define_ovtab_symbol (htab, "__icache_rewrite_from_size");
2014
h->root.u.def.value = 16 << (htab->fromelem_size_log2
2015
+ htab->num_lines_log2);
2016
h->root.u.def.section = bfd_abs_section_ptr;
2018
h = define_ovtab_symbol (htab, "__icache_log2_fromelemsize");
2021
h->root.u.def.value = htab->fromelem_size_log2;
2022
h->root.u.def.section = bfd_abs_section_ptr;
2024
h = define_ovtab_symbol (htab, "__icache_base");
2027
h->root.u.def.value = htab->ovl_sec[0]->vma;
2028
h->root.u.def.section = bfd_abs_section_ptr;
2029
h->size = htab->num_buf << htab->line_size_log2;
2031
h = define_ovtab_symbol (htab, "__icache_linesize");
2034
h->root.u.def.value = 1 << htab->line_size_log2;
2035
h->root.u.def.section = bfd_abs_section_ptr;
2037
h = define_ovtab_symbol (htab, "__icache_log2_linesize");
2040
h->root.u.def.value = htab->line_size_log2;
2041
h->root.u.def.section = bfd_abs_section_ptr;
2043
h = define_ovtab_symbol (htab, "__icache_neg_log2_linesize");
2046
h->root.u.def.value = -htab->line_size_log2;
2047
h->root.u.def.section = bfd_abs_section_ptr;
2049
h = define_ovtab_symbol (htab, "__icache_cachesize");
2052
h->root.u.def.value = 1 << (htab->num_lines_log2 + htab->line_size_log2);
2053
h->root.u.def.section = bfd_abs_section_ptr;
2055
h = define_ovtab_symbol (htab, "__icache_log2_cachesize");
2058
h->root.u.def.value = htab->num_lines_log2 + htab->line_size_log2;
2059
h->root.u.def.section = bfd_abs_section_ptr;
2061
h = define_ovtab_symbol (htab, "__icache_neg_log2_cachesize");
2064
h->root.u.def.value = -(htab->num_lines_log2 + htab->line_size_log2);
2065
h->root.u.def.section = bfd_abs_section_ptr;
2067
if (htab->init != NULL && htab->init->size != 0)
2069
htab->init->contents = bfd_zalloc (htab->init->owner,
2071
if (htab->init->contents == NULL)
2074
h = define_ovtab_symbol (htab, "__icache_fileoff");
2077
h->root.u.def.value = 0;
2078
h->root.u.def.section = htab->init;
2084
/* Write out _ovly_table. */
2085
/* set low bit of .size to mark non-overlay area as present. */
2087
obfd = htab->ovtab->output_section->owner;
2088
for (s = obfd->sections; s != NULL; s = s->next)
2090
unsigned int ovl_index = spu_elf_section_data (s)->u.o.ovl_index;
2094
unsigned long off = ovl_index * 16;
2095
unsigned int ovl_buf = spu_elf_section_data (s)->u.o.ovl_buf;
2097
bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
2098
bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16,
2100
/* file_off written later in spu_elf_modify_program_headers. */
2101
bfd_put_32 (htab->ovtab->owner, ovl_buf, p + off + 12);
2105
h = define_ovtab_symbol (htab, "_ovly_table");
2108
h->root.u.def.value = 16;
2109
h->size = htab->num_overlays * 16;
2111
h = define_ovtab_symbol (htab, "_ovly_table_end");
2114
h->root.u.def.value = htab->num_overlays * 16 + 16;
2117
h = define_ovtab_symbol (htab, "_ovly_buf_table");
2120
h->root.u.def.value = htab->num_overlays * 16 + 16;
2121
h->size = htab->num_buf * 4;
2123
h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
2126
h->root.u.def.value = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
2130
h = define_ovtab_symbol (htab, "_EAR_");
2133
h->root.u.def.section = htab->toe;
2134
h->root.u.def.value = 0;
2140
/* Check that all loadable section VMAs lie in the range
2141
LO .. HI inclusive, and stash some parameters for --auto-overlay. */
2144
spu_elf_check_vma (struct bfd_link_info *info)
2146
struct elf_segment_map *m;
2148
struct spu_link_hash_table *htab = spu_hash_table (info);
2149
bfd *abfd = info->output_bfd;
2150
bfd_vma hi = htab->params->local_store_hi;
2151
bfd_vma lo = htab->params->local_store_lo;
2153
htab->local_store = hi + 1 - lo;
2155
for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2156
if (m->p_type == PT_LOAD)
2157
for (i = 0; i < m->count; i++)
2158
if (m->sections[i]->size != 0
2159
&& (m->sections[i]->vma < lo
2160
|| m->sections[i]->vma > hi
2161
|| m->sections[i]->vma + m->sections[i]->size - 1 > hi))
2162
return m->sections[i];
2167
/* OFFSET in SEC (presumably) is the beginning of a function prologue.
2168
Search for stack adjusting insns, and return the sp delta.
2169
If a store of lr is found save the instruction offset to *LR_STORE.
2170
If a stack adjusting instruction is found, save that offset to
2174
find_function_stack_adjust (asection *sec,
2181
memset (reg, 0, sizeof (reg));
2182
for ( ; offset + 4 <= sec->size; offset += 4)
2184
unsigned char buf[4];
2188
/* Assume no relocs on stack adjusing insns. */
2189
if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
2193
ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
2195
if (buf[0] == 0x24 /* stqd */)
2197
if (rt == 0 /* lr */ && ra == 1 /* sp */)
2202
/* Partly decoded immediate field. */
2203
imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
2205
if (buf[0] == 0x1c /* ai */)
2208
imm = (imm ^ 0x200) - 0x200;
2209
reg[rt] = reg[ra] + imm;
2211
if (rt == 1 /* sp */)
2215
*sp_adjust = offset;
2219
else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
2221
int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2223
reg[rt] = reg[ra] + reg[rb];
2228
*sp_adjust = offset;
2232
else if (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */)
2234
int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2236
reg[rt] = reg[rb] - reg[ra];
2241
*sp_adjust = offset;
2245
else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
2247
if (buf[0] >= 0x42 /* ila */)
2248
imm |= (buf[0] & 1) << 17;
2253
if (buf[0] == 0x40 /* il */)
2255
if ((buf[1] & 0x80) == 0)
2257
imm = (imm ^ 0x8000) - 0x8000;
2259
else if ((buf[1] & 0x80) == 0 /* ilhu */)
2265
else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
2267
reg[rt] |= imm & 0xffff;
2270
else if (buf[0] == 0x04 /* ori */)
2273
imm = (imm ^ 0x200) - 0x200;
2274
reg[rt] = reg[ra] | imm;
2277
else if (buf[0] == 0x32 && (buf[1] & 0x80) != 0 /* fsmbi */)
2279
reg[rt] = ( ((imm & 0x8000) ? 0xff000000 : 0)
2280
| ((imm & 0x4000) ? 0x00ff0000 : 0)
2281
| ((imm & 0x2000) ? 0x0000ff00 : 0)
2282
| ((imm & 0x1000) ? 0x000000ff : 0));
2285
else if (buf[0] == 0x16 /* andbi */)
2291
reg[rt] = reg[ra] & imm;
2294
else if (buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
2296
/* Used in pic reg load. Say rt is trashed. Won't be used
2297
in stack adjust, but we need to continue past this branch. */
2301
else if (is_branch (buf) || is_indirect_branch (buf))
2302
/* If we hit a branch then we must be out of the prologue. */
2309
/* qsort predicate to sort symbols by section and value. */
2311
static Elf_Internal_Sym *sort_syms_syms;
2312
static asection **sort_syms_psecs;
2315
sort_syms (const void *a, const void *b)
2317
Elf_Internal_Sym *const *s1 = a;
2318
Elf_Internal_Sym *const *s2 = b;
2319
asection *sec1,*sec2;
2320
bfd_signed_vma delta;
2322
sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
2323
sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
2326
return sec1->index - sec2->index;
2328
delta = (*s1)->st_value - (*s2)->st_value;
2330
return delta < 0 ? -1 : 1;
2332
delta = (*s2)->st_size - (*s1)->st_size;
2334
return delta < 0 ? -1 : 1;
2336
return *s1 < *s2 ? -1 : 1;
2339
/* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
2340
entries for section SEC. */
2342
static struct spu_elf_stack_info *
2343
alloc_stack_info (asection *sec, int max_fun)
2345
struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2348
amt = sizeof (struct spu_elf_stack_info);
2349
amt += (max_fun - 1) * sizeof (struct function_info);
2350
sec_data->u.i.stack_info = bfd_zmalloc (amt);
2351
if (sec_data->u.i.stack_info != NULL)
2352
sec_data->u.i.stack_info->max_fun = max_fun;
2353
return sec_data->u.i.stack_info;
2356
/* Add a new struct function_info describing a (part of a) function
2357
starting at SYM_H. Keep the array sorted by address. */
2359
static struct function_info *
2360
maybe_insert_function (asection *sec,
2363
bfd_boolean is_func)
2365
struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2366
struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2372
sinfo = alloc_stack_info (sec, 20);
2379
Elf_Internal_Sym *sym = sym_h;
2380
off = sym->st_value;
2381
size = sym->st_size;
2385
struct elf_link_hash_entry *h = sym_h;
2386
off = h->root.u.def.value;
2390
for (i = sinfo->num_fun; --i >= 0; )
2391
if (sinfo->fun[i].lo <= off)
2396
/* Don't add another entry for an alias, but do update some
2398
if (sinfo->fun[i].lo == off)
2400
/* Prefer globals over local syms. */
2401
if (global && !sinfo->fun[i].global)
2403
sinfo->fun[i].global = TRUE;
2404
sinfo->fun[i].u.h = sym_h;
2407
sinfo->fun[i].is_func = TRUE;
2408
return &sinfo->fun[i];
2410
/* Ignore a zero-size symbol inside an existing function. */
2411
else if (sinfo->fun[i].hi > off && size == 0)
2412
return &sinfo->fun[i];
2415
if (sinfo->num_fun >= sinfo->max_fun)
2417
bfd_size_type amt = sizeof (struct spu_elf_stack_info);
2418
bfd_size_type old = amt;
2420
old += (sinfo->max_fun - 1) * sizeof (struct function_info);
2421
sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
2422
amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
2423
sinfo = bfd_realloc (sinfo, amt);
2426
memset ((char *) sinfo + old, 0, amt - old);
2427
sec_data->u.i.stack_info = sinfo;
2430
if (++i < sinfo->num_fun)
2431
memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
2432
(sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
2433
sinfo->fun[i].is_func = is_func;
2434
sinfo->fun[i].global = global;
2435
sinfo->fun[i].sec = sec;
2437
sinfo->fun[i].u.h = sym_h;
2439
sinfo->fun[i].u.sym = sym_h;
2440
sinfo->fun[i].lo = off;
2441
sinfo->fun[i].hi = off + size;
2442
sinfo->fun[i].lr_store = -1;
2443
sinfo->fun[i].sp_adjust = -1;
2444
sinfo->fun[i].stack = -find_function_stack_adjust (sec, off,
2445
&sinfo->fun[i].lr_store,
2446
&sinfo->fun[i].sp_adjust);
2447
sinfo->num_fun += 1;
2448
return &sinfo->fun[i];
2451
/* Return the name of FUN. */
2454
func_name (struct function_info *fun)
2458
Elf_Internal_Shdr *symtab_hdr;
2460
while (fun->start != NULL)
2464
return fun->u.h->root.root.string;
2467
if (fun->u.sym->st_name == 0)
2469
size_t len = strlen (sec->name);
2470
char *name = bfd_malloc (len + 10);
2473
sprintf (name, "%s+%lx", sec->name,
2474
(unsigned long) fun->u.sym->st_value & 0xffffffff);
2478
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2479
return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
2482
/* Read the instruction at OFF in SEC. Return true iff the instruction
2483
is a nop, lnop, or stop 0 (all zero insn). */
2486
is_nop (asection *sec, bfd_vma off)
2488
unsigned char insn[4];
2490
if (off + 4 > sec->size
2491
|| !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
2493
if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
2495
if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
2500
/* Extend the range of FUN to cover nop padding up to LIMIT.
2501
Return TRUE iff some instruction other than a NOP was found. */
2504
insns_at_end (struct function_info *fun, bfd_vma limit)
2506
bfd_vma off = (fun->hi + 3) & -4;
2508
while (off < limit && is_nop (fun->sec, off))
2519
/* Check and fix overlapping function ranges. Return TRUE iff there
2520
are gaps in the current info we have about functions in SEC. */
2523
check_function_ranges (asection *sec, struct bfd_link_info *info)
2525
struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2526
struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2528
bfd_boolean gaps = FALSE;
2533
for (i = 1; i < sinfo->num_fun; i++)
2534
if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
2536
/* Fix overlapping symbols. */
2537
const char *f1 = func_name (&sinfo->fun[i - 1]);
2538
const char *f2 = func_name (&sinfo->fun[i]);
2540
info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
2541
sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
2543
else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
2546
if (sinfo->num_fun == 0)
2550
if (sinfo->fun[0].lo != 0)
2552
if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
2554
const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
2556
info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
2557
sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
2559
else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
2565
/* Search current function info for a function that contains address
2566
OFFSET in section SEC. */
2568
static struct function_info *
2569
find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
2571
struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2572
struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2576
hi = sinfo->num_fun;
2579
mid = (lo + hi) / 2;
2580
if (offset < sinfo->fun[mid].lo)
2582
else if (offset >= sinfo->fun[mid].hi)
2585
return &sinfo->fun[mid];
2587
info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
2589
bfd_set_error (bfd_error_bad_value);
2593
/* Add CALLEE to CALLER call list if not already present. Return TRUE
2594
if CALLEE was new. If this function return FALSE, CALLEE should
2598
insert_callee (struct function_info *caller, struct call_info *callee)
2600
struct call_info **pp, *p;
2602
for (pp = &caller->call_list; (p = *pp) != NULL; pp = &p->next)
2603
if (p->fun == callee->fun)
2605
/* Tail calls use less stack than normal calls. Retain entry
2606
for normal call over one for tail call. */
2607
p->is_tail &= callee->is_tail;
2610
p->fun->start = NULL;
2611
p->fun->is_func = TRUE;
2613
p->count += callee->count;
2614
/* Reorder list so most recent call is first. */
2616
p->next = caller->call_list;
2617
caller->call_list = p;
2620
callee->next = caller->call_list;
2621
caller->call_list = callee;
2625
/* Copy CALL and insert the copy into CALLER. */
2628
copy_callee (struct function_info *caller, const struct call_info *call)
2630
struct call_info *callee;
2631
callee = bfd_malloc (sizeof (*callee));
2635
if (!insert_callee (caller, callee))
2640
/* We're only interested in code sections. Testing SEC_IN_MEMORY excludes
2641
overlay stub sections. */
2644
interesting_section (asection *s)
2646
return (s->output_section != bfd_abs_section_ptr
2647
&& ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_IN_MEMORY))
2648
== (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2652
/* Rummage through the relocs for SEC, looking for function calls.
2653
If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
2654
mark destination symbols on calls as being functions. Also
2655
look at branches, which may be tail calls or go to hot/cold
2656
section part of same function. */
2659
mark_functions_via_relocs (asection *sec,
2660
struct bfd_link_info *info,
2663
Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2664
Elf_Internal_Shdr *symtab_hdr;
2666
unsigned int priority = 0;
2667
static bfd_boolean warned;
2669
if (!interesting_section (sec)
2670
|| sec->reloc_count == 0)
2673
internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
2675
if (internal_relocs == NULL)
2678
symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
2679
psyms = &symtab_hdr->contents;
2680
irela = internal_relocs;
2681
irelaend = irela + sec->reloc_count;
2682
for (; irela < irelaend; irela++)
2684
enum elf_spu_reloc_type r_type;
2685
unsigned int r_indx;
2687
Elf_Internal_Sym *sym;
2688
struct elf_link_hash_entry *h;
2690
bfd_boolean nonbranch, is_call;
2691
struct function_info *caller;
2692
struct call_info *callee;
2694
r_type = ELF32_R_TYPE (irela->r_info);
2695
nonbranch = r_type != R_SPU_REL16 && r_type != R_SPU_ADDR16;
2697
r_indx = ELF32_R_SYM (irela->r_info);
2698
if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
2702
|| sym_sec->output_section == bfd_abs_section_ptr)
2708
unsigned char insn[4];
2710
if (!bfd_get_section_contents (sec->owner, sec, insn,
2711
irela->r_offset, 4))
2713
if (is_branch (insn))
2715
is_call = (insn[0] & 0xfd) == 0x31;
2716
priority = insn[1] & 0x0f;
2718
priority |= insn[2];
2720
priority |= insn[3];
2722
if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2723
!= (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2726
info->callbacks->einfo
2727
(_("%B(%A+0x%v): call to non-code section"
2728
" %B(%A), analysis incomplete\n"),
2729
sec->owner, sec, irela->r_offset,
2730
sym_sec->owner, sym_sec);
2745
/* For --auto-overlay, count possible stubs we need for
2746
function pointer references. */
2747
unsigned int sym_type;
2751
sym_type = ELF_ST_TYPE (sym->st_info);
2752
if (sym_type == STT_FUNC)
2754
if (call_tree && spu_hash_table (info)->params->auto_overlay)
2755
spu_hash_table (info)->non_ovly_stub += 1;
2756
/* If the symbol type is STT_FUNC then this must be a
2757
function pointer initialisation. */
2760
/* Ignore data references. */
2761
if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2762
!= (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2764
/* Otherwise we probably have a jump table reloc for
2765
a switch statement or some other reference to a
2770
val = h->root.u.def.value;
2772
val = sym->st_value;
2773
val += irela->r_addend;
2777
struct function_info *fun;
2779
if (irela->r_addend != 0)
2781
Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
2784
fake->st_value = val;
2786
= _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
2790
fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
2792
fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
2795
if (irela->r_addend != 0
2796
&& fun->u.sym != sym)
2801
caller = find_function (sec, irela->r_offset, info);
2804
callee = bfd_malloc (sizeof *callee);
2808
callee->fun = find_function (sym_sec, val, info);
2809
if (callee->fun == NULL)
2811
callee->is_tail = !is_call;
2812
callee->is_pasted = FALSE;
2813
callee->broken_cycle = FALSE;
2814
callee->priority = priority;
2815
callee->count = nonbranch? 0 : 1;
2816
if (callee->fun->last_caller != sec)
2818
callee->fun->last_caller = sec;
2819
callee->fun->call_count += 1;
2821
if (!insert_callee (caller, callee))
2824
&& !callee->fun->is_func
2825
&& callee->fun->stack == 0)
2827
/* This is either a tail call or a branch from one part of
2828
the function to another, ie. hot/cold section. If the
2829
destination has been called by some other function then
2830
it is a separate function. We also assume that functions
2831
are not split across input files. */
2832
if (sec->owner != sym_sec->owner)
2834
callee->fun->start = NULL;
2835
callee->fun->is_func = TRUE;
2837
else if (callee->fun->start == NULL)
2839
struct function_info *caller_start = caller;
2840
while (caller_start->start)
2841
caller_start = caller_start->start;
2843
if (caller_start != callee->fun)
2844
callee->fun->start = caller_start;
2848
struct function_info *callee_start;
2849
struct function_info *caller_start;
2850
callee_start = callee->fun;
2851
while (callee_start->start)
2852
callee_start = callee_start->start;
2853
caller_start = caller;
2854
while (caller_start->start)
2855
caller_start = caller_start->start;
2856
if (caller_start != callee_start)
2858
callee->fun->start = NULL;
2859
callee->fun->is_func = TRUE;
2868
/* Handle something like .init or .fini, which has a piece of a function.
2869
These sections are pasted together to form a single function. */
2872
pasted_function (asection *sec)
2874
struct bfd_link_order *l;
2875
struct _spu_elf_section_data *sec_data;
2876
struct spu_elf_stack_info *sinfo;
2877
Elf_Internal_Sym *fake;
2878
struct function_info *fun, *fun_start;
2880
fake = bfd_zmalloc (sizeof (*fake));
2884
fake->st_size = sec->size;
2886
= _bfd_elf_section_from_bfd_section (sec->owner, sec);
2887
fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2891
/* Find a function immediately preceding this section. */
2893
for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2895
if (l->u.indirect.section == sec)
2897
if (fun_start != NULL)
2899
struct call_info *callee = bfd_malloc (sizeof *callee);
2903
fun->start = fun_start;
2905
callee->is_tail = TRUE;
2906
callee->is_pasted = TRUE;
2907
callee->broken_cycle = FALSE;
2908
callee->priority = 0;
2910
if (!insert_callee (fun_start, callee))
2916
if (l->type == bfd_indirect_link_order
2917
&& (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
2918
&& (sinfo = sec_data->u.i.stack_info) != NULL
2919
&& sinfo->num_fun != 0)
2920
fun_start = &sinfo->fun[sinfo->num_fun - 1];
2923
/* Don't return an error if we did not find a function preceding this
2924
section. The section may have incorrect flags. */
2928
/* Map address ranges in code sections to functions. */
2931
discover_functions (struct bfd_link_info *info)
2935
Elf_Internal_Sym ***psym_arr;
2936
asection ***sec_arr;
2937
bfd_boolean gaps = FALSE;
2940
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2943
psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2944
if (psym_arr == NULL)
2946
sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2947
if (sec_arr == NULL)
2950
for (ibfd = info->input_bfds, bfd_idx = 0;
2952
ibfd = ibfd->link_next, bfd_idx++)
2954
extern const bfd_target bfd_elf32_spu_vec;
2955
Elf_Internal_Shdr *symtab_hdr;
2958
Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2959
asection **psecs, **p;
2961
if (ibfd->xvec != &bfd_elf32_spu_vec)
2964
/* Read all the symbols. */
2965
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2966
symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2970
for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2971
if (interesting_section (sec))
2979
if (symtab_hdr->contents != NULL)
2981
/* Don't use cached symbols since the generic ELF linker
2982
code only reads local symbols, and we need globals too. */
2983
free (symtab_hdr->contents);
2984
symtab_hdr->contents = NULL;
2986
syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2988
symtab_hdr->contents = (void *) syms;
2992
/* Select defined function symbols that are going to be output. */
2993
psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2996
psym_arr[bfd_idx] = psyms;
2997
psecs = bfd_malloc (symcount * sizeof (*psecs));
3000
sec_arr[bfd_idx] = psecs;
3001
for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
3002
if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
3003
|| ELF_ST_TYPE (sy->st_info) == STT_FUNC)
3007
*p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
3008
if (s != NULL && interesting_section (s))
3011
symcount = psy - psyms;
3014
/* Sort them by section and offset within section. */
3015
sort_syms_syms = syms;
3016
sort_syms_psecs = psecs;
3017
qsort (psyms, symcount, sizeof (*psyms), sort_syms);
3019
/* Now inspect the function symbols. */
3020
for (psy = psyms; psy < psyms + symcount; )
3022
asection *s = psecs[*psy - syms];
3023
Elf_Internal_Sym **psy2;
3025
for (psy2 = psy; ++psy2 < psyms + symcount; )
3026
if (psecs[*psy2 - syms] != s)
3029
if (!alloc_stack_info (s, psy2 - psy))
3034
/* First install info about properly typed and sized functions.
3035
In an ideal world this will cover all code sections, except
3036
when partitioning functions into hot and cold sections,
3037
and the horrible pasted together .init and .fini functions. */
3038
for (psy = psyms; psy < psyms + symcount; ++psy)
3041
if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
3043
asection *s = psecs[sy - syms];
3044
if (!maybe_insert_function (s, sy, FALSE, TRUE))
3049
for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3050
if (interesting_section (sec))
3051
gaps |= check_function_ranges (sec, info);
3056
/* See if we can discover more function symbols by looking at
3058
for (ibfd = info->input_bfds, bfd_idx = 0;
3060
ibfd = ibfd->link_next, bfd_idx++)
3064
if (psym_arr[bfd_idx] == NULL)
3067
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3068
if (!mark_functions_via_relocs (sec, info, FALSE))
3072
for (ibfd = info->input_bfds, bfd_idx = 0;
3074
ibfd = ibfd->link_next, bfd_idx++)
3076
Elf_Internal_Shdr *symtab_hdr;
3078
Elf_Internal_Sym *syms, *sy, **psyms, **psy;
3081
if ((psyms = psym_arr[bfd_idx]) == NULL)
3084
psecs = sec_arr[bfd_idx];
3086
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3087
syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3090
for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3091
if (interesting_section (sec))
3092
gaps |= check_function_ranges (sec, info);
3096
/* Finally, install all globals. */
3097
for (psy = psyms; (sy = *psy) != NULL; ++psy)
3101
s = psecs[sy - syms];
3103
/* Global syms might be improperly typed functions. */
3104
if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
3105
&& ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
3107
if (!maybe_insert_function (s, sy, FALSE, FALSE))
3113
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3115
extern const bfd_target bfd_elf32_spu_vec;
3118
if (ibfd->xvec != &bfd_elf32_spu_vec)
3121
/* Some of the symbols we've installed as marking the
3122
beginning of functions may have a size of zero. Extend
3123
the range of such functions to the beginning of the
3124
next symbol of interest. */
3125
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3126
if (interesting_section (sec))
3128
struct _spu_elf_section_data *sec_data;
3129
struct spu_elf_stack_info *sinfo;
3131
sec_data = spu_elf_section_data (sec);
3132
sinfo = sec_data->u.i.stack_info;
3133
if (sinfo != NULL && sinfo->num_fun != 0)
3136
bfd_vma hi = sec->size;
3138
for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
3140
sinfo->fun[fun_idx].hi = hi;
3141
hi = sinfo->fun[fun_idx].lo;
3144
sinfo->fun[0].lo = 0;
3146
/* No symbols in this section. Must be .init or .fini
3147
or something similar. */
3148
else if (!pasted_function (sec))
3154
for (ibfd = info->input_bfds, bfd_idx = 0;
3156
ibfd = ibfd->link_next, bfd_idx++)
3158
if (psym_arr[bfd_idx] == NULL)
3161
free (psym_arr[bfd_idx]);
3162
free (sec_arr[bfd_idx]);
3171
/* Iterate over all function_info we have collected, calling DOIT on
3172
each node if ROOT_ONLY is false. Only call DOIT on root nodes
3176
for_each_node (bfd_boolean (*doit) (struct function_info *,
3177
struct bfd_link_info *,
3179
struct bfd_link_info *info,
3185
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3187
extern const bfd_target bfd_elf32_spu_vec;
3190
if (ibfd->xvec != &bfd_elf32_spu_vec)
3193
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3195
struct _spu_elf_section_data *sec_data;
3196
struct spu_elf_stack_info *sinfo;
3198
if ((sec_data = spu_elf_section_data (sec)) != NULL
3199
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3202
for (i = 0; i < sinfo->num_fun; ++i)
3203
if (!root_only || !sinfo->fun[i].non_root)
3204
if (!doit (&sinfo->fun[i], info, param))
3212
/* Transfer call info attached to struct function_info entries for
3213
all of a given function's sections to the first entry. */
3216
transfer_calls (struct function_info *fun,
3217
struct bfd_link_info *info ATTRIBUTE_UNUSED,
3218
void *param ATTRIBUTE_UNUSED)
3220
struct function_info *start = fun->start;
3224
struct call_info *call, *call_next;
3226
while (start->start != NULL)
3227
start = start->start;
3228
for (call = fun->call_list; call != NULL; call = call_next)
3230
call_next = call->next;
3231
if (!insert_callee (start, call))
3234
fun->call_list = NULL;
3239
/* Mark nodes in the call graph that are called by some other node. */
3242
mark_non_root (struct function_info *fun,
3243
struct bfd_link_info *info ATTRIBUTE_UNUSED,
3244
void *param ATTRIBUTE_UNUSED)
3246
struct call_info *call;
3251
for (call = fun->call_list; call; call = call->next)
3253
call->fun->non_root = TRUE;
3254
mark_non_root (call->fun, 0, 0);
3259
/* Remove cycles from the call graph. Set depth of nodes. */
3262
remove_cycles (struct function_info *fun,
3263
struct bfd_link_info *info,
3266
struct call_info **callp, *call;
3267
unsigned int depth = *(unsigned int *) param;
3268
unsigned int max_depth = depth;
3272
fun->marking = TRUE;
3274
callp = &fun->call_list;
3275
while ((call = *callp) != NULL)
3277
call->max_depth = depth + !call->is_pasted;
3278
if (!call->fun->visit2)
3280
if (!remove_cycles (call->fun, info, &call->max_depth))
3282
if (max_depth < call->max_depth)
3283
max_depth = call->max_depth;
3285
else if (call->fun->marking)
3287
struct spu_link_hash_table *htab = spu_hash_table (info);
3289
if (!htab->params->auto_overlay
3290
&& htab->params->stack_analysis)
3292
const char *f1 = func_name (fun);
3293
const char *f2 = func_name (call->fun);
3295
info->callbacks->info (_("Stack analysis will ignore the call "
3300
call->broken_cycle = TRUE;
3302
callp = &call->next;
3304
fun->marking = FALSE;
3305
*(unsigned int *) param = max_depth;
3309
/* Check that we actually visited all nodes in remove_cycles. If we
3310
didn't, then there is some cycle in the call graph not attached to
3311
any root node. Arbitrarily choose a node in the cycle as a new
3312
root and break the cycle. */
3315
mark_detached_root (struct function_info *fun,
3316
struct bfd_link_info *info,
3321
fun->non_root = FALSE;
3322
*(unsigned int *) param = 0;
3323
return remove_cycles (fun, info, param);
3326
/* Populate call_list for each function. */
3329
build_call_tree (struct bfd_link_info *info)
3334
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3336
extern const bfd_target bfd_elf32_spu_vec;
3339
if (ibfd->xvec != &bfd_elf32_spu_vec)
3342
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3343
if (!mark_functions_via_relocs (sec, info, TRUE))
3347
/* Transfer call info from hot/cold section part of function
3349
if (!spu_hash_table (info)->params->auto_overlay
3350
&& !for_each_node (transfer_calls, info, 0, FALSE))
3353
/* Find the call graph root(s). */
3354
if (!for_each_node (mark_non_root, info, 0, FALSE))
3357
/* Remove cycles from the call graph. We start from the root node(s)
3358
so that we break cycles in a reasonable place. */
3360
if (!for_each_node (remove_cycles, info, &depth, TRUE))
3363
return for_each_node (mark_detached_root, info, &depth, FALSE);
3366
/* qsort predicate to sort calls by priority, max_depth then count. */
3369
sort_calls (const void *a, const void *b)
3371
struct call_info *const *c1 = a;
3372
struct call_info *const *c2 = b;
3375
delta = (*c2)->priority - (*c1)->priority;
3379
delta = (*c2)->max_depth - (*c1)->max_depth;
3383
delta = (*c2)->count - (*c1)->count;
3387
return (char *) c1 - (char *) c2;
3391
unsigned int max_overlay_size;
3394
/* Set linker_mark and gc_mark on any sections that we will put in
3395
overlays. These flags are used by the generic ELF linker, but we
3396
won't be continuing on to bfd_elf_final_link so it is OK to use
3397
them. linker_mark is clear before we get here. Set segment_mark
3398
on sections that are part of a pasted function (excluding the last
3401
Set up function rodata section if --overlay-rodata. We don't
3402
currently include merged string constant rodata sections since
3404
Sort the call graph so that the deepest nodes will be visited
3408
mark_overlay_section (struct function_info *fun,
3409
struct bfd_link_info *info,
3412
struct call_info *call;
3414
struct _mos_param *mos_param = param;
3415
struct spu_link_hash_table *htab = spu_hash_table (info);
3421
if (!fun->sec->linker_mark
3422
&& (htab->params->ovly_flavour != ovly_soft_icache
3423
|| htab->params->non_ia_text
3424
|| strncmp (fun->sec->name, ".text.ia.", 9) == 0
3425
|| strcmp (fun->sec->name, ".init") == 0
3426
|| strcmp (fun->sec->name, ".fini") == 0))
3430
fun->sec->linker_mark = 1;
3431
fun->sec->gc_mark = 1;
3432
fun->sec->segment_mark = 0;
3433
/* Ensure SEC_CODE is set on this text section (it ought to
3434
be!), and SEC_CODE is clear on rodata sections. We use
3435
this flag to differentiate the two overlay section types. */
3436
fun->sec->flags |= SEC_CODE;
3438
size = fun->sec->size;
3439
if (htab->params->auto_overlay & OVERLAY_RODATA)
3443
/* Find the rodata section corresponding to this function's
3445
if (strcmp (fun->sec->name, ".text") == 0)
3447
name = bfd_malloc (sizeof (".rodata"));
3450
memcpy (name, ".rodata", sizeof (".rodata"));
3452
else if (strncmp (fun->sec->name, ".text.", 6) == 0)
3454
size_t len = strlen (fun->sec->name);
3455
name = bfd_malloc (len + 3);
3458
memcpy (name, ".rodata", sizeof (".rodata"));
3459
memcpy (name + 7, fun->sec->name + 5, len - 4);
3461
else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
3463
size_t len = strlen (fun->sec->name) + 1;
3464
name = bfd_malloc (len);
3467
memcpy (name, fun->sec->name, len);
3473
asection *rodata = NULL;
3474
asection *group_sec = elf_section_data (fun->sec)->next_in_group;
3475
if (group_sec == NULL)
3476
rodata = bfd_get_section_by_name (fun->sec->owner, name);
3478
while (group_sec != NULL && group_sec != fun->sec)
3480
if (strcmp (group_sec->name, name) == 0)
3485
group_sec = elf_section_data (group_sec)->next_in_group;
3487
fun->rodata = rodata;
3490
size += fun->rodata->size;
3491
if (htab->params->line_size != 0
3492
&& size > htab->params->line_size)
3494
size -= fun->rodata->size;
3499
fun->rodata->linker_mark = 1;
3500
fun->rodata->gc_mark = 1;
3501
fun->rodata->flags &= ~SEC_CODE;
3507
if (mos_param->max_overlay_size < size)
3508
mos_param->max_overlay_size = size;
3511
for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3516
struct call_info **calls = bfd_malloc (count * sizeof (*calls));
3520
for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3521
calls[count++] = call;
3523
qsort (calls, count, sizeof (*calls), sort_calls);
3525
fun->call_list = NULL;
3529
calls[count]->next = fun->call_list;
3530
fun->call_list = calls[count];
3535
for (call = fun->call_list; call != NULL; call = call->next)
3537
if (call->is_pasted)
3539
/* There can only be one is_pasted call per function_info. */
3540
BFD_ASSERT (!fun->sec->segment_mark);
3541
fun->sec->segment_mark = 1;
3543
if (!call->broken_cycle
3544
&& !mark_overlay_section (call->fun, info, param))
3548
/* Don't put entry code into an overlay. The overlay manager needs
3549
a stack! Also, don't mark .ovl.init as an overlay. */
3550
if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
3551
== info->output_bfd->start_address
3552
|| strncmp (fun->sec->output_section->name, ".ovl.init", 9) == 0)
3554
fun->sec->linker_mark = 0;
3555
if (fun->rodata != NULL)
3556
fun->rodata->linker_mark = 0;
3561
/* If non-zero then unmark functions called from those within sections
3562
that we need to unmark. Unfortunately this isn't reliable since the
3563
call graph cannot know the destination of function pointer calls. */
3564
#define RECURSE_UNMARK 0
3567
asection *exclude_input_section;
3568
asection *exclude_output_section;
3569
unsigned long clearing;
3572
/* Undo some of mark_overlay_section's work. */
3575
unmark_overlay_section (struct function_info *fun,
3576
struct bfd_link_info *info,
3579
struct call_info *call;
3580
struct _uos_param *uos_param = param;
3581
unsigned int excluded = 0;
3589
if (fun->sec == uos_param->exclude_input_section
3590
|| fun->sec->output_section == uos_param->exclude_output_section)
3594
uos_param->clearing += excluded;
3596
if (RECURSE_UNMARK ? uos_param->clearing : excluded)
3598
fun->sec->linker_mark = 0;
3600
fun->rodata->linker_mark = 0;
3603
for (call = fun->call_list; call != NULL; call = call->next)
3604
if (!call->broken_cycle
3605
&& !unmark_overlay_section (call->fun, info, param))
3609
uos_param->clearing -= excluded;
3614
unsigned int lib_size;
3615
asection **lib_sections;
3618
/* Add sections we have marked as belonging to overlays to an array
3619
for consideration as non-overlay sections. The array consist of
3620
pairs of sections, (text,rodata), for functions in the call graph. */
3623
collect_lib_sections (struct function_info *fun,
3624
struct bfd_link_info *info,
3627
struct _cl_param *lib_param = param;
3628
struct call_info *call;
3635
if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
3638
size = fun->sec->size;
3640
size += fun->rodata->size;
3642
if (size <= lib_param->lib_size)
3644
*lib_param->lib_sections++ = fun->sec;
3645
fun->sec->gc_mark = 0;
3646
if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3648
*lib_param->lib_sections++ = fun->rodata;
3649
fun->rodata->gc_mark = 0;
3652
*lib_param->lib_sections++ = NULL;
3655
for (call = fun->call_list; call != NULL; call = call->next)
3656
if (!call->broken_cycle)
3657
collect_lib_sections (call->fun, info, param);
3662
/* qsort predicate to sort sections by call count. */
3665
sort_lib (const void *a, const void *b)
3667
asection *const *s1 = a;
3668
asection *const *s2 = b;
3669
struct _spu_elf_section_data *sec_data;
3670
struct spu_elf_stack_info *sinfo;
3674
if ((sec_data = spu_elf_section_data (*s1)) != NULL
3675
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3678
for (i = 0; i < sinfo->num_fun; ++i)
3679
delta -= sinfo->fun[i].call_count;
3682
if ((sec_data = spu_elf_section_data (*s2)) != NULL
3683
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3686
for (i = 0; i < sinfo->num_fun; ++i)
3687
delta += sinfo->fun[i].call_count;
3696
/* Remove some sections from those marked to be in overlays. Choose
3697
those that are called from many places, likely library functions. */
3700
auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3703
asection **lib_sections;
3704
unsigned int i, lib_count;
3705
struct _cl_param collect_lib_param;
3706
struct function_info dummy_caller;
3707
struct spu_link_hash_table *htab;
3709
memset (&dummy_caller, 0, sizeof (dummy_caller));
3711
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3713
extern const bfd_target bfd_elf32_spu_vec;
3716
if (ibfd->xvec != &bfd_elf32_spu_vec)
3719
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3720
if (sec->linker_mark
3721
&& sec->size < lib_size
3722
&& (sec->flags & SEC_CODE) != 0)
3725
lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3726
if (lib_sections == NULL)
3727
return (unsigned int) -1;
3728
collect_lib_param.lib_size = lib_size;
3729
collect_lib_param.lib_sections = lib_sections;
3730
if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3732
return (unsigned int) -1;
3733
lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3735
/* Sort sections so that those with the most calls are first. */
3737
qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3739
htab = spu_hash_table (info);
3740
for (i = 0; i < lib_count; i++)
3742
unsigned int tmp, stub_size;
3744
struct _spu_elf_section_data *sec_data;
3745
struct spu_elf_stack_info *sinfo;
3747
sec = lib_sections[2 * i];
3748
/* If this section is OK, its size must be less than lib_size. */
3750
/* If it has a rodata section, then add that too. */
3751
if (lib_sections[2 * i + 1])
3752
tmp += lib_sections[2 * i + 1]->size;
3753
/* Add any new overlay call stubs needed by the section. */
3756
&& (sec_data = spu_elf_section_data (sec)) != NULL
3757
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3760
struct call_info *call;
3762
for (k = 0; k < sinfo->num_fun; ++k)
3763
for (call = sinfo->fun[k].call_list; call; call = call->next)
3764
if (call->fun->sec->linker_mark)
3766
struct call_info *p;
3767
for (p = dummy_caller.call_list; p; p = p->next)
3768
if (p->fun == call->fun)
3771
stub_size += ovl_stub_size (htab->params);
3774
if (tmp + stub_size < lib_size)
3776
struct call_info **pp, *p;
3778
/* This section fits. Mark it as non-overlay. */
3779
lib_sections[2 * i]->linker_mark = 0;
3780
if (lib_sections[2 * i + 1])
3781
lib_sections[2 * i + 1]->linker_mark = 0;
3782
lib_size -= tmp + stub_size;
3783
/* Call stubs to the section we just added are no longer
3785
pp = &dummy_caller.call_list;
3786
while ((p = *pp) != NULL)
3787
if (!p->fun->sec->linker_mark)
3789
lib_size += ovl_stub_size (htab->params);
3795
/* Add new call stubs to dummy_caller. */
3796
if ((sec_data = spu_elf_section_data (sec)) != NULL
3797
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3800
struct call_info *call;
3802
for (k = 0; k < sinfo->num_fun; ++k)
3803
for (call = sinfo->fun[k].call_list;
3806
if (call->fun->sec->linker_mark)
3808
struct call_info *callee;
3809
callee = bfd_malloc (sizeof (*callee));
3811
return (unsigned int) -1;
3813
if (!insert_callee (&dummy_caller, callee))
3819
while (dummy_caller.call_list != NULL)
3821
struct call_info *call = dummy_caller.call_list;
3822
dummy_caller.call_list = call->next;
3825
for (i = 0; i < 2 * lib_count; i++)
3826
if (lib_sections[i])
3827
lib_sections[i]->gc_mark = 1;
3828
free (lib_sections);
3832
/* Build an array of overlay sections. The deepest node's section is
3833
added first, then its parent node's section, then everything called
3834
from the parent section. The idea being to group sections to
3835
minimise calls between different overlays. */
3838
collect_overlays (struct function_info *fun,
3839
struct bfd_link_info *info,
3842
struct call_info *call;
3843
bfd_boolean added_fun;
3844
asection ***ovly_sections = param;
3850
for (call = fun->call_list; call != NULL; call = call->next)
3851
if (!call->is_pasted && !call->broken_cycle)
3853
if (!collect_overlays (call->fun, info, ovly_sections))
3859
if (fun->sec->linker_mark && fun->sec->gc_mark)
3861
fun->sec->gc_mark = 0;
3862
*(*ovly_sections)++ = fun->sec;
3863
if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3865
fun->rodata->gc_mark = 0;
3866
*(*ovly_sections)++ = fun->rodata;
3869
*(*ovly_sections)++ = NULL;
3872
/* Pasted sections must stay with the first section. We don't
3873
put pasted sections in the array, just the first section.
3874
Mark subsequent sections as already considered. */
3875
if (fun->sec->segment_mark)
3877
struct function_info *call_fun = fun;
3880
for (call = call_fun->call_list; call != NULL; call = call->next)
3881
if (call->is_pasted)
3883
call_fun = call->fun;
3884
call_fun->sec->gc_mark = 0;
3885
if (call_fun->rodata)
3886
call_fun->rodata->gc_mark = 0;
3892
while (call_fun->sec->segment_mark);
3896
for (call = fun->call_list; call != NULL; call = call->next)
3897
if (!call->broken_cycle
3898
&& !collect_overlays (call->fun, info, ovly_sections))
3903
struct _spu_elf_section_data *sec_data;
3904
struct spu_elf_stack_info *sinfo;
3906
if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3907
&& (sinfo = sec_data->u.i.stack_info) != NULL)
3910
for (i = 0; i < sinfo->num_fun; ++i)
3911
if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3919
struct _sum_stack_param {
3921
size_t overall_stack;
3922
bfd_boolean emit_stack_syms;
3925
/* Descend the call graph for FUN, accumulating total stack required. */
3928
sum_stack (struct function_info *fun,
3929
struct bfd_link_info *info,
3932
struct call_info *call;
3933
struct function_info *max;
3934
size_t stack, cum_stack;
3936
bfd_boolean has_call;
3937
struct _sum_stack_param *sum_stack_param = param;
3938
struct spu_link_hash_table *htab;
3940
cum_stack = fun->stack;
3941
sum_stack_param->cum_stack = cum_stack;
3947
for (call = fun->call_list; call; call = call->next)
3949
if (call->broken_cycle)
3951
if (!call->is_pasted)
3953
if (!sum_stack (call->fun, info, sum_stack_param))
3955
stack = sum_stack_param->cum_stack;
3956
/* Include caller stack for normal calls, don't do so for
3957
tail calls. fun->stack here is local stack usage for
3959
if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
3960
stack += fun->stack;
3961
if (cum_stack < stack)
3968
sum_stack_param->cum_stack = cum_stack;
3970
/* Now fun->stack holds cumulative stack. */
3971
fun->stack = cum_stack;
3975
&& sum_stack_param->overall_stack < cum_stack)
3976
sum_stack_param->overall_stack = cum_stack;
3978
htab = spu_hash_table (info);
3979
if (htab->params->auto_overlay)
3982
f1 = func_name (fun);
3983
if (htab->params->stack_analysis)
3986
info->callbacks->info (_(" %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
3987
info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
3988
f1, (bfd_vma) stack, (bfd_vma) cum_stack);
3992
info->callbacks->minfo (_(" calls:\n"));
3993
for (call = fun->call_list; call; call = call->next)
3994
if (!call->is_pasted && !call->broken_cycle)
3996
const char *f2 = func_name (call->fun);
3997
const char *ann1 = call->fun == max ? "*" : " ";
3998
const char *ann2 = call->is_tail ? "t" : " ";
4000
info->callbacks->minfo (_(" %s%s %s\n"), ann1, ann2, f2);
4005
if (sum_stack_param->emit_stack_syms)
4007
char *name = bfd_malloc (18 + strlen (f1));
4008
struct elf_link_hash_entry *h;
4013
if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
4014
sprintf (name, "__stack_%s", f1);
4016
sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
4018
h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
4021
&& (h->root.type == bfd_link_hash_new
4022
|| h->root.type == bfd_link_hash_undefined
4023
|| h->root.type == bfd_link_hash_undefweak))
4025
h->root.type = bfd_link_hash_defined;
4026
h->root.u.def.section = bfd_abs_section_ptr;
4027
h->root.u.def.value = cum_stack;
4032
h->ref_regular_nonweak = 1;
4033
h->forced_local = 1;
4041
/* SEC is part of a pasted function. Return the call_info for the
4042
next section of this function. */
4044
static struct call_info *
4045
find_pasted_call (asection *sec)
4047
struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
4048
struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
4049
struct call_info *call;
4052
for (k = 0; k < sinfo->num_fun; ++k)
4053
for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
4054
if (call->is_pasted)
4060
/* qsort predicate to sort bfds by file name. */
4063
sort_bfds (const void *a, const void *b)
4065
bfd *const *abfd1 = a;
4066
bfd *const *abfd2 = b;
4068
return filename_cmp ((*abfd1)->filename, (*abfd2)->filename);
4072
print_one_overlay_section (FILE *script,
4075
unsigned int ovlynum,
4076
unsigned int *ovly_map,
4077
asection **ovly_sections,
4078
struct bfd_link_info *info)
4082
for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4084
asection *sec = ovly_sections[2 * j];
4086
if (fprintf (script, " %s%c%s (%s)\n",
4087
(sec->owner->my_archive != NULL
4088
? sec->owner->my_archive->filename : ""),
4089
info->path_separator,
4090
sec->owner->filename,
4093
if (sec->segment_mark)
4095
struct call_info *call = find_pasted_call (sec);
4096
while (call != NULL)
4098
struct function_info *call_fun = call->fun;
4099
sec = call_fun->sec;
4100
if (fprintf (script, " %s%c%s (%s)\n",
4101
(sec->owner->my_archive != NULL
4102
? sec->owner->my_archive->filename : ""),
4103
info->path_separator,
4104
sec->owner->filename,
4107
for (call = call_fun->call_list; call; call = call->next)
4108
if (call->is_pasted)
4114
for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4116
asection *sec = ovly_sections[2 * j + 1];
4118
&& fprintf (script, " %s%c%s (%s)\n",
4119
(sec->owner->my_archive != NULL
4120
? sec->owner->my_archive->filename : ""),
4121
info->path_separator,
4122
sec->owner->filename,
4126
sec = ovly_sections[2 * j];
4127
if (sec->segment_mark)
4129
struct call_info *call = find_pasted_call (sec);
4130
while (call != NULL)
4132
struct function_info *call_fun = call->fun;
4133
sec = call_fun->rodata;
4135
&& fprintf (script, " %s%c%s (%s)\n",
4136
(sec->owner->my_archive != NULL
4137
? sec->owner->my_archive->filename : ""),
4138
info->path_separator,
4139
sec->owner->filename,
4142
for (call = call_fun->call_list; call; call = call->next)
4143
if (call->is_pasted)
4152
/* Handle --auto-overlay. */
4155
spu_elf_auto_overlay (struct bfd_link_info *info)
4159
struct elf_segment_map *m;
4160
unsigned int fixed_size, lo, hi;
4161
unsigned int reserved;
4162
struct spu_link_hash_table *htab;
4163
unsigned int base, i, count, bfd_count;
4164
unsigned int region, ovlynum;
4165
asection **ovly_sections, **ovly_p;
4166
unsigned int *ovly_map;
4168
unsigned int total_overlay_size, overlay_size;
4169
const char *ovly_mgr_entry;
4170
struct elf_link_hash_entry *h;
4171
struct _mos_param mos_param;
4172
struct _uos_param uos_param;
4173
struct function_info dummy_caller;
4175
/* Find the extents of our loadable image. */
4176
lo = (unsigned int) -1;
4178
for (m = elf_seg_map (info->output_bfd); m != NULL; m = m->next)
4179
if (m->p_type == PT_LOAD)
4180
for (i = 0; i < m->count; i++)
4181
if (m->sections[i]->size != 0)
4183
if (m->sections[i]->vma < lo)
4184
lo = m->sections[i]->vma;
4185
if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
4186
hi = m->sections[i]->vma + m->sections[i]->size - 1;
4188
fixed_size = hi + 1 - lo;
4190
if (!discover_functions (info))
4193
if (!build_call_tree (info))
4196
htab = spu_hash_table (info);
4197
reserved = htab->params->auto_overlay_reserved;
4200
struct _sum_stack_param sum_stack_param;
4202
sum_stack_param.emit_stack_syms = 0;
4203
sum_stack_param.overall_stack = 0;
4204
if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4206
reserved = (sum_stack_param.overall_stack
4207
+ htab->params->extra_stack_space);
4210
/* No need for overlays if everything already fits. */
4211
if (fixed_size + reserved <= htab->local_store
4212
&& htab->params->ovly_flavour != ovly_soft_icache)
4214
htab->params->auto_overlay = 0;
4218
uos_param.exclude_input_section = 0;
4219
uos_param.exclude_output_section
4220
= bfd_get_section_by_name (info->output_bfd, ".interrupt");
4222
ovly_mgr_entry = "__ovly_load";
4223
if (htab->params->ovly_flavour == ovly_soft_icache)
4224
ovly_mgr_entry = "__icache_br_handler";
4225
h = elf_link_hash_lookup (&htab->elf, ovly_mgr_entry,
4226
FALSE, FALSE, FALSE);
4228
&& (h->root.type == bfd_link_hash_defined
4229
|| h->root.type == bfd_link_hash_defweak)
4232
/* We have a user supplied overlay manager. */
4233
uos_param.exclude_input_section = h->root.u.def.section;
4237
/* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4238
builtin version to .text, and will adjust .text size. */
4239
fixed_size += (*htab->params->spu_elf_load_ovl_mgr) ();
4242
/* Mark overlay sections, and find max overlay section size. */
4243
mos_param.max_overlay_size = 0;
4244
if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
4247
/* We can't put the overlay manager or interrupt routines in
4249
uos_param.clearing = 0;
4250
if ((uos_param.exclude_input_section
4251
|| uos_param.exclude_output_section)
4252
&& !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
4256
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4258
bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
4259
if (bfd_arr == NULL)
4262
/* Count overlay sections, and subtract their sizes from "fixed_size". */
4265
total_overlay_size = 0;
4266
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4268
extern const bfd_target bfd_elf32_spu_vec;
4270
unsigned int old_count;
4272
if (ibfd->xvec != &bfd_elf32_spu_vec)
4276
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4277
if (sec->linker_mark)
4279
if ((sec->flags & SEC_CODE) != 0)
4281
fixed_size -= sec->size;
4282
total_overlay_size += sec->size;
4284
else if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)
4285
&& sec->output_section->owner == info->output_bfd
4286
&& strncmp (sec->output_section->name, ".ovl.init", 9) == 0)
4287
fixed_size -= sec->size;
4288
if (count != old_count)
4289
bfd_arr[bfd_count++] = ibfd;
4292
/* Since the overlay link script selects sections by file name and
4293
section name, ensure that file names are unique. */
4296
bfd_boolean ok = TRUE;
4298
qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
4299
for (i = 1; i < bfd_count; ++i)
4300
if (filename_cmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
4302
if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
4304
if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
4305
info->callbacks->einfo (_("%s duplicated in %s\n"),
4306
bfd_arr[i]->filename,
4307
bfd_arr[i]->my_archive->filename);
4309
info->callbacks->einfo (_("%s duplicated\n"),
4310
bfd_arr[i]->filename);
4316
info->callbacks->einfo (_("sorry, no support for duplicate "
4317
"object files in auto-overlay script\n"));
4318
bfd_set_error (bfd_error_bad_value);
4324
fixed_size += reserved;
4325
fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
4326
if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
4328
if (htab->params->ovly_flavour == ovly_soft_icache)
4330
/* Stubs in the non-icache area are bigger. */
4331
fixed_size += htab->non_ovly_stub * 16;
4332
/* Space for icache manager tables.
4333
a) Tag array, one quadword per cache line.
4334
- word 0: ia address of present line, init to zero. */
4335
fixed_size += 16 << htab->num_lines_log2;
4336
/* b) Rewrite "to" list, one quadword per cache line. */
4337
fixed_size += 16 << htab->num_lines_log2;
4338
/* c) Rewrite "from" list, one byte per outgoing branch (rounded up
4339
to a power-of-two number of full quadwords) per cache line. */
4340
fixed_size += 16 << (htab->fromelem_size_log2
4341
+ htab->num_lines_log2);
4342
/* d) Pointer to __ea backing store (toe), 1 quadword. */
4347
/* Guess number of overlays. Assuming overlay buffer is on
4348
average only half full should be conservative. */
4349
ovlynum = (total_overlay_size * 2 * htab->params->num_lines
4350
/ (htab->local_store - fixed_size));
4351
/* Space for _ovly_table[], _ovly_buf_table[] and toe. */
4352
fixed_size += ovlynum * 16 + 16 + 4 + 16;
4356
if (fixed_size + mos_param.max_overlay_size > htab->local_store)
4357
info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4358
"size of 0x%v exceeds local store\n"),
4359
(bfd_vma) fixed_size,
4360
(bfd_vma) mos_param.max_overlay_size);
4362
/* Now see if we should put some functions in the non-overlay area. */
4363
else if (fixed_size < htab->params->auto_overlay_fixed)
4365
unsigned int max_fixed, lib_size;
4367
max_fixed = htab->local_store - mos_param.max_overlay_size;
4368
if (max_fixed > htab->params->auto_overlay_fixed)
4369
max_fixed = htab->params->auto_overlay_fixed;
4370
lib_size = max_fixed - fixed_size;
4371
lib_size = auto_ovl_lib_functions (info, lib_size);
4372
if (lib_size == (unsigned int) -1)
4374
fixed_size = max_fixed - lib_size;
4377
/* Build an array of sections, suitably sorted to place into
4379
ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
4380
if (ovly_sections == NULL)
4382
ovly_p = ovly_sections;
4383
if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
4385
count = (size_t) (ovly_p - ovly_sections) / 2;
4386
ovly_map = bfd_malloc (count * sizeof (*ovly_map));
4387
if (ovly_map == NULL)
4390
memset (&dummy_caller, 0, sizeof (dummy_caller));
4391
overlay_size = (htab->local_store - fixed_size) / htab->params->num_lines;
4392
if (htab->params->line_size != 0)
4393
overlay_size = htab->params->line_size;
4396
while (base < count)
4398
unsigned int size = 0, rosize = 0, roalign = 0;
4400
for (i = base; i < count; i++)
4402
asection *sec, *rosec;
4403
unsigned int tmp, rotmp;
4404
unsigned int num_stubs;
4405
struct call_info *call, *pasty;
4406
struct _spu_elf_section_data *sec_data;
4407
struct spu_elf_stack_info *sinfo;
4410
/* See whether we can add this section to the current
4411
overlay without overflowing our overlay buffer. */
4412
sec = ovly_sections[2 * i];
4413
tmp = align_power (size, sec->alignment_power) + sec->size;
4415
rosec = ovly_sections[2 * i + 1];
4418
rotmp = align_power (rotmp, rosec->alignment_power) + rosec->size;
4419
if (roalign < rosec->alignment_power)
4420
roalign = rosec->alignment_power;
4422
if (align_power (tmp, roalign) + rotmp > overlay_size)
4424
if (sec->segment_mark)
4426
/* Pasted sections must stay together, so add their
4428
pasty = find_pasted_call (sec);
4429
while (pasty != NULL)
4431
struct function_info *call_fun = pasty->fun;
4432
tmp = (align_power (tmp, call_fun->sec->alignment_power)
4433
+ call_fun->sec->size);
4434
if (call_fun->rodata)
4436
rotmp = (align_power (rotmp,
4437
call_fun->rodata->alignment_power)
4438
+ call_fun->rodata->size);
4439
if (roalign < rosec->alignment_power)
4440
roalign = rosec->alignment_power;
4442
for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
4443
if (pasty->is_pasted)
4447
if (align_power (tmp, roalign) + rotmp > overlay_size)
4450
/* If we add this section, we might need new overlay call
4451
stubs. Add any overlay section calls to dummy_call. */
4453
sec_data = spu_elf_section_data (sec);
4454
sinfo = sec_data->u.i.stack_info;
4455
for (k = 0; k < (unsigned) sinfo->num_fun; ++k)
4456
for (call = sinfo->fun[k].call_list; call; call = call->next)
4457
if (call->is_pasted)
4459
BFD_ASSERT (pasty == NULL);
4462
else if (call->fun->sec->linker_mark)
4464
if (!copy_callee (&dummy_caller, call))
4467
while (pasty != NULL)
4469
struct function_info *call_fun = pasty->fun;
4471
for (call = call_fun->call_list; call; call = call->next)
4472
if (call->is_pasted)
4474
BFD_ASSERT (pasty == NULL);
4477
else if (!copy_callee (&dummy_caller, call))
4481
/* Calculate call stub size. */
4483
for (call = dummy_caller.call_list; call; call = call->next)
4485
unsigned int stub_delta = 1;
4487
if (htab->params->ovly_flavour == ovly_soft_icache)
4488
stub_delta = call->count;
4489
num_stubs += stub_delta;
4491
/* If the call is within this overlay, we won't need a
4493
for (k = base; k < i + 1; k++)
4494
if (call->fun->sec == ovly_sections[2 * k])
4496
num_stubs -= stub_delta;
4500
if (htab->params->ovly_flavour == ovly_soft_icache
4501
&& num_stubs > htab->params->max_branch)
4503
if (align_power (tmp, roalign) + rotmp
4504
+ num_stubs * ovl_stub_size (htab->params) > overlay_size)
4512
info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
4513
ovly_sections[2 * i]->owner,
4514
ovly_sections[2 * i],
4515
ovly_sections[2 * i + 1] ? " + rodata" : "");
4516
bfd_set_error (bfd_error_bad_value);
4520
while (dummy_caller.call_list != NULL)
4522
struct call_info *call = dummy_caller.call_list;
4523
dummy_caller.call_list = call->next;
4529
ovly_map[base++] = ovlynum;
4532
script = htab->params->spu_elf_open_overlay_script ();
4534
if (htab->params->ovly_flavour == ovly_soft_icache)
4536
if (fprintf (script, "SECTIONS\n{\n") <= 0)
4539
if (fprintf (script,
4540
" . = ALIGN (%u);\n"
4541
" .ovl.init : { *(.ovl.init) }\n"
4542
" . = ABSOLUTE (ADDR (.ovl.init));\n",
4543
htab->params->line_size) <= 0)
4548
while (base < count)
4550
unsigned int indx = ovlynum - 1;
4551
unsigned int vma, lma;
4553
vma = (indx & (htab->params->num_lines - 1)) << htab->line_size_log2;
4554
lma = vma + (((indx >> htab->num_lines_log2) + 1) << 18);
4556
if (fprintf (script, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4557
": AT (LOADADDR (.ovl.init) + %u) {\n",
4558
ovlynum, vma, lma) <= 0)
4561
base = print_one_overlay_section (script, base, count, ovlynum,
4562
ovly_map, ovly_sections, info);
4563
if (base == (unsigned) -1)
4566
if (fprintf (script, " }\n") <= 0)
4572
if (fprintf (script, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4573
1 << (htab->num_lines_log2 + htab->line_size_log2)) <= 0)
4576
if (fprintf (script, "}\nINSERT AFTER .toe;\n") <= 0)
4581
if (fprintf (script, "SECTIONS\n{\n") <= 0)
4584
if (fprintf (script,
4585
" . = ALIGN (16);\n"
4586
" .ovl.init : { *(.ovl.init) }\n"
4587
" . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
4590
for (region = 1; region <= htab->params->num_lines; region++)
4594
while (base < count && ovly_map[base] < ovlynum)
4602
/* We need to set lma since we are overlaying .ovl.init. */
4603
if (fprintf (script,
4604
" OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4609
if (fprintf (script, " OVERLAY :\n {\n") <= 0)
4613
while (base < count)
4615
if (fprintf (script, " .ovly%u {\n", ovlynum) <= 0)
4618
base = print_one_overlay_section (script, base, count, ovlynum,
4619
ovly_map, ovly_sections, info);
4620
if (base == (unsigned) -1)
4623
if (fprintf (script, " }\n") <= 0)
4626
ovlynum += htab->params->num_lines;
4627
while (base < count && ovly_map[base] < ovlynum)
4631
if (fprintf (script, " }\n") <= 0)
4635
if (fprintf (script, "}\nINSERT BEFORE .text;\n") <= 0)
4640
free (ovly_sections);
4642
if (fclose (script) != 0)
4645
if (htab->params->auto_overlay & AUTO_RELINK)
4646
(*htab->params->spu_elf_relink) ();
4651
bfd_set_error (bfd_error_system_call);
4653
info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
4657
/* Provide an estimate of total stack required. */
4660
spu_elf_stack_analysis (struct bfd_link_info *info)
4662
struct spu_link_hash_table *htab;
4663
struct _sum_stack_param sum_stack_param;
4665
if (!discover_functions (info))
4668
if (!build_call_tree (info))
4671
htab = spu_hash_table (info);
4672
if (htab->params->stack_analysis)
4674
info->callbacks->info (_("Stack size for call graph root nodes.\n"));
4675
info->callbacks->minfo (_("\nStack size for functions. "
4676
"Annotations: '*' max stack, 't' tail call\n"));
4679
sum_stack_param.emit_stack_syms = htab->params->emit_stack_syms;
4680
sum_stack_param.overall_stack = 0;
4681
if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4684
if (htab->params->stack_analysis)
4685
info->callbacks->info (_("Maximum stack required is 0x%v\n"),
4686
(bfd_vma) sum_stack_param.overall_stack);
4690
/* Perform a final link. */
4693
spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
4695
struct spu_link_hash_table *htab = spu_hash_table (info);
4697
if (htab->params->auto_overlay)
4698
spu_elf_auto_overlay (info);
4700
if ((htab->params->stack_analysis
4701
|| (htab->params->ovly_flavour == ovly_soft_icache
4702
&& htab->params->lrlive_analysis))
4703
&& !spu_elf_stack_analysis (info))
4704
info->callbacks->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4706
if (!spu_elf_build_stubs (info))
4707
info->callbacks->einfo ("%F%P: can not build overlay stubs: %E\n");
4709
return bfd_elf_final_link (output_bfd, info);
4712
/* Called when not normally emitting relocs, ie. !info->relocatable
4713
and !info->emitrelocations. Returns a count of special relocs
4714
that need to be emitted. */
4717
spu_elf_count_relocs (struct bfd_link_info *info, asection *sec)
4719
Elf_Internal_Rela *relocs;
4720
unsigned int count = 0;
4722
relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
4726
Elf_Internal_Rela *rel;
4727
Elf_Internal_Rela *relend = relocs + sec->reloc_count;
4729
for (rel = relocs; rel < relend; rel++)
4731
int r_type = ELF32_R_TYPE (rel->r_info);
4732
if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4736
if (elf_section_data (sec)->relocs != relocs)
4743
/* Functions for adding fixup records to .fixup */
4745
#define FIXUP_RECORD_SIZE 4
4747
#define FIXUP_PUT(output_bfd,htab,index,addr) \
4748
bfd_put_32 (output_bfd, addr, \
4749
htab->sfixup->contents + FIXUP_RECORD_SIZE * (index))
4750
#define FIXUP_GET(output_bfd,htab,index) \
4751
bfd_get_32 (output_bfd, \
4752
htab->sfixup->contents + FIXUP_RECORD_SIZE * (index))
4754
/* Store OFFSET in .fixup. This assumes it will be called with an
4755
increasing OFFSET. When this OFFSET fits with the last base offset,
4756
it just sets a bit, otherwise it adds a new fixup record. */
4758
spu_elf_emit_fixup (bfd * output_bfd, struct bfd_link_info *info,
4761
struct spu_link_hash_table *htab = spu_hash_table (info);
4762
asection *sfixup = htab->sfixup;
4763
bfd_vma qaddr = offset & ~(bfd_vma) 15;
4764
bfd_vma bit = ((bfd_vma) 8) >> ((offset & 15) >> 2);
4765
if (sfixup->reloc_count == 0)
4767
FIXUP_PUT (output_bfd, htab, 0, qaddr | bit);
4768
sfixup->reloc_count++;
4772
bfd_vma base = FIXUP_GET (output_bfd, htab, sfixup->reloc_count - 1);
4773
if (qaddr != (base & ~(bfd_vma) 15))
4775
if ((sfixup->reloc_count + 1) * FIXUP_RECORD_SIZE > sfixup->size)
4776
(*_bfd_error_handler) (_("fatal error while creating .fixup"));
4777
FIXUP_PUT (output_bfd, htab, sfixup->reloc_count, qaddr | bit);
4778
sfixup->reloc_count++;
4781
FIXUP_PUT (output_bfd, htab, sfixup->reloc_count - 1, base | bit);
4785
/* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
4788
spu_elf_relocate_section (bfd *output_bfd,
4789
struct bfd_link_info *info,
4791
asection *input_section,
4793
Elf_Internal_Rela *relocs,
4794
Elf_Internal_Sym *local_syms,
4795
asection **local_sections)
4797
Elf_Internal_Shdr *symtab_hdr;
4798
struct elf_link_hash_entry **sym_hashes;
4799
Elf_Internal_Rela *rel, *relend;
4800
struct spu_link_hash_table *htab;
4803
bfd_boolean emit_these_relocs = FALSE;
4804
bfd_boolean is_ea_sym;
4806
unsigned int iovl = 0;
4808
htab = spu_hash_table (info);
4809
stubs = (htab->stub_sec != NULL
4810
&& maybe_needs_stubs (input_section));
4811
iovl = overlay_index (input_section);
4812
ea = bfd_get_section_by_name (output_bfd, "._ea");
4813
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4814
sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
4817
relend = relocs + input_section->reloc_count;
4818
for (; rel < relend; rel++)
4821
reloc_howto_type *howto;
4822
unsigned int r_symndx;
4823
Elf_Internal_Sym *sym;
4825
struct elf_link_hash_entry *h;
4826
const char *sym_name;
4829
bfd_reloc_status_type r;
4830
bfd_boolean unresolved_reloc;
4831
enum _stub_type stub_type;
4833
r_symndx = ELF32_R_SYM (rel->r_info);
4834
r_type = ELF32_R_TYPE (rel->r_info);
4835
howto = elf_howto_table + r_type;
4836
unresolved_reloc = FALSE;
4840
if (r_symndx < symtab_hdr->sh_info)
4842
sym = local_syms + r_symndx;
4843
sec = local_sections[r_symndx];
4844
sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
4845
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4849
if (sym_hashes == NULL)
4852
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4854
while (h->root.type == bfd_link_hash_indirect
4855
|| h->root.type == bfd_link_hash_warning)
4856
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4859
if (h->root.type == bfd_link_hash_defined
4860
|| h->root.type == bfd_link_hash_defweak)
4862
sec = h->root.u.def.section;
4864
|| sec->output_section == NULL)
4865
/* Set a flag that will be cleared later if we find a
4866
relocation value for this symbol. output_section
4867
is typically NULL for symbols satisfied by a shared
4869
unresolved_reloc = TRUE;
4871
relocation = (h->root.u.def.value
4872
+ sec->output_section->vma
4873
+ sec->output_offset);
4875
else if (h->root.type == bfd_link_hash_undefweak)
4877
else if (info->unresolved_syms_in_objects == RM_IGNORE
4878
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4880
else if (!info->relocatable
4881
&& !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
4884
err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4885
|| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
4886
if (!info->callbacks->undefined_symbol (info,
4887
h->root.root.string,
4890
rel->r_offset, err))
4893
sym_name = h->root.root.string;
4896
if (sec != NULL && discarded_section (sec))
4897
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4898
rel, 1, relend, howto, 0, contents);
4900
if (info->relocatable)
4903
/* Change "a rt,ra,rb" to "ai rt,ra,0". */
4904
if (r_type == R_SPU_ADD_PIC
4906
&& !(h->def_regular || ELF_COMMON_DEF_P (h)))
4908
bfd_byte *loc = contents + rel->r_offset;
4914
is_ea_sym = (ea != NULL
4916
&& sec->output_section == ea);
4918
/* If this symbol is in an overlay area, we may need to relocate
4919
to the overlay stub. */
4920
addend = rel->r_addend;
4923
&& (stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
4924
contents, info)) != no_stub)
4926
unsigned int ovl = 0;
4927
struct got_entry *g, **head;
4929
if (stub_type != nonovl_stub)
4933
head = &h->got.glist;
4935
head = elf_local_got_ents (input_bfd) + r_symndx;
4937
for (g = *head; g != NULL; g = g->next)
4938
if (htab->params->ovly_flavour == ovly_soft_icache
4940
&& g->br_addr == (rel->r_offset
4941
+ input_section->output_offset
4942
+ input_section->output_section->vma))
4943
: g->addend == addend && (g->ovl == ovl || g->ovl == 0))
4948
relocation = g->stub_addr;
4953
/* For soft icache, encode the overlay index into addresses. */
4954
if (htab->params->ovly_flavour == ovly_soft_icache
4955
&& (r_type == R_SPU_ADDR16_HI
4956
|| r_type == R_SPU_ADDR32 || r_type == R_SPU_REL32)
4959
unsigned int ovl = overlay_index (sec);
4962
unsigned int set_id = ((ovl - 1) >> htab->num_lines_log2) + 1;
4963
relocation += set_id << 18;
4968
if (htab->params->emit_fixups && !info->relocatable
4969
&& (input_section->flags & SEC_ALLOC) != 0
4970
&& r_type == R_SPU_ADDR32)
4973
offset = rel->r_offset + input_section->output_section->vma
4974
+ input_section->output_offset;
4975
spu_elf_emit_fixup (output_bfd, info, offset);
4978
if (unresolved_reloc)
4980
else if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4984
/* ._ea is a special section that isn't allocated in SPU
4985
memory, but rather occupies space in PPU memory as
4986
part of an embedded ELF image. If this reloc is
4987
against a symbol defined in ._ea, then transform the
4988
reloc into an equivalent one without a symbol
4989
relative to the start of the ELF image. */
4990
rel->r_addend += (relocation
4992
+ elf_section_data (ea)->this_hdr.sh_offset);
4993
rel->r_info = ELF32_R_INFO (0, r_type);
4995
emit_these_relocs = TRUE;
4999
unresolved_reloc = TRUE;
5001
if (unresolved_reloc
5002
&& _bfd_elf_section_offset (output_bfd, info, input_section,
5003
rel->r_offset) != (bfd_vma) -1)
5005
(*_bfd_error_handler)
5006
(_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
5008
bfd_get_section_name (input_bfd, input_section),
5009
(long) rel->r_offset,
5015
r = _bfd_final_link_relocate (howto,
5019
rel->r_offset, relocation, addend);
5021
if (r != bfd_reloc_ok)
5023
const char *msg = (const char *) 0;
5027
case bfd_reloc_overflow:
5028
if (!((*info->callbacks->reloc_overflow)
5029
(info, (h ? &h->root : NULL), sym_name, howto->name,
5030
(bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
5034
case bfd_reloc_undefined:
5035
if (!((*info->callbacks->undefined_symbol)
5036
(info, sym_name, input_bfd, input_section,
5037
rel->r_offset, TRUE)))
5041
case bfd_reloc_outofrange:
5042
msg = _("internal error: out of range error");
5045
case bfd_reloc_notsupported:
5046
msg = _("internal error: unsupported relocation error");
5049
case bfd_reloc_dangerous:
5050
msg = _("internal error: dangerous error");
5054
msg = _("internal error: unknown error");
5059
if (!((*info->callbacks->warning)
5060
(info, msg, sym_name, input_bfd, input_section,
5069
&& emit_these_relocs
5070
&& !info->emitrelocations)
5072
Elf_Internal_Rela *wrel;
5073
Elf_Internal_Shdr *rel_hdr;
5075
wrel = rel = relocs;
5076
relend = relocs + input_section->reloc_count;
5077
for (; rel < relend; rel++)
5081
r_type = ELF32_R_TYPE (rel->r_info);
5082
if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
5085
input_section->reloc_count = wrel - relocs;
5086
/* Backflips for _bfd_elf_link_output_relocs. */
5087
rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5088
rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
5096
spu_elf_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5097
struct bfd_link_info *info ATTRIBUTE_UNUSED)
5102
/* Adjust _SPUEAR_ syms to point at their overlay stubs. */
5105
spu_elf_output_symbol_hook (struct bfd_link_info *info,
5106
const char *sym_name ATTRIBUTE_UNUSED,
5107
Elf_Internal_Sym *sym,
5108
asection *sym_sec ATTRIBUTE_UNUSED,
5109
struct elf_link_hash_entry *h)
5111
struct spu_link_hash_table *htab = spu_hash_table (info);
5113
if (!info->relocatable
5114
&& htab->stub_sec != NULL
5116
&& (h->root.type == bfd_link_hash_defined
5117
|| h->root.type == bfd_link_hash_defweak)
5119
&& strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
5121
struct got_entry *g;
5123
for (g = h->got.glist; g != NULL; g = g->next)
5124
if (htab->params->ovly_flavour == ovly_soft_icache
5125
? g->br_addr == g->stub_addr
5126
: g->addend == 0 && g->ovl == 0)
5128
sym->st_shndx = (_bfd_elf_section_from_bfd_section
5129
(htab->stub_sec[0]->output_section->owner,
5130
htab->stub_sec[0]->output_section));
5131
sym->st_value = g->stub_addr;
5139
static int spu_plugin = 0;
5142
spu_elf_plugin (int val)
5147
/* Set ELF header e_type for plugins. */
5150
spu_elf_post_process_headers (bfd *abfd,
5151
struct bfd_link_info *info ATTRIBUTE_UNUSED)
5155
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5157
i_ehdrp->e_type = ET_DYN;
5161
/* We may add an extra PT_LOAD segment for .toe. We also need extra
5162
segments for overlays. */
5165
spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
5172
struct spu_link_hash_table *htab = spu_hash_table (info);
5173
extra = htab->num_overlays;
5179
sec = bfd_get_section_by_name (abfd, ".toe");
5180
if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
5186
/* Remove .toe section from other PT_LOAD segments and put it in
5187
a segment of its own. Put overlays in separate segments too. */
5190
spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
5193
struct elf_segment_map *m, *m_overlay;
5194
struct elf_segment_map **p, **p_overlay;
5200
toe = bfd_get_section_by_name (abfd, ".toe");
5201
for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5202
if (m->p_type == PT_LOAD && m->count > 1)
5203
for (i = 0; i < m->count; i++)
5204
if ((s = m->sections[i]) == toe
5205
|| spu_elf_section_data (s)->u.o.ovl_index != 0)
5207
struct elf_segment_map *m2;
5210
if (i + 1 < m->count)
5212
amt = sizeof (struct elf_segment_map);
5213
amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
5214
m2 = bfd_zalloc (abfd, amt);
5217
m2->count = m->count - (i + 1);
5218
memcpy (m2->sections, m->sections + i + 1,
5219
m2->count * sizeof (m->sections[0]));
5220
m2->p_type = PT_LOAD;
5228
amt = sizeof (struct elf_segment_map);
5229
m2 = bfd_zalloc (abfd, amt);
5232
m2->p_type = PT_LOAD;
5234
m2->sections[0] = s;
5242
/* Some SPU ELF loaders ignore the PF_OVERLAY flag and just load all
5243
PT_LOAD segments. This can cause the .ovl.init section to be
5244
overwritten with the contents of some overlay segment. To work
5245
around this issue, we ensure that all PF_OVERLAY segments are
5246
sorted first amongst the program headers; this ensures that even
5247
with a broken loader, the .ovl.init section (which is not marked
5248
as PF_OVERLAY) will be placed into SPU local store on startup. */
5250
/* Move all overlay segments onto a separate list. */
5251
p = &elf_seg_map (abfd);
5252
p_overlay = &m_overlay;
5255
if ((*p)->p_type == PT_LOAD && (*p)->count == 1
5256
&& spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
5261
p_overlay = &m->next;
5268
/* Re-insert overlay segments at the head of the segment map. */
5269
*p_overlay = elf_seg_map (abfd);
5270
elf_seg_map (abfd) = m_overlay;
5275
/* Tweak the section type of .note.spu_name. */
5278
spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
5279
Elf_Internal_Shdr *hdr,
5282
if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
5283
hdr->sh_type = SHT_NOTE;
5287
/* Tweak phdrs before writing them out. */
5290
spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
5292
const struct elf_backend_data *bed;
5293
struct elf_obj_tdata *tdata;
5294
Elf_Internal_Phdr *phdr, *last;
5295
struct spu_link_hash_table *htab;
5302
bed = get_elf_backend_data (abfd);
5303
tdata = elf_tdata (abfd);
5305
count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
5306
htab = spu_hash_table (info);
5307
if (htab->num_overlays != 0)
5309
struct elf_segment_map *m;
5312
for (i = 0, m = elf_seg_map (abfd); m; ++i, m = m->next)
5314
&& (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
5316
/* Mark this as an overlay header. */
5317
phdr[i].p_flags |= PF_OVERLAY;
5319
if (htab->ovtab != NULL && htab->ovtab->size != 0
5320
&& htab->params->ovly_flavour != ovly_soft_icache)
5322
bfd_byte *p = htab->ovtab->contents;
5323
unsigned int off = o * 16 + 8;
5325
/* Write file_off into _ovly_table. */
5326
bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
5329
/* Soft-icache has its file offset put in .ovl.init. */
5330
if (htab->init != NULL && htab->init->size != 0)
5332
bfd_vma val = elf_section_data (htab->ovl_sec[0])->this_hdr.sh_offset;
5334
bfd_put_32 (htab->init->owner, val, htab->init->contents + 4);
5338
/* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5339
of 16. This should always be possible when using the standard
5340
linker scripts, but don't create overlapping segments if
5341
someone is playing games with linker scripts. */
5343
for (i = count; i-- != 0; )
5344
if (phdr[i].p_type == PT_LOAD)
5348
adjust = -phdr[i].p_filesz & 15;
5351
&& phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
5354
adjust = -phdr[i].p_memsz & 15;
5357
&& phdr[i].p_filesz != 0
5358
&& phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
5359
&& phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
5362
if (phdr[i].p_filesz != 0)
5366
if (i == (unsigned int) -1)
5367
for (i = count; i-- != 0; )
5368
if (phdr[i].p_type == PT_LOAD)
5372
adjust = -phdr[i].p_filesz & 15;
5373
phdr[i].p_filesz += adjust;
5375
adjust = -phdr[i].p_memsz & 15;
5376
phdr[i].p_memsz += adjust;
5383
spu_elf_size_sections (bfd * output_bfd, struct bfd_link_info *info)
5385
struct spu_link_hash_table *htab = spu_hash_table (info);
5386
if (htab->params->emit_fixups)
5388
asection *sfixup = htab->sfixup;
5389
int fixup_count = 0;
5393
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5397
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5400
/* Walk over each section attached to the input bfd. */
5401
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
5403
Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
5406
/* If there aren't any relocs, then there's nothing more
5408
if ((isec->flags & SEC_ALLOC) == 0
5409
|| (isec->flags & SEC_RELOC) == 0
5410
|| isec->reloc_count == 0)
5413
/* Get the relocs. */
5415
_bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
5417
if (internal_relocs == NULL)
5420
/* 1 quadword can contain up to 4 R_SPU_ADDR32
5421
relocations. They are stored in a single word by
5422
saving the upper 28 bits of the address and setting the
5423
lower 4 bits to a bit mask of the words that have the
5424
relocation. BASE_END keeps track of the next quadword. */
5425
irela = internal_relocs;
5426
irelaend = irela + isec->reloc_count;
5428
for (; irela < irelaend; irela++)
5429
if (ELF32_R_TYPE (irela->r_info) == R_SPU_ADDR32
5430
&& irela->r_offset >= base_end)
5432
base_end = (irela->r_offset & ~(bfd_vma) 15) + 16;
5438
/* We always have a NULL fixup as a sentinel */
5439
size = (fixup_count + 1) * FIXUP_RECORD_SIZE;
5440
if (!bfd_set_section_size (output_bfd, sfixup, size))
5442
sfixup->contents = (bfd_byte *) bfd_zalloc (info->input_bfds, size);
5443
if (sfixup->contents == NULL)
5449
#define TARGET_BIG_SYM bfd_elf32_spu_vec
5450
#define TARGET_BIG_NAME "elf32-spu"
5451
#define ELF_ARCH bfd_arch_spu
5452
#define ELF_TARGET_ID SPU_ELF_DATA
5453
#define ELF_MACHINE_CODE EM_SPU
5454
/* This matches the alignment need for DMA. */
5455
#define ELF_MAXPAGESIZE 0x80
5456
#define elf_backend_rela_normal 1
5457
#define elf_backend_can_gc_sections 1
5459
#define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
5460
#define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
5461
#define elf_info_to_howto spu_elf_info_to_howto
5462
#define elf_backend_count_relocs spu_elf_count_relocs
5463
#define elf_backend_relocate_section spu_elf_relocate_section
5464
#define elf_backend_finish_dynamic_sections spu_elf_finish_dynamic_sections
5465
#define elf_backend_symbol_processing spu_elf_backend_symbol_processing
5466
#define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
5467
#define elf_backend_object_p spu_elf_object_p
5468
#define bfd_elf32_new_section_hook spu_elf_new_section_hook
5469
#define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
5471
#define elf_backend_additional_program_headers spu_elf_additional_program_headers
5472
#define elf_backend_modify_segment_map spu_elf_modify_segment_map
5473
#define elf_backend_modify_program_headers spu_elf_modify_program_headers
5474
#define elf_backend_post_process_headers spu_elf_post_process_headers
5475
#define elf_backend_fake_sections spu_elf_fake_sections
5476
#define elf_backend_special_sections spu_elf_special_sections
5477
#define bfd_elf32_bfd_final_link spu_elf_final_link
5479
#include "elf32-target.h"
added
removed
binutils-2.23.52.20130611/bfd/elf32-spu.c
