1 /* SPU specific support for 32-bit ELF
3 Copyright 2006, 2007 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
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.
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. */
27 #include "elf32-spu.h"
29 /* We use RELA style relocs. Don't define USE_REL. */
31 static bfd_reloc_status_type
spu_elf_rel9 (bfd
*, arelent
*, asymbol
*,
35 /* Values of type 'enum elf_spu_reloc_type' are used to index this
36 array, so it must be declared in the order of that type. */
38 static reloc_howto_type elf_howto_table
[] = {
39 HOWTO (R_SPU_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
40 bfd_elf_generic_reloc
, "SPU_NONE",
41 FALSE
, 0, 0x00000000, FALSE
),
42 HOWTO (R_SPU_ADDR10
, 4, 2, 10, FALSE
, 14, complain_overflow_bitfield
,
43 bfd_elf_generic_reloc
, "SPU_ADDR10",
44 FALSE
, 0, 0x00ffc000, FALSE
),
45 HOWTO (R_SPU_ADDR16
, 2, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
46 bfd_elf_generic_reloc
, "SPU_ADDR16",
47 FALSE
, 0, 0x007fff80, FALSE
),
48 HOWTO (R_SPU_ADDR16_HI
, 16, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
49 bfd_elf_generic_reloc
, "SPU_ADDR16_HI",
50 FALSE
, 0, 0x007fff80, FALSE
),
51 HOWTO (R_SPU_ADDR16_LO
, 0, 2, 16, FALSE
, 7, complain_overflow_dont
,
52 bfd_elf_generic_reloc
, "SPU_ADDR16_LO",
53 FALSE
, 0, 0x007fff80, FALSE
),
54 HOWTO (R_SPU_ADDR18
, 0, 2, 18, FALSE
, 7, complain_overflow_bitfield
,
55 bfd_elf_generic_reloc
, "SPU_ADDR18",
56 FALSE
, 0, 0x01ffff80, FALSE
),
57 HOWTO (R_SPU_ADDR32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
58 bfd_elf_generic_reloc
, "SPU_ADDR32",
59 FALSE
, 0, 0xffffffff, FALSE
),
60 HOWTO (R_SPU_REL16
, 2, 2, 16, TRUE
, 7, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "SPU_REL16",
62 FALSE
, 0, 0x007fff80, TRUE
),
63 HOWTO (R_SPU_ADDR7
, 0, 2, 7, FALSE
, 14, complain_overflow_dont
,
64 bfd_elf_generic_reloc
, "SPU_ADDR7",
65 FALSE
, 0, 0x001fc000, FALSE
),
66 HOWTO (R_SPU_REL9
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
67 spu_elf_rel9
, "SPU_REL9",
68 FALSE
, 0, 0x0180007f, TRUE
),
69 HOWTO (R_SPU_REL9I
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
70 spu_elf_rel9
, "SPU_REL9I",
71 FALSE
, 0, 0x0000c07f, TRUE
),
72 HOWTO (R_SPU_ADDR10I
, 0, 2, 10, FALSE
, 14, complain_overflow_signed
,
73 bfd_elf_generic_reloc
, "SPU_ADDR10I",
74 FALSE
, 0, 0x00ffc000, FALSE
),
75 HOWTO (R_SPU_ADDR16I
, 0, 2, 16, FALSE
, 7, complain_overflow_signed
,
76 bfd_elf_generic_reloc
, "SPU_ADDR16I",
77 FALSE
, 0, 0x007fff80, FALSE
),
78 HOWTO (R_SPU_REL32
, 0, 2, 32, TRUE
, 0, complain_overflow_dont
,
79 bfd_elf_generic_reloc
, "SPU_REL32",
80 FALSE
, 0, 0xffffffff, TRUE
),
83 static struct bfd_elf_special_section
const spu_elf_special_sections
[] = {
84 { ".toe", 4, 0, SHT_NOBITS
, SHF_ALLOC
},
88 static enum elf_spu_reloc_type
89 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code
)
95 case BFD_RELOC_SPU_IMM10W
:
97 case BFD_RELOC_SPU_IMM16W
:
99 case BFD_RELOC_SPU_LO16
:
100 return R_SPU_ADDR16_LO
;
101 case BFD_RELOC_SPU_HI16
:
102 return R_SPU_ADDR16_HI
;
103 case BFD_RELOC_SPU_IMM18
:
105 case BFD_RELOC_SPU_PCREL16
:
107 case BFD_RELOC_SPU_IMM7
:
109 case BFD_RELOC_SPU_IMM8
:
111 case BFD_RELOC_SPU_PCREL9a
:
113 case BFD_RELOC_SPU_PCREL9b
:
115 case BFD_RELOC_SPU_IMM10
:
116 return R_SPU_ADDR10I
;
117 case BFD_RELOC_SPU_IMM16
:
118 return R_SPU_ADDR16I
;
121 case BFD_RELOC_32_PCREL
:
127 spu_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
129 Elf_Internal_Rela
*dst
)
131 enum elf_spu_reloc_type r_type
;
133 r_type
= (enum elf_spu_reloc_type
) ELF32_R_TYPE (dst
->r_info
);
134 BFD_ASSERT (r_type
< R_SPU_max
);
135 cache_ptr
->howto
= &elf_howto_table
[(int) r_type
];
138 static reloc_howto_type
*
139 spu_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
140 bfd_reloc_code_real_type code
)
142 return elf_howto_table
+ spu_elf_bfd_to_reloc_type (code
);
145 static reloc_howto_type
*
146 spu_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
151 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
152 if (elf_howto_table
[i
].name
!= NULL
153 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
154 return &elf_howto_table
[i
];
159 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
161 static bfd_reloc_status_type
162 spu_elf_rel9 (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
163 void *data
, asection
*input_section
,
164 bfd
*output_bfd
, char **error_message
)
166 bfd_size_type octets
;
170 /* If this is a relocatable link (output_bfd test tells us), just
171 call the generic function. Any adjustment will be done at final
173 if (output_bfd
!= NULL
)
174 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
175 input_section
, output_bfd
, error_message
);
177 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
178 return bfd_reloc_outofrange
;
179 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
181 /* Get symbol value. */
183 if (!bfd_is_com_section (symbol
->section
))
185 if (symbol
->section
->output_section
)
186 val
+= symbol
->section
->output_section
->vma
;
188 val
+= reloc_entry
->addend
;
190 /* Make it pc-relative. */
191 val
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
194 if (val
+ 256 >= 512)
195 return bfd_reloc_overflow
;
197 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
199 /* Move two high bits of value to REL9I and REL9 position.
200 The mask will take care of selecting the right field. */
201 val
= (val
& 0x7f) | ((val
& 0x180) << 7) | ((val
& 0x180) << 16);
202 insn
&= ~reloc_entry
->howto
->dst_mask
;
203 insn
|= val
& reloc_entry
->howto
->dst_mask
;
204 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
209 spu_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
211 if (!sec
->used_by_bfd
)
213 struct _spu_elf_section_data
*sdata
;
215 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
218 sec
->used_by_bfd
= sdata
;
221 return _bfd_elf_new_section_hook (abfd
, sec
);
224 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
225 strip --strip-unneeded will not remove them. */
228 spu_elf_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*sym
)
230 if (sym
->name
!= NULL
231 && sym
->section
!= bfd_abs_section_ptr
232 && strncmp (sym
->name
, "_EAR_", 5) == 0)
233 sym
->flags
|= BSF_KEEP
;
236 /* SPU ELF linker hash table. */
238 struct spu_link_hash_table
240 struct elf_link_hash_table elf
;
242 /* The stub hash table. */
243 struct bfd_hash_table stub_hash_table
;
245 /* Shortcuts to overlay sections. */
249 struct elf_link_hash_entry
*ovly_load
;
251 /* An array of two output sections per overlay region, chosen such that
252 the first section vma is the overlay buffer vma (ie. the section has
253 the lowest vma in the group that occupy the region), and the second
254 section vma+size specifies the end of the region. We keep pointers
255 to sections like this because section vmas may change when laying
257 asection
**ovl_region
;
259 /* Number of overlay buffers. */
260 unsigned int num_buf
;
262 /* Total number of overlays. */
263 unsigned int num_overlays
;
265 /* Set if we should emit symbols for stubs. */
266 unsigned int emit_stub_syms
:1;
268 /* Set if we want stubs on calls out of overlay regions to
269 non-overlay regions. */
270 unsigned int non_overlay_stubs
: 1;
273 unsigned int stub_overflow
: 1;
275 /* Set if stack size analysis should be done. */
276 unsigned int stack_analysis
: 1;
278 /* Set if __stack_* syms will be emitted. */
279 unsigned int emit_stack_syms
: 1;
282 #define spu_hash_table(p) \
283 ((struct spu_link_hash_table *) ((p)->hash))
285 struct spu_stub_hash_entry
287 struct bfd_hash_entry root
;
289 /* Destination of this stub. */
290 asection
*target_section
;
293 /* Offset of entry in stub section. */
296 /* Offset from this stub to stub that loads the overlay index. */
300 /* Create an entry in a spu stub hash table. */
302 static struct bfd_hash_entry
*
303 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
304 struct bfd_hash_table
*table
,
307 /* Allocate the structure if it has not already been allocated by a
311 entry
= bfd_hash_allocate (table
, sizeof (struct spu_stub_hash_entry
));
316 /* Call the allocation method of the superclass. */
317 entry
= bfd_hash_newfunc (entry
, table
, string
);
320 struct spu_stub_hash_entry
*sh
= (struct spu_stub_hash_entry
*) entry
;
322 sh
->target_section
= NULL
;
331 /* Create a spu ELF linker hash table. */
333 static struct bfd_link_hash_table
*
334 spu_elf_link_hash_table_create (bfd
*abfd
)
336 struct spu_link_hash_table
*htab
;
338 htab
= bfd_malloc (sizeof (*htab
));
342 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
,
343 _bfd_elf_link_hash_newfunc
,
344 sizeof (struct elf_link_hash_entry
)))
350 /* Init the stub hash table too. */
351 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
352 sizeof (struct spu_stub_hash_entry
)))
355 memset (&htab
->stub
, 0,
356 sizeof (*htab
) - offsetof (struct spu_link_hash_table
, stub
));
358 return &htab
->elf
.root
;
361 /* Free the derived linker hash table. */
364 spu_elf_link_hash_table_free (struct bfd_link_hash_table
*hash
)
366 struct spu_link_hash_table
*ret
= (struct spu_link_hash_table
*) hash
;
368 bfd_hash_table_free (&ret
->stub_hash_table
);
369 _bfd_generic_link_hash_table_free (hash
);
372 /* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
373 to (hash, NULL) for global symbols, and (NULL, sym) for locals. Set
374 *SYMSECP to the symbol's section. *LOCSYMSP caches local syms. */
377 get_sym_h (struct elf_link_hash_entry
**hp
,
378 Elf_Internal_Sym
**symp
,
380 Elf_Internal_Sym
**locsymsp
,
381 unsigned long r_symndx
,
384 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
386 if (r_symndx
>= symtab_hdr
->sh_info
)
388 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
389 struct elf_link_hash_entry
*h
;
391 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
392 while (h
->root
.type
== bfd_link_hash_indirect
393 || h
->root
.type
== bfd_link_hash_warning
)
394 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
404 asection
*symsec
= NULL
;
405 if (h
->root
.type
== bfd_link_hash_defined
406 || h
->root
.type
== bfd_link_hash_defweak
)
407 symsec
= h
->root
.u
.def
.section
;
413 Elf_Internal_Sym
*sym
;
414 Elf_Internal_Sym
*locsyms
= *locsymsp
;
418 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
421 size_t symcount
= symtab_hdr
->sh_info
;
423 /* If we are reading symbols into the contents, then
424 read the global syms too. This is done to cache
425 syms for later stack analysis. */
426 if ((unsigned char **) locsymsp
== &symtab_hdr
->contents
)
427 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
428 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
, symcount
, 0,
435 sym
= locsyms
+ r_symndx
;
445 asection
*symsec
= NULL
;
446 if ((sym
->st_shndx
!= SHN_UNDEF
447 && sym
->st_shndx
< SHN_LORESERVE
)
448 || sym
->st_shndx
> SHN_HIRESERVE
)
449 symsec
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
457 /* Build a name for an entry in the stub hash table. We can't use a
458 local symbol name because ld -r might generate duplicate local symbols. */
461 spu_stub_name (const asection
*sym_sec
,
462 const struct elf_link_hash_entry
*h
,
463 const Elf_Internal_Rela
*rel
)
470 len
= strlen (h
->root
.root
.string
) + 1 + 8 + 1;
471 stub_name
= bfd_malloc (len
);
472 if (stub_name
== NULL
)
475 sprintf (stub_name
, "%s+%x",
477 (int) rel
->r_addend
& 0xffffffff);
482 len
= 8 + 1 + 8 + 1 + 8 + 1;
483 stub_name
= bfd_malloc (len
);
484 if (stub_name
== NULL
)
487 sprintf (stub_name
, "%x:%x+%x",
488 sym_sec
->id
& 0xffffffff,
489 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
490 (int) rel
->r_addend
& 0xffffffff);
491 len
= strlen (stub_name
);
494 if (stub_name
[len
- 2] == '+'
495 && stub_name
[len
- 1] == '0'
496 && stub_name
[len
] == 0)
497 stub_name
[len
- 2] = 0;
502 /* Create the note section if not already present. This is done early so
503 that the linker maps the sections to the right place in the output. */
506 spu_elf_create_sections (bfd
*output_bfd
,
507 struct bfd_link_info
*info
,
512 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
514 /* Stash some options away where we can get at them later. */
515 htab
->stack_analysis
= stack_analysis
;
516 htab
->emit_stack_syms
= emit_stack_syms
;
518 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->next
)
519 if (bfd_get_section_by_name (ibfd
, SPU_PTNOTE_SPUNAME
) != NULL
)
524 /* Make SPU_PTNOTE_SPUNAME section. */
531 ibfd
= info
->input_bfds
;
532 flags
= SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
533 s
= bfd_make_section_anyway_with_flags (ibfd
, SPU_PTNOTE_SPUNAME
, flags
);
535 || !bfd_set_section_alignment (ibfd
, s
, 4))
538 name_len
= strlen (bfd_get_filename (output_bfd
)) + 1;
539 size
= 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4);
540 size
+= (name_len
+ 3) & -4;
542 if (!bfd_set_section_size (ibfd
, s
, size
))
545 data
= bfd_zalloc (ibfd
, size
);
549 bfd_put_32 (ibfd
, sizeof (SPU_PLUGIN_NAME
), data
+ 0);
550 bfd_put_32 (ibfd
, name_len
, data
+ 4);
551 bfd_put_32 (ibfd
, 1, data
+ 8);
552 memcpy (data
+ 12, SPU_PLUGIN_NAME
, sizeof (SPU_PLUGIN_NAME
));
553 memcpy (data
+ 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4),
554 bfd_get_filename (output_bfd
), name_len
);
561 /* Return the section that should be marked against GC for a given
565 spu_elf_gc_mark_hook (asection
*sec
,
566 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
567 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
568 struct elf_link_hash_entry
*h
,
569 Elf_Internal_Sym
*sym
)
573 switch (h
->root
.type
)
575 case bfd_link_hash_defined
:
576 case bfd_link_hash_defweak
:
577 return h
->root
.u
.def
.section
;
579 case bfd_link_hash_common
:
580 return h
->root
.u
.c
.p
->section
;
587 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
592 /* qsort predicate to sort sections by vma. */
595 sort_sections (const void *a
, const void *b
)
597 const asection
*const *s1
= a
;
598 const asection
*const *s2
= b
;
599 bfd_signed_vma delta
= (*s1
)->vma
- (*s2
)->vma
;
602 return delta
< 0 ? -1 : 1;
604 return (*s1
)->index
- (*s2
)->index
;
607 /* Identify overlays in the output bfd, and number them. */
610 spu_elf_find_overlays (bfd
*output_bfd
, struct bfd_link_info
*info
)
612 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
613 asection
**alloc_sec
;
614 unsigned int i
, n
, ovl_index
, num_buf
;
618 if (output_bfd
->section_count
< 2)
621 alloc_sec
= bfd_malloc (output_bfd
->section_count
* sizeof (*alloc_sec
));
622 if (alloc_sec
== NULL
)
625 /* Pick out all the alloced sections. */
626 for (n
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
627 if ((s
->flags
& SEC_ALLOC
) != 0
628 && (s
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != SEC_THREAD_LOCAL
638 /* Sort them by vma. */
639 qsort (alloc_sec
, n
, sizeof (*alloc_sec
), sort_sections
);
641 /* Look for overlapping vmas. Any with overlap must be overlays.
642 Count them. Also count the number of overlay regions and for
643 each region save a section from that region with the lowest vma
644 and another section with the highest end vma. */
645 ovl_end
= alloc_sec
[0]->vma
+ alloc_sec
[0]->size
;
646 for (ovl_index
= 0, num_buf
= 0, i
= 1; i
< n
; i
++)
649 if (s
->vma
< ovl_end
)
651 asection
*s0
= alloc_sec
[i
- 1];
653 if (spu_elf_section_data (s0
)->ovl_index
== 0)
655 spu_elf_section_data (s0
)->ovl_index
= ++ovl_index
;
656 alloc_sec
[num_buf
* 2] = s0
;
657 alloc_sec
[num_buf
* 2 + 1] = s0
;
660 spu_elf_section_data (s
)->ovl_index
= ++ovl_index
;
661 if (ovl_end
< s
->vma
+ s
->size
)
663 ovl_end
= s
->vma
+ s
->size
;
664 alloc_sec
[num_buf
* 2 - 1] = s
;
668 ovl_end
= s
->vma
+ s
->size
;
671 htab
->num_overlays
= ovl_index
;
672 htab
->num_buf
= num_buf
;
679 alloc_sec
= bfd_realloc (alloc_sec
, num_buf
* 2 * sizeof (*alloc_sec
));
680 if (alloc_sec
== NULL
)
683 htab
->ovl_region
= alloc_sec
;
687 /* One of these per stub. */
688 #define SIZEOF_STUB1 8
689 #define ILA_79 0x4200004f /* ila $79,function_address */
690 #define BR 0x32000000 /* br stub2 */
692 /* One of these per overlay. */
693 #define SIZEOF_STUB2 8
694 #define ILA_78 0x4200004e /* ila $78,overlay_number */
696 #define NOP 0x40200000
698 /* Return true for all relative and absolute branch instructions.
706 brhnz 00100011 0.. */
709 is_branch (const unsigned char *insn
)
711 return (insn
[0] & 0xec) == 0x20 && (insn
[1] & 0x80) == 0;
714 /* Return true for branch hint instructions.
719 is_hint (const unsigned char *insn
)
721 return (insn
[0] & 0xfc) == 0x10;
724 /* Return TRUE if this reloc symbol should possibly go via an overlay stub. */
727 needs_ovl_stub (const char *sym_name
,
729 asection
*input_section
,
730 struct spu_link_hash_table
*htab
,
731 bfd_boolean is_branch
)
733 if (htab
->num_overlays
== 0)
737 || sym_sec
->output_section
== NULL
738 || spu_elf_section_data (sym_sec
->output_section
) == NULL
)
741 /* setjmp always goes via an overlay stub, because then the return
742 and hence the longjmp goes via __ovly_return. That magically
743 makes setjmp/longjmp between overlays work. */
744 if (strncmp (sym_name
, "setjmp", 6) == 0
745 && (sym_name
[6] == '\0' || sym_name
[6] == '@'))
748 /* Usually, symbols in non-overlay sections don't need stubs. */
749 if (spu_elf_section_data (sym_sec
->output_section
)->ovl_index
== 0
750 && !htab
->non_overlay_stubs
)
753 /* A reference from some other section to a symbol in an overlay
754 section needs a stub. */
755 if (spu_elf_section_data (sym_sec
->output_section
)->ovl_index
756 != spu_elf_section_data (input_section
->output_section
)->ovl_index
)
759 /* If this insn isn't a branch then we are possibly taking the
760 address of a function and passing it out somehow. */
765 struct bfd_hash_table
*stub_hash_table
;
766 struct spu_stub_hash_entry
**sh
;
771 /* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
775 allocate_spuear_stubs (struct elf_link_hash_entry
*h
, void *inf
)
777 /* Symbols starting with _SPUEAR_ need a stub because they may be
778 invoked by the PPU. */
779 if ((h
->root
.type
== bfd_link_hash_defined
780 || h
->root
.type
== bfd_link_hash_defweak
)
782 && strncmp (h
->root
.root
.string
, "_SPUEAR_", 8) == 0)
784 struct stubarr
*stubs
= inf
;
785 static Elf_Internal_Rela zero_rel
;
786 char *stub_name
= spu_stub_name (h
->root
.u
.def
.section
, h
, &zero_rel
);
787 struct spu_stub_hash_entry
*sh
;
789 if (stub_name
== NULL
)
795 sh
= (struct spu_stub_hash_entry
*)
796 bfd_hash_lookup (stubs
->stub_hash_table
, stub_name
, TRUE
, FALSE
);
803 /* If this entry isn't new, we already have a stub. */
804 if (sh
->target_section
!= NULL
)
810 sh
->target_section
= h
->root
.u
.def
.section
;
811 sh
->target_off
= h
->root
.u
.def
.value
;
818 /* Called via bfd_hash_traverse to set up pointers to all symbols
819 in the stub hash table. */
822 populate_stubs (struct bfd_hash_entry
*bh
, void *inf
)
824 struct stubarr
*stubs
= inf
;
826 stubs
->sh
[--stubs
->count
] = (struct spu_stub_hash_entry
*) bh
;
830 /* qsort predicate to sort stubs by overlay number. */
833 sort_stubs (const void *a
, const void *b
)
835 const struct spu_stub_hash_entry
*const *sa
= a
;
836 const struct spu_stub_hash_entry
*const *sb
= b
;
840 i
= spu_elf_section_data ((*sa
)->target_section
->output_section
)->ovl_index
;
841 i
-= spu_elf_section_data ((*sb
)->target_section
->output_section
)->ovl_index
;
845 d
= ((*sa
)->target_section
->output_section
->vma
846 + (*sa
)->target_section
->output_offset
848 - (*sb
)->target_section
->output_section
->vma
849 - (*sb
)->target_section
->output_offset
850 - (*sb
)->target_off
);
852 return d
< 0 ? -1 : 1;
854 /* Two functions at the same address. Aliases perhaps. */
855 i
= strcmp ((*sb
)->root
.string
, (*sa
)->root
.string
);
860 /* Allocate space for overlay call and return stubs. */
863 spu_elf_size_stubs (bfd
*output_bfd
,
864 struct bfd_link_info
*info
,
865 int non_overlay_stubs
,
871 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
873 struct stubarr stubs
;
877 htab
->non_overlay_stubs
= non_overlay_stubs
;
878 stubs
.stub_hash_table
= &htab
->stub_hash_table
;
881 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
883 extern const bfd_target bfd_elf32_spu_vec
;
884 Elf_Internal_Shdr
*symtab_hdr
;
886 Elf_Internal_Sym
*local_syms
= NULL
;
887 Elf_Internal_Sym
**psyms
;
889 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
892 /* We'll need the symbol table in a second. */
893 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
894 if (symtab_hdr
->sh_info
== 0)
897 /* Arrange to read and keep global syms for later stack analysis. */
900 psyms
= (Elf_Internal_Sym
**) &symtab_hdr
->contents
;
902 /* Walk over each section attached to the input bfd. */
903 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
905 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
907 /* If there aren't any relocs, then there's nothing more to do. */
908 if ((section
->flags
& SEC_RELOC
) == 0
909 || (section
->flags
& SEC_ALLOC
) == 0
910 || (section
->flags
& SEC_LOAD
) == 0
911 || section
->reloc_count
== 0)
914 /* If this section is a link-once section that will be
915 discarded, then don't create any stubs. */
916 if (section
->output_section
== NULL
917 || section
->output_section
->owner
!= output_bfd
)
920 /* Get the relocs. */
922 = _bfd_elf_link_read_relocs (ibfd
, section
, NULL
, NULL
,
924 if (internal_relocs
== NULL
)
925 goto error_ret_free_local
;
927 /* Now examine each relocation. */
928 irela
= internal_relocs
;
929 irelaend
= irela
+ section
->reloc_count
;
930 for (; irela
< irelaend
; irela
++)
932 enum elf_spu_reloc_type r_type
;
935 Elf_Internal_Sym
*sym
;
936 struct elf_link_hash_entry
*h
;
937 const char *sym_name
;
939 struct spu_stub_hash_entry
*sh
;
940 unsigned int sym_type
;
941 enum _insn_type
{ non_branch
, branch
, call
} insn_type
;
943 r_type
= ELF32_R_TYPE (irela
->r_info
);
944 r_indx
= ELF32_R_SYM (irela
->r_info
);
946 if (r_type
>= R_SPU_max
)
948 bfd_set_error (bfd_error_bad_value
);
949 goto error_ret_free_internal
;
952 /* Determine the reloc target section. */
953 if (!get_sym_h (&h
, &sym
, &sym_sec
, psyms
, r_indx
, ibfd
))
954 goto error_ret_free_internal
;
957 || sym_sec
->output_section
== NULL
958 || sym_sec
->output_section
->owner
!= output_bfd
)
961 /* Ensure no stubs for user supplied overlay manager syms. */
963 && (strcmp (h
->root
.root
.string
, "__ovly_load") == 0
964 || strcmp (h
->root
.root
.string
, "__ovly_return") == 0))
967 insn_type
= non_branch
;
968 if (r_type
== R_SPU_REL16
969 || r_type
== R_SPU_ADDR16
)
971 unsigned char insn
[4];
973 if (!bfd_get_section_contents (ibfd
, section
, insn
,
975 goto error_ret_free_internal
;
977 if (is_branch (insn
) || is_hint (insn
))
980 if ((insn
[0] & 0xfd) == 0x31)
985 /* We are only interested in function symbols. */
989 sym_name
= h
->root
.root
.string
;
993 sym_type
= ELF_ST_TYPE (sym
->st_info
);
994 sym_name
= bfd_elf_sym_name (sym_sec
->owner
,
999 if (sym_type
!= STT_FUNC
)
1001 /* It's common for people to write assembly and forget
1002 to give function symbols the right type. Handle
1003 calls to such symbols, but warn so that (hopefully)
1004 people will fix their code. We need the symbol
1005 type to be correct to distinguish function pointer
1006 initialisation from other pointer initialisation. */
1007 if (insn_type
== call
)
1008 (*_bfd_error_handler
) (_("warning: call to non-function"
1009 " symbol %s defined in %B"),
1010 sym_sec
->owner
, sym_name
);
1015 if (!needs_ovl_stub (sym_name
, sym_sec
, section
, htab
,
1016 insn_type
!= non_branch
))
1019 stub_name
= spu_stub_name (sym_sec
, h
, irela
);
1020 if (stub_name
== NULL
)
1021 goto error_ret_free_internal
;
1023 sh
= (struct spu_stub_hash_entry
*)
1024 bfd_hash_lookup (&htab
->stub_hash_table
, stub_name
,
1029 error_ret_free_internal
:
1030 if (elf_section_data (section
)->relocs
!= internal_relocs
)
1031 free (internal_relocs
);
1032 error_ret_free_local
:
1033 if (local_syms
!= NULL
1034 && (symtab_hdr
->contents
1035 != (unsigned char *) local_syms
))
1040 /* If this entry isn't new, we already have a stub. */
1041 if (sh
->target_section
!= NULL
)
1047 sh
->target_section
= sym_sec
;
1049 sh
->target_off
= h
->root
.u
.def
.value
;
1051 sh
->target_off
= sym
->st_value
;
1052 sh
->target_off
+= irela
->r_addend
;
1057 /* We're done with the internal relocs, free them. */
1058 if (elf_section_data (section
)->relocs
!= internal_relocs
)
1059 free (internal_relocs
);
1062 if (local_syms
!= NULL
1063 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
1065 if (!info
->keep_memory
)
1068 symtab_hdr
->contents
= (unsigned char *) local_syms
;
1072 elf_link_hash_traverse (&htab
->elf
, allocate_spuear_stubs
, &stubs
);
1077 if (stubs
.count
== 0)
1080 ibfd
= info
->input_bfds
;
1081 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
1082 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
1083 htab
->stub
= bfd_make_section_anyway_with_flags (ibfd
, ".stub", flags
);
1085 if (htab
->stub
== NULL
1086 || !bfd_set_section_alignment (ibfd
, htab
->stub
, 2))
1089 flags
= (SEC_ALLOC
| SEC_LOAD
1090 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
1091 htab
->ovtab
= bfd_make_section_anyway_with_flags (ibfd
, ".ovtab", flags
);
1092 *ovtab
= htab
->ovtab
;
1093 if (htab
->ovtab
== NULL
1094 || !bfd_set_section_alignment (ibfd
, htab
->stub
, 4))
1097 *toe
= bfd_make_section_anyway_with_flags (ibfd
, ".toe", SEC_ALLOC
);
1099 || !bfd_set_section_alignment (ibfd
, *toe
, 4))
1103 /* Retrieve all the stubs and sort. */
1104 stubs
.sh
= bfd_malloc (stubs
.count
* sizeof (*stubs
.sh
));
1105 if (stubs
.sh
== NULL
)
1108 bfd_hash_traverse (&htab
->stub_hash_table
, populate_stubs
, &stubs
);
1109 BFD_ASSERT (stubs
.count
== 0);
1112 qsort (stubs
.sh
, stubs
.count
, sizeof (*stubs
.sh
), sort_stubs
);
1114 /* Now that the stubs are sorted, place them in the stub section.
1115 Stubs are grouped per overlay
1129 for (i
= 0; i
< stubs
.count
; i
++)
1131 if (spu_elf_section_data (stubs
.sh
[group
]->target_section
1132 ->output_section
)->ovl_index
1133 != spu_elf_section_data (stubs
.sh
[i
]->target_section
1134 ->output_section
)->ovl_index
)
1136 htab
->stub
->size
+= SIZEOF_STUB2
;
1137 for (; group
!= i
; group
++)
1138 stubs
.sh
[group
]->delta
1139 = stubs
.sh
[i
- 1]->off
- stubs
.sh
[group
]->off
;
1142 || ((stubs
.sh
[i
- 1]->target_section
->output_section
->vma
1143 + stubs
.sh
[i
- 1]->target_section
->output_offset
1144 + stubs
.sh
[i
- 1]->target_off
)
1145 != (stubs
.sh
[i
]->target_section
->output_section
->vma
1146 + stubs
.sh
[i
]->target_section
->output_offset
1147 + stubs
.sh
[i
]->target_off
)))
1149 stubs
.sh
[i
]->off
= htab
->stub
->size
;
1150 htab
->stub
->size
+= SIZEOF_STUB1
;
1153 stubs
.sh
[i
]->off
= stubs
.sh
[i
- 1]->off
;
1156 htab
->stub
->size
+= SIZEOF_STUB2
;
1157 for (; group
!= i
; group
++)
1158 stubs
.sh
[group
]->delta
= stubs
.sh
[i
- 1]->off
- stubs
.sh
[group
]->off
;
1160 /* htab->ovtab consists of two arrays.
1170 . } _ovly_buf_table[]; */
1172 htab
->ovtab
->alignment_power
= 4;
1173 htab
->ovtab
->size
= htab
->num_overlays
* 16 + htab
->num_buf
* 4;
1178 /* Functions to handle embedded spu_ovl.o object. */
1181 ovl_mgr_open (struct bfd
*nbfd ATTRIBUTE_UNUSED
, void *stream
)
1187 ovl_mgr_pread (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1193 struct _ovl_stream
*os
;
1197 os
= (struct _ovl_stream
*) stream
;
1198 max
= (const char *) os
->end
- (const char *) os
->start
;
1200 if ((ufile_ptr
) offset
>= max
)
1204 if (count
> max
- offset
)
1205 count
= max
- offset
;
1207 memcpy (buf
, (const char *) os
->start
+ offset
, count
);
1212 spu_elf_open_builtin_lib (bfd
**ovl_bfd
, const struct _ovl_stream
*stream
)
1214 *ovl_bfd
= bfd_openr_iovec ("builtin ovl_mgr",
1221 return *ovl_bfd
!= NULL
;
1224 /* Fill in the ila and br for a stub. On the last stub for a group,
1225 write the stub that sets the overlay number too. */
1228 write_one_stub (struct bfd_hash_entry
*bh
, void *inf
)
1230 struct spu_stub_hash_entry
*ent
= (struct spu_stub_hash_entry
*) bh
;
1231 struct spu_link_hash_table
*htab
= inf
;
1232 asection
*sec
= htab
->stub
;
1233 asection
*s
= ent
->target_section
;
1237 val
= ent
->target_off
+ s
->output_offset
+ s
->output_section
->vma
;
1238 bfd_put_32 (sec
->owner
, ILA_79
+ ((val
<< 7) & 0x01ffff80),
1239 sec
->contents
+ ent
->off
);
1240 val
= ent
->delta
+ 4;
1241 bfd_put_32 (sec
->owner
, BR
+ ((val
<< 5) & 0x007fff80),
1242 sec
->contents
+ ent
->off
+ 4);
1244 /* If this is the last stub of this group, write stub2. */
1245 if (ent
->delta
== 0)
1247 bfd_put_32 (sec
->owner
, NOP
,
1248 sec
->contents
+ ent
->off
+ 4);
1250 ovl
= spu_elf_section_data (s
->output_section
)->ovl_index
;
1251 bfd_put_32 (sec
->owner
, ILA_78
+ ((ovl
<< 7) & 0x01ffff80),
1252 sec
->contents
+ ent
->off
+ 8);
1254 val
= (htab
->ovly_load
->root
.u
.def
.section
->output_section
->vma
1255 + htab
->ovly_load
->root
.u
.def
.section
->output_offset
1256 + htab
->ovly_load
->root
.u
.def
.value
1257 - (sec
->output_section
->vma
1258 + sec
->output_offset
1261 if (val
+ 0x20000 >= 0x40000)
1262 htab
->stub_overflow
= TRUE
;
1264 bfd_put_32 (sec
->owner
, BR
+ ((val
<< 5) & 0x007fff80),
1265 sec
->contents
+ ent
->off
+ 12);
1268 if (htab
->emit_stub_syms
)
1270 struct elf_link_hash_entry
*h
;
1274 len1
= sizeof ("00000000.ovl_call.") - 1;
1275 len2
= strlen (ent
->root
.string
);
1276 name
= bfd_malloc (len1
+ len2
+ 1);
1279 memcpy (name
, "00000000.ovl_call.", len1
);
1280 memcpy (name
+ len1
, ent
->root
.string
, len2
+ 1);
1281 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, TRUE
, FALSE
);
1285 if (h
->root
.type
== bfd_link_hash_new
)
1287 h
->root
.type
= bfd_link_hash_defined
;
1288 h
->root
.u
.def
.section
= sec
;
1289 h
->root
.u
.def
.value
= ent
->off
;
1290 h
->size
= (ent
->delta
== 0
1291 ? SIZEOF_STUB1
+ SIZEOF_STUB2
: SIZEOF_STUB1
);
1295 h
->ref_regular_nonweak
= 1;
1296 h
->forced_local
= 1;
1304 /* Define an STT_OBJECT symbol. */
1306 static struct elf_link_hash_entry
*
1307 define_ovtab_symbol (struct spu_link_hash_table
*htab
, const char *name
)
1309 struct elf_link_hash_entry
*h
;
1311 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
1315 if (h
->root
.type
!= bfd_link_hash_defined
1318 h
->root
.type
= bfd_link_hash_defined
;
1319 h
->root
.u
.def
.section
= htab
->ovtab
;
1320 h
->type
= STT_OBJECT
;
1323 h
->ref_regular_nonweak
= 1;
1328 (*_bfd_error_handler
) (_("%B is not allowed to define %s"),
1329 h
->root
.u
.def
.section
->owner
,
1330 h
->root
.root
.string
);
1331 bfd_set_error (bfd_error_bad_value
);
1338 /* Fill in all stubs and the overlay tables. */
1341 spu_elf_build_stubs (struct bfd_link_info
*info
, int emit_syms
, asection
*toe
)
1343 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1344 struct elf_link_hash_entry
*h
;
1350 htab
->emit_stub_syms
= emit_syms
;
1351 htab
->stub
->contents
= bfd_zalloc (htab
->stub
->owner
, htab
->stub
->size
);
1352 if (htab
->stub
->contents
== NULL
)
1355 h
= elf_link_hash_lookup (&htab
->elf
, "__ovly_load", FALSE
, FALSE
, FALSE
);
1356 htab
->ovly_load
= h
;
1357 BFD_ASSERT (h
!= NULL
1358 && (h
->root
.type
== bfd_link_hash_defined
1359 || h
->root
.type
== bfd_link_hash_defweak
)
1362 s
= h
->root
.u
.def
.section
->output_section
;
1363 if (spu_elf_section_data (s
)->ovl_index
)
1365 (*_bfd_error_handler
) (_("%s in overlay section"),
1366 h
->root
.u
.def
.section
->owner
);
1367 bfd_set_error (bfd_error_bad_value
);
1371 /* Write out all the stubs. */
1372 bfd_hash_traverse (&htab
->stub_hash_table
, write_one_stub
, htab
);
1374 if (htab
->stub_overflow
)
1376 (*_bfd_error_handler
) (_("overlay stub relocation overflow"));
1377 bfd_set_error (bfd_error_bad_value
);
1381 htab
->ovtab
->contents
= bfd_zalloc (htab
->ovtab
->owner
, htab
->ovtab
->size
);
1382 if (htab
->ovtab
->contents
== NULL
)
1385 /* Write out _ovly_table. */
1386 p
= htab
->ovtab
->contents
;
1387 obfd
= htab
->ovtab
->output_section
->owner
;
1388 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
1390 unsigned int ovl_index
= spu_elf_section_data (s
)->ovl_index
;
1394 unsigned int lo
, hi
, mid
;
1395 unsigned long off
= (ovl_index
- 1) * 16;
1396 bfd_put_32 (htab
->ovtab
->owner
, s
->vma
, p
+ off
);
1397 bfd_put_32 (htab
->ovtab
->owner
, (s
->size
+ 15) & -16, p
+ off
+ 4);
1398 /* file_off written later in spu_elf_modify_program_headers. */
1404 mid
= (lo
+ hi
) >> 1;
1405 if (htab
->ovl_region
[2 * mid
+ 1]->vma
1406 + htab
->ovl_region
[2 * mid
+ 1]->size
<= s
->vma
)
1408 else if (htab
->ovl_region
[2 * mid
]->vma
> s
->vma
)
1412 bfd_put_32 (htab
->ovtab
->owner
, mid
+ 1, p
+ off
+ 12);
1416 BFD_ASSERT (lo
< hi
);
1420 /* Write out _ovly_buf_table. */
1421 p
= htab
->ovtab
->contents
+ htab
->num_overlays
* 16;
1422 for (i
= 0; i
< htab
->num_buf
; i
++)
1424 bfd_put_32 (htab
->ovtab
->owner
, 0, p
);
1428 h
= define_ovtab_symbol (htab
, "_ovly_table");
1431 h
->root
.u
.def
.value
= 0;
1432 h
->size
= htab
->num_overlays
* 16;
1434 h
= define_ovtab_symbol (htab
, "_ovly_table_end");
1437 h
->root
.u
.def
.value
= htab
->num_overlays
* 16;
1440 h
= define_ovtab_symbol (htab
, "_ovly_buf_table");
1443 h
->root
.u
.def
.value
= htab
->num_overlays
* 16;
1444 h
->size
= htab
->num_buf
* 4;
1446 h
= define_ovtab_symbol (htab
, "_ovly_buf_table_end");
1449 h
->root
.u
.def
.value
= htab
->num_overlays
* 16 + htab
->num_buf
* 4;
1452 h
= define_ovtab_symbol (htab
, "_EAR_");
1455 h
->root
.u
.def
.section
= toe
;
1456 h
->root
.u
.def
.value
= 0;
1462 /* OFFSET in SEC (presumably) is the beginning of a function prologue.
1463 Search for stack adjusting insns, and return the sp delta. */
1466 find_function_stack_adjust (asection
*sec
, bfd_vma offset
)
1471 memset (reg
, 0, sizeof (reg
));
1472 for (unrecog
= 0; offset
+ 4 <= sec
->size
&& unrecog
< 32; offset
+= 4)
1474 unsigned char buf
[4];
1478 /* Assume no relocs on stack adjusing insns. */
1479 if (!bfd_get_section_contents (sec
->owner
, sec
, buf
, offset
, 4))
1482 if (buf
[0] == 0x24 /* stqd */)
1486 ra
= ((buf
[2] & 0x3f) << 1) | (buf
[3] >> 7);
1487 /* Partly decoded immediate field. */
1488 imm
= (buf
[1] << 9) | (buf
[2] << 1) | (buf
[3] >> 7);
1490 if (buf
[0] == 0x1c /* ai */)
1493 imm
= (imm
^ 0x200) - 0x200;
1494 reg
[rt
] = reg
[ra
] + imm
;
1496 if (rt
== 1 /* sp */)
1503 else if (buf
[0] == 0x18 && (buf
[1] & 0xe0) == 0 /* a */)
1505 int rb
= ((buf
[1] & 0x1f) << 2) | ((buf
[2] & 0xc0) >> 6);
1507 reg
[rt
] = reg
[ra
] + reg
[rb
];
1511 else if ((buf
[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
1513 if (buf
[0] >= 0x42 /* ila */)
1514 imm
|= (buf
[0] & 1) << 17;
1519 if (buf
[0] == 0x40 /* il */)
1521 if ((buf
[1] & 0x80) == 0)
1523 imm
= (imm
^ 0x8000) - 0x8000;
1525 else if ((buf
[1] & 0x80) == 0 /* ilhu */)
1531 else if (buf
[0] == 0x60 && (buf
[1] & 0x80) != 0 /* iohl */)
1533 reg
[rt
] |= imm
& 0xffff;
1536 else if (buf
[0] == 0x04 /* ori */)
1539 imm
= (imm
^ 0x200) - 0x200;
1540 reg
[rt
] = reg
[ra
] | imm
;
1543 else if ((buf
[0] == 0x33 && imm
== 1 /* brsl .+4 */)
1544 || (buf
[0] == 0x08 && (buf
[1] & 0xe0) == 0 /* sf */))
1546 /* Used in pic reg load. Say rt is trashed. */
1550 else if (is_branch (buf
))
1551 /* If we hit a branch then we must be out of the prologue. */
1560 /* qsort predicate to sort symbols by section and value. */
1562 static Elf_Internal_Sym
*sort_syms_syms
;
1563 static asection
**sort_syms_psecs
;
1566 sort_syms (const void *a
, const void *b
)
1568 Elf_Internal_Sym
*const *s1
= a
;
1569 Elf_Internal_Sym
*const *s2
= b
;
1570 asection
*sec1
,*sec2
;
1571 bfd_signed_vma delta
;
1573 sec1
= sort_syms_psecs
[*s1
- sort_syms_syms
];
1574 sec2
= sort_syms_psecs
[*s2
- sort_syms_syms
];
1577 return sec1
->index
- sec2
->index
;
1579 delta
= (*s1
)->st_value
- (*s2
)->st_value
;
1581 return delta
< 0 ? -1 : 1;
1583 delta
= (*s2
)->st_size
- (*s1
)->st_size
;
1585 return delta
< 0 ? -1 : 1;
1587 return *s1
< *s2
? -1 : 1;
1592 struct function_info
*fun
;
1593 struct call_info
*next
;
1597 struct function_info
1599 /* List of functions called. Also branches to hot/cold part of
1601 struct call_info
*call_list
;
1602 /* For hot/cold part of function, point to owner. */
1603 struct function_info
*start
;
1604 /* Symbol at start of function. */
1606 Elf_Internal_Sym
*sym
;
1607 struct elf_link_hash_entry
*h
;
1609 /* Function section. */
1611 /* Address range of (this part of) function. */
1615 /* Set if global symbol. */
1616 unsigned int global
: 1;
1617 /* Set if known to be start of function (as distinct from a hunk
1618 in hot/cold section. */
1619 unsigned int is_func
: 1;
1620 /* Flags used during call tree traversal. */
1621 unsigned int visit1
: 1;
1622 unsigned int non_root
: 1;
1623 unsigned int visit2
: 1;
1624 unsigned int marking
: 1;
1625 unsigned int visit3
: 1;
1628 struct spu_elf_stack_info
1632 /* Variable size array describing functions, one per contiguous
1633 address range belonging to a function. */
1634 struct function_info fun
[1];
1637 /* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
1638 entries for section SEC. */
1640 static struct spu_elf_stack_info
*
1641 alloc_stack_info (asection
*sec
, int max_fun
)
1643 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
1646 amt
= sizeof (struct spu_elf_stack_info
);
1647 amt
+= (max_fun
- 1) * sizeof (struct function_info
);
1648 sec_data
->stack_info
= bfd_zmalloc (amt
);
1649 if (sec_data
->stack_info
!= NULL
)
1650 sec_data
->stack_info
->max_fun
= max_fun
;
1651 return sec_data
->stack_info
;
1654 /* Add a new struct function_info describing a (part of a) function
1655 starting at SYM_H. Keep the array sorted by address. */
1657 static struct function_info
*
1658 maybe_insert_function (asection
*sec
,
1661 bfd_boolean is_func
)
1663 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
1664 struct spu_elf_stack_info
*sinfo
= sec_data
->stack_info
;
1670 sinfo
= alloc_stack_info (sec
, 20);
1677 Elf_Internal_Sym
*sym
= sym_h
;
1678 off
= sym
->st_value
;
1679 size
= sym
->st_size
;
1683 struct elf_link_hash_entry
*h
= sym_h
;
1684 off
= h
->root
.u
.def
.value
;
1688 for (i
= sinfo
->num_fun
; --i
>= 0; )
1689 if (sinfo
->fun
[i
].lo
<= off
)
1694 /* Don't add another entry for an alias, but do update some
1696 if (sinfo
->fun
[i
].lo
== off
)
1698 /* Prefer globals over local syms. */
1699 if (global
&& !sinfo
->fun
[i
].global
)
1701 sinfo
->fun
[i
].global
= TRUE
;
1702 sinfo
->fun
[i
].u
.h
= sym_h
;
1705 sinfo
->fun
[i
].is_func
= TRUE
;
1706 return &sinfo
->fun
[i
];
1708 /* Ignore a zero-size symbol inside an existing function. */
1709 else if (sinfo
->fun
[i
].hi
> off
&& size
== 0)
1710 return &sinfo
->fun
[i
];
1713 if (++i
< sinfo
->num_fun
)
1714 memmove (&sinfo
->fun
[i
+ 1], &sinfo
->fun
[i
],
1715 (sinfo
->num_fun
- i
) * sizeof (sinfo
->fun
[i
]));
1716 else if (i
>= sinfo
->max_fun
)
1718 bfd_size_type amt
= sizeof (struct spu_elf_stack_info
);
1719 bfd_size_type old
= amt
;
1721 old
+= (sinfo
->max_fun
- 1) * sizeof (struct function_info
);
1722 sinfo
->max_fun
+= 20 + (sinfo
->max_fun
>> 1);
1723 amt
+= (sinfo
->max_fun
- 1) * sizeof (struct function_info
);
1724 sinfo
= bfd_realloc (sinfo
, amt
);
1727 memset ((char *) sinfo
+ old
, 0, amt
- old
);
1728 sec_data
->stack_info
= sinfo
;
1730 sinfo
->fun
[i
].is_func
= is_func
;
1731 sinfo
->fun
[i
].global
= global
;
1732 sinfo
->fun
[i
].sec
= sec
;
1734 sinfo
->fun
[i
].u
.h
= sym_h
;
1736 sinfo
->fun
[i
].u
.sym
= sym_h
;
1737 sinfo
->fun
[i
].lo
= off
;
1738 sinfo
->fun
[i
].hi
= off
+ size
;
1739 sinfo
->fun
[i
].stack
= -find_function_stack_adjust (sec
, off
);
1740 sinfo
->num_fun
+= 1;
1741 return &sinfo
->fun
[i
];
1744 /* Return the name of FUN. */
1747 func_name (struct function_info
*fun
)
1751 Elf_Internal_Shdr
*symtab_hdr
;
1753 while (fun
->start
!= NULL
)
1757 return fun
->u
.h
->root
.root
.string
;
1760 if (fun
->u
.sym
->st_name
== 0)
1762 size_t len
= strlen (sec
->name
);
1763 char *name
= bfd_malloc (len
+ 10);
1766 sprintf (name
, "%s+%lx", sec
->name
,
1767 (unsigned long) fun
->u
.sym
->st_value
& 0xffffffff);
1771 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1772 return bfd_elf_sym_name (ibfd
, symtab_hdr
, fun
->u
.sym
, sec
);
1775 /* Read the instruction at OFF in SEC. Return true iff the instruction
1776 is a nop, lnop, or stop 0 (all zero insn). */
1779 is_nop (asection
*sec
, bfd_vma off
)
1781 unsigned char insn
[4];
1783 if (off
+ 4 > sec
->size
1784 || !bfd_get_section_contents (sec
->owner
, sec
, insn
, off
, 4))
1786 if ((insn
[0] & 0xbf) == 0 && (insn
[1] & 0xe0) == 0x20)
1788 if (insn
[0] == 0 && insn
[1] == 0 && insn
[2] == 0 && insn
[3] == 0)
1793 /* Extend the range of FUN to cover nop padding up to LIMIT.
1794 Return TRUE iff some instruction other than a NOP was found. */
1797 insns_at_end (struct function_info
*fun
, bfd_vma limit
)
1799 bfd_vma off
= (fun
->hi
+ 3) & -4;
1801 while (off
< limit
&& is_nop (fun
->sec
, off
))
1812 /* Check and fix overlapping function ranges. Return TRUE iff there
1813 are gaps in the current info we have about functions in SEC. */
1816 check_function_ranges (asection
*sec
, struct bfd_link_info
*info
)
1818 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
1819 struct spu_elf_stack_info
*sinfo
= sec_data
->stack_info
;
1821 bfd_boolean gaps
= FALSE
;
1826 for (i
= 1; i
< sinfo
->num_fun
; i
++)
1827 if (sinfo
->fun
[i
- 1].hi
> sinfo
->fun
[i
].lo
)
1829 /* Fix overlapping symbols. */
1830 const char *f1
= func_name (&sinfo
->fun
[i
- 1]);
1831 const char *f2
= func_name (&sinfo
->fun
[i
]);
1833 info
->callbacks
->einfo (_("warning: %s overlaps %s\n"), f1
, f2
);
1834 sinfo
->fun
[i
- 1].hi
= sinfo
->fun
[i
].lo
;
1836 else if (insns_at_end (&sinfo
->fun
[i
- 1], sinfo
->fun
[i
].lo
))
1839 if (sinfo
->num_fun
== 0)
1843 if (sinfo
->fun
[0].lo
!= 0)
1845 if (sinfo
->fun
[sinfo
->num_fun
- 1].hi
> sec
->size
)
1847 const char *f1
= func_name (&sinfo
->fun
[sinfo
->num_fun
- 1]);
1849 info
->callbacks
->einfo (_("warning: %s exceeds section size\n"), f1
);
1850 sinfo
->fun
[sinfo
->num_fun
- 1].hi
= sec
->size
;
1852 else if (insns_at_end (&sinfo
->fun
[sinfo
->num_fun
- 1], sec
->size
))
1858 /* Search current function info for a function that contains address
1859 OFFSET in section SEC. */
1861 static struct function_info
*
1862 find_function (asection
*sec
, bfd_vma offset
, struct bfd_link_info
*info
)
1864 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
1865 struct spu_elf_stack_info
*sinfo
= sec_data
->stack_info
;
1869 hi
= sinfo
->num_fun
;
1872 mid
= (lo
+ hi
) / 2;
1873 if (offset
< sinfo
->fun
[mid
].lo
)
1875 else if (offset
>= sinfo
->fun
[mid
].hi
)
1878 return &sinfo
->fun
[mid
];
1880 info
->callbacks
->einfo (_("%A:0x%v not found in function table\n"),
1885 /* Add CALLEE to CALLER call list if not already present. */
1888 insert_callee (struct function_info
*caller
, struct call_info
*callee
)
1890 struct call_info
*p
;
1891 for (p
= caller
->call_list
; p
!= NULL
; p
= p
->next
)
1892 if (p
->fun
== callee
->fun
)
1894 /* Tail calls use less stack than normal calls. Retain entry
1895 for normal call over one for tail call. */
1896 if (p
->is_tail
> callee
->is_tail
)
1897 p
->is_tail
= callee
->is_tail
;
1900 callee
->next
= caller
->call_list
;
1901 caller
->call_list
= callee
;
1905 /* Rummage through the relocs for SEC, looking for function calls.
1906 If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
1907 mark destination symbols on calls as being functions. Also
1908 look at branches, which may be tail calls or go to hot/cold
1909 section part of same function. */
1912 mark_functions_via_relocs (asection
*sec
,
1913 struct bfd_link_info
*info
,
1916 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
1917 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (sec
->owner
)->symtab_hdr
;
1918 Elf_Internal_Sym
*syms
, **psyms
;
1919 static bfd_boolean warned
;
1921 internal_relocs
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
,
1923 if (internal_relocs
== NULL
)
1926 symtab_hdr
= &elf_tdata (sec
->owner
)->symtab_hdr
;
1927 psyms
= (Elf_Internal_Sym
**) &symtab_hdr
->contents
;
1929 irela
= internal_relocs
;
1930 irelaend
= irela
+ sec
->reloc_count
;
1931 for (; irela
< irelaend
; irela
++)
1933 enum elf_spu_reloc_type r_type
;
1934 unsigned int r_indx
;
1936 Elf_Internal_Sym
*sym
;
1937 struct elf_link_hash_entry
*h
;
1939 unsigned char insn
[4];
1940 bfd_boolean is_call
;
1941 struct function_info
*caller
;
1942 struct call_info
*callee
;
1944 r_type
= ELF32_R_TYPE (irela
->r_info
);
1945 if (r_type
!= R_SPU_REL16
1946 && r_type
!= R_SPU_ADDR16
)
1949 r_indx
= ELF32_R_SYM (irela
->r_info
);
1950 if (!get_sym_h (&h
, &sym
, &sym_sec
, psyms
, r_indx
, sec
->owner
))
1954 || sym_sec
->output_section
== NULL
1955 || sym_sec
->output_section
->owner
!= sec
->output_section
->owner
)
1958 if (!bfd_get_section_contents (sec
->owner
, sec
, insn
,
1959 irela
->r_offset
, 4))
1961 if (!is_branch (insn
))
1964 if ((sym_sec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
1965 != (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
1969 if (!call_tree
|| !warned
)
1970 info
->callbacks
->einfo (_("%B(%A+0x%v): call to non-code section"
1971 " %B(%A), stack analysis incomplete\n"),
1972 sec
->owner
, sec
, irela
->r_offset
,
1973 sym_sec
->owner
, sym_sec
);
1977 is_call
= (insn
[0] & 0xfd) == 0x31;
1980 val
= h
->root
.u
.def
.value
;
1982 val
= sym
->st_value
;
1983 val
+= irela
->r_addend
;
1987 struct function_info
*fun
;
1989 if (irela
->r_addend
!= 0)
1991 Elf_Internal_Sym
*fake
= bfd_zmalloc (sizeof (*fake
));
1994 fake
->st_value
= val
;
1996 = _bfd_elf_section_from_bfd_section (sym_sec
->owner
, sym_sec
);
2000 fun
= maybe_insert_function (sym_sec
, sym
, FALSE
, is_call
);
2002 fun
= maybe_insert_function (sym_sec
, h
, TRUE
, is_call
);
2005 if (irela
->r_addend
!= 0
2006 && fun
->u
.sym
!= sym
)
2011 caller
= find_function (sec
, irela
->r_offset
, info
);
2014 callee
= bfd_malloc (sizeof *callee
);
2018 callee
->fun
= find_function (sym_sec
, val
, info
);
2019 if (callee
->fun
== NULL
)
2021 callee
->is_tail
= !is_call
;
2022 if (!insert_callee (caller
, callee
))
2025 && !callee
->fun
->is_func
2026 && callee
->fun
->stack
== 0)
2028 /* This is either a tail call or a branch from one part of
2029 the function to another, ie. hot/cold section. If the
2030 destination has been called by some other function then
2031 it is a separate function. We also assume that functions
2032 are not split across input files. */
2033 if (callee
->fun
->start
!= NULL
2034 || sec
->owner
!= sym_sec
->owner
)
2036 callee
->fun
->start
= NULL
;
2037 callee
->fun
->is_func
= TRUE
;
2040 callee
->fun
->start
= caller
;
2047 /* Handle something like .init or .fini, which has a piece of a function.
2048 These sections are pasted together to form a single function. */
2051 pasted_function (asection
*sec
, struct bfd_link_info
*info
)
2053 struct bfd_link_order
*l
;
2054 struct _spu_elf_section_data
*sec_data
;
2055 struct spu_elf_stack_info
*sinfo
;
2056 Elf_Internal_Sym
*fake
;
2057 struct function_info
*fun
, *fun_start
;
2059 fake
= bfd_zmalloc (sizeof (*fake
));
2063 fake
->st_size
= sec
->size
;
2065 = _bfd_elf_section_from_bfd_section (sec
->owner
, sec
);
2066 fun
= maybe_insert_function (sec
, fake
, FALSE
, FALSE
);
2070 /* Find a function immediately preceding this section. */
2072 for (l
= sec
->output_section
->map_head
.link_order
; l
!= NULL
; l
= l
->next
)
2074 if (l
->u
.indirect
.section
== sec
)
2076 if (fun_start
!= NULL
)
2078 if (fun_start
->start
)
2079 fun_start
= fun_start
->start
;
2080 fun
->start
= fun_start
;
2084 if (l
->type
== bfd_indirect_link_order
2085 && (sec_data
= spu_elf_section_data (l
->u
.indirect
.section
)) != NULL
2086 && (sinfo
= sec_data
->stack_info
) != NULL
2087 && sinfo
->num_fun
!= 0)
2088 fun_start
= &sinfo
->fun
[sinfo
->num_fun
- 1];
2091 info
->callbacks
->einfo (_("%A link_order not found\n"), sec
);
2095 /* We're only interested in code sections. */
2098 interesting_section (asection
*s
, bfd
*obfd
, struct spu_link_hash_table
*htab
)
2100 return (s
!= htab
->stub
2101 && s
->output_section
!= NULL
2102 && s
->output_section
->owner
== obfd
2103 && ((s
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
2104 == (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
2108 /* Map address ranges in code sections to functions. */
2111 discover_functions (bfd
*output_bfd
, struct bfd_link_info
*info
)
2113 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2116 Elf_Internal_Sym
***psym_arr
;
2117 asection
***sec_arr
;
2118 bfd_boolean gaps
= FALSE
;
2121 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2124 psym_arr
= bfd_zmalloc (bfd_idx
* sizeof (*psym_arr
));
2125 if (psym_arr
== NULL
)
2127 sec_arr
= bfd_zmalloc (bfd_idx
* sizeof (*sec_arr
));
2128 if (sec_arr
== NULL
)
2132 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2134 ibfd
= ibfd
->link_next
, bfd_idx
++)
2136 extern const bfd_target bfd_elf32_spu_vec
;
2137 Elf_Internal_Shdr
*symtab_hdr
;
2140 Elf_Internal_Sym
*syms
, *sy
, **psyms
, **psy
;
2141 asection
**psecs
, **p
;
2143 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2146 /* Read all the symbols. */
2147 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2148 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
2152 syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2155 syms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
, symcount
, 0,
2157 symtab_hdr
->contents
= (void *) syms
;
2162 /* Select defined function symbols that are going to be output. */
2163 psyms
= bfd_malloc ((symcount
+ 1) * sizeof (*psyms
));
2166 psym_arr
[bfd_idx
] = psyms
;
2167 psecs
= bfd_malloc (symcount
* sizeof (*psecs
));
2170 sec_arr
[bfd_idx
] = psecs
;
2171 for (psy
= psyms
, p
= psecs
, sy
= syms
; sy
< syms
+ symcount
; ++p
, ++sy
)
2172 if (ELF_ST_TYPE (sy
->st_info
) == STT_NOTYPE
2173 || ELF_ST_TYPE (sy
->st_info
) == STT_FUNC
)
2177 *p
= s
= bfd_section_from_elf_index (ibfd
, sy
->st_shndx
);
2178 if (s
!= NULL
&& interesting_section (s
, output_bfd
, htab
))
2181 symcount
= psy
- psyms
;
2184 /* Sort them by section and offset within section. */
2185 sort_syms_syms
= syms
;
2186 sort_syms_psecs
= psecs
;
2187 qsort (psyms
, symcount
, sizeof (*psyms
), sort_syms
);
2189 /* Now inspect the function symbols. */
2190 for (psy
= psyms
; psy
< psyms
+ symcount
; )
2192 asection
*s
= psecs
[*psy
- syms
];
2193 Elf_Internal_Sym
**psy2
;
2195 for (psy2
= psy
; ++psy2
< psyms
+ symcount
; )
2196 if (psecs
[*psy2
- syms
] != s
)
2199 if (!alloc_stack_info (s
, psy2
- psy
))
2204 /* First install info about properly typed and sized functions.
2205 In an ideal world this will cover all code sections, except
2206 when partitioning functions into hot and cold sections,
2207 and the horrible pasted together .init and .fini functions. */
2208 for (psy
= psyms
; psy
< psyms
+ symcount
; ++psy
)
2211 if (ELF_ST_TYPE (sy
->st_info
) == STT_FUNC
)
2213 asection
*s
= psecs
[sy
- syms
];
2214 if (!maybe_insert_function (s
, sy
, FALSE
, TRUE
))
2219 for (sec
= ibfd
->sections
; sec
!= NULL
&& !gaps
; sec
= sec
->next
)
2220 if (interesting_section (sec
, output_bfd
, htab
))
2221 gaps
|= check_function_ranges (sec
, info
);
2226 /* See if we can discover more function symbols by looking at
2228 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2230 ibfd
= ibfd
->link_next
, bfd_idx
++)
2234 if (psym_arr
[bfd_idx
] == NULL
)
2237 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2238 if (interesting_section (sec
, output_bfd
, htab
)
2239 && sec
->reloc_count
!= 0)
2241 if (!mark_functions_via_relocs (sec
, info
, FALSE
))
2246 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2248 ibfd
= ibfd
->link_next
, bfd_idx
++)
2250 Elf_Internal_Shdr
*symtab_hdr
;
2252 Elf_Internal_Sym
*syms
, *sy
, **psyms
, **psy
;
2255 if ((psyms
= psym_arr
[bfd_idx
]) == NULL
)
2258 psecs
= sec_arr
[bfd_idx
];
2260 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2261 syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2264 for (sec
= ibfd
->sections
; sec
!= NULL
&& !gaps
; sec
= sec
->next
)
2265 if (interesting_section (sec
, output_bfd
, htab
))
2266 gaps
|= check_function_ranges (sec
, info
);
2270 /* Finally, install all globals. */
2271 for (psy
= psyms
; (sy
= *psy
) != NULL
; ++psy
)
2275 s
= psecs
[sy
- syms
];
2277 /* Global syms might be improperly typed functions. */
2278 if (ELF_ST_TYPE (sy
->st_info
) != STT_FUNC
2279 && ELF_ST_BIND (sy
->st_info
) == STB_GLOBAL
)
2281 if (!maybe_insert_function (s
, sy
, FALSE
, FALSE
))
2286 /* Some of the symbols we've installed as marking the
2287 beginning of functions may have a size of zero. Extend
2288 the range of such functions to the beginning of the
2289 next symbol of interest. */
2290 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2291 if (interesting_section (sec
, output_bfd
, htab
))
2293 struct _spu_elf_section_data
*sec_data
;
2294 struct spu_elf_stack_info
*sinfo
;
2296 sec_data
= spu_elf_section_data (sec
);
2297 sinfo
= sec_data
->stack_info
;
2301 bfd_vma hi
= sec
->size
;
2303 for (fun_idx
= sinfo
->num_fun
; --fun_idx
>= 0; )
2305 sinfo
->fun
[fun_idx
].hi
= hi
;
2306 hi
= sinfo
->fun
[fun_idx
].lo
;
2309 /* No symbols in this section. Must be .init or .fini
2310 or something similar. */
2311 else if (!pasted_function (sec
, info
))
2317 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2319 ibfd
= ibfd
->link_next
, bfd_idx
++)
2321 if (psym_arr
[bfd_idx
] == NULL
)
2324 free (psym_arr
[bfd_idx
]);
2325 free (sec_arr
[bfd_idx
]);
2334 /* Mark nodes in the call graph that are called by some other node. */
2337 mark_non_root (struct function_info
*fun
)
2339 struct call_info
*call
;
2342 for (call
= fun
->call_list
; call
; call
= call
->next
)
2344 call
->fun
->non_root
= TRUE
;
2345 if (!call
->fun
->visit1
)
2346 mark_non_root (call
->fun
);
2350 /* Remove cycles from the call graph. */
2353 call_graph_traverse (struct function_info
*fun
, struct bfd_link_info
*info
)
2355 struct call_info
**callp
, *call
;
2358 fun
->marking
= TRUE
;
2360 callp
= &fun
->call_list
;
2361 while ((call
= *callp
) != NULL
)
2363 if (!call
->fun
->visit2
)
2364 call_graph_traverse (call
->fun
, info
);
2365 else if (call
->fun
->marking
)
2367 const char *f1
= func_name (fun
);
2368 const char *f2
= func_name (call
->fun
);
2370 info
->callbacks
->info (_("Stack analysis will ignore the call "
2373 *callp
= call
->next
;
2376 callp
= &call
->next
;
2378 fun
->marking
= FALSE
;
2381 /* Populate call_list for each function. */
2384 build_call_tree (bfd
*output_bfd
, struct bfd_link_info
*info
)
2386 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2389 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2391 extern const bfd_target bfd_elf32_spu_vec
;
2394 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2397 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2399 if (!interesting_section (sec
, output_bfd
, htab
)
2400 || sec
->reloc_count
== 0)
2403 if (!mark_functions_via_relocs (sec
, info
, TRUE
))
2407 /* Transfer call info from hot/cold section part of function
2409 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2411 struct _spu_elf_section_data
*sec_data
;
2412 struct spu_elf_stack_info
*sinfo
;
2414 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
2415 && (sinfo
= sec_data
->stack_info
) != NULL
)
2418 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
2420 if (sinfo
->fun
[i
].start
!= NULL
)
2422 struct call_info
*call
= sinfo
->fun
[i
].call_list
;
2424 while (call
!= NULL
)
2426 struct call_info
*call_next
= call
->next
;
2427 if (!insert_callee (sinfo
->fun
[i
].start
, call
))
2431 sinfo
->fun
[i
].call_list
= NULL
;
2432 sinfo
->fun
[i
].non_root
= TRUE
;
2439 /* Find the call graph root(s). */
2440 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2442 extern const bfd_target bfd_elf32_spu_vec
;
2445 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2448 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2450 struct _spu_elf_section_data
*sec_data
;
2451 struct spu_elf_stack_info
*sinfo
;
2453 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
2454 && (sinfo
= sec_data
->stack_info
) != NULL
)
2457 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
2458 if (!sinfo
->fun
[i
].visit1
)
2459 mark_non_root (&sinfo
->fun
[i
]);
2464 /* Remove cycles from the call graph. We start from the root node(s)
2465 so that we break cycles in a reasonable place. */
2466 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2468 extern const bfd_target bfd_elf32_spu_vec
;
2471 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2474 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2476 struct _spu_elf_section_data
*sec_data
;
2477 struct spu_elf_stack_info
*sinfo
;
2479 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
2480 && (sinfo
= sec_data
->stack_info
) != NULL
)
2483 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
2484 if (!sinfo
->fun
[i
].non_root
)
2485 call_graph_traverse (&sinfo
->fun
[i
], info
);
2493 /* Descend the call graph for FUN, accumulating total stack required. */
2496 sum_stack (struct function_info
*fun
,
2497 struct bfd_link_info
*info
,
2498 int emit_stack_syms
)
2500 struct call_info
*call
;
2501 struct function_info
*max
= NULL
;
2502 bfd_vma max_stack
= fun
->stack
;
2509 for (call
= fun
->call_list
; call
; call
= call
->next
)
2511 stack
= sum_stack (call
->fun
, info
, emit_stack_syms
);
2512 /* Include caller stack for normal calls, don't do so for
2513 tail calls. fun->stack here is local stack usage for
2516 stack
+= fun
->stack
;
2517 if (max_stack
< stack
)
2524 f1
= func_name (fun
);
2525 info
->callbacks
->minfo (_("%s: 0x%v 0x%v\n"), f1
, fun
->stack
, max_stack
);
2529 info
->callbacks
->minfo (_(" calls:\n"));
2530 for (call
= fun
->call_list
; call
; call
= call
->next
)
2532 const char *f2
= func_name (call
->fun
);
2533 const char *ann1
= call
->fun
== max
? "*" : " ";
2534 const char *ann2
= call
->is_tail
? "t" : " ";
2536 info
->callbacks
->minfo (_(" %s%s %s\n"), ann1
, ann2
, f2
);
2540 /* Now fun->stack holds cumulative stack. */
2541 fun
->stack
= max_stack
;
2544 if (emit_stack_syms
)
2546 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2547 char *name
= bfd_malloc (18 + strlen (f1
));
2548 struct elf_link_hash_entry
*h
;
2552 if (fun
->global
|| ELF_ST_BIND (fun
->u
.sym
->st_info
) == STB_GLOBAL
)
2553 sprintf (name
, "__stack_%s", f1
);
2555 sprintf (name
, "__stack_%x_%s", fun
->sec
->id
& 0xffffffff, f1
);
2557 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, TRUE
, FALSE
);
2560 && (h
->root
.type
== bfd_link_hash_new
2561 || h
->root
.type
== bfd_link_hash_undefined
2562 || h
->root
.type
== bfd_link_hash_undefweak
))
2564 h
->root
.type
= bfd_link_hash_defined
;
2565 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
2566 h
->root
.u
.def
.value
= max_stack
;
2571 h
->ref_regular_nonweak
= 1;
2572 h
->forced_local
= 1;
2581 /* Provide an estimate of total stack required. */
2584 spu_elf_stack_analysis (bfd
*output_bfd
,
2585 struct bfd_link_info
*info
,
2586 int emit_stack_syms
)
2589 bfd_vma max_stack
= 0;
2591 if (!discover_functions (output_bfd
, info
))
2594 if (!build_call_tree (output_bfd
, info
))
2597 info
->callbacks
->info (_("Stack size for call graph root nodes.\n"));
2598 info
->callbacks
->minfo (_("\nStack size for functions. "
2599 "Annotations: '*' max stack, 't' tail call\n"));
2600 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2602 extern const bfd_target bfd_elf32_spu_vec
;
2605 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2608 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2610 struct _spu_elf_section_data
*sec_data
;
2611 struct spu_elf_stack_info
*sinfo
;
2613 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
2614 && (sinfo
= sec_data
->stack_info
) != NULL
)
2617 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
2619 if (!sinfo
->fun
[i
].non_root
)
2624 stack
= sum_stack (&sinfo
->fun
[i
], info
,
2626 f1
= func_name (&sinfo
->fun
[i
]);
2627 info
->callbacks
->info (_(" %s: 0x%v\n"),
2629 if (max_stack
< stack
)
2637 info
->callbacks
->info (_("Maximum stack required is 0x%v\n"), max_stack
);
2641 /* Perform a final link. */
2644 spu_elf_final_link (bfd
*output_bfd
, struct bfd_link_info
*info
)
2646 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2648 if (htab
->stack_analysis
2649 && !spu_elf_stack_analysis (output_bfd
, info
, htab
->emit_stack_syms
))
2650 info
->callbacks
->einfo ("%X%P: stack analysis error: %E\n");
2652 return bfd_elf_final_link (output_bfd
, info
);
2655 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
2658 spu_elf_relocate_section (bfd
*output_bfd
,
2659 struct bfd_link_info
*info
,
2661 asection
*input_section
,
2663 Elf_Internal_Rela
*relocs
,
2664 Elf_Internal_Sym
*local_syms
,
2665 asection
**local_sections
)
2667 Elf_Internal_Shdr
*symtab_hdr
;
2668 struct elf_link_hash_entry
**sym_hashes
;
2669 Elf_Internal_Rela
*rel
, *relend
;
2670 struct spu_link_hash_table
*htab
;
2671 bfd_boolean ret
= TRUE
;
2673 htab
= spu_hash_table (info
);
2674 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2675 sym_hashes
= (struct elf_link_hash_entry
**) (elf_sym_hashes (input_bfd
));
2678 relend
= relocs
+ input_section
->reloc_count
;
2679 for (; rel
< relend
; rel
++)
2682 reloc_howto_type
*howto
;
2683 unsigned long r_symndx
;
2684 Elf_Internal_Sym
*sym
;
2686 struct elf_link_hash_entry
*h
;
2687 const char *sym_name
;
2690 bfd_reloc_status_type r
;
2691 bfd_boolean unresolved_reloc
;
2695 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2696 r_type
= ELF32_R_TYPE (rel
->r_info
);
2697 howto
= elf_howto_table
+ r_type
;
2698 unresolved_reloc
= FALSE
;
2704 if (r_symndx
< symtab_hdr
->sh_info
)
2706 sym
= local_syms
+ r_symndx
;
2707 sec
= local_sections
[r_symndx
];
2708 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
2709 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2713 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2714 r_symndx
, symtab_hdr
, sym_hashes
,
2716 unresolved_reloc
, warned
);
2717 sym_name
= h
->root
.root
.string
;
2720 if (sec
!= NULL
&& elf_discarded_section (sec
))
2722 /* For relocs against symbols from removed linkonce sections,
2723 or sections discarded by a linker script, we just want the
2724 section contents zeroed. Avoid any special processing. */
2725 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2731 if (info
->relocatable
)
2734 if (unresolved_reloc
)
2736 (*_bfd_error_handler
)
2737 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
2739 bfd_get_section_name (input_bfd
, input_section
),
2740 (long) rel
->r_offset
,
2746 /* If this symbol is in an overlay area, we may need to relocate
2747 to the overlay stub. */
2748 addend
= rel
->r_addend
;
2749 branch
= (is_branch (contents
+ rel
->r_offset
)
2750 || is_hint (contents
+ rel
->r_offset
));
2751 if (needs_ovl_stub (sym_name
, sec
, input_section
, htab
, branch
))
2754 struct spu_stub_hash_entry
*sh
;
2756 stub_name
= spu_stub_name (sec
, h
, rel
);
2757 if (stub_name
== NULL
)
2760 sh
= (struct spu_stub_hash_entry
*)
2761 bfd_hash_lookup (&htab
->stub_hash_table
, stub_name
, FALSE
, FALSE
);
2764 relocation
= (htab
->stub
->output_section
->vma
2765 + htab
->stub
->output_offset
2772 r
= _bfd_final_link_relocate (howto
,
2776 rel
->r_offset
, relocation
, addend
);
2778 if (r
!= bfd_reloc_ok
)
2780 const char *msg
= (const char *) 0;
2784 case bfd_reloc_overflow
:
2785 if (!((*info
->callbacks
->reloc_overflow
)
2786 (info
, (h
? &h
->root
: NULL
), sym_name
, howto
->name
,
2787 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
)))
2791 case bfd_reloc_undefined
:
2792 if (!((*info
->callbacks
->undefined_symbol
)
2793 (info
, sym_name
, input_bfd
, input_section
,
2794 rel
->r_offset
, TRUE
)))
2798 case bfd_reloc_outofrange
:
2799 msg
= _("internal error: out of range error");
2802 case bfd_reloc_notsupported
:
2803 msg
= _("internal error: unsupported relocation error");
2806 case bfd_reloc_dangerous
:
2807 msg
= _("internal error: dangerous error");
2811 msg
= _("internal error: unknown error");
2815 if (!((*info
->callbacks
->warning
)
2816 (info
, msg
, sym_name
, input_bfd
, input_section
,
2827 /* Adjust _SPUEAR_ syms to point at their overlay stubs. */
2830 spu_elf_output_symbol_hook (struct bfd_link_info
*info
,
2831 const char *sym_name ATTRIBUTE_UNUSED
,
2832 Elf_Internal_Sym
*sym
,
2833 asection
*sym_sec ATTRIBUTE_UNUSED
,
2834 struct elf_link_hash_entry
*h
)
2836 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2838 if (!info
->relocatable
2839 && htab
->num_overlays
!= 0
2841 && (h
->root
.type
== bfd_link_hash_defined
2842 || h
->root
.type
== bfd_link_hash_defweak
)
2844 && strncmp (h
->root
.root
.string
, "_SPUEAR_", 8) == 0)
2846 static Elf_Internal_Rela zero_rel
;
2847 char *stub_name
= spu_stub_name (h
->root
.u
.def
.section
, h
, &zero_rel
);
2848 struct spu_stub_hash_entry
*sh
;
2850 if (stub_name
== NULL
)
2852 sh
= (struct spu_stub_hash_entry
*)
2853 bfd_hash_lookup (&htab
->stub_hash_table
, stub_name
, FALSE
, FALSE
);
2858 = _bfd_elf_section_from_bfd_section (htab
->stub
->output_section
->owner
,
2859 htab
->stub
->output_section
);
2860 sym
->st_value
= (htab
->stub
->output_section
->vma
2861 + htab
->stub
->output_offset
2868 static int spu_plugin
= 0;
2871 spu_elf_plugin (int val
)
2876 /* Set ELF header e_type for plugins. */
2879 spu_elf_post_process_headers (bfd
*abfd
,
2880 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2884 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
2886 i_ehdrp
->e_type
= ET_DYN
;
2890 /* We may add an extra PT_LOAD segment for .toe. We also need extra
2891 segments for overlays. */
2894 spu_elf_additional_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2896 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2897 int extra
= htab
->num_overlays
;
2903 sec
= bfd_get_section_by_name (abfd
, ".toe");
2904 if (sec
!= NULL
&& (sec
->flags
& SEC_LOAD
) != 0)
2910 /* Remove .toe section from other PT_LOAD segments and put it in
2911 a segment of its own. Put overlays in separate segments too. */
2914 spu_elf_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
2917 struct elf_segment_map
*m
;
2923 toe
= bfd_get_section_by_name (abfd
, ".toe");
2924 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2925 if (m
->p_type
== PT_LOAD
&& m
->count
> 1)
2926 for (i
= 0; i
< m
->count
; i
++)
2927 if ((s
= m
->sections
[i
]) == toe
2928 || spu_elf_section_data (s
)->ovl_index
!= 0)
2930 struct elf_segment_map
*m2
;
2933 if (i
+ 1 < m
->count
)
2935 amt
= sizeof (struct elf_segment_map
);
2936 amt
+= (m
->count
- (i
+ 2)) * sizeof (m
->sections
[0]);
2937 m2
= bfd_zalloc (abfd
, amt
);
2940 m2
->count
= m
->count
- (i
+ 1);
2941 memcpy (m2
->sections
, m
->sections
+ i
+ 1,
2942 m2
->count
* sizeof (m
->sections
[0]));
2943 m2
->p_type
= PT_LOAD
;
2951 amt
= sizeof (struct elf_segment_map
);
2952 m2
= bfd_zalloc (abfd
, amt
);
2955 m2
->p_type
= PT_LOAD
;
2957 m2
->sections
[0] = s
;
2967 /* Check that all loadable section VMAs lie in the range
2968 LO .. HI inclusive. */
2971 spu_elf_check_vma (bfd
*abfd
, bfd_vma lo
, bfd_vma hi
)
2973 struct elf_segment_map
*m
;
2976 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2977 if (m
->p_type
== PT_LOAD
)
2978 for (i
= 0; i
< m
->count
; i
++)
2979 if (m
->sections
[i
]->size
!= 0
2980 && (m
->sections
[i
]->vma
< lo
2981 || m
->sections
[i
]->vma
> hi
2982 || m
->sections
[i
]->vma
+ m
->sections
[i
]->size
- 1 > hi
))
2983 return m
->sections
[i
];
2988 /* Tweak phdrs before writing them out. */
2991 spu_elf_modify_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2993 const struct elf_backend_data
*bed
;
2994 struct elf_obj_tdata
*tdata
;
2995 Elf_Internal_Phdr
*phdr
, *last
;
2996 struct spu_link_hash_table
*htab
;
3003 bed
= get_elf_backend_data (abfd
);
3004 tdata
= elf_tdata (abfd
);
3006 count
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
3007 htab
= spu_hash_table (info
);
3008 if (htab
->num_overlays
!= 0)
3010 struct elf_segment_map
*m
;
3013 for (i
= 0, m
= elf_tdata (abfd
)->segment_map
; m
; ++i
, m
= m
->next
)
3015 && (o
= spu_elf_section_data (m
->sections
[0])->ovl_index
) != 0)
3017 /* Mark this as an overlay header. */
3018 phdr
[i
].p_flags
|= PF_OVERLAY
;
3020 if (htab
->ovtab
!= NULL
&& htab
->ovtab
->size
!= 0)
3022 bfd_byte
*p
= htab
->ovtab
->contents
;
3023 unsigned int off
= (o
- 1) * 16 + 8;
3025 /* Write file_off into _ovly_table. */
3026 bfd_put_32 (htab
->ovtab
->owner
, phdr
[i
].p_offset
, p
+ off
);
3031 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
3032 of 16. This should always be possible when using the standard
3033 linker scripts, but don't create overlapping segments if
3034 someone is playing games with linker scripts. */
3036 for (i
= count
; i
-- != 0; )
3037 if (phdr
[i
].p_type
== PT_LOAD
)
3041 adjust
= -phdr
[i
].p_filesz
& 15;
3044 && phdr
[i
].p_offset
+ phdr
[i
].p_filesz
> last
->p_offset
- adjust
)
3047 adjust
= -phdr
[i
].p_memsz
& 15;
3050 && phdr
[i
].p_filesz
!= 0
3051 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
> last
->p_vaddr
- adjust
3052 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
<= last
->p_vaddr
)
3055 if (phdr
[i
].p_filesz
!= 0)
3059 if (i
== (unsigned int) -1)
3060 for (i
= count
; i
-- != 0; )
3061 if (phdr
[i
].p_type
== PT_LOAD
)
3065 adjust
= -phdr
[i
].p_filesz
& 15;
3066 phdr
[i
].p_filesz
+= adjust
;
3068 adjust
= -phdr
[i
].p_memsz
& 15;
3069 phdr
[i
].p_memsz
+= adjust
;
3075 /* Arrange for our linker created section to be output. */
3078 spu_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
3079 Elf_Internal_Shdr
*i_shdrp
)
3083 sec
= i_shdrp
->bfd_section
;
3085 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
3086 && sec
->name
!= NULL
3087 && strcmp (sec
->name
, SPU_PTNOTE_SPUNAME
) == 0)
3088 i_shdrp
->contents
= sec
->contents
;
3093 #define TARGET_BIG_SYM bfd_elf32_spu_vec
3094 #define TARGET_BIG_NAME "elf32-spu"
3095 #define ELF_ARCH bfd_arch_spu
3096 #define ELF_MACHINE_CODE EM_SPU
3097 /* This matches the alignment need for DMA. */
3098 #define ELF_MAXPAGESIZE 0x80
3099 #define elf_backend_rela_normal 1
3100 #define elf_backend_can_gc_sections 1
3102 #define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
3103 #define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
3104 #define elf_info_to_howto spu_elf_info_to_howto
3105 #define elf_backend_gc_mark_hook spu_elf_gc_mark_hook
3106 #define elf_backend_relocate_section spu_elf_relocate_section
3107 #define elf_backend_symbol_processing spu_elf_backend_symbol_processing
3108 #define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
3109 #define bfd_elf32_new_section_hook spu_elf_new_section_hook
3110 #define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
3111 #define bfd_elf32_bfd_link_hash_table_free spu_elf_link_hash_table_free
3113 #define elf_backend_additional_program_headers spu_elf_additional_program_headers
3114 #define elf_backend_modify_segment_map spu_elf_modify_segment_map
3115 #define elf_backend_modify_program_headers spu_elf_modify_program_headers
3116 #define elf_backend_post_process_headers spu_elf_post_process_headers
3117 #define elf_backend_section_processing spu_elf_section_processing
3118 #define elf_backend_special_sections spu_elf_special_sections
3119 #define bfd_elf32_bfd_final_link spu_elf_final_link
3121 #include "elf32-target.h"