1 /* SPU specific support for 32-bit ELF
3 Copyright 2006, 2007 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
27 #include "elf32-spu.h"
29 /* We use RELA style relocs. Don't define USE_REL. */
31 static bfd_reloc_status_type
spu_elf_rel9 (bfd
*, arelent
*, asymbol
*,
35 /* Values of type 'enum elf_spu_reloc_type' are used to index this
36 array, so it must be declared in the order of that type. */
38 static reloc_howto_type elf_howto_table
[] = {
39 HOWTO (R_SPU_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
40 bfd_elf_generic_reloc
, "SPU_NONE",
41 FALSE
, 0, 0x00000000, FALSE
),
42 HOWTO (R_SPU_ADDR10
, 4, 2, 10, FALSE
, 14, complain_overflow_bitfield
,
43 bfd_elf_generic_reloc
, "SPU_ADDR10",
44 FALSE
, 0, 0x00ffc000, FALSE
),
45 HOWTO (R_SPU_ADDR16
, 2, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
46 bfd_elf_generic_reloc
, "SPU_ADDR16",
47 FALSE
, 0, 0x007fff80, FALSE
),
48 HOWTO (R_SPU_ADDR16_HI
, 16, 2, 16, FALSE
, 7, complain_overflow_bitfield
,
49 bfd_elf_generic_reloc
, "SPU_ADDR16_HI",
50 FALSE
, 0, 0x007fff80, FALSE
),
51 HOWTO (R_SPU_ADDR16_LO
, 0, 2, 16, FALSE
, 7, complain_overflow_dont
,
52 bfd_elf_generic_reloc
, "SPU_ADDR16_LO",
53 FALSE
, 0, 0x007fff80, FALSE
),
54 HOWTO (R_SPU_ADDR18
, 0, 2, 18, FALSE
, 7, complain_overflow_bitfield
,
55 bfd_elf_generic_reloc
, "SPU_ADDR18",
56 FALSE
, 0, 0x01ffff80, FALSE
),
57 HOWTO (R_SPU_ADDR32
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
58 bfd_elf_generic_reloc
, "SPU_ADDR32",
59 FALSE
, 0, 0xffffffff, FALSE
),
60 HOWTO (R_SPU_REL16
, 2, 2, 16, TRUE
, 7, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "SPU_REL16",
62 FALSE
, 0, 0x007fff80, TRUE
),
63 HOWTO (R_SPU_ADDR7
, 0, 2, 7, FALSE
, 14, complain_overflow_dont
,
64 bfd_elf_generic_reloc
, "SPU_ADDR7",
65 FALSE
, 0, 0x001fc000, FALSE
),
66 HOWTO (R_SPU_REL9
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
67 spu_elf_rel9
, "SPU_REL9",
68 FALSE
, 0, 0x0180007f, TRUE
),
69 HOWTO (R_SPU_REL9I
, 2, 2, 9, TRUE
, 0, complain_overflow_signed
,
70 spu_elf_rel9
, "SPU_REL9I",
71 FALSE
, 0, 0x0000c07f, TRUE
),
72 HOWTO (R_SPU_ADDR10I
, 0, 2, 10, FALSE
, 14, complain_overflow_signed
,
73 bfd_elf_generic_reloc
, "SPU_ADDR10I",
74 FALSE
, 0, 0x00ffc000, FALSE
),
75 HOWTO (R_SPU_ADDR16I
, 0, 2, 16, FALSE
, 7, complain_overflow_signed
,
76 bfd_elf_generic_reloc
, "SPU_ADDR16I",
77 FALSE
, 0, 0x007fff80, FALSE
),
78 HOWTO (R_SPU_REL32
, 0, 2, 32, TRUE
, 0, complain_overflow_dont
,
79 bfd_elf_generic_reloc
, "SPU_REL32",
80 FALSE
, 0, 0xffffffff, TRUE
),
83 static struct bfd_elf_special_section
const spu_elf_special_sections
[] = {
84 { ".toe", 4, 0, SHT_NOBITS
, SHF_ALLOC
},
88 static enum elf_spu_reloc_type
89 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code
)
95 case BFD_RELOC_SPU_IMM10W
:
97 case BFD_RELOC_SPU_IMM16W
:
99 case BFD_RELOC_SPU_LO16
:
100 return R_SPU_ADDR16_LO
;
101 case BFD_RELOC_SPU_HI16
:
102 return R_SPU_ADDR16_HI
;
103 case BFD_RELOC_SPU_IMM18
:
105 case BFD_RELOC_SPU_PCREL16
:
107 case BFD_RELOC_SPU_IMM7
:
109 case BFD_RELOC_SPU_IMM8
:
111 case BFD_RELOC_SPU_PCREL9a
:
113 case BFD_RELOC_SPU_PCREL9b
:
115 case BFD_RELOC_SPU_IMM10
:
116 return R_SPU_ADDR10I
;
117 case BFD_RELOC_SPU_IMM16
:
118 return R_SPU_ADDR16I
;
121 case BFD_RELOC_32_PCREL
:
127 spu_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
129 Elf_Internal_Rela
*dst
)
131 enum elf_spu_reloc_type r_type
;
133 r_type
= (enum elf_spu_reloc_type
) ELF32_R_TYPE (dst
->r_info
);
134 BFD_ASSERT (r_type
< R_SPU_max
);
135 cache_ptr
->howto
= &elf_howto_table
[(int) r_type
];
138 static reloc_howto_type
*
139 spu_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
140 bfd_reloc_code_real_type code
)
142 return elf_howto_table
+ spu_elf_bfd_to_reloc_type (code
);
145 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs. */
147 static bfd_reloc_status_type
148 spu_elf_rel9 (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
149 void *data
, asection
*input_section
,
150 bfd
*output_bfd
, char **error_message
)
152 bfd_size_type octets
;
156 /* If this is a relocatable link (output_bfd test tells us), just
157 call the generic function. Any adjustment will be done at final
159 if (output_bfd
!= NULL
)
160 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
161 input_section
, output_bfd
, error_message
);
163 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
164 return bfd_reloc_outofrange
;
165 octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
167 /* Get symbol value. */
169 if (!bfd_is_com_section (symbol
->section
))
171 if (symbol
->section
->output_section
)
172 val
+= symbol
->section
->output_section
->vma
;
174 val
+= reloc_entry
->addend
;
176 /* Make it pc-relative. */
177 val
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
180 if (val
+ 256 >= 512)
181 return bfd_reloc_overflow
;
183 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
185 /* Move two high bits of value to REL9I and REL9 position.
186 The mask will take care of selecting the right field. */
187 val
= (val
& 0x7f) | ((val
& 0x180) << 7) | ((val
& 0x180) << 16);
188 insn
&= ~reloc_entry
->howto
->dst_mask
;
189 insn
|= val
& reloc_entry
->howto
->dst_mask
;
190 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
195 spu_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
197 if (!sec
->used_by_bfd
)
199 struct _spu_elf_section_data
*sdata
;
201 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
204 sec
->used_by_bfd
= sdata
;
207 return _bfd_elf_new_section_hook (abfd
, sec
);
210 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
211 strip --strip-unneeded will not remove them. */
214 spu_elf_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*sym
)
216 if (sym
->name
!= NULL
217 && sym
->section
!= bfd_abs_section_ptr
218 && strncmp (sym
->name
, "_EAR_", 5) == 0)
219 sym
->flags
|= BSF_KEEP
;
222 /* SPU ELF linker hash table. */
224 struct spu_link_hash_table
226 struct elf_link_hash_table elf
;
228 /* The stub hash table. */
229 struct bfd_hash_table stub_hash_table
;
231 /* Shortcuts to overlay sections. */
235 struct elf_link_hash_entry
*ovly_load
;
237 /* An array of two output sections per overlay region, chosen such that
238 the first section vma is the overlay buffer vma (ie. the section has
239 the lowest vma in the group that occupy the region), and the second
240 section vma+size specifies the end of the region. We keep pointers
241 to sections like this because section vmas may change when laying
243 asection
**ovl_region
;
245 /* Number of overlay buffers. */
246 unsigned int num_buf
;
248 /* Total number of overlays. */
249 unsigned int num_overlays
;
251 /* Set if we should emit symbols for stubs. */
252 unsigned int emit_stub_syms
:1;
254 /* Set if we want stubs on calls out of overlay regions to
255 non-overlay regions. */
256 unsigned int non_overlay_stubs
: 1;
259 unsigned int stub_overflow
: 1;
262 #define spu_hash_table(p) \
263 ((struct spu_link_hash_table *) ((p)->hash))
265 struct spu_stub_hash_entry
267 struct bfd_hash_entry root
;
269 /* Destination of this stub. */
270 asection
*target_section
;
273 /* Offset of entry in stub section. */
276 /* Offset from this stub to stub that loads the overlay index. */
280 /* Create an entry in a spu stub hash table. */
282 static struct bfd_hash_entry
*
283 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
284 struct bfd_hash_table
*table
,
287 /* Allocate the structure if it has not already been allocated by a
291 entry
= bfd_hash_allocate (table
, sizeof (struct spu_stub_hash_entry
));
296 /* Call the allocation method of the superclass. */
297 entry
= bfd_hash_newfunc (entry
, table
, string
);
300 struct spu_stub_hash_entry
*sh
= (struct spu_stub_hash_entry
*) entry
;
302 sh
->target_section
= NULL
;
311 /* Create a spu ELF linker hash table. */
313 static struct bfd_link_hash_table
*
314 spu_elf_link_hash_table_create (bfd
*abfd
)
316 struct spu_link_hash_table
*htab
;
318 htab
= bfd_malloc (sizeof (*htab
));
322 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
,
323 _bfd_elf_link_hash_newfunc
,
324 sizeof (struct elf_link_hash_entry
)))
330 /* Init the stub hash table too. */
331 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
332 sizeof (struct spu_stub_hash_entry
)))
335 memset (&htab
->stub
, 0,
336 sizeof (*htab
) - offsetof (struct spu_link_hash_table
, stub
));
338 return &htab
->elf
.root
;
341 /* Free the derived linker hash table. */
344 spu_elf_link_hash_table_free (struct bfd_link_hash_table
*hash
)
346 struct spu_link_hash_table
*ret
= (struct spu_link_hash_table
*) hash
;
348 bfd_hash_table_free (&ret
->stub_hash_table
);
349 _bfd_generic_link_hash_table_free (hash
);
352 /* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
353 to (hash, NULL) for global symbols, and (NULL, sym) for locals. Set
354 *SYMSECP to the symbol's section. *LOCSYMSP caches local syms. */
357 get_sym_h (struct elf_link_hash_entry
**hp
,
358 Elf_Internal_Sym
**symp
,
360 Elf_Internal_Sym
**locsymsp
,
361 unsigned long r_symndx
,
364 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
366 if (r_symndx
>= symtab_hdr
->sh_info
)
368 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
369 struct elf_link_hash_entry
*h
;
371 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
372 while (h
->root
.type
== bfd_link_hash_indirect
373 || h
->root
.type
== bfd_link_hash_warning
)
374 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
384 asection
*symsec
= NULL
;
385 if (h
->root
.type
== bfd_link_hash_defined
386 || h
->root
.type
== bfd_link_hash_defweak
)
387 symsec
= h
->root
.u
.def
.section
;
393 Elf_Internal_Sym
*sym
;
394 Elf_Internal_Sym
*locsyms
= *locsymsp
;
398 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
400 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
402 0, NULL
, NULL
, NULL
);
407 sym
= locsyms
+ r_symndx
;
417 asection
*symsec
= NULL
;
418 if ((sym
->st_shndx
!= SHN_UNDEF
419 && sym
->st_shndx
< SHN_LORESERVE
)
420 || sym
->st_shndx
> SHN_HIRESERVE
)
421 symsec
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
428 /* Build a name for an entry in the stub hash table. The input section
429 id isn't really necessary but we add that in for consistency with
430 ppc32 and ppc64 stub names. We can't use a local symbol name
431 because ld -r might generate duplicate local symbols. */
434 spu_stub_name (const asection
*input_sec
,
435 const asection
*sym_sec
,
436 const struct elf_link_hash_entry
*h
,
437 const Elf_Internal_Rela
*rel
)
444 len
= 8 + 1 + strlen (h
->root
.root
.string
) + 1 + 8 + 1;
445 stub_name
= bfd_malloc (len
);
446 if (stub_name
== NULL
)
449 sprintf (stub_name
, "%08x.%s+%x",
450 input_sec
->id
& 0xffffffff,
452 (int) rel
->r_addend
& 0xffffffff);
457 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
458 stub_name
= bfd_malloc (len
);
459 if (stub_name
== NULL
)
462 sprintf (stub_name
, "%08x.%x:%x+%x",
463 input_sec
->id
& 0xffffffff,
464 sym_sec
->id
& 0xffffffff,
465 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
466 (int) rel
->r_addend
& 0xffffffff);
467 len
= strlen (stub_name
);
470 if (stub_name
[len
- 2] == '+'
471 && stub_name
[len
- 1] == '0'
472 && stub_name
[len
] == 0)
473 stub_name
[len
- 2] = 0;
478 /* Create the note section if not already present. This is done early so
479 that the linker maps the sections to the right place in the output. */
482 spu_elf_create_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
486 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->next
)
487 if (bfd_get_section_by_name (ibfd
, SPU_PTNOTE_SPUNAME
) != NULL
)
492 /* Make SPU_PTNOTE_SPUNAME section. */
499 ibfd
= info
->input_bfds
;
500 flags
= SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
501 s
= bfd_make_section_anyway_with_flags (ibfd
, SPU_PTNOTE_SPUNAME
, flags
);
503 || !bfd_set_section_alignment (ibfd
, s
, 4))
506 name_len
= strlen (bfd_get_filename (output_bfd
)) + 1;
507 size
= 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4);
508 size
+= (name_len
+ 3) & -4;
510 if (!bfd_set_section_size (ibfd
, s
, size
))
513 data
= bfd_zalloc (ibfd
, size
);
517 bfd_put_32 (ibfd
, sizeof (SPU_PLUGIN_NAME
), data
+ 0);
518 bfd_put_32 (ibfd
, name_len
, data
+ 4);
519 bfd_put_32 (ibfd
, 1, data
+ 8);
520 memcpy (data
+ 12, SPU_PLUGIN_NAME
, sizeof (SPU_PLUGIN_NAME
));
521 memcpy (data
+ 12 + ((sizeof (SPU_PLUGIN_NAME
) + 3) & -4),
522 bfd_get_filename (output_bfd
), name_len
);
529 /* Return the section that should be marked against GC for a given
533 spu_elf_gc_mark_hook (asection
*sec
,
534 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
535 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
536 struct elf_link_hash_entry
*h
,
537 Elf_Internal_Sym
*sym
)
541 switch (h
->root
.type
)
543 case bfd_link_hash_defined
:
544 case bfd_link_hash_defweak
:
545 return h
->root
.u
.def
.section
;
547 case bfd_link_hash_common
:
548 return h
->root
.u
.c
.p
->section
;
555 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
560 /* qsort predicate to sort sections by vma. */
563 sort_sections (const void *a
, const void *b
)
565 const asection
*const *s1
= a
;
566 const asection
*const *s2
= b
;
567 bfd_signed_vma delta
= (*s1
)->vma
- (*s2
)->vma
;
570 return delta
< 0 ? -1 : 1;
572 return (*s1
)->index
- (*s2
)->index
;
575 /* Identify overlays in the output bfd, and number them. */
578 spu_elf_find_overlays (bfd
*output_bfd
, struct bfd_link_info
*info
)
580 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
581 asection
**alloc_sec
;
582 unsigned int i
, n
, ovl_index
, num_buf
;
586 if (output_bfd
->section_count
< 2)
589 alloc_sec
= bfd_malloc (output_bfd
->section_count
* sizeof (*alloc_sec
));
590 if (alloc_sec
== NULL
)
593 /* Pick out all the alloced sections. */
594 for (n
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
595 if ((s
->flags
& SEC_ALLOC
) != 0
596 && (s
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != SEC_THREAD_LOCAL
606 /* Sort them by vma. */
607 qsort (alloc_sec
, n
, sizeof (*alloc_sec
), sort_sections
);
609 /* Look for overlapping vmas. Any with overlap must be overlays.
610 Count them. Also count the number of overlay regions and for
611 each region save a section from that region with the lowest vma
612 and another section with the highest end vma. */
613 ovl_end
= alloc_sec
[0]->vma
+ alloc_sec
[0]->size
;
614 for (ovl_index
= 0, num_buf
= 0, i
= 1; i
< n
; i
++)
617 if (s
->vma
< ovl_end
)
619 asection
*s0
= alloc_sec
[i
- 1];
621 if (spu_elf_section_data (s0
)->ovl_index
== 0)
623 spu_elf_section_data (s0
)->ovl_index
= ++ovl_index
;
624 alloc_sec
[num_buf
* 2] = s0
;
625 alloc_sec
[num_buf
* 2 + 1] = s0
;
628 spu_elf_section_data (s
)->ovl_index
= ++ovl_index
;
629 if (ovl_end
< s
->vma
+ s
->size
)
631 ovl_end
= s
->vma
+ s
->size
;
632 alloc_sec
[num_buf
* 2 - 1] = s
;
636 ovl_end
= s
->vma
+ s
->size
;
639 htab
->num_overlays
= ovl_index
;
640 htab
->num_buf
= num_buf
;
647 alloc_sec
= bfd_realloc (alloc_sec
, num_buf
* 2 * sizeof (*alloc_sec
));
648 if (alloc_sec
== NULL
)
651 htab
->ovl_region
= alloc_sec
;
655 /* One of these per stub. */
656 #define SIZEOF_STUB1 8
657 #define ILA_79 0x4200004f /* ila $79,function_address */
658 #define BR 0x32000000 /* br stub2 */
660 /* One of these per overlay. */
661 #define SIZEOF_STUB2 8
662 #define ILA_78 0x4200004e /* ila $78,overlay_number */
664 #define NOP 0x40200000
666 /* Return true for all relative and absolute branch and hint instructions.
679 is_branch (const unsigned char *insn
)
681 return (((insn
[0] & 0xec) == 0x20 && (insn
[1] & 0x80) == 0)
682 || (insn
[0] & 0xfc) == 0x10);
686 struct spu_stub_hash_entry
**sh
;
690 /* Called via bfd_hash_traverse to set up pointers to all symbols
691 in the stub hash table. */
694 populate_stubs (struct bfd_hash_entry
*bh
, void *inf
)
696 struct stubarr
*stubs
= inf
;
698 stubs
->sh
[--stubs
->count
] = (struct spu_stub_hash_entry
*) bh
;
702 /* qsort predicate to sort stubs by overlay number. */
705 sort_stubs (const void *a
, const void *b
)
707 const struct spu_stub_hash_entry
*const *sa
= a
;
708 const struct spu_stub_hash_entry
*const *sb
= b
;
712 i
= spu_elf_section_data ((*sa
)->target_section
->output_section
)->ovl_index
;
713 i
-= spu_elf_section_data ((*sb
)->target_section
->output_section
)->ovl_index
;
717 d
= ((*sa
)->target_section
->output_section
->vma
718 + (*sa
)->target_section
->output_offset
720 - (*sb
)->target_section
->output_section
->vma
721 - (*sb
)->target_section
->output_offset
722 - (*sb
)->target_off
);
724 return d
< 0 ? -1 : 1;
726 /* Two functions at the same address. Aliases perhaps. */
727 i
= strcmp ((*sb
)->root
.string
, (*sa
)->root
.string
);
732 /* Allocate space for overlay call and return stubs. */
735 spu_elf_size_stubs (bfd
*output_bfd
,
736 struct bfd_link_info
*info
,
737 int non_overlay_stubs
,
742 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
744 struct stubarr stubs
;
748 htab
->non_overlay_stubs
= non_overlay_stubs
;
750 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
752 extern const bfd_target bfd_elf32_spu_vec
;
753 Elf_Internal_Shdr
*symtab_hdr
;
755 Elf_Internal_Sym
*local_syms
= NULL
;
757 if (ibfd
->xvec
!= &bfd_elf32_spu_vec
)
760 /* We'll need the symbol table in a second. */
761 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
762 if (symtab_hdr
->sh_info
== 0)
765 /* Walk over each section attached to the input bfd. */
766 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
768 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
770 /* If there aren't any relocs, then there's nothing more to do. */
771 if ((section
->flags
& SEC_RELOC
) == 0
772 || (section
->flags
& SEC_ALLOC
) == 0
773 || (section
->flags
& SEC_LOAD
) == 0
774 || section
->reloc_count
== 0)
777 /* If this section is a link-once section that will be
778 discarded, then don't create any stubs. */
779 if (section
->output_section
== NULL
780 || section
->output_section
->owner
!= output_bfd
)
783 /* Get the relocs. */
785 = _bfd_elf_link_read_relocs (ibfd
, section
, NULL
, NULL
,
787 if (internal_relocs
== NULL
)
788 goto error_ret_free_local
;
790 /* Now examine each relocation. */
791 irela
= internal_relocs
;
792 irelaend
= irela
+ section
->reloc_count
;
793 for (; irela
< irelaend
; irela
++)
795 enum elf_spu_reloc_type r_type
;
798 Elf_Internal_Sym
*sym
;
799 struct elf_link_hash_entry
*h
;
801 struct spu_stub_hash_entry
*sh
;
802 unsigned int sym_type
;
803 enum _insn_type
{ non_branch
, branch
, call
} insn_type
;
804 bfd_boolean is_setjmp
;
806 r_type
= ELF32_R_TYPE (irela
->r_info
);
807 r_indx
= ELF32_R_SYM (irela
->r_info
);
809 if (r_type
>= R_SPU_max
)
811 bfd_set_error (bfd_error_bad_value
);
812 goto error_ret_free_internal
;
815 /* Determine the reloc target section. */
816 if (!get_sym_h (&h
, &sym
, &sym_sec
, &local_syms
, r_indx
, ibfd
))
817 goto error_ret_free_internal
;
820 || sym_sec
->output_section
== NULL
821 || sym_sec
->output_section
->owner
!= output_bfd
)
824 /* Ensure no stubs for user supplied overlay manager syms. */
826 && (strcmp (h
->root
.root
.string
, "__ovly_load") == 0
827 || strcmp (h
->root
.root
.string
, "__ovly_return") == 0))
830 insn_type
= non_branch
;
831 if (r_type
== R_SPU_REL16
832 || r_type
== R_SPU_ADDR16
)
834 unsigned char insn
[4];
836 if (!bfd_get_section_contents (ibfd
, section
, insn
,
838 goto error_ret_free_internal
;
840 if (is_branch (insn
))
843 if ((insn
[0] & 0xfd) == 0x31)
848 /* We are only interested in function symbols. */
852 sym_type
= ELF_ST_TYPE (sym
->st_info
);
853 if (sym_type
!= STT_FUNC
)
855 /* It's common for people to write assembly and forget
856 to give function symbols the right type. Handle
857 calls to such symbols, but warn so that (hopefully)
858 people will fix their code. We need the symbol
859 type to be correct to distinguish function pointer
860 initialisation from other pointer initialisation. */
861 if (insn_type
== call
)
863 const char *sym_name
;
866 sym_name
= h
->root
.root
.string
;
868 sym_name
= bfd_elf_sym_name (sym_sec
->owner
,
873 (*_bfd_error_handler
) (_("warning: call to non-function"
874 " symbol %s defined in %B"),
875 sym_sec
->owner
, sym_name
);
881 /* setjmp always goes via an overlay stub, because
882 then the return and hence the longjmp goes via
883 __ovly_return. That magically makes setjmp/longjmp
884 between overlays work. */
885 is_setjmp
= (h
!= NULL
886 && strncmp (h
->root
.root
.string
, "setjmp", 6) == 0
887 && (h
->root
.root
.string
[6] == '\0'
888 || h
->root
.root
.string
[6] == '@'));
890 /* Usually, non-overlay sections don't need stubs. */
891 if (!spu_elf_section_data (sym_sec
->output_section
)->ovl_index
892 && !non_overlay_stubs
896 /* We need a reference from some other section before
897 we consider that a symbol might need an overlay stub. */
898 if (spu_elf_section_data (sym_sec
->output_section
)->ovl_index
899 == spu_elf_section_data (section
->output_section
)->ovl_index
902 /* Or we need this to *not* be a branch. ie. We are
903 possibly taking the address of a function and
904 passing it out somehow. */
905 if (insn_type
!= non_branch
)
909 stub_name
= spu_stub_name (section
, sym_sec
, h
, irela
);
910 if (stub_name
== NULL
)
911 goto error_ret_free_internal
;
913 sh
= (struct spu_stub_hash_entry
*)
914 bfd_hash_lookup (&htab
->stub_hash_table
, stub_name
,
919 error_ret_free_internal
:
920 if (elf_section_data (section
)->relocs
!= internal_relocs
)
921 free (internal_relocs
);
922 error_ret_free_local
:
923 if (local_syms
!= NULL
924 && (symtab_hdr
->contents
925 != (unsigned char *) local_syms
))
930 /* If this entry isn't new, we already have a stub. */
931 if (sh
->target_section
!= NULL
)
937 sh
->target_section
= sym_sec
;
939 sh
->target_off
= h
->root
.u
.def
.value
;
941 sh
->target_off
= sym
->st_value
;
942 sh
->target_off
+= irela
->r_addend
;
947 /* We're done with the internal relocs, free them. */
948 if (elf_section_data (section
)->relocs
!= internal_relocs
)
949 free (internal_relocs
);
952 if (local_syms
!= NULL
953 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
955 if (!info
->keep_memory
)
958 symtab_hdr
->contents
= (unsigned char *) local_syms
;
963 if (stubs
.count
== 0)
966 ibfd
= info
->input_bfds
;
967 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
968 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
969 htab
->stub
= bfd_make_section_anyway_with_flags (ibfd
, ".stub", flags
);
971 if (htab
->stub
== NULL
972 || !bfd_set_section_alignment (ibfd
, htab
->stub
, 2))
975 flags
= (SEC_ALLOC
| SEC_LOAD
976 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
);
977 htab
->ovtab
= bfd_make_section_anyway_with_flags (ibfd
, ".ovtab", flags
);
978 *ovtab
= htab
->ovtab
;
979 if (htab
->ovtab
== NULL
980 || !bfd_set_section_alignment (ibfd
, htab
->stub
, 4))
983 *toe
= bfd_make_section_anyway_with_flags (ibfd
, ".toe", SEC_ALLOC
);
985 || !bfd_set_section_alignment (ibfd
, *toe
, 4))
989 /* Retrieve all the stubs and sort. */
990 stubs
.sh
= bfd_malloc (stubs
.count
* sizeof (*stubs
.sh
));
991 if (stubs
.sh
== NULL
)
994 bfd_hash_traverse (&htab
->stub_hash_table
, populate_stubs
, &stubs
);
995 BFD_ASSERT (stubs
.count
== 0);
998 qsort (stubs
.sh
, stubs
.count
, sizeof (*stubs
.sh
), sort_stubs
);
1000 /* Now that the stubs are sorted, place them in the stub section.
1001 Stubs are grouped per overlay
1015 for (i
= 0; i
< stubs
.count
; i
++)
1017 if (spu_elf_section_data (stubs
.sh
[group
]->target_section
1018 ->output_section
)->ovl_index
1019 != spu_elf_section_data (stubs
.sh
[i
]->target_section
1020 ->output_section
)->ovl_index
)
1022 htab
->stub
->size
+= SIZEOF_STUB2
;
1023 for (; group
!= i
; group
++)
1024 stubs
.sh
[group
]->delta
1025 = stubs
.sh
[i
- 1]->off
- stubs
.sh
[group
]->off
;
1028 || ((stubs
.sh
[i
- 1]->target_section
->output_section
->vma
1029 + stubs
.sh
[i
- 1]->target_section
->output_offset
1030 + stubs
.sh
[i
- 1]->target_off
)
1031 != (stubs
.sh
[i
]->target_section
->output_section
->vma
1032 + stubs
.sh
[i
]->target_section
->output_offset
1033 + stubs
.sh
[i
]->target_off
)))
1035 stubs
.sh
[i
]->off
= htab
->stub
->size
;
1036 htab
->stub
->size
+= SIZEOF_STUB1
;
1039 stubs
.sh
[i
]->off
= stubs
.sh
[i
- 1]->off
;
1042 htab
->stub
->size
+= SIZEOF_STUB2
;
1043 for (; group
!= i
; group
++)
1044 stubs
.sh
[group
]->delta
= stubs
.sh
[i
- 1]->off
- stubs
.sh
[group
]->off
;
1046 /* htab->ovtab consists of two arrays.
1056 . } _ovly_buf_table[]; */
1058 htab
->ovtab
->alignment_power
= 4;
1059 htab
->ovtab
->size
= htab
->num_overlays
* 16 + htab
->num_buf
* 4;
1064 /* Functions to handle embedded spu_ovl.o object. */
1067 ovl_mgr_open (struct bfd
*nbfd ATTRIBUTE_UNUSED
, void *stream
)
1073 ovl_mgr_pread (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1079 struct _ovl_stream
*os
;
1083 os
= (struct _ovl_stream
*) stream
;
1084 max
= (const char *) os
->end
- (const char *) os
->start
;
1086 if ((ufile_ptr
) offset
>= max
)
1090 if (count
> max
- offset
)
1091 count
= max
- offset
;
1093 memcpy (buf
, (const char *) os
->start
+ offset
, count
);
1098 spu_elf_open_builtin_lib (bfd
**ovl_bfd
, const struct _ovl_stream
*stream
)
1100 *ovl_bfd
= bfd_openr_iovec ("builtin ovl_mgr",
1107 return *ovl_bfd
!= NULL
;
1110 /* Fill in the ila and br for a stub. On the last stub for a group,
1111 write the stub that sets the overlay number too. */
1114 write_one_stub (struct bfd_hash_entry
*bh
, void *inf
)
1116 struct spu_stub_hash_entry
*ent
= (struct spu_stub_hash_entry
*) bh
;
1117 struct spu_link_hash_table
*htab
= inf
;
1118 asection
*sec
= htab
->stub
;
1119 asection
*s
= ent
->target_section
;
1123 val
= ent
->target_off
+ s
->output_offset
+ s
->output_section
->vma
;
1124 bfd_put_32 (sec
->owner
, ILA_79
+ ((val
<< 7) & 0x01ffff80),
1125 sec
->contents
+ ent
->off
);
1126 val
= ent
->delta
+ 4;
1127 bfd_put_32 (sec
->owner
, BR
+ ((val
<< 5) & 0x007fff80),
1128 sec
->contents
+ ent
->off
+ 4);
1130 /* If this is the last stub of this group, write stub2. */
1131 if (ent
->delta
== 0)
1133 bfd_put_32 (sec
->owner
, NOP
,
1134 sec
->contents
+ ent
->off
+ 4);
1136 ovl
= spu_elf_section_data (s
->output_section
)->ovl_index
;
1137 bfd_put_32 (sec
->owner
, ILA_78
+ ((ovl
<< 7) & 0x01ffff80),
1138 sec
->contents
+ ent
->off
+ 8);
1140 val
= (htab
->ovly_load
->root
.u
.def
.section
->output_section
->vma
1141 + htab
->ovly_load
->root
.u
.def
.section
->output_offset
1142 + htab
->ovly_load
->root
.u
.def
.value
1143 - (sec
->output_section
->vma
1144 + sec
->output_offset
1147 if (val
+ 0x20000 >= 0x40000)
1148 htab
->stub_overflow
= TRUE
;
1150 bfd_put_32 (sec
->owner
, BR
+ ((val
<< 5) & 0x007fff80),
1151 sec
->contents
+ ent
->off
+ 12);
1154 if (htab
->emit_stub_syms
)
1156 struct elf_link_hash_entry
*h
;
1160 len1
= sizeof ("ovl_call.") - 1;
1161 len2
= strlen (ent
->root
.string
);
1162 name
= bfd_malloc (len1
+ len2
+ 1);
1165 memcpy (name
, ent
->root
.string
, 9);
1166 memcpy (name
+ 9, "ovl_call.", len1
);
1167 memcpy (name
+ 9 + len1
, ent
->root
.string
+ 9, len2
- 9 + 1);
1168 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
1171 if (h
->root
.type
== bfd_link_hash_new
)
1173 h
->root
.type
= bfd_link_hash_defined
;
1174 h
->root
.u
.def
.section
= sec
;
1175 h
->root
.u
.def
.value
= ent
->off
;
1176 h
->size
= (ent
->delta
== 0
1177 ? SIZEOF_STUB1
+ SIZEOF_STUB2
: SIZEOF_STUB1
);
1181 h
->ref_regular_nonweak
= 1;
1182 h
->forced_local
= 1;
1190 /* Define an STT_OBJECT symbol. */
1192 static struct elf_link_hash_entry
*
1193 define_ovtab_symbol (struct spu_link_hash_table
*htab
, const char *name
)
1195 struct elf_link_hash_entry
*h
;
1197 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
1201 if (h
->root
.type
!= bfd_link_hash_defined
1204 h
->root
.type
= bfd_link_hash_defined
;
1205 h
->root
.u
.def
.section
= htab
->ovtab
;
1206 h
->type
= STT_OBJECT
;
1209 h
->ref_regular_nonweak
= 1;
1214 (*_bfd_error_handler
) (_("%B is not allowed to define %s"),
1215 h
->root
.u
.def
.section
->owner
,
1216 h
->root
.root
.string
);
1217 bfd_set_error (bfd_error_bad_value
);
1224 /* Fill in all stubs and the overlay tables. */
1227 spu_elf_build_stubs (struct bfd_link_info
*info
, int emit_syms
, asection
*toe
)
1229 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1230 struct elf_link_hash_entry
*h
;
1236 htab
->emit_stub_syms
= emit_syms
;
1237 htab
->stub
->contents
= bfd_zalloc (htab
->stub
->owner
, htab
->stub
->size
);
1238 if (htab
->stub
->contents
== NULL
)
1241 h
= elf_link_hash_lookup (&htab
->elf
, "__ovly_load", FALSE
, FALSE
, FALSE
);
1242 htab
->ovly_load
= h
;
1243 BFD_ASSERT (h
!= NULL
1244 && (h
->root
.type
== bfd_link_hash_defined
1245 || h
->root
.type
== bfd_link_hash_defweak
)
1248 s
= h
->root
.u
.def
.section
->output_section
;
1249 if (spu_elf_section_data (s
)->ovl_index
)
1251 (*_bfd_error_handler
) (_("%s in overlay section"),
1252 h
->root
.u
.def
.section
->owner
);
1253 bfd_set_error (bfd_error_bad_value
);
1257 /* Write out all the stubs. */
1258 bfd_hash_traverse (&htab
->stub_hash_table
, write_one_stub
, htab
);
1260 if (htab
->stub_overflow
)
1262 (*_bfd_error_handler
) (_("overlay stub relocation overflow"));
1263 bfd_set_error (bfd_error_bad_value
);
1267 htab
->ovtab
->contents
= bfd_zalloc (htab
->ovtab
->owner
, htab
->ovtab
->size
);
1268 if (htab
->ovtab
->contents
== NULL
)
1271 /* Write out _ovly_table. */
1272 p
= htab
->ovtab
->contents
;
1273 obfd
= htab
->ovtab
->output_section
->owner
;
1274 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
1276 unsigned int ovl_index
= spu_elf_section_data (s
)->ovl_index
;
1280 unsigned int lo
, hi
, mid
;
1281 unsigned long off
= (ovl_index
- 1) * 16;
1282 bfd_put_32 (htab
->ovtab
->owner
, s
->vma
, p
+ off
);
1283 bfd_put_32 (htab
->ovtab
->owner
, (s
->size
+ 15) & -16, p
+ off
+ 4);
1284 /* file_off written later in spu_elf_modify_program_headers. */
1290 mid
= (lo
+ hi
) >> 1;
1291 if (htab
->ovl_region
[2 * mid
+ 1]->vma
1292 + htab
->ovl_region
[2 * mid
+ 1]->size
<= s
->vma
)
1294 else if (htab
->ovl_region
[2 * mid
]->vma
> s
->vma
)
1298 bfd_put_32 (htab
->ovtab
->owner
, mid
+ 1, p
+ off
+ 12);
1302 BFD_ASSERT (lo
< hi
);
1306 /* Write out _ovly_buf_table. */
1307 p
= htab
->ovtab
->contents
+ htab
->num_overlays
* 16;
1308 for (i
= 0; i
< htab
->num_buf
; i
++)
1310 bfd_put_32 (htab
->ovtab
->owner
, 0, p
);
1314 h
= define_ovtab_symbol (htab
, "_ovly_table");
1317 h
->root
.u
.def
.value
= 0;
1318 h
->size
= htab
->num_overlays
* 16;
1320 h
= define_ovtab_symbol (htab
, "_ovly_table_end");
1323 h
->root
.u
.def
.value
= htab
->num_overlays
* 16;
1326 h
= define_ovtab_symbol (htab
, "_ovly_buf_table");
1329 h
->root
.u
.def
.value
= htab
->num_overlays
* 16;
1330 h
->size
= htab
->num_buf
* 4;
1332 h
= define_ovtab_symbol (htab
, "_ovly_buf_table_end");
1335 h
->root
.u
.def
.value
= htab
->num_overlays
* 16 + htab
->num_buf
* 4;
1338 h
= define_ovtab_symbol (htab
, "_EAR_");
1341 h
->root
.u
.def
.section
= toe
;
1342 h
->root
.u
.def
.value
= 0;
1348 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD. */
1351 spu_elf_relocate_section (bfd
*output_bfd
,
1352 struct bfd_link_info
*info
,
1354 asection
*input_section
,
1356 Elf_Internal_Rela
*relocs
,
1357 Elf_Internal_Sym
*local_syms
,
1358 asection
**local_sections
)
1360 Elf_Internal_Shdr
*symtab_hdr
;
1361 struct elf_link_hash_entry
**sym_hashes
;
1362 Elf_Internal_Rela
*rel
, *relend
;
1363 struct spu_link_hash_table
*htab
;
1364 bfd_boolean ret
= TRUE
;
1366 htab
= spu_hash_table (info
);
1367 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1368 sym_hashes
= (struct elf_link_hash_entry
**) (elf_sym_hashes (input_bfd
));
1371 relend
= relocs
+ input_section
->reloc_count
;
1372 for (; rel
< relend
; rel
++)
1375 reloc_howto_type
*howto
;
1376 unsigned long r_symndx
;
1377 Elf_Internal_Sym
*sym
;
1379 struct elf_link_hash_entry
*h
;
1380 const char *sym_name
;
1383 bfd_reloc_status_type r
;
1384 bfd_boolean unresolved_reloc
;
1387 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1388 r_type
= ELF32_R_TYPE (rel
->r_info
);
1389 howto
= elf_howto_table
+ r_type
;
1390 unresolved_reloc
= FALSE
;
1396 if (r_symndx
< symtab_hdr
->sh_info
)
1398 sym
= local_syms
+ r_symndx
;
1399 sec
= local_sections
[r_symndx
];
1400 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
1401 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1405 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1406 r_symndx
, symtab_hdr
, sym_hashes
,
1408 unresolved_reloc
, warned
);
1409 sym_name
= h
->root
.root
.string
;
1412 if (sec
!= NULL
&& elf_discarded_section (sec
))
1414 /* For relocs against symbols from removed linkonce sections,
1415 or sections discarded by a linker script, we just want the
1416 section contents zeroed. Avoid any special processing. */
1417 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
1423 if (info
->relocatable
)
1426 if (unresolved_reloc
)
1428 (*_bfd_error_handler
)
1429 (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
1431 bfd_get_section_name (input_bfd
, input_section
),
1432 (long) rel
->r_offset
,
1438 /* If this symbol is in an overlay area, we may need to relocate
1439 to the overlay stub. */
1440 addend
= rel
->r_addend
;
1442 && sec
->output_section
!= NULL
1443 && sec
->output_section
->owner
== output_bfd
1444 && (spu_elf_section_data (sec
->output_section
)->ovl_index
!= 0
1445 || htab
->non_overlay_stubs
)
1446 && !(sec
== input_section
1447 && is_branch (contents
+ rel
->r_offset
)))
1450 struct spu_stub_hash_entry
*sh
;
1452 stub_name
= spu_stub_name (input_section
, sec
, h
, rel
);
1453 if (stub_name
== NULL
)
1456 sh
= (struct spu_stub_hash_entry
*)
1457 bfd_hash_lookup (&htab
->stub_hash_table
, stub_name
, FALSE
, FALSE
);
1460 relocation
= (htab
->stub
->output_section
->vma
1461 + htab
->stub
->output_offset
1468 r
= _bfd_final_link_relocate (howto
,
1472 rel
->r_offset
, relocation
, addend
);
1474 if (r
!= bfd_reloc_ok
)
1476 const char *msg
= (const char *) 0;
1480 case bfd_reloc_overflow
:
1481 if (!((*info
->callbacks
->reloc_overflow
)
1482 (info
, (h
? &h
->root
: NULL
), sym_name
, howto
->name
,
1483 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
)))
1487 case bfd_reloc_undefined
:
1488 if (!((*info
->callbacks
->undefined_symbol
)
1489 (info
, sym_name
, input_bfd
, input_section
,
1490 rel
->r_offset
, TRUE
)))
1494 case bfd_reloc_outofrange
:
1495 msg
= _("internal error: out of range error");
1498 case bfd_reloc_notsupported
:
1499 msg
= _("internal error: unsupported relocation error");
1502 case bfd_reloc_dangerous
:
1503 msg
= _("internal error: dangerous error");
1507 msg
= _("internal error: unknown error");
1511 if (!((*info
->callbacks
->warning
)
1512 (info
, msg
, sym_name
, input_bfd
, input_section
,
1523 static int spu_plugin
= 0;
1526 spu_elf_plugin (int val
)
1531 /* Set ELF header e_type for plugins. */
1534 spu_elf_post_process_headers (bfd
*abfd
,
1535 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1539 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1541 i_ehdrp
->e_type
= ET_DYN
;
1545 /* We may add an extra PT_LOAD segment for .toe. We also need extra
1546 segments for overlays. */
1549 spu_elf_additional_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
1551 struct spu_link_hash_table
*htab
= spu_hash_table (info
);
1552 int extra
= htab
->num_overlays
;
1558 sec
= bfd_get_section_by_name (abfd
, ".toe");
1559 if (sec
!= NULL
&& (sec
->flags
& SEC_LOAD
) != 0)
1565 /* Remove .toe section from other PT_LOAD segments and put it in
1566 a segment of its own. Put overlays in separate segments too. */
1569 spu_elf_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
1572 struct elf_segment_map
*m
;
1578 toe
= bfd_get_section_by_name (abfd
, ".toe");
1579 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1580 if (m
->p_type
== PT_LOAD
&& m
->count
> 1)
1581 for (i
= 0; i
< m
->count
; i
++)
1582 if ((s
= m
->sections
[i
]) == toe
1583 || spu_elf_section_data (s
)->ovl_index
!= 0)
1585 struct elf_segment_map
*m2
;
1588 if (i
+ 1 < m
->count
)
1590 amt
= sizeof (struct elf_segment_map
);
1591 amt
+= (m
->count
- (i
+ 2)) * sizeof (m
->sections
[0]);
1592 m2
= bfd_zalloc (abfd
, amt
);
1595 m2
->count
= m
->count
- (i
+ 1);
1596 memcpy (m2
->sections
, m
->sections
+ i
+ 1,
1597 m2
->count
* sizeof (m
->sections
[0]));
1598 m2
->p_type
= PT_LOAD
;
1606 amt
= sizeof (struct elf_segment_map
);
1607 m2
= bfd_zalloc (abfd
, amt
);
1610 m2
->p_type
= PT_LOAD
;
1612 m2
->sections
[0] = s
;
1622 /* Check that all loadable section VMAs lie in the range
1623 LO .. HI inclusive. */
1626 spu_elf_check_vma (bfd
*abfd
, bfd_vma lo
, bfd_vma hi
)
1628 struct elf_segment_map
*m
;
1631 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1632 if (m
->p_type
== PT_LOAD
)
1633 for (i
= 0; i
< m
->count
; i
++)
1634 if (m
->sections
[i
]->size
!= 0
1635 && (m
->sections
[i
]->vma
< lo
1636 || m
->sections
[i
]->vma
> hi
1637 || m
->sections
[i
]->vma
+ m
->sections
[i
]->size
- 1 > hi
))
1638 return m
->sections
[i
];
1643 /* Tweak phdrs before writing them out. */
1646 spu_elf_modify_program_headers (bfd
*abfd
, struct bfd_link_info
*info
)
1648 const struct elf_backend_data
*bed
;
1649 struct elf_obj_tdata
*tdata
;
1650 Elf_Internal_Phdr
*phdr
, *last
;
1651 struct spu_link_hash_table
*htab
;
1658 bed
= get_elf_backend_data (abfd
);
1659 tdata
= elf_tdata (abfd
);
1661 count
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
1662 htab
= spu_hash_table (info
);
1663 if (htab
->num_overlays
!= 0)
1665 struct elf_segment_map
*m
;
1668 for (i
= 0, m
= elf_tdata (abfd
)->segment_map
; m
; ++i
, m
= m
->next
)
1670 && (o
= spu_elf_section_data (m
->sections
[0])->ovl_index
) != 0)
1672 /* Mark this as an overlay header. */
1673 phdr
[i
].p_flags
|= PF_OVERLAY
;
1675 if (htab
->ovtab
!= NULL
&& htab
->ovtab
->size
!= 0)
1677 bfd_byte
*p
= htab
->ovtab
->contents
;
1678 unsigned int off
= (o
- 1) * 16 + 8;
1680 /* Write file_off into _ovly_table. */
1681 bfd_put_32 (htab
->ovtab
->owner
, phdr
[i
].p_offset
, p
+ off
);
1686 /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
1687 of 16. This should always be possible when using the standard
1688 linker scripts, but don't create overlapping segments if
1689 someone is playing games with linker scripts. */
1691 for (i
= count
; i
-- != 0; )
1692 if (phdr
[i
].p_type
== PT_LOAD
)
1696 adjust
= -phdr
[i
].p_filesz
& 15;
1699 && phdr
[i
].p_offset
+ phdr
[i
].p_filesz
> last
->p_offset
- adjust
)
1702 adjust
= -phdr
[i
].p_memsz
& 15;
1705 && phdr
[i
].p_filesz
!= 0
1706 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
> last
->p_vaddr
- adjust
1707 && phdr
[i
].p_vaddr
+ phdr
[i
].p_memsz
<= last
->p_vaddr
)
1710 if (phdr
[i
].p_filesz
!= 0)
1714 if (i
== (unsigned int) -1)
1715 for (i
= count
; i
-- != 0; )
1716 if (phdr
[i
].p_type
== PT_LOAD
)
1720 adjust
= -phdr
[i
].p_filesz
& 15;
1721 phdr
[i
].p_filesz
+= adjust
;
1723 adjust
= -phdr
[i
].p_memsz
& 15;
1724 phdr
[i
].p_memsz
+= adjust
;
1730 /* Arrange for our linker created section to be output. */
1733 spu_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
1734 Elf_Internal_Shdr
*i_shdrp
)
1738 sec
= i_shdrp
->bfd_section
;
1740 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1741 && sec
->name
!= NULL
1742 && strcmp (sec
->name
, SPU_PTNOTE_SPUNAME
) == 0)
1743 i_shdrp
->contents
= sec
->contents
;
1748 #define TARGET_BIG_SYM bfd_elf32_spu_vec
1749 #define TARGET_BIG_NAME "elf32-spu"
1750 #define ELF_ARCH bfd_arch_spu
1751 #define ELF_MACHINE_CODE EM_SPU
1752 /* This matches the alignment need for DMA. */
1753 #define ELF_MAXPAGESIZE 0x80
1754 #define elf_backend_rela_normal 1
1755 #define elf_backend_can_gc_sections 1
1757 #define bfd_elf32_bfd_reloc_type_lookup spu_elf_reloc_type_lookup
1758 #define elf_info_to_howto spu_elf_info_to_howto
1759 #define elf_backend_gc_mark_hook spu_elf_gc_mark_hook
1760 #define elf_backend_relocate_section spu_elf_relocate_section
1761 #define elf_backend_symbol_processing spu_elf_backend_symbol_processing
1762 #define bfd_elf32_new_section_hook spu_elf_new_section_hook
1763 #define bfd_elf32_bfd_link_hash_table_create spu_elf_link_hash_table_create
1764 #define bfd_elf32_bfd_link_hash_table_free spu_elf_link_hash_table_free
1766 #define elf_backend_additional_program_headers spu_elf_additional_program_headers
1767 #define elf_backend_modify_segment_map spu_elf_modify_segment_map
1768 #define elf_backend_modify_program_headers spu_elf_modify_program_headers
1769 #define elf_backend_post_process_headers spu_elf_post_process_headers
1770 #define elf_backend_section_processing spu_elf_section_processing
1771 #define elf_backend_special_sections spu_elf_special_sections
1773 #include "elf32-target.h"