1 /* SPU specific support for 32-bit ELF
3 Copyright 2006, 2007, 2008, 2009 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 3 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. */
22 #include "libiberty.h"
28 #include "elf32-spu.h"
30 /* We use RELA style relocs. Don't define USE_REL. */
32 static bfd_reloc_status_type
spu_elf_rel9 (bfd
*, arelent
*, asymbol
*,
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. */
39 static reloc_howto_type elf_howto_table
[] = {
40 HOWTO (R_SPU_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
41 bfd_elf_generic_reloc
, "SPU_NONE",
42 FALSE
, 0, 0x00000000, FALSE
),
43 HOWTO (R_SPU_ADDR10
, 4, 2, 10, FALSE
, 14, complain_overflow_bitfield
,
44 bfd_elf_generic_reloc
, "SPU_ADDR10",
45 FALSE
, 0, 0x00ffc000, FALSE
),
46 HOWTO (R_SPU_ADDR16
, 2, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
47 bfd_elf_generic_reloc
, "SPU_ADDR16",
48 FALSE
, 0, 0x007fff80, FALSE
),
49 HOWTO (R_SPU_ADDR16_HI
, 16, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
50 bfd_elf_generic_reloc
, "SPU_ADDR16_HI",
51 FALSE
, 0, 0x007fff80, FALSE
),
52 HOWTO (R_SPU_ADDR16_LO
, 0, 2, 16, FALSE
, 7, complain_overflow_dont
,
53 bfd_elf_generic_reloc
, "SPU_ADDR16_LO",
54 FALSE
, 0, 0x007fff80, FALSE
),
55 HOWTO (R_SPU_ADDR18
, 0, 2, 18, FALSE
, 7, complain_overflow_bitfield
,
56 bfd_elf_generic_reloc
, "SPU_ADDR18",
57 FALSE
, 0, 0x01ffff80, FALSE
),
58 HOWTO (R_SPU_ADDR32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "SPU_ADDR32",
60 FALSE
, 0, 0xffffffff, FALSE
),
61 HOWTO (R_SPU_REL16
, 2, 2, 16, TRUE
, 7, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "SPU_REL16",
63 FALSE
, 0, 0x007fff80, TRUE
),
64 HOWTO (R_SPU_ADDR7
, 0, 2, 7, FALSE
, 14, complain_overflow_dont
,
65 bfd_elf_generic_reloc
, "SPU_ADDR7",
66 FALSE
, 0, 0x001fc000, FALSE
),
67 HOWTO (R_SPU_REL9
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
68 spu_elf_rel9
, "SPU_REL9",
69 FALSE
, 0, 0x0180007f, TRUE
),
70 HOWTO (R_SPU_REL9I
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
71 spu_elf_rel9
, "SPU_REL9I",
72 FALSE
, 0, 0x0000c07f, TRUE
),
73 HOWTO (R_SPU_ADDR10I
, 0, 2, 10, FALSE
, 14, complain_overflow_signed
,
74 bfd_elf_generic_reloc
, "SPU_ADDR10I",
75 FALSE
, 0, 0x00ffc000, FALSE
),
76 HOWTO (R_SPU_ADDR16I
, 0, 2, 16, FALSE
, 7, complain_overflow_signed
,
77 bfd_elf_generic_reloc
, "SPU_ADDR16I",
78 FALSE
, 0, 0x007fff80, FALSE
),
79 HOWTO (R_SPU_REL32
, 0, 2, 32, TRUE
, 0, complain_overflow_dont
,
80 bfd_elf_generic_reloc
, "SPU_REL32",
81 FALSE
, 0, 0xffffffff, TRUE
),
82 HOWTO (R_SPU_ADDR16X
, 0, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "SPU_ADDR16X",
84 FALSE
, 0, 0x007fff80, FALSE
),
85 HOWTO (R_SPU_PPU32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
86 bfd_elf_generic_reloc
, "SPU_PPU32",
87 FALSE
, 0, 0xffffffff, FALSE
),
88 HOWTO (R_SPU_PPU64
, 0, 4, 64, FALSE
, 0, complain_overflow_dont
,
89 bfd_elf_generic_reloc
, "SPU_PPU64",
93 static struct bfd_elf_special_section
const spu_elf_special_sections
[] = {
94 { "._ea", 4, 0, SHT_PROGBITS
, SHF_WRITE
},
95 { ".toe", 4, 0, SHT_NOBITS
, SHF_ALLOC
},
99 static enum elf_spu_reloc_type
100 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code
)
106 case BFD_RELOC_SPU_IMM10W
:
108 case BFD_RELOC_SPU_IMM16W
:
110 case BFD_RELOC_SPU_LO16
:
111 return R_SPU_ADDR16_LO
;
112 case BFD_RELOC_SPU_HI16
:
113 return R_SPU_ADDR16_HI
;
114 case BFD_RELOC_SPU_IMM18
:
116 case BFD_RELOC_SPU_PCREL16
:
118 case BFD_RELOC_SPU_IMM7
:
120 case BFD_RELOC_SPU_IMM8
:
122 case BFD_RELOC_SPU_PCREL9a
:
124 case BFD_RELOC_SPU_PCREL9b
:
126 case BFD_RELOC_SPU_IMM10
:
127 return R_SPU_ADDR10I
;
128 case BFD_RELOC_SPU_IMM16
:
129 return R_SPU_ADDR16I
;
132 case BFD_RELOC_32_PCREL
:
134 case BFD_RELOC_SPU_PPU32
:
136 case BFD_RELOC_SPU_PPU64
:
142 spu_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
144 Elf_Internal_Rela
*dst
)
146 enum elf_spu_reloc_type r_type
;
148 r_type
= (enum elf_spu_reloc_type
) ELF32_R_TYPE (dst
->r_info
);
149 BFD_ASSERT (r_type
< R_SPU_max
);
150 cache_ptr
->howto
= &elf_howto_table
[(int) r_type
];
153 static reloc_howto_type
*
154 spu_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
155 bfd_reloc_code_real_type code
)
157 enum elf_spu_reloc_type r_type
= spu_elf_bfd_to_reloc_type (code
);
159 if (r_type
== R_SPU_NONE
)
162 return elf_howto_table
+ r_type
;
165 static reloc_howto_type
*
166 spu_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
171 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
172 if (elf_howto_table
[i
].name
!= NULL
173 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
174 return &elf_howto_table
[i
];
179 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
181 static bfd_reloc_status_type
182 spu_elf_rel9 (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
183 void *data
, asection
*input_section
,
184 bfd
*output_bfd
, char **error_message
)
186 bfd_size_type octets
;
190 /* If this is a relocatable link (output_bfd test tells us), just
191 call the generic function. Any adjustment will be done at final
193 if (output_bfd
!= NULL
)
194 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
195 input_section
, output_bfd
, error_message
);
197 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
198 return bfd_reloc_outofrange
;
199 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
201 /* Get symbol value. */
203 if (!bfd_is_com_section (symbol
->section
))
205 if (symbol
->section
->output_section
)
206 val
+= symbol
->section
->output_section
->vma
;
208 val
+= reloc_entry
->addend
;
210 /* Make it pc-relative. */
211 val
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
214 if (val
+ 256 >= 512)
215 return bfd_reloc_overflow
;
217 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
219 /* Move two high bits of value to REL9I and REL9 position.
220 The mask will take care of selecting the right field. */
221 val
= (val
& 0x7f) | ((val
& 0x180) << 7) | ((val
& 0x180) << 16);
222 insn
&= ~reloc_entry
->howto
->dst_mask
;
223 insn
|= val
& reloc_entry
->howto
->dst_mask
;
224 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
229 spu_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
231 if (!sec
->used_by_bfd
)
233 struct _spu_elf_section_data
*sdata
;
235 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
238 sec
->used_by_bfd
= sdata
;
241 return _bfd_elf_new_section_hook (abfd
, sec
);
244 /* Set up overlay info for executables. */
247 spu_elf_object_p (bfd
*abfd
)
249 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
251 unsigned int i
, num_ovl
, num_buf
;
252 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
253 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
254 Elf_Internal_Phdr
*last_phdr
= NULL
;
256 for (num_buf
= 0, num_ovl
= 0, i
= 0; i
< ehdr
->e_phnum
; i
++, phdr
++)
257 if (phdr
->p_type
== PT_LOAD
&& (phdr
->p_flags
& PF_OVERLAY
) != 0)
262 if (last_phdr
== NULL
263 || ((last_phdr
->p_vaddr
^ phdr
->p_vaddr
) & 0x3ffff) != 0)
266 for (j
= 1; j
< elf_numsections (abfd
); j
++)
268 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[j
];
270 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (shdr
, phdr
))
272 asection
*sec
= shdr
->bfd_section
;
273 spu_elf_section_data (sec
)->u
.o
.ovl_index
= num_ovl
;
274 spu_elf_section_data (sec
)->u
.o
.ovl_buf
= num_buf
;
282 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
283 strip --strip-unneeded will not remove them. */
286 spu_elf_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*sym
)
288 if (sym
->name
!= NULL
289 && sym
->section
!= bfd_abs_section_ptr
290 && strncmp (sym
->name
, "_EAR_", 5) == 0)
291 sym
->flags
|= BSF_KEEP
;
294 /* SPU ELF linker hash table. */
296 struct spu_link_hash_table
298 struct elf_link_hash_table elf
;
300 struct spu_elf_params
*params
;
302 /* Shortcuts to overlay sections. */
308 /* Count of stubs in each overlay section. */
309 unsigned int *stub_count
;
311 /* The stub section for each overlay section. */
314 struct elf_link_hash_entry
*ovly_entry
[2];
316 /* Number of overlay buffers. */
317 unsigned int num_buf
;
319 /* Total number of overlays. */
320 unsigned int num_overlays
;
322 /* For soft icache. */
323 unsigned int line_size_log2
;
324 unsigned int num_lines_log2
;
326 /* How much memory we have. */
327 unsigned int local_store
;
328 /* Local store --auto-overlay should reserve for non-overlay
329 functions and data. */
330 unsigned int overlay_fixed
;
331 /* Local store --auto-overlay should reserve for stack and heap. */
332 unsigned int reserved
;
333 /* If reserved is not specified, stack analysis will calculate a value
334 for the stack. This parameter adjusts that value to allow for
335 negative sp access (the ABI says 2000 bytes below sp are valid,
336 and the overlay manager uses some of this area). */
337 int extra_stack_space
;
338 /* Count of overlay stubs needed in non-overlay area. */
339 unsigned int non_ovly_stub
;
342 unsigned int stub_err
: 1;
345 /* Hijack the generic got fields for overlay stub accounting. */
349 struct got_entry
*next
;
358 #define spu_hash_table(p) \
359 ((struct spu_link_hash_table *) ((p)->hash))
363 struct function_info
*fun
;
364 struct call_info
*next
;
366 unsigned int max_depth
;
367 unsigned int is_tail
: 1;
368 unsigned int is_pasted
: 1;
369 unsigned int priority
: 13;
374 /* List of functions called. Also branches to hot/cold part of
376 struct call_info
*call_list
;
377 /* For hot/cold part of function, point to owner. */
378 struct function_info
*start
;
379 /* Symbol at start of function. */
381 Elf_Internal_Sym
*sym
;
382 struct elf_link_hash_entry
*h
;
384 /* Function section. */
387 /* Where last called from, and number of sections called from. */
388 asection
*last_caller
;
389 unsigned int call_count
;
390 /* Address range of (this part of) function. */
392 /* Offset where we found a store of lr, or -1 if none found. */
394 /* Offset where we found the stack adjustment insn. */
398 /* Distance from root of call tree. Tail and hot/cold branches
399 count as one deeper. We aren't counting stack frames here. */
401 /* Set if global symbol. */
402 unsigned int global
: 1;
403 /* Set if known to be start of function (as distinct from a hunk
404 in hot/cold section. */
405 unsigned int is_func
: 1;
406 /* Set if not a root node. */
407 unsigned int non_root
: 1;
408 /* Flags used during call tree traversal. It's cheaper to replicate
409 the visit flags than have one which needs clearing after a traversal. */
410 unsigned int visit1
: 1;
411 unsigned int visit2
: 1;
412 unsigned int marking
: 1;
413 unsigned int visit3
: 1;
414 unsigned int visit4
: 1;
415 unsigned int visit5
: 1;
416 unsigned int visit6
: 1;
417 unsigned int visit7
: 1;
420 struct spu_elf_stack_info
424 /* Variable size array describing functions, one per contiguous
425 address range belonging to a function. */
426 struct function_info fun
[1];
429 static struct function_info
*find_function (asection
*, bfd_vma
,
430 struct bfd_link_info
*);
432 /* Create a spu ELF linker hash table. */
434 static struct bfd_link_hash_table
*
435 spu_elf_link_hash_table_create (bfd
*abfd
)
437 struct spu_link_hash_table
*htab
;
439 htab
= bfd_malloc (sizeof (*htab
));
443 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
,
444 _bfd_elf_link_hash_newfunc
,
445 sizeof (struct elf_link_hash_entry
)))
451 memset (&htab
->ovtab
, 0,
452 sizeof (*htab
) - offsetof (struct spu_link_hash_table
, ovtab
));
454 htab
->elf
.init_got_refcount
.refcount
= 0;
455 htab
->elf
.init_got_refcount
.glist
= NULL
;
456 htab
->elf
.init_got_offset
.offset
= 0;
457 htab
->elf
.init_got_offset
.glist
= NULL
;
458 return &htab
->elf
.root
;
462 spu_elf_setup (struct bfd_link_info
*info
, struct spu_elf_params
*params
)
464 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
465 htab
->params
= params
;
466 htab
->line_size_log2
= bfd_log2 (htab
->params
->line_size
);
467 htab
->num_lines_log2
= bfd_log2 (htab
->params
->num_lines
);
470 /* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
471 to (hash, NULL) for global symbols, and (NULL, sym) for locals. Set
472 *SYMSECP to the symbol's section. *LOCSYMSP caches local syms. */
475 get_sym_h (struct elf_link_hash_entry
**hp
,
476 Elf_Internal_Sym
**symp
,
478 Elf_Internal_Sym
**locsymsp
,
479 unsigned long r_symndx
,
482 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
484 if (r_symndx
>= symtab_hdr
->sh_info
)
486 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
487 struct elf_link_hash_entry
*h
;
489 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
490 while (h
->root
.type
== bfd_link_hash_indirect
491 || h
->root
.type
== bfd_link_hash_warning
)
492 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
502 asection
*symsec
= NULL
;
503 if (h
->root
.type
== bfd_link_hash_defined
504 || h
->root
.type
== bfd_link_hash_defweak
)
505 symsec
= h
->root
.u
.def
.section
;
511 Elf_Internal_Sym
*sym
;
512 Elf_Internal_Sym
*locsyms
= *locsymsp
;
516 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
518 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
520 0, NULL
, NULL
, NULL
);
525 sym
= locsyms
+ r_symndx
;
534 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
540 /* Create the note section if not already present. This is done early so
541 that the linker maps the sections to the right place in the output. */
544 spu_elf_create_sections (struct bfd_link_info
*info
)
548 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
549 if (bfd_get_section_by_name (ibfd
, SPU_PTNOTE_SPUNAME
) != NULL
)
554 /* Make SPU_PTNOTE_SPUNAME section. */
561 ibfd
= info
->input_bfds
;
562 flags
= SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
563 s
= bfd_make_section_anyway_with_flags (ibfd
, SPU_PTNOTE_SPUNAME
, flags
);
565 || !bfd_set_section_alignment (ibfd
, s
, 4))
568 name_len
= strlen (bfd_get_filename (info
->output_bfd
)) + 1;
569 size
= 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4);
570 size
+= (name_len
+ 3) & -4;
572 if (!bfd_set_section_size (ibfd
, s
, size
))
575 data
= bfd_zalloc (ibfd
, size
);
579 bfd_put_32 (ibfd
, sizeof (SPU_PLUGIN_NAME
), data
+ 0);
580 bfd_put_32 (ibfd
, name_len
, data
+ 4);
581 bfd_put_32 (ibfd
, 1, data
+ 8);
582 memcpy (data
+ 12, SPU_PLUGIN_NAME
, sizeof (SPU_PLUGIN_NAME
));
583 memcpy (data
+ 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4),
584 bfd_get_filename (info
->output_bfd
), name_len
);
591 /* qsort predicate to sort sections by vma. */
594 sort_sections (const void *a
, const void *b
)
596 const asection
*const *s1
= a
;
597 const asection
*const *s2
= b
;
598 bfd_signed_vma delta
= (*s1
)->vma
- (*s2
)->vma
;
601 return delta
< 0 ? -1 : 1;
603 return (*s1
)->index
- (*s2
)->index
;
606 /* Identify overlays in the output bfd, and number them.
607 Returns 0 on error, 1 if no overlays, 2 if overlays. */
610 spu_elf_find_overlays (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
;
617 static const char *const entry_names
[2][2] = {
618 { "__ovly_load", "__icache_br_handler" },
619 { "__ovly_return", "__icache_call_handler" }
622 if (info
->output_bfd
->section_count
< 2)
626 = bfd_malloc (info
->output_bfd
->section_count
* sizeof (*alloc_sec
));
627 if (alloc_sec
== NULL
)
630 /* Pick out all the alloced sections. */
631 for (n
= 0, s
= info
->output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
632 if ((s
->flags
& SEC_ALLOC
) != 0
633 && (s
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != SEC_THREAD_LOCAL
643 /* Sort them by vma. */
644 qsort (alloc_sec
, n
, sizeof (*alloc_sec
), sort_sections
);
646 ovl_end
= alloc_sec
[0]->vma
+ alloc_sec
[0]->size
;
647 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
649 /* Look for an overlapping vma to find the first overlay section. */
650 bfd_vma vma_start
= 0;
651 bfd_vma lma_start
= 0;
653 for (i
= 1; i
< n
; i
++)
656 if (s
->vma
< ovl_end
)
658 asection
*s0
= alloc_sec
[i
- 1];
663 << (htab
->num_lines_log2
+ htab
->line_size_log2
)));
668 ovl_end
= s
->vma
+ s
->size
;
671 /* Now find any sections within the cache area. */
672 for (ovl_index
= 0, num_buf
= 0; i
< n
; i
++)
675 if (s
->vma
>= ovl_end
)
678 /* A section in an overlay area called .ovl.init is not
679 an overlay, in the sense that it might be loaded in
680 by the overlay manager, but rather the initial
681 section contents for the overlay buffer. */
682 if (strncmp (s
->name
, ".ovl.init", 9) != 0)
684 num_buf
= ((s
->vma
- vma_start
) >> htab
->line_size_log2
) + 1;
685 if (((s
->vma
- vma_start
) & (htab
->params
->line_size
- 1))
686 || ((s
->lma
- lma_start
) & (htab
->params
->line_size
- 1)))
688 info
->callbacks
->einfo (_("%X%P: overlay section %A "
689 "does not start on a cache line.\n"),
691 bfd_set_error (bfd_error_bad_value
);
694 else if (s
->size
> htab
->params
->line_size
)
696 info
->callbacks
->einfo (_("%X%P: overlay section %A "
697 "is larger than a cache line.\n"),
699 bfd_set_error (bfd_error_bad_value
);
703 alloc_sec
[ovl_index
++] = s
;
704 spu_elf_section_data (s
)->u
.o
.ovl_index
705 = ((s
->lma
- lma_start
) >> htab
->line_size_log2
) + 1;
706 spu_elf_section_data (s
)->u
.o
.ovl_buf
= num_buf
;
710 /* Ensure there are no more overlay sections. */
714 if (s
->vma
< ovl_end
)
716 info
->callbacks
->einfo (_("%X%P: overlay section %A "
717 "is not in cache area.\n"),
719 bfd_set_error (bfd_error_bad_value
);
723 ovl_end
= s
->vma
+ s
->size
;
728 /* Look for overlapping vmas. Any with overlap must be overlays.
729 Count them. Also count the number of overlay regions. */
730 for (ovl_index
= 0, num_buf
= 0, i
= 1; i
< n
; i
++)
733 if (s
->vma
< ovl_end
)
735 asection
*s0
= alloc_sec
[i
- 1];
737 if (spu_elf_section_data (s0
)->u
.o
.ovl_index
== 0)
740 if (strncmp (s0
->name
, ".ovl.init", 9) != 0)
742 alloc_sec
[ovl_index
] = s0
;
743 spu_elf_section_data (s0
)->u
.o
.ovl_index
= ++ovl_index
;
744 spu_elf_section_data (s0
)->u
.o
.ovl_buf
= num_buf
;
747 ovl_end
= s
->vma
+ s
->size
;
749 if (strncmp (s
->name
, ".ovl.init", 9) != 0)
751 alloc_sec
[ovl_index
] = s
;
752 spu_elf_section_data (s
)->u
.o
.ovl_index
= ++ovl_index
;
753 spu_elf_section_data (s
)->u
.o
.ovl_buf
= num_buf
;
754 if (s0
->vma
!= s
->vma
)
756 info
->callbacks
->einfo (_("%X%P: overlay sections %A "
757 "and %A do not start at the "
760 bfd_set_error (bfd_error_bad_value
);
763 if (ovl_end
< s
->vma
+ s
->size
)
764 ovl_end
= s
->vma
+ s
->size
;
768 ovl_end
= s
->vma
+ s
->size
;
772 htab
->num_overlays
= ovl_index
;
773 htab
->num_buf
= num_buf
;
774 htab
->ovl_sec
= alloc_sec
;
779 for (i
= 0; i
< 2; i
++)
782 struct elf_link_hash_entry
*h
;
784 name
= entry_names
[i
][htab
->params
->ovly_flavour
];
785 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
789 if (h
->root
.type
== bfd_link_hash_new
)
791 h
->root
.type
= bfd_link_hash_undefined
;
793 h
->ref_regular_nonweak
= 1;
796 htab
->ovly_entry
[i
] = h
;
802 /* Non-zero to use bra in overlay stubs rather than br. */
805 #define BRA 0x30000000
806 #define BRASL 0x31000000
807 #define BR 0x32000000
808 #define BRSL 0x33000000
809 #define NOP 0x40200000
810 #define LNOP 0x00200000
811 #define ILA 0x42000000
813 /* Return true for all relative and absolute branch instructions.
821 brhnz 00100011 0.. */
824 is_branch (const unsigned char *insn
)
826 return (insn
[0] & 0xec) == 0x20 && (insn
[1] & 0x80) == 0;
829 /* Return true for all indirect branch instructions.
837 bihnz 00100101 011 */
840 is_indirect_branch (const unsigned char *insn
)
842 return (insn
[0] & 0xef) == 0x25 && (insn
[1] & 0x80) == 0;
845 /* Return true for branch hint instructions.
850 is_hint (const unsigned char *insn
)
852 return (insn
[0] & 0xfc) == 0x10;
855 /* True if INPUT_SECTION might need overlay stubs. */
858 maybe_needs_stubs (asection
*input_section
)
860 /* No stubs for debug sections and suchlike. */
861 if ((input_section
->flags
& SEC_ALLOC
) == 0)
864 /* No stubs for link-once sections that will be discarded. */
865 if (input_section
->output_section
== bfd_abs_section_ptr
)
868 /* Don't create stubs for .eh_frame references. */
869 if (strcmp (input_section
->name
, ".eh_frame") == 0)
891 /* Return non-zero if this reloc symbol should go via an overlay stub.
892 Return 2 if the stub must be in non-overlay area. */
894 static enum _stub_type
895 needs_ovl_stub (struct elf_link_hash_entry
*h
,
896 Elf_Internal_Sym
*sym
,
898 asection
*input_section
,
899 Elf_Internal_Rela
*irela
,
901 struct bfd_link_info
*info
)
903 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
904 enum elf_spu_reloc_type r_type
;
905 unsigned int sym_type
;
906 bfd_boolean branch
, hint
, call
;
907 enum _stub_type ret
= no_stub
;
911 || sym_sec
->output_section
== bfd_abs_section_ptr
912 || spu_elf_section_data (sym_sec
->output_section
) == NULL
)
917 /* Ensure no stubs for user supplied overlay manager syms. */
918 if (h
== htab
->ovly_entry
[0] || h
== htab
->ovly_entry
[1])
921 /* setjmp always goes via an overlay stub, because then the return
922 and hence the longjmp goes via __ovly_return. That magically
923 makes setjmp/longjmp between overlays work. */
924 if (strncmp (h
->root
.root
.string
, "setjmp", 6) == 0
925 && (h
->root
.root
.string
[6] == '\0' || h
->root
.root
.string
[6] == '@'))
932 sym_type
= ELF_ST_TYPE (sym
->st_info
);
934 r_type
= ELF32_R_TYPE (irela
->r_info
);
938 if (r_type
== R_SPU_REL16
|| r_type
== R_SPU_ADDR16
)
940 if (contents
== NULL
)
943 if (!bfd_get_section_contents (input_section
->owner
,
950 contents
+= irela
->r_offset
;
952 branch
= is_branch (contents
);
953 hint
= is_hint (contents
);
956 call
= (contents
[0] & 0xfd) == 0x31;
958 && sym_type
!= STT_FUNC
961 /* It's common for people to write assembly and forget
962 to give function symbols the right type. Handle
963 calls to such symbols, but warn so that (hopefully)
964 people will fix their code. We need the symbol
965 type to be correct to distinguish function pointer
966 initialisation from other pointer initialisations. */
967 const char *sym_name
;
970 sym_name
= h
->root
.root
.string
;
973 Elf_Internal_Shdr
*symtab_hdr
;
974 symtab_hdr
= &elf_tdata (input_section
->owner
)->symtab_hdr
;
975 sym_name
= bfd_elf_sym_name (input_section
->owner
,
980 (*_bfd_error_handler
) (_("warning: call to non-function"
981 " symbol %s defined in %B"),
982 sym_sec
->owner
, sym_name
);
988 if ((!branch
&& htab
->params
->ovly_flavour
== ovly_soft_icache
)
989 || (sym_type
!= STT_FUNC
991 && (sym_sec
->flags
& SEC_CODE
) == 0))
994 /* Usually, symbols in non-overlay sections don't need stubs. */
995 if (spu_elf_section_data (sym_sec
->output_section
)->u
.o
.ovl_index
== 0
996 && !htab
->params
->non_overlay_stubs
)
999 /* A reference from some other section to a symbol in an overlay
1000 section needs a stub. */
1001 if (spu_elf_section_data (sym_sec
->output_section
)->u
.o
.ovl_index
1002 != spu_elf_section_data (input_section
->output_section
)->u
.o
.ovl_index
)
1004 if (call
|| sym_type
== STT_FUNC
)
1005 ret
= call_ovl_stub
;
1008 ret
= br000_ovl_stub
;
1012 unsigned int lrlive
= (contents
[1] & 0x70) >> 4;
1018 /* If this insn isn't a branch then we are possibly taking the
1019 address of a function and passing it out somehow. Soft-icache code
1020 always generates inline code to do indirect branches. */
1021 if (!(branch
|| hint
)
1022 && sym_type
== STT_FUNC
1023 && htab
->params
->ovly_flavour
!= ovly_soft_icache
)
1030 count_stub (struct spu_link_hash_table
*htab
,
1033 enum _stub_type stub_type
,
1034 struct elf_link_hash_entry
*h
,
1035 const Elf_Internal_Rela
*irela
)
1037 unsigned int ovl
= 0;
1038 struct got_entry
*g
, **head
;
1041 /* If this instruction is a branch or call, we need a stub
1042 for it. One stub per function per overlay.
1043 If it isn't a branch, then we are taking the address of
1044 this function so need a stub in the non-overlay area
1045 for it. One stub per function. */
1046 if (stub_type
!= nonovl_stub
)
1047 ovl
= spu_elf_section_data (isec
->output_section
)->u
.o
.ovl_index
;
1050 head
= &h
->got
.glist
;
1053 if (elf_local_got_ents (ibfd
) == NULL
)
1055 bfd_size_type amt
= (elf_tdata (ibfd
)->symtab_hdr
.sh_info
1056 * sizeof (*elf_local_got_ents (ibfd
)));
1057 elf_local_got_ents (ibfd
) = bfd_zmalloc (amt
);
1058 if (elf_local_got_ents (ibfd
) == NULL
)
1061 head
= elf_local_got_ents (ibfd
) + ELF32_R_SYM (irela
->r_info
);
1064 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1066 htab
->stub_count
[ovl
] += 1;
1072 addend
= irela
->r_addend
;
1076 struct got_entry
*gnext
;
1078 for (g
= *head
; g
!= NULL
; g
= g
->next
)
1079 if (g
->addend
== addend
&& g
->ovl
== 0)
1084 /* Need a new non-overlay area stub. Zap other stubs. */
1085 for (g
= *head
; g
!= NULL
; g
= gnext
)
1088 if (g
->addend
== addend
)
1090 htab
->stub_count
[g
->ovl
] -= 1;
1098 for (g
= *head
; g
!= NULL
; g
= g
->next
)
1099 if (g
->addend
== addend
&& (g
->ovl
== ovl
|| g
->ovl
== 0))
1105 g
= bfd_malloc (sizeof *g
);
1110 g
->stub_addr
= (bfd_vma
) -1;
1114 htab
->stub_count
[ovl
] += 1;
1120 /* Support two sizes of overlay stubs, a slower more compact stub of two
1121 intructions, and a faster stub of four instructions.
1122 Soft-icache stubs are four or eight words. */
1125 ovl_stub_size (struct spu_elf_params
*params
)
1127 return 16 << params
->ovly_flavour
>> params
->compact_stub
;
1131 ovl_stub_size_log2 (struct spu_elf_params
*params
)
1133 return 4 + params
->ovly_flavour
- params
->compact_stub
;
1136 /* Two instruction overlay stubs look like:
1138 brsl $75,__ovly_load
1139 .word target_ovl_and_address
1141 ovl_and_address is a word with the overlay number in the top 14 bits
1142 and local store address in the bottom 18 bits.
1144 Four instruction overlay stubs look like:
1148 ila $79,target_address
1151 Software icache stubs are:
1155 .word lrlive_branchlocalstoreaddr;
1156 brasl $75,__icache_br_handler
1161 build_stub (struct bfd_link_info
*info
,
1164 enum _stub_type stub_type
,
1165 struct elf_link_hash_entry
*h
,
1166 const Elf_Internal_Rela
*irela
,
1170 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1171 unsigned int ovl
, dest_ovl
, set_id
;
1172 struct got_entry
*g
, **head
;
1174 bfd_vma addend
, from
, to
, br_dest
, patt
;
1175 unsigned int lrlive
;
1178 if (stub_type
!= nonovl_stub
)
1179 ovl
= spu_elf_section_data (isec
->output_section
)->u
.o
.ovl_index
;
1182 head
= &h
->got
.glist
;
1184 head
= elf_local_got_ents (ibfd
) + ELF32_R_SYM (irela
->r_info
);
1188 addend
= irela
->r_addend
;
1190 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1192 g
= bfd_malloc (sizeof *g
);
1198 g
->br_addr
= (irela
->r_offset
1199 + isec
->output_offset
1200 + isec
->output_section
->vma
);
1206 for (g
= *head
; g
!= NULL
; g
= g
->next
)
1207 if (g
->addend
== addend
&& (g
->ovl
== ovl
|| g
->ovl
== 0))
1212 if (g
->ovl
== 0 && ovl
!= 0)
1215 if (g
->stub_addr
!= (bfd_vma
) -1)
1219 sec
= htab
->stub_sec
[ovl
];
1220 dest
+= dest_sec
->output_offset
+ dest_sec
->output_section
->vma
;
1221 from
= sec
->size
+ sec
->output_offset
+ sec
->output_section
->vma
;
1222 g
->stub_addr
= from
;
1223 to
= (htab
->ovly_entry
[0]->root
.u
.def
.value
1224 + htab
->ovly_entry
[0]->root
.u
.def
.section
->output_offset
1225 + htab
->ovly_entry
[0]->root
.u
.def
.section
->output_section
->vma
);
1227 if (((dest
| to
| from
) & 3) != 0)
1232 dest_ovl
= spu_elf_section_data (dest_sec
->output_section
)->u
.o
.ovl_index
;
1234 if (htab
->params
->ovly_flavour
== ovly_normal
1235 && !htab
->params
->compact_stub
)
1237 bfd_put_32 (sec
->owner
, ILA
+ ((dest_ovl
<< 7) & 0x01ffff80) + 78,
1238 sec
->contents
+ sec
->size
);
1239 bfd_put_32 (sec
->owner
, LNOP
,
1240 sec
->contents
+ sec
->size
+ 4);
1241 bfd_put_32 (sec
->owner
, ILA
+ ((dest
<< 7) & 0x01ffff80) + 79,
1242 sec
->contents
+ sec
->size
+ 8);
1244 bfd_put_32 (sec
->owner
, BR
+ (((to
- (from
+ 12)) << 5) & 0x007fff80),
1245 sec
->contents
+ sec
->size
+ 12);
1247 bfd_put_32 (sec
->owner
, BRA
+ ((to
<< 5) & 0x007fff80),
1248 sec
->contents
+ sec
->size
+ 12);
1250 else if (htab
->params
->ovly_flavour
== ovly_normal
1251 && htab
->params
->compact_stub
)
1254 bfd_put_32 (sec
->owner
, BRSL
+ (((to
- from
) << 5) & 0x007fff80) + 75,
1255 sec
->contents
+ sec
->size
);
1257 bfd_put_32 (sec
->owner
, BRASL
+ ((to
<< 5) & 0x007fff80) + 75,
1258 sec
->contents
+ sec
->size
);
1259 bfd_put_32 (sec
->owner
, (dest
& 0x3ffff) | (dest_ovl
<< 18),
1260 sec
->contents
+ sec
->size
+ 4);
1262 else if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1265 if (stub_type
== nonovl_stub
)
1267 else if (stub_type
== call_ovl_stub
)
1268 /* A brsl makes lr live and *(*sp+16) is live.
1269 Tail calls have the same liveness. */
1271 else if (!htab
->params
->lrlive_analysis
)
1272 /* Assume stack frame and lr save. */
1274 else if (irela
!= NULL
)
1276 /* Analyse branch instructions. */
1277 struct function_info
*caller
;
1280 caller
= find_function (isec
, irela
->r_offset
, info
);
1281 if (caller
->start
== NULL
)
1282 off
= irela
->r_offset
;
1285 struct function_info
*found
= NULL
;
1287 /* Find the earliest piece of this function that
1288 has frame adjusting instructions. We might
1289 see dynamic frame adjustment (eg. for alloca)
1290 in some later piece, but functions using
1291 alloca always set up a frame earlier. Frame
1292 setup instructions are always in one piece. */
1293 if (caller
->lr_store
!= (bfd_vma
) -1
1294 || caller
->sp_adjust
!= (bfd_vma
) -1)
1296 while (caller
->start
!= NULL
)
1298 caller
= caller
->start
;
1299 if (caller
->lr_store
!= (bfd_vma
) -1
1300 || caller
->sp_adjust
!= (bfd_vma
) -1)
1308 if (off
> caller
->sp_adjust
)
1310 if (off
> caller
->lr_store
)
1311 /* Only *(*sp+16) is live. */
1314 /* If no lr save, then we must be in a
1315 leaf function with a frame.
1316 lr is still live. */
1319 else if (off
> caller
->lr_store
)
1321 /* Between lr save and stack adjust. */
1323 /* This should never happen since prologues won't
1328 /* On entry to function. */
1331 if (stub_type
!= br000_ovl_stub
1332 && lrlive
!= stub_type
- br000_ovl_stub
)
1333 info
->callbacks
->einfo (_("%A:0x%v lrlive .brinfo (%u) differs "
1334 "from analysis (%u)\n"),
1335 isec
, irela
->r_offset
, lrlive
,
1336 stub_type
- br000_ovl_stub
);
1339 /* If given lrlive info via .brinfo, use it. */
1340 if (stub_type
> br000_ovl_stub
)
1341 lrlive
= stub_type
- br000_ovl_stub
;
1344 to
= (htab
->ovly_entry
[1]->root
.u
.def
.value
1345 + htab
->ovly_entry
[1]->root
.u
.def
.section
->output_offset
1346 + htab
->ovly_entry
[1]->root
.u
.def
.section
->output_section
->vma
);
1348 if (!htab
->params
->compact_stub
)
1350 /* The branch that uses this stub goes to stub_addr + 12. We'll
1351 set up an xor pattern that can be used by the icache manager
1352 to modify this branch to go directly to its destination. */
1354 br_dest
= g
->stub_addr
;
1357 /* Except in the case of _SPUEAR_ stubs, the branch in
1358 question is the one in the stub itself. */
1359 BFD_ASSERT (stub_type
== nonovl_stub
);
1360 g
->br_addr
= g
->stub_addr
;
1364 bfd_put_32 (sec
->owner
, dest_ovl
- 1,
1365 sec
->contents
+ sec
->size
+ 0);
1366 set_id
= ((dest_ovl
- 1) >> htab
->num_lines_log2
) + 1;
1367 bfd_put_32 (sec
->owner
, (set_id
<< 18) | (dest
& 0x3ffff),
1368 sec
->contents
+ sec
->size
+ 4);
1369 bfd_put_32 (sec
->owner
, (lrlive
<< 29) | (g
->br_addr
& 0x3ffff),
1370 sec
->contents
+ sec
->size
+ 8);
1371 bfd_put_32 (sec
->owner
, BRASL
+ ((to
<< 5) & 0x007fff80) + 75,
1372 sec
->contents
+ sec
->size
+ 12);
1373 patt
= dest
^ br_dest
;
1374 if (irela
!= NULL
&& ELF32_R_TYPE (irela
->r_info
) == R_SPU_REL16
)
1375 patt
= (dest
- g
->br_addr
) ^ (br_dest
- g
->br_addr
);
1376 bfd_put_32 (sec
->owner
, (patt
<< 5) & 0x007fff80,
1377 sec
->contents
+ sec
->size
+ 16 + (g
->br_addr
& 0xf));
1382 br_dest
= g
->stub_addr
;
1385 BFD_ASSERT (stub_type
== nonovl_stub
);
1386 g
->br_addr
= g
->stub_addr
;
1390 set_id
= ((dest_ovl
- 1) >> htab
->num_lines_log2
) + 1;
1391 bfd_put_32 (sec
->owner
, (set_id
<< 18) | (dest
& 0x3ffff),
1392 sec
->contents
+ sec
->size
);
1393 bfd_put_32 (sec
->owner
, BRASL
+ ((to
<< 5) & 0x007fff80) + 75,
1394 sec
->contents
+ sec
->size
+ 4);
1395 bfd_put_32 (sec
->owner
, (lrlive
<< 29) | (g
->br_addr
& 0x3ffff),
1396 sec
->contents
+ sec
->size
+ 8);
1397 patt
= dest
^ br_dest
;
1398 if (irela
!= NULL
&& ELF32_R_TYPE (irela
->r_info
) == R_SPU_REL16
)
1399 patt
= (dest
- g
->br_addr
) ^ (br_dest
- g
->br_addr
);
1400 bfd_put_32 (sec
->owner
, (patt
<< 5) & 0x007fff80,
1401 sec
->contents
+ sec
->size
+ 12);
1405 /* Extra space for linked list entries. */
1411 sec
->size
+= ovl_stub_size (htab
->params
);
1413 if (htab
->params
->emit_stub_syms
)
1419 len
= 8 + sizeof (".ovl_call.") - 1;
1421 len
+= strlen (h
->root
.root
.string
);
1426 add
= (int) irela
->r_addend
& 0xffffffff;
1429 name
= bfd_malloc (len
);
1433 sprintf (name
, "%08x.ovl_call.", g
->ovl
);
1435 strcpy (name
+ 8 + sizeof (".ovl_call.") - 1, h
->root
.root
.string
);
1437 sprintf (name
+ 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1438 dest_sec
->id
& 0xffffffff,
1439 (int) ELF32_R_SYM (irela
->r_info
) & 0xffffffff);
1441 sprintf (name
+ len
- 9, "+%x", add
);
1443 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, TRUE
, FALSE
);
1447 if (h
->root
.type
== bfd_link_hash_new
)
1449 h
->root
.type
= bfd_link_hash_defined
;
1450 h
->root
.u
.def
.section
= sec
;
1451 h
->size
= ovl_stub_size (htab
->params
);
1452 h
->root
.u
.def
.value
= sec
->size
- h
->size
;
1456 h
->ref_regular_nonweak
= 1;
1457 h
->forced_local
= 1;
1465 /* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1469 allocate_spuear_stubs (struct elf_link_hash_entry
*h
, void *inf
)
1471 /* Symbols starting with _SPUEAR_ need a stub because they may be
1472 invoked by the PPU. */
1473 struct bfd_link_info
*info
= inf
;
1474 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1477 if ((h
->root
.type
== bfd_link_hash_defined
1478 || h
->root
.type
== bfd_link_hash_defweak
)
1480 && strncmp (h
->root
.root
.string
, "_SPUEAR_", 8) == 0
1481 && (sym_sec
= h
->root
.u
.def
.section
) != NULL
1482 && sym_sec
->output_section
!= bfd_abs_section_ptr
1483 && spu_elf_section_data (sym_sec
->output_section
) != NULL
1484 && (spu_elf_section_data (sym_sec
->output_section
)->u
.o
.ovl_index
!= 0
1485 || htab
->params
->non_overlay_stubs
))
1487 return count_stub (htab
, NULL
, NULL
, nonovl_stub
, h
, NULL
);
1494 build_spuear_stubs (struct elf_link_hash_entry
*h
, void *inf
)
1496 /* Symbols starting with _SPUEAR_ need a stub because they may be
1497 invoked by the PPU. */
1498 struct bfd_link_info
*info
= inf
;
1499 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1502 if ((h
->root
.type
== bfd_link_hash_defined
1503 || h
->root
.type
== bfd_link_hash_defweak
)
1505 && strncmp (h
->root
.root
.string
, "_SPUEAR_", 8) == 0
1506 && (sym_sec
= h
->root
.u
.def
.section
) != NULL
1507 && sym_sec
->output_section
!= bfd_abs_section_ptr
1508 && spu_elf_section_data (sym_sec
->output_section
) != NULL
1509 && (spu_elf_section_data (sym_sec
->output_section
)->u
.o
.ovl_index
!= 0
1510 || htab
->params
->non_overlay_stubs
))
1512 return build_stub (info
, NULL
, NULL
, nonovl_stub
, h
, NULL
,
1513 h
->root
.u
.def
.value
, sym_sec
);
1519 /* Size or build stubs. */
1522 process_stubs (struct bfd_link_info
*info
, bfd_boolean build
)
1524 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1527 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1529 extern const bfd_target bfd_elf32_spu_vec
;
1530 Elf_Internal_Shdr
*symtab_hdr
;
1532 Elf_Internal_Sym
*local_syms
= NULL
;
1534 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
1537 /* We'll need the symbol table in a second. */
1538 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1539 if (symtab_hdr
->sh_info
== 0)
1542 /* Walk over each section attached to the input bfd. */
1543 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
1545 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
1547 /* If there aren't any relocs, then there's nothing more to do. */
1548 if ((isec
->flags
& SEC_RELOC
) == 0
1549 || isec
->reloc_count
== 0)
1552 if (!maybe_needs_stubs (isec
))
1555 /* Get the relocs. */
1556 internal_relocs
= _bfd_elf_link_read_relocs (ibfd
, isec
, NULL
, NULL
,
1558 if (internal_relocs
== NULL
)
1559 goto error_ret_free_local
;
1561 /* Now examine each relocation. */
1562 irela
= internal_relocs
;
1563 irelaend
= irela
+ isec
->reloc_count
;
1564 for (; irela
< irelaend
; irela
++)
1566 enum elf_spu_reloc_type r_type
;
1567 unsigned int r_indx
;
1569 Elf_Internal_Sym
*sym
;
1570 struct elf_link_hash_entry
*h
;
1571 enum _stub_type stub_type
;
1573 r_type
= ELF32_R_TYPE (irela
->r_info
);
1574 r_indx
= ELF32_R_SYM (irela
->r_info
);
1576 if (r_type
>= R_SPU_max
)
1578 bfd_set_error (bfd_error_bad_value
);
1579 error_ret_free_internal
:
1580 if (elf_section_data (isec
)->relocs
!= internal_relocs
)
1581 free (internal_relocs
);
1582 error_ret_free_local
:
1583 if (local_syms
!= NULL
1584 && (symtab_hdr
->contents
1585 != (unsigned char *) local_syms
))
1590 /* Determine the reloc target section. */
1591 if (!get_sym_h (&h
, &sym
, &sym_sec
, &local_syms
, r_indx
, ibfd
))
1592 goto error_ret_free_internal
;
1594 stub_type
= needs_ovl_stub (h
, sym
, sym_sec
, isec
, irela
,
1596 if (stub_type
== no_stub
)
1598 else if (stub_type
== stub_error
)
1599 goto error_ret_free_internal
;
1601 if (htab
->stub_count
== NULL
)
1604 amt
= (htab
->num_overlays
+ 1) * sizeof (*htab
->stub_count
);
1605 htab
->stub_count
= bfd_zmalloc (amt
);
1606 if (htab
->stub_count
== NULL
)
1607 goto error_ret_free_internal
;
1612 if (!count_stub (htab
, ibfd
, isec
, stub_type
, h
, irela
))
1613 goto error_ret_free_internal
;
1620 dest
= h
->root
.u
.def
.value
;
1622 dest
= sym
->st_value
;
1623 dest
+= irela
->r_addend
;
1624 if (!build_stub (info
, ibfd
, isec
, stub_type
, h
, irela
,
1626 goto error_ret_free_internal
;
1630 /* We're done with the internal relocs, free them. */
1631 if (elf_section_data (isec
)->relocs
!= internal_relocs
)
1632 free (internal_relocs
);
1635 if (local_syms
!= NULL
1636 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
1638 if (!info
->keep_memory
)
1641 symtab_hdr
->contents
= (unsigned char *) local_syms
;
1648 /* Allocate space for overlay call and return stubs.
1649 Return 0 on error, 1 if no stubs, 2 otherwise. */
1652 spu_elf_size_stubs (struct bfd_link_info
*info
)
1654 struct spu_link_hash_table
*htab
;
1662 if (!process_stubs (info
, FALSE
))
1665 htab
= spu_hash_table (info
);
1666 elf_link_hash_traverse (&htab
->elf
, allocate_spuear_stubs
, info
);
1670 if (htab
->stub_count
== NULL
)
1673 ibfd
= info
->input_bfds
;
1674 amt
= (htab
->num_overlays
+ 1) * sizeof (*htab
->stub_sec
);
1675 htab
->stub_sec
= bfd_zmalloc (amt
);
1676 if (htab
->stub_sec
== NULL
)
1679 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
1680 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
1681 stub
= bfd_make_section_anyway_with_flags (ibfd
, ".stub", flags
);
1682 htab
->stub_sec
[0] = stub
;
1684 || !bfd_set_section_alignment (ibfd
, stub
,
1685 ovl_stub_size_log2 (htab
->params
)))
1687 stub
->size
= htab
->stub_count
[0] * ovl_stub_size (htab
->params
);
1688 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1689 /* Extra space for linked list entries. */
1690 stub
->size
+= htab
->stub_count
[0] * 16;
1691 (*htab
->params
->place_spu_section
) (stub
, NULL
, ".text");
1693 for (i
= 0; i
< htab
->num_overlays
; ++i
)
1695 asection
*osec
= htab
->ovl_sec
[i
];
1696 unsigned int ovl
= spu_elf_section_data (osec
)->u
.o
.ovl_index
;
1697 stub
= bfd_make_section_anyway_with_flags (ibfd
, ".stub", flags
);
1698 htab
->stub_sec
[ovl
] = stub
;
1700 || !bfd_set_section_alignment (ibfd
, stub
,
1701 ovl_stub_size_log2 (htab
->params
)))
1703 stub
->size
= htab
->stub_count
[ovl
] * ovl_stub_size (htab
->params
);
1704 (*htab
->params
->place_spu_section
) (stub
, osec
, NULL
);
1707 flags
= (SEC_ALLOC
| SEC_LOAD
1708 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
1709 htab
->ovtab
= bfd_make_section_anyway_with_flags (ibfd
, ".ovtab", flags
);
1710 if (htab
->ovtab
== NULL
1711 || !bfd_set_section_alignment (ibfd
, htab
->ovtab
, 4))
1714 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1716 /* Space for icache manager tables.
1717 a) Tag array, one quadword per cache line.
1718 b) Linked list elements, max_branch per line quadwords. */
1719 htab
->ovtab
->size
= 16 * ((1 + htab
->params
->max_branch
)
1720 << htab
->num_lines_log2
);
1722 htab
->init
= bfd_make_section_anyway_with_flags (ibfd
, ".ovini", flags
);
1723 if (htab
->init
== NULL
1724 || !bfd_set_section_alignment (ibfd
, htab
->init
, 4))
1727 htab
->init
->size
= 16;
1728 (*htab
->params
->place_spu_section
) (htab
->init
, NULL
, ".ovl.init");
1732 /* htab->ovtab consists of two arrays.
1742 . } _ovly_buf_table[];
1745 htab
->ovtab
->size
= htab
->num_overlays
* 16 + 16 + htab
->num_buf
* 4;
1748 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1749 ovout
= ".data.icache";
1750 (*htab
->params
->place_spu_section
) (htab
->ovtab
, NULL
, ovout
);
1752 htab
->toe
= bfd_make_section_anyway_with_flags (ibfd
, ".toe", SEC_ALLOC
);
1753 if (htab
->toe
== NULL
1754 || !bfd_set_section_alignment (ibfd
, htab
->toe
, 4))
1756 htab
->toe
->size
= htab
->params
->ovly_flavour
== ovly_soft_icache
? 256 : 16;
1757 (*htab
->params
->place_spu_section
) (htab
->toe
, NULL
, ".toe");
1762 /* Functions to handle embedded spu_ovl.o object. */
1765 ovl_mgr_open (struct bfd
*nbfd ATTRIBUTE_UNUSED
, void *stream
)
1771 ovl_mgr_pread (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1777 struct _ovl_stream
*os
;
1781 os
= (struct _ovl_stream
*) stream
;
1782 max
= (const char *) os
->end
- (const char *) os
->start
;
1784 if ((ufile_ptr
) offset
>= max
)
1788 if (count
> max
- offset
)
1789 count
= max
- offset
;
1791 memcpy (buf
, (const char *) os
->start
+ offset
, count
);
1796 spu_elf_open_builtin_lib (bfd
**ovl_bfd
, const struct _ovl_stream
*stream
)
1798 *ovl_bfd
= bfd_openr_iovec ("builtin ovl_mgr",
1805 return *ovl_bfd
!= NULL
;
1809 overlay_index (asection
*sec
)
1812 || sec
->output_section
== bfd_abs_section_ptr
)
1814 return spu_elf_section_data (sec
->output_section
)->u
.o
.ovl_index
;
1817 /* Define an STT_OBJECT symbol. */
1819 static struct elf_link_hash_entry
*
1820 define_ovtab_symbol (struct spu_link_hash_table
*htab
, const char *name
)
1822 struct elf_link_hash_entry
*h
;
1824 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
1828 if (h
->root
.type
!= bfd_link_hash_defined
1831 h
->root
.type
= bfd_link_hash_defined
;
1832 h
->root
.u
.def
.section
= htab
->ovtab
;
1833 h
->type
= STT_OBJECT
;
1836 h
->ref_regular_nonweak
= 1;
1839 else if (h
->root
.u
.def
.section
->owner
!= NULL
)
1841 (*_bfd_error_handler
) (_("%B is not allowed to define %s"),
1842 h
->root
.u
.def
.section
->owner
,
1843 h
->root
.root
.string
);
1844 bfd_set_error (bfd_error_bad_value
);
1849 (*_bfd_error_handler
) (_("you are not allowed to define %s in a script"),
1850 h
->root
.root
.string
);
1851 bfd_set_error (bfd_error_bad_value
);
1858 /* Fill in all stubs and the overlay tables. */
1861 spu_elf_build_stubs (struct bfd_link_info
*info
)
1863 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1864 struct elf_link_hash_entry
*h
;
1870 if (htab
->stub_count
== NULL
)
1873 for (i
= 0; i
<= htab
->num_overlays
; i
++)
1874 if (htab
->stub_sec
[i
]->size
!= 0)
1876 htab
->stub_sec
[i
]->contents
= bfd_zalloc (htab
->stub_sec
[i
]->owner
,
1877 htab
->stub_sec
[i
]->size
);
1878 if (htab
->stub_sec
[i
]->contents
== NULL
)
1880 htab
->stub_sec
[i
]->rawsize
= htab
->stub_sec
[i
]->size
;
1881 htab
->stub_sec
[i
]->size
= 0;
1884 for (i
= 0; i
< 2; i
++)
1886 h
= htab
->ovly_entry
[i
];
1887 BFD_ASSERT (h
!= NULL
);
1889 if ((h
->root
.type
== bfd_link_hash_defined
1890 || h
->root
.type
== bfd_link_hash_defweak
)
1893 s
= h
->root
.u
.def
.section
->output_section
;
1894 if (spu_elf_section_data (s
)->u
.o
.ovl_index
)
1896 (*_bfd_error_handler
) (_("%s in overlay section"),
1897 h
->root
.root
.string
);
1898 bfd_set_error (bfd_error_bad_value
);
1906 /* Fill in all the stubs. */
1907 process_stubs (info
, TRUE
);
1908 if (!htab
->stub_err
)
1909 elf_link_hash_traverse (&htab
->elf
, build_spuear_stubs
, info
);
1913 (*_bfd_error_handler
) (_("overlay stub relocation overflow"));
1914 bfd_set_error (bfd_error_bad_value
);
1918 for (i
= 0; i
<= htab
->num_overlays
; i
++)
1920 if (htab
->stub_sec
[i
]->size
!= htab
->stub_sec
[i
]->rawsize
)
1922 (*_bfd_error_handler
) (_("stubs don't match calculated size"));
1923 bfd_set_error (bfd_error_bad_value
);
1926 htab
->stub_sec
[i
]->rawsize
= 0;
1929 if (htab
->ovtab
== NULL
|| htab
->ovtab
->size
== 0)
1932 htab
->ovtab
->contents
= bfd_zalloc (htab
->ovtab
->owner
, htab
->ovtab
->size
);
1933 if (htab
->ovtab
->contents
== NULL
)
1936 p
= htab
->ovtab
->contents
;
1937 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
1939 bfd_vma off
, icache_base
, linklist
;
1941 h
= define_ovtab_symbol (htab
, "__icache_tagbase");
1944 h
->root
.u
.def
.value
= 0;
1945 h
->size
= 16 << htab
->num_lines_log2
;
1947 icache_base
= htab
->ovl_sec
[0]->vma
;
1948 linklist
= (htab
->ovtab
->output_section
->vma
1949 + htab
->ovtab
->output_offset
1951 for (i
= 0; i
< htab
->params
->num_lines
; i
++)
1953 bfd_vma line_end
= icache_base
+ ((i
+ 1) << htab
->line_size_log2
);
1954 bfd_vma stub_base
= line_end
- htab
->params
->max_branch
* 32;
1955 bfd_vma link_elem
= linklist
+ i
* htab
->params
->max_branch
* 16;
1956 bfd_vma locator
= link_elem
- stub_base
/ 2;
1958 bfd_put_32 (htab
->ovtab
->owner
, locator
, p
+ 4);
1959 bfd_put_16 (htab
->ovtab
->owner
, link_elem
, p
+ 8);
1960 bfd_put_16 (htab
->ovtab
->owner
, link_elem
, p
+ 10);
1961 bfd_put_16 (htab
->ovtab
->owner
, link_elem
, p
+ 12);
1962 bfd_put_16 (htab
->ovtab
->owner
, link_elem
, p
+ 14);
1966 h
= define_ovtab_symbol (htab
, "__icache_linked_list");
1969 h
->root
.u
.def
.value
= off
;
1970 h
->size
= htab
->params
->max_branch
<< (htab
->num_lines_log2
+ 4);
1974 h
= define_ovtab_symbol (htab
, "__icache_base");
1977 h
->root
.u
.def
.value
= htab
->ovl_sec
[0]->vma
;
1978 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
1979 h
->size
= htab
->num_buf
<< htab
->line_size_log2
;
1981 h
= define_ovtab_symbol (htab
, "__icache_neg_log2_linesize");
1984 h
->root
.u
.def
.value
= -htab
->line_size_log2
;
1985 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
1987 if (htab
->init
!= NULL
&& htab
->init
->size
!= 0)
1989 htab
->init
->contents
= bfd_zalloc (htab
->init
->owner
,
1991 if (htab
->init
->contents
== NULL
)
1994 h
= define_ovtab_symbol (htab
, "__icache_fileoff");
1997 h
->root
.u
.def
.value
= 0;
1998 h
->root
.u
.def
.section
= htab
->init
;
2004 /* Write out _ovly_table. */
2005 /* set low bit of .size to mark non-overlay area as present. */
2007 obfd
= htab
->ovtab
->output_section
->owner
;
2008 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
2010 unsigned int ovl_index
= spu_elf_section_data (s
)->u
.o
.ovl_index
;
2014 unsigned long off
= ovl_index
* 16;
2015 unsigned int ovl_buf
= spu_elf_section_data (s
)->u
.o
.ovl_buf
;
2017 bfd_put_32 (htab
->ovtab
->owner
, s
->vma
, p
+ off
);
2018 bfd_put_32 (htab
->ovtab
->owner
, (s
->size
+ 15) & -16,
2020 /* file_off written later in spu_elf_modify_program_headers. */
2021 bfd_put_32 (htab
->ovtab
->owner
, ovl_buf
, p
+ off
+ 12);
2025 h
= define_ovtab_symbol (htab
, "_ovly_table");
2028 h
->root
.u
.def
.value
= 16;
2029 h
->size
= htab
->num_overlays
* 16;
2031 h
= define_ovtab_symbol (htab
, "_ovly_table_end");
2034 h
->root
.u
.def
.value
= htab
->num_overlays
* 16 + 16;
2037 h
= define_ovtab_symbol (htab
, "_ovly_buf_table");
2040 h
->root
.u
.def
.value
= htab
->num_overlays
* 16 + 16;
2041 h
->size
= htab
->num_buf
* 4;
2043 h
= define_ovtab_symbol (htab
, "_ovly_buf_table_end");
2046 h
->root
.u
.def
.value
= htab
->num_overlays
* 16 + 16 + htab
->num_buf
* 4;
2050 h
= define_ovtab_symbol (htab
, "_EAR_");
2053 h
->root
.u
.def
.section
= htab
->toe
;
2054 h
->root
.u
.def
.value
= 0;
2055 h
->size
= htab
->params
->ovly_flavour
== ovly_soft_icache
? 16 * 16 : 16;
2060 /* Check that all loadable section VMAs lie in the range
2061 LO .. HI inclusive, and stash some parameters for --auto-overlay. */
2064 spu_elf_check_vma (struct bfd_link_info
*info
)
2066 struct elf_segment_map
*m
;
2068 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
2069 bfd
*abfd
= info
->output_bfd
;
2070 bfd_vma hi
= htab
->params
->local_store_hi
;
2071 bfd_vma lo
= htab
->params
->local_store_lo
;
2073 htab
->local_store
= hi
+ 1 - lo
;
2075 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2076 if (m
->p_type
== PT_LOAD
)
2077 for (i
= 0; i
< m
->count
; i
++)
2078 if (m
->sections
[i
]->size
!= 0
2079 && (m
->sections
[i
]->vma
< lo
2080 || m
->sections
[i
]->vma
> hi
2081 || m
->sections
[i
]->vma
+ m
->sections
[i
]->size
- 1 > hi
))
2082 return m
->sections
[i
];
2087 /* OFFSET in SEC (presumably) is the beginning of a function prologue.
2088 Search for stack adjusting insns, and return the sp delta.
2089 If a store of lr is found save the instruction offset to *LR_STORE.
2090 If a stack adjusting instruction is found, save that offset to
2094 find_function_stack_adjust (asection
*sec
,
2101 memset (reg
, 0, sizeof (reg
));
2102 for ( ; offset
+ 4 <= sec
->size
; offset
+= 4)
2104 unsigned char buf
[4];
2108 /* Assume no relocs on stack adjusing insns. */
2109 if (!bfd_get_section_contents (sec
->owner
, sec
, buf
, offset
, 4))
2113 ra
= ((buf
[2] & 0x3f) << 1) | (buf
[3] >> 7);
2115 if (buf
[0] == 0x24 /* stqd */)
2117 if (rt
== 0 /* lr */ && ra
== 1 /* sp */)
2122 /* Partly decoded immediate field. */
2123 imm
= (buf
[1] << 9) | (buf
[2] << 1) | (buf
[3] >> 7);
2125 if (buf
[0] == 0x1c /* ai */)
2128 imm
= (imm
^ 0x200) - 0x200;
2129 reg
[rt
] = reg
[ra
] + imm
;
2131 if (rt
== 1 /* sp */)
2135 *sp_adjust
= offset
;
2139 else if (buf
[0] == 0x18 && (buf
[1] & 0xe0) == 0 /* a */)
2141 int rb
= ((buf
[1] & 0x1f) << 2) | ((buf
[2] & 0xc0) >> 6);
2143 reg
[rt
] = reg
[ra
] + reg
[rb
];
2148 *sp_adjust
= offset
;
2152 else if (buf
[0] == 0x08 && (buf
[1] & 0xe0) == 0 /* sf */)
2154 int rb
= ((buf
[1] & 0x1f) << 2) | ((buf
[2] & 0xc0) >> 6);
2156 reg
[rt
] = reg
[rb
] - reg
[ra
];
2161 *sp_adjust
= offset
;
2165 else if ((buf
[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
2167 if (buf
[0] >= 0x42 /* ila */)
2168 imm
|= (buf
[0] & 1) << 17;
2173 if (buf
[0] == 0x40 /* il */)
2175 if ((buf
[1] & 0x80) == 0)
2177 imm
= (imm
^ 0x8000) - 0x8000;
2179 else if ((buf
[1] & 0x80) == 0 /* ilhu */)
2185 else if (buf
[0] == 0x60 && (buf
[1] & 0x80) != 0 /* iohl */)
2187 reg
[rt
] |= imm
& 0xffff;
2190 else if (buf
[0] == 0x04 /* ori */)
2193 imm
= (imm
^ 0x200) - 0x200;
2194 reg
[rt
] = reg
[ra
] | imm
;
2197 else if (buf
[0] == 0x32 && (buf
[1] & 0x80) != 0 /* fsmbi */)
2199 reg
[rt
] = ( ((imm
& 0x8000) ? 0xff000000 : 0)
2200 | ((imm
& 0x4000) ? 0x00ff0000 : 0)
2201 | ((imm
& 0x2000) ? 0x0000ff00 : 0)
2202 | ((imm
& 0x1000) ? 0x000000ff : 0));
2205 else if (buf
[0] == 0x16 /* andbi */)
2211 reg
[rt
] = reg
[ra
] & imm
;
2214 else if (buf
[0] == 0x33 && imm
== 1 /* brsl .+4 */)
2216 /* Used in pic reg load. Say rt is trashed. Won't be used
2217 in stack adjust, but we need to continue past this branch. */
2221 else if (is_branch (buf
) || is_indirect_branch (buf
))
2222 /* If we hit a branch then we must be out of the prologue. */
2229 /* qsort predicate to sort symbols by section and value. */
2231 static Elf_Internal_Sym
*sort_syms_syms
;
2232 static asection
**sort_syms_psecs
;
2235 sort_syms (const void *a
, const void *b
)
2237 Elf_Internal_Sym
*const *s1
= a
;
2238 Elf_Internal_Sym
*const *s2
= b
;
2239 asection
*sec1
,*sec2
;
2240 bfd_signed_vma delta
;
2242 sec1
= sort_syms_psecs
[*s1
- sort_syms_syms
];
2243 sec2
= sort_syms_psecs
[*s2
- sort_syms_syms
];
2246 return sec1
->index
- sec2
->index
;
2248 delta
= (*s1
)->st_value
- (*s2
)->st_value
;
2250 return delta
< 0 ? -1 : 1;
2252 delta
= (*s2
)->st_size
- (*s1
)->st_size
;
2254 return delta
< 0 ? -1 : 1;
2256 return *s1
< *s2
? -1 : 1;
2259 /* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
2260 entries for section SEC. */
2262 static struct spu_elf_stack_info
*
2263 alloc_stack_info (asection
*sec
, int max_fun
)
2265 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
2268 amt
= sizeof (struct spu_elf_stack_info
);
2269 amt
+= (max_fun
- 1) * sizeof (struct function_info
);
2270 sec_data
->u
.i
.stack_info
= bfd_zmalloc (amt
);
2271 if (sec_data
->u
.i
.stack_info
!= NULL
)
2272 sec_data
->u
.i
.stack_info
->max_fun
= max_fun
;
2273 return sec_data
->u
.i
.stack_info
;
2276 /* Add a new struct function_info describing a (part of a) function
2277 starting at SYM_H. Keep the array sorted by address. */
2279 static struct function_info
*
2280 maybe_insert_function (asection
*sec
,
2283 bfd_boolean is_func
)
2285 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
2286 struct spu_elf_stack_info
*sinfo
= sec_data
->u
.i
.stack_info
;
2292 sinfo
= alloc_stack_info (sec
, 20);
2299 Elf_Internal_Sym
*sym
= sym_h
;
2300 off
= sym
->st_value
;
2301 size
= sym
->st_size
;
2305 struct elf_link_hash_entry
*h
= sym_h
;
2306 off
= h
->root
.u
.def
.value
;
2310 for (i
= sinfo
->num_fun
; --i
>= 0; )
2311 if (sinfo
->fun
[i
].lo
<= off
)
2316 /* Don't add another entry for an alias, but do update some
2318 if (sinfo
->fun
[i
].lo
== off
)
2320 /* Prefer globals over local syms. */
2321 if (global
&& !sinfo
->fun
[i
].global
)
2323 sinfo
->fun
[i
].global
= TRUE
;
2324 sinfo
->fun
[i
].u
.h
= sym_h
;
2327 sinfo
->fun
[i
].is_func
= TRUE
;
2328 return &sinfo
->fun
[i
];
2330 /* Ignore a zero-size symbol inside an existing function. */
2331 else if (sinfo
->fun
[i
].hi
> off
&& size
== 0)
2332 return &sinfo
->fun
[i
];
2335 if (sinfo
->num_fun
>= sinfo
->max_fun
)
2337 bfd_size_type amt
= sizeof (struct spu_elf_stack_info
);
2338 bfd_size_type old
= amt
;
2340 old
+= (sinfo
->max_fun
- 1) * sizeof (struct function_info
);
2341 sinfo
->max_fun
+= 20 + (sinfo
->max_fun
>> 1);
2342 amt
+= (sinfo
->max_fun
- 1) * sizeof (struct function_info
);
2343 sinfo
= bfd_realloc (sinfo
, amt
);
2346 memset ((char *) sinfo
+ old
, 0, amt
- old
);
2347 sec_data
->u
.i
.stack_info
= sinfo
;
2350 if (++i
< sinfo
->num_fun
)
2351 memmove (&sinfo
->fun
[i
+ 1], &sinfo
->fun
[i
],
2352 (sinfo
->num_fun
- i
) * sizeof (sinfo
->fun
[i
]));
2353 sinfo
->fun
[i
].is_func
= is_func
;
2354 sinfo
->fun
[i
].global
= global
;
2355 sinfo
->fun
[i
].sec
= sec
;
2357 sinfo
->fun
[i
].u
.h
= sym_h
;
2359 sinfo
->fun
[i
].u
.sym
= sym_h
;
2360 sinfo
->fun
[i
].lo
= off
;
2361 sinfo
->fun
[i
].hi
= off
+ size
;
2362 sinfo
->fun
[i
].lr_store
= -1;
2363 sinfo
->fun
[i
].sp_adjust
= -1;
2364 sinfo
->fun
[i
].stack
= -find_function_stack_adjust (sec
, off
,
2365 &sinfo
->fun
[i
].lr_store
,
2366 &sinfo
->fun
[i
].sp_adjust
);
2367 sinfo
->num_fun
+= 1;
2368 return &sinfo
->fun
[i
];
2371 /* Return the name of FUN. */
2374 func_name (struct function_info
*fun
)
2378 Elf_Internal_Shdr
*symtab_hdr
;
2380 while (fun
->start
!= NULL
)
2384 return fun
->u
.h
->root
.root
.string
;
2387 if (fun
->u
.sym
->st_name
== 0)
2389 size_t len
= strlen (sec
->name
);
2390 char *name
= bfd_malloc (len
+ 10);
2393 sprintf (name
, "%s+%lx", sec
->name
,
2394 (unsigned long) fun
->u
.sym
->st_value
& 0xffffffff);
2398 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2399 return bfd_elf_sym_name (ibfd
, symtab_hdr
, fun
->u
.sym
, sec
);
2402 /* Read the instruction at OFF in SEC. Return true iff the instruction
2403 is a nop, lnop, or stop 0 (all zero insn). */
2406 is_nop (asection
*sec
, bfd_vma off
)
2408 unsigned char insn
[4];
2410 if (off
+ 4 > sec
->size
2411 || !bfd_get_section_contents (sec
->owner
, sec
, insn
, off
, 4))
2413 if ((insn
[0] & 0xbf) == 0 && (insn
[1] & 0xe0) == 0x20)
2415 if (insn
[0] == 0 && insn
[1] == 0 && insn
[2] == 0 && insn
[3] == 0)
2420 /* Extend the range of FUN to cover nop padding up to LIMIT.
2421 Return TRUE iff some instruction other than a NOP was found. */
2424 insns_at_end (struct function_info
*fun
, bfd_vma limit
)
2426 bfd_vma off
= (fun
->hi
+ 3) & -4;
2428 while (off
< limit
&& is_nop (fun
->sec
, off
))
2439 /* Check and fix overlapping function ranges. Return TRUE iff there
2440 are gaps in the current info we have about functions in SEC. */
2443 check_function_ranges (asection
*sec
, struct bfd_link_info
*info
)
2445 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
2446 struct spu_elf_stack_info
*sinfo
= sec_data
->u
.i
.stack_info
;
2448 bfd_boolean gaps
= FALSE
;
2453 for (i
= 1; i
< sinfo
->num_fun
; i
++)
2454 if (sinfo
->fun
[i
- 1].hi
> sinfo
->fun
[i
].lo
)
2456 /* Fix overlapping symbols. */
2457 const char *f1
= func_name (&sinfo
->fun
[i
- 1]);
2458 const char *f2
= func_name (&sinfo
->fun
[i
]);
2460 info
->callbacks
->einfo (_("warning: %s overlaps %s\n"), f1
, f2
);
2461 sinfo
->fun
[i
- 1].hi
= sinfo
->fun
[i
].lo
;
2463 else if (insns_at_end (&sinfo
->fun
[i
- 1], sinfo
->fun
[i
].lo
))
2466 if (sinfo
->num_fun
== 0)
2470 if (sinfo
->fun
[0].lo
!= 0)
2472 if (sinfo
->fun
[sinfo
->num_fun
- 1].hi
> sec
->size
)
2474 const char *f1
= func_name (&sinfo
->fun
[sinfo
->num_fun
- 1]);
2476 info
->callbacks
->einfo (_("warning: %s exceeds section size\n"), f1
);
2477 sinfo
->fun
[sinfo
->num_fun
- 1].hi
= sec
->size
;
2479 else if (insns_at_end (&sinfo
->fun
[sinfo
->num_fun
- 1], sec
->size
))
2485 /* Search current function info for a function that contains address
2486 OFFSET in section SEC. */
2488 static struct function_info
*
2489 find_function (asection
*sec
, bfd_vma offset
, struct bfd_link_info
*info
)
2491 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
2492 struct spu_elf_stack_info
*sinfo
= sec_data
->u
.i
.stack_info
;
2496 hi
= sinfo
->num_fun
;
2499 mid
= (lo
+ hi
) / 2;
2500 if (offset
< sinfo
->fun
[mid
].lo
)
2502 else if (offset
>= sinfo
->fun
[mid
].hi
)
2505 return &sinfo
->fun
[mid
];
2507 info
->callbacks
->einfo (_("%A:0x%v not found in function table\n"),
2509 bfd_set_error (bfd_error_bad_value
);
2513 /* Add CALLEE to CALLER call list if not already present. Return TRUE
2514 if CALLEE was new. If this function return FALSE, CALLEE should
2518 insert_callee (struct function_info
*caller
, struct call_info
*callee
)
2520 struct call_info
**pp
, *p
;
2522 for (pp
= &caller
->call_list
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2523 if (p
->fun
== callee
->fun
)
2525 /* Tail calls use less stack than normal calls. Retain entry
2526 for normal call over one for tail call. */
2527 p
->is_tail
&= callee
->is_tail
;
2530 p
->fun
->start
= NULL
;
2531 p
->fun
->is_func
= TRUE
;
2534 /* Reorder list so most recent call is first. */
2536 p
->next
= caller
->call_list
;
2537 caller
->call_list
= p
;
2540 callee
->next
= caller
->call_list
;
2542 caller
->call_list
= callee
;
2546 /* Copy CALL and insert the copy into CALLER. */
2549 copy_callee (struct function_info
*caller
, const struct call_info
*call
)
2551 struct call_info
*callee
;
2552 callee
= bfd_malloc (sizeof (*callee
));
2556 if (!insert_callee (caller
, callee
))
2561 /* We're only interested in code sections. Testing SEC_IN_MEMORY excludes
2562 overlay stub sections. */
2565 interesting_section (asection
*s
)
2567 return (s
->output_section
!= bfd_abs_section_ptr
2568 && ((s
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_IN_MEMORY
))
2569 == (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
2573 /* Rummage through the relocs for SEC, looking for function calls.
2574 If CALL_TREE is true, fill in call graph. If CALL_TREE is false,
2575 mark destination symbols on calls as being functions. Also
2576 look at branches, which may be tail calls or go to hot/cold
2577 section part of same function. */
2580 mark_functions_via_relocs (asection
*sec
,
2581 struct bfd_link_info
*info
,
2584 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2585 Elf_Internal_Shdr
*symtab_hdr
;
2587 unsigned int priority
= 0;
2588 static bfd_boolean warned
;
2590 if (!interesting_section (sec
)
2591 || sec
->reloc_count
== 0)
2594 internal_relocs
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
,
2596 if (internal_relocs
== NULL
)
2599 symtab_hdr
= &elf_tdata (sec
->owner
)->symtab_hdr
;
2600 psyms
= &symtab_hdr
->contents
;
2601 irela
= internal_relocs
;
2602 irelaend
= irela
+ sec
->reloc_count
;
2603 for (; irela
< irelaend
; irela
++)
2605 enum elf_spu_reloc_type r_type
;
2606 unsigned int r_indx
;
2608 Elf_Internal_Sym
*sym
;
2609 struct elf_link_hash_entry
*h
;
2611 bfd_boolean reject
, is_call
;
2612 struct function_info
*caller
;
2613 struct call_info
*callee
;
2616 r_type
= ELF32_R_TYPE (irela
->r_info
);
2617 if (r_type
!= R_SPU_REL16
2618 && r_type
!= R_SPU_ADDR16
)
2621 if (!(call_tree
&& spu_hash_table (info
)->params
->auto_overlay
))
2625 r_indx
= ELF32_R_SYM (irela
->r_info
);
2626 if (!get_sym_h (&h
, &sym
, &sym_sec
, psyms
, r_indx
, sec
->owner
))
2630 || sym_sec
->output_section
== bfd_abs_section_ptr
)
2636 unsigned char insn
[4];
2638 if (!bfd_get_section_contents (sec
->owner
, sec
, insn
,
2639 irela
->r_offset
, 4))
2641 if (is_branch (insn
))
2643 is_call
= (insn
[0] & 0xfd) == 0x31;
2644 priority
= insn
[1] & 0x0f;
2646 priority
|= insn
[2];
2648 priority
|= insn
[3];
2650 if ((sym_sec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
2651 != (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
))
2654 info
->callbacks
->einfo
2655 (_("%B(%A+0x%v): call to non-code section"
2656 " %B(%A), analysis incomplete\n"),
2657 sec
->owner
, sec
, irela
->r_offset
,
2658 sym_sec
->owner
, sym_sec
);
2666 if (!(call_tree
&& spu_hash_table (info
)->params
->auto_overlay
)
2674 /* For --auto-overlay, count possible stubs we need for
2675 function pointer references. */
2676 unsigned int sym_type
;
2680 sym_type
= ELF_ST_TYPE (sym
->st_info
);
2681 if (sym_type
== STT_FUNC
)
2682 spu_hash_table (info
)->non_ovly_stub
+= 1;
2687 val
= h
->root
.u
.def
.value
;
2689 val
= sym
->st_value
;
2690 val
+= irela
->r_addend
;
2694 struct function_info
*fun
;
2696 if (irela
->r_addend
!= 0)
2698 Elf_Internal_Sym
*fake
= bfd_zmalloc (sizeof (*fake
));
2701 fake
->st_value
= val
;
2703 = _bfd_elf_section_from_bfd_section (sym_sec
->owner
, sym_sec
);
2707 fun
= maybe_insert_function (sym_sec
, sym
, FALSE
, is_call
);
2709 fun
= maybe_insert_function (sym_sec
, h
, TRUE
, is_call
);
2712 if (irela
->r_addend
!= 0
2713 && fun
->u
.sym
!= sym
)
2718 caller
= find_function (sec
, irela
->r_offset
, info
);
2721 callee
= bfd_malloc (sizeof *callee
);
2725 callee
->fun
= find_function (sym_sec
, val
, info
);
2726 if (callee
->fun
== NULL
)
2728 callee
->is_tail
= !is_call
;
2729 callee
->is_pasted
= FALSE
;
2730 callee
->priority
= priority
;
2732 if (callee
->fun
->last_caller
!= sec
)
2734 callee
->fun
->last_caller
= sec
;
2735 callee
->fun
->call_count
+= 1;
2737 if (!insert_callee (caller
, callee
))
2740 && !callee
->fun
->is_func
2741 && callee
->fun
->stack
== 0)
2743 /* This is either a tail call or a branch from one part of
2744 the function to another, ie. hot/cold section. If the
2745 destination has been called by some other function then
2746 it is a separate function. We also assume that functions
2747 are not split across input files. */
2748 if (sec
->owner
!= sym_sec
->owner
)
2750 callee
->fun
->start
= NULL
;
2751 callee
->fun
->is_func
= TRUE
;
2753 else if (callee
->fun
->start
== NULL
)
2754 callee
->fun
->start
= caller
;
2757 struct function_info
*callee_start
;
2758 struct function_info
*caller_start
;
2759 callee_start
= callee
->fun
;
2760 while (callee_start
->start
)
2761 callee_start
= callee_start
->start
;
2762 caller_start
= caller
;
2763 while (caller_start
->start
)
2764 caller_start
= caller_start
->start
;
2765 if (caller_start
!= callee_start
)
2767 callee
->fun
->start
= NULL
;
2768 callee
->fun
->is_func
= TRUE
;
2777 /* Handle something like .init or .fini, which has a piece of a function.
2778 These sections are pasted together to form a single function. */
2781 pasted_function (asection
*sec
)
2783 struct bfd_link_order
*l
;
2784 struct _spu_elf_section_data
*sec_data
;
2785 struct spu_elf_stack_info
*sinfo
;
2786 Elf_Internal_Sym
*fake
;
2787 struct function_info
*fun
, *fun_start
;
2789 fake
= bfd_zmalloc (sizeof (*fake
));
2793 fake
->st_size
= sec
->size
;
2795 = _bfd_elf_section_from_bfd_section (sec
->owner
, sec
);
2796 fun
= maybe_insert_function (sec
, fake
, FALSE
, FALSE
);
2800 /* Find a function immediately preceding this section. */
2802 for (l
= sec
->output_section
->map_head
.link_order
; l
!= NULL
; l
= l
->next
)
2804 if (l
->u
.indirect
.section
== sec
)
2806 if (fun_start
!= NULL
)
2808 struct call_info
*callee
= bfd_malloc (sizeof *callee
);
2812 fun
->start
= fun_start
;
2814 callee
->is_tail
= TRUE
;
2815 callee
->is_pasted
= TRUE
;
2817 if (!insert_callee (fun_start
, callee
))
2823 if (l
->type
== bfd_indirect_link_order
2824 && (sec_data
= spu_elf_section_data (l
->u
.indirect
.section
)) != NULL
2825 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
2826 && sinfo
->num_fun
!= 0)
2827 fun_start
= &sinfo
->fun
[sinfo
->num_fun
- 1];
2830 /* Don't return an error if we did not find a function preceding this
2831 section. The section may have incorrect flags. */
2835 /* Map address ranges in code sections to functions. */
2838 discover_functions (struct bfd_link_info
*info
)
2842 Elf_Internal_Sym
***psym_arr
;
2843 asection
***sec_arr
;
2844 bfd_boolean gaps
= FALSE
;
2847 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2850 psym_arr
= bfd_zmalloc (bfd_idx
* sizeof (*psym_arr
));
2851 if (psym_arr
== NULL
)
2853 sec_arr
= bfd_zmalloc (bfd_idx
* sizeof (*sec_arr
));
2854 if (sec_arr
== NULL
)
2857 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2859 ibfd
= ibfd
->link_next
, bfd_idx
++)
2861 extern const bfd_target bfd_elf32_spu_vec
;
2862 Elf_Internal_Shdr
*symtab_hdr
;
2865 Elf_Internal_Sym
*syms
, *sy
, **psyms
, **psy
;
2866 asection
**psecs
, **p
;
2868 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
2871 /* Read all the symbols. */
2872 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2873 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
2877 for (sec
= ibfd
->sections
; sec
!= NULL
&& !gaps
; sec
= sec
->next
)
2878 if (interesting_section (sec
))
2886 if (symtab_hdr
->contents
!= NULL
)
2888 /* Don't use cached symbols since the generic ELF linker
2889 code only reads local symbols, and we need globals too. */
2890 free (symtab_hdr
->contents
);
2891 symtab_hdr
->contents
= NULL
;
2893 syms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
, symcount
, 0,
2895 symtab_hdr
->contents
= (void *) syms
;
2899 /* Select defined function symbols that are going to be output. */
2900 psyms
= bfd_malloc ((symcount
+ 1) * sizeof (*psyms
));
2903 psym_arr
[bfd_idx
] = psyms
;
2904 psecs
= bfd_malloc (symcount
* sizeof (*psecs
));
2907 sec_arr
[bfd_idx
] = psecs
;
2908 for (psy
= psyms
, p
= psecs
, sy
= syms
; sy
< syms
+ symcount
; ++p
, ++sy
)
2909 if (ELF_ST_TYPE (sy
->st_info
) == STT_NOTYPE
2910 || ELF_ST_TYPE (sy
->st_info
) == STT_FUNC
)
2914 *p
= s
= bfd_section_from_elf_index (ibfd
, sy
->st_shndx
);
2915 if (s
!= NULL
&& interesting_section (s
))
2918 symcount
= psy
- psyms
;
2921 /* Sort them by section and offset within section. */
2922 sort_syms_syms
= syms
;
2923 sort_syms_psecs
= psecs
;
2924 qsort (psyms
, symcount
, sizeof (*psyms
), sort_syms
);
2926 /* Now inspect the function symbols. */
2927 for (psy
= psyms
; psy
< psyms
+ symcount
; )
2929 asection
*s
= psecs
[*psy
- syms
];
2930 Elf_Internal_Sym
**psy2
;
2932 for (psy2
= psy
; ++psy2
< psyms
+ symcount
; )
2933 if (psecs
[*psy2
- syms
] != s
)
2936 if (!alloc_stack_info (s
, psy2
- psy
))
2941 /* First install info about properly typed and sized functions.
2942 In an ideal world this will cover all code sections, except
2943 when partitioning functions into hot and cold sections,
2944 and the horrible pasted together .init and .fini functions. */
2945 for (psy
= psyms
; psy
< psyms
+ symcount
; ++psy
)
2948 if (ELF_ST_TYPE (sy
->st_info
) == STT_FUNC
)
2950 asection
*s
= psecs
[sy
- syms
];
2951 if (!maybe_insert_function (s
, sy
, FALSE
, TRUE
))
2956 for (sec
= ibfd
->sections
; sec
!= NULL
&& !gaps
; sec
= sec
->next
)
2957 if (interesting_section (sec
))
2958 gaps
|= check_function_ranges (sec
, info
);
2963 /* See if we can discover more function symbols by looking at
2965 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2967 ibfd
= ibfd
->link_next
, bfd_idx
++)
2971 if (psym_arr
[bfd_idx
] == NULL
)
2974 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2975 if (!mark_functions_via_relocs (sec
, info
, FALSE
))
2979 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
2981 ibfd
= ibfd
->link_next
, bfd_idx
++)
2983 Elf_Internal_Shdr
*symtab_hdr
;
2985 Elf_Internal_Sym
*syms
, *sy
, **psyms
, **psy
;
2988 if ((psyms
= psym_arr
[bfd_idx
]) == NULL
)
2991 psecs
= sec_arr
[bfd_idx
];
2993 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2994 syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2997 for (sec
= ibfd
->sections
; sec
!= NULL
&& !gaps
; sec
= sec
->next
)
2998 if (interesting_section (sec
))
2999 gaps
|= check_function_ranges (sec
, info
);
3003 /* Finally, install all globals. */
3004 for (psy
= psyms
; (sy
= *psy
) != NULL
; ++psy
)
3008 s
= psecs
[sy
- syms
];
3010 /* Global syms might be improperly typed functions. */
3011 if (ELF_ST_TYPE (sy
->st_info
) != STT_FUNC
3012 && ELF_ST_BIND (sy
->st_info
) == STB_GLOBAL
)
3014 if (!maybe_insert_function (s
, sy
, FALSE
, FALSE
))
3020 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3022 extern const bfd_target bfd_elf32_spu_vec
;
3025 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
3028 /* Some of the symbols we've installed as marking the
3029 beginning of functions may have a size of zero. Extend
3030 the range of such functions to the beginning of the
3031 next symbol of interest. */
3032 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3033 if (interesting_section (sec
))
3035 struct _spu_elf_section_data
*sec_data
;
3036 struct spu_elf_stack_info
*sinfo
;
3038 sec_data
= spu_elf_section_data (sec
);
3039 sinfo
= sec_data
->u
.i
.stack_info
;
3040 if (sinfo
!= NULL
&& sinfo
->num_fun
!= 0)
3043 bfd_vma hi
= sec
->size
;
3045 for (fun_idx
= sinfo
->num_fun
; --fun_idx
>= 0; )
3047 sinfo
->fun
[fun_idx
].hi
= hi
;
3048 hi
= sinfo
->fun
[fun_idx
].lo
;
3051 sinfo
->fun
[0].lo
= 0;
3053 /* No symbols in this section. Must be .init or .fini
3054 or something similar. */
3055 else if (!pasted_function (sec
))
3061 for (ibfd
= info
->input_bfds
, bfd_idx
= 0;
3063 ibfd
= ibfd
->link_next
, bfd_idx
++)
3065 if (psym_arr
[bfd_idx
] == NULL
)
3068 free (psym_arr
[bfd_idx
]);
3069 free (sec_arr
[bfd_idx
]);
3078 /* Iterate over all function_info we have collected, calling DOIT on
3079 each node if ROOT_ONLY is false. Only call DOIT on root nodes
3083 for_each_node (bfd_boolean (*doit
) (struct function_info
*,
3084 struct bfd_link_info
*,
3086 struct bfd_link_info
*info
,
3092 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3094 extern const bfd_target bfd_elf32_spu_vec
;
3097 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
3100 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3102 struct _spu_elf_section_data
*sec_data
;
3103 struct spu_elf_stack_info
*sinfo
;
3105 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
3106 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3109 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
3110 if (!root_only
|| !sinfo
->fun
[i
].non_root
)
3111 if (!doit (&sinfo
->fun
[i
], info
, param
))
3119 /* Transfer call info attached to struct function_info entries for
3120 all of a given function's sections to the first entry. */
3123 transfer_calls (struct function_info
*fun
,
3124 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3125 void *param ATTRIBUTE_UNUSED
)
3127 struct function_info
*start
= fun
->start
;
3131 struct call_info
*call
, *call_next
;
3133 while (start
->start
!= NULL
)
3134 start
= start
->start
;
3135 for (call
= fun
->call_list
; call
!= NULL
; call
= call_next
)
3137 call_next
= call
->next
;
3138 if (!insert_callee (start
, call
))
3141 fun
->call_list
= NULL
;
3146 /* Mark nodes in the call graph that are called by some other node. */
3149 mark_non_root (struct function_info
*fun
,
3150 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3151 void *param ATTRIBUTE_UNUSED
)
3153 struct call_info
*call
;
3158 for (call
= fun
->call_list
; call
; call
= call
->next
)
3160 call
->fun
->non_root
= TRUE
;
3161 mark_non_root (call
->fun
, 0, 0);
3166 /* Remove cycles from the call graph. Set depth of nodes. */
3169 remove_cycles (struct function_info
*fun
,
3170 struct bfd_link_info
*info
,
3173 struct call_info
**callp
, *call
;
3174 unsigned int depth
= *(unsigned int *) param
;
3175 unsigned int max_depth
= depth
;
3179 fun
->marking
= TRUE
;
3181 callp
= &fun
->call_list
;
3182 while ((call
= *callp
) != NULL
)
3184 call
->max_depth
= depth
+ !call
->is_pasted
;
3185 if (!call
->fun
->visit2
)
3187 if (!remove_cycles (call
->fun
, info
, &call
->max_depth
))
3189 if (max_depth
< call
->max_depth
)
3190 max_depth
= call
->max_depth
;
3192 else if (call
->fun
->marking
)
3194 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
3196 if (!htab
->params
->auto_overlay
3197 && htab
->params
->stack_analysis
)
3199 const char *f1
= func_name (fun
);
3200 const char *f2
= func_name (call
->fun
);
3202 info
->callbacks
->info (_("Stack analysis will ignore the call "
3206 *callp
= call
->next
;
3210 callp
= &call
->next
;
3212 fun
->marking
= FALSE
;
3213 *(unsigned int *) param
= max_depth
;
3217 /* Check that we actually visited all nodes in remove_cycles. If we
3218 didn't, then there is some cycle in the call graph not attached to
3219 any root node. Arbitrarily choose a node in the cycle as a new
3220 root and break the cycle. */
3223 mark_detached_root (struct function_info
*fun
,
3224 struct bfd_link_info
*info
,
3229 fun
->non_root
= FALSE
;
3230 *(unsigned int *) param
= 0;
3231 return remove_cycles (fun
, info
, param
);
3234 /* Populate call_list for each function. */
3237 build_call_tree (struct bfd_link_info
*info
)
3242 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3244 extern const bfd_target bfd_elf32_spu_vec
;
3247 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
3250 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3251 if (!mark_functions_via_relocs (sec
, info
, TRUE
))
3255 /* Transfer call info from hot/cold section part of function
3257 if (!spu_hash_table (info
)->params
->auto_overlay
3258 && !for_each_node (transfer_calls
, info
, 0, FALSE
))
3261 /* Find the call graph root(s). */
3262 if (!for_each_node (mark_non_root
, info
, 0, FALSE
))
3265 /* Remove cycles from the call graph. We start from the root node(s)
3266 so that we break cycles in a reasonable place. */
3268 if (!for_each_node (remove_cycles
, info
, &depth
, TRUE
))
3271 return for_each_node (mark_detached_root
, info
, &depth
, FALSE
);
3274 /* qsort predicate to sort calls by priority, max_depth then count. */
3277 sort_calls (const void *a
, const void *b
)
3279 struct call_info
*const *c1
= a
;
3280 struct call_info
*const *c2
= b
;
3283 delta
= (*c2
)->priority
- (*c1
)->priority
;
3287 delta
= (*c2
)->max_depth
- (*c1
)->max_depth
;
3291 delta
= (*c2
)->count
- (*c1
)->count
;
3295 return (char *) c1
- (char *) c2
;
3299 unsigned int max_overlay_size
;
3302 /* Set linker_mark and gc_mark on any sections that we will put in
3303 overlays. These flags are used by the generic ELF linker, but we
3304 won't be continuing on to bfd_elf_final_link so it is OK to use
3305 them. linker_mark is clear before we get here. Set segment_mark
3306 on sections that are part of a pasted function (excluding the last
3309 Set up function rodata section if --overlay-rodata. We don't
3310 currently include merged string constant rodata sections since
3312 Sort the call graph so that the deepest nodes will be visited
3316 mark_overlay_section (struct function_info
*fun
,
3317 struct bfd_link_info
*info
,
3320 struct call_info
*call
;
3322 struct _mos_param
*mos_param
= param
;
3323 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
3329 if (!fun
->sec
->linker_mark
3330 && (htab
->params
->ovly_flavour
!= ovly_soft_icache
3331 || htab
->params
->non_ia_text
3332 || strncmp (fun
->sec
->name
, ".text.ia.", 9) == 0))
3336 fun
->sec
->linker_mark
= 1;
3337 fun
->sec
->gc_mark
= 1;
3338 fun
->sec
->segment_mark
= 0;
3339 /* Ensure SEC_CODE is set on this text section (it ought to
3340 be!), and SEC_CODE is clear on rodata sections. We use
3341 this flag to differentiate the two overlay section types. */
3342 fun
->sec
->flags
|= SEC_CODE
;
3344 size
= fun
->sec
->size
;
3345 if (htab
->params
->auto_overlay
& OVERLAY_RODATA
)
3349 /* Find the rodata section corresponding to this function's
3351 if (strcmp (fun
->sec
->name
, ".text") == 0)
3353 name
= bfd_malloc (sizeof (".rodata"));
3356 memcpy (name
, ".rodata", sizeof (".rodata"));
3358 else if (strncmp (fun
->sec
->name
, ".text.", 6) == 0)
3360 size_t len
= strlen (fun
->sec
->name
);
3361 name
= bfd_malloc (len
+ 3);
3364 memcpy (name
, ".rodata", sizeof (".rodata"));
3365 memcpy (name
+ 7, fun
->sec
->name
+ 5, len
- 4);
3367 else if (strncmp (fun
->sec
->name
, ".gnu.linkonce.t.", 16) == 0)
3369 size_t len
= strlen (fun
->sec
->name
) + 1;
3370 name
= bfd_malloc (len
);
3373 memcpy (name
, fun
->sec
->name
, len
);
3379 asection
*rodata
= NULL
;
3380 asection
*group_sec
= elf_section_data (fun
->sec
)->next_in_group
;
3381 if (group_sec
== NULL
)
3382 rodata
= bfd_get_section_by_name (fun
->sec
->owner
, name
);
3384 while (group_sec
!= NULL
&& group_sec
!= fun
->sec
)
3386 if (strcmp (group_sec
->name
, name
) == 0)
3391 group_sec
= elf_section_data (group_sec
)->next_in_group
;
3393 fun
->rodata
= rodata
;
3396 size
+= fun
->rodata
->size
;
3397 if (htab
->params
->line_size
!= 0
3398 && size
> htab
->params
->line_size
)
3400 size
-= fun
->rodata
->size
;
3405 fun
->rodata
->linker_mark
= 1;
3406 fun
->rodata
->gc_mark
= 1;
3407 fun
->rodata
->flags
&= ~SEC_CODE
;
3413 if (mos_param
->max_overlay_size
< size
)
3414 mos_param
->max_overlay_size
= size
;
3417 for (count
= 0, call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3422 struct call_info
**calls
= bfd_malloc (count
* sizeof (*calls
));
3426 for (count
= 0, call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3427 calls
[count
++] = call
;
3429 qsort (calls
, count
, sizeof (*calls
), sort_calls
);
3431 fun
->call_list
= NULL
;
3435 calls
[count
]->next
= fun
->call_list
;
3436 fun
->call_list
= calls
[count
];
3441 for (call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3443 if (call
->is_pasted
)
3445 /* There can only be one is_pasted call per function_info. */
3446 BFD_ASSERT (!fun
->sec
->segment_mark
);
3447 fun
->sec
->segment_mark
= 1;
3449 if (!mark_overlay_section (call
->fun
, info
, param
))
3453 /* Don't put entry code into an overlay. The overlay manager needs
3454 a stack! Also, don't mark .ovl.init as an overlay. */
3455 if (fun
->lo
+ fun
->sec
->output_offset
+ fun
->sec
->output_section
->vma
3456 == info
->output_bfd
->start_address
3457 || strncmp (fun
->sec
->output_section
->name
, ".ovl.init", 9) == 0)
3459 fun
->sec
->linker_mark
= 0;
3460 if (fun
->rodata
!= NULL
)
3461 fun
->rodata
->linker_mark
= 0;
3466 /* If non-zero then unmark functions called from those within sections
3467 that we need to unmark. Unfortunately this isn't reliable since the
3468 call graph cannot know the destination of function pointer calls. */
3469 #define RECURSE_UNMARK 0
3472 asection
*exclude_input_section
;
3473 asection
*exclude_output_section
;
3474 unsigned long clearing
;
3477 /* Undo some of mark_overlay_section's work. */
3480 unmark_overlay_section (struct function_info
*fun
,
3481 struct bfd_link_info
*info
,
3484 struct call_info
*call
;
3485 struct _uos_param
*uos_param
= param
;
3486 unsigned int excluded
= 0;
3494 if (fun
->sec
== uos_param
->exclude_input_section
3495 || fun
->sec
->output_section
== uos_param
->exclude_output_section
)
3499 uos_param
->clearing
+= excluded
;
3501 if (RECURSE_UNMARK
? uos_param
->clearing
: excluded
)
3503 fun
->sec
->linker_mark
= 0;
3505 fun
->rodata
->linker_mark
= 0;
3508 for (call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3509 if (!unmark_overlay_section (call
->fun
, info
, param
))
3513 uos_param
->clearing
-= excluded
;
3518 unsigned int lib_size
;
3519 asection
**lib_sections
;
3522 /* Add sections we have marked as belonging to overlays to an array
3523 for consideration as non-overlay sections. The array consist of
3524 pairs of sections, (text,rodata), for functions in the call graph. */
3527 collect_lib_sections (struct function_info
*fun
,
3528 struct bfd_link_info
*info
,
3531 struct _cl_param
*lib_param
= param
;
3532 struct call_info
*call
;
3539 if (!fun
->sec
->linker_mark
|| !fun
->sec
->gc_mark
|| fun
->sec
->segment_mark
)
3542 size
= fun
->sec
->size
;
3544 size
+= fun
->rodata
->size
;
3546 if (size
<= lib_param
->lib_size
)
3548 *lib_param
->lib_sections
++ = fun
->sec
;
3549 fun
->sec
->gc_mark
= 0;
3550 if (fun
->rodata
&& fun
->rodata
->linker_mark
&& fun
->rodata
->gc_mark
)
3552 *lib_param
->lib_sections
++ = fun
->rodata
;
3553 fun
->rodata
->gc_mark
= 0;
3556 *lib_param
->lib_sections
++ = NULL
;
3559 for (call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3560 collect_lib_sections (call
->fun
, info
, param
);
3565 /* qsort predicate to sort sections by call count. */
3568 sort_lib (const void *a
, const void *b
)
3570 asection
*const *s1
= a
;
3571 asection
*const *s2
= b
;
3572 struct _spu_elf_section_data
*sec_data
;
3573 struct spu_elf_stack_info
*sinfo
;
3577 if ((sec_data
= spu_elf_section_data (*s1
)) != NULL
3578 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3581 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
3582 delta
-= sinfo
->fun
[i
].call_count
;
3585 if ((sec_data
= spu_elf_section_data (*s2
)) != NULL
3586 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3589 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
3590 delta
+= sinfo
->fun
[i
].call_count
;
3599 /* Remove some sections from those marked to be in overlays. Choose
3600 those that are called from many places, likely library functions. */
3603 auto_ovl_lib_functions (struct bfd_link_info
*info
, unsigned int lib_size
)
3606 asection
**lib_sections
;
3607 unsigned int i
, lib_count
;
3608 struct _cl_param collect_lib_param
;
3609 struct function_info dummy_caller
;
3610 struct spu_link_hash_table
*htab
;
3612 memset (&dummy_caller
, 0, sizeof (dummy_caller
));
3614 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3616 extern const bfd_target bfd_elf32_spu_vec
;
3619 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
3622 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3623 if (sec
->linker_mark
3624 && sec
->size
< lib_size
3625 && (sec
->flags
& SEC_CODE
) != 0)
3628 lib_sections
= bfd_malloc (lib_count
* 2 * sizeof (*lib_sections
));
3629 if (lib_sections
== NULL
)
3630 return (unsigned int) -1;
3631 collect_lib_param
.lib_size
= lib_size
;
3632 collect_lib_param
.lib_sections
= lib_sections
;
3633 if (!for_each_node (collect_lib_sections
, info
, &collect_lib_param
,
3635 return (unsigned int) -1;
3636 lib_count
= (collect_lib_param
.lib_sections
- lib_sections
) / 2;
3638 /* Sort sections so that those with the most calls are first. */
3640 qsort (lib_sections
, lib_count
, 2 * sizeof (*lib_sections
), sort_lib
);
3642 htab
= spu_hash_table (info
);
3643 for (i
= 0; i
< lib_count
; i
++)
3645 unsigned int tmp
, stub_size
;
3647 struct _spu_elf_section_data
*sec_data
;
3648 struct spu_elf_stack_info
*sinfo
;
3650 sec
= lib_sections
[2 * i
];
3651 /* If this section is OK, its size must be less than lib_size. */
3653 /* If it has a rodata section, then add that too. */
3654 if (lib_sections
[2 * i
+ 1])
3655 tmp
+= lib_sections
[2 * i
+ 1]->size
;
3656 /* Add any new overlay call stubs needed by the section. */
3659 && (sec_data
= spu_elf_section_data (sec
)) != NULL
3660 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3663 struct call_info
*call
;
3665 for (k
= 0; k
< sinfo
->num_fun
; ++k
)
3666 for (call
= sinfo
->fun
[k
].call_list
; call
; call
= call
->next
)
3667 if (call
->fun
->sec
->linker_mark
)
3669 struct call_info
*p
;
3670 for (p
= dummy_caller
.call_list
; p
; p
= p
->next
)
3671 if (p
->fun
== call
->fun
)
3674 stub_size
+= ovl_stub_size (htab
->params
);
3677 if (tmp
+ stub_size
< lib_size
)
3679 struct call_info
**pp
, *p
;
3681 /* This section fits. Mark it as non-overlay. */
3682 lib_sections
[2 * i
]->linker_mark
= 0;
3683 if (lib_sections
[2 * i
+ 1])
3684 lib_sections
[2 * i
+ 1]->linker_mark
= 0;
3685 lib_size
-= tmp
+ stub_size
;
3686 /* Call stubs to the section we just added are no longer
3688 pp
= &dummy_caller
.call_list
;
3689 while ((p
= *pp
) != NULL
)
3690 if (!p
->fun
->sec
->linker_mark
)
3692 lib_size
+= ovl_stub_size (htab
->params
);
3698 /* Add new call stubs to dummy_caller. */
3699 if ((sec_data
= spu_elf_section_data (sec
)) != NULL
3700 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3703 struct call_info
*call
;
3705 for (k
= 0; k
< sinfo
->num_fun
; ++k
)
3706 for (call
= sinfo
->fun
[k
].call_list
;
3709 if (call
->fun
->sec
->linker_mark
)
3711 struct call_info
*callee
;
3712 callee
= bfd_malloc (sizeof (*callee
));
3714 return (unsigned int) -1;
3716 if (!insert_callee (&dummy_caller
, callee
))
3722 while (dummy_caller
.call_list
!= NULL
)
3724 struct call_info
*call
= dummy_caller
.call_list
;
3725 dummy_caller
.call_list
= call
->next
;
3728 for (i
= 0; i
< 2 * lib_count
; i
++)
3729 if (lib_sections
[i
])
3730 lib_sections
[i
]->gc_mark
= 1;
3731 free (lib_sections
);
3735 /* Build an array of overlay sections. The deepest node's section is
3736 added first, then its parent node's section, then everything called
3737 from the parent section. The idea being to group sections to
3738 minimise calls between different overlays. */
3741 collect_overlays (struct function_info
*fun
,
3742 struct bfd_link_info
*info
,
3745 struct call_info
*call
;
3746 bfd_boolean added_fun
;
3747 asection
***ovly_sections
= param
;
3753 for (call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3754 if (!call
->is_pasted
)
3756 if (!collect_overlays (call
->fun
, info
, ovly_sections
))
3762 if (fun
->sec
->linker_mark
&& fun
->sec
->gc_mark
)
3764 fun
->sec
->gc_mark
= 0;
3765 *(*ovly_sections
)++ = fun
->sec
;
3766 if (fun
->rodata
&& fun
->rodata
->linker_mark
&& fun
->rodata
->gc_mark
)
3768 fun
->rodata
->gc_mark
= 0;
3769 *(*ovly_sections
)++ = fun
->rodata
;
3772 *(*ovly_sections
)++ = NULL
;
3775 /* Pasted sections must stay with the first section. We don't
3776 put pasted sections in the array, just the first section.
3777 Mark subsequent sections as already considered. */
3778 if (fun
->sec
->segment_mark
)
3780 struct function_info
*call_fun
= fun
;
3783 for (call
= call_fun
->call_list
; call
!= NULL
; call
= call
->next
)
3784 if (call
->is_pasted
)
3786 call_fun
= call
->fun
;
3787 call_fun
->sec
->gc_mark
= 0;
3788 if (call_fun
->rodata
)
3789 call_fun
->rodata
->gc_mark
= 0;
3795 while (call_fun
->sec
->segment_mark
);
3799 for (call
= fun
->call_list
; call
!= NULL
; call
= call
->next
)
3800 if (!collect_overlays (call
->fun
, info
, ovly_sections
))
3805 struct _spu_elf_section_data
*sec_data
;
3806 struct spu_elf_stack_info
*sinfo
;
3808 if ((sec_data
= spu_elf_section_data (fun
->sec
)) != NULL
3809 && (sinfo
= sec_data
->u
.i
.stack_info
) != NULL
)
3812 for (i
= 0; i
< sinfo
->num_fun
; ++i
)
3813 if (!collect_overlays (&sinfo
->fun
[i
], info
, ovly_sections
))
3821 struct _sum_stack_param
{
3823 size_t overall_stack
;
3824 bfd_boolean emit_stack_syms
;
3827 /* Descend the call graph for FUN, accumulating total stack required. */
3830 sum_stack (struct function_info
*fun
,
3831 struct bfd_link_info
*info
,
3834 struct call_info
*call
;
3835 struct function_info
*max
;
3836 size_t stack
, cum_stack
;
3838 bfd_boolean has_call
;
3839 struct _sum_stack_param
*sum_stack_param
= param
;
3840 struct spu_link_hash_table
*htab
;
3842 cum_stack
= fun
->stack
;
3843 sum_stack_param
->cum_stack
= cum_stack
;
3849 for (call
= fun
->call_list
; call
; call
= call
->next
)
3851 if (!call
->is_pasted
)
3853 if (!sum_stack (call
->fun
, info
, sum_stack_param
))
3855 stack
= sum_stack_param
->cum_stack
;
3856 /* Include caller stack for normal calls, don't do so for
3857 tail calls. fun->stack here is local stack usage for
3859 if (!call
->is_tail
|| call
->is_pasted
|| call
->fun
->start
!= NULL
)
3860 stack
+= fun
->stack
;
3861 if (cum_stack
< stack
)
3868 sum_stack_param
->cum_stack
= cum_stack
;
3870 /* Now fun->stack holds cumulative stack. */
3871 fun
->stack
= cum_stack
;
3875 && sum_stack_param
->overall_stack
< cum_stack
)
3876 sum_stack_param
->overall_stack
= cum_stack
;
3878 htab
= spu_hash_table (info
);
3879 if (htab
->params
->auto_overlay
)
3882 f1
= func_name (fun
);
3883 if (htab
->params
->stack_analysis
)
3886 info
->callbacks
->info (_(" %s: 0x%v\n"), f1
, (bfd_vma
) cum_stack
);
3887 info
->callbacks
->minfo (_("%s: 0x%v 0x%v\n"),
3888 f1
, (bfd_vma
) stack
, (bfd_vma
) cum_stack
);
3892 info
->callbacks
->minfo (_(" calls:\n"));
3893 for (call
= fun
->call_list
; call
; call
= call
->next
)
3894 if (!call
->is_pasted
)
3896 const char *f2
= func_name (call
->fun
);
3897 const char *ann1
= call
->fun
== max
? "*" : " ";
3898 const char *ann2
= call
->is_tail
? "t" : " ";
3900 info
->callbacks
->minfo (_(" %s%s %s\n"), ann1
, ann2
, f2
);
3905 if (sum_stack_param
->emit_stack_syms
)
3907 char *name
= bfd_malloc (18 + strlen (f1
));
3908 struct elf_link_hash_entry
*h
;
3913 if (fun
->global
|| ELF_ST_BIND (fun
->u
.sym
->st_info
) == STB_GLOBAL
)
3914 sprintf (name
, "__stack_%s", f1
);
3916 sprintf (name
, "__stack_%x_%s", fun
->sec
->id
& 0xffffffff, f1
);
3918 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, TRUE
, FALSE
);
3921 && (h
->root
.type
== bfd_link_hash_new
3922 || h
->root
.type
== bfd_link_hash_undefined
3923 || h
->root
.type
== bfd_link_hash_undefweak
))
3925 h
->root
.type
= bfd_link_hash_defined
;
3926 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3927 h
->root
.u
.def
.value
= cum_stack
;
3932 h
->ref_regular_nonweak
= 1;
3933 h
->forced_local
= 1;
3941 /* SEC is part of a pasted function. Return the call_info for the
3942 next section of this function. */
3944 static struct call_info
*
3945 find_pasted_call (asection
*sec
)
3947 struct _spu_elf_section_data
*sec_data
= spu_elf_section_data (sec
);
3948 struct spu_elf_stack_info
*sinfo
= sec_data
->u
.i
.stack_info
;
3949 struct call_info
*call
;
3952 for (k
= 0; k
< sinfo
->num_fun
; ++k
)
3953 for (call
= sinfo
->fun
[k
].call_list
; call
!= NULL
; call
= call
->next
)
3954 if (call
->is_pasted
)
3960 /* qsort predicate to sort bfds by file name. */
3963 sort_bfds (const void *a
, const void *b
)
3965 bfd
*const *abfd1
= a
;
3966 bfd
*const *abfd2
= b
;
3968 return strcmp ((*abfd1
)->filename
, (*abfd2
)->filename
);
3972 print_one_overlay_section (FILE *script
,
3975 unsigned int ovlynum
,
3976 unsigned int *ovly_map
,
3977 asection
**ovly_sections
,
3978 struct bfd_link_info
*info
)
3982 for (j
= base
; j
< count
&& ovly_map
[j
] == ovlynum
; j
++)
3984 asection
*sec
= ovly_sections
[2 * j
];
3986 if (fprintf (script
, " %s%c%s (%s)\n",
3987 (sec
->owner
->my_archive
!= NULL
3988 ? sec
->owner
->my_archive
->filename
: ""),
3989 info
->path_separator
,
3990 sec
->owner
->filename
,
3993 if (sec
->segment_mark
)
3995 struct call_info
*call
= find_pasted_call (sec
);
3996 while (call
!= NULL
)
3998 struct function_info
*call_fun
= call
->fun
;
3999 sec
= call_fun
->sec
;
4000 if (fprintf (script
, " %s%c%s (%s)\n",
4001 (sec
->owner
->my_archive
!= NULL
4002 ? sec
->owner
->my_archive
->filename
: ""),
4003 info
->path_separator
,
4004 sec
->owner
->filename
,
4007 for (call
= call_fun
->call_list
; call
; call
= call
->next
)
4008 if (call
->is_pasted
)
4014 for (j
= base
; j
< count
&& ovly_map
[j
] == ovlynum
; j
++)
4016 asection
*sec
= ovly_sections
[2 * j
+ 1];
4018 && fprintf (script
, " %s%c%s (%s)\n",
4019 (sec
->owner
->my_archive
!= NULL
4020 ? sec
->owner
->my_archive
->filename
: ""),
4021 info
->path_separator
,
4022 sec
->owner
->filename
,
4026 sec
= ovly_sections
[2 * j
];
4027 if (sec
->segment_mark
)
4029 struct call_info
*call
= find_pasted_call (sec
);
4030 while (call
!= NULL
)
4032 struct function_info
*call_fun
= call
->fun
;
4033 sec
= call_fun
->rodata
;
4035 && fprintf (script
, " %s%c%s (%s)\n",
4036 (sec
->owner
->my_archive
!= NULL
4037 ? sec
->owner
->my_archive
->filename
: ""),
4038 info
->path_separator
,
4039 sec
->owner
->filename
,
4042 for (call
= call_fun
->call_list
; call
; call
= call
->next
)
4043 if (call
->is_pasted
)
4052 /* Handle --auto-overlay. */
4055 spu_elf_auto_overlay (struct bfd_link_info
*info
)
4059 struct elf_segment_map
*m
;
4060 unsigned int fixed_size
, lo
, hi
;
4061 struct spu_link_hash_table
*htab
;
4062 unsigned int base
, i
, count
, bfd_count
;
4063 unsigned int region
, ovlynum
;
4064 asection
**ovly_sections
, **ovly_p
;
4065 unsigned int *ovly_map
;
4067 unsigned int total_overlay_size
, overlay_size
;
4068 const char *ovly_mgr_entry
;
4069 struct elf_link_hash_entry
*h
;
4070 struct _mos_param mos_param
;
4071 struct _uos_param uos_param
;
4072 struct function_info dummy_caller
;
4074 /* Find the extents of our loadable image. */
4075 lo
= (unsigned int) -1;
4077 for (m
= elf_tdata (info
->output_bfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4078 if (m
->p_type
== PT_LOAD
)
4079 for (i
= 0; i
< m
->count
; i
++)
4080 if (m
->sections
[i
]->size
!= 0)
4082 if (m
->sections
[i
]->vma
< lo
)
4083 lo
= m
->sections
[i
]->vma
;
4084 if (m
->sections
[i
]->vma
+ m
->sections
[i
]->size
- 1 > hi
)
4085 hi
= m
->sections
[i
]->vma
+ m
->sections
[i
]->size
- 1;
4087 fixed_size
= hi
+ 1 - lo
;
4089 if (!discover_functions (info
))
4092 if (!build_call_tree (info
))
4095 htab
= spu_hash_table (info
);
4096 if (htab
->reserved
== 0)
4098 struct _sum_stack_param sum_stack_param
;
4100 sum_stack_param
.emit_stack_syms
= 0;
4101 sum_stack_param
.overall_stack
= 0;
4102 if (!for_each_node (sum_stack
, info
, &sum_stack_param
, TRUE
))
4104 htab
->reserved
= sum_stack_param
.overall_stack
+ htab
->extra_stack_space
;
4107 /* No need for overlays if everything already fits. */
4108 if (fixed_size
+ htab
->reserved
<= htab
->local_store
4109 && htab
->params
->ovly_flavour
!= ovly_soft_icache
)
4111 htab
->params
->auto_overlay
= 0;
4115 uos_param
.exclude_input_section
= 0;
4116 uos_param
.exclude_output_section
4117 = bfd_get_section_by_name (info
->output_bfd
, ".interrupt");
4119 ovly_mgr_entry
= "__ovly_load";
4120 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
4121 ovly_mgr_entry
= "__icache_br_handler";
4122 h
= elf_link_hash_lookup (&htab
->elf
, ovly_mgr_entry
,
4123 FALSE
, FALSE
, FALSE
);
4125 && (h
->root
.type
== bfd_link_hash_defined
4126 || h
->root
.type
== bfd_link_hash_defweak
)
4129 /* We have a user supplied overlay manager. */
4130 uos_param
.exclude_input_section
= h
->root
.u
.def
.section
;
4134 /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4135 builtin version to .text, and will adjust .text size. */
4136 fixed_size
+= (*htab
->params
->spu_elf_load_ovl_mgr
) ();
4139 /* Mark overlay sections, and find max overlay section size. */
4140 mos_param
.max_overlay_size
= 0;
4141 if (!for_each_node (mark_overlay_section
, info
, &mos_param
, TRUE
))
4144 /* We can't put the overlay manager or interrupt routines in
4146 uos_param
.clearing
= 0;
4147 if ((uos_param
.exclude_input_section
4148 || uos_param
.exclude_output_section
)
4149 && !for_each_node (unmark_overlay_section
, info
, &uos_param
, TRUE
))
4153 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
4155 bfd_arr
= bfd_malloc (bfd_count
* sizeof (*bfd_arr
));
4156 if (bfd_arr
== NULL
)
4159 /* Count overlay sections, and subtract their sizes from "fixed_size". */
4162 total_overlay_size
= 0;
4163 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
4165 extern const bfd_target bfd_elf32_spu_vec
;
4167 unsigned int old_count
;
4169 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
4173 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4174 if (sec
->linker_mark
)
4176 if ((sec
->flags
& SEC_CODE
) != 0)
4178 fixed_size
-= sec
->size
;
4179 total_overlay_size
+= sec
->size
;
4181 else if ((sec
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
)
4182 && sec
->output_section
->owner
== info
->output_bfd
4183 && strncmp (sec
->output_section
->name
, ".ovl.init", 9) == 0)
4184 fixed_size
-= sec
->size
;
4185 if (count
!= old_count
)
4186 bfd_arr
[bfd_count
++] = ibfd
;
4189 /* Since the overlay link script selects sections by file name and
4190 section name, ensure that file names are unique. */
4193 bfd_boolean ok
= TRUE
;
4195 qsort (bfd_arr
, bfd_count
, sizeof (*bfd_arr
), sort_bfds
);
4196 for (i
= 1; i
< bfd_count
; ++i
)
4197 if (strcmp (bfd_arr
[i
- 1]->filename
, bfd_arr
[i
]->filename
) == 0)
4199 if (bfd_arr
[i
- 1]->my_archive
== bfd_arr
[i
]->my_archive
)
4201 if (bfd_arr
[i
- 1]->my_archive
&& bfd_arr
[i
]->my_archive
)
4202 info
->callbacks
->einfo (_("%s duplicated in %s\n"),
4203 bfd_arr
[i
]->filename
,
4204 bfd_arr
[i
]->my_archive
->filename
);
4206 info
->callbacks
->einfo (_("%s duplicated\n"),
4207 bfd_arr
[i
]->filename
);
4213 info
->callbacks
->einfo (_("sorry, no support for duplicate "
4214 "object files in auto-overlay script\n"));
4215 bfd_set_error (bfd_error_bad_value
);
4221 fixed_size
+= htab
->reserved
;
4222 fixed_size
+= htab
->non_ovly_stub
* ovl_stub_size (htab
->params
);
4223 if (fixed_size
+ mos_param
.max_overlay_size
<= htab
->local_store
)
4225 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
4227 /* Stubs in the non-icache area are bigger. */
4228 fixed_size
+= htab
->non_ovly_stub
* 16;
4229 /* Space for icache manager tables.
4230 a) Tag array, one quadword per cache line.
4231 - word 0: ia address of present line, init to zero.
4232 - word 1: link locator. link_elem=stub_addr/2+locator
4233 - halfwords 4-7: head/tail pointers for linked lists. */
4234 fixed_size
+= 16 << htab
->num_lines_log2
;
4235 /* b) Linked list elements, max_branch per line. */
4236 fixed_size
+= htab
->params
->max_branch
<< (htab
->num_lines_log2
+ 4);
4237 /* c) Indirect branch descriptors, 8 quadwords. */
4238 fixed_size
+= 8 * 16;
4239 /* d) Pointers to __ea backing store, 16 quadwords. */
4240 fixed_size
+= 16 * 16;
4244 /* Guess number of overlays. Assuming overlay buffer is on
4245 average only half full should be conservative. */
4246 ovlynum
= (total_overlay_size
* 2 * htab
->params
->num_lines
4247 / (htab
->local_store
- fixed_size
));
4248 /* Space for _ovly_table[], _ovly_buf_table[] and toe. */
4249 fixed_size
+= ovlynum
* 16 + 16 + 4 + 16;
4253 if (fixed_size
+ mos_param
.max_overlay_size
> htab
->local_store
)
4254 info
->callbacks
->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4255 "size of 0x%v exceeds local store\n"),
4256 (bfd_vma
) fixed_size
,
4257 (bfd_vma
) mos_param
.max_overlay_size
);
4259 /* Now see if we should put some functions in the non-overlay area. */
4260 else if (fixed_size
< htab
->overlay_fixed
)
4262 unsigned int max_fixed
, lib_size
;
4264 max_fixed
= htab
->local_store
- mos_param
.max_overlay_size
;
4265 if (max_fixed
> htab
->overlay_fixed
)
4266 max_fixed
= htab
->overlay_fixed
;
4267 lib_size
= max_fixed
- fixed_size
;
4268 lib_size
= auto_ovl_lib_functions (info
, lib_size
);
4269 if (lib_size
== (unsigned int) -1)
4271 fixed_size
= max_fixed
- lib_size
;
4274 /* Build an array of sections, suitably sorted to place into
4276 ovly_sections
= bfd_malloc (2 * count
* sizeof (*ovly_sections
));
4277 if (ovly_sections
== NULL
)
4279 ovly_p
= ovly_sections
;
4280 if (!for_each_node (collect_overlays
, info
, &ovly_p
, TRUE
))
4282 count
= (size_t) (ovly_p
- ovly_sections
) / 2;
4283 ovly_map
= bfd_malloc (count
* sizeof (*ovly_map
));
4284 if (ovly_map
== NULL
)
4287 memset (&dummy_caller
, 0, sizeof (dummy_caller
));
4288 overlay_size
= (htab
->local_store
- fixed_size
) / htab
->params
->num_lines
;
4289 if (htab
->params
->line_size
!= 0)
4290 overlay_size
= htab
->params
->line_size
;
4293 while (base
< count
)
4295 unsigned int size
= 0;
4297 for (i
= base
; i
< count
; i
++)
4301 unsigned int num_stubs
;
4302 struct call_info
*call
, *pasty
;
4303 struct _spu_elf_section_data
*sec_data
;
4304 struct spu_elf_stack_info
*sinfo
;
4307 /* See whether we can add this section to the current
4308 overlay without overflowing our overlay buffer. */
4309 sec
= ovly_sections
[2 * i
];
4310 tmp
= size
+ sec
->size
;
4311 if (ovly_sections
[2 * i
+ 1])
4312 tmp
+= ovly_sections
[2 * i
+ 1]->size
;
4313 if (tmp
> overlay_size
)
4315 if (sec
->segment_mark
)
4317 /* Pasted sections must stay together, so add their
4319 struct call_info
*pasty
= find_pasted_call (sec
);
4320 while (pasty
!= NULL
)
4322 struct function_info
*call_fun
= pasty
->fun
;
4323 tmp
+= call_fun
->sec
->size
;
4324 if (call_fun
->rodata
)
4325 tmp
+= call_fun
->rodata
->size
;
4326 for (pasty
= call_fun
->call_list
; pasty
; pasty
= pasty
->next
)
4327 if (pasty
->is_pasted
)
4331 if (tmp
> overlay_size
)
4334 /* If we add this section, we might need new overlay call
4335 stubs. Add any overlay section calls to dummy_call. */
4337 sec_data
= spu_elf_section_data (sec
);
4338 sinfo
= sec_data
->u
.i
.stack_info
;
4339 for (k
= 0; k
< sinfo
->num_fun
; ++k
)
4340 for (call
= sinfo
->fun
[k
].call_list
; call
; call
= call
->next
)
4341 if (call
->is_pasted
)
4343 BFD_ASSERT (pasty
== NULL
);
4346 else if (call
->fun
->sec
->linker_mark
)
4348 if (!copy_callee (&dummy_caller
, call
))
4351 while (pasty
!= NULL
)
4353 struct function_info
*call_fun
= pasty
->fun
;
4355 for (call
= call_fun
->call_list
; call
; call
= call
->next
)
4356 if (call
->is_pasted
)
4358 BFD_ASSERT (pasty
== NULL
);
4361 else if (!copy_callee (&dummy_caller
, call
))
4365 /* Calculate call stub size. */
4367 for (call
= dummy_caller
.call_list
; call
; call
= call
->next
)
4372 /* If the call is within this overlay, we won't need a
4374 for (k
= base
; k
< i
+ 1; k
++)
4375 if (call
->fun
->sec
== ovly_sections
[2 * k
])
4381 if (htab
->params
->ovly_flavour
== ovly_soft_icache
4382 && num_stubs
> htab
->params
->max_branch
)
4384 if (tmp
+ num_stubs
* ovl_stub_size (htab
->params
)
4392 info
->callbacks
->einfo (_("%B:%A%s exceeds overlay size\n"),
4393 ovly_sections
[2 * i
]->owner
,
4394 ovly_sections
[2 * i
],
4395 ovly_sections
[2 * i
+ 1] ? " + rodata" : "");
4396 bfd_set_error (bfd_error_bad_value
);
4400 while (dummy_caller
.call_list
!= NULL
)
4402 struct call_info
*call
= dummy_caller
.call_list
;
4403 dummy_caller
.call_list
= call
->next
;
4409 ovly_map
[base
++] = ovlynum
;
4412 script
= htab
->params
->spu_elf_open_overlay_script ();
4414 if (fprintf (script
, "SECTIONS\n{\n") <= 0)
4417 if (htab
->params
->ovly_flavour
== ovly_soft_icache
)
4419 if (fprintf (script
,
4420 " .data.icache ALIGN (16) : { *(.ovtab) *(.data.icache) }\n"
4421 " . = ALIGN (%u);\n"
4422 " .ovl.init : { *(.ovl.init) }\n"
4423 " . = ABSOLUTE (ADDR (.ovl.init));\n",
4424 htab
->params
->line_size
) <= 0)
4429 while (base
< count
)
4431 unsigned int indx
= ovlynum
- 1;
4432 unsigned int vma
, lma
;
4434 vma
= (indx
& (htab
->params
->num_lines
- 1)) << htab
->line_size_log2
;
4435 lma
= indx
<< htab
->line_size_log2
;
4437 if (fprintf (script
, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4438 ": AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16) + %u) {\n",
4439 ovlynum
, vma
, lma
) <= 0)
4442 base
= print_one_overlay_section (script
, base
, count
, ovlynum
,
4443 ovly_map
, ovly_sections
, info
);
4444 if (base
== (unsigned) -1)
4447 if (fprintf (script
, " }\n") <= 0)
4453 if (fprintf (script
, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4454 1 << (htab
->num_lines_log2
+ htab
->line_size_log2
)) <= 0)
4459 if (fprintf (script
,
4460 " . = ALIGN (16);\n"
4461 " .ovl.init : { *(.ovl.init) }\n"
4462 " . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
4465 for (region
= 1; region
<= htab
->params
->num_lines
; region
++)
4469 while (base
< count
&& ovly_map
[base
] < ovlynum
)
4477 /* We need to set lma since we are overlaying .ovl.init. */
4478 if (fprintf (script
,
4479 " OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4484 if (fprintf (script
, " OVERLAY :\n {\n") <= 0)
4488 while (base
< count
)
4490 if (fprintf (script
, " .ovly%u {\n", ovlynum
) <= 0)
4493 base
= print_one_overlay_section (script
, base
, count
, ovlynum
,
4494 ovly_map
, ovly_sections
, info
);
4495 if (base
== (unsigned) -1)
4498 if (fprintf (script
, " }\n") <= 0)
4501 ovlynum
+= htab
->params
->num_lines
;
4502 while (base
< count
&& ovly_map
[base
] < ovlynum
)
4506 if (fprintf (script
, " }\n") <= 0)
4513 free (ovly_sections
);
4515 if (fprintf (script
, "}\nINSERT BEFORE .text;\n") <= 0)
4517 if (fclose (script
) != 0)
4520 if (htab
->params
->auto_overlay
& AUTO_RELINK
)
4521 (*htab
->params
->spu_elf_relink
) ();
4526 bfd_set_error (bfd_error_system_call
);
4528 info
->callbacks
->einfo ("%F%P: auto overlay error: %E\n");
4532 /* Provide an estimate of total stack required. */
4535 spu_elf_stack_analysis (struct bfd_link_info
*info
)
4537 struct spu_link_hash_table
*htab
;
4538 struct _sum_stack_param sum_stack_param
;
4540 if (!discover_functions (info
))
4543 if (!build_call_tree (info
))
4546 htab
= spu_hash_table (info
);
4547 if (htab
->params
->stack_analysis
)
4549 info
->callbacks
->info (_("Stack size for call graph root nodes.\n"));
4550 info
->callbacks
->minfo (_("\nStack size for functions. "
4551 "Annotations: '*' max stack, 't' tail call\n"));
4554 sum_stack_param
.emit_stack_syms
= htab
->params
->emit_stack_syms
;
4555 sum_stack_param
.overall_stack
= 0;
4556 if (!for_each_node (sum_stack
, info
, &sum_stack_param
, TRUE
))
4559 if (htab
->params
->stack_analysis
)
4560 info
->callbacks
->info (_("Maximum stack required is 0x%v\n"),
4561 (bfd_vma
) sum_stack_param
.overall_stack
);
4565 /* Perform a final link. */
4568 spu_elf_final_link (bfd
*output_bfd
, struct bfd_link_info
*info
)
4570 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
4572 if (htab
->params
->auto_overlay
)
4573 spu_elf_auto_overlay (info
);
4575 if ((htab
->params
->stack_analysis
4576 || (htab
->params
->ovly_flavour
== ovly_soft_icache
4577 && htab
->params
->lrlive_analysis
))
4578 && !spu_elf_stack_analysis (info
))
4579 info
->callbacks
->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4581 if (!spu_elf_build_stubs (info
))
4582 info
->callbacks
->einfo ("%F%P: can not build overlay stubs: %E\n");
4584 return bfd_elf_final_link (output_bfd
, info
);
4587 /* Called when not normally emitting relocs, ie. !info->relocatable
4588 and !info->emitrelocations. Returns a count of special relocs
4589 that need to be emitted. */
4592 spu_elf_count_relocs (struct bfd_link_info
*info
, asection
*sec
)
4594 Elf_Internal_Rela
*relocs
;
4595 unsigned int count
= 0;
4597 relocs
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
,
4601 Elf_Internal_Rela
*rel
;
4602 Elf_Internal_Rela
*relend
= relocs
+ sec
->reloc_count
;
4604 for (rel
= relocs
; rel
< relend
; rel
++)
4606 int r_type
= ELF32_R_TYPE (rel
->r_info
);
4607 if (r_type
== R_SPU_PPU32
|| r_type
== R_SPU_PPU64
)
4611 if (elf_section_data (sec
)->relocs
!= relocs
)
4618 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
4621 spu_elf_relocate_section (bfd
*output_bfd
,
4622 struct bfd_link_info
*info
,
4624 asection
*input_section
,
4626 Elf_Internal_Rela
*relocs
,
4627 Elf_Internal_Sym
*local_syms
,
4628 asection
**local_sections
)
4630 Elf_Internal_Shdr
*symtab_hdr
;
4631 struct elf_link_hash_entry
**sym_hashes
;
4632 Elf_Internal_Rela
*rel
, *relend
;
4633 struct spu_link_hash_table
*htab
;
4636 bfd_boolean emit_these_relocs
= FALSE
;
4637 bfd_boolean is_ea_sym
;
4639 unsigned int iovl
= 0;
4641 htab
= spu_hash_table (info
);
4642 stubs
= (htab
->stub_sec
!= NULL
4643 && maybe_needs_stubs (input_section
));
4644 iovl
= overlay_index (input_section
);
4645 ea
= bfd_get_section_by_name (output_bfd
, "._ea");
4646 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4647 sym_hashes
= (struct elf_link_hash_entry
**) (elf_sym_hashes (input_bfd
));
4650 relend
= relocs
+ input_section
->reloc_count
;
4651 for (; rel
< relend
; rel
++)
4654 reloc_howto_type
*howto
;
4655 unsigned int r_symndx
;
4656 Elf_Internal_Sym
*sym
;
4658 struct elf_link_hash_entry
*h
;
4659 const char *sym_name
;
4662 bfd_reloc_status_type r
;
4663 bfd_boolean unresolved_reloc
;
4665 bfd_boolean overlay_encoded
;
4666 enum _stub_type stub_type
;
4668 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4669 r_type
= ELF32_R_TYPE (rel
->r_info
);
4670 howto
= elf_howto_table
+ r_type
;
4671 unresolved_reloc
= FALSE
;
4676 if (r_symndx
< symtab_hdr
->sh_info
)
4678 sym
= local_syms
+ r_symndx
;
4679 sec
= local_sections
[r_symndx
];
4680 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
4681 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
4685 if (sym_hashes
== NULL
)
4688 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4690 while (h
->root
.type
== bfd_link_hash_indirect
4691 || h
->root
.type
== bfd_link_hash_warning
)
4692 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4695 if (h
->root
.type
== bfd_link_hash_defined
4696 || h
->root
.type
== bfd_link_hash_defweak
)
4698 sec
= h
->root
.u
.def
.section
;
4700 || sec
->output_section
== NULL
)
4701 /* Set a flag that will be cleared later if we find a
4702 relocation value for this symbol. output_section
4703 is typically NULL for symbols satisfied by a shared
4705 unresolved_reloc
= TRUE
;
4707 relocation
= (h
->root
.u
.def
.value
4708 + sec
->output_section
->vma
4709 + sec
->output_offset
);
4711 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4713 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4714 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
4716 else if (!info
->relocatable
4717 && !(r_type
== R_SPU_PPU32
|| r_type
== R_SPU_PPU64
))
4720 err
= (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
4721 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
);
4722 if (!info
->callbacks
->undefined_symbol (info
,
4723 h
->root
.root
.string
,
4726 rel
->r_offset
, err
))
4730 sym_name
= h
->root
.root
.string
;
4733 if (sec
!= NULL
&& elf_discarded_section (sec
))
4735 /* For relocs against symbols from removed linkonce sections,
4736 or sections discarded by a linker script, we just want the
4737 section contents zeroed. Avoid any special processing. */
4738 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
4744 if (info
->relocatable
)
4747 is_ea_sym
= (ea
!= NULL
4749 && sec
->output_section
== ea
);
4750 overlay_encoded
= FALSE
;
4752 /* If this symbol is in an overlay area, we may need to relocate
4753 to the overlay stub. */
4754 addend
= rel
->r_addend
;
4757 && (stub_type
= needs_ovl_stub (h
, sym
, sec
, input_section
, rel
,
4758 contents
, info
)) != no_stub
)
4760 unsigned int ovl
= 0;
4761 struct got_entry
*g
, **head
;
4763 if (stub_type
!= nonovl_stub
)
4767 head
= &h
->got
.glist
;
4769 head
= elf_local_got_ents (input_bfd
) + r_symndx
;
4771 for (g
= *head
; g
!= NULL
; g
= g
->next
)
4772 if (htab
->params
->ovly_flavour
== ovly_soft_icache
4773 ? g
->br_addr
== (rel
->r_offset
4774 + input_section
->output_offset
4775 + input_section
->output_section
->vma
)
4776 : g
->addend
== addend
&& (g
->ovl
== ovl
|| g
->ovl
== 0))
4781 relocation
= g
->stub_addr
;
4786 /* For soft icache, encode the overlay index into addresses. */
4787 if (htab
->params
->ovly_flavour
== ovly_soft_icache
4790 unsigned int ovl
= overlay_index (sec
);
4793 unsigned int set_id
= ((ovl
- 1) >> htab
->num_lines_log2
) + 1;
4794 relocation
+= set_id
<< 18;
4795 overlay_encoded
= TRUE
;
4800 if (unresolved_reloc
)
4802 else if (r_type
== R_SPU_PPU32
|| r_type
== R_SPU_PPU64
)
4806 /* ._ea is a special section that isn't allocated in SPU
4807 memory, but rather occupies space in PPU memory as
4808 part of an embedded ELF image. If this reloc is
4809 against a symbol defined in ._ea, then transform the
4810 reloc into an equivalent one without a symbol
4811 relative to the start of the ELF image. */
4812 rel
->r_addend
+= (relocation
4814 + elf_section_data (ea
)->this_hdr
.sh_offset
);
4815 rel
->r_info
= ELF32_R_INFO (0, r_type
);
4817 emit_these_relocs
= TRUE
;
4821 unresolved_reloc
= TRUE
;
4823 if (unresolved_reloc
)
4825 (*_bfd_error_handler
)
4826 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
4828 bfd_get_section_name (input_bfd
, input_section
),
4829 (long) rel
->r_offset
,
4835 r
= _bfd_final_link_relocate (howto
,
4839 rel
->r_offset
, relocation
, addend
);
4841 if (r
!= bfd_reloc_ok
)
4843 const char *msg
= (const char *) 0;
4847 case bfd_reloc_overflow
:
4848 /* FIXME: We don't want to warn on most references
4849 within an overlay to itself, but this may silence a
4850 warning that should be reported. */
4851 if (overlay_encoded
&& sec
== input_section
)
4853 if (!((*info
->callbacks
->reloc_overflow
)
4854 (info
, (h
? &h
->root
: NULL
), sym_name
, howto
->name
,
4855 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
)))
4859 case bfd_reloc_undefined
:
4860 if (!((*info
->callbacks
->undefined_symbol
)
4861 (info
, sym_name
, input_bfd
, input_section
,
4862 rel
->r_offset
, TRUE
)))
4866 case bfd_reloc_outofrange
:
4867 msg
= _("internal error: out of range error");
4870 case bfd_reloc_notsupported
:
4871 msg
= _("internal error: unsupported relocation error");
4874 case bfd_reloc_dangerous
:
4875 msg
= _("internal error: dangerous error");
4879 msg
= _("internal error: unknown error");
4884 if (!((*info
->callbacks
->warning
)
4885 (info
, msg
, sym_name
, input_bfd
, input_section
,
4894 && emit_these_relocs
4895 && !info
->emitrelocations
)
4897 Elf_Internal_Rela
*wrel
;
4898 Elf_Internal_Shdr
*rel_hdr
;
4900 wrel
= rel
= relocs
;
4901 relend
= relocs
+ input_section
->reloc_count
;
4902 for (; rel
< relend
; rel
++)
4906 r_type
= ELF32_R_TYPE (rel
->r_info
);
4907 if (r_type
== R_SPU_PPU32
|| r_type
== R_SPU_PPU64
)
4910 input_section
->reloc_count
= wrel
- relocs
;
4911 /* Backflips for _bfd_elf_link_output_relocs. */
4912 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
4913 rel_hdr
->sh_size
= input_section
->reloc_count
* rel_hdr
->sh_entsize
;
4920 /* Adjust _SPUEAR_ syms to point at their overlay stubs. */
4923 spu_elf_output_symbol_hook (struct bfd_link_info
*info
,
4924 const char *sym_name ATTRIBUTE_UNUSED
,
4925 Elf_Internal_Sym
*sym
,
4926 asection
*sym_sec ATTRIBUTE_UNUSED
,
4927 struct elf_link_hash_entry
*h
)
4929 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
4931 if (!info
->relocatable
4932 && htab
->stub_sec
!= NULL
4934 && (h
->root
.type
== bfd_link_hash_defined
4935 || h
->root
.type
== bfd_link_hash_defweak
)
4937 && strncmp (h
->root
.root
.string
, "_SPUEAR_", 8) == 0)
4939 struct got_entry
*g
;
4941 for (g
= h
->got
.glist
; g
!= NULL
; g
= g
->next
)
4942 if (htab
->params
->ovly_flavour
== ovly_soft_icache
4943 ? g
->br_addr
== g
->stub_addr
4944 : g
->addend
== 0 && g
->ovl
== 0)
4946 sym
->st_shndx
= (_bfd_elf_section_from_bfd_section
4947 (htab
->stub_sec
[0]->output_section
->owner
,
4948 htab
->stub_sec
[0]->output_section
));
4949 sym
->st_value
= g
->stub_addr
;
4957 static int spu_plugin
= 0;
4960 spu_elf_plugin (int val
)
4965 /* Set ELF header e_type for plugins. */
4968 spu_elf_post_process_headers (bfd
*abfd
,
4969 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4973 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4975 i_ehdrp
->e_type
= ET_DYN
;
4979 /* We may add an extra PT_LOAD segment for .toe. We also need extra
4980 segments for overlays. */
4983 spu_elf_additional_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
4990 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
4991 extra
= htab
->num_overlays
;
4997 sec
= bfd_get_section_by_name (abfd
, ".toe");
4998 if (sec
!= NULL
&& (sec
->flags
& SEC_LOAD
) != 0)
5004 /* Remove .toe section from other PT_LOAD segments and put it in
5005 a segment of its own. Put overlays in separate segments too. */
5008 spu_elf_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
5011 struct elf_segment_map
*m
;
5017 toe
= bfd_get_section_by_name (abfd
, ".toe");
5018 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
5019 if (m
->p_type
== PT_LOAD
&& m
->count
> 1)
5020 for (i
= 0; i
< m
->count
; i
++)
5021 if ((s
= m
->sections
[i
]) == toe
5022 || spu_elf_section_data (s
)->u
.o
.ovl_index
!= 0)
5024 struct elf_segment_map
*m2
;
5027 if (i
+ 1 < m
->count
)
5029 amt
= sizeof (struct elf_segment_map
);
5030 amt
+= (m
->count
- (i
+ 2)) * sizeof (m
->sections
[0]);
5031 m2
= bfd_zalloc (abfd
, amt
);
5034 m2
->count
= m
->count
- (i
+ 1);
5035 memcpy (m2
->sections
, m
->sections
+ i
+ 1,
5036 m2
->count
* sizeof (m
->sections
[0]));
5037 m2
->p_type
= PT_LOAD
;
5045 amt
= sizeof (struct elf_segment_map
);
5046 m2
= bfd_zalloc (abfd
, amt
);
5049 m2
->p_type
= PT_LOAD
;
5051 m2
->sections
[0] = s
;
5061 /* Tweak the section type of .note.spu_name. */
5064 spu_elf_fake_sections (bfd
*obfd ATTRIBUTE_UNUSED
,
5065 Elf_Internal_Shdr
*hdr
,
5068 if (strcmp (sec
->name
, SPU_PTNOTE_SPUNAME
) == 0)
5069 hdr
->sh_type
= SHT_NOTE
;
5073 /* Tweak phdrs before writing them out. */
5076 spu_elf_modify_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
5078 const struct elf_backend_data
*bed
;
5079 struct elf_obj_tdata
*tdata
;
5080 Elf_Internal_Phdr
*phdr
, *last
;
5081 struct spu_link_hash_table
*htab
;
5088 bed
= get_elf_backend_data (abfd
);
5089 tdata
= elf_tdata (abfd
);
5091 count
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
5092 htab
= spu_hash_table (info
);
5093 if (htab
->num_overlays
!= 0)
5095 struct elf_segment_map
*m
;
5098 for (i
= 0, m
= elf_tdata (abfd
)->segment_map
; m
; ++i
, m
= m
->next
)
5100 && (o
= spu_elf_section_data (m
->sections
[0])->u
.o
.ovl_index
) != 0)
5102 /* Mark this as an overlay header. */
5103 phdr
[i
].p_flags
|= PF_OVERLAY
;
5105 if (htab
->ovtab
!= NULL
&& htab
->ovtab
->size
!= 0
5106 && htab
->params
->ovly_flavour
!= ovly_soft_icache
)
5108 bfd_byte
*p
= htab
->ovtab
->contents
;
5109 unsigned int off
= o
* 16 + 8;
5111 /* Write file_off into _ovly_table. */
5112 bfd_put_32 (htab
->ovtab
->owner
, phdr
[i
].p_offset
, p
+ off
);
5115 /* Soft-icache has its file offset put in .ovl.init. */
5116 if (htab
->init
!= NULL
&& htab
->init
->size
!= 0)
5118 bfd_vma val
= elf_section_data (htab
->ovl_sec
[0])->this_hdr
.sh_offset
;
5120 bfd_put_32 (htab
->init
->owner
, val
, htab
->init
->contents
+ 4);
5124 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5125 of 16. This should always be possible when using the standard
5126 linker scripts, but don't create overlapping segments if
5127 someone is playing games with linker scripts. */
5129 for (i
= count
; i
-- != 0; )
5130 if (phdr
[i
].p_type
== PT_LOAD
)
5134 adjust
= -phdr
[i
].p_filesz
& 15;
5137 && phdr
[i
].p_offset
+ phdr
[i
].p_filesz
> last
->p_offset
- adjust
)
5140 adjust
= -phdr
[i
].p_memsz
& 15;
5143 && phdr
[i
].p_filesz
!= 0
5144 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
> last
->p_vaddr
- adjust
5145 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
<= last
->p_vaddr
)
5148 if (phdr
[i
].p_filesz
!= 0)
5152 if (i
== (unsigned int) -1)
5153 for (i
= count
; i
-- != 0; )
5154 if (phdr
[i
].p_type
== PT_LOAD
)
5158 adjust
= -phdr
[i
].p_filesz
& 15;
5159 phdr
[i
].p_filesz
+= adjust
;
5161 adjust
= -phdr
[i
].p_memsz
& 15;
5162 phdr
[i
].p_memsz
+= adjust
;
5168 #define TARGET_BIG_SYM bfd_elf32_spu_vec
5169 #define TARGET_BIG_NAME "elf32-spu"
5170 #define ELF_ARCH bfd_arch_spu
5171 #define ELF_MACHINE_CODE EM_SPU
5172 /* This matches the alignment need for DMA. */
5173 #define ELF_MAXPAGESIZE 0x80
5174 #define elf_backend_rela_normal 1
5175 #define elf_backend_can_gc_sections 1
5177 #define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
5178 #define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
5179 #define elf_info_to_howto spu_elf_info_to_howto
5180 #define elf_backend_count_relocs spu_elf_count_relocs
5181 #define elf_backend_relocate_section spu_elf_relocate_section
5182 #define elf_backend_symbol_processing spu_elf_backend_symbol_processing
5183 #define elf_backend_link_output_symbol_hook spu_elf_output_symbol_hook
5184 #define elf_backend_object_p spu_elf_object_p
5185 #define bfd_elf32_new_section_hook spu_elf_new_section_hook
5186 #define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
5188 #define elf_backend_additional_program_headers spu_elf_additional_program_headers
5189 #define elf_backend_modify_segment_map spu_elf_modify_segment_map
5190 #define elf_backend_modify_program_headers spu_elf_modify_program_headers
5191 #define elf_backend_post_process_headers spu_elf_post_process_headers
5192 #define elf_backend_fake_sections spu_elf_fake_sections
5193 #define elf_backend_special_sections spu_elf_special_sections
5194 #define bfd_elf32_bfd_final_link spu_elf_final_link
5196 #include "elf32-target.h"