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