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