projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elflink.c (bfd_elf_size_dynamic_sections): Ignore GNU-stack note
[deliverable/binutils-gdb.git] / bfd / elf32-spu.c
CommitLineData
e9f53129
AM		 1/* SPU specific support for 32-bit ELF
2
d16c7321 3 Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
e9f53129
AM		 4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
e9f53129
AM		 10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
e9f53129 21#include "sysdep.h"
9dcc4794 22#include "libiberty.h"
3db64b00 23#include "bfd.h"
e9f53129
AM		 24#include "bfdlink.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
27#include "elf/spu.h"
28#include "elf32-spu.h"
29
30/* We use RELA style relocs. Don't define USE_REL. */
31
32static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
33 void *, asection *,
34 bfd *, char **);
35
36/* Values of type 'enum elf_spu_reloc_type' are used to index this
37 array, so it must be declared in the order of that type. */
38
39static reloc_howto_type elf_howto_table[] = {
40 HOWTO (R_SPU_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
41 bfd_elf_generic_reloc, "SPU_NONE",
42 FALSE, 0, 0x00000000, FALSE),
43 HOWTO (R_SPU_ADDR10, 4, 2, 10, FALSE, 14, complain_overflow_bitfield,
44 bfd_elf_generic_reloc, "SPU_ADDR10",
45 FALSE, 0, 0x00ffc000, FALSE),
46 HOWTO (R_SPU_ADDR16, 2, 2, 16, FALSE, 7, complain_overflow_bitfield,
47 bfd_elf_generic_reloc, "SPU_ADDR16",
48 FALSE, 0, 0x007fff80, FALSE),
49 HOWTO (R_SPU_ADDR16_HI, 16, 2, 16, FALSE, 7, complain_overflow_bitfield,
50 bfd_elf_generic_reloc, "SPU_ADDR16_HI",
51 FALSE, 0, 0x007fff80, FALSE),
52 HOWTO (R_SPU_ADDR16_LO, 0, 2, 16, FALSE, 7, complain_overflow_dont,
53 bfd_elf_generic_reloc, "SPU_ADDR16_LO",
54 FALSE, 0, 0x007fff80, FALSE),
55 HOWTO (R_SPU_ADDR18, 0, 2, 18, FALSE, 7, complain_overflow_bitfield,
56 bfd_elf_generic_reloc, "SPU_ADDR18",
57 FALSE, 0, 0x01ffff80, FALSE),
b427ea91 58 HOWTO (R_SPU_ADDR32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
e9f53129
AM		 59 bfd_elf_generic_reloc, "SPU_ADDR32",
60 FALSE, 0, 0xffffffff, FALSE),
61 HOWTO (R_SPU_REL16, 2, 2, 16, TRUE, 7, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "SPU_REL16",
63 FALSE, 0, 0x007fff80, TRUE),
64 HOWTO (R_SPU_ADDR7, 0, 2, 7, FALSE, 14, complain_overflow_dont,
65 bfd_elf_generic_reloc, "SPU_ADDR7",
66 FALSE, 0, 0x001fc000, FALSE),
67 HOWTO (R_SPU_REL9, 2, 2, 9, TRUE, 0, complain_overflow_signed,
68 spu_elf_rel9, "SPU_REL9",
69 FALSE, 0, 0x0180007f, TRUE),
70 HOWTO (R_SPU_REL9I, 2, 2, 9, TRUE, 0, complain_overflow_signed,
71 spu_elf_rel9, "SPU_REL9I",
72 FALSE, 0, 0x0000c07f, TRUE),
73 HOWTO (R_SPU_ADDR10I, 0, 2, 10, FALSE, 14, complain_overflow_signed,
74 bfd_elf_generic_reloc, "SPU_ADDR10I",
75 FALSE, 0, 0x00ffc000, FALSE),
76 HOWTO (R_SPU_ADDR16I, 0, 2, 16, FALSE, 7, complain_overflow_signed,
77 bfd_elf_generic_reloc, "SPU_ADDR16I",
78 FALSE, 0, 0x007fff80, FALSE),
b427ea91 79 HOWTO (R_SPU_REL32, 0, 2, 32, TRUE, 0, complain_overflow_dont,
e9f53129
AM		 80 bfd_elf_generic_reloc, "SPU_REL32",
81 FALSE, 0, 0xffffffff, TRUE),
4f4416b5
AM		 82 HOWTO (R_SPU_ADDR16X, 0, 2, 16, FALSE, 7, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "SPU_ADDR16X",
84 FALSE, 0, 0x007fff80, FALSE),
b427ea91 85 HOWTO (R_SPU_PPU32, 0, 2, 32, FALSE, 0, complain_overflow_dont,
ece5ef60
AM		 86 bfd_elf_generic_reloc, "SPU_PPU32",
87 FALSE, 0, 0xffffffff, FALSE),
b427ea91 88 HOWTO (R_SPU_PPU64, 0, 4, 64, FALSE, 0, complain_overflow_dont,
ece5ef60
AM		 89 bfd_elf_generic_reloc, "SPU_PPU64",
90 FALSE, 0, -1, FALSE),
e9f53129
AM		 91};
92
93static struct bfd_elf_special_section const spu_elf_special_sections[] = {
94 { ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
95 { NULL, 0, 0, 0, 0 }
96};
97
98static enum elf_spu_reloc_type
99spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
100{
101 switch (code)
102 {
103 default:
104 return R_SPU_NONE;
105 case BFD_RELOC_SPU_IMM10W:
106 return R_SPU_ADDR10;
107 case BFD_RELOC_SPU_IMM16W:
108 return R_SPU_ADDR16;
109 case BFD_RELOC_SPU_LO16:
110 return R_SPU_ADDR16_LO;
111 case BFD_RELOC_SPU_HI16:
112 return R_SPU_ADDR16_HI;
113 case BFD_RELOC_SPU_IMM18:
114 return R_SPU_ADDR18;
115 case BFD_RELOC_SPU_PCREL16:
116 return R_SPU_REL16;
117 case BFD_RELOC_SPU_IMM7:
118 return R_SPU_ADDR7;
119 case BFD_RELOC_SPU_IMM8:
120 return R_SPU_NONE;
121 case BFD_RELOC_SPU_PCREL9a:
122 return R_SPU_REL9;
123 case BFD_RELOC_SPU_PCREL9b:
124 return R_SPU_REL9I;
125 case BFD_RELOC_SPU_IMM10:
126 return R_SPU_ADDR10I;
127 case BFD_RELOC_SPU_IMM16:
128 return R_SPU_ADDR16I;
129 case BFD_RELOC_32:
130 return R_SPU_ADDR32;
131 case BFD_RELOC_32_PCREL:
132 return R_SPU_REL32;
ece5ef60
AM		 133 case BFD_RELOC_SPU_PPU32:
134 return R_SPU_PPU32;
135 case BFD_RELOC_SPU_PPU64:
136 return R_SPU_PPU64;
e9f53129
AM		 137 }
138}
139
140static void
141spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
142 arelent *cache_ptr,
143 Elf_Internal_Rela *dst)
144{
145 enum elf_spu_reloc_type r_type;
146
147 r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
148 BFD_ASSERT (r_type < R_SPU_max);
149 cache_ptr->howto = &elf_howto_table[(int) r_type];
150}
151
152static reloc_howto_type *
153spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
154 bfd_reloc_code_real_type code)
155{
b16f296e
AM		 156 enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
157
158 if (r_type == R_SPU_NONE)
159 return NULL;
160
161 return elf_howto_table + r_type;
e9f53129
AM		 162}
163
157090f7
AM		 164static reloc_howto_type *
165spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
166 const char *r_name)
167{
168 unsigned int i;
169
170 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
171 if (elf_howto_table[i].name != NULL
172 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
173 return &elf_howto_table[i];
174
175 return NULL;
176}
177
e9f53129
AM		 178/* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
179
180static bfd_reloc_status_type
181spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
182 void *data, asection *input_section,
183 bfd *output_bfd, char **error_message)
184{
185 bfd_size_type octets;
186 bfd_vma val;
187 long insn;
188
189 /* If this is a relocatable link (output_bfd test tells us), just
190 call the generic function. Any adjustment will be done at final
191 link time. */
192 if (output_bfd != NULL)
193 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
194 input_section, output_bfd, error_message);
195
196 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
197 return bfd_reloc_outofrange;
198 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
199
200 /* Get symbol value. */
201 val = 0;
202 if (!bfd_is_com_section (symbol->section))
203 val = symbol->value;
204 if (symbol->section->output_section)
205 val += symbol->section->output_section->vma;
206
207 val += reloc_entry->addend;
208
209 /* Make it pc-relative. */
210 val -= input_section->output_section->vma + input_section->output_offset;
211
212 val >>= 2;
213 if (val + 256 >= 512)
214 return bfd_reloc_overflow;
215
216 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
217
218 /* Move two high bits of value to REL9I and REL9 position.
219 The mask will take care of selecting the right field. */
220 val = (val & 0x7f) | ((val & 0x180) << 7) | ((val & 0x180) << 16);
221 insn &= ~reloc_entry->howto->dst_mask;
222 insn |= val & reloc_entry->howto->dst_mask;
223 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
224 return bfd_reloc_ok;
225}
226
227static bfd_boolean
228spu_elf_new_section_hook (bfd *abfd, asection *sec)
229{
230 if (!sec->used_by_bfd)
231 {
232 struct _spu_elf_section_data *sdata;
233
234 sdata = bfd_zalloc (abfd, sizeof (*sdata));
235 if (sdata == NULL)
236 return FALSE;
237 sec->used_by_bfd = sdata;
238 }
239
240 return _bfd_elf_new_section_hook (abfd, sec);
241}
242
243/* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
244 strip --strip-unneeded will not remove them. */
245
246static void
247spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
248{
249 if (sym->name != NULL
250 && sym->section != bfd_abs_section_ptr
251 && strncmp (sym->name, "_EAR_", 5) == 0)
252 sym->flags |= BSF_KEEP;
253}
254
255/* SPU ELF linker hash table. */
256
257struct spu_link_hash_table
258{
259 struct elf_link_hash_table elf;
260
e9f53129 261 /* Shortcuts to overlay sections. */
e9f53129 262 asection *ovtab;
47f6dab9
AM		 263 asection *toe;
264 asection **ovl_sec;
265
266 /* Count of stubs in each overlay section. */
267 unsigned int *stub_count;
268
269 /* The stub section for each overlay section. */
270 asection **stub_sec;
e9f53129
AM		 271
272 struct elf_link_hash_entry *ovly_load;
47f6dab9 273 struct elf_link_hash_entry *ovly_return;
2cb5950e 274 unsigned long ovly_load_r_symndx;
e9f53129 275
e9f53129
AM		 276 /* Number of overlay buffers. */
277 unsigned int num_buf;
278
279 /* Total number of overlays. */
280 unsigned int num_overlays;
281
9dcc4794
AM		 282 /* How much memory we have. */
283 unsigned int local_store;
284 /* Local store --auto-overlay should reserve for non-overlay
285 functions and data. */
286 unsigned int overlay_fixed;
287 /* Local store --auto-overlay should reserve for stack and heap. */
288 unsigned int reserved;
289 /* Count of overlay stubs needed in non-overlay area. */
290 unsigned int non_ovly_stub;
291
292 /* Stash various callbacks for --auto-overlay. */
293 void (*spu_elf_load_ovl_mgr) (void);
294 FILE *(*spu_elf_open_overlay_script) (void);
295 void (*spu_elf_relink) (void);
296
297 /* Bit 0 set if --auto-overlay.
298 Bit 1 set if --auto-relink.
299 Bit 2 set if --overlay-rodata. */
300 unsigned int auto_overlay : 3;
301#define AUTO_OVERLAY 1
302#define AUTO_RELINK 2
303#define OVERLAY_RODATA 4
304
e9f53129
AM		 305 /* Set if we should emit symbols for stubs. */
306 unsigned int emit_stub_syms:1;
307
308 /* Set if we want stubs on calls out of overlay regions to
309 non-overlay regions. */
310 unsigned int non_overlay_stubs : 1;
311
312 /* Set on error. */
47f6dab9 313 unsigned int stub_err : 1;
49fa1e15
AM		 314
315 /* Set if stack size analysis should be done. */
316 unsigned int stack_analysis : 1;
317
318 /* Set if __stack_* syms will be emitted. */
319 unsigned int emit_stack_syms : 1;
e9f53129
AM		 320};
321
47f6dab9 322/* Hijack the generic got fields for overlay stub accounting. */
e9f53129 323
47f6dab9 324struct got_entry
e9f53129 325{
47f6dab9
AM		 326 struct got_entry *next;
327 unsigned int ovl;
4a628337 328 bfd_vma addend;
47f6dab9 329 bfd_vma stub_addr;
e9f53129
AM		 330};
331
47f6dab9
AM		 332#define spu_hash_table(p) \
333 ((struct spu_link_hash_table *) ((p)->hash))
e9f53129
AM		 334
335/* Create a spu ELF linker hash table. */
336
337static struct bfd_link_hash_table *
338spu_elf_link_hash_table_create (bfd *abfd)
339{
340 struct spu_link_hash_table *htab;
341
342 htab = bfd_malloc (sizeof (*htab));
343 if (htab == NULL)
344 return NULL;
345
346 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
347 _bfd_elf_link_hash_newfunc,
348 sizeof (struct elf_link_hash_entry)))
349 {
350 free (htab);
351 return NULL;
352 }
353
47f6dab9
AM		 354 memset (&htab->ovtab, 0,
355 sizeof (*htab) - offsetof (struct spu_link_hash_table, ovtab));
e9f53129 356
47f6dab9
AM		 357 htab->elf.init_got_refcount.refcount = 0;
358 htab->elf.init_got_refcount.glist = NULL;
359 htab->elf.init_got_offset.offset = 0;
360 htab->elf.init_got_offset.glist = NULL;
e9f53129
AM		 361 return &htab->elf.root;
362}
363
e9f53129
AM		 364/* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
365 to (hash, NULL) for global symbols, and (NULL, sym) for locals. Set
366 *SYMSECP to the symbol's section. *LOCSYMSP caches local syms. */
367
368static bfd_boolean
369get_sym_h (struct elf_link_hash_entry **hp,
370 Elf_Internal_Sym **symp,
371 asection **symsecp,
372 Elf_Internal_Sym **locsymsp,
373 unsigned long r_symndx,
374 bfd *ibfd)
375{
376 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
377
378 if (r_symndx >= symtab_hdr->sh_info)
379 {
380 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
381 struct elf_link_hash_entry *h;
382
383 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
384 while (h->root.type == bfd_link_hash_indirect
385 || h->root.type == bfd_link_hash_warning)
386 h = (struct elf_link_hash_entry *) h->root.u.i.link;
387
388 if (hp != NULL)
389 *hp = h;
390
391 if (symp != NULL)
392 *symp = NULL;
393
394 if (symsecp != NULL)
395 {
396 asection *symsec = NULL;
397 if (h->root.type == bfd_link_hash_defined
398 || h->root.type == bfd_link_hash_defweak)
399 symsec = h->root.u.def.section;
400 *symsecp = symsec;
401 }
402 }
403 else
404 {
405 Elf_Internal_Sym *sym;
406 Elf_Internal_Sym *locsyms = *locsymsp;
407
408 if (locsyms == NULL)
409 {
410 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
411 if (locsyms == NULL)
49fa1e15
AM		 412 {
413 size_t symcount = symtab_hdr->sh_info;
414
415 /* If we are reading symbols into the contents, then
416 read the global syms too. This is done to cache
417 syms for later stack analysis. */
418 if ((unsigned char **) locsymsp == &symtab_hdr->contents)
419 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
420 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
421 NULL, NULL, NULL);
422 }
e9f53129
AM		 423 if (locsyms == NULL)
424 return FALSE;
425 *locsymsp = locsyms;
426 }
427 sym = locsyms + r_symndx;
428
429 if (hp != NULL)
430 *hp = NULL;
431
432 if (symp != NULL)
433 *symp = sym;
434
435 if (symsecp != NULL)
cb33740c 436 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
e9f53129 437 }
49fa1e15 438
e9f53129
AM		 439 return TRUE;
440}
441
e9f53129
AM		 442/* Create the note section if not already present. This is done early so
443 that the linker maps the sections to the right place in the output. */
444
445bfd_boolean
c65be8d7 446spu_elf_create_sections (struct bfd_link_info *info,
49fa1e15
AM		 447 int stack_analysis,
448 int emit_stack_syms)
e9f53129
AM		 449{
450 bfd *ibfd;
49fa1e15
AM		 451 struct spu_link_hash_table *htab = spu_hash_table (info);
452
453 /* Stash some options away where we can get at them later. */
454 htab->stack_analysis = stack_analysis;
455 htab->emit_stack_syms = emit_stack_syms;
e9f53129 456
58eb693e 457 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
e9f53129
AM		 458 if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
459 break;
460
461 if (ibfd == NULL)
462 {
463 /* Make SPU_PTNOTE_SPUNAME section. */
464 asection *s;
465 size_t name_len;
466 size_t size;
467 bfd_byte *data;
468 flagword flags;
469
470 ibfd = info->input_bfds;
471 flags = SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
472 s = bfd_make_section_anyway_with_flags (ibfd, SPU_PTNOTE_SPUNAME, flags);
473 if (s == NULL
474 || !bfd_set_section_alignment (ibfd, s, 4))
475 return FALSE;
476
c65be8d7 477 name_len = strlen (bfd_get_filename (info->output_bfd)) + 1;
e9f53129
AM		 478 size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
479 size += (name_len + 3) & -4;
480
481 if (!bfd_set_section_size (ibfd, s, size))
482 return FALSE;
483
484 data = bfd_zalloc (ibfd, size);
485 if (data == NULL)
486 return FALSE;
487
488 bfd_put_32 (ibfd, sizeof (SPU_PLUGIN_NAME), data + 0);
489 bfd_put_32 (ibfd, name_len, data + 4);
490 bfd_put_32 (ibfd, 1, data + 8);
491 memcpy (data + 12, SPU_PLUGIN_NAME, sizeof (SPU_PLUGIN_NAME));
492 memcpy (data + 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4),
c65be8d7 493 bfd_get_filename (info->output_bfd), name_len);
e9f53129
AM		 494 s->contents = data;
495 }
496
497 return TRUE;
498}
499
e9f53129
AM		 500/* qsort predicate to sort sections by vma. */
501
502static int
503sort_sections (const void *a, const void *b)
504{
505 const asection *const *s1 = a;
506 const asection *const *s2 = b;
507 bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
508
509 if (delta != 0)
510 return delta < 0 ? -1 : 1;
511
512 return (*s1)->index - (*s2)->index;
513}
514
515/* Identify overlays in the output bfd, and number them. */
516
517bfd_boolean
c65be8d7 518spu_elf_find_overlays (struct bfd_link_info *info)
e9f53129
AM		 519{
520 struct spu_link_hash_table *htab = spu_hash_table (info);
521 asection **alloc_sec;
522 unsigned int i, n, ovl_index, num_buf;
523 asection *s;
524 bfd_vma ovl_end;
525
c65be8d7 526 if (info->output_bfd->section_count < 2)
e9f53129
AM		 527 return FALSE;
528
c65be8d7
AM		 529 alloc_sec
530 = bfd_malloc (info->output_bfd->section_count * sizeof (*alloc_sec));
e9f53129
AM		 531 if (alloc_sec == NULL)
532 return FALSE;
533
534 /* Pick out all the alloced sections. */
c65be8d7 535 for (n = 0, s = info->output_bfd->sections; s != NULL; s = s->next)
e9f53129
AM		 536 if ((s->flags & SEC_ALLOC) != 0
537 && (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
538 && s->size != 0)
539 alloc_sec[n++] = s;
540
541 if (n == 0)
542 {
543 free (alloc_sec);
544 return FALSE;
545 }
546
547 /* Sort them by vma. */
548 qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
549
550 /* Look for overlapping vmas. Any with overlap must be overlays.
47f6dab9 551 Count them. Also count the number of overlay regions. */
e9f53129
AM		 552 ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
553 for (ovl_index = 0, num_buf = 0, i = 1; i < n; i++)
554 {
555 s = alloc_sec[i];
556 if (s->vma < ovl_end)
557 {
558 asection *s0 = alloc_sec[i - 1];
559
47f6dab9 560 if (spu_elf_section_data (s0)->u.o.ovl_index == 0)
e9f53129 561 {
47f6dab9
AM		 562 alloc_sec[ovl_index] = s0;
563 spu_elf_section_data (s0)->u.o.ovl_index = ++ovl_index;
564 spu_elf_section_data (s0)->u.o.ovl_buf = ++num_buf;
e9f53129 565 }
47f6dab9
AM		 566 alloc_sec[ovl_index] = s;
567 spu_elf_section_data (s)->u.o.ovl_index = ++ovl_index;
568 spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
569 if (s0->vma != s->vma)
e9f53129 570 {
47f6dab9
AM		 571 info->callbacks->einfo (_("%X%P: overlay sections %A and %A "
572 "do not start at the same address.\n"),
573 s0, s);
574 return FALSE;
e9f53129 575 }
47f6dab9
AM		 576 if (ovl_end < s->vma + s->size)
577 ovl_end = s->vma + s->size;
e9f53129
AM		 578 }
579 else
580 ovl_end = s->vma + s->size;
581 }
582
583 htab->num_overlays = ovl_index;
584 htab->num_buf = num_buf;
47f6dab9 585 htab->ovl_sec = alloc_sec;
fdba2fcd
AM		 586 htab->ovly_load = elf_link_hash_lookup (&htab->elf, "__ovly_load",
587 FALSE, FALSE, FALSE);
588 htab->ovly_return = elf_link_hash_lookup (&htab->elf, "__ovly_return",
589 FALSE, FALSE, FALSE);
47f6dab9 590 return ovl_index != 0;
e9f53129
AM		 591}
592
47f6dab9
AM		 593/* Support two sizes of overlay stubs, a slower more compact stub of two
594 intructions, and a faster stub of four instructions. */
595#ifndef OVL_STUB_SIZE
596/* Default to faster. */
597#define OVL_STUB_SIZE 16
598/* #define OVL_STUB_SIZE 8 */
599#endif
600#define BRSL 0x33000000
601#define BR 0x32000000
e9f53129 602#define NOP 0x40200000
47f6dab9
AM		 603#define LNOP 0x00200000
604#define ILA 0x42000000
e9f53129 605
49fa1e15 606/* Return true for all relative and absolute branch instructions.
e9f53129
AM		 607 bra 00110000 0..
608 brasl 00110001 0..
609 br 00110010 0..
610 brsl 00110011 0..
611 brz 00100000 0..
612 brnz 00100001 0..
613 brhz 00100010 0..
49fa1e15
AM		 614 brhnz 00100011 0.. */
615
616static bfd_boolean
617is_branch (const unsigned char *insn)
618{
619 return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
620}
621
fad9eaf0
AM		 622/* Return true for all indirect branch instructions.
623 bi 00110101 000
624 bisl 00110101 001
625 iret 00110101 010
626 bisled 00110101 011
627 biz 00100101 000
628 binz 00100101 001
629 bihz 00100101 010
630 bihnz 00100101 011 */
631
632static bfd_boolean
633is_indirect_branch (const unsigned char *insn)
634{
635 return (insn[0] & 0xef) == 0x25 && (insn[1] & 0x80) == 0;
636}
637
49fa1e15 638/* Return true for branch hint instructions.
e9f53129
AM		 639 hbra 0001000..
640 hbrr 0001001.. */
641
642static bfd_boolean
49fa1e15 643is_hint (const unsigned char *insn)
e9f53129 644{
49fa1e15 645 return (insn[0] & 0xfc) == 0x10;
e9f53129
AM		 646}
647
fdba2fcd 648/* True if INPUT_SECTION might need overlay stubs. */
aa7a0635
AM		 649
650static bfd_boolean
fdba2fcd
AM		 651maybe_needs_stubs (asection *input_section, bfd *output_bfd)
652{
653 /* No stubs for debug sections and suchlike. */
654 if ((input_section->flags & SEC_ALLOC) == 0)
655 return FALSE;
656
657 /* No stubs for link-once sections that will be discarded. */
658 if (input_section->output_section == NULL
659 || input_section->output_section->owner != output_bfd)
660 return FALSE;
661
662 /* Don't create stubs for .eh_frame references. */
663 if (strcmp (input_section->name, ".eh_frame") == 0)
664 return FALSE;
665
666 return TRUE;
667}
668
669enum _stub_type
670{
671 no_stub,
672 ovl_stub,
673 nonovl_stub,
674 stub_error
675};
676
677/* Return non-zero if this reloc symbol should go via an overlay stub.
678 Return 2 if the stub must be in non-overlay area. */
679
680static enum _stub_type
681needs_ovl_stub (struct elf_link_hash_entry *h,
682 Elf_Internal_Sym *sym,
aa7a0635
AM		 683 asection *sym_sec,
684 asection *input_section,
fdba2fcd
AM		 685 Elf_Internal_Rela *irela,
686 bfd_byte *contents,
687 struct bfd_link_info *info)
aa7a0635 688{
fdba2fcd
AM		 689 struct spu_link_hash_table *htab = spu_hash_table (info);
690 enum elf_spu_reloc_type r_type;
691 unsigned int sym_type;
692 bfd_boolean branch;
693 enum _stub_type ret = no_stub;
aa7a0635
AM		 694
695 if (sym_sec == NULL
2c67c5f3 696 || sym_sec->output_section == NULL
fdba2fcd 697 || sym_sec->output_section->owner != info->output_bfd
2c67c5f3 698 || spu_elf_section_data (sym_sec->output_section) == NULL)
fdba2fcd 699 return ret;
aa7a0635 700
fdba2fcd
AM		 701 if (h != NULL)
702 {
703 /* Ensure no stubs for user supplied overlay manager syms. */
704 if (h == htab->ovly_load || h == htab->ovly_return)
705 return ret;
706
707 /* setjmp always goes via an overlay stub, because then the return
708 and hence the longjmp goes via __ovly_return. That magically
709 makes setjmp/longjmp between overlays work. */
710 if (strncmp (h->root.root.string, "setjmp", 6) == 0
711 && (h->root.root.string[6] == '\0' || h->root.root.string[6] == '@'))
712 ret = ovl_stub;
713 }
aa7a0635
AM		 714
715 /* Usually, symbols in non-overlay sections don't need stubs. */
47f6dab9 716 if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index == 0
aa7a0635 717 && !htab->non_overlay_stubs)
fdba2fcd
AM		 718 return ret;
719
720 if (h != NULL)
721 sym_type = h->type;
722 else
723 sym_type = ELF_ST_TYPE (sym->st_info);
724
725 r_type = ELF32_R_TYPE (irela->r_info);
726 branch = FALSE;
727 if (r_type == R_SPU_REL16 || r_type == R_SPU_ADDR16)
728 {
729 bfd_byte insn[4];
730
731 if (contents == NULL)
732 {
733 contents = insn;
734 if (!bfd_get_section_contents (input_section->owner,
735 input_section,
736 contents,
737 irela->r_offset, 4))
738 return stub_error;
739 }
740 else
741 contents += irela->r_offset;
742
743 if (is_branch (contents) || is_hint (contents))
744 {
745 branch = TRUE;
746 if ((contents[0] & 0xfd) == 0x31
747 && sym_type != STT_FUNC
9dcc4794 748 && contents != insn)
fdba2fcd
AM		 749 {
750 /* It's common for people to write assembly and forget
751 to give function symbols the right type. Handle
752 calls to such symbols, but warn so that (hopefully)
753 people will fix their code. We need the symbol
754 type to be correct to distinguish function pointer
755 initialisation from other pointer initialisations. */
756 const char *sym_name;
757
758 if (h != NULL)
759 sym_name = h->root.root.string;
760 else
761 {
762 Elf_Internal_Shdr *symtab_hdr;
763 symtab_hdr = &elf_tdata (input_section->owner)->symtab_hdr;
764 sym_name = bfd_elf_sym_name (input_section->owner,
765 symtab_hdr,
766 sym,
767 sym_sec);
768 }
769 (*_bfd_error_handler) (_("warning: call to non-function"
770 " symbol %s defined in %B"),
771 sym_sec->owner, sym_name);
772
773 }
774 }
775 }
776
777 if (sym_type != STT_FUNC
778 && !branch
779 && (sym_sec->flags & SEC_CODE) == 0)
780 return ret;
aa7a0635
AM		 781
782 /* A reference from some other section to a symbol in an overlay
783 section needs a stub. */
47f6dab9
AM		 784 if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index
785 != spu_elf_section_data (input_section->output_section)->u.o.ovl_index)
fdba2fcd 786 return ovl_stub;
aa7a0635
AM		 787
788 /* If this insn isn't a branch then we are possibly taking the
789 address of a function and passing it out somehow. */
fdba2fcd 790 return !branch && sym_type == STT_FUNC ? nonovl_stub : ret;
aa7a0635
AM		 791}
792
47f6dab9
AM		 793static bfd_boolean
794count_stub (struct spu_link_hash_table *htab,
795 bfd *ibfd,
796 asection *isec,
fdba2fcd 797 enum _stub_type stub_type,
47f6dab9
AM		 798 struct elf_link_hash_entry *h,
799 const Elf_Internal_Rela *irela)
800{
801 unsigned int ovl = 0;
802 struct got_entry *g, **head;
4a628337 803 bfd_vma addend;
47f6dab9
AM		 804
805 /* If this instruction is a branch or call, we need a stub
806 for it. One stub per function per overlay.
807 If it isn't a branch, then we are taking the address of
808 this function so need a stub in the non-overlay area
809 for it. One stub per function. */
fdba2fcd 810 if (stub_type != nonovl_stub)
47f6dab9
AM		 811 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
812
813 if (h != NULL)
814 head = &h->got.glist;
815 else
816 {
817 if (elf_local_got_ents (ibfd) == NULL)
818 {
819 bfd_size_type amt = (elf_tdata (ibfd)->symtab_hdr.sh_info
820 * sizeof (*elf_local_got_ents (ibfd)));
821 elf_local_got_ents (ibfd) = bfd_zmalloc (amt);
822 if (elf_local_got_ents (ibfd) == NULL)
823 return FALSE;
824 }
825 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
826 }
827
4a628337
AM		 828 addend = 0;
829 if (irela != NULL)
830 addend = irela->r_addend;
47f6dab9
AM		 831
832 if (ovl == 0)
833 {
834 struct got_entry *gnext;
835
4a628337
AM		 836 for (g = *head; g != NULL; g = g->next)
837 if (g->addend == addend && g->ovl == 0)
838 break;
839
840 if (g == NULL)
47f6dab9 841 {
4a628337
AM		 842 /* Need a new non-overlay area stub. Zap other stubs. */
843 for (g = *head; g != NULL; g = gnext)
844 {
845 gnext = g->next;
846 if (g->addend == addend)
847 {
848 htab->stub_count[g->ovl] -= 1;
849 free (g);
850 }
851 }
47f6dab9
AM		 852 }
853 }
854 else
855 {
4a628337
AM		 856 for (g = *head; g != NULL; g = g->next)
857 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
47f6dab9
AM		 858 break;
859 }
860
861 if (g == NULL)
862 {
863 g = bfd_malloc (sizeof *g);
864 if (g == NULL)
865 return FALSE;
866 g->ovl = ovl;
4a628337 867 g->addend = addend;
47f6dab9
AM		 868 g->stub_addr = (bfd_vma) -1;
869 g->next = *head;
870 *head = g;
871
872 htab->stub_count[ovl] += 1;
873 }
874
875 return TRUE;
876}
877
878/* Two instruction overlay stubs look like:
879
880 brsl $75,__ovly_load
881 .word target_ovl_and_address
882
883 ovl_and_address is a word with the overlay number in the top 14 bits
884 and local store address in the bottom 18 bits.
885
886 Four instruction overlay stubs look like:
887
888 ila $78,ovl_number
889 lnop
890 ila $79,target_address
891 br __ovly_load */
892
893static bfd_boolean
894build_stub (struct spu_link_hash_table *htab,
895 bfd *ibfd,
896 asection *isec,
fdba2fcd 897 enum _stub_type stub_type,
47f6dab9
AM		 898 struct elf_link_hash_entry *h,
899 const Elf_Internal_Rela *irela,
900 bfd_vma dest,
901 asection *dest_sec)
902{
903 unsigned int ovl;
904 struct got_entry *g, **head;
905 asection *sec;
4a628337 906 bfd_vma addend, val, from, to;
47f6dab9
AM		 907
908 ovl = 0;
fdba2fcd 909 if (stub_type != nonovl_stub)
47f6dab9
AM		 910 ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
911
912 if (h != NULL)
913 head = &h->got.glist;
914 else
915 head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
916
4a628337
AM		 917 addend = 0;
918 if (irela != NULL)
919 addend = irela->r_addend;
47f6dab9 920
4a628337
AM		 921 for (g = *head; g != NULL; g = g->next)
922 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
47f6dab9
AM		 923 break;
924 if (g == NULL)
925 abort ();
926
4a628337
AM		 927 if (g->ovl == 0 && ovl != 0)
928 return TRUE;
929
47f6dab9
AM		 930 if (g->stub_addr != (bfd_vma) -1)
931 return TRUE;
932
933 sec = htab->stub_sec[ovl];
934 dest += dest_sec->output_offset + dest_sec->output_section->vma;
935 from = sec->size + sec->output_offset + sec->output_section->vma;
936 g->stub_addr = from;
937 to = (htab->ovly_load->root.u.def.value
938 + htab->ovly_load->root.u.def.section->output_offset
939 + htab->ovly_load->root.u.def.section->output_section->vma);
940 val = to - from;
941 if (OVL_STUB_SIZE == 16)
942 val -= 12;
943 if (((dest | to | from) & 3) != 0
944 || val + 0x20000 >= 0x40000)
945 {
946 htab->stub_err = 1;
947 return FALSE;
948 }
949 ovl = spu_elf_section_data (dest_sec->output_section)->u.o.ovl_index;
950
951 if (OVL_STUB_SIZE == 16)
952 {
953 bfd_put_32 (sec->owner, ILA + ((ovl << 7) & 0x01ffff80) + 78,
954 sec->contents + sec->size);
955 bfd_put_32 (sec->owner, LNOP,
956 sec->contents + sec->size + 4);
957 bfd_put_32 (sec->owner, ILA + ((dest << 7) & 0x01ffff80) + 79,
958 sec->contents + sec->size + 8);
959 bfd_put_32 (sec->owner, BR + ((val << 5) & 0x007fff80),
960 sec->contents + sec->size + 12);
961 }
962 else if (OVL_STUB_SIZE == 8)
963 {
964 bfd_put_32 (sec->owner, BRSL + ((val << 5) & 0x007fff80) + 75,
965 sec->contents + sec->size);
966
967 val = (dest & 0x3ffff) | (ovl << 14);
968 bfd_put_32 (sec->owner, val,
969 sec->contents + sec->size + 4);
970 }
971 else
972 abort ();
973 sec->size += OVL_STUB_SIZE;
974
975 if (htab->emit_stub_syms)
976 {
977 size_t len;
978 char *name;
979 int add;
980
981 len = 8 + sizeof (".ovl_call.") - 1;
982 if (h != NULL)
983 len += strlen (h->root.root.string);
984 else
985 len += 8 + 1 + 8;
986 add = 0;
987 if (irela != NULL)
988 add = (int) irela->r_addend & 0xffffffff;
989 if (add != 0)
990 len += 1 + 8;
991 name = bfd_malloc (len);
992 if (name == NULL)
993 return FALSE;
994
995 sprintf (name, "%08x.ovl_call.", g->ovl);
996 if (h != NULL)
997 strcpy (name + 8 + sizeof (".ovl_call.") - 1, h->root.root.string);
998 else
999 sprintf (name + 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1000 dest_sec->id & 0xffffffff,
1001 (int) ELF32_R_SYM (irela->r_info) & 0xffffffff);
1002 if (add != 0)
1003 sprintf (name + len - 9, "+%x", add);
1004
1005 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1006 free (name);
1007 if (h == NULL)
1008 return FALSE;
1009 if (h->root.type == bfd_link_hash_new)
1010 {
1011 h->root.type = bfd_link_hash_defined;
1012 h->root.u.def.section = sec;
1013 h->root.u.def.value = sec->size - OVL_STUB_SIZE;
1014 h->size = OVL_STUB_SIZE;
1015 h->type = STT_FUNC;
1016 h->ref_regular = 1;
1017 h->def_regular = 1;
1018 h->ref_regular_nonweak = 1;
1019 h->forced_local = 1;
1020 h->non_elf = 0;
1021 }
1022 }
1023
1024 return TRUE;
1025}
1026
f4b39977
AM		 1027/* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1028 symbols. */
1029
1030static bfd_boolean
1031allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1032{
1033 /* Symbols starting with _SPUEAR_ need a stub because they may be
1034 invoked by the PPU. */
380814a6
AM		 1035 struct bfd_link_info *info = inf;
1036 struct spu_link_hash_table *htab = spu_hash_table (info);
1037 asection *sym_sec;
1038
f4b39977
AM		 1039 if ((h->root.type == bfd_link_hash_defined
1040 || h->root.type == bfd_link_hash_defweak)
1041 && h->def_regular
380814a6
AM		 1042 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1043 && (sym_sec = h->root.u.def.section) != NULL
1044 && sym_sec->output_section != NULL
1045 && sym_sec->output_section->owner == info->output_bfd
1046 && spu_elf_section_data (sym_sec->output_section) != NULL
1047 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1048 || htab->non_overlay_stubs))
f4b39977 1049 {
fdba2fcd 1050 count_stub (htab, NULL, NULL, nonovl_stub, h, NULL);
f4b39977
AM		 1051 }
1052
1053 return TRUE;
1054}
1055
e9f53129 1056static bfd_boolean
47f6dab9 1057build_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
e9f53129 1058{
47f6dab9
AM		 1059 /* Symbols starting with _SPUEAR_ need a stub because they may be
1060 invoked by the PPU. */
380814a6
AM		 1061 struct bfd_link_info *info = inf;
1062 struct spu_link_hash_table *htab = spu_hash_table (info);
1063 asection *sym_sec;
1064
47f6dab9
AM		 1065 if ((h->root.type == bfd_link_hash_defined
1066 || h->root.type == bfd_link_hash_defweak)
1067 && h->def_regular
380814a6
AM		 1068 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1069 && (sym_sec = h->root.u.def.section) != NULL
1070 && sym_sec->output_section != NULL
1071 && sym_sec->output_section->owner == info->output_bfd
1072 && spu_elf_section_data (sym_sec->output_section) != NULL
1073 && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1074 || htab->non_overlay_stubs))
47f6dab9 1075 {
fdba2fcd 1076 build_stub (htab, NULL, NULL, nonovl_stub, h, NULL,
380814a6 1077 h->root.u.def.value, sym_sec);
47f6dab9
AM		 1078 }
1079
e9f53129
AM		 1080 return TRUE;
1081}
1082
47f6dab9 1083/* Size or build stubs. */
e9f53129 1084
47f6dab9 1085static bfd_boolean
c65be8d7 1086process_stubs (struct bfd_link_info *info, bfd_boolean build)
e9f53129
AM		 1087{
1088 struct spu_link_hash_table *htab = spu_hash_table (info);
1089 bfd *ibfd;
e9f53129 1090
e9f53129
AM		 1091 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1092 {
1093 extern const bfd_target bfd_elf32_spu_vec;
1094 Elf_Internal_Shdr *symtab_hdr;
47f6dab9 1095 asection *isec;
e9f53129 1096 Elf_Internal_Sym *local_syms = NULL;
d0249648 1097 void *psyms;
e9f53129
AM		 1098
1099 if (ibfd->xvec != &bfd_elf32_spu_vec)
1100 continue;
1101
1102 /* We'll need the symbol table in a second. */
1103 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1104 if (symtab_hdr->sh_info == 0)
1105 continue;
1106
49fa1e15
AM		 1107 /* Arrange to read and keep global syms for later stack analysis. */
1108 psyms = &local_syms;
47f6dab9 1109 if (htab->stack_analysis)
d0249648 1110 psyms = &symtab_hdr->contents;
49fa1e15 1111
e9f53129 1112 /* Walk over each section attached to the input bfd. */
47f6dab9 1113 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
e9f53129
AM		 1114 {
1115 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1116
1117 /* If there aren't any relocs, then there's nothing more to do. */
47f6dab9 1118 if ((isec->flags & SEC_RELOC) == 0
47f6dab9 1119 || isec->reloc_count == 0)
e9f53129
AM		 1120 continue;
1121
c65be8d7 1122 if (!maybe_needs_stubs (isec, info->output_bfd))
e9f53129
AM		 1123 continue;
1124
1125 /* Get the relocs. */
47f6dab9
AM		 1126 internal_relocs = _bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
1127 info->keep_memory);
e9f53129
AM		 1128 if (internal_relocs == NULL)
1129 goto error_ret_free_local;
1130
1131 /* Now examine each relocation. */
1132 irela = internal_relocs;
47f6dab9 1133 irelaend = irela + isec->reloc_count;
e9f53129
AM		 1134 for (; irela < irelaend; irela++)
1135 {
1136 enum elf_spu_reloc_type r_type;
1137 unsigned int r_indx;
1138 asection *sym_sec;
1139 Elf_Internal_Sym *sym;
1140 struct elf_link_hash_entry *h;
fdba2fcd 1141 enum _stub_type stub_type;
e9f53129
AM		 1142
1143 r_type = ELF32_R_TYPE (irela->r_info);
1144 r_indx = ELF32_R_SYM (irela->r_info);
1145
1146 if (r_type >= R_SPU_max)
1147 {
1148 bfd_set_error (bfd_error_bad_value);
47f6dab9
AM		 1149 error_ret_free_internal:
1150 if (elf_section_data (isec)->relocs != internal_relocs)
1151 free (internal_relocs);
1152 error_ret_free_local:
1153 if (local_syms != NULL
1154 && (symtab_hdr->contents
1155 != (unsigned char *) local_syms))
1156 free (local_syms);
1157 return FALSE;
e9f53129
AM		 1158 }
1159
1160 /* Determine the reloc target section. */
49fa1e15 1161 if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, ibfd))
e9f53129
AM		 1162 goto error_ret_free_internal;
1163
fdba2fcd
AM		 1164 stub_type = needs_ovl_stub (h, sym, sym_sec, isec, irela,
1165 NULL, info);
1166 if (stub_type == no_stub)
e9f53129 1167 continue;
fdba2fcd
AM		 1168 else if (stub_type == stub_error)
1169 goto error_ret_free_internal;
e9f53129 1170
47f6dab9 1171 if (htab->stub_count == NULL)
e9f53129 1172 {
47f6dab9
AM		 1173 bfd_size_type amt;
1174 amt = (htab->num_overlays + 1) * sizeof (*htab->stub_count);
1175 htab->stub_count = bfd_zmalloc (amt);
1176 if (htab->stub_count == NULL)
1177 goto error_ret_free_internal;
e9f53129
AM		 1178 }
1179
47f6dab9 1180 if (!build)
e9f53129 1181 {
fdba2fcd 1182 if (!count_stub (htab, ibfd, isec, stub_type, h, irela))
47f6dab9 1183 goto error_ret_free_internal;
e9f53129 1184 }
e9f53129 1185 else
47f6dab9
AM		 1186 {
1187 bfd_vma dest;
1188
1189 if (h != NULL)
1190 dest = h->root.u.def.value;
1191 else
1192 dest = sym->st_value;
4a628337 1193 dest += irela->r_addend;
fdba2fcd 1194 if (!build_stub (htab, ibfd, isec, stub_type, h, irela,
47f6dab9
AM		 1195 dest, sym_sec))
1196 goto error_ret_free_internal;
1197 }
e9f53129
AM		 1198 }
1199
1200 /* We're done with the internal relocs, free them. */
47f6dab9 1201 if (elf_section_data (isec)->relocs != internal_relocs)
e9f53129
AM		 1202 free (internal_relocs);
1203 }
1204
1205 if (local_syms != NULL
1206 && symtab_hdr->contents != (unsigned char *) local_syms)
1207 {
1208 if (!info->keep_memory)
1209 free (local_syms);
1210 else
1211 symtab_hdr->contents = (unsigned char *) local_syms;
1212 }
1213 }
1214
47f6dab9
AM		 1215 return TRUE;
1216}
1217
1218/* Allocate space for overlay call and return stubs. */
1219
1220int
c65be8d7 1221spu_elf_size_stubs (struct bfd_link_info *info,
47f6dab9
AM		 1222 void (*place_spu_section) (asection *, asection *,
1223 const char *),
1224 int non_overlay_stubs)
1225{
1226 struct spu_link_hash_table *htab = spu_hash_table (info);
1227 bfd *ibfd;
1228 bfd_size_type amt;
1229 flagword flags;
1230 unsigned int i;
1231 asection *stub;
1232
1233 htab->non_overlay_stubs = non_overlay_stubs;
c65be8d7 1234 if (!process_stubs (info, FALSE))
47f6dab9
AM		 1235 return 0;
1236
380814a6 1237 elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, info);
47f6dab9
AM		 1238 if (htab->stub_err)
1239 return 0;
f4b39977 1240
47f6dab9
AM		 1241 if (htab->stub_count == NULL)
1242 return 1;
e9f53129
AM		 1243
1244 ibfd = info->input_bfds;
47f6dab9
AM		 1245 amt = (htab->num_overlays + 1) * sizeof (*htab->stub_sec);
1246 htab->stub_sec = bfd_zmalloc (amt);
1247 if (htab->stub_sec == NULL)
1248 return 0;
e9f53129 1249
47f6dab9 1250 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
e9f53129 1251 | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
47f6dab9
AM		 1252 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1253 htab->stub_sec[0] = stub;
1254 if (stub == NULL
1255 || !bfd_set_section_alignment (ibfd, stub, 3 + (OVL_STUB_SIZE > 8)))
1256 return 0;
1257 stub->size = htab->stub_count[0] * OVL_STUB_SIZE;
1258 (*place_spu_section) (stub, NULL, ".text");
e9f53129 1259
47f6dab9 1260 for (i = 0; i < htab->num_overlays; ++i)
e9f53129 1261 {
47f6dab9
AM		 1262 asection *osec = htab->ovl_sec[i];
1263 unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1264 stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1265 htab->stub_sec[ovl] = stub;
1266 if (stub == NULL
1267 || !bfd_set_section_alignment (ibfd, stub, 3 + (OVL_STUB_SIZE > 8)))
1268 return 0;
1269 stub->size = htab->stub_count[ovl] * OVL_STUB_SIZE;
1270 (*place_spu_section) (stub, osec, NULL);
e9f53129 1271 }
e9f53129
AM		 1272
1273 /* htab->ovtab consists of two arrays.
1274 . struct {
1275 . u32 vma;
1276 . u32 size;
1277 . u32 file_off;
1278 . u32 buf;
1279 . } _ovly_table[];
1280 .
1281 . struct {
1282 . u32 mapped;
47f6dab9
AM		 1283 . } _ovly_buf_table[];
1284 . */
e9f53129 1285
47f6dab9
AM		 1286 flags = (SEC_ALLOC | SEC_LOAD
1287 | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1288 htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1289 if (htab->ovtab == NULL
1290 || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1291 return 0;
e9f53129 1292
2e444bea 1293 htab->ovtab->size = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
47f6dab9
AM		 1294 (*place_spu_section) (htab->ovtab, NULL, ".data");
1295
1296 htab->toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1297 if (htab->toe == NULL
1298 || !bfd_set_section_alignment (ibfd, htab->toe, 4))
1299 return 0;
1300 htab->toe->size = 16;
1301 (*place_spu_section) (htab->toe, NULL, ".toe");
1302
1303 return 2;
e9f53129
AM		 1304}
1305
1306/* Functions to handle embedded spu_ovl.o object. */
1307
1308static void *
1309ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1310{
1311 return stream;
1312}
1313
1314static file_ptr
1315ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1316 void *stream,
1317 void *buf,
1318 file_ptr nbytes,
1319 file_ptr offset)
1320{
1321 struct _ovl_stream *os;
1322 size_t count;
1323 size_t max;
1324
1325 os = (struct _ovl_stream *) stream;
7a8757b3 1326 max = (const char *) os->end - (const char *) os->start;
e9f53129
AM		 1327
1328 if ((ufile_ptr) offset >= max)
1329 return 0;
1330
1331 count = nbytes;
1332 if (count > max - offset)
1333 count = max - offset;
1334
7a8757b3 1335 memcpy (buf, (const char *) os->start + offset, count);
e9f53129
AM		 1336 return count;
1337}
1338
1339bfd_boolean
1340spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1341{
1342 *ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1343 "elf32-spu",
1344 ovl_mgr_open,
1345 (void *) stream,
1346 ovl_mgr_pread,
f6cf9273 1347 NULL,
e9f53129
AM		 1348 NULL);
1349 return *ovl_bfd != NULL;
1350}
1351
e9f53129
AM		 1352/* Define an STT_OBJECT symbol. */
1353
1354static struct elf_link_hash_entry *
1355define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1356{
1357 struct elf_link_hash_entry *h;
1358
1359 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1360 if (h == NULL)
1361 return NULL;
1362
1363 if (h->root.type != bfd_link_hash_defined
1364 || !h->def_regular)
1365 {
1366 h->root.type = bfd_link_hash_defined;
1367 h->root.u.def.section = htab->ovtab;
1368 h->type = STT_OBJECT;
1369 h->ref_regular = 1;
1370 h->def_regular = 1;
1371 h->ref_regular_nonweak = 1;
1372 h->non_elf = 0;
1373 }
1374 else
1375 {
1376 (*_bfd_error_handler) (_("%B is not allowed to define %s"),
1377 h->root.u.def.section->owner,
1378 h->root.root.string);
1379 bfd_set_error (bfd_error_bad_value);
1380 return NULL;
1381 }
1382
1383 return h;
1384}
1385
1386/* Fill in all stubs and the overlay tables. */
1387
1388bfd_boolean
47f6dab9 1389spu_elf_build_stubs (struct bfd_link_info *info, int emit_syms)
e9f53129
AM		 1390{
1391 struct spu_link_hash_table *htab = spu_hash_table (info);
1392 struct elf_link_hash_entry *h;
1393 bfd_byte *p;
1394 asection *s;
1395 bfd *obfd;
1396 unsigned int i;
1397
1398 htab->emit_stub_syms = emit_syms;
47f6dab9
AM		 1399 if (htab->stub_count == NULL)
1400 return TRUE;
1401
1402 for (i = 0; i <= htab->num_overlays; i++)
1403 if (htab->stub_sec[i]->size != 0)
1404 {
1405 htab->stub_sec[i]->contents = bfd_zalloc (htab->stub_sec[i]->owner,
1406 htab->stub_sec[i]->size);
1407 if (htab->stub_sec[i]->contents == NULL)
1408 return FALSE;
1409 htab->stub_sec[i]->rawsize = htab->stub_sec[i]->size;
1410 htab->stub_sec[i]->size = 0;
1411 }
e9f53129
AM		 1412
1413 h = elf_link_hash_lookup (&htab->elf, "__ovly_load", FALSE, FALSE, FALSE);
1414 htab->ovly_load = h;
1415 BFD_ASSERT (h != NULL
1416 && (h->root.type == bfd_link_hash_defined
1417 || h->root.type == bfd_link_hash_defweak)
1418 && h->def_regular);
1419
1420 s = h->root.u.def.section->output_section;
47f6dab9 1421 if (spu_elf_section_data (s)->u.o.ovl_index)
e9f53129
AM		 1422 {
1423 (*_bfd_error_handler) (_("%s in overlay section"),
1424 h->root.u.def.section->owner);
1425 bfd_set_error (bfd_error_bad_value);
1426 return FALSE;
1427 }
1428
47f6dab9
AM		 1429 h = elf_link_hash_lookup (&htab->elf, "__ovly_return", FALSE, FALSE, FALSE);
1430 htab->ovly_return = h;
1431
c65be8d7
AM		 1432 /* Fill in all the stubs. */
1433 process_stubs (info, TRUE);
47f6dab9 1434
380814a6 1435 elf_link_hash_traverse (&htab->elf, build_spuear_stubs, info);
47f6dab9
AM		 1436 if (htab->stub_err)
1437 return FALSE;
e9f53129 1438
47f6dab9
AM		 1439 for (i = 0; i <= htab->num_overlays; i++)
1440 {
1441 if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
1442 {
1443 (*_bfd_error_handler) (_("stubs don't match calculated size"));
1444 bfd_set_error (bfd_error_bad_value);
1445 return FALSE;
1446 }
1447 htab->stub_sec[i]->rawsize = 0;
1448 }
1449
1450 if (htab->stub_err)
e9f53129
AM		 1451 {
1452 (*_bfd_error_handler) (_("overlay stub relocation overflow"));
1453 bfd_set_error (bfd_error_bad_value);
1454 return FALSE;
1455 }
1456
1457 htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1458 if (htab->ovtab->contents == NULL)
1459 return FALSE;
1460
1461 /* Write out _ovly_table. */
1462 p = htab->ovtab->contents;
2e444bea
AM		 1463 /* set low bit of .size to mark non-overlay area as present. */
1464 p[7] = 1;
c65be8d7 1465 obfd = htab->ovtab->output_section->owner;
e9f53129
AM		 1466 for (s = obfd->sections; s != NULL; s = s->next)
1467 {
47f6dab9 1468 unsigned int ovl_index = spu_elf_section_data (s)->u.o.ovl_index;
e9f53129
AM		 1469
1470 if (ovl_index != 0)
1471 {
47f6dab9
AM		 1472 unsigned long off = ovl_index * 16;
1473 unsigned int ovl_buf = spu_elf_section_data (s)->u.o.ovl_buf;
1474
e9f53129
AM		 1475 bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
1476 bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16, p + off + 4);
1477 /* file_off written later in spu_elf_modify_program_headers. */
2e444bea 1478 bfd_put_32 (htab->ovtab->owner, ovl_buf, p + off + 12);
e9f53129
AM		 1479 }
1480 }
1481
e9f53129
AM		 1482 h = define_ovtab_symbol (htab, "_ovly_table");
1483 if (h == NULL)
1484 return FALSE;
47f6dab9 1485 h->root.u.def.value = 16;
e9f53129
AM		 1486 h->size = htab->num_overlays * 16;
1487
1488 h = define_ovtab_symbol (htab, "_ovly_table_end");
1489 if (h == NULL)
1490 return FALSE;
47f6dab9 1491 h->root.u.def.value = htab->num_overlays * 16 + 16;
e9f53129
AM		 1492 h->size = 0;
1493
1494 h = define_ovtab_symbol (htab, "_ovly_buf_table");
1495 if (h == NULL)
1496 return FALSE;
47f6dab9 1497 h->root.u.def.value = htab->num_overlays * 16 + 16;
2e444bea 1498 h->size = htab->num_buf * 4;
e9f53129
AM		 1499
1500 h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
1501 if (h == NULL)
1502 return FALSE;
2e444bea 1503 h->root.u.def.value = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
e9f53129
AM		 1504 h->size = 0;
1505
1506 h = define_ovtab_symbol (htab, "_EAR_");
1507 if (h == NULL)
1508 return FALSE;
47f6dab9 1509 h->root.u.def.section = htab->toe;
e9f53129
AM		 1510 h->root.u.def.value = 0;
1511 h->size = 16;
1512
1513 return TRUE;
1514}
1515
c65be8d7 1516/* Check that all loadable section VMAs lie in the range
9dcc4794 1517 LO .. HI inclusive, and stash some parameters for --auto-overlay. */
c65be8d7
AM		 1518
1519asection *
9dcc4794
AM		 1520spu_elf_check_vma (struct bfd_link_info *info,
1521 int auto_overlay,
1522 unsigned int lo,
1523 unsigned int hi,
1524 unsigned int overlay_fixed,
1525 unsigned int reserved,
1526 void (*spu_elf_load_ovl_mgr) (void),
1527 FILE *(*spu_elf_open_overlay_script) (void),
1528 void (*spu_elf_relink) (void))
c65be8d7
AM		 1529{
1530 struct elf_segment_map *m;
1531 unsigned int i;
9dcc4794 1532 struct spu_link_hash_table *htab = spu_hash_table (info);
c65be8d7
AM		 1533 bfd *abfd = info->output_bfd;
1534
9dcc4794
AM		 1535 if (auto_overlay & AUTO_OVERLAY)
1536 htab->auto_overlay = auto_overlay;
1537 htab->local_store = hi + 1 - lo;
1538 htab->overlay_fixed = overlay_fixed;
1539 htab->reserved = reserved;
1540 htab->spu_elf_load_ovl_mgr = spu_elf_load_ovl_mgr;
1541 htab->spu_elf_open_overlay_script = spu_elf_open_overlay_script;
1542 htab->spu_elf_relink = spu_elf_relink;
1543
c65be8d7
AM		 1544 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1545 if (m->p_type == PT_LOAD)
1546 for (i = 0; i < m->count; i++)
1547 if (m->sections[i]->size != 0
1548 && (m->sections[i]->vma < lo
1549 || m->sections[i]->vma > hi
1550 || m->sections[i]->vma + m->sections[i]->size - 1 > hi))
1551 return m->sections[i];
1552
9dcc4794
AM		 1553 /* No need for overlays if it all fits. */
1554 htab->auto_overlay = 0;
c65be8d7
AM		 1555 return NULL;
1556}
1557
49fa1e15
AM		 1558/* OFFSET in SEC (presumably) is the beginning of a function prologue.
1559 Search for stack adjusting insns, and return the sp delta. */
1560
1561static int
1562find_function_stack_adjust (asection *sec, bfd_vma offset)
1563{
1564 int unrecog;
1565 int reg[128];
1566
1567 memset (reg, 0, sizeof (reg));
1568 for (unrecog = 0; offset + 4 <= sec->size && unrecog < 32; offset += 4)
1569 {
1570 unsigned char buf[4];
1571 int rt, ra;
1572 int imm;
1573
1574 /* Assume no relocs on stack adjusing insns. */
1575 if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
1576 break;
1577
1578 if (buf[0] == 0x24 /* stqd */)
1579 continue;
1580
1581 rt = buf[3] & 0x7f;
1582 ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
1583 /* Partly decoded immediate field. */
1584 imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
1585
1586 if (buf[0] == 0x1c /* ai */)
1587 {
1588 imm >>= 7;
1589 imm = (imm ^ 0x200) - 0x200;
1590 reg[rt] = reg[ra] + imm;
1591
1592 if (rt == 1 /* sp */)
1593 {
1594 if (imm > 0)
1595 break;
1596 return reg[rt];
1597 }
1598 }
1599 else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
1600 {
1601 int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
1602
1603 reg[rt] = reg[ra] + reg[rb];
1604 if (rt == 1)
1605 return reg[rt];
1606 }
1607 else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
1608 {
1609 if (buf[0] >= 0x42 /* ila */)
1610 imm |= (buf[0] & 1) << 17;
1611 else
1612 {
1613 imm &= 0xffff;
1614
1615 if (buf[0] == 0x40 /* il */)
1616 {
1617 if ((buf[1] & 0x80) == 0)
1618 goto unknown_insn;
1619 imm = (imm ^ 0x8000) - 0x8000;
1620 }
1621 else if ((buf[1] & 0x80) == 0 /* ilhu */)
1622 imm <<= 16;
1623 }
1624 reg[rt] = imm;
1625 continue;
1626 }
1627 else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
1628 {
1629 reg[rt] |= imm & 0xffff;
1630 continue;
1631 }
1632 else if (buf[0] == 0x04 /* ori */)
1633 {
1634 imm >>= 7;
1635 imm = (imm ^ 0x200) - 0x200;
1636 reg[rt] = reg[ra] | imm;
1637 continue;
1638 }
1639 else if ((buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
1640 || (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */))
1641 {
1642 /* Used in pic reg load. Say rt is trashed. */
1643 reg[rt] = 0;
1644 continue;
1645 }
fad9eaf0 1646 else if (is_branch (buf) || is_indirect_branch (buf))
49fa1e15
AM		 1647 /* If we hit a branch then we must be out of the prologue. */
1648 break;
1649 unknown_insn:
1650 ++unrecog;
1651 }
1652
1653 return 0;
1654}
1655
1656/* qsort predicate to sort symbols by section and value. */
1657
1658static Elf_Internal_Sym *sort_syms_syms;
1659static asection **sort_syms_psecs;
1660
1661static int
1662sort_syms (const void *a, const void *b)
1663{
1664 Elf_Internal_Sym *const *s1 = a;
1665 Elf_Internal_Sym *const *s2 = b;
1666 asection *sec1,*sec2;
1667 bfd_signed_vma delta;
1668
1669 sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
1670 sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
1671
1672 if (sec1 != sec2)
1673 return sec1->index - sec2->index;
1674
1675 delta = (*s1)->st_value - (*s2)->st_value;
1676 if (delta != 0)
1677 return delta < 0 ? -1 : 1;
1678
1679 delta = (*s2)->st_size - (*s1)->st_size;
1680 if (delta != 0)
1681 return delta < 0 ? -1 : 1;
1682
1683 return *s1 < *s2 ? -1 : 1;
1684}
1685
1686struct call_info
1687{
1688 struct function_info *fun;
1689 struct call_info *next;
9dcc4794
AM		 1690 unsigned int count;
1691 unsigned int max_depth;
c65be8d7 1692 unsigned int is_tail : 1;
9dcc4794 1693 unsigned int is_pasted : 1;
49fa1e15
AM		 1694};
1695
1696struct function_info
1697{
1698 /* List of functions called. Also branches to hot/cold part of
1699 function. */
1700 struct call_info *call_list;
1701 /* For hot/cold part of function, point to owner. */
1702 struct function_info *start;
1703 /* Symbol at start of function. */
1704 union {
1705 Elf_Internal_Sym *sym;
1706 struct elf_link_hash_entry *h;
1707 } u;
1708 /* Function section. */
1709 asection *sec;
9dcc4794
AM		 1710 asection *rodata;
1711 /* Where last called from, and number of sections called from. */
1712 asection *last_caller;
1713 unsigned int call_count;
49fa1e15
AM		 1714 /* Address range of (this part of) function. */
1715 bfd_vma lo, hi;
1716 /* Stack usage. */
1717 int stack;
9dcc4794
AM		 1718 /* Distance from root of call tree. Tail and hot/cold branches
1719 count as one deeper. We aren't counting stack frames here. */
1720 unsigned int depth;
49fa1e15
AM		 1721 /* Set if global symbol. */
1722 unsigned int global : 1;
1723 /* Set if known to be start of function (as distinct from a hunk
1724 in hot/cold section. */
1725 unsigned int is_func : 1;
9dcc4794 1726 /* Set if not a root node. */
49fa1e15 1727 unsigned int non_root : 1;
9dcc4794
AM		 1728 /* Flags used during call tree traversal. It's cheaper to replicate
1729 the visit flags than have one which needs clearing after a traversal. */
1730 unsigned int visit1 : 1;
49fa1e15
AM		 1731 unsigned int visit2 : 1;
1732 unsigned int marking : 1;
1733 unsigned int visit3 : 1;
9dcc4794
AM		 1734 unsigned int visit4 : 1;
1735 unsigned int visit5 : 1;
1736 unsigned int visit6 : 1;
1737 unsigned int visit7 : 1;
49fa1e15
AM		 1738};
1739
1740struct spu_elf_stack_info
1741{
1742 int num_fun;
1743 int max_fun;
1744 /* Variable size array describing functions, one per contiguous
1745 address range belonging to a function. */
1746 struct function_info fun[1];
1747};
1748
1749/* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
1750 entries for section SEC. */
1751
1752static struct spu_elf_stack_info *
1753alloc_stack_info (asection *sec, int max_fun)
1754{
1755 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
1756 bfd_size_type amt;
1757
1758 amt = sizeof (struct spu_elf_stack_info);
1759 amt += (max_fun - 1) * sizeof (struct function_info);
47f6dab9
AM		 1760 sec_data->u.i.stack_info = bfd_zmalloc (amt);
1761 if (sec_data->u.i.stack_info != NULL)
1762 sec_data->u.i.stack_info->max_fun = max_fun;
1763 return sec_data->u.i.stack_info;
49fa1e15
AM		 1764}
1765
1766/* Add a new struct function_info describing a (part of a) function
1767 starting at SYM_H. Keep the array sorted by address. */
1768
1769static struct function_info *
1770maybe_insert_function (asection *sec,
1771 void *sym_h,
1772 bfd_boolean global,
1773 bfd_boolean is_func)
1774{
1775 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 1776 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 1777 int i;
1778 bfd_vma off, size;
1779
1780 if (sinfo == NULL)
1781 {
1782 sinfo = alloc_stack_info (sec, 20);
1783 if (sinfo == NULL)
1784 return NULL;
1785 }
1786
1787 if (!global)
1788 {
1789 Elf_Internal_Sym *sym = sym_h;
1790 off = sym->st_value;
1791 size = sym->st_size;
1792 }
1793 else
1794 {
1795 struct elf_link_hash_entry *h = sym_h;
1796 off = h->root.u.def.value;
1797 size = h->size;
1798 }
1799
1800 for (i = sinfo->num_fun; --i >= 0; )
1801 if (sinfo->fun[i].lo <= off)
1802 break;
1803
1804 if (i >= 0)
1805 {
1806 /* Don't add another entry for an alias, but do update some
1807 info. */
1808 if (sinfo->fun[i].lo == off)
1809 {
1810 /* Prefer globals over local syms. */
1811 if (global && !sinfo->fun[i].global)
1812 {
1813 sinfo->fun[i].global = TRUE;
1814 sinfo->fun[i].u.h = sym_h;
1815 }
1816 if (is_func)
1817 sinfo->fun[i].is_func = TRUE;
1818 return &sinfo->fun[i];
1819 }
1820 /* Ignore a zero-size symbol inside an existing function. */
1821 else if (sinfo->fun[i].hi > off && size == 0)
1822 return &sinfo->fun[i];
1823 }
1824
1825 if (++i < sinfo->num_fun)
1826 memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
1827 (sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
1828 else if (i >= sinfo->max_fun)
1829 {
1830 bfd_size_type amt = sizeof (struct spu_elf_stack_info);
1831 bfd_size_type old = amt;
1832
1833 old += (sinfo->max_fun - 1) * sizeof (struct function_info);
1834 sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
1835 amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
1836 sinfo = bfd_realloc (sinfo, amt);
1837 if (sinfo == NULL)
1838 return NULL;
1839 memset ((char *) sinfo + old, 0, amt - old);
47f6dab9 1840 sec_data->u.i.stack_info = sinfo;
49fa1e15
AM		 1841 }
1842 sinfo->fun[i].is_func = is_func;
1843 sinfo->fun[i].global = global;
1844 sinfo->fun[i].sec = sec;
1845 if (global)
1846 sinfo->fun[i].u.h = sym_h;
1847 else
1848 sinfo->fun[i].u.sym = sym_h;
1849 sinfo->fun[i].lo = off;
1850 sinfo->fun[i].hi = off + size;
1851 sinfo->fun[i].stack = -find_function_stack_adjust (sec, off);
1852 sinfo->num_fun += 1;
1853 return &sinfo->fun[i];
1854}
1855
1856/* Return the name of FUN. */
1857
1858static const char *
1859func_name (struct function_info *fun)
1860{
1861 asection *sec;
1862 bfd *ibfd;
1863 Elf_Internal_Shdr *symtab_hdr;
1864
1865 while (fun->start != NULL)
1866 fun = fun->start;
1867
1868 if (fun->global)
1869 return fun->u.h->root.root.string;
1870
1871 sec = fun->sec;
1872 if (fun->u.sym->st_name == 0)
1873 {
1874 size_t len = strlen (sec->name);
1875 char *name = bfd_malloc (len + 10);
1876 if (name == NULL)
1877 return "(null)";
1878 sprintf (name, "%s+%lx", sec->name,
1879 (unsigned long) fun->u.sym->st_value & 0xffffffff);
1880 return name;
1881 }
1882 ibfd = sec->owner;
1883 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1884 return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
1885}
1886
1887/* Read the instruction at OFF in SEC. Return true iff the instruction
1888 is a nop, lnop, or stop 0 (all zero insn). */
1889
1890static bfd_boolean
1891is_nop (asection *sec, bfd_vma off)
1892{
1893 unsigned char insn[4];
1894
1895 if (off + 4 > sec->size
1896 || !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
1897 return FALSE;
1898 if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
1899 return TRUE;
1900 if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
1901 return TRUE;
1902 return FALSE;
1903}
1904
1905/* Extend the range of FUN to cover nop padding up to LIMIT.
1906 Return TRUE iff some instruction other than a NOP was found. */
1907
1908static bfd_boolean
1909insns_at_end (struct function_info *fun, bfd_vma limit)
1910{
1911 bfd_vma off = (fun->hi + 3) & -4;
1912
1913 while (off < limit && is_nop (fun->sec, off))
1914 off += 4;
1915 if (off < limit)
1916 {
1917 fun->hi = off;
1918 return TRUE;
1919 }
1920 fun->hi = limit;
1921 return FALSE;
1922}
1923
1924/* Check and fix overlapping function ranges. Return TRUE iff there
1925 are gaps in the current info we have about functions in SEC. */
1926
1927static bfd_boolean
1928check_function_ranges (asection *sec, struct bfd_link_info *info)
1929{
1930 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 1931 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 1932 int i;
1933 bfd_boolean gaps = FALSE;
1934
1935 if (sinfo == NULL)
1936 return FALSE;
1937
1938 for (i = 1; i < sinfo->num_fun; i++)
1939 if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
1940 {
1941 /* Fix overlapping symbols. */
1942 const char *f1 = func_name (&sinfo->fun[i - 1]);
1943 const char *f2 = func_name (&sinfo->fun[i]);
1944
1945 info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
1946 sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
1947 }
1948 else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
1949 gaps = TRUE;
1950
1951 if (sinfo->num_fun == 0)
1952 gaps = TRUE;
1953 else
1954 {
1955 if (sinfo->fun[0].lo != 0)
1956 gaps = TRUE;
1957 if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
1958 {
1959 const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
1960
1961 info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
1962 sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
1963 }
1964 else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
1965 gaps = TRUE;
1966 }
1967 return gaps;
1968}
1969
1970/* Search current function info for a function that contains address
1971 OFFSET in section SEC. */
1972
1973static struct function_info *
1974find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
1975{
1976 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
47f6dab9 1977 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 1978 int lo, hi, mid;
1979
1980 lo = 0;
1981 hi = sinfo->num_fun;
1982 while (lo < hi)
1983 {
1984 mid = (lo + hi) / 2;
1985 if (offset < sinfo->fun[mid].lo)
1986 hi = mid;
1987 else if (offset >= sinfo->fun[mid].hi)
1988 lo = mid + 1;
1989 else
1990 return &sinfo->fun[mid];
1991 }
1992 info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
1993 sec, offset);
1994 return NULL;
1995}
1996
9dcc4794
AM		 1997/* Add CALLEE to CALLER call list if not already present. Return TRUE
1998 if CALLEE was new. If this function return FALSE, CALLEE should
1999 be freed. */
49fa1e15
AM		 2000
2001static bfd_boolean
2002insert_callee (struct function_info *caller, struct call_info *callee)
2003{
055ed83b
AM		 2004 struct call_info **pp, *p;
2005
2006 for (pp = &caller->call_list; (p = *pp) != NULL; pp = &p->next)
49fa1e15
AM		 2007 if (p->fun == callee->fun)
2008 {
2009 /* Tail calls use less stack than normal calls. Retain entry
2010 for normal call over one for tail call. */
c65be8d7
AM		 2011 p->is_tail &= callee->is_tail;
2012 if (!p->is_tail)
2013 {
2014 p->fun->start = NULL;
2015 p->fun->is_func = TRUE;
2016 }
9dcc4794 2017 p->count += 1;
055ed83b
AM		 2018 /* Reorder list so most recent call is first. */
2019 *pp = p->next;
2020 p->next = caller->call_list;
2021 caller->call_list = p;
49fa1e15
AM		 2022 return FALSE;
2023 }
2024 callee->next = caller->call_list;
9dcc4794 2025 callee->count += 1;
49fa1e15
AM		 2026 caller->call_list = callee;
2027 return TRUE;
2028}
2029
9dcc4794
AM		 2030/* Copy CALL and insert the copy into CALLER. */
2031
2032static bfd_boolean
2033copy_callee (struct function_info *caller, const struct call_info *call)
2034{
2035 struct call_info *callee;
2036 callee = bfd_malloc (sizeof (*callee));
2037 if (callee == NULL)
2038 return FALSE;
2039 *callee = *call;
2040 if (!insert_callee (caller, callee))
2041 free (callee);
2042 return TRUE;
2043}
2044
055ed83b
AM		 2045/* We're only interested in code sections. Testing SEC_IN_MEMORY excludes
2046 overlay stub sections. */
2047
2048static bfd_boolean
2049interesting_section (asection *s, bfd *obfd)
2050{
2051 return (s->output_section != NULL
2052 && s->output_section->owner == obfd
2053 && ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_IN_MEMORY))
2054 == (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2055 && s->size != 0);
2056}
2057
49fa1e15
AM		 2058/* Rummage through the relocs for SEC, looking for function calls.
2059 If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
2060 mark destination symbols on calls as being functions. Also
2061 look at branches, which may be tail calls or go to hot/cold
2062 section part of same function. */
2063
2064static bfd_boolean
2065mark_functions_via_relocs (asection *sec,
2066 struct bfd_link_info *info,
2067 int call_tree)
2068{
2069 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2070 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
d0249648
AM		 2071 Elf_Internal_Sym *syms;
2072 void *psyms;
49fa1e15
AM		 2073 static bfd_boolean warned;
2074
055ed83b
AM		 2075 if (!interesting_section (sec, info->output_bfd)
2076 || sec->reloc_count == 0)
2077 return TRUE;
2078
49fa1e15
AM		 2079 internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
2080 info->keep_memory);
2081 if (internal_relocs == NULL)
2082 return FALSE;
2083
2084 symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
d0249648
AM		 2085 psyms = &symtab_hdr->contents;
2086 syms = *(Elf_Internal_Sym **) psyms;
49fa1e15
AM		 2087 irela = internal_relocs;
2088 irelaend = irela + sec->reloc_count;
2089 for (; irela < irelaend; irela++)
2090 {
2091 enum elf_spu_reloc_type r_type;
2092 unsigned int r_indx;
2093 asection *sym_sec;
2094 Elf_Internal_Sym *sym;
2095 struct elf_link_hash_entry *h;
2096 bfd_vma val;
9dcc4794 2097 bfd_boolean reject, is_call;
49fa1e15
AM		 2098 struct function_info *caller;
2099 struct call_info *callee;
2100
9dcc4794 2101 reject = FALSE;
49fa1e15
AM		 2102 r_type = ELF32_R_TYPE (irela->r_info);
2103 if (r_type != R_SPU_REL16
2104 && r_type != R_SPU_ADDR16)
9dcc4794
AM		 2105 {
2106 reject = TRUE;
2107 if (!(call_tree && spu_hash_table (info)->auto_overlay))
2108 continue;
2109 }
49fa1e15
AM		 2110
2111 r_indx = ELF32_R_SYM (irela->r_info);
2112 if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
2113 return FALSE;
2114
2115 if (sym_sec == NULL
2116 || sym_sec->output_section == NULL
055ed83b 2117 || sym_sec->output_section->owner != info->output_bfd)
49fa1e15
AM		 2118 continue;
2119
9dcc4794
AM		 2120 is_call = FALSE;
2121 if (!reject)
2122 {
2123 unsigned char insn[4];
2124
2125 if (!bfd_get_section_contents (sec->owner, sec, insn,
2126 irela->r_offset, 4))
2127 return FALSE;
2128 if (is_branch (insn))
2129 {
2130 is_call = (insn[0] & 0xfd) == 0x31;
2131 if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2132 != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2133 {
2134 if (!warned)
2135 info->callbacks->einfo
2136 (_("%B(%A+0x%v): call to non-code section"
2137 " %B(%A), analysis incomplete\n"),
2138 sec->owner, sec, irela->r_offset,
2139 sym_sec->owner, sym_sec);
2140 warned = TRUE;
2141 continue;
2142 }
2143 }
2144 else
2145 {
2146 reject = TRUE;
2147 if (!(call_tree && spu_hash_table (info)->auto_overlay)
2148 || is_hint (insn))
2149 continue;
2150 }
2151 }
49fa1e15 2152
9dcc4794 2153 if (reject)
49fa1e15 2154 {
9dcc4794
AM		 2155 /* For --auto-overlay, count possible stubs we need for
2156 function pointer references. */
2157 unsigned int sym_type;
2158 if (h)
2159 sym_type = h->type;
2160 else
2161 sym_type = ELF_ST_TYPE (sym->st_info);
2162 if (sym_type == STT_FUNC)
2163 spu_hash_table (info)->non_ovly_stub += 1;
49fa1e15
AM		 2164 continue;
2165 }
2166
49fa1e15
AM		 2167 if (h)
2168 val = h->root.u.def.value;
2169 else
2170 val = sym->st_value;
2171 val += irela->r_addend;
2172
2173 if (!call_tree)
2174 {
2175 struct function_info *fun;
2176
2177 if (irela->r_addend != 0)
2178 {
2179 Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
2180 if (fake == NULL)
2181 return FALSE;
2182 fake->st_value = val;
2183 fake->st_shndx
2184 = _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
2185 sym = fake;
2186 }
2187 if (sym)
2188 fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
2189 else
2190 fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
2191 if (fun == NULL)
2192 return FALSE;
2193 if (irela->r_addend != 0
2194 && fun->u.sym != sym)
2195 free (sym);
2196 continue;
2197 }
2198
2199 caller = find_function (sec, irela->r_offset, info);
2200 if (caller == NULL)
2201 return FALSE;
2202 callee = bfd_malloc (sizeof *callee);
2203 if (callee == NULL)
2204 return FALSE;
2205
2206 callee->fun = find_function (sym_sec, val, info);
2207 if (callee->fun == NULL)
2208 return FALSE;
2209 callee->is_tail = !is_call;
9dcc4794
AM		 2210 callee->is_pasted = FALSE;
2211 callee->count = 0;
2212 if (callee->fun->last_caller != sec)
2213 {
2214 callee->fun->last_caller = sec;
2215 callee->fun->call_count += 1;
2216 }
49fa1e15
AM		 2217 if (!insert_callee (caller, callee))
2218 free (callee);
2219 else if (!is_call
2220 && !callee->fun->is_func
2221 && callee->fun->stack == 0)
2222 {
2223 /* This is either a tail call or a branch from one part of
2224 the function to another, ie. hot/cold section. If the
2225 destination has been called by some other function then
2226 it is a separate function. We also assume that functions
2227 are not split across input files. */
911f096e 2228 if (sec->owner != sym_sec->owner)
49fa1e15
AM		 2229 {
2230 callee->fun->start = NULL;
2231 callee->fun->is_func = TRUE;
2232 }
911f096e 2233 else if (callee->fun->start == NULL)
49fa1e15 2234 callee->fun->start = caller;
911f096e
AM		 2235 else
2236 {
2237 struct function_info *callee_start;
2238 struct function_info *caller_start;
2239 callee_start = callee->fun;
2240 while (callee_start->start)
2241 callee_start = callee_start->start;
2242 caller_start = caller;
2243 while (caller_start->start)
2244 caller_start = caller_start->start;
2245 if (caller_start != callee_start)
2246 {
2247 callee->fun->start = NULL;
2248 callee->fun->is_func = TRUE;
2249 }
2250 }
49fa1e15
AM		 2251 }
2252 }
2253
2254 return TRUE;
2255}
2256
2257/* Handle something like .init or .fini, which has a piece of a function.
2258 These sections are pasted together to form a single function. */
2259
2260static bfd_boolean
2261pasted_function (asection *sec, struct bfd_link_info *info)
2262{
2263 struct bfd_link_order *l;
2264 struct _spu_elf_section_data *sec_data;
2265 struct spu_elf_stack_info *sinfo;
2266 Elf_Internal_Sym *fake;
2267 struct function_info *fun, *fun_start;
2268
2269 fake = bfd_zmalloc (sizeof (*fake));
2270 if (fake == NULL)
2271 return FALSE;
2272 fake->st_value = 0;
2273 fake->st_size = sec->size;
2274 fake->st_shndx
2275 = _bfd_elf_section_from_bfd_section (sec->owner, sec);
2276 fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2277 if (!fun)
2278 return FALSE;
2279
2280 /* Find a function immediately preceding this section. */
2281 fun_start = NULL;
2282 for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2283 {
2284 if (l->u.indirect.section == sec)
2285 {
2286 if (fun_start != NULL)
9dcc4794
AM		 2287 {
2288 struct call_info *callee = bfd_malloc (sizeof *callee);
2289 if (callee == NULL)
2290 return FALSE;
2291
2292 fun->start = fun_start;
2293 callee->fun = fun;
2294 callee->is_tail = TRUE;
2295 callee->is_pasted = TRUE;
2296 callee->count = 0;
2297 if (!insert_callee (fun_start, callee))
2298 free (callee);
2299 return TRUE;
2300 }
2301 break;
49fa1e15
AM		 2302 }
2303 if (l->type == bfd_indirect_link_order
2304 && (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
47f6dab9 2305 && (sinfo = sec_data->u.i.stack_info) != NULL
49fa1e15
AM		 2306 && sinfo->num_fun != 0)
2307 fun_start = &sinfo->fun[sinfo->num_fun - 1];
2308 }
2309
2310 info->callbacks->einfo (_("%A link_order not found\n"), sec);
2311 return FALSE;
2312}
2313
49fa1e15
AM		 2314/* Map address ranges in code sections to functions. */
2315
2316static bfd_boolean
c65be8d7 2317discover_functions (struct bfd_link_info *info)
49fa1e15 2318{
49fa1e15
AM		 2319 bfd *ibfd;
2320 int bfd_idx;
2321 Elf_Internal_Sym ***psym_arr;
2322 asection ***sec_arr;
2323 bfd_boolean gaps = FALSE;
2324
2325 bfd_idx = 0;
2326 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2327 bfd_idx++;
2328
2329 psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2330 if (psym_arr == NULL)
2331 return FALSE;
2332 sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2333 if (sec_arr == NULL)
2334 return FALSE;
2335
2336
2337 for (ibfd = info->input_bfds, bfd_idx = 0;
2338 ibfd != NULL;
2339 ibfd = ibfd->link_next, bfd_idx++)
2340 {
2341 extern const bfd_target bfd_elf32_spu_vec;
2342 Elf_Internal_Shdr *symtab_hdr;
2343 asection *sec;
2344 size_t symcount;
2345 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2346 asection **psecs, **p;
2347
2348 if (ibfd->xvec != &bfd_elf32_spu_vec)
2349 continue;
2350
2351 /* Read all the symbols. */
2352 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2353 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2354 if (symcount == 0)
055ed83b
AM		 2355 {
2356 if (!gaps)
2357 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2358 if (interesting_section (sec, info->output_bfd))
2359 {
2360 gaps = TRUE;
2361 break;
2362 }
2363 continue;
2364 }
49fa1e15
AM		 2365
2366 syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2367 if (syms == NULL)
2368 {
2369 syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2370 NULL, NULL, NULL);
2371 symtab_hdr->contents = (void *) syms;
2372 if (syms == NULL)
2373 return FALSE;
2374 }
2375
2376 /* Select defined function symbols that are going to be output. */
2377 psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2378 if (psyms == NULL)
2379 return FALSE;
2380 psym_arr[bfd_idx] = psyms;
2381 psecs = bfd_malloc (symcount * sizeof (*psecs));
2382 if (psecs == NULL)
2383 return FALSE;
2384 sec_arr[bfd_idx] = psecs;
2385 for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
2386 if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
2387 || ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2388 {
2389 asection *s;
2390
2391 *p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
c65be8d7 2392 if (s != NULL && interesting_section (s, info->output_bfd))
49fa1e15
AM		 2393 *psy++ = sy;
2394 }
2395 symcount = psy - psyms;
2396 *psy = NULL;
2397
2398 /* Sort them by section and offset within section. */
2399 sort_syms_syms = syms;
2400 sort_syms_psecs = psecs;
2401 qsort (psyms, symcount, sizeof (*psyms), sort_syms);
2402
2403 /* Now inspect the function symbols. */
2404 for (psy = psyms; psy < psyms + symcount; )
2405 {
2406 asection *s = psecs[*psy - syms];
2407 Elf_Internal_Sym **psy2;
2408
2409 for (psy2 = psy; ++psy2 < psyms + symcount; )
2410 if (psecs[*psy2 - syms] != s)
2411 break;
2412
2413 if (!alloc_stack_info (s, psy2 - psy))
2414 return FALSE;
2415 psy = psy2;
2416 }
2417
2418 /* First install info about properly typed and sized functions.
2419 In an ideal world this will cover all code sections, except
2420 when partitioning functions into hot and cold sections,
2421 and the horrible pasted together .init and .fini functions. */
2422 for (psy = psyms; psy < psyms + symcount; ++psy)
2423 {
2424 sy = *psy;
2425 if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2426 {
2427 asection *s = psecs[sy - syms];
2428 if (!maybe_insert_function (s, sy, FALSE, TRUE))
2429 return FALSE;
2430 }
2431 }
2432
2433 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
c65be8d7 2434 if (interesting_section (sec, info->output_bfd))
49fa1e15
AM		 2435 gaps |= check_function_ranges (sec, info);
2436 }
2437
2438 if (gaps)
2439 {
2440 /* See if we can discover more function symbols by looking at
2441 relocations. */
2442 for (ibfd = info->input_bfds, bfd_idx = 0;
2443 ibfd != NULL;
2444 ibfd = ibfd->link_next, bfd_idx++)
2445 {
2446 asection *sec;
2447
2448 if (psym_arr[bfd_idx] == NULL)
2449 continue;
2450
2451 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
055ed83b
AM		 2452 if (!mark_functions_via_relocs (sec, info, FALSE))
2453 return FALSE;
49fa1e15
AM		 2454 }
2455
2456 for (ibfd = info->input_bfds, bfd_idx = 0;
2457 ibfd != NULL;
2458 ibfd = ibfd->link_next, bfd_idx++)
2459 {
2460 Elf_Internal_Shdr *symtab_hdr;
2461 asection *sec;
2462 Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2463 asection **psecs;
2464
2465 if ((psyms = psym_arr[bfd_idx]) == NULL)
2466 continue;
2467
2468 psecs = sec_arr[bfd_idx];
2469
2470 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2471 syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2472
2473 gaps = FALSE;
2474 for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
c65be8d7 2475 if (interesting_section (sec, info->output_bfd))
49fa1e15
AM		 2476 gaps |= check_function_ranges (sec, info);
2477 if (!gaps)
2478 continue;
2479
2480 /* Finally, install all globals. */
2481 for (psy = psyms; (sy = *psy) != NULL; ++psy)
2482 {
2483 asection *s;
2484
2485 s = psecs[sy - syms];
2486
2487 /* Global syms might be improperly typed functions. */
2488 if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
2489 && ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
2490 {
2491 if (!maybe_insert_function (s, sy, FALSE, FALSE))
2492 return FALSE;
2493 }
2494 }
055ed83b
AM		 2495 }
2496
2497 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2498 {
2499 extern const bfd_target bfd_elf32_spu_vec;
2500 asection *sec;
2501
2502 if (ibfd->xvec != &bfd_elf32_spu_vec)
2503 continue;
49fa1e15
AM		 2504
2505 /* Some of the symbols we've installed as marking the
2506 beginning of functions may have a size of zero. Extend
2507 the range of such functions to the beginning of the
2508 next symbol of interest. */
2509 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
c65be8d7 2510 if (interesting_section (sec, info->output_bfd))
49fa1e15
AM		 2511 {
2512 struct _spu_elf_section_data *sec_data;
2513 struct spu_elf_stack_info *sinfo;
2514
2515 sec_data = spu_elf_section_data (sec);
47f6dab9 2516 sinfo = sec_data->u.i.stack_info;
49fa1e15
AM		 2517 if (sinfo != NULL)
2518 {
2519 int fun_idx;
2520 bfd_vma hi = sec->size;
2521
2522 for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
2523 {
2524 sinfo->fun[fun_idx].hi = hi;
2525 hi = sinfo->fun[fun_idx].lo;
2526 }
2527 }
2528 /* No symbols in this section. Must be .init or .fini
2529 or something similar. */
2530 else if (!pasted_function (sec, info))
2531 return FALSE;
2532 }
2533 }
2534 }
2535
2536 for (ibfd = info->input_bfds, bfd_idx = 0;
2537 ibfd != NULL;
2538 ibfd = ibfd->link_next, bfd_idx++)
2539 {
2540 if (psym_arr[bfd_idx] == NULL)
2541 continue;
2542
2543 free (psym_arr[bfd_idx]);
2544 free (sec_arr[bfd_idx]);
2545 }
2546
2547 free (psym_arr);
2548 free (sec_arr);
2549
2550 return TRUE;
2551}
2552
055ed83b
AM		 2553/* Iterate over all function_info we have collected, calling DOIT on
2554 each node if ROOT_ONLY is false. Only call DOIT on root nodes
2555 if ROOT_ONLY. */
2556
2557static bfd_boolean
2558for_each_node (bfd_boolean (*doit) (struct function_info *,
2559 struct bfd_link_info *,
2560 void *),
2561 struct bfd_link_info *info,
2562 void *param,
2563 int root_only)
2564{
2565 bfd *ibfd;
2566
2567 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2568 {
2569 extern const bfd_target bfd_elf32_spu_vec;
2570 asection *sec;
2571
2572 if (ibfd->xvec != &bfd_elf32_spu_vec)
2573 continue;
2574
2575 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2576 {
2577 struct _spu_elf_section_data *sec_data;
2578 struct spu_elf_stack_info *sinfo;
2579
2580 if ((sec_data = spu_elf_section_data (sec)) != NULL
2581 && (sinfo = sec_data->u.i.stack_info) != NULL)
2582 {
2583 int i;
2584 for (i = 0; i < sinfo->num_fun; ++i)
2585 if (!root_only || !sinfo->fun[i].non_root)
2586 if (!doit (&sinfo->fun[i], info, param))
2587 return FALSE;
2588 }
2589 }
2590 }
2591 return TRUE;
2592}
2593
2594/* Transfer call info attached to struct function_info entries for
2595 all of a given function's sections to the first entry. */
2596
2597static bfd_boolean
2598transfer_calls (struct function_info *fun,
2599 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2600 void *param ATTRIBUTE_UNUSED)
2601{
2602 struct function_info *start = fun->start;
2603
2604 if (start != NULL)
2605 {
2606 struct call_info *call, *call_next;
2607
2608 while (start->start != NULL)
2609 start = start->start;
2610 for (call = fun->call_list; call != NULL; call = call_next)
2611 {
2612 call_next = call->next;
2613 if (!insert_callee (start, call))
2614 free (call);
2615 }
2616 fun->call_list = NULL;
2617 }
2618 return TRUE;
2619}
2620
49fa1e15
AM		 2621/* Mark nodes in the call graph that are called by some other node. */
2622
055ed83b
AM		 2623static bfd_boolean
2624mark_non_root (struct function_info *fun,
2625 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2626 void *param ATTRIBUTE_UNUSED)
49fa1e15
AM		 2627{
2628 struct call_info *call;
2629
055ed83b
AM		 2630 if (fun->visit1)
2631 return TRUE;
49fa1e15
AM		 2632 fun->visit1 = TRUE;
2633 for (call = fun->call_list; call; call = call->next)
2634 {
2635 call->fun->non_root = TRUE;
055ed83b 2636 mark_non_root (call->fun, 0, 0);
49fa1e15 2637 }
055ed83b 2638 return TRUE;
49fa1e15
AM		 2639}
2640
9dcc4794 2641/* Remove cycles from the call graph. Set depth of nodes. */
49fa1e15 2642
055ed83b
AM		 2643static bfd_boolean
2644remove_cycles (struct function_info *fun,
2645 struct bfd_link_info *info,
9dcc4794 2646 void *param)
49fa1e15
AM		 2647{
2648 struct call_info **callp, *call;
9dcc4794
AM		 2649 unsigned int depth = *(unsigned int *) param;
2650 unsigned int max_depth = depth;
49fa1e15 2651
9dcc4794 2652 fun->depth = depth;
49fa1e15
AM		 2653 fun->visit2 = TRUE;
2654 fun->marking = TRUE;
2655
2656 callp = &fun->call_list;
2657 while ((call = *callp) != NULL)
2658 {
2659 if (!call->fun->visit2)
055ed83b 2660 {
9dcc4794
AM		 2661 call->max_depth = depth + !call->is_pasted;
2662 if (!remove_cycles (call->fun, info, &call->max_depth))
055ed83b 2663 return FALSE;
9dcc4794
AM		 2664 if (max_depth < call->max_depth)
2665 max_depth = call->max_depth;
055ed83b 2666 }
49fa1e15
AM		 2667 else if (call->fun->marking)
2668 {
9dcc4794
AM		 2669 if (!spu_hash_table (info)->auto_overlay)
2670 {
2671 const char *f1 = func_name (fun);
2672 const char *f2 = func_name (call->fun);
49fa1e15 2673
9dcc4794
AM		 2674 info->callbacks->info (_("Stack analysis will ignore the call "
2675 "from %s to %s\n"),
2676 f1, f2);
2677 }
49fa1e15 2678 *callp = call->next;
055ed83b 2679 free (call);
49fa1e15
AM		 2680 continue;
2681 }
2682 callp = &call->next;
2683 }
2684 fun->marking = FALSE;
9dcc4794 2685 *(unsigned int *) param = max_depth;
055ed83b 2686 return TRUE;
49fa1e15
AM		 2687}
2688
2689/* Populate call_list for each function. */
2690
2691static bfd_boolean
c65be8d7 2692build_call_tree (struct bfd_link_info *info)
49fa1e15 2693{
49fa1e15 2694 bfd *ibfd;
9dcc4794 2695 unsigned int depth;
49fa1e15
AM		 2696
2697 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2698 {
2699 extern const bfd_target bfd_elf32_spu_vec;
2700 asection *sec;
2701
2702 if (ibfd->xvec != &bfd_elf32_spu_vec)
2703 continue;
2704
2705 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
055ed83b
AM		 2706 if (!mark_functions_via_relocs (sec, info, TRUE))
2707 return FALSE;
49fa1e15
AM		 2708 }
2709
055ed83b
AM		 2710 /* Transfer call info from hot/cold section part of function
2711 to main entry. */
9dcc4794
AM		 2712 if (!spu_hash_table (info)->auto_overlay
2713 && !for_each_node (transfer_calls, info, 0, FALSE))
055ed83b 2714 return FALSE;
49fa1e15 2715
055ed83b
AM		 2716 /* Find the call graph root(s). */
2717 if (!for_each_node (mark_non_root, info, 0, FALSE))
2718 return FALSE;
49fa1e15
AM		 2719
2720 /* Remove cycles from the call graph. We start from the root node(s)
2721 so that we break cycles in a reasonable place. */
9dcc4794
AM		 2722 depth = 0;
2723 return for_each_node (remove_cycles, info, &depth, TRUE);
2724}
2725
2726/* qsort predicate to sort calls by max_depth then count. */
2727
2728static int
2729sort_calls (const void *a, const void *b)
2730{
2731 struct call_info *const *c1 = a;
2732 struct call_info *const *c2 = b;
2733 int delta;
2734
2735 delta = (*c2)->max_depth - (*c1)->max_depth;
2736 if (delta != 0)
2737 return delta;
2738
2739 delta = (*c2)->count - (*c1)->count;
2740 if (delta != 0)
2741 return delta;
2742
2743 return c1 - c2;
2744}
2745
2746struct _mos_param {
2747 unsigned int max_overlay_size;
2748};
2749
2750/* Set linker_mark and gc_mark on any sections that we will put in
2751 overlays. These flags are used by the generic ELF linker, but we
2752 won't be continuing on to bfd_elf_final_link so it is OK to use
2753 them. linker_mark is clear before we get here. Set segment_mark
2754 on sections that are part of a pasted function (excluding the last
2755 section).
2756
2757 Set up function rodata section if --overlay-rodata. We don't
2758 currently include merged string constant rodata sections since
2759
2760 Sort the call graph so that the deepest nodes will be visited
2761 first. */
2762
2763static bfd_boolean
2764mark_overlay_section (struct function_info *fun,
2765 struct bfd_link_info *info,
2766 void *param)
2767{
2768 struct call_info *call;
2769 unsigned int count;
2770 struct _mos_param *mos_param = param;
2771
2772 if (fun->visit4)
2773 return TRUE;
2774
2775 fun->visit4 = TRUE;
2776 if (!fun->sec->linker_mark)
2777 {
2778 fun->sec->linker_mark = 1;
2779 fun->sec->gc_mark = 1;
2780 fun->sec->segment_mark = 0;
2781 /* Ensure SEC_CODE is set on this text section (it ought to
2782 be!), and SEC_CODE is clear on rodata sections. We use
2783 this flag to differentiate the two overlay section types. */
2784 fun->sec->flags |= SEC_CODE;
2785 if (spu_hash_table (info)->auto_overlay & OVERLAY_RODATA)
2786 {
2787 char *name = NULL;
2788 unsigned int size;
2789
2790 /* Find the rodata section corresponding to this function's
2791 text section. */
2792 if (strcmp (fun->sec->name, ".text") == 0)
2793 {
2794 name = bfd_malloc (sizeof (".rodata"));
2795 if (name == NULL)
2796 return FALSE;
2797 memcpy (name, ".rodata", sizeof (".rodata"));
2798 }
2799 else if (strncmp (fun->sec->name, ".text.", 6) == 0)
2800 {
2801 size_t len = strlen (fun->sec->name);
2802 name = bfd_malloc (len + 3);
2803 if (name == NULL)
2804 return FALSE;
2805 memcpy (name, ".rodata", sizeof (".rodata"));
2806 memcpy (name + 7, fun->sec->name + 5, len - 4);
2807 }
2808 else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
2809 {
2810 size_t len = strlen (fun->sec->name) + 1;
2811 name = bfd_malloc (len);
2812 if (name == NULL)
2813 return FALSE;
2814 memcpy (name, fun->sec->name, len);
2815 name[14] = 'r';
2816 }
2817
2818 if (name != NULL)
2819 {
2820 asection *rodata = NULL;
2821 asection *group_sec = elf_section_data (fun->sec)->next_in_group;
2822 if (group_sec == NULL)
2823 rodata = bfd_get_section_by_name (fun->sec->owner, name);
2824 else
2825 while (group_sec != NULL && group_sec != fun->sec)
2826 {
2827 if (strcmp (group_sec->name, name) == 0)
2828 {
2829 rodata = group_sec;
2830 break;
2831 }
2832 group_sec = elf_section_data (group_sec)->next_in_group;
2833 }
2834 fun->rodata = rodata;
2835 if (fun->rodata)
2836 {
2837 fun->rodata->linker_mark = 1;
2838 fun->rodata->gc_mark = 1;
2839 fun->rodata->flags &= ~SEC_CODE;
2840 }
2841 free (name);
2842 }
2843 size = fun->sec->size;
2844 if (fun->rodata)
2845 size += fun->rodata->size;
2846 if (mos_param->max_overlay_size < size)
2847 mos_param->max_overlay_size = size;
2848 }
2849 }
2850
2851 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
2852 count += 1;
2853
2854 if (count > 1)
2855 {
2856 struct call_info **calls = bfd_malloc (count * sizeof (*calls));
2857 if (calls == NULL)
2858 return FALSE;
2859
2860 for (count = 0, call = fun->call_list; call != NULL; call = call->next)
2861 calls[count++] = call;
2862
2863 qsort (calls, count, sizeof (*calls), sort_calls);
2864
2865 fun->call_list = NULL;
2866 while (count != 0)
2867 {
2868 --count;
2869 calls[count]->next = fun->call_list;
2870 fun->call_list = calls[count];
2871 }
2872 free (calls);
2873 }
2874
2875 for (call = fun->call_list; call != NULL; call = call->next)
2876 {
2877 if (call->is_pasted)
2878 {
2879 /* There can only be one is_pasted call per function_info. */
2880 BFD_ASSERT (!fun->sec->segment_mark);
2881 fun->sec->segment_mark = 1;
2882 }
2883 if (!mark_overlay_section (call->fun, info, param))
2884 return FALSE;
2885 }
2886
2887 /* Don't put entry code into an overlay. The overlay manager needs
2888 a stack! */
2889 if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
2890 == info->output_bfd->start_address)
2891 {
2892 fun->sec->linker_mark = 0;
2893 if (fun->rodata != NULL)
2894 fun->rodata->linker_mark = 0;
2895 }
2896 return TRUE;
2897}
2898
2899struct _uos_param {
2900 asection *exclude_input_section;
2901 asection *exclude_output_section;
2902 unsigned long clearing;
2903};
2904
2905/* Undo some of mark_overlay_section's work. */
2906
2907static bfd_boolean
2908unmark_overlay_section (struct function_info *fun,
2909 struct bfd_link_info *info,
2910 void *param)
2911{
2912 struct call_info *call;
2913 struct _uos_param *uos_param = param;
2914 unsigned int excluded = 0;
2915
2916 if (fun->visit5)
2917 return TRUE;
2918
2919 fun->visit5 = TRUE;
2920
2921 excluded = 0;
2922 if (fun->sec == uos_param->exclude_input_section
2923 || fun->sec->output_section == uos_param->exclude_output_section)
2924 excluded = 1;
2925
2926 uos_param->clearing += excluded;
2927
2928 if (uos_param->clearing)
2929 {
2930 fun->sec->linker_mark = 0;
2931 if (fun->rodata)
2932 fun->rodata->linker_mark = 0;
2933 }
2934
2935 for (call = fun->call_list; call != NULL; call = call->next)
2936 if (!unmark_overlay_section (call->fun, info, param))
2937 return FALSE;
2938
2939 uos_param->clearing -= excluded;
2940 return TRUE;
2941}
2942
2943struct _cl_param {
2944 unsigned int lib_size;
2945 asection **lib_sections;
2946};
2947
2948/* Add sections we have marked as belonging to overlays to an array
2949 for consideration as non-overlay sections. The array consist of
2950 pairs of sections, (text,rodata), for functions in the call graph. */
2951
2952static bfd_boolean
2953collect_lib_sections (struct function_info *fun,
2954 struct bfd_link_info *info,
2955 void *param)
2956{
2957 struct _cl_param *lib_param = param;
2958 struct call_info *call;
2959 unsigned int size;
2960
2961 if (fun->visit6)
2962 return TRUE;
2963
2964 fun->visit6 = TRUE;
2965 if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
2966 return TRUE;
2967
2968 size = fun->sec->size;
2969 if (fun->rodata)
2970 size += fun->rodata->size;
2971 if (size > lib_param->lib_size)
2972 return TRUE;
2973
2974 *lib_param->lib_sections++ = fun->sec;
2975 fun->sec->gc_mark = 0;
2976 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
2977 {
2978 *lib_param->lib_sections++ = fun->rodata;
2979 fun->rodata->gc_mark = 0;
2980 }
2981 else
2982 *lib_param->lib_sections++ = NULL;
2983
2984 for (call = fun->call_list; call != NULL; call = call->next)
2985 collect_lib_sections (call->fun, info, param);
2986
2987 return TRUE;
2988}
2989
2990/* qsort predicate to sort sections by call count. */
2991
2992static int
2993sort_lib (const void *a, const void *b)
2994{
2995 asection *const *s1 = a;
2996 asection *const *s2 = b;
2997 struct _spu_elf_section_data *sec_data;
2998 struct spu_elf_stack_info *sinfo;
2999 int delta;
3000
3001 delta = 0;
3002 if ((sec_data = spu_elf_section_data (*s1)) != NULL
3003 && (sinfo = sec_data->u.i.stack_info) != NULL)
3004 {
3005 int i;
3006 for (i = 0; i < sinfo->num_fun; ++i)
3007 delta -= sinfo->fun[i].call_count;
3008 }
3009
3010 if ((sec_data = spu_elf_section_data (*s2)) != NULL
3011 && (sinfo = sec_data->u.i.stack_info) != NULL)
3012 {
3013 int i;
3014 for (i = 0; i < sinfo->num_fun; ++i)
3015 delta += sinfo->fun[i].call_count;
3016 }
3017
3018 if (delta != 0)
3019 return delta;
3020
3021 return s1 - s2;
3022}
3023
3024/* Remove some sections from those marked to be in overlays. Choose
3025 those that are called from many places, likely library functions. */
3026
3027static unsigned int
3028auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3029{
3030 bfd *ibfd;
3031 asection **lib_sections;
3032 unsigned int i, lib_count;
3033 struct _cl_param collect_lib_param;
3034 struct function_info dummy_caller;
3035
3036 memset (&dummy_caller, 0, sizeof (dummy_caller));
3037 lib_count = 0;
3038 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3039 {
3040 extern const bfd_target bfd_elf32_spu_vec;
3041 asection *sec;
3042
3043 if (ibfd->xvec != &bfd_elf32_spu_vec)
3044 continue;
3045
3046 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3047 if (sec->linker_mark
3048 && sec->size < lib_size
3049 && (sec->flags & SEC_CODE) != 0)
3050 lib_count += 1;
3051 }
3052 lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3053 if (lib_sections == NULL)
3054 return (unsigned int) -1;
3055 collect_lib_param.lib_size = lib_size;
3056 collect_lib_param.lib_sections = lib_sections;
3057 if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3058 TRUE))
3059 return (unsigned int) -1;
3060 lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3061
3062 /* Sort sections so that those with the most calls are first. */
3063 if (lib_count > 1)
3064 qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3065
3066 for (i = 0; i < lib_count; i++)
3067 {
3068 unsigned int tmp, stub_size;
3069 asection *sec;
3070 struct _spu_elf_section_data *sec_data;
3071 struct spu_elf_stack_info *sinfo;
3072
3073 sec = lib_sections[2 * i];
3074 /* If this section is OK, its size must be less than lib_size. */
3075 tmp = sec->size;
3076 /* If it has a rodata section, then add that too. */
3077 if (lib_sections[2 * i + 1])
3078 tmp += lib_sections[2 * i + 1]->size;
3079 /* Add any new overlay call stubs needed by the section. */
3080 stub_size = 0;
3081 if (tmp < lib_size
3082 && (sec_data = spu_elf_section_data (sec)) != NULL
3083 && (sinfo = sec_data->u.i.stack_info) != NULL)
3084 {
3085 int k;
3086 struct call_info *call;
3087
3088 for (k = 0; k < sinfo->num_fun; ++k)
3089 for (call = sinfo->fun[k].call_list; call; call = call->next)
3090 if (call->fun->sec->linker_mark)
3091 {
3092 struct call_info *p;
3093 for (p = dummy_caller.call_list; p; p = p->next)
3094 if (p->fun == call->fun)
3095 break;
3096 if (!p)
3097 stub_size += OVL_STUB_SIZE;
3098 }
3099 }
3100 if (tmp + stub_size < lib_size)
3101 {
3102 struct call_info **pp, *p;
3103
3104 /* This section fits. Mark it as non-overlay. */
3105 lib_sections[2 * i]->linker_mark = 0;
3106 if (lib_sections[2 * i + 1])
3107 lib_sections[2 * i + 1]->linker_mark = 0;
3108 lib_size -= tmp + stub_size;
3109 /* Call stubs to the section we just added are no longer
3110 needed. */
3111 pp = &dummy_caller.call_list;
3112 while ((p = *pp) != NULL)
3113 if (!p->fun->sec->linker_mark)
3114 {
3115 lib_size += OVL_STUB_SIZE;
3116 *pp = p->next;
3117 free (p);
3118 }
3119 else
3120 pp = &p->next;
3121 /* Add new call stubs to dummy_caller. */
3122 if ((sec_data = spu_elf_section_data (sec)) != NULL
3123 && (sinfo = sec_data->u.i.stack_info) != NULL)
3124 {
3125 int k;
3126 struct call_info *call;
3127
3128 for (k = 0; k < sinfo->num_fun; ++k)
3129 for (call = sinfo->fun[k].call_list;
3130 call;
3131 call = call->next)
3132 if (call->fun->sec->linker_mark)
3133 {
3134 struct call_info *callee;
3135 callee = bfd_malloc (sizeof (*callee));
3136 if (callee == NULL)
3137 return (unsigned int) -1;
3138 *callee = *call;
3139 if (!insert_callee (&dummy_caller, callee))
3140 free (callee);
3141 }
3142 }
3143 }
3144 }
3145 while (dummy_caller.call_list != NULL)
3146 {
3147 struct call_info *call = dummy_caller.call_list;
3148 dummy_caller.call_list = call->next;
3149 free (call);
3150 }
3151 for (i = 0; i < 2 * lib_count; i++)
3152 if (lib_sections[i])
3153 lib_sections[i]->gc_mark = 1;
3154 free (lib_sections);
3155 return lib_size;
3156}
3157
3158/* Build an array of overlay sections. The deepest node's section is
3159 added first, the its parent node's section, then everything called
3160 from the parent section. The idea being to group sections to
3161 minimise calls between different overlays. */
3162
3163static bfd_boolean
3164collect_overlays (struct function_info *fun,
3165 struct bfd_link_info *info,
3166 void *param)
3167{
3168 struct call_info *call;
3169 bfd_boolean added_fun;
3170 asection ***ovly_sections = param;
3171
3172 if (fun->visit7)
3173 return TRUE;
3174
3175 fun->visit7 = TRUE;
3176 for (call = fun->call_list; call != NULL; call = call->next)
3177 if (!call->is_pasted)
3178 {
3179 if (!collect_overlays (call->fun, info, ovly_sections))
3180 return FALSE;
3181 break;
3182 }
3183
3184 added_fun = FALSE;
3185 if (fun->sec->linker_mark && fun->sec->gc_mark)
3186 {
3187 fun->sec->gc_mark = 0;
3188 *(*ovly_sections)++ = fun->sec;
3189 if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3190 {
3191 fun->rodata->gc_mark = 0;
3192 *(*ovly_sections)++ = fun->rodata;
3193 }
3194 else
3195 *(*ovly_sections)++ = NULL;
3196 added_fun = TRUE;
3197
3198 /* Pasted sections must stay with the first section. We don't
3199 put pasted sections in the array, just the first section.
3200 Mark subsequent sections as already considered. */
3201 if (fun->sec->segment_mark)
3202 {
3203 struct function_info *call_fun = fun;
3204 do
3205 {
3206 for (call = call_fun->call_list; call != NULL; call = call->next)
3207 if (call->is_pasted)
3208 {
3209 call_fun = call->fun;
3210 call_fun->sec->gc_mark = 0;
3211 if (call_fun->rodata)
3212 call_fun->rodata->gc_mark = 0;
3213 break;
3214 }
3215 if (call == NULL)
3216 abort ();
3217 }
3218 while (call_fun->sec->segment_mark);
3219 }
3220 }
3221
3222 for (call = fun->call_list; call != NULL; call = call->next)
3223 if (!collect_overlays (call->fun, info, ovly_sections))
3224 return FALSE;
3225
3226 if (added_fun)
3227 {
3228 struct _spu_elf_section_data *sec_data;
3229 struct spu_elf_stack_info *sinfo;
3230
3231 if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3232 && (sinfo = sec_data->u.i.stack_info) != NULL)
3233 {
3234 int i;
3235 for (i = 0; i < sinfo->num_fun; ++i)
3236 if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3237 return FALSE;
3238 }
3239 }
3240
3241 return TRUE;
49fa1e15
AM		 3242}
3243
055ed83b
AM		 3244struct _sum_stack_param {
3245 size_t cum_stack;
3246 size_t overall_stack;
3247 bfd_boolean emit_stack_syms;
3248};
3249
49fa1e15
AM		 3250/* Descend the call graph for FUN, accumulating total stack required. */
3251
055ed83b 3252static bfd_boolean
49fa1e15
AM		 3253sum_stack (struct function_info *fun,
3254 struct bfd_link_info *info,
055ed83b 3255 void *param)
49fa1e15
AM		 3256{
3257 struct call_info *call;
055ed83b
AM		 3258 struct function_info *max;
3259 size_t stack, cum_stack;
49fa1e15 3260 const char *f1;
9dcc4794 3261 bfd_boolean has_call;
055ed83b 3262 struct _sum_stack_param *sum_stack_param = param;
9dcc4794 3263 struct spu_link_hash_table *htab;
49fa1e15 3264
055ed83b
AM		 3265 cum_stack = fun->stack;
3266 sum_stack_param->cum_stack = cum_stack;
49fa1e15 3267 if (fun->visit3)
055ed83b 3268 return TRUE;
49fa1e15 3269
9dcc4794 3270 has_call = FALSE;
055ed83b 3271 max = NULL;
49fa1e15
AM		 3272 for (call = fun->call_list; call; call = call->next)
3273 {
9dcc4794
AM		 3274 if (!call->is_pasted)
3275 has_call = TRUE;
055ed83b
AM		 3276 if (!sum_stack (call->fun, info, sum_stack_param))
3277 return FALSE;
3278 stack = sum_stack_param->cum_stack;
49fa1e15
AM		 3279 /* Include caller stack for normal calls, don't do so for
3280 tail calls. fun->stack here is local stack usage for
3281 this function. */
9dcc4794 3282 if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
49fa1e15 3283 stack += fun->stack;
055ed83b 3284 if (cum_stack < stack)
49fa1e15 3285 {
055ed83b 3286 cum_stack = stack;
49fa1e15
AM		 3287 max = call->fun;
3288 }
3289 }
3290
055ed83b
AM		 3291 sum_stack_param->cum_stack = cum_stack;
3292 stack = fun->stack;
3293 /* Now fun->stack holds cumulative stack. */
3294 fun->stack = cum_stack;
3295 fun->visit3 = TRUE;
3296
3297 if (!fun->non_root
3298 && sum_stack_param->overall_stack < cum_stack)
3299 sum_stack_param->overall_stack = cum_stack;
3300
9dcc4794
AM		 3301 htab = spu_hash_table (info);
3302 if (htab->auto_overlay)
3303 return TRUE;
3304
49fa1e15 3305 f1 = func_name (fun);
055ed83b
AM		 3306 if (!fun->non_root)
3307 info->callbacks->info (_(" %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
fad9eaf0 3308 info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
055ed83b 3309 f1, (bfd_vma) stack, (bfd_vma) cum_stack);
49fa1e15 3310
9dcc4794 3311 if (has_call)
49fa1e15
AM		 3312 {
3313 info->callbacks->minfo (_(" calls:\n"));
3314 for (call = fun->call_list; call; call = call->next)
9dcc4794
AM		 3315 if (!call->is_pasted)
3316 {
3317 const char *f2 = func_name (call->fun);
3318 const char *ann1 = call->fun == max ? "*" : " ";
3319 const char *ann2 = call->is_tail ? "t" : " ";
49fa1e15 3320
9dcc4794
AM		 3321 info->callbacks->minfo (_(" %s%s %s\n"), ann1, ann2, f2);
3322 }
49fa1e15
AM		 3323 }
3324
055ed83b 3325 if (sum_stack_param->emit_stack_syms)
49fa1e15 3326 {
49fa1e15
AM		 3327 char *name = bfd_malloc (18 + strlen (f1));
3328 struct elf_link_hash_entry *h;
3329
055ed83b
AM		 3330 if (name == NULL)
3331 return FALSE;
3332
3333 if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
3334 sprintf (name, "__stack_%s", f1);
3335 else
3336 sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
3337
3338 h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
3339 free (name);
3340 if (h != NULL
3341 && (h->root.type == bfd_link_hash_new
3342 || h->root.type == bfd_link_hash_undefined
3343 || h->root.type == bfd_link_hash_undefweak))
49fa1e15 3344 {
055ed83b
AM		 3345 h->root.type = bfd_link_hash_defined;
3346 h->root.u.def.section = bfd_abs_section_ptr;
3347 h->root.u.def.value = cum_stack;
3348 h->size = 0;
3349 h->type = 0;
3350 h->ref_regular = 1;
3351 h->def_regular = 1;
3352 h->ref_regular_nonweak = 1;
3353 h->forced_local = 1;
3354 h->non_elf = 0;
49fa1e15
AM		 3355 }
3356 }
3357
055ed83b 3358 return TRUE;
49fa1e15
AM		 3359}
3360
9dcc4794
AM		 3361/* SEC is part of a pasted function. Return the call_info for the
3362 next section of this function. */
3363
3364static struct call_info *
3365find_pasted_call (asection *sec)
3366{
3367 struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
3368 struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
3369 struct call_info *call;
3370 int k;
3371
3372 for (k = 0; k < sinfo->num_fun; ++k)
3373 for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
3374 if (call->is_pasted)
3375 return call;
3376 abort ();
3377 return 0;
3378}
3379
3380/* qsort predicate to sort bfds by file name. */
3381
3382static int
3383sort_bfds (const void *a, const void *b)
3384{
3385 bfd *const *abfd1 = a;
3386 bfd *const *abfd2 = b;
3387
3388 return strcmp ((*abfd1)->filename, (*abfd2)->filename);
3389}
3390
3391/* Handle --auto-overlay. */
3392
3393static void spu_elf_auto_overlay (struct bfd_link_info *, void (*) (void))
3394 ATTRIBUTE_NORETURN;
3395
3396static void
3397spu_elf_auto_overlay (struct bfd_link_info *info,
3398 void (*spu_elf_load_ovl_mgr) (void))
3399{
3400 bfd *ibfd;
3401 bfd **bfd_arr;
3402 struct elf_segment_map *m;
3403 unsigned int fixed_size, lo, hi;
3404 struct spu_link_hash_table *htab;
3405 unsigned int base, i, count, bfd_count;
3406 int ovlynum;
3407 asection **ovly_sections, **ovly_p;
3408 FILE *script;
3409 unsigned int total_overlay_size, overlay_size;
3410 struct elf_link_hash_entry *h;
3411 struct _mos_param mos_param;
3412 struct _uos_param uos_param;
3413 struct function_info dummy_caller;
3414
3415 /* Find the extents of our loadable image. */
3416 lo = (unsigned int) -1;
3417 hi = 0;
3418 for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
3419 if (m->p_type == PT_LOAD)
3420 for (i = 0; i < m->count; i++)
3421 if (m->sections[i]->size != 0)
3422 {
3423 if (m->sections[i]->vma < lo)
3424 lo = m->sections[i]->vma;
3425 if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
3426 hi = m->sections[i]->vma + m->sections[i]->size - 1;
3427 }
3428 fixed_size = hi + 1 - lo;
3429
3430 if (!discover_functions (info))
3431 goto err_exit;
3432
3433 if (!build_call_tree (info))
3434 goto err_exit;
3435
3436 uos_param.exclude_input_section = 0;
3437 uos_param.exclude_output_section
3438 = bfd_get_section_by_name (info->output_bfd, ".interrupt");
3439
3440 htab = spu_hash_table (info);
3441 h = elf_link_hash_lookup (&htab->elf, "__ovly_load",
3442 FALSE, FALSE, FALSE);
3443 if (h != NULL
3444 && (h->root.type == bfd_link_hash_defined
3445 || h->root.type == bfd_link_hash_defweak)
3446 && h->def_regular)
3447 {
3448 /* We have a user supplied overlay manager. */
3449 uos_param.exclude_input_section = h->root.u.def.section;
3450 }
3451 else
3452 {
3453 /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
3454 builtin version to .text, and will adjust .text size. */
3455 asection *text = bfd_get_section_by_name (info->output_bfd, ".text");
3456 if (text != NULL)
3457 fixed_size -= text->size;
3458 spu_elf_load_ovl_mgr ();
3459 text = bfd_get_section_by_name (info->output_bfd, ".text");
3460 if (text != NULL)
3461 fixed_size += text->size;
3462 }
3463
3464 /* Mark overlay sections, and find max overlay section size. */
3465 mos_param.max_overlay_size = 0;
3466 if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
3467 goto err_exit;
3468
3469 /* We can't put the overlay manager or interrupt routines in
3470 overlays. */
3471 uos_param.clearing = 0;
3472 if ((uos_param.exclude_input_section
3473 || uos_param.exclude_output_section)
3474 && !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
3475 goto err_exit;
3476
3477 bfd_count = 0;
3478 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3479 ++bfd_count;
3480 bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
3481 if (bfd_arr == NULL)
3482 goto err_exit;
3483
3484 /* Count overlay sections, and subtract their sizes from "fixed_size". */
3485 count = 0;
3486 bfd_count = 0;
3487 total_overlay_size = 0;
3488 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3489 {
3490 extern const bfd_target bfd_elf32_spu_vec;
3491 asection *sec;
3492 unsigned int old_count;
3493
3494 if (ibfd->xvec != &bfd_elf32_spu_vec)
3495 continue;
3496
3497 old_count = count;
3498 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3499 if (sec->linker_mark)
3500 {
3501 if ((sec->flags & SEC_CODE) != 0)
3502 count += 1;
3503 fixed_size -= sec->size;
3504 total_overlay_size += sec->size;
3505 }
3506 if (count != old_count)
3507 bfd_arr[bfd_count++] = ibfd;
3508 }
3509
3510 /* Since the overlay link script selects sections by file name and
3511 section name, ensure that file names are unique. */
3512 if (bfd_count > 1)
3513 {
3514 bfd_boolean ok = TRUE;
3515
3516 qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
3517 for (i = 1; i < bfd_count; ++i)
3518 if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
3519 {
3520 if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
3521 {
3522 if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
3523 info->callbacks->einfo (_("%s duplicated in %s\n"),
3524 bfd_arr[i - 1]->filename,
3525 bfd_arr[i - 1]->my_archive->filename);
3526 else
3527 info->callbacks->einfo (_("%s in both %s and %s\n"),
3528 bfd_arr[i - 1]->filename,
3529 bfd_arr[i - 1]->my_archive->filename,
3530 bfd_arr[i]->my_archive->filename);
3531 }
3532 else if (bfd_arr[i - 1]->my_archive)
3533 info->callbacks->einfo (_("%s in %s and as an object\n"),
3534 bfd_arr[i - 1]->filename,
3535 bfd_arr[i - 1]->my_archive->filename);
3536 else if (bfd_arr[i]->my_archive)
3537 info->callbacks->einfo (_("%s in %s and as an object\n"),
3538 bfd_arr[i]->filename,
3539 bfd_arr[i]->my_archive->filename);
3540 else
3541 info->callbacks->einfo (_("%s duplicated\n"),
3542 bfd_arr[i]->filename);
3543 ok = FALSE;
3544 }
3545 if (!ok)
3546 {
3547 /* FIXME: modify plain object files from foo.o to ./foo.o
3548 and emit EXCLUDE_FILE to handle the duplicates in
3549 archives. There is a pathological case we can't handle:
3550 We may have duplicate file names within a single archive. */
3551 info->callbacks->einfo (_("sorry, no support for duplicate "
3552 "object files in auto-overlay script\n"));
3553 bfd_set_error (bfd_error_bad_value);
3554 goto err_exit;
3555 }
3556 }
3557 free (bfd_arr);
3558
3559 if (htab->reserved == 0)
3560 {
3561 struct _sum_stack_param sum_stack_param;
3562
3563 sum_stack_param.emit_stack_syms = 0;
3564 sum_stack_param.overall_stack = 0;
3565 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
3566 goto err_exit;
3567 htab->reserved = sum_stack_param.overall_stack;
3568 }
3569 fixed_size += htab->reserved;
3570 fixed_size += htab->non_ovly_stub * OVL_STUB_SIZE;
3571 if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
3572 {
3573 /* Guess number of overlays. Assuming overlay buffer is on
3574 average only half full should be conservative. */
3575 ovlynum = total_overlay_size * 2 / (htab->local_store - fixed_size);
3576 /* Space for _ovly_table[], _ovly_buf_table[] and toe. */
3577 fixed_size += ovlynum * 16 + 16 + 4 + 16;
3578 }
3579
3580 if (fixed_size + mos_param.max_overlay_size > htab->local_store)
3581 info->callbacks->einfo (_("non-overlay plus maximum overlay size "
3582 "of 0x%x exceeds local store\n"),
3583 fixed_size + mos_param.max_overlay_size);
3584
3585 /* Now see if we should put some functions in the non-overlay area. */
3586 if (fixed_size < htab->overlay_fixed
3587 && htab->overlay_fixed + mos_param.max_overlay_size < htab->local_store)
3588 {
3589 unsigned int lib_size = htab->overlay_fixed - fixed_size;
3590 lib_size = auto_ovl_lib_functions (info, lib_size);
3591 if (lib_size == (unsigned int) -1)
3592 goto err_exit;
3593 fixed_size = htab->overlay_fixed - lib_size;
3594 }
3595
3596 /* Build an array of sections, suitably sorted to place into
3597 overlays. */
3598 ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
3599 if (ovly_sections == NULL)
3600 goto err_exit;
3601 ovly_p = ovly_sections;
3602 if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
3603 goto err_exit;
3604 count = (size_t) (ovly_p - ovly_sections) / 2;
3605
3606 script = htab->spu_elf_open_overlay_script ();
3607
3608 if (fprintf (script, "SECTIONS\n{\n OVERLAY :\n {\n") <= 0)
3609 goto file_err;
3610
3611 memset (&dummy_caller, 0, sizeof (dummy_caller));
3612 overlay_size = htab->local_store - fixed_size;
3613 base = 0;
3614 ovlynum = 0;
3615 while (base < count)
3616 {
3617 unsigned int size = 0;
3618 unsigned int j;
3619
3620 for (i = base; i < count; i++)
3621 {
3622 asection *sec;
3623 unsigned int tmp;
3624 unsigned int stub_size;
3625 struct call_info *call, *pasty;
3626 struct _spu_elf_section_data *sec_data;
3627 struct spu_elf_stack_info *sinfo;
3628 int k;
3629
3630 /* See whether we can add this section to the current
3631 overlay without overflowing our overlay buffer. */
3632 sec = ovly_sections[2 * i];
3633 tmp = size + sec->size;
3634 if (ovly_sections[2 * i + 1])
3635 tmp += ovly_sections[2 * i + 1]->size;
3636 if (tmp > overlay_size)
3637 break;
3638 if (sec->segment_mark)
3639 {
3640 /* Pasted sections must stay together, so add their
3641 sizes too. */
3642 struct call_info *pasty = find_pasted_call (sec);
3643 while (pasty != NULL)
3644 {
3645 struct function_info *call_fun = pasty->fun;
3646 tmp += call_fun->sec->size;
3647 if (call_fun->rodata)
3648 tmp += call_fun->rodata->size;
3649 for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
3650 if (pasty->is_pasted)
3651 break;
3652 }
3653 }
3654 if (tmp > overlay_size)
3655 break;
3656
3657 /* If we add this section, we might need new overlay call
3658 stubs. Add any overlay section calls to dummy_call. */
3659 pasty = NULL;
3660 sec_data = spu_elf_section_data (sec);
3661 sinfo = sec_data->u.i.stack_info;
3662 for (k = 0; k < sinfo->num_fun; ++k)
3663 for (call = sinfo->fun[k].call_list; call; call = call->next)
3664 if (call->is_pasted)
3665 {
3666 BFD_ASSERT (pasty == NULL);
3667 pasty = call;
3668 }
3669 else if (call->fun->sec->linker_mark)
3670 {
3671 if (!copy_callee (&dummy_caller, call))
3672 goto err_exit;
3673 }
3674 while (pasty != NULL)
3675 {
3676 struct function_info *call_fun = pasty->fun;
3677 pasty = NULL;
3678 for (call = call_fun->call_list; call; call = call->next)
3679 if (call->is_pasted)
3680 {
3681 BFD_ASSERT (pasty == NULL);
3682 pasty = call;
3683 }
3684 else if (!copy_callee (&dummy_caller, call))
3685 goto err_exit;
3686 }
3687
3688 /* Calculate call stub size. */
3689 stub_size = 0;
3690 for (call = dummy_caller.call_list; call; call = call->next)
3691 {
3692 unsigned int k;
3693
3694 stub_size += OVL_STUB_SIZE;
3695 /* If the call is within this overlay, we won't need a
3696 stub. */
3697 for (k = base; k < i + 1; k++)
3698 if (call->fun->sec == ovly_sections[2 * k])
3699 {
3700 stub_size -= OVL_STUB_SIZE;
3701 break;
3702 }
3703 }
3704 if (tmp + stub_size > overlay_size)
3705 break;
3706
3707 size = tmp;
3708 }
3709
3710 if (i == base)
3711 {
3712 info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
3713 ovly_sections[2 * i]->owner,
3714 ovly_sections[2 * i],
3715 ovly_sections[2 * i + 1] ? " + rodata" : "");
3716 bfd_set_error (bfd_error_bad_value);
3717 goto err_exit;
3718 }
3719
3720 if (fprintf (script, " .ovly%d {\n", ++ovlynum) <= 0)
3721 goto file_err;
3722 for (j = base; j < i; j++)
3723 {
3724 asection *sec = ovly_sections[2 * j];
3725
3726 if (fprintf (script, " [%c]%s (%s)\n",
3727 sec->owner->filename[0],
3728 sec->owner->filename + 1,
3729 sec->name) <= 0)
3730 goto file_err;
3731 if (sec->segment_mark)
3732 {
3733 struct call_info *call = find_pasted_call (sec);
3734 while (call != NULL)
3735 {
3736 struct function_info *call_fun = call->fun;
3737 sec = call_fun->sec;
3738 if (fprintf (script, " [%c]%s (%s)\n",
3739 sec->owner->filename[0],
3740 sec->owner->filename + 1,
3741 sec->name) <= 0)
3742 goto file_err;
3743 for (call = call_fun->call_list; call; call = call->next)
3744 if (call->is_pasted)
3745 break;
3746 }
3747 }
3748 }
3749
3750 for (j = base; j < i; j++)
3751 {
3752 asection *sec = ovly_sections[2 * j + 1];
3753 if (sec != NULL && fprintf (script, " [%c]%s (%s)\n",
3754 sec->owner->filename[0],
3755 sec->owner->filename + 1,
3756 sec->name) <= 0)
3757 goto file_err;
3758
3759 sec = ovly_sections[2 * j];
3760 if (sec->segment_mark)
3761 {
3762 struct call_info *call = find_pasted_call (sec);
3763 while (call != NULL)
3764 {
3765 struct function_info *call_fun = call->fun;
3766 sec = call_fun->rodata;
3767 if (sec != NULL && fprintf (script, " [%c]%s (%s)\n",
3768 sec->owner->filename[0],
3769 sec->owner->filename + 1,
3770 sec->name) <= 0)
3771 goto file_err;
3772 for (call = call_fun->call_list; call; call = call->next)
3773 if (call->is_pasted)
3774 break;
3775 }
3776 }
3777 }
3778
3779 if (fprintf (script, " }\n") <= 0)
3780 goto file_err;
3781
3782 while (dummy_caller.call_list != NULL)
3783 {
3784 struct call_info *call = dummy_caller.call_list;
3785 dummy_caller.call_list = call->next;
3786 free (call);
3787 }
3788
3789 base = i;
3790 }
3791 free (ovly_sections);
3792
3793 if (fprintf (script, " }\n}\nINSERT AFTER .text;\n") <= 0)
3794 goto file_err;
3795 if (fclose (script) != 0)
3796 goto file_err;
3797
3798 if (htab->auto_overlay & AUTO_RELINK)
3799 htab->spu_elf_relink ();
3800
3801 xexit (0);
3802
3803 file_err:
3804 bfd_set_error (bfd_error_system_call);
3805 err_exit:
3806 info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
3807 xexit (1);
3808}
3809
49fa1e15
AM		 3810/* Provide an estimate of total stack required. */
3811
3812static bfd_boolean
c65be8d7 3813spu_elf_stack_analysis (struct bfd_link_info *info, int emit_stack_syms)
49fa1e15 3814{
055ed83b 3815 struct _sum_stack_param sum_stack_param;
49fa1e15 3816
c65be8d7 3817 if (!discover_functions (info))
49fa1e15
AM		 3818 return FALSE;
3819
c65be8d7 3820 if (!build_call_tree (info))
49fa1e15
AM		 3821 return FALSE;
3822
3823 info->callbacks->info (_("Stack size for call graph root nodes.\n"));
3824 info->callbacks->minfo (_("\nStack size for functions. "
3825 "Annotations: '*' max stack, 't' tail call\n"));
49fa1e15 3826
055ed83b
AM		 3827 sum_stack_param.emit_stack_syms = emit_stack_syms;
3828 sum_stack_param.overall_stack = 0;
3829 if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
3830 return FALSE;
49fa1e15 3831
055ed83b
AM		 3832 info->callbacks->info (_("Maximum stack required is 0x%v\n"),
3833 (bfd_vma) sum_stack_param.overall_stack);
49fa1e15
AM		 3834 return TRUE;
3835}
3836
3837/* Perform a final link. */
3838
3839static bfd_boolean
3840spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
3841{
3842 struct spu_link_hash_table *htab = spu_hash_table (info);
3843
9dcc4794
AM		 3844 if (htab->auto_overlay)
3845 spu_elf_auto_overlay (info, htab->spu_elf_load_ovl_mgr);
3846
49fa1e15 3847 if (htab->stack_analysis
c65be8d7 3848 && !spu_elf_stack_analysis (info, htab->emit_stack_syms))
49fa1e15
AM		 3849 info->callbacks->einfo ("%X%P: stack analysis error: %E\n");
3850
3851 return bfd_elf_final_link (output_bfd, info);
3852}
3853
ece5ef60
AM		 3854/* Called when not normally emitting relocs, ie. !info->relocatable
3855 and !info->emitrelocations. Returns a count of special relocs
3856 that need to be emitted. */
3857
3858static unsigned int
3859spu_elf_count_relocs (asection *sec, Elf_Internal_Rela *relocs)
3860{
3861 unsigned int count = 0;
3862 Elf_Internal_Rela *relend = relocs + sec->reloc_count;
3863
3864 for (; relocs < relend; relocs++)
3865 {
3866 int r_type = ELF32_R_TYPE (relocs->r_info);
3867 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
3868 ++count;
3869 }
3870
3871 return count;
3872}
3873
e9f53129
AM		 3874/* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
3875
d16c7321 3876static int
e9f53129
AM		 3877spu_elf_relocate_section (bfd *output_bfd,
3878 struct bfd_link_info *info,
3879 bfd *input_bfd,
3880 asection *input_section,
3881 bfd_byte *contents,
3882 Elf_Internal_Rela *relocs,
3883 Elf_Internal_Sym *local_syms,
3884 asection **local_sections)
3885{
3886 Elf_Internal_Shdr *symtab_hdr;
3887 struct elf_link_hash_entry **sym_hashes;
3888 Elf_Internal_Rela *rel, *relend;
3889 struct spu_link_hash_table *htab;
d16c7321 3890 int ret = TRUE;
ece5ef60 3891 bfd_boolean emit_these_relocs = FALSE;
fdba2fcd 3892 bfd_boolean stubs;
e9f53129 3893
e9f53129 3894 htab = spu_hash_table (info);
fdba2fcd
AM		 3895 stubs = (htab->stub_sec != NULL
3896 && maybe_needs_stubs (input_section, output_bfd));
e9f53129
AM		 3897 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3898 sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
3899
3900 rel = relocs;
3901 relend = relocs + input_section->reloc_count;
3902 for (; rel < relend; rel++)
3903 {
3904 int r_type;
3905 reloc_howto_type *howto;
3906 unsigned long r_symndx;
3907 Elf_Internal_Sym *sym;
3908 asection *sec;
3909 struct elf_link_hash_entry *h;
3910 const char *sym_name;
3911 bfd_vma relocation;
3912 bfd_vma addend;
3913 bfd_reloc_status_type r;
3914 bfd_boolean unresolved_reloc;
3915 bfd_boolean warned;
3916
3917 r_symndx = ELF32_R_SYM (rel->r_info);
3918 r_type = ELF32_R_TYPE (rel->r_info);
ece5ef60
AM		 3919 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
3920 {
3921 emit_these_relocs = TRUE;
3922 continue;
3923 }
3924
e9f53129
AM		 3925 howto = elf_howto_table + r_type;
3926 unresolved_reloc = FALSE;
3927 warned = FALSE;
e9f53129
AM		 3928 h = NULL;
3929 sym = NULL;
3930 sec = NULL;
3931 if (r_symndx < symtab_hdr->sh_info)
3932 {
3933 sym = local_syms + r_symndx;
3934 sec = local_sections[r_symndx];
3935 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
3936 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3937 }
3938 else
3939 {
3940 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3941 r_symndx, symtab_hdr, sym_hashes,
3942 h, sec, relocation,
3943 unresolved_reloc, warned);
3944 sym_name = h->root.root.string;
3945 }
3946
ab96bf03
AM		 3947 if (sec != NULL && elf_discarded_section (sec))
3948 {
3949 /* For relocs against symbols from removed linkonce sections,
3950 or sections discarded by a linker script, we just want the
3951 section contents zeroed. Avoid any special processing. */
3952 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
3953 rel->r_info = 0;
3954 rel->r_addend = 0;
3955 continue;
3956 }
3957
3958 if (info->relocatable)
3959 continue;
3960
e9f53129
AM		 3961 if (unresolved_reloc)
3962 {
3963 (*_bfd_error_handler)
3964 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
3965 input_bfd,
3966 bfd_get_section_name (input_bfd, input_section),
3967 (long) rel->r_offset,
3968 howto->name,
3969 sym_name);
3970 ret = FALSE;
3971 }
3972
3973 /* If this symbol is in an overlay area, we may need to relocate
3974 to the overlay stub. */
3975 addend = rel->r_addend;
fdba2fcd 3976 if (stubs)
e9f53129 3977 {
fdba2fcd 3978 enum _stub_type stub_type;
47f6dab9 3979
fdba2fcd
AM		 3980 stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
3981 contents, info);
3982 if (stub_type != no_stub)
5f5fb9ec
AM		 3983 {
3984 unsigned int ovl = 0;
3985 struct got_entry *g, **head;
3986
fdba2fcd 3987 if (stub_type != nonovl_stub)
5f5fb9ec
AM		 3988 ovl = (spu_elf_section_data (input_section->output_section)
3989 ->u.o.ovl_index);
3990
3991 if (h != NULL)
3992 head = &h->got.glist;
3993 else
3994 head = elf_local_got_ents (input_bfd) + r_symndx;
47f6dab9 3995
5f5fb9ec
AM		 3996 for (g = *head; g != NULL; g = g->next)
3997 if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
3998 break;
3999 if (g == NULL)
4000 abort ();
4001
4002 relocation = g->stub_addr;
4003 addend = 0;
4004 }
e9f53129
AM		 4005 }
4006
4007 r = _bfd_final_link_relocate (howto,
4008 input_bfd,
4009 input_section,
4010 contents,
4011 rel->r_offset, relocation, addend);
4012
4013 if (r != bfd_reloc_ok)
4014 {
4015 const char *msg = (const char *) 0;
4016
4017 switch (r)
4018 {
4019 case bfd_reloc_overflow:
4020 if (!((*info->callbacks->reloc_overflow)
4021 (info, (h ? &h->root : NULL), sym_name, howto->name,
4022 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
4023 return FALSE;
4024 break;
4025
4026 case bfd_reloc_undefined:
4027 if (!((*info->callbacks->undefined_symbol)
4028 (info, sym_name, input_bfd, input_section,
4029 rel->r_offset, TRUE)))
4030 return FALSE;
4031 break;
4032
4033 case bfd_reloc_outofrange:
4034 msg = _("internal error: out of range error");
4035 goto common_error;
4036
4037 case bfd_reloc_notsupported:
4038 msg = _("internal error: unsupported relocation error");
4039 goto common_error;
4040
4041 case bfd_reloc_dangerous:
4042 msg = _("internal error: dangerous error");
4043 goto common_error;
4044
4045 default:
4046 msg = _("internal error: unknown error");
4047 /* fall through */
4048
4049 common_error:
d16c7321 4050 ret = FALSE;
e9f53129
AM		 4051 if (!((*info->callbacks->warning)
4052 (info, msg, sym_name, input_bfd, input_section,
4053 rel->r_offset)))
4054 return FALSE;
4055 break;
4056 }
4057 }
4058 }
4059
ece5ef60
AM		 4060 if (ret
4061 && emit_these_relocs
4062 && !info->relocatable
4063 && !info->emitrelocations)
4064 {
4065 Elf_Internal_Rela *wrel;
4066 Elf_Internal_Shdr *rel_hdr;
4067
4068 wrel = rel = relocs;
4069 relend = relocs + input_section->reloc_count;
4070 for (; rel < relend; rel++)
4071 {
4072 int r_type;
4073
4074 r_type = ELF32_R_TYPE (rel->r_info);
4075 if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4076 *wrel++ = *rel;
4077 }
4078 input_section->reloc_count = wrel - relocs;
4079 /* Backflips for _bfd_elf_link_output_relocs. */
4080 rel_hdr = &elf_section_data (input_section)->rel_hdr;
4081 rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
4082 ret = 2;
4083 }
4084
e9f53129
AM		 4085 return ret;
4086}
4087
c1b2796f
AM		 4088/* Adjust _SPUEAR_ syms to point at their overlay stubs. */
4089
4090static bfd_boolean
4091spu_elf_output_symbol_hook (struct bfd_link_info *info,
4092 const char *sym_name ATTRIBUTE_UNUSED,
4093 Elf_Internal_Sym *sym,
4094 asection *sym_sec ATTRIBUTE_UNUSED,
4095 struct elf_link_hash_entry *h)
4096{
4097 struct spu_link_hash_table *htab = spu_hash_table (info);
4098
4099 if (!info->relocatable
47f6dab9 4100 && htab->stub_sec != NULL
c1b2796f
AM		 4101 && h != NULL
4102 && (h->root.type == bfd_link_hash_defined
4103 || h->root.type == bfd_link_hash_defweak)
4104 && h->def_regular
4105 && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
4106 {
4a628337 4107 struct got_entry *g;
c1b2796f 4108
4a628337
AM		 4109 for (g = h->got.glist; g != NULL; g = g->next)
4110 if (g->addend == 0 && g->ovl == 0)
4111 {
4112 sym->st_shndx = (_bfd_elf_section_from_bfd_section
4113 (htab->stub_sec[0]->output_section->owner,
4114 htab->stub_sec[0]->output_section));
4115 sym->st_value = g->stub_addr;
4116 break;
4117 }
c1b2796f
AM		 4118 }
4119
4120 return TRUE;
4121}
4122
e9f53129
AM		 4123static int spu_plugin = 0;
4124
4125void
4126spu_elf_plugin (int val)
4127{
4128 spu_plugin = val;
4129}
4130
4131/* Set ELF header e_type for plugins. */
4132
4133static void
4134spu_elf_post_process_headers (bfd *abfd,
4135 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4136{
4137 if (spu_plugin)
4138 {
4139 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4140
4141 i_ehdrp->e_type = ET_DYN;
4142 }
4143}
4144
4145/* We may add an extra PT_LOAD segment for .toe. We also need extra
4146 segments for overlays. */
4147
4148static int
4149spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
4150{
4151 struct spu_link_hash_table *htab = spu_hash_table (info);
4152 int extra = htab->num_overlays;
4153 asection *sec;
4154
4155 if (extra)
4156 ++extra;
4157
4158 sec = bfd_get_section_by_name (abfd, ".toe");
4159 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
4160 ++extra;
4161
4162 return extra;
4163}
4164
4165/* Remove .toe section from other PT_LOAD segments and put it in
4166 a segment of its own. Put overlays in separate segments too. */
4167
4168static bfd_boolean
4169spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
4170{
4171 asection *toe, *s;
4172 struct elf_segment_map *m;
4173 unsigned int i;
4174
4175 if (info == NULL)
4176 return TRUE;
4177
4178 toe = bfd_get_section_by_name (abfd, ".toe");
4179 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4180 if (m->p_type == PT_LOAD && m->count > 1)
4181 for (i = 0; i < m->count; i++)
4182 if ((s = m->sections[i]) == toe
47f6dab9 4183 || spu_elf_section_data (s)->u.o.ovl_index != 0)
e9f53129
AM		 4184 {
4185 struct elf_segment_map *m2;
4186 bfd_vma amt;
4187
4188 if (i + 1 < m->count)
4189 {
4190 amt = sizeof (struct elf_segment_map);
4191 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
4192 m2 = bfd_zalloc (abfd, amt);
4193 if (m2 == NULL)
4194 return FALSE;
4195 m2->count = m->count - (i + 1);
4196 memcpy (m2->sections, m->sections + i + 1,
4197 m2->count * sizeof (m->sections[0]));
4198 m2->p_type = PT_LOAD;
4199 m2->next = m->next;
4200 m->next = m2;
4201 }
4202 m->count = 1;
4203 if (i != 0)
4204 {
4205 m->count = i;
4206 amt = sizeof (struct elf_segment_map);
4207 m2 = bfd_zalloc (abfd, amt);
4208 if (m2 == NULL)
4209 return FALSE;
4210 m2->p_type = PT_LOAD;
4211 m2->count = 1;
4212 m2->sections[0] = s;
4213 m2->next = m->next;
4214 m->next = m2;
4215 }
4216 break;
4217 }
4218
4219 return TRUE;
4220}
4221
7d3287cb
AM		 4222/* Tweak the section type of .note.spu_name. */
4223
4224static bfd_boolean
4225spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
4226 Elf_Internal_Shdr *hdr,
4227 asection *sec)
4228{
4229 if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
4230 hdr->sh_type = SHT_NOTE;
4231 return TRUE;
4232}
4233
e9f53129
AM		 4234/* Tweak phdrs before writing them out. */
4235
4236static int
4237spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
4238{
4239 const struct elf_backend_data *bed;
4240 struct elf_obj_tdata *tdata;
4241 Elf_Internal_Phdr *phdr, *last;
4242 struct spu_link_hash_table *htab;
4243 unsigned int count;
4244 unsigned int i;
4245
4246 if (info == NULL)
4247 return TRUE;
4248
4249 bed = get_elf_backend_data (abfd);
4250 tdata = elf_tdata (abfd);
4251 phdr = tdata->phdr;
4252 count = tdata->program_header_size / bed->s->sizeof_phdr;
4253 htab = spu_hash_table (info);
4254 if (htab->num_overlays != 0)
4255 {
4256 struct elf_segment_map *m;
4257 unsigned int o;
4258
4259 for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
4260 if (m->count != 0
47f6dab9 4261 && (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
e9f53129
AM		 4262 {
4263 /* Mark this as an overlay header. */
4264 phdr[i].p_flags |= PF_OVERLAY;
4265
4266 if (htab->ovtab != NULL && htab->ovtab->size != 0)
4267 {
4268 bfd_byte *p = htab->ovtab->contents;
47f6dab9 4269 unsigned int off = o * 16 + 8;
e9f53129
AM		 4270
4271 /* Write file_off into _ovly_table. */
4272 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
4273 }
4274 }
4275 }
4276
4277 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
4278 of 16. This should always be possible when using the standard
4279 linker scripts, but don't create overlapping segments if
4280 someone is playing games with linker scripts. */
4281 last = NULL;
4282 for (i = count; i-- != 0; )
4283 if (phdr[i].p_type == PT_LOAD)
4284 {
4285 unsigned adjust;
4286
4287 adjust = -phdr[i].p_filesz & 15;
4288 if (adjust != 0
4289 && last != NULL
4290 && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
4291 break;
4292
4293 adjust = -phdr[i].p_memsz & 15;
4294 if (adjust != 0
4295 && last != NULL
4296 && phdr[i].p_filesz != 0
4297 && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
4298 && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
4299 break;
4300
4301 if (phdr[i].p_filesz != 0)
4302 last = &phdr[i];
4303 }
4304
4305 if (i == (unsigned int) -1)
4306 for (i = count; i-- != 0; )
4307 if (phdr[i].p_type == PT_LOAD)
4308 {
4309 unsigned adjust;
4310
4311 adjust = -phdr[i].p_filesz & 15;
4312 phdr[i].p_filesz += adjust;
4313
4314 adjust = -phdr[i].p_memsz & 15;
4315 phdr[i].p_memsz += adjust;
4316 }
4317
4318 return TRUE;
4319}
4320
e9f53129
AM		 4321#define TARGET_BIG_SYM bfd_elf32_spu_vec
4322#define TARGET_BIG_NAME "elf32-spu"
4323#define ELF_ARCH bfd_arch_spu
4324#define ELF_MACHINE_CODE EM_SPU
4325/* This matches the alignment need for DMA. */
4326#define ELF_MAXPAGESIZE 0x80
4327#define elf_backend_rela_normal 1
4328#define elf_backend_can_gc_sections 1
4329
4330#define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
157090f7 4331#define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
e9f53129 4332#define elf_info_to_howto spu_elf_info_to_howto
ece5ef60 4333#define elf_backend_count_relocs spu_elf_count_relocs
e9f53129
AM		 4334#define elf_backend_relocate_section spu_elf_relocate_section
4335#define elf_backend_symbol_processing spu_elf_backend_symbol_processing
c1b2796f 4336#define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
e9f53129
AM		 4337#define bfd_elf32_new_section_hook spu_elf_new_section_hook
4338#define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
e9f53129
AM		 4339
4340#define elf_backend_additional_program_headers spu_elf_additional_program_headers
4341#define elf_backend_modify_segment_map spu_elf_modify_segment_map
4342#define elf_backend_modify_program_headers spu_elf_modify_program_headers
4343#define elf_backend_post_process_headers spu_elf_post_process_headers
7d3287cb 4344#define elf_backend_fake_sections spu_elf_fake_sections
e9f53129 4345#define elf_backend_special_sections spu_elf_special_sections
49fa1e15 4346#define bfd_elf32_bfd_final_link spu_elf_final_link
e9f53129
AM		 4347
4348#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.372761 seconds and 4 git commands to generate.