1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007 Free Software Foundation, Inc.
4 Contributed by Ian Lance Taylor, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "elf-vxworks.h"
30 #include "libiberty.h"
31 #include "../opcodes/sh-opc.h"
33 static bfd_reloc_status_type sh_elf_reloc
34 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
35 static bfd_reloc_status_type sh_elf_ignore_reloc
36 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
37 static bfd_boolean sh_elf_relax_delete_bytes
38 (bfd
*, asection
*, bfd_vma
, int);
39 static bfd_boolean sh_elf_align_loads
40 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_boolean
*);
42 static bfd_boolean sh_elf_swap_insns
43 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
45 static int sh_elf_optimized_tls_reloc
46 (struct bfd_link_info
*, int, int);
47 static bfd_vma dtpoff_base
48 (struct bfd_link_info
*);
50 (struct bfd_link_info
*, bfd_vma
);
52 /* The name of the dynamic interpreter. This is put in the .interp
55 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
57 #define MINUS_ONE ((bfd_vma) 0 - 1)
59 #define SH_PARTIAL32 TRUE
60 #define SH_SRC_MASK32 0xffffffff
61 #define SH_ELF_RELOC sh_elf_reloc
62 static reloc_howto_type sh_elf_howto_table
[] =
64 #include "elf32-sh-relocs.h"
67 #define SH_PARTIAL32 FALSE
68 #define SH_SRC_MASK32 0
69 #define SH_ELF_RELOC bfd_elf_generic_reloc
70 static reloc_howto_type sh_vxworks_howto_table
[] =
72 #include "elf32-sh-relocs.h"
75 /* Return true if OUTPUT_BFD is a VxWorks object. */
78 vxworks_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
80 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
81 extern const bfd_target bfd_elf32_shlvxworks_vec
;
82 extern const bfd_target bfd_elf32_shvxworks_vec
;
84 return (abfd
->xvec
== &bfd_elf32_shlvxworks_vec
85 || abfd
->xvec
== &bfd_elf32_shvxworks_vec
);
91 /* Return the howto table for ABFD. */
93 static reloc_howto_type
*
94 get_howto_table (bfd
*abfd
)
96 if (vxworks_object_p (abfd
))
97 return sh_vxworks_howto_table
;
98 return sh_elf_howto_table
;
101 static bfd_reloc_status_type
102 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
103 asection
*input_section
, bfd_byte
*contents
,
104 bfd_vma addr
, asection
*symbol_section
,
105 bfd_vma start
, bfd_vma end
)
107 static bfd_vma last_addr
;
108 static asection
*last_symbol_section
;
109 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
114 /* Sanity check the address. */
115 if (addr
> bfd_get_section_limit (input_bfd
, input_section
))
116 return bfd_reloc_outofrange
;
118 /* We require the start and end relocations to be processed consecutively -
119 although we allow then to be processed forwards or backwards. */
123 last_symbol_section
= symbol_section
;
126 if (last_addr
!= addr
)
130 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
131 return bfd_reloc_outofrange
;
133 /* Get the symbol_section contents. */
134 if (symbol_section
!= input_section
)
136 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
137 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
140 if (!bfd_malloc_and_get_section (input_bfd
, symbol_section
,
143 if (contents
!= NULL
)
145 return bfd_reloc_outofrange
;
149 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
150 start_ptr
= contents
+ start
;
151 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
153 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
156 diff
= (last_ptr
- ptr
) >> 1;
157 cum_diff
+= diff
& 1;
160 /* Calculate the start / end values to load into rs / re minus four -
161 so that will cancel out the four we would otherwise have to add to
162 addr to get the value to subtract in order to get relative addressing. */
166 end
= (ptr
+ cum_diff
* 2) - contents
;
170 bfd_vma start0
= start
- 4;
172 while (start0
&& IS_PPI (contents
+ start0
))
174 start0
= start
- 2 - ((start
- start0
) & 2);
175 start
= start0
- cum_diff
- 2;
180 && elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
183 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
185 x
= (insn
& 0x200 ? end
: start
) - addr
;
186 if (input_section
!= symbol_section
)
187 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
188 - (input_section
->output_section
->vma
189 + input_section
->output_offset
));
191 if (x
< -128 || x
> 127)
192 return bfd_reloc_overflow
;
194 x
= (insn
& ~0xff) | (x
& 0xff);
195 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
200 /* This function is used for normal relocs. This used to be like the COFF
201 function, and is almost certainly incorrect for other ELF targets. */
203 static bfd_reloc_status_type
204 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
205 void *data
, asection
*input_section
, bfd
*output_bfd
,
206 char **error_message ATTRIBUTE_UNUSED
)
210 enum elf_sh_reloc_type r_type
;
211 bfd_vma addr
= reloc_entry
->address
;
212 bfd_byte
*hit_data
= addr
+ (bfd_byte
*) data
;
214 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
216 if (output_bfd
!= NULL
)
218 /* Partial linking--do nothing. */
219 reloc_entry
->address
+= input_section
->output_offset
;
223 /* Almost all relocs have to do with relaxing. If any work must be
224 done for them, it has been done in sh_relax_section. */
225 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
228 if (symbol_in
!= NULL
229 && bfd_is_und_section (symbol_in
->section
))
230 return bfd_reloc_undefined
;
232 if (bfd_is_com_section (symbol_in
->section
))
235 sym_value
= (symbol_in
->value
+
236 symbol_in
->section
->output_section
->vma
+
237 symbol_in
->section
->output_offset
);
242 insn
= bfd_get_32 (abfd
, hit_data
);
243 insn
+= sym_value
+ reloc_entry
->addend
;
244 bfd_put_32 (abfd
, (bfd_vma
) insn
, hit_data
);
247 insn
= bfd_get_16 (abfd
, hit_data
);
248 sym_value
+= reloc_entry
->addend
;
249 sym_value
-= (input_section
->output_section
->vma
250 + input_section
->output_offset
253 sym_value
+= (insn
& 0xfff) << 1;
256 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
257 bfd_put_16 (abfd
, (bfd_vma
) insn
, hit_data
);
258 if (sym_value
< (bfd_vma
) -0x1000 || sym_value
>= 0x1000)
259 return bfd_reloc_overflow
;
269 /* This function is used for relocs which are only used for relaxing,
270 which the linker should otherwise ignore. */
272 static bfd_reloc_status_type
273 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
274 asymbol
*symbol ATTRIBUTE_UNUSED
,
275 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
277 char **error_message ATTRIBUTE_UNUSED
)
279 if (output_bfd
!= NULL
)
280 reloc_entry
->address
+= input_section
->output_offset
;
284 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
288 bfd_reloc_code_real_type bfd_reloc_val
;
289 unsigned char elf_reloc_val
;
292 /* An array mapping BFD reloc codes to SH ELF relocs. */
294 static const struct elf_reloc_map sh_reloc_map
[] =
296 { BFD_RELOC_NONE
, R_SH_NONE
},
297 { BFD_RELOC_32
, R_SH_DIR32
},
298 { BFD_RELOC_16
, R_SH_DIR16
},
299 { BFD_RELOC_8
, R_SH_DIR8
},
300 { BFD_RELOC_CTOR
, R_SH_DIR32
},
301 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
302 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
303 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
304 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
305 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
306 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
307 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
308 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
309 { BFD_RELOC_SH_USES
, R_SH_USES
},
310 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
311 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
312 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
313 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
314 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
315 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
316 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
317 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
318 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
319 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
320 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
321 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
322 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
323 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
324 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
325 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
326 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
327 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
328 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
329 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
330 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
331 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
332 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
333 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
334 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
335 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
336 #ifdef INCLUDE_SHMEDIA
337 { BFD_RELOC_SH_GOT_LOW16
, R_SH_GOT_LOW16
},
338 { BFD_RELOC_SH_GOT_MEDLOW16
, R_SH_GOT_MEDLOW16
},
339 { BFD_RELOC_SH_GOT_MEDHI16
, R_SH_GOT_MEDHI16
},
340 { BFD_RELOC_SH_GOT_HI16
, R_SH_GOT_HI16
},
341 { BFD_RELOC_SH_GOTPLT_LOW16
, R_SH_GOTPLT_LOW16
},
342 { BFD_RELOC_SH_GOTPLT_MEDLOW16
, R_SH_GOTPLT_MEDLOW16
},
343 { BFD_RELOC_SH_GOTPLT_MEDHI16
, R_SH_GOTPLT_MEDHI16
},
344 { BFD_RELOC_SH_GOTPLT_HI16
, R_SH_GOTPLT_HI16
},
345 { BFD_RELOC_SH_PLT_LOW16
, R_SH_PLT_LOW16
},
346 { BFD_RELOC_SH_PLT_MEDLOW16
, R_SH_PLT_MEDLOW16
},
347 { BFD_RELOC_SH_PLT_MEDHI16
, R_SH_PLT_MEDHI16
},
348 { BFD_RELOC_SH_PLT_HI16
, R_SH_PLT_HI16
},
349 { BFD_RELOC_SH_GOTOFF_LOW16
, R_SH_GOTOFF_LOW16
},
350 { BFD_RELOC_SH_GOTOFF_MEDLOW16
, R_SH_GOTOFF_MEDLOW16
},
351 { BFD_RELOC_SH_GOTOFF_MEDHI16
, R_SH_GOTOFF_MEDHI16
},
352 { BFD_RELOC_SH_GOTOFF_HI16
, R_SH_GOTOFF_HI16
},
353 { BFD_RELOC_SH_GOTPC_LOW16
, R_SH_GOTPC_LOW16
},
354 { BFD_RELOC_SH_GOTPC_MEDLOW16
, R_SH_GOTPC_MEDLOW16
},
355 { BFD_RELOC_SH_GOTPC_MEDHI16
, R_SH_GOTPC_MEDHI16
},
356 { BFD_RELOC_SH_GOTPC_HI16
, R_SH_GOTPC_HI16
},
357 { BFD_RELOC_SH_COPY64
, R_SH_COPY64
},
358 { BFD_RELOC_SH_GLOB_DAT64
, R_SH_GLOB_DAT64
},
359 { BFD_RELOC_SH_JMP_SLOT64
, R_SH_JMP_SLOT64
},
360 { BFD_RELOC_SH_RELATIVE64
, R_SH_RELATIVE64
},
361 { BFD_RELOC_SH_GOT10BY4
, R_SH_GOT10BY4
},
362 { BFD_RELOC_SH_GOT10BY8
, R_SH_GOT10BY8
},
363 { BFD_RELOC_SH_GOTPLT10BY4
, R_SH_GOTPLT10BY4
},
364 { BFD_RELOC_SH_GOTPLT10BY8
, R_SH_GOTPLT10BY8
},
365 { BFD_RELOC_SH_PT_16
, R_SH_PT_16
},
366 { BFD_RELOC_SH_SHMEDIA_CODE
, R_SH_SHMEDIA_CODE
},
367 { BFD_RELOC_SH_IMMU5
, R_SH_DIR5U
},
368 { BFD_RELOC_SH_IMMS6
, R_SH_DIR6S
},
369 { BFD_RELOC_SH_IMMU6
, R_SH_DIR6U
},
370 { BFD_RELOC_SH_IMMS10
, R_SH_DIR10S
},
371 { BFD_RELOC_SH_IMMS10BY2
, R_SH_DIR10SW
},
372 { BFD_RELOC_SH_IMMS10BY4
, R_SH_DIR10SL
},
373 { BFD_RELOC_SH_IMMS10BY8
, R_SH_DIR10SQ
},
374 { BFD_RELOC_SH_IMMS16
, R_SH_IMMS16
},
375 { BFD_RELOC_SH_IMMU16
, R_SH_IMMU16
},
376 { BFD_RELOC_SH_IMM_LOW16
, R_SH_IMM_LOW16
},
377 { BFD_RELOC_SH_IMM_LOW16_PCREL
, R_SH_IMM_LOW16_PCREL
},
378 { BFD_RELOC_SH_IMM_MEDLOW16
, R_SH_IMM_MEDLOW16
},
379 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL
, R_SH_IMM_MEDLOW16_PCREL
},
380 { BFD_RELOC_SH_IMM_MEDHI16
, R_SH_IMM_MEDHI16
},
381 { BFD_RELOC_SH_IMM_MEDHI16_PCREL
, R_SH_IMM_MEDHI16_PCREL
},
382 { BFD_RELOC_SH_IMM_HI16
, R_SH_IMM_HI16
},
383 { BFD_RELOC_SH_IMM_HI16_PCREL
, R_SH_IMM_HI16_PCREL
},
384 { BFD_RELOC_64
, R_SH_64
},
385 { BFD_RELOC_64_PCREL
, R_SH_64_PCREL
},
386 #endif /* not INCLUDE_SHMEDIA */
389 /* Given a BFD reloc code, return the howto structure for the
390 corresponding SH ELF reloc. */
392 static reloc_howto_type
*
393 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
397 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
399 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
400 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
406 static reloc_howto_type
*
407 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
411 if (vxworks_object_p (abfd
))
414 i
< (sizeof (sh_vxworks_howto_table
)
415 / sizeof (sh_vxworks_howto_table
[0]));
417 if (sh_vxworks_howto_table
[i
].name
!= NULL
418 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
419 return &sh_vxworks_howto_table
[i
];
424 i
< (sizeof (sh_elf_howto_table
)
425 / sizeof (sh_elf_howto_table
[0]));
427 if (sh_elf_howto_table
[i
].name
!= NULL
428 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
429 return &sh_elf_howto_table
[i
];
435 /* Given an ELF reloc, fill in the howto field of a relent. */
438 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
442 r
= ELF32_R_TYPE (dst
->r_info
);
444 BFD_ASSERT (r
< (unsigned int) R_SH_max
);
445 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC
|| r
> R_SH_LAST_INVALID_RELOC
);
446 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_2
|| r
> R_SH_LAST_INVALID_RELOC_2
);
447 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_3
|| r
> R_SH_LAST_INVALID_RELOC_3
);
448 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_4
|| r
> R_SH_LAST_INVALID_RELOC_4
);
449 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_5
|| r
> R_SH_LAST_INVALID_RELOC_5
);
451 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
454 /* This function handles relaxing for SH ELF. See the corresponding
455 function in coff-sh.c for a description of what this does. FIXME:
456 There is a lot of duplication here between this code and the COFF
457 specific code. The format of relocs and symbols is wound deeply
458 into this code, but it would still be better if the duplication
459 could be eliminated somehow. Note in particular that although both
460 functions use symbols like R_SH_CODE, those symbols have different
461 values; in coff-sh.c they come from include/coff/sh.h, whereas here
462 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
465 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
466 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
468 Elf_Internal_Shdr
*symtab_hdr
;
469 Elf_Internal_Rela
*internal_relocs
;
470 bfd_boolean have_code
;
471 Elf_Internal_Rela
*irel
, *irelend
;
472 bfd_byte
*contents
= NULL
;
473 Elf_Internal_Sym
*isymbuf
= NULL
;
477 if (link_info
->relocatable
478 || (sec
->flags
& SEC_RELOC
) == 0
479 || sec
->reloc_count
== 0)
482 #ifdef INCLUDE_SHMEDIA
483 if (elf_section_data (sec
)->this_hdr
.sh_flags
484 & (SHF_SH5_ISA32
| SHF_SH5_ISA32_MIXED
))
490 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
492 internal_relocs
= (_bfd_elf_link_read_relocs
493 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
494 link_info
->keep_memory
));
495 if (internal_relocs
== NULL
)
500 irelend
= internal_relocs
+ sec
->reloc_count
;
501 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
503 bfd_vma laddr
, paddr
, symval
;
505 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
508 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
511 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
514 /* Get the section contents. */
515 if (contents
== NULL
)
517 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
518 contents
= elf_section_data (sec
)->this_hdr
.contents
;
521 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
526 /* The r_addend field of the R_SH_USES reloc will point us to
527 the register load. The 4 is because the r_addend field is
528 computed as though it were a jump offset, which are based
529 from 4 bytes after the jump instruction. */
530 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
531 if (laddr
>= sec
->size
)
533 (*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
535 (unsigned long) irel
->r_offset
);
538 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
540 /* If the instruction is not mov.l NN,rN, we don't know what to
542 if ((insn
& 0xf000) != 0xd000)
544 ((*_bfd_error_handler
)
545 (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
546 abfd
, (unsigned long) irel
->r_offset
, insn
));
550 /* Get the address from which the register is being loaded. The
551 displacement in the mov.l instruction is quadrupled. It is a
552 displacement from four bytes after the movl instruction, but,
553 before adding in the PC address, two least significant bits
554 of the PC are cleared. We assume that the section is aligned
555 on a four byte boundary. */
558 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
559 if (paddr
>= sec
->size
)
561 ((*_bfd_error_handler
)
562 (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
563 abfd
, (unsigned long) irel
->r_offset
));
567 /* Get the reloc for the address from which the register is
568 being loaded. This reloc will tell us which function is
569 actually being called. */
570 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
571 if (irelfn
->r_offset
== paddr
572 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
574 if (irelfn
>= irelend
)
576 ((*_bfd_error_handler
)
577 (_("%B: 0x%lx: warning: could not find expected reloc"),
578 abfd
, (unsigned long) paddr
));
582 /* Read this BFD's symbols if we haven't done so already. */
583 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
585 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
587 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
588 symtab_hdr
->sh_info
, 0,
594 /* Get the value of the symbol referred to by the reloc. */
595 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
597 /* A local symbol. */
598 Elf_Internal_Sym
*isym
;
600 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
602 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
604 ((*_bfd_error_handler
)
605 (_("%B: 0x%lx: warning: symbol in unexpected section"),
606 abfd
, (unsigned long) paddr
));
610 symval
= (isym
->st_value
611 + sec
->output_section
->vma
612 + sec
->output_offset
);
617 struct elf_link_hash_entry
*h
;
619 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
620 h
= elf_sym_hashes (abfd
)[indx
];
621 BFD_ASSERT (h
!= NULL
);
622 if (h
->root
.type
!= bfd_link_hash_defined
623 && h
->root
.type
!= bfd_link_hash_defweak
)
625 /* This appears to be a reference to an undefined
626 symbol. Just ignore it--it will be caught by the
627 regular reloc processing. */
631 symval
= (h
->root
.u
.def
.value
632 + h
->root
.u
.def
.section
->output_section
->vma
633 + h
->root
.u
.def
.section
->output_offset
);
636 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
637 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
639 symval
+= irelfn
->r_addend
;
641 /* See if this function call can be shortened. */
644 + sec
->output_section
->vma
647 /* A branch to an address beyond ours might be increased by an
648 .align that doesn't move when bytes behind us are deleted.
649 So, we add some slop in this calculation to allow for
651 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
653 /* After all that work, we can't shorten this function call. */
657 /* Shorten the function call. */
659 /* For simplicity of coding, we are going to modify the section
660 contents, the section relocs, and the BFD symbol table. We
661 must tell the rest of the code not to free up this
662 information. It would be possible to instead create a table
663 of changes which have to be made, as is done in coff-mips.c;
664 that would be more work, but would require less memory when
665 the linker is run. */
667 elf_section_data (sec
)->relocs
= internal_relocs
;
668 elf_section_data (sec
)->this_hdr
.contents
= contents
;
669 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
671 /* Replace the jsr with a bsr. */
673 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
674 replace the jsr with a bsr. */
675 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
676 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
677 here, but that only checks if the symbol is an external symbol,
678 not if the symbol is in a different section. Besides, we need
679 a consistent meaning for the relocation, so we just assume here that
680 the value of the symbol is not available. */
682 /* We can't fully resolve this yet, because the external
683 symbol value may be changed by future relaxing. We let
684 the final link phase handle it. */
685 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
689 /* When we calculated the symbol "value" we had an offset in the
690 DIR32's word in memory (we read and add it above). However,
691 the jsr we create does NOT have this offset encoded, so we
692 have to add it to the addend to preserve it. */
693 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
695 /* See if there is another R_SH_USES reloc referring to the same
697 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
698 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
699 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
701 if (irelscan
< irelend
)
703 /* Some other function call depends upon this register load,
704 and we have not yet converted that function call.
705 Indeed, we may never be able to convert it. There is
706 nothing else we can do at this point. */
710 /* Look for a R_SH_COUNT reloc on the location where the
711 function address is stored. Do this before deleting any
712 bytes, to avoid confusion about the address. */
713 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
714 if (irelcount
->r_offset
== paddr
715 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
718 /* Delete the register load. */
719 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
722 /* That will change things, so, just in case it permits some
723 other function call to come within range, we should relax
724 again. Note that this is not required, and it may be slow. */
727 /* Now check whether we got a COUNT reloc. */
728 if (irelcount
>= irelend
)
730 ((*_bfd_error_handler
)
731 (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
732 abfd
, (unsigned long) paddr
));
736 /* The number of uses is stored in the r_addend field. We've
738 if (irelcount
->r_addend
== 0)
740 ((*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad count"),
742 (unsigned long) paddr
));
746 --irelcount
->r_addend
;
748 /* If there are no more uses, we can delete the address. Reload
749 the address from irelfn, in case it was changed by the
750 previous call to sh_elf_relax_delete_bytes. */
751 if (irelcount
->r_addend
== 0)
753 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
757 /* We've done all we can with that function call. */
760 /* Look for load and store instructions that we can align on four
762 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
767 /* Get the section contents. */
768 if (contents
== NULL
)
770 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
771 contents
= elf_section_data (sec
)->this_hdr
.contents
;
774 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
779 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
785 elf_section_data (sec
)->relocs
= internal_relocs
;
786 elf_section_data (sec
)->this_hdr
.contents
= contents
;
787 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
792 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
794 if (! link_info
->keep_memory
)
798 /* Cache the symbols for elf_link_input_bfd. */
799 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
804 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
806 if (! link_info
->keep_memory
)
810 /* Cache the section contents for elf_link_input_bfd. */
811 elf_section_data (sec
)->this_hdr
.contents
= contents
;
815 if (internal_relocs
!= NULL
816 && elf_section_data (sec
)->relocs
!= internal_relocs
)
817 free (internal_relocs
);
823 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
826 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
828 if (internal_relocs
!= NULL
829 && elf_section_data (sec
)->relocs
!= internal_relocs
)
830 free (internal_relocs
);
835 /* Delete some bytes from a section while relaxing. FIXME: There is a
836 lot of duplication between this function and sh_relax_delete_bytes
840 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
843 Elf_Internal_Shdr
*symtab_hdr
;
844 unsigned int sec_shndx
;
846 Elf_Internal_Rela
*irel
, *irelend
;
847 Elf_Internal_Rela
*irelalign
;
849 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
850 struct elf_link_hash_entry
**sym_hashes
;
851 struct elf_link_hash_entry
**end_hashes
;
852 unsigned int symcount
;
855 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
856 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
858 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
860 contents
= elf_section_data (sec
)->this_hdr
.contents
;
862 /* The deletion must stop at the next ALIGN reloc for an aligment
863 power larger than the number of bytes we are deleting. */
868 irel
= elf_section_data (sec
)->relocs
;
869 irelend
= irel
+ sec
->reloc_count
;
870 for (; irel
< irelend
; irel
++)
872 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
873 && irel
->r_offset
> addr
874 && count
< (1 << irel
->r_addend
))
877 toaddr
= irel
->r_offset
;
882 /* Actually delete the bytes. */
883 memmove (contents
+ addr
, contents
+ addr
+ count
,
884 (size_t) (toaddr
- addr
- count
));
885 if (irelalign
== NULL
)
891 #define NOP_OPCODE (0x0009)
893 BFD_ASSERT ((count
& 1) == 0);
894 for (i
= 0; i
< count
; i
+= 2)
895 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
898 /* Adjust all the relocs. */
899 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
901 bfd_vma nraddr
, stop
;
904 int off
, adjust
, oinsn
;
905 bfd_signed_vma voff
= 0;
906 bfd_boolean overflow
;
908 /* Get the new reloc address. */
909 nraddr
= irel
->r_offset
;
910 if ((irel
->r_offset
> addr
911 && irel
->r_offset
< toaddr
)
912 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
913 && irel
->r_offset
== toaddr
))
916 /* See if this reloc was for the bytes we have deleted, in which
917 case we no longer care about it. Don't delete relocs which
918 represent addresses, though. */
919 if (irel
->r_offset
>= addr
920 && irel
->r_offset
< addr
+ count
921 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
922 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
923 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
924 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
925 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
928 /* If this is a PC relative reloc, see if the range it covers
929 includes the bytes we have deleted. */
930 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
939 start
= irel
->r_offset
;
940 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
944 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
951 /* If this reloc is against a symbol defined in this
952 section, and the symbol will not be adjusted below, we
953 must check the addend to see it will put the value in
954 range to be adjusted, and hence must be changed. */
955 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
957 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
958 if (isym
->st_shndx
== sec_shndx
959 && (isym
->st_value
<= addr
960 || isym
->st_value
>= toaddr
))
964 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
966 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
967 val
+= isym
->st_value
;
968 if (val
> addr
&& val
< toaddr
)
969 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
973 val
= isym
->st_value
+ irel
->r_addend
;
974 if (val
> addr
&& val
< toaddr
)
975 irel
->r_addend
-= count
;
986 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
993 /* This has been made by previous relaxation. Since the
994 relocation will be against an external symbol, the
995 final relocation will just do the right thing. */
1002 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1004 /* The addend will be against the section symbol, thus
1005 for adjusting the addend, the relevant start is the
1006 start of the section.
1007 N.B. If we want to abandon in-place changes here and
1008 test directly using symbol + addend, we have to take into
1009 account that the addend has already been adjusted by -4. */
1010 if (stop
> addr
&& stop
< toaddr
)
1011 irel
->r_addend
-= count
;
1017 stop
= start
+ 4 + off
* 2;
1022 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1028 /* These relocs types represent
1030 The r_addend field holds the difference between the reloc
1031 address and L1. That is the start of the reloc, and
1032 adding in the contents gives us the top. We must adjust
1033 both the r_offset field and the section contents.
1034 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1035 and the elf bfd r_offset is called r_vaddr. */
1037 stop
= irel
->r_offset
;
1038 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1042 && (stop
<= addr
|| stop
>= toaddr
))
1043 irel
->r_addend
+= count
;
1044 else if (stop
> addr
1046 && (start
<= addr
|| start
>= toaddr
))
1047 irel
->r_addend
-= count
;
1049 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1050 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1051 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1052 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1054 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1055 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1060 start
= irel
->r_offset
;
1061 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1062 + (long) irel
->r_addend
1069 && (stop
<= addr
|| stop
>= toaddr
))
1071 else if (stop
> addr
1073 && (start
<= addr
|| start
>= toaddr
))
1082 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1091 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1093 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1098 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1100 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1104 BFD_ASSERT (adjust
== count
|| count
>= 4);
1109 if ((irel
->r_offset
& 3) == 0)
1112 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1114 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1119 if (voff
< 0 || voff
>= 0xff)
1121 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1126 if (voff
< - 0x8000 || voff
>= 0x8000)
1128 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1133 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1137 irel
->r_addend
+= adjust
;
1143 ((*_bfd_error_handler
)
1144 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1145 abfd
, (unsigned long) irel
->r_offset
));
1146 bfd_set_error (bfd_error_bad_value
);
1151 irel
->r_offset
= nraddr
;
1154 /* Look through all the other sections. If there contain any IMM32
1155 relocs against internal symbols which we are not going to adjust
1156 below, we may need to adjust the addends. */
1157 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1159 Elf_Internal_Rela
*internal_relocs
;
1160 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1161 bfd_byte
*ocontents
;
1164 || (o
->flags
& SEC_RELOC
) == 0
1165 || o
->reloc_count
== 0)
1168 /* We always cache the relocs. Perhaps, if info->keep_memory is
1169 FALSE, we should free them, if we are permitted to, when we
1170 leave sh_coff_relax_section. */
1171 internal_relocs
= (_bfd_elf_link_read_relocs
1172 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
));
1173 if (internal_relocs
== NULL
)
1177 irelscanend
= internal_relocs
+ o
->reloc_count
;
1178 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1180 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1181 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1183 bfd_vma start
, stop
;
1184 bfd_signed_vma voff
;
1186 if (ocontents
== NULL
)
1188 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1189 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1192 /* We always cache the section contents.
1193 Perhaps, if info->keep_memory is FALSE, we
1194 should free them, if we are permitted to,
1195 when we leave sh_coff_relax_section. */
1196 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1198 if (ocontents
!= NULL
)
1203 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1207 stop
= irelscan
->r_offset
;
1209 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1211 /* STOP is in a different section, so it won't change. */
1212 if (start
> addr
&& start
< toaddr
)
1213 irelscan
->r_addend
+= count
;
1215 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1216 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1220 && (stop
<= addr
|| stop
>= toaddr
))
1221 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1222 ocontents
+ irelscan
->r_offset
);
1223 else if (stop
> addr
1225 && (start
<= addr
|| start
>= toaddr
))
1226 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1227 ocontents
+ irelscan
->r_offset
);
1230 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1233 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1237 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1238 if (isym
->st_shndx
== sec_shndx
1239 && (isym
->st_value
<= addr
1240 || isym
->st_value
>= toaddr
))
1244 if (ocontents
== NULL
)
1246 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1247 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1250 /* We always cache the section contents.
1251 Perhaps, if info->keep_memory is FALSE, we
1252 should free them, if we are permitted to,
1253 when we leave sh_coff_relax_section. */
1254 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1256 if (ocontents
!= NULL
)
1261 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1265 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1266 val
+= isym
->st_value
;
1267 if (val
> addr
&& val
< toaddr
)
1268 bfd_put_32 (abfd
, val
- count
,
1269 ocontents
+ irelscan
->r_offset
);
1274 /* Adjust the local symbols defined in this section. */
1275 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1276 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1278 if (isym
->st_shndx
== sec_shndx
1279 && isym
->st_value
> addr
1280 && isym
->st_value
< toaddr
)
1281 isym
->st_value
-= count
;
1284 /* Now adjust the global symbols defined in this section. */
1285 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1286 - symtab_hdr
->sh_info
);
1287 sym_hashes
= elf_sym_hashes (abfd
);
1288 end_hashes
= sym_hashes
+ symcount
;
1289 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1291 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1292 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1293 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1294 && sym_hash
->root
.u
.def
.section
== sec
1295 && sym_hash
->root
.u
.def
.value
> addr
1296 && sym_hash
->root
.u
.def
.value
< toaddr
)
1298 sym_hash
->root
.u
.def
.value
-= count
;
1302 /* See if we can move the ALIGN reloc forward. We have adjusted
1303 r_offset for it already. */
1304 if (irelalign
!= NULL
)
1306 bfd_vma alignto
, alignaddr
;
1308 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1309 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1310 1 << irelalign
->r_addend
);
1311 if (alignto
!= alignaddr
)
1313 /* Tail recursion. */
1314 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1315 (int) (alignto
- alignaddr
));
1322 /* Look for loads and stores which we can align to four byte
1323 boundaries. This is like sh_align_loads in coff-sh.c. */
1326 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1327 Elf_Internal_Rela
*internal_relocs
,
1328 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1329 bfd_boolean
*pswapped
)
1331 Elf_Internal_Rela
*irel
, *irelend
;
1332 bfd_vma
*labels
= NULL
;
1333 bfd_vma
*label
, *label_end
;
1338 irelend
= internal_relocs
+ sec
->reloc_count
;
1340 /* Get all the addresses with labels on them. */
1341 amt
= sec
->reloc_count
;
1342 amt
*= sizeof (bfd_vma
);
1343 labels
= (bfd_vma
*) bfd_malloc (amt
);
1347 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1349 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1351 *label_end
= irel
->r_offset
;
1356 /* Note that the assembler currently always outputs relocs in
1357 address order. If that ever changes, this code will need to sort
1358 the label values and the relocs. */
1362 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1364 bfd_vma start
, stop
;
1366 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1369 start
= irel
->r_offset
;
1371 for (irel
++; irel
< irelend
; irel
++)
1372 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1375 stop
= irel
->r_offset
;
1379 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1380 internal_relocs
, &label
,
1381 label_end
, start
, stop
, pswapped
))
1396 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1399 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1400 bfd_byte
*contents
, bfd_vma addr
)
1402 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1403 unsigned short i1
, i2
;
1404 Elf_Internal_Rela
*irel
, *irelend
;
1406 /* Swap the instructions themselves. */
1407 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1408 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1409 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1410 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1412 /* Adjust all reloc addresses. */
1413 irelend
= internal_relocs
+ sec
->reloc_count
;
1414 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1416 enum elf_sh_reloc_type type
;
1419 /* There are a few special types of relocs that we don't want to
1420 adjust. These relocs do not apply to the instruction itself,
1421 but are only associated with the address. */
1422 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1423 if (type
== R_SH_ALIGN
1424 || type
== R_SH_CODE
1425 || type
== R_SH_DATA
1426 || type
== R_SH_LABEL
)
1429 /* If an R_SH_USES reloc points to one of the addresses being
1430 swapped, we must adjust it. It would be incorrect to do this
1431 for a jump, though, since we want to execute both
1432 instructions after the jump. (We have avoided swapping
1433 around a label, so the jump will not wind up executing an
1434 instruction it shouldn't). */
1435 if (type
== R_SH_USES
)
1439 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1441 irel
->r_offset
+= 2;
1442 else if (off
== addr
+ 2)
1443 irel
->r_offset
-= 2;
1446 if (irel
->r_offset
== addr
)
1448 irel
->r_offset
+= 2;
1451 else if (irel
->r_offset
== addr
+ 2)
1453 irel
->r_offset
-= 2;
1462 unsigned short insn
, oinsn
;
1463 bfd_boolean overflow
;
1465 loc
= contents
+ irel
->r_offset
;
1474 insn
= bfd_get_16 (abfd
, loc
);
1477 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1479 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1483 insn
= bfd_get_16 (abfd
, loc
);
1486 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1488 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1492 /* This reloc ignores the least significant 3 bits of
1493 the program counter before adding in the offset.
1494 This means that if ADDR is at an even address, the
1495 swap will not affect the offset. If ADDR is an at an
1496 odd address, then the instruction will be crossing a
1497 four byte boundary, and must be adjusted. */
1498 if ((addr
& 3) != 0)
1500 insn
= bfd_get_16 (abfd
, loc
);
1503 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1505 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1513 ((*_bfd_error_handler
)
1514 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1515 abfd
, (unsigned long) irel
->r_offset
));
1516 bfd_set_error (bfd_error_bad_value
);
1524 #endif /* defined SH64_ELF */
1526 /* Describes one of the various PLT styles. */
1528 struct elf_sh_plt_info
1530 /* The template for the first PLT entry, or NULL if there is no special
1532 const bfd_byte
*plt0_entry
;
1534 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1535 bfd_vma plt0_entry_size
;
1537 /* Index I is the offset into PLT0_ENTRY of a pointer to
1538 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1539 if there is no such pointer. */
1540 bfd_vma plt0_got_fields
[3];
1542 /* The template for a symbol's PLT entry. */
1543 const bfd_byte
*symbol_entry
;
1545 /* The size of SYMBOL_ENTRY in bytes. */
1546 bfd_vma symbol_entry_size
;
1548 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1549 on all targets. The comments by each member indicate the value
1550 that the field must hold. */
1552 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1553 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1554 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1557 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1558 bfd_vma symbol_resolve_offset
;
1561 #ifdef INCLUDE_SHMEDIA
1563 /* The size in bytes of an entry in the procedure linkage table. */
1565 #define ELF_PLT_ENTRY_SIZE 64
1567 /* First entry in an absolute procedure linkage table look like this. */
1569 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1571 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1572 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1573 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1574 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1575 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1576 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1577 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1578 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1579 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1580 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1581 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1582 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1583 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1584 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1585 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1586 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1589 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1591 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1592 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1593 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1594 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1595 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1596 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1597 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1598 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1599 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1600 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1601 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1602 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1603 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1604 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1605 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1606 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1609 /* Sebsequent entries in an absolute procedure linkage table look like
1612 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1614 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1615 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1616 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1617 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1618 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1619 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1620 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1621 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1622 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1623 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1624 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1625 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1626 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1627 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1628 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1629 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1632 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1634 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1635 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1636 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1637 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1638 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1639 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1640 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1641 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1642 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1643 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1644 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1645 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1646 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1647 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1648 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1649 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1652 /* Entries in a PIC procedure linkage table look like this. */
1654 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1656 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1657 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1658 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1659 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1660 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1661 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1662 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1663 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1664 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1665 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1666 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1667 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1668 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1669 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1670 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1671 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1674 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1676 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1677 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1678 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1679 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1680 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1681 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1682 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1683 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1684 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1685 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1686 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1687 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1688 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1689 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1690 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1691 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1694 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1697 /* Big-endian non-PIC. */
1698 elf_sh_plt0_entry_be
,
1700 { 0, MINUS_ONE
, MINUS_ONE
},
1701 elf_sh_plt_entry_be
,
1704 33 /* includes ISA encoding */
1707 /* Little-endian non-PIC. */
1708 elf_sh_plt0_entry_le
,
1710 { 0, MINUS_ONE
, MINUS_ONE
},
1711 elf_sh_plt_entry_le
,
1714 33 /* includes ISA encoding */
1719 /* Big-endian PIC. */
1720 elf_sh_plt0_entry_be
,
1722 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1723 elf_sh_pic_plt_entry_be
,
1725 { 0, MINUS_ONE
, 52 },
1726 33 /* includes ISA encoding */
1729 /* Little-endian PIC. */
1730 elf_sh_plt0_entry_le
,
1732 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1733 elf_sh_pic_plt_entry_le
,
1735 { 0, MINUS_ONE
, 52 },
1736 33 /* includes ISA encoding */
1741 /* Return offset of the linker in PLT0 entry. */
1742 #define elf_sh_plt0_gotplt_offset(info) 0
1744 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1745 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1748 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1751 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p
,
1752 unsigned long value
, bfd_byte
*addr
)
1755 bfd_put_32 (output_bfd
,
1756 bfd_get_32 (output_bfd
, addr
)
1757 | ((value
>> 6) & 0x3fffc00),
1759 bfd_put_32 (output_bfd
,
1760 bfd_get_32 (output_bfd
, addr
+ 4)
1761 | ((value
<< 10) & 0x3fffc00),
1765 /* Return the type of PLT associated with ABFD. PIC_P is true if
1766 the object is position-independent. */
1768 static const struct elf_sh_plt_info
*
1769 get_plt_info (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean pic_p
)
1771 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
1774 /* The size in bytes of an entry in the procedure linkage table. */
1776 #define ELF_PLT_ENTRY_SIZE 28
1778 /* First entry in an absolute procedure linkage table look like this. */
1780 /* Note - this code has been "optimised" not to use r2. r2 is used by
1781 GCC to return the address of large structures, so it should not be
1782 corrupted here. This does mean however, that this PLT does not conform
1783 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1784 and r2 contains the GOT id. This version stores the GOT id in r0 and
1785 ignores the type. Loaders can easily detect this difference however,
1786 since the type will always be 0 or 8, and the GOT ids will always be
1787 greater than or equal to 12. */
1788 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1790 0xd0, 0x05, /* mov.l 2f,r0 */
1791 0x60, 0x02, /* mov.l @r0,r0 */
1792 0x2f, 0x06, /* mov.l r0,@-r15 */
1793 0xd0, 0x03, /* mov.l 1f,r0 */
1794 0x60, 0x02, /* mov.l @r0,r0 */
1795 0x40, 0x2b, /* jmp @r0 */
1796 0x60, 0xf6, /* mov.l @r15+,r0 */
1797 0x00, 0x09, /* nop */
1798 0x00, 0x09, /* nop */
1799 0x00, 0x09, /* nop */
1800 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1801 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1804 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1806 0x05, 0xd0, /* mov.l 2f,r0 */
1807 0x02, 0x60, /* mov.l @r0,r0 */
1808 0x06, 0x2f, /* mov.l r0,@-r15 */
1809 0x03, 0xd0, /* mov.l 1f,r0 */
1810 0x02, 0x60, /* mov.l @r0,r0 */
1811 0x2b, 0x40, /* jmp @r0 */
1812 0xf6, 0x60, /* mov.l @r15+,r0 */
1813 0x09, 0x00, /* nop */
1814 0x09, 0x00, /* nop */
1815 0x09, 0x00, /* nop */
1816 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1817 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1820 /* Sebsequent entries in an absolute procedure linkage table look like
1823 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1825 0xd0, 0x04, /* mov.l 1f,r0 */
1826 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1827 0xd1, 0x02, /* mov.l 0f,r1 */
1828 0x40, 0x2b, /* jmp @r0 */
1829 0x60, 0x13, /* mov r1,r0 */
1830 0xd1, 0x03, /* mov.l 2f,r1 */
1831 0x40, 0x2b, /* jmp @r0 */
1832 0x00, 0x09, /* nop */
1833 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1834 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1835 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1838 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1840 0x04, 0xd0, /* mov.l 1f,r0 */
1841 0x02, 0x60, /* mov.l @r0,r0 */
1842 0x02, 0xd1, /* mov.l 0f,r1 */
1843 0x2b, 0x40, /* jmp @r0 */
1844 0x13, 0x60, /* mov r1,r0 */
1845 0x03, 0xd1, /* mov.l 2f,r1 */
1846 0x2b, 0x40, /* jmp @r0 */
1847 0x09, 0x00, /* nop */
1848 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1849 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1850 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1853 /* Entries in a PIC procedure linkage table look like this. */
1855 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1857 0xd0, 0x04, /* mov.l 1f,r0 */
1858 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1859 0x40, 0x2b, /* jmp @r0 */
1860 0x00, 0x09, /* nop */
1861 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1862 0xd1, 0x03, /* mov.l 2f,r1 */
1863 0x40, 0x2b, /* jmp @r0 */
1864 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1865 0x00, 0x09, /* nop */
1866 0x00, 0x09, /* nop */
1867 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1868 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1871 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1873 0x04, 0xd0, /* mov.l 1f,r0 */
1874 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1875 0x2b, 0x40, /* jmp @r0 */
1876 0x09, 0x00, /* nop */
1877 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1878 0x03, 0xd1, /* mov.l 2f,r1 */
1879 0x2b, 0x40, /* jmp @r0 */
1880 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1881 0x09, 0x00, /* nop */
1882 0x09, 0x00, /* nop */
1883 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1884 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1887 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1890 /* Big-endian non-PIC. */
1891 elf_sh_plt0_entry_be
,
1893 { MINUS_ONE
, 24, 20 },
1894 elf_sh_plt_entry_be
,
1900 /* Little-endian non-PIC. */
1901 elf_sh_plt0_entry_le
,
1903 { MINUS_ONE
, 24, 20 },
1904 elf_sh_plt_entry_le
,
1912 /* Big-endian PIC. */
1913 elf_sh_plt0_entry_be
,
1915 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1916 elf_sh_pic_plt_entry_be
,
1918 { 20, MINUS_ONE
, 24 },
1922 /* Little-endian PIC. */
1923 elf_sh_plt0_entry_le
,
1925 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1926 elf_sh_pic_plt_entry_le
,
1928 { 20, MINUS_ONE
, 24 },
1934 #define VXWORKS_PLT_HEADER_SIZE 12
1935 #define VXWORKS_PLT_ENTRY_SIZE 24
1937 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1939 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1940 0x61, 0x12, /* mov.l @r1,r1 */
1941 0x41, 0x2b, /* jmp @r1 */
1942 0x00, 0x09, /* nop */
1943 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1946 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1948 0x01, 0xd1, /* mov.l @(8,pc),r1 */
1949 0x12, 0x61, /* mov.l @r1,r1 */
1950 0x2b, 0x41, /* jmp @r1 */
1951 0x09, 0x00, /* nop */
1952 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1955 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1957 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1958 0x60, 0x02, /* mov.l @r0,r0 */
1959 0x40, 0x2b, /* jmp @r0 */
1960 0x00, 0x09, /* nop */
1961 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1962 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1963 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
1964 0x00, 0x09, /* nop */
1965 0x00, 0x09, /* nop */
1966 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1969 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1971 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1972 0x02, 0x60, /* mov.l @r0,r0 */
1973 0x2b, 0x40, /* jmp @r0 */
1974 0x09, 0x00, /* nop */
1975 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1976 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1977 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
1978 0x09, 0x00, /* nop */
1979 0x09, 0x00, /* nop */
1980 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1983 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1985 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1986 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1987 0x40, 0x2b, /* jmp @r0 */
1988 0x00, 0x09, /* nop */
1989 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1990 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1991 0x51, 0xc2, /* mov.l @(8,r12),r1 */
1992 0x41, 0x2b, /* jmp @r1 */
1993 0x00, 0x09, /* nop */
1994 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1997 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1999 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2000 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2001 0x2b, 0x40, /* jmp @r0 */
2002 0x09, 0x00, /* nop */
2003 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2004 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2005 0xc2, 0x51, /* mov.l @(8,r12),r1 */
2006 0x2b, 0x41, /* jmp @r1 */
2007 0x09, 0x00, /* nop */
2008 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2011 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
2014 /* Big-endian non-PIC. */
2015 vxworks_sh_plt0_entry_be
,
2016 VXWORKS_PLT_HEADER_SIZE
,
2017 { MINUS_ONE
, MINUS_ONE
, 8 },
2018 vxworks_sh_plt_entry_be
,
2019 VXWORKS_PLT_ENTRY_SIZE
,
2024 /* Little-endian non-PIC. */
2025 vxworks_sh_plt0_entry_le
,
2026 VXWORKS_PLT_HEADER_SIZE
,
2027 { MINUS_ONE
, MINUS_ONE
, 8 },
2028 vxworks_sh_plt_entry_le
,
2029 VXWORKS_PLT_ENTRY_SIZE
,
2036 /* Big-endian PIC. */
2039 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2040 vxworks_sh_pic_plt_entry_be
,
2041 VXWORKS_PLT_ENTRY_SIZE
,
2042 { 8, MINUS_ONE
, 20 },
2046 /* Little-endian PIC. */
2049 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2050 vxworks_sh_pic_plt_entry_le
,
2051 VXWORKS_PLT_ENTRY_SIZE
,
2052 { 8, MINUS_ONE
, 20 },
2058 /* Return the type of PLT associated with ABFD. PIC_P is true if
2059 the object is position-independent. */
2061 static const struct elf_sh_plt_info
*
2062 get_plt_info (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean pic_p
)
2064 if (vxworks_object_p (abfd
))
2065 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2066 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2069 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2070 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2074 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2075 unsigned long value
, bfd_byte
*addr
)
2077 bfd_put_32 (output_bfd
, value
, addr
);
2081 /* Return the index of the PLT entry at byte offset OFFSET. */
2084 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2086 return (offset
- info
->plt0_entry_size
) / info
->symbol_entry_size
;
2089 /* Do the inverse operation. */
2092 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma index
)
2094 return info
->plt0_entry_size
+ (index
* info
->symbol_entry_size
);
2097 /* The sh linker needs to keep track of the number of relocs that it
2098 decides to copy as dynamic relocs in check_relocs for each symbol.
2099 This is so that it can later discard them if they are found to be
2100 unnecessary. We store the information in a field extending the
2101 regular ELF linker hash table. */
2103 struct elf_sh_dyn_relocs
2105 struct elf_sh_dyn_relocs
*next
;
2107 /* The input section of the reloc. */
2110 /* Total number of relocs copied for the input section. */
2111 bfd_size_type count
;
2113 /* Number of pc-relative relocs copied for the input section. */
2114 bfd_size_type pc_count
;
2117 /* sh ELF linker hash entry. */
2119 struct elf_sh_link_hash_entry
2121 struct elf_link_hash_entry root
;
2123 #ifdef INCLUDE_SHMEDIA
2126 bfd_signed_vma refcount
;
2131 /* Track dynamic relocs copied for this symbol. */
2132 struct elf_sh_dyn_relocs
*dyn_relocs
;
2134 bfd_signed_vma gotplt_refcount
;
2137 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
2141 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2143 struct sh_elf_obj_tdata
2145 struct elf_obj_tdata root
;
2147 /* tls_type for each local got entry. */
2148 char *local_got_tls_type
;
2151 #define sh_elf_tdata(abfd) \
2152 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2154 #define sh_elf_local_got_tls_type(abfd) \
2155 (sh_elf_tdata (abfd)->local_got_tls_type)
2157 /* Override the generic function because we need to store sh_elf_obj_tdata
2158 as the specific tdata. */
2161 sh_elf_mkobject (bfd
*abfd
)
2163 if (abfd
->tdata
.any
== NULL
)
2165 bfd_size_type amt
= sizeof (struct sh_elf_obj_tdata
);
2166 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
2167 if (abfd
->tdata
.any
== NULL
)
2170 return bfd_elf_mkobject (abfd
);
2173 /* sh ELF linker hash table. */
2175 struct elf_sh_link_hash_table
2177 struct elf_link_hash_table root
;
2179 /* Short-cuts to get to dynamic linker sections. */
2188 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2191 /* Small local sym to section mapping cache. */
2192 struct sym_sec_cache sym_sec
;
2194 /* A counter or offset to track a TLS got entry. */
2197 bfd_signed_vma refcount
;
2201 /* The type of PLT to use. */
2202 const struct elf_sh_plt_info
*plt_info
;
2204 /* True if the target system is VxWorks. */
2205 bfd_boolean vxworks_p
;
2208 /* Traverse an sh ELF linker hash table. */
2210 #define sh_elf_link_hash_traverse(table, func, info) \
2211 (elf_link_hash_traverse \
2213 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2216 /* Get the sh ELF linker hash table from a link_info structure. */
2218 #define sh_elf_hash_table(p) \
2219 ((struct elf_sh_link_hash_table *) ((p)->hash))
2221 /* Create an entry in an sh ELF linker hash table. */
2223 static struct bfd_hash_entry
*
2224 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2225 struct bfd_hash_table
*table
,
2228 struct elf_sh_link_hash_entry
*ret
=
2229 (struct elf_sh_link_hash_entry
*) entry
;
2231 /* Allocate the structure if it has not already been allocated by a
2233 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2234 ret
= ((struct elf_sh_link_hash_entry
*)
2235 bfd_hash_allocate (table
,
2236 sizeof (struct elf_sh_link_hash_entry
)));
2237 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2238 return (struct bfd_hash_entry
*) ret
;
2240 /* Call the allocation method of the superclass. */
2241 ret
= ((struct elf_sh_link_hash_entry
*)
2242 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2244 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2246 ret
->dyn_relocs
= NULL
;
2247 ret
->gotplt_refcount
= 0;
2248 #ifdef INCLUDE_SHMEDIA
2249 ret
->datalabel_got
.refcount
= ret
->root
.got
.refcount
;
2251 ret
->tls_type
= GOT_UNKNOWN
;
2254 return (struct bfd_hash_entry
*) ret
;
2257 /* Create an sh ELF linker hash table. */
2259 static struct bfd_link_hash_table
*
2260 sh_elf_link_hash_table_create (bfd
*abfd
)
2262 struct elf_sh_link_hash_table
*ret
;
2263 bfd_size_type amt
= sizeof (struct elf_sh_link_hash_table
);
2265 ret
= (struct elf_sh_link_hash_table
*) bfd_malloc (amt
);
2266 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2269 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2270 sh_elf_link_hash_newfunc
,
2271 sizeof (struct elf_sh_link_hash_entry
)))
2278 ret
->sgotplt
= NULL
;
2279 ret
->srelgot
= NULL
;
2281 ret
->srelplt
= NULL
;
2282 ret
->sdynbss
= NULL
;
2283 ret
->srelbss
= NULL
;
2284 ret
->srelplt2
= NULL
;
2285 ret
->sym_sec
.abfd
= NULL
;
2286 ret
->tls_ldm_got
.refcount
= 0;
2287 ret
->plt_info
= NULL
;
2288 ret
->vxworks_p
= vxworks_object_p (abfd
);
2290 return &ret
->root
.root
;
2293 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2294 shortcuts to them in our hash table. */
2297 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2299 struct elf_sh_link_hash_table
*htab
;
2301 if (! _bfd_elf_create_got_section (dynobj
, info
))
2304 htab
= sh_elf_hash_table (info
);
2305 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
2306 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
2307 if (! htab
->sgot
|| ! htab
->sgotplt
)
2310 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
2311 (SEC_ALLOC
| SEC_LOAD
2314 | SEC_LINKER_CREATED
2316 if (htab
->srelgot
== NULL
2317 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
2322 /* Create dynamic sections when linking against a dynamic object. */
2325 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2327 struct elf_sh_link_hash_table
*htab
;
2328 flagword flags
, pltflags
;
2329 register asection
*s
;
2330 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2333 switch (bed
->s
->arch_size
)
2344 bfd_set_error (bfd_error_bad_value
);
2348 htab
= sh_elf_hash_table (info
);
2349 if (htab
->root
.dynamic_sections_created
)
2352 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2353 .rel[a].bss sections. */
2355 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2356 | SEC_LINKER_CREATED
);
2359 pltflags
|= SEC_CODE
;
2360 if (bed
->plt_not_loaded
)
2361 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2362 if (bed
->plt_readonly
)
2363 pltflags
|= SEC_READONLY
;
2365 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
2368 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2371 if (bed
->want_plt_sym
)
2373 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2375 struct elf_link_hash_entry
*h
;
2376 struct bfd_link_hash_entry
*bh
= NULL
;
2378 if (! (_bfd_generic_link_add_one_symbol
2379 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2380 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2381 get_elf_backend_data (abfd
)->collect
, &bh
)))
2384 h
= (struct elf_link_hash_entry
*) bh
;
2386 h
->type
= STT_OBJECT
;
2387 htab
->root
.hplt
= h
;
2390 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2394 s
= bfd_make_section_with_flags (abfd
,
2395 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt",
2396 flags
| SEC_READONLY
);
2399 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2402 if (htab
->sgot
== NULL
2403 && !create_got_section (abfd
, info
))
2407 const char *secname
;
2412 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2414 secflags
= bfd_get_section_flags (abfd
, sec
);
2415 if ((secflags
& (SEC_DATA
| SEC_LINKER_CREATED
))
2416 || ((secflags
& SEC_HAS_CONTENTS
) != SEC_HAS_CONTENTS
))
2418 secname
= bfd_get_section_name (abfd
, sec
);
2419 relname
= (char *) bfd_malloc ((bfd_size_type
) strlen (secname
) + 6);
2420 strcpy (relname
, ".rela");
2421 strcat (relname
, secname
);
2422 if (bfd_get_section_by_name (abfd
, secname
))
2424 s
= bfd_make_section_with_flags (abfd
, relname
,
2425 flags
| SEC_READONLY
);
2427 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2432 if (bed
->want_dynbss
)
2434 /* The .dynbss section is a place to put symbols which are defined
2435 by dynamic objects, are referenced by regular objects, and are
2436 not functions. We must allocate space for them in the process
2437 image and use a R_*_COPY reloc to tell the dynamic linker to
2438 initialize them at run time. The linker script puts the .dynbss
2439 section into the .bss section of the final image. */
2440 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
2441 SEC_ALLOC
| SEC_LINKER_CREATED
);
2446 /* The .rel[a].bss section holds copy relocs. This section is not
2447 normally needed. We need to create it here, though, so that the
2448 linker will map it to an output section. We can't just create it
2449 only if we need it, because we will not know whether we need it
2450 until we have seen all the input files, and the first time the
2451 main linker code calls BFD after examining all the input files
2452 (size_dynamic_sections) the input sections have already been
2453 mapped to the output sections. If the section turns out not to
2454 be needed, we can discard it later. We will never need this
2455 section when generating a shared object, since they do not use
2459 s
= bfd_make_section_with_flags (abfd
,
2460 (bed
->default_use_rela_p
2461 ? ".rela.bss" : ".rel.bss"),
2462 flags
| SEC_READONLY
);
2465 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2470 if (htab
->vxworks_p
)
2472 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2479 /* Adjust a symbol defined by a dynamic object and referenced by a
2480 regular object. The current definition is in some section of the
2481 dynamic object, but we're not including those sections. We have to
2482 change the definition to something the rest of the link can
2486 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2487 struct elf_link_hash_entry
*h
)
2489 struct elf_sh_link_hash_table
*htab
;
2490 struct elf_sh_link_hash_entry
*eh
;
2491 struct elf_sh_dyn_relocs
*p
;
2494 htab
= sh_elf_hash_table (info
);
2496 /* Make sure we know what is going on here. */
2497 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2499 || h
->u
.weakdef
!= NULL
2502 && !h
->def_regular
)));
2504 /* If this is a function, put it in the procedure linkage table. We
2505 will fill in the contents of the procedure linkage table later,
2506 when we know the address of the .got section. */
2507 if (h
->type
== STT_FUNC
2510 if (h
->plt
.refcount
<= 0
2511 || SYMBOL_CALLS_LOCAL (info
, h
)
2512 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2513 && h
->root
.type
== bfd_link_hash_undefweak
))
2515 /* This case can occur if we saw a PLT reloc in an input
2516 file, but the symbol was never referred to by a dynamic
2517 object. In such a case, we don't actually need to build
2518 a procedure linkage table, and we can just do a REL32
2520 h
->plt
.offset
= (bfd_vma
) -1;
2527 h
->plt
.offset
= (bfd_vma
) -1;
2529 /* If this is a weak symbol, and there is a real definition, the
2530 processor independent code will have arranged for us to see the
2531 real definition first, and we can just use the same value. */
2532 if (h
->u
.weakdef
!= NULL
)
2534 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2535 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2536 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2537 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2538 if (info
->nocopyreloc
)
2539 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2543 /* This is a reference to a symbol defined by a dynamic object which
2544 is not a function. */
2546 /* If we are creating a shared library, we must presume that the
2547 only references to the symbol are via the global offset table.
2548 For such cases we need not do anything here; the relocations will
2549 be handled correctly by relocate_section. */
2553 /* If there are no references to this symbol that do not use the
2554 GOT, we don't need to generate a copy reloc. */
2555 if (!h
->non_got_ref
)
2558 /* If -z nocopyreloc was given, we won't generate them either. */
2559 if (info
->nocopyreloc
)
2565 eh
= (struct elf_sh_link_hash_entry
*) h
;
2566 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2568 s
= p
->sec
->output_section
;
2569 if (s
!= NULL
&& (s
->flags
& (SEC_READONLY
| SEC_HAS_CONTENTS
)) != 0)
2573 /* If we didn't find any dynamic relocs in sections which needs the
2574 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2584 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
2585 h
->root
.root
.string
);
2589 /* We must allocate the symbol in our .dynbss section, which will
2590 become part of the .bss section of the executable. There will be
2591 an entry for this symbol in the .dynsym section. The dynamic
2592 object will contain position independent code, so all references
2593 from the dynamic object to this symbol will go through the global
2594 offset table. The dynamic linker will use the .dynsym entry to
2595 determine the address it must put in the global offset table, so
2596 both the dynamic object and the regular object will refer to the
2597 same memory location for the variable. */
2600 BFD_ASSERT (s
!= NULL
);
2602 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2603 copy the initial value out of the dynamic object and into the
2604 runtime process image. We need to remember the offset into the
2605 .rela.bss section we are going to use. */
2606 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2610 srel
= htab
->srelbss
;
2611 BFD_ASSERT (srel
!= NULL
);
2612 srel
->size
+= sizeof (Elf32_External_Rela
);
2616 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2619 /* Allocate space in .plt, .got and associated reloc sections for
2623 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2625 struct bfd_link_info
*info
;
2626 struct elf_sh_link_hash_table
*htab
;
2627 struct elf_sh_link_hash_entry
*eh
;
2628 struct elf_sh_dyn_relocs
*p
;
2630 if (h
->root
.type
== bfd_link_hash_indirect
)
2633 if (h
->root
.type
== bfd_link_hash_warning
)
2634 /* When warning symbols are created, they **replace** the "real"
2635 entry in the hash table, thus we never get to see the real
2636 symbol in a hash traversal. So look at it now. */
2637 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2639 info
= (struct bfd_link_info
*) inf
;
2640 htab
= sh_elf_hash_table (info
);
2642 eh
= (struct elf_sh_link_hash_entry
*) h
;
2643 if ((h
->got
.refcount
> 0
2645 && eh
->gotplt_refcount
> 0)
2647 /* The symbol has been forced local, or we have some direct got refs,
2648 so treat all the gotplt refs as got refs. */
2649 h
->got
.refcount
+= eh
->gotplt_refcount
;
2650 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2651 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2654 if (htab
->root
.dynamic_sections_created
2655 && h
->plt
.refcount
> 0
2656 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2657 || h
->root
.type
!= bfd_link_hash_undefweak
))
2659 /* Make sure this symbol is output as a dynamic symbol.
2660 Undefined weak syms won't yet be marked as dynamic. */
2661 if (h
->dynindx
== -1
2662 && !h
->forced_local
)
2664 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2669 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2671 asection
*s
= htab
->splt
;
2673 /* If this is the first .plt entry, make room for the special
2676 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2678 h
->plt
.offset
= s
->size
;
2680 /* If this symbol is not defined in a regular file, and we are
2681 not generating a shared library, then set the symbol to this
2682 location in the .plt. This is required to make function
2683 pointers compare as equal between the normal executable and
2684 the shared library. */
2688 h
->root
.u
.def
.section
= s
;
2689 h
->root
.u
.def
.value
= h
->plt
.offset
;
2692 /* Make room for this entry. */
2693 s
->size
+= htab
->plt_info
->symbol_entry_size
;
2695 /* We also need to make an entry in the .got.plt section, which
2696 will be placed in the .got section by the linker script. */
2697 htab
->sgotplt
->size
+= 4;
2699 /* We also need to make an entry in the .rel.plt section. */
2700 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2702 if (htab
->vxworks_p
&& !info
->shared
)
2704 /* VxWorks executables have a second set of relocations
2705 for each PLT entry. They go in a separate relocation
2706 section, which is processed by the kernel loader. */
2708 /* There is a relocation for the initial PLT entry:
2709 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
2710 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
2711 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
2713 /* There are two extra relocations for each subsequent
2714 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2715 and an R_SH_DIR32 relocation for the PLT entry. */
2716 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
2721 h
->plt
.offset
= (bfd_vma
) -1;
2727 h
->plt
.offset
= (bfd_vma
) -1;
2731 if (h
->got
.refcount
> 0)
2735 int tls_type
= sh_elf_hash_entry (h
)->tls_type
;
2737 /* Make sure this symbol is output as a dynamic symbol.
2738 Undefined weak syms won't yet be marked as dynamic. */
2739 if (h
->dynindx
== -1
2740 && !h
->forced_local
)
2742 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2747 h
->got
.offset
= s
->size
;
2749 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
2750 if (tls_type
== GOT_TLS_GD
)
2752 dyn
= htab
->root
.dynamic_sections_created
;
2753 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2754 R_SH_TLS_GD needs one if local symbol and two if global. */
2755 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2756 || (tls_type
== GOT_TLS_IE
&& dyn
))
2757 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2758 else if (tls_type
== GOT_TLS_GD
)
2759 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2760 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2761 || h
->root
.type
!= bfd_link_hash_undefweak
)
2763 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2764 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2767 h
->got
.offset
= (bfd_vma
) -1;
2769 #ifdef INCLUDE_SHMEDIA
2770 if (eh
->datalabel_got
.refcount
> 0)
2775 /* Make sure this symbol is output as a dynamic symbol.
2776 Undefined weak syms won't yet be marked as dynamic. */
2777 if (h
->dynindx
== -1
2778 && !h
->forced_local
)
2780 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2785 eh
->datalabel_got
.offset
= s
->size
;
2787 dyn
= htab
->root
.dynamic_sections_created
;
2788 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
2789 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2792 eh
->datalabel_got
.offset
= (bfd_vma
) -1;
2795 if (eh
->dyn_relocs
== NULL
)
2798 /* In the shared -Bsymbolic case, discard space allocated for
2799 dynamic pc-relative relocs against symbols which turn out to be
2800 defined in regular objects. For the normal shared case, discard
2801 space for pc-relative relocs that have become local due to symbol
2802 visibility changes. */
2806 if (SYMBOL_CALLS_LOCAL (info
, h
))
2808 struct elf_sh_dyn_relocs
**pp
;
2810 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2812 p
->count
-= p
->pc_count
;
2821 /* Also discard relocs on undefined weak syms with non-default
2823 if (eh
->dyn_relocs
!= NULL
2824 && h
->root
.type
== bfd_link_hash_undefweak
)
2826 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2827 eh
->dyn_relocs
= NULL
;
2829 /* Make sure undefined weak symbols are output as a dynamic
2831 else if (h
->dynindx
== -1
2832 && !h
->forced_local
)
2834 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2841 /* For the non-shared case, discard space for relocs against
2842 symbols which turn out to need copy relocs or are not
2848 || (htab
->root
.dynamic_sections_created
2849 && (h
->root
.type
== bfd_link_hash_undefweak
2850 || h
->root
.type
== bfd_link_hash_undefined
))))
2852 /* Make sure this symbol is output as a dynamic symbol.
2853 Undefined weak syms won't yet be marked as dynamic. */
2854 if (h
->dynindx
== -1
2855 && !h
->forced_local
)
2857 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2861 /* If that succeeded, we know we'll be keeping all the
2863 if (h
->dynindx
!= -1)
2867 eh
->dyn_relocs
= NULL
;
2872 /* Finally, allocate space. */
2873 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2875 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2876 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2882 /* Find any dynamic relocs that apply to read-only sections. */
2885 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2887 struct elf_sh_link_hash_entry
*eh
;
2888 struct elf_sh_dyn_relocs
*p
;
2890 if (h
->root
.type
== bfd_link_hash_warning
)
2891 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2893 eh
= (struct elf_sh_link_hash_entry
*) h
;
2894 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2896 asection
*s
= p
->sec
->output_section
;
2898 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2900 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2902 info
->flags
|= DF_TEXTREL
;
2904 /* Not an error, just cut short the traversal. */
2911 /* This function is called after all the input files have been read,
2912 and the input sections have been assigned to output sections.
2913 It's a convenient place to determine the PLT style. */
2916 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2918 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
, info
->shared
);
2922 /* Set the sizes of the dynamic sections. */
2925 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2926 struct bfd_link_info
*info
)
2928 struct elf_sh_link_hash_table
*htab
;
2934 htab
= sh_elf_hash_table (info
);
2935 dynobj
= htab
->root
.dynobj
;
2936 BFD_ASSERT (dynobj
!= NULL
);
2938 if (htab
->root
.dynamic_sections_created
)
2940 /* Set the contents of the .interp section to the interpreter. */
2941 if (info
->executable
)
2943 s
= bfd_get_section_by_name (dynobj
, ".interp");
2944 BFD_ASSERT (s
!= NULL
);
2945 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2946 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2950 /* Set up .got offsets for local syms, and space for local dynamic
2952 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2954 bfd_signed_vma
*local_got
;
2955 bfd_signed_vma
*end_local_got
;
2956 char *local_tls_type
;
2957 bfd_size_type locsymcount
;
2958 Elf_Internal_Shdr
*symtab_hdr
;
2961 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2964 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2966 struct elf_sh_dyn_relocs
*p
;
2968 for (p
= ((struct elf_sh_dyn_relocs
*)
2969 elf_section_data (s
)->local_dynrel
);
2973 if (! bfd_is_abs_section (p
->sec
)
2974 && bfd_is_abs_section (p
->sec
->output_section
))
2976 /* Input section has been discarded, either because
2977 it is a copy of a linkonce section or due to
2978 linker script /DISCARD/, so we'll be discarding
2981 else if (p
->count
!= 0)
2983 srel
= elf_section_data (p
->sec
)->sreloc
;
2984 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2985 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2986 info
->flags
|= DF_TEXTREL
;
2991 local_got
= elf_local_got_refcounts (ibfd
);
2995 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2996 locsymcount
= symtab_hdr
->sh_info
;
2997 #ifdef INCLUDE_SHMEDIA
2998 /* Count datalabel local GOT. */
3001 end_local_got
= local_got
+ locsymcount
;
3002 local_tls_type
= sh_elf_local_got_tls_type (ibfd
);
3004 srel
= htab
->srelgot
;
3005 for (; local_got
< end_local_got
; ++local_got
)
3009 *local_got
= s
->size
;
3011 if (*local_tls_type
== GOT_TLS_GD
)
3014 srel
->size
+= sizeof (Elf32_External_Rela
);
3017 *local_got
= (bfd_vma
) -1;
3022 if (htab
->tls_ldm_got
.refcount
> 0)
3024 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3026 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
3027 htab
->sgot
->size
+= 8;
3028 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3031 htab
->tls_ldm_got
.offset
= -1;
3033 /* Allocate global sym .plt and .got entries, and space for global
3034 sym dynamic relocs. */
3035 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3037 /* We now have determined the sizes of the various dynamic sections.
3038 Allocate memory for them. */
3040 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3042 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3047 || s
== htab
->sgotplt
3048 || s
== htab
->sdynbss
)
3050 /* Strip this section if we don't need it; see the
3053 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3055 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
3058 /* We use the reloc_count field as a counter if we need
3059 to copy relocs into the output file. */
3064 /* It's not one of our sections, so don't allocate space. */
3070 /* If we don't need this section, strip it from the
3071 output file. This is mostly to handle .rela.bss and
3072 .rela.plt. We must create both sections in
3073 create_dynamic_sections, because they must be created
3074 before the linker maps input sections to output
3075 sections. The linker does that before
3076 adjust_dynamic_symbol is called, and it is that
3077 function which decides whether anything needs to go
3078 into these sections. */
3080 s
->flags
|= SEC_EXCLUDE
;
3084 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3087 /* Allocate memory for the section contents. We use bfd_zalloc
3088 here in case unused entries are not reclaimed before the
3089 section's contents are written out. This should not happen,
3090 but this way if it does, we get a R_SH_NONE reloc instead
3092 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3093 if (s
->contents
== NULL
)
3097 if (htab
->root
.dynamic_sections_created
)
3099 /* Add some entries to the .dynamic section. We fill in the
3100 values later, in sh_elf_finish_dynamic_sections, but we
3101 must add the entries now so that we get the correct size for
3102 the .dynamic section. The DT_DEBUG entry is filled in by the
3103 dynamic linker and used by the debugger. */
3104 #define add_dynamic_entry(TAG, VAL) \
3105 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3107 if (info
->executable
)
3109 if (! add_dynamic_entry (DT_DEBUG
, 0))
3113 if (htab
->splt
->size
!= 0)
3115 if (! add_dynamic_entry (DT_PLTGOT
, 0)
3116 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
3117 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3118 || ! add_dynamic_entry (DT_JMPREL
, 0))
3124 if (! add_dynamic_entry (DT_RELA
, 0)
3125 || ! add_dynamic_entry (DT_RELASZ
, 0)
3126 || ! add_dynamic_entry (DT_RELAENT
,
3127 sizeof (Elf32_External_Rela
)))
3130 /* If any dynamic relocs apply to a read-only section,
3131 then we need a DT_TEXTREL entry. */
3132 if ((info
->flags
& DF_TEXTREL
) == 0)
3133 elf_link_hash_traverse (&htab
->root
, readonly_dynrelocs
, info
);
3135 if ((info
->flags
& DF_TEXTREL
) != 0)
3137 if (! add_dynamic_entry (DT_TEXTREL
, 0))
3142 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3145 #undef add_dynamic_entry
3150 /* Relocate an SH ELF section. */
3153 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3154 bfd
*input_bfd
, asection
*input_section
,
3155 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3156 Elf_Internal_Sym
*local_syms
,
3157 asection
**local_sections
)
3159 struct elf_sh_link_hash_table
*htab
;
3160 Elf_Internal_Shdr
*symtab_hdr
;
3161 struct elf_link_hash_entry
**sym_hashes
;
3162 Elf_Internal_Rela
*rel
, *relend
;
3164 bfd_vma
*local_got_offsets
;
3171 htab
= sh_elf_hash_table (info
);
3172 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3173 sym_hashes
= elf_sym_hashes (input_bfd
);
3174 dynobj
= htab
->root
.dynobj
;
3175 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3178 sgotplt
= htab
->sgotplt
;
3184 relend
= relocs
+ input_section
->reloc_count
;
3185 for (; rel
< relend
; rel
++)
3188 reloc_howto_type
*howto
;
3189 unsigned long r_symndx
;
3190 Elf_Internal_Sym
*sym
;
3192 struct elf_link_hash_entry
*h
;
3194 bfd_vma addend
= (bfd_vma
) 0;
3195 bfd_reloc_status_type r
;
3196 int seen_stt_datalabel
= 0;
3200 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3202 r_type
= ELF32_R_TYPE (rel
->r_info
);
3204 /* Many of the relocs are only used for relaxing, and are
3205 handled entirely by the relaxation code. */
3206 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3207 && r_type
<= (int) R_SH_LABEL
)
3209 if (r_type
== (int) R_SH_NONE
)
3213 || r_type
>= R_SH_max
3214 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3215 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3216 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3217 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3218 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3219 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3220 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3221 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3222 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3223 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
))
3225 bfd_set_error (bfd_error_bad_value
);
3229 howto
= get_howto_table (output_bfd
) + r_type
;
3231 /* For relocs that aren't partial_inplace, we get the addend from
3233 if (! howto
->partial_inplace
)
3234 addend
= rel
->r_addend
;
3239 if (r_symndx
< symtab_hdr
->sh_info
)
3241 sym
= local_syms
+ r_symndx
;
3242 sec
= local_sections
[r_symndx
];
3243 relocation
= (sec
->output_section
->vma
3244 + sec
->output_offset
3246 /* A local symbol never has STO_SH5_ISA32, so we don't need
3247 datalabel processing here. Make sure this does not change
3249 if ((sym
->st_other
& STO_SH5_ISA32
) != 0)
3250 ((*info
->callbacks
->reloc_dangerous
)
3252 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
3253 input_bfd
, input_section
, rel
->r_offset
));
3255 if (sec
!= NULL
&& elf_discarded_section (sec
))
3256 /* Handled below. */
3258 else if (info
->relocatable
)
3260 /* This is a relocatable link. We don't have to change
3261 anything, unless the reloc is against a section symbol,
3262 in which case we have to adjust according to where the
3263 section symbol winds up in the output section. */
3264 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3266 if (! howto
->partial_inplace
)
3268 /* For relocations with the addend in the
3269 relocation, we need just to update the addend.
3270 All real relocs are of type partial_inplace; this
3271 code is mostly for completeness. */
3272 rel
->r_addend
+= sec
->output_offset
;
3277 /* Relocs of type partial_inplace need to pick up the
3278 contents in the contents and add the offset resulting
3279 from the changed location of the section symbol.
3280 Using _bfd_final_link_relocate (e.g. goto
3281 final_link_relocate) here would be wrong, because
3282 relocations marked pc_relative would get the current
3283 location subtracted, and we must only do that at the
3285 r
= _bfd_relocate_contents (howto
, input_bfd
,
3288 contents
+ rel
->r_offset
);
3289 goto relocation_done
;
3294 else if (! howto
->partial_inplace
)
3296 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3297 addend
= rel
->r_addend
;
3299 else if ((sec
->flags
& SEC_MERGE
)
3300 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3304 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
3306 (*_bfd_error_handler
)
3307 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3308 input_bfd
, input_section
,
3309 (long) rel
->r_offset
, howto
->name
);
3313 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3316 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
3318 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3319 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
3325 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
3328 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3329 while (h
->root
.type
== bfd_link_hash_indirect
3330 || h
->root
.type
== bfd_link_hash_warning
)
3332 #ifdef INCLUDE_SHMEDIA
3333 /* If the reference passes a symbol marked with
3334 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
3336 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
3338 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3340 if (h
->root
.type
== bfd_link_hash_defined
3341 || h
->root
.type
== bfd_link_hash_defweak
)
3345 dyn
= htab
->root
.dynamic_sections_created
;
3346 sec
= h
->root
.u
.def
.section
;
3347 /* In these cases, we don't need the relocation value.
3348 We check specially because in some obscure cases
3349 sec->output_section will be NULL. */
3350 if (r_type
== R_SH_GOTPC
3351 || r_type
== R_SH_GOTPC_LOW16
3352 || r_type
== R_SH_GOTPC_MEDLOW16
3353 || r_type
== R_SH_GOTPC_MEDHI16
3354 || r_type
== R_SH_GOTPC_HI16
3355 || ((r_type
== R_SH_PLT32
3356 || r_type
== R_SH_PLT_LOW16
3357 || r_type
== R_SH_PLT_MEDLOW16
3358 || r_type
== R_SH_PLT_MEDHI16
3359 || r_type
== R_SH_PLT_HI16
)
3360 && h
->plt
.offset
!= (bfd_vma
) -1)
3361 || ((r_type
== R_SH_GOT32
3362 || r_type
== R_SH_GOT_LOW16
3363 || r_type
== R_SH_GOT_MEDLOW16
3364 || r_type
== R_SH_GOT_MEDHI16
3365 || r_type
== R_SH_GOT_HI16
)
3366 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3368 || (! info
->symbolic
&& h
->dynindx
!= -1)
3369 || !h
->def_regular
))
3370 /* The cases above are those in which relocation is
3371 overwritten in the switch block below. The cases
3372 below are those in which we must defer relocation
3373 to run-time, because we can't resolve absolute
3374 addresses when creating a shared library. */
3376 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3378 && ((r_type
== R_SH_DIR32
3379 && !h
->forced_local
)
3380 || (r_type
== R_SH_REL32
3381 && !SYMBOL_CALLS_LOCAL (info
, h
)))
3382 && ((input_section
->flags
& SEC_ALLOC
) != 0
3383 /* DWARF will emit R_SH_DIR32 relocations in its
3384 sections against symbols defined externally
3385 in shared libraries. We can't do anything
3387 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
3388 && h
->def_dynamic
)))
3389 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3390 sections because such sections are not SEC_ALLOC and
3391 thus ld.so will not process them. */
3392 || (sec
->output_section
== NULL
3393 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
3395 || (sec
->output_section
== NULL
3396 && (sh_elf_hash_entry (h
)->tls_type
== GOT_TLS_IE
3397 || sh_elf_hash_entry (h
)->tls_type
== GOT_TLS_GD
)))
3399 else if (sec
->output_section
!= NULL
)
3400 relocation
= ((h
->root
.u
.def
.value
3401 + sec
->output_section
->vma
3402 + sec
->output_offset
)
3403 /* A STO_SH5_ISA32 causes a "bitor 1" to the
3404 symbol value, unless we've seen
3405 STT_DATALABEL on the way to it. */
3406 | ((h
->other
& STO_SH5_ISA32
) != 0
3407 && ! seen_stt_datalabel
));
3408 else if (!info
->relocatable
)
3410 (*_bfd_error_handler
)
3411 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3414 (long) rel
->r_offset
,
3416 h
->root
.root
.string
);
3420 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3422 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3423 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3425 else if (!info
->relocatable
)
3427 if (! info
->callbacks
->undefined_symbol
3428 (info
, h
->root
.root
.string
, input_bfd
,
3429 input_section
, rel
->r_offset
,
3430 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
3431 || ELF_ST_VISIBILITY (h
->other
))))
3436 if (sec
!= NULL
&& elf_discarded_section (sec
))
3438 /* For relocs against symbols from removed linkonce sections,
3439 or sections discarded by a linker script, we just want the
3440 section contents zeroed. Avoid any special processing. */
3441 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
3447 if (info
->relocatable
)
3450 switch ((int) r_type
)
3452 final_link_relocate
:
3453 /* COFF relocs don't use the addend. The addend is used for
3454 R_SH_DIR32 to be compatible with other compilers. */
3455 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3456 contents
, rel
->r_offset
,
3457 relocation
, addend
);
3461 goto final_link_relocate
;
3466 /* If the reloc is against the start of this section, then
3467 the assembler has already taken care of it and the reloc
3468 is here only to assist in relaxing. If the reloc is not
3469 against the start of this section, then it's against an
3470 external symbol and we must deal with it ourselves. */
3471 if (input_section
->output_section
->vma
+ input_section
->output_offset
3474 int disp
= (relocation
3475 - input_section
->output_section
->vma
3476 - input_section
->output_offset
3482 case R_SH_DIR8WPZ
: mask
= 1; break;
3483 case R_SH_DIR8WPL
: mask
= 3; break;
3484 default: mask
= 0; break;
3488 ((*_bfd_error_handler
)
3489 (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
3490 input_section
->owner
,
3491 (unsigned long) rel
->r_offset
));
3492 bfd_set_error (bfd_error_bad_value
);
3496 goto final_link_relocate
;
3502 #ifdef INCLUDE_SHMEDIA
3503 if (shmedia_prepare_reloc (info
, input_bfd
, input_section
,
3504 contents
, rel
, &relocation
))
3505 goto final_link_relocate
;
3507 bfd_set_error (bfd_error_bad_value
);
3515 goto final_link_relocate
;
3521 ((*_bfd_error_handler
)
3522 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
3523 input_section
->owner
,
3524 (unsigned long) rel
->r_offset
, howto
->name
,
3525 (unsigned long) relocation
));
3526 bfd_set_error (bfd_error_bad_value
);
3529 goto final_link_relocate
;
3536 ((*_bfd_error_handler
)
3537 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
3538 input_section
->owner
,
3539 (unsigned long) rel
->r_offset
, howto
->name
,
3540 (unsigned long) relocation
));
3541 bfd_set_error (bfd_error_bad_value
);
3544 goto final_link_relocate
;
3547 if ((signed int)relocation
< -32
3548 || (signed int)relocation
> 32)
3550 ((*_bfd_error_handler
)
3551 (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
3552 input_section
->owner
,
3553 (unsigned long) rel
->r_offset
,
3554 (unsigned long) relocation
));
3555 bfd_set_error (bfd_error_bad_value
);
3558 goto final_link_relocate
;
3561 if ((signed int)relocation
< -16
3562 || (signed int)relocation
> 16)
3564 ((*_bfd_error_handler
)
3565 (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
3566 input_section
->owner
,
3567 (unsigned long) rel
->r_offset
,
3568 (unsigned long) relocation
));
3569 bfd_set_error (bfd_error_bad_value
);
3572 goto final_link_relocate
;
3576 #ifdef INCLUDE_SHMEDIA
3577 case R_SH_IMM_LOW16_PCREL
:
3578 case R_SH_IMM_MEDLOW16_PCREL
:
3579 case R_SH_IMM_MEDHI16_PCREL
:
3580 case R_SH_IMM_HI16_PCREL
:
3584 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3585 || h
->root
.type
!= bfd_link_hash_undefweak
)
3587 && (input_section
->flags
& SEC_ALLOC
) != 0
3588 && (r_type
== R_SH_DIR32
3589 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3591 Elf_Internal_Rela outrel
;
3593 bfd_boolean skip
, relocate
;
3595 /* When generating a shared object, these relocations
3596 are copied into the output file to be resolved at run
3603 name
= (bfd_elf_string_from_elf_section
3605 elf_elfheader (input_bfd
)->e_shstrndx
,
3606 elf_section_data (input_section
)->rel_hdr
.sh_name
));
3610 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
3611 && strcmp (bfd_get_section_name (input_bfd
,
3615 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3616 BFD_ASSERT (sreloc
!= NULL
);
3623 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3625 if (outrel
.r_offset
== (bfd_vma
) -1)
3627 else if (outrel
.r_offset
== (bfd_vma
) -2)
3628 skip
= TRUE
, relocate
= TRUE
;
3629 outrel
.r_offset
+= (input_section
->output_section
->vma
3630 + input_section
->output_offset
);
3633 memset (&outrel
, 0, sizeof outrel
);
3634 else if (r_type
== R_SH_REL32
)
3636 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3637 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
3639 = (howto
->partial_inplace
3640 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3643 #ifdef INCLUDE_SHMEDIA
3644 else if (r_type
== R_SH_IMM_LOW16_PCREL
3645 || r_type
== R_SH_IMM_MEDLOW16_PCREL
3646 || r_type
== R_SH_IMM_MEDHI16_PCREL
3647 || r_type
== R_SH_IMM_HI16_PCREL
)
3649 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3650 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3651 outrel
.r_addend
= addend
;
3656 /* h->dynindx may be -1 if this symbol was marked to
3659 || ((info
->symbolic
|| h
->dynindx
== -1)
3662 relocate
= howto
->partial_inplace
;
3663 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3667 BFD_ASSERT (h
->dynindx
!= -1);
3668 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
3670 outrel
.r_addend
= relocation
;
3672 += (howto
->partial_inplace
3673 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3677 loc
= sreloc
->contents
;
3678 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3679 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3681 /* If this reloc is against an external symbol, we do
3682 not want to fiddle with the addend. Otherwise, we
3683 need to include the symbol value so that it becomes
3684 an addend for the dynamic reloc. */
3688 goto final_link_relocate
;
3691 #ifdef INCLUDE_SHMEDIA
3692 case R_SH_GOTPLT_LOW16
:
3693 case R_SH_GOTPLT_MEDLOW16
:
3694 case R_SH_GOTPLT_MEDHI16
:
3695 case R_SH_GOTPLT_HI16
:
3696 case R_SH_GOTPLT10BY4
:
3697 case R_SH_GOTPLT10BY8
:
3699 /* Relocation is to the entry for this symbol in the
3700 procedure linkage table. */
3707 || h
->plt
.offset
== (bfd_vma
) -1
3708 || h
->got
.offset
!= (bfd_vma
) -1)
3711 /* Relocation is to the entry for this symbol in the global
3712 offset table extension for the procedure linkage table. */
3714 BFD_ASSERT (sgotplt
!= NULL
);
3715 relocation
= (sgotplt
->output_offset
3716 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
3720 relocation
-= GOT_BIAS
;
3723 goto final_link_relocate
;
3727 #ifdef INCLUDE_SHMEDIA
3728 case R_SH_GOT_LOW16
:
3729 case R_SH_GOT_MEDLOW16
:
3730 case R_SH_GOT_MEDHI16
:
3735 /* Relocation is to the entry for this symbol in the global
3738 BFD_ASSERT (sgot
!= NULL
);
3744 off
= h
->got
.offset
;
3745 #ifdef INCLUDE_SHMEDIA
3746 if (seen_stt_datalabel
)
3748 struct elf_sh_link_hash_entry
*hsh
;
3750 hsh
= (struct elf_sh_link_hash_entry
*)h
;
3751 off
= hsh
->datalabel_got
.offset
;
3754 BFD_ASSERT (off
!= (bfd_vma
) -1);
3756 dyn
= htab
->root
.dynamic_sections_created
;
3757 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3759 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3760 || (ELF_ST_VISIBILITY (h
->other
)
3761 && h
->root
.type
== bfd_link_hash_undefweak
))
3763 /* This is actually a static link, or it is a
3764 -Bsymbolic link and the symbol is defined
3765 locally, or the symbol was forced to be local
3766 because of a version file. We must initialize
3767 this entry in the global offset table. Since the
3768 offset must always be a multiple of 4, we use the
3769 least significant bit to record whether we have
3770 initialized it already.
3772 When doing a dynamic link, we create a .rela.got
3773 relocation entry to initialize the value. This
3774 is done in the finish_dynamic_symbol routine. */
3779 bfd_put_32 (output_bfd
, relocation
,
3780 sgot
->contents
+ off
);
3781 #ifdef INCLUDE_SHMEDIA
3782 if (seen_stt_datalabel
)
3784 struct elf_sh_link_hash_entry
*hsh
;
3786 hsh
= (struct elf_sh_link_hash_entry
*)h
;
3787 hsh
->datalabel_got
.offset
|= 1;
3795 relocation
= sgot
->output_offset
+ off
;
3799 #ifdef INCLUDE_SHMEDIA
3802 BFD_ASSERT (local_got_offsets
!= NULL
3803 && (local_got_offsets
[symtab_hdr
->sh_info
3807 off
= local_got_offsets
[symtab_hdr
->sh_info
3813 BFD_ASSERT (local_got_offsets
!= NULL
3814 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
3816 off
= local_got_offsets
[r_symndx
];
3817 #ifdef INCLUDE_SHMEDIA
3821 /* The offset must always be a multiple of 4. We use
3822 the least significant bit to record whether we have
3823 already generated the necessary reloc. */
3828 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
3832 Elf_Internal_Rela outrel
;
3835 if (srelgot
== NULL
)
3837 srelgot
= bfd_get_section_by_name (dynobj
,
3839 BFD_ASSERT (srelgot
!= NULL
);
3842 outrel
.r_offset
= (sgot
->output_section
->vma
3843 + sgot
->output_offset
3845 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3846 outrel
.r_addend
= relocation
;
3847 loc
= srelgot
->contents
;
3848 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3849 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3852 #ifdef INCLUDE_SHMEDIA
3854 local_got_offsets
[symtab_hdr
->sh_info
+ r_symndx
] |= 1;
3857 local_got_offsets
[r_symndx
] |= 1;
3860 relocation
= sgot
->output_offset
+ off
;
3864 relocation
-= GOT_BIAS
;
3867 goto final_link_relocate
;
3870 #ifdef INCLUDE_SHMEDIA
3871 case R_SH_GOTOFF_LOW16
:
3872 case R_SH_GOTOFF_MEDLOW16
:
3873 case R_SH_GOTOFF_MEDHI16
:
3874 case R_SH_GOTOFF_HI16
:
3876 /* Relocation is relative to the start of the global offset
3879 BFD_ASSERT (sgot
!= NULL
);
3881 /* Note that sgot->output_offset is not involved in this
3882 calculation. We always want the start of .got. If we
3883 defined _GLOBAL_OFFSET_TABLE in a different way, as is
3884 permitted by the ABI, we might have to change this
3886 relocation
-= sgot
->output_section
->vma
;
3889 relocation
-= GOT_BIAS
;
3892 addend
= rel
->r_addend
;
3894 goto final_link_relocate
;
3897 #ifdef INCLUDE_SHMEDIA
3898 case R_SH_GOTPC_LOW16
:
3899 case R_SH_GOTPC_MEDLOW16
:
3900 case R_SH_GOTPC_MEDHI16
:
3901 case R_SH_GOTPC_HI16
:
3903 /* Use global offset table as symbol value. */
3905 BFD_ASSERT (sgot
!= NULL
);
3906 relocation
= sgot
->output_section
->vma
;
3909 relocation
+= GOT_BIAS
;
3912 addend
= rel
->r_addend
;
3914 goto final_link_relocate
;
3917 #ifdef INCLUDE_SHMEDIA
3918 case R_SH_PLT_LOW16
:
3919 case R_SH_PLT_MEDLOW16
:
3920 case R_SH_PLT_MEDHI16
:
3923 /* Relocation is to the entry for this symbol in the
3924 procedure linkage table. */
3926 /* Resolve a PLT reloc against a local symbol directly,
3927 without using the procedure linkage table. */
3929 goto final_link_relocate
;
3931 if (h
->forced_local
)
3932 goto final_link_relocate
;
3934 if (h
->plt
.offset
== (bfd_vma
) -1)
3936 /* We didn't make a PLT entry for this symbol. This
3937 happens when statically linking PIC code, or when
3938 using -Bsymbolic. */
3939 goto final_link_relocate
;
3942 BFD_ASSERT (splt
!= NULL
);
3943 relocation
= (splt
->output_section
->vma
3944 + splt
->output_offset
3947 #ifdef INCLUDE_SHMEDIA
3951 addend
= rel
->r_addend
;
3953 goto final_link_relocate
;
3955 case R_SH_LOOP_START
:
3957 static bfd_vma start
, end
;
3959 start
= (relocation
+ rel
->r_addend
3960 - (sec
->output_section
->vma
+ sec
->output_offset
));
3961 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
3962 rel
->r_offset
, sec
, start
, end
);
3966 end
= (relocation
+ rel
->r_addend
3967 - (sec
->output_section
->vma
+ sec
->output_offset
));
3968 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
3969 rel
->r_offset
, sec
, start
, end
);
3973 case R_SH_TLS_GD_32
:
3974 case R_SH_TLS_IE_32
:
3975 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
3976 tls_type
= GOT_UNKNOWN
;
3977 if (h
== NULL
&& local_got_offsets
)
3978 tls_type
= sh_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3981 tls_type
= sh_elf_hash_entry (h
)->tls_type
;
3983 && (h
->dynindx
== -1
3985 r_type
= R_SH_TLS_LE_32
;
3988 if (r_type
== R_SH_TLS_GD_32
&& tls_type
== GOT_TLS_IE
)
3989 r_type
= R_SH_TLS_IE_32
;
3991 if (r_type
== R_SH_TLS_LE_32
)
3994 unsigned short insn
;
3996 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
3998 /* GD->LE transition:
3999 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4000 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4001 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4003 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4005 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
4007 offset
= rel
->r_offset
;
4008 BFD_ASSERT (offset
>= 16);
4009 /* Size of GD instructions is 16 or 18. */
4011 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4012 if ((insn
& 0xff00) == 0xc700)
4014 BFD_ASSERT (offset
>= 2);
4016 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4019 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4020 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4021 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4022 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4023 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4024 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4025 BFD_ASSERT (insn
== 0x310c);
4026 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4027 BFD_ASSERT (insn
== 0x410b);
4028 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4029 BFD_ASSERT (insn
== 0x34cc);
4031 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
4032 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
4033 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4034 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4035 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4041 /* IE->LE transition:
4042 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
4043 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
4045 mov.l .Ln,rM; stc gbr,rN; nop; ...;
4048 offset
= rel
->r_offset
;
4049 BFD_ASSERT (offset
>= 16);
4050 /* Size of IE instructions is 10 or 12. */
4052 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4053 if ((insn
& 0xf0ff) == 0x0012)
4055 BFD_ASSERT (offset
>= 2);
4057 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4060 BFD_ASSERT ((insn
& 0xff00) == 0xd000);
4061 index
= insn
& 0x00ff;
4062 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4063 BFD_ASSERT ((insn
& 0xf0ff) == 0x0012);
4064 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4065 BFD_ASSERT ((insn
& 0xf0ff) == 0x00ce);
4066 insn
= 0xd000 | (insn
& 0x0f00) | index
;
4067 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
4068 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4071 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4072 contents
+ rel
->r_offset
);
4081 off
= h
->got
.offset
;
4084 if (local_got_offsets
== NULL
)
4087 off
= local_got_offsets
[r_symndx
];
4090 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
4091 if (r_type
== R_SH_TLS_IE_32
4092 && ! htab
->root
.dynamic_sections_created
)
4095 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4096 sgot
->contents
+ off
);
4097 bfd_put_32 (output_bfd
, sgot
->output_offset
+ off
,
4098 contents
+ rel
->r_offset
);
4106 Elf_Internal_Rela outrel
;
4110 if (srelgot
== NULL
)
4112 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4113 BFD_ASSERT (srelgot
!= NULL
);
4116 outrel
.r_offset
= (sgot
->output_section
->vma
4117 + sgot
->output_offset
+ off
);
4119 if (h
== NULL
|| h
->dynindx
== -1)
4124 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
4126 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
4127 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4129 outrel
.r_addend
= 0;
4130 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4131 loc
= srelgot
->contents
;
4132 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4133 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4135 if (r_type
== R_SH_TLS_GD_32
)
4139 bfd_put_32 (output_bfd
,
4140 relocation
- dtpoff_base (info
),
4141 sgot
->contents
+ off
+ 4);
4145 outrel
.r_info
= ELF32_R_INFO (indx
,
4147 outrel
.r_offset
+= 4;
4148 outrel
.r_addend
= 0;
4149 srelgot
->reloc_count
++;
4150 loc
+= sizeof (Elf32_External_Rela
);
4151 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4158 local_got_offsets
[r_symndx
] |= 1;
4161 if (off
>= (bfd_vma
) -2)
4164 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
4165 relocation
= sgot
->output_offset
+ off
;
4169 unsigned short insn
;
4171 /* GD->IE transition:
4172 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4173 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4174 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4176 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4177 nop; nop; bra 3f; nop; .align 2;
4178 1: .long x@TPOFF; 2:...; 3:. */
4180 offset
= rel
->r_offset
;
4181 BFD_ASSERT (offset
>= 16);
4182 /* Size of GD instructions is 16 or 18. */
4184 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4185 if ((insn
& 0xff00) == 0xc700)
4187 BFD_ASSERT (offset
>= 2);
4189 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4192 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4194 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
4195 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
4197 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4198 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4199 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4200 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4201 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4202 BFD_ASSERT (insn
== 0x310c);
4203 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4204 BFD_ASSERT (insn
== 0x410b);
4205 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4206 BFD_ASSERT (insn
== 0x34cc);
4208 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
4209 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
4210 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
4211 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4212 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4214 bfd_put_32 (output_bfd
, sgot
->output_offset
+ off
,
4215 contents
+ rel
->r_offset
);
4220 addend
= rel
->r_addend
;
4222 goto final_link_relocate
;
4224 case R_SH_TLS_LD_32
:
4228 unsigned short insn
;
4230 /* LD->LE transition:
4231 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4232 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4233 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4235 stc gbr,r0; nop; nop; nop;
4236 nop; nop; bra 3f; ...; 3:. */
4238 offset
= rel
->r_offset
;
4239 BFD_ASSERT (offset
>= 16);
4240 /* Size of LD instructions is 16 or 18. */
4242 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4243 if ((insn
& 0xff00) == 0xc700)
4245 BFD_ASSERT (offset
>= 2);
4247 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4250 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4251 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4252 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4253 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4254 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4255 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4256 BFD_ASSERT (insn
== 0x310c);
4257 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4258 BFD_ASSERT (insn
== 0x410b);
4259 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4260 BFD_ASSERT (insn
== 0x34cc);
4262 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
4263 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
4264 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4265 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4266 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4267 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4276 off
= htab
->tls_ldm_got
.offset
;
4281 Elf_Internal_Rela outrel
;
4284 srelgot
= htab
->srelgot
;
4285 if (srelgot
== NULL
)
4288 outrel
.r_offset
= (sgot
->output_section
->vma
4289 + sgot
->output_offset
+ off
);
4290 outrel
.r_addend
= 0;
4291 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
4292 loc
= srelgot
->contents
;
4293 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4294 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4295 htab
->tls_ldm_got
.offset
|= 1;
4298 relocation
= sgot
->output_offset
+ off
;
4299 addend
= rel
->r_addend
;
4301 goto final_link_relocate
;
4303 case R_SH_TLS_LDO_32
:
4305 relocation
= tpoff (info
, relocation
);
4307 relocation
-= dtpoff_base (info
);
4309 addend
= rel
->r_addend
;
4310 goto final_link_relocate
;
4312 case R_SH_TLS_LE_32
:
4315 Elf_Internal_Rela outrel
;
4320 relocation
= tpoff (info
, relocation
);
4321 addend
= rel
->r_addend
;
4322 goto final_link_relocate
;
4329 name
= (bfd_elf_string_from_elf_section
4331 elf_elfheader (input_bfd
)->e_shstrndx
,
4332 elf_section_data (input_section
)->rel_hdr
.sh_name
));
4336 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
4337 && strcmp (bfd_get_section_name (input_bfd
,
4341 sreloc
= bfd_get_section_by_name (dynobj
, name
);
4342 BFD_ASSERT (sreloc
!= NULL
);
4345 if (h
== NULL
|| h
->dynindx
== -1)
4350 outrel
.r_offset
= (input_section
->output_section
->vma
4351 + input_section
->output_offset
4353 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
4355 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4357 outrel
.r_addend
= 0;
4359 loc
= sreloc
->contents
;
4360 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4361 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4367 if (r
!= bfd_reloc_ok
)
4372 case bfd_reloc_outofrange
:
4374 case bfd_reloc_overflow
:
4382 name
= (bfd_elf_string_from_elf_section
4383 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4387 name
= bfd_section_name (input_bfd
, sec
);
4389 if (! ((*info
->callbacks
->reloc_overflow
)
4390 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4391 (bfd_vma
) 0, input_bfd
, input_section
,
4403 /* This is a version of bfd_generic_get_relocated_section_contents
4404 which uses sh_elf_relocate_section. */
4407 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
4408 struct bfd_link_info
*link_info
,
4409 struct bfd_link_order
*link_order
,
4411 bfd_boolean relocatable
,
4414 Elf_Internal_Shdr
*symtab_hdr
;
4415 asection
*input_section
= link_order
->u
.indirect
.section
;
4416 bfd
*input_bfd
= input_section
->owner
;
4417 asection
**sections
= NULL
;
4418 Elf_Internal_Rela
*internal_relocs
= NULL
;
4419 Elf_Internal_Sym
*isymbuf
= NULL
;
4421 /* We only need to handle the case of relaxing, or of having a
4422 particular set of section contents, specially. */
4424 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
4425 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
4430 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4432 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
4433 (size_t) input_section
->size
);
4435 if ((input_section
->flags
& SEC_RELOC
) != 0
4436 && input_section
->reloc_count
> 0)
4439 Elf_Internal_Sym
*isym
, *isymend
;
4442 internal_relocs
= (_bfd_elf_link_read_relocs
4443 (input_bfd
, input_section
, NULL
,
4444 (Elf_Internal_Rela
*) NULL
, FALSE
));
4445 if (internal_relocs
== NULL
)
4448 if (symtab_hdr
->sh_info
!= 0)
4450 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
4451 if (isymbuf
== NULL
)
4452 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
4453 symtab_hdr
->sh_info
, 0,
4455 if (isymbuf
== NULL
)
4459 amt
= symtab_hdr
->sh_info
;
4460 amt
*= sizeof (asection
*);
4461 sections
= (asection
**) bfd_malloc (amt
);
4462 if (sections
== NULL
&& amt
!= 0)
4465 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
4466 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
4470 if (isym
->st_shndx
== SHN_UNDEF
)
4471 isec
= bfd_und_section_ptr
;
4472 else if (isym
->st_shndx
== SHN_ABS
)
4473 isec
= bfd_abs_section_ptr
;
4474 else if (isym
->st_shndx
== SHN_COMMON
)
4475 isec
= bfd_com_section_ptr
;
4477 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
4482 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
4483 input_section
, data
, internal_relocs
,
4487 if (sections
!= NULL
)
4490 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
4492 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
4493 free (internal_relocs
);
4499 if (sections
!= NULL
)
4502 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
4504 if (internal_relocs
!= NULL
4505 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
4506 free (internal_relocs
);
4510 /* Return the base VMA address which should be subtracted from real addresses
4511 when resolving @dtpoff relocation.
4512 This is PT_TLS segment p_vaddr. */
4515 dtpoff_base (struct bfd_link_info
*info
)
4517 /* If tls_sec is NULL, we should have signalled an error already. */
4518 if (elf_hash_table (info
)->tls_sec
== NULL
)
4520 return elf_hash_table (info
)->tls_sec
->vma
;
4523 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
4526 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4528 /* If tls_sec is NULL, we should have signalled an error already. */
4529 if (elf_hash_table (info
)->tls_sec
== NULL
)
4531 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
4532 structure which has 2 pointer fields. */
4533 return (address
- elf_hash_table (info
)->tls_sec
->vma
4534 + align_power ((bfd_vma
) 8,
4535 elf_hash_table (info
)->tls_sec
->alignment_power
));
4539 sh_elf_gc_mark_hook (asection
*sec
,
4540 struct bfd_link_info
*info
,
4541 Elf_Internal_Rela
*rel
,
4542 struct elf_link_hash_entry
*h
,
4543 Elf_Internal_Sym
*sym
)
4546 switch (ELF32_R_TYPE (rel
->r_info
))
4548 case R_SH_GNU_VTINHERIT
:
4549 case R_SH_GNU_VTENTRY
:
4553 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4556 /* Update the got entry reference counts for the section being removed. */
4559 sh_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4560 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4562 Elf_Internal_Shdr
*symtab_hdr
;
4563 struct elf_link_hash_entry
**sym_hashes
;
4564 bfd_signed_vma
*local_got_refcounts
;
4565 const Elf_Internal_Rela
*rel
, *relend
;
4567 if (info
->relocatable
)
4570 elf_section_data (sec
)->local_dynrel
= NULL
;
4572 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4573 sym_hashes
= elf_sym_hashes (abfd
);
4574 local_got_refcounts
= elf_local_got_refcounts (abfd
);
4576 relend
= relocs
+ sec
->reloc_count
;
4577 for (rel
= relocs
; rel
< relend
; rel
++)
4579 unsigned long r_symndx
;
4580 unsigned int r_type
;
4581 struct elf_link_hash_entry
*h
= NULL
;
4582 #ifdef INCLUDE_SHMEDIA
4583 int seen_stt_datalabel
= 0;
4586 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4587 if (r_symndx
>= symtab_hdr
->sh_info
)
4589 struct elf_sh_link_hash_entry
*eh
;
4590 struct elf_sh_dyn_relocs
**pp
;
4591 struct elf_sh_dyn_relocs
*p
;
4593 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4594 while (h
->root
.type
== bfd_link_hash_indirect
4595 || h
->root
.type
== bfd_link_hash_warning
)
4597 #ifdef INCLUDE_SHMEDIA
4598 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
4600 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4602 eh
= (struct elf_sh_link_hash_entry
*) h
;
4603 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
4606 /* Everything must go for SEC. */
4612 r_type
= ELF32_R_TYPE (rel
->r_info
);
4613 switch (sh_elf_optimized_tls_reloc (info
, r_type
, h
!= NULL
))
4615 case R_SH_TLS_LD_32
:
4616 if (sh_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
4617 sh_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
4623 #ifdef INCLUDE_SHMEDIA
4624 case R_SH_GOT_LOW16
:
4625 case R_SH_GOT_MEDLOW16
:
4626 case R_SH_GOT_MEDHI16
:
4630 case R_SH_GOTOFF_LOW16
:
4631 case R_SH_GOTOFF_MEDLOW16
:
4632 case R_SH_GOTOFF_MEDHI16
:
4633 case R_SH_GOTOFF_HI16
:
4634 case R_SH_GOTPC_LOW16
:
4635 case R_SH_GOTPC_MEDLOW16
:
4636 case R_SH_GOTPC_MEDHI16
:
4637 case R_SH_GOTPC_HI16
:
4639 case R_SH_TLS_GD_32
:
4640 case R_SH_TLS_IE_32
:
4643 #ifdef INCLUDE_SHMEDIA
4644 if (seen_stt_datalabel
)
4646 struct elf_sh_link_hash_entry
*eh
;
4647 eh
= (struct elf_sh_link_hash_entry
*) h
;
4648 if (eh
->datalabel_got
.refcount
> 0)
4649 eh
->datalabel_got
.refcount
-= 1;
4653 if (h
->got
.refcount
> 0)
4654 h
->got
.refcount
-= 1;
4656 else if (local_got_refcounts
!= NULL
)
4658 #ifdef INCLUDE_SHMEDIA
4659 if (rel
->r_addend
& 1)
4661 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
4662 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
4666 if (local_got_refcounts
[r_symndx
] > 0)
4667 local_got_refcounts
[r_symndx
] -= 1;
4678 #ifdef INCLUDE_SHMEDIA
4679 case R_SH_PLT_LOW16
:
4680 case R_SH_PLT_MEDLOW16
:
4681 case R_SH_PLT_MEDHI16
:
4686 if (h
->plt
.refcount
> 0)
4687 h
->plt
.refcount
-= 1;
4692 #ifdef INCLUDE_SHMEDIA
4693 case R_SH_GOTPLT_LOW16
:
4694 case R_SH_GOTPLT_MEDLOW16
:
4695 case R_SH_GOTPLT_MEDHI16
:
4696 case R_SH_GOTPLT_HI16
:
4697 case R_SH_GOTPLT10BY4
:
4698 case R_SH_GOTPLT10BY8
:
4702 struct elf_sh_link_hash_entry
*eh
;
4703 eh
= (struct elf_sh_link_hash_entry
*) h
;
4704 if (eh
->gotplt_refcount
> 0)
4706 eh
->gotplt_refcount
-= 1;
4707 if (h
->plt
.refcount
> 0)
4708 h
->plt
.refcount
-= 1;
4710 #ifdef INCLUDE_SHMEDIA
4711 else if (seen_stt_datalabel
)
4713 if (eh
->datalabel_got
.refcount
> 0)
4714 eh
->datalabel_got
.refcount
-= 1;
4717 else if (h
->got
.refcount
> 0)
4718 h
->got
.refcount
-= 1;
4720 else if (local_got_refcounts
!= NULL
)
4722 #ifdef INCLUDE_SHMEDIA
4723 if (rel
->r_addend
& 1)
4725 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
4726 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
4730 if (local_got_refcounts
[r_symndx
] > 0)
4731 local_got_refcounts
[r_symndx
] -= 1;
4743 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4746 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
4747 struct elf_link_hash_entry
*dir
,
4748 struct elf_link_hash_entry
*ind
)
4750 struct elf_sh_link_hash_entry
*edir
, *eind
;
4752 edir
= (struct elf_sh_link_hash_entry
*) dir
;
4753 eind
= (struct elf_sh_link_hash_entry
*) ind
;
4755 if (eind
->dyn_relocs
!= NULL
)
4757 if (edir
->dyn_relocs
!= NULL
)
4759 struct elf_sh_dyn_relocs
**pp
;
4760 struct elf_sh_dyn_relocs
*p
;
4762 /* Add reloc counts against the indirect sym to the direct sym
4763 list. Merge any entries against the same section. */
4764 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
4766 struct elf_sh_dyn_relocs
*q
;
4768 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
4769 if (q
->sec
== p
->sec
)
4771 q
->pc_count
+= p
->pc_count
;
4772 q
->count
+= p
->count
;
4779 *pp
= edir
->dyn_relocs
;
4782 edir
->dyn_relocs
= eind
->dyn_relocs
;
4783 eind
->dyn_relocs
= NULL
;
4785 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
4786 eind
->gotplt_refcount
= 0;
4787 #ifdef INCLUDE_SHMEDIA
4788 edir
->datalabel_got
.refcount
+= eind
->datalabel_got
.refcount
;
4789 eind
->datalabel_got
.refcount
= 0;
4792 if (ind
->root
.type
== bfd_link_hash_indirect
4793 && dir
->got
.refcount
<= 0)
4795 edir
->tls_type
= eind
->tls_type
;
4796 eind
->tls_type
= GOT_UNKNOWN
;
4799 if (ind
->root
.type
!= bfd_link_hash_indirect
4800 && dir
->dynamic_adjusted
)
4802 /* If called to transfer flags for a weakdef during processing
4803 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
4804 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4805 dir
->ref_dynamic
|= ind
->ref_dynamic
;
4806 dir
->ref_regular
|= ind
->ref_regular
;
4807 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
4808 dir
->needs_plt
|= ind
->needs_plt
;
4811 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
4815 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
4823 case R_SH_TLS_GD_32
:
4824 case R_SH_TLS_IE_32
:
4826 return R_SH_TLS_LE_32
;
4827 return R_SH_TLS_IE_32
;
4828 case R_SH_TLS_LD_32
:
4829 return R_SH_TLS_LE_32
;
4835 /* Look through the relocs for a section during the first phase.
4836 Since we don't do .gots or .plts, we just need to consider the
4837 virtual table relocs for gc. */
4840 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
4841 const Elf_Internal_Rela
*relocs
)
4843 Elf_Internal_Shdr
*symtab_hdr
;
4844 struct elf_link_hash_entry
**sym_hashes
;
4845 struct elf_sh_link_hash_table
*htab
;
4846 const Elf_Internal_Rela
*rel
;
4847 const Elf_Internal_Rela
*rel_end
;
4848 bfd_vma
*local_got_offsets
;
4852 unsigned int r_type
;
4853 int tls_type
, old_tls_type
;
4859 if (info
->relocatable
)
4862 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4863 sym_hashes
= elf_sym_hashes (abfd
);
4865 htab
= sh_elf_hash_table (info
);
4866 local_got_offsets
= elf_local_got_offsets (abfd
);
4868 rel_end
= relocs
+ sec
->reloc_count
;
4869 for (rel
= relocs
; rel
< rel_end
; rel
++)
4871 struct elf_link_hash_entry
*h
;
4872 unsigned long r_symndx
;
4873 #ifdef INCLUDE_SHMEDIA
4874 int seen_stt_datalabel
= 0;
4877 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4878 r_type
= ELF32_R_TYPE (rel
->r_info
);
4880 if (r_symndx
< symtab_hdr
->sh_info
)
4884 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4885 while (h
->root
.type
== bfd_link_hash_indirect
4886 || h
->root
.type
== bfd_link_hash_warning
)
4888 #ifdef INCLUDE_SHMEDIA
4889 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
4891 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4895 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
4897 && r_type
== R_SH_TLS_IE_32
4899 && h
->root
.type
!= bfd_link_hash_undefined
4900 && h
->root
.type
!= bfd_link_hash_undefweak
4901 && (h
->dynindx
== -1
4903 r_type
= R_SH_TLS_LE_32
;
4905 /* Some relocs require a global offset table. */
4906 if (htab
->sgot
== NULL
)
4914 #ifdef INCLUDE_SHMEDIA
4915 case R_SH_GOTPLT_LOW16
:
4916 case R_SH_GOTPLT_MEDLOW16
:
4917 case R_SH_GOTPLT_MEDHI16
:
4918 case R_SH_GOTPLT_HI16
:
4919 case R_SH_GOTPLT10BY4
:
4920 case R_SH_GOTPLT10BY8
:
4921 case R_SH_GOT_LOW16
:
4922 case R_SH_GOT_MEDLOW16
:
4923 case R_SH_GOT_MEDHI16
:
4927 case R_SH_GOTOFF_LOW16
:
4928 case R_SH_GOTOFF_MEDLOW16
:
4929 case R_SH_GOTOFF_MEDHI16
:
4930 case R_SH_GOTOFF_HI16
:
4931 case R_SH_GOTPC_LOW16
:
4932 case R_SH_GOTPC_MEDLOW16
:
4933 case R_SH_GOTPC_MEDHI16
:
4934 case R_SH_GOTPC_HI16
:
4936 case R_SH_TLS_GD_32
:
4937 case R_SH_TLS_LD_32
:
4938 case R_SH_TLS_IE_32
:
4939 if (htab
->sgot
== NULL
)
4941 if (htab
->root
.dynobj
== NULL
)
4942 htab
->root
.dynobj
= abfd
;
4943 if (!create_got_section (htab
->root
.dynobj
, info
))
4955 /* This relocation describes the C++ object vtable hierarchy.
4956 Reconstruct it for later use during GC. */
4957 case R_SH_GNU_VTINHERIT
:
4958 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4962 /* This relocation describes which C++ vtable entries are actually
4963 used. Record for later use during GC. */
4964 case R_SH_GNU_VTENTRY
:
4965 BFD_ASSERT (h
!= NULL
);
4967 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4971 case R_SH_TLS_IE_32
:
4973 info
->flags
|= DF_STATIC_TLS
;
4977 case R_SH_TLS_GD_32
:
4979 #ifdef INCLUDE_SHMEDIA
4980 case R_SH_GOT_LOW16
:
4981 case R_SH_GOT_MEDLOW16
:
4982 case R_SH_GOT_MEDHI16
:
4990 tls_type
= GOT_NORMAL
;
4992 case R_SH_TLS_GD_32
:
4993 tls_type
= GOT_TLS_GD
;
4995 case R_SH_TLS_IE_32
:
4996 tls_type
= GOT_TLS_IE
;
5002 #ifdef INCLUDE_SHMEDIA
5003 if (seen_stt_datalabel
)
5005 struct elf_sh_link_hash_entry
*eh
5006 = (struct elf_sh_link_hash_entry
*) h
;
5008 eh
->datalabel_got
.refcount
+= 1;
5012 h
->got
.refcount
+= 1;
5013 old_tls_type
= sh_elf_hash_entry (h
)->tls_type
;
5017 bfd_signed_vma
*local_got_refcounts
;
5019 /* This is a global offset table entry for a local
5021 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5022 if (local_got_refcounts
== NULL
)
5026 size
= symtab_hdr
->sh_info
;
5027 size
*= sizeof (bfd_signed_vma
);
5028 #ifdef INCLUDE_SHMEDIA
5029 /* Reserve space for both the datalabel and
5030 codelabel local GOT offsets. */
5033 size
+= symtab_hdr
->sh_info
;
5034 local_got_refcounts
= ((bfd_signed_vma
*)
5035 bfd_zalloc (abfd
, size
));
5036 if (local_got_refcounts
== NULL
)
5038 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
5039 #ifdef INCLUDE_SHMEDIA
5040 /* Take care of both the datalabel and codelabel local
5042 sh_elf_local_got_tls_type (abfd
)
5043 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
5045 sh_elf_local_got_tls_type (abfd
)
5046 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
5049 #ifdef INCLUDE_SHMEDIA
5050 if (rel
->r_addend
& 1)
5051 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] += 1;
5054 local_got_refcounts
[r_symndx
] += 1;
5055 old_tls_type
= sh_elf_local_got_tls_type (abfd
) [r_symndx
];
5058 /* If a TLS symbol is accessed using IE at least once,
5059 there is no point to use dynamic model for it. */
5060 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
5061 && (old_tls_type
!= GOT_TLS_GD
|| tls_type
!= GOT_TLS_IE
))
5063 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
5064 tls_type
= GOT_TLS_IE
;
5067 (*_bfd_error_handler
)
5068 (_("%B: `%s' accessed both as normal and thread local symbol"),
5069 abfd
, h
->root
.root
.string
);
5074 if (old_tls_type
!= tls_type
)
5077 sh_elf_hash_entry (h
)->tls_type
= tls_type
;
5079 sh_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
5084 case R_SH_TLS_LD_32
:
5085 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
5089 #ifdef INCLUDE_SHMEDIA
5090 case R_SH_GOTPLT_LOW16
:
5091 case R_SH_GOTPLT_MEDLOW16
:
5092 case R_SH_GOTPLT_MEDHI16
:
5093 case R_SH_GOTPLT_HI16
:
5094 case R_SH_GOTPLT10BY4
:
5095 case R_SH_GOTPLT10BY8
:
5097 /* If this is a local symbol, we resolve it directly without
5098 creating a procedure linkage table entry. */
5104 || h
->dynindx
== -1)
5108 h
->plt
.refcount
+= 1;
5109 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
5114 #ifdef INCLUDE_SHMEDIA
5115 case R_SH_PLT_LOW16
:
5116 case R_SH_PLT_MEDLOW16
:
5117 case R_SH_PLT_MEDHI16
:
5120 /* This symbol requires a procedure linkage table entry. We
5121 actually build the entry in adjust_dynamic_symbol,
5122 because this might be a case of linking PIC code which is
5123 never referenced by a dynamic object, in which case we
5124 don't need to generate a procedure linkage table entry
5127 /* If this is a local symbol, we resolve it directly without
5128 creating a procedure linkage table entry. */
5132 if (h
->forced_local
)
5136 h
->plt
.refcount
+= 1;
5141 #ifdef INCLUDE_SHMEDIA
5142 case R_SH_IMM_LOW16_PCREL
:
5143 case R_SH_IMM_MEDLOW16_PCREL
:
5144 case R_SH_IMM_MEDHI16_PCREL
:
5145 case R_SH_IMM_HI16_PCREL
:
5147 if (h
!= NULL
&& ! info
->shared
)
5150 h
->plt
.refcount
+= 1;
5153 /* If we are creating a shared library, and this is a reloc
5154 against a global symbol, or a non PC relative reloc
5155 against a local symbol, then we need to copy the reloc
5156 into the shared library. However, if we are linking with
5157 -Bsymbolic, we do not need to copy a reloc against a
5158 global symbol which is defined in an object we are
5159 including in the link (i.e., DEF_REGULAR is set). At
5160 this point we have not seen all the input files, so it is
5161 possible that DEF_REGULAR is not set now but will be set
5162 later (it is never cleared). We account for that
5163 possibility below by storing information in the
5164 dyn_relocs field of the hash table entry. A similar
5165 situation occurs when creating shared libraries and symbol
5166 visibility changes render the symbol local.
5168 If on the other hand, we are creating an executable, we
5169 may need to keep relocations for symbols satisfied by a
5170 dynamic library if we manage to avoid copy relocs for the
5173 && (sec
->flags
& SEC_ALLOC
) != 0
5174 && (r_type
!= R_SH_REL32
5176 && (! info
->symbolic
5177 || h
->root
.type
== bfd_link_hash_defweak
5178 || !h
->def_regular
))))
5180 && (sec
->flags
& SEC_ALLOC
) != 0
5182 && (h
->root
.type
== bfd_link_hash_defweak
5183 || !h
->def_regular
)))
5185 struct elf_sh_dyn_relocs
*p
;
5186 struct elf_sh_dyn_relocs
**head
;
5188 if (htab
->root
.dynobj
== NULL
)
5189 htab
->root
.dynobj
= abfd
;
5191 /* When creating a shared object, we must copy these
5192 reloc types into the output file. We create a reloc
5193 section in dynobj and make room for this reloc. */
5198 name
= (bfd_elf_string_from_elf_section
5200 elf_elfheader (abfd
)->e_shstrndx
,
5201 elf_section_data (sec
)->rel_hdr
.sh_name
));
5205 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
5206 && strcmp (bfd_get_section_name (abfd
, sec
),
5209 sreloc
= bfd_get_section_by_name (htab
->root
.dynobj
, name
);
5214 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
5215 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
5216 if ((sec
->flags
& SEC_ALLOC
) != 0)
5217 flags
|= SEC_ALLOC
| SEC_LOAD
;
5218 sreloc
= bfd_make_section_with_flags (htab
->root
.dynobj
,
5222 || ! bfd_set_section_alignment (htab
->root
.dynobj
,
5226 elf_section_data (sec
)->sreloc
= sreloc
;
5229 /* If this is a global symbol, we count the number of
5230 relocations we need for this symbol. */
5232 head
= &((struct elf_sh_link_hash_entry
*) h
)->dyn_relocs
;
5238 /* Track dynamic relocs needed for local syms too. */
5239 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
5244 vpp
= &elf_section_data (s
)->local_dynrel
;
5245 head
= (struct elf_sh_dyn_relocs
**) vpp
;
5249 if (p
== NULL
|| p
->sec
!= sec
)
5251 bfd_size_type amt
= sizeof (*p
);
5252 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
5263 if (r_type
== R_SH_REL32
5264 #ifdef INCLUDE_SHMEDIA
5265 || r_type
== R_SH_IMM_LOW16_PCREL
5266 || r_type
== R_SH_IMM_MEDLOW16_PCREL
5267 || r_type
== R_SH_IMM_MEDHI16_PCREL
5268 || r_type
== R_SH_IMM_HI16_PCREL
5276 case R_SH_TLS_LE_32
:
5279 (*_bfd_error_handler
)
5280 (_("%B: TLS local exec code cannot be linked into shared objects"),
5287 case R_SH_TLS_LDO_32
:
5288 /* Nothing to do. */
5299 #ifndef sh_elf_set_mach_from_flags
5300 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
5303 sh_elf_set_mach_from_flags (bfd
*abfd
)
5305 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
5307 if (flags
>= sizeof(sh_ef_bfd_table
))
5310 if (sh_ef_bfd_table
[flags
] == 0)
5313 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
5319 /* Reverse table lookup for sh_ef_bfd_table[].
5320 Given a bfd MACH value from archures.c
5321 return the equivalent ELF flags from the table.
5322 Return -1 if no match is found. */
5325 sh_elf_get_flags_from_mach (unsigned long mach
)
5327 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
5330 if (sh_ef_bfd_table
[i
] == mach
)
5333 /* shouldn't get here */
5338 #endif /* not sh_elf_set_mach_from_flags */
5340 #ifndef sh_elf_set_private_flags
5341 /* Function to keep SH specific file flags. */
5344 sh_elf_set_private_flags (bfd
*abfd
, flagword flags
)
5346 BFD_ASSERT (! elf_flags_init (abfd
)
5347 || elf_elfheader (abfd
)->e_flags
== flags
);
5349 elf_elfheader (abfd
)->e_flags
= flags
;
5350 elf_flags_init (abfd
) = TRUE
;
5351 return sh_elf_set_mach_from_flags (abfd
);
5353 #endif /* not sh_elf_set_private_flags */
5355 #ifndef sh_elf_copy_private_data
5356 /* Copy backend specific data from one object module to another */
5359 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
5361 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5362 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5365 /* Copy object attributes. */
5366 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
5368 return sh_elf_set_private_flags (obfd
, elf_elfheader (ibfd
)->e_flags
);
5370 #endif /* not sh_elf_copy_private_data */
5372 #ifndef sh_elf_merge_private_data
5374 /* This function returns the ELF architecture number that
5375 corresponds to the given arch_sh* flags. */
5378 sh_find_elf_flags (unsigned int arch_set
)
5380 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5381 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
5383 return sh_elf_get_flags_from_mach (bfd_mach
);
5386 /* This routine initialises the elf flags when required and
5387 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
5390 sh_elf_merge_private_data (bfd
*ibfd
, bfd
*obfd
)
5392 extern bfd_boolean
sh_merge_bfd_arch (bfd
*, bfd
*);
5394 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5395 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5398 if (! elf_flags_init (obfd
))
5400 /* This happens when ld starts out with a 'blank' output file. */
5401 elf_flags_init (obfd
) = TRUE
;
5402 elf_elfheader (obfd
)->e_flags
= EF_SH1
;
5403 sh_elf_set_mach_from_flags (obfd
);
5406 if (! sh_merge_bfd_arch (ibfd
, obfd
))
5408 _bfd_error_handler ("%B: uses instructions which are incompatible "
5409 "with instructions used in previous modules",
5411 bfd_set_error (bfd_error_bad_value
);
5415 elf_elfheader (obfd
)->e_flags
=
5416 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
5420 #endif /* not sh_elf_merge_private_data */
5422 /* Override the generic function because we need to store sh_elf_obj_tdata
5423 as the specific tdata. We set also the machine architecture from flags
5427 sh_elf_object_p (bfd
*abfd
)
5429 return sh_elf_set_mach_from_flags (abfd
);
5432 /* Finish up dynamic symbol handling. We set the contents of various
5433 dynamic sections here. */
5436 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
5437 struct elf_link_hash_entry
*h
,
5438 Elf_Internal_Sym
*sym
)
5440 struct elf_sh_link_hash_table
*htab
;
5442 htab
= sh_elf_hash_table (info
);
5444 if (h
->plt
.offset
!= (bfd_vma
) -1)
5452 Elf_Internal_Rela rel
;
5455 /* This symbol has an entry in the procedure linkage table. Set
5458 BFD_ASSERT (h
->dynindx
!= -1);
5461 sgot
= htab
->sgotplt
;
5462 srel
= htab
->srelplt
;
5463 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
5465 /* Get the index in the procedure linkage table which
5466 corresponds to this symbol. This is the index of this symbol
5467 in all the symbols for which we are making plt entries. The
5468 first entry in the procedure linkage table is reserved. */
5469 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
5471 /* Get the offset into the .got table of the entry that
5472 corresponds to this function. Each .got entry is 4 bytes.
5473 The first three are reserved. */
5474 got_offset
= (plt_index
+ 3) * 4;
5478 got_offset
-= GOT_BIAS
;
5481 /* Fill in the entry in the procedure linkage table. */
5482 memcpy (splt
->contents
+ h
->plt
.offset
,
5483 htab
->plt_info
->symbol_entry
,
5484 htab
->plt_info
->symbol_entry_size
);
5487 install_plt_field (output_bfd
, FALSE
, got_offset
,
5490 + htab
->plt_info
->symbol_fields
.got_entry
));
5493 install_plt_field (output_bfd
, FALSE
,
5494 (sgot
->output_section
->vma
5495 + sgot
->output_offset
5499 + htab
->plt_info
->symbol_fields
.got_entry
));
5500 if (htab
->vxworks_p
)
5502 unsigned int reachable_plts
, plts_per_4k
;
5505 /* Divide the PLT into groups. The first group contains
5506 REACHABLE_PLTS entries and the other groups contain
5507 PLTS_PER_4K entries. Entries in the first group can
5508 branch directly to .plt; those in later groups branch
5509 to the last element of the previous group. */
5510 /* ??? It would be better to create multiple copies of
5511 the common resolver stub. */
5512 reachable_plts
= ((4096
5513 - htab
->plt_info
->plt0_entry_size
5514 - (htab
->plt_info
->symbol_fields
.plt
+ 4))
5515 / htab
->plt_info
->symbol_entry_size
) + 1;
5516 plts_per_4k
= (4096 / htab
->plt_info
->symbol_entry_size
);
5517 if (plt_index
< reachable_plts
)
5518 distance
= -(h
->plt
.offset
5519 + htab
->plt_info
->symbol_fields
.plt
);
5521 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
5522 * htab
->plt_info
->symbol_entry_size
);
5524 /* Install the 'bra' with this offset. */
5525 bfd_put_16 (output_bfd
,
5526 0xa000 | (0x0fff & ((distance
- 4) / 2)),
5529 + htab
->plt_info
->symbol_fields
.plt
));
5532 install_plt_field (output_bfd
, TRUE
,
5533 splt
->output_section
->vma
+ splt
->output_offset
,
5536 + htab
->plt_info
->symbol_fields
.plt
));
5541 got_offset
+= GOT_BIAS
;
5544 install_plt_field (output_bfd
, FALSE
,
5545 plt_index
* sizeof (Elf32_External_Rela
),
5548 + htab
->plt_info
->symbol_fields
.reloc_offset
));
5550 /* Fill in the entry in the global offset table. */
5551 bfd_put_32 (output_bfd
,
5552 (splt
->output_section
->vma
5553 + splt
->output_offset
5555 + htab
->plt_info
->symbol_resolve_offset
),
5556 sgot
->contents
+ got_offset
);
5558 /* Fill in the entry in the .rela.plt section. */
5559 rel
.r_offset
= (sgot
->output_section
->vma
5560 + sgot
->output_offset
5562 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
5565 rel
.r_addend
= GOT_BIAS
;
5567 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
5568 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5570 if (htab
->vxworks_p
&& !info
->shared
)
5572 /* Create the .rela.plt.unloaded relocations for this PLT entry.
5573 Begin by pointing LOC to the first such relocation. */
5574 loc
= (htab
->srelplt2
->contents
5575 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
5577 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
5578 for the PLT entry's pointer to the .got.plt entry. */
5579 rel
.r_offset
= (htab
->splt
->output_section
->vma
5580 + htab
->splt
->output_offset
5582 + htab
->plt_info
->symbol_fields
.got_entry
);
5583 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
5584 rel
.r_addend
= got_offset
;
5585 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5586 loc
+= sizeof (Elf32_External_Rela
);
5588 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
5589 the .got.plt entry, which initially points to .plt. */
5590 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
5591 + htab
->sgotplt
->output_offset
5593 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
5595 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5598 if (!h
->def_regular
)
5600 /* Mark the symbol as undefined, rather than as defined in
5601 the .plt section. Leave the value alone. */
5602 sym
->st_shndx
= SHN_UNDEF
;
5606 if (h
->got
.offset
!= (bfd_vma
) -1
5607 && sh_elf_hash_entry (h
)->tls_type
!= GOT_TLS_GD
5608 && sh_elf_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
5612 Elf_Internal_Rela rel
;
5615 /* This symbol has an entry in the global offset table. Set it
5619 srel
= htab
->srelgot
;
5620 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
5622 rel
.r_offset
= (sgot
->output_section
->vma
5623 + sgot
->output_offset
5624 + (h
->got
.offset
&~ (bfd_vma
) 1));
5626 /* If this is a static link, or it is a -Bsymbolic link and the
5627 symbol is defined locally or was forced to be local because
5628 of a version file, we just want to emit a RELATIVE reloc.
5629 The entry in the global offset table will already have been
5630 initialized in the relocate_section function. */
5632 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5634 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
5635 rel
.r_addend
= (h
->root
.u
.def
.value
5636 + h
->root
.u
.def
.section
->output_section
->vma
5637 + h
->root
.u
.def
.section
->output_offset
);
5641 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
5642 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
5646 loc
= srel
->contents
;
5647 loc
+= srel
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5648 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5651 #ifdef INCLUDE_SHMEDIA
5653 struct elf_sh_link_hash_entry
*eh
;
5655 eh
= (struct elf_sh_link_hash_entry
*) h
;
5656 if (eh
->datalabel_got
.offset
!= (bfd_vma
) -1)
5660 Elf_Internal_Rela rel
;
5663 /* This symbol has a datalabel entry in the global offset table.
5667 srel
= htab
->srelgot
;
5668 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
5670 rel
.r_offset
= (sgot
->output_section
->vma
5671 + sgot
->output_offset
5672 + (eh
->datalabel_got
.offset
&~ (bfd_vma
) 1));
5674 /* If this is a static link, or it is a -Bsymbolic link and the
5675 symbol is defined locally or was forced to be local because
5676 of a version file, we just want to emit a RELATIVE reloc.
5677 The entry in the global offset table will already have been
5678 initialized in the relocate_section function. */
5680 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5682 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
5683 rel
.r_addend
= (h
->root
.u
.def
.value
5684 + h
->root
.u
.def
.section
->output_section
->vma
5685 + h
->root
.u
.def
.section
->output_offset
);
5689 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
5690 + eh
->datalabel_got
.offset
);
5691 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
5695 loc
= srel
->contents
;
5696 loc
+= srel
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5697 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5705 Elf_Internal_Rela rel
;
5708 /* This symbol needs a copy reloc. Set it up. */
5710 BFD_ASSERT (h
->dynindx
!= -1
5711 && (h
->root
.type
== bfd_link_hash_defined
5712 || h
->root
.type
== bfd_link_hash_defweak
));
5714 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
5716 BFD_ASSERT (s
!= NULL
);
5718 rel
.r_offset
= (h
->root
.u
.def
.value
5719 + h
->root
.u
.def
.section
->output_section
->vma
5720 + h
->root
.u
.def
.section
->output_offset
);
5721 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
5723 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5724 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5727 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
5728 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
5730 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5731 || (!htab
->vxworks_p
&& h
== htab
->root
.hgot
))
5732 sym
->st_shndx
= SHN_ABS
;
5737 /* Finish up the dynamic sections. */
5740 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
5742 struct elf_sh_link_hash_table
*htab
;
5746 htab
= sh_elf_hash_table (info
);
5747 sgot
= htab
->sgotplt
;
5748 sdyn
= bfd_get_section_by_name (htab
->root
.dynobj
, ".dynamic");
5750 if (htab
->root
.dynamic_sections_created
)
5753 Elf32_External_Dyn
*dyncon
, *dynconend
;
5755 BFD_ASSERT (sgot
!= NULL
&& sdyn
!= NULL
);
5757 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5758 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5759 for (; dyncon
< dynconend
; dyncon
++)
5761 Elf_Internal_Dyn dyn
;
5763 #ifdef INCLUDE_SHMEDIA
5767 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
5773 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5774 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5777 #ifdef INCLUDE_SHMEDIA
5779 name
= info
->init_function
;
5783 name
= info
->fini_function
;
5785 if (dyn
.d_un
.d_val
!= 0)
5787 struct elf_link_hash_entry
*h
;
5789 h
= elf_link_hash_lookup (&htab
->root
, name
,
5790 FALSE
, FALSE
, TRUE
);
5791 if (h
!= NULL
&& (h
->other
& STO_SH5_ISA32
))
5793 dyn
.d_un
.d_val
|= 1;
5794 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5801 s
= htab
->sgot
->output_section
;
5805 s
= htab
->srelplt
->output_section
;
5807 BFD_ASSERT (s
!= NULL
);
5808 dyn
.d_un
.d_ptr
= s
->vma
;
5809 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5813 s
= htab
->srelplt
->output_section
;
5814 BFD_ASSERT (s
!= NULL
);
5815 dyn
.d_un
.d_val
= s
->size
;
5816 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5820 /* My reading of the SVR4 ABI indicates that the
5821 procedure linkage table relocs (DT_JMPREL) should be
5822 included in the overall relocs (DT_RELA). This is
5823 what Solaris does. However, UnixWare can not handle
5824 that case. Therefore, we override the DT_RELASZ entry
5825 here to make it not include the JMPREL relocs. Since
5826 the linker script arranges for .rela.plt to follow all
5827 other relocation sections, we don't have to worry
5828 about changing the DT_RELA entry. */
5829 if (htab
->srelplt
!= NULL
)
5831 s
= htab
->srelplt
->output_section
;
5832 dyn
.d_un
.d_val
-= s
->size
;
5834 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5839 /* Fill in the first entry in the procedure linkage table. */
5841 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
5845 memcpy (splt
->contents
,
5846 htab
->plt_info
->plt0_entry
,
5847 htab
->plt_info
->plt0_entry_size
);
5848 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
5849 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
5850 install_plt_field (output_bfd
, FALSE
,
5851 (sgot
->output_section
->vma
5852 + sgot
->output_offset
5855 + htab
->plt_info
->plt0_got_fields
[i
]));
5857 if (htab
->vxworks_p
)
5859 /* Finalize the .rela.plt.unloaded contents. */
5860 Elf_Internal_Rela rel
;
5863 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
5864 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
5865 loc
= htab
->srelplt2
->contents
;
5866 rel
.r_offset
= (splt
->output_section
->vma
5867 + splt
->output_offset
5868 + htab
->plt_info
->plt0_got_fields
[2]);
5869 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
5871 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
5872 loc
+= sizeof (Elf32_External_Rela
);
5874 /* Fix up the remaining .rela.plt.unloaded relocations.
5875 They may have the wrong symbol index for _G_O_T_ or
5876 _P_L_T_ depending on the order in which symbols were
5878 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
5880 /* The PLT entry's pointer to the .got.plt slot. */
5881 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
5882 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
5884 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5885 loc
+= sizeof (Elf32_External_Rela
);
5887 /* The .got.plt slot's pointer to .plt. */
5888 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
5889 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
5891 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5892 loc
+= sizeof (Elf32_External_Rela
);
5896 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5897 really seem like the right value. */
5898 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
5902 /* Fill in the first three entries in the global offset table. */
5903 if (sgot
&& sgot
->size
> 0)
5906 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
5908 bfd_put_32 (output_bfd
,
5909 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5911 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
5912 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
5914 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5920 static enum elf_reloc_type_class
5921 sh_elf_reloc_type_class (const Elf_Internal_Rela
*rela
)
5923 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5926 return reloc_class_relative
;
5928 return reloc_class_plt
;
5930 return reloc_class_copy
;
5932 return reloc_class_normal
;
5936 #if !defined SH_TARGET_ALREADY_DEFINED
5937 /* Support for Linux core dump NOTE sections. */
5940 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
5945 switch (note
->descsz
)
5950 case 168: /* Linux/SH */
5952 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
5955 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
5964 /* Make a ".reg/999" section. */
5965 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
5966 size
, note
->descpos
+ offset
);
5970 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
5972 switch (note
->descsz
)
5977 case 124: /* Linux/SH elf_prpsinfo */
5978 elf_tdata (abfd
)->core_program
5979 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
5980 elf_tdata (abfd
)->core_command
5981 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
5984 /* Note that for some reason, a spurious space is tacked
5985 onto the end of the args in some (at least one anyway)
5986 implementations, so strip it off if it exists. */
5989 char *command
= elf_tdata (abfd
)->core_command
;
5990 int n
= strlen (command
);
5992 if (0 < n
&& command
[n
- 1] == ' ')
5993 command
[n
- 1] = '\0';
5998 #endif /* not SH_TARGET_ALREADY_DEFINED */
6001 /* Return address for Ith PLT stub in section PLT, for relocation REL
6002 or (bfd_vma) -1 if it should not be included. */
6005 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
6006 const arelent
*rel ATTRIBUTE_UNUSED
)
6008 const struct elf_sh_plt_info
*plt_info
;
6010 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
6011 return plt
->vma
+ get_plt_offset (plt_info
, i
);
6014 #if !defined SH_TARGET_ALREADY_DEFINED
6015 #define TARGET_BIG_SYM bfd_elf32_sh_vec
6016 #define TARGET_BIG_NAME "elf32-sh"
6017 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
6018 #define TARGET_LITTLE_NAME "elf32-shl"
6021 #define ELF_ARCH bfd_arch_sh
6022 #define ELF_MACHINE_CODE EM_SH
6023 #ifdef __QNXTARGET__
6024 #define ELF_MAXPAGESIZE 0x1000
6026 #define ELF_MAXPAGESIZE 0x80
6029 #define elf_symbol_leading_char '_'
6031 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6032 #define bfd_elf32_bfd_reloc_name_lookup \
6033 sh_elf_reloc_name_lookup
6034 #define elf_info_to_howto sh_elf_info_to_howto
6035 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
6036 #define elf_backend_relocate_section sh_elf_relocate_section
6037 #define bfd_elf32_bfd_get_relocated_section_contents \
6038 sh_elf_get_relocated_section_contents
6039 #define bfd_elf32_mkobject sh_elf_mkobject
6040 #define elf_backend_object_p sh_elf_object_p
6041 #define bfd_elf32_bfd_set_private_bfd_flags \
6042 sh_elf_set_private_flags
6043 #define bfd_elf32_bfd_copy_private_bfd_data \
6044 sh_elf_copy_private_data
6045 #define bfd_elf32_bfd_merge_private_bfd_data \
6046 sh_elf_merge_private_data
6048 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
6049 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
6050 #define elf_backend_check_relocs sh_elf_check_relocs
6051 #define elf_backend_copy_indirect_symbol \
6052 sh_elf_copy_indirect_symbol
6053 #define elf_backend_create_dynamic_sections \
6054 sh_elf_create_dynamic_sections
6055 #define bfd_elf32_bfd_link_hash_table_create \
6056 sh_elf_link_hash_table_create
6057 #define elf_backend_adjust_dynamic_symbol \
6058 sh_elf_adjust_dynamic_symbol
6059 #define elf_backend_always_size_sections \
6060 sh_elf_always_size_sections
6061 #define elf_backend_size_dynamic_sections \
6062 sh_elf_size_dynamic_sections
6063 #define elf_backend_omit_section_dynsym \
6064 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6065 #define elf_backend_finish_dynamic_symbol \
6066 sh_elf_finish_dynamic_symbol
6067 #define elf_backend_finish_dynamic_sections \
6068 sh_elf_finish_dynamic_sections
6069 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
6070 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
6072 #define elf_backend_can_gc_sections 1
6073 #define elf_backend_can_refcount 1
6074 #define elf_backend_want_got_plt 1
6075 #define elf_backend_plt_readonly 1
6076 #define elf_backend_want_plt_sym 0
6077 #define elf_backend_got_header_size 12
6079 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
6081 #include "elf32-target.h"
6083 /* NetBSD support. */
6084 #undef TARGET_BIG_SYM
6085 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
6086 #undef TARGET_BIG_NAME
6087 #define TARGET_BIG_NAME "elf32-sh-nbsd"
6088 #undef TARGET_LITTLE_SYM
6089 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
6090 #undef TARGET_LITTLE_NAME
6091 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
6092 #undef ELF_MAXPAGESIZE
6093 #define ELF_MAXPAGESIZE 0x10000
6094 #undef ELF_COMMONPAGESIZE
6095 #undef elf_symbol_leading_char
6096 #define elf_symbol_leading_char 0
6098 #define elf32_bed elf32_sh_nbsd_bed
6100 #include "elf32-target.h"
6103 /* Linux support. */
6104 #undef TARGET_BIG_SYM
6105 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
6106 #undef TARGET_BIG_NAME
6107 #define TARGET_BIG_NAME "elf32-shbig-linux"
6108 #undef TARGET_LITTLE_SYM
6109 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
6110 #undef TARGET_LITTLE_NAME
6111 #define TARGET_LITTLE_NAME "elf32-sh-linux"
6112 #undef ELF_COMMONPAGESIZE
6113 #define ELF_COMMONPAGESIZE 0x1000
6115 #undef elf_backend_grok_prstatus
6116 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
6117 #undef elf_backend_grok_psinfo
6118 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
6120 #define elf32_bed elf32_sh_lin_bed
6122 #include "elf32-target.h"
6124 #undef TARGET_BIG_SYM
6125 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
6126 #undef TARGET_BIG_NAME
6127 #define TARGET_BIG_NAME "elf32-sh-vxworks"
6128 #undef TARGET_LITTLE_SYM
6129 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
6130 #undef TARGET_LITTLE_NAME
6131 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
6133 #define elf32_bed elf32_sh_vxworks_bed
6135 #undef elf_backend_want_plt_sym
6136 #define elf_backend_want_plt_sym 1
6137 #undef elf_symbol_leading_char
6138 #define elf_symbol_leading_char '_'
6139 #define elf_backend_want_got_underscore 1
6140 #undef elf_backend_grok_prstatus
6141 #undef elf_backend_grok_psinfo
6142 #undef elf_backend_add_symbol_hook
6143 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
6144 #undef elf_backend_link_output_symbol_hook
6145 #define elf_backend_link_output_symbol_hook \
6146 elf_vxworks_link_output_symbol_hook
6147 #undef elf_backend_emit_relocs
6148 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6149 #undef elf_backend_final_write_processing
6150 #define elf_backend_final_write_processing \
6151 elf_vxworks_final_write_processing
6152 #undef ELF_MAXPAGESIZE
6153 #define ELF_MAXPAGESIZE 0x1000
6154 #undef ELF_COMMONPAGESIZE
6156 #include "elf32-target.h"
6158 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */