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, 2008, 2009, 2010 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"
31 #include "libiberty.h"
32 #include "../opcodes/sh-opc.h"
34 static bfd_reloc_status_type sh_elf_reloc
35 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
36 static bfd_reloc_status_type sh_elf_ignore_reloc
37 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
38 static bfd_boolean sh_elf_relax_delete_bytes
39 (bfd
*, asection
*, bfd_vma
, int);
40 static bfd_boolean sh_elf_align_loads
41 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_boolean
*);
43 static bfd_boolean sh_elf_swap_insns
44 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
46 static int sh_elf_optimized_tls_reloc
47 (struct bfd_link_info
*, int, int);
48 static bfd_vma dtpoff_base
49 (struct bfd_link_info
*);
51 (struct bfd_link_info
*, bfd_vma
);
53 /* The name of the dynamic interpreter. This is put in the .interp
56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
58 /* FDPIC binaries have a default 128K stack. */
59 #define DEFAULT_STACK_SIZE 0x20000
61 #define MINUS_ONE ((bfd_vma) 0 - 1)
63 /* Decide whether a reference to a symbol can be resolved locally or
64 not. If the symbol is protected, we want the local address, but
65 its function descriptor must be assigned by the dynamic linker. */
66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
68 || ! elf_hash_table (INFO)->dynamic_sections_created)
70 #define SH_PARTIAL32 TRUE
71 #define SH_SRC_MASK32 0xffffffff
72 #define SH_ELF_RELOC sh_elf_reloc
73 static reloc_howto_type sh_elf_howto_table
[] =
75 #include "elf32-sh-relocs.h"
78 #define SH_PARTIAL32 FALSE
79 #define SH_SRC_MASK32 0
80 #define SH_ELF_RELOC bfd_elf_generic_reloc
81 static reloc_howto_type sh_vxworks_howto_table
[] =
83 #include "elf32-sh-relocs.h"
86 /* Return true if OUTPUT_BFD is a VxWorks object. */
89 vxworks_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
91 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
92 extern const bfd_target bfd_elf32_shlvxworks_vec
;
93 extern const bfd_target bfd_elf32_shvxworks_vec
;
95 return (abfd
->xvec
== &bfd_elf32_shlvxworks_vec
96 || abfd
->xvec
== &bfd_elf32_shvxworks_vec
);
102 /* Return true if OUTPUT_BFD is an FDPIC object. */
105 fdpic_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
107 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
108 extern const bfd_target bfd_elf32_shfd_vec
;
109 extern const bfd_target bfd_elf32_shbfd_vec
;
111 return (abfd
->xvec
== &bfd_elf32_shfd_vec
112 || abfd
->xvec
== &bfd_elf32_shbfd_vec
);
118 /* Return the howto table for ABFD. */
120 static reloc_howto_type
*
121 get_howto_table (bfd
*abfd
)
123 if (vxworks_object_p (abfd
))
124 return sh_vxworks_howto_table
;
125 return sh_elf_howto_table
;
128 static bfd_reloc_status_type
129 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
130 asection
*input_section
, bfd_byte
*contents
,
131 bfd_vma addr
, asection
*symbol_section
,
132 bfd_vma start
, bfd_vma end
)
134 static bfd_vma last_addr
;
135 static asection
*last_symbol_section
;
136 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
141 /* Sanity check the address. */
142 if (addr
> bfd_get_section_limit (input_bfd
, input_section
))
143 return bfd_reloc_outofrange
;
145 /* We require the start and end relocations to be processed consecutively -
146 although we allow then to be processed forwards or backwards. */
150 last_symbol_section
= symbol_section
;
153 if (last_addr
!= addr
)
157 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
158 return bfd_reloc_outofrange
;
160 /* Get the symbol_section contents. */
161 if (symbol_section
!= input_section
)
163 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
164 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
167 if (!bfd_malloc_and_get_section (input_bfd
, symbol_section
,
170 if (contents
!= NULL
)
172 return bfd_reloc_outofrange
;
176 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
177 start_ptr
= contents
+ start
;
178 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
180 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
183 diff
= (last_ptr
- ptr
) >> 1;
184 cum_diff
+= diff
& 1;
187 /* Calculate the start / end values to load into rs / re minus four -
188 so that will cancel out the four we would otherwise have to add to
189 addr to get the value to subtract in order to get relative addressing. */
193 end
= (ptr
+ cum_diff
* 2) - contents
;
197 bfd_vma start0
= start
- 4;
199 while (start0
&& IS_PPI (contents
+ start0
))
201 start0
= start
- 2 - ((start
- start0
) & 2);
202 start
= start0
- cum_diff
- 2;
207 && elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
210 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
212 x
= (insn
& 0x200 ? end
: start
) - addr
;
213 if (input_section
!= symbol_section
)
214 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
215 - (input_section
->output_section
->vma
216 + input_section
->output_offset
));
218 if (x
< -128 || x
> 127)
219 return bfd_reloc_overflow
;
221 x
= (insn
& ~0xff) | (x
& 0xff);
222 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
227 /* This function is used for normal relocs. This used to be like the COFF
228 function, and is almost certainly incorrect for other ELF targets. */
230 static bfd_reloc_status_type
231 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
232 void *data
, asection
*input_section
, bfd
*output_bfd
,
233 char **error_message ATTRIBUTE_UNUSED
)
237 enum elf_sh_reloc_type r_type
;
238 bfd_vma addr
= reloc_entry
->address
;
239 bfd_byte
*hit_data
= addr
+ (bfd_byte
*) data
;
241 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
243 if (output_bfd
!= NULL
)
245 /* Partial linking--do nothing. */
246 reloc_entry
->address
+= input_section
->output_offset
;
250 /* Almost all relocs have to do with relaxing. If any work must be
251 done for them, it has been done in sh_relax_section. */
252 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
255 if (symbol_in
!= NULL
256 && bfd_is_und_section (symbol_in
->section
))
257 return bfd_reloc_undefined
;
259 if (bfd_is_com_section (symbol_in
->section
))
262 sym_value
= (symbol_in
->value
+
263 symbol_in
->section
->output_section
->vma
+
264 symbol_in
->section
->output_offset
);
269 insn
= bfd_get_32 (abfd
, hit_data
);
270 insn
+= sym_value
+ reloc_entry
->addend
;
271 bfd_put_32 (abfd
, (bfd_vma
) insn
, hit_data
);
274 insn
= bfd_get_16 (abfd
, hit_data
);
275 sym_value
+= reloc_entry
->addend
;
276 sym_value
-= (input_section
->output_section
->vma
277 + input_section
->output_offset
280 sym_value
+= (insn
& 0xfff) << 1;
283 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
284 bfd_put_16 (abfd
, (bfd_vma
) insn
, hit_data
);
285 if (sym_value
< (bfd_vma
) -0x1000 || sym_value
>= 0x1000)
286 return bfd_reloc_overflow
;
296 /* This function is used for relocs which are only used for relaxing,
297 which the linker should otherwise ignore. */
299 static bfd_reloc_status_type
300 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
301 asymbol
*symbol ATTRIBUTE_UNUSED
,
302 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
304 char **error_message ATTRIBUTE_UNUSED
)
306 if (output_bfd
!= NULL
)
307 reloc_entry
->address
+= input_section
->output_offset
;
311 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
315 bfd_reloc_code_real_type bfd_reloc_val
;
316 unsigned char elf_reloc_val
;
319 /* An array mapping BFD reloc codes to SH ELF relocs. */
321 static const struct elf_reloc_map sh_reloc_map
[] =
323 { BFD_RELOC_NONE
, R_SH_NONE
},
324 { BFD_RELOC_32
, R_SH_DIR32
},
325 { BFD_RELOC_16
, R_SH_DIR16
},
326 { BFD_RELOC_8
, R_SH_DIR8
},
327 { BFD_RELOC_CTOR
, R_SH_DIR32
},
328 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
329 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
330 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
331 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
332 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
333 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
334 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
335 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
336 { BFD_RELOC_SH_USES
, R_SH_USES
},
337 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
338 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
339 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
340 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
341 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
342 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
343 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
344 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
345 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
346 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
347 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
348 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
349 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
350 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
351 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
352 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
353 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
354 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
355 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
356 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
357 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
358 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
359 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
360 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
361 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
362 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
363 { BFD_RELOC_SH_GOT20
, R_SH_GOT20
},
364 { BFD_RELOC_SH_GOTOFF20
, R_SH_GOTOFF20
},
365 { BFD_RELOC_SH_GOTFUNCDESC
, R_SH_GOTFUNCDESC
},
366 { BFD_RELOC_SH_GOTFUNCDESC20
, R_SH_GOTFUNCDESC20
},
367 { BFD_RELOC_SH_GOTOFFFUNCDESC
, R_SH_GOTOFFFUNCDESC
},
368 { BFD_RELOC_SH_GOTOFFFUNCDESC20
, R_SH_GOTOFFFUNCDESC20
},
369 { BFD_RELOC_SH_FUNCDESC
, R_SH_FUNCDESC
},
370 #ifdef INCLUDE_SHMEDIA
371 { BFD_RELOC_SH_GOT_LOW16
, R_SH_GOT_LOW16
},
372 { BFD_RELOC_SH_GOT_MEDLOW16
, R_SH_GOT_MEDLOW16
},
373 { BFD_RELOC_SH_GOT_MEDHI16
, R_SH_GOT_MEDHI16
},
374 { BFD_RELOC_SH_GOT_HI16
, R_SH_GOT_HI16
},
375 { BFD_RELOC_SH_GOTPLT_LOW16
, R_SH_GOTPLT_LOW16
},
376 { BFD_RELOC_SH_GOTPLT_MEDLOW16
, R_SH_GOTPLT_MEDLOW16
},
377 { BFD_RELOC_SH_GOTPLT_MEDHI16
, R_SH_GOTPLT_MEDHI16
},
378 { BFD_RELOC_SH_GOTPLT_HI16
, R_SH_GOTPLT_HI16
},
379 { BFD_RELOC_SH_PLT_LOW16
, R_SH_PLT_LOW16
},
380 { BFD_RELOC_SH_PLT_MEDLOW16
, R_SH_PLT_MEDLOW16
},
381 { BFD_RELOC_SH_PLT_MEDHI16
, R_SH_PLT_MEDHI16
},
382 { BFD_RELOC_SH_PLT_HI16
, R_SH_PLT_HI16
},
383 { BFD_RELOC_SH_GOTOFF_LOW16
, R_SH_GOTOFF_LOW16
},
384 { BFD_RELOC_SH_GOTOFF_MEDLOW16
, R_SH_GOTOFF_MEDLOW16
},
385 { BFD_RELOC_SH_GOTOFF_MEDHI16
, R_SH_GOTOFF_MEDHI16
},
386 { BFD_RELOC_SH_GOTOFF_HI16
, R_SH_GOTOFF_HI16
},
387 { BFD_RELOC_SH_GOTPC_LOW16
, R_SH_GOTPC_LOW16
},
388 { BFD_RELOC_SH_GOTPC_MEDLOW16
, R_SH_GOTPC_MEDLOW16
},
389 { BFD_RELOC_SH_GOTPC_MEDHI16
, R_SH_GOTPC_MEDHI16
},
390 { BFD_RELOC_SH_GOTPC_HI16
, R_SH_GOTPC_HI16
},
391 { BFD_RELOC_SH_COPY64
, R_SH_COPY64
},
392 { BFD_RELOC_SH_GLOB_DAT64
, R_SH_GLOB_DAT64
},
393 { BFD_RELOC_SH_JMP_SLOT64
, R_SH_JMP_SLOT64
},
394 { BFD_RELOC_SH_RELATIVE64
, R_SH_RELATIVE64
},
395 { BFD_RELOC_SH_GOT10BY4
, R_SH_GOT10BY4
},
396 { BFD_RELOC_SH_GOT10BY8
, R_SH_GOT10BY8
},
397 { BFD_RELOC_SH_GOTPLT10BY4
, R_SH_GOTPLT10BY4
},
398 { BFD_RELOC_SH_GOTPLT10BY8
, R_SH_GOTPLT10BY8
},
399 { BFD_RELOC_SH_PT_16
, R_SH_PT_16
},
400 { BFD_RELOC_SH_SHMEDIA_CODE
, R_SH_SHMEDIA_CODE
},
401 { BFD_RELOC_SH_IMMU5
, R_SH_DIR5U
},
402 { BFD_RELOC_SH_IMMS6
, R_SH_DIR6S
},
403 { BFD_RELOC_SH_IMMU6
, R_SH_DIR6U
},
404 { BFD_RELOC_SH_IMMS10
, R_SH_DIR10S
},
405 { BFD_RELOC_SH_IMMS10BY2
, R_SH_DIR10SW
},
406 { BFD_RELOC_SH_IMMS10BY4
, R_SH_DIR10SL
},
407 { BFD_RELOC_SH_IMMS10BY8
, R_SH_DIR10SQ
},
408 { BFD_RELOC_SH_IMMS16
, R_SH_IMMS16
},
409 { BFD_RELOC_SH_IMMU16
, R_SH_IMMU16
},
410 { BFD_RELOC_SH_IMM_LOW16
, R_SH_IMM_LOW16
},
411 { BFD_RELOC_SH_IMM_LOW16_PCREL
, R_SH_IMM_LOW16_PCREL
},
412 { BFD_RELOC_SH_IMM_MEDLOW16
, R_SH_IMM_MEDLOW16
},
413 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL
, R_SH_IMM_MEDLOW16_PCREL
},
414 { BFD_RELOC_SH_IMM_MEDHI16
, R_SH_IMM_MEDHI16
},
415 { BFD_RELOC_SH_IMM_MEDHI16_PCREL
, R_SH_IMM_MEDHI16_PCREL
},
416 { BFD_RELOC_SH_IMM_HI16
, R_SH_IMM_HI16
},
417 { BFD_RELOC_SH_IMM_HI16_PCREL
, R_SH_IMM_HI16_PCREL
},
418 { BFD_RELOC_64
, R_SH_64
},
419 { BFD_RELOC_64_PCREL
, R_SH_64_PCREL
},
420 #endif /* not INCLUDE_SHMEDIA */
423 /* Given a BFD reloc code, return the howto structure for the
424 corresponding SH ELF reloc. */
426 static reloc_howto_type
*
427 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
431 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
433 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
434 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
440 static reloc_howto_type
*
441 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
445 if (vxworks_object_p (abfd
))
448 i
< (sizeof (sh_vxworks_howto_table
)
449 / sizeof (sh_vxworks_howto_table
[0]));
451 if (sh_vxworks_howto_table
[i
].name
!= NULL
452 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
453 return &sh_vxworks_howto_table
[i
];
458 i
< (sizeof (sh_elf_howto_table
)
459 / sizeof (sh_elf_howto_table
[0]));
461 if (sh_elf_howto_table
[i
].name
!= NULL
462 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
463 return &sh_elf_howto_table
[i
];
469 /* Given an ELF reloc, fill in the howto field of a relent. */
472 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
476 r
= ELF32_R_TYPE (dst
->r_info
);
478 BFD_ASSERT (r
< (unsigned int) R_SH_max
);
479 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC
|| r
> R_SH_LAST_INVALID_RELOC
);
480 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_2
|| r
> R_SH_LAST_INVALID_RELOC_2
);
481 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_3
|| r
> R_SH_LAST_INVALID_RELOC_3
);
482 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_4
|| r
> R_SH_LAST_INVALID_RELOC_4
);
483 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_5
|| r
> R_SH_LAST_INVALID_RELOC_5
);
484 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_6
|| r
> R_SH_LAST_INVALID_RELOC_6
);
486 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
489 /* This function handles relaxing for SH ELF. See the corresponding
490 function in coff-sh.c for a description of what this does. FIXME:
491 There is a lot of duplication here between this code and the COFF
492 specific code. The format of relocs and symbols is wound deeply
493 into this code, but it would still be better if the duplication
494 could be eliminated somehow. Note in particular that although both
495 functions use symbols like R_SH_CODE, those symbols have different
496 values; in coff-sh.c they come from include/coff/sh.h, whereas here
497 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
500 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
501 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
503 Elf_Internal_Shdr
*symtab_hdr
;
504 Elf_Internal_Rela
*internal_relocs
;
505 bfd_boolean have_code
;
506 Elf_Internal_Rela
*irel
, *irelend
;
507 bfd_byte
*contents
= NULL
;
508 Elf_Internal_Sym
*isymbuf
= NULL
;
512 if (link_info
->relocatable
513 || (sec
->flags
& SEC_RELOC
) == 0
514 || sec
->reloc_count
== 0)
517 #ifdef INCLUDE_SHMEDIA
518 if (elf_section_data (sec
)->this_hdr
.sh_flags
519 & (SHF_SH5_ISA32
| SHF_SH5_ISA32_MIXED
))
525 symtab_hdr
= &elf_symtab_hdr (abfd
);
527 internal_relocs
= (_bfd_elf_link_read_relocs
528 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
529 link_info
->keep_memory
));
530 if (internal_relocs
== NULL
)
535 irelend
= internal_relocs
+ sec
->reloc_count
;
536 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
538 bfd_vma laddr
, paddr
, symval
;
540 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
543 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
546 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
549 /* Get the section contents. */
550 if (contents
== NULL
)
552 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
553 contents
= elf_section_data (sec
)->this_hdr
.contents
;
556 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
561 /* The r_addend field of the R_SH_USES reloc will point us to
562 the register load. The 4 is because the r_addend field is
563 computed as though it were a jump offset, which are based
564 from 4 bytes after the jump instruction. */
565 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
566 if (laddr
>= sec
->size
)
568 (*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
570 (unsigned long) irel
->r_offset
);
573 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
575 /* If the instruction is not mov.l NN,rN, we don't know what to
577 if ((insn
& 0xf000) != 0xd000)
579 ((*_bfd_error_handler
)
580 (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
581 abfd
, (unsigned long) irel
->r_offset
, insn
));
585 /* Get the address from which the register is being loaded. The
586 displacement in the mov.l instruction is quadrupled. It is a
587 displacement from four bytes after the movl instruction, but,
588 before adding in the PC address, two least significant bits
589 of the PC are cleared. We assume that the section is aligned
590 on a four byte boundary. */
593 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
594 if (paddr
>= sec
->size
)
596 ((*_bfd_error_handler
)
597 (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
598 abfd
, (unsigned long) irel
->r_offset
));
602 /* Get the reloc for the address from which the register is
603 being loaded. This reloc will tell us which function is
604 actually being called. */
605 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
606 if (irelfn
->r_offset
== paddr
607 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
609 if (irelfn
>= irelend
)
611 ((*_bfd_error_handler
)
612 (_("%B: 0x%lx: warning: could not find expected reloc"),
613 abfd
, (unsigned long) paddr
));
617 /* Read this BFD's symbols if we haven't done so already. */
618 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
620 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
622 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
623 symtab_hdr
->sh_info
, 0,
629 /* Get the value of the symbol referred to by the reloc. */
630 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
632 /* A local symbol. */
633 Elf_Internal_Sym
*isym
;
635 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
637 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
639 ((*_bfd_error_handler
)
640 (_("%B: 0x%lx: warning: symbol in unexpected section"),
641 abfd
, (unsigned long) paddr
));
645 symval
= (isym
->st_value
646 + sec
->output_section
->vma
647 + sec
->output_offset
);
652 struct elf_link_hash_entry
*h
;
654 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
655 h
= elf_sym_hashes (abfd
)[indx
];
656 BFD_ASSERT (h
!= NULL
);
657 if (h
->root
.type
!= bfd_link_hash_defined
658 && h
->root
.type
!= bfd_link_hash_defweak
)
660 /* This appears to be a reference to an undefined
661 symbol. Just ignore it--it will be caught by the
662 regular reloc processing. */
666 symval
= (h
->root
.u
.def
.value
667 + h
->root
.u
.def
.section
->output_section
->vma
668 + h
->root
.u
.def
.section
->output_offset
);
671 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
672 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
674 symval
+= irelfn
->r_addend
;
676 /* See if this function call can be shortened. */
679 + sec
->output_section
->vma
682 /* A branch to an address beyond ours might be increased by an
683 .align that doesn't move when bytes behind us are deleted.
684 So, we add some slop in this calculation to allow for
686 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
688 /* After all that work, we can't shorten this function call. */
692 /* Shorten the function call. */
694 /* For simplicity of coding, we are going to modify the section
695 contents, the section relocs, and the BFD symbol table. We
696 must tell the rest of the code not to free up this
697 information. It would be possible to instead create a table
698 of changes which have to be made, as is done in coff-mips.c;
699 that would be more work, but would require less memory when
700 the linker is run. */
702 elf_section_data (sec
)->relocs
= internal_relocs
;
703 elf_section_data (sec
)->this_hdr
.contents
= contents
;
704 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
706 /* Replace the jsr with a bsr. */
708 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
709 replace the jsr with a bsr. */
710 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
711 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
712 here, but that only checks if the symbol is an external symbol,
713 not if the symbol is in a different section. Besides, we need
714 a consistent meaning for the relocation, so we just assume here that
715 the value of the symbol is not available. */
717 /* We can't fully resolve this yet, because the external
718 symbol value may be changed by future relaxing. We let
719 the final link phase handle it. */
720 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
724 /* When we calculated the symbol "value" we had an offset in the
725 DIR32's word in memory (we read and add it above). However,
726 the jsr we create does NOT have this offset encoded, so we
727 have to add it to the addend to preserve it. */
728 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
730 /* See if there is another R_SH_USES reloc referring to the same
732 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
733 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
734 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
736 if (irelscan
< irelend
)
738 /* Some other function call depends upon this register load,
739 and we have not yet converted that function call.
740 Indeed, we may never be able to convert it. There is
741 nothing else we can do at this point. */
745 /* Look for a R_SH_COUNT reloc on the location where the
746 function address is stored. Do this before deleting any
747 bytes, to avoid confusion about the address. */
748 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
749 if (irelcount
->r_offset
== paddr
750 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
753 /* Delete the register load. */
754 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
757 /* That will change things, so, just in case it permits some
758 other function call to come within range, we should relax
759 again. Note that this is not required, and it may be slow. */
762 /* Now check whether we got a COUNT reloc. */
763 if (irelcount
>= irelend
)
765 ((*_bfd_error_handler
)
766 (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
767 abfd
, (unsigned long) paddr
));
771 /* The number of uses is stored in the r_addend field. We've
773 if (irelcount
->r_addend
== 0)
775 ((*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad count"),
777 (unsigned long) paddr
));
781 --irelcount
->r_addend
;
783 /* If there are no more uses, we can delete the address. Reload
784 the address from irelfn, in case it was changed by the
785 previous call to sh_elf_relax_delete_bytes. */
786 if (irelcount
->r_addend
== 0)
788 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
792 /* We've done all we can with that function call. */
795 /* Look for load and store instructions that we can align on four
797 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
802 /* Get the section contents. */
803 if (contents
== NULL
)
805 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
806 contents
= elf_section_data (sec
)->this_hdr
.contents
;
809 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
814 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
820 elf_section_data (sec
)->relocs
= internal_relocs
;
821 elf_section_data (sec
)->this_hdr
.contents
= contents
;
822 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
827 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
829 if (! link_info
->keep_memory
)
833 /* Cache the symbols for elf_link_input_bfd. */
834 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
839 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
841 if (! link_info
->keep_memory
)
845 /* Cache the section contents for elf_link_input_bfd. */
846 elf_section_data (sec
)->this_hdr
.contents
= contents
;
850 if (internal_relocs
!= NULL
851 && elf_section_data (sec
)->relocs
!= internal_relocs
)
852 free (internal_relocs
);
858 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
861 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
863 if (internal_relocs
!= NULL
864 && elf_section_data (sec
)->relocs
!= internal_relocs
)
865 free (internal_relocs
);
870 /* Delete some bytes from a section while relaxing. FIXME: There is a
871 lot of duplication between this function and sh_relax_delete_bytes
875 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
878 Elf_Internal_Shdr
*symtab_hdr
;
879 unsigned int sec_shndx
;
881 Elf_Internal_Rela
*irel
, *irelend
;
882 Elf_Internal_Rela
*irelalign
;
884 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
885 struct elf_link_hash_entry
**sym_hashes
;
886 struct elf_link_hash_entry
**end_hashes
;
887 unsigned int symcount
;
890 symtab_hdr
= &elf_symtab_hdr (abfd
);
891 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
893 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
895 contents
= elf_section_data (sec
)->this_hdr
.contents
;
897 /* The deletion must stop at the next ALIGN reloc for an aligment
898 power larger than the number of bytes we are deleting. */
903 irel
= elf_section_data (sec
)->relocs
;
904 irelend
= irel
+ sec
->reloc_count
;
905 for (; irel
< irelend
; irel
++)
907 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
908 && irel
->r_offset
> addr
909 && count
< (1 << irel
->r_addend
))
912 toaddr
= irel
->r_offset
;
917 /* Actually delete the bytes. */
918 memmove (contents
+ addr
, contents
+ addr
+ count
,
919 (size_t) (toaddr
- addr
- count
));
920 if (irelalign
== NULL
)
926 #define NOP_OPCODE (0x0009)
928 BFD_ASSERT ((count
& 1) == 0);
929 for (i
= 0; i
< count
; i
+= 2)
930 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
933 /* Adjust all the relocs. */
934 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
936 bfd_vma nraddr
, stop
;
939 int off
, adjust
, oinsn
;
940 bfd_signed_vma voff
= 0;
941 bfd_boolean overflow
;
943 /* Get the new reloc address. */
944 nraddr
= irel
->r_offset
;
945 if ((irel
->r_offset
> addr
946 && irel
->r_offset
< toaddr
)
947 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
948 && irel
->r_offset
== toaddr
))
951 /* See if this reloc was for the bytes we have deleted, in which
952 case we no longer care about it. Don't delete relocs which
953 represent addresses, though. */
954 if (irel
->r_offset
>= addr
955 && irel
->r_offset
< addr
+ count
956 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
957 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
958 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
959 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
960 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
963 /* If this is a PC relative reloc, see if the range it covers
964 includes the bytes we have deleted. */
965 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
974 start
= irel
->r_offset
;
975 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
979 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
986 /* If this reloc is against a symbol defined in this
987 section, and the symbol will not be adjusted below, we
988 must check the addend to see it will put the value in
989 range to be adjusted, and hence must be changed. */
990 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
992 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
993 if (isym
->st_shndx
== sec_shndx
994 && (isym
->st_value
<= addr
995 || isym
->st_value
>= toaddr
))
999 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
1001 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
1002 val
+= isym
->st_value
;
1003 if (val
> addr
&& val
< toaddr
)
1004 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
1008 val
= isym
->st_value
+ irel
->r_addend
;
1009 if (val
> addr
&& val
< toaddr
)
1010 irel
->r_addend
-= count
;
1014 start
= stop
= addr
;
1021 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1028 /* This has been made by previous relaxation. Since the
1029 relocation will be against an external symbol, the
1030 final relocation will just do the right thing. */
1031 start
= stop
= addr
;
1037 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1039 /* The addend will be against the section symbol, thus
1040 for adjusting the addend, the relevant start is the
1041 start of the section.
1042 N.B. If we want to abandon in-place changes here and
1043 test directly using symbol + addend, we have to take into
1044 account that the addend has already been adjusted by -4. */
1045 if (stop
> addr
&& stop
< toaddr
)
1046 irel
->r_addend
-= count
;
1052 stop
= start
+ 4 + off
* 2;
1057 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1063 /* These relocs types represent
1065 The r_addend field holds the difference between the reloc
1066 address and L1. That is the start of the reloc, and
1067 adding in the contents gives us the top. We must adjust
1068 both the r_offset field and the section contents.
1069 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1070 and the elf bfd r_offset is called r_vaddr. */
1072 stop
= irel
->r_offset
;
1073 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1077 && (stop
<= addr
|| stop
>= toaddr
))
1078 irel
->r_addend
+= count
;
1079 else if (stop
> addr
1081 && (start
<= addr
|| start
>= toaddr
))
1082 irel
->r_addend
-= count
;
1084 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1085 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1086 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1087 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1089 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1090 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1095 start
= irel
->r_offset
;
1096 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1097 + (long) irel
->r_addend
1104 && (stop
<= addr
|| stop
>= toaddr
))
1106 else if (stop
> addr
1108 && (start
<= addr
|| start
>= toaddr
))
1117 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1126 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1128 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1133 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1135 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1139 BFD_ASSERT (adjust
== count
|| count
>= 4);
1144 if ((irel
->r_offset
& 3) == 0)
1147 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1149 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1154 if (voff
< 0 || voff
>= 0xff)
1156 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1161 if (voff
< - 0x8000 || voff
>= 0x8000)
1163 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1168 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1172 irel
->r_addend
+= adjust
;
1178 ((*_bfd_error_handler
)
1179 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1180 abfd
, (unsigned long) irel
->r_offset
));
1181 bfd_set_error (bfd_error_bad_value
);
1186 irel
->r_offset
= nraddr
;
1189 /* Look through all the other sections. If there contain any IMM32
1190 relocs against internal symbols which we are not going to adjust
1191 below, we may need to adjust the addends. */
1192 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1194 Elf_Internal_Rela
*internal_relocs
;
1195 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1196 bfd_byte
*ocontents
;
1199 || (o
->flags
& SEC_RELOC
) == 0
1200 || o
->reloc_count
== 0)
1203 /* We always cache the relocs. Perhaps, if info->keep_memory is
1204 FALSE, we should free them, if we are permitted to, when we
1205 leave sh_coff_relax_section. */
1206 internal_relocs
= (_bfd_elf_link_read_relocs
1207 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
));
1208 if (internal_relocs
== NULL
)
1212 irelscanend
= internal_relocs
+ o
->reloc_count
;
1213 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1215 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1216 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1218 bfd_vma start
, stop
;
1219 bfd_signed_vma voff
;
1221 if (ocontents
== NULL
)
1223 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1224 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1227 /* We always cache the section contents.
1228 Perhaps, if info->keep_memory is FALSE, we
1229 should free them, if we are permitted to,
1230 when we leave sh_coff_relax_section. */
1231 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1233 if (ocontents
!= NULL
)
1238 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1242 stop
= irelscan
->r_offset
;
1244 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1246 /* STOP is in a different section, so it won't change. */
1247 if (start
> addr
&& start
< toaddr
)
1248 irelscan
->r_addend
+= count
;
1250 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1251 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1255 && (stop
<= addr
|| stop
>= toaddr
))
1256 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1257 ocontents
+ irelscan
->r_offset
);
1258 else if (stop
> addr
1260 && (start
<= addr
|| start
>= toaddr
))
1261 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1262 ocontents
+ irelscan
->r_offset
);
1265 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1268 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1272 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1273 if (isym
->st_shndx
== sec_shndx
1274 && (isym
->st_value
<= addr
1275 || isym
->st_value
>= toaddr
))
1279 if (ocontents
== NULL
)
1281 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1282 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1285 /* We always cache the section contents.
1286 Perhaps, if info->keep_memory is FALSE, we
1287 should free them, if we are permitted to,
1288 when we leave sh_coff_relax_section. */
1289 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1291 if (ocontents
!= NULL
)
1296 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1300 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1301 val
+= isym
->st_value
;
1302 if (val
> addr
&& val
< toaddr
)
1303 bfd_put_32 (abfd
, val
- count
,
1304 ocontents
+ irelscan
->r_offset
);
1309 /* Adjust the local symbols defined in this section. */
1310 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1311 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1313 if (isym
->st_shndx
== sec_shndx
1314 && isym
->st_value
> addr
1315 && isym
->st_value
< toaddr
)
1316 isym
->st_value
-= count
;
1319 /* Now adjust the global symbols defined in this section. */
1320 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1321 - symtab_hdr
->sh_info
);
1322 sym_hashes
= elf_sym_hashes (abfd
);
1323 end_hashes
= sym_hashes
+ symcount
;
1324 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1326 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1327 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1328 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1329 && sym_hash
->root
.u
.def
.section
== sec
1330 && sym_hash
->root
.u
.def
.value
> addr
1331 && sym_hash
->root
.u
.def
.value
< toaddr
)
1333 sym_hash
->root
.u
.def
.value
-= count
;
1337 /* See if we can move the ALIGN reloc forward. We have adjusted
1338 r_offset for it already. */
1339 if (irelalign
!= NULL
)
1341 bfd_vma alignto
, alignaddr
;
1343 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1344 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1345 1 << irelalign
->r_addend
);
1346 if (alignto
!= alignaddr
)
1348 /* Tail recursion. */
1349 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1350 (int) (alignto
- alignaddr
));
1357 /* Look for loads and stores which we can align to four byte
1358 boundaries. This is like sh_align_loads in coff-sh.c. */
1361 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1362 Elf_Internal_Rela
*internal_relocs
,
1363 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1364 bfd_boolean
*pswapped
)
1366 Elf_Internal_Rela
*irel
, *irelend
;
1367 bfd_vma
*labels
= NULL
;
1368 bfd_vma
*label
, *label_end
;
1373 irelend
= internal_relocs
+ sec
->reloc_count
;
1375 /* Get all the addresses with labels on them. */
1376 amt
= sec
->reloc_count
;
1377 amt
*= sizeof (bfd_vma
);
1378 labels
= (bfd_vma
*) bfd_malloc (amt
);
1382 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1384 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1386 *label_end
= irel
->r_offset
;
1391 /* Note that the assembler currently always outputs relocs in
1392 address order. If that ever changes, this code will need to sort
1393 the label values and the relocs. */
1397 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1399 bfd_vma start
, stop
;
1401 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1404 start
= irel
->r_offset
;
1406 for (irel
++; irel
< irelend
; irel
++)
1407 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1410 stop
= irel
->r_offset
;
1414 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1415 internal_relocs
, &label
,
1416 label_end
, start
, stop
, pswapped
))
1431 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1434 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1435 bfd_byte
*contents
, bfd_vma addr
)
1437 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1438 unsigned short i1
, i2
;
1439 Elf_Internal_Rela
*irel
, *irelend
;
1441 /* Swap the instructions themselves. */
1442 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1443 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1444 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1445 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1447 /* Adjust all reloc addresses. */
1448 irelend
= internal_relocs
+ sec
->reloc_count
;
1449 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1451 enum elf_sh_reloc_type type
;
1454 /* There are a few special types of relocs that we don't want to
1455 adjust. These relocs do not apply to the instruction itself,
1456 but are only associated with the address. */
1457 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1458 if (type
== R_SH_ALIGN
1459 || type
== R_SH_CODE
1460 || type
== R_SH_DATA
1461 || type
== R_SH_LABEL
)
1464 /* If an R_SH_USES reloc points to one of the addresses being
1465 swapped, we must adjust it. It would be incorrect to do this
1466 for a jump, though, since we want to execute both
1467 instructions after the jump. (We have avoided swapping
1468 around a label, so the jump will not wind up executing an
1469 instruction it shouldn't). */
1470 if (type
== R_SH_USES
)
1474 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1476 irel
->r_offset
+= 2;
1477 else if (off
== addr
+ 2)
1478 irel
->r_offset
-= 2;
1481 if (irel
->r_offset
== addr
)
1483 irel
->r_offset
+= 2;
1486 else if (irel
->r_offset
== addr
+ 2)
1488 irel
->r_offset
-= 2;
1497 unsigned short insn
, oinsn
;
1498 bfd_boolean overflow
;
1500 loc
= contents
+ irel
->r_offset
;
1509 insn
= bfd_get_16 (abfd
, loc
);
1512 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1514 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1518 insn
= bfd_get_16 (abfd
, loc
);
1521 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1523 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1527 /* This reloc ignores the least significant 3 bits of
1528 the program counter before adding in the offset.
1529 This means that if ADDR is at an even address, the
1530 swap will not affect the offset. If ADDR is an at an
1531 odd address, then the instruction will be crossing a
1532 four byte boundary, and must be adjusted. */
1533 if ((addr
& 3) != 0)
1535 insn
= bfd_get_16 (abfd
, loc
);
1538 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1540 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1548 ((*_bfd_error_handler
)
1549 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1550 abfd
, (unsigned long) irel
->r_offset
));
1551 bfd_set_error (bfd_error_bad_value
);
1559 #endif /* defined SH64_ELF */
1561 /* Describes one of the various PLT styles. */
1563 struct elf_sh_plt_info
1565 /* The template for the first PLT entry, or NULL if there is no special
1567 const bfd_byte
*plt0_entry
;
1569 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1570 bfd_vma plt0_entry_size
;
1572 /* Index I is the offset into PLT0_ENTRY of a pointer to
1573 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1574 if there is no such pointer. */
1575 bfd_vma plt0_got_fields
[3];
1577 /* The template for a symbol's PLT entry. */
1578 const bfd_byte
*symbol_entry
;
1580 /* The size of SYMBOL_ENTRY in bytes. */
1581 bfd_vma symbol_entry_size
;
1583 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1584 on all targets. The comments by each member indicate the value
1585 that the field must hold. */
1587 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1588 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1589 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1590 bfd_boolean got20
; /* TRUE if got_entry points to a movi20
1591 instruction (instead of a constant pool
1595 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1596 bfd_vma symbol_resolve_offset
;
1598 /* A different PLT layout which can be used for the first
1599 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1601 const struct elf_sh_plt_info
*short_plt
;
1604 #ifdef INCLUDE_SHMEDIA
1606 /* The size in bytes of an entry in the procedure linkage table. */
1608 #define ELF_PLT_ENTRY_SIZE 64
1610 /* First entry in an absolute procedure linkage table look like this. */
1612 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1614 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1615 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1616 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1617 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1618 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1619 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1620 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1621 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1622 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1623 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1624 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1625 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1626 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1627 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1628 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1629 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1632 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1634 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1635 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1636 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1637 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1638 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1639 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1640 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1641 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1642 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1643 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1644 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1645 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1646 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1647 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1648 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1649 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1652 /* Sebsequent entries in an absolute procedure linkage table look like
1655 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1657 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1658 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1659 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1660 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1661 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1662 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1663 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1664 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1665 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1666 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1667 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1668 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1669 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1670 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1671 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1672 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1675 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1677 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1678 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1679 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1680 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1681 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1682 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1683 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1684 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1685 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1686 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1687 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1688 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1689 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1690 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1691 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1692 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1695 /* Entries in a PIC procedure linkage table look like this. */
1697 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1699 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1700 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1701 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1702 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1703 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1704 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1705 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1706 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1707 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1708 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1709 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1710 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1711 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1712 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1713 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1714 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1717 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1719 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1720 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1721 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1722 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1723 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1724 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1725 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1726 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1727 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1728 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1729 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1730 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1731 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1732 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1733 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1734 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1737 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1740 /* Big-endian non-PIC. */
1741 elf_sh_plt0_entry_be
,
1743 { 0, MINUS_ONE
, MINUS_ONE
},
1744 elf_sh_plt_entry_be
,
1746 { 0, 32, 48, FALSE
},
1747 33, /* includes ISA encoding */
1751 /* Little-endian non-PIC. */
1752 elf_sh_plt0_entry_le
,
1754 { 0, MINUS_ONE
, MINUS_ONE
},
1755 elf_sh_plt_entry_le
,
1757 { 0, 32, 48, FALSE
},
1758 33, /* includes ISA encoding */
1764 /* Big-endian PIC. */
1765 elf_sh_plt0_entry_be
,
1767 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1768 elf_sh_pic_plt_entry_be
,
1770 { 0, MINUS_ONE
, 52, FALSE
},
1771 33, /* includes ISA encoding */
1775 /* Little-endian PIC. */
1776 elf_sh_plt0_entry_le
,
1778 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1779 elf_sh_pic_plt_entry_le
,
1781 { 0, MINUS_ONE
, 52, FALSE
},
1782 33, /* includes ISA encoding */
1788 /* Return offset of the linker in PLT0 entry. */
1789 #define elf_sh_plt0_gotplt_offset(info) 0
1791 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1792 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1795 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1798 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p
,
1799 unsigned long value
, bfd_byte
*addr
)
1802 bfd_put_32 (output_bfd
,
1803 bfd_get_32 (output_bfd
, addr
)
1804 | ((value
>> 6) & 0x3fffc00),
1806 bfd_put_32 (output_bfd
,
1807 bfd_get_32 (output_bfd
, addr
+ 4)
1808 | ((value
<< 10) & 0x3fffc00),
1812 /* Return the type of PLT associated with ABFD. PIC_P is true if
1813 the object is position-independent. */
1815 static const struct elf_sh_plt_info
*
1816 get_plt_info (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean pic_p
)
1818 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
1821 /* The size in bytes of an entry in the procedure linkage table. */
1823 #define ELF_PLT_ENTRY_SIZE 28
1825 /* First entry in an absolute procedure linkage table look like this. */
1827 /* Note - this code has been "optimised" not to use r2. r2 is used by
1828 GCC to return the address of large structures, so it should not be
1829 corrupted here. This does mean however, that this PLT does not conform
1830 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1831 and r2 contains the GOT id. This version stores the GOT id in r0 and
1832 ignores the type. Loaders can easily detect this difference however,
1833 since the type will always be 0 or 8, and the GOT ids will always be
1834 greater than or equal to 12. */
1835 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1837 0xd0, 0x05, /* mov.l 2f,r0 */
1838 0x60, 0x02, /* mov.l @r0,r0 */
1839 0x2f, 0x06, /* mov.l r0,@-r15 */
1840 0xd0, 0x03, /* mov.l 1f,r0 */
1841 0x60, 0x02, /* mov.l @r0,r0 */
1842 0x40, 0x2b, /* jmp @r0 */
1843 0x60, 0xf6, /* mov.l @r15+,r0 */
1844 0x00, 0x09, /* nop */
1845 0x00, 0x09, /* nop */
1846 0x00, 0x09, /* nop */
1847 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1848 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1851 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1853 0x05, 0xd0, /* mov.l 2f,r0 */
1854 0x02, 0x60, /* mov.l @r0,r0 */
1855 0x06, 0x2f, /* mov.l r0,@-r15 */
1856 0x03, 0xd0, /* mov.l 1f,r0 */
1857 0x02, 0x60, /* mov.l @r0,r0 */
1858 0x2b, 0x40, /* jmp @r0 */
1859 0xf6, 0x60, /* mov.l @r15+,r0 */
1860 0x09, 0x00, /* nop */
1861 0x09, 0x00, /* nop */
1862 0x09, 0x00, /* nop */
1863 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1864 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1867 /* Sebsequent entries in an absolute procedure linkage table look like
1870 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1872 0xd0, 0x04, /* mov.l 1f,r0 */
1873 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1874 0xd1, 0x02, /* mov.l 0f,r1 */
1875 0x40, 0x2b, /* jmp @r0 */
1876 0x60, 0x13, /* mov r1,r0 */
1877 0xd1, 0x03, /* mov.l 2f,r1 */
1878 0x40, 0x2b, /* jmp @r0 */
1879 0x00, 0x09, /* nop */
1880 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1881 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1882 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1885 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1887 0x04, 0xd0, /* mov.l 1f,r0 */
1888 0x02, 0x60, /* mov.l @r0,r0 */
1889 0x02, 0xd1, /* mov.l 0f,r1 */
1890 0x2b, 0x40, /* jmp @r0 */
1891 0x13, 0x60, /* mov r1,r0 */
1892 0x03, 0xd1, /* mov.l 2f,r1 */
1893 0x2b, 0x40, /* jmp @r0 */
1894 0x09, 0x00, /* nop */
1895 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1896 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1897 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1900 /* Entries in a PIC procedure linkage table look like this. */
1902 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1904 0xd0, 0x04, /* mov.l 1f,r0 */
1905 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1906 0x40, 0x2b, /* jmp @r0 */
1907 0x00, 0x09, /* nop */
1908 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1909 0xd1, 0x03, /* mov.l 2f,r1 */
1910 0x40, 0x2b, /* jmp @r0 */
1911 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1912 0x00, 0x09, /* nop */
1913 0x00, 0x09, /* nop */
1914 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1915 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1918 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1920 0x04, 0xd0, /* mov.l 1f,r0 */
1921 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1922 0x2b, 0x40, /* jmp @r0 */
1923 0x09, 0x00, /* nop */
1924 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1925 0x03, 0xd1, /* mov.l 2f,r1 */
1926 0x2b, 0x40, /* jmp @r0 */
1927 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1928 0x09, 0x00, /* nop */
1929 0x09, 0x00, /* nop */
1930 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1931 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1934 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1937 /* Big-endian non-PIC. */
1938 elf_sh_plt0_entry_be
,
1940 { MINUS_ONE
, 24, 20 },
1941 elf_sh_plt_entry_be
,
1943 { 20, 16, 24, FALSE
},
1948 /* Little-endian non-PIC. */
1949 elf_sh_plt0_entry_le
,
1951 { MINUS_ONE
, 24, 20 },
1952 elf_sh_plt_entry_le
,
1954 { 20, 16, 24, FALSE
},
1961 /* Big-endian PIC. */
1962 elf_sh_plt0_entry_be
,
1964 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1965 elf_sh_pic_plt_entry_be
,
1967 { 20, MINUS_ONE
, 24, FALSE
},
1972 /* Little-endian PIC. */
1973 elf_sh_plt0_entry_le
,
1975 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1976 elf_sh_pic_plt_entry_le
,
1978 { 20, MINUS_ONE
, 24, FALSE
},
1985 #define VXWORKS_PLT_HEADER_SIZE 12
1986 #define VXWORKS_PLT_ENTRY_SIZE 24
1988 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1990 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1991 0x61, 0x12, /* mov.l @r1,r1 */
1992 0x41, 0x2b, /* jmp @r1 */
1993 0x00, 0x09, /* nop */
1994 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1997 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1999 0x01, 0xd1, /* mov.l @(8,pc),r1 */
2000 0x12, 0x61, /* mov.l @r1,r1 */
2001 0x2b, 0x41, /* jmp @r1 */
2002 0x09, 0x00, /* nop */
2003 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2006 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
2008 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2009 0x60, 0x02, /* mov.l @r0,r0 */
2010 0x40, 0x2b, /* jmp @r0 */
2011 0x00, 0x09, /* nop */
2012 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2013 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2014 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
2015 0x00, 0x09, /* nop */
2016 0x00, 0x09, /* nop */
2017 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2020 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
2022 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2023 0x02, 0x60, /* mov.l @r0,r0 */
2024 0x2b, 0x40, /* jmp @r0 */
2025 0x09, 0x00, /* nop */
2026 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2027 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2028 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
2029 0x09, 0x00, /* nop */
2030 0x09, 0x00, /* nop */
2031 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2034 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
2036 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2037 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2038 0x40, 0x2b, /* jmp @r0 */
2039 0x00, 0x09, /* nop */
2040 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2041 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2042 0x51, 0xc2, /* mov.l @(8,r12),r1 */
2043 0x41, 0x2b, /* jmp @r1 */
2044 0x00, 0x09, /* nop */
2045 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2048 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
2050 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2051 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2052 0x2b, 0x40, /* jmp @r0 */
2053 0x09, 0x00, /* nop */
2054 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2055 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2056 0xc2, 0x51, /* mov.l @(8,r12),r1 */
2057 0x2b, 0x41, /* jmp @r1 */
2058 0x09, 0x00, /* nop */
2059 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2062 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
2065 /* Big-endian non-PIC. */
2066 vxworks_sh_plt0_entry_be
,
2067 VXWORKS_PLT_HEADER_SIZE
,
2068 { MINUS_ONE
, MINUS_ONE
, 8 },
2069 vxworks_sh_plt_entry_be
,
2070 VXWORKS_PLT_ENTRY_SIZE
,
2071 { 8, 14, 20, FALSE
},
2076 /* Little-endian non-PIC. */
2077 vxworks_sh_plt0_entry_le
,
2078 VXWORKS_PLT_HEADER_SIZE
,
2079 { MINUS_ONE
, MINUS_ONE
, 8 },
2080 vxworks_sh_plt_entry_le
,
2081 VXWORKS_PLT_ENTRY_SIZE
,
2082 { 8, 14, 20, FALSE
},
2089 /* Big-endian PIC. */
2092 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2093 vxworks_sh_pic_plt_entry_be
,
2094 VXWORKS_PLT_ENTRY_SIZE
,
2095 { 8, MINUS_ONE
, 20, FALSE
},
2100 /* Little-endian PIC. */
2103 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2104 vxworks_sh_pic_plt_entry_le
,
2105 VXWORKS_PLT_ENTRY_SIZE
,
2106 { 8, MINUS_ONE
, 20, FALSE
},
2113 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2114 binding are to omit the lazy binding stub when linking with -z now
2115 and to move lazy binding stubs into a separate region for better
2118 #define FDPIC_PLT_ENTRY_SIZE 28
2119 #define FDPIC_PLT_LAZY_OFFSET 20
2121 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2122 duplicated if it is out of range, or which can be inlined. So
2123 right now it is always inlined, which wastes a word per stub. It
2124 might be easier to handle the duplication if we put the lazy
2125 stubs separately. */
2127 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
2129 0xd0, 0x02, /* mov.l @(12,pc),r0 */
2130 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2131 0x70, 0x04, /* add #4, r0 */
2132 0x41, 0x2b, /* jmp @r1 */
2133 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2134 0x00, 0x09, /* nop */
2135 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2136 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2137 0x60, 0xc2, /* mov.l @r12,r0 */
2138 0x40, 0x2b, /* jmp @r0 */
2139 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2140 0x00, 0x09, /* nop */
2143 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
2145 0x02, 0xd0, /* mov.l @(12,pc),r0 */
2146 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2147 0x04, 0x70, /* add #4, r0 */
2148 0x2b, 0x41, /* jmp @r1 */
2149 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2150 0x09, 0x00, /* nop */
2151 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2152 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2153 0xc2, 0x60, /* mov.l @r12,r0 */
2154 0x2b, 0x40, /* jmp @r0 */
2155 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2156 0x09, 0x00, /* nop */
2159 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
2161 /* Big-endian PIC. */
2164 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2165 fdpic_sh_plt_entry_be
,
2166 FDPIC_PLT_ENTRY_SIZE
,
2167 { 12, MINUS_ONE
, 16, FALSE
},
2168 FDPIC_PLT_LAZY_OFFSET
,
2172 /* Little-endian PIC. */
2175 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2176 fdpic_sh_plt_entry_le
,
2177 FDPIC_PLT_ENTRY_SIZE
,
2178 { 12, MINUS_ONE
, 16, FALSE
},
2179 FDPIC_PLT_LAZY_OFFSET
,
2184 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2185 entries for the first 64K slots. We use the normal FDPIC PLT entry
2186 past that point; we could also use movi20s, which might be faster,
2187 but would not be any smaller. */
2189 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2190 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2192 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
2194 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2195 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2196 0x70, 0x04, /* add #4, r0 */
2197 0x41, 0x2b, /* jmp @r1 */
2198 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2199 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2200 0x60, 0xc2, /* mov.l @r12,r0 */
2201 0x40, 0x2b, /* jmp @r0 */
2202 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2203 0x00, 0x09, /* nop */
2206 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
2208 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2209 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2210 0x04, 0x70, /* add #4, r0 */
2211 0x2b, 0x41, /* jmp @r1 */
2212 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2213 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2214 0xc2, 0x60, /* mov.l @r12,r0 */
2215 0x2b, 0x40, /* jmp @r0 */
2216 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2217 0x09, 0x00, /* nop */
2220 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
2221 /* Big-endian FDPIC, max index 64K. */
2224 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2225 fdpic_sh2a_plt_entry_be
,
2226 FDPIC_SH2A_PLT_ENTRY_SIZE
,
2227 { 0, MINUS_ONE
, 12, TRUE
},
2228 FDPIC_SH2A_PLT_LAZY_OFFSET
,
2232 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
2233 /* Little-endian FDPIC, max index 64K. */
2236 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2237 fdpic_sh2a_plt_entry_le
,
2238 FDPIC_SH2A_PLT_ENTRY_SIZE
,
2239 { 0, MINUS_ONE
, 12, TRUE
},
2240 FDPIC_SH2A_PLT_LAZY_OFFSET
,
2244 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
2246 /* Big-endian PIC. */
2249 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2250 fdpic_sh_plt_entry_be
,
2251 FDPIC_PLT_ENTRY_SIZE
,
2252 { 12, MINUS_ONE
, 16, FALSE
},
2253 FDPIC_PLT_LAZY_OFFSET
,
2254 &fdpic_sh2a_short_plt_be
2257 /* Little-endian PIC. */
2260 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2261 fdpic_sh_plt_entry_le
,
2262 FDPIC_PLT_ENTRY_SIZE
,
2263 { 12, MINUS_ONE
, 16, FALSE
},
2264 FDPIC_PLT_LAZY_OFFSET
,
2265 &fdpic_sh2a_short_plt_le
2269 /* Return the type of PLT associated with ABFD. PIC_P is true if
2270 the object is position-independent. */
2272 static const struct elf_sh_plt_info
*
2273 get_plt_info (bfd
*abfd
, bfd_boolean pic_p
)
2275 if (fdpic_object_p (abfd
))
2277 /* If any input file requires SH2A we can use a shorter PLT
2279 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2280 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2282 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2284 if (vxworks_object_p (abfd
))
2285 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2286 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2289 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2290 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2294 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2295 unsigned long value
, bfd_byte
*addr
)
2297 bfd_put_32 (output_bfd
, value
, addr
);
2301 /* The number of PLT entries which can use a shorter PLT, if any.
2302 Currently always 64K, since only SH-2A FDPIC uses this; a
2303 20-bit movi20 can address that many function descriptors below
2304 _GLOBAL_OFFSET_TABLE_. */
2305 #define MAX_SHORT_PLT 65536
2307 /* Return the index of the PLT entry at byte offset OFFSET. */
2310 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2312 bfd_vma plt_index
= 0;
2314 offset
-= info
->plt0_entry_size
;
2315 if (info
->short_plt
!= NULL
)
2317 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2319 plt_index
= MAX_SHORT_PLT
;
2320 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2323 info
= info
->short_plt
;
2325 return plt_index
+ offset
/ info
->symbol_entry_size
;
2328 /* Do the inverse operation. */
2331 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2335 if (info
->short_plt
!= NULL
)
2337 if (plt_index
> MAX_SHORT_PLT
)
2339 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2340 plt_index
-= MAX_SHORT_PLT
;
2343 info
= info
->short_plt
;
2345 return (offset
+ info
->plt0_entry_size
2346 + (plt_index
* info
->symbol_entry_size
));
2349 /* The sh linker needs to keep track of the number of relocs that it
2350 decides to copy as dynamic relocs in check_relocs for each symbol.
2351 This is so that it can later discard them if they are found to be
2352 unnecessary. We store the information in a field extending the
2353 regular ELF linker hash table. */
2355 struct elf_sh_dyn_relocs
2357 struct elf_sh_dyn_relocs
*next
;
2359 /* The input section of the reloc. */
2362 /* Total number of relocs copied for the input section. */
2363 bfd_size_type count
;
2365 /* Number of pc-relative relocs copied for the input section. */
2366 bfd_size_type pc_count
;
2371 bfd_signed_vma refcount
;
2375 /* sh ELF linker hash entry. */
2377 struct elf_sh_link_hash_entry
2379 struct elf_link_hash_entry root
;
2381 #ifdef INCLUDE_SHMEDIA
2384 bfd_signed_vma refcount
;
2389 /* Track dynamic relocs copied for this symbol. */
2390 struct elf_sh_dyn_relocs
*dyn_relocs
;
2392 bfd_signed_vma gotplt_refcount
;
2394 /* A local function descriptor, for FDPIC. The refcount counts
2395 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2396 relocations; the PLT and GOT entry are accounted
2397 for separately. After adjust_dynamic_symbol, the offset is
2398 MINUS_ONE if there is no local descriptor (dynamic linker
2399 managed and no PLT entry, or undefined weak non-dynamic).
2400 During check_relocs we do not yet know whether the local
2401 descriptor will be canonical. */
2402 union gotref funcdesc
;
2404 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2405 and thus require fixups or relocations. */
2406 bfd_signed_vma abs_funcdesc_refcount
;
2409 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2413 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2415 struct sh_elf_obj_tdata
2417 struct elf_obj_tdata root
;
2419 /* got_type for each local got entry. */
2420 char *local_got_type
;
2422 /* Function descriptor refcount and offset for each local symbol. */
2423 union gotref
*local_funcdesc
;
2426 #define sh_elf_tdata(abfd) \
2427 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2429 #define sh_elf_local_got_type(abfd) \
2430 (sh_elf_tdata (abfd)->local_got_type)
2432 #define sh_elf_local_funcdesc(abfd) \
2433 (sh_elf_tdata (abfd)->local_funcdesc)
2435 #define is_sh_elf(bfd) \
2436 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2437 && elf_tdata (bfd) != NULL \
2438 && elf_object_id (bfd) == SH_ELF_DATA)
2440 /* Override the generic function because we need to store sh_elf_obj_tdata
2441 as the specific tdata. */
2444 sh_elf_mkobject (bfd
*abfd
)
2446 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2450 /* sh ELF linker hash table. */
2452 struct elf_sh_link_hash_table
2454 struct elf_link_hash_table root
;
2456 /* Short-cuts to get to dynamic linker sections. */
2464 asection
*sfuncdesc
;
2465 asection
*srelfuncdesc
;
2468 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2471 /* Small local sym cache. */
2472 struct sym_cache sym_cache
;
2474 /* A counter or offset to track a TLS got entry. */
2477 bfd_signed_vma refcount
;
2481 /* The type of PLT to use. */
2482 const struct elf_sh_plt_info
*plt_info
;
2484 /* True if the target system is VxWorks. */
2485 bfd_boolean vxworks_p
;
2487 /* True if the target system uses FDPIC. */
2488 bfd_boolean fdpic_p
;
2491 /* Traverse an sh ELF linker hash table. */
2493 #define sh_elf_link_hash_traverse(table, func, info) \
2494 (elf_link_hash_traverse \
2496 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2499 /* Get the sh ELF linker hash table from a link_info structure. */
2501 #define sh_elf_hash_table(p) \
2502 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2503 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2505 /* Create an entry in an sh ELF linker hash table. */
2507 static struct bfd_hash_entry
*
2508 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2509 struct bfd_hash_table
*table
,
2512 struct elf_sh_link_hash_entry
*ret
=
2513 (struct elf_sh_link_hash_entry
*) entry
;
2515 /* Allocate the structure if it has not already been allocated by a
2517 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2518 ret
= ((struct elf_sh_link_hash_entry
*)
2519 bfd_hash_allocate (table
,
2520 sizeof (struct elf_sh_link_hash_entry
)));
2521 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2522 return (struct bfd_hash_entry
*) ret
;
2524 /* Call the allocation method of the superclass. */
2525 ret
= ((struct elf_sh_link_hash_entry
*)
2526 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2528 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2530 ret
->dyn_relocs
= NULL
;
2531 ret
->gotplt_refcount
= 0;
2532 #ifdef INCLUDE_SHMEDIA
2533 ret
->datalabel_got
.refcount
= ret
->root
.got
.refcount
;
2535 ret
->funcdesc
.refcount
= 0;
2536 ret
->abs_funcdesc_refcount
= 0;
2537 ret
->got_type
= GOT_UNKNOWN
;
2540 return (struct bfd_hash_entry
*) ret
;
2543 /* Create an sh ELF linker hash table. */
2545 static struct bfd_link_hash_table
*
2546 sh_elf_link_hash_table_create (bfd
*abfd
)
2548 struct elf_sh_link_hash_table
*ret
;
2549 bfd_size_type amt
= sizeof (struct elf_sh_link_hash_table
);
2551 ret
= (struct elf_sh_link_hash_table
*) bfd_malloc (amt
);
2552 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2555 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2556 sh_elf_link_hash_newfunc
,
2557 sizeof (struct elf_sh_link_hash_entry
),
2565 ret
->sgotplt
= NULL
;
2566 ret
->srelgot
= NULL
;
2568 ret
->srelplt
= NULL
;
2569 ret
->sdynbss
= NULL
;
2570 ret
->srelbss
= NULL
;
2571 ret
->srelplt2
= NULL
;
2572 ret
->sym_cache
.abfd
= NULL
;
2573 ret
->tls_ldm_got
.refcount
= 0;
2574 ret
->plt_info
= NULL
;
2575 ret
->vxworks_p
= vxworks_object_p (abfd
);
2576 ret
->fdpic_p
= fdpic_object_p (abfd
);
2578 return &ret
->root
.root
;
2582 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2583 struct bfd_link_info
*info
, asection
*p
)
2585 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2587 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2591 /* We need dynamic symbols for every section, since segments can
2592 relocate independently. */
2593 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2597 /* If sh_type is yet undecided, assume it could be
2598 SHT_PROGBITS/SHT_NOBITS. */
2602 /* There shouldn't be section relative relocations
2603 against any other section. */
2609 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2610 shortcuts to them in our hash table. */
2613 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2615 struct elf_sh_link_hash_table
*htab
;
2617 if (! _bfd_elf_create_got_section (dynobj
, info
))
2620 htab
= sh_elf_hash_table (info
);
2624 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
2625 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
2626 htab
->srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
2627 if (! htab
->sgot
|| ! htab
->sgotplt
|| ! htab
->srelgot
)
2630 htab
->sfuncdesc
= bfd_make_section_with_flags (dynobj
, ".got.funcdesc",
2631 (SEC_ALLOC
| SEC_LOAD
2634 | SEC_LINKER_CREATED
));
2635 if (htab
->sfuncdesc
== NULL
2636 || ! bfd_set_section_alignment (dynobj
, htab
->sfuncdesc
, 2))
2639 htab
->srelfuncdesc
= bfd_make_section_with_flags (dynobj
,
2640 ".rela.got.funcdesc",
2641 (SEC_ALLOC
| SEC_LOAD
2644 | SEC_LINKER_CREATED
2646 if (htab
->srelfuncdesc
== NULL
2647 || ! bfd_set_section_alignment (dynobj
, htab
->srelfuncdesc
, 2))
2650 /* Also create .rofixup. */
2651 htab
->srofixup
= bfd_make_section_with_flags (dynobj
, ".rofixup",
2652 (SEC_ALLOC
| SEC_LOAD
2655 | SEC_LINKER_CREATED
2657 if (htab
->srofixup
== NULL
2658 || ! bfd_set_section_alignment (dynobj
, htab
->srofixup
, 2))
2664 /* Create dynamic sections when linking against a dynamic object. */
2667 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2669 struct elf_sh_link_hash_table
*htab
;
2670 flagword flags
, pltflags
;
2672 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2675 switch (bed
->s
->arch_size
)
2686 bfd_set_error (bfd_error_bad_value
);
2690 htab
= sh_elf_hash_table (info
);
2694 if (htab
->root
.dynamic_sections_created
)
2697 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2698 .rel[a].bss sections. */
2700 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2701 | SEC_LINKER_CREATED
);
2704 pltflags
|= SEC_CODE
;
2705 if (bed
->plt_not_loaded
)
2706 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2707 if (bed
->plt_readonly
)
2708 pltflags
|= SEC_READONLY
;
2710 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
2713 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2716 if (bed
->want_plt_sym
)
2718 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2720 struct elf_link_hash_entry
*h
;
2721 struct bfd_link_hash_entry
*bh
= NULL
;
2723 if (! (_bfd_generic_link_add_one_symbol
2724 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2725 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2726 get_elf_backend_data (abfd
)->collect
, &bh
)))
2729 h
= (struct elf_link_hash_entry
*) bh
;
2731 h
->type
= STT_OBJECT
;
2732 htab
->root
.hplt
= h
;
2735 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2739 s
= bfd_make_section_with_flags (abfd
,
2740 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt",
2741 flags
| SEC_READONLY
);
2744 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2747 if (htab
->sgot
== NULL
2748 && !create_got_section (abfd
, info
))
2752 const char *secname
;
2757 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2759 secflags
= bfd_get_section_flags (abfd
, sec
);
2760 if ((secflags
& (SEC_DATA
| SEC_LINKER_CREATED
))
2761 || ((secflags
& SEC_HAS_CONTENTS
) != SEC_HAS_CONTENTS
))
2763 secname
= bfd_get_section_name (abfd
, sec
);
2764 relname
= (char *) bfd_malloc ((bfd_size_type
) strlen (secname
) + 6);
2765 strcpy (relname
, ".rela");
2766 strcat (relname
, secname
);
2767 if (bfd_get_section_by_name (abfd
, secname
))
2769 s
= bfd_make_section_with_flags (abfd
, relname
,
2770 flags
| SEC_READONLY
);
2772 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2777 if (bed
->want_dynbss
)
2779 /* The .dynbss section is a place to put symbols which are defined
2780 by dynamic objects, are referenced by regular objects, and are
2781 not functions. We must allocate space for them in the process
2782 image and use a R_*_COPY reloc to tell the dynamic linker to
2783 initialize them at run time. The linker script puts the .dynbss
2784 section into the .bss section of the final image. */
2785 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
2786 SEC_ALLOC
| SEC_LINKER_CREATED
);
2791 /* The .rel[a].bss section holds copy relocs. This section is not
2792 normally needed. We need to create it here, though, so that the
2793 linker will map it to an output section. We can't just create it
2794 only if we need it, because we will not know whether we need it
2795 until we have seen all the input files, and the first time the
2796 main linker code calls BFD after examining all the input files
2797 (size_dynamic_sections) the input sections have already been
2798 mapped to the output sections. If the section turns out not to
2799 be needed, we can discard it later. We will never need this
2800 section when generating a shared object, since they do not use
2804 s
= bfd_make_section_with_flags (abfd
,
2805 (bed
->default_use_rela_p
2806 ? ".rela.bss" : ".rel.bss"),
2807 flags
| SEC_READONLY
);
2810 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2815 if (htab
->vxworks_p
)
2817 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2824 /* Adjust a symbol defined by a dynamic object and referenced by a
2825 regular object. The current definition is in some section of the
2826 dynamic object, but we're not including those sections. We have to
2827 change the definition to something the rest of the link can
2831 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2832 struct elf_link_hash_entry
*h
)
2834 struct elf_sh_link_hash_table
*htab
;
2835 struct elf_sh_link_hash_entry
*eh
;
2836 struct elf_sh_dyn_relocs
*p
;
2839 htab
= sh_elf_hash_table (info
);
2843 /* Make sure we know what is going on here. */
2844 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2846 || h
->u
.weakdef
!= NULL
2849 && !h
->def_regular
)));
2851 /* If this is a function, put it in the procedure linkage table. We
2852 will fill in the contents of the procedure linkage table later,
2853 when we know the address of the .got section. */
2854 if (h
->type
== STT_FUNC
2857 if (h
->plt
.refcount
<= 0
2858 || SYMBOL_CALLS_LOCAL (info
, h
)
2859 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2860 && h
->root
.type
== bfd_link_hash_undefweak
))
2862 /* This case can occur if we saw a PLT reloc in an input
2863 file, but the symbol was never referred to by a dynamic
2864 object. In such a case, we don't actually need to build
2865 a procedure linkage table, and we can just do a REL32
2867 h
->plt
.offset
= (bfd_vma
) -1;
2874 h
->plt
.offset
= (bfd_vma
) -1;
2876 /* If this is a weak symbol, and there is a real definition, the
2877 processor independent code will have arranged for us to see the
2878 real definition first, and we can just use the same value. */
2879 if (h
->u
.weakdef
!= NULL
)
2881 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2882 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2883 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2884 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2885 if (info
->nocopyreloc
)
2886 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2890 /* This is a reference to a symbol defined by a dynamic object which
2891 is not a function. */
2893 /* If we are creating a shared library, we must presume that the
2894 only references to the symbol are via the global offset table.
2895 For such cases we need not do anything here; the relocations will
2896 be handled correctly by relocate_section. */
2900 /* If there are no references to this symbol that do not use the
2901 GOT, we don't need to generate a copy reloc. */
2902 if (!h
->non_got_ref
)
2905 /* If -z nocopyreloc was given, we won't generate them either. */
2906 if (info
->nocopyreloc
)
2912 eh
= (struct elf_sh_link_hash_entry
*) h
;
2913 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2915 s
= p
->sec
->output_section
;
2916 if (s
!= NULL
&& (s
->flags
& (SEC_READONLY
| SEC_HAS_CONTENTS
)) != 0)
2920 /* If we didn't find any dynamic relocs in sections which needs the
2921 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2931 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
2932 h
->root
.root
.string
);
2936 /* We must allocate the symbol in our .dynbss section, which will
2937 become part of the .bss section of the executable. There will be
2938 an entry for this symbol in the .dynsym section. The dynamic
2939 object will contain position independent code, so all references
2940 from the dynamic object to this symbol will go through the global
2941 offset table. The dynamic linker will use the .dynsym entry to
2942 determine the address it must put in the global offset table, so
2943 both the dynamic object and the regular object will refer to the
2944 same memory location for the variable. */
2947 BFD_ASSERT (s
!= NULL
);
2949 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2950 copy the initial value out of the dynamic object and into the
2951 runtime process image. We need to remember the offset into the
2952 .rela.bss section we are going to use. */
2953 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2957 srel
= htab
->srelbss
;
2958 BFD_ASSERT (srel
!= NULL
);
2959 srel
->size
+= sizeof (Elf32_External_Rela
);
2963 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2966 /* Allocate space in .plt, .got and associated reloc sections for
2970 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2972 struct bfd_link_info
*info
;
2973 struct elf_sh_link_hash_table
*htab
;
2974 struct elf_sh_link_hash_entry
*eh
;
2975 struct elf_sh_dyn_relocs
*p
;
2977 if (h
->root
.type
== bfd_link_hash_indirect
)
2980 if (h
->root
.type
== bfd_link_hash_warning
)
2981 /* When warning symbols are created, they **replace** the "real"
2982 entry in the hash table, thus we never get to see the real
2983 symbol in a hash traversal. So look at it now. */
2984 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2986 info
= (struct bfd_link_info
*) inf
;
2987 htab
= sh_elf_hash_table (info
);
2991 eh
= (struct elf_sh_link_hash_entry
*) h
;
2992 if ((h
->got
.refcount
> 0
2994 && eh
->gotplt_refcount
> 0)
2996 /* The symbol has been forced local, or we have some direct got refs,
2997 so treat all the gotplt refs as got refs. */
2998 h
->got
.refcount
+= eh
->gotplt_refcount
;
2999 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
3000 h
->plt
.refcount
-= eh
->gotplt_refcount
;
3003 if (htab
->root
.dynamic_sections_created
3004 && h
->plt
.refcount
> 0
3005 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3006 || h
->root
.type
!= bfd_link_hash_undefweak
))
3008 /* Make sure this symbol is output as a dynamic symbol.
3009 Undefined weak syms won't yet be marked as dynamic. */
3010 if (h
->dynindx
== -1
3011 && !h
->forced_local
)
3013 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3018 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3020 asection
*s
= htab
->splt
;
3021 const struct elf_sh_plt_info
*plt_info
;
3023 /* If this is the first .plt entry, make room for the special
3026 s
->size
+= htab
->plt_info
->plt0_entry_size
;
3028 h
->plt
.offset
= s
->size
;
3030 /* If this symbol is not defined in a regular file, and we are
3031 not generating a shared library, then set the symbol to this
3032 location in the .plt. This is required to make function
3033 pointers compare as equal between the normal executable and
3034 the shared library. Skip this for FDPIC, since the
3035 function's address will be the address of the canonical
3036 function descriptor. */
3037 if (!htab
->fdpic_p
&& !info
->shared
&& !h
->def_regular
)
3039 h
->root
.u
.def
.section
= s
;
3040 h
->root
.u
.def
.value
= h
->plt
.offset
;
3043 /* Make room for this entry. */
3044 plt_info
= htab
->plt_info
;
3045 if (plt_info
->short_plt
!= NULL
3046 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
3047 plt_info
= plt_info
->short_plt
;
3048 s
->size
+= plt_info
->symbol_entry_size
;
3050 /* We also need to make an entry in the .got.plt section, which
3051 will be placed in the .got section by the linker script. */
3053 htab
->sgotplt
->size
+= 4;
3055 htab
->sgotplt
->size
+= 8;
3057 /* We also need to make an entry in the .rel.plt section. */
3058 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
3060 if (htab
->vxworks_p
&& !info
->shared
)
3062 /* VxWorks executables have a second set of relocations
3063 for each PLT entry. They go in a separate relocation
3064 section, which is processed by the kernel loader. */
3066 /* There is a relocation for the initial PLT entry:
3067 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3068 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
3069 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
3071 /* There are two extra relocations for each subsequent
3072 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3073 and an R_SH_DIR32 relocation for the PLT entry. */
3074 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
3079 h
->plt
.offset
= (bfd_vma
) -1;
3085 h
->plt
.offset
= (bfd_vma
) -1;
3089 if (h
->got
.refcount
> 0)
3093 int got_type
= sh_elf_hash_entry (h
)->got_type
;
3095 /* Make sure this symbol is output as a dynamic symbol.
3096 Undefined weak syms won't yet be marked as dynamic. */
3097 if (h
->dynindx
== -1
3098 && !h
->forced_local
)
3100 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3105 h
->got
.offset
= s
->size
;
3107 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3108 if (got_type
== GOT_TLS_GD
)
3110 dyn
= htab
->root
.dynamic_sections_created
;
3113 /* No dynamic relocations required. */
3114 if (htab
->fdpic_p
&& !info
->shared
3115 && h
->root
.type
!= bfd_link_hash_undefweak
3116 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
3117 htab
->srofixup
->size
+= 4;
3119 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3120 R_SH_TLS_GD needs one if local symbol and two if global. */
3121 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
3122 || got_type
== GOT_TLS_IE
)
3123 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3124 else if (got_type
== GOT_TLS_GD
)
3125 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
3126 else if (got_type
== GOT_FUNCDESC
)
3128 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
3129 htab
->srofixup
->size
+= 4;
3131 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3133 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3134 || h
->root
.type
!= bfd_link_hash_undefweak
)
3136 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3137 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3138 else if (htab
->fdpic_p
&& !info
->shared
&& got_type
== GOT_NORMAL
3139 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3140 || h
->root
.type
!= bfd_link_hash_undefweak
))
3141 htab
->srofixup
->size
+= 4;
3144 h
->got
.offset
= (bfd_vma
) -1;
3146 #ifdef INCLUDE_SHMEDIA
3147 if (eh
->datalabel_got
.refcount
> 0)
3152 /* Make sure this symbol is output as a dynamic symbol.
3153 Undefined weak syms won't yet be marked as dynamic. */
3154 if (h
->dynindx
== -1
3155 && !h
->forced_local
)
3157 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3162 eh
->datalabel_got
.offset
= s
->size
;
3164 dyn
= htab
->root
.dynamic_sections_created
;
3165 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
3166 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3169 eh
->datalabel_got
.offset
= (bfd_vma
) -1;
3172 /* Allocate space for any dynamic relocations to function
3173 descriptors, canonical or otherwise. We need to relocate the
3174 reference unless it resolves to zero, which only happens for
3175 undefined weak symbols (either non-default visibility, or when
3176 static linking). Any GOT slot is accounted for elsewhere. */
3177 if (eh
->abs_funcdesc_refcount
> 0
3178 && (h
->root
.type
!= bfd_link_hash_undefweak
3179 || (htab
->root
.dynamic_sections_created
3180 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
3182 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
3183 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
3186 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
3189 /* We must allocate a function descriptor if there are references to
3190 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3191 the dynamic linker isn't going to allocate it. None of this
3192 applies if we already created one in .got.plt, but if the
3193 canonical function descriptor can be in this object, there
3194 won't be a PLT entry at all. */
3195 if ((eh
->funcdesc
.refcount
> 0
3196 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
3197 && h
->root
.type
!= bfd_link_hash_undefweak
3198 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
3200 /* Make room for this function descriptor. */
3201 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
3202 htab
->sfuncdesc
->size
+= 8;
3204 /* We will need a relocation or two fixups to initialize the
3205 function descriptor, so allocate those too. */
3206 if (!info
->shared
&& SYMBOL_CALLS_LOCAL (info
, h
))
3207 htab
->srofixup
->size
+= 8;
3209 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3212 if (eh
->dyn_relocs
== NULL
)
3215 /* In the shared -Bsymbolic case, discard space allocated for
3216 dynamic pc-relative relocs against symbols which turn out to be
3217 defined in regular objects. For the normal shared case, discard
3218 space for pc-relative relocs that have become local due to symbol
3219 visibility changes. */
3223 if (SYMBOL_CALLS_LOCAL (info
, h
))
3225 struct elf_sh_dyn_relocs
**pp
;
3227 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3229 p
->count
-= p
->pc_count
;
3238 if (htab
->vxworks_p
)
3240 struct elf_sh_dyn_relocs
**pp
;
3242 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3244 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
3251 /* Also discard relocs on undefined weak syms with non-default
3253 if (eh
->dyn_relocs
!= NULL
3254 && h
->root
.type
== bfd_link_hash_undefweak
)
3256 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
3257 eh
->dyn_relocs
= NULL
;
3259 /* Make sure undefined weak symbols are output as a dynamic
3261 else if (h
->dynindx
== -1
3262 && !h
->forced_local
)
3264 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3271 /* For the non-shared case, discard space for relocs against
3272 symbols which turn out to need copy relocs or are not
3278 || (htab
->root
.dynamic_sections_created
3279 && (h
->root
.type
== bfd_link_hash_undefweak
3280 || h
->root
.type
== bfd_link_hash_undefined
))))
3282 /* Make sure this symbol is output as a dynamic symbol.
3283 Undefined weak syms won't yet be marked as dynamic. */
3284 if (h
->dynindx
== -1
3285 && !h
->forced_local
)
3287 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3291 /* If that succeeded, we know we'll be keeping all the
3293 if (h
->dynindx
!= -1)
3297 eh
->dyn_relocs
= NULL
;
3302 /* Finally, allocate space. */
3303 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3305 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
3306 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3308 /* If we need relocations, we do not need fixups. */
3309 if (htab
->fdpic_p
&& !info
->shared
)
3310 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3316 /* Find any dynamic relocs that apply to read-only sections. */
3319 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3321 struct elf_sh_link_hash_entry
*eh
;
3322 struct elf_sh_dyn_relocs
*p
;
3324 if (h
->root
.type
== bfd_link_hash_warning
)
3325 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3327 eh
= (struct elf_sh_link_hash_entry
*) h
;
3328 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3330 asection
*s
= p
->sec
->output_section
;
3332 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3334 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3336 info
->flags
|= DF_TEXTREL
;
3338 /* Not an error, just cut short the traversal. */
3345 /* This function is called after all the input files have been read,
3346 and the input sections have been assigned to output sections.
3347 It's a convenient place to determine the PLT style. */
3350 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3352 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
, info
->shared
);
3354 if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->relocatable
)
3356 struct elf_link_hash_entry
*h
;
3358 /* Force a PT_GNU_STACK segment to be created. */
3359 if (! elf_tdata (output_bfd
)->stack_flags
)
3360 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
3362 /* Define __stacksize if it's not defined yet. */
3363 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
3364 FALSE
, FALSE
, FALSE
);
3365 if (! h
|| h
->root
.type
!= bfd_link_hash_defined
3366 || h
->type
!= STT_OBJECT
3369 struct bfd_link_hash_entry
*bh
= NULL
;
3371 if (!(_bfd_generic_link_add_one_symbol
3372 (info
, output_bfd
, "__stacksize",
3373 BSF_GLOBAL
, bfd_abs_section_ptr
, DEFAULT_STACK_SIZE
,
3374 (const char *) NULL
, FALSE
,
3375 get_elf_backend_data (output_bfd
)->collect
, &bh
)))
3378 h
= (struct elf_link_hash_entry
*) bh
;
3380 h
->type
= STT_OBJECT
;
3386 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
3389 sh_elf_modify_program_headers (bfd
*output_bfd
, struct bfd_link_info
*info
)
3391 struct elf_obj_tdata
*tdata
= elf_tdata (output_bfd
);
3392 struct elf_segment_map
*m
;
3393 Elf_Internal_Phdr
*p
;
3395 /* objcopy and strip preserve what's already there using
3396 sh_elf_copy_private_bfd_data (). */
3400 for (p
= tdata
->phdr
, m
= tdata
->segment_map
; m
!= NULL
; m
= m
->next
, p
++)
3401 if (m
->p_type
== PT_GNU_STACK
)
3406 struct elf_link_hash_entry
*h
;
3408 /* Obtain the pointer to the __stacksize symbol. */
3409 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
3410 FALSE
, FALSE
, FALSE
);
3413 while (h
->root
.type
== bfd_link_hash_indirect
3414 || h
->root
.type
== bfd_link_hash_warning
)
3415 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3416 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
3419 /* Set the header p_memsz from the symbol value. We
3420 intentionally ignore the symbol section. */
3421 if (h
&& h
->root
.type
== bfd_link_hash_defined
)
3422 p
->p_memsz
= h
->root
.u
.def
.value
;
3424 p
->p_memsz
= DEFAULT_STACK_SIZE
;
3434 /* Set the sizes of the dynamic sections. */
3437 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3438 struct bfd_link_info
*info
)
3440 struct elf_sh_link_hash_table
*htab
;
3446 htab
= sh_elf_hash_table (info
);
3450 dynobj
= htab
->root
.dynobj
;
3451 BFD_ASSERT (dynobj
!= NULL
);
3453 if (htab
->root
.dynamic_sections_created
)
3455 /* Set the contents of the .interp section to the interpreter. */
3456 if (info
->executable
)
3458 s
= bfd_get_section_by_name (dynobj
, ".interp");
3459 BFD_ASSERT (s
!= NULL
);
3460 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3461 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3465 /* Set up .got offsets for local syms, and space for local dynamic
3467 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3469 bfd_signed_vma
*local_got
;
3470 bfd_signed_vma
*end_local_got
;
3471 union gotref
*local_funcdesc
, *end_local_funcdesc
;
3472 char *local_got_type
;
3473 bfd_size_type locsymcount
;
3474 Elf_Internal_Shdr
*symtab_hdr
;
3477 if (! is_sh_elf (ibfd
))
3480 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3482 struct elf_sh_dyn_relocs
*p
;
3484 for (p
= ((struct elf_sh_dyn_relocs
*)
3485 elf_section_data (s
)->local_dynrel
);
3489 if (! bfd_is_abs_section (p
->sec
)
3490 && bfd_is_abs_section (p
->sec
->output_section
))
3492 /* Input section has been discarded, either because
3493 it is a copy of a linkonce section or due to
3494 linker script /DISCARD/, so we'll be discarding
3497 else if (htab
->vxworks_p
3498 && strcmp (p
->sec
->output_section
->name
,
3501 /* Relocations in vxworks .tls_vars sections are
3502 handled specially by the loader. */
3504 else if (p
->count
!= 0)
3506 srel
= elf_section_data (p
->sec
)->sreloc
;
3507 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3508 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3509 info
->flags
|= DF_TEXTREL
;
3511 /* If we need relocations, we do not need fixups. */
3512 if (htab
->fdpic_p
&& !info
->shared
)
3513 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3518 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3519 locsymcount
= symtab_hdr
->sh_info
;
3520 #ifdef INCLUDE_SHMEDIA
3521 /* Count datalabel local GOT. */
3525 srel
= htab
->srelgot
;
3527 local_got
= elf_local_got_refcounts (ibfd
);
3530 end_local_got
= local_got
+ locsymcount
;
3531 local_got_type
= sh_elf_local_got_type (ibfd
);
3532 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3533 for (; local_got
< end_local_got
; ++local_got
)
3537 *local_got
= s
->size
;
3539 if (*local_got_type
== GOT_TLS_GD
)
3542 srel
->size
+= sizeof (Elf32_External_Rela
);
3544 htab
->srofixup
->size
+= 4;
3546 if (*local_got_type
== GOT_FUNCDESC
)
3548 if (local_funcdesc
== NULL
)
3552 size
= locsymcount
* sizeof (union gotref
);
3553 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3555 if (local_funcdesc
== NULL
)
3557 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3558 local_funcdesc
+= (local_got
3559 - elf_local_got_refcounts (ibfd
));
3561 local_funcdesc
->refcount
++;
3566 *local_got
= (bfd_vma
) -1;
3571 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3574 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3576 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3578 if (local_funcdesc
->refcount
> 0)
3580 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3581 htab
->sfuncdesc
->size
+= 8;
3583 htab
->srofixup
->size
+= 8;
3585 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3588 local_funcdesc
->offset
= MINUS_ONE
;
3594 if (htab
->tls_ldm_got
.refcount
> 0)
3596 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3598 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
3599 htab
->sgot
->size
+= 8;
3600 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3603 htab
->tls_ldm_got
.offset
= -1;
3605 /* Only the reserved entries should be present. For FDPIC, they go at
3606 the end of .got.plt. */
3609 BFD_ASSERT (htab
->sgotplt
&& htab
->sgotplt
->size
== 12);
3610 htab
->sgotplt
->size
= 0;
3613 /* Allocate global sym .plt and .got entries, and space for global
3614 sym dynamic relocs. */
3615 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3617 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3618 end of the FDPIC .got.plt. */
3621 htab
->root
.hgot
->root
.u
.def
.value
= htab
->sgotplt
->size
;
3622 htab
->sgotplt
->size
+= 12;
3625 /* At the very end of the .rofixup section is a pointer to the GOT. */
3626 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3627 htab
->srofixup
->size
+= 4;
3629 /* We now have determined the sizes of the various dynamic sections.
3630 Allocate memory for them. */
3632 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3634 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3639 || s
== htab
->sgotplt
3640 || s
== htab
->sfuncdesc
3641 || s
== htab
->srofixup
3642 || s
== htab
->sdynbss
)
3644 /* Strip this section if we don't need it; see the
3647 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3649 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
3652 /* We use the reloc_count field as a counter if we need
3653 to copy relocs into the output file. */
3658 /* It's not one of our sections, so don't allocate space. */
3664 /* If we don't need this section, strip it from the
3665 output file. This is mostly to handle .rela.bss and
3666 .rela.plt. We must create both sections in
3667 create_dynamic_sections, because they must be created
3668 before the linker maps input sections to output
3669 sections. The linker does that before
3670 adjust_dynamic_symbol is called, and it is that
3671 function which decides whether anything needs to go
3672 into these sections. */
3674 s
->flags
|= SEC_EXCLUDE
;
3678 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3681 /* Allocate memory for the section contents. We use bfd_zalloc
3682 here in case unused entries are not reclaimed before the
3683 section's contents are written out. This should not happen,
3684 but this way if it does, we get a R_SH_NONE reloc instead
3686 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3687 if (s
->contents
== NULL
)
3691 if (htab
->root
.dynamic_sections_created
)
3693 /* Add some entries to the .dynamic section. We fill in the
3694 values later, in sh_elf_finish_dynamic_sections, but we
3695 must add the entries now so that we get the correct size for
3696 the .dynamic section. The DT_DEBUG entry is filled in by the
3697 dynamic linker and used by the debugger. */
3698 #define add_dynamic_entry(TAG, VAL) \
3699 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3701 if (info
->executable
)
3703 if (! add_dynamic_entry (DT_DEBUG
, 0))
3707 if (htab
->splt
->size
!= 0)
3709 if (! add_dynamic_entry (DT_PLTGOT
, 0)
3710 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
3711 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3712 || ! add_dynamic_entry (DT_JMPREL
, 0))
3715 else if ((elf_elfheader (output_bfd
)->e_flags
& EF_SH_FDPIC
)
3716 && htab
->sgot
->size
!= 0)
3718 if (! add_dynamic_entry (DT_PLTGOT
, 0))
3724 if (! add_dynamic_entry (DT_RELA
, 0)
3725 || ! add_dynamic_entry (DT_RELASZ
, 0)
3726 || ! add_dynamic_entry (DT_RELAENT
,
3727 sizeof (Elf32_External_Rela
)))
3730 /* If any dynamic relocs apply to a read-only section,
3731 then we need a DT_TEXTREL entry. */
3732 if ((info
->flags
& DF_TEXTREL
) == 0)
3733 elf_link_hash_traverse (&htab
->root
, readonly_dynrelocs
, info
);
3735 if ((info
->flags
& DF_TEXTREL
) != 0)
3737 if (! add_dynamic_entry (DT_TEXTREL
, 0))
3742 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3745 #undef add_dynamic_entry
3750 /* Add a dynamic relocation to the SRELOC section. */
3752 inline static bfd_vma
3753 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3754 int reloc_type
, long dynindx
, bfd_vma addend
)
3756 Elf_Internal_Rela outrel
;
3757 bfd_vma reloc_offset
;
3759 outrel
.r_offset
= offset
;
3760 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3761 outrel
.r_addend
= addend
;
3763 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3764 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3765 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3766 sreloc
->contents
+ reloc_offset
);
3767 sreloc
->reloc_count
++;
3769 return reloc_offset
;
3772 /* Add an FDPIC read-only fixup. */
3775 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3777 bfd_vma fixup_offset
;
3779 fixup_offset
= srofixup
->reloc_count
++ * 4;
3780 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3781 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3784 /* Return the offset of the generated .got section from the
3785 _GLOBAL_OFFSET_TABLE_ symbol. */
3787 static bfd_signed_vma
3788 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3790 return (htab
->sgot
->output_offset
- htab
->sgotplt
->output_offset
3791 - htab
->root
.hgot
->root
.u
.def
.value
);
3794 /* Find the segment number in which OSEC, and output section, is
3798 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3800 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
,
3803 /* FIXME: Nothing ever says what this index is relative to. The kernel
3804 supplies data in terms of the number of load segments but this is
3805 a phdr index and the first phdr may not be a load segment. */
3806 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3810 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3812 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3814 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
3817 /* Generate the initial contents of a local function descriptor, along
3818 with any relocations or fixups required. */
3820 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3821 struct bfd_link_info
*info
,
3822 struct elf_link_hash_entry
*h
,
3827 struct elf_sh_link_hash_table
*htab
;
3831 htab
= sh_elf_hash_table (info
);
3833 /* FIXME: The ABI says that the offset to the function goes in the
3834 descriptor, along with the segment index. We're RELA, so it could
3835 go in the reloc instead... */
3837 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3839 section
= h
->root
.u
.def
.section
;
3840 value
= h
->root
.u
.def
.value
;
3843 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3845 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3846 addr
= value
+ section
->output_offset
;
3847 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3851 BFD_ASSERT (h
->dynindx
!= -1);
3852 dynindx
= h
->dynindx
;
3856 if (!info
->shared
&& SYMBOL_CALLS_LOCAL (info
, h
))
3858 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3860 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3862 + htab
->sfuncdesc
->output_section
->vma
3863 + htab
->sfuncdesc
->output_offset
);
3864 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3866 + htab
->sfuncdesc
->output_section
->vma
3867 + htab
->sfuncdesc
->output_offset
);
3870 /* There are no dynamic relocations so fill in the final
3871 address and gp value (barring fixups). */
3872 addr
+= section
->output_section
->vma
;
3873 seg
= htab
->root
.hgot
->root
.u
.def
.value
3874 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3875 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3878 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3880 + htab
->sfuncdesc
->output_section
->vma
3881 + htab
->sfuncdesc
->output_offset
,
3882 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3884 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3885 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3890 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3891 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3894 static bfd_reloc_status_type
3895 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3896 bfd
*input_bfd
, asection
*input_section
,
3897 bfd_byte
*contents
, bfd_vma offset
)
3899 unsigned long cur_val
;
3901 bfd_reloc_status_type r
;
3903 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3904 return bfd_reloc_outofrange
;
3906 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3907 bfd_arch_bits_per_address (input_bfd
), relocation
);
3908 if (r
!= bfd_reloc_ok
)
3911 addr
= contents
+ offset
;
3912 cur_val
= bfd_get_16 (output_bfd
, addr
);
3913 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3914 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3916 return bfd_reloc_ok
;
3919 /* Relocate an SH ELF section. */
3922 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3923 bfd
*input_bfd
, asection
*input_section
,
3924 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3925 Elf_Internal_Sym
*local_syms
,
3926 asection
**local_sections
)
3928 struct elf_sh_link_hash_table
*htab
;
3929 Elf_Internal_Shdr
*symtab_hdr
;
3930 struct elf_link_hash_entry
**sym_hashes
;
3931 Elf_Internal_Rela
*rel
, *relend
;
3933 bfd_vma
*local_got_offsets
;
3934 asection
*sgot
= NULL
;
3935 asection
*sgotplt
= NULL
;
3936 asection
*splt
= NULL
;
3937 asection
*sreloc
= NULL
;
3938 asection
*srelgot
= NULL
;
3939 bfd_boolean is_vxworks_tls
;
3940 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3941 bfd_boolean fdpic_p
= FALSE
;
3943 BFD_ASSERT (is_sh_elf (input_bfd
));
3945 htab
= sh_elf_hash_table (info
);
3948 dynobj
= htab
->root
.dynobj
;
3950 sgotplt
= htab
->sgotplt
;
3952 fdpic_p
= htab
->fdpic_p
;
3954 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3955 sym_hashes
= elf_sym_hashes (input_bfd
);
3956 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3958 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3959 input_section
->output_section
);
3960 if (fdpic_p
&& sgot
)
3961 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3962 sgot
->output_section
);
3965 if (fdpic_p
&& splt
)
3966 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3967 splt
->output_section
);
3971 /* We have to handle relocations in vxworks .tls_vars sections
3972 specially, because the dynamic loader is 'weird'. */
3973 is_vxworks_tls
= (htab
&& htab
->vxworks_p
&& info
->shared
3974 && !strcmp (input_section
->output_section
->name
,
3978 relend
= relocs
+ input_section
->reloc_count
;
3979 for (; rel
< relend
; rel
++)
3982 reloc_howto_type
*howto
;
3983 unsigned long r_symndx
;
3984 Elf_Internal_Sym
*sym
;
3986 struct elf_link_hash_entry
*h
;
3988 bfd_vma addend
= (bfd_vma
) 0;
3989 bfd_reloc_status_type r
;
3990 int seen_stt_datalabel
= 0;
3993 const char *symname
= NULL
;
3995 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3997 r_type
= ELF32_R_TYPE (rel
->r_info
);
3999 /* Many of the relocs are only used for relaxing, and are
4000 handled entirely by the relaxation code. */
4001 if (r_type
>= (int) R_SH_GNU_VTINHERIT
4002 && r_type
<= (int) R_SH_LABEL
)
4004 if (r_type
== (int) R_SH_NONE
)
4008 || r_type
>= R_SH_max
4009 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
4010 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
4011 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
4012 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
4013 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
4014 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
4015 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
4016 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
4017 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
4018 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
4019 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
4020 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
4022 bfd_set_error (bfd_error_bad_value
);
4026 howto
= get_howto_table (output_bfd
) + r_type
;
4028 /* For relocs that aren't partial_inplace, we get the addend from
4030 if (! howto
->partial_inplace
)
4031 addend
= rel
->r_addend
;
4036 check_segment
[0] = -1;
4037 check_segment
[1] = -1;
4038 if (r_symndx
< symtab_hdr
->sh_info
)
4040 sym
= local_syms
+ r_symndx
;
4041 sec
= local_sections
[r_symndx
];
4043 symname
= bfd_elf_string_from_elf_section
4044 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
4045 if (symname
== NULL
|| *symname
== '\0')
4046 symname
= bfd_section_name (input_bfd
, sec
);
4048 relocation
= (sec
->output_section
->vma
4049 + sec
->output_offset
4051 /* A local symbol never has STO_SH5_ISA32, so we don't need
4052 datalabel processing here. Make sure this does not change
4054 if ((sym
->st_other
& STO_SH5_ISA32
) != 0)
4055 ((*info
->callbacks
->reloc_dangerous
)
4057 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4058 input_bfd
, input_section
, rel
->r_offset
));
4060 if (sec
!= NULL
&& elf_discarded_section (sec
))
4061 /* Handled below. */
4063 else if (info
->relocatable
)
4065 /* This is a relocatable link. We don't have to change
4066 anything, unless the reloc is against a section symbol,
4067 in which case we have to adjust according to where the
4068 section symbol winds up in the output section. */
4069 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4071 if (! howto
->partial_inplace
)
4073 /* For relocations with the addend in the
4074 relocation, we need just to update the addend.
4075 All real relocs are of type partial_inplace; this
4076 code is mostly for completeness. */
4077 rel
->r_addend
+= sec
->output_offset
;
4082 /* Relocs of type partial_inplace need to pick up the
4083 contents in the contents and add the offset resulting
4084 from the changed location of the section symbol.
4085 Using _bfd_final_link_relocate (e.g. goto
4086 final_link_relocate) here would be wrong, because
4087 relocations marked pc_relative would get the current
4088 location subtracted, and we must only do that at the
4090 r
= _bfd_relocate_contents (howto
, input_bfd
,
4093 contents
+ rel
->r_offset
);
4094 goto relocation_done
;
4099 else if (! howto
->partial_inplace
)
4101 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
4102 addend
= rel
->r_addend
;
4104 else if ((sec
->flags
& SEC_MERGE
)
4105 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4109 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
4111 (*_bfd_error_handler
)
4112 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4113 input_bfd
, input_section
,
4114 (long) rel
->r_offset
, howto
->name
);
4118 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4121 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
4123 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
4124 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
4130 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4133 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4134 symname
= h
->root
.root
.string
;
4135 while (h
->root
.type
== bfd_link_hash_indirect
4136 || h
->root
.type
== bfd_link_hash_warning
)
4138 #ifdef INCLUDE_SHMEDIA
4139 /* If the reference passes a symbol marked with
4140 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4142 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
4144 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4146 if (h
->root
.type
== bfd_link_hash_defined
4147 || h
->root
.type
== bfd_link_hash_defweak
)
4151 dyn
= htab
? htab
->root
.dynamic_sections_created
: FALSE
;
4152 sec
= h
->root
.u
.def
.section
;
4153 /* In these cases, we don't need the relocation value.
4154 We check specially because in some obscure cases
4155 sec->output_section will be NULL. */
4156 if (r_type
== R_SH_GOTPC
4157 || r_type
== R_SH_GOTPC_LOW16
4158 || r_type
== R_SH_GOTPC_MEDLOW16
4159 || r_type
== R_SH_GOTPC_MEDHI16
4160 || r_type
== R_SH_GOTPC_HI16
4161 || ((r_type
== R_SH_PLT32
4162 || r_type
== R_SH_PLT_LOW16
4163 || r_type
== R_SH_PLT_MEDLOW16
4164 || r_type
== R_SH_PLT_MEDHI16
4165 || r_type
== R_SH_PLT_HI16
)
4166 && h
->plt
.offset
!= (bfd_vma
) -1)
4167 || ((r_type
== R_SH_GOT32
4168 || r_type
== R_SH_GOT20
4169 || r_type
== R_SH_GOTFUNCDESC
4170 || r_type
== R_SH_GOTFUNCDESC20
4171 || r_type
== R_SH_GOTOFFFUNCDESC
4172 || r_type
== R_SH_GOTOFFFUNCDESC20
4173 || r_type
== R_SH_FUNCDESC
4174 || r_type
== R_SH_GOT_LOW16
4175 || r_type
== R_SH_GOT_MEDLOW16
4176 || r_type
== R_SH_GOT_MEDHI16
4177 || r_type
== R_SH_GOT_HI16
)
4178 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
4180 || (! info
->symbolic
&& h
->dynindx
!= -1)
4181 || !h
->def_regular
))
4182 /* The cases above are those in which relocation is
4183 overwritten in the switch block below. The cases
4184 below are those in which we must defer relocation
4185 to run-time, because we can't resolve absolute
4186 addresses when creating a shared library. */
4188 && ((! info
->symbolic
&& h
->dynindx
!= -1)
4190 && ((r_type
== R_SH_DIR32
4191 && !h
->forced_local
)
4192 || (r_type
== R_SH_REL32
4193 && !SYMBOL_CALLS_LOCAL (info
, h
)))
4194 && ((input_section
->flags
& SEC_ALLOC
) != 0
4195 /* DWARF will emit R_SH_DIR32 relocations in its
4196 sections against symbols defined externally
4197 in shared libraries. We can't do anything
4199 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
4200 && h
->def_dynamic
)))
4201 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4202 sections because such sections are not SEC_ALLOC and
4203 thus ld.so will not process them. */
4204 || (sec
->output_section
== NULL
4205 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
4207 || (sec
->output_section
== NULL
4208 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
4209 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
4211 else if (sec
->output_section
!= NULL
)
4212 relocation
= ((h
->root
.u
.def
.value
4213 + sec
->output_section
->vma
4214 + sec
->output_offset
)
4215 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4216 symbol value, unless we've seen
4217 STT_DATALABEL on the way to it. */
4218 | ((h
->other
& STO_SH5_ISA32
) != 0
4219 && ! seen_stt_datalabel
));
4220 else if (!info
->relocatable
)
4222 (*_bfd_error_handler
)
4223 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4226 (long) rel
->r_offset
,
4228 h
->root
.root
.string
);
4232 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4234 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4235 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
4237 else if (!info
->relocatable
)
4239 if (! info
->callbacks
->undefined_symbol
4240 (info
, h
->root
.root
.string
, input_bfd
,
4241 input_section
, rel
->r_offset
,
4242 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
4243 || ELF_ST_VISIBILITY (h
->other
))))
4248 if (sec
!= NULL
&& elf_discarded_section (sec
))
4250 /* For relocs against symbols from removed linkonce sections,
4251 or sections discarded by a linker script, we just want the
4252 section contents zeroed. Avoid any special processing. */
4253 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
4259 if (info
->relocatable
)
4262 /* Check for inter-segment relocations in FDPIC files. Most
4263 relocations connect the relocation site to the location of
4264 the target symbol, but there are some exceptions below. */
4265 check_segment
[0] = isec_segment
;
4267 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
4268 sec
->output_section
);
4270 check_segment
[1] = -1;
4272 switch ((int) r_type
)
4274 final_link_relocate
:
4275 /* COFF relocs don't use the addend. The addend is used for
4276 R_SH_DIR32 to be compatible with other compilers. */
4277 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4278 contents
, rel
->r_offset
,
4279 relocation
, addend
);
4283 goto final_link_relocate
;
4288 /* If the reloc is against the start of this section, then
4289 the assembler has already taken care of it and the reloc
4290 is here only to assist in relaxing. If the reloc is not
4291 against the start of this section, then it's against an
4292 external symbol and we must deal with it ourselves. */
4293 if (input_section
->output_section
->vma
+ input_section
->output_offset
4296 int disp
= (relocation
4297 - input_section
->output_section
->vma
4298 - input_section
->output_offset
4304 case R_SH_DIR8WPZ
: mask
= 1; break;
4305 case R_SH_DIR8WPL
: mask
= 3; break;
4306 default: mask
= 0; break;
4310 ((*_bfd_error_handler
)
4311 (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4312 input_section
->owner
,
4313 (unsigned long) rel
->r_offset
));
4314 bfd_set_error (bfd_error_bad_value
);
4318 goto final_link_relocate
;
4324 #ifdef INCLUDE_SHMEDIA
4325 if (shmedia_prepare_reloc (info
, input_bfd
, input_section
,
4326 contents
, rel
, &relocation
))
4327 goto final_link_relocate
;
4329 bfd_set_error (bfd_error_bad_value
);
4337 goto final_link_relocate
;
4343 ((*_bfd_error_handler
)
4344 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4345 input_section
->owner
,
4346 (unsigned long) rel
->r_offset
, howto
->name
,
4347 (unsigned long) relocation
));
4348 bfd_set_error (bfd_error_bad_value
);
4351 goto final_link_relocate
;
4358 ((*_bfd_error_handler
)
4359 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4360 input_section
->owner
,
4361 (unsigned long) rel
->r_offset
, howto
->name
,
4362 (unsigned long) relocation
));
4363 bfd_set_error (bfd_error_bad_value
);
4366 goto final_link_relocate
;
4369 if ((signed int)relocation
< -32
4370 || (signed int)relocation
> 32)
4372 ((*_bfd_error_handler
)
4373 (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
4374 input_section
->owner
,
4375 (unsigned long) rel
->r_offset
,
4376 (unsigned long) relocation
));
4377 bfd_set_error (bfd_error_bad_value
);
4380 goto final_link_relocate
;
4383 if ((signed int)relocation
< -16
4384 || (signed int)relocation
> 16)
4386 ((*_bfd_error_handler
)
4387 (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
4388 input_section
->owner
,
4389 (unsigned long) rel
->r_offset
,
4390 (unsigned long) relocation
));
4391 bfd_set_error (bfd_error_bad_value
);
4394 goto final_link_relocate
;
4398 #ifdef INCLUDE_SHMEDIA
4399 case R_SH_IMM_LOW16_PCREL
:
4400 case R_SH_IMM_MEDLOW16_PCREL
:
4401 case R_SH_IMM_MEDHI16_PCREL
:
4402 case R_SH_IMM_HI16_PCREL
:
4406 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4407 || h
->root
.type
!= bfd_link_hash_undefweak
)
4409 && (input_section
->flags
& SEC_ALLOC
) != 0
4411 && (r_type
== R_SH_DIR32
4412 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4414 Elf_Internal_Rela outrel
;
4416 bfd_boolean skip
, relocate
;
4418 /* When generating a shared object, these relocations
4419 are copied into the output file to be resolved at run
4424 sreloc
= _bfd_elf_get_dynamic_reloc_section
4425 (input_bfd
, input_section
, /*rela?*/ TRUE
);
4434 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4436 if (outrel
.r_offset
== (bfd_vma
) -1)
4438 else if (outrel
.r_offset
== (bfd_vma
) -2)
4439 skip
= TRUE
, relocate
= TRUE
;
4440 outrel
.r_offset
+= (input_section
->output_section
->vma
4441 + input_section
->output_offset
);
4444 memset (&outrel
, 0, sizeof outrel
);
4445 else if (r_type
== R_SH_REL32
)
4447 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
4448 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
4450 = (howto
->partial_inplace
4451 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4454 #ifdef INCLUDE_SHMEDIA
4455 else if (r_type
== R_SH_IMM_LOW16_PCREL
4456 || r_type
== R_SH_IMM_MEDLOW16_PCREL
4457 || r_type
== R_SH_IMM_MEDHI16_PCREL
4458 || r_type
== R_SH_IMM_HI16_PCREL
)
4460 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
4461 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4462 outrel
.r_addend
= addend
;
4467 || ((info
->symbolic
|| h
->dynindx
== -1)
4468 && h
->def_regular
)))
4472 BFD_ASSERT (sec
!= NULL
);
4473 BFD_ASSERT (sec
->output_section
!= NULL
);
4474 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
4475 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4476 outrel
.r_addend
= relocation
;
4478 += (howto
->partial_inplace
4479 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4481 outrel
.r_addend
-= sec
->output_section
->vma
;
4485 /* h->dynindx may be -1 if this symbol was marked to
4488 || ((info
->symbolic
|| h
->dynindx
== -1)
4491 relocate
= howto
->partial_inplace
;
4492 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4496 BFD_ASSERT (h
->dynindx
!= -1);
4497 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
4499 outrel
.r_addend
= relocation
;
4501 += (howto
->partial_inplace
4502 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4506 loc
= sreloc
->contents
;
4507 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4508 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4510 check_segment
[0] = check_segment
[1] = -1;
4512 /* If this reloc is against an external symbol, we do
4513 not want to fiddle with the addend. Otherwise, we
4514 need to include the symbol value so that it becomes
4515 an addend for the dynamic reloc. */
4519 else if (fdpic_p
&& !info
->shared
4520 && r_type
== R_SH_DIR32
4521 && (input_section
->flags
& SEC_ALLOC
) != 0)
4527 if (sh_elf_osec_readonly_p (output_bfd
,
4528 input_section
->output_section
))
4530 (*_bfd_error_handler
)
4531 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4534 (long) rel
->r_offset
,
4539 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4540 input_section
, rel
->r_offset
);
4541 if (offset
!= (bfd_vma
)-1)
4542 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4543 input_section
->output_section
->vma
4544 + input_section
->output_offset
4547 check_segment
[0] = check_segment
[1] = -1;
4549 goto final_link_relocate
;
4552 #ifdef INCLUDE_SHMEDIA
4553 case R_SH_GOTPLT_LOW16
:
4554 case R_SH_GOTPLT_MEDLOW16
:
4555 case R_SH_GOTPLT_MEDHI16
:
4556 case R_SH_GOTPLT_HI16
:
4557 case R_SH_GOTPLT10BY4
:
4558 case R_SH_GOTPLT10BY8
:
4560 /* Relocation is to the entry for this symbol in the
4561 procedure linkage table. */
4568 || h
->plt
.offset
== (bfd_vma
) -1
4569 || h
->got
.offset
!= (bfd_vma
) -1)
4572 /* Relocation is to the entry for this symbol in the global
4573 offset table extension for the procedure linkage table. */
4576 BFD_ASSERT (sgotplt
!= NULL
);
4577 relocation
= (sgotplt
->output_offset
4578 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4582 relocation
-= GOT_BIAS
;
4585 goto final_link_relocate
;
4590 #ifdef INCLUDE_SHMEDIA
4591 case R_SH_GOT_LOW16
:
4592 case R_SH_GOT_MEDLOW16
:
4593 case R_SH_GOT_MEDHI16
:
4598 /* Relocation is to the entry for this symbol in the global
4602 BFD_ASSERT (sgot
!= NULL
);
4603 check_segment
[0] = check_segment
[1] = -1;
4609 off
= h
->got
.offset
;
4610 #ifdef INCLUDE_SHMEDIA
4611 if (seen_stt_datalabel
)
4613 struct elf_sh_link_hash_entry
*hsh
;
4615 hsh
= (struct elf_sh_link_hash_entry
*)h
;
4616 off
= hsh
->datalabel_got
.offset
;
4619 BFD_ASSERT (off
!= (bfd_vma
) -1);
4621 dyn
= htab
->root
.dynamic_sections_created
;
4622 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
4624 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4625 || (ELF_ST_VISIBILITY (h
->other
)
4626 && h
->root
.type
== bfd_link_hash_undefweak
))
4628 /* This is actually a static link, or it is a
4629 -Bsymbolic link and the symbol is defined
4630 locally, or the symbol was forced to be local
4631 because of a version file. We must initialize
4632 this entry in the global offset table. Since the
4633 offset must always be a multiple of 4, we use the
4634 least significant bit to record whether we have
4635 initialized it already.
4637 When doing a dynamic link, we create a .rela.got
4638 relocation entry to initialize the value. This
4639 is done in the finish_dynamic_symbol routine. */
4644 bfd_put_32 (output_bfd
, relocation
,
4645 sgot
->contents
+ off
);
4646 #ifdef INCLUDE_SHMEDIA
4647 if (seen_stt_datalabel
)
4649 struct elf_sh_link_hash_entry
*hsh
;
4651 hsh
= (struct elf_sh_link_hash_entry
*)h
;
4652 hsh
->datalabel_got
.offset
|= 1;
4658 /* If we initialize the GOT entry here with a valid
4659 symbol address, also add a fixup. */
4660 if (fdpic_p
&& !info
->shared
4661 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4662 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4663 || h
->root
.type
!= bfd_link_hash_undefweak
))
4664 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4665 sgot
->output_section
->vma
4666 + sgot
->output_offset
4671 relocation
= sh_elf_got_offset (htab
) + off
;
4675 #ifdef INCLUDE_SHMEDIA
4678 BFD_ASSERT (local_got_offsets
!= NULL
4679 && (local_got_offsets
[symtab_hdr
->sh_info
4683 off
= local_got_offsets
[symtab_hdr
->sh_info
4689 BFD_ASSERT (local_got_offsets
!= NULL
4690 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4692 off
= local_got_offsets
[r_symndx
];
4693 #ifdef INCLUDE_SHMEDIA
4697 /* The offset must always be a multiple of 4. We use
4698 the least significant bit to record whether we have
4699 already generated the necessary reloc. */
4704 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4708 Elf_Internal_Rela outrel
;
4711 if (srelgot
== NULL
)
4713 srelgot
= bfd_get_section_by_name (dynobj
,
4715 BFD_ASSERT (srelgot
!= NULL
);
4718 outrel
.r_offset
= (sgot
->output_section
->vma
4719 + sgot
->output_offset
4724 = elf_section_data (sec
->output_section
)->dynindx
;
4725 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4726 outrel
.r_addend
= relocation
;
4727 outrel
.r_addend
-= sec
->output_section
->vma
;
4731 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4732 outrel
.r_addend
= relocation
;
4734 loc
= srelgot
->contents
;
4735 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4736 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4739 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4741 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4742 sgot
->output_section
->vma
4743 + sgot
->output_offset
4746 #ifdef INCLUDE_SHMEDIA
4748 local_got_offsets
[symtab_hdr
->sh_info
+ r_symndx
] |= 1;
4751 local_got_offsets
[r_symndx
] |= 1;
4754 relocation
= sh_elf_got_offset (htab
) + off
;
4758 relocation
-= GOT_BIAS
;
4761 if (r_type
== R_SH_GOT20
)
4763 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4764 input_bfd
, input_section
, contents
,
4769 goto final_link_relocate
;
4773 #ifdef INCLUDE_SHMEDIA
4774 case R_SH_GOTOFF_LOW16
:
4775 case R_SH_GOTOFF_MEDLOW16
:
4776 case R_SH_GOTOFF_MEDHI16
:
4777 case R_SH_GOTOFF_HI16
:
4779 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4780 we place at the start of the .got.plt section. This is the same
4781 as the start of the output .got section, unless there are function
4782 descriptors in front of it. */
4784 BFD_ASSERT (sgotplt
!= NULL
);
4785 check_segment
[0] = got_segment
;
4786 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4787 + htab
->root
.hgot
->root
.u
.def
.value
;
4790 relocation
-= GOT_BIAS
;
4793 addend
= rel
->r_addend
;
4795 if (r_type
== R_SH_GOTOFF20
)
4797 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4798 input_bfd
, input_section
, contents
,
4803 goto final_link_relocate
;
4806 #ifdef INCLUDE_SHMEDIA
4807 case R_SH_GOTPC_LOW16
:
4808 case R_SH_GOTPC_MEDLOW16
:
4809 case R_SH_GOTPC_MEDHI16
:
4810 case R_SH_GOTPC_HI16
:
4812 /* Use global offset table as symbol value. */
4814 BFD_ASSERT (sgotplt
!= NULL
);
4815 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4818 relocation
+= GOT_BIAS
;
4821 addend
= rel
->r_addend
;
4823 goto final_link_relocate
;
4826 #ifdef INCLUDE_SHMEDIA
4827 case R_SH_PLT_LOW16
:
4828 case R_SH_PLT_MEDLOW16
:
4829 case R_SH_PLT_MEDHI16
:
4832 /* Relocation is to the entry for this symbol in the
4833 procedure linkage table. */
4835 /* Resolve a PLT reloc against a local symbol directly,
4836 without using the procedure linkage table. */
4838 goto final_link_relocate
;
4840 /* We don't want to warn on calls to undefined weak symbols,
4841 as calls to them must be protected by non-NULL tests
4842 anyway, and unprotected calls would invoke undefined
4844 if (h
->root
.type
== bfd_link_hash_undefweak
)
4845 check_segment
[0] = check_segment
[1] = -1;
4847 if (h
->forced_local
)
4848 goto final_link_relocate
;
4850 if (h
->plt
.offset
== (bfd_vma
) -1)
4852 /* We didn't make a PLT entry for this symbol. This
4853 happens when statically linking PIC code, or when
4854 using -Bsymbolic. */
4855 goto final_link_relocate
;
4858 BFD_ASSERT (splt
!= NULL
);
4859 check_segment
[1] = plt_segment
;
4860 relocation
= (splt
->output_section
->vma
4861 + splt
->output_offset
4864 #ifdef INCLUDE_SHMEDIA
4868 addend
= rel
->r_addend
;
4870 goto final_link_relocate
;
4872 /* Relocation is to the canonical function descriptor for this
4873 symbol, possibly via the GOT. Initialize the GOT
4874 entry and function descriptor if necessary. */
4875 case R_SH_GOTFUNCDESC
:
4876 case R_SH_GOTFUNCDESC20
:
4880 asection
*reloc_section
;
4881 bfd_vma reloc_offset
;
4882 int reloc_type
= R_SH_FUNCDESC
;
4886 check_segment
[0] = check_segment
[1] = -1;
4888 /* FIXME: See what FRV does for global symbols in the
4889 executable, with --export-dynamic. Do they need ld.so
4890 to allocate official descriptors? See what this code
4896 if (r_type
== R_SH_FUNCDESC
)
4898 reloc_section
= input_section
;
4899 reloc_offset
= rel
->r_offset
;
4903 reloc_section
= sgot
;
4906 reloc_offset
= h
->got
.offset
;
4909 BFD_ASSERT (local_got_offsets
!= NULL
);
4910 reloc_offset
= local_got_offsets
[r_symndx
];
4912 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4914 if (reloc_offset
& 1)
4917 goto funcdesc_done_got
;
4921 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4922 && (SYMBOL_CALLS_LOCAL (info
, h
)
4923 || !htab
->root
.dynamic_sections_created
))
4924 /* Undefined weak symbol which will not be dynamically
4925 resolved later; leave it at zero. */
4926 goto funcdesc_leave_zero
;
4927 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4928 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4930 /* If the symbol needs a non-local function descriptor
4931 but binds locally (i.e., its visibility is
4932 protected), emit a dynamic relocation decayed to
4933 section+offset. This is an optimization; the dynamic
4934 linker would resolve our function descriptor request
4935 to our copy of the function anyway. */
4936 dynindx
= elf_section_data (h
->root
.u
.def
.section
4937 ->output_section
)->dynindx
;
4938 relocation
+= h
->root
.u
.def
.section
->output_offset
4939 + h
->root
.u
.def
.value
;
4941 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4943 /* If the symbol is dynamic and there will be dynamic
4944 symbol resolution because we are or are linked with a
4945 shared library, emit a FUNCDESC relocation such that
4946 the dynamic linker will allocate the function
4948 BFD_ASSERT (h
->dynindx
!= -1);
4949 dynindx
= h
->dynindx
;
4955 /* Otherwise, we know we have a private function
4956 descriptor, so reference it directly. */
4957 reloc_type
= R_SH_DIR32
;
4958 dynindx
= elf_section_data (htab
->sfuncdesc
4959 ->output_section
)->dynindx
;
4963 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4964 BFD_ASSERT (offset
!= MINUS_ONE
);
4965 if ((offset
& 1) == 0)
4967 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4970 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4975 union gotref
*local_funcdesc
;
4977 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4978 offset
= local_funcdesc
[r_symndx
].offset
;
4979 BFD_ASSERT (offset
!= MINUS_ONE
);
4980 if ((offset
& 1) == 0)
4982 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4986 local_funcdesc
[r_symndx
].offset
|= 1;
4990 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4993 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
4997 if (sh_elf_osec_readonly_p (output_bfd
,
4998 reloc_section
->output_section
))
5000 (*_bfd_error_handler
)
5001 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
5004 (long) rel
->r_offset
,
5009 offset
= _bfd_elf_section_offset (output_bfd
, info
,
5010 reloc_section
, reloc_offset
);
5012 if (offset
!= (bfd_vma
)-1)
5013 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
5015 + reloc_section
->output_section
->vma
5016 + reloc_section
->output_offset
);
5018 else if ((reloc_section
->output_section
->flags
5019 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
5023 if (sh_elf_osec_readonly_p (output_bfd
,
5024 reloc_section
->output_section
))
5026 info
->callbacks
->warning
5028 _("cannot emit dynamic relocations in read-only section"),
5029 symname
, input_bfd
, reloc_section
, reloc_offset
);
5033 if (srelgot
== NULL
)
5035 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
5036 BFD_ASSERT (srelgot
!= NULL
);
5039 offset
= _bfd_elf_section_offset (output_bfd
, info
,
5040 reloc_section
, reloc_offset
);
5042 if (offset
!= (bfd_vma
)-1)
5043 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
5045 + reloc_section
->output_section
->vma
5046 + reloc_section
->output_offset
,
5047 reloc_type
, dynindx
, relocation
);
5049 if (r_type
== R_SH_FUNCDESC
)
5057 goto funcdesc_leave_zero
;
5061 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
5062 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
5063 funcdesc_leave_zero
:
5064 if (r_type
!= R_SH_FUNCDESC
)
5066 bfd_put_32 (output_bfd
, relocation
,
5067 reloc_section
->contents
+ reloc_offset
);
5071 local_got_offsets
[r_symndx
] |= 1;
5075 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
5077 relocation
-= GOT_BIAS
;
5080 if (r_type
== R_SH_GOTFUNCDESC20
)
5082 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
5083 input_bfd
, input_section
, contents
,
5088 goto final_link_relocate
;
5092 case R_SH_GOTOFFFUNCDESC
:
5093 case R_SH_GOTOFFFUNCDESC20
:
5094 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5095 executable and --export-dynamic. If such symbols get
5096 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5100 check_segment
[0] = check_segment
[1] = -1;
5102 addend
= rel
->r_addend
;
5104 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
5105 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
5108 (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
5109 input_bfd
, input_section
, (long) rel
->r_offset
, howto
->name
,
5110 h
->root
.root
.string
);
5117 /* Otherwise, we know we have a private function
5118 descriptor, so reference it directly. */
5121 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
5122 BFD_ASSERT (offset
!= MINUS_ONE
);
5123 if ((offset
& 1) == 0)
5125 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
5128 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
5133 union gotref
*local_funcdesc
;
5135 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
5136 offset
= local_funcdesc
[r_symndx
].offset
;
5137 BFD_ASSERT (offset
!= MINUS_ONE
);
5138 if ((offset
& 1) == 0)
5140 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
5144 local_funcdesc
[r_symndx
].offset
|= 1;
5148 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
5151 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
5152 + sgotplt
->output_offset
);
5154 relocation
-= GOT_BIAS
;
5157 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
5159 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
5160 input_bfd
, input_section
, contents
,
5165 goto final_link_relocate
;
5167 case R_SH_LOOP_START
:
5169 static bfd_vma start
, end
;
5171 start
= (relocation
+ rel
->r_addend
5172 - (sec
->output_section
->vma
+ sec
->output_offset
));
5173 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
5174 rel
->r_offset
, sec
, start
, end
);
5178 end
= (relocation
+ rel
->r_addend
5179 - (sec
->output_section
->vma
+ sec
->output_offset
));
5180 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
5181 rel
->r_offset
, sec
, start
, end
);
5185 case R_SH_TLS_GD_32
:
5186 case R_SH_TLS_IE_32
:
5188 check_segment
[0] = check_segment
[1] = -1;
5189 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5190 got_type
= GOT_UNKNOWN
;
5191 if (h
== NULL
&& local_got_offsets
)
5192 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
5195 got_type
= sh_elf_hash_entry (h
)->got_type
;
5197 && (h
->dynindx
== -1
5199 r_type
= R_SH_TLS_LE_32
;
5202 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
5203 r_type
= R_SH_TLS_IE_32
;
5205 if (r_type
== R_SH_TLS_LE_32
)
5208 unsigned short insn
;
5210 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
5212 /* GD->LE transition:
5213 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5214 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5215 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5217 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5219 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5221 offset
= rel
->r_offset
;
5222 BFD_ASSERT (offset
>= 16);
5223 /* Size of GD instructions is 16 or 18. */
5225 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5226 if ((insn
& 0xff00) == 0xc700)
5228 BFD_ASSERT (offset
>= 2);
5230 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5233 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5234 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5235 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5236 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5237 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5238 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5239 BFD_ASSERT (insn
== 0x310c);
5240 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5241 BFD_ASSERT (insn
== 0x410b);
5242 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5243 BFD_ASSERT (insn
== 0x34cc);
5245 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
5246 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
5247 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5248 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5249 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5255 /* IE->LE transition:
5256 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5257 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5259 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5262 offset
= rel
->r_offset
;
5263 BFD_ASSERT (offset
>= 16);
5264 /* Size of IE instructions is 10 or 12. */
5266 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5267 if ((insn
& 0xf0ff) == 0x0012)
5269 BFD_ASSERT (offset
>= 2);
5271 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5274 BFD_ASSERT ((insn
& 0xff00) == 0xd000);
5275 target
= insn
& 0x00ff;
5276 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5277 BFD_ASSERT ((insn
& 0xf0ff) == 0x0012);
5278 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5279 BFD_ASSERT ((insn
& 0xf0ff) == 0x00ce);
5280 insn
= 0xd000 | (insn
& 0x0f00) | target
;
5281 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
5282 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5285 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
5286 contents
+ rel
->r_offset
);
5290 if (sgot
== NULL
|| sgotplt
== NULL
)
5294 off
= h
->got
.offset
;
5297 if (local_got_offsets
== NULL
)
5300 off
= local_got_offsets
[r_symndx
];
5303 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5304 if (r_type
== R_SH_TLS_IE_32
5305 && ! htab
->root
.dynamic_sections_created
)
5308 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
5309 sgot
->contents
+ off
);
5310 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
5311 contents
+ rel
->r_offset
);
5319 Elf_Internal_Rela outrel
;
5323 if (srelgot
== NULL
)
5325 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
5326 BFD_ASSERT (srelgot
!= NULL
);
5329 outrel
.r_offset
= (sgot
->output_section
->vma
5330 + sgot
->output_offset
+ off
);
5332 if (h
== NULL
|| h
->dynindx
== -1)
5337 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
5339 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
5340 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5342 outrel
.r_addend
= 0;
5343 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
5344 loc
= srelgot
->contents
;
5345 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5346 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5348 if (r_type
== R_SH_TLS_GD_32
)
5352 bfd_put_32 (output_bfd
,
5353 relocation
- dtpoff_base (info
),
5354 sgot
->contents
+ off
+ 4);
5358 outrel
.r_info
= ELF32_R_INFO (indx
,
5360 outrel
.r_offset
+= 4;
5361 outrel
.r_addend
= 0;
5362 srelgot
->reloc_count
++;
5363 loc
+= sizeof (Elf32_External_Rela
);
5364 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5371 local_got_offsets
[r_symndx
] |= 1;
5374 if (off
>= (bfd_vma
) -2)
5377 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
5378 relocation
= sh_elf_got_offset (htab
) + off
;
5382 unsigned short insn
;
5384 /* GD->IE transition:
5385 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5386 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5387 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5389 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5390 nop; nop; bra 3f; nop; .align 2;
5391 1: .long x@TPOFF; 2:...; 3:. */
5393 offset
= rel
->r_offset
;
5394 BFD_ASSERT (offset
>= 16);
5395 /* Size of GD instructions is 16 or 18. */
5397 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5398 if ((insn
& 0xff00) == 0xc700)
5400 BFD_ASSERT (offset
>= 2);
5402 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5405 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5407 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5408 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
5410 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5411 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5412 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5413 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5414 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5415 BFD_ASSERT (insn
== 0x310c);
5416 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5417 BFD_ASSERT (insn
== 0x410b);
5418 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5419 BFD_ASSERT (insn
== 0x34cc);
5421 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
5422 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
5423 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
5424 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5425 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5427 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
5428 contents
+ rel
->r_offset
);
5433 addend
= rel
->r_addend
;
5435 goto final_link_relocate
;
5437 case R_SH_TLS_LD_32
:
5439 check_segment
[0] = check_segment
[1] = -1;
5443 unsigned short insn
;
5445 /* LD->LE transition:
5446 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5447 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5448 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5450 stc gbr,r0; nop; nop; nop;
5451 nop; nop; bra 3f; ...; 3:. */
5453 offset
= rel
->r_offset
;
5454 BFD_ASSERT (offset
>= 16);
5455 /* Size of LD instructions is 16 or 18. */
5457 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5458 if ((insn
& 0xff00) == 0xc700)
5460 BFD_ASSERT (offset
>= 2);
5462 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5465 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5466 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5467 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5468 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5469 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5470 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5471 BFD_ASSERT (insn
== 0x310c);
5472 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5473 BFD_ASSERT (insn
== 0x410b);
5474 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5475 BFD_ASSERT (insn
== 0x34cc);
5477 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
5478 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
5479 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5480 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5481 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5482 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5487 if (sgot
== NULL
|| sgotplt
== NULL
)
5490 off
= htab
->tls_ldm_got
.offset
;
5495 Elf_Internal_Rela outrel
;
5498 srelgot
= htab
->srelgot
;
5499 if (srelgot
== NULL
)
5502 outrel
.r_offset
= (sgot
->output_section
->vma
5503 + sgot
->output_offset
+ off
);
5504 outrel
.r_addend
= 0;
5505 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
5506 loc
= srelgot
->contents
;
5507 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5508 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5509 htab
->tls_ldm_got
.offset
|= 1;
5512 relocation
= sh_elf_got_offset (htab
) + off
;
5513 addend
= rel
->r_addend
;
5515 goto final_link_relocate
;
5517 case R_SH_TLS_LDO_32
:
5518 check_segment
[0] = check_segment
[1] = -1;
5520 relocation
= tpoff (info
, relocation
);
5522 relocation
-= dtpoff_base (info
);
5524 addend
= rel
->r_addend
;
5525 goto final_link_relocate
;
5527 case R_SH_TLS_LE_32
:
5530 Elf_Internal_Rela outrel
;
5533 check_segment
[0] = check_segment
[1] = -1;
5537 relocation
= tpoff (info
, relocation
);
5538 addend
= rel
->r_addend
;
5539 goto final_link_relocate
;
5544 sreloc
= _bfd_elf_get_dynamic_reloc_section
5545 (input_bfd
, input_section
, /*rela?*/ TRUE
);
5550 if (h
== NULL
|| h
->dynindx
== -1)
5555 outrel
.r_offset
= (input_section
->output_section
->vma
5556 + input_section
->output_offset
5558 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
5560 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5562 outrel
.r_addend
= 0;
5564 loc
= sreloc
->contents
;
5565 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5566 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5572 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5573 && check_segment
[0] != check_segment
[1])
5575 /* We don't want duplicate errors for undefined symbols. */
5576 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5580 info
->callbacks
->einfo
5581 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5582 input_bfd
, input_section
, rel
->r_offset
, symname
);
5586 info
->callbacks
->einfo
5587 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5588 input_bfd
, input_section
, rel
->r_offset
, symname
);
5591 elf_elfheader (output_bfd
)->e_flags
&= ~EF_SH_PIC
;
5594 if (r
!= bfd_reloc_ok
)
5599 case bfd_reloc_outofrange
:
5601 case bfd_reloc_overflow
:
5609 name
= (bfd_elf_string_from_elf_section
5610 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5614 name
= bfd_section_name (input_bfd
, sec
);
5616 if (! ((*info
->callbacks
->reloc_overflow
)
5617 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5618 (bfd_vma
) 0, input_bfd
, input_section
,
5630 /* This is a version of bfd_generic_get_relocated_section_contents
5631 which uses sh_elf_relocate_section. */
5634 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5635 struct bfd_link_info
*link_info
,
5636 struct bfd_link_order
*link_order
,
5638 bfd_boolean relocatable
,
5641 Elf_Internal_Shdr
*symtab_hdr
;
5642 asection
*input_section
= link_order
->u
.indirect
.section
;
5643 bfd
*input_bfd
= input_section
->owner
;
5644 asection
**sections
= NULL
;
5645 Elf_Internal_Rela
*internal_relocs
= NULL
;
5646 Elf_Internal_Sym
*isymbuf
= NULL
;
5648 /* We only need to handle the case of relaxing, or of having a
5649 particular set of section contents, specially. */
5651 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5652 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5657 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5659 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5660 (size_t) input_section
->size
);
5662 if ((input_section
->flags
& SEC_RELOC
) != 0
5663 && input_section
->reloc_count
> 0)
5666 Elf_Internal_Sym
*isym
, *isymend
;
5669 internal_relocs
= (_bfd_elf_link_read_relocs
5670 (input_bfd
, input_section
, NULL
,
5671 (Elf_Internal_Rela
*) NULL
, FALSE
));
5672 if (internal_relocs
== NULL
)
5675 if (symtab_hdr
->sh_info
!= 0)
5677 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5678 if (isymbuf
== NULL
)
5679 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5680 symtab_hdr
->sh_info
, 0,
5682 if (isymbuf
== NULL
)
5686 amt
= symtab_hdr
->sh_info
;
5687 amt
*= sizeof (asection
*);
5688 sections
= (asection
**) bfd_malloc (amt
);
5689 if (sections
== NULL
&& amt
!= 0)
5692 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5693 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5697 if (isym
->st_shndx
== SHN_UNDEF
)
5698 isec
= bfd_und_section_ptr
;
5699 else if (isym
->st_shndx
== SHN_ABS
)
5700 isec
= bfd_abs_section_ptr
;
5701 else if (isym
->st_shndx
== SHN_COMMON
)
5702 isec
= bfd_com_section_ptr
;
5704 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5709 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5710 input_section
, data
, internal_relocs
,
5714 if (sections
!= NULL
)
5717 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5719 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5720 free (internal_relocs
);
5726 if (sections
!= NULL
)
5729 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5731 if (internal_relocs
!= NULL
5732 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
5733 free (internal_relocs
);
5737 /* Return the base VMA address which should be subtracted from real addresses
5738 when resolving @dtpoff relocation.
5739 This is PT_TLS segment p_vaddr. */
5742 dtpoff_base (struct bfd_link_info
*info
)
5744 /* If tls_sec is NULL, we should have signalled an error already. */
5745 if (elf_hash_table (info
)->tls_sec
== NULL
)
5747 return elf_hash_table (info
)->tls_sec
->vma
;
5750 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5753 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5755 /* If tls_sec is NULL, we should have signalled an error already. */
5756 if (elf_hash_table (info
)->tls_sec
== NULL
)
5758 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5759 structure which has 2 pointer fields. */
5760 return (address
- elf_hash_table (info
)->tls_sec
->vma
5761 + align_power ((bfd_vma
) 8,
5762 elf_hash_table (info
)->tls_sec
->alignment_power
));
5766 sh_elf_gc_mark_hook (asection
*sec
,
5767 struct bfd_link_info
*info
,
5768 Elf_Internal_Rela
*rel
,
5769 struct elf_link_hash_entry
*h
,
5770 Elf_Internal_Sym
*sym
)
5773 switch (ELF32_R_TYPE (rel
->r_info
))
5775 case R_SH_GNU_VTINHERIT
:
5776 case R_SH_GNU_VTENTRY
:
5780 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5783 /* Update the got entry reference counts for the section being removed. */
5786 sh_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5787 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5789 Elf_Internal_Shdr
*symtab_hdr
;
5790 struct elf_link_hash_entry
**sym_hashes
;
5791 bfd_signed_vma
*local_got_refcounts
;
5792 union gotref
*local_funcdesc
;
5793 const Elf_Internal_Rela
*rel
, *relend
;
5795 if (info
->relocatable
)
5798 elf_section_data (sec
)->local_dynrel
= NULL
;
5800 symtab_hdr
= &elf_symtab_hdr (abfd
);
5801 sym_hashes
= elf_sym_hashes (abfd
);
5802 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5803 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5805 relend
= relocs
+ sec
->reloc_count
;
5806 for (rel
= relocs
; rel
< relend
; rel
++)
5808 unsigned long r_symndx
;
5809 unsigned int r_type
;
5810 struct elf_link_hash_entry
*h
= NULL
;
5811 #ifdef INCLUDE_SHMEDIA
5812 int seen_stt_datalabel
= 0;
5815 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5816 if (r_symndx
>= symtab_hdr
->sh_info
)
5818 struct elf_sh_link_hash_entry
*eh
;
5819 struct elf_sh_dyn_relocs
**pp
;
5820 struct elf_sh_dyn_relocs
*p
;
5822 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5823 while (h
->root
.type
== bfd_link_hash_indirect
5824 || h
->root
.type
== bfd_link_hash_warning
)
5826 #ifdef INCLUDE_SHMEDIA
5827 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
5829 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5831 eh
= (struct elf_sh_link_hash_entry
*) h
;
5832 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
5835 /* Everything must go for SEC. */
5841 r_type
= ELF32_R_TYPE (rel
->r_info
);
5842 switch (sh_elf_optimized_tls_reloc (info
, r_type
, h
!= NULL
))
5844 case R_SH_TLS_LD_32
:
5845 if (sh_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
5846 sh_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
5854 #ifdef INCLUDE_SHMEDIA
5855 case R_SH_GOT_LOW16
:
5856 case R_SH_GOT_MEDLOW16
:
5857 case R_SH_GOT_MEDHI16
:
5861 case R_SH_GOTOFF_LOW16
:
5862 case R_SH_GOTOFF_MEDLOW16
:
5863 case R_SH_GOTOFF_MEDHI16
:
5864 case R_SH_GOTOFF_HI16
:
5865 case R_SH_GOTPC_LOW16
:
5866 case R_SH_GOTPC_MEDLOW16
:
5867 case R_SH_GOTPC_MEDHI16
:
5868 case R_SH_GOTPC_HI16
:
5870 case R_SH_TLS_GD_32
:
5871 case R_SH_TLS_IE_32
:
5872 case R_SH_GOTFUNCDESC
:
5873 case R_SH_GOTFUNCDESC20
:
5876 #ifdef INCLUDE_SHMEDIA
5877 if (seen_stt_datalabel
)
5879 struct elf_sh_link_hash_entry
*eh
;
5880 eh
= (struct elf_sh_link_hash_entry
*) h
;
5881 if (eh
->datalabel_got
.refcount
> 0)
5882 eh
->datalabel_got
.refcount
-= 1;
5886 if (h
->got
.refcount
> 0)
5887 h
->got
.refcount
-= 1;
5889 else if (local_got_refcounts
!= NULL
)
5891 #ifdef INCLUDE_SHMEDIA
5892 if (rel
->r_addend
& 1)
5894 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
5895 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
5899 if (local_got_refcounts
[r_symndx
] > 0)
5900 local_got_refcounts
[r_symndx
] -= 1;
5906 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
-= 1;
5907 else if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->shared
)
5908 sh_elf_hash_table (info
)->srofixup
->size
-= 4;
5912 case R_SH_GOTOFFFUNCDESC
:
5913 case R_SH_GOTOFFFUNCDESC20
:
5915 sh_elf_hash_entry (h
)->funcdesc
.refcount
-= 1;
5917 local_funcdesc
[r_symndx
].refcount
-= 1;
5921 if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->shared
5922 && (sec
->flags
& SEC_ALLOC
) != 0)
5923 sh_elf_hash_table (info
)->srofixup
->size
-= 4;
5932 #ifdef INCLUDE_SHMEDIA
5933 case R_SH_PLT_LOW16
:
5934 case R_SH_PLT_MEDLOW16
:
5935 case R_SH_PLT_MEDHI16
:
5940 if (h
->plt
.refcount
> 0)
5941 h
->plt
.refcount
-= 1;
5946 #ifdef INCLUDE_SHMEDIA
5947 case R_SH_GOTPLT_LOW16
:
5948 case R_SH_GOTPLT_MEDLOW16
:
5949 case R_SH_GOTPLT_MEDHI16
:
5950 case R_SH_GOTPLT_HI16
:
5951 case R_SH_GOTPLT10BY4
:
5952 case R_SH_GOTPLT10BY8
:
5956 struct elf_sh_link_hash_entry
*eh
;
5957 eh
= (struct elf_sh_link_hash_entry
*) h
;
5958 if (eh
->gotplt_refcount
> 0)
5960 eh
->gotplt_refcount
-= 1;
5961 if (h
->plt
.refcount
> 0)
5962 h
->plt
.refcount
-= 1;
5964 #ifdef INCLUDE_SHMEDIA
5965 else if (seen_stt_datalabel
)
5967 if (eh
->datalabel_got
.refcount
> 0)
5968 eh
->datalabel_got
.refcount
-= 1;
5971 else if (h
->got
.refcount
> 0)
5972 h
->got
.refcount
-= 1;
5974 else if (local_got_refcounts
!= NULL
)
5976 #ifdef INCLUDE_SHMEDIA
5977 if (rel
->r_addend
& 1)
5979 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
5980 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
5984 if (local_got_refcounts
[r_symndx
] > 0)
5985 local_got_refcounts
[r_symndx
] -= 1;
5997 /* Copy the extra info we tack onto an elf_link_hash_entry. */
6000 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
6001 struct elf_link_hash_entry
*dir
,
6002 struct elf_link_hash_entry
*ind
)
6004 struct elf_sh_link_hash_entry
*edir
, *eind
;
6006 edir
= (struct elf_sh_link_hash_entry
*) dir
;
6007 eind
= (struct elf_sh_link_hash_entry
*) ind
;
6009 if (eind
->dyn_relocs
!= NULL
)
6011 if (edir
->dyn_relocs
!= NULL
)
6013 struct elf_sh_dyn_relocs
**pp
;
6014 struct elf_sh_dyn_relocs
*p
;
6016 /* Add reloc counts against the indirect sym to the direct sym
6017 list. Merge any entries against the same section. */
6018 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
6020 struct elf_sh_dyn_relocs
*q
;
6022 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
6023 if (q
->sec
== p
->sec
)
6025 q
->pc_count
+= p
->pc_count
;
6026 q
->count
+= p
->count
;
6033 *pp
= edir
->dyn_relocs
;
6036 edir
->dyn_relocs
= eind
->dyn_relocs
;
6037 eind
->dyn_relocs
= NULL
;
6039 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
6040 eind
->gotplt_refcount
= 0;
6041 #ifdef INCLUDE_SHMEDIA
6042 edir
->datalabel_got
.refcount
+= eind
->datalabel_got
.refcount
;
6043 eind
->datalabel_got
.refcount
= 0;
6045 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
6046 eind
->funcdesc
.refcount
= 0;
6047 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
6048 eind
->abs_funcdesc_refcount
= 0;
6050 if (ind
->root
.type
== bfd_link_hash_indirect
6051 && dir
->got
.refcount
<= 0)
6053 edir
->got_type
= eind
->got_type
;
6054 eind
->got_type
= GOT_UNKNOWN
;
6057 if (ind
->root
.type
!= bfd_link_hash_indirect
6058 && dir
->dynamic_adjusted
)
6060 /* If called to transfer flags for a weakdef during processing
6061 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6062 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6063 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6064 dir
->ref_regular
|= ind
->ref_regular
;
6065 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6066 dir
->needs_plt
|= ind
->needs_plt
;
6069 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
6073 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
6081 case R_SH_TLS_GD_32
:
6082 case R_SH_TLS_IE_32
:
6084 return R_SH_TLS_LE_32
;
6085 return R_SH_TLS_IE_32
;
6086 case R_SH_TLS_LD_32
:
6087 return R_SH_TLS_LE_32
;
6093 /* Look through the relocs for a section during the first phase.
6094 Since we don't do .gots or .plts, we just need to consider the
6095 virtual table relocs for gc. */
6098 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
6099 const Elf_Internal_Rela
*relocs
)
6101 Elf_Internal_Shdr
*symtab_hdr
;
6102 struct elf_link_hash_entry
**sym_hashes
;
6103 struct elf_sh_link_hash_table
*htab
;
6104 const Elf_Internal_Rela
*rel
;
6105 const Elf_Internal_Rela
*rel_end
;
6107 unsigned int r_type
;
6108 int got_type
, old_got_type
;
6112 if (info
->relocatable
)
6115 BFD_ASSERT (is_sh_elf (abfd
));
6117 symtab_hdr
= &elf_symtab_hdr (abfd
);
6118 sym_hashes
= elf_sym_hashes (abfd
);
6120 htab
= sh_elf_hash_table (info
);
6124 rel_end
= relocs
+ sec
->reloc_count
;
6125 for (rel
= relocs
; rel
< rel_end
; rel
++)
6127 struct elf_link_hash_entry
*h
;
6128 unsigned long r_symndx
;
6129 #ifdef INCLUDE_SHMEDIA
6130 int seen_stt_datalabel
= 0;
6133 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6134 r_type
= ELF32_R_TYPE (rel
->r_info
);
6136 if (r_symndx
< symtab_hdr
->sh_info
)
6140 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6141 while (h
->root
.type
== bfd_link_hash_indirect
6142 || h
->root
.type
== bfd_link_hash_warning
)
6144 #ifdef INCLUDE_SHMEDIA
6145 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
6147 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6151 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
6153 && r_type
== R_SH_TLS_IE_32
6155 && h
->root
.type
!= bfd_link_hash_undefined
6156 && h
->root
.type
!= bfd_link_hash_undefweak
6157 && (h
->dynindx
== -1
6159 r_type
= R_SH_TLS_LE_32
;
6164 case R_SH_GOTOFFFUNCDESC
:
6165 case R_SH_GOTOFFFUNCDESC20
:
6167 case R_SH_GOTFUNCDESC
:
6168 case R_SH_GOTFUNCDESC20
:
6171 if (h
->dynindx
== -1)
6172 switch (ELF_ST_VISIBILITY (h
->other
))
6178 bfd_elf_link_record_dynamic_symbol (info
, h
);
6185 /* Some relocs require a global offset table. */
6186 if (htab
->sgot
== NULL
)
6191 /* This may require an rofixup. */
6200 case R_SH_GOTFUNCDESC
:
6201 case R_SH_GOTFUNCDESC20
:
6202 case R_SH_GOTOFFFUNCDESC
:
6203 case R_SH_GOTOFFFUNCDESC20
:
6205 #ifdef INCLUDE_SHMEDIA
6206 case R_SH_GOTPLT_LOW16
:
6207 case R_SH_GOTPLT_MEDLOW16
:
6208 case R_SH_GOTPLT_MEDHI16
:
6209 case R_SH_GOTPLT_HI16
:
6210 case R_SH_GOTPLT10BY4
:
6211 case R_SH_GOTPLT10BY8
:
6212 case R_SH_GOT_LOW16
:
6213 case R_SH_GOT_MEDLOW16
:
6214 case R_SH_GOT_MEDHI16
:
6218 case R_SH_GOTOFF_LOW16
:
6219 case R_SH_GOTOFF_MEDLOW16
:
6220 case R_SH_GOTOFF_MEDHI16
:
6221 case R_SH_GOTOFF_HI16
:
6222 case R_SH_GOTPC_LOW16
:
6223 case R_SH_GOTPC_MEDLOW16
:
6224 case R_SH_GOTPC_MEDHI16
:
6225 case R_SH_GOTPC_HI16
:
6227 case R_SH_TLS_GD_32
:
6228 case R_SH_TLS_LD_32
:
6229 case R_SH_TLS_IE_32
:
6230 if (htab
->root
.dynobj
== NULL
)
6231 htab
->root
.dynobj
= abfd
;
6232 if (!create_got_section (htab
->root
.dynobj
, info
))
6243 /* This relocation describes the C++ object vtable hierarchy.
6244 Reconstruct it for later use during GC. */
6245 case R_SH_GNU_VTINHERIT
:
6246 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6250 /* This relocation describes which C++ vtable entries are actually
6251 used. Record for later use during GC. */
6252 case R_SH_GNU_VTENTRY
:
6253 BFD_ASSERT (h
!= NULL
);
6255 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
6259 case R_SH_TLS_IE_32
:
6261 info
->flags
|= DF_STATIC_TLS
;
6265 case R_SH_TLS_GD_32
:
6268 #ifdef INCLUDE_SHMEDIA
6269 case R_SH_GOT_LOW16
:
6270 case R_SH_GOT_MEDLOW16
:
6271 case R_SH_GOT_MEDHI16
:
6276 case R_SH_GOTFUNCDESC
:
6277 case R_SH_GOTFUNCDESC20
:
6281 got_type
= GOT_NORMAL
;
6283 case R_SH_TLS_GD_32
:
6284 got_type
= GOT_TLS_GD
;
6286 case R_SH_TLS_IE_32
:
6287 got_type
= GOT_TLS_IE
;
6289 case R_SH_GOTFUNCDESC
:
6290 case R_SH_GOTFUNCDESC20
:
6291 got_type
= GOT_FUNCDESC
;
6297 #ifdef INCLUDE_SHMEDIA
6298 if (seen_stt_datalabel
)
6300 struct elf_sh_link_hash_entry
*eh
6301 = (struct elf_sh_link_hash_entry
*) h
;
6303 eh
->datalabel_got
.refcount
+= 1;
6307 h
->got
.refcount
+= 1;
6308 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
6312 bfd_signed_vma
*local_got_refcounts
;
6314 /* This is a global offset table entry for a local
6316 local_got_refcounts
= elf_local_got_refcounts (abfd
);
6317 if (local_got_refcounts
== NULL
)
6321 size
= symtab_hdr
->sh_info
;
6322 size
*= sizeof (bfd_signed_vma
);
6323 #ifdef INCLUDE_SHMEDIA
6324 /* Reserve space for both the datalabel and
6325 codelabel local GOT offsets. */
6328 size
+= symtab_hdr
->sh_info
;
6329 local_got_refcounts
= ((bfd_signed_vma
*)
6330 bfd_zalloc (abfd
, size
));
6331 if (local_got_refcounts
== NULL
)
6333 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
6334 #ifdef INCLUDE_SHMEDIA
6335 /* Take care of both the datalabel and codelabel local
6337 sh_elf_local_got_type (abfd
)
6338 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
6340 sh_elf_local_got_type (abfd
)
6341 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
6344 #ifdef INCLUDE_SHMEDIA
6345 if (rel
->r_addend
& 1)
6346 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] += 1;
6349 local_got_refcounts
[r_symndx
] += 1;
6350 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
6353 /* If a TLS symbol is accessed using IE at least once,
6354 there is no point to use dynamic model for it. */
6355 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
6356 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
6358 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
6359 got_type
= GOT_TLS_IE
;
6362 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
6363 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
6364 (*_bfd_error_handler
)
6365 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6366 abfd
, h
->root
.root
.string
);
6367 else if (old_got_type
== GOT_FUNCDESC
6368 || got_type
== GOT_FUNCDESC
)
6369 (*_bfd_error_handler
)
6370 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6371 abfd
, h
->root
.root
.string
);
6373 (*_bfd_error_handler
)
6374 (_("%B: `%s' accessed both as normal and thread local symbol"),
6375 abfd
, h
->root
.root
.string
);
6380 if (old_got_type
!= got_type
)
6383 sh_elf_hash_entry (h
)->got_type
= got_type
;
6385 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
6390 case R_SH_TLS_LD_32
:
6391 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
6395 case R_SH_GOTOFFFUNCDESC
:
6396 case R_SH_GOTOFFFUNCDESC20
:
6399 (*_bfd_error_handler
)
6400 (_("%B: Function descriptor relocation with non-zero addend"),
6407 union gotref
*local_funcdesc
;
6409 /* We need a function descriptor for a local symbol. */
6410 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
6411 if (local_funcdesc
== NULL
)
6415 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
6416 #ifdef INCLUDE_SHMEDIA
6417 /* Count datalabel local GOT. */
6420 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
6421 if (local_funcdesc
== NULL
)
6423 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
6425 local_funcdesc
[r_symndx
].refcount
+= 1;
6427 if (r_type
== R_SH_FUNCDESC
)
6430 htab
->srofixup
->size
+= 4;
6432 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
6437 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
6438 if (r_type
== R_SH_FUNCDESC
)
6439 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
6441 /* If there is a function descriptor reference, then
6442 there should not be any non-FDPIC references. */
6443 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
6444 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
6446 if (old_got_type
== GOT_NORMAL
)
6447 (*_bfd_error_handler
)
6448 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6449 abfd
, h
->root
.root
.string
);
6451 (*_bfd_error_handler
)
6452 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6453 abfd
, h
->root
.root
.string
);
6459 #ifdef INCLUDE_SHMEDIA
6460 case R_SH_GOTPLT_LOW16
:
6461 case R_SH_GOTPLT_MEDLOW16
:
6462 case R_SH_GOTPLT_MEDHI16
:
6463 case R_SH_GOTPLT_HI16
:
6464 case R_SH_GOTPLT10BY4
:
6465 case R_SH_GOTPLT10BY8
:
6467 /* If this is a local symbol, we resolve it directly without
6468 creating a procedure linkage table entry. */
6474 || h
->dynindx
== -1)
6478 h
->plt
.refcount
+= 1;
6479 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
6484 #ifdef INCLUDE_SHMEDIA
6485 case R_SH_PLT_LOW16
:
6486 case R_SH_PLT_MEDLOW16
:
6487 case R_SH_PLT_MEDHI16
:
6490 /* This symbol requires a procedure linkage table entry. We
6491 actually build the entry in adjust_dynamic_symbol,
6492 because this might be a case of linking PIC code which is
6493 never referenced by a dynamic object, in which case we
6494 don't need to generate a procedure linkage table entry
6497 /* If this is a local symbol, we resolve it directly without
6498 creating a procedure linkage table entry. */
6502 if (h
->forced_local
)
6506 h
->plt
.refcount
+= 1;
6511 #ifdef INCLUDE_SHMEDIA
6512 case R_SH_IMM_LOW16_PCREL
:
6513 case R_SH_IMM_MEDLOW16_PCREL
:
6514 case R_SH_IMM_MEDHI16_PCREL
:
6515 case R_SH_IMM_HI16_PCREL
:
6517 if (h
!= NULL
&& ! info
->shared
)
6520 h
->plt
.refcount
+= 1;
6523 /* If we are creating a shared library, and this is a reloc
6524 against a global symbol, or a non PC relative reloc
6525 against a local symbol, then we need to copy the reloc
6526 into the shared library. However, if we are linking with
6527 -Bsymbolic, we do not need to copy a reloc against a
6528 global symbol which is defined in an object we are
6529 including in the link (i.e., DEF_REGULAR is set). At
6530 this point we have not seen all the input files, so it is
6531 possible that DEF_REGULAR is not set now but will be set
6532 later (it is never cleared). We account for that
6533 possibility below by storing information in the
6534 dyn_relocs field of the hash table entry. A similar
6535 situation occurs when creating shared libraries and symbol
6536 visibility changes render the symbol local.
6538 If on the other hand, we are creating an executable, we
6539 may need to keep relocations for symbols satisfied by a
6540 dynamic library if we manage to avoid copy relocs for the
6543 && (sec
->flags
& SEC_ALLOC
) != 0
6544 && (r_type
!= R_SH_REL32
6546 && (! info
->symbolic
6547 || h
->root
.type
== bfd_link_hash_defweak
6548 || !h
->def_regular
))))
6550 && (sec
->flags
& SEC_ALLOC
) != 0
6552 && (h
->root
.type
== bfd_link_hash_defweak
6553 || !h
->def_regular
)))
6555 struct elf_sh_dyn_relocs
*p
;
6556 struct elf_sh_dyn_relocs
**head
;
6558 if (htab
->root
.dynobj
== NULL
)
6559 htab
->root
.dynobj
= abfd
;
6561 /* When creating a shared object, we must copy these
6562 reloc types into the output file. We create a reloc
6563 section in dynobj and make room for this reloc. */
6566 sreloc
= _bfd_elf_make_dynamic_reloc_section
6567 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
6573 /* If this is a global symbol, we count the number of
6574 relocations we need for this symbol. */
6576 head
= &((struct elf_sh_link_hash_entry
*) h
)->dyn_relocs
;
6579 /* Track dynamic relocs needed for local syms too. */
6582 Elf_Internal_Sym
*isym
;
6584 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
6589 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
6593 vpp
= &elf_section_data (s
)->local_dynrel
;
6594 head
= (struct elf_sh_dyn_relocs
**) vpp
;
6598 if (p
== NULL
|| p
->sec
!= sec
)
6600 bfd_size_type amt
= sizeof (*p
);
6601 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
6612 if (r_type
== R_SH_REL32
6613 #ifdef INCLUDE_SHMEDIA
6614 || r_type
== R_SH_IMM_LOW16_PCREL
6615 || r_type
== R_SH_IMM_MEDLOW16_PCREL
6616 || r_type
== R_SH_IMM_MEDHI16_PCREL
6617 || r_type
== R_SH_IMM_HI16_PCREL
6623 /* Allocate the fixup regardless of whether we need a relocation.
6624 If we end up generating the relocation, we'll unallocate the
6626 if (htab
->fdpic_p
&& !info
->shared
6627 && r_type
== R_SH_DIR32
6628 && (sec
->flags
& SEC_ALLOC
) != 0)
6629 htab
->srofixup
->size
+= 4;
6632 case R_SH_TLS_LE_32
:
6635 (*_bfd_error_handler
)
6636 (_("%B: TLS local exec code cannot be linked into shared objects"),
6643 case R_SH_TLS_LDO_32
:
6644 /* Nothing to do. */
6655 #ifndef sh_elf_set_mach_from_flags
6656 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
6659 sh_elf_set_mach_from_flags (bfd
*abfd
)
6661 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
6663 if (flags
>= sizeof(sh_ef_bfd_table
))
6666 if (sh_ef_bfd_table
[flags
] == 0)
6669 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
6675 /* Reverse table lookup for sh_ef_bfd_table[].
6676 Given a bfd MACH value from archures.c
6677 return the equivalent ELF flags from the table.
6678 Return -1 if no match is found. */
6681 sh_elf_get_flags_from_mach (unsigned long mach
)
6683 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
6686 if (sh_ef_bfd_table
[i
] == mach
)
6689 /* shouldn't get here */
6694 #endif /* not sh_elf_set_mach_from_flags */
6696 #ifndef sh_elf_set_private_flags
6697 /* Function to keep SH specific file flags. */
6700 sh_elf_set_private_flags (bfd
*abfd
, flagword flags
)
6702 BFD_ASSERT (! elf_flags_init (abfd
)
6703 || elf_elfheader (abfd
)->e_flags
== flags
);
6705 elf_elfheader (abfd
)->e_flags
= flags
;
6706 elf_flags_init (abfd
) = TRUE
;
6707 return sh_elf_set_mach_from_flags (abfd
);
6709 #endif /* not sh_elf_set_private_flags */
6711 #ifndef sh_elf_copy_private_data
6712 /* Copy backend specific data from one object module to another */
6715 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
6717 /* Copy object attributes. */
6718 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
6720 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6723 /* Copy the stack size. */
6724 if (elf_tdata (ibfd
)->phdr
&& elf_tdata (obfd
)->phdr
6725 && fdpic_object_p (ibfd
) && fdpic_object_p (obfd
))
6729 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
6730 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
6732 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
6734 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
6735 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
6737 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
6739 /* Rewrite the phdrs, since we're only called after they
6740 were first written. */
6742 (bfd_signed_vma
) get_elf_backend_data (obfd
)
6743 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
6744 || get_elf_backend_data (obfd
)->s
6745 ->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
6746 elf_elfheader (obfd
)->e_phnum
) != 0)
6755 return sh_elf_set_private_flags (obfd
, elf_elfheader (ibfd
)->e_flags
);
6757 #endif /* not sh_elf_copy_private_data */
6759 #ifndef sh_elf_merge_private_data
6761 /* This function returns the ELF architecture number that
6762 corresponds to the given arch_sh* flags. */
6765 sh_find_elf_flags (unsigned int arch_set
)
6767 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
6768 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
6770 return sh_elf_get_flags_from_mach (bfd_mach
);
6773 /* This routine initialises the elf flags when required and
6774 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6777 sh_elf_merge_private_data (bfd
*ibfd
, bfd
*obfd
)
6779 extern bfd_boolean
sh_merge_bfd_arch (bfd
*, bfd
*);
6781 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6784 if (! elf_flags_init (obfd
))
6786 /* This happens when ld starts out with a 'blank' output file. */
6787 elf_flags_init (obfd
) = TRUE
;
6788 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
6789 sh_elf_set_mach_from_flags (obfd
);
6790 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
6791 elf_elfheader (obfd
)->e_flags
|= EF_SH_PIC
;
6794 if (! sh_merge_bfd_arch (ibfd
, obfd
))
6796 _bfd_error_handler ("%B: uses instructions which are incompatible "
6797 "with instructions used in previous modules",
6799 bfd_set_error (bfd_error_bad_value
);
6803 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
6804 elf_elfheader (obfd
)->e_flags
|=
6805 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
6807 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
6809 _bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects",
6811 bfd_set_error (bfd_error_bad_value
);
6817 #endif /* not sh_elf_merge_private_data */
6819 /* Override the generic function because we need to store sh_elf_obj_tdata
6820 as the specific tdata. We set also the machine architecture from flags
6824 sh_elf_object_p (bfd
*abfd
)
6826 if (! sh_elf_set_mach_from_flags (abfd
))
6829 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
6830 == fdpic_object_p (abfd
));
6833 /* Finish up dynamic symbol handling. We set the contents of various
6834 dynamic sections here. */
6837 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
6838 struct elf_link_hash_entry
*h
,
6839 Elf_Internal_Sym
*sym
)
6841 struct elf_sh_link_hash_table
*htab
;
6843 htab
= sh_elf_hash_table (info
);
6847 if (h
->plt
.offset
!= (bfd_vma
) -1)
6855 Elf_Internal_Rela rel
;
6857 const struct elf_sh_plt_info
*plt_info
;
6859 /* This symbol has an entry in the procedure linkage table. Set
6862 BFD_ASSERT (h
->dynindx
!= -1);
6865 sgotplt
= htab
->sgotplt
;
6866 srelplt
= htab
->srelplt
;
6867 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
6869 /* Get the index in the procedure linkage table which
6870 corresponds to this symbol. This is the index of this symbol
6871 in all the symbols for which we are making plt entries. The
6872 first entry in the procedure linkage table is reserved. */
6873 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
6875 plt_info
= htab
->plt_info
;
6876 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
6877 plt_info
= plt_info
->short_plt
;
6879 /* Get the offset into the .got table of the entry that
6880 corresponds to this function. */
6882 /* The offset must be relative to the GOT symbol, twelve bytes
6883 before the end of .got.plt. Each descriptor is eight
6885 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
6887 /* Each .got entry is 4 bytes. The first three are
6889 got_offset
= (plt_index
+ 3) * 4;
6893 got_offset
-= GOT_BIAS
;
6896 /* Fill in the entry in the procedure linkage table. */
6897 memcpy (splt
->contents
+ h
->plt
.offset
,
6898 plt_info
->symbol_entry
,
6899 plt_info
->symbol_entry_size
);
6901 if (info
->shared
|| htab
->fdpic_p
)
6903 if (plt_info
->symbol_fields
.got20
)
6905 bfd_reloc_status_type r
;
6906 r
= install_movi20_field (output_bfd
, got_offset
,
6907 splt
->owner
, splt
, splt
->contents
,
6909 + plt_info
->symbol_fields
.got_entry
);
6910 BFD_ASSERT (r
== bfd_reloc_ok
);
6913 install_plt_field (output_bfd
, FALSE
, got_offset
,
6916 + plt_info
->symbol_fields
.got_entry
));
6920 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6922 install_plt_field (output_bfd
, FALSE
,
6923 (sgotplt
->output_section
->vma
6924 + sgotplt
->output_offset
6928 + plt_info
->symbol_fields
.got_entry
));
6929 if (htab
->vxworks_p
)
6931 unsigned int reachable_plts
, plts_per_4k
;
6934 /* Divide the PLT into groups. The first group contains
6935 REACHABLE_PLTS entries and the other groups contain
6936 PLTS_PER_4K entries. Entries in the first group can
6937 branch directly to .plt; those in later groups branch
6938 to the last element of the previous group. */
6939 /* ??? It would be better to create multiple copies of
6940 the common resolver stub. */
6941 reachable_plts
= ((4096
6942 - plt_info
->plt0_entry_size
6943 - (plt_info
->symbol_fields
.plt
+ 4))
6944 / plt_info
->symbol_entry_size
) + 1;
6945 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6946 if (plt_index
< reachable_plts
)
6947 distance
= -(h
->plt
.offset
6948 + plt_info
->symbol_fields
.plt
);
6950 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6951 * plt_info
->symbol_entry_size
);
6953 /* Install the 'bra' with this offset. */
6954 bfd_put_16 (output_bfd
,
6955 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6958 + plt_info
->symbol_fields
.plt
));
6961 install_plt_field (output_bfd
, TRUE
,
6962 splt
->output_section
->vma
+ splt
->output_offset
,
6965 + plt_info
->symbol_fields
.plt
));
6968 /* Make got_offset relative to the start of .got.plt. */
6971 got_offset
+= GOT_BIAS
;
6974 got_offset
= plt_index
* 8;
6976 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6977 install_plt_field (output_bfd
, FALSE
,
6978 plt_index
* sizeof (Elf32_External_Rela
),
6981 + plt_info
->symbol_fields
.reloc_offset
));
6983 /* Fill in the entry in the global offset table. */
6984 bfd_put_32 (output_bfd
,
6985 (splt
->output_section
->vma
6986 + splt
->output_offset
6988 + plt_info
->symbol_resolve_offset
),
6989 sgotplt
->contents
+ got_offset
);
6991 bfd_put_32 (output_bfd
,
6992 sh_elf_osec_to_segment (output_bfd
,
6993 htab
->splt
->output_section
),
6994 sgotplt
->contents
+ got_offset
+ 4);
6996 /* Fill in the entry in the .rela.plt section. */
6997 rel
.r_offset
= (sgotplt
->output_section
->vma
6998 + sgotplt
->output_offset
7001 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
7003 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
7006 rel
.r_addend
= GOT_BIAS
;
7008 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
7009 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7011 if (htab
->vxworks_p
&& !info
->shared
)
7013 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7014 Begin by pointing LOC to the first such relocation. */
7015 loc
= (htab
->srelplt2
->contents
7016 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
7018 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7019 for the PLT entry's pointer to the .got.plt entry. */
7020 rel
.r_offset
= (htab
->splt
->output_section
->vma
7021 + htab
->splt
->output_offset
7023 + plt_info
->symbol_fields
.got_entry
);
7024 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
7025 rel
.r_addend
= got_offset
;
7026 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7027 loc
+= sizeof (Elf32_External_Rela
);
7029 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7030 the .got.plt entry, which initially points to .plt. */
7031 rel
.r_offset
= (sgotplt
->output_section
->vma
7032 + sgotplt
->output_offset
7034 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
7036 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7039 if (!h
->def_regular
)
7041 /* Mark the symbol as undefined, rather than as defined in
7042 the .plt section. Leave the value alone. */
7043 sym
->st_shndx
= SHN_UNDEF
;
7047 if (h
->got
.offset
!= (bfd_vma
) -1
7048 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
7049 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
7050 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
7054 Elf_Internal_Rela rel
;
7057 /* This symbol has an entry in the global offset table. Set it
7061 srelgot
= htab
->srelgot
;
7062 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
7064 rel
.r_offset
= (sgot
->output_section
->vma
7065 + sgot
->output_offset
7066 + (h
->got
.offset
&~ (bfd_vma
) 1));
7068 /* If this is a static link, or it is a -Bsymbolic link and the
7069 symbol is defined locally or was forced to be local because
7070 of a version file, we just want to emit a RELATIVE reloc.
7071 The entry in the global offset table will already have been
7072 initialized in the relocate_section function. */
7074 && SYMBOL_REFERENCES_LOCAL (info
, h
))
7078 asection
*sec
= h
->root
.u
.def
.section
;
7080 = elf_section_data (sec
->output_section
)->dynindx
;
7082 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
7083 rel
.r_addend
= (h
->root
.u
.def
.value
7084 + h
->root
.u
.def
.section
->output_offset
);
7088 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
7089 rel
.r_addend
= (h
->root
.u
.def
.value
7090 + h
->root
.u
.def
.section
->output_section
->vma
7091 + h
->root
.u
.def
.section
->output_offset
);
7096 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
7097 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
7101 loc
= srelgot
->contents
;
7102 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7103 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7106 #ifdef INCLUDE_SHMEDIA
7108 struct elf_sh_link_hash_entry
*eh
;
7110 eh
= (struct elf_sh_link_hash_entry
*) h
;
7111 if (eh
->datalabel_got
.offset
!= (bfd_vma
) -1)
7115 Elf_Internal_Rela rel
;
7118 /* This symbol has a datalabel entry in the global offset table.
7122 srelgot
= htab
->srelgot
;
7123 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
7125 rel
.r_offset
= (sgot
->output_section
->vma
7126 + sgot
->output_offset
7127 + (eh
->datalabel_got
.offset
&~ (bfd_vma
) 1));
7129 /* If this is a static link, or it is a -Bsymbolic link and the
7130 symbol is defined locally or was forced to be local because
7131 of a version file, we just want to emit a RELATIVE reloc.
7132 The entry in the global offset table will already have been
7133 initialized in the relocate_section function. */
7135 && SYMBOL_REFERENCES_LOCAL (info
, h
))
7139 asection
*sec
= h
->root
.u
.def
.section
;
7141 = elf_section_data (sec
->output_section
)->dynindx
;
7143 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
7144 rel
.r_addend
= (h
->root
.u
.def
.value
7145 + h
->root
.u
.def
.section
->output_offset
);
7149 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
7150 rel
.r_addend
= (h
->root
.u
.def
.value
7151 + h
->root
.u
.def
.section
->output_section
->vma
7152 + h
->root
.u
.def
.section
->output_offset
);
7157 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
7158 + eh
->datalabel_got
.offset
);
7159 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
7163 loc
= srelgot
->contents
;
7164 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7165 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7173 Elf_Internal_Rela rel
;
7176 /* This symbol needs a copy reloc. Set it up. */
7178 BFD_ASSERT (h
->dynindx
!= -1
7179 && (h
->root
.type
== bfd_link_hash_defined
7180 || h
->root
.type
== bfd_link_hash_defweak
));
7182 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
7184 BFD_ASSERT (s
!= NULL
);
7186 rel
.r_offset
= (h
->root
.u
.def
.value
7187 + h
->root
.u
.def
.section
->output_section
->vma
7188 + h
->root
.u
.def
.section
->output_offset
);
7189 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
7191 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7192 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7195 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7196 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7198 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
7199 || (!htab
->vxworks_p
&& h
== htab
->root
.hgot
))
7200 sym
->st_shndx
= SHN_ABS
;
7205 /* Finish up the dynamic sections. */
7208 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
7210 struct elf_sh_link_hash_table
*htab
;
7214 htab
= sh_elf_hash_table (info
);
7218 sgotplt
= htab
->sgotplt
;
7219 sdyn
= bfd_get_section_by_name (htab
->root
.dynobj
, ".dynamic");
7221 if (htab
->root
.dynamic_sections_created
)
7224 Elf32_External_Dyn
*dyncon
, *dynconend
;
7226 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
7228 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
7229 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
7230 for (; dyncon
< dynconend
; dyncon
++)
7232 Elf_Internal_Dyn dyn
;
7234 #ifdef INCLUDE_SHMEDIA
7238 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
7244 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
7245 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7248 #ifdef INCLUDE_SHMEDIA
7250 name
= info
->init_function
;
7254 name
= info
->fini_function
;
7256 if (dyn
.d_un
.d_val
!= 0)
7258 struct elf_link_hash_entry
*h
;
7260 h
= elf_link_hash_lookup (&htab
->root
, name
,
7261 FALSE
, FALSE
, TRUE
);
7262 if (h
!= NULL
&& (h
->other
& STO_SH5_ISA32
))
7264 dyn
.d_un
.d_val
|= 1;
7265 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7272 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
7273 s
= htab
->root
.hgot
->root
.u
.def
.section
;
7274 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
7275 + s
->output_section
->vma
+ s
->output_offset
;
7276 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7280 s
= htab
->srelplt
->output_section
;
7281 BFD_ASSERT (s
!= NULL
);
7282 dyn
.d_un
.d_ptr
= s
->vma
;
7283 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7287 s
= htab
->srelplt
->output_section
;
7288 BFD_ASSERT (s
!= NULL
);
7289 dyn
.d_un
.d_val
= s
->size
;
7290 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7294 /* My reading of the SVR4 ABI indicates that the
7295 procedure linkage table relocs (DT_JMPREL) should be
7296 included in the overall relocs (DT_RELA). This is
7297 what Solaris does. However, UnixWare can not handle
7298 that case. Therefore, we override the DT_RELASZ entry
7299 here to make it not include the JMPREL relocs. Since
7300 the linker script arranges for .rela.plt to follow all
7301 other relocation sections, we don't have to worry
7302 about changing the DT_RELA entry. */
7303 if (htab
->srelplt
!= NULL
)
7305 s
= htab
->srelplt
->output_section
;
7306 dyn
.d_un
.d_val
-= s
->size
;
7308 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7313 /* Fill in the first entry in the procedure linkage table. */
7315 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
7319 memcpy (splt
->contents
,
7320 htab
->plt_info
->plt0_entry
,
7321 htab
->plt_info
->plt0_entry_size
);
7322 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
7323 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
7324 install_plt_field (output_bfd
, FALSE
,
7325 (sgotplt
->output_section
->vma
7326 + sgotplt
->output_offset
7329 + htab
->plt_info
->plt0_got_fields
[i
]));
7331 if (htab
->vxworks_p
)
7333 /* Finalize the .rela.plt.unloaded contents. */
7334 Elf_Internal_Rela rel
;
7337 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7338 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7339 loc
= htab
->srelplt2
->contents
;
7340 rel
.r_offset
= (splt
->output_section
->vma
7341 + splt
->output_offset
7342 + htab
->plt_info
->plt0_got_fields
[2]);
7343 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
7345 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7346 loc
+= sizeof (Elf32_External_Rela
);
7348 /* Fix up the remaining .rela.plt.unloaded relocations.
7349 They may have the wrong symbol index for _G_O_T_ or
7350 _P_L_T_ depending on the order in which symbols were
7352 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
7354 /* The PLT entry's pointer to the .got.plt slot. */
7355 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
7356 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
7358 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7359 loc
+= sizeof (Elf32_External_Rela
);
7361 /* The .got.plt slot's pointer to .plt. */
7362 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
7363 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
7365 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7366 loc
+= sizeof (Elf32_External_Rela
);
7370 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7371 really seem like the right value. */
7372 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
7376 /* Fill in the first three entries in the global offset table. */
7377 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
7380 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
7382 bfd_put_32 (output_bfd
,
7383 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
7385 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
7386 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
7389 if (sgotplt
&& sgotplt
->size
> 0)
7390 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
7392 /* At the very end of the .rofixup section is a pointer to the GOT. */
7393 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
7395 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
7396 bfd_vma got_value
= hgot
->root
.u
.def
.value
7397 + hgot
->root
.u
.def
.section
->output_section
->vma
7398 + hgot
->root
.u
.def
.section
->output_offset
;
7400 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
7402 /* Make sure we allocated and generated the same number of fixups. */
7403 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
7406 if (htab
->srelfuncdesc
)
7407 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
7408 == htab
->srelfuncdesc
->size
);
7411 BFD_ASSERT (htab
->srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
7412 == htab
->srelgot
->size
);
7417 static enum elf_reloc_type_class
7418 sh_elf_reloc_type_class (const Elf_Internal_Rela
*rela
)
7420 switch ((int) ELF32_R_TYPE (rela
->r_info
))
7423 return reloc_class_relative
;
7425 return reloc_class_plt
;
7427 return reloc_class_copy
;
7429 return reloc_class_normal
;
7433 #if !defined SH_TARGET_ALREADY_DEFINED
7434 /* Support for Linux core dump NOTE sections. */
7437 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7442 switch (note
->descsz
)
7447 case 168: /* Linux/SH */
7449 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
7452 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
7461 /* Make a ".reg/999" section. */
7462 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7463 size
, note
->descpos
+ offset
);
7467 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7469 switch (note
->descsz
)
7474 case 124: /* Linux/SH elf_prpsinfo */
7475 elf_tdata (abfd
)->core_program
7476 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
7477 elf_tdata (abfd
)->core_command
7478 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
7481 /* Note that for some reason, a spurious space is tacked
7482 onto the end of the args in some (at least one anyway)
7483 implementations, so strip it off if it exists. */
7486 char *command
= elf_tdata (abfd
)->core_command
;
7487 int n
= strlen (command
);
7489 if (0 < n
&& command
[n
- 1] == ' ')
7490 command
[n
- 1] = '\0';
7495 #endif /* not SH_TARGET_ALREADY_DEFINED */
7498 /* Return address for Ith PLT stub in section PLT, for relocation REL
7499 or (bfd_vma) -1 if it should not be included. */
7502 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
7503 const arelent
*rel ATTRIBUTE_UNUSED
)
7505 const struct elf_sh_plt_info
*plt_info
;
7507 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
7508 return plt
->vma
+ get_plt_offset (plt_info
, i
);
7511 /* Decide whether to attempt to turn absptr or lsda encodings in
7512 shared libraries into pcrel within the given input section. */
7515 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
7516 struct bfd_link_info
*info
,
7517 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
7519 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
7521 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7528 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7531 sh_elf_encode_eh_address (bfd
*abfd
,
7532 struct bfd_link_info
*info
,
7533 asection
*osec
, bfd_vma offset
,
7534 asection
*loc_sec
, bfd_vma loc_offset
,
7537 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
7538 struct elf_link_hash_entry
*h
;
7541 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
7542 loc_offset
, encoded
);
7544 h
= htab
->root
.hgot
;
7545 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
7547 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
7548 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
7549 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
7550 loc_sec
, loc_offset
, encoded
);
7552 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
7553 == (sh_elf_osec_to_segment
7554 (abfd
, h
->root
.u
.def
.section
->output_section
)));
7556 *encoded
= osec
->vma
+ offset
7557 - (h
->root
.u
.def
.value
7558 + h
->root
.u
.def
.section
->output_section
->vma
7559 + h
->root
.u
.def
.section
->output_offset
);
7561 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
7564 #if !defined SH_TARGET_ALREADY_DEFINED
7565 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7566 #define TARGET_BIG_NAME "elf32-sh"
7567 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7568 #define TARGET_LITTLE_NAME "elf32-shl"
7571 #define ELF_ARCH bfd_arch_sh
7572 #define ELF_TARGET_ID SH_ELF_DATA
7573 #define ELF_MACHINE_CODE EM_SH
7574 #ifdef __QNXTARGET__
7575 #define ELF_MAXPAGESIZE 0x1000
7577 #define ELF_MAXPAGESIZE 0x80
7580 #define elf_symbol_leading_char '_'
7582 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7583 #define bfd_elf32_bfd_reloc_name_lookup \
7584 sh_elf_reloc_name_lookup
7585 #define elf_info_to_howto sh_elf_info_to_howto
7586 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7587 #define elf_backend_relocate_section sh_elf_relocate_section
7588 #define bfd_elf32_bfd_get_relocated_section_contents \
7589 sh_elf_get_relocated_section_contents
7590 #define bfd_elf32_mkobject sh_elf_mkobject
7591 #define elf_backend_object_p sh_elf_object_p
7592 #define bfd_elf32_bfd_set_private_bfd_flags \
7593 sh_elf_set_private_flags
7594 #define bfd_elf32_bfd_copy_private_bfd_data \
7595 sh_elf_copy_private_data
7596 #define bfd_elf32_bfd_merge_private_bfd_data \
7597 sh_elf_merge_private_data
7599 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7600 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7601 #define elf_backend_check_relocs sh_elf_check_relocs
7602 #define elf_backend_copy_indirect_symbol \
7603 sh_elf_copy_indirect_symbol
7604 #define elf_backend_create_dynamic_sections \
7605 sh_elf_create_dynamic_sections
7606 #define bfd_elf32_bfd_link_hash_table_create \
7607 sh_elf_link_hash_table_create
7608 #define elf_backend_adjust_dynamic_symbol \
7609 sh_elf_adjust_dynamic_symbol
7610 #define elf_backend_always_size_sections \
7611 sh_elf_always_size_sections
7612 #define elf_backend_size_dynamic_sections \
7613 sh_elf_size_dynamic_sections
7614 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7615 #define elf_backend_finish_dynamic_symbol \
7616 sh_elf_finish_dynamic_symbol
7617 #define elf_backend_finish_dynamic_sections \
7618 sh_elf_finish_dynamic_sections
7619 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7620 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7621 #define elf_backend_can_make_relative_eh_frame \
7622 sh_elf_use_relative_eh_frame
7623 #define elf_backend_can_make_lsda_relative_eh_frame \
7624 sh_elf_use_relative_eh_frame
7625 #define elf_backend_encode_eh_address \
7626 sh_elf_encode_eh_address
7628 #define elf_backend_can_gc_sections 1
7629 #define elf_backend_can_refcount 1
7630 #define elf_backend_want_got_plt 1
7631 #define elf_backend_plt_readonly 1
7632 #define elf_backend_want_plt_sym 0
7633 #define elf_backend_got_header_size 12
7635 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7637 #include "elf32-target.h"
7639 /* NetBSD support. */
7640 #undef TARGET_BIG_SYM
7641 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7642 #undef TARGET_BIG_NAME
7643 #define TARGET_BIG_NAME "elf32-sh-nbsd"
7644 #undef TARGET_LITTLE_SYM
7645 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7646 #undef TARGET_LITTLE_NAME
7647 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7648 #undef ELF_MAXPAGESIZE
7649 #define ELF_MAXPAGESIZE 0x10000
7650 #undef ELF_COMMONPAGESIZE
7651 #undef elf_symbol_leading_char
7652 #define elf_symbol_leading_char 0
7654 #define elf32_bed elf32_sh_nbsd_bed
7656 #include "elf32-target.h"
7659 /* Linux support. */
7660 #undef TARGET_BIG_SYM
7661 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7662 #undef TARGET_BIG_NAME
7663 #define TARGET_BIG_NAME "elf32-shbig-linux"
7664 #undef TARGET_LITTLE_SYM
7665 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7666 #undef TARGET_LITTLE_NAME
7667 #define TARGET_LITTLE_NAME "elf32-sh-linux"
7668 #undef ELF_COMMONPAGESIZE
7669 #define ELF_COMMONPAGESIZE 0x1000
7671 #undef elf_backend_grok_prstatus
7672 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7673 #undef elf_backend_grok_psinfo
7674 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7676 #define elf32_bed elf32_sh_lin_bed
7678 #include "elf32-target.h"
7681 /* FDPIC support. */
7682 #undef TARGET_BIG_SYM
7683 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7684 #undef TARGET_BIG_NAME
7685 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
7686 #undef TARGET_LITTLE_SYM
7687 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7688 #undef TARGET_LITTLE_NAME
7689 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
7690 #undef elf_backend_modify_program_headers
7691 #define elf_backend_modify_program_headers \
7692 sh_elf_modify_program_headers
7695 #define elf32_bed elf32_sh_fd_bed
7697 #include "elf32-target.h"
7699 #undef elf_backend_modify_program_headers
7701 /* VxWorks support. */
7702 #undef TARGET_BIG_SYM
7703 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7704 #undef TARGET_BIG_NAME
7705 #define TARGET_BIG_NAME "elf32-sh-vxworks"
7706 #undef TARGET_LITTLE_SYM
7707 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7708 #undef TARGET_LITTLE_NAME
7709 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
7711 #define elf32_bed elf32_sh_vxworks_bed
7713 #undef elf_backend_want_plt_sym
7714 #define elf_backend_want_plt_sym 1
7715 #undef elf_symbol_leading_char
7716 #define elf_symbol_leading_char '_'
7717 #define elf_backend_want_got_underscore 1
7718 #undef elf_backend_grok_prstatus
7719 #undef elf_backend_grok_psinfo
7720 #undef elf_backend_add_symbol_hook
7721 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7722 #undef elf_backend_link_output_symbol_hook
7723 #define elf_backend_link_output_symbol_hook \
7724 elf_vxworks_link_output_symbol_hook
7725 #undef elf_backend_emit_relocs
7726 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7727 #undef elf_backend_final_write_processing
7728 #define elf_backend_final_write_processing \
7729 elf_vxworks_final_write_processing
7730 #undef ELF_MAXPAGESIZE
7731 #define ELF_MAXPAGESIZE 0x1000
7732 #undef ELF_COMMONPAGESIZE
7734 #include "elf32-target.h"
7736 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */