projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* emultempl/ppc32elf.em (ppc_before_allocation): Turn on
[deliverable/binutils-gdb.git] / bfd / elf32-spu.c
CommitLineData
e9f53129
AM		 1/* SPU specific support for 32-bit ELF
2
cd4a7468 3 Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
e9f53129
AM		 4
5 This file is part of BFD, the Binary File Descriptor library.
6
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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
e9f53129
AM		 10 (at your option) any later version.
11
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.
16
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. */
20
e9f53129 21#include "sysdep.h"
9dcc4794 22#include "libiberty.h"
3db64b00 23#include "bfd.h"
e9f53129
AM		 24#include "bfdlink.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
27#include "elf/spu.h"
28#include "elf32-spu.h"
29
30/* We use RELA style relocs. Don't define USE_REL. */
31
32static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
33 void *, asection *,
34 bfd *, char **);
35
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. */
38
39static 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),
b427ea91 58 HOWTO (R_SPU_ADDR32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
e9f53129
AM		 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),
b427ea91 79 HOWTO (R_SPU_REL32, 0, 2, 32, TRUE, 0, complain_overflow_dont,
e9f53129
AM		 80 bfd_elf_generic_reloc, "SPU_REL32",
81 FALSE, 0, 0xffffffff, TRUE),
4f4416b5
AM		 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),
b427ea91 85 HOWTO (R_SPU_PPU32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
ece5ef60
AM		 86 bfd_elf_generic_reloc, "SPU_PPU32",
87 FALSE, 0, 0xffffffff, FALSE),
b427ea91 88 HOWTO (R_SPU_PPU64, 0, 4, 64, FALSE, 0, complain_overflow_dont,
ece5ef60
AM		 89 bfd_elf_generic_reloc, "SPU_PPU64",
90 FALSE, 0, -1, FALSE),
e9f53129
AM		 91};
92
93static struct bfd_elf_special_section const spu_elf_special_sections[] = {
8374f9d4 94 { "._ea", 4, 0, SHT_PROGBITS, SHF_WRITE },
e9f53129
AM		 95 { ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
96 { NULL, 0, 0, 0, 0 }
97};
98
99static enum elf_spu_reloc_type
100spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
101{
102 switch (code)
103 {
104 default:
105 return R_SPU_NONE;
106 case BFD_RELOC_SPU_IMM10W:
107 return R_SPU_ADDR10;
108 case BFD_RELOC_SPU_IMM16W:
109 return R_SPU_ADDR16;
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:
115 return R_SPU_ADDR18;
116 case BFD_RELOC_SPU_PCREL16:
117 return R_SPU_REL16;
118 case BFD_RELOC_SPU_IMM7:
119 return R_SPU_ADDR7;
120 case BFD_RELOC_SPU_IMM8:
121 return R_SPU_NONE;
122 case BFD_RELOC_SPU_PCREL9a:
123 return R_SPU_REL9;
124 case BFD_RELOC_SPU_PCREL9b:
125 return R_SPU_REL9I;
126 case BFD_RELOC_SPU_IMM10:
127 return R_SPU_ADDR10I;
128 case BFD_RELOC_SPU_IMM16:
129 return R_SPU_ADDR16I;
130 case BFD_RELOC_32:
131 return R_SPU_ADDR32;
132 case BFD_RELOC_32_PCREL:
133 return R_SPU_REL32;
ece5ef60
AM		 134 case BFD_RELOC_SPU_PPU32:
135 return R_SPU_PPU32;
136 case BFD_RELOC_SPU_PPU64:
137 return R_SPU_PPU64;
e9f53129
AM		 138 }
139}
140
141static void
142spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
143 arelent *cache_ptr,
144 Elf_Internal_Rela *dst)
145{
146 enum elf_spu_reloc_type r_type;
147
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];
151}
152
153static reloc_howto_type *
154spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
155 bfd_reloc_code_real_type code)
156{
b16f296e
AM		 157 enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
158
159 if (r_type == R_SPU_NONE)
160 return NULL;
161
162 return elf_howto_table + r_type;
e9f53129
AM		 163}
164
157090f7
AM		 165static reloc_howto_type *
166spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
167 const char *r_name)
168{
169 unsigned int i;
170
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];
175
176 return NULL;
177}
178
e9f53129
AM		 179/* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
180
181static bfd_reloc_status_type
182spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
183 void *data, asection *input_section,
184 bfd *output_bfd, char **error_message)
185{
186 bfd_size_type octets;
187 bfd_vma val;
188 long insn;
189
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
192 link time. */
193 if (output_bfd != NULL)
194 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
195 input_section, output_bfd, error_message);
196
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);
200
201 /* Get symbol value. */
202 val = 0;
203 if (!bfd_is_com_section (symbol->section))
204 val = symbol->value;
205 if (symbol->section->output_section)
206 val += symbol->section->output_section->vma;
207
208 val += reloc_entry->addend;
209
210 /* Make it pc-relative. */
211 val -= input_section->output_section->vma + input_section->output_offset;
212
213 val >>= 2;
214 if (val + 256 >= 512)
215 return bfd_reloc_overflow;
216
217 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
218
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);
225 return bfd_reloc_ok;
226}
227
228static bfd_boolean
229spu_elf_new_section_hook (bfd *abfd, asection *sec)
230{
231 if (!sec->used_by_bfd)
232 {
233 struct _spu_elf_section_data *sdata;
234
235 sdata = bfd_zalloc (abfd, sizeof (*sdata));
236 if (sdata == NULL)
237 return FALSE;
238 sec->used_by_bfd = sdata;
239 }
240
241 return _bfd_elf_new_section_hook (abfd, sec);
242}
243
124b52c6
AM		 244/* Set up overlay info for executables. */
245
246static bfd_boolean
247spu_elf_object_p (bfd *abfd)
248{
249 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
250 {
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;
255
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)
258 {
259 unsigned int j;
260
261 ++num_ovl;
262 if (last_phdr == NULL
263 || ((last_phdr->p_vaddr ^ phdr->p_vaddr) & 0x3ffff) != 0)
264 ++num_buf;
265 last_phdr = phdr;
266 for (j = 1; j < elf_numsections (abfd); j++)
267 {
268 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[j];
269
270 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (shdr, phdr))
271 {
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;
275 }
276 }
277 }
278 }
279 return TRUE;
280}
281
e9f53129
AM		 282/* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
283 strip --strip-unneeded will not remove them. */
284
285static void
286spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
287{
288 if (sym->name != NULL
289 && sym->section != bfd_abs_section_ptr
290 && strncmp (sym->name, "_EAR_", 5) == 0)
291 sym->flags |= BSF_KEEP;
292}
293
294/* SPU ELF linker hash table. */
295
296struct spu_link_hash_table
297{
298 struct elf_link_hash_table elf;
299
64615358
AM		 300 struct spu_elf_params *params;
301
e9f53129 302 /* Shortcuts to overlay sections. */
e9f53129 303 asection *ovtab;
cd4a7468 304 asection *init;
47f6dab9
AM		 305 asection *toe;
306 asection **ovl_sec;
307
308 /* Count of stubs in each overlay section. */
309 unsigned int *stub_count;
310
311 /* The stub section for each overlay section. */
312 asection **stub_sec;
e9f53129 313
a7e11ee1 314 struct elf_link_hash_entry *ovly_entry[2];
e9f53129 315
e9f53129
AM		 316 /* Number of overlay buffers. */
317 unsigned int num_buf;
318
319 /* Total number of overlays. */
320 unsigned int num_overlays;
321
cd4a7468
AM		 322 /* For soft icache. */
323 unsigned int line_size_log2;
324 unsigned int num_lines_log2;
97fc8d84 325 unsigned int fromelem_size_log2;
cd4a7468 326
9dcc4794
AM		 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;
99302af9
AM		 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;
9dcc4794
AM		 339 /* Count of overlay stubs needed in non-overlay area. */
340 unsigned int non_ovly_stub;
341
e9f53129 342 /* Set on error. */
47f6dab9 343 unsigned int stub_err : 1;
e9f53129
AM		 344};
345
47f6dab9 346/* Hijack the generic got fields for overlay stub accounting. */
e9f53129 347
47f6dab9 348struct got_entry
e9f53129 349{
47f6dab9
AM		 350 struct got_entry *next;
351 unsigned int ovl;
cd4a7468
AM		 352 union {
353 bfd_vma addend;
354 bfd_vma br_addr;
355 };
47f6dab9 356 bfd_vma stub_addr;
e9f53129
AM		 357};
358
47f6dab9
AM		 359#define spu_hash_table(p) \
360 ((struct spu_link_hash_table *) ((p)->hash))
e9f53129 361
64615358
AM		 362struct call_info
363{
364 struct function_info *fun;
365 struct call_info *next;
366 unsigned int count;
367 unsigned int max_depth;
368 unsigned int is_tail : 1;
369 unsigned int is_pasted : 1;
5ebe2858 370 unsigned int broken_cycle : 1;
cd4a7468 371 unsigned int priority : 13;
64615358
AM		 372};
373
374struct function_info
375{
376 /* List of functions called. Also branches to hot/cold part of
377 function. */
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. */
382 union {
383 Elf_Internal_Sym *sym;
384 struct elf_link_hash_entry *h;
385 } u;
386 /* Function section. */
387 asection *sec;
388 asection *rodata;
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. */
393 bfd_vma lo, hi;
cd4a7468
AM		 394 /* Offset where we found a store of lr, or -1 if none found. */
395 bfd_vma lr_store;
396 /* Offset where we found the stack adjustment insn. */
397 bfd_vma sp_adjust;
64615358
AM		 398 /* Stack usage. */
399 int stack;
400 /* Distance from root of call tree. Tail and hot/cold branches
401 count as one deeper. We aren't counting stack frames here. */
402 unsigned int depth;
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;
420};
421
422struct spu_elf_stack_info
423{
424 int num_fun;
425 int max_fun;
426 /* Variable size array describing functions, one per contiguous
427 address range belonging to a function. */
428 struct function_info fun[1];
429};
430
cd4a7468
AM		 431static struct function_info *find_function (asection *, bfd_vma,
432 struct bfd_link_info *);
433
e9f53129
AM		 434/* Create a spu ELF linker hash table. */
435
436static struct bfd_link_hash_table *
437spu_elf_link_hash_table_create (bfd *abfd)
438{
439 struct spu_link_hash_table *htab;
440
441 htab = bfd_malloc (sizeof (*htab));
442 if (htab == NULL)
443 return NULL;
444
445 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
446 _bfd_elf_link_hash_newfunc,
447 sizeof (struct elf_link_hash_entry)))
448 {
449 free (htab);
450 return NULL;
451 }
452
47f6dab9
AM		 453 memset (&htab->ovtab, 0,
454 sizeof (*htab) - offsetof (struct spu_link_hash_table, ovtab));
e9f53129 455
47f6dab9
AM		 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;
e9f53129
AM		 460 return &htab->elf.root;
461}
462
64615358
AM		 463void
464spu_elf_setup (struct bfd_link_info *info, struct spu_elf_params *params)
465{
97fc8d84
UW		 466 bfd_vma max_branch_log2;
467
64615358
AM		 468 struct spu_link_hash_table *htab = spu_hash_table (info);
469 htab->params = params;
cd4a7468
AM		 470 htab->line_size_log2 = bfd_log2 (htab->params->line_size);
471 htab->num_lines_log2 = bfd_log2 (htab->params->num_lines);
97fc8d84
UW		 472
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;
64615358
AM		 478}
479
e9f53129
AM		 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. */
483
484static bfd_boolean
485get_sym_h (struct elf_link_hash_entry **hp,
486 Elf_Internal_Sym **symp,
487 asection **symsecp,
488 Elf_Internal_Sym **locsymsp,
489 unsigned long r_symndx,
490 bfd *ibfd)
491{
492 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
493
494 if (r_symndx >= symtab_hdr->sh_info)
495 {
496 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
497 struct elf_link_hash_entry *h;
498
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;
503
504 if (hp != NULL)
505 *hp = h;
506
507 if (symp != NULL)
508 *symp = NULL;
509
510 if (symsecp != NULL)
511 {
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;
516 *symsecp = symsec;
517 }
518 }
519 else
520 {
521 Elf_Internal_Sym *sym;
522 Elf_Internal_Sym *locsyms = *locsymsp;
523
524 if (locsyms == NULL)
525 {
526 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
527 if (locsyms == NULL)
1f27ab8d
AM		 528 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
529 symtab_hdr->sh_info,
530 0, NULL, NULL, NULL);
e9f53129
AM		 531 if (locsyms == NULL)
532 return FALSE;
533 *locsymsp = locsyms;
534 }
535 sym = locsyms + r_symndx;
536
537 if (hp != NULL)
538 *hp = NULL;
539
540 if (symp != NULL)
541 *symp = sym;
542
543 if (symsecp != NULL)
cb33740c 544 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
e9f53129 545 }
49fa1e15 546
e9f53129
AM		 547 return TRUE;
548}
549
e9f53129
AM		 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. */
552
553bfd_boolean
64615358 554spu_elf_create_sections (struct bfd_link_info *info)
e9f53129
AM		 555{
556 bfd *ibfd;
557
58eb693e 558 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
e9f53129
AM		 559 if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
560 break;
561
562 if (ibfd == NULL)
563 {
564 /* Make SPU_PTNOTE_SPUNAME section. */
565 asection *s;
566 size_t name_len;
567 size_t size;
568 bfd_byte *data;
569 flagword flags;
570
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);
574 if (s == NULL
575 || !bfd_set_section_alignment (ibfd, s, 4))
576 return FALSE;
577
c65be8d7 578 name_len = strlen (bfd_get_filename (info->output_bfd)) + 1;
e9f53129
AM		 579 size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
580 size += (name_len + 3) & -4;
581
582 if (!bfd_set_section_size (ibfd, s, size))
583 return FALSE;
584
585 data = bfd_zalloc (ibfd, size);
586 if (data == NULL)
587 return FALSE;
588
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),
c65be8d7 594 bfd_get_filename (info->output_bfd), name_len);
e9f53129
AM		 595 s->contents = data;
596 }
597
598 return TRUE;
599}
600
e9f53129
AM		 601/* qsort predicate to sort sections by vma. */
602
603static int
604sort_sections (const void *a, const void *b)
605{
606 const asection *const *s1 = a;
607 const asection *const *s2 = b;
608 bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
609
610 if (delta != 0)
611 return delta < 0 ? -1 : 1;
612
613 return (*s1)->index - (*s2)->index;
614}
615
ad2adbc8
AM		 616/* Identify overlays in the output bfd, and number them.
617 Returns 0 on error, 1 if no overlays, 2 if overlays. */
e9f53129 618
ad2adbc8 619int
c65be8d7 620spu_elf_find_overlays (struct bfd_link_info *info)
e9f53129
AM		 621{
622 struct spu_link_hash_table *htab = spu_hash_table (info);
623 asection **alloc_sec;
624 unsigned int i, n, ovl_index, num_buf;
625 asection *s;
626 bfd_vma ovl_end;
ad2adbc8
AM		 627 static const char *const entry_names[2][2] = {
628 { "__ovly_load", "__icache_br_handler" },
629 { "__ovly_return", "__icache_call_handler" }
630 };
e9f53129 631
c65be8d7 632 if (info->output_bfd->section_count < 2)
ad2adbc8 633 return 1;
e9f53129 634
c65be8d7
AM		 635 alloc_sec
636 = bfd_malloc (info->output_bfd->section_count * sizeof (*alloc_sec));
e9f53129 637 if (alloc_sec == NULL)
ad2adbc8 638 return 0;
e9f53129
AM		 639
640 /* Pick out all the alloced sections. */
c65be8d7 641 for (n = 0, s = info->output_bfd->sections; s != NULL; s = s->next)
e9f53129
AM		 642 if ((s->flags & SEC_ALLOC) != 0
643 && (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
644 && s->size != 0)
645 alloc_sec[n++] = s;
646
647 if (n == 0)
648 {
649 free (alloc_sec);
ad2adbc8 650 return 1;
e9f53129
AM		 651 }
652
653 /* Sort them by vma. */
654 qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
655
e9f53129 656 ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
cd4a7468 657 if (htab->params->ovly_flavour == ovly_soft_icache)
e9f53129 658 {
cd4a7468
AM		 659 /* Look for an overlapping vma to find the first overlay section. */
660 bfd_vma vma_start = 0;
661 bfd_vma lma_start = 0;
662
663 for (i = 1; i < n; i++)
e9f53129 664 {
cd4a7468
AM		 665 s = alloc_sec[i];
666 if (s->vma < ovl_end)
667 {
668 asection *s0 = alloc_sec[i - 1];
669 vma_start = s0->vma;
77ae44b0
AM		 670 if (strncmp (s0->name, ".ovl.init", 9) != 0)
671 lma_start = s0->lma;
672 else
673 lma_start = s->lma;
cd4a7468
AM		 674 ovl_end = (s0->vma
675 + ((bfd_vma) 1
676 << (htab->num_lines_log2 + htab->line_size_log2)));
677 --i;
678 break;
679 }
680 else
681 ovl_end = s->vma + s->size;
682 }
e9f53129 683
cd4a7468
AM		 684 /* Now find any sections within the cache area. */
685 for (ovl_index = 0, num_buf = 0; i < n; i++)
686 {
687 s = alloc_sec[i];
688 if (s->vma >= ovl_end)
689 break;
690
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)
e9f53129 696 {
cd4a7468
AM		 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)))
700 {
701 info->callbacks->einfo (_("%X%P: overlay section %A "
702 "does not start on a cache line.\n"),
703 s);
3209bffa 704 bfd_set_error (bfd_error_bad_value);
ad2adbc8 705 return 0;
cd4a7468
AM		 706 }
707 else if (s->size > htab->params->line_size)
708 {
709 info->callbacks->einfo (_("%X%P: overlay section %A "
710 "is larger than a cache line.\n"),
711 s);
3209bffa 712 bfd_set_error (bfd_error_bad_value);
ad2adbc8 713 return 0;
cd4a7468
AM		 714 }
715
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;
e9f53129 720 }
cd4a7468
AM		 721 }
722
723 /* Ensure there are no more overlay sections. */
724 for ( ; i < n; i++)
725 {
726 s = alloc_sec[i];
727 if (s->vma < ovl_end)
e9f53129 728 {
cd4a7468
AM		 729 info->callbacks->einfo (_("%X%P: overlay section %A "
730 "is not in cache area.\n"),
731 alloc_sec[i-1]);
3209bffa 732 bfd_set_error (bfd_error_bad_value);
ad2adbc8 733 return 0;
e9f53129 734 }
cd4a7468
AM		 735 else
736 ovl_end = s->vma + s->size;
737 }
738 }
739 else
740 {
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++)
744 {
745 s = alloc_sec[i];
746 if (s->vma < ovl_end)
747 {
748 asection *s0 = alloc_sec[i - 1];
749
750 if (spu_elf_section_data (s0)->u.o.ovl_index == 0)
751 {
752 ++num_buf;
753 if (strncmp (s0->name, ".ovl.init", 9) != 0)
754 {
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;
758 }
759 else
760 ovl_end = s->vma + s->size;
761 }
762 if (strncmp (s->name, ".ovl.init", 9) != 0)
763 {
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)
768 {
769 info->callbacks->einfo (_("%X%P: overlay sections %A "
770 "and %A do not start at the "
771 "same address.\n"),
772 s0, s);
3209bffa 773 bfd_set_error (bfd_error_bad_value);
ad2adbc8 774 return 0;
cd4a7468
AM		 775 }
776 if (ovl_end < s->vma + s->size)
777 ovl_end = s->vma + s->size;
778 }
779 }
780 else
47f6dab9 781 ovl_end = s->vma + s->size;
e9f53129 782 }
e9f53129
AM		 783 }
784
785 htab->num_overlays = ovl_index;
786 htab->num_buf = num_buf;
47f6dab9 787 htab->ovl_sec = alloc_sec;
ad2adbc8
AM		 788
789 if (ovl_index == 0)
790 return 1;
791
792 for (i = 0; i < 2; i++)
793 {
794 const char *name;
795 struct elf_link_hash_entry *h;
796
797 name = entry_names[i][htab->params->ovly_flavour];
798 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
799 if (h == NULL)
800 return 0;
801
802 if (h->root.type == bfd_link_hash_new)
803 {
804 h->root.type = bfd_link_hash_undefined;
805 h->ref_regular = 1;
806 h->ref_regular_nonweak = 1;
807 h->non_elf = 0;
808 }
809 htab->ovly_entry[i] = h;
810 }
811
812 return 2;
e9f53129
AM		 813}
814
cd4a7468
AM		 815/* Non-zero to use bra in overlay stubs rather than br. */
816#define BRA_STUBS 0
817
818#define BRA 0x30000000
819#define BRASL 0x31000000
47f6dab9 820#define BR 0x32000000
cd4a7468 821#define BRSL 0x33000000
e9f53129 822#define NOP 0x40200000
47f6dab9
AM		 823#define LNOP 0x00200000
824#define ILA 0x42000000
e9f53129 825
49fa1e15 826/* Return true for all relative and absolute branch instructions.
e9f53129
AM		 827 bra 00110000 0..
828 brasl 00110001 0..
829 br 00110010 0..
830 brsl 00110011 0..
831 brz 00100000 0..
832 brnz 00100001 0..
833 brhz 00100010 0..
49fa1e15
AM		 834 brhnz 00100011 0.. */
835
836static bfd_boolean
837is_branch (const unsigned char *insn)
838{
839 return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
840}
841
fad9eaf0
AM		 842/* Return true for all indirect branch instructions.
843 bi 00110101 000
844 bisl 00110101 001
845 iret 00110101 010
846 bisled 00110101 011
847 biz 00100101 000
848 binz 00100101 001
849 bihz 00100101 010
850 bihnz 00100101 011 */
851
852static bfd_boolean
853is_indirect_branch (const unsigned char *insn)
854{
855 return (insn[0] & 0xef) == 0x25 && (insn[1] & 0x80) == 0;
856}
857
49fa1e15 858/* Return true for branch hint instructions.
e9f53129
AM		 859 hbra 0001000..
860 hbrr 0001001.. */
861
862static bfd_boolean
49fa1e15 863is_hint (const unsigned char *insn)
e9f53129 864{
49fa1e15 865 return (insn[0] & 0xfc) == 0x10;
e9f53129
AM		 866}
867
fdba2fcd 868/* True if INPUT_SECTION might need overlay stubs. */
aa7a0635
AM		 869
870static bfd_boolean
64615358 871maybe_needs_stubs (asection *input_section)
fdba2fcd
AM		 872{
873 /* No stubs for debug sections and suchlike. */
874 if ((input_section->flags & SEC_ALLOC) == 0)
875 return FALSE;
876
877 /* No stubs for link-once sections that will be discarded. */
64615358 878 if (input_section->output_section == bfd_abs_section_ptr)
fdba2fcd
AM		 879 return FALSE;
880
881 /* Don't create stubs for .eh_frame references. */
882 if (strcmp (input_section->name, ".eh_frame") == 0)
883 return FALSE;
884
885 return TRUE;
886}
887
888enum _stub_type
889{
890 no_stub,
cd4a7468
AM		 891 call_ovl_stub,
892 br000_ovl_stub,
893 br001_ovl_stub,
894 br010_ovl_stub,
895 br011_ovl_stub,
896 br100_ovl_stub,
897 br101_ovl_stub,
898 br110_ovl_stub,
899 br111_ovl_stub,
fdba2fcd
AM		 900 nonovl_stub,
901 stub_error
902};
903
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. */
906
907static enum _stub_type
908needs_ovl_stub (struct elf_link_hash_entry *h,
909 Elf_Internal_Sym *sym,
aa7a0635
AM		 910 asection *sym_sec,
911 asection *input_section,
fdba2fcd
AM		 912 Elf_Internal_Rela *irela,
913 bfd_byte *contents,
914 struct bfd_link_info *info)
aa7a0635 915{
fdba2fcd
AM		 916 struct spu_link_hash_table *htab = spu_hash_table (info);
917 enum elf_spu_reloc_type r_type;
918 unsigned int sym_type;
cd4a7468 919 bfd_boolean branch, hint, call;
fdba2fcd 920 enum _stub_type ret = no_stub;
cd4a7468 921 bfd_byte insn[4];
aa7a0635
AM		 922
923 if (sym_sec == NULL
64615358 924 || sym_sec->output_section == bfd_abs_section_ptr
2c67c5f3 925 || spu_elf_section_data (sym_sec->output_section) == NULL)
fdba2fcd 926 return ret;
aa7a0635 927
fdba2fcd
AM		 928 if (h != NULL)
929 {
930 /* Ensure no stubs for user supplied overlay manager syms. */
ad2adbc8 931 if (h == htab->ovly_entry[0] || h == htab->ovly_entry[1])
fdba2fcd
AM		 932 return ret;
933
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] == '@'))
cd4a7468 939 ret = call_ovl_stub;
fdba2fcd 940 }
aa7a0635 941
fdba2fcd
AM		 942 if (h != NULL)
943 sym_type = h->type;
944 else
945 sym_type = ELF_ST_TYPE (sym->st_info);
946
947 r_type = ELF32_R_TYPE (irela->r_info);
948 branch = FALSE;
cd4a7468
AM		 949 hint = FALSE;
950 call = FALSE;
fdba2fcd
AM		 951 if (r_type == R_SPU_REL16 || r_type == R_SPU_ADDR16)
952 {
fdba2fcd
AM		 953 if (contents == NULL)
954 {
955 contents = insn;
956 if (!bfd_get_section_contents (input_section->owner,
957 input_section,
958 contents,
959 irela->r_offset, 4))
960 return stub_error;
961 }
962 else
963 contents += irela->r_offset;
964
cd4a7468
AM		 965 branch = is_branch (contents);
966 hint = is_hint (contents);
967 if (branch || hint)
fdba2fcd 968 {
cd4a7468
AM		 969 call = (contents[0] & 0xfd) == 0x31;
970 if (call
fdba2fcd 971 && sym_type != STT_FUNC
9dcc4794 972 && contents != insn)
fdba2fcd
AM		 973 {
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;
981
982 if (h != NULL)
983 sym_name = h->root.root.string;
984 else
985 {
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,
989 symtab_hdr,
990 sym,
991 sym_sec);
992 }
993 (*_bfd_error_handler) (_("warning: call to non-function"
994 " symbol %s defined in %B"),
995 sym_sec->owner, sym_name);
996
997 }
998 }
999 }
1000
cd4a7468
AM		 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))
1005 return no_stub;
1006
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)
fdba2fcd 1010 return ret;
aa7a0635
AM		 1011
1012 /* A reference from some other section to a symbol in an overlay
1013 section needs a stub. */
47f6dab9
AM		 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)
cd4a7468 1016 {
be3e406d
UW		 1017 unsigned int lrlive = 0;
1018 if (branch)
1019 lrlive = (contents[1] & 0x70) >> 4;
1020
1021 if (!lrlive && (call || sym_type == STT_FUNC))
cd4a7468
AM		 1022 ret = call_ovl_stub;
1023 else
be3e406d 1024 ret = br000_ovl_stub + lrlive;
cd4a7468 1025 }
aa7a0635
AM		 1026
1027 /* If this insn isn't a branch then we are possibly taking the
cd4a7468
AM		 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)
1033 ret = nonovl_stub;
1034
1035 return ret;
aa7a0635
AM		 1036}
1037
47f6dab9
AM		 1038static bfd_boolean
1039count_stub (struct spu_link_hash_table *htab,
1040 bfd *ibfd,
1041 asection *isec,
fdba2fcd 1042 enum _stub_type stub_type,
47f6dab9
AM		 1043 struct elf_link_hash_entry *h,
1044 const Elf_Internal_Rela *irela)
1045{
1046 unsigned int ovl = 0;
1047 struct got_entry *g, **head;
4a628337 1048 bfd_vma addend;
47f6dab9
AM		 1049
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. */
fdba2fcd 1055 if (stub_type != nonovl_stub)
47f6dab9
AM		 1056 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1057
1058 if (h != NULL)
1059 head = &h->got.glist;
1060 else
1061 {
1062 if (elf_local_got_ents (ibfd) == NULL)
1063 {
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)
1068 return FALSE;
1069 }
1070 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1071 }
1072
cd4a7468
AM		 1073 if (htab->params->ovly_flavour == ovly_soft_icache)
1074 {
1075 htab->stub_count[ovl] += 1;
1076 return TRUE;
1077 }
1078
4a628337
AM		 1079 addend = 0;
1080 if (irela != NULL)
1081 addend = irela->r_addend;
47f6dab9
AM		 1082
1083 if (ovl == 0)
1084 {
1085 struct got_entry *gnext;
1086
4a628337
AM		 1087 for (g = *head; g != NULL; g = g->next)
1088 if (g->addend == addend && g->ovl == 0)
1089 break;
1090
1091 if (g == NULL)
47f6dab9 1092 {
4a628337
AM		 1093 /* Need a new non-overlay area stub. Zap other stubs. */
1094 for (g = *head; g != NULL; g = gnext)
1095 {
1096 gnext = g->next;
1097 if (g->addend == addend)
1098 {
1099 htab->stub_count[g->ovl] -= 1;
1100 free (g);
1101 }
1102 }
47f6dab9
AM		 1103 }
1104 }
1105 else
1106 {
4a628337
AM		 1107 for (g = *head; g != NULL; g = g->next)
1108 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
47f6dab9
AM		 1109 break;
1110 }
1111
1112 if (g == NULL)
1113 {
1114 g = bfd_malloc (sizeof *g);
1115 if (g == NULL)
1116 return FALSE;
1117 g->ovl = ovl;
4a628337 1118 g->addend = addend;
47f6dab9
AM		 1119 g->stub_addr = (bfd_vma) -1;
1120 g->next = *head;
1121 *head = g;
1122
1123 htab->stub_count[ovl] += 1;
1124 }
1125
1126 return TRUE;
1127}
1128
64615358 1129/* Support two sizes of overlay stubs, a slower more compact stub of two
a7e11ee1
AM		 1130 intructions, and a faster stub of four instructions.
1131 Soft-icache stubs are four or eight words. */
1132
1133static unsigned int
1134ovl_stub_size (struct spu_elf_params *params)
1135{
1136 return 16 << params->ovly_flavour >> params->compact_stub;
1137}
64615358
AM		 1138
1139static unsigned int
a7e11ee1 1140ovl_stub_size_log2 (struct spu_elf_params *params)
64615358 1141{
a7e11ee1 1142 return 4 + params->ovly_flavour - params->compact_stub;
64615358
AM		 1143}
1144
47f6dab9
AM		 1145/* Two instruction overlay stubs look like:
1146
1147 brsl $75,__ovly_load
1148 .word target_ovl_and_address
1149
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.
1152
1153 Four instruction overlay stubs look like:
1154
1155 ila $78,ovl_number
1156 lnop
1157 ila $79,target_address
cd4a7468
AM		 1158 br __ovly_load
1159
1160 Software icache stubs are:
1161
1162 .word target_index
1163 .word target_ia;
1164 .word lrlive_branchlocalstoreaddr;
1165 brasl $75,__icache_br_handler
1166 .quad xor_pattern
1167*/
47f6dab9
AM		 1168
1169static bfd_boolean
cd4a7468 1170build_stub (struct bfd_link_info *info,
47f6dab9
AM		 1171 bfd *ibfd,
1172 asection *isec,
fdba2fcd 1173 enum _stub_type stub_type,
47f6dab9
AM		 1174 struct elf_link_hash_entry *h,
1175 const Elf_Internal_Rela *irela,
1176 bfd_vma dest,
1177 asection *dest_sec)
1178{
cd4a7468
AM		 1179 struct spu_link_hash_table *htab = spu_hash_table (info);
1180 unsigned int ovl, dest_ovl, set_id;
47f6dab9
AM		 1181 struct got_entry *g, **head;
1182 asection *sec;
cd4a7468
AM		 1183 bfd_vma addend, from, to, br_dest, patt;
1184 unsigned int lrlive;
47f6dab9
AM		 1185
1186 ovl = 0;
fdba2fcd 1187 if (stub_type != nonovl_stub)
47f6dab9
AM		 1188 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1189
1190 if (h != NULL)
1191 head = &h->got.glist;
1192 else
1193 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1194
4a628337
AM		 1195 addend = 0;
1196 if (irela != NULL)
1197 addend = irela->r_addend;
47f6dab9 1198
cd4a7468
AM		 1199 if (htab->params->ovly_flavour == ovly_soft_icache)
1200 {
1201 g = bfd_malloc (sizeof *g);
1202 if (g == NULL)
1203 return FALSE;
1204 g->ovl = ovl;
1205 g->br_addr = 0;
1206 if (irela != NULL)
1207 g->br_addr = (irela->r_offset
1208 + isec->output_offset
1209 + isec->output_section->vma);
1210 g->next = *head;
1211 *head = g;
1212 }
1213 else
1214 {
1215 for (g = *head; g != NULL; g = g->next)
1216 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1217 break;
1218 if (g == NULL)
1219 abort ();
47f6dab9 1220
cd4a7468
AM		 1221 if (g->ovl == 0 && ovl != 0)
1222 return TRUE;
4a628337 1223
cd4a7468
AM		 1224 if (g->stub_addr != (bfd_vma) -1)
1225 return TRUE;
1226 }
47f6dab9
AM		 1227
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;
a7e11ee1
AM		 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);
64615358
AM		 1235
1236 if (((dest | to | from) & 3) != 0)
47f6dab9
AM		 1237 {
1238 htab->stub_err = 1;
1239 return FALSE;
1240 }
64615358 1241 dest_ovl = spu_elf_section_data (dest_sec->output_section)->u.o.ovl_index;
47f6dab9 1242
a7e11ee1
AM		 1243 if (htab->params->ovly_flavour == ovly_normal
1244 && !htab->params->compact_stub)
47f6dab9 1245 {
64615358 1246 bfd_put_32 (sec->owner, ILA + ((dest_ovl << 7) & 0x01ffff80) + 78,
47f6dab9
AM		 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);
cd4a7468
AM		 1252 if (!BRA_STUBS)
1253 bfd_put_32 (sec->owner, BR + (((to - (from + 12)) << 5) & 0x007fff80),
1254 sec->contents + sec->size + 12);
1255 else
1256 bfd_put_32 (sec->owner, BRA + ((to << 5) & 0x007fff80),
1257 sec->contents + sec->size + 12);
a7e11ee1
AM		 1258 }
1259 else if (htab->params->ovly_flavour == ovly_normal
1260 && htab->params->compact_stub)
1261 {
cd4a7468
AM		 1262 if (!BRA_STUBS)
1263 bfd_put_32 (sec->owner, BRSL + (((to - from) << 5) & 0x007fff80) + 75,
1264 sec->contents + sec->size);
1265 else
1266 bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1267 sec->contents + sec->size);
64615358 1268 bfd_put_32 (sec->owner, (dest & 0x3ffff) | (dest_ovl << 18),
47f6dab9 1269 sec->contents + sec->size + 4);
a7e11ee1 1270 }
cdc83fba
UW		 1271 else if (htab->params->ovly_flavour == ovly_soft_icache
1272 && htab->params->compact_stub)
a7e11ee1 1273 {
cd4a7468
AM		 1274 lrlive = 0;
1275 if (stub_type == nonovl_stub)
1276 ;
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. */
1280 lrlive = 5;
1281 else if (!htab->params->lrlive_analysis)
1282 /* Assume stack frame and lr save. */
1283 lrlive = 1;
1284 else if (irela != NULL)
1285 {
1286 /* Analyse branch instructions. */
1287 struct function_info *caller;
1288 bfd_vma off;
1289
1290 caller = find_function (isec, irela->r_offset, info);
1291 if (caller->start == NULL)
1292 off = irela->r_offset;
1293 else
1294 {
1295 struct function_info *found = NULL;
1296
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)
1305 found = caller;
1306 while (caller->start != NULL)
1307 {
1308 caller = caller->start;
1309 if (caller->lr_store != (bfd_vma) -1
1310 || caller->sp_adjust != (bfd_vma) -1)
1311 found = caller;
1312 }
1313 if (found != NULL)
1314 caller = found;
1315 off = (bfd_vma) -1;
1316 }
1317
1318 if (off > caller->sp_adjust)
1319 {
1320 if (off > caller->lr_store)
1321 /* Only *(*sp+16) is live. */
1322 lrlive = 1;
1323 else
1324 /* If no lr save, then we must be in a
1325 leaf function with a frame.
1326 lr is still live. */
1327 lrlive = 4;
1328 }
1329 else if (off > caller->lr_store)
1330 {
1331 /* Between lr save and stack adjust. */
1332 lrlive = 3;
1333 /* This should never happen since prologues won't
1334 be split here. */
1335 BFD_ASSERT (0);
1336 }
1337 else
1338 /* On entry to function. */
1339 lrlive = 5;
1340
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);
1347 }
1348
1349 /* If given lrlive info via .brinfo, use it. */
1350 if (stub_type > br000_ovl_stub)
1351 lrlive = stub_type - br000_ovl_stub;
1352
a7e11ee1
AM		 1353 if (ovl == 0)
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);
1357
cdc83fba
UW		 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. */
1361 g->stub_addr += 4;
1362 br_dest = g->stub_addr;
1363 if (irela == NULL)
a7e11ee1 1364 {
cdc83fba
UW		 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;
1369 br_dest = to;
a7e11ee1 1370 }
a7e11ee1 1371
cdc83fba
UW		 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);
cd4a7468 1384
cd4a7468
AM		 1385 if (ovl == 0)
1386 /* Extra space for linked list entries. */
1387 sec->size += 16;
47f6dab9 1388 }
a7e11ee1
AM		 1389 else
1390 abort ();
1391
1392 sec->size += ovl_stub_size (htab->params);
47f6dab9 1393
64615358 1394 if (htab->params->emit_stub_syms)
47f6dab9
AM		 1395 {
1396 size_t len;
1397 char *name;
1398 int add;
1399
1400 len = 8 + sizeof (".ovl_call.") - 1;
1401 if (h != NULL)
1402 len += strlen (h->root.root.string);
1403 else
1404 len += 8 + 1 + 8;
1405 add = 0;
1406 if (irela != NULL)
1407 add = (int) irela->r_addend & 0xffffffff;
1408 if (add != 0)
1409 len += 1 + 8;
1410 name = bfd_malloc (len);
1411 if (name == NULL)
1412 return FALSE;
1413
1414 sprintf (name, "%08x.ovl_call.", g->ovl);
1415 if (h != NULL)
1416 strcpy (name + 8 + sizeof (".ovl_call.") - 1, h->root.root.string);
1417 else
1418 sprintf (name + 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1419 dest_sec->id & 0xffffffff,
1420 (int) ELF32_R_SYM (irela->r_info) & 0xffffffff);
1421 if (add != 0)
1422 sprintf (name + len - 9, "+%x", add);
1423
1424 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1425 free (name);
1426 if (h == NULL)
1427 return FALSE;
1428 if (h->root.type == bfd_link_hash_new)
1429 {
1430 h->root.type = bfd_link_hash_defined;
1431 h->root.u.def.section = sec;
a7e11ee1 1432 h->size = ovl_stub_size (htab->params);
64615358 1433 h->root.u.def.value = sec->size - h->size;
47f6dab9
AM		 1434 h->type = STT_FUNC;
1435 h->ref_regular = 1;
1436 h->def_regular = 1;
1437 h->ref_regular_nonweak = 1;
1438 h->forced_local = 1;
1439 h->non_elf = 0;
1440 }
1441 }
1442
1443 return TRUE;
1444}
1445
f4b39977
AM		 1446/* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1447 symbols. */
1448
1449static bfd_boolean
1450allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1451{
1452 /* Symbols starting with _SPUEAR_ need a stub because they may be
1453 invoked by the PPU. */
380814a6
AM		 1454 struct bfd_link_info *info = inf;
1455 struct spu_link_hash_table *htab = spu_hash_table (info);
1456 asection *sym_sec;
1457
f4b39977
AM		 1458 if ((h->root.type == bfd_link_hash_defined
1459 || h->root.type == bfd_link_hash_defweak)
1460 && h->def_regular
380814a6
AM		 1461 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1462 && (sym_sec = h->root.u.def.section) != NULL
64615358 1463 && sym_sec->output_section != bfd_abs_section_ptr
380814a6
AM		 1464 && spu_elf_section_data (sym_sec->output_section) != NULL
1465 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
64615358 1466 || htab->params->non_overlay_stubs))
f4b39977 1467 {
f3c29e8a 1468 return count_stub (htab, NULL, NULL, nonovl_stub, h, NULL);
f4b39977
AM		 1469 }
1470
1471 return TRUE;
1472}
1473
e9f53129 1474static bfd_boolean
47f6dab9 1475build_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
e9f53129 1476{
47f6dab9
AM		 1477 /* Symbols starting with _SPUEAR_ need a stub because they may be
1478 invoked by the PPU. */
380814a6
AM		 1479 struct bfd_link_info *info = inf;
1480 struct spu_link_hash_table *htab = spu_hash_table (info);
1481 asection *sym_sec;
1482
47f6dab9
AM		 1483 if ((h->root.type == bfd_link_hash_defined
1484 || h->root.type == bfd_link_hash_defweak)
1485 && h->def_regular
380814a6
AM		 1486 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1487 && (sym_sec = h->root.u.def.section) != NULL
64615358 1488 && sym_sec->output_section != bfd_abs_section_ptr
380814a6
AM		 1489 && spu_elf_section_data (sym_sec->output_section) != NULL
1490 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
64615358 1491 || htab->params->non_overlay_stubs))
47f6dab9 1492 {
cd4a7468 1493 return build_stub (info, NULL, NULL, nonovl_stub, h, NULL,
f3c29e8a 1494 h->root.u.def.value, sym_sec);
47f6dab9
AM		 1495 }
1496
e9f53129
AM		 1497 return TRUE;
1498}
1499
47f6dab9 1500/* Size or build stubs. */
e9f53129 1501
47f6dab9 1502static bfd_boolean
c65be8d7 1503process_stubs (struct bfd_link_info *info, bfd_boolean build)
e9f53129
AM		 1504{
1505 struct spu_link_hash_table *htab = spu_hash_table (info);
1506 bfd *ibfd;
e9f53129 1507
e9f53129
AM		 1508 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1509 {
1510 extern const bfd_target bfd_elf32_spu_vec;
1511 Elf_Internal_Shdr *symtab_hdr;
47f6dab9 1512 asection *isec;
e9f53129
AM		 1513 Elf_Internal_Sym *local_syms = NULL;
1514
1515 if (ibfd->xvec != &bfd_elf32_spu_vec)
1516 continue;
1517
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)
1521 continue;
1522
1523 /* Walk over each section attached to the input bfd. */
47f6dab9 1524 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
e9f53129
AM		 1525 {
1526 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1527
1528 /* If there aren't any relocs, then there's nothing more to do. */
47f6dab9 1529 if ((isec->flags & SEC_RELOC) == 0
47f6dab9 1530 || isec->reloc_count == 0)
e9f53129
AM		 1531 continue;
1532
64615358 1533 if (!maybe_needs_stubs (isec))
e9f53129
AM		 1534 continue;
1535
1536 /* Get the relocs. */
47f6dab9
AM		 1537 internal_relocs = _bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
1538 info->keep_memory);
e9f53129
AM		 1539 if (internal_relocs == NULL)
1540 goto error_ret_free_local;
1541
1542 /* Now examine each relocation. */
1543 irela = internal_relocs;
47f6dab9 1544 irelaend = irela + isec->reloc_count;
e9f53129
AM		 1545 for (; irela < irelaend; irela++)
1546 {
1547 enum elf_spu_reloc_type r_type;
1548 unsigned int r_indx;
1549 asection *sym_sec;
1550 Elf_Internal_Sym *sym;
1551 struct elf_link_hash_entry *h;
fdba2fcd 1552 enum _stub_type stub_type;
e9f53129
AM		 1553
1554 r_type = ELF32_R_TYPE (irela->r_info);
1555 r_indx = ELF32_R_SYM (irela->r_info);
1556
1557 if (r_type >= R_SPU_max)
1558 {
1559 bfd_set_error (bfd_error_bad_value);
47f6dab9
AM		 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))
1567 free (local_syms);
1568 return FALSE;
e9f53129
AM		 1569 }
1570
1571 /* Determine the reloc target section. */
1f27ab8d 1572 if (!get_sym_h (&h, &sym, &sym_sec, &local_syms, r_indx, ibfd))
e9f53129
AM		 1573 goto error_ret_free_internal;
1574
fdba2fcd
AM		 1575 stub_type = needs_ovl_stub (h, sym, sym_sec, isec, irela,
1576 NULL, info);
1577 if (stub_type == no_stub)
e9f53129 1578 continue;
fdba2fcd
AM		 1579 else if (stub_type == stub_error)
1580 goto error_ret_free_internal;
e9f53129 1581
47f6dab9 1582 if (htab->stub_count == NULL)
e9f53129 1583 {
47f6dab9
AM		 1584 bfd_size_type amt;
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;
e9f53129
AM		 1589 }
1590
47f6dab9 1591 if (!build)
e9f53129 1592 {
fdba2fcd 1593 if (!count_stub (htab, ibfd, isec, stub_type, h, irela))
47f6dab9 1594 goto error_ret_free_internal;
e9f53129 1595 }
e9f53129 1596 else
47f6dab9
AM		 1597 {
1598 bfd_vma dest;
1599
1600 if (h != NULL)
1601 dest = h->root.u.def.value;
1602 else
1603 dest = sym->st_value;
4a628337 1604 dest += irela->r_addend;
cd4a7468 1605 if (!build_stub (info, ibfd, isec, stub_type, h, irela,
47f6dab9
AM		 1606 dest, sym_sec))
1607 goto error_ret_free_internal;
1608 }
e9f53129
AM		 1609 }
1610
1611 /* We're done with the internal relocs, free them. */
47f6dab9 1612 if (elf_section_data (isec)->relocs != internal_relocs)
e9f53129
AM		 1613 free (internal_relocs);
1614 }
1615
1616 if (local_syms != NULL
1617 && symtab_hdr->contents != (unsigned char *) local_syms)
1618 {
1619 if (!info->keep_memory)
1620 free (local_syms);
1621 else
1622 symtab_hdr->contents = (unsigned char *) local_syms;
1623 }
1624 }
1625
47f6dab9
AM		 1626 return TRUE;
1627}
1628
a7e11ee1
AM		 1629/* Allocate space for overlay call and return stubs.
1630 Return 0 on error, 1 if no stubs, 2 otherwise. */
47f6dab9
AM		 1631
1632int
64615358 1633spu_elf_size_stubs (struct bfd_link_info *info)
47f6dab9 1634{
64615358 1635 struct spu_link_hash_table *htab;
47f6dab9
AM		 1636 bfd *ibfd;
1637 bfd_size_type amt;
1638 flagword flags;
1639 unsigned int i;
1640 asection *stub;
1641
c65be8d7 1642 if (!process_stubs (info, FALSE))
47f6dab9
AM		 1643 return 0;
1644
64615358 1645 htab = spu_hash_table (info);
380814a6 1646 elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, info);
47f6dab9
AM		 1647 if (htab->stub_err)
1648 return 0;
f4b39977 1649
47f6dab9
AM		 1650 if (htab->stub_count == NULL)
1651 return 1;
e9f53129
AM		 1652
1653 ibfd = info->input_bfds;
47f6dab9
AM		 1654 amt = (htab->num_overlays + 1) * sizeof (*htab->stub_sec);
1655 htab->stub_sec = bfd_zmalloc (amt);
1656 if (htab->stub_sec == NULL)
1657 return 0;
e9f53129 1658
47f6dab9 1659 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
e9f53129 1660 | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
47f6dab9
AM		 1661 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1662 htab->stub_sec[0] = stub;
1663 if (stub == NULL
64615358 1664 || !bfd_set_section_alignment (ibfd, stub,
a7e11ee1 1665 ovl_stub_size_log2 (htab->params)))
47f6dab9 1666 return 0;
a7e11ee1 1667 stub->size = htab->stub_count[0] * ovl_stub_size (htab->params);
cd4a7468
AM		 1668 if (htab->params->ovly_flavour == ovly_soft_icache)
1669 /* Extra space for linked list entries. */
1670 stub->size += htab->stub_count[0] * 16;
e9f53129 1671
47f6dab9 1672 for (i = 0; i < htab->num_overlays; ++i)
e9f53129 1673 {
47f6dab9
AM		 1674 asection *osec = htab->ovl_sec[i];
1675 unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1676 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1677 htab->stub_sec[ovl] = stub;
1678 if (stub == NULL
64615358 1679 || !bfd_set_section_alignment (ibfd, stub,
a7e11ee1 1680 ovl_stub_size_log2 (htab->params)))
47f6dab9 1681 return 0;
a7e11ee1 1682 stub->size = htab->stub_count[ovl] * ovl_stub_size (htab->params);
e9f53129 1683 }
e9f53129 1684
cd4a7468
AM		 1685 if (htab->params->ovly_flavour == ovly_soft_icache)
1686 {
1687 /* Space for icache manager tables.
1688 a) Tag array, one quadword per cache line.
97fc8d84
UW		 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. */
1692
1693 flags = SEC_ALLOC;
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))
1697 return 0;
1698
1699 htab->ovtab->size = (16 + 16 + (16 << htab->fromelem_size_log2))
1700 << htab->num_lines_log2;
cd4a7468 1701
97fc8d84 1702 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
cd4a7468
AM		 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))
1706 return 0;
1707
1708 htab->init->size = 16;
cd4a7468
AM		 1709 }
1710 else
1711 {
1712 /* htab->ovtab consists of two arrays.
1713 . struct {
1714 . u32 vma;
1715 . u32 size;
1716 . u32 file_off;
1717 . u32 buf;
1718 . } _ovly_table[];
1719 .
1720 . struct {
1721 . u32 mapped;
1722 . } _ovly_buf_table[];
1723 . */
1724
97fc8d84
UW		 1725 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1726 htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1727 if (htab->ovtab == NULL
1728 || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1729 return 0;
1730
cd4a7468
AM		 1731 htab->ovtab->size = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
1732 }
47f6dab9
AM		 1733
1734 htab->toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1735 if (htab->toe == NULL
1736 || !bfd_set_section_alignment (ibfd, htab->toe, 4))
1737 return 0;
c1ea05bb 1738 htab->toe->size = 16;
47f6dab9
AM		 1739
1740 return 2;
e9f53129
AM		 1741}
1742
bbb0fc04
AM		 1743/* Called from ld to place overlay manager data sections. This is done
1744 after the overlay manager itself is loaded, mainly so that the
1745 linker's htab->init section is placed after any other .ovl.init
1746 sections. */
1747
1748void
1749spu_elf_place_overlay_data (struct bfd_link_info *info)
1750{
1751 struct spu_link_hash_table *htab = spu_hash_table (info);
1752 unsigned int i;
1753 const char *ovout;
1754
1755 if (htab->stub_count == NULL)
1756 return;
1757
1758 (*htab->params->place_spu_section) (htab->stub_sec[0], NULL, ".text");
1759
1760 for (i = 0; i < htab->num_overlays; ++i)
1761 {
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);
1765 }
1766
1767 if (htab->params->ovly_flavour == ovly_soft_icache)
1768 (*htab->params->place_spu_section) (htab->init, NULL, ".ovl.init");
1769
1770 ovout = ".data";
1771 if (htab->params->ovly_flavour == ovly_soft_icache)
97fc8d84 1772 ovout = ".bss";
bbb0fc04
AM		 1773 (*htab->params->place_spu_section) (htab->ovtab, NULL, ovout);
1774
1775 (*htab->params->place_spu_section) (htab->toe, NULL, ".toe");
1776}
1777
e9f53129
AM		 1778/* Functions to handle embedded spu_ovl.o object. */
1779
1780static void *
1781ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1782{
1783 return stream;
1784}
1785
1786static file_ptr
1787ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1788 void *stream,
1789 void *buf,
1790 file_ptr nbytes,
1791 file_ptr offset)
1792{
1793 struct _ovl_stream *os;
1794 size_t count;
1795 size_t max;
1796
1797 os = (struct _ovl_stream *) stream;
7a8757b3 1798 max = (const char *) os->end - (const char *) os->start;
e9f53129
AM		 1799
1800 if ((ufile_ptr) offset >= max)
1801 return 0;
1802
1803 count = nbytes;
1804 if (count > max - offset)
1805 count = max - offset;
1806
7a8757b3 1807 memcpy (buf, (const char *) os->start + offset, count);
e9f53129
AM		 1808 return count;
1809}
1810
1811bfd_boolean
1812spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1813{
1814 *ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1815 "elf32-spu",
1816 ovl_mgr_open,
1817 (void *) stream,
1818 ovl_mgr_pread,
f6cf9273 1819 NULL,
e9f53129
AM		 1820 NULL);
1821 return *ovl_bfd != NULL;
1822}
1823
cd4a7468
AM		 1824static unsigned int
1825overlay_index (asection *sec)
1826{
1827 if (sec == NULL
1828 || sec->output_section == bfd_abs_section_ptr)
1829 return 0;
1830 return spu_elf_section_data (sec->output_section)->u.o.ovl_index;
1831}
1832
e9f53129
AM		 1833/* Define an STT_OBJECT symbol. */
1834
1835static struct elf_link_hash_entry *
1836define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1837{
1838 struct elf_link_hash_entry *h;
1839
1840 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1841 if (h == NULL)
1842 return NULL;
1843
1844 if (h->root.type != bfd_link_hash_defined
1845 || !h->def_regular)
1846 {
1847 h->root.type = bfd_link_hash_defined;
1848 h->root.u.def.section = htab->ovtab;
1849 h->type = STT_OBJECT;
1850 h->ref_regular = 1;
1851 h->def_regular = 1;
1852 h->ref_regular_nonweak = 1;
1853 h->non_elf = 0;
1854 }
b0c41709 1855 else if (h->root.u.def.section->owner != NULL)
e9f53129
AM		 1856 {
1857 (*_bfd_error_handler) (_("%B is not allowed to define %s"),
1858 h->root.u.def.section->owner,
1859 h->root.root.string);
1860 bfd_set_error (bfd_error_bad_value);
1861 return NULL;
1862 }
b0c41709
AM		 1863 else
1864 {
1865 (*_bfd_error_handler) (_("you are not allowed to define %s in a script"),
1866 h->root.root.string);
1867 bfd_set_error (bfd_error_bad_value);
1868 return NULL;
1869 }
e9f53129
AM		 1870
1871 return h;
1872}
1873
1874/* Fill in all stubs and the overlay tables. */
1875
cd4a7468 1876static bfd_boolean
64615358 1877spu_elf_build_stubs (struct bfd_link_info *info)
e9f53129
AM		 1878{
1879 struct spu_link_hash_table *htab = spu_hash_table (info);
1880 struct elf_link_hash_entry *h;
1881 bfd_byte *p;
1882 asection *s;
1883 bfd *obfd;
1884 unsigned int i;
1885
47f6dab9
AM		 1886 if (htab->stub_count == NULL)
1887 return TRUE;
1888
1889 for (i = 0; i <= htab->num_overlays; i++)
1890 if (htab->stub_sec[i]->size != 0)
1891 {
1892 htab->stub_sec[i]->contents = bfd_zalloc (htab->stub_sec[i]->owner,
1893 htab->stub_sec[i]->size);
1894 if (htab->stub_sec[i]->contents == NULL)
1895 return FALSE;
1896 htab->stub_sec[i]->rawsize = htab->stub_sec[i]->size;
1897 htab->stub_sec[i]->size = 0;
1898 }
e9f53129 1899
ad2adbc8 1900 for (i = 0; i < 2; i++)
cd4a7468 1901 {
ad2adbc8
AM		 1902 h = htab->ovly_entry[i];
1903 BFD_ASSERT (h != NULL);
a7e11ee1 1904
ad2adbc8
AM		 1905 if ((h->root.type == bfd_link_hash_defined
1906 || h->root.type == bfd_link_hash_defweak)
1907 && h->def_regular)
1908 {
1909 s = h->root.u.def.section->output_section;
1910 if (spu_elf_section_data (s)->u.o.ovl_index)
1911 {
1912 (*_bfd_error_handler) (_("%s in overlay section"),
1913 h->root.root.string);
1914 bfd_set_error (bfd_error_bad_value);
1915 return FALSE;
1916 }
1917 }
1918 else
1919 BFD_ASSERT (0);
cd4a7468 1920 }
47f6dab9 1921
c65be8d7
AM		 1922 /* Fill in all the stubs. */
1923 process_stubs (info, TRUE);
f3c29e8a
AM		 1924 if (!htab->stub_err)
1925 elf_link_hash_traverse (&htab->elf, build_spuear_stubs, info);
47f6dab9 1926
47f6dab9 1927 if (htab->stub_err)
f3c29e8a
AM		 1928 {
1929 (*_bfd_error_handler) (_("overlay stub relocation overflow"));
1930 bfd_set_error (bfd_error_bad_value);
1931 return FALSE;
1932 }
e9f53129 1933
47f6dab9
AM		 1934 for (i = 0; i <= htab->num_overlays; i++)
1935 {
1936 if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
1937 {
1938 (*_bfd_error_handler) (_("stubs don't match calculated size"));
1939 bfd_set_error (bfd_error_bad_value);
1940 return FALSE;
1941 }
1942 htab->stub_sec[i]->rawsize = 0;
1943 }
1944
cd4a7468
AM		 1945 if (htab->ovtab == NULL || htab->ovtab->size == 0)
1946 return TRUE;
1947
e9f53129
AM		 1948 htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1949 if (htab->ovtab->contents == NULL)
1950 return FALSE;
1951
e9f53129 1952 p = htab->ovtab->contents;
cd4a7468 1953 if (htab->params->ovly_flavour == ovly_soft_icache)
e9f53129 1954 {
97fc8d84 1955 bfd_vma off;
cd4a7468 1956
77ae44b0 1957 h = define_ovtab_symbol (htab, "__icache_tag_array");
cd4a7468
AM		 1958 if (h == NULL)
1959 return FALSE;
1960 h->root.u.def.value = 0;
1961 h->size = 16 << htab->num_lines_log2;
1962 off = h->size;
77ae44b0
AM		 1963
1964 h = define_ovtab_symbol (htab, "__icache_tag_array_size");
1965 if (h == NULL)
1966 return FALSE;
1967 h->root.u.def.value = 16 << htab->num_lines_log2;
1968 h->root.u.def.section = bfd_abs_section_ptr;
1969
97fc8d84
UW		 1970 h = define_ovtab_symbol (htab, "__icache_rewrite_to");
1971 if (h == NULL)
1972 return FALSE;
1973 h->root.u.def.value = off;
1974 h->size = 16 << htab->num_lines_log2;
1975 off += h->size;
1976
1977 h = define_ovtab_symbol (htab, "__icache_rewrite_to_size");
1978 if (h == NULL)
1979 return FALSE;
1980 h->root.u.def.value = 16 << htab->num_lines_log2;
1981 h->root.u.def.section = bfd_abs_section_ptr;
cd4a7468 1982
97fc8d84 1983 h = define_ovtab_symbol (htab, "__icache_rewrite_from");
cd4a7468
AM		 1984 if (h == NULL)
1985 return FALSE;
1986 h->root.u.def.value = off;
97fc8d84 1987 h->size = 16 << (htab->fromelem_size_log2 + htab->num_lines_log2);
cd4a7468 1988 off += h->size;
97fc8d84
UW		 1989
1990 h = define_ovtab_symbol (htab, "__icache_rewrite_from_size");
1991 if (h == NULL)
1992 return FALSE;
1993 h->root.u.def.value = 16 << (htab->fromelem_size_log2
1994 + htab->num_lines_log2);
1995 h->root.u.def.section = bfd_abs_section_ptr;
1996
1997 h = define_ovtab_symbol (htab, "__icache_log2_fromelemsize");
1998 if (h == NULL)
1999 return FALSE;
2000 h->root.u.def.value = htab->fromelem_size_log2;
2001 h->root.u.def.section = bfd_abs_section_ptr;
cd4a7468 2002
cd4a7468
AM		 2003 h = define_ovtab_symbol (htab, "__icache_base");
2004 if (h == NULL)
2005 return FALSE;
460e679b
AM		 2006 h->root.u.def.value = htab->ovl_sec[0]->vma;
2007 h->root.u.def.section = bfd_abs_section_ptr;
cd4a7468 2008 h->size = htab->num_buf << htab->line_size_log2;
e9f53129 2009
97fc8d84
UW		 2010 h = define_ovtab_symbol (htab, "__icache_linesize");
2011 if (h == NULL)
2012 return FALSE;
2013 h->root.u.def.value = 1 << htab->line_size_log2;
2014 h->root.u.def.section = bfd_abs_section_ptr;
2015
2016 h = define_ovtab_symbol (htab, "__icache_log2_linesize");
2017 if (h == NULL)
2018 return FALSE;
2019 h->root.u.def.value = htab->line_size_log2;
2020 h->root.u.def.section = bfd_abs_section_ptr;
2021
50e00962
AM		 2022 h = define_ovtab_symbol (htab, "__icache_neg_log2_linesize");
2023 if (h == NULL)
2024 return FALSE;
2025 h->root.u.def.value = -htab->line_size_log2;
2026 h->root.u.def.section = bfd_abs_section_ptr;
2027
97fc8d84
UW		 2028 h = define_ovtab_symbol (htab, "__icache_cachesize");
2029 if (h == NULL)
2030 return FALSE;
2031 h->root.u.def.value = 1 << (htab->num_lines_log2 + htab->line_size_log2);
2032 h->root.u.def.section = bfd_abs_section_ptr;
2033
2034 h = define_ovtab_symbol (htab, "__icache_log2_cachesize");
2035 if (h == NULL)
2036 return FALSE;
2037 h->root.u.def.value = htab->num_lines_log2 + htab->line_size_log2;
2038 h->root.u.def.section = bfd_abs_section_ptr;
2039
2040 h = define_ovtab_symbol (htab, "__icache_neg_log2_cachesize");
2041 if (h == NULL)
2042 return FALSE;
2043 h->root.u.def.value = -(htab->num_lines_log2 + htab->line_size_log2);
2044 h->root.u.def.section = bfd_abs_section_ptr;
2045
cd4a7468 2046 if (htab->init != NULL && htab->init->size != 0)
e9f53129 2047 {
cd4a7468
AM		 2048 htab->init->contents = bfd_zalloc (htab->init->owner,
2049 htab->init->size);
2050 if (htab->init->contents == NULL)
2051 return FALSE;
47f6dab9 2052
cd4a7468
AM		 2053 h = define_ovtab_symbol (htab, "__icache_fileoff");
2054 if (h == NULL)
2055 return FALSE;
2056 h->root.u.def.value = 0;
2057 h->root.u.def.section = htab->init;
2058 h->size = 8;
e9f53129
AM		 2059 }
2060 }
cd4a7468
AM		 2061 else
2062 {
2063 /* Write out _ovly_table. */
2064 /* set low bit of .size to mark non-overlay area as present. */
2065 p[7] = 1;
2066 obfd = htab->ovtab->output_section->owner;
2067 for (s = obfd->sections; s != NULL; s = s->next)
2068 {
2069 unsigned int ovl_index = spu_elf_section_data (s)->u.o.ovl_index;
e9f53129 2070
cd4a7468
AM		 2071 if (ovl_index != 0)
2072 {
2073 unsigned long off = ovl_index * 16;
2074 unsigned int ovl_buf = spu_elf_section_data (s)->u.o.ovl_buf;
2075
2076 bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
2077 bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16,
2078 p + off + 4);
2079 /* file_off written later in spu_elf_modify_program_headers. */
2080 bfd_put_32 (htab->ovtab->owner, ovl_buf, p + off + 12);
2081 }
2082 }
e9f53129 2083
cd4a7468
AM		 2084 h = define_ovtab_symbol (htab, "_ovly_table");
2085 if (h == NULL)
2086 return FALSE;
2087 h->root.u.def.value = 16;
2088 h->size = htab->num_overlays * 16;
e9f53129 2089
cd4a7468
AM		 2090 h = define_ovtab_symbol (htab, "_ovly_table_end");
2091 if (h == NULL)
2092 return FALSE;
2093 h->root.u.def.value = htab->num_overlays * 16 + 16;
2094 h->size = 0;
e9f53129 2095
cd4a7468
AM		 2096 h = define_ovtab_symbol (htab, "_ovly_buf_table");
2097 if (h == NULL)
2098 return FALSE;
2099 h->root.u.def.value = htab->num_overlays * 16 + 16;
2100 h->size = htab->num_buf * 4;
2101
2102 h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
2103 if (h == NULL)
2104 return FALSE;
2105 h->root.u.def.value = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
2106 h->size = 0;
2107 }
e9f53129
AM		 2108
2109 h = define_ovtab_symbol (htab, "_EAR_");
2110 if (h == NULL)
2111 return FALSE;
47f6dab9 2112 h->root.u.def.section = htab->toe;
e9f53129 2113 h->root.u.def.value = 0;
c1ea05bb 2114 h->size = 16;
e9f53129
AM		 2115
2116 return TRUE;
2117}
2118
c65be8d7 2119/* Check that all loadable section VMAs lie in the range
9dcc4794 2120 LO .. HI inclusive, and stash some parameters for --auto-overlay. */
c65be8d7
AM		 2121
2122asection *
64615358 2123spu_elf_check_vma (struct bfd_link_info *info)
c65be8d7
AM		 2124{
2125 struct elf_segment_map *m;
2126 unsigned int i;
9dcc4794 2127 struct spu_link_hash_table *htab = spu_hash_table (info);
c65be8d7 2128 bfd *abfd = info->output_bfd;
64615358
AM		 2129 bfd_vma hi = htab->params->local_store_hi;
2130 bfd_vma lo = htab->params->local_store_lo;
c65be8d7 2131
9dcc4794 2132 htab->local_store = hi + 1 - lo;
9dcc4794 2133
c65be8d7
AM		 2134 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2135 if (m->p_type == PT_LOAD)
2136 for (i = 0; i < m->count; i++)
2137 if (m->sections[i]->size != 0
2138 && (m->sections[i]->vma < lo
2139 || m->sections[i]->vma > hi
2140 || m->sections[i]->vma + m->sections[i]->size - 1 > hi))
2141 return m->sections[i];
2142
2143 return NULL;
2144}
2145
49fa1e15 2146/* OFFSET in SEC (presumably) is the beginning of a function prologue.
cd4a7468
AM		 2147 Search for stack adjusting insns, and return the sp delta.
2148 If a store of lr is found save the instruction offset to *LR_STORE.
2149 If a stack adjusting instruction is found, save that offset to
2150 *SP_ADJUST. */
49fa1e15
AM		 2151
2152static int
cd4a7468
AM		 2153find_function_stack_adjust (asection *sec,
2154 bfd_vma offset,
2155 bfd_vma *lr_store,
2156 bfd_vma *sp_adjust)
49fa1e15 2157{
49fa1e15
AM		 2158 int reg[128];
2159
2160 memset (reg, 0, sizeof (reg));
667f3338 2161 for ( ; offset + 4 <= sec->size; offset += 4)
49fa1e15
AM		 2162 {
2163 unsigned char buf[4];
2164 int rt, ra;
2165 int imm;
2166
2167 /* Assume no relocs on stack adjusing insns. */
2168 if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
2169 break;
2170
49fa1e15
AM		 2171 rt = buf[3] & 0x7f;
2172 ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
cd4a7468
AM		 2173
2174 if (buf[0] == 0x24 /* stqd */)
2175 {
2176 if (rt == 0 /* lr */ && ra == 1 /* sp */)
2177 *lr_store = offset;
2178 continue;
2179 }
2180
49fa1e15
AM		 2181 /* Partly decoded immediate field. */
2182 imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
2183
2184 if (buf[0] == 0x1c /* ai */)
2185 {
2186 imm >>= 7;
2187 imm = (imm ^ 0x200) - 0x200;
2188 reg[rt] = reg[ra] + imm;
2189
2190 if (rt == 1 /* sp */)
2191 {
667f3338 2192 if (reg[rt] > 0)
49fa1e15 2193 break;
cd4a7468 2194 *sp_adjust = offset;
49fa1e15
AM		 2195 return reg[rt];
2196 }
2197 }
2198 else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
2199 {
2200 int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2201
2202 reg[rt] = reg[ra] + reg[rb];
2203 if (rt == 1)
667f3338
AM		 2204 {
2205 if (reg[rt] > 0)
2206 break;
cd4a7468 2207 *sp_adjust = offset;
667f3338
AM		 2208 return reg[rt];
2209 }
49fa1e15 2210 }
9b175a76
UW		 2211 else if (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */)
2212 {
2213 int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2214
2215 reg[rt] = reg[rb] - reg[ra];
2216 if (rt == 1)
2217 {
2218 if (reg[rt] > 0)
2219 break;
2220 *sp_adjust = offset;
2221 return reg[rt];
2222 }
2223 }
49fa1e15
AM		 2224 else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
2225 {
2226 if (buf[0] >= 0x42 /* ila */)
2227 imm |= (buf[0] & 1) << 17;
2228 else
2229 {
2230 imm &= 0xffff;
2231
2232 if (buf[0] == 0x40 /* il */)
2233 {
2234 if ((buf[1] & 0x80) == 0)
667f3338 2235 continue;
49fa1e15
AM		 2236 imm = (imm ^ 0x8000) - 0x8000;
2237 }
2238 else if ((buf[1] & 0x80) == 0 /* ilhu */)
2239 imm <<= 16;
2240 }
2241 reg[rt] = imm;
2242 continue;
2243 }
2244 else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
2245 {
2246 reg[rt] |= imm & 0xffff;
2247 continue;
2248 }
2249 else if (buf[0] == 0x04 /* ori */)
2250 {
2251 imm >>= 7;
2252 imm = (imm ^ 0x200) - 0x200;
2253 reg[rt] = reg[ra] | imm;
2254 continue;
2255 }
667f3338
AM		 2256 else if (buf[0] == 0x32 && (buf[1] & 0x80) != 0 /* fsmbi */)
2257 {
2258 reg[rt] = ( ((imm & 0x8000) ? 0xff000000 : 0)
2259 | ((imm & 0x4000) ? 0x00ff0000 : 0)
2260 | ((imm & 0x2000) ? 0x0000ff00 : 0)
2261 | ((imm & 0x1000) ? 0x000000ff : 0));
2262 continue;
2263 }
2264 else if (buf[0] == 0x16 /* andbi */)
49fa1e15 2265 {
667f3338
AM		 2266 imm >>= 7;
2267 imm &= 0xff;
2268 imm |= imm << 8;
2269 imm |= imm << 16;
2270 reg[rt] = reg[ra] & imm;
2271 continue;
2272 }
2273 else if (buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
2274 {
2275 /* Used in pic reg load. Say rt is trashed. Won't be used
2276 in stack adjust, but we need to continue past this branch. */
49fa1e15
AM		 2277 reg[rt] = 0;
2278 continue;
2279 }
fad9eaf0 2280 else if (is_branch (buf) || is_indirect_branch (buf))
49fa1e15
AM		 2281 /* If we hit a branch then we must be out of the prologue. */
2282 break;
49fa1e15
AM		 2283 }
2284
2285 return 0;
2286}
2287
2288/* qsort predicate to sort symbols by section and value. */
2289
2290static Elf_Internal_Sym *sort_syms_syms;
2291static asection **sort_syms_psecs;
2292
2293static int
2294sort_syms (const void *a, const void *b)
2295{
2296 Elf_Internal_Sym *const *s1 = a;
2297 Elf_Internal_Sym *const *s2 = b;
2298 asection *sec1,*sec2;
2299 bfd_signed_vma delta;
2300
2301 sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
2302 sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
2303
2304 if (sec1 != sec2)
2305 return sec1->index - sec2->index;
2306
2307 delta = (*s1)->st_value - (*s2)->st_value;
2308 if (delta != 0)
2309 return delta < 0 ? -1 : 1;
2310
2311 delta = (*s2)->st_size - (*s1)->st_size;
2312 if (delta != 0)
2313 return delta < 0 ? -1 : 1;
2314
2315 return *s1 < *s2 ? -1 : 1;
2316}
2317
49fa1e15
AM		 2318/* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
2319 entries for section SEC. */
2320
2321static struct spu_elf_stack_info *
2322alloc_stack_info (asection *sec, int max_fun)
2323{
2324 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2325 bfd_size_type amt;
2326
2327 amt = sizeof (struct spu_elf_stack_info);
2328 amt += (max_fun - 1) * sizeof (struct function_info);
47f6dab9
AM		 2329 sec_data->u.i.stack_info = bfd_zmalloc (amt);
2330 if (sec_data->u.i.stack_info != NULL)
2331 sec_data->u.i.stack_info->max_fun = max_fun;
2332 return sec_data->u.i.stack_info;
49fa1e15
AM		 2333}
2334
2335/* Add a new struct function_info describing a (part of a) function
2336 starting at SYM_H. Keep the array sorted by address. */
2337
2338static struct function_info *
2339maybe_insert_function (asection *sec,
2340 void *sym_h,
2341 bfd_boolean global,
2342 bfd_boolean is_func)
2343{
2344 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 2345 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 2346 int i;
2347 bfd_vma off, size;
2348
2349 if (sinfo == NULL)
2350 {
2351 sinfo = alloc_stack_info (sec, 20);
2352 if (sinfo == NULL)
2353 return NULL;
2354 }
2355
2356 if (!global)
2357 {
2358 Elf_Internal_Sym *sym = sym_h;
2359 off = sym->st_value;
2360 size = sym->st_size;
2361 }
2362 else
2363 {
2364 struct elf_link_hash_entry *h = sym_h;
2365 off = h->root.u.def.value;
2366 size = h->size;
2367 }
2368
2369 for (i = sinfo->num_fun; --i >= 0; )
2370 if (sinfo->fun[i].lo <= off)
2371 break;
2372
2373 if (i >= 0)
2374 {
2375 /* Don't add another entry for an alias, but do update some
2376 info. */
2377 if (sinfo->fun[i].lo == off)
2378 {
2379 /* Prefer globals over local syms. */
2380 if (global && !sinfo->fun[i].global)
2381 {
2382 sinfo->fun[i].global = TRUE;
2383 sinfo->fun[i].u.h = sym_h;
2384 }
2385 if (is_func)
2386 sinfo->fun[i].is_func = TRUE;
2387 return &sinfo->fun[i];
2388 }
2389 /* Ignore a zero-size symbol inside an existing function. */
2390 else if (sinfo->fun[i].hi > off && size == 0)
2391 return &sinfo->fun[i];
2392 }
2393
1f27ab8d 2394 if (sinfo->num_fun >= sinfo->max_fun)
49fa1e15
AM		 2395 {
2396 bfd_size_type amt = sizeof (struct spu_elf_stack_info);
2397 bfd_size_type old = amt;
2398
2399 old += (sinfo->max_fun - 1) * sizeof (struct function_info);
2400 sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
2401 amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
2402 sinfo = bfd_realloc (sinfo, amt);
2403 if (sinfo == NULL)
2404 return NULL;
2405 memset ((char *) sinfo + old, 0, amt - old);
47f6dab9 2406 sec_data->u.i.stack_info = sinfo;
49fa1e15 2407 }
1f27ab8d
AM		 2408
2409 if (++i < sinfo->num_fun)
2410 memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
2411 (sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
49fa1e15
AM		 2412 sinfo->fun[i].is_func = is_func;
2413 sinfo->fun[i].global = global;
2414 sinfo->fun[i].sec = sec;
2415 if (global)
2416 sinfo->fun[i].u.h = sym_h;
2417 else
2418 sinfo->fun[i].u.sym = sym_h;
2419 sinfo->fun[i].lo = off;
2420 sinfo->fun[i].hi = off + size;
cd4a7468
AM		 2421 sinfo->fun[i].lr_store = -1;
2422 sinfo->fun[i].sp_adjust = -1;
2423 sinfo->fun[i].stack = -find_function_stack_adjust (sec, off,
2424 &sinfo->fun[i].lr_store,
2425 &sinfo->fun[i].sp_adjust);
49fa1e15
AM		 2426 sinfo->num_fun += 1;
2427 return &sinfo->fun[i];
2428}
2429
2430/* Return the name of FUN. */
2431
2432static const char *
2433func_name (struct function_info *fun)
2434{
2435 asection *sec;
2436 bfd *ibfd;
2437 Elf_Internal_Shdr *symtab_hdr;
2438
2439 while (fun->start != NULL)
2440 fun = fun->start;
2441
2442 if (fun->global)
2443 return fun->u.h->root.root.string;
2444
2445 sec = fun->sec;
2446 if (fun->u.sym->st_name == 0)
2447 {
2448 size_t len = strlen (sec->name);
2449 char *name = bfd_malloc (len + 10);
2450 if (name == NULL)
2451 return "(null)";
2452 sprintf (name, "%s+%lx", sec->name,
2453 (unsigned long) fun->u.sym->st_value & 0xffffffff);
2454 return name;
2455 }
2456 ibfd = sec->owner;
2457 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2458 return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
2459}
2460
2461/* Read the instruction at OFF in SEC. Return true iff the instruction
2462 is a nop, lnop, or stop 0 (all zero insn). */
2463
2464static bfd_boolean
2465is_nop (asection *sec, bfd_vma off)
2466{
2467 unsigned char insn[4];
2468
2469 if (off + 4 > sec->size
2470 || !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
2471 return FALSE;
2472 if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
2473 return TRUE;
2474 if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
2475 return TRUE;
2476 return FALSE;
2477}
2478
2479/* Extend the range of FUN to cover nop padding up to LIMIT.
2480 Return TRUE iff some instruction other than a NOP was found. */
2481
2482static bfd_boolean
2483insns_at_end (struct function_info *fun, bfd_vma limit)
2484{
2485 bfd_vma off = (fun->hi + 3) & -4;
2486
2487 while (off < limit && is_nop (fun->sec, off))
2488 off += 4;
2489 if (off < limit)
2490 {
2491 fun->hi = off;
2492 return TRUE;
2493 }
2494 fun->hi = limit;
2495 return FALSE;
2496}
2497
2498/* Check and fix overlapping function ranges. Return TRUE iff there
2499 are gaps in the current info we have about functions in SEC. */
2500
2501static bfd_boolean
2502check_function_ranges (asection *sec, struct bfd_link_info *info)
2503{
2504 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 2505 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 2506 int i;
2507 bfd_boolean gaps = FALSE;
2508
2509 if (sinfo == NULL)
2510 return FALSE;
2511
2512 for (i = 1; i < sinfo->num_fun; i++)
2513 if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
2514 {
2515 /* Fix overlapping symbols. */
2516 const char *f1 = func_name (&sinfo->fun[i - 1]);
2517 const char *f2 = func_name (&sinfo->fun[i]);
2518
2519 info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
2520 sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
2521 }
2522 else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
2523 gaps = TRUE;
2524
2525 if (sinfo->num_fun == 0)
2526 gaps = TRUE;
2527 else
2528 {
2529 if (sinfo->fun[0].lo != 0)
2530 gaps = TRUE;
2531 if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
2532 {
2533 const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
2534
2535 info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
2536 sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
2537 }
2538 else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
2539 gaps = TRUE;
2540 }
2541 return gaps;
2542}
2543
2544/* Search current function info for a function that contains address
2545 OFFSET in section SEC. */
2546
2547static struct function_info *
2548find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
2549{
2550 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 2551 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 2552 int lo, hi, mid;
2553
2554 lo = 0;
2555 hi = sinfo->num_fun;
2556 while (lo < hi)
2557 {
2558 mid = (lo + hi) / 2;
2559 if (offset < sinfo->fun[mid].lo)
2560 hi = mid;
2561 else if (offset >= sinfo->fun[mid].hi)
2562 lo = mid + 1;
2563 else
2564 return &sinfo->fun[mid];
2565 }
2566 info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
2567 sec, offset);
3209bffa 2568 bfd_set_error (bfd_error_bad_value);
49fa1e15
AM		 2569 return NULL;
2570}
2571
9dcc4794
AM		 2572/* Add CALLEE to CALLER call list if not already present. Return TRUE
2573 if CALLEE was new. If this function return FALSE, CALLEE should
2574 be freed. */
49fa1e15
AM		 2575
2576static bfd_boolean
2577insert_callee (struct function_info *caller, struct call_info *callee)
2578{
055ed83b
AM		 2579 struct call_info **pp, *p;
2580
2581 for (pp = &caller->call_list; (p = *pp) != NULL; pp = &p->next)
49fa1e15
AM		 2582 if (p->fun == callee->fun)
2583 {
2584 /* Tail calls use less stack than normal calls. Retain entry
2585 for normal call over one for tail call. */
c65be8d7
AM		 2586 p->is_tail &= callee->is_tail;
2587 if (!p->is_tail)
2588 {
2589 p->fun->start = NULL;
2590 p->fun->is_func = TRUE;
2591 }
34ad4cb0 2592 p->count += callee->count;
055ed83b
AM		 2593 /* Reorder list so most recent call is first. */
2594 *pp = p->next;
2595 p->next = caller->call_list;
2596 caller->call_list = p;
49fa1e15
AM		 2597 return FALSE;
2598 }
2599 callee->next = caller->call_list;
2600 caller->call_list = callee;
2601 return TRUE;
2602}
2603
9dcc4794
AM		 2604/* Copy CALL and insert the copy into CALLER. */
2605
2606static bfd_boolean
2607copy_callee (struct function_info *caller, const struct call_info *call)
2608{
2609 struct call_info *callee;
2610 callee = bfd_malloc (sizeof (*callee));
2611 if (callee == NULL)
2612 return FALSE;
2613 *callee = *call;
2614 if (!insert_callee (caller, callee))
2615 free (callee);
2616 return TRUE;
2617}
2618
055ed83b
AM		 2619/* We're only interested in code sections. Testing SEC_IN_MEMORY excludes
2620 overlay stub sections. */
2621
2622static bfd_boolean
64615358 2623interesting_section (asection *s)
055ed83b 2624{
64615358 2625 return (s->output_section != bfd_abs_section_ptr
055ed83b
AM		 2626 && ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_IN_MEMORY))
2627 == (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2628 && s->size != 0);
2629}
2630
49fa1e15
AM		 2631/* Rummage through the relocs for SEC, looking for function calls.
2632 If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
2633 mark destination symbols on calls as being functions. Also
2634 look at branches, which may be tail calls or go to hot/cold
2635 section part of same function. */
2636
2637static bfd_boolean
2638mark_functions_via_relocs (asection *sec,
2639 struct bfd_link_info *info,
2640 int call_tree)
2641{
2642 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2ec9638b 2643 Elf_Internal_Shdr *symtab_hdr;
d0249648 2644 void *psyms;
cd4a7468 2645 unsigned int priority = 0;
49fa1e15
AM		 2646 static bfd_boolean warned;
2647
64615358 2648 if (!interesting_section (sec)
055ed83b
AM		 2649 || sec->reloc_count == 0)
2650 return TRUE;
2651
49fa1e15
AM		 2652 internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
2653 info->keep_memory);
2654 if (internal_relocs == NULL)
2655 return FALSE;
2656
2657 symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
d0249648 2658 psyms = &symtab_hdr->contents;
49fa1e15
AM		 2659 irela = internal_relocs;
2660 irelaend = irela + sec->reloc_count;
2661 for (; irela < irelaend; irela++)
2662 {
2663 enum elf_spu_reloc_type r_type;
2664 unsigned int r_indx;
2665 asection *sym_sec;
2666 Elf_Internal_Sym *sym;
2667 struct elf_link_hash_entry *h;
2668 bfd_vma val;
9dcc4794 2669 bfd_boolean reject, is_call;
49fa1e15
AM		 2670 struct function_info *caller;
2671 struct call_info *callee;
2672
9dcc4794 2673 reject = FALSE;
49fa1e15
AM		 2674 r_type = ELF32_R_TYPE (irela->r_info);
2675 if (r_type != R_SPU_REL16
2676 && r_type != R_SPU_ADDR16)
9dcc4794
AM		 2677 {
2678 reject = TRUE;
64615358 2679 if (!(call_tree && spu_hash_table (info)->params->auto_overlay))
9dcc4794
AM		 2680 continue;
2681 }
49fa1e15
AM		 2682
2683 r_indx = ELF32_R_SYM (irela->r_info);
2684 if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
2685 return FALSE;
2686
2687 if (sym_sec == NULL
64615358 2688 || sym_sec->output_section == bfd_abs_section_ptr)
49fa1e15
AM		 2689 continue;
2690
9dcc4794
AM		 2691 is_call = FALSE;
2692 if (!reject)
2693 {
2694 unsigned char insn[4];
2695
2696 if (!bfd_get_section_contents (sec->owner, sec, insn,
2697 irela->r_offset, 4))
2698 return FALSE;
2699 if (is_branch (insn))
2700 {
2701 is_call = (insn[0] & 0xfd) == 0x31;
cd4a7468
AM		 2702 priority = insn[1] & 0x0f;
2703 priority <<= 8;
2704 priority |= insn[2];
2705 priority <<= 8;
2706 priority |= insn[3];
2707 priority >>= 7;
9dcc4794
AM		 2708 if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2709 != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2710 {
2711 if (!warned)
2712 info->callbacks->einfo
2713 (_("%B(%A+0x%v): call to non-code section"
2714 " %B(%A), analysis incomplete\n"),
2715 sec->owner, sec, irela->r_offset,
2716 sym_sec->owner, sym_sec);
2717 warned = TRUE;
2718 continue;
2719 }
2720 }
2721 else
2722 {
2723 reject = TRUE;
64615358 2724 if (!(call_tree && spu_hash_table (info)->params->auto_overlay)
9dcc4794
AM		 2725 || is_hint (insn))
2726 continue;
2727 }
2728 }
49fa1e15 2729
9dcc4794 2730 if (reject)
49fa1e15 2731 {
9dcc4794
AM		 2732 /* For --auto-overlay, count possible stubs we need for
2733 function pointer references. */
2734 unsigned int sym_type;
2735 if (h)
2736 sym_type = h->type;
2737 else
2738 sym_type = ELF_ST_TYPE (sym->st_info);
2739 if (sym_type == STT_FUNC)
2740 spu_hash_table (info)->non_ovly_stub += 1;
49fa1e15
AM		 2741 continue;
2742 }
2743
49fa1e15
AM		 2744 if (h)
2745 val = h->root.u.def.value;
2746 else
2747 val = sym->st_value;
2748 val += irela->r_addend;
2749
2750 if (!call_tree)
2751 {
2752 struct function_info *fun;
2753
2754 if (irela->r_addend != 0)
2755 {
2756 Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
2757 if (fake == NULL)
2758 return FALSE;
2759 fake->st_value = val;
2760 fake->st_shndx
2761 = _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
2762 sym = fake;
2763 }
2764 if (sym)
2765 fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
2766 else
2767 fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
2768 if (fun == NULL)
2769 return FALSE;
2770 if (irela->r_addend != 0
2771 && fun->u.sym != sym)
2772 free (sym);
2773 continue;
2774 }
2775
2776 caller = find_function (sec, irela->r_offset, info);
2777 if (caller == NULL)
2778 return FALSE;
2779 callee = bfd_malloc (sizeof *callee);
2780 if (callee == NULL)
2781 return FALSE;
2782
2783 callee->fun = find_function (sym_sec, val, info);
2784 if (callee->fun == NULL)
2785 return FALSE;
2786 callee->is_tail = !is_call;
9dcc4794 2787 callee->is_pasted = FALSE;
9c4d0c1f 2788 callee->broken_cycle = FALSE;
cd4a7468 2789 callee->priority = priority;
34ad4cb0 2790 callee->count = 1;
9dcc4794
AM		 2791 if (callee->fun->last_caller != sec)
2792 {
2793 callee->fun->last_caller = sec;
2794 callee->fun->call_count += 1;
2795 }
49fa1e15
AM		 2796 if (!insert_callee (caller, callee))
2797 free (callee);
2798 else if (!is_call
2799 && !callee->fun->is_func
2800 && callee->fun->stack == 0)
2801 {
2802 /* This is either a tail call or a branch from one part of
2803 the function to another, ie. hot/cold section. If the
2804 destination has been called by some other function then
2805 it is a separate function. We also assume that functions
2806 are not split across input files. */
911f096e 2807 if (sec->owner != sym_sec->owner)
49fa1e15
AM		 2808 {
2809 callee->fun->start = NULL;
2810 callee->fun->is_func = TRUE;
2811 }
911f096e 2812 else if (callee->fun->start == NULL)
cc210763
UW		 2813 {
2814 struct function_info *caller_start = caller;
2815 while (caller_start->start)
2816 caller_start = caller_start->start;
2817
2818 if (caller_start != callee->fun)
2819 callee->fun->start = caller_start;
2820 }
911f096e
AM		 2821 else
2822 {
2823 struct function_info *callee_start;
2824 struct function_info *caller_start;
2825 callee_start = callee->fun;
2826 while (callee_start->start)
2827 callee_start = callee_start->start;
2828 caller_start = caller;
2829 while (caller_start->start)
2830 caller_start = caller_start->start;
2831 if (caller_start != callee_start)
2832 {
2833 callee->fun->start = NULL;
2834 callee->fun->is_func = TRUE;
2835 }
2836 }
49fa1e15
AM		 2837 }
2838 }
2839
2840 return TRUE;
2841}
2842
2843/* Handle something like .init or .fini, which has a piece of a function.
2844 These sections are pasted together to form a single function. */
2845
2846static bfd_boolean
3209bffa 2847pasted_function (asection *sec)
49fa1e15
AM		 2848{
2849 struct bfd_link_order *l;
2850 struct _spu_elf_section_data *sec_data;
2851 struct spu_elf_stack_info *sinfo;
2852 Elf_Internal_Sym *fake;
2853 struct function_info *fun, *fun_start;
2854
2855 fake = bfd_zmalloc (sizeof (*fake));
2856 if (fake == NULL)
2857 return FALSE;
2858 fake->st_value = 0;
2859 fake->st_size = sec->size;
2860 fake->st_shndx
2861 = _bfd_elf_section_from_bfd_section (sec->owner, sec);
2862 fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2863 if (!fun)
2864 return FALSE;
2865
2866 /* Find a function immediately preceding this section. */
2867 fun_start = NULL;
2868 for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2869 {
2870 if (l->u.indirect.section == sec)
2871 {
2872 if (fun_start != NULL)
9dcc4794
AM		 2873 {
2874 struct call_info *callee = bfd_malloc (sizeof *callee);
2875 if (callee == NULL)
2876 return FALSE;
2877
2878 fun->start = fun_start;
2879 callee->fun = fun;
2880 callee->is_tail = TRUE;
2881 callee->is_pasted = TRUE;
9c4d0c1f
AM		 2882 callee->broken_cycle = FALSE;
2883 callee->priority = 0;
34ad4cb0 2884 callee->count = 1;
9dcc4794
AM		 2885 if (!insert_callee (fun_start, callee))
2886 free (callee);
2887 return TRUE;
2888 }
2889 break;
49fa1e15
AM		 2890 }
2891 if (l->type == bfd_indirect_link_order
2892 && (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
47f6dab9 2893 && (sinfo = sec_data->u.i.stack_info) != NULL
49fa1e15
AM		 2894 && sinfo->num_fun != 0)
2895 fun_start = &sinfo->fun[sinfo->num_fun - 1];
2896 }
2897
3209bffa
AM		 2898 /* Don't return an error if we did not find a function preceding this
2899 section. The section may have incorrect flags. */
2900 return TRUE;
49fa1e15
AM		 2901}
2902
49fa1e15
AM		 2903/* Map address ranges in code sections to functions. */
2904
2905static bfd_boolean
c65be8d7 2906discover_functions (struct bfd_link_info *info)
49fa1e15 2907{
49fa1e15
AM		 2908 bfd *ibfd;
2909 int bfd_idx;
2910 Elf_Internal_Sym ***psym_arr;
2911 asection ***sec_arr;
2912 bfd_boolean gaps = FALSE;
2913
2914 bfd_idx = 0;
2915 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2916 bfd_idx++;
2917
2918 psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2919 if (psym_arr == NULL)
2920 return FALSE;
2921 sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2922 if (sec_arr == NULL)
2923 return FALSE;
49fa1e15
AM		 2924
2925 for (ibfd = info->input_bfds, bfd_idx = 0;
2926 ibfd != NULL;
2927 ibfd = ibfd->link_next, bfd_idx++)
2928 {
2929 extern const bfd_target bfd_elf32_spu_vec;
2930 Elf_Internal_Shdr *symtab_hdr;
2931 asection *sec;
2932 size_t symcount;
2933 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2934 asection **psecs, **p;
2935
2936 if (ibfd->xvec != &bfd_elf32_spu_vec)
2937 continue;
2938
2939 /* Read all the symbols. */
2940 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2941 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2942 if (symcount == 0)
055ed83b
AM		 2943 {
2944 if (!gaps)
2945 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
64615358 2946 if (interesting_section (sec))
055ed83b
AM		 2947 {
2948 gaps = TRUE;
2949 break;
2950 }
2951 continue;
2952 }
49fa1e15 2953
1f27ab8d 2954 if (symtab_hdr->contents != NULL)
49fa1e15 2955 {
1f27ab8d
AM		 2956 /* Don't use cached symbols since the generic ELF linker
2957 code only reads local symbols, and we need globals too. */
2958 free (symtab_hdr->contents);
2959 symtab_hdr->contents = NULL;
49fa1e15 2960 }
1f27ab8d
AM		 2961 syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2962 NULL, NULL, NULL);
2963 symtab_hdr->contents = (void *) syms;
2964 if (syms == NULL)
2965 return FALSE;
49fa1e15
AM		 2966
2967 /* Select defined function symbols that are going to be output. */
2968 psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2969 if (psyms == NULL)
2970 return FALSE;
2971 psym_arr[bfd_idx] = psyms;
2972 psecs = bfd_malloc (symcount * sizeof (*psecs));
2973 if (psecs == NULL)
2974 return FALSE;
2975 sec_arr[bfd_idx] = psecs;
2976 for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
2977 if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
3209bffa 2978 || ELF_ST_TYPE (sy->st_info) == STT_FUNC)
49fa1e15
AM		 2979 {
2980 asection *s;
2981
2982 *p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
64615358 2983 if (s != NULL && interesting_section (s))
49fa1e15
AM		 2984 *psy++ = sy;
2985 }
2986 symcount = psy - psyms;
2987 *psy = NULL;
2988
2989 /* Sort them by section and offset within section. */
2990 sort_syms_syms = syms;
2991 sort_syms_psecs = psecs;
2992 qsort (psyms, symcount, sizeof (*psyms), sort_syms);
2993
2994 /* Now inspect the function symbols. */
2995 for (psy = psyms; psy < psyms + symcount; )
2996 {
2997 asection *s = psecs[*psy - syms];
2998 Elf_Internal_Sym **psy2;
2999
3000 for (psy2 = psy; ++psy2 < psyms + symcount; )
3001 if (psecs[*psy2 - syms] != s)
3002 break;
3003
3004 if (!alloc_stack_info (s, psy2 - psy))
3005 return FALSE;
3006 psy = psy2;
3007 }
3008
3009 /* First install info about properly typed and sized functions.
3010 In an ideal world this will cover all code sections, except
3011 when partitioning functions into hot and cold sections,
3012 and the horrible pasted together .init and .fini functions. */
3013 for (psy = psyms; psy < psyms + symcount; ++psy)
3014 {
3015 sy = *psy;
3016 if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
3017 {
3018 asection *s = psecs[sy - syms];
3019 if (!maybe_insert_function (s, sy, FALSE, TRUE))
3020 return FALSE;
3021 }
3022 }
3023
3024 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
64615358 3025 if (interesting_section (sec))
49fa1e15
AM		 3026 gaps |= check_function_ranges (sec, info);
3027 }
3028
3029 if (gaps)
3030 {
3031 /* See if we can discover more function symbols by looking at
3032 relocations. */
3033 for (ibfd = info->input_bfds, bfd_idx = 0;
3034 ibfd != NULL;
3035 ibfd = ibfd->link_next, bfd_idx++)
3036 {
3037 asection *sec;
3038
3039 if (psym_arr[bfd_idx] == NULL)
3040 continue;
3041
3042 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
055ed83b
AM		 3043 if (!mark_functions_via_relocs (sec, info, FALSE))
3044 return FALSE;
49fa1e15
AM		 3045 }
3046
3047 for (ibfd = info->input_bfds, bfd_idx = 0;
3048 ibfd != NULL;
3049 ibfd = ibfd->link_next, bfd_idx++)
3050 {
3051 Elf_Internal_Shdr *symtab_hdr;
3052 asection *sec;
3053 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
3054 asection **psecs;
3055
3056 if ((psyms = psym_arr[bfd_idx]) == NULL)
3057 continue;
3058
3059 psecs = sec_arr[bfd_idx];
3060
3061 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3062 syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3063
3064 gaps = FALSE;
3065 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
64615358 3066 if (interesting_section (sec))
49fa1e15
AM		 3067 gaps |= check_function_ranges (sec, info);
3068 if (!gaps)
3069 continue;
3070
3071 /* Finally, install all globals. */
3072 for (psy = psyms; (sy = *psy) != NULL; ++psy)
3073 {
3074 asection *s;
3075
3076 s = psecs[sy - syms];
3077
3078 /* Global syms might be improperly typed functions. */
3079 if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
3080 && ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
3081 {
3082 if (!maybe_insert_function (s, sy, FALSE, FALSE))
3083 return FALSE;
3084 }
3085 }
055ed83b
AM		 3086 }
3087
3088 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3089 {
3090 extern const bfd_target bfd_elf32_spu_vec;
3091 asection *sec;
3092
3093 if (ibfd->xvec != &bfd_elf32_spu_vec)
3094 continue;
49fa1e15
AM		 3095
3096 /* Some of the symbols we've installed as marking the
3097 beginning of functions may have a size of zero. Extend
3098 the range of such functions to the beginning of the
3099 next symbol of interest. */
3100 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
64615358 3101 if (interesting_section (sec))
49fa1e15
AM		 3102 {
3103 struct _spu_elf_section_data *sec_data;
3104 struct spu_elf_stack_info *sinfo;
3105
3106 sec_data = spu_elf_section_data (sec);
47f6dab9 3107 sinfo = sec_data->u.i.stack_info;
3209bffa 3108 if (sinfo != NULL && sinfo->num_fun != 0)
49fa1e15
AM		 3109 {
3110 int fun_idx;
3111 bfd_vma hi = sec->size;
3112
3113 for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
3114 {
3115 sinfo->fun[fun_idx].hi = hi;
3116 hi = sinfo->fun[fun_idx].lo;
3117 }
3209bffa
AM		 3118
3119 sinfo->fun[0].lo = 0;
49fa1e15
AM		 3120 }
3121 /* No symbols in this section. Must be .init or .fini
3122 or something similar. */
3209bffa 3123 else if (!pasted_function (sec))
49fa1e15
AM		 3124 return FALSE;
3125 }
3126 }
3127 }
3128
3129 for (ibfd = info->input_bfds, bfd_idx = 0;
3130 ibfd != NULL;
3131 ibfd = ibfd->link_next, bfd_idx++)
3132 {
3133 if (psym_arr[bfd_idx] == NULL)
3134 continue;
3135
3136 free (psym_arr[bfd_idx]);
3137 free (sec_arr[bfd_idx]);
3138 }
3139
3140 free (psym_arr);
3141 free (sec_arr);
3142
3143 return TRUE;
3144}
3145
055ed83b
AM		 3146/* Iterate over all function_info we have collected, calling DOIT on
3147 each node if ROOT_ONLY is false. Only call DOIT on root nodes
3148 if ROOT_ONLY. */
3149
3150static bfd_boolean
3151for_each_node (bfd_boolean (*doit) (struct function_info *,
3152 struct bfd_link_info *,
3153 void *),
3154 struct bfd_link_info *info,
3155 void *param,
3156 int root_only)
3157{
3158 bfd *ibfd;
3159
3160 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3161 {
3162 extern const bfd_target bfd_elf32_spu_vec;
3163 asection *sec;
3164
3165 if (ibfd->xvec != &bfd_elf32_spu_vec)
3166 continue;
3167
3168 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3169 {
3170 struct _spu_elf_section_data *sec_data;
3171 struct spu_elf_stack_info *sinfo;
3172
3173 if ((sec_data = spu_elf_section_data (sec)) != NULL
3174 && (sinfo = sec_data->u.i.stack_info) != NULL)
3175 {
3176 int i;
3177 for (i = 0; i < sinfo->num_fun; ++i)
3178 if (!root_only || !sinfo->fun[i].non_root)
3179 if (!doit (&sinfo->fun[i], info, param))
3180 return FALSE;
3181 }
3182 }
3183 }
3184 return TRUE;
3185}
3186
3187/* Transfer call info attached to struct function_info entries for
3188 all of a given function's sections to the first entry. */
3189
3190static bfd_boolean
3191transfer_calls (struct function_info *fun,
3192 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3193 void *param ATTRIBUTE_UNUSED)
3194{
3195 struct function_info *start = fun->start;
3196
3197 if (start != NULL)
3198 {
3199 struct call_info *call, *call_next;
3200
3201 while (start->start != NULL)
3202 start = start->start;
3203 for (call = fun->call_list; call != NULL; call = call_next)
3204 {
3205 call_next = call->next;
3206 if (!insert_callee (start, call))
3207 free (call);
3208 }
3209 fun->call_list = NULL;
3210 }
3211 return TRUE;
3212}
3213
49fa1e15
AM		 3214/* Mark nodes in the call graph that are called by some other node. */
3215
055ed83b
AM		 3216static bfd_boolean
3217mark_non_root (struct function_info *fun,
3218 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3219 void *param ATTRIBUTE_UNUSED)
49fa1e15
AM		 3220{
3221 struct call_info *call;
3222
055ed83b
AM		 3223 if (fun->visit1)
3224 return TRUE;
49fa1e15
AM		 3225 fun->visit1 = TRUE;
3226 for (call = fun->call_list; call; call = call->next)
3227 {
3228 call->fun->non_root = TRUE;
055ed83b 3229 mark_non_root (call->fun, 0, 0);
49fa1e15 3230 }
055ed83b 3231 return TRUE;
49fa1e15
AM		 3232}
3233
9dcc4794 3234/* Remove cycles from the call graph. Set depth of nodes. */
49fa1e15 3235
055ed83b
AM		 3236static bfd_boolean
3237remove_cycles (struct function_info *fun,
3238 struct bfd_link_info *info,
9dcc4794 3239 void *param)
49fa1e15
AM		 3240{
3241 struct call_info **callp, *call;
9dcc4794
AM		 3242 unsigned int depth = *(unsigned int *) param;
3243 unsigned int max_depth = depth;
49fa1e15 3244
9dcc4794 3245 fun->depth = depth;
49fa1e15
AM		 3246 fun->visit2 = TRUE;
3247 fun->marking = TRUE;
3248
3249 callp = &fun->call_list;
3250 while ((call = *callp) != NULL)
3251 {
25076afa 3252 call->max_depth = depth + !call->is_pasted;
49fa1e15 3253 if (!call->fun->visit2)
055ed83b 3254 {
9dcc4794 3255 if (!remove_cycles (call->fun, info, &call->max_depth))
055ed83b 3256 return FALSE;
9dcc4794
AM		 3257 if (max_depth < call->max_depth)
3258 max_depth = call->max_depth;
055ed83b 3259 }
49fa1e15
AM		 3260 else if (call->fun->marking)
3261 {
cd4a7468
AM		 3262 struct spu_link_hash_table *htab = spu_hash_table (info);
3263
3264 if (!htab->params->auto_overlay
3265 && htab->params->stack_analysis)
9dcc4794
AM		 3266 {
3267 const char *f1 = func_name (fun);
3268 const char *f2 = func_name (call->fun);
49fa1e15 3269
9dcc4794
AM		 3270 info->callbacks->info (_("Stack analysis will ignore the call "
3271 "from %s to %s\n"),
3272 f1, f2);
3273 }
5ebe2858
UW		 3274
3275 call->broken_cycle = TRUE;
49fa1e15
AM		 3276 }
3277 callp = &call->next;
3278 }
3279 fun->marking = FALSE;
9dcc4794 3280 *(unsigned int *) param = max_depth;
055ed83b 3281 return TRUE;
49fa1e15
AM		 3282}
3283
667f3338
AM		 3284/* Check that we actually visited all nodes in remove_cycles. If we
3285 didn't, then there is some cycle in the call graph not attached to
3286 any root node. Arbitrarily choose a node in the cycle as a new
3287 root and break the cycle. */
3288
3289static bfd_boolean
3290mark_detached_root (struct function_info *fun,
3291 struct bfd_link_info *info,
3292 void *param)
3293{
3294 if (fun->visit2)
3295 return TRUE;
3296 fun->non_root = FALSE;
3297 *(unsigned int *) param = 0;
3298 return remove_cycles (fun, info, param);
3299}
3300
49fa1e15
AM		 3301/* Populate call_list for each function. */
3302
3303static bfd_boolean
c65be8d7 3304build_call_tree (struct bfd_link_info *info)
49fa1e15 3305{
49fa1e15 3306 bfd *ibfd;
9dcc4794 3307 unsigned int depth;
49fa1e15
AM		 3308
3309 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3310 {
3311 extern const bfd_target bfd_elf32_spu_vec;
3312 asection *sec;
3313
3314 if (ibfd->xvec != &bfd_elf32_spu_vec)
3315 continue;
3316
3317 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
055ed83b
AM		 3318 if (!mark_functions_via_relocs (sec, info, TRUE))
3319 return FALSE;
49fa1e15
AM		 3320 }
3321
055ed83b
AM		 3322 /* Transfer call info from hot/cold section part of function
3323 to main entry. */
64615358 3324 if (!spu_hash_table (info)->params->auto_overlay
9dcc4794 3325 && !for_each_node (transfer_calls, info, 0, FALSE))
055ed83b 3326 return FALSE;
49fa1e15 3327
055ed83b
AM		 3328 /* Find the call graph root(s). */
3329 if (!for_each_node (mark_non_root, info, 0, FALSE))
3330 return FALSE;
49fa1e15
AM		 3331
3332 /* Remove cycles from the call graph. We start from the root node(s)
3333 so that we break cycles in a reasonable place. */
9dcc4794 3334 depth = 0;
667f3338
AM		 3335 if (!for_each_node (remove_cycles, info, &depth, TRUE))
3336 return FALSE;
3337
3338 return for_each_node (mark_detached_root, info, &depth, FALSE);
9dcc4794
AM		 3339}
3340
cd4a7468 3341/* qsort predicate to sort calls by priority, max_depth then count. */
9dcc4794
AM		 3342
3343static int
3344sort_calls (const void *a, const void *b)
3345{
3346 struct call_info *const *c1 = a;
3347 struct call_info *const *c2 = b;
3348 int delta;
3349
cd4a7468
AM		 3350 delta = (*c2)->priority - (*c1)->priority;
3351 if (delta != 0)
3352 return delta;
3353
9dcc4794
AM		 3354 delta = (*c2)->max_depth - (*c1)->max_depth;
3355 if (delta != 0)
3356 return delta;
3357
3358 delta = (*c2)->count - (*c1)->count;
3359 if (delta != 0)
3360 return delta;
3361
667f3338 3362 return (char *) c1 - (char *) c2;
9dcc4794
AM		 3363}
3364
3365struct _mos_param {
3366 unsigned int max_overlay_size;
3367};
3368
3369/* Set linker_mark and gc_mark on any sections that we will put in
3370 overlays. These flags are used by the generic ELF linker, but we
3371 won't be continuing on to bfd_elf_final_link so it is OK to use
3372 them. linker_mark is clear before we get here. Set segment_mark
3373 on sections that are part of a pasted function (excluding the last
3374 section).
3375
3376 Set up function rodata section if --overlay-rodata. We don't
3377 currently include merged string constant rodata sections since
3378
3379 Sort the call graph so that the deepest nodes will be visited
3380 first. */
3381
3382static bfd_boolean
3383mark_overlay_section (struct function_info *fun,
3384 struct bfd_link_info *info,
3385 void *param)
3386{
3387 struct call_info *call;
3388 unsigned int count;
3389 struct _mos_param *mos_param = param;
fb266b8b 3390 struct spu_link_hash_table *htab = spu_hash_table (info);
9dcc4794
AM		 3391
3392 if (fun->visit4)
3393 return TRUE;
3394
3395 fun->visit4 = TRUE;
fb266b8b
AM		 3396 if (!fun->sec->linker_mark
3397 && (htab->params->ovly_flavour != ovly_soft_icache
3398 || htab->params->non_ia_text
335bd8f2
UW		 3399 || strncmp (fun->sec->name, ".text.ia.", 9) == 0
3400 || strcmp (fun->sec->name, ".init") == 0
3401 || strcmp (fun->sec->name, ".fini") == 0))
9dcc4794 3402 {
4f0d75be
AM		 3403 unsigned int size;
3404
9dcc4794
AM		 3405 fun->sec->linker_mark = 1;
3406 fun->sec->gc_mark = 1;
3407 fun->sec->segment_mark = 0;
3408 /* Ensure SEC_CODE is set on this text section (it ought to
3409 be!), and SEC_CODE is clear on rodata sections. We use
3410 this flag to differentiate the two overlay section types. */
3411 fun->sec->flags |= SEC_CODE;
4f0d75be 3412
fb266b8b
AM		 3413 size = fun->sec->size;
3414 if (htab->params->auto_overlay & OVERLAY_RODATA)
9dcc4794
AM		 3415 {
3416 char *name = NULL;
9dcc4794
AM		 3417
3418 /* Find the rodata section corresponding to this function's
3419 text section. */
3420 if (strcmp (fun->sec->name, ".text") == 0)
3421 {
3422 name = bfd_malloc (sizeof (".rodata"));
3423 if (name == NULL)
3424 return FALSE;
3425 memcpy (name, ".rodata", sizeof (".rodata"));
3426 }
3427 else if (strncmp (fun->sec->name, ".text.", 6) == 0)
3428 {
3429 size_t len = strlen (fun->sec->name);
3430 name = bfd_malloc (len + 3);
3431 if (name == NULL)
3432 return FALSE;
3433 memcpy (name, ".rodata", sizeof (".rodata"));
3434 memcpy (name + 7, fun->sec->name + 5, len - 4);
3435 }
3436 else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
3437 {
3438 size_t len = strlen (fun->sec->name) + 1;
3439 name = bfd_malloc (len);
3440 if (name == NULL)
3441 return FALSE;
3442 memcpy (name, fun->sec->name, len);
3443 name[14] = 'r';
3444 }
3445
3446 if (name != NULL)
3447 {
3448 asection *rodata = NULL;
3449 asection *group_sec = elf_section_data (fun->sec)->next_in_group;
3450 if (group_sec == NULL)
3451 rodata = bfd_get_section_by_name (fun->sec->owner, name);
3452 else
3453 while (group_sec != NULL && group_sec != fun->sec)
3454 {
3455 if (strcmp (group_sec->name, name) == 0)
3456 {
3457 rodata = group_sec;
3458 break;
3459 }
3460 group_sec = elf_section_data (group_sec)->next_in_group;
3461 }
3462 fun->rodata = rodata;
3463 if (fun->rodata)
3464 {
fb266b8b
AM		 3465 size += fun->rodata->size;
3466 if (htab->params->line_size != 0
3467 && size > htab->params->line_size)
3468 {
3469 size -= fun->rodata->size;
3470 fun->rodata = NULL;
3471 }
3472 else
3473 {
3474 fun->rodata->linker_mark = 1;
3475 fun->rodata->gc_mark = 1;
3476 fun->rodata->flags &= ~SEC_CODE;
3477 }
9dcc4794
AM		 3478 }
3479 free (name);
3480 }
9dcc4794 3481 }
4f0d75be
AM		 3482 if (mos_param->max_overlay_size < size)
3483 mos_param->max_overlay_size = size;
9dcc4794
AM		 3484 }
3485
3486 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3487 count += 1;
3488
3489 if (count > 1)
3490 {
3491 struct call_info **calls = bfd_malloc (count * sizeof (*calls));
3492 if (calls == NULL)
3493 return FALSE;
3494
3495 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3496 calls[count++] = call;
3497
3498 qsort (calls, count, sizeof (*calls), sort_calls);
3499
3500 fun->call_list = NULL;
3501 while (count != 0)
3502 {
3503 --count;
3504 calls[count]->next = fun->call_list;
3505 fun->call_list = calls[count];
3506 }
3507 free (calls);
3508 }
3509
3510 for (call = fun->call_list; call != NULL; call = call->next)
3511 {
3512 if (call->is_pasted)
3513 {
3514 /* There can only be one is_pasted call per function_info. */
3515 BFD_ASSERT (!fun->sec->segment_mark);
3516 fun->sec->segment_mark = 1;
3517 }
5ebe2858
UW		 3518 if (!call->broken_cycle
3519 && !mark_overlay_section (call->fun, info, param))
9dcc4794
AM		 3520 return FALSE;
3521 }
3522
3523 /* Don't put entry code into an overlay. The overlay manager needs
cd4a7468 3524 a stack! Also, don't mark .ovl.init as an overlay. */
9dcc4794 3525 if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
cd4a7468
AM		 3526 == info->output_bfd->start_address
3527 || strncmp (fun->sec->output_section->name, ".ovl.init", 9) == 0)
9dcc4794
AM		 3528 {
3529 fun->sec->linker_mark = 0;
3530 if (fun->rodata != NULL)
3531 fun->rodata->linker_mark = 0;
3532 }
3533 return TRUE;
3534}
3535
99302af9
AM		 3536/* If non-zero then unmark functions called from those within sections
3537 that we need to unmark. Unfortunately this isn't reliable since the
3538 call graph cannot know the destination of function pointer calls. */
3539#define RECURSE_UNMARK 0
3540
9dcc4794
AM		 3541struct _uos_param {
3542 asection *exclude_input_section;
3543 asection *exclude_output_section;
3544 unsigned long clearing;
3545};
3546
3547/* Undo some of mark_overlay_section's work. */
3548
3549static bfd_boolean
3550unmark_overlay_section (struct function_info *fun,
3551 struct bfd_link_info *info,
3552 void *param)
3553{
3554 struct call_info *call;
3555 struct _uos_param *uos_param = param;
3556 unsigned int excluded = 0;
3557
3558 if (fun->visit5)
3559 return TRUE;
3560
3561 fun->visit5 = TRUE;
3562
3563 excluded = 0;
3564 if (fun->sec == uos_param->exclude_input_section
3565 || fun->sec->output_section == uos_param->exclude_output_section)
3566 excluded = 1;
3567
99302af9
AM		 3568 if (RECURSE_UNMARK)
3569 uos_param->clearing += excluded;
9dcc4794 3570
99302af9 3571 if (RECURSE_UNMARK ? uos_param->clearing : excluded)
9dcc4794
AM		 3572 {
3573 fun->sec->linker_mark = 0;
3574 if (fun->rodata)
3575 fun->rodata->linker_mark = 0;
3576 }
3577
3578 for (call = fun->call_list; call != NULL; call = call->next)
5ebe2858
UW		 3579 if (!call->broken_cycle
3580 && !unmark_overlay_section (call->fun, info, param))
9dcc4794
AM		 3581 return FALSE;
3582
99302af9
AM		 3583 if (RECURSE_UNMARK)
3584 uos_param->clearing -= excluded;
9dcc4794
AM		 3585 return TRUE;
3586}
3587
3588struct _cl_param {
3589 unsigned int lib_size;
3590 asection **lib_sections;
3591};
3592
3593/* Add sections we have marked as belonging to overlays to an array
3594 for consideration as non-overlay sections. The array consist of
3595 pairs of sections, (text,rodata), for functions in the call graph. */
3596
3597static bfd_boolean
3598collect_lib_sections (struct function_info *fun,
3599 struct bfd_link_info *info,
3600 void *param)
3601{
3602 struct _cl_param *lib_param = param;
3603 struct call_info *call;
3604 unsigned int size;
3605
3606 if (fun->visit6)
3607 return TRUE;
3608
3609 fun->visit6 = TRUE;
3610 if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
3611 return TRUE;
3612
3613 size = fun->sec->size;
3614 if (fun->rodata)
3615 size += fun->rodata->size;
cd4a7468 3616
b0c41709 3617 if (size <= lib_param->lib_size)
9dcc4794 3618 {
b0c41709
AM		 3619 *lib_param->lib_sections++ = fun->sec;
3620 fun->sec->gc_mark = 0;
3621 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3622 {
3623 *lib_param->lib_sections++ = fun->rodata;
3624 fun->rodata->gc_mark = 0;
3625 }
3626 else
3627 *lib_param->lib_sections++ = NULL;
9dcc4794 3628 }
9dcc4794
AM		 3629
3630 for (call = fun->call_list; call != NULL; call = call->next)
5ebe2858
UW		 3631 if (!call->broken_cycle)
3632 collect_lib_sections (call->fun, info, param);
9dcc4794
AM		 3633
3634 return TRUE;
3635}
3636
3637/* qsort predicate to sort sections by call count. */
3638
3639static int
3640sort_lib (const void *a, const void *b)
3641{
3642 asection *const *s1 = a;
3643 asection *const *s2 = b;
3644 struct _spu_elf_section_data *sec_data;
3645 struct spu_elf_stack_info *sinfo;
3646 int delta;
3647
3648 delta = 0;
3649 if ((sec_data = spu_elf_section_data (*s1)) != NULL
3650 && (sinfo = sec_data->u.i.stack_info) != NULL)
3651 {
3652 int i;
3653 for (i = 0; i < sinfo->num_fun; ++i)
3654 delta -= sinfo->fun[i].call_count;
3655 }
3656
3657 if ((sec_data = spu_elf_section_data (*s2)) != NULL
3658 && (sinfo = sec_data->u.i.stack_info) != NULL)
3659 {
3660 int i;
3661 for (i = 0; i < sinfo->num_fun; ++i)
3662 delta += sinfo->fun[i].call_count;
3663 }
3664
3665 if (delta != 0)
3666 return delta;
3667
3668 return s1 - s2;
3669}
3670
3671/* Remove some sections from those marked to be in overlays. Choose
3672 those that are called from many places, likely library functions. */
3673
3674static unsigned int
3675auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3676{
3677 bfd *ibfd;
3678 asection **lib_sections;
3679 unsigned int i, lib_count;
3680 struct _cl_param collect_lib_param;
3681 struct function_info dummy_caller;
64615358 3682 struct spu_link_hash_table *htab;
9dcc4794
AM		 3683
3684 memset (&dummy_caller, 0, sizeof (dummy_caller));
3685 lib_count = 0;
3686 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3687 {
3688 extern const bfd_target bfd_elf32_spu_vec;
3689 asection *sec;
3690
3691 if (ibfd->xvec != &bfd_elf32_spu_vec)
3692 continue;
3693
3694 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3695 if (sec->linker_mark
3696 && sec->size < lib_size
3697 && (sec->flags & SEC_CODE) != 0)
3698 lib_count += 1;
3699 }
3700 lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3701 if (lib_sections == NULL)
3702 return (unsigned int) -1;
3703 collect_lib_param.lib_size = lib_size;
3704 collect_lib_param.lib_sections = lib_sections;
3705 if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3706 TRUE))
3707 return (unsigned int) -1;
3708 lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3709
3710 /* Sort sections so that those with the most calls are first. */
3711 if (lib_count > 1)
3712 qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3713
64615358 3714 htab = spu_hash_table (info);
9dcc4794
AM		 3715 for (i = 0; i < lib_count; i++)
3716 {
3717 unsigned int tmp, stub_size;
3718 asection *sec;
3719 struct _spu_elf_section_data *sec_data;
3720 struct spu_elf_stack_info *sinfo;
3721
3722 sec = lib_sections[2 * i];
3723 /* If this section is OK, its size must be less than lib_size. */
3724 tmp = sec->size;
3725 /* If it has a rodata section, then add that too. */
3726 if (lib_sections[2 * i + 1])
3727 tmp += lib_sections[2 * i + 1]->size;
3728 /* Add any new overlay call stubs needed by the section. */
3729 stub_size = 0;
3730 if (tmp < lib_size
3731 && (sec_data = spu_elf_section_data (sec)) != NULL
3732 && (sinfo = sec_data->u.i.stack_info) != NULL)
3733 {
3734 int k;
3735 struct call_info *call;
3736
3737 for (k = 0; k < sinfo->num_fun; ++k)
3738 for (call = sinfo->fun[k].call_list; call; call = call->next)
3739 if (call->fun->sec->linker_mark)
3740 {
3741 struct call_info *p;
3742 for (p = dummy_caller.call_list; p; p = p->next)
3743 if (p->fun == call->fun)
3744 break;
3745 if (!p)
a7e11ee1 3746 stub_size += ovl_stub_size (htab->params);
9dcc4794
AM		 3747 }
3748 }
3749 if (tmp + stub_size < lib_size)
3750 {
3751 struct call_info **pp, *p;
3752
3753 /* This section fits. Mark it as non-overlay. */
3754 lib_sections[2 * i]->linker_mark = 0;
3755 if (lib_sections[2 * i + 1])
3756 lib_sections[2 * i + 1]->linker_mark = 0;
3757 lib_size -= tmp + stub_size;
3758 /* Call stubs to the section we just added are no longer
3759 needed. */
3760 pp = &dummy_caller.call_list;
3761 while ((p = *pp) != NULL)
3762 if (!p->fun->sec->linker_mark)
3763 {
a7e11ee1 3764 lib_size += ovl_stub_size (htab->params);
9dcc4794
AM		 3765 *pp = p->next;
3766 free (p);
3767 }
3768 else
3769 pp = &p->next;
3770 /* Add new call stubs to dummy_caller. */
3771 if ((sec_data = spu_elf_section_data (sec)) != NULL
3772 && (sinfo = sec_data->u.i.stack_info) != NULL)
3773 {
3774 int k;
3775 struct call_info *call;
3776
3777 for (k = 0; k < sinfo->num_fun; ++k)
3778 for (call = sinfo->fun[k].call_list;
3779 call;
3780 call = call->next)
3781 if (call->fun->sec->linker_mark)
3782 {
3783 struct call_info *callee;
3784 callee = bfd_malloc (sizeof (*callee));
3785 if (callee == NULL)
3786 return (unsigned int) -1;
3787 *callee = *call;
3788 if (!insert_callee (&dummy_caller, callee))
3789 free (callee);
3790 }
3791 }
3792 }
3793 }
3794 while (dummy_caller.call_list != NULL)
3795 {
3796 struct call_info *call = dummy_caller.call_list;
3797 dummy_caller.call_list = call->next;
3798 free (call);
3799 }
3800 for (i = 0; i < 2 * lib_count; i++)
3801 if (lib_sections[i])
3802 lib_sections[i]->gc_mark = 1;
3803 free (lib_sections);
3804 return lib_size;
3805}
3806
3807/* Build an array of overlay sections. The deepest node's section is
2ec9638b 3808 added first, then its parent node's section, then everything called
9dcc4794
AM		 3809 from the parent section. The idea being to group sections to
3810 minimise calls between different overlays. */
3811
3812static bfd_boolean
3813collect_overlays (struct function_info *fun,
3814 struct bfd_link_info *info,
3815 void *param)
3816{
3817 struct call_info *call;
3818 bfd_boolean added_fun;
3819 asection ***ovly_sections = param;
3820
3821 if (fun->visit7)
3822 return TRUE;
3823
3824 fun->visit7 = TRUE;
3825 for (call = fun->call_list; call != NULL; call = call->next)
5ebe2858 3826 if (!call->is_pasted && !call->broken_cycle)
9dcc4794
AM		 3827 {
3828 if (!collect_overlays (call->fun, info, ovly_sections))
3829 return FALSE;
3830 break;
3831 }
3832
3833 added_fun = FALSE;
3834 if (fun->sec->linker_mark && fun->sec->gc_mark)
3835 {
3836 fun->sec->gc_mark = 0;
3837 *(*ovly_sections)++ = fun->sec;
3838 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3839 {
3840 fun->rodata->gc_mark = 0;
3841 *(*ovly_sections)++ = fun->rodata;
3842 }
3843 else
3844 *(*ovly_sections)++ = NULL;
3845 added_fun = TRUE;
3846
3847 /* Pasted sections must stay with the first section. We don't
3848 put pasted sections in the array, just the first section.
3849 Mark subsequent sections as already considered. */
3850 if (fun->sec->segment_mark)
3851 {
3852 struct function_info *call_fun = fun;
3853 do
3854 {
3855 for (call = call_fun->call_list; call != NULL; call = call->next)
3856 if (call->is_pasted)
3857 {
3858 call_fun = call->fun;
3859 call_fun->sec->gc_mark = 0;
3860 if (call_fun->rodata)
3861 call_fun->rodata->gc_mark = 0;
3862 break;
3863 }
3864 if (call == NULL)
3865 abort ();
3866 }
3867 while (call_fun->sec->segment_mark);
3868 }
3869 }
3870
3871 for (call = fun->call_list; call != NULL; call = call->next)
5ebe2858
UW		 3872 if (!call->broken_cycle
3873 && !collect_overlays (call->fun, info, ovly_sections))
9dcc4794
AM		 3874 return FALSE;
3875
3876 if (added_fun)
3877 {
3878 struct _spu_elf_section_data *sec_data;
3879 struct spu_elf_stack_info *sinfo;
3880
3881 if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3882 && (sinfo = sec_data->u.i.stack_info) != NULL)
3883 {
3884 int i;
3885 for (i = 0; i < sinfo->num_fun; ++i)
3886 if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3887 return FALSE;
3888 }
3889 }
3890
3891 return TRUE;
49fa1e15
AM		 3892}
3893
055ed83b
AM		 3894struct _sum_stack_param {
3895 size_t cum_stack;
3896 size_t overall_stack;
3897 bfd_boolean emit_stack_syms;
3898};
3899
49fa1e15
AM		 3900/* Descend the call graph for FUN, accumulating total stack required. */
3901
055ed83b 3902static bfd_boolean
49fa1e15
AM		 3903sum_stack (struct function_info *fun,
3904 struct bfd_link_info *info,
055ed83b 3905 void *param)
49fa1e15
AM		 3906{
3907 struct call_info *call;
055ed83b
AM		 3908 struct function_info *max;
3909 size_t stack, cum_stack;
49fa1e15 3910 const char *f1;
9dcc4794 3911 bfd_boolean has_call;
055ed83b 3912 struct _sum_stack_param *sum_stack_param = param;
9dcc4794 3913 struct spu_link_hash_table *htab;
49fa1e15 3914
055ed83b
AM		 3915 cum_stack = fun->stack;
3916 sum_stack_param->cum_stack = cum_stack;
49fa1e15 3917 if (fun->visit3)
055ed83b 3918 return TRUE;
49fa1e15 3919
9dcc4794 3920 has_call = FALSE;
055ed83b 3921 max = NULL;
49fa1e15
AM		 3922 for (call = fun->call_list; call; call = call->next)
3923 {
5ebe2858
UW		 3924 if (call->broken_cycle)
3925 continue;
9dcc4794
AM		 3926 if (!call->is_pasted)
3927 has_call = TRUE;
055ed83b
AM		 3928 if (!sum_stack (call->fun, info, sum_stack_param))
3929 return FALSE;
3930 stack = sum_stack_param->cum_stack;
49fa1e15
AM		 3931 /* Include caller stack for normal calls, don't do so for
3932 tail calls. fun->stack here is local stack usage for
3933 this function. */
9dcc4794 3934 if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
49fa1e15 3935 stack += fun->stack;
055ed83b 3936 if (cum_stack < stack)
49fa1e15 3937 {
055ed83b 3938 cum_stack = stack;
49fa1e15
AM		 3939 max = call->fun;
3940 }
3941 }
3942
055ed83b
AM		 3943 sum_stack_param->cum_stack = cum_stack;
3944 stack = fun->stack;
3945 /* Now fun->stack holds cumulative stack. */
3946 fun->stack = cum_stack;
3947 fun->visit3 = TRUE;
3948
3949 if (!fun->non_root
3950 && sum_stack_param->overall_stack < cum_stack)
3951 sum_stack_param->overall_stack = cum_stack;
3952
9dcc4794 3953 htab = spu_hash_table (info);
64615358 3954 if (htab->params->auto_overlay)
9dcc4794
AM		 3955 return TRUE;
3956
49fa1e15 3957 f1 = func_name (fun);
cd4a7468 3958 if (htab->params->stack_analysis)
49fa1e15 3959 {
cd4a7468
AM		 3960 if (!fun->non_root)
3961 info->callbacks->info (_(" %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
3962 info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
3963 f1, (bfd_vma) stack, (bfd_vma) cum_stack);
49fa1e15 3964
cd4a7468
AM		 3965 if (has_call)
3966 {
3967 info->callbacks->minfo (_(" calls:\n"));
3968 for (call = fun->call_list; call; call = call->next)
5ebe2858 3969 if (!call->is_pasted && !call->broken_cycle)
cd4a7468
AM		 3970 {
3971 const char *f2 = func_name (call->fun);
3972 const char *ann1 = call->fun == max ? "*" : " ";
3973 const char *ann2 = call->is_tail ? "t" : " ";
3974
3975 info->callbacks->minfo (_(" %s%s %s\n"), ann1, ann2, f2);
3976 }
3977 }
49fa1e15
AM		 3978 }
3979
055ed83b 3980 if (sum_stack_param->emit_stack_syms)
49fa1e15 3981 {
49fa1e15
AM		 3982 char *name = bfd_malloc (18 + strlen (f1));
3983 struct elf_link_hash_entry *h;
3984
055ed83b
AM		 3985 if (name == NULL)
3986 return FALSE;
3987
3988 if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
3989 sprintf (name, "__stack_%s", f1);
3990 else
3991 sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
3992
3993 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
3994 free (name);
3995 if (h != NULL
3996 && (h->root.type == bfd_link_hash_new
3997 || h->root.type == bfd_link_hash_undefined
3998 || h->root.type == bfd_link_hash_undefweak))
49fa1e15 3999 {
055ed83b
AM		 4000 h->root.type = bfd_link_hash_defined;
4001 h->root.u.def.section = bfd_abs_section_ptr;
4002 h->root.u.def.value = cum_stack;
4003 h->size = 0;
4004 h->type = 0;
4005 h->ref_regular = 1;
4006 h->def_regular = 1;
4007 h->ref_regular_nonweak = 1;
4008 h->forced_local = 1;
4009 h->non_elf = 0;
49fa1e15
AM		 4010 }
4011 }
4012
055ed83b 4013 return TRUE;
49fa1e15
AM		 4014}
4015
9dcc4794
AM		 4016/* SEC is part of a pasted function. Return the call_info for the
4017 next section of this function. */
4018
4019static struct call_info *
4020find_pasted_call (asection *sec)
4021{
4022 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
4023 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
4024 struct call_info *call;
4025 int k;
4026
4027 for (k = 0; k < sinfo->num_fun; ++k)
4028 for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
4029 if (call->is_pasted)
4030 return call;
4031 abort ();
4032 return 0;
4033}
4034
4035/* qsort predicate to sort bfds by file name. */
4036
4037static int
4038sort_bfds (const void *a, const void *b)
4039{
4040 bfd *const *abfd1 = a;
4041 bfd *const *abfd2 = b;
4042
4043 return strcmp ((*abfd1)->filename, (*abfd2)->filename);
4044}
4045
cd4a7468
AM		 4046static unsigned int
4047print_one_overlay_section (FILE *script,
4048 unsigned int base,
4049 unsigned int count,
4050 unsigned int ovlynum,
4051 unsigned int *ovly_map,
4052 asection **ovly_sections,
4053 struct bfd_link_info *info)
4054{
4055 unsigned int j;
4056
4057 for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4058 {
4059 asection *sec = ovly_sections[2 * j];
4060
4061 if (fprintf (script, " %s%c%s (%s)\n",
4062 (sec->owner->my_archive != NULL
4063 ? sec->owner->my_archive->filename : ""),
4064 info->path_separator,
4065 sec->owner->filename,
4066 sec->name) <= 0)
4067 return -1;
4068 if (sec->segment_mark)
4069 {
4070 struct call_info *call = find_pasted_call (sec);
4071 while (call != NULL)
4072 {
4073 struct function_info *call_fun = call->fun;
4074 sec = call_fun->sec;
4075 if (fprintf (script, " %s%c%s (%s)\n",
4076 (sec->owner->my_archive != NULL
4077 ? sec->owner->my_archive->filename : ""),
4078 info->path_separator,
4079 sec->owner->filename,
4080 sec->name) <= 0)
4081 return -1;
4082 for (call = call_fun->call_list; call; call = call->next)
4083 if (call->is_pasted)
4084 break;
4085 }
4086 }
4087 }
4088
4089 for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4090 {
4091 asection *sec = ovly_sections[2 * j + 1];
4092 if (sec != NULL
4093 && fprintf (script, " %s%c%s (%s)\n",
4094 (sec->owner->my_archive != NULL
4095 ? sec->owner->my_archive->filename : ""),
4096 info->path_separator,
4097 sec->owner->filename,
4098 sec->name) <= 0)
4099 return -1;
4100
4101 sec = ovly_sections[2 * j];
4102 if (sec->segment_mark)
4103 {
4104 struct call_info *call = find_pasted_call (sec);
4105 while (call != NULL)
4106 {
4107 struct function_info *call_fun = call->fun;
4108 sec = call_fun->rodata;
4109 if (sec != NULL
4110 && fprintf (script, " %s%c%s (%s)\n",
4111 (sec->owner->my_archive != NULL
4112 ? sec->owner->my_archive->filename : ""),
4113 info->path_separator,
4114 sec->owner->filename,
4115 sec->name) <= 0)
4116 return -1;
4117 for (call = call_fun->call_list; call; call = call->next)
4118 if (call->is_pasted)
4119 break;
4120 }
4121 }
4122 }
4123
4124 return j;
4125}
4126
9dcc4794
AM		 4127/* Handle --auto-overlay. */
4128
9dcc4794 4129static void
64615358 4130spu_elf_auto_overlay (struct bfd_link_info *info)
9dcc4794
AM		 4131{
4132 bfd *ibfd;
4133 bfd **bfd_arr;
4134 struct elf_segment_map *m;
4135 unsigned int fixed_size, lo, hi;
4136 struct spu_link_hash_table *htab;
4137 unsigned int base, i, count, bfd_count;
a3a219a9 4138 unsigned int region, ovlynum;
9dcc4794 4139 asection **ovly_sections, **ovly_p;
a3a219a9 4140 unsigned int *ovly_map;
9dcc4794
AM		 4141 FILE *script;
4142 unsigned int total_overlay_size, overlay_size;
cd4a7468 4143 const char *ovly_mgr_entry;
9dcc4794
AM		 4144 struct elf_link_hash_entry *h;
4145 struct _mos_param mos_param;
4146 struct _uos_param uos_param;
4147 struct function_info dummy_caller;
4148
4149 /* Find the extents of our loadable image. */
4150 lo = (unsigned int) -1;
4151 hi = 0;
4152 for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
4153 if (m->p_type == PT_LOAD)
4154 for (i = 0; i < m->count; i++)
4155 if (m->sections[i]->size != 0)
4156 {
4157 if (m->sections[i]->vma < lo)
4158 lo = m->sections[i]->vma;
4159 if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
4160 hi = m->sections[i]->vma + m->sections[i]->size - 1;
4161 }
4162 fixed_size = hi + 1 - lo;
4163
4164 if (!discover_functions (info))
4165 goto err_exit;
4166
4167 if (!build_call_tree (info))
4168 goto err_exit;
4169
a14c90c1
UW		 4170 htab = spu_hash_table (info);
4171 if (htab->reserved == 0)
4172 {
4173 struct _sum_stack_param sum_stack_param;
4174
4175 sum_stack_param.emit_stack_syms = 0;
4176 sum_stack_param.overall_stack = 0;
4177 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4178 goto err_exit;
4179 htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
4180 }
4181
4182 /* No need for overlays if everything already fits. */
4183 if (fixed_size + htab->reserved <= htab->local_store
4184 && htab->params->ovly_flavour != ovly_soft_icache)
4185 {
4186 htab->params->auto_overlay = 0;
4187 return;
4188 }
4189
9dcc4794
AM		 4190 uos_param.exclude_input_section = 0;
4191 uos_param.exclude_output_section
4192 = bfd_get_section_by_name (info->output_bfd, ".interrupt");
4193
cd4a7468
AM		 4194 ovly_mgr_entry = "__ovly_load";
4195 if (htab->params->ovly_flavour == ovly_soft_icache)
4196 ovly_mgr_entry = "__icache_br_handler";
4197 h = elf_link_hash_lookup (&htab->elf, ovly_mgr_entry,
9dcc4794
AM		 4198 FALSE, FALSE, FALSE);
4199 if (h != NULL
4200 && (h->root.type == bfd_link_hash_defined
4201 || h->root.type == bfd_link_hash_defweak)
4202 && h->def_regular)
4203 {
4204 /* We have a user supplied overlay manager. */
4205 uos_param.exclude_input_section = h->root.u.def.section;
4206 }
4207 else
4208 {
4209 /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4210 builtin version to .text, and will adjust .text size. */
64615358 4211 fixed_size += (*htab->params->spu_elf_load_ovl_mgr) ();
9dcc4794
AM		 4212 }
4213
4214 /* Mark overlay sections, and find max overlay section size. */
4215 mos_param.max_overlay_size = 0;
4216 if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
4217 goto err_exit;
4218
4219 /* We can't put the overlay manager or interrupt routines in
4220 overlays. */
4221 uos_param.clearing = 0;
4222 if ((uos_param.exclude_input_section
4223 || uos_param.exclude_output_section)
4224 && !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
4225 goto err_exit;
4226
4227 bfd_count = 0;
4228 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4229 ++bfd_count;
4230 bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
4231 if (bfd_arr == NULL)
4232 goto err_exit;
4233
4234 /* Count overlay sections, and subtract their sizes from "fixed_size". */
4235 count = 0;
4236 bfd_count = 0;
4237 total_overlay_size = 0;
4238 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4239 {
4240 extern const bfd_target bfd_elf32_spu_vec;
4241 asection *sec;
4242 unsigned int old_count;
4243
4244 if (ibfd->xvec != &bfd_elf32_spu_vec)
4245 continue;
4246
4247 old_count = count;
4248 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4249 if (sec->linker_mark)
4250 {
4251 if ((sec->flags & SEC_CODE) != 0)
4252 count += 1;
4253 fixed_size -= sec->size;
4254 total_overlay_size += sec->size;
4255 }
cd4a7468
AM		 4256 else if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)
4257 && sec->output_section->owner == info->output_bfd
4258 && strncmp (sec->output_section->name, ".ovl.init", 9) == 0)
4259 fixed_size -= sec->size;
9dcc4794
AM		 4260 if (count != old_count)
4261 bfd_arr[bfd_count++] = ibfd;
4262 }
4263
4264 /* Since the overlay link script selects sections by file name and
4265 section name, ensure that file names are unique. */
4266 if (bfd_count > 1)
4267 {
4268 bfd_boolean ok = TRUE;
4269
4270 qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
4271 for (i = 1; i < bfd_count; ++i)
4272 if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
4273 {
97407faf 4274 if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
9dcc4794 4275 {
97407faf 4276 if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
9dcc4794 4277 info->callbacks->einfo (_("%s duplicated in %s\n"),
97407faf 4278 bfd_arr[i]->filename,
9dcc4794 4279 bfd_arr[i]->my_archive->filename);
97407faf
AM		 4280 else
4281 info->callbacks->einfo (_("%s duplicated\n"),
4282 bfd_arr[i]->filename);
4283 ok = FALSE;
9dcc4794 4284 }
9dcc4794
AM		 4285 }
4286 if (!ok)
4287 {
9dcc4794
AM		 4288 info->callbacks->einfo (_("sorry, no support for duplicate "
4289 "object files in auto-overlay script\n"));
4290 bfd_set_error (bfd_error_bad_value);
4291 goto err_exit;
4292 }
4293 }
4294 free (bfd_arr);
4295
9dcc4794 4296 fixed_size += htab->reserved;
a7e11ee1 4297 fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
9dcc4794
AM		 4298 if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
4299 {
cd4a7468
AM		 4300 if (htab->params->ovly_flavour == ovly_soft_icache)
4301 {
4302 /* Stubs in the non-icache area are bigger. */
4303 fixed_size += htab->non_ovly_stub * 16;
4304 /* Space for icache manager tables.
4305 a) Tag array, one quadword per cache line.
97fc8d84
UW		 4306 - word 0: ia address of present line, init to zero. */
4307 fixed_size += 16 << htab->num_lines_log2;
4308 /* b) Rewrite "to" list, one quadword per cache line. */
cd4a7468 4309 fixed_size += 16 << htab->num_lines_log2;
97fc8d84
UW		 4310 /* c) Rewrite "from" list, one byte per outgoing branch (rounded up
4311 to a power-of-two number of full quadwords) per cache line. */
4312 fixed_size += 16 << (htab->fromelem_size_log2
4313 + htab->num_lines_log2);
c1ea05bb
UW		 4314 /* d) Pointer to __ea backing store (toe), 1 quadword. */
4315 fixed_size += 16;
cd4a7468
AM		 4316 }
4317 else
4318 {
4319 /* Guess number of overlays. Assuming overlay buffer is on
4320 average only half full should be conservative. */
4321 ovlynum = (total_overlay_size * 2 * htab->params->num_lines
4322 / (htab->local_store - fixed_size));
4323 /* Space for _ovly_table[], _ovly_buf_table[] and toe. */
4324 fixed_size += ovlynum * 16 + 16 + 4 + 16;
4325 }
9dcc4794
AM		 4326 }
4327
4328 if (fixed_size + mos_param.max_overlay_size > htab->local_store)
4f0d75be
AM		 4329 info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4330 "size of 0x%v exceeds local store\n"),
4331 (bfd_vma) fixed_size,
4332 (bfd_vma) mos_param.max_overlay_size);
9dcc4794
AM		 4333
4334 /* Now see if we should put some functions in the non-overlay area. */
e5e6a5ff 4335 else if (fixed_size < htab->overlay_fixed)
9dcc4794 4336 {
e5e6a5ff
AM		 4337 unsigned int max_fixed, lib_size;
4338
4339 max_fixed = htab->local_store - mos_param.max_overlay_size;
4340 if (max_fixed > htab->overlay_fixed)
4341 max_fixed = htab->overlay_fixed;
4342 lib_size = max_fixed - fixed_size;
9dcc4794
AM		 4343 lib_size = auto_ovl_lib_functions (info, lib_size);
4344 if (lib_size == (unsigned int) -1)
4345 goto err_exit;
e5e6a5ff 4346 fixed_size = max_fixed - lib_size;
9dcc4794
AM		 4347 }
4348
4349 /* Build an array of sections, suitably sorted to place into
4350 overlays. */
4351 ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
4352 if (ovly_sections == NULL)
4353 goto err_exit;
4354 ovly_p = ovly_sections;
4355 if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
4356 goto err_exit;
4357 count = (size_t) (ovly_p - ovly_sections) / 2;
a3a219a9
AM		 4358 ovly_map = bfd_malloc (count * sizeof (*ovly_map));
4359 if (ovly_map == NULL)
4360 goto err_exit;
9dcc4794
AM		 4361
4362 memset (&dummy_caller, 0, sizeof (dummy_caller));
cd4a7468
AM		 4363 overlay_size = (htab->local_store - fixed_size) / htab->params->num_lines;
4364 if (htab->params->line_size != 0)
4365 overlay_size = htab->params->line_size;
9dcc4794
AM		 4366 base = 0;
4367 ovlynum = 0;
4368 while (base < count)
4369 {
2fc6d3b0 4370 unsigned int size = 0, rosize = 0, roalign = 0;
9dcc4794
AM		 4371
4372 for (i = base; i < count; i++)
4373 {
2fc6d3b0
AM		 4374 asection *sec, *rosec;
4375 unsigned int tmp, rotmp;
64615358 4376 unsigned int num_stubs;
9dcc4794
AM		 4377 struct call_info *call, *pasty;
4378 struct _spu_elf_section_data *sec_data;
4379 struct spu_elf_stack_info *sinfo;
4380 int k;
4381
4382 /* See whether we can add this section to the current
4383 overlay without overflowing our overlay buffer. */
4384 sec = ovly_sections[2 * i];
2fc6d3b0
AM		 4385 tmp = align_power (size, sec->alignment_power) + sec->size;
4386 rotmp = rosize;
4387 rosec = ovly_sections[2 * i + 1];
4388 if (rosec != NULL)
4389 {
4390 rotmp = align_power (rotmp, rosec->alignment_power) + rosec->size;
4391 if (roalign < rosec->alignment_power)
4392 roalign = rosec->alignment_power;
4393 }
4394 if (align_power (tmp, roalign) + rotmp > overlay_size)
9dcc4794
AM		 4395 break;
4396 if (sec->segment_mark)
4397 {
4398 /* Pasted sections must stay together, so add their
4399 sizes too. */
4400 struct call_info *pasty = find_pasted_call (sec);
4401 while (pasty != NULL)
4402 {
4403 struct function_info *call_fun = pasty->fun;
2fc6d3b0
AM		 4404 tmp = (align_power (tmp, call_fun->sec->alignment_power)
4405 + call_fun->sec->size);
9dcc4794 4406 if (call_fun->rodata)
2fc6d3b0
AM		 4407 {
4408 rotmp = (align_power (rotmp,
4409 call_fun->rodata->alignment_power)
4410 + call_fun->rodata->size);
4411 if (roalign < rosec->alignment_power)
4412 roalign = rosec->alignment_power;
4413 }
9dcc4794
AM		 4414 for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
4415 if (pasty->is_pasted)
4416 break;
4417 }
4418 }
2fc6d3b0 4419 if (align_power (tmp, roalign) + rotmp > overlay_size)
9dcc4794
AM		 4420 break;
4421
4422 /* If we add this section, we might need new overlay call
4423 stubs. Add any overlay section calls to dummy_call. */
4424 pasty = NULL;
4425 sec_data = spu_elf_section_data (sec);
4426 sinfo = sec_data->u.i.stack_info;
4427 for (k = 0; k < sinfo->num_fun; ++k)
4428 for (call = sinfo->fun[k].call_list; call; call = call->next)
4429 if (call->is_pasted)
4430 {
4431 BFD_ASSERT (pasty == NULL);
4432 pasty = call;
4433 }
4434 else if (call->fun->sec->linker_mark)
4435 {
4436 if (!copy_callee (&dummy_caller, call))
4437 goto err_exit;
4438 }
4439 while (pasty != NULL)
4440 {
4441 struct function_info *call_fun = pasty->fun;
4442 pasty = NULL;
4443 for (call = call_fun->call_list; call; call = call->next)
4444 if (call->is_pasted)
4445 {
4446 BFD_ASSERT (pasty == NULL);
4447 pasty = call;
4448 }
4449 else if (!copy_callee (&dummy_caller, call))
4450 goto err_exit;
4451 }
4452
4453 /* Calculate call stub size. */
64615358 4454 num_stubs = 0;
9dcc4794
AM		 4455 for (call = dummy_caller.call_list; call; call = call->next)
4456 {
4457 unsigned int k;
34ad4cb0
UW		 4458 unsigned int stub_delta = 1;
4459
4460 if (htab->params->ovly_flavour == ovly_soft_icache)
4461 stub_delta = call->count;
4462 num_stubs += stub_delta;
9dcc4794 4463
9dcc4794
AM		 4464 /* If the call is within this overlay, we won't need a
4465 stub. */
4466 for (k = base; k < i + 1; k++)
4467 if (call->fun->sec == ovly_sections[2 * k])
4468 {
34ad4cb0 4469 num_stubs -= stub_delta;
9dcc4794
AM		 4470 break;
4471 }
4472 }
cd4a7468
AM		 4473 if (htab->params->ovly_flavour == ovly_soft_icache
4474 && num_stubs > htab->params->max_branch)
4475 break;
2fc6d3b0
AM		 4476 if (align_power (tmp, roalign) + rotmp
4477 + num_stubs * ovl_stub_size (htab->params) > overlay_size)
9dcc4794 4478 break;
9dcc4794 4479 size = tmp;
2fc6d3b0 4480 rosize = rotmp;
9dcc4794
AM		 4481 }
4482
4483 if (i == base)
4484 {
4485 info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
4486 ovly_sections[2 * i]->owner,
4487 ovly_sections[2 * i],
4488 ovly_sections[2 * i + 1] ? " + rodata" : "");
4489 bfd_set_error (bfd_error_bad_value);
4490 goto err_exit;
4491 }
4492
a3a219a9
AM		 4493 while (dummy_caller.call_list != NULL)
4494 {
4495 struct call_info *call = dummy_caller.call_list;
4496 dummy_caller.call_list = call->next;
4497 free (call);
4498 }
4499
4500 ++ovlynum;
4501 while (base < i)
4502 ovly_map[base++] = ovlynum;
4503 }
4504
4505 script = htab->params->spu_elf_open_overlay_script ();
4506
4507 if (fprintf (script, "SECTIONS\n{\n") <= 0)
4508 goto file_err;
4509
cd4a7468 4510 if (htab->params->ovly_flavour == ovly_soft_icache)
a3a219a9 4511 {
cd4a7468
AM		 4512 if (fprintf (script,
4513 " .data.icache ALIGN (16) : { *(.ovtab) *(.data.icache) }\n"
4514 " . = ALIGN (%u);\n"
4515 " .ovl.init : { *(.ovl.init) }\n"
4516 " . = ABSOLUTE (ADDR (.ovl.init));\n",
4517 htab->params->line_size) <= 0)
4518 goto file_err;
4519
a3a219a9 4520 base = 0;
cd4a7468
AM		 4521 ovlynum = 1;
4522 while (base < count)
4523 {
4524 unsigned int indx = ovlynum - 1;
4525 unsigned int vma, lma;
a3a219a9 4526
37107878 4527 vma = (indx & (htab->params->num_lines - 1)) << htab->line_size_log2;
cd4a7468
AM		 4528 lma = indx << htab->line_size_log2;
4529
4530 if (fprintf (script, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4531 ": AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16) + %u) {\n",
4532 ovlynum, vma, lma) <= 0)
4533 goto file_err;
4534
4535 base = print_one_overlay_section (script, base, count, ovlynum,
4536 ovly_map, ovly_sections, info);
4537 if (base == (unsigned) -1)
4538 goto file_err;
4539
4540 if (fprintf (script, " }\n") <= 0)
4541 goto file_err;
4542
4543 ovlynum++;
4544 }
a3a219a9 4545
cd4a7468
AM		 4546 if (fprintf (script, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4547 1 << (htab->num_lines_log2 + htab->line_size_log2)) <= 0)
4548 goto file_err;
4549 }
4550 else
4551 {
4552 if (fprintf (script,
4553 " . = ALIGN (16);\n"
4554 " .ovl.init : { *(.ovl.init) }\n"
4555 " . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
9dcc4794 4556 goto file_err;
a3a219a9 4557
cd4a7468 4558 for (region = 1; region <= htab->params->num_lines; region++)
9dcc4794 4559 {
cd4a7468
AM		 4560 ovlynum = region;
4561 base = 0;
4562 while (base < count && ovly_map[base] < ovlynum)
4563 base++;
a3a219a9 4564
cd4a7468
AM		 4565 if (base == count)
4566 break;
a3a219a9 4567
cd4a7468
AM		 4568 if (region == 1)
4569 {
4570 /* We need to set lma since we are overlaying .ovl.init. */
4571 if (fprintf (script,
4572 " OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4573 goto file_err;
4574 }
4575 else
4576 {
4577 if (fprintf (script, " OVERLAY :\n {\n") <= 0)
a3a219a9 4578 goto file_err;
9dcc4794 4579 }
9dcc4794 4580
cd4a7468 4581 while (base < count)
9dcc4794 4582 {
cd4a7468 4583 if (fprintf (script, " .ovly%u {\n", ovlynum) <= 0)
a3a219a9
AM		 4584 goto file_err;
4585
cd4a7468
AM		 4586 base = print_one_overlay_section (script, base, count, ovlynum,
4587 ovly_map, ovly_sections, info);
4588 if (base == (unsigned) -1)
4589 goto file_err;
4590
4591 if (fprintf (script, " }\n") <= 0)
4592 goto file_err;
4593
4594 ovlynum += htab->params->num_lines;
4595 while (base < count && ovly_map[base] < ovlynum)
4596 base++;
9dcc4794 4597 }
9dcc4794 4598
cd4a7468 4599 if (fprintf (script, " }\n") <= 0)
a3a219a9 4600 goto file_err;
9dcc4794
AM		 4601 }
4602
9dcc4794 4603 }
a3a219a9
AM		 4604
4605 free (ovly_map);
9dcc4794
AM		 4606 free (ovly_sections);
4607
a3a219a9 4608 if (fprintf (script, "}\nINSERT BEFORE .text;\n") <= 0)
9dcc4794
AM		 4609 goto file_err;
4610 if (fclose (script) != 0)
4611 goto file_err;
4612
64615358
AM		 4613 if (htab->params->auto_overlay & AUTO_RELINK)
4614 (*htab->params->spu_elf_relink) ();
9dcc4794
AM		 4615
4616 xexit (0);
4617
4618 file_err:
4619 bfd_set_error (bfd_error_system_call);
4620 err_exit:
4621 info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
4622 xexit (1);
4623}
4624
49fa1e15
AM		 4625/* Provide an estimate of total stack required. */
4626
4627static bfd_boolean
64615358 4628spu_elf_stack_analysis (struct bfd_link_info *info)
49fa1e15 4629{
64615358 4630 struct spu_link_hash_table *htab;
055ed83b 4631 struct _sum_stack_param sum_stack_param;
49fa1e15 4632
c65be8d7 4633 if (!discover_functions (info))
49fa1e15
AM		 4634 return FALSE;
4635
c65be8d7 4636 if (!build_call_tree (info))
49fa1e15
AM		 4637 return FALSE;
4638
64615358 4639 htab = spu_hash_table (info);
cd4a7468
AM		 4640 if (htab->params->stack_analysis)
4641 {
4642 info->callbacks->info (_("Stack size for call graph root nodes.\n"));
4643 info->callbacks->minfo (_("\nStack size for functions. "
4644 "Annotations: '*' max stack, 't' tail call\n"));
4645 }
49fa1e15 4646
64615358 4647 sum_stack_param.emit_stack_syms = htab->params->emit_stack_syms;
055ed83b
AM		 4648 sum_stack_param.overall_stack = 0;
4649 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4650 return FALSE;
49fa1e15 4651
cd4a7468
AM		 4652 if (htab->params->stack_analysis)
4653 info->callbacks->info (_("Maximum stack required is 0x%v\n"),
4654 (bfd_vma) sum_stack_param.overall_stack);
49fa1e15
AM		 4655 return TRUE;
4656}
4657
4658/* Perform a final link. */
4659
4660static bfd_boolean
4661spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
4662{
4663 struct spu_link_hash_table *htab = spu_hash_table (info);
4664
64615358
AM		 4665 if (htab->params->auto_overlay)
4666 spu_elf_auto_overlay (info);
9dcc4794 4667
cd4a7468
AM		 4668 if ((htab->params->stack_analysis
4669 || (htab->params->ovly_flavour == ovly_soft_icache
4670 && htab->params->lrlive_analysis))
64615358 4671 && !spu_elf_stack_analysis (info))
cd4a7468
AM		 4672 info->callbacks->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4673
4674 if (!spu_elf_build_stubs (info))
4675 info->callbacks->einfo ("%F%P: can not build overlay stubs: %E\n");
49fa1e15
AM		 4676
4677 return bfd_elf_final_link (output_bfd, info);
4678}
4679
ece5ef60
AM		 4680/* Called when not normally emitting relocs, ie. !info->relocatable
4681 and !info->emitrelocations. Returns a count of special relocs
4682 that need to be emitted. */
4683
4684static unsigned int
58217f29 4685spu_elf_count_relocs (struct bfd_link_info *info, asection *sec)
ece5ef60 4686{
58217f29 4687 Elf_Internal_Rela *relocs;
ece5ef60 4688 unsigned int count = 0;
ece5ef60 4689
58217f29
AM		 4690 relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
4691 info->keep_memory);
4692 if (relocs != NULL)
ece5ef60 4693 {
58217f29
AM		 4694 Elf_Internal_Rela *rel;
4695 Elf_Internal_Rela *relend = relocs + sec->reloc_count;
4696
4697 for (rel = relocs; rel < relend; rel++)
4698 {
4699 int r_type = ELF32_R_TYPE (rel->r_info);
4700 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4701 ++count;
4702 }
4703
4704 if (elf_section_data (sec)->relocs != relocs)
4705 free (relocs);
ece5ef60
AM		 4706 }
4707
4708 return count;
4709}
4710
e9f53129
AM		 4711/* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
4712
d16c7321 4713static int
e9f53129
AM		 4714spu_elf_relocate_section (bfd *output_bfd,
4715 struct bfd_link_info *info,
4716 bfd *input_bfd,
4717 asection *input_section,
4718 bfd_byte *contents,
4719 Elf_Internal_Rela *relocs,
4720 Elf_Internal_Sym *local_syms,
4721 asection **local_sections)
4722{
4723 Elf_Internal_Shdr *symtab_hdr;
4724 struct elf_link_hash_entry **sym_hashes;
4725 Elf_Internal_Rela *rel, *relend;
4726 struct spu_link_hash_table *htab;
64615358 4727 asection *ea;
d16c7321 4728 int ret = TRUE;
ece5ef60 4729 bfd_boolean emit_these_relocs = FALSE;
cc5ca406 4730 bfd_boolean is_ea_sym;
fdba2fcd 4731 bfd_boolean stubs;
cd4a7468 4732 unsigned int iovl = 0;
e9f53129 4733
e9f53129 4734 htab = spu_hash_table (info);
fdba2fcd 4735 stubs = (htab->stub_sec != NULL
64615358 4736 && maybe_needs_stubs (input_section));
cd4a7468 4737 iovl = overlay_index (input_section);
64615358 4738 ea = bfd_get_section_by_name (output_bfd, "._ea");
e9f53129
AM		 4739 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4740 sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
4741
4742 rel = relocs;
4743 relend = relocs + input_section->reloc_count;
4744 for (; rel < relend; rel++)
4745 {
4746 int r_type;
4747 reloc_howto_type *howto;
8374f9d4 4748 unsigned int r_symndx;
e9f53129
AM		 4749 Elf_Internal_Sym *sym;
4750 asection *sec;
4751 struct elf_link_hash_entry *h;
4752 const char *sym_name;
4753 bfd_vma relocation;
4754 bfd_vma addend;
4755 bfd_reloc_status_type r;
4756 bfd_boolean unresolved_reloc;
4757 bfd_boolean warned;
124b52c6 4758 enum _stub_type stub_type;
e9f53129
AM		 4759
4760 r_symndx = ELF32_R_SYM (rel->r_info);
4761 r_type = ELF32_R_TYPE (rel->r_info);
4762 howto = elf_howto_table + r_type;
4763 unresolved_reloc = FALSE;
4764 warned = FALSE;
e9f53129
AM		 4765 h = NULL;
4766 sym = NULL;
4767 sec = NULL;
4768 if (r_symndx < symtab_hdr->sh_info)
4769 {
4770 sym = local_syms + r_symndx;
4771 sec = local_sections[r_symndx];
4772 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
4773 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4774 }
4775 else
4776 {
dc1859a6
AM		 4777 if (sym_hashes == NULL)
4778 return FALSE;
4779
4780 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4781
4782 while (h->root.type == bfd_link_hash_indirect
4783 || h->root.type == bfd_link_hash_warning)
4784 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4785
4786 relocation = 0;
4787 if (h->root.type == bfd_link_hash_defined
4788 || h->root.type == bfd_link_hash_defweak)
4789 {
4790 sec = h->root.u.def.section;
4791 if (sec == NULL
4792 || sec->output_section == NULL)
4793 /* Set a flag that will be cleared later if we find a
4794 relocation value for this symbol. output_section
4795 is typically NULL for symbols satisfied by a shared
4796 library. */
4797 unresolved_reloc = TRUE;
4798 else
4799 relocation = (h->root.u.def.value
4800 + sec->output_section->vma
4801 + sec->output_offset);
4802 }
4803 else if (h->root.type == bfd_link_hash_undefweak)
4804 ;
4805 else if (info->unresolved_syms_in_objects == RM_IGNORE
4806 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4807 ;
4808 else if (!info->relocatable
4809 && !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
4810 {
4811 bfd_boolean err;
4812 err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4813 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
4814 if (!info->callbacks->undefined_symbol (info,
4815 h->root.root.string,
4816 input_bfd,
4817 input_section,
4818 rel->r_offset, err))
4819 return FALSE;
4820 warned = TRUE;
4821 }
e9f53129
AM		 4822 sym_name = h->root.root.string;
4823 }
4824
ab96bf03
AM		 4825 if (sec != NULL && elf_discarded_section (sec))
4826 {
4827 /* For relocs against symbols from removed linkonce sections,
4828 or sections discarded by a linker script, we just want the
4829 section contents zeroed. Avoid any special processing. */
4830 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4831 rel->r_info = 0;
4832 rel->r_addend = 0;
4833 continue;
4834 }
4835
4836 if (info->relocatable)
4837 continue;
4838
cc5ca406
AM		 4839 is_ea_sym = (ea != NULL
4840 && sec != NULL
4841 && sec->output_section == ea);
cd4a7468
AM		 4842
4843 /* If this symbol is in an overlay area, we may need to relocate
4844 to the overlay stub. */
4845 addend = rel->r_addend;
4846 if (stubs
4847 && !is_ea_sym
4848 && (stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
4849 contents, info)) != no_stub)
4850 {
4851 unsigned int ovl = 0;
4852 struct got_entry *g, **head;
4853
4854 if (stub_type != nonovl_stub)
4855 ovl = iovl;
4856
4857 if (h != NULL)
4858 head = &h->got.glist;
4859 else
4860 head = elf_local_got_ents (input_bfd) + r_symndx;
cc5ca406 4861
cd4a7468
AM		 4862 for (g = *head; g != NULL; g = g->next)
4863 if (htab->params->ovly_flavour == ovly_soft_icache
74681fc4
AM		 4864 ? (g->ovl == ovl
4865 && g->br_addr == (rel->r_offset
4866 + input_section->output_offset
4867 + input_section->output_section->vma))
cd4a7468
AM		 4868 : g->addend == addend && (g->ovl == ovl || g->ovl == 0))
4869 break;
4870 if (g == NULL)
4871 abort ();
4872
4873 relocation = g->stub_addr;
4874 addend = 0;
4875 }
4876 else
4877 {
4878 /* For soft icache, encode the overlay index into addresses. */
4879 if (htab->params->ovly_flavour == ovly_soft_icache
d342a8b1
UW		 4880 && (r_type == R_SPU_ADDR16_HI
4881 || r_type == R_SPU_ADDR32 || r_type == R_SPU_REL32)
cd4a7468
AM		 4882 && !is_ea_sym)
4883 {
4884 unsigned int ovl = overlay_index (sec);
4885 if (ovl != 0)
4886 {
30c665df 4887 unsigned int set_id = ((ovl - 1) >> htab->num_lines_log2) + 1;
cd4a7468 4888 relocation += set_id << 18;
cd4a7468
AM		 4889 }
4890 }
4891 }
4892
4893 if (unresolved_reloc)
4894 ;
4895 else if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
8374f9d4 4896 {
cc5ca406 4897 if (is_ea_sym)
8374f9d4
AM		 4898 {
4899 /* ._ea is a special section that isn't allocated in SPU
4900 memory, but rather occupies space in PPU memory as
4901 part of an embedded ELF image. If this reloc is
4902 against a symbol defined in ._ea, then transform the
4903 reloc into an equivalent one without a symbol
4904 relative to the start of the ELF image. */
4905 rel->r_addend += (relocation
4906 - ea->vma
4907 + elf_section_data (ea)->this_hdr.sh_offset);
4908 rel->r_info = ELF32_R_INFO (0, r_type);
4909 }
4910 emit_these_relocs = TRUE;
4911 continue;
4912 }
cd4a7468 4913 else if (is_ea_sym)
8374f9d4
AM		 4914 unresolved_reloc = TRUE;
4915
e9f53129
AM		 4916 if (unresolved_reloc)
4917 {
4918 (*_bfd_error_handler)
4919 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
4920 input_bfd,
4921 bfd_get_section_name (input_bfd, input_section),
4922 (long) rel->r_offset,
4923 howto->name,
4924 sym_name);
4925 ret = FALSE;
4926 }
4927
e9f53129
AM		 4928 r = _bfd_final_link_relocate (howto,
4929 input_bfd,
4930 input_section,
4931 contents,
4932 rel->r_offset, relocation, addend);
4933
4934 if (r != bfd_reloc_ok)
4935 {
4936 const char *msg = (const char *) 0;
4937
4938 switch (r)
4939 {
4940 case bfd_reloc_overflow:
4941 if (!((*info->callbacks->reloc_overflow)
4942 (info, (h ? &h->root : NULL), sym_name, howto->name,
4943 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
4944 return FALSE;
4945 break;
4946
4947 case bfd_reloc_undefined:
4948 if (!((*info->callbacks->undefined_symbol)
4949 (info, sym_name, input_bfd, input_section,
4950 rel->r_offset, TRUE)))
4951 return FALSE;
4952 break;
4953
4954 case bfd_reloc_outofrange:
4955 msg = _("internal error: out of range error");
4956 goto common_error;
4957
4958 case bfd_reloc_notsupported:
4959 msg = _("internal error: unsupported relocation error");
4960 goto common_error;
4961
4962 case bfd_reloc_dangerous:
4963 msg = _("internal error: dangerous error");
4964 goto common_error;
4965
4966 default:
4967 msg = _("internal error: unknown error");
4968 /* fall through */
4969
4970 common_error:
d16c7321 4971 ret = FALSE;
e9f53129
AM		 4972 if (!((*info->callbacks->warning)
4973 (info, msg, sym_name, input_bfd, input_section,
4974 rel->r_offset)))
4975 return FALSE;
4976 break;
4977 }
4978 }
4979 }
4980
ece5ef60
AM		 4981 if (ret
4982 && emit_these_relocs
ece5ef60
AM		 4983 && !info->emitrelocations)
4984 {
4985 Elf_Internal_Rela *wrel;
4986 Elf_Internal_Shdr *rel_hdr;
4987
4988 wrel = rel = relocs;
4989 relend = relocs + input_section->reloc_count;
4990 for (; rel < relend; rel++)
4991 {
4992 int r_type;
4993
4994 r_type = ELF32_R_TYPE (rel->r_info);
4995 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4996 *wrel++ = *rel;
4997 }
4998 input_section->reloc_count = wrel - relocs;
4999 /* Backflips for _bfd_elf_link_output_relocs. */
5000 rel_hdr = &elf_section_data (input_section)->rel_hdr;
5001 rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
5002 ret = 2;
5003 }
5004
e9f53129
AM		 5005 return ret;
5006}
5007
c1b2796f
AM		 5008/* Adjust _SPUEAR_ syms to point at their overlay stubs. */
5009
6e0b88f1 5010static int
c1b2796f
AM		 5011spu_elf_output_symbol_hook (struct bfd_link_info *info,
5012 const char *sym_name ATTRIBUTE_UNUSED,
5013 Elf_Internal_Sym *sym,
5014 asection *sym_sec ATTRIBUTE_UNUSED,
5015 struct elf_link_hash_entry *h)
5016{
5017 struct spu_link_hash_table *htab = spu_hash_table (info);
5018
5019 if (!info->relocatable
47f6dab9 5020 && htab->stub_sec != NULL
c1b2796f
AM		 5021 && h != NULL
5022 && (h->root.type == bfd_link_hash_defined
5023 || h->root.type == bfd_link_hash_defweak)
5024 && h->def_regular
5025 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
5026 {
4a628337 5027 struct got_entry *g;
c1b2796f 5028
4a628337 5029 for (g = h->got.glist; g != NULL; g = g->next)
cd4a7468
AM		 5030 if (htab->params->ovly_flavour == ovly_soft_icache
5031 ? g->br_addr == g->stub_addr
5032 : g->addend == 0 && g->ovl == 0)
4a628337
AM		 5033 {
5034 sym->st_shndx = (_bfd_elf_section_from_bfd_section
5035 (htab->stub_sec[0]->output_section->owner,
5036 htab->stub_sec[0]->output_section));
5037 sym->st_value = g->stub_addr;
5038 break;
5039 }
c1b2796f
AM		 5040 }
5041
6e0b88f1 5042 return 1;
c1b2796f
AM		 5043}
5044
e9f53129
AM		 5045static int spu_plugin = 0;
5046
5047void
5048spu_elf_plugin (int val)
5049{
5050 spu_plugin = val;
5051}
5052
5053/* Set ELF header e_type for plugins. */
5054
5055static void
5056spu_elf_post_process_headers (bfd *abfd,
5057 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5058{
5059 if (spu_plugin)
5060 {
5061 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5062
5063 i_ehdrp->e_type = ET_DYN;
5064 }
5065}
5066
5067/* We may add an extra PT_LOAD segment for .toe. We also need extra
5068 segments for overlays. */
5069
5070static int
5071spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
5072{
ceae84aa 5073 int extra = 0;
e9f53129
AM		 5074 asection *sec;
5075
ceae84aa
AM		 5076 if (info != NULL)
5077 {
5078 struct spu_link_hash_table *htab = spu_hash_table (info);
5079 extra = htab->num_overlays;
5080 }
5081
e9f53129
AM		 5082 if (extra)
5083 ++extra;
5084
5085 sec = bfd_get_section_by_name (abfd, ".toe");
5086 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
5087 ++extra;
5088
5089 return extra;
5090}
5091
5092/* Remove .toe section from other PT_LOAD segments and put it in
5093 a segment of its own. Put overlays in separate segments too. */
5094
5095static bfd_boolean
5096spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
5097{
5098 asection *toe, *s;
452de53c
UW		 5099 struct elf_segment_map *m, *m_overlay;
5100 struct elf_segment_map **p, **p_overlay;
e9f53129
AM		 5101 unsigned int i;
5102
5103 if (info == NULL)
5104 return TRUE;
5105
5106 toe = bfd_get_section_by_name (abfd, ".toe");
5107 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
5108 if (m->p_type == PT_LOAD && m->count > 1)
5109 for (i = 0; i < m->count; i++)
5110 if ((s = m->sections[i]) == toe
47f6dab9 5111 || spu_elf_section_data (s)->u.o.ovl_index != 0)
e9f53129
AM		 5112 {
5113 struct elf_segment_map *m2;
5114 bfd_vma amt;
5115
5116 if (i + 1 < m->count)
5117 {
5118 amt = sizeof (struct elf_segment_map);
5119 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
5120 m2 = bfd_zalloc (abfd, amt);
5121 if (m2 == NULL)
5122 return FALSE;
5123 m2->count = m->count - (i + 1);
5124 memcpy (m2->sections, m->sections + i + 1,
5125 m2->count * sizeof (m->sections[0]));
5126 m2->p_type = PT_LOAD;
5127 m2->next = m->next;
5128 m->next = m2;
5129 }
5130 m->count = 1;
5131 if (i != 0)
5132 {
5133 m->count = i;
5134 amt = sizeof (struct elf_segment_map);
5135 m2 = bfd_zalloc (abfd, amt);
5136 if (m2 == NULL)
5137 return FALSE;
5138 m2->p_type = PT_LOAD;
5139 m2->count = 1;
5140 m2->sections[0] = s;
5141 m2->next = m->next;
5142 m->next = m2;
5143 }
5144 break;
5145 }
5146
452de53c
UW		 5147
5148 /* Some SPU ELF loaders ignore the PF_OVERLAY flag and just load all
5149 PT_LOAD segments. This can cause the .ovl.init section to be
5150 overwritten with the contents of some overlay segment. To work
5151 around this issue, we ensure that all PF_OVERLAY segments are
5152 sorted first amongst the program headers; this ensures that even
5153 with a broken loader, the .ovl.init section (which is not marked
5154 as PF_OVERLAY) will be placed into SPU local store on startup. */
5155
5156 /* Move all overlay segments onto a separate list. */
5157 p = &elf_tdata (abfd)->segment_map;
5158 p_overlay = &m_overlay;
5159 while (*p != NULL)
5160 {
5161 if ((*p)->p_type == PT_LOAD && (*p)->count == 1
5162 && spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
5163 {
5164 struct elf_segment_map *m = *p;
5165 *p = m->next;
5166 *p_overlay = m;
5167 p_overlay = &m->next;
5168 continue;
5169 }
5170
5171 p = &((*p)->next);
5172 }
5173
5174 /* Re-insert overlay segments at the head of the segment map. */
5175 *p_overlay = elf_tdata (abfd)->segment_map;
5176 elf_tdata (abfd)->segment_map = m_overlay;
5177
e9f53129
AM		 5178 return TRUE;
5179}
5180
7d3287cb
AM		 5181/* Tweak the section type of .note.spu_name. */
5182
5183static bfd_boolean
5184spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
5185 Elf_Internal_Shdr *hdr,
5186 asection *sec)
5187{
5188 if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
5189 hdr->sh_type = SHT_NOTE;
5190 return TRUE;
5191}
5192
e9f53129
AM		 5193/* Tweak phdrs before writing them out. */
5194
5195static int
5196spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
5197{
5198 const struct elf_backend_data *bed;
5199 struct elf_obj_tdata *tdata;
5200 Elf_Internal_Phdr *phdr, *last;
5201 struct spu_link_hash_table *htab;
5202 unsigned int count;
5203 unsigned int i;
5204
5205 if (info == NULL)
5206 return TRUE;
5207
5208 bed = get_elf_backend_data (abfd);
5209 tdata = elf_tdata (abfd);
5210 phdr = tdata->phdr;
5211 count = tdata->program_header_size / bed->s->sizeof_phdr;
5212 htab = spu_hash_table (info);
5213 if (htab->num_overlays != 0)
5214 {
5215 struct elf_segment_map *m;
5216 unsigned int o;
5217
5218 for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
5219 if (m->count != 0
47f6dab9 5220 && (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
e9f53129
AM		 5221 {
5222 /* Mark this as an overlay header. */
5223 phdr[i].p_flags |= PF_OVERLAY;
5224
cd4a7468
AM		 5225 if (htab->ovtab != NULL && htab->ovtab->size != 0
5226 && htab->params->ovly_flavour != ovly_soft_icache)
e9f53129
AM		 5227 {
5228 bfd_byte *p = htab->ovtab->contents;
47f6dab9 5229 unsigned int off = o * 16 + 8;
e9f53129
AM		 5230
5231 /* Write file_off into _ovly_table. */
5232 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
5233 }
5234 }
cd4a7468
AM		 5235 /* Soft-icache has its file offset put in .ovl.init. */
5236 if (htab->init != NULL && htab->init->size != 0)
5237 {
5238 bfd_vma val = elf_section_data (htab->ovl_sec[0])->this_hdr.sh_offset;
5239
5240 bfd_put_32 (htab->init->owner, val, htab->init->contents + 4);
5241 }
e9f53129
AM		 5242 }
5243
5244 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5245 of 16. This should always be possible when using the standard
5246 linker scripts, but don't create overlapping segments if
5247 someone is playing games with linker scripts. */
5248 last = NULL;
5249 for (i = count; i-- != 0; )
5250 if (phdr[i].p_type == PT_LOAD)
5251 {
5252 unsigned adjust;
5253
5254 adjust = -phdr[i].p_filesz & 15;
5255 if (adjust != 0
5256 && last != NULL
5257 && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
5258 break;
5259
5260 adjust = -phdr[i].p_memsz & 15;
5261 if (adjust != 0
5262 && last != NULL
5263 && phdr[i].p_filesz != 0
5264 && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
5265 && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
5266 break;
5267
5268 if (phdr[i].p_filesz != 0)
5269 last = &phdr[i];
5270 }
5271
5272 if (i == (unsigned int) -1)
5273 for (i = count; i-- != 0; )
5274 if (phdr[i].p_type == PT_LOAD)
5275 {
5276 unsigned adjust;
5277
5278 adjust = -phdr[i].p_filesz & 15;
5279 phdr[i].p_filesz += adjust;
5280
5281 adjust = -phdr[i].p_memsz & 15;
5282 phdr[i].p_memsz += adjust;
5283 }
5284
5285 return TRUE;
5286}
5287
e9f53129
AM		 5288#define TARGET_BIG_SYM bfd_elf32_spu_vec
5289#define TARGET_BIG_NAME "elf32-spu"
5290#define ELF_ARCH bfd_arch_spu
5291#define ELF_MACHINE_CODE EM_SPU
5292/* This matches the alignment need for DMA. */
5293#define ELF_MAXPAGESIZE 0x80
5294#define elf_backend_rela_normal 1
5295#define elf_backend_can_gc_sections 1
5296
5297#define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
ad2adbc8 5298#define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
e9f53129 5299#define elf_info_to_howto spu_elf_info_to_howto
ece5ef60 5300#define elf_backend_count_relocs spu_elf_count_relocs
e9f53129
AM		 5301#define elf_backend_relocate_section spu_elf_relocate_section
5302#define elf_backend_symbol_processing spu_elf_backend_symbol_processing
c1b2796f 5303#define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
124b52c6 5304#define elf_backend_object_p spu_elf_object_p
e9f53129
AM		 5305#define bfd_elf32_new_section_hook spu_elf_new_section_hook
5306#define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
e9f53129
AM		 5307
5308#define elf_backend_additional_program_headers spu_elf_additional_program_headers
5309#define elf_backend_modify_segment_map spu_elf_modify_segment_map
5310#define elf_backend_modify_program_headers spu_elf_modify_program_headers
5311#define elf_backend_post_process_headers spu_elf_post_process_headers
7d3287cb 5312#define elf_backend_fake_sections spu_elf_fake_sections
e9f53129 5313#define elf_backend_special_sections spu_elf_special_sections
49fa1e15 5314#define bfd_elf32_bfd_final_link spu_elf_final_link
e9f53129
AM		 5315
5316#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.502357 seconds and 4 git commands to generate.