1 /* SPU specific support for 32-bit ELF
3 Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22 #include "libiberty.h"
28 #include "elf32-spu.h"
30 /* We use RELA style relocs. Don't define USE_REL. */
32 static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
36 /* Values of type 'enum elf_spu_reloc_type' are used to index this
37 array, so it must be declared in the order of that type. */
39 static reloc_howto_type elf_howto_table[] = {
40 HOWTO (R_SPU_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
41 bfd_elf_generic_reloc, "SPU_NONE",
42 FALSE, 0, 0x00000000, FALSE),
43 HOWTO (R_SPU_ADDR10, 4, 2, 10, FALSE, 14, complain_overflow_bitfield,
44 bfd_elf_generic_reloc, "SPU_ADDR10",
45 FALSE, 0, 0x00ffc000, FALSE),
46 HOWTO (R_SPU_ADDR16, 2, 2, 16, FALSE, 7, complain_overflow_bitfield,
47 bfd_elf_generic_reloc, "SPU_ADDR16",
48 FALSE, 0, 0x007fff80, FALSE),
49 HOWTO (R_SPU_ADDR16_HI, 16, 2, 16, FALSE, 7, complain_overflow_bitfield,
50 bfd_elf_generic_reloc, "SPU_ADDR16_HI",
51 FALSE, 0, 0x007fff80, FALSE),
52 HOWTO (R_SPU_ADDR16_LO, 0, 2, 16, FALSE, 7, complain_overflow_dont,
53 bfd_elf_generic_reloc, "SPU_ADDR16_LO",
54 FALSE, 0, 0x007fff80, FALSE),
55 HOWTO (R_SPU_ADDR18, 0, 2, 18, FALSE, 7, complain_overflow_bitfield,
56 bfd_elf_generic_reloc, "SPU_ADDR18",
57 FALSE, 0, 0x01ffff80, FALSE),
58 HOWTO (R_SPU_ADDR32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
59 bfd_elf_generic_reloc, "SPU_ADDR32",
60 FALSE, 0, 0xffffffff, FALSE),
61 HOWTO (R_SPU_REL16, 2, 2, 16, TRUE, 7, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "SPU_REL16",
63 FALSE, 0, 0x007fff80, TRUE),
64 HOWTO (R_SPU_ADDR7, 0, 2, 7, FALSE, 14, complain_overflow_dont,
65 bfd_elf_generic_reloc, "SPU_ADDR7",
66 FALSE, 0, 0x001fc000, FALSE),
67 HOWTO (R_SPU_REL9, 2, 2, 9, TRUE, 0, complain_overflow_signed,
68 spu_elf_rel9, "SPU_REL9",
69 FALSE, 0, 0x0180007f, TRUE),
70 HOWTO (R_SPU_REL9I, 2, 2, 9, TRUE, 0, complain_overflow_signed,
71 spu_elf_rel9, "SPU_REL9I",
72 FALSE, 0, 0x0000c07f, TRUE),
73 HOWTO (R_SPU_ADDR10I, 0, 2, 10, FALSE, 14, complain_overflow_signed,
74 bfd_elf_generic_reloc, "SPU_ADDR10I",
75 FALSE, 0, 0x00ffc000, FALSE),
76 HOWTO (R_SPU_ADDR16I, 0, 2, 16, FALSE, 7, complain_overflow_signed,
77 bfd_elf_generic_reloc, "SPU_ADDR16I",
78 FALSE, 0, 0x007fff80, FALSE),
79 HOWTO (R_SPU_REL32, 0, 2, 32, TRUE, 0, complain_overflow_dont,
80 bfd_elf_generic_reloc, "SPU_REL32",
81 FALSE, 0, 0xffffffff, TRUE),
82 HOWTO (R_SPU_ADDR16X, 0, 2, 16, FALSE, 7, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "SPU_ADDR16X",
84 FALSE, 0, 0x007fff80, FALSE),
85 HOWTO (R_SPU_PPU32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
86 bfd_elf_generic_reloc, "SPU_PPU32",
87 FALSE, 0, 0xffffffff, FALSE),
88 HOWTO (R_SPU_PPU64, 0, 4, 64, FALSE, 0, complain_overflow_dont,
89 bfd_elf_generic_reloc, "SPU_PPU64",
93 static struct bfd_elf_special_section const spu_elf_special_sections[] = {
94 { "._ea", 4, 0, SHT_PROGBITS, SHF_WRITE },
95 { ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
99 static enum elf_spu_reloc_type
100 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
106 case BFD_RELOC_SPU_IMM10W:
108 case BFD_RELOC_SPU_IMM16W:
110 case BFD_RELOC_SPU_LO16:
111 return R_SPU_ADDR16_LO;
112 case BFD_RELOC_SPU_HI16:
113 return R_SPU_ADDR16_HI;
114 case BFD_RELOC_SPU_IMM18:
116 case BFD_RELOC_SPU_PCREL16:
118 case BFD_RELOC_SPU_IMM7:
120 case BFD_RELOC_SPU_IMM8:
122 case BFD_RELOC_SPU_PCREL9a:
124 case BFD_RELOC_SPU_PCREL9b:
126 case BFD_RELOC_SPU_IMM10:
127 return R_SPU_ADDR10I;
128 case BFD_RELOC_SPU_IMM16:
129 return R_SPU_ADDR16I;
132 case BFD_RELOC_32_PCREL:
134 case BFD_RELOC_SPU_PPU32:
136 case BFD_RELOC_SPU_PPU64:
142 spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
144 Elf_Internal_Rela *dst)
146 enum elf_spu_reloc_type r_type;
148 r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
149 BFD_ASSERT (r_type < R_SPU_max);
150 cache_ptr->howto = &elf_howto_table[(int) r_type];
153 static reloc_howto_type *
154 spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
155 bfd_reloc_code_real_type code)
157 enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
159 if (r_type == R_SPU_NONE)
162 return elf_howto_table + r_type;
165 static reloc_howto_type *
166 spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
171 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
172 if (elf_howto_table[i].name != NULL
173 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
174 return &elf_howto_table[i];
179 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
181 static bfd_reloc_status_type
182 spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
183 void *data, asection *input_section,
184 bfd *output_bfd, char **error_message)
186 bfd_size_type octets;
190 /* If this is a relocatable link (output_bfd test tells us), just
191 call the generic function. Any adjustment will be done at final
193 if (output_bfd != NULL)
194 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
195 input_section, output_bfd, error_message);
197 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
198 return bfd_reloc_outofrange;
199 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
201 /* Get symbol value. */
203 if (!bfd_is_com_section (symbol->section))
205 if (symbol->section->output_section)
206 val += symbol->section->output_section->vma;
208 val += reloc_entry->addend;
210 /* Make it pc-relative. */
211 val -= input_section->output_section->vma + input_section->output_offset;
214 if (val + 256 >= 512)
215 return bfd_reloc_overflow;
217 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
219 /* Move two high bits of value to REL9I and REL9 position.
220 The mask will take care of selecting the right field. */
221 val = (val & 0x7f) | ((val & 0x180) << 7) | ((val & 0x180) << 16);
222 insn &= ~reloc_entry->howto->dst_mask;
223 insn |= val & reloc_entry->howto->dst_mask;
224 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
229 spu_elf_new_section_hook (bfd *abfd, asection *sec)
231 if (!sec->used_by_bfd)
233 struct _spu_elf_section_data *sdata;
235 sdata = bfd_zalloc (abfd, sizeof (*sdata));
238 sec->used_by_bfd = sdata;
241 return _bfd_elf_new_section_hook (abfd, sec);
244 /* Set up overlay info for executables. */
247 spu_elf_object_p (bfd *abfd)
249 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
251 unsigned int i, num_ovl, num_buf;
252 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
253 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
254 Elf_Internal_Phdr *last_phdr = NULL;
256 for (num_buf = 0, num_ovl = 0, i = 0; i < ehdr->e_phnum; i++, phdr++)
257 if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_OVERLAY) != 0)
262 if (last_phdr == NULL
263 || ((last_phdr->p_vaddr ^ phdr->p_vaddr) & 0x3ffff) != 0)
266 for (j = 1; j < elf_numsections (abfd); j++)
268 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[j];
270 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (shdr, phdr))
272 asection *sec = shdr->bfd_section;
273 spu_elf_section_data (sec)->u.o.ovl_index = num_ovl;
274 spu_elf_section_data (sec)->u.o.ovl_buf = num_buf;
282 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
283 strip --strip-unneeded will not remove them. */
286 spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
288 if (sym->name != NULL
289 && sym->section != bfd_abs_section_ptr
290 && strncmp (sym->name, "_EAR_", 5) == 0)
291 sym->flags |= BSF_KEEP;
294 /* SPU ELF linker hash table. */
296 struct spu_link_hash_table
298 struct elf_link_hash_table elf;
300 struct spu_elf_params *params;
302 /* Shortcuts to overlay sections. */
308 /* Count of stubs in each overlay section. */
309 unsigned int *stub_count;
311 /* The stub section for each overlay section. */
314 struct elf_link_hash_entry *ovly_entry[2];
316 /* Number of overlay buffers. */
317 unsigned int num_buf;
319 /* Total number of overlays. */
320 unsigned int num_overlays;
322 /* For soft icache. */
323 unsigned int line_size_log2;
324 unsigned int num_lines_log2;
325 unsigned int fromelem_size_log2;
327 /* How much memory we have. */
328 unsigned int local_store;
329 /* Local store --auto-overlay should reserve for non-overlay
330 functions and data. */
331 unsigned int overlay_fixed;
332 /* Local store --auto-overlay should reserve for stack and heap. */
333 unsigned int reserved;
334 /* If reserved is not specified, stack analysis will calculate a value
335 for the stack. This parameter adjusts that value to allow for
336 negative sp access (the ABI says 2000 bytes below sp are valid,
337 and the overlay manager uses some of this area). */
338 int extra_stack_space;
339 /* Count of overlay stubs needed in non-overlay area. */
340 unsigned int non_ovly_stub;
343 unsigned int stub_err : 1;
346 /* Hijack the generic got fields for overlay stub accounting. */
350 struct got_entry *next;
359 #define spu_hash_table(p) \
360 ((struct spu_link_hash_table *) ((p)->hash))
364 struct function_info *fun;
365 struct call_info *next;
367 unsigned int max_depth;
368 unsigned int is_tail : 1;
369 unsigned int is_pasted : 1;
370 unsigned int broken_cycle : 1;
371 unsigned int priority : 13;
376 /* List of functions called. Also branches to hot/cold part of
378 struct call_info *call_list;
379 /* For hot/cold part of function, point to owner. */
380 struct function_info *start;
381 /* Symbol at start of function. */
383 Elf_Internal_Sym *sym;
384 struct elf_link_hash_entry *h;
386 /* Function section. */
389 /* Where last called from, and number of sections called from. */
390 asection *last_caller;
391 unsigned int call_count;
392 /* Address range of (this part of) function. */
394 /* Offset where we found a store of lr, or -1 if none found. */
396 /* Offset where we found the stack adjustment insn. */
400 /* Distance from root of call tree. Tail and hot/cold branches
401 count as one deeper. We aren't counting stack frames here. */
403 /* Set if global symbol. */
404 unsigned int global : 1;
405 /* Set if known to be start of function (as distinct from a hunk
406 in hot/cold section. */
407 unsigned int is_func : 1;
408 /* Set if not a root node. */
409 unsigned int non_root : 1;
410 /* Flags used during call tree traversal. It's cheaper to replicate
411 the visit flags than have one which needs clearing after a traversal. */
412 unsigned int visit1 : 1;
413 unsigned int visit2 : 1;
414 unsigned int marking : 1;
415 unsigned int visit3 : 1;
416 unsigned int visit4 : 1;
417 unsigned int visit5 : 1;
418 unsigned int visit6 : 1;
419 unsigned int visit7 : 1;
422 struct spu_elf_stack_info
426 /* Variable size array describing functions, one per contiguous
427 address range belonging to a function. */
428 struct function_info fun[1];
431 static struct function_info *find_function (asection *, bfd_vma,
432 struct bfd_link_info *);
434 /* Create a spu ELF linker hash table. */
436 static struct bfd_link_hash_table *
437 spu_elf_link_hash_table_create (bfd *abfd)
439 struct spu_link_hash_table *htab;
441 htab = bfd_malloc (sizeof (*htab));
445 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
446 _bfd_elf_link_hash_newfunc,
447 sizeof (struct elf_link_hash_entry)))
453 memset (&htab->ovtab, 0,
454 sizeof (*htab) - offsetof (struct spu_link_hash_table, ovtab));
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)
558 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
559 if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
564 /* Make SPU_PTNOTE_SPUNAME section. */
571 ibfd = info->input_bfds;
572 flags = SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
573 s = bfd_make_section_anyway_with_flags (ibfd, SPU_PTNOTE_SPUNAME, flags);
575 || !bfd_set_section_alignment (ibfd, s, 4))
578 name_len = strlen (bfd_get_filename (info->output_bfd)) + 1;
579 size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
580 size += (name_len + 3) & -4;
582 if (!bfd_set_section_size (ibfd, s, size))
585 data = bfd_zalloc (ibfd, size);
589 bfd_put_32 (ibfd, sizeof (SPU_PLUGIN_NAME), data + 0);
590 bfd_put_32 (ibfd, name_len, data + 4);
591 bfd_put_32 (ibfd, 1, data + 8);
592 memcpy (data + 12, SPU_PLUGIN_NAME, sizeof (SPU_PLUGIN_NAME));
593 memcpy (data + 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4),
594 bfd_get_filename (info->output_bfd), name_len);
601 /* qsort predicate to sort sections by vma. */
604 sort_sections (const void *a, const void *b)
606 const asection *const *s1 = a;
607 const asection *const *s2 = b;
608 bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
611 return delta < 0 ? -1 : 1;
613 return (*s1)->index - (*s2)->index;
616 /* Identify overlays in the output bfd, and number them.
617 Returns 0 on error, 1 if no overlays, 2 if overlays. */
620 spu_elf_find_overlays (struct bfd_link_info *info)
622 struct spu_link_hash_table *htab = spu_hash_table (info);
623 asection **alloc_sec;
624 unsigned int i, n, ovl_index, num_buf;
627 static const char *const entry_names[2][2] = {
628 { "__ovly_load", "__icache_br_handler" },
629 { "__ovly_return", "__icache_call_handler" }
632 if (info->output_bfd->section_count < 2)
636 = bfd_malloc (info->output_bfd->section_count * sizeof (*alloc_sec));
637 if (alloc_sec == NULL)
640 /* Pick out all the alloced sections. */
641 for (n = 0, s = info->output_bfd->sections; s != NULL; s = s->next)
642 if ((s->flags & SEC_ALLOC) != 0
643 && (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
653 /* Sort them by vma. */
654 qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
656 ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
657 if (htab->params->ovly_flavour == ovly_soft_icache)
659 /* Look for an overlapping vma to find the first overlay section. */
660 bfd_vma vma_start = 0;
661 bfd_vma lma_start = 0;
663 for (i = 1; i < n; i++)
666 if (s->vma < ovl_end)
668 asection *s0 = alloc_sec[i - 1];
670 if (strncmp (s0->name, ".ovl.init", 9) != 0)
676 << (htab->num_lines_log2 + htab->line_size_log2)));
681 ovl_end = s->vma + s->size;
684 /* Now find any sections within the cache area. */
685 for (ovl_index = 0, num_buf = 0; i < n; i++)
688 if (s->vma >= ovl_end)
691 /* A section in an overlay area called .ovl.init is not
692 an overlay, in the sense that it might be loaded in
693 by the overlay manager, but rather the initial
694 section contents for the overlay buffer. */
695 if (strncmp (s->name, ".ovl.init", 9) != 0)
697 num_buf = ((s->vma - vma_start) >> htab->line_size_log2) + 1;
698 if (((s->vma - vma_start) & (htab->params->line_size - 1))
699 || ((s->lma - lma_start) & (htab->params->line_size - 1)))
701 info->callbacks->einfo (_("%X%P: overlay section %A "
702 "does not start on a cache line.\n"),
704 bfd_set_error (bfd_error_bad_value);
707 else if (s->size > htab->params->line_size)
709 info->callbacks->einfo (_("%X%P: overlay section %A "
710 "is larger than a cache line.\n"),
712 bfd_set_error (bfd_error_bad_value);
716 alloc_sec[ovl_index++] = s;
717 spu_elf_section_data (s)->u.o.ovl_index
718 = ((s->lma - lma_start) >> htab->line_size_log2) + 1;
719 spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
723 /* Ensure there are no more overlay sections. */
727 if (s->vma < ovl_end)
729 info->callbacks->einfo (_("%X%P: overlay section %A "
730 "is not in cache area.\n"),
732 bfd_set_error (bfd_error_bad_value);
736 ovl_end = s->vma + s->size;
741 /* Look for overlapping vmas. Any with overlap must be overlays.
742 Count them. Also count the number of overlay regions. */
743 for (ovl_index = 0, num_buf = 0, i = 1; i < n; i++)
746 if (s->vma < ovl_end)
748 asection *s0 = alloc_sec[i - 1];
750 if (spu_elf_section_data (s0)->u.o.ovl_index == 0)
753 if (strncmp (s0->name, ".ovl.init", 9) != 0)
755 alloc_sec[ovl_index] = s0;
756 spu_elf_section_data (s0)->u.o.ovl_index = ++ovl_index;
757 spu_elf_section_data (s0)->u.o.ovl_buf = num_buf;
760 ovl_end = s->vma + s->size;
762 if (strncmp (s->name, ".ovl.init", 9) != 0)
764 alloc_sec[ovl_index] = s;
765 spu_elf_section_data (s)->u.o.ovl_index = ++ovl_index;
766 spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
767 if (s0->vma != s->vma)
769 info->callbacks->einfo (_("%X%P: overlay sections %A "
770 "and %A do not start at the "
773 bfd_set_error (bfd_error_bad_value);
776 if (ovl_end < s->vma + s->size)
777 ovl_end = s->vma + s->size;
781 ovl_end = s->vma + s->size;
785 htab->num_overlays = ovl_index;
786 htab->num_buf = num_buf;
787 htab->ovl_sec = alloc_sec;
792 for (i = 0; i < 2; i++)
795 struct elf_link_hash_entry *h;
797 name = entry_names[i][htab->params->ovly_flavour];
798 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
802 if (h->root.type == bfd_link_hash_new)
804 h->root.type = bfd_link_hash_undefined;
806 h->ref_regular_nonweak = 1;
809 htab->ovly_entry[i] = h;
815 /* Non-zero to use bra in overlay stubs rather than br. */
818 #define BRA 0x30000000
819 #define BRASL 0x31000000
820 #define BR 0x32000000
821 #define BRSL 0x33000000
822 #define NOP 0x40200000
823 #define LNOP 0x00200000
824 #define ILA 0x42000000
826 /* Return true for all relative and absolute branch instructions.
834 brhnz 00100011 0.. */
837 is_branch (const unsigned char *insn)
839 return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
842 /* Return true for all indirect branch instructions.
850 bihnz 00100101 011 */
853 is_indirect_branch (const unsigned char *insn)
855 return (insn[0] & 0xef) == 0x25 && (insn[1] & 0x80) == 0;
858 /* Return true for branch hint instructions.
863 is_hint (const unsigned char *insn)
865 return (insn[0] & 0xfc) == 0x10;
868 /* True if INPUT_SECTION might need overlay stubs. */
871 maybe_needs_stubs (asection *input_section)
873 /* No stubs for debug sections and suchlike. */
874 if ((input_section->flags & SEC_ALLOC) == 0)
877 /* No stubs for link-once sections that will be discarded. */
878 if (input_section->output_section == bfd_abs_section_ptr)
881 /* Don't create stubs for .eh_frame references. */
882 if (strcmp (input_section->name, ".eh_frame") == 0)
904 /* Return non-zero if this reloc symbol should go via an overlay stub.
905 Return 2 if the stub must be in non-overlay area. */
907 static enum _stub_type
908 needs_ovl_stub (struct elf_link_hash_entry *h,
909 Elf_Internal_Sym *sym,
911 asection *input_section,
912 Elf_Internal_Rela *irela,
914 struct bfd_link_info *info)
916 struct spu_link_hash_table *htab = spu_hash_table (info);
917 enum elf_spu_reloc_type r_type;
918 unsigned int sym_type;
919 bfd_boolean branch, hint, call;
920 enum _stub_type ret = no_stub;
924 || sym_sec->output_section == bfd_abs_section_ptr
925 || spu_elf_section_data (sym_sec->output_section) == NULL)
930 /* Ensure no stubs for user supplied overlay manager syms. */
931 if (h == htab->ovly_entry[0] || h == htab->ovly_entry[1])
934 /* setjmp always goes via an overlay stub, because then the return
935 and hence the longjmp goes via __ovly_return. That magically
936 makes setjmp/longjmp between overlays work. */
937 if (strncmp (h->root.root.string, "setjmp", 6) == 0
938 && (h->root.root.string[6] == '\0' || h->root.root.string[6] == '@'))
945 sym_type = ELF_ST_TYPE (sym->st_info);
947 r_type = ELF32_R_TYPE (irela->r_info);
951 if (r_type == R_SPU_REL16 || r_type == R_SPU_ADDR16)
953 if (contents == NULL)
956 if (!bfd_get_section_contents (input_section->owner,
963 contents += irela->r_offset;
965 branch = is_branch (contents);
966 hint = is_hint (contents);
969 call = (contents[0] & 0xfd) == 0x31;
971 && sym_type != STT_FUNC
974 /* It's common for people to write assembly and forget
975 to give function symbols the right type. Handle
976 calls to such symbols, but warn so that (hopefully)
977 people will fix their code. We need the symbol
978 type to be correct to distinguish function pointer
979 initialisation from other pointer initialisations. */
980 const char *sym_name;
983 sym_name = h->root.root.string;
986 Elf_Internal_Shdr *symtab_hdr;
987 symtab_hdr = &elf_tdata (input_section->owner)->symtab_hdr;
988 sym_name = bfd_elf_sym_name (input_section->owner,
993 (*_bfd_error_handler) (_("warning: call to non-function"
994 " symbol %s defined in %B"),
995 sym_sec->owner, sym_name);
1001 if ((!branch && htab->params->ovly_flavour == ovly_soft_icache)
1002 || (sym_type != STT_FUNC
1003 && !(branch || hint)
1004 && (sym_sec->flags & SEC_CODE) == 0))
1007 /* Usually, symbols in non-overlay sections don't need stubs. */
1008 if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index == 0
1009 && !htab->params->non_overlay_stubs)
1012 /* A reference from some other section to a symbol in an overlay
1013 section needs a stub. */
1014 if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index
1015 != spu_elf_section_data (input_section->output_section)->u.o.ovl_index)
1017 unsigned int lrlive = 0;
1019 lrlive = (contents[1] & 0x70) >> 4;
1021 if (!lrlive && (call || sym_type == STT_FUNC))
1022 ret = call_ovl_stub;
1024 ret = br000_ovl_stub + lrlive;
1027 /* If this insn isn't a branch then we are possibly taking the
1028 address of a function and passing it out somehow. Soft-icache code
1029 always generates inline code to do indirect branches. */
1030 if (!(branch || hint)
1031 && sym_type == STT_FUNC
1032 && htab->params->ovly_flavour != ovly_soft_icache)
1039 count_stub (struct spu_link_hash_table *htab,
1042 enum _stub_type stub_type,
1043 struct elf_link_hash_entry *h,
1044 const Elf_Internal_Rela *irela)
1046 unsigned int ovl = 0;
1047 struct got_entry *g, **head;
1050 /* If this instruction is a branch or call, we need a stub
1051 for it. One stub per function per overlay.
1052 If it isn't a branch, then we are taking the address of
1053 this function so need a stub in the non-overlay area
1054 for it. One stub per function. */
1055 if (stub_type != nonovl_stub)
1056 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1059 head = &h->got.glist;
1062 if (elf_local_got_ents (ibfd) == NULL)
1064 bfd_size_type amt = (elf_tdata (ibfd)->symtab_hdr.sh_info
1065 * sizeof (*elf_local_got_ents (ibfd)));
1066 elf_local_got_ents (ibfd) = bfd_zmalloc (amt);
1067 if (elf_local_got_ents (ibfd) == NULL)
1070 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1073 if (htab->params->ovly_flavour == ovly_soft_icache)
1075 htab->stub_count[ovl] += 1;
1081 addend = irela->r_addend;
1085 struct got_entry *gnext;
1087 for (g = *head; g != NULL; g = g->next)
1088 if (g->addend == addend && g->ovl == 0)
1093 /* Need a new non-overlay area stub. Zap other stubs. */
1094 for (g = *head; g != NULL; g = gnext)
1097 if (g->addend == addend)
1099 htab->stub_count[g->ovl] -= 1;
1107 for (g = *head; g != NULL; g = g->next)
1108 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1114 g = bfd_malloc (sizeof *g);
1119 g->stub_addr = (bfd_vma) -1;
1123 htab->stub_count[ovl] += 1;
1129 /* Support two sizes of overlay stubs, a slower more compact stub of two
1130 intructions, and a faster stub of four instructions.
1131 Soft-icache stubs are four or eight words. */
1134 ovl_stub_size (struct spu_elf_params *params)
1136 return 16 << params->ovly_flavour >> params->compact_stub;
1140 ovl_stub_size_log2 (struct spu_elf_params *params)
1142 return 4 + params->ovly_flavour - params->compact_stub;
1145 /* Two instruction overlay stubs look like:
1147 brsl $75,__ovly_load
1148 .word target_ovl_and_address
1150 ovl_and_address is a word with the overlay number in the top 14 bits
1151 and local store address in the bottom 18 bits.
1153 Four instruction overlay stubs look like:
1157 ila $79,target_address
1160 Software icache stubs are:
1164 .word lrlive_branchlocalstoreaddr;
1165 brasl $75,__icache_br_handler
1170 build_stub (struct bfd_link_info *info,
1173 enum _stub_type stub_type,
1174 struct elf_link_hash_entry *h,
1175 const Elf_Internal_Rela *irela,
1179 struct spu_link_hash_table *htab = spu_hash_table (info);
1180 unsigned int ovl, dest_ovl, set_id;
1181 struct got_entry *g, **head;
1183 bfd_vma addend, from, to, br_dest, patt;
1184 unsigned int lrlive;
1187 if (stub_type != nonovl_stub)
1188 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1191 head = &h->got.glist;
1193 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1197 addend = irela->r_addend;
1199 if (htab->params->ovly_flavour == ovly_soft_icache)
1201 g = bfd_malloc (sizeof *g);
1207 g->br_addr = (irela->r_offset
1208 + isec->output_offset
1209 + isec->output_section->vma);
1215 for (g = *head; g != NULL; g = g->next)
1216 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1221 if (g->ovl == 0 && ovl != 0)
1224 if (g->stub_addr != (bfd_vma) -1)
1228 sec = htab->stub_sec[ovl];
1229 dest += dest_sec->output_offset + dest_sec->output_section->vma;
1230 from = sec->size + sec->output_offset + sec->output_section->vma;
1231 g->stub_addr = from;
1232 to = (htab->ovly_entry[0]->root.u.def.value
1233 + htab->ovly_entry[0]->root.u.def.section->output_offset
1234 + htab->ovly_entry[0]->root.u.def.section->output_section->vma);
1236 if (((dest | to | from) & 3) != 0)
1241 dest_ovl = spu_elf_section_data (dest_sec->output_section)->u.o.ovl_index;
1243 if (htab->params->ovly_flavour == ovly_normal
1244 && !htab->params->compact_stub)
1246 bfd_put_32 (sec->owner, ILA + ((dest_ovl << 7) & 0x01ffff80) + 78,
1247 sec->contents + sec->size);
1248 bfd_put_32 (sec->owner, LNOP,
1249 sec->contents + sec->size + 4);
1250 bfd_put_32 (sec->owner, ILA + ((dest << 7) & 0x01ffff80) + 79,
1251 sec->contents + sec->size + 8);
1253 bfd_put_32 (sec->owner, BR + (((to - (from + 12)) << 5) & 0x007fff80),
1254 sec->contents + sec->size + 12);
1256 bfd_put_32 (sec->owner, BRA + ((to << 5) & 0x007fff80),
1257 sec->contents + sec->size + 12);
1259 else if (htab->params->ovly_flavour == ovly_normal
1260 && htab->params->compact_stub)
1263 bfd_put_32 (sec->owner, BRSL + (((to - from) << 5) & 0x007fff80) + 75,
1264 sec->contents + sec->size);
1266 bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1267 sec->contents + sec->size);
1268 bfd_put_32 (sec->owner, (dest & 0x3ffff) | (dest_ovl << 18),
1269 sec->contents + sec->size + 4);
1271 else if (htab->params->ovly_flavour == ovly_soft_icache
1272 && htab->params->compact_stub)
1275 if (stub_type == nonovl_stub)
1277 else if (stub_type == call_ovl_stub)
1278 /* A brsl makes lr live and *(*sp+16) is live.
1279 Tail calls have the same liveness. */
1281 else if (!htab->params->lrlive_analysis)
1282 /* Assume stack frame and lr save. */
1284 else if (irela != NULL)
1286 /* Analyse branch instructions. */
1287 struct function_info *caller;
1290 caller = find_function (isec, irela->r_offset, info);
1291 if (caller->start == NULL)
1292 off = irela->r_offset;
1295 struct function_info *found = NULL;
1297 /* Find the earliest piece of this function that
1298 has frame adjusting instructions. We might
1299 see dynamic frame adjustment (eg. for alloca)
1300 in some later piece, but functions using
1301 alloca always set up a frame earlier. Frame
1302 setup instructions are always in one piece. */
1303 if (caller->lr_store != (bfd_vma) -1
1304 || caller->sp_adjust != (bfd_vma) -1)
1306 while (caller->start != NULL)
1308 caller = caller->start;
1309 if (caller->lr_store != (bfd_vma) -1
1310 || caller->sp_adjust != (bfd_vma) -1)
1318 if (off > caller->sp_adjust)
1320 if (off > caller->lr_store)
1321 /* Only *(*sp+16) is live. */
1324 /* If no lr save, then we must be in a
1325 leaf function with a frame.
1326 lr is still live. */
1329 else if (off > caller->lr_store)
1331 /* Between lr save and stack adjust. */
1333 /* This should never happen since prologues won't
1338 /* On entry to function. */
1341 if (stub_type != br000_ovl_stub
1342 && lrlive != stub_type - br000_ovl_stub)
1343 info->callbacks->einfo (_("%A:0x%v lrlive .brinfo (%u) differs "
1344 "from analysis (%u)\n"),
1345 isec, irela->r_offset, lrlive,
1346 stub_type - br000_ovl_stub);
1349 /* If given lrlive info via .brinfo, use it. */
1350 if (stub_type > br000_ovl_stub)
1351 lrlive = stub_type - br000_ovl_stub;
1354 to = (htab->ovly_entry[1]->root.u.def.value
1355 + htab->ovly_entry[1]->root.u.def.section->output_offset
1356 + htab->ovly_entry[1]->root.u.def.section->output_section->vma);
1358 /* The branch that uses this stub goes to stub_addr + 4. We'll
1359 set up an xor pattern that can be used by the icache manager
1360 to modify this branch to go directly to its destination. */
1362 br_dest = g->stub_addr;
1365 /* Except in the case of _SPUEAR_ stubs, the branch in
1366 question is the one in the stub itself. */
1367 BFD_ASSERT (stub_type == nonovl_stub);
1368 g->br_addr = g->stub_addr;
1372 set_id = ((dest_ovl - 1) >> htab->num_lines_log2) + 1;
1373 bfd_put_32 (sec->owner, (set_id << 18) | (dest & 0x3ffff),
1374 sec->contents + sec->size);
1375 bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1376 sec->contents + sec->size + 4);
1377 bfd_put_32 (sec->owner, (lrlive << 29) | (g->br_addr & 0x3ffff),
1378 sec->contents + sec->size + 8);
1379 patt = dest ^ br_dest;
1380 if (irela != NULL && ELF32_R_TYPE (irela->r_info) == R_SPU_REL16)
1381 patt = (dest - g->br_addr) ^ (br_dest - g->br_addr);
1382 bfd_put_32 (sec->owner, (patt << 5) & 0x007fff80,
1383 sec->contents + sec->size + 12);
1386 /* Extra space for linked list entries. */
1392 sec->size += ovl_stub_size (htab->params);
1394 if (htab->params->emit_stub_syms)
1400 len = 8 + sizeof (".ovl_call.") - 1;
1402 len += strlen (h->root.root.string);
1407 add = (int) irela->r_addend & 0xffffffff;
1410 name = bfd_malloc (len);
1414 sprintf (name, "%08x.ovl_call.", g->ovl);
1416 strcpy (name + 8 + sizeof (".ovl_call.") - 1, h->root.root.string);
1418 sprintf (name + 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1419 dest_sec->id & 0xffffffff,
1420 (int) ELF32_R_SYM (irela->r_info) & 0xffffffff);
1422 sprintf (name + len - 9, "+%x", add);
1424 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1428 if (h->root.type == bfd_link_hash_new)
1430 h->root.type = bfd_link_hash_defined;
1431 h->root.u.def.section = sec;
1432 h->size = ovl_stub_size (htab->params);
1433 h->root.u.def.value = sec->size - h->size;
1437 h->ref_regular_nonweak = 1;
1438 h->forced_local = 1;
1446 /* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1450 allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1452 /* Symbols starting with _SPUEAR_ need a stub because they may be
1453 invoked by the PPU. */
1454 struct bfd_link_info *info = inf;
1455 struct spu_link_hash_table *htab = spu_hash_table (info);
1458 if ((h->root.type == bfd_link_hash_defined
1459 || h->root.type == bfd_link_hash_defweak)
1461 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1462 && (sym_sec = h->root.u.def.section) != NULL
1463 && sym_sec->output_section != bfd_abs_section_ptr
1464 && spu_elf_section_data (sym_sec->output_section) != NULL
1465 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1466 || htab->params->non_overlay_stubs))
1468 return count_stub (htab, NULL, NULL, nonovl_stub, h, NULL);
1475 build_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1477 /* Symbols starting with _SPUEAR_ need a stub because they may be
1478 invoked by the PPU. */
1479 struct bfd_link_info *info = inf;
1480 struct spu_link_hash_table *htab = spu_hash_table (info);
1483 if ((h->root.type == bfd_link_hash_defined
1484 || h->root.type == bfd_link_hash_defweak)
1486 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1487 && (sym_sec = h->root.u.def.section) != NULL
1488 && sym_sec->output_section != bfd_abs_section_ptr
1489 && spu_elf_section_data (sym_sec->output_section) != NULL
1490 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1491 || htab->params->non_overlay_stubs))
1493 return build_stub (info, NULL, NULL, nonovl_stub, h, NULL,
1494 h->root.u.def.value, sym_sec);
1500 /* Size or build stubs. */
1503 process_stubs (struct bfd_link_info *info, bfd_boolean build)
1505 struct spu_link_hash_table *htab = spu_hash_table (info);
1508 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1510 extern const bfd_target bfd_elf32_spu_vec;
1511 Elf_Internal_Shdr *symtab_hdr;
1513 Elf_Internal_Sym *local_syms = NULL;
1515 if (ibfd->xvec != &bfd_elf32_spu_vec)
1518 /* We'll need the symbol table in a second. */
1519 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1520 if (symtab_hdr->sh_info == 0)
1523 /* Walk over each section attached to the input bfd. */
1524 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
1526 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1528 /* If there aren't any relocs, then there's nothing more to do. */
1529 if ((isec->flags & SEC_RELOC) == 0
1530 || isec->reloc_count == 0)
1533 if (!maybe_needs_stubs (isec))
1536 /* Get the relocs. */
1537 internal_relocs = _bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
1539 if (internal_relocs == NULL)
1540 goto error_ret_free_local;
1542 /* Now examine each relocation. */
1543 irela = internal_relocs;
1544 irelaend = irela + isec->reloc_count;
1545 for (; irela < irelaend; irela++)
1547 enum elf_spu_reloc_type r_type;
1548 unsigned int r_indx;
1550 Elf_Internal_Sym *sym;
1551 struct elf_link_hash_entry *h;
1552 enum _stub_type stub_type;
1554 r_type = ELF32_R_TYPE (irela->r_info);
1555 r_indx = ELF32_R_SYM (irela->r_info);
1557 if (r_type >= R_SPU_max)
1559 bfd_set_error (bfd_error_bad_value);
1560 error_ret_free_internal:
1561 if (elf_section_data (isec)->relocs != internal_relocs)
1562 free (internal_relocs);
1563 error_ret_free_local:
1564 if (local_syms != NULL
1565 && (symtab_hdr->contents
1566 != (unsigned char *) local_syms))
1571 /* Determine the reloc target section. */
1572 if (!get_sym_h (&h, &sym, &sym_sec, &local_syms, r_indx, ibfd))
1573 goto error_ret_free_internal;
1575 stub_type = needs_ovl_stub (h, sym, sym_sec, isec, irela,
1577 if (stub_type == no_stub)
1579 else if (stub_type == stub_error)
1580 goto error_ret_free_internal;
1582 if (htab->stub_count == NULL)
1585 amt = (htab->num_overlays + 1) * sizeof (*htab->stub_count);
1586 htab->stub_count = bfd_zmalloc (amt);
1587 if (htab->stub_count == NULL)
1588 goto error_ret_free_internal;
1593 if (!count_stub (htab, ibfd, isec, stub_type, h, irela))
1594 goto error_ret_free_internal;
1601 dest = h->root.u.def.value;
1603 dest = sym->st_value;
1604 dest += irela->r_addend;
1605 if (!build_stub (info, ibfd, isec, stub_type, h, irela,
1607 goto error_ret_free_internal;
1611 /* We're done with the internal relocs, free them. */
1612 if (elf_section_data (isec)->relocs != internal_relocs)
1613 free (internal_relocs);
1616 if (local_syms != NULL
1617 && symtab_hdr->contents != (unsigned char *) local_syms)
1619 if (!info->keep_memory)
1622 symtab_hdr->contents = (unsigned char *) local_syms;
1629 /* Allocate space for overlay call and return stubs.
1630 Return 0 on error, 1 if no overlays, 2 otherwise. */
1633 spu_elf_size_stubs (struct bfd_link_info *info)
1635 struct spu_link_hash_table *htab;
1642 if (!process_stubs (info, FALSE))
1645 htab = spu_hash_table (info);
1646 elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, info);
1650 ibfd = info->input_bfds;
1651 if (htab->stub_count != NULL)
1653 amt = (htab->num_overlays + 1) * sizeof (*htab->stub_sec);
1654 htab->stub_sec = bfd_zmalloc (amt);
1655 if (htab->stub_sec == NULL)
1658 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
1659 | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1660 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1661 htab->stub_sec[0] = stub;
1663 || !bfd_set_section_alignment (ibfd, stub,
1664 ovl_stub_size_log2 (htab->params)))
1666 stub->size = htab->stub_count[0] * ovl_stub_size (htab->params);
1667 if (htab->params->ovly_flavour == ovly_soft_icache)
1668 /* Extra space for linked list entries. */
1669 stub->size += htab->stub_count[0] * 16;
1671 for (i = 0; i < htab->num_overlays; ++i)
1673 asection *osec = htab->ovl_sec[i];
1674 unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1675 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1676 htab->stub_sec[ovl] = stub;
1678 || !bfd_set_section_alignment (ibfd, stub,
1679 ovl_stub_size_log2 (htab->params)))
1681 stub->size = htab->stub_count[ovl] * ovl_stub_size (htab->params);
1685 if (htab->params->ovly_flavour == ovly_soft_icache)
1687 /* Space for icache manager tables.
1688 a) Tag array, one quadword per cache line.
1689 b) Rewrite "to" list, one quadword per cache line.
1690 c) Rewrite "from" list, one byte per outgoing branch (rounded up to
1691 a power-of-two number of full quadwords) per cache line. */
1694 htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1695 if (htab->ovtab == NULL
1696 || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1699 htab->ovtab->size = (16 + 16 + (16 << htab->fromelem_size_log2))
1700 << htab->num_lines_log2;
1702 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1703 htab->init = bfd_make_section_anyway_with_flags (ibfd, ".ovini", flags);
1704 if (htab->init == NULL
1705 || !bfd_set_section_alignment (ibfd, htab->init, 4))
1708 htab->init->size = 16;
1710 else if (htab->stub_count == NULL)
1714 /* htab->ovtab consists of two arrays.
1724 . } _ovly_buf_table[];
1727 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1728 htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1729 if (htab->ovtab == NULL
1730 || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1733 htab->ovtab->size = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
1736 htab->toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1737 if (htab->toe == NULL
1738 || !bfd_set_section_alignment (ibfd, htab->toe, 4))
1740 htab->toe->size = 16;
1745 /* Called from ld to place overlay manager data sections. This is done
1746 after the overlay manager itself is loaded, mainly so that the
1747 linker's htab->init section is placed after any other .ovl.init
1751 spu_elf_place_overlay_data (struct bfd_link_info *info)
1753 struct spu_link_hash_table *htab = spu_hash_table (info);
1756 if (htab->stub_sec != NULL)
1758 (*htab->params->place_spu_section) (htab->stub_sec[0], NULL, ".text");
1760 for (i = 0; i < htab->num_overlays; ++i)
1762 asection *osec = htab->ovl_sec[i];
1763 unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1764 (*htab->params->place_spu_section) (htab->stub_sec[ovl], osec, NULL);
1768 if (htab->params->ovly_flavour == ovly_soft_icache)
1769 (*htab->params->place_spu_section) (htab->init, NULL, ".ovl.init");
1771 if (htab->ovtab != NULL)
1773 const char *ovout = ".data";
1774 if (htab->params->ovly_flavour == ovly_soft_icache)
1776 (*htab->params->place_spu_section) (htab->ovtab, NULL, ovout);
1779 if (htab->toe != NULL)
1780 (*htab->params->place_spu_section) (htab->toe, NULL, ".toe");
1783 /* Functions to handle embedded spu_ovl.o object. */
1786 ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1792 ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1798 struct _ovl_stream *os;
1802 os = (struct _ovl_stream *) stream;
1803 max = (const char *) os->end - (const char *) os->start;
1805 if ((ufile_ptr) offset >= max)
1809 if (count > max - offset)
1810 count = max - offset;
1812 memcpy (buf, (const char *) os->start + offset, count);
1817 spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1819 *ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1826 return *ovl_bfd != NULL;
1830 overlay_index (asection *sec)
1833 || sec->output_section == bfd_abs_section_ptr)
1835 return spu_elf_section_data (sec->output_section)->u.o.ovl_index;
1838 /* Define an STT_OBJECT symbol. */
1840 static struct elf_link_hash_entry *
1841 define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1843 struct elf_link_hash_entry *h;
1845 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1849 if (h->root.type != bfd_link_hash_defined
1852 h->root.type = bfd_link_hash_defined;
1853 h->root.u.def.section = htab->ovtab;
1854 h->type = STT_OBJECT;
1857 h->ref_regular_nonweak = 1;
1860 else if (h->root.u.def.section->owner != NULL)
1862 (*_bfd_error_handler) (_("%B is not allowed to define %s"),
1863 h->root.u.def.section->owner,
1864 h->root.root.string);
1865 bfd_set_error (bfd_error_bad_value);
1870 (*_bfd_error_handler) (_("you are not allowed to define %s in a script"),
1871 h->root.root.string);
1872 bfd_set_error (bfd_error_bad_value);
1879 /* Fill in all stubs and the overlay tables. */
1882 spu_elf_build_stubs (struct bfd_link_info *info)
1884 struct spu_link_hash_table *htab = spu_hash_table (info);
1885 struct elf_link_hash_entry *h;
1891 if (htab->num_overlays != 0)
1893 for (i = 0; i < 2; i++)
1895 h = htab->ovly_entry[i];
1897 && (h->root.type == bfd_link_hash_defined
1898 || h->root.type == bfd_link_hash_defweak)
1901 s = h->root.u.def.section->output_section;
1902 if (spu_elf_section_data (s)->u.o.ovl_index)
1904 (*_bfd_error_handler) (_("%s in overlay section"),
1905 h->root.root.string);
1906 bfd_set_error (bfd_error_bad_value);
1913 if (htab->stub_sec != NULL)
1915 for (i = 0; i <= htab->num_overlays; i++)
1916 if (htab->stub_sec[i]->size != 0)
1918 htab->stub_sec[i]->contents = bfd_zalloc (htab->stub_sec[i]->owner,
1919 htab->stub_sec[i]->size);
1920 if (htab->stub_sec[i]->contents == NULL)
1922 htab->stub_sec[i]->rawsize = htab->stub_sec[i]->size;
1923 htab->stub_sec[i]->size = 0;
1926 /* Fill in all the stubs. */
1927 process_stubs (info, TRUE);
1928 if (!htab->stub_err)
1929 elf_link_hash_traverse (&htab->elf, build_spuear_stubs, info);
1933 (*_bfd_error_handler) (_("overlay stub relocation overflow"));
1934 bfd_set_error (bfd_error_bad_value);
1938 for (i = 0; i <= htab->num_overlays; i++)
1940 if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
1942 (*_bfd_error_handler) (_("stubs don't match calculated size"));
1943 bfd_set_error (bfd_error_bad_value);
1946 htab->stub_sec[i]->rawsize = 0;
1950 if (htab->ovtab == NULL || htab->ovtab->size == 0)
1953 htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1954 if (htab->ovtab->contents == NULL)
1957 p = htab->ovtab->contents;
1958 if (htab->params->ovly_flavour == ovly_soft_icache)
1962 h = define_ovtab_symbol (htab, "__icache_tag_array");
1965 h->root.u.def.value = 0;
1966 h->size = 16 << htab->num_lines_log2;
1969 h = define_ovtab_symbol (htab, "__icache_tag_array_size");
1972 h->root.u.def.value = 16 << htab->num_lines_log2;
1973 h->root.u.def.section = bfd_abs_section_ptr;
1975 h = define_ovtab_symbol (htab, "__icache_rewrite_to");
1978 h->root.u.def.value = off;
1979 h->size = 16 << htab->num_lines_log2;
1982 h = define_ovtab_symbol (htab, "__icache_rewrite_to_size");
1985 h->root.u.def.value = 16 << htab->num_lines_log2;
1986 h->root.u.def.section = bfd_abs_section_ptr;
1988 h = define_ovtab_symbol (htab, "__icache_rewrite_from");
1991 h->root.u.def.value = off;
1992 h->size = 16 << (htab->fromelem_size_log2 + htab->num_lines_log2);
1995 h = define_ovtab_symbol (htab, "__icache_rewrite_from_size");
1998 h->root.u.def.value = 16 << (htab->fromelem_size_log2
1999 + htab->num_lines_log2);
2000 h->root.u.def.section = bfd_abs_section_ptr;
2002 h = define_ovtab_symbol (htab, "__icache_log2_fromelemsize");
2005 h->root.u.def.value = htab->fromelem_size_log2;
2006 h->root.u.def.section = bfd_abs_section_ptr;
2008 h = define_ovtab_symbol (htab, "__icache_base");
2011 h->root.u.def.value = htab->ovl_sec[0]->vma;
2012 h->root.u.def.section = bfd_abs_section_ptr;
2013 h->size = htab->num_buf << htab->line_size_log2;
2015 h = define_ovtab_symbol (htab, "__icache_linesize");
2018 h->root.u.def.value = 1 << htab->line_size_log2;
2019 h->root.u.def.section = bfd_abs_section_ptr;
2021 h = define_ovtab_symbol (htab, "__icache_log2_linesize");
2024 h->root.u.def.value = htab->line_size_log2;
2025 h->root.u.def.section = bfd_abs_section_ptr;
2027 h = define_ovtab_symbol (htab, "__icache_neg_log2_linesize");
2030 h->root.u.def.value = -htab->line_size_log2;
2031 h->root.u.def.section = bfd_abs_section_ptr;
2033 h = define_ovtab_symbol (htab, "__icache_cachesize");
2036 h->root.u.def.value = 1 << (htab->num_lines_log2 + htab->line_size_log2);
2037 h->root.u.def.section = bfd_abs_section_ptr;
2039 h = define_ovtab_symbol (htab, "__icache_log2_cachesize");
2042 h->root.u.def.value = htab->num_lines_log2 + htab->line_size_log2;
2043 h->root.u.def.section = bfd_abs_section_ptr;
2045 h = define_ovtab_symbol (htab, "__icache_neg_log2_cachesize");
2048 h->root.u.def.value = -(htab->num_lines_log2 + htab->line_size_log2);
2049 h->root.u.def.section = bfd_abs_section_ptr;
2051 if (htab->init != NULL && htab->init->size != 0)
2053 htab->init->contents = bfd_zalloc (htab->init->owner,
2055 if (htab->init->contents == NULL)
2058 h = define_ovtab_symbol (htab, "__icache_fileoff");
2061 h->root.u.def.value = 0;
2062 h->root.u.def.section = htab->init;
2068 /* Write out _ovly_table. */
2069 /* set low bit of .size to mark non-overlay area as present. */
2071 obfd = htab->ovtab->output_section->owner;
2072 for (s = obfd->sections; s != NULL; s = s->next)
2074 unsigned int ovl_index = spu_elf_section_data (s)->u.o.ovl_index;
2078 unsigned long off = ovl_index * 16;
2079 unsigned int ovl_buf = spu_elf_section_data (s)->u.o.ovl_buf;
2081 bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
2082 bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16,
2084 /* file_off written later in spu_elf_modify_program_headers. */
2085 bfd_put_32 (htab->ovtab->owner, ovl_buf, p + off + 12);
2089 h = define_ovtab_symbol (htab, "_ovly_table");
2092 h->root.u.def.value = 16;
2093 h->size = htab->num_overlays * 16;
2095 h = define_ovtab_symbol (htab, "_ovly_table_end");
2098 h->root.u.def.value = htab->num_overlays * 16 + 16;
2101 h = define_ovtab_symbol (htab, "_ovly_buf_table");
2104 h->root.u.def.value = htab->num_overlays * 16 + 16;
2105 h->size = htab->num_buf * 4;
2107 h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
2110 h->root.u.def.value = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
2114 h = define_ovtab_symbol (htab, "_EAR_");
2117 h->root.u.def.section = htab->toe;
2118 h->root.u.def.value = 0;
2124 /* Check that all loadable section VMAs lie in the range
2125 LO .. HI inclusive, and stash some parameters for --auto-overlay. */
2128 spu_elf_check_vma (struct bfd_link_info *info)
2130 struct elf_segment_map *m;
2132 struct spu_link_hash_table *htab = spu_hash_table (info);
2133 bfd *abfd = info->output_bfd;
2134 bfd_vma hi = htab->params->local_store_hi;
2135 bfd_vma lo = htab->params->local_store_lo;
2137 htab->local_store = hi + 1 - lo;
2139 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2140 if (m->p_type == PT_LOAD)
2141 for (i = 0; i < m->count; i++)
2142 if (m->sections[i]->size != 0
2143 && (m->sections[i]->vma < lo
2144 || m->sections[i]->vma > hi
2145 || m->sections[i]->vma + m->sections[i]->size - 1 > hi))
2146 return m->sections[i];
2151 /* OFFSET in SEC (presumably) is the beginning of a function prologue.
2152 Search for stack adjusting insns, and return the sp delta.
2153 If a store of lr is found save the instruction offset to *LR_STORE.
2154 If a stack adjusting instruction is found, save that offset to
2158 find_function_stack_adjust (asection *sec,
2165 memset (reg, 0, sizeof (reg));
2166 for ( ; offset + 4 <= sec->size; offset += 4)
2168 unsigned char buf[4];
2172 /* Assume no relocs on stack adjusing insns. */
2173 if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
2177 ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
2179 if (buf[0] == 0x24 /* stqd */)
2181 if (rt == 0 /* lr */ && ra == 1 /* sp */)
2186 /* Partly decoded immediate field. */
2187 imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
2189 if (buf[0] == 0x1c /* ai */)
2192 imm = (imm ^ 0x200) - 0x200;
2193 reg[rt] = reg[ra] + imm;
2195 if (rt == 1 /* sp */)
2199 *sp_adjust = offset;
2203 else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
2205 int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2207 reg[rt] = reg[ra] + reg[rb];
2212 *sp_adjust = offset;
2216 else if (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */)
2218 int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2220 reg[rt] = reg[rb] - reg[ra];
2225 *sp_adjust = offset;
2229 else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
2231 if (buf[0] >= 0x42 /* ila */)
2232 imm |= (buf[0] & 1) << 17;
2237 if (buf[0] == 0x40 /* il */)
2239 if ((buf[1] & 0x80) == 0)
2241 imm = (imm ^ 0x8000) - 0x8000;
2243 else if ((buf[1] & 0x80) == 0 /* ilhu */)
2249 else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
2251 reg[rt] |= imm & 0xffff;
2254 else if (buf[0] == 0x04 /* ori */)
2257 imm = (imm ^ 0x200) - 0x200;
2258 reg[rt] = reg[ra] | imm;
2261 else if (buf[0] == 0x32 && (buf[1] & 0x80) != 0 /* fsmbi */)
2263 reg[rt] = ( ((imm & 0x8000) ? 0xff000000 : 0)
2264 | ((imm & 0x4000) ? 0x00ff0000 : 0)
2265 | ((imm & 0x2000) ? 0x0000ff00 : 0)
2266 | ((imm & 0x1000) ? 0x000000ff : 0));
2269 else if (buf[0] == 0x16 /* andbi */)
2275 reg[rt] = reg[ra] & imm;
2278 else if (buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
2280 /* Used in pic reg load. Say rt is trashed. Won't be used
2281 in stack adjust, but we need to continue past this branch. */
2285 else if (is_branch (buf) || is_indirect_branch (buf))
2286 /* If we hit a branch then we must be out of the prologue. */
2293 /* qsort predicate to sort symbols by section and value. */
2295 static Elf_Internal_Sym *sort_syms_syms;
2296 static asection **sort_syms_psecs;
2299 sort_syms (const void *a, const void *b)
2301 Elf_Internal_Sym *const *s1 = a;
2302 Elf_Internal_Sym *const *s2 = b;
2303 asection *sec1,*sec2;
2304 bfd_signed_vma delta;
2306 sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
2307 sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
2310 return sec1->index - sec2->index;
2312 delta = (*s1)->st_value - (*s2)->st_value;
2314 return delta < 0 ? -1 : 1;
2316 delta = (*s2)->st_size - (*s1)->st_size;
2318 return delta < 0 ? -1 : 1;
2320 return *s1 < *s2 ? -1 : 1;
2323 /* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
2324 entries for section SEC. */
2326 static struct spu_elf_stack_info *
2327 alloc_stack_info (asection *sec, int max_fun)
2329 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2332 amt = sizeof (struct spu_elf_stack_info);
2333 amt += (max_fun - 1) * sizeof (struct function_info);
2334 sec_data->u.i.stack_info = bfd_zmalloc (amt);
2335 if (sec_data->u.i.stack_info != NULL)
2336 sec_data->u.i.stack_info->max_fun = max_fun;
2337 return sec_data->u.i.stack_info;
2340 /* Add a new struct function_info describing a (part of a) function
2341 starting at SYM_H. Keep the array sorted by address. */
2343 static struct function_info *
2344 maybe_insert_function (asection *sec,
2347 bfd_boolean is_func)
2349 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2350 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2356 sinfo = alloc_stack_info (sec, 20);
2363 Elf_Internal_Sym *sym = sym_h;
2364 off = sym->st_value;
2365 size = sym->st_size;
2369 struct elf_link_hash_entry *h = sym_h;
2370 off = h->root.u.def.value;
2374 for (i = sinfo->num_fun; --i >= 0; )
2375 if (sinfo->fun[i].lo <= off)
2380 /* Don't add another entry for an alias, but do update some
2382 if (sinfo->fun[i].lo == off)
2384 /* Prefer globals over local syms. */
2385 if (global && !sinfo->fun[i].global)
2387 sinfo->fun[i].global = TRUE;
2388 sinfo->fun[i].u.h = sym_h;
2391 sinfo->fun[i].is_func = TRUE;
2392 return &sinfo->fun[i];
2394 /* Ignore a zero-size symbol inside an existing function. */
2395 else if (sinfo->fun[i].hi > off && size == 0)
2396 return &sinfo->fun[i];
2399 if (sinfo->num_fun >= sinfo->max_fun)
2401 bfd_size_type amt = sizeof (struct spu_elf_stack_info);
2402 bfd_size_type old = amt;
2404 old += (sinfo->max_fun - 1) * sizeof (struct function_info);
2405 sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
2406 amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
2407 sinfo = bfd_realloc (sinfo, amt);
2410 memset ((char *) sinfo + old, 0, amt - old);
2411 sec_data->u.i.stack_info = sinfo;
2414 if (++i < sinfo->num_fun)
2415 memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
2416 (sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
2417 sinfo->fun[i].is_func = is_func;
2418 sinfo->fun[i].global = global;
2419 sinfo->fun[i].sec = sec;
2421 sinfo->fun[i].u.h = sym_h;
2423 sinfo->fun[i].u.sym = sym_h;
2424 sinfo->fun[i].lo = off;
2425 sinfo->fun[i].hi = off + size;
2426 sinfo->fun[i].lr_store = -1;
2427 sinfo->fun[i].sp_adjust = -1;
2428 sinfo->fun[i].stack = -find_function_stack_adjust (sec, off,
2429 &sinfo->fun[i].lr_store,
2430 &sinfo->fun[i].sp_adjust);
2431 sinfo->num_fun += 1;
2432 return &sinfo->fun[i];
2435 /* Return the name of FUN. */
2438 func_name (struct function_info *fun)
2442 Elf_Internal_Shdr *symtab_hdr;
2444 while (fun->start != NULL)
2448 return fun->u.h->root.root.string;
2451 if (fun->u.sym->st_name == 0)
2453 size_t len = strlen (sec->name);
2454 char *name = bfd_malloc (len + 10);
2457 sprintf (name, "%s+%lx", sec->name,
2458 (unsigned long) fun->u.sym->st_value & 0xffffffff);
2462 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2463 return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
2466 /* Read the instruction at OFF in SEC. Return true iff the instruction
2467 is a nop, lnop, or stop 0 (all zero insn). */
2470 is_nop (asection *sec, bfd_vma off)
2472 unsigned char insn[4];
2474 if (off + 4 > sec->size
2475 || !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
2477 if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
2479 if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
2484 /* Extend the range of FUN to cover nop padding up to LIMIT.
2485 Return TRUE iff some instruction other than a NOP was found. */
2488 insns_at_end (struct function_info *fun, bfd_vma limit)
2490 bfd_vma off = (fun->hi + 3) & -4;
2492 while (off < limit && is_nop (fun->sec, off))
2503 /* Check and fix overlapping function ranges. Return TRUE iff there
2504 are gaps in the current info we have about functions in SEC. */
2507 check_function_ranges (asection *sec, struct bfd_link_info *info)
2509 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2510 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2512 bfd_boolean gaps = FALSE;
2517 for (i = 1; i < sinfo->num_fun; i++)
2518 if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
2520 /* Fix overlapping symbols. */
2521 const char *f1 = func_name (&sinfo->fun[i - 1]);
2522 const char *f2 = func_name (&sinfo->fun[i]);
2524 info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
2525 sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
2527 else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
2530 if (sinfo->num_fun == 0)
2534 if (sinfo->fun[0].lo != 0)
2536 if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
2538 const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
2540 info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
2541 sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
2543 else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
2549 /* Search current function info for a function that contains address
2550 OFFSET in section SEC. */
2552 static struct function_info *
2553 find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
2555 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2556 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2560 hi = sinfo->num_fun;
2563 mid = (lo + hi) / 2;
2564 if (offset < sinfo->fun[mid].lo)
2566 else if (offset >= sinfo->fun[mid].hi)
2569 return &sinfo->fun[mid];
2571 info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
2573 bfd_set_error (bfd_error_bad_value);
2577 /* Add CALLEE to CALLER call list if not already present. Return TRUE
2578 if CALLEE was new. If this function return FALSE, CALLEE should
2582 insert_callee (struct function_info *caller, struct call_info *callee)
2584 struct call_info **pp, *p;
2586 for (pp = &caller->call_list; (p = *pp) != NULL; pp = &p->next)
2587 if (p->fun == callee->fun)
2589 /* Tail calls use less stack than normal calls. Retain entry
2590 for normal call over one for tail call. */
2591 p->is_tail &= callee->is_tail;
2594 p->fun->start = NULL;
2595 p->fun->is_func = TRUE;
2597 p->count += callee->count;
2598 /* Reorder list so most recent call is first. */
2600 p->next = caller->call_list;
2601 caller->call_list = p;
2604 callee->next = caller->call_list;
2605 caller->call_list = callee;
2609 /* Copy CALL and insert the copy into CALLER. */
2612 copy_callee (struct function_info *caller, const struct call_info *call)
2614 struct call_info *callee;
2615 callee = bfd_malloc (sizeof (*callee));
2619 if (!insert_callee (caller, callee))
2624 /* We're only interested in code sections. Testing SEC_IN_MEMORY excludes
2625 overlay stub sections. */
2628 interesting_section (asection *s)
2630 return (s->output_section != bfd_abs_section_ptr
2631 && ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_IN_MEMORY))
2632 == (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2636 /* Rummage through the relocs for SEC, looking for function calls.
2637 If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
2638 mark destination symbols on calls as being functions. Also
2639 look at branches, which may be tail calls or go to hot/cold
2640 section part of same function. */
2643 mark_functions_via_relocs (asection *sec,
2644 struct bfd_link_info *info,
2647 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2648 Elf_Internal_Shdr *symtab_hdr;
2650 unsigned int priority = 0;
2651 static bfd_boolean warned;
2653 if (!interesting_section (sec)
2654 || sec->reloc_count == 0)
2657 internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
2659 if (internal_relocs == NULL)
2662 symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
2663 psyms = &symtab_hdr->contents;
2664 irela = internal_relocs;
2665 irelaend = irela + sec->reloc_count;
2666 for (; irela < irelaend; irela++)
2668 enum elf_spu_reloc_type r_type;
2669 unsigned int r_indx;
2671 Elf_Internal_Sym *sym;
2672 struct elf_link_hash_entry *h;
2674 bfd_boolean reject, is_call;
2675 struct function_info *caller;
2676 struct call_info *callee;
2679 r_type = ELF32_R_TYPE (irela->r_info);
2680 if (r_type != R_SPU_REL16
2681 && r_type != R_SPU_ADDR16)
2684 if (!(call_tree && spu_hash_table (info)->params->auto_overlay))
2688 r_indx = ELF32_R_SYM (irela->r_info);
2689 if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
2693 || sym_sec->output_section == bfd_abs_section_ptr)
2699 unsigned char insn[4];
2701 if (!bfd_get_section_contents (sec->owner, sec, insn,
2702 irela->r_offset, 4))
2704 if (is_branch (insn))
2706 is_call = (insn[0] & 0xfd) == 0x31;
2707 priority = insn[1] & 0x0f;
2709 priority |= insn[2];
2711 priority |= insn[3];
2713 if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2714 != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2717 info->callbacks->einfo
2718 (_("%B(%A+0x%v): call to non-code section"
2719 " %B(%A), analysis incomplete\n"),
2720 sec->owner, sec, irela->r_offset,
2721 sym_sec->owner, sym_sec);
2729 if (!(call_tree && spu_hash_table (info)->params->auto_overlay)
2737 /* For --auto-overlay, count possible stubs we need for
2738 function pointer references. */
2739 unsigned int sym_type;
2743 sym_type = ELF_ST_TYPE (sym->st_info);
2744 if (sym_type == STT_FUNC)
2745 spu_hash_table (info)->non_ovly_stub += 1;
2750 val = h->root.u.def.value;
2752 val = sym->st_value;
2753 val += irela->r_addend;
2757 struct function_info *fun;
2759 if (irela->r_addend != 0)
2761 Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
2764 fake->st_value = val;
2766 = _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
2770 fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
2772 fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
2775 if (irela->r_addend != 0
2776 && fun->u.sym != sym)
2781 caller = find_function (sec, irela->r_offset, info);
2784 callee = bfd_malloc (sizeof *callee);
2788 callee->fun = find_function (sym_sec, val, info);
2789 if (callee->fun == NULL)
2791 callee->is_tail = !is_call;
2792 callee->is_pasted = FALSE;
2793 callee->broken_cycle = FALSE;
2794 callee->priority = priority;
2796 if (callee->fun->last_caller != sec)
2798 callee->fun->last_caller = sec;
2799 callee->fun->call_count += 1;
2801 if (!insert_callee (caller, callee))
2804 && !callee->fun->is_func
2805 && callee->fun->stack == 0)
2807 /* This is either a tail call or a branch from one part of
2808 the function to another, ie. hot/cold section. If the
2809 destination has been called by some other function then
2810 it is a separate function. We also assume that functions
2811 are not split across input files. */
2812 if (sec->owner != sym_sec->owner)
2814 callee->fun->start = NULL;
2815 callee->fun->is_func = TRUE;
2817 else if (callee->fun->start == NULL)
2819 struct function_info *caller_start = caller;
2820 while (caller_start->start)
2821 caller_start = caller_start->start;
2823 if (caller_start != callee->fun)
2824 callee->fun->start = caller_start;
2828 struct function_info *callee_start;
2829 struct function_info *caller_start;
2830 callee_start = callee->fun;
2831 while (callee_start->start)
2832 callee_start = callee_start->start;
2833 caller_start = caller;
2834 while (caller_start->start)
2835 caller_start = caller_start->start;
2836 if (caller_start != callee_start)
2838 callee->fun->start = NULL;
2839 callee->fun->is_func = TRUE;
2848 /* Handle something like .init or .fini, which has a piece of a function.
2849 These sections are pasted together to form a single function. */
2852 pasted_function (asection *sec)
2854 struct bfd_link_order *l;
2855 struct _spu_elf_section_data *sec_data;
2856 struct spu_elf_stack_info *sinfo;
2857 Elf_Internal_Sym *fake;
2858 struct function_info *fun, *fun_start;
2860 fake = bfd_zmalloc (sizeof (*fake));
2864 fake->st_size = sec->size;
2866 = _bfd_elf_section_from_bfd_section (sec->owner, sec);
2867 fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2871 /* Find a function immediately preceding this section. */
2873 for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2875 if (l->u.indirect.section == sec)
2877 if (fun_start != NULL)
2879 struct call_info *callee = bfd_malloc (sizeof *callee);
2883 fun->start = fun_start;
2885 callee->is_tail = TRUE;
2886 callee->is_pasted = TRUE;
2887 callee->broken_cycle = FALSE;
2888 callee->priority = 0;
2890 if (!insert_callee (fun_start, callee))
2896 if (l->type == bfd_indirect_link_order
2897 && (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
2898 && (sinfo = sec_data->u.i.stack_info) != NULL
2899 && sinfo->num_fun != 0)
2900 fun_start = &sinfo->fun[sinfo->num_fun - 1];
2903 /* Don't return an error if we did not find a function preceding this
2904 section. The section may have incorrect flags. */
2908 /* Map address ranges in code sections to functions. */
2911 discover_functions (struct bfd_link_info *info)
2915 Elf_Internal_Sym ***psym_arr;
2916 asection ***sec_arr;
2917 bfd_boolean gaps = FALSE;
2920 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2923 psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2924 if (psym_arr == NULL)
2926 sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2927 if (sec_arr == NULL)
2930 for (ibfd = info->input_bfds, bfd_idx = 0;
2932 ibfd = ibfd->link_next, bfd_idx++)
2934 extern const bfd_target bfd_elf32_spu_vec;
2935 Elf_Internal_Shdr *symtab_hdr;
2938 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2939 asection **psecs, **p;
2941 if (ibfd->xvec != &bfd_elf32_spu_vec)
2944 /* Read all the symbols. */
2945 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2946 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2950 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2951 if (interesting_section (sec))
2959 if (symtab_hdr->contents != NULL)
2961 /* Don't use cached symbols since the generic ELF linker
2962 code only reads local symbols, and we need globals too. */
2963 free (symtab_hdr->contents);
2964 symtab_hdr->contents = NULL;
2966 syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2968 symtab_hdr->contents = (void *) syms;
2972 /* Select defined function symbols that are going to be output. */
2973 psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2976 psym_arr[bfd_idx] = psyms;
2977 psecs = bfd_malloc (symcount * sizeof (*psecs));
2980 sec_arr[bfd_idx] = psecs;
2981 for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
2982 if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
2983 || ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2987 *p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
2988 if (s != NULL && interesting_section (s))
2991 symcount = psy - psyms;
2994 /* Sort them by section and offset within section. */
2995 sort_syms_syms = syms;
2996 sort_syms_psecs = psecs;
2997 qsort (psyms, symcount, sizeof (*psyms), sort_syms);
2999 /* Now inspect the function symbols. */
3000 for (psy = psyms; psy < psyms + symcount; )
3002 asection *s = psecs[*psy - syms];
3003 Elf_Internal_Sym **psy2;
3005 for (psy2 = psy; ++psy2 < psyms + symcount; )
3006 if (psecs[*psy2 - syms] != s)
3009 if (!alloc_stack_info (s, psy2 - psy))
3014 /* First install info about properly typed and sized functions.
3015 In an ideal world this will cover all code sections, except
3016 when partitioning functions into hot and cold sections,
3017 and the horrible pasted together .init and .fini functions. */
3018 for (psy = psyms; psy < psyms + symcount; ++psy)
3021 if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
3023 asection *s = psecs[sy - syms];
3024 if (!maybe_insert_function (s, sy, FALSE, TRUE))
3029 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3030 if (interesting_section (sec))
3031 gaps |= check_function_ranges (sec, info);
3036 /* See if we can discover more function symbols by looking at
3038 for (ibfd = info->input_bfds, bfd_idx = 0;
3040 ibfd = ibfd->link_next, bfd_idx++)
3044 if (psym_arr[bfd_idx] == NULL)
3047 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3048 if (!mark_functions_via_relocs (sec, info, FALSE))
3052 for (ibfd = info->input_bfds, bfd_idx = 0;
3054 ibfd = ibfd->link_next, bfd_idx++)
3056 Elf_Internal_Shdr *symtab_hdr;
3058 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
3061 if ((psyms = psym_arr[bfd_idx]) == NULL)
3064 psecs = sec_arr[bfd_idx];
3066 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3067 syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3070 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3071 if (interesting_section (sec))
3072 gaps |= check_function_ranges (sec, info);
3076 /* Finally, install all globals. */
3077 for (psy = psyms; (sy = *psy) != NULL; ++psy)
3081 s = psecs[sy - syms];
3083 /* Global syms might be improperly typed functions. */
3084 if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
3085 && ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
3087 if (!maybe_insert_function (s, sy, FALSE, FALSE))
3093 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3095 extern const bfd_target bfd_elf32_spu_vec;
3098 if (ibfd->xvec != &bfd_elf32_spu_vec)
3101 /* Some of the symbols we've installed as marking the
3102 beginning of functions may have a size of zero. Extend
3103 the range of such functions to the beginning of the
3104 next symbol of interest. */
3105 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3106 if (interesting_section (sec))
3108 struct _spu_elf_section_data *sec_data;
3109 struct spu_elf_stack_info *sinfo;
3111 sec_data = spu_elf_section_data (sec);
3112 sinfo = sec_data->u.i.stack_info;
3113 if (sinfo != NULL && sinfo->num_fun != 0)
3116 bfd_vma hi = sec->size;
3118 for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
3120 sinfo->fun[fun_idx].hi = hi;
3121 hi = sinfo->fun[fun_idx].lo;
3124 sinfo->fun[0].lo = 0;
3126 /* No symbols in this section. Must be .init or .fini
3127 or something similar. */
3128 else if (!pasted_function (sec))
3134 for (ibfd = info->input_bfds, bfd_idx = 0;
3136 ibfd = ibfd->link_next, bfd_idx++)
3138 if (psym_arr[bfd_idx] == NULL)
3141 free (psym_arr[bfd_idx]);
3142 free (sec_arr[bfd_idx]);
3151 /* Iterate over all function_info we have collected, calling DOIT on
3152 each node if ROOT_ONLY is false. Only call DOIT on root nodes
3156 for_each_node (bfd_boolean (*doit) (struct function_info *,
3157 struct bfd_link_info *,
3159 struct bfd_link_info *info,
3165 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3167 extern const bfd_target bfd_elf32_spu_vec;
3170 if (ibfd->xvec != &bfd_elf32_spu_vec)
3173 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3175 struct _spu_elf_section_data *sec_data;
3176 struct spu_elf_stack_info *sinfo;
3178 if ((sec_data = spu_elf_section_data (sec)) != NULL
3179 && (sinfo = sec_data->u.i.stack_info) != NULL)
3182 for (i = 0; i < sinfo->num_fun; ++i)
3183 if (!root_only || !sinfo->fun[i].non_root)
3184 if (!doit (&sinfo->fun[i], info, param))
3192 /* Transfer call info attached to struct function_info entries for
3193 all of a given function's sections to the first entry. */
3196 transfer_calls (struct function_info *fun,
3197 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3198 void *param ATTRIBUTE_UNUSED)
3200 struct function_info *start = fun->start;
3204 struct call_info *call, *call_next;
3206 while (start->start != NULL)
3207 start = start->start;
3208 for (call = fun->call_list; call != NULL; call = call_next)
3210 call_next = call->next;
3211 if (!insert_callee (start, call))
3214 fun->call_list = NULL;
3219 /* Mark nodes in the call graph that are called by some other node. */
3222 mark_non_root (struct function_info *fun,
3223 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3224 void *param ATTRIBUTE_UNUSED)
3226 struct call_info *call;
3231 for (call = fun->call_list; call; call = call->next)
3233 call->fun->non_root = TRUE;
3234 mark_non_root (call->fun, 0, 0);
3239 /* Remove cycles from the call graph. Set depth of nodes. */
3242 remove_cycles (struct function_info *fun,
3243 struct bfd_link_info *info,
3246 struct call_info **callp, *call;
3247 unsigned int depth = *(unsigned int *) param;
3248 unsigned int max_depth = depth;
3252 fun->marking = TRUE;
3254 callp = &fun->call_list;
3255 while ((call = *callp) != NULL)
3257 call->max_depth = depth + !call->is_pasted;
3258 if (!call->fun->visit2)
3260 if (!remove_cycles (call->fun, info, &call->max_depth))
3262 if (max_depth < call->max_depth)
3263 max_depth = call->max_depth;
3265 else if (call->fun->marking)
3267 struct spu_link_hash_table *htab = spu_hash_table (info);
3269 if (!htab->params->auto_overlay
3270 && htab->params->stack_analysis)
3272 const char *f1 = func_name (fun);
3273 const char *f2 = func_name (call->fun);
3275 info->callbacks->info (_("Stack analysis will ignore the call "
3280 call->broken_cycle = TRUE;
3282 callp = &call->next;
3284 fun->marking = FALSE;
3285 *(unsigned int *) param = max_depth;
3289 /* Check that we actually visited all nodes in remove_cycles. If we
3290 didn't, then there is some cycle in the call graph not attached to
3291 any root node. Arbitrarily choose a node in the cycle as a new
3292 root and break the cycle. */
3295 mark_detached_root (struct function_info *fun,
3296 struct bfd_link_info *info,
3301 fun->non_root = FALSE;
3302 *(unsigned int *) param = 0;
3303 return remove_cycles (fun, info, param);
3306 /* Populate call_list for each function. */
3309 build_call_tree (struct bfd_link_info *info)
3314 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3316 extern const bfd_target bfd_elf32_spu_vec;
3319 if (ibfd->xvec != &bfd_elf32_spu_vec)
3322 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3323 if (!mark_functions_via_relocs (sec, info, TRUE))
3327 /* Transfer call info from hot/cold section part of function
3329 if (!spu_hash_table (info)->params->auto_overlay
3330 && !for_each_node (transfer_calls, info, 0, FALSE))
3333 /* Find the call graph root(s). */
3334 if (!for_each_node (mark_non_root, info, 0, FALSE))
3337 /* Remove cycles from the call graph. We start from the root node(s)
3338 so that we break cycles in a reasonable place. */
3340 if (!for_each_node (remove_cycles, info, &depth, TRUE))
3343 return for_each_node (mark_detached_root, info, &depth, FALSE);
3346 /* qsort predicate to sort calls by priority, max_depth then count. */
3349 sort_calls (const void *a, const void *b)
3351 struct call_info *const *c1 = a;
3352 struct call_info *const *c2 = b;
3355 delta = (*c2)->priority - (*c1)->priority;
3359 delta = (*c2)->max_depth - (*c1)->max_depth;
3363 delta = (*c2)->count - (*c1)->count;
3367 return (char *) c1 - (char *) c2;
3371 unsigned int max_overlay_size;
3374 /* Set linker_mark and gc_mark on any sections that we will put in
3375 overlays. These flags are used by the generic ELF linker, but we
3376 won't be continuing on to bfd_elf_final_link so it is OK to use
3377 them. linker_mark is clear before we get here. Set segment_mark
3378 on sections that are part of a pasted function (excluding the last
3381 Set up function rodata section if --overlay-rodata. We don't
3382 currently include merged string constant rodata sections since
3384 Sort the call graph so that the deepest nodes will be visited
3388 mark_overlay_section (struct function_info *fun,
3389 struct bfd_link_info *info,
3392 struct call_info *call;
3394 struct _mos_param *mos_param = param;
3395 struct spu_link_hash_table *htab = spu_hash_table (info);
3401 if (!fun->sec->linker_mark
3402 && (htab->params->ovly_flavour != ovly_soft_icache
3403 || htab->params->non_ia_text
3404 || strncmp (fun->sec->name, ".text.ia.", 9) == 0
3405 || strcmp (fun->sec->name, ".init") == 0
3406 || strcmp (fun->sec->name, ".fini") == 0))
3410 fun->sec->linker_mark = 1;
3411 fun->sec->gc_mark = 1;
3412 fun->sec->segment_mark = 0;
3413 /* Ensure SEC_CODE is set on this text section (it ought to
3414 be!), and SEC_CODE is clear on rodata sections. We use
3415 this flag to differentiate the two overlay section types. */
3416 fun->sec->flags |= SEC_CODE;
3418 size = fun->sec->size;
3419 if (htab->params->auto_overlay & OVERLAY_RODATA)
3423 /* Find the rodata section corresponding to this function's
3425 if (strcmp (fun->sec->name, ".text") == 0)
3427 name = bfd_malloc (sizeof (".rodata"));
3430 memcpy (name, ".rodata", sizeof (".rodata"));
3432 else if (strncmp (fun->sec->name, ".text.", 6) == 0)
3434 size_t len = strlen (fun->sec->name);
3435 name = bfd_malloc (len + 3);
3438 memcpy (name, ".rodata", sizeof (".rodata"));
3439 memcpy (name + 7, fun->sec->name + 5, len - 4);
3441 else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
3443 size_t len = strlen (fun->sec->name) + 1;
3444 name = bfd_malloc (len);
3447 memcpy (name, fun->sec->name, len);
3453 asection *rodata = NULL;
3454 asection *group_sec = elf_section_data (fun->sec)->next_in_group;
3455 if (group_sec == NULL)
3456 rodata = bfd_get_section_by_name (fun->sec->owner, name);
3458 while (group_sec != NULL && group_sec != fun->sec)
3460 if (strcmp (group_sec->name, name) == 0)
3465 group_sec = elf_section_data (group_sec)->next_in_group;
3467 fun->rodata = rodata;
3470 size += fun->rodata->size;
3471 if (htab->params->line_size != 0
3472 && size > htab->params->line_size)
3474 size -= fun->rodata->size;
3479 fun->rodata->linker_mark = 1;
3480 fun->rodata->gc_mark = 1;
3481 fun->rodata->flags &= ~SEC_CODE;
3487 if (mos_param->max_overlay_size < size)
3488 mos_param->max_overlay_size = size;
3491 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3496 struct call_info **calls = bfd_malloc (count * sizeof (*calls));
3500 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3501 calls[count++] = call;
3503 qsort (calls, count, sizeof (*calls), sort_calls);
3505 fun->call_list = NULL;
3509 calls[count]->next = fun->call_list;
3510 fun->call_list = calls[count];
3515 for (call = fun->call_list; call != NULL; call = call->next)
3517 if (call->is_pasted)
3519 /* There can only be one is_pasted call per function_info. */
3520 BFD_ASSERT (!fun->sec->segment_mark);
3521 fun->sec->segment_mark = 1;
3523 if (!call->broken_cycle
3524 && !mark_overlay_section (call->fun, info, param))
3528 /* Don't put entry code into an overlay. The overlay manager needs
3529 a stack! Also, don't mark .ovl.init as an overlay. */
3530 if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
3531 == info->output_bfd->start_address
3532 || strncmp (fun->sec->output_section->name, ".ovl.init", 9) == 0)
3534 fun->sec->linker_mark = 0;
3535 if (fun->rodata != NULL)
3536 fun->rodata->linker_mark = 0;
3541 /* If non-zero then unmark functions called from those within sections
3542 that we need to unmark. Unfortunately this isn't reliable since the
3543 call graph cannot know the destination of function pointer calls. */
3544 #define RECURSE_UNMARK 0
3547 asection *exclude_input_section;
3548 asection *exclude_output_section;
3549 unsigned long clearing;
3552 /* Undo some of mark_overlay_section's work. */
3555 unmark_overlay_section (struct function_info *fun,
3556 struct bfd_link_info *info,
3559 struct call_info *call;
3560 struct _uos_param *uos_param = param;
3561 unsigned int excluded = 0;
3569 if (fun->sec == uos_param->exclude_input_section
3570 || fun->sec->output_section == uos_param->exclude_output_section)
3574 uos_param->clearing += excluded;
3576 if (RECURSE_UNMARK ? uos_param->clearing : excluded)
3578 fun->sec->linker_mark = 0;
3580 fun->rodata->linker_mark = 0;
3583 for (call = fun->call_list; call != NULL; call = call->next)
3584 if (!call->broken_cycle
3585 && !unmark_overlay_section (call->fun, info, param))
3589 uos_param->clearing -= excluded;
3594 unsigned int lib_size;
3595 asection **lib_sections;
3598 /* Add sections we have marked as belonging to overlays to an array
3599 for consideration as non-overlay sections. The array consist of
3600 pairs of sections, (text,rodata), for functions in the call graph. */
3603 collect_lib_sections (struct function_info *fun,
3604 struct bfd_link_info *info,
3607 struct _cl_param *lib_param = param;
3608 struct call_info *call;
3615 if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
3618 size = fun->sec->size;
3620 size += fun->rodata->size;
3622 if (size <= lib_param->lib_size)
3624 *lib_param->lib_sections++ = fun->sec;
3625 fun->sec->gc_mark = 0;
3626 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3628 *lib_param->lib_sections++ = fun->rodata;
3629 fun->rodata->gc_mark = 0;
3632 *lib_param->lib_sections++ = NULL;
3635 for (call = fun->call_list; call != NULL; call = call->next)
3636 if (!call->broken_cycle)
3637 collect_lib_sections (call->fun, info, param);
3642 /* qsort predicate to sort sections by call count. */
3645 sort_lib (const void *a, const void *b)
3647 asection *const *s1 = a;
3648 asection *const *s2 = b;
3649 struct _spu_elf_section_data *sec_data;
3650 struct spu_elf_stack_info *sinfo;
3654 if ((sec_data = spu_elf_section_data (*s1)) != NULL
3655 && (sinfo = sec_data->u.i.stack_info) != NULL)
3658 for (i = 0; i < sinfo->num_fun; ++i)
3659 delta -= sinfo->fun[i].call_count;
3662 if ((sec_data = spu_elf_section_data (*s2)) != NULL
3663 && (sinfo = sec_data->u.i.stack_info) != NULL)
3666 for (i = 0; i < sinfo->num_fun; ++i)
3667 delta += sinfo->fun[i].call_count;
3676 /* Remove some sections from those marked to be in overlays. Choose
3677 those that are called from many places, likely library functions. */
3680 auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3683 asection **lib_sections;
3684 unsigned int i, lib_count;
3685 struct _cl_param collect_lib_param;
3686 struct function_info dummy_caller;
3687 struct spu_link_hash_table *htab;
3689 memset (&dummy_caller, 0, sizeof (dummy_caller));
3691 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3693 extern const bfd_target bfd_elf32_spu_vec;
3696 if (ibfd->xvec != &bfd_elf32_spu_vec)
3699 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3700 if (sec->linker_mark
3701 && sec->size < lib_size
3702 && (sec->flags & SEC_CODE) != 0)
3705 lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3706 if (lib_sections == NULL)
3707 return (unsigned int) -1;
3708 collect_lib_param.lib_size = lib_size;
3709 collect_lib_param.lib_sections = lib_sections;
3710 if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3712 return (unsigned int) -1;
3713 lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3715 /* Sort sections so that those with the most calls are first. */
3717 qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3719 htab = spu_hash_table (info);
3720 for (i = 0; i < lib_count; i++)
3722 unsigned int tmp, stub_size;
3724 struct _spu_elf_section_data *sec_data;
3725 struct spu_elf_stack_info *sinfo;
3727 sec = lib_sections[2 * i];
3728 /* If this section is OK, its size must be less than lib_size. */
3730 /* If it has a rodata section, then add that too. */
3731 if (lib_sections[2 * i + 1])
3732 tmp += lib_sections[2 * i + 1]->size;
3733 /* Add any new overlay call stubs needed by the section. */
3736 && (sec_data = spu_elf_section_data (sec)) != NULL
3737 && (sinfo = sec_data->u.i.stack_info) != NULL)
3740 struct call_info *call;
3742 for (k = 0; k < sinfo->num_fun; ++k)
3743 for (call = sinfo->fun[k].call_list; call; call = call->next)
3744 if (call->fun->sec->linker_mark)
3746 struct call_info *p;
3747 for (p = dummy_caller.call_list; p; p = p->next)
3748 if (p->fun == call->fun)
3751 stub_size += ovl_stub_size (htab->params);
3754 if (tmp + stub_size < lib_size)
3756 struct call_info **pp, *p;
3758 /* This section fits. Mark it as non-overlay. */
3759 lib_sections[2 * i]->linker_mark = 0;
3760 if (lib_sections[2 * i + 1])
3761 lib_sections[2 * i + 1]->linker_mark = 0;
3762 lib_size -= tmp + stub_size;
3763 /* Call stubs to the section we just added are no longer
3765 pp = &dummy_caller.call_list;
3766 while ((p = *pp) != NULL)
3767 if (!p->fun->sec->linker_mark)
3769 lib_size += ovl_stub_size (htab->params);
3775 /* Add new call stubs to dummy_caller. */
3776 if ((sec_data = spu_elf_section_data (sec)) != NULL
3777 && (sinfo = sec_data->u.i.stack_info) != NULL)
3780 struct call_info *call;
3782 for (k = 0; k < sinfo->num_fun; ++k)
3783 for (call = sinfo->fun[k].call_list;
3786 if (call->fun->sec->linker_mark)
3788 struct call_info *callee;
3789 callee = bfd_malloc (sizeof (*callee));
3791 return (unsigned int) -1;
3793 if (!insert_callee (&dummy_caller, callee))
3799 while (dummy_caller.call_list != NULL)
3801 struct call_info *call = dummy_caller.call_list;
3802 dummy_caller.call_list = call->next;
3805 for (i = 0; i < 2 * lib_count; i++)
3806 if (lib_sections[i])
3807 lib_sections[i]->gc_mark = 1;
3808 free (lib_sections);
3812 /* Build an array of overlay sections. The deepest node's section is
3813 added first, then its parent node's section, then everything called
3814 from the parent section. The idea being to group sections to
3815 minimise calls between different overlays. */
3818 collect_overlays (struct function_info *fun,
3819 struct bfd_link_info *info,
3822 struct call_info *call;
3823 bfd_boolean added_fun;
3824 asection ***ovly_sections = param;
3830 for (call = fun->call_list; call != NULL; call = call->next)
3831 if (!call->is_pasted && !call->broken_cycle)
3833 if (!collect_overlays (call->fun, info, ovly_sections))
3839 if (fun->sec->linker_mark && fun->sec->gc_mark)
3841 fun->sec->gc_mark = 0;
3842 *(*ovly_sections)++ = fun->sec;
3843 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3845 fun->rodata->gc_mark = 0;
3846 *(*ovly_sections)++ = fun->rodata;
3849 *(*ovly_sections)++ = NULL;
3852 /* Pasted sections must stay with the first section. We don't
3853 put pasted sections in the array, just the first section.
3854 Mark subsequent sections as already considered. */
3855 if (fun->sec->segment_mark)
3857 struct function_info *call_fun = fun;
3860 for (call = call_fun->call_list; call != NULL; call = call->next)
3861 if (call->is_pasted)
3863 call_fun = call->fun;
3864 call_fun->sec->gc_mark = 0;
3865 if (call_fun->rodata)
3866 call_fun->rodata->gc_mark = 0;
3872 while (call_fun->sec->segment_mark);
3876 for (call = fun->call_list; call != NULL; call = call->next)
3877 if (!call->broken_cycle
3878 && !collect_overlays (call->fun, info, ovly_sections))
3883 struct _spu_elf_section_data *sec_data;
3884 struct spu_elf_stack_info *sinfo;
3886 if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3887 && (sinfo = sec_data->u.i.stack_info) != NULL)
3890 for (i = 0; i < sinfo->num_fun; ++i)
3891 if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3899 struct _sum_stack_param {
3901 size_t overall_stack;
3902 bfd_boolean emit_stack_syms;
3905 /* Descend the call graph for FUN, accumulating total stack required. */
3908 sum_stack (struct function_info *fun,
3909 struct bfd_link_info *info,
3912 struct call_info *call;
3913 struct function_info *max;
3914 size_t stack, cum_stack;
3916 bfd_boolean has_call;
3917 struct _sum_stack_param *sum_stack_param = param;
3918 struct spu_link_hash_table *htab;
3920 cum_stack = fun->stack;
3921 sum_stack_param->cum_stack = cum_stack;
3927 for (call = fun->call_list; call; call = call->next)
3929 if (call->broken_cycle)
3931 if (!call->is_pasted)
3933 if (!sum_stack (call->fun, info, sum_stack_param))
3935 stack = sum_stack_param->cum_stack;
3936 /* Include caller stack for normal calls, don't do so for
3937 tail calls. fun->stack here is local stack usage for
3939 if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
3940 stack += fun->stack;
3941 if (cum_stack < stack)
3948 sum_stack_param->cum_stack = cum_stack;
3950 /* Now fun->stack holds cumulative stack. */
3951 fun->stack = cum_stack;
3955 && sum_stack_param->overall_stack < cum_stack)
3956 sum_stack_param->overall_stack = cum_stack;
3958 htab = spu_hash_table (info);
3959 if (htab->params->auto_overlay)
3962 f1 = func_name (fun);
3963 if (htab->params->stack_analysis)
3966 info->callbacks->info (_(" %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
3967 info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
3968 f1, (bfd_vma) stack, (bfd_vma) cum_stack);
3972 info->callbacks->minfo (_(" calls:\n"));
3973 for (call = fun->call_list; call; call = call->next)
3974 if (!call->is_pasted && !call->broken_cycle)
3976 const char *f2 = func_name (call->fun);
3977 const char *ann1 = call->fun == max ? "*" : " ";
3978 const char *ann2 = call->is_tail ? "t" : " ";
3980 info->callbacks->minfo (_(" %s%s %s\n"), ann1, ann2, f2);
3985 if (sum_stack_param->emit_stack_syms)
3987 char *name = bfd_malloc (18 + strlen (f1));
3988 struct elf_link_hash_entry *h;
3993 if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
3994 sprintf (name, "__stack_%s", f1);
3996 sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
3998 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
4001 && (h->root.type == bfd_link_hash_new
4002 || h->root.type == bfd_link_hash_undefined
4003 || h->root.type == bfd_link_hash_undefweak))
4005 h->root.type = bfd_link_hash_defined;
4006 h->root.u.def.section = bfd_abs_section_ptr;
4007 h->root.u.def.value = cum_stack;
4012 h->ref_regular_nonweak = 1;
4013 h->forced_local = 1;
4021 /* SEC is part of a pasted function. Return the call_info for the
4022 next section of this function. */
4024 static struct call_info *
4025 find_pasted_call (asection *sec)
4027 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
4028 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
4029 struct call_info *call;
4032 for (k = 0; k < sinfo->num_fun; ++k)
4033 for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
4034 if (call->is_pasted)
4040 /* qsort predicate to sort bfds by file name. */
4043 sort_bfds (const void *a, const void *b)
4045 bfd *const *abfd1 = a;
4046 bfd *const *abfd2 = b;
4048 return strcmp ((*abfd1)->filename, (*abfd2)->filename);
4052 print_one_overlay_section (FILE *script,
4055 unsigned int ovlynum,
4056 unsigned int *ovly_map,
4057 asection **ovly_sections,
4058 struct bfd_link_info *info)
4062 for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4064 asection *sec = ovly_sections[2 * j];
4066 if (fprintf (script, " %s%c%s (%s)\n",
4067 (sec->owner->my_archive != NULL
4068 ? sec->owner->my_archive->filename : ""),
4069 info->path_separator,
4070 sec->owner->filename,
4073 if (sec->segment_mark)
4075 struct call_info *call = find_pasted_call (sec);
4076 while (call != NULL)
4078 struct function_info *call_fun = call->fun;
4079 sec = call_fun->sec;
4080 if (fprintf (script, " %s%c%s (%s)\n",
4081 (sec->owner->my_archive != NULL
4082 ? sec->owner->my_archive->filename : ""),
4083 info->path_separator,
4084 sec->owner->filename,
4087 for (call = call_fun->call_list; call; call = call->next)
4088 if (call->is_pasted)
4094 for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4096 asection *sec = ovly_sections[2 * j + 1];
4098 && fprintf (script, " %s%c%s (%s)\n",
4099 (sec->owner->my_archive != NULL
4100 ? sec->owner->my_archive->filename : ""),
4101 info->path_separator,
4102 sec->owner->filename,
4106 sec = ovly_sections[2 * j];
4107 if (sec->segment_mark)
4109 struct call_info *call = find_pasted_call (sec);
4110 while (call != NULL)
4112 struct function_info *call_fun = call->fun;
4113 sec = call_fun->rodata;
4115 && fprintf (script, " %s%c%s (%s)\n",
4116 (sec->owner->my_archive != NULL
4117 ? sec->owner->my_archive->filename : ""),
4118 info->path_separator,
4119 sec->owner->filename,
4122 for (call = call_fun->call_list; call; call = call->next)
4123 if (call->is_pasted)
4132 /* Handle --auto-overlay. */
4135 spu_elf_auto_overlay (struct bfd_link_info *info)
4139 struct elf_segment_map *m;
4140 unsigned int fixed_size, lo, hi;
4141 struct spu_link_hash_table *htab;
4142 unsigned int base, i, count, bfd_count;
4143 unsigned int region, ovlynum;
4144 asection **ovly_sections, **ovly_p;
4145 unsigned int *ovly_map;
4147 unsigned int total_overlay_size, overlay_size;
4148 const char *ovly_mgr_entry;
4149 struct elf_link_hash_entry *h;
4150 struct _mos_param mos_param;
4151 struct _uos_param uos_param;
4152 struct function_info dummy_caller;
4154 /* Find the extents of our loadable image. */
4155 lo = (unsigned int) -1;
4157 for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
4158 if (m->p_type == PT_LOAD)
4159 for (i = 0; i < m->count; i++)
4160 if (m->sections[i]->size != 0)
4162 if (m->sections[i]->vma < lo)
4163 lo = m->sections[i]->vma;
4164 if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
4165 hi = m->sections[i]->vma + m->sections[i]->size - 1;
4167 fixed_size = hi + 1 - lo;
4169 if (!discover_functions (info))
4172 if (!build_call_tree (info))
4175 htab = spu_hash_table (info);
4176 if (htab->reserved == 0)
4178 struct _sum_stack_param sum_stack_param;
4180 sum_stack_param.emit_stack_syms = 0;
4181 sum_stack_param.overall_stack = 0;
4182 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4184 htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
4187 /* No need for overlays if everything already fits. */
4188 if (fixed_size + htab->reserved <= htab->local_store
4189 && htab->params->ovly_flavour != ovly_soft_icache)
4191 htab->params->auto_overlay = 0;
4195 uos_param.exclude_input_section = 0;
4196 uos_param.exclude_output_section
4197 = bfd_get_section_by_name (info->output_bfd, ".interrupt");
4199 ovly_mgr_entry = "__ovly_load";
4200 if (htab->params->ovly_flavour == ovly_soft_icache)
4201 ovly_mgr_entry = "__icache_br_handler";
4202 h = elf_link_hash_lookup (&htab->elf, ovly_mgr_entry,
4203 FALSE, FALSE, FALSE);
4205 && (h->root.type == bfd_link_hash_defined
4206 || h->root.type == bfd_link_hash_defweak)
4209 /* We have a user supplied overlay manager. */
4210 uos_param.exclude_input_section = h->root.u.def.section;
4214 /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4215 builtin version to .text, and will adjust .text size. */
4216 fixed_size += (*htab->params->spu_elf_load_ovl_mgr) ();
4219 /* Mark overlay sections, and find max overlay section size. */
4220 mos_param.max_overlay_size = 0;
4221 if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
4224 /* We can't put the overlay manager or interrupt routines in
4226 uos_param.clearing = 0;
4227 if ((uos_param.exclude_input_section
4228 || uos_param.exclude_output_section)
4229 && !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
4233 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4235 bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
4236 if (bfd_arr == NULL)
4239 /* Count overlay sections, and subtract their sizes from "fixed_size". */
4242 total_overlay_size = 0;
4243 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4245 extern const bfd_target bfd_elf32_spu_vec;
4247 unsigned int old_count;
4249 if (ibfd->xvec != &bfd_elf32_spu_vec)
4253 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4254 if (sec->linker_mark)
4256 if ((sec->flags & SEC_CODE) != 0)
4258 fixed_size -= sec->size;
4259 total_overlay_size += sec->size;
4261 else if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)
4262 && sec->output_section->owner == info->output_bfd
4263 && strncmp (sec->output_section->name, ".ovl.init", 9) == 0)
4264 fixed_size -= sec->size;
4265 if (count != old_count)
4266 bfd_arr[bfd_count++] = ibfd;
4269 /* Since the overlay link script selects sections by file name and
4270 section name, ensure that file names are unique. */
4273 bfd_boolean ok = TRUE;
4275 qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
4276 for (i = 1; i < bfd_count; ++i)
4277 if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
4279 if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
4281 if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
4282 info->callbacks->einfo (_("%s duplicated in %s\n"),
4283 bfd_arr[i]->filename,
4284 bfd_arr[i]->my_archive->filename);
4286 info->callbacks->einfo (_("%s duplicated\n"),
4287 bfd_arr[i]->filename);
4293 info->callbacks->einfo (_("sorry, no support for duplicate "
4294 "object files in auto-overlay script\n"));
4295 bfd_set_error (bfd_error_bad_value);
4301 fixed_size += htab->reserved;
4302 fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
4303 if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
4305 if (htab->params->ovly_flavour == ovly_soft_icache)
4307 /* Stubs in the non-icache area are bigger. */
4308 fixed_size += htab->non_ovly_stub * 16;
4309 /* Space for icache manager tables.
4310 a) Tag array, one quadword per cache line.
4311 - word 0: ia address of present line, init to zero. */
4312 fixed_size += 16 << htab->num_lines_log2;
4313 /* b) Rewrite "to" list, one quadword per cache line. */
4314 fixed_size += 16 << htab->num_lines_log2;
4315 /* c) Rewrite "from" list, one byte per outgoing branch (rounded up
4316 to a power-of-two number of full quadwords) per cache line. */
4317 fixed_size += 16 << (htab->fromelem_size_log2
4318 + htab->num_lines_log2);
4319 /* d) Pointer to __ea backing store (toe), 1 quadword. */
4324 /* Guess number of overlays. Assuming overlay buffer is on
4325 average only half full should be conservative. */
4326 ovlynum = (total_overlay_size * 2 * htab->params->num_lines
4327 / (htab->local_store - fixed_size));
4328 /* Space for _ovly_table[], _ovly_buf_table[] and toe. */
4329 fixed_size += ovlynum * 16 + 16 + 4 + 16;
4333 if (fixed_size + mos_param.max_overlay_size > htab->local_store)
4334 info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4335 "size of 0x%v exceeds local store\n"),
4336 (bfd_vma) fixed_size,
4337 (bfd_vma) mos_param.max_overlay_size);
4339 /* Now see if we should put some functions in the non-overlay area. */
4340 else if (fixed_size < htab->overlay_fixed)
4342 unsigned int max_fixed, lib_size;
4344 max_fixed = htab->local_store - mos_param.max_overlay_size;
4345 if (max_fixed > htab->overlay_fixed)
4346 max_fixed = htab->overlay_fixed;
4347 lib_size = max_fixed - fixed_size;
4348 lib_size = auto_ovl_lib_functions (info, lib_size);
4349 if (lib_size == (unsigned int) -1)
4351 fixed_size = max_fixed - lib_size;
4354 /* Build an array of sections, suitably sorted to place into
4356 ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
4357 if (ovly_sections == NULL)
4359 ovly_p = ovly_sections;
4360 if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
4362 count = (size_t) (ovly_p - ovly_sections) / 2;
4363 ovly_map = bfd_malloc (count * sizeof (*ovly_map));
4364 if (ovly_map == NULL)
4367 memset (&dummy_caller, 0, sizeof (dummy_caller));
4368 overlay_size = (htab->local_store - fixed_size) / htab->params->num_lines;
4369 if (htab->params->line_size != 0)
4370 overlay_size = htab->params->line_size;
4373 while (base < count)
4375 unsigned int size = 0, rosize = 0, roalign = 0;
4377 for (i = base; i < count; i++)
4379 asection *sec, *rosec;
4380 unsigned int tmp, rotmp;
4381 unsigned int num_stubs;
4382 struct call_info *call, *pasty;
4383 struct _spu_elf_section_data *sec_data;
4384 struct spu_elf_stack_info *sinfo;
4387 /* See whether we can add this section to the current
4388 overlay without overflowing our overlay buffer. */
4389 sec = ovly_sections[2 * i];
4390 tmp = align_power (size, sec->alignment_power) + sec->size;
4392 rosec = ovly_sections[2 * i + 1];
4395 rotmp = align_power (rotmp, rosec->alignment_power) + rosec->size;
4396 if (roalign < rosec->alignment_power)
4397 roalign = rosec->alignment_power;
4399 if (align_power (tmp, roalign) + rotmp > overlay_size)
4401 if (sec->segment_mark)
4403 /* Pasted sections must stay together, so add their
4405 struct call_info *pasty = find_pasted_call (sec);
4406 while (pasty != NULL)
4408 struct function_info *call_fun = pasty->fun;
4409 tmp = (align_power (tmp, call_fun->sec->alignment_power)
4410 + call_fun->sec->size);
4411 if (call_fun->rodata)
4413 rotmp = (align_power (rotmp,
4414 call_fun->rodata->alignment_power)
4415 + call_fun->rodata->size);
4416 if (roalign < rosec->alignment_power)
4417 roalign = rosec->alignment_power;
4419 for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
4420 if (pasty->is_pasted)
4424 if (align_power (tmp, roalign) + rotmp > overlay_size)
4427 /* If we add this section, we might need new overlay call
4428 stubs. Add any overlay section calls to dummy_call. */
4430 sec_data = spu_elf_section_data (sec);
4431 sinfo = sec_data->u.i.stack_info;
4432 for (k = 0; k < sinfo->num_fun; ++k)
4433 for (call = sinfo->fun[k].call_list; call; call = call->next)
4434 if (call->is_pasted)
4436 BFD_ASSERT (pasty == NULL);
4439 else if (call->fun->sec->linker_mark)
4441 if (!copy_callee (&dummy_caller, call))
4444 while (pasty != NULL)
4446 struct function_info *call_fun = pasty->fun;
4448 for (call = call_fun->call_list; call; call = call->next)
4449 if (call->is_pasted)
4451 BFD_ASSERT (pasty == NULL);
4454 else if (!copy_callee (&dummy_caller, call))
4458 /* Calculate call stub size. */
4460 for (call = dummy_caller.call_list; call; call = call->next)
4463 unsigned int stub_delta = 1;
4465 if (htab->params->ovly_flavour == ovly_soft_icache)
4466 stub_delta = call->count;
4467 num_stubs += stub_delta;
4469 /* If the call is within this overlay, we won't need a
4471 for (k = base; k < i + 1; k++)
4472 if (call->fun->sec == ovly_sections[2 * k])
4474 num_stubs -= stub_delta;
4478 if (htab->params->ovly_flavour == ovly_soft_icache
4479 && num_stubs > htab->params->max_branch)
4481 if (align_power (tmp, roalign) + rotmp
4482 + num_stubs * ovl_stub_size (htab->params) > overlay_size)
4490 info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
4491 ovly_sections[2 * i]->owner,
4492 ovly_sections[2 * i],
4493 ovly_sections[2 * i + 1] ? " + rodata" : "");
4494 bfd_set_error (bfd_error_bad_value);
4498 while (dummy_caller.call_list != NULL)
4500 struct call_info *call = dummy_caller.call_list;
4501 dummy_caller.call_list = call->next;
4507 ovly_map[base++] = ovlynum;
4510 script = htab->params->spu_elf_open_overlay_script ();
4512 if (fprintf (script, "SECTIONS\n{\n") <= 0)
4515 if (htab->params->ovly_flavour == ovly_soft_icache)
4517 if (fprintf (script,
4518 " .data.icache ALIGN (16) : { *(.ovtab) *(.data.icache) }\n"
4519 " . = ALIGN (%u);\n"
4520 " .ovl.init : { *(.ovl.init) }\n"
4521 " . = ABSOLUTE (ADDR (.ovl.init));\n",
4522 htab->params->line_size) <= 0)
4527 while (base < count)
4529 unsigned int indx = ovlynum - 1;
4530 unsigned int vma, lma;
4532 vma = (indx & (htab->params->num_lines - 1)) << htab->line_size_log2;
4533 lma = indx << htab->line_size_log2;
4535 if (fprintf (script, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4536 ": AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16) + %u) {\n",
4537 ovlynum, vma, lma) <= 0)
4540 base = print_one_overlay_section (script, base, count, ovlynum,
4541 ovly_map, ovly_sections, info);
4542 if (base == (unsigned) -1)
4545 if (fprintf (script, " }\n") <= 0)
4551 if (fprintf (script, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4552 1 << (htab->num_lines_log2 + htab->line_size_log2)) <= 0)
4557 if (fprintf (script,
4558 " . = ALIGN (16);\n"
4559 " .ovl.init : { *(.ovl.init) }\n"
4560 " . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
4563 for (region = 1; region <= htab->params->num_lines; region++)
4567 while (base < count && ovly_map[base] < ovlynum)
4575 /* We need to set lma since we are overlaying .ovl.init. */
4576 if (fprintf (script,
4577 " OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4582 if (fprintf (script, " OVERLAY :\n {\n") <= 0)
4586 while (base < count)
4588 if (fprintf (script, " .ovly%u {\n", ovlynum) <= 0)
4591 base = print_one_overlay_section (script, base, count, ovlynum,
4592 ovly_map, ovly_sections, info);
4593 if (base == (unsigned) -1)
4596 if (fprintf (script, " }\n") <= 0)
4599 ovlynum += htab->params->num_lines;
4600 while (base < count && ovly_map[base] < ovlynum)
4604 if (fprintf (script, " }\n") <= 0)
4611 free (ovly_sections);
4613 if (fprintf (script, "}\nINSERT BEFORE .text;\n") <= 0)
4615 if (fclose (script) != 0)
4618 if (htab->params->auto_overlay & AUTO_RELINK)
4619 (*htab->params->spu_elf_relink) ();
4624 bfd_set_error (bfd_error_system_call);
4626 info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
4630 /* Provide an estimate of total stack required. */
4633 spu_elf_stack_analysis (struct bfd_link_info *info)
4635 struct spu_link_hash_table *htab;
4636 struct _sum_stack_param sum_stack_param;
4638 if (!discover_functions (info))
4641 if (!build_call_tree (info))
4644 htab = spu_hash_table (info);
4645 if (htab->params->stack_analysis)
4647 info->callbacks->info (_("Stack size for call graph root nodes.\n"));
4648 info->callbacks->minfo (_("\nStack size for functions. "
4649 "Annotations: '*' max stack, 't' tail call\n"));
4652 sum_stack_param.emit_stack_syms = htab->params->emit_stack_syms;
4653 sum_stack_param.overall_stack = 0;
4654 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4657 if (htab->params->stack_analysis)
4658 info->callbacks->info (_("Maximum stack required is 0x%v\n"),
4659 (bfd_vma) sum_stack_param.overall_stack);
4663 /* Perform a final link. */
4666 spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
4668 struct spu_link_hash_table *htab = spu_hash_table (info);
4670 if (htab->params->auto_overlay)
4671 spu_elf_auto_overlay (info);
4673 if ((htab->params->stack_analysis
4674 || (htab->params->ovly_flavour == ovly_soft_icache
4675 && htab->params->lrlive_analysis))
4676 && !spu_elf_stack_analysis (info))
4677 info->callbacks->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4679 if (!spu_elf_build_stubs (info))
4680 info->callbacks->einfo ("%F%P: can not build overlay stubs: %E\n");
4682 return bfd_elf_final_link (output_bfd, info);
4685 /* Called when not normally emitting relocs, ie. !info->relocatable
4686 and !info->emitrelocations. Returns a count of special relocs
4687 that need to be emitted. */
4690 spu_elf_count_relocs (struct bfd_link_info *info, asection *sec)
4692 Elf_Internal_Rela *relocs;
4693 unsigned int count = 0;
4695 relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
4699 Elf_Internal_Rela *rel;
4700 Elf_Internal_Rela *relend = relocs + sec->reloc_count;
4702 for (rel = relocs; rel < relend; rel++)
4704 int r_type = ELF32_R_TYPE (rel->r_info);
4705 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4709 if (elf_section_data (sec)->relocs != relocs)
4716 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
4719 spu_elf_relocate_section (bfd *output_bfd,
4720 struct bfd_link_info *info,
4722 asection *input_section,
4724 Elf_Internal_Rela *relocs,
4725 Elf_Internal_Sym *local_syms,
4726 asection **local_sections)
4728 Elf_Internal_Shdr *symtab_hdr;
4729 struct elf_link_hash_entry **sym_hashes;
4730 Elf_Internal_Rela *rel, *relend;
4731 struct spu_link_hash_table *htab;
4734 bfd_boolean emit_these_relocs = FALSE;
4735 bfd_boolean is_ea_sym;
4737 unsigned int iovl = 0;
4739 htab = spu_hash_table (info);
4740 stubs = (htab->stub_sec != NULL
4741 && maybe_needs_stubs (input_section));
4742 iovl = overlay_index (input_section);
4743 ea = bfd_get_section_by_name (output_bfd, "._ea");
4744 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4745 sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
4748 relend = relocs + input_section->reloc_count;
4749 for (; rel < relend; rel++)
4752 reloc_howto_type *howto;
4753 unsigned int r_symndx;
4754 Elf_Internal_Sym *sym;
4756 struct elf_link_hash_entry *h;
4757 const char *sym_name;
4760 bfd_reloc_status_type r;
4761 bfd_boolean unresolved_reloc;
4763 enum _stub_type stub_type;
4765 r_symndx = ELF32_R_SYM (rel->r_info);
4766 r_type = ELF32_R_TYPE (rel->r_info);
4767 howto = elf_howto_table + r_type;
4768 unresolved_reloc = FALSE;
4773 if (r_symndx < symtab_hdr->sh_info)
4775 sym = local_syms + r_symndx;
4776 sec = local_sections[r_symndx];
4777 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
4778 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4782 if (sym_hashes == NULL)
4785 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4787 while (h->root.type == bfd_link_hash_indirect
4788 || h->root.type == bfd_link_hash_warning)
4789 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4792 if (h->root.type == bfd_link_hash_defined
4793 || h->root.type == bfd_link_hash_defweak)
4795 sec = h->root.u.def.section;
4797 || sec->output_section == NULL)
4798 /* Set a flag that will be cleared later if we find a
4799 relocation value for this symbol. output_section
4800 is typically NULL for symbols satisfied by a shared
4802 unresolved_reloc = TRUE;
4804 relocation = (h->root.u.def.value
4805 + sec->output_section->vma
4806 + sec->output_offset);
4808 else if (h->root.type == bfd_link_hash_undefweak)
4810 else if (info->unresolved_syms_in_objects == RM_IGNORE
4811 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4813 else if (!info->relocatable
4814 && !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
4817 err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4818 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
4819 if (!info->callbacks->undefined_symbol (info,
4820 h->root.root.string,
4823 rel->r_offset, err))
4827 sym_name = h->root.root.string;
4830 if (sec != NULL && elf_discarded_section (sec))
4832 /* For relocs against symbols from removed linkonce sections,
4833 or sections discarded by a linker script, we just want the
4834 section contents zeroed. Avoid any special processing. */
4835 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4841 if (info->relocatable)
4844 is_ea_sym = (ea != NULL
4846 && sec->output_section == ea);
4848 /* If this symbol is in an overlay area, we may need to relocate
4849 to the overlay stub. */
4850 addend = rel->r_addend;
4853 && (stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
4854 contents, info)) != no_stub)
4856 unsigned int ovl = 0;
4857 struct got_entry *g, **head;
4859 if (stub_type != nonovl_stub)
4863 head = &h->got.glist;
4865 head = elf_local_got_ents (input_bfd) + r_symndx;
4867 for (g = *head; g != NULL; g = g->next)
4868 if (htab->params->ovly_flavour == ovly_soft_icache
4870 && g->br_addr == (rel->r_offset
4871 + input_section->output_offset
4872 + input_section->output_section->vma))
4873 : g->addend == addend && (g->ovl == ovl || g->ovl == 0))
4878 relocation = g->stub_addr;
4883 /* For soft icache, encode the overlay index into addresses. */
4884 if (htab->params->ovly_flavour == ovly_soft_icache
4885 && (r_type == R_SPU_ADDR16_HI
4886 || r_type == R_SPU_ADDR32 || r_type == R_SPU_REL32)
4889 unsigned int ovl = overlay_index (sec);
4892 unsigned int set_id = ((ovl - 1) >> htab->num_lines_log2) + 1;
4893 relocation += set_id << 18;
4898 if (unresolved_reloc)
4900 else if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4904 /* ._ea is a special section that isn't allocated in SPU
4905 memory, but rather occupies space in PPU memory as
4906 part of an embedded ELF image. If this reloc is
4907 against a symbol defined in ._ea, then transform the
4908 reloc into an equivalent one without a symbol
4909 relative to the start of the ELF image. */
4910 rel->r_addend += (relocation
4912 + elf_section_data (ea)->this_hdr.sh_offset);
4913 rel->r_info = ELF32_R_INFO (0, r_type);
4915 emit_these_relocs = TRUE;
4919 unresolved_reloc = TRUE;
4921 if (unresolved_reloc)
4923 (*_bfd_error_handler)
4924 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
4926 bfd_get_section_name (input_bfd, input_section),
4927 (long) rel->r_offset,
4933 r = _bfd_final_link_relocate (howto,
4937 rel->r_offset, relocation, addend);
4939 if (r != bfd_reloc_ok)
4941 const char *msg = (const char *) 0;
4945 case bfd_reloc_overflow:
4946 if (!((*info->callbacks->reloc_overflow)
4947 (info, (h ? &h->root : NULL), sym_name, howto->name,
4948 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
4952 case bfd_reloc_undefined:
4953 if (!((*info->callbacks->undefined_symbol)
4954 (info, sym_name, input_bfd, input_section,
4955 rel->r_offset, TRUE)))
4959 case bfd_reloc_outofrange:
4960 msg = _("internal error: out of range error");
4963 case bfd_reloc_notsupported:
4964 msg = _("internal error: unsupported relocation error");
4967 case bfd_reloc_dangerous:
4968 msg = _("internal error: dangerous error");
4972 msg = _("internal error: unknown error");
4977 if (!((*info->callbacks->warning)
4978 (info, msg, sym_name, input_bfd, input_section,
4987 && emit_these_relocs
4988 && !info->emitrelocations)
4990 Elf_Internal_Rela *wrel;
4991 Elf_Internal_Shdr *rel_hdr;
4993 wrel = rel = relocs;
4994 relend = relocs + input_section->reloc_count;
4995 for (; rel < relend; rel++)
4999 r_type = ELF32_R_TYPE (rel->r_info);
5000 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
5003 input_section->reloc_count = wrel - relocs;
5004 /* Backflips for _bfd_elf_link_output_relocs. */
5005 rel_hdr = &elf_section_data (input_section)->rel_hdr;
5006 rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
5013 /* Adjust _SPUEAR_ syms to point at their overlay stubs. */
5016 spu_elf_output_symbol_hook (struct bfd_link_info *info,
5017 const char *sym_name ATTRIBUTE_UNUSED,
5018 Elf_Internal_Sym *sym,
5019 asection *sym_sec ATTRIBUTE_UNUSED,
5020 struct elf_link_hash_entry *h)
5022 struct spu_link_hash_table *htab = spu_hash_table (info);
5024 if (!info->relocatable
5025 && htab->stub_sec != NULL
5027 && (h->root.type == bfd_link_hash_defined
5028 || h->root.type == bfd_link_hash_defweak)
5030 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
5032 struct got_entry *g;
5034 for (g = h->got.glist; g != NULL; g = g->next)
5035 if (htab->params->ovly_flavour == ovly_soft_icache
5036 ? g->br_addr == g->stub_addr
5037 : g->addend == 0 && g->ovl == 0)
5039 sym->st_shndx = (_bfd_elf_section_from_bfd_section
5040 (htab->stub_sec[0]->output_section->owner,
5041 htab->stub_sec[0]->output_section));
5042 sym->st_value = g->stub_addr;
5050 static int spu_plugin = 0;
5053 spu_elf_plugin (int val)
5058 /* Set ELF header e_type for plugins. */
5061 spu_elf_post_process_headers (bfd *abfd,
5062 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5066 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5068 i_ehdrp->e_type = ET_DYN;
5072 /* We may add an extra PT_LOAD segment for .toe. We also need extra
5073 segments for overlays. */
5076 spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
5083 struct spu_link_hash_table *htab = spu_hash_table (info);
5084 extra = htab->num_overlays;
5090 sec = bfd_get_section_by_name (abfd, ".toe");
5091 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
5097 /* Remove .toe section from other PT_LOAD segments and put it in
5098 a segment of its own. Put overlays in separate segments too. */
5101 spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
5104 struct elf_segment_map *m, *m_overlay;
5105 struct elf_segment_map **p, **p_overlay;
5111 toe = bfd_get_section_by_name (abfd, ".toe");
5112 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
5113 if (m->p_type == PT_LOAD && m->count > 1)
5114 for (i = 0; i < m->count; i++)
5115 if ((s = m->sections[i]) == toe
5116 || spu_elf_section_data (s)->u.o.ovl_index != 0)
5118 struct elf_segment_map *m2;
5121 if (i + 1 < m->count)
5123 amt = sizeof (struct elf_segment_map);
5124 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
5125 m2 = bfd_zalloc (abfd, amt);
5128 m2->count = m->count - (i + 1);
5129 memcpy (m2->sections, m->sections + i + 1,
5130 m2->count * sizeof (m->sections[0]));
5131 m2->p_type = PT_LOAD;
5139 amt = sizeof (struct elf_segment_map);
5140 m2 = bfd_zalloc (abfd, amt);
5143 m2->p_type = PT_LOAD;
5145 m2->sections[0] = s;
5153 /* Some SPU ELF loaders ignore the PF_OVERLAY flag and just load all
5154 PT_LOAD segments. This can cause the .ovl.init section to be
5155 overwritten with the contents of some overlay segment. To work
5156 around this issue, we ensure that all PF_OVERLAY segments are
5157 sorted first amongst the program headers; this ensures that even
5158 with a broken loader, the .ovl.init section (which is not marked
5159 as PF_OVERLAY) will be placed into SPU local store on startup. */
5161 /* Move all overlay segments onto a separate list. */
5162 p = &elf_tdata (abfd)->segment_map;
5163 p_overlay = &m_overlay;
5166 if ((*p)->p_type == PT_LOAD && (*p)->count == 1
5167 && spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
5169 struct elf_segment_map *m = *p;
5172 p_overlay = &m->next;
5179 /* Re-insert overlay segments at the head of the segment map. */
5180 *p_overlay = elf_tdata (abfd)->segment_map;
5181 elf_tdata (abfd)->segment_map = m_overlay;
5186 /* Tweak the section type of .note.spu_name. */
5189 spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
5190 Elf_Internal_Shdr *hdr,
5193 if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
5194 hdr->sh_type = SHT_NOTE;
5198 /* Tweak phdrs before writing them out. */
5201 spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
5203 const struct elf_backend_data *bed;
5204 struct elf_obj_tdata *tdata;
5205 Elf_Internal_Phdr *phdr, *last;
5206 struct spu_link_hash_table *htab;
5213 bed = get_elf_backend_data (abfd);
5214 tdata = elf_tdata (abfd);
5216 count = tdata->program_header_size / bed->s->sizeof_phdr;
5217 htab = spu_hash_table (info);
5218 if (htab->num_overlays != 0)
5220 struct elf_segment_map *m;
5223 for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
5225 && (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
5227 /* Mark this as an overlay header. */
5228 phdr[i].p_flags |= PF_OVERLAY;
5230 if (htab->ovtab != NULL && htab->ovtab->size != 0
5231 && htab->params->ovly_flavour != ovly_soft_icache)
5233 bfd_byte *p = htab->ovtab->contents;
5234 unsigned int off = o * 16 + 8;
5236 /* Write file_off into _ovly_table. */
5237 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
5240 /* Soft-icache has its file offset put in .ovl.init. */
5241 if (htab->init != NULL && htab->init->size != 0)
5243 bfd_vma val = elf_section_data (htab->ovl_sec[0])->this_hdr.sh_offset;
5245 bfd_put_32 (htab->init->owner, val, htab->init->contents + 4);
5249 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5250 of 16. This should always be possible when using the standard
5251 linker scripts, but don't create overlapping segments if
5252 someone is playing games with linker scripts. */
5254 for (i = count; i-- != 0; )
5255 if (phdr[i].p_type == PT_LOAD)
5259 adjust = -phdr[i].p_filesz & 15;
5262 && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
5265 adjust = -phdr[i].p_memsz & 15;
5268 && phdr[i].p_filesz != 0
5269 && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
5270 && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
5273 if (phdr[i].p_filesz != 0)
5277 if (i == (unsigned int) -1)
5278 for (i = count; i-- != 0; )
5279 if (phdr[i].p_type == PT_LOAD)
5283 adjust = -phdr[i].p_filesz & 15;
5284 phdr[i].p_filesz += adjust;
5286 adjust = -phdr[i].p_memsz & 15;
5287 phdr[i].p_memsz += adjust;
5293 #define TARGET_BIG_SYM bfd_elf32_spu_vec
5294 #define TARGET_BIG_NAME "elf32-spu"
5295 #define ELF_ARCH bfd_arch_spu
5296 #define ELF_MACHINE_CODE EM_SPU
5297 /* This matches the alignment need for DMA. */
5298 #define ELF_MAXPAGESIZE 0x80
5299 #define elf_backend_rela_normal 1
5300 #define elf_backend_can_gc_sections 1
5302 #define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
5303 #define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
5304 #define elf_info_to_howto spu_elf_info_to_howto
5305 #define elf_backend_count_relocs spu_elf_count_relocs
5306 #define elf_backend_relocate_section spu_elf_relocate_section
5307 #define elf_backend_symbol_processing spu_elf_backend_symbol_processing
5308 #define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
5309 #define elf_backend_object_p spu_elf_object_p
5310 #define bfd_elf32_new_section_hook spu_elf_new_section_hook
5311 #define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
5313 #define elf_backend_additional_program_headers spu_elf_additional_program_headers
5314 #define elf_backend_modify_segment_map spu_elf_modify_segment_map
5315 #define elf_backend_modify_program_headers spu_elf_modify_program_headers
5316 #define elf_backend_post_process_headers spu_elf_post_process_headers
5317 #define elf_backend_fake_sections spu_elf_fake_sections
5318 #define elf_backend_special_sections spu_elf_special_sections
5319 #define bfd_elf32_bfd_final_link spu_elf_final_link
5321 #include "elf32-target.h"