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