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