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