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, 2011, 2012
4 Free Software Foundation, Inc.
5 Contributed by Ian Lance Taylor, Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 #include "elf-vxworks.h"
32 #include "libiberty.h"
33 #include "../opcodes/sh-opc.h"
35 static bfd_reloc_status_type sh_elf_reloc
36 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
37 static bfd_reloc_status_type sh_elf_ignore_reloc
38 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
39 static bfd_boolean sh_elf_relax_delete_bytes
40 (bfd
*, asection
*, bfd_vma
, int);
41 static bfd_boolean sh_elf_align_loads
42 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_boolean
*);
44 static bfd_boolean sh_elf_swap_insns
45 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
47 static int sh_elf_optimized_tls_reloc
48 (struct bfd_link_info
*, int, int);
49 static bfd_vma dtpoff_base
50 (struct bfd_link_info
*);
52 (struct bfd_link_info
*, bfd_vma
);
54 /* The name of the dynamic interpreter. This is put in the .interp
57 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
59 /* FDPIC binaries have a default 128K stack. */
60 #define DEFAULT_STACK_SIZE 0x20000
62 #define MINUS_ONE ((bfd_vma) 0 - 1)
64 /* Decide whether a reference to a symbol can be resolved locally or
65 not. If the symbol is protected, we want the local address, but
66 its function descriptor must be assigned by the dynamic linker. */
67 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
68 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
69 || ! elf_hash_table (INFO)->dynamic_sections_created)
71 #define SH_PARTIAL32 TRUE
72 #define SH_SRC_MASK32 0xffffffff
73 #define SH_ELF_RELOC sh_elf_reloc
74 static reloc_howto_type sh_elf_howto_table
[] =
76 #include "elf32-sh-relocs.h"
79 #define SH_PARTIAL32 FALSE
80 #define SH_SRC_MASK32 0
81 #define SH_ELF_RELOC bfd_elf_generic_reloc
82 static reloc_howto_type sh_vxworks_howto_table
[] =
84 #include "elf32-sh-relocs.h"
87 /* Return true if OUTPUT_BFD is a VxWorks object. */
90 vxworks_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
92 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
93 extern const bfd_target bfd_elf32_shlvxworks_vec
;
94 extern const bfd_target bfd_elf32_shvxworks_vec
;
96 return (abfd
->xvec
== &bfd_elf32_shlvxworks_vec
97 || abfd
->xvec
== &bfd_elf32_shvxworks_vec
);
103 /* Return true if OUTPUT_BFD is an FDPIC object. */
106 fdpic_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
108 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
109 extern const bfd_target bfd_elf32_shfd_vec
;
110 extern const bfd_target bfd_elf32_shbfd_vec
;
112 return (abfd
->xvec
== &bfd_elf32_shfd_vec
113 || abfd
->xvec
== &bfd_elf32_shbfd_vec
);
119 /* Return the howto table for ABFD. */
121 static reloc_howto_type
*
122 get_howto_table (bfd
*abfd
)
124 if (vxworks_object_p (abfd
))
125 return sh_vxworks_howto_table
;
126 return sh_elf_howto_table
;
129 static bfd_reloc_status_type
130 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
131 asection
*input_section
, bfd_byte
*contents
,
132 bfd_vma addr
, asection
*symbol_section
,
133 bfd_vma start
, bfd_vma end
)
135 static bfd_vma last_addr
;
136 static asection
*last_symbol_section
;
137 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
142 /* Sanity check the address. */
143 if (addr
> bfd_get_section_limit (input_bfd
, input_section
))
144 return bfd_reloc_outofrange
;
146 /* We require the start and end relocations to be processed consecutively -
147 although we allow then to be processed forwards or backwards. */
151 last_symbol_section
= symbol_section
;
154 if (last_addr
!= addr
)
158 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
159 return bfd_reloc_outofrange
;
161 /* Get the symbol_section contents. */
162 if (symbol_section
!= input_section
)
164 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
165 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
168 if (!bfd_malloc_and_get_section (input_bfd
, symbol_section
,
171 if (contents
!= NULL
)
173 return bfd_reloc_outofrange
;
177 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
178 start_ptr
= contents
+ start
;
179 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
181 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
184 diff
= (last_ptr
- ptr
) >> 1;
185 cum_diff
+= diff
& 1;
188 /* Calculate the start / end values to load into rs / re minus four -
189 so that will cancel out the four we would otherwise have to add to
190 addr to get the value to subtract in order to get relative addressing. */
194 end
= (ptr
+ cum_diff
* 2) - contents
;
198 bfd_vma start0
= start
- 4;
200 while (start0
&& IS_PPI (contents
+ start0
))
202 start0
= start
- 2 - ((start
- start0
) & 2);
203 start
= start0
- cum_diff
- 2;
208 && elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
211 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
213 x
= (insn
& 0x200 ? end
: start
) - addr
;
214 if (input_section
!= symbol_section
)
215 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
216 - (input_section
->output_section
->vma
217 + input_section
->output_offset
));
219 if (x
< -128 || x
> 127)
220 return bfd_reloc_overflow
;
222 x
= (insn
& ~0xff) | (x
& 0xff);
223 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
228 /* This function is used for normal relocs. This used to be like the COFF
229 function, and is almost certainly incorrect for other ELF targets. */
231 static bfd_reloc_status_type
232 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
233 void *data
, asection
*input_section
, bfd
*output_bfd
,
234 char **error_message ATTRIBUTE_UNUSED
)
238 enum elf_sh_reloc_type r_type
;
239 bfd_vma addr
= reloc_entry
->address
;
240 bfd_byte
*hit_data
= addr
+ (bfd_byte
*) data
;
242 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
244 if (output_bfd
!= NULL
)
246 /* Partial linking--do nothing. */
247 reloc_entry
->address
+= input_section
->output_offset
;
251 /* Almost all relocs have to do with relaxing. If any work must be
252 done for them, it has been done in sh_relax_section. */
253 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
256 if (symbol_in
!= NULL
257 && bfd_is_und_section (symbol_in
->section
))
258 return bfd_reloc_undefined
;
260 if (bfd_is_com_section (symbol_in
->section
))
263 sym_value
= (symbol_in
->value
+
264 symbol_in
->section
->output_section
->vma
+
265 symbol_in
->section
->output_offset
);
270 insn
= bfd_get_32 (abfd
, hit_data
);
271 insn
+= sym_value
+ reloc_entry
->addend
;
272 bfd_put_32 (abfd
, (bfd_vma
) insn
, hit_data
);
275 insn
= bfd_get_16 (abfd
, hit_data
);
276 sym_value
+= reloc_entry
->addend
;
277 sym_value
-= (input_section
->output_section
->vma
278 + input_section
->output_offset
281 sym_value
+= (insn
& 0xfff) << 1;
284 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
285 bfd_put_16 (abfd
, (bfd_vma
) insn
, hit_data
);
286 if (sym_value
< (bfd_vma
) -0x1000 || sym_value
>= 0x1000)
287 return bfd_reloc_overflow
;
297 /* This function is used for relocs which are only used for relaxing,
298 which the linker should otherwise ignore. */
300 static bfd_reloc_status_type
301 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
302 asymbol
*symbol ATTRIBUTE_UNUSED
,
303 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
305 char **error_message ATTRIBUTE_UNUSED
)
307 if (output_bfd
!= NULL
)
308 reloc_entry
->address
+= input_section
->output_offset
;
312 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
316 bfd_reloc_code_real_type bfd_reloc_val
;
317 unsigned char elf_reloc_val
;
320 /* An array mapping BFD reloc codes to SH ELF relocs. */
322 static const struct elf_reloc_map sh_reloc_map
[] =
324 { BFD_RELOC_NONE
, R_SH_NONE
},
325 { BFD_RELOC_32
, R_SH_DIR32
},
326 { BFD_RELOC_16
, R_SH_DIR16
},
327 { BFD_RELOC_8
, R_SH_DIR8
},
328 { BFD_RELOC_CTOR
, R_SH_DIR32
},
329 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
330 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
331 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
332 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
333 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
334 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
335 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
336 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
337 { BFD_RELOC_SH_USES
, R_SH_USES
},
338 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
339 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
340 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
341 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
342 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
343 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
344 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
345 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
346 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
347 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
348 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
349 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
350 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
351 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
352 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
353 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
354 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
355 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
356 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
357 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
358 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
359 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
360 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
361 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
362 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
363 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
364 { BFD_RELOC_SH_GOT20
, R_SH_GOT20
},
365 { BFD_RELOC_SH_GOTOFF20
, R_SH_GOTOFF20
},
366 { BFD_RELOC_SH_GOTFUNCDESC
, R_SH_GOTFUNCDESC
},
367 { BFD_RELOC_SH_GOTFUNCDESC20
, R_SH_GOTFUNCDESC20
},
368 { BFD_RELOC_SH_GOTOFFFUNCDESC
, R_SH_GOTOFFFUNCDESC
},
369 { BFD_RELOC_SH_GOTOFFFUNCDESC20
, R_SH_GOTOFFFUNCDESC20
},
370 { BFD_RELOC_SH_FUNCDESC
, R_SH_FUNCDESC
},
371 #ifdef INCLUDE_SHMEDIA
372 { BFD_RELOC_SH_GOT_LOW16
, R_SH_GOT_LOW16
},
373 { BFD_RELOC_SH_GOT_MEDLOW16
, R_SH_GOT_MEDLOW16
},
374 { BFD_RELOC_SH_GOT_MEDHI16
, R_SH_GOT_MEDHI16
},
375 { BFD_RELOC_SH_GOT_HI16
, R_SH_GOT_HI16
},
376 { BFD_RELOC_SH_GOTPLT_LOW16
, R_SH_GOTPLT_LOW16
},
377 { BFD_RELOC_SH_GOTPLT_MEDLOW16
, R_SH_GOTPLT_MEDLOW16
},
378 { BFD_RELOC_SH_GOTPLT_MEDHI16
, R_SH_GOTPLT_MEDHI16
},
379 { BFD_RELOC_SH_GOTPLT_HI16
, R_SH_GOTPLT_HI16
},
380 { BFD_RELOC_SH_PLT_LOW16
, R_SH_PLT_LOW16
},
381 { BFD_RELOC_SH_PLT_MEDLOW16
, R_SH_PLT_MEDLOW16
},
382 { BFD_RELOC_SH_PLT_MEDHI16
, R_SH_PLT_MEDHI16
},
383 { BFD_RELOC_SH_PLT_HI16
, R_SH_PLT_HI16
},
384 { BFD_RELOC_SH_GOTOFF_LOW16
, R_SH_GOTOFF_LOW16
},
385 { BFD_RELOC_SH_GOTOFF_MEDLOW16
, R_SH_GOTOFF_MEDLOW16
},
386 { BFD_RELOC_SH_GOTOFF_MEDHI16
, R_SH_GOTOFF_MEDHI16
},
387 { BFD_RELOC_SH_GOTOFF_HI16
, R_SH_GOTOFF_HI16
},
388 { BFD_RELOC_SH_GOTPC_LOW16
, R_SH_GOTPC_LOW16
},
389 { BFD_RELOC_SH_GOTPC_MEDLOW16
, R_SH_GOTPC_MEDLOW16
},
390 { BFD_RELOC_SH_GOTPC_MEDHI16
, R_SH_GOTPC_MEDHI16
},
391 { BFD_RELOC_SH_GOTPC_HI16
, R_SH_GOTPC_HI16
},
392 { BFD_RELOC_SH_COPY64
, R_SH_COPY64
},
393 { BFD_RELOC_SH_GLOB_DAT64
, R_SH_GLOB_DAT64
},
394 { BFD_RELOC_SH_JMP_SLOT64
, R_SH_JMP_SLOT64
},
395 { BFD_RELOC_SH_RELATIVE64
, R_SH_RELATIVE64
},
396 { BFD_RELOC_SH_GOT10BY4
, R_SH_GOT10BY4
},
397 { BFD_RELOC_SH_GOT10BY8
, R_SH_GOT10BY8
},
398 { BFD_RELOC_SH_GOTPLT10BY4
, R_SH_GOTPLT10BY4
},
399 { BFD_RELOC_SH_GOTPLT10BY8
, R_SH_GOTPLT10BY8
},
400 { BFD_RELOC_SH_PT_16
, R_SH_PT_16
},
401 { BFD_RELOC_SH_SHMEDIA_CODE
, R_SH_SHMEDIA_CODE
},
402 { BFD_RELOC_SH_IMMU5
, R_SH_DIR5U
},
403 { BFD_RELOC_SH_IMMS6
, R_SH_DIR6S
},
404 { BFD_RELOC_SH_IMMU6
, R_SH_DIR6U
},
405 { BFD_RELOC_SH_IMMS10
, R_SH_DIR10S
},
406 { BFD_RELOC_SH_IMMS10BY2
, R_SH_DIR10SW
},
407 { BFD_RELOC_SH_IMMS10BY4
, R_SH_DIR10SL
},
408 { BFD_RELOC_SH_IMMS10BY8
, R_SH_DIR10SQ
},
409 { BFD_RELOC_SH_IMMS16
, R_SH_IMMS16
},
410 { BFD_RELOC_SH_IMMU16
, R_SH_IMMU16
},
411 { BFD_RELOC_SH_IMM_LOW16
, R_SH_IMM_LOW16
},
412 { BFD_RELOC_SH_IMM_LOW16_PCREL
, R_SH_IMM_LOW16_PCREL
},
413 { BFD_RELOC_SH_IMM_MEDLOW16
, R_SH_IMM_MEDLOW16
},
414 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL
, R_SH_IMM_MEDLOW16_PCREL
},
415 { BFD_RELOC_SH_IMM_MEDHI16
, R_SH_IMM_MEDHI16
},
416 { BFD_RELOC_SH_IMM_MEDHI16_PCREL
, R_SH_IMM_MEDHI16_PCREL
},
417 { BFD_RELOC_SH_IMM_HI16
, R_SH_IMM_HI16
},
418 { BFD_RELOC_SH_IMM_HI16_PCREL
, R_SH_IMM_HI16_PCREL
},
419 { BFD_RELOC_64
, R_SH_64
},
420 { BFD_RELOC_64_PCREL
, R_SH_64_PCREL
},
421 #endif /* not INCLUDE_SHMEDIA */
424 /* Given a BFD reloc code, return the howto structure for the
425 corresponding SH ELF reloc. */
427 static reloc_howto_type
*
428 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
432 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
434 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
435 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
441 static reloc_howto_type
*
442 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
446 if (vxworks_object_p (abfd
))
449 i
< (sizeof (sh_vxworks_howto_table
)
450 / sizeof (sh_vxworks_howto_table
[0]));
452 if (sh_vxworks_howto_table
[i
].name
!= NULL
453 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
454 return &sh_vxworks_howto_table
[i
];
459 i
< (sizeof (sh_elf_howto_table
)
460 / sizeof (sh_elf_howto_table
[0]));
462 if (sh_elf_howto_table
[i
].name
!= NULL
463 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
464 return &sh_elf_howto_table
[i
];
470 /* Given an ELF reloc, fill in the howto field of a relent. */
473 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
477 r
= ELF32_R_TYPE (dst
->r_info
);
479 BFD_ASSERT (r
< (unsigned int) R_SH_max
);
480 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC
|| r
> R_SH_LAST_INVALID_RELOC
);
481 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_2
|| r
> R_SH_LAST_INVALID_RELOC_2
);
482 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_3
|| r
> R_SH_LAST_INVALID_RELOC_3
);
483 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_4
|| r
> R_SH_LAST_INVALID_RELOC_4
);
484 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_5
|| r
> R_SH_LAST_INVALID_RELOC_5
);
485 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_6
|| r
> R_SH_LAST_INVALID_RELOC_6
);
487 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
490 /* This function handles relaxing for SH ELF. See the corresponding
491 function in coff-sh.c for a description of what this does. FIXME:
492 There is a lot of duplication here between this code and the COFF
493 specific code. The format of relocs and symbols is wound deeply
494 into this code, but it would still be better if the duplication
495 could be eliminated somehow. Note in particular that although both
496 functions use symbols like R_SH_CODE, those symbols have different
497 values; in coff-sh.c they come from include/coff/sh.h, whereas here
498 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
501 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
502 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
504 Elf_Internal_Shdr
*symtab_hdr
;
505 Elf_Internal_Rela
*internal_relocs
;
506 bfd_boolean have_code
;
507 Elf_Internal_Rela
*irel
, *irelend
;
508 bfd_byte
*contents
= NULL
;
509 Elf_Internal_Sym
*isymbuf
= NULL
;
513 if (link_info
->relocatable
514 || (sec
->flags
& SEC_RELOC
) == 0
515 || sec
->reloc_count
== 0)
518 #ifdef INCLUDE_SHMEDIA
519 if (elf_section_data (sec
)->this_hdr
.sh_flags
520 & (SHF_SH5_ISA32
| SHF_SH5_ISA32_MIXED
))
526 symtab_hdr
= &elf_symtab_hdr (abfd
);
528 internal_relocs
= (_bfd_elf_link_read_relocs
529 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
530 link_info
->keep_memory
));
531 if (internal_relocs
== NULL
)
536 irelend
= internal_relocs
+ sec
->reloc_count
;
537 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
539 bfd_vma laddr
, paddr
, symval
;
541 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
544 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
547 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
550 /* Get the section contents. */
551 if (contents
== NULL
)
553 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
554 contents
= elf_section_data (sec
)->this_hdr
.contents
;
557 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
562 /* The r_addend field of the R_SH_USES reloc will point us to
563 the register load. The 4 is because the r_addend field is
564 computed as though it were a jump offset, which are based
565 from 4 bytes after the jump instruction. */
566 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
567 if (laddr
>= sec
->size
)
569 (*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
571 (unsigned long) irel
->r_offset
);
574 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
576 /* If the instruction is not mov.l NN,rN, we don't know what to
578 if ((insn
& 0xf000) != 0xd000)
580 ((*_bfd_error_handler
)
581 (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
582 abfd
, (unsigned long) irel
->r_offset
, insn
));
586 /* Get the address from which the register is being loaded. The
587 displacement in the mov.l instruction is quadrupled. It is a
588 displacement from four bytes after the movl instruction, but,
589 before adding in the PC address, two least significant bits
590 of the PC are cleared. We assume that the section is aligned
591 on a four byte boundary. */
594 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
595 if (paddr
>= sec
->size
)
597 ((*_bfd_error_handler
)
598 (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
599 abfd
, (unsigned long) irel
->r_offset
));
603 /* Get the reloc for the address from which the register is
604 being loaded. This reloc will tell us which function is
605 actually being called. */
606 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
607 if (irelfn
->r_offset
== paddr
608 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
610 if (irelfn
>= irelend
)
612 ((*_bfd_error_handler
)
613 (_("%B: 0x%lx: warning: could not find expected reloc"),
614 abfd
, (unsigned long) paddr
));
618 /* Read this BFD's symbols if we haven't done so already. */
619 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
621 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
623 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
624 symtab_hdr
->sh_info
, 0,
630 /* Get the value of the symbol referred to by the reloc. */
631 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
633 /* A local symbol. */
634 Elf_Internal_Sym
*isym
;
636 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
638 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
640 ((*_bfd_error_handler
)
641 (_("%B: 0x%lx: warning: symbol in unexpected section"),
642 abfd
, (unsigned long) paddr
));
646 symval
= (isym
->st_value
647 + sec
->output_section
->vma
648 + sec
->output_offset
);
653 struct elf_link_hash_entry
*h
;
655 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
656 h
= elf_sym_hashes (abfd
)[indx
];
657 BFD_ASSERT (h
!= NULL
);
658 if (h
->root
.type
!= bfd_link_hash_defined
659 && h
->root
.type
!= bfd_link_hash_defweak
)
661 /* This appears to be a reference to an undefined
662 symbol. Just ignore it--it will be caught by the
663 regular reloc processing. */
667 symval
= (h
->root
.u
.def
.value
668 + h
->root
.u
.def
.section
->output_section
->vma
669 + h
->root
.u
.def
.section
->output_offset
);
672 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
673 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
675 symval
+= irelfn
->r_addend
;
677 /* See if this function call can be shortened. */
680 + sec
->output_section
->vma
683 /* A branch to an address beyond ours might be increased by an
684 .align that doesn't move when bytes behind us are deleted.
685 So, we add some slop in this calculation to allow for
687 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
689 /* After all that work, we can't shorten this function call. */
693 /* Shorten the function call. */
695 /* For simplicity of coding, we are going to modify the section
696 contents, the section relocs, and the BFD symbol table. We
697 must tell the rest of the code not to free up this
698 information. It would be possible to instead create a table
699 of changes which have to be made, as is done in coff-mips.c;
700 that would be more work, but would require less memory when
701 the linker is run. */
703 elf_section_data (sec
)->relocs
= internal_relocs
;
704 elf_section_data (sec
)->this_hdr
.contents
= contents
;
705 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
707 /* Replace the jsr with a bsr. */
709 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
710 replace the jsr with a bsr. */
711 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
712 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
713 here, but that only checks if the symbol is an external symbol,
714 not if the symbol is in a different section. Besides, we need
715 a consistent meaning for the relocation, so we just assume here that
716 the value of the symbol is not available. */
718 /* We can't fully resolve this yet, because the external
719 symbol value may be changed by future relaxing. We let
720 the final link phase handle it. */
721 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
725 /* When we calculated the symbol "value" we had an offset in the
726 DIR32's word in memory (we read and add it above). However,
727 the jsr we create does NOT have this offset encoded, so we
728 have to add it to the addend to preserve it. */
729 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
731 /* See if there is another R_SH_USES reloc referring to the same
733 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
734 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
735 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
737 if (irelscan
< irelend
)
739 /* Some other function call depends upon this register load,
740 and we have not yet converted that function call.
741 Indeed, we may never be able to convert it. There is
742 nothing else we can do at this point. */
746 /* Look for a R_SH_COUNT reloc on the location where the
747 function address is stored. Do this before deleting any
748 bytes, to avoid confusion about the address. */
749 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
750 if (irelcount
->r_offset
== paddr
751 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
754 /* Delete the register load. */
755 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
758 /* That will change things, so, just in case it permits some
759 other function call to come within range, we should relax
760 again. Note that this is not required, and it may be slow. */
763 /* Now check whether we got a COUNT reloc. */
764 if (irelcount
>= irelend
)
766 ((*_bfd_error_handler
)
767 (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
768 abfd
, (unsigned long) paddr
));
772 /* The number of uses is stored in the r_addend field. We've
774 if (irelcount
->r_addend
== 0)
776 ((*_bfd_error_handler
) (_("%B: 0x%lx: warning: bad count"),
778 (unsigned long) paddr
));
782 --irelcount
->r_addend
;
784 /* If there are no more uses, we can delete the address. Reload
785 the address from irelfn, in case it was changed by the
786 previous call to sh_elf_relax_delete_bytes. */
787 if (irelcount
->r_addend
== 0)
789 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
793 /* We've done all we can with that function call. */
796 /* Look for load and store instructions that we can align on four
798 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
803 /* Get the section contents. */
804 if (contents
== NULL
)
806 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
807 contents
= elf_section_data (sec
)->this_hdr
.contents
;
810 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
815 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
821 elf_section_data (sec
)->relocs
= internal_relocs
;
822 elf_section_data (sec
)->this_hdr
.contents
= contents
;
823 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
828 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
830 if (! link_info
->keep_memory
)
834 /* Cache the symbols for elf_link_input_bfd. */
835 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
840 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
842 if (! link_info
->keep_memory
)
846 /* Cache the section contents for elf_link_input_bfd. */
847 elf_section_data (sec
)->this_hdr
.contents
= contents
;
851 if (internal_relocs
!= NULL
852 && elf_section_data (sec
)->relocs
!= internal_relocs
)
853 free (internal_relocs
);
859 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
862 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
864 if (internal_relocs
!= NULL
865 && elf_section_data (sec
)->relocs
!= internal_relocs
)
866 free (internal_relocs
);
871 /* Delete some bytes from a section while relaxing. FIXME: There is a
872 lot of duplication between this function and sh_relax_delete_bytes
876 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
879 Elf_Internal_Shdr
*symtab_hdr
;
880 unsigned int sec_shndx
;
882 Elf_Internal_Rela
*irel
, *irelend
;
883 Elf_Internal_Rela
*irelalign
;
885 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
886 struct elf_link_hash_entry
**sym_hashes
;
887 struct elf_link_hash_entry
**end_hashes
;
888 unsigned int symcount
;
891 symtab_hdr
= &elf_symtab_hdr (abfd
);
892 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
894 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
896 contents
= elf_section_data (sec
)->this_hdr
.contents
;
898 /* The deletion must stop at the next ALIGN reloc for an aligment
899 power larger than the number of bytes we are deleting. */
904 irel
= elf_section_data (sec
)->relocs
;
905 irelend
= irel
+ sec
->reloc_count
;
906 for (; irel
< irelend
; irel
++)
908 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
909 && irel
->r_offset
> addr
910 && count
< (1 << irel
->r_addend
))
913 toaddr
= irel
->r_offset
;
918 /* Actually delete the bytes. */
919 memmove (contents
+ addr
, contents
+ addr
+ count
,
920 (size_t) (toaddr
- addr
- count
));
921 if (irelalign
== NULL
)
927 #define NOP_OPCODE (0x0009)
929 BFD_ASSERT ((count
& 1) == 0);
930 for (i
= 0; i
< count
; i
+= 2)
931 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
934 /* Adjust all the relocs. */
935 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
937 bfd_vma nraddr
, stop
;
940 int off
, adjust
, oinsn
;
941 bfd_signed_vma voff
= 0;
942 bfd_boolean overflow
;
944 /* Get the new reloc address. */
945 nraddr
= irel
->r_offset
;
946 if ((irel
->r_offset
> addr
947 && irel
->r_offset
< toaddr
)
948 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
949 && irel
->r_offset
== toaddr
))
952 /* See if this reloc was for the bytes we have deleted, in which
953 case we no longer care about it. Don't delete relocs which
954 represent addresses, though. */
955 if (irel
->r_offset
>= addr
956 && irel
->r_offset
< addr
+ count
957 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
958 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
959 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
960 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
961 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
964 /* If this is a PC relative reloc, see if the range it covers
965 includes the bytes we have deleted. */
966 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
975 start
= irel
->r_offset
;
976 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
980 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
987 /* If this reloc is against a symbol defined in this
988 section, and the symbol will not be adjusted below, we
989 must check the addend to see it will put the value in
990 range to be adjusted, and hence must be changed. */
991 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
993 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
994 if (isym
->st_shndx
== sec_shndx
995 && (isym
->st_value
<= addr
996 || isym
->st_value
>= toaddr
))
1000 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
1002 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
1003 val
+= isym
->st_value
;
1004 if (val
> addr
&& val
< toaddr
)
1005 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
1009 val
= isym
->st_value
+ irel
->r_addend
;
1010 if (val
> addr
&& val
< toaddr
)
1011 irel
->r_addend
-= count
;
1015 start
= stop
= addr
;
1022 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1029 /* This has been made by previous relaxation. Since the
1030 relocation will be against an external symbol, the
1031 final relocation will just do the right thing. */
1032 start
= stop
= addr
;
1038 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1040 /* The addend will be against the section symbol, thus
1041 for adjusting the addend, the relevant start is the
1042 start of the section.
1043 N.B. If we want to abandon in-place changes here and
1044 test directly using symbol + addend, we have to take into
1045 account that the addend has already been adjusted by -4. */
1046 if (stop
> addr
&& stop
< toaddr
)
1047 irel
->r_addend
-= count
;
1053 stop
= start
+ 4 + off
* 2;
1058 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1064 /* These relocs types represent
1066 The r_addend field holds the difference between the reloc
1067 address and L1. That is the start of the reloc, and
1068 adding in the contents gives us the top. We must adjust
1069 both the r_offset field and the section contents.
1070 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1071 and the elf bfd r_offset is called r_vaddr. */
1073 stop
= irel
->r_offset
;
1074 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1078 && (stop
<= addr
|| stop
>= toaddr
))
1079 irel
->r_addend
+= count
;
1080 else if (stop
> addr
1082 && (start
<= addr
|| start
>= toaddr
))
1083 irel
->r_addend
-= count
;
1085 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1086 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1087 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1088 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1090 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1091 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1096 start
= irel
->r_offset
;
1097 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1098 + (long) irel
->r_addend
1105 && (stop
<= addr
|| stop
>= toaddr
))
1107 else if (stop
> addr
1109 && (start
<= addr
|| start
>= toaddr
))
1118 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1127 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1129 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1134 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1136 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1140 BFD_ASSERT (adjust
== count
|| count
>= 4);
1145 if ((irel
->r_offset
& 3) == 0)
1148 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1150 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1155 if (voff
< 0 || voff
>= 0xff)
1157 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1162 if (voff
< - 0x8000 || voff
>= 0x8000)
1164 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1169 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1173 irel
->r_addend
+= adjust
;
1179 ((*_bfd_error_handler
)
1180 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1181 abfd
, (unsigned long) irel
->r_offset
));
1182 bfd_set_error (bfd_error_bad_value
);
1187 irel
->r_offset
= nraddr
;
1190 /* Look through all the other sections. If there contain any IMM32
1191 relocs against internal symbols which we are not going to adjust
1192 below, we may need to adjust the addends. */
1193 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1195 Elf_Internal_Rela
*internal_relocs
;
1196 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1197 bfd_byte
*ocontents
;
1200 || (o
->flags
& SEC_RELOC
) == 0
1201 || o
->reloc_count
== 0)
1204 /* We always cache the relocs. Perhaps, if info->keep_memory is
1205 FALSE, we should free them, if we are permitted to, when we
1206 leave sh_coff_relax_section. */
1207 internal_relocs
= (_bfd_elf_link_read_relocs
1208 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
));
1209 if (internal_relocs
== NULL
)
1213 irelscanend
= internal_relocs
+ o
->reloc_count
;
1214 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1216 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1217 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1219 bfd_vma start
, stop
;
1220 bfd_signed_vma voff
;
1222 if (ocontents
== NULL
)
1224 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1225 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1228 /* We always cache the section contents.
1229 Perhaps, if info->keep_memory is FALSE, we
1230 should free them, if we are permitted to,
1231 when we leave sh_coff_relax_section. */
1232 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1234 if (ocontents
!= NULL
)
1239 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1243 stop
= irelscan
->r_offset
;
1245 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1247 /* STOP is in a different section, so it won't change. */
1248 if (start
> addr
&& start
< toaddr
)
1249 irelscan
->r_addend
+= count
;
1251 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1252 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1256 && (stop
<= addr
|| stop
>= toaddr
))
1257 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1258 ocontents
+ irelscan
->r_offset
);
1259 else if (stop
> addr
1261 && (start
<= addr
|| start
>= toaddr
))
1262 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1263 ocontents
+ irelscan
->r_offset
);
1266 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1269 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1273 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1274 if (isym
->st_shndx
== sec_shndx
1275 && (isym
->st_value
<= addr
1276 || isym
->st_value
>= toaddr
))
1280 if (ocontents
== NULL
)
1282 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1283 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1286 /* We always cache the section contents.
1287 Perhaps, if info->keep_memory is FALSE, we
1288 should free them, if we are permitted to,
1289 when we leave sh_coff_relax_section. */
1290 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1292 if (ocontents
!= NULL
)
1297 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1301 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1302 val
+= isym
->st_value
;
1303 if (val
> addr
&& val
< toaddr
)
1304 bfd_put_32 (abfd
, val
- count
,
1305 ocontents
+ irelscan
->r_offset
);
1310 /* Adjust the local symbols defined in this section. */
1311 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1312 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1314 if (isym
->st_shndx
== sec_shndx
1315 && isym
->st_value
> addr
1316 && isym
->st_value
< toaddr
)
1317 isym
->st_value
-= count
;
1320 /* Now adjust the global symbols defined in this section. */
1321 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1322 - symtab_hdr
->sh_info
);
1323 sym_hashes
= elf_sym_hashes (abfd
);
1324 end_hashes
= sym_hashes
+ symcount
;
1325 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1327 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1328 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1329 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1330 && sym_hash
->root
.u
.def
.section
== sec
1331 && sym_hash
->root
.u
.def
.value
> addr
1332 && sym_hash
->root
.u
.def
.value
< toaddr
)
1334 sym_hash
->root
.u
.def
.value
-= count
;
1338 /* See if we can move the ALIGN reloc forward. We have adjusted
1339 r_offset for it already. */
1340 if (irelalign
!= NULL
)
1342 bfd_vma alignto
, alignaddr
;
1344 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1345 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1346 1 << irelalign
->r_addend
);
1347 if (alignto
!= alignaddr
)
1349 /* Tail recursion. */
1350 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1351 (int) (alignto
- alignaddr
));
1358 /* Look for loads and stores which we can align to four byte
1359 boundaries. This is like sh_align_loads in coff-sh.c. */
1362 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1363 Elf_Internal_Rela
*internal_relocs
,
1364 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1365 bfd_boolean
*pswapped
)
1367 Elf_Internal_Rela
*irel
, *irelend
;
1368 bfd_vma
*labels
= NULL
;
1369 bfd_vma
*label
, *label_end
;
1374 irelend
= internal_relocs
+ sec
->reloc_count
;
1376 /* Get all the addresses with labels on them. */
1377 amt
= sec
->reloc_count
;
1378 amt
*= sizeof (bfd_vma
);
1379 labels
= (bfd_vma
*) bfd_malloc (amt
);
1383 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1385 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1387 *label_end
= irel
->r_offset
;
1392 /* Note that the assembler currently always outputs relocs in
1393 address order. If that ever changes, this code will need to sort
1394 the label values and the relocs. */
1398 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1400 bfd_vma start
, stop
;
1402 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1405 start
= irel
->r_offset
;
1407 for (irel
++; irel
< irelend
; irel
++)
1408 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1411 stop
= irel
->r_offset
;
1415 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1416 internal_relocs
, &label
,
1417 label_end
, start
, stop
, pswapped
))
1432 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1435 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1436 bfd_byte
*contents
, bfd_vma addr
)
1438 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1439 unsigned short i1
, i2
;
1440 Elf_Internal_Rela
*irel
, *irelend
;
1442 /* Swap the instructions themselves. */
1443 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1444 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1445 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1446 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1448 /* Adjust all reloc addresses. */
1449 irelend
= internal_relocs
+ sec
->reloc_count
;
1450 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1452 enum elf_sh_reloc_type type
;
1455 /* There are a few special types of relocs that we don't want to
1456 adjust. These relocs do not apply to the instruction itself,
1457 but are only associated with the address. */
1458 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1459 if (type
== R_SH_ALIGN
1460 || type
== R_SH_CODE
1461 || type
== R_SH_DATA
1462 || type
== R_SH_LABEL
)
1465 /* If an R_SH_USES reloc points to one of the addresses being
1466 swapped, we must adjust it. It would be incorrect to do this
1467 for a jump, though, since we want to execute both
1468 instructions after the jump. (We have avoided swapping
1469 around a label, so the jump will not wind up executing an
1470 instruction it shouldn't). */
1471 if (type
== R_SH_USES
)
1475 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1477 irel
->r_offset
+= 2;
1478 else if (off
== addr
+ 2)
1479 irel
->r_offset
-= 2;
1482 if (irel
->r_offset
== addr
)
1484 irel
->r_offset
+= 2;
1487 else if (irel
->r_offset
== addr
+ 2)
1489 irel
->r_offset
-= 2;
1498 unsigned short insn
, oinsn
;
1499 bfd_boolean overflow
;
1501 loc
= contents
+ irel
->r_offset
;
1510 insn
= bfd_get_16 (abfd
, loc
);
1513 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1515 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1519 insn
= bfd_get_16 (abfd
, loc
);
1522 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1524 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1528 /* This reloc ignores the least significant 3 bits of
1529 the program counter before adding in the offset.
1530 This means that if ADDR is at an even address, the
1531 swap will not affect the offset. If ADDR is an at an
1532 odd address, then the instruction will be crossing a
1533 four byte boundary, and must be adjusted. */
1534 if ((addr
& 3) != 0)
1536 insn
= bfd_get_16 (abfd
, loc
);
1539 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1541 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1549 ((*_bfd_error_handler
)
1550 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1551 abfd
, (unsigned long) irel
->r_offset
));
1552 bfd_set_error (bfd_error_bad_value
);
1560 #endif /* defined SH64_ELF */
1562 /* Describes one of the various PLT styles. */
1564 struct elf_sh_plt_info
1566 /* The template for the first PLT entry, or NULL if there is no special
1568 const bfd_byte
*plt0_entry
;
1570 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1571 bfd_vma plt0_entry_size
;
1573 /* Index I is the offset into PLT0_ENTRY of a pointer to
1574 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1575 if there is no such pointer. */
1576 bfd_vma plt0_got_fields
[3];
1578 /* The template for a symbol's PLT entry. */
1579 const bfd_byte
*symbol_entry
;
1581 /* The size of SYMBOL_ENTRY in bytes. */
1582 bfd_vma symbol_entry_size
;
1584 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1585 on all targets. The comments by each member indicate the value
1586 that the field must hold. */
1588 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1589 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1590 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1591 bfd_boolean got20
; /* TRUE if got_entry points to a movi20
1592 instruction (instead of a constant pool
1596 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1597 bfd_vma symbol_resolve_offset
;
1599 /* A different PLT layout which can be used for the first
1600 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1602 const struct elf_sh_plt_info
*short_plt
;
1605 #ifdef INCLUDE_SHMEDIA
1607 /* The size in bytes of an entry in the procedure linkage table. */
1609 #define ELF_PLT_ENTRY_SIZE 64
1611 /* First entry in an absolute procedure linkage table look like this. */
1613 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1615 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1616 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1617 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1618 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1619 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1620 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
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 */
1630 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1633 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1635 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1636 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1637 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1638 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1639 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1640 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
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 */
1650 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1653 /* Sebsequent entries in an absolute procedure linkage table look like
1656 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1658 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1659 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1660 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1661 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1662 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1663 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1664 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1665 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1666 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1667 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1668 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1669 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1670 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1671 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1672 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1673 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1676 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1678 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1679 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1680 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1681 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1682 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1683 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1684 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1685 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1686 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1687 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1688 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1689 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1690 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1691 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1692 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1693 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1696 /* Entries in a PIC procedure linkage table look like this. */
1698 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1700 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1701 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1702 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1703 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1704 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1705 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1706 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1707 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1708 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1709 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1710 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1711 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1712 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1713 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1714 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1715 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1718 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1720 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1721 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1722 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1723 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1724 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1725 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1726 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1727 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1728 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1729 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1730 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1731 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1732 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1733 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1734 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1735 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1738 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1741 /* Big-endian non-PIC. */
1742 elf_sh_plt0_entry_be
,
1744 { 0, MINUS_ONE
, MINUS_ONE
},
1745 elf_sh_plt_entry_be
,
1747 { 0, 32, 48, FALSE
},
1748 33, /* includes ISA encoding */
1752 /* Little-endian non-PIC. */
1753 elf_sh_plt0_entry_le
,
1755 { 0, MINUS_ONE
, MINUS_ONE
},
1756 elf_sh_plt_entry_le
,
1758 { 0, 32, 48, FALSE
},
1759 33, /* includes ISA encoding */
1765 /* Big-endian PIC. */
1766 elf_sh_plt0_entry_be
,
1768 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1769 elf_sh_pic_plt_entry_be
,
1771 { 0, MINUS_ONE
, 52, FALSE
},
1772 33, /* includes ISA encoding */
1776 /* Little-endian PIC. */
1777 elf_sh_plt0_entry_le
,
1779 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1780 elf_sh_pic_plt_entry_le
,
1782 { 0, MINUS_ONE
, 52, FALSE
},
1783 33, /* includes ISA encoding */
1789 /* Return offset of the linker in PLT0 entry. */
1790 #define elf_sh_plt0_gotplt_offset(info) 0
1792 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1793 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1796 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1799 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p
,
1800 unsigned long value
, bfd_byte
*addr
)
1803 bfd_put_32 (output_bfd
,
1804 bfd_get_32 (output_bfd
, addr
)
1805 | ((value
>> 6) & 0x3fffc00),
1807 bfd_put_32 (output_bfd
,
1808 bfd_get_32 (output_bfd
, addr
+ 4)
1809 | ((value
<< 10) & 0x3fffc00),
1813 /* Return the type of PLT associated with ABFD. PIC_P is true if
1814 the object is position-independent. */
1816 static const struct elf_sh_plt_info
*
1817 get_plt_info (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean pic_p
)
1819 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
1822 /* The size in bytes of an entry in the procedure linkage table. */
1824 #define ELF_PLT_ENTRY_SIZE 28
1826 /* First entry in an absolute procedure linkage table look like this. */
1828 /* Note - this code has been "optimised" not to use r2. r2 is used by
1829 GCC to return the address of large structures, so it should not be
1830 corrupted here. This does mean however, that this PLT does not conform
1831 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1832 and r2 contains the GOT id. This version stores the GOT id in r0 and
1833 ignores the type. Loaders can easily detect this difference however,
1834 since the type will always be 0 or 8, and the GOT ids will always be
1835 greater than or equal to 12. */
1836 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1838 0xd0, 0x05, /* mov.l 2f,r0 */
1839 0x60, 0x02, /* mov.l @r0,r0 */
1840 0x2f, 0x06, /* mov.l r0,@-r15 */
1841 0xd0, 0x03, /* mov.l 1f,r0 */
1842 0x60, 0x02, /* mov.l @r0,r0 */
1843 0x40, 0x2b, /* jmp @r0 */
1844 0x60, 0xf6, /* mov.l @r15+,r0 */
1845 0x00, 0x09, /* nop */
1846 0x00, 0x09, /* nop */
1847 0x00, 0x09, /* nop */
1848 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1849 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1852 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1854 0x05, 0xd0, /* mov.l 2f,r0 */
1855 0x02, 0x60, /* mov.l @r0,r0 */
1856 0x06, 0x2f, /* mov.l r0,@-r15 */
1857 0x03, 0xd0, /* mov.l 1f,r0 */
1858 0x02, 0x60, /* mov.l @r0,r0 */
1859 0x2b, 0x40, /* jmp @r0 */
1860 0xf6, 0x60, /* mov.l @r15+,r0 */
1861 0x09, 0x00, /* nop */
1862 0x09, 0x00, /* nop */
1863 0x09, 0x00, /* nop */
1864 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1865 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1868 /* Sebsequent entries in an absolute procedure linkage table look like
1871 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1873 0xd0, 0x04, /* mov.l 1f,r0 */
1874 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1875 0xd1, 0x02, /* mov.l 0f,r1 */
1876 0x40, 0x2b, /* jmp @r0 */
1877 0x60, 0x13, /* mov r1,r0 */
1878 0xd1, 0x03, /* mov.l 2f,r1 */
1879 0x40, 0x2b, /* jmp @r0 */
1880 0x00, 0x09, /* nop */
1881 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1882 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1883 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1886 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1888 0x04, 0xd0, /* mov.l 1f,r0 */
1889 0x02, 0x60, /* mov.l @r0,r0 */
1890 0x02, 0xd1, /* mov.l 0f,r1 */
1891 0x2b, 0x40, /* jmp @r0 */
1892 0x13, 0x60, /* mov r1,r0 */
1893 0x03, 0xd1, /* mov.l 2f,r1 */
1894 0x2b, 0x40, /* jmp @r0 */
1895 0x09, 0x00, /* nop */
1896 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1897 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1898 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1901 /* Entries in a PIC procedure linkage table look like this. */
1903 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1905 0xd0, 0x04, /* mov.l 1f,r0 */
1906 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1907 0x40, 0x2b, /* jmp @r0 */
1908 0x00, 0x09, /* nop */
1909 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1910 0xd1, 0x03, /* mov.l 2f,r1 */
1911 0x40, 0x2b, /* jmp @r0 */
1912 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1913 0x00, 0x09, /* nop */
1914 0x00, 0x09, /* nop */
1915 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1916 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1919 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1921 0x04, 0xd0, /* mov.l 1f,r0 */
1922 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1923 0x2b, 0x40, /* jmp @r0 */
1924 0x09, 0x00, /* nop */
1925 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1926 0x03, 0xd1, /* mov.l 2f,r1 */
1927 0x2b, 0x40, /* jmp @r0 */
1928 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1929 0x09, 0x00, /* nop */
1930 0x09, 0x00, /* nop */
1931 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1932 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1935 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1938 /* Big-endian non-PIC. */
1939 elf_sh_plt0_entry_be
,
1941 { MINUS_ONE
, 24, 20 },
1942 elf_sh_plt_entry_be
,
1944 { 20, 16, 24, FALSE
},
1949 /* Little-endian non-PIC. */
1950 elf_sh_plt0_entry_le
,
1952 { MINUS_ONE
, 24, 20 },
1953 elf_sh_plt_entry_le
,
1955 { 20, 16, 24, FALSE
},
1962 /* Big-endian PIC. */
1963 elf_sh_plt0_entry_be
,
1965 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1966 elf_sh_pic_plt_entry_be
,
1968 { 20, MINUS_ONE
, 24, FALSE
},
1973 /* Little-endian PIC. */
1974 elf_sh_plt0_entry_le
,
1976 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1977 elf_sh_pic_plt_entry_le
,
1979 { 20, MINUS_ONE
, 24, FALSE
},
1986 #define VXWORKS_PLT_HEADER_SIZE 12
1987 #define VXWORKS_PLT_ENTRY_SIZE 24
1989 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1991 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1992 0x61, 0x12, /* mov.l @r1,r1 */
1993 0x41, 0x2b, /* jmp @r1 */
1994 0x00, 0x09, /* nop */
1995 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1998 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
2000 0x01, 0xd1, /* mov.l @(8,pc),r1 */
2001 0x12, 0x61, /* mov.l @r1,r1 */
2002 0x2b, 0x41, /* jmp @r1 */
2003 0x09, 0x00, /* nop */
2004 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2007 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
2009 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2010 0x60, 0x02, /* mov.l @r0,r0 */
2011 0x40, 0x2b, /* jmp @r0 */
2012 0x00, 0x09, /* nop */
2013 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2014 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2015 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
2016 0x00, 0x09, /* nop */
2017 0x00, 0x09, /* nop */
2018 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2021 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
2023 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2024 0x02, 0x60, /* mov.l @r0,r0 */
2025 0x2b, 0x40, /* jmp @r0 */
2026 0x09, 0x00, /* nop */
2027 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2028 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2029 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
2030 0x09, 0x00, /* nop */
2031 0x09, 0x00, /* nop */
2032 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2035 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
2037 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2038 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2039 0x40, 0x2b, /* jmp @r0 */
2040 0x00, 0x09, /* nop */
2041 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2042 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2043 0x51, 0xc2, /* mov.l @(8,r12),r1 */
2044 0x41, 0x2b, /* jmp @r1 */
2045 0x00, 0x09, /* nop */
2046 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2049 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
2051 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2052 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2053 0x2b, 0x40, /* jmp @r0 */
2054 0x09, 0x00, /* nop */
2055 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2056 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2057 0xc2, 0x51, /* mov.l @(8,r12),r1 */
2058 0x2b, 0x41, /* jmp @r1 */
2059 0x09, 0x00, /* nop */
2060 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2063 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
2066 /* Big-endian non-PIC. */
2067 vxworks_sh_plt0_entry_be
,
2068 VXWORKS_PLT_HEADER_SIZE
,
2069 { MINUS_ONE
, MINUS_ONE
, 8 },
2070 vxworks_sh_plt_entry_be
,
2071 VXWORKS_PLT_ENTRY_SIZE
,
2072 { 8, 14, 20, FALSE
},
2077 /* Little-endian non-PIC. */
2078 vxworks_sh_plt0_entry_le
,
2079 VXWORKS_PLT_HEADER_SIZE
,
2080 { MINUS_ONE
, MINUS_ONE
, 8 },
2081 vxworks_sh_plt_entry_le
,
2082 VXWORKS_PLT_ENTRY_SIZE
,
2083 { 8, 14, 20, FALSE
},
2090 /* Big-endian PIC. */
2093 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2094 vxworks_sh_pic_plt_entry_be
,
2095 VXWORKS_PLT_ENTRY_SIZE
,
2096 { 8, MINUS_ONE
, 20, FALSE
},
2101 /* Little-endian PIC. */
2104 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2105 vxworks_sh_pic_plt_entry_le
,
2106 VXWORKS_PLT_ENTRY_SIZE
,
2107 { 8, MINUS_ONE
, 20, FALSE
},
2114 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2115 binding are to omit the lazy binding stub when linking with -z now
2116 and to move lazy binding stubs into a separate region for better
2119 #define FDPIC_PLT_ENTRY_SIZE 28
2120 #define FDPIC_PLT_LAZY_OFFSET 20
2122 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2123 duplicated if it is out of range, or which can be inlined. So
2124 right now it is always inlined, which wastes a word per stub. It
2125 might be easier to handle the duplication if we put the lazy
2126 stubs separately. */
2128 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
2130 0xd0, 0x02, /* mov.l @(12,pc),r0 */
2131 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2132 0x70, 0x04, /* add #4, r0 */
2133 0x41, 0x2b, /* jmp @r1 */
2134 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2135 0x00, 0x09, /* nop */
2136 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2137 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2138 0x60, 0xc2, /* mov.l @r12,r0 */
2139 0x40, 0x2b, /* jmp @r0 */
2140 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2141 0x00, 0x09, /* nop */
2144 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
2146 0x02, 0xd0, /* mov.l @(12,pc),r0 */
2147 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2148 0x04, 0x70, /* add #4, r0 */
2149 0x2b, 0x41, /* jmp @r1 */
2150 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2151 0x09, 0x00, /* nop */
2152 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2153 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2154 0xc2, 0x60, /* mov.l @r12,r0 */
2155 0x2b, 0x40, /* jmp @r0 */
2156 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2157 0x09, 0x00, /* nop */
2160 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
2162 /* Big-endian PIC. */
2165 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2166 fdpic_sh_plt_entry_be
,
2167 FDPIC_PLT_ENTRY_SIZE
,
2168 { 12, MINUS_ONE
, 16, FALSE
},
2169 FDPIC_PLT_LAZY_OFFSET
,
2173 /* Little-endian PIC. */
2176 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2177 fdpic_sh_plt_entry_le
,
2178 FDPIC_PLT_ENTRY_SIZE
,
2179 { 12, MINUS_ONE
, 16, FALSE
},
2180 FDPIC_PLT_LAZY_OFFSET
,
2185 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2186 entries for the first 64K slots. We use the normal FDPIC PLT entry
2187 past that point; we could also use movi20s, which might be faster,
2188 but would not be any smaller. */
2190 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2191 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2193 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
2195 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2196 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2197 0x70, 0x04, /* add #4, r0 */
2198 0x41, 0x2b, /* jmp @r1 */
2199 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2200 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2201 0x60, 0xc2, /* mov.l @r12,r0 */
2202 0x40, 0x2b, /* jmp @r0 */
2203 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2204 0x00, 0x09, /* nop */
2207 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
2209 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2210 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2211 0x04, 0x70, /* add #4, r0 */
2212 0x2b, 0x41, /* jmp @r1 */
2213 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2214 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2215 0xc2, 0x60, /* mov.l @r12,r0 */
2216 0x2b, 0x40, /* jmp @r0 */
2217 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2218 0x09, 0x00, /* nop */
2221 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
2222 /* Big-endian FDPIC, max index 64K. */
2225 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2226 fdpic_sh2a_plt_entry_be
,
2227 FDPIC_SH2A_PLT_ENTRY_SIZE
,
2228 { 0, MINUS_ONE
, 12, TRUE
},
2229 FDPIC_SH2A_PLT_LAZY_OFFSET
,
2233 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
2234 /* Little-endian FDPIC, max index 64K. */
2237 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2238 fdpic_sh2a_plt_entry_le
,
2239 FDPIC_SH2A_PLT_ENTRY_SIZE
,
2240 { 0, MINUS_ONE
, 12, TRUE
},
2241 FDPIC_SH2A_PLT_LAZY_OFFSET
,
2245 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
2247 /* Big-endian PIC. */
2250 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2251 fdpic_sh_plt_entry_be
,
2252 FDPIC_PLT_ENTRY_SIZE
,
2253 { 12, MINUS_ONE
, 16, FALSE
},
2254 FDPIC_PLT_LAZY_OFFSET
,
2255 &fdpic_sh2a_short_plt_be
2258 /* Little-endian PIC. */
2261 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2262 fdpic_sh_plt_entry_le
,
2263 FDPIC_PLT_ENTRY_SIZE
,
2264 { 12, MINUS_ONE
, 16, FALSE
},
2265 FDPIC_PLT_LAZY_OFFSET
,
2266 &fdpic_sh2a_short_plt_le
2270 /* Return the type of PLT associated with ABFD. PIC_P is true if
2271 the object is position-independent. */
2273 static const struct elf_sh_plt_info
*
2274 get_plt_info (bfd
*abfd
, bfd_boolean pic_p
)
2276 if (fdpic_object_p (abfd
))
2278 /* If any input file requires SH2A we can use a shorter PLT
2280 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2281 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2283 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2285 if (vxworks_object_p (abfd
))
2286 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2287 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2290 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2291 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2295 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2296 unsigned long value
, bfd_byte
*addr
)
2298 bfd_put_32 (output_bfd
, value
, addr
);
2302 /* The number of PLT entries which can use a shorter PLT, if any.
2303 Currently always 64K, since only SH-2A FDPIC uses this; a
2304 20-bit movi20 can address that many function descriptors below
2305 _GLOBAL_OFFSET_TABLE_. */
2306 #define MAX_SHORT_PLT 65536
2308 /* Return the index of the PLT entry at byte offset OFFSET. */
2311 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2313 bfd_vma plt_index
= 0;
2315 offset
-= info
->plt0_entry_size
;
2316 if (info
->short_plt
!= NULL
)
2318 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2320 plt_index
= MAX_SHORT_PLT
;
2321 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2324 info
= info
->short_plt
;
2326 return plt_index
+ offset
/ info
->symbol_entry_size
;
2329 /* Do the inverse operation. */
2332 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2336 if (info
->short_plt
!= NULL
)
2338 if (plt_index
> MAX_SHORT_PLT
)
2340 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2341 plt_index
-= MAX_SHORT_PLT
;
2344 info
= info
->short_plt
;
2346 return (offset
+ info
->plt0_entry_size
2347 + (plt_index
* info
->symbol_entry_size
));
2350 /* The sh linker needs to keep track of the number of relocs that it
2351 decides to copy as dynamic relocs in check_relocs for each symbol.
2352 This is so that it can later discard them if they are found to be
2353 unnecessary. We store the information in a field extending the
2354 regular ELF linker hash table. */
2356 struct elf_sh_dyn_relocs
2358 struct elf_sh_dyn_relocs
*next
;
2360 /* The input section of the reloc. */
2363 /* Total number of relocs copied for the input section. */
2364 bfd_size_type count
;
2366 /* Number of pc-relative relocs copied for the input section. */
2367 bfd_size_type pc_count
;
2372 bfd_signed_vma refcount
;
2376 /* sh ELF linker hash entry. */
2378 struct elf_sh_link_hash_entry
2380 struct elf_link_hash_entry root
;
2382 #ifdef INCLUDE_SHMEDIA
2385 bfd_signed_vma refcount
;
2390 /* Track dynamic relocs copied for this symbol. */
2391 struct elf_sh_dyn_relocs
*dyn_relocs
;
2393 bfd_signed_vma gotplt_refcount
;
2395 /* A local function descriptor, for FDPIC. The refcount counts
2396 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2397 relocations; the PLT and GOT entry are accounted
2398 for separately. After adjust_dynamic_symbol, the offset is
2399 MINUS_ONE if there is no local descriptor (dynamic linker
2400 managed and no PLT entry, or undefined weak non-dynamic).
2401 During check_relocs we do not yet know whether the local
2402 descriptor will be canonical. */
2403 union gotref funcdesc
;
2405 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2406 and thus require fixups or relocations. */
2407 bfd_signed_vma abs_funcdesc_refcount
;
2410 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2414 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2416 struct sh_elf_obj_tdata
2418 struct elf_obj_tdata root
;
2420 /* got_type for each local got entry. */
2421 char *local_got_type
;
2423 /* Function descriptor refcount and offset for each local symbol. */
2424 union gotref
*local_funcdesc
;
2427 #define sh_elf_tdata(abfd) \
2428 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2430 #define sh_elf_local_got_type(abfd) \
2431 (sh_elf_tdata (abfd)->local_got_type)
2433 #define sh_elf_local_funcdesc(abfd) \
2434 (sh_elf_tdata (abfd)->local_funcdesc)
2436 #define is_sh_elf(bfd) \
2437 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2438 && elf_tdata (bfd) != NULL \
2439 && elf_object_id (bfd) == SH_ELF_DATA)
2441 /* Override the generic function because we need to store sh_elf_obj_tdata
2442 as the specific tdata. */
2445 sh_elf_mkobject (bfd
*abfd
)
2447 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2451 /* sh ELF linker hash table. */
2453 struct elf_sh_link_hash_table
2455 struct elf_link_hash_table root
;
2457 /* Short-cuts to get to dynamic linker sections. */
2465 asection
*sfuncdesc
;
2466 asection
*srelfuncdesc
;
2469 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2472 /* Small local sym cache. */
2473 struct sym_cache sym_cache
;
2475 /* A counter or offset to track a TLS got entry. */
2478 bfd_signed_vma refcount
;
2482 /* The type of PLT to use. */
2483 const struct elf_sh_plt_info
*plt_info
;
2485 /* True if the target system is VxWorks. */
2486 bfd_boolean vxworks_p
;
2488 /* True if the target system uses FDPIC. */
2489 bfd_boolean fdpic_p
;
2492 /* Traverse an sh ELF linker hash table. */
2494 #define sh_elf_link_hash_traverse(table, func, info) \
2495 (elf_link_hash_traverse \
2497 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2500 /* Get the sh ELF linker hash table from a link_info structure. */
2502 #define sh_elf_hash_table(p) \
2503 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2504 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2506 /* Create an entry in an sh ELF linker hash table. */
2508 static struct bfd_hash_entry
*
2509 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2510 struct bfd_hash_table
*table
,
2513 struct elf_sh_link_hash_entry
*ret
=
2514 (struct elf_sh_link_hash_entry
*) entry
;
2516 /* Allocate the structure if it has not already been allocated by a
2518 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2519 ret
= ((struct elf_sh_link_hash_entry
*)
2520 bfd_hash_allocate (table
,
2521 sizeof (struct elf_sh_link_hash_entry
)));
2522 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2523 return (struct bfd_hash_entry
*) ret
;
2525 /* Call the allocation method of the superclass. */
2526 ret
= ((struct elf_sh_link_hash_entry
*)
2527 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2529 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2531 ret
->dyn_relocs
= NULL
;
2532 ret
->gotplt_refcount
= 0;
2533 #ifdef INCLUDE_SHMEDIA
2534 ret
->datalabel_got
.refcount
= ret
->root
.got
.refcount
;
2536 ret
->funcdesc
.refcount
= 0;
2537 ret
->abs_funcdesc_refcount
= 0;
2538 ret
->got_type
= GOT_UNKNOWN
;
2541 return (struct bfd_hash_entry
*) ret
;
2544 /* Create an sh ELF linker hash table. */
2546 static struct bfd_link_hash_table
*
2547 sh_elf_link_hash_table_create (bfd
*abfd
)
2549 struct elf_sh_link_hash_table
*ret
;
2550 bfd_size_type amt
= sizeof (struct elf_sh_link_hash_table
);
2552 ret
= (struct elf_sh_link_hash_table
*) bfd_malloc (amt
);
2553 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2556 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2557 sh_elf_link_hash_newfunc
,
2558 sizeof (struct elf_sh_link_hash_entry
),
2566 ret
->sgotplt
= NULL
;
2567 ret
->srelgot
= NULL
;
2569 ret
->srelplt
= NULL
;
2570 ret
->sdynbss
= NULL
;
2571 ret
->srelbss
= NULL
;
2572 ret
->srelplt2
= NULL
;
2573 ret
->sym_cache
.abfd
= NULL
;
2574 ret
->tls_ldm_got
.refcount
= 0;
2575 ret
->plt_info
= NULL
;
2576 ret
->vxworks_p
= vxworks_object_p (abfd
);
2577 ret
->fdpic_p
= fdpic_object_p (abfd
);
2579 return &ret
->root
.root
;
2583 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2584 struct bfd_link_info
*info
, asection
*p
)
2586 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2588 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2592 /* We need dynamic symbols for every section, since segments can
2593 relocate independently. */
2594 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2598 /* If sh_type is yet undecided, assume it could be
2599 SHT_PROGBITS/SHT_NOBITS. */
2603 /* There shouldn't be section relative relocations
2604 against any other section. */
2610 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2611 shortcuts to them in our hash table. */
2614 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2616 struct elf_sh_link_hash_table
*htab
;
2618 if (! _bfd_elf_create_got_section (dynobj
, info
))
2621 htab
= sh_elf_hash_table (info
);
2625 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
2626 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
2627 htab
->srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
2628 if (! htab
->sgot
|| ! htab
->sgotplt
|| ! htab
->srelgot
)
2631 htab
->sfuncdesc
= bfd_make_section_with_flags (dynobj
, ".got.funcdesc",
2632 (SEC_ALLOC
| SEC_LOAD
2635 | SEC_LINKER_CREATED
));
2636 if (htab
->sfuncdesc
== NULL
2637 || ! bfd_set_section_alignment (dynobj
, htab
->sfuncdesc
, 2))
2640 htab
->srelfuncdesc
= bfd_make_section_with_flags (dynobj
,
2641 ".rela.got.funcdesc",
2642 (SEC_ALLOC
| SEC_LOAD
2645 | SEC_LINKER_CREATED
2647 if (htab
->srelfuncdesc
== NULL
2648 || ! bfd_set_section_alignment (dynobj
, htab
->srelfuncdesc
, 2))
2651 /* Also create .rofixup. */
2652 htab
->srofixup
= bfd_make_section_with_flags (dynobj
, ".rofixup",
2653 (SEC_ALLOC
| SEC_LOAD
2656 | SEC_LINKER_CREATED
2658 if (htab
->srofixup
== NULL
2659 || ! bfd_set_section_alignment (dynobj
, htab
->srofixup
, 2))
2665 /* Create dynamic sections when linking against a dynamic object. */
2668 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2670 struct elf_sh_link_hash_table
*htab
;
2671 flagword flags
, pltflags
;
2673 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2676 switch (bed
->s
->arch_size
)
2687 bfd_set_error (bfd_error_bad_value
);
2691 htab
= sh_elf_hash_table (info
);
2695 if (htab
->root
.dynamic_sections_created
)
2698 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2699 .rel[a].bss sections. */
2701 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2702 | SEC_LINKER_CREATED
);
2705 pltflags
|= SEC_CODE
;
2706 if (bed
->plt_not_loaded
)
2707 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2708 if (bed
->plt_readonly
)
2709 pltflags
|= SEC_READONLY
;
2711 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
2714 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2717 if (bed
->want_plt_sym
)
2719 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2721 struct elf_link_hash_entry
*h
;
2722 struct bfd_link_hash_entry
*bh
= NULL
;
2724 if (! (_bfd_generic_link_add_one_symbol
2725 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2726 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2727 get_elf_backend_data (abfd
)->collect
, &bh
)))
2730 h
= (struct elf_link_hash_entry
*) bh
;
2732 h
->type
= STT_OBJECT
;
2733 htab
->root
.hplt
= h
;
2736 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2740 s
= bfd_make_section_with_flags (abfd
,
2741 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt",
2742 flags
| SEC_READONLY
);
2745 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2748 if (htab
->sgot
== NULL
2749 && !create_got_section (abfd
, info
))
2752 if (bed
->want_dynbss
)
2754 /* The .dynbss section is a place to put symbols which are defined
2755 by dynamic objects, are referenced by regular objects, and are
2756 not functions. We must allocate space for them in the process
2757 image and use a R_*_COPY reloc to tell the dynamic linker to
2758 initialize them at run time. The linker script puts the .dynbss
2759 section into the .bss section of the final image. */
2760 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
2761 SEC_ALLOC
| SEC_LINKER_CREATED
);
2766 /* The .rel[a].bss section holds copy relocs. This section is not
2767 normally needed. We need to create it here, though, so that the
2768 linker will map it to an output section. We can't just create it
2769 only if we need it, because we will not know whether we need it
2770 until we have seen all the input files, and the first time the
2771 main linker code calls BFD after examining all the input files
2772 (size_dynamic_sections) the input sections have already been
2773 mapped to the output sections. If the section turns out not to
2774 be needed, we can discard it later. We will never need this
2775 section when generating a shared object, since they do not use
2779 s
= bfd_make_section_with_flags (abfd
,
2780 (bed
->default_use_rela_p
2781 ? ".rela.bss" : ".rel.bss"),
2782 flags
| SEC_READONLY
);
2785 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2790 if (htab
->vxworks_p
)
2792 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2799 /* Adjust a symbol defined by a dynamic object and referenced by a
2800 regular object. The current definition is in some section of the
2801 dynamic object, but we're not including those sections. We have to
2802 change the definition to something the rest of the link can
2806 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2807 struct elf_link_hash_entry
*h
)
2809 struct elf_sh_link_hash_table
*htab
;
2810 struct elf_sh_link_hash_entry
*eh
;
2811 struct elf_sh_dyn_relocs
*p
;
2814 htab
= sh_elf_hash_table (info
);
2818 /* Make sure we know what is going on here. */
2819 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2821 || h
->u
.weakdef
!= NULL
2824 && !h
->def_regular
)));
2826 /* If this is a function, put it in the procedure linkage table. We
2827 will fill in the contents of the procedure linkage table later,
2828 when we know the address of the .got section. */
2829 if (h
->type
== STT_FUNC
2832 if (h
->plt
.refcount
<= 0
2833 || SYMBOL_CALLS_LOCAL (info
, h
)
2834 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2835 && h
->root
.type
== bfd_link_hash_undefweak
))
2837 /* This case can occur if we saw a PLT reloc in an input
2838 file, but the symbol was never referred to by a dynamic
2839 object. In such a case, we don't actually need to build
2840 a procedure linkage table, and we can just do a REL32
2842 h
->plt
.offset
= (bfd_vma
) -1;
2849 h
->plt
.offset
= (bfd_vma
) -1;
2851 /* If this is a weak symbol, and there is a real definition, the
2852 processor independent code will have arranged for us to see the
2853 real definition first, and we can just use the same value. */
2854 if (h
->u
.weakdef
!= NULL
)
2856 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2857 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2858 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2859 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2860 if (info
->nocopyreloc
)
2861 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2865 /* This is a reference to a symbol defined by a dynamic object which
2866 is not a function. */
2868 /* If we are creating a shared library, we must presume that the
2869 only references to the symbol are via the global offset table.
2870 For such cases we need not do anything here; the relocations will
2871 be handled correctly by relocate_section. */
2875 /* If there are no references to this symbol that do not use the
2876 GOT, we don't need to generate a copy reloc. */
2877 if (!h
->non_got_ref
)
2880 /* If -z nocopyreloc was given, we won't generate them either. */
2881 if (info
->nocopyreloc
)
2887 eh
= (struct elf_sh_link_hash_entry
*) h
;
2888 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2890 s
= p
->sec
->output_section
;
2891 if (s
!= NULL
&& (s
->flags
& (SEC_READONLY
| SEC_HAS_CONTENTS
)) != 0)
2895 /* If we didn't find any dynamic relocs in sections which needs the
2896 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2904 /* We must allocate the symbol in our .dynbss section, which will
2905 become part of the .bss section of the executable. There will be
2906 an entry for this symbol in the .dynsym section. The dynamic
2907 object will contain position independent code, so all references
2908 from the dynamic object to this symbol will go through the global
2909 offset table. The dynamic linker will use the .dynsym entry to
2910 determine the address it must put in the global offset table, so
2911 both the dynamic object and the regular object will refer to the
2912 same memory location for the variable. */
2915 BFD_ASSERT (s
!= NULL
);
2917 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2918 copy the initial value out of the dynamic object and into the
2919 runtime process image. We need to remember the offset into the
2920 .rela.bss section we are going to use. */
2921 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2925 srel
= htab
->srelbss
;
2926 BFD_ASSERT (srel
!= NULL
);
2927 srel
->size
+= sizeof (Elf32_External_Rela
);
2931 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2934 /* Allocate space in .plt, .got and associated reloc sections for
2938 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2940 struct bfd_link_info
*info
;
2941 struct elf_sh_link_hash_table
*htab
;
2942 struct elf_sh_link_hash_entry
*eh
;
2943 struct elf_sh_dyn_relocs
*p
;
2945 if (h
->root
.type
== bfd_link_hash_indirect
)
2948 info
= (struct bfd_link_info
*) inf
;
2949 htab
= sh_elf_hash_table (info
);
2953 eh
= (struct elf_sh_link_hash_entry
*) h
;
2954 if ((h
->got
.refcount
> 0
2956 && eh
->gotplt_refcount
> 0)
2958 /* The symbol has been forced local, or we have some direct got refs,
2959 so treat all the gotplt refs as got refs. */
2960 h
->got
.refcount
+= eh
->gotplt_refcount
;
2961 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2962 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2965 if (htab
->root
.dynamic_sections_created
2966 && h
->plt
.refcount
> 0
2967 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2968 || h
->root
.type
!= bfd_link_hash_undefweak
))
2970 /* Make sure this symbol is output as a dynamic symbol.
2971 Undefined weak syms won't yet be marked as dynamic. */
2972 if (h
->dynindx
== -1
2973 && !h
->forced_local
)
2975 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2980 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2982 asection
*s
= htab
->splt
;
2983 const struct elf_sh_plt_info
*plt_info
;
2985 /* If this is the first .plt entry, make room for the special
2988 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2990 h
->plt
.offset
= s
->size
;
2992 /* If this symbol is not defined in a regular file, and we are
2993 not generating a shared library, then set the symbol to this
2994 location in the .plt. This is required to make function
2995 pointers compare as equal between the normal executable and
2996 the shared library. Skip this for FDPIC, since the
2997 function's address will be the address of the canonical
2998 function descriptor. */
2999 if (!htab
->fdpic_p
&& !info
->shared
&& !h
->def_regular
)
3001 h
->root
.u
.def
.section
= s
;
3002 h
->root
.u
.def
.value
= h
->plt
.offset
;
3005 /* Make room for this entry. */
3006 plt_info
= htab
->plt_info
;
3007 if (plt_info
->short_plt
!= NULL
3008 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
3009 plt_info
= plt_info
->short_plt
;
3010 s
->size
+= plt_info
->symbol_entry_size
;
3012 /* We also need to make an entry in the .got.plt section, which
3013 will be placed in the .got section by the linker script. */
3015 htab
->sgotplt
->size
+= 4;
3017 htab
->sgotplt
->size
+= 8;
3019 /* We also need to make an entry in the .rel.plt section. */
3020 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
3022 if (htab
->vxworks_p
&& !info
->shared
)
3024 /* VxWorks executables have a second set of relocations
3025 for each PLT entry. They go in a separate relocation
3026 section, which is processed by the kernel loader. */
3028 /* There is a relocation for the initial PLT entry:
3029 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3030 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
3031 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
3033 /* There are two extra relocations for each subsequent
3034 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3035 and an R_SH_DIR32 relocation for the PLT entry. */
3036 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
3041 h
->plt
.offset
= (bfd_vma
) -1;
3047 h
->plt
.offset
= (bfd_vma
) -1;
3051 if (h
->got
.refcount
> 0)
3055 enum got_type got_type
= sh_elf_hash_entry (h
)->got_type
;
3057 /* Make sure this symbol is output as a dynamic symbol.
3058 Undefined weak syms won't yet be marked as dynamic. */
3059 if (h
->dynindx
== -1
3060 && !h
->forced_local
)
3062 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3067 h
->got
.offset
= s
->size
;
3069 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3070 if (got_type
== GOT_TLS_GD
)
3072 dyn
= htab
->root
.dynamic_sections_created
;
3075 /* No dynamic relocations required. */
3076 if (htab
->fdpic_p
&& !info
->shared
3077 && h
->root
.type
!= bfd_link_hash_undefweak
3078 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
3079 htab
->srofixup
->size
+= 4;
3081 /* No dynamic relocations required when IE->LE conversion happens. */
3082 else if (got_type
== GOT_TLS_IE
&& !h
->def_dynamic
&& !info
->shared
)
3084 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3085 R_SH_TLS_GD needs one if local symbol and two if global. */
3086 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
3087 || got_type
== GOT_TLS_IE
)
3088 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3089 else if (got_type
== GOT_TLS_GD
)
3090 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
3091 else if (got_type
== GOT_FUNCDESC
)
3093 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
3094 htab
->srofixup
->size
+= 4;
3096 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3098 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3099 || h
->root
.type
!= bfd_link_hash_undefweak
)
3101 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3102 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3103 else if (htab
->fdpic_p
&& !info
->shared
&& got_type
== GOT_NORMAL
3104 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3105 || h
->root
.type
!= bfd_link_hash_undefweak
))
3106 htab
->srofixup
->size
+= 4;
3109 h
->got
.offset
= (bfd_vma
) -1;
3111 #ifdef INCLUDE_SHMEDIA
3112 if (eh
->datalabel_got
.refcount
> 0)
3117 /* Make sure this symbol is output as a dynamic symbol.
3118 Undefined weak syms won't yet be marked as dynamic. */
3119 if (h
->dynindx
== -1
3120 && !h
->forced_local
)
3122 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3127 eh
->datalabel_got
.offset
= s
->size
;
3129 dyn
= htab
->root
.dynamic_sections_created
;
3130 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
3131 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3134 eh
->datalabel_got
.offset
= (bfd_vma
) -1;
3137 /* Allocate space for any dynamic relocations to function
3138 descriptors, canonical or otherwise. We need to relocate the
3139 reference unless it resolves to zero, which only happens for
3140 undefined weak symbols (either non-default visibility, or when
3141 static linking). Any GOT slot is accounted for elsewhere. */
3142 if (eh
->abs_funcdesc_refcount
> 0
3143 && (h
->root
.type
!= bfd_link_hash_undefweak
3144 || (htab
->root
.dynamic_sections_created
3145 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
3147 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
3148 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
3151 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
3154 /* We must allocate a function descriptor if there are references to
3155 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3156 the dynamic linker isn't going to allocate it. None of this
3157 applies if we already created one in .got.plt, but if the
3158 canonical function descriptor can be in this object, there
3159 won't be a PLT entry at all. */
3160 if ((eh
->funcdesc
.refcount
> 0
3161 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
3162 && h
->root
.type
!= bfd_link_hash_undefweak
3163 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
3165 /* Make room for this function descriptor. */
3166 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
3167 htab
->sfuncdesc
->size
+= 8;
3169 /* We will need a relocation or two fixups to initialize the
3170 function descriptor, so allocate those too. */
3171 if (!info
->shared
&& SYMBOL_CALLS_LOCAL (info
, h
))
3172 htab
->srofixup
->size
+= 8;
3174 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3177 if (eh
->dyn_relocs
== NULL
)
3180 /* In the shared -Bsymbolic case, discard space allocated for
3181 dynamic pc-relative relocs against symbols which turn out to be
3182 defined in regular objects. For the normal shared case, discard
3183 space for pc-relative relocs that have become local due to symbol
3184 visibility changes. */
3188 if (SYMBOL_CALLS_LOCAL (info
, h
))
3190 struct elf_sh_dyn_relocs
**pp
;
3192 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3194 p
->count
-= p
->pc_count
;
3203 if (htab
->vxworks_p
)
3205 struct elf_sh_dyn_relocs
**pp
;
3207 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3209 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
3216 /* Also discard relocs on undefined weak syms with non-default
3218 if (eh
->dyn_relocs
!= NULL
3219 && h
->root
.type
== bfd_link_hash_undefweak
)
3221 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
3222 eh
->dyn_relocs
= NULL
;
3224 /* Make sure undefined weak symbols are output as a dynamic
3226 else if (h
->dynindx
== -1
3227 && !h
->forced_local
)
3229 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3236 /* For the non-shared case, discard space for relocs against
3237 symbols which turn out to need copy relocs or are not
3243 || (htab
->root
.dynamic_sections_created
3244 && (h
->root
.type
== bfd_link_hash_undefweak
3245 || h
->root
.type
== bfd_link_hash_undefined
))))
3247 /* Make sure this symbol is output as a dynamic symbol.
3248 Undefined weak syms won't yet be marked as dynamic. */
3249 if (h
->dynindx
== -1
3250 && !h
->forced_local
)
3252 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3256 /* If that succeeded, we know we'll be keeping all the
3258 if (h
->dynindx
!= -1)
3262 eh
->dyn_relocs
= NULL
;
3267 /* Finally, allocate space. */
3268 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3270 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
3271 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3273 /* If we need relocations, we do not need fixups. */
3274 if (htab
->fdpic_p
&& !info
->shared
)
3275 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3281 /* Find any dynamic relocs that apply to read-only sections. */
3284 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3286 struct elf_sh_link_hash_entry
*eh
;
3287 struct elf_sh_dyn_relocs
*p
;
3289 eh
= (struct elf_sh_link_hash_entry
*) h
;
3290 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3292 asection
*s
= p
->sec
->output_section
;
3294 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3296 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3298 info
->flags
|= DF_TEXTREL
;
3300 /* Not an error, just cut short the traversal. */
3307 /* This function is called after all the input files have been read,
3308 and the input sections have been assigned to output sections.
3309 It's a convenient place to determine the PLT style. */
3312 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3314 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
, info
->shared
);
3316 if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->relocatable
)
3318 struct elf_link_hash_entry
*h
;
3320 /* Force a PT_GNU_STACK segment to be created. */
3321 if (! elf_tdata (output_bfd
)->stack_flags
)
3322 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
3324 /* Define __stacksize if it's not defined yet. */
3325 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
3326 FALSE
, FALSE
, FALSE
);
3327 if (! h
|| h
->root
.type
!= bfd_link_hash_defined
3328 || h
->type
!= STT_OBJECT
3331 struct bfd_link_hash_entry
*bh
= NULL
;
3333 if (!(_bfd_generic_link_add_one_symbol
3334 (info
, output_bfd
, "__stacksize",
3335 BSF_GLOBAL
, bfd_abs_section_ptr
, DEFAULT_STACK_SIZE
,
3336 (const char *) NULL
, FALSE
,
3337 get_elf_backend_data (output_bfd
)->collect
, &bh
)))
3340 h
= (struct elf_link_hash_entry
*) bh
;
3342 h
->type
= STT_OBJECT
;
3348 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
3351 sh_elf_modify_program_headers (bfd
*output_bfd
, struct bfd_link_info
*info
)
3353 struct elf_obj_tdata
*tdata
= elf_tdata (output_bfd
);
3354 struct elf_segment_map
*m
;
3355 Elf_Internal_Phdr
*p
;
3357 /* objcopy and strip preserve what's already there using
3358 sh_elf_copy_private_bfd_data (). */
3362 for (p
= tdata
->phdr
, m
= tdata
->segment_map
; m
!= NULL
; m
= m
->next
, p
++)
3363 if (m
->p_type
== PT_GNU_STACK
)
3368 struct elf_link_hash_entry
*h
;
3370 /* Obtain the pointer to the __stacksize symbol. */
3371 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
3372 FALSE
, FALSE
, FALSE
);
3375 while (h
->root
.type
== bfd_link_hash_indirect
3376 || h
->root
.type
== bfd_link_hash_warning
)
3377 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3378 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
3381 /* Set the header p_memsz from the symbol value. We
3382 intentionally ignore the symbol section. */
3383 if (h
&& h
->root
.type
== bfd_link_hash_defined
)
3384 p
->p_memsz
= h
->root
.u
.def
.value
;
3386 p
->p_memsz
= DEFAULT_STACK_SIZE
;
3396 /* Set the sizes of the dynamic sections. */
3399 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3400 struct bfd_link_info
*info
)
3402 struct elf_sh_link_hash_table
*htab
;
3408 htab
= sh_elf_hash_table (info
);
3412 dynobj
= htab
->root
.dynobj
;
3413 BFD_ASSERT (dynobj
!= NULL
);
3415 if (htab
->root
.dynamic_sections_created
)
3417 /* Set the contents of the .interp section to the interpreter. */
3418 if (info
->executable
)
3420 s
= bfd_get_section_by_name (dynobj
, ".interp");
3421 BFD_ASSERT (s
!= NULL
);
3422 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3423 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3427 /* Set up .got offsets for local syms, and space for local dynamic
3429 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3431 bfd_signed_vma
*local_got
;
3432 bfd_signed_vma
*end_local_got
;
3433 union gotref
*local_funcdesc
, *end_local_funcdesc
;
3434 char *local_got_type
;
3435 bfd_size_type locsymcount
;
3436 Elf_Internal_Shdr
*symtab_hdr
;
3439 if (! is_sh_elf (ibfd
))
3442 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3444 struct elf_sh_dyn_relocs
*p
;
3446 for (p
= ((struct elf_sh_dyn_relocs
*)
3447 elf_section_data (s
)->local_dynrel
);
3451 if (! bfd_is_abs_section (p
->sec
)
3452 && bfd_is_abs_section (p
->sec
->output_section
))
3454 /* Input section has been discarded, either because
3455 it is a copy of a linkonce section or due to
3456 linker script /DISCARD/, so we'll be discarding
3459 else if (htab
->vxworks_p
3460 && strcmp (p
->sec
->output_section
->name
,
3463 /* Relocations in vxworks .tls_vars sections are
3464 handled specially by the loader. */
3466 else if (p
->count
!= 0)
3468 srel
= elf_section_data (p
->sec
)->sreloc
;
3469 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3470 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3471 info
->flags
|= DF_TEXTREL
;
3473 /* If we need relocations, we do not need fixups. */
3474 if (htab
->fdpic_p
&& !info
->shared
)
3475 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3480 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3481 locsymcount
= symtab_hdr
->sh_info
;
3482 #ifdef INCLUDE_SHMEDIA
3483 /* Count datalabel local GOT. */
3487 srel
= htab
->srelgot
;
3489 local_got
= elf_local_got_refcounts (ibfd
);
3492 end_local_got
= local_got
+ locsymcount
;
3493 local_got_type
= sh_elf_local_got_type (ibfd
);
3494 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3495 for (; local_got
< end_local_got
; ++local_got
)
3499 *local_got
= s
->size
;
3501 if (*local_got_type
== GOT_TLS_GD
)
3504 srel
->size
+= sizeof (Elf32_External_Rela
);
3506 htab
->srofixup
->size
+= 4;
3508 if (*local_got_type
== GOT_FUNCDESC
)
3510 if (local_funcdesc
== NULL
)
3514 size
= locsymcount
* sizeof (union gotref
);
3515 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3517 if (local_funcdesc
== NULL
)
3519 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3520 local_funcdesc
+= (local_got
3521 - elf_local_got_refcounts (ibfd
));
3523 local_funcdesc
->refcount
++;
3528 *local_got
= (bfd_vma
) -1;
3533 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3536 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3538 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3540 if (local_funcdesc
->refcount
> 0)
3542 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3543 htab
->sfuncdesc
->size
+= 8;
3545 htab
->srofixup
->size
+= 8;
3547 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3550 local_funcdesc
->offset
= MINUS_ONE
;
3556 if (htab
->tls_ldm_got
.refcount
> 0)
3558 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3560 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
3561 htab
->sgot
->size
+= 8;
3562 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
3565 htab
->tls_ldm_got
.offset
= -1;
3567 /* Only the reserved entries should be present. For FDPIC, they go at
3568 the end of .got.plt. */
3571 BFD_ASSERT (htab
->sgotplt
&& htab
->sgotplt
->size
== 12);
3572 htab
->sgotplt
->size
= 0;
3575 /* Allocate global sym .plt and .got entries, and space for global
3576 sym dynamic relocs. */
3577 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3579 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3580 end of the FDPIC .got.plt. */
3583 htab
->root
.hgot
->root
.u
.def
.value
= htab
->sgotplt
->size
;
3584 htab
->sgotplt
->size
+= 12;
3587 /* At the very end of the .rofixup section is a pointer to the GOT. */
3588 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3589 htab
->srofixup
->size
+= 4;
3591 /* We now have determined the sizes of the various dynamic sections.
3592 Allocate memory for them. */
3594 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3596 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3601 || s
== htab
->sgotplt
3602 || s
== htab
->sfuncdesc
3603 || s
== htab
->srofixup
3604 || s
== htab
->sdynbss
)
3606 /* Strip this section if we don't need it; see the
3609 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3611 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
3614 /* We use the reloc_count field as a counter if we need
3615 to copy relocs into the output file. */
3620 /* It's not one of our sections, so don't allocate space. */
3626 /* If we don't need this section, strip it from the
3627 output file. This is mostly to handle .rela.bss and
3628 .rela.plt. We must create both sections in
3629 create_dynamic_sections, because they must be created
3630 before the linker maps input sections to output
3631 sections. The linker does that before
3632 adjust_dynamic_symbol is called, and it is that
3633 function which decides whether anything needs to go
3634 into these sections. */
3636 s
->flags
|= SEC_EXCLUDE
;
3640 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3643 /* Allocate memory for the section contents. We use bfd_zalloc
3644 here in case unused entries are not reclaimed before the
3645 section's contents are written out. This should not happen,
3646 but this way if it does, we get a R_SH_NONE reloc instead
3648 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3649 if (s
->contents
== NULL
)
3653 if (htab
->root
.dynamic_sections_created
)
3655 /* Add some entries to the .dynamic section. We fill in the
3656 values later, in sh_elf_finish_dynamic_sections, but we
3657 must add the entries now so that we get the correct size for
3658 the .dynamic section. The DT_DEBUG entry is filled in by the
3659 dynamic linker and used by the debugger. */
3660 #define add_dynamic_entry(TAG, VAL) \
3661 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3663 if (info
->executable
)
3665 if (! add_dynamic_entry (DT_DEBUG
, 0))
3669 if (htab
->splt
->size
!= 0)
3671 if (! add_dynamic_entry (DT_PLTGOT
, 0)
3672 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
3673 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3674 || ! add_dynamic_entry (DT_JMPREL
, 0))
3677 else if ((elf_elfheader (output_bfd
)->e_flags
& EF_SH_FDPIC
)
3678 && htab
->sgot
->size
!= 0)
3680 if (! add_dynamic_entry (DT_PLTGOT
, 0))
3686 if (! add_dynamic_entry (DT_RELA
, 0)
3687 || ! add_dynamic_entry (DT_RELASZ
, 0)
3688 || ! add_dynamic_entry (DT_RELAENT
,
3689 sizeof (Elf32_External_Rela
)))
3692 /* If any dynamic relocs apply to a read-only section,
3693 then we need a DT_TEXTREL entry. */
3694 if ((info
->flags
& DF_TEXTREL
) == 0)
3695 elf_link_hash_traverse (&htab
->root
, readonly_dynrelocs
, info
);
3697 if ((info
->flags
& DF_TEXTREL
) != 0)
3699 if (! add_dynamic_entry (DT_TEXTREL
, 0))
3704 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3707 #undef add_dynamic_entry
3712 /* Add a dynamic relocation to the SRELOC section. */
3714 inline static bfd_vma
3715 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3716 int reloc_type
, long dynindx
, bfd_vma addend
)
3718 Elf_Internal_Rela outrel
;
3719 bfd_vma reloc_offset
;
3721 outrel
.r_offset
= offset
;
3722 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3723 outrel
.r_addend
= addend
;
3725 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3726 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3727 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3728 sreloc
->contents
+ reloc_offset
);
3729 sreloc
->reloc_count
++;
3731 return reloc_offset
;
3734 /* Add an FDPIC read-only fixup. */
3737 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3739 bfd_vma fixup_offset
;
3741 fixup_offset
= srofixup
->reloc_count
++ * 4;
3742 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3743 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3746 /* Return the offset of the generated .got section from the
3747 _GLOBAL_OFFSET_TABLE_ symbol. */
3749 static bfd_signed_vma
3750 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3752 return (htab
->sgot
->output_offset
- htab
->sgotplt
->output_offset
3753 - htab
->root
.hgot
->root
.u
.def
.value
);
3756 /* Find the segment number in which OSEC, and output section, is
3760 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3762 Elf_Internal_Phdr
*p
= NULL
;
3764 if (output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
)
3765 p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
3767 /* FIXME: Nothing ever says what this index is relative to. The kernel
3768 supplies data in terms of the number of load segments but this is
3769 a phdr index and the first phdr may not be a load segment. */
3770 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3774 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3776 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3778 return (seg
!= (unsigned) -1
3779 && ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
));
3782 /* Generate the initial contents of a local function descriptor, along
3783 with any relocations or fixups required. */
3785 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3786 struct bfd_link_info
*info
,
3787 struct elf_link_hash_entry
*h
,
3792 struct elf_sh_link_hash_table
*htab
;
3796 htab
= sh_elf_hash_table (info
);
3798 /* FIXME: The ABI says that the offset to the function goes in the
3799 descriptor, along with the segment index. We're RELA, so it could
3800 go in the reloc instead... */
3802 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3804 section
= h
->root
.u
.def
.section
;
3805 value
= h
->root
.u
.def
.value
;
3808 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3810 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3811 addr
= value
+ section
->output_offset
;
3812 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3816 BFD_ASSERT (h
->dynindx
!= -1);
3817 dynindx
= h
->dynindx
;
3821 if (!info
->shared
&& SYMBOL_CALLS_LOCAL (info
, h
))
3823 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3825 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3827 + htab
->sfuncdesc
->output_section
->vma
3828 + htab
->sfuncdesc
->output_offset
);
3829 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3831 + htab
->sfuncdesc
->output_section
->vma
3832 + htab
->sfuncdesc
->output_offset
);
3835 /* There are no dynamic relocations so fill in the final
3836 address and gp value (barring fixups). */
3837 addr
+= section
->output_section
->vma
;
3838 seg
= htab
->root
.hgot
->root
.u
.def
.value
3839 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3840 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3843 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3845 + htab
->sfuncdesc
->output_section
->vma
3846 + htab
->sfuncdesc
->output_offset
,
3847 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3849 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3850 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3855 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3856 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3859 static bfd_reloc_status_type
3860 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3861 bfd
*input_bfd
, asection
*input_section
,
3862 bfd_byte
*contents
, bfd_vma offset
)
3864 unsigned long cur_val
;
3866 bfd_reloc_status_type r
;
3868 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3869 return bfd_reloc_outofrange
;
3871 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3872 bfd_arch_bits_per_address (input_bfd
), relocation
);
3873 if (r
!= bfd_reloc_ok
)
3876 addr
= contents
+ offset
;
3877 cur_val
= bfd_get_16 (output_bfd
, addr
);
3878 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3879 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3881 return bfd_reloc_ok
;
3884 /* Relocate an SH ELF section. */
3887 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3888 bfd
*input_bfd
, asection
*input_section
,
3889 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3890 Elf_Internal_Sym
*local_syms
,
3891 asection
**local_sections
)
3893 struct elf_sh_link_hash_table
*htab
;
3894 Elf_Internal_Shdr
*symtab_hdr
;
3895 struct elf_link_hash_entry
**sym_hashes
;
3896 Elf_Internal_Rela
*rel
, *relend
;
3898 bfd_vma
*local_got_offsets
;
3899 asection
*sgot
= NULL
;
3900 asection
*sgotplt
= NULL
;
3901 asection
*splt
= NULL
;
3902 asection
*sreloc
= NULL
;
3903 asection
*srelgot
= NULL
;
3904 bfd_boolean is_vxworks_tls
;
3905 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3906 bfd_boolean fdpic_p
= FALSE
;
3908 BFD_ASSERT (is_sh_elf (input_bfd
));
3910 htab
= sh_elf_hash_table (info
);
3913 dynobj
= htab
->root
.dynobj
;
3915 sgotplt
= htab
->sgotplt
;
3917 fdpic_p
= htab
->fdpic_p
;
3919 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3920 sym_hashes
= elf_sym_hashes (input_bfd
);
3921 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3923 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3924 input_section
->output_section
);
3925 if (fdpic_p
&& sgot
)
3926 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3927 sgot
->output_section
);
3930 if (fdpic_p
&& splt
)
3931 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3932 splt
->output_section
);
3936 /* We have to handle relocations in vxworks .tls_vars sections
3937 specially, because the dynamic loader is 'weird'. */
3938 is_vxworks_tls
= (htab
&& htab
->vxworks_p
&& info
->shared
3939 && !strcmp (input_section
->output_section
->name
,
3943 relend
= relocs
+ input_section
->reloc_count
;
3944 for (; rel
< relend
; rel
++)
3947 reloc_howto_type
*howto
;
3948 unsigned long r_symndx
;
3949 Elf_Internal_Sym
*sym
;
3951 struct elf_link_hash_entry
*h
;
3953 bfd_vma addend
= (bfd_vma
) 0;
3954 bfd_reloc_status_type r
;
3955 int seen_stt_datalabel
= 0;
3957 enum got_type got_type
;
3958 const char *symname
= NULL
;
3960 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3962 r_type
= ELF32_R_TYPE (rel
->r_info
);
3964 /* Many of the relocs are only used for relaxing, and are
3965 handled entirely by the relaxation code. */
3966 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3967 && r_type
<= (int) R_SH_LABEL
)
3969 if (r_type
== (int) R_SH_NONE
)
3973 || r_type
>= R_SH_max
3974 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3975 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3976 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3977 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
3978 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3979 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3980 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3981 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3982 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3983 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3984 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
3985 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
3987 bfd_set_error (bfd_error_bad_value
);
3991 howto
= get_howto_table (output_bfd
) + r_type
;
3993 /* For relocs that aren't partial_inplace, we get the addend from
3995 if (! howto
->partial_inplace
)
3996 addend
= rel
->r_addend
;
4001 check_segment
[0] = -1;
4002 check_segment
[1] = -1;
4003 if (r_symndx
< symtab_hdr
->sh_info
)
4005 sym
= local_syms
+ r_symndx
;
4006 sec
= local_sections
[r_symndx
];
4008 symname
= bfd_elf_string_from_elf_section
4009 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
4010 if (symname
== NULL
|| *symname
== '\0')
4011 symname
= bfd_section_name (input_bfd
, sec
);
4013 relocation
= (sec
->output_section
->vma
4014 + sec
->output_offset
4016 /* A local symbol never has STO_SH5_ISA32, so we don't need
4017 datalabel processing here. Make sure this does not change
4019 if ((sym
->st_other
& STO_SH5_ISA32
) != 0)
4020 ((*info
->callbacks
->reloc_dangerous
)
4022 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4023 input_bfd
, input_section
, rel
->r_offset
));
4025 if (sec
!= NULL
&& discarded_section (sec
))
4026 /* Handled below. */
4028 else if (info
->relocatable
)
4030 /* This is a relocatable link. We don't have to change
4031 anything, unless the reloc is against a section symbol,
4032 in which case we have to adjust according to where the
4033 section symbol winds up in the output section. */
4034 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4036 if (! howto
->partial_inplace
)
4038 /* For relocations with the addend in the
4039 relocation, we need just to update the addend.
4040 All real relocs are of type partial_inplace; this
4041 code is mostly for completeness. */
4042 rel
->r_addend
+= sec
->output_offset
;
4047 /* Relocs of type partial_inplace need to pick up the
4048 contents in the contents and add the offset resulting
4049 from the changed location of the section symbol.
4050 Using _bfd_final_link_relocate (e.g. goto
4051 final_link_relocate) here would be wrong, because
4052 relocations marked pc_relative would get the current
4053 location subtracted, and we must only do that at the
4055 r
= _bfd_relocate_contents (howto
, input_bfd
,
4058 contents
+ rel
->r_offset
);
4059 goto relocation_done
;
4064 else if (! howto
->partial_inplace
)
4066 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
4067 addend
= rel
->r_addend
;
4069 else if ((sec
->flags
& SEC_MERGE
)
4070 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4074 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
4076 (*_bfd_error_handler
)
4077 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4078 input_bfd
, input_section
,
4079 (long) rel
->r_offset
, howto
->name
);
4083 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4086 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
4088 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
4089 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
4095 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4098 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4099 symname
= h
->root
.root
.string
;
4100 while (h
->root
.type
== bfd_link_hash_indirect
4101 || h
->root
.type
== bfd_link_hash_warning
)
4103 #ifdef INCLUDE_SHMEDIA
4104 /* If the reference passes a symbol marked with
4105 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4107 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
4109 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4111 if (h
->root
.type
== bfd_link_hash_defined
4112 || h
->root
.type
== bfd_link_hash_defweak
)
4116 dyn
= htab
? htab
->root
.dynamic_sections_created
: FALSE
;
4117 sec
= h
->root
.u
.def
.section
;
4118 /* In these cases, we don't need the relocation value.
4119 We check specially because in some obscure cases
4120 sec->output_section will be NULL. */
4121 if (r_type
== R_SH_GOTPC
4122 || r_type
== R_SH_GOTPC_LOW16
4123 || r_type
== R_SH_GOTPC_MEDLOW16
4124 || r_type
== R_SH_GOTPC_MEDHI16
4125 || r_type
== R_SH_GOTPC_HI16
4126 || ((r_type
== R_SH_PLT32
4127 || r_type
== R_SH_PLT_LOW16
4128 || r_type
== R_SH_PLT_MEDLOW16
4129 || r_type
== R_SH_PLT_MEDHI16
4130 || r_type
== R_SH_PLT_HI16
)
4131 && h
->plt
.offset
!= (bfd_vma
) -1)
4132 || ((r_type
== R_SH_GOT32
4133 || r_type
== R_SH_GOT20
4134 || r_type
== R_SH_GOTFUNCDESC
4135 || r_type
== R_SH_GOTFUNCDESC20
4136 || r_type
== R_SH_GOTOFFFUNCDESC
4137 || r_type
== R_SH_GOTOFFFUNCDESC20
4138 || r_type
== R_SH_FUNCDESC
4139 || r_type
== R_SH_GOT_LOW16
4140 || r_type
== R_SH_GOT_MEDLOW16
4141 || r_type
== R_SH_GOT_MEDHI16
4142 || r_type
== R_SH_GOT_HI16
)
4143 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
4145 || (! info
->symbolic
&& h
->dynindx
!= -1)
4146 || !h
->def_regular
))
4147 /* The cases above are those in which relocation is
4148 overwritten in the switch block below. The cases
4149 below are those in which we must defer relocation
4150 to run-time, because we can't resolve absolute
4151 addresses when creating a shared library. */
4153 && ((! info
->symbolic
&& h
->dynindx
!= -1)
4155 && ((r_type
== R_SH_DIR32
4156 && !h
->forced_local
)
4157 || (r_type
== R_SH_REL32
4158 && !SYMBOL_CALLS_LOCAL (info
, h
)))
4159 && ((input_section
->flags
& SEC_ALLOC
) != 0
4160 /* DWARF will emit R_SH_DIR32 relocations in its
4161 sections against symbols defined externally
4162 in shared libraries. We can't do anything
4164 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
4165 && h
->def_dynamic
)))
4166 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4167 sections because such sections are not SEC_ALLOC and
4168 thus ld.so will not process them. */
4169 || (sec
->output_section
== NULL
4170 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
4172 || (sec
->output_section
== NULL
4173 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
4174 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
4176 else if (sec
->output_section
!= NULL
)
4177 relocation
= ((h
->root
.u
.def
.value
4178 + sec
->output_section
->vma
4179 + sec
->output_offset
)
4180 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4181 symbol value, unless we've seen
4182 STT_DATALABEL on the way to it. */
4183 | ((h
->other
& STO_SH5_ISA32
) != 0
4184 && ! seen_stt_datalabel
));
4185 else if (!info
->relocatable
4186 && (_bfd_elf_section_offset (output_bfd
, info
,
4191 (*_bfd_error_handler
)
4192 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4195 (long) rel
->r_offset
,
4197 h
->root
.root
.string
);
4201 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4203 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4204 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
4206 else if (!info
->relocatable
)
4208 if (! info
->callbacks
->undefined_symbol
4209 (info
, h
->root
.root
.string
, input_bfd
,
4210 input_section
, rel
->r_offset
,
4211 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
4212 || ELF_ST_VISIBILITY (h
->other
))))
4217 if (sec
!= NULL
&& discarded_section (sec
))
4218 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4219 rel
, 1, relend
, howto
, 0, contents
);
4221 if (info
->relocatable
)
4224 /* Check for inter-segment relocations in FDPIC files. Most
4225 relocations connect the relocation site to the location of
4226 the target symbol, but there are some exceptions below. */
4227 check_segment
[0] = isec_segment
;
4229 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
4230 sec
->output_section
);
4232 check_segment
[1] = -1;
4234 switch ((int) r_type
)
4236 final_link_relocate
:
4237 /* COFF relocs don't use the addend. The addend is used for
4238 R_SH_DIR32 to be compatible with other compilers. */
4239 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4240 contents
, rel
->r_offset
,
4241 relocation
, addend
);
4245 goto final_link_relocate
;
4250 /* If the reloc is against the start of this section, then
4251 the assembler has already taken care of it and the reloc
4252 is here only to assist in relaxing. If the reloc is not
4253 against the start of this section, then it's against an
4254 external symbol and we must deal with it ourselves. */
4255 if (input_section
->output_section
->vma
+ input_section
->output_offset
4258 int disp
= (relocation
4259 - input_section
->output_section
->vma
4260 - input_section
->output_offset
4266 case R_SH_DIR8WPZ
: mask
= 1; break;
4267 case R_SH_DIR8WPL
: mask
= 3; break;
4268 default: mask
= 0; break;
4272 ((*_bfd_error_handler
)
4273 (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4274 input_section
->owner
,
4275 (unsigned long) rel
->r_offset
));
4276 bfd_set_error (bfd_error_bad_value
);
4280 goto final_link_relocate
;
4286 #ifdef INCLUDE_SHMEDIA
4287 if (shmedia_prepare_reloc (info
, input_bfd
, input_section
,
4288 contents
, rel
, &relocation
))
4289 goto final_link_relocate
;
4291 bfd_set_error (bfd_error_bad_value
);
4299 goto final_link_relocate
;
4305 ((*_bfd_error_handler
)
4306 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4307 input_section
->owner
,
4308 (unsigned long) rel
->r_offset
, howto
->name
,
4309 (unsigned long) relocation
));
4310 bfd_set_error (bfd_error_bad_value
);
4313 goto final_link_relocate
;
4320 ((*_bfd_error_handler
)
4321 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4322 input_section
->owner
,
4323 (unsigned long) rel
->r_offset
, howto
->name
,
4324 (unsigned long) relocation
));
4325 bfd_set_error (bfd_error_bad_value
);
4328 goto final_link_relocate
;
4331 if ((signed int)relocation
< -32
4332 || (signed int)relocation
> 32)
4334 ((*_bfd_error_handler
)
4335 (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
4336 input_section
->owner
,
4337 (unsigned long) rel
->r_offset
,
4338 (unsigned long) relocation
));
4339 bfd_set_error (bfd_error_bad_value
);
4342 goto final_link_relocate
;
4345 if ((signed int)relocation
< -16
4346 || (signed int)relocation
> 16)
4348 ((*_bfd_error_handler
)
4349 (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
4350 input_section
->owner
,
4351 (unsigned long) rel
->r_offset
,
4352 (unsigned long) relocation
));
4353 bfd_set_error (bfd_error_bad_value
);
4356 goto final_link_relocate
;
4360 #ifdef INCLUDE_SHMEDIA
4361 case R_SH_IMM_LOW16_PCREL
:
4362 case R_SH_IMM_MEDLOW16_PCREL
:
4363 case R_SH_IMM_MEDHI16_PCREL
:
4364 case R_SH_IMM_HI16_PCREL
:
4368 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4369 || h
->root
.type
!= bfd_link_hash_undefweak
)
4370 && r_symndx
!= STN_UNDEF
4371 && (input_section
->flags
& SEC_ALLOC
) != 0
4373 && (r_type
== R_SH_DIR32
4374 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4376 Elf_Internal_Rela outrel
;
4378 bfd_boolean skip
, relocate
;
4380 /* When generating a shared object, these relocations
4381 are copied into the output file to be resolved at run
4386 sreloc
= _bfd_elf_get_dynamic_reloc_section
4387 (input_bfd
, input_section
, /*rela?*/ TRUE
);
4396 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4398 if (outrel
.r_offset
== (bfd_vma
) -1)
4400 else if (outrel
.r_offset
== (bfd_vma
) -2)
4401 skip
= TRUE
, relocate
= TRUE
;
4402 outrel
.r_offset
+= (input_section
->output_section
->vma
4403 + input_section
->output_offset
);
4406 memset (&outrel
, 0, sizeof outrel
);
4407 else if (r_type
== R_SH_REL32
)
4409 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
4410 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
4412 = (howto
->partial_inplace
4413 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4416 #ifdef INCLUDE_SHMEDIA
4417 else if (r_type
== R_SH_IMM_LOW16_PCREL
4418 || r_type
== R_SH_IMM_MEDLOW16_PCREL
4419 || r_type
== R_SH_IMM_MEDHI16_PCREL
4420 || r_type
== R_SH_IMM_HI16_PCREL
)
4422 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
4423 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4424 outrel
.r_addend
= addend
;
4429 || ((info
->symbolic
|| h
->dynindx
== -1)
4430 && h
->def_regular
)))
4434 BFD_ASSERT (sec
!= NULL
);
4435 BFD_ASSERT (sec
->output_section
!= NULL
);
4436 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
4437 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4438 outrel
.r_addend
= relocation
;
4440 += (howto
->partial_inplace
4441 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4443 outrel
.r_addend
-= sec
->output_section
->vma
;
4447 /* h->dynindx may be -1 if this symbol was marked to
4450 || ((info
->symbolic
|| h
->dynindx
== -1)
4453 relocate
= howto
->partial_inplace
;
4454 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4458 BFD_ASSERT (h
->dynindx
!= -1);
4459 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
4461 outrel
.r_addend
= relocation
;
4463 += (howto
->partial_inplace
4464 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4468 loc
= sreloc
->contents
;
4469 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4470 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4472 check_segment
[0] = check_segment
[1] = -1;
4474 /* If this reloc is against an external symbol, we do
4475 not want to fiddle with the addend. Otherwise, we
4476 need to include the symbol value so that it becomes
4477 an addend for the dynamic reloc. */
4481 else if (fdpic_p
&& !info
->shared
4482 && r_type
== R_SH_DIR32
4483 && (input_section
->flags
& SEC_ALLOC
) != 0)
4489 if (sh_elf_osec_readonly_p (output_bfd
,
4490 input_section
->output_section
))
4492 (*_bfd_error_handler
)
4493 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4496 (long) rel
->r_offset
,
4501 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4502 input_section
, rel
->r_offset
);
4503 if (offset
!= (bfd_vma
)-1)
4504 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4505 input_section
->output_section
->vma
4506 + input_section
->output_offset
4509 check_segment
[0] = check_segment
[1] = -1;
4511 goto final_link_relocate
;
4514 #ifdef INCLUDE_SHMEDIA
4515 case R_SH_GOTPLT_LOW16
:
4516 case R_SH_GOTPLT_MEDLOW16
:
4517 case R_SH_GOTPLT_MEDHI16
:
4518 case R_SH_GOTPLT_HI16
:
4519 case R_SH_GOTPLT10BY4
:
4520 case R_SH_GOTPLT10BY8
:
4522 /* Relocation is to the entry for this symbol in the
4523 procedure linkage table. */
4530 || h
->plt
.offset
== (bfd_vma
) -1
4531 || h
->got
.offset
!= (bfd_vma
) -1)
4534 /* Relocation is to the entry for this symbol in the global
4535 offset table extension for the procedure linkage table. */
4538 BFD_ASSERT (sgotplt
!= NULL
);
4539 relocation
= (sgotplt
->output_offset
4540 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4544 relocation
-= GOT_BIAS
;
4547 goto final_link_relocate
;
4552 #ifdef INCLUDE_SHMEDIA
4553 case R_SH_GOT_LOW16
:
4554 case R_SH_GOT_MEDLOW16
:
4555 case R_SH_GOT_MEDHI16
:
4560 /* Relocation is to the entry for this symbol in the global
4564 BFD_ASSERT (sgot
!= NULL
);
4565 check_segment
[0] = check_segment
[1] = -1;
4571 off
= h
->got
.offset
;
4572 #ifdef INCLUDE_SHMEDIA
4573 if (seen_stt_datalabel
)
4575 struct elf_sh_link_hash_entry
*hsh
;
4577 hsh
= (struct elf_sh_link_hash_entry
*)h
;
4578 off
= hsh
->datalabel_got
.offset
;
4581 BFD_ASSERT (off
!= (bfd_vma
) -1);
4583 dyn
= htab
->root
.dynamic_sections_created
;
4584 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
4586 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4587 || (ELF_ST_VISIBILITY (h
->other
)
4588 && h
->root
.type
== bfd_link_hash_undefweak
))
4590 /* This is actually a static link, or it is a
4591 -Bsymbolic link and the symbol is defined
4592 locally, or the symbol was forced to be local
4593 because of a version file. We must initialize
4594 this entry in the global offset table. Since the
4595 offset must always be a multiple of 4, we use the
4596 least significant bit to record whether we have
4597 initialized it already.
4599 When doing a dynamic link, we create a .rela.got
4600 relocation entry to initialize the value. This
4601 is done in the finish_dynamic_symbol routine. */
4606 bfd_put_32 (output_bfd
, relocation
,
4607 sgot
->contents
+ off
);
4608 #ifdef INCLUDE_SHMEDIA
4609 if (seen_stt_datalabel
)
4611 struct elf_sh_link_hash_entry
*hsh
;
4613 hsh
= (struct elf_sh_link_hash_entry
*)h
;
4614 hsh
->datalabel_got
.offset
|= 1;
4620 /* If we initialize the GOT entry here with a valid
4621 symbol address, also add a fixup. */
4622 if (fdpic_p
&& !info
->shared
4623 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4624 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4625 || h
->root
.type
!= bfd_link_hash_undefweak
))
4626 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4627 sgot
->output_section
->vma
4628 + sgot
->output_offset
4633 relocation
= sh_elf_got_offset (htab
) + off
;
4637 #ifdef INCLUDE_SHMEDIA
4640 BFD_ASSERT (local_got_offsets
!= NULL
4641 && (local_got_offsets
[symtab_hdr
->sh_info
4645 off
= local_got_offsets
[symtab_hdr
->sh_info
4651 BFD_ASSERT (local_got_offsets
!= NULL
4652 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4654 off
= local_got_offsets
[r_symndx
];
4655 #ifdef INCLUDE_SHMEDIA
4659 /* The offset must always be a multiple of 4. We use
4660 the least significant bit to record whether we have
4661 already generated the necessary reloc. */
4666 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4670 Elf_Internal_Rela outrel
;
4673 if (srelgot
== NULL
)
4675 srelgot
= bfd_get_section_by_name (dynobj
,
4677 BFD_ASSERT (srelgot
!= NULL
);
4680 outrel
.r_offset
= (sgot
->output_section
->vma
4681 + sgot
->output_offset
4686 = elf_section_data (sec
->output_section
)->dynindx
;
4687 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4688 outrel
.r_addend
= relocation
;
4689 outrel
.r_addend
-= sec
->output_section
->vma
;
4693 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4694 outrel
.r_addend
= relocation
;
4696 loc
= srelgot
->contents
;
4697 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4698 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4701 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4703 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4704 sgot
->output_section
->vma
4705 + sgot
->output_offset
4708 #ifdef INCLUDE_SHMEDIA
4710 local_got_offsets
[symtab_hdr
->sh_info
+ r_symndx
] |= 1;
4713 local_got_offsets
[r_symndx
] |= 1;
4716 relocation
= sh_elf_got_offset (htab
) + off
;
4720 relocation
-= GOT_BIAS
;
4723 if (r_type
== R_SH_GOT20
)
4725 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4726 input_bfd
, input_section
, contents
,
4731 goto final_link_relocate
;
4735 #ifdef INCLUDE_SHMEDIA
4736 case R_SH_GOTOFF_LOW16
:
4737 case R_SH_GOTOFF_MEDLOW16
:
4738 case R_SH_GOTOFF_MEDHI16
:
4739 case R_SH_GOTOFF_HI16
:
4741 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4742 we place at the start of the .got.plt section. This is the same
4743 as the start of the output .got section, unless there are function
4744 descriptors in front of it. */
4746 BFD_ASSERT (sgotplt
!= NULL
);
4747 check_segment
[0] = got_segment
;
4748 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4749 + htab
->root
.hgot
->root
.u
.def
.value
;
4752 relocation
-= GOT_BIAS
;
4755 addend
= rel
->r_addend
;
4757 if (r_type
== R_SH_GOTOFF20
)
4759 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4760 input_bfd
, input_section
, contents
,
4765 goto final_link_relocate
;
4768 #ifdef INCLUDE_SHMEDIA
4769 case R_SH_GOTPC_LOW16
:
4770 case R_SH_GOTPC_MEDLOW16
:
4771 case R_SH_GOTPC_MEDHI16
:
4772 case R_SH_GOTPC_HI16
:
4774 /* Use global offset table as symbol value. */
4776 BFD_ASSERT (sgotplt
!= NULL
);
4777 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4780 relocation
+= GOT_BIAS
;
4783 addend
= rel
->r_addend
;
4785 goto final_link_relocate
;
4788 #ifdef INCLUDE_SHMEDIA
4789 case R_SH_PLT_LOW16
:
4790 case R_SH_PLT_MEDLOW16
:
4791 case R_SH_PLT_MEDHI16
:
4794 /* Relocation is to the entry for this symbol in the
4795 procedure linkage table. */
4797 /* Resolve a PLT reloc against a local symbol directly,
4798 without using the procedure linkage table. */
4800 goto final_link_relocate
;
4802 /* We don't want to warn on calls to undefined weak symbols,
4803 as calls to them must be protected by non-NULL tests
4804 anyway, and unprotected calls would invoke undefined
4806 if (h
->root
.type
== bfd_link_hash_undefweak
)
4807 check_segment
[0] = check_segment
[1] = -1;
4809 if (h
->forced_local
)
4810 goto final_link_relocate
;
4812 if (h
->plt
.offset
== (bfd_vma
) -1)
4814 /* We didn't make a PLT entry for this symbol. This
4815 happens when statically linking PIC code, or when
4816 using -Bsymbolic. */
4817 goto final_link_relocate
;
4820 BFD_ASSERT (splt
!= NULL
);
4821 check_segment
[1] = plt_segment
;
4822 relocation
= (splt
->output_section
->vma
4823 + splt
->output_offset
4826 #ifdef INCLUDE_SHMEDIA
4830 addend
= rel
->r_addend
;
4832 goto final_link_relocate
;
4834 /* Relocation is to the canonical function descriptor for this
4835 symbol, possibly via the GOT. Initialize the GOT
4836 entry and function descriptor if necessary. */
4837 case R_SH_GOTFUNCDESC
:
4838 case R_SH_GOTFUNCDESC20
:
4842 asection
*reloc_section
;
4843 bfd_vma reloc_offset
;
4844 int reloc_type
= R_SH_FUNCDESC
;
4848 check_segment
[0] = check_segment
[1] = -1;
4850 /* FIXME: See what FRV does for global symbols in the
4851 executable, with --export-dynamic. Do they need ld.so
4852 to allocate official descriptors? See what this code
4858 if (r_type
== R_SH_FUNCDESC
)
4860 reloc_section
= input_section
;
4861 reloc_offset
= rel
->r_offset
;
4865 reloc_section
= sgot
;
4868 reloc_offset
= h
->got
.offset
;
4871 BFD_ASSERT (local_got_offsets
!= NULL
);
4872 reloc_offset
= local_got_offsets
[r_symndx
];
4874 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4876 if (reloc_offset
& 1)
4879 goto funcdesc_done_got
;
4883 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4884 && (SYMBOL_CALLS_LOCAL (info
, h
)
4885 || !htab
->root
.dynamic_sections_created
))
4886 /* Undefined weak symbol which will not be dynamically
4887 resolved later; leave it at zero. */
4888 goto funcdesc_leave_zero
;
4889 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4890 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4892 /* If the symbol needs a non-local function descriptor
4893 but binds locally (i.e., its visibility is
4894 protected), emit a dynamic relocation decayed to
4895 section+offset. This is an optimization; the dynamic
4896 linker would resolve our function descriptor request
4897 to our copy of the function anyway. */
4898 dynindx
= elf_section_data (h
->root
.u
.def
.section
4899 ->output_section
)->dynindx
;
4900 relocation
+= h
->root
.u
.def
.section
->output_offset
4901 + h
->root
.u
.def
.value
;
4903 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4905 /* If the symbol is dynamic and there will be dynamic
4906 symbol resolution because we are or are linked with a
4907 shared library, emit a FUNCDESC relocation such that
4908 the dynamic linker will allocate the function
4910 BFD_ASSERT (h
->dynindx
!= -1);
4911 dynindx
= h
->dynindx
;
4917 /* Otherwise, we know we have a private function
4918 descriptor, so reference it directly. */
4919 reloc_type
= R_SH_DIR32
;
4920 dynindx
= elf_section_data (htab
->sfuncdesc
4921 ->output_section
)->dynindx
;
4925 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4926 BFD_ASSERT (offset
!= MINUS_ONE
);
4927 if ((offset
& 1) == 0)
4929 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4932 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4937 union gotref
*local_funcdesc
;
4939 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4940 offset
= local_funcdesc
[r_symndx
].offset
;
4941 BFD_ASSERT (offset
!= MINUS_ONE
);
4942 if ((offset
& 1) == 0)
4944 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4948 local_funcdesc
[r_symndx
].offset
|= 1;
4952 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4955 if (!info
->shared
&& SYMBOL_FUNCDESC_LOCAL (info
, h
))
4959 if (sh_elf_osec_readonly_p (output_bfd
,
4960 reloc_section
->output_section
))
4962 (*_bfd_error_handler
)
4963 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4966 (long) rel
->r_offset
,
4971 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4972 reloc_section
, reloc_offset
);
4974 if (offset
!= (bfd_vma
)-1)
4975 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4977 + reloc_section
->output_section
->vma
4978 + reloc_section
->output_offset
);
4980 else if ((reloc_section
->output_section
->flags
4981 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
4985 if (sh_elf_osec_readonly_p (output_bfd
,
4986 reloc_section
->output_section
))
4988 info
->callbacks
->warning
4990 _("cannot emit dynamic relocations in read-only section"),
4991 symname
, input_bfd
, reloc_section
, reloc_offset
);
4995 if (srelgot
== NULL
)
4997 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4998 BFD_ASSERT (srelgot
!= NULL
);
5001 offset
= _bfd_elf_section_offset (output_bfd
, info
,
5002 reloc_section
, reloc_offset
);
5004 if (offset
!= (bfd_vma
)-1)
5005 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
5007 + reloc_section
->output_section
->vma
5008 + reloc_section
->output_offset
,
5009 reloc_type
, dynindx
, relocation
);
5011 if (r_type
== R_SH_FUNCDESC
)
5019 goto funcdesc_leave_zero
;
5023 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
5024 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
5025 funcdesc_leave_zero
:
5026 if (r_type
!= R_SH_FUNCDESC
)
5028 bfd_put_32 (output_bfd
, relocation
,
5029 reloc_section
->contents
+ reloc_offset
);
5033 local_got_offsets
[r_symndx
] |= 1;
5037 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
5039 relocation
-= GOT_BIAS
;
5042 if (r_type
== R_SH_GOTFUNCDESC20
)
5044 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
5045 input_bfd
, input_section
, contents
,
5050 goto final_link_relocate
;
5054 case R_SH_GOTOFFFUNCDESC
:
5055 case R_SH_GOTOFFFUNCDESC20
:
5056 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5057 executable and --export-dynamic. If such symbols get
5058 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5062 check_segment
[0] = check_segment
[1] = -1;
5064 addend
= rel
->r_addend
;
5066 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
5067 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
5070 (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
5071 input_bfd
, input_section
, (long) rel
->r_offset
, howto
->name
,
5072 h
->root
.root
.string
);
5079 /* Otherwise, we know we have a private function
5080 descriptor, so reference it directly. */
5083 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
5084 BFD_ASSERT (offset
!= MINUS_ONE
);
5085 if ((offset
& 1) == 0)
5087 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
5090 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
5095 union gotref
*local_funcdesc
;
5097 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
5098 offset
= local_funcdesc
[r_symndx
].offset
;
5099 BFD_ASSERT (offset
!= MINUS_ONE
);
5100 if ((offset
& 1) == 0)
5102 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
5106 local_funcdesc
[r_symndx
].offset
|= 1;
5110 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
5113 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
5114 + sgotplt
->output_offset
);
5116 relocation
-= GOT_BIAS
;
5119 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
5121 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
5122 input_bfd
, input_section
, contents
,
5127 goto final_link_relocate
;
5129 case R_SH_LOOP_START
:
5131 static bfd_vma start
, end
;
5133 start
= (relocation
+ rel
->r_addend
5134 - (sec
->output_section
->vma
+ sec
->output_offset
));
5135 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
5136 rel
->r_offset
, sec
, start
, end
);
5140 end
= (relocation
+ rel
->r_addend
5141 - (sec
->output_section
->vma
+ sec
->output_offset
));
5142 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
5143 rel
->r_offset
, sec
, start
, end
);
5147 case R_SH_TLS_GD_32
:
5148 case R_SH_TLS_IE_32
:
5150 check_segment
[0] = check_segment
[1] = -1;
5151 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5152 got_type
= GOT_UNKNOWN
;
5153 if (h
== NULL
&& local_got_offsets
)
5154 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
5157 got_type
= sh_elf_hash_entry (h
)->got_type
;
5159 && (h
->dynindx
== -1
5161 r_type
= R_SH_TLS_LE_32
;
5164 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
5165 r_type
= R_SH_TLS_IE_32
;
5167 if (r_type
== R_SH_TLS_LE_32
)
5170 unsigned short insn
;
5172 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
5174 /* GD->LE transition:
5175 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5176 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5177 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5179 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5181 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5183 offset
= rel
->r_offset
;
5184 BFD_ASSERT (offset
>= 16);
5185 /* Size of GD instructions is 16 or 18. */
5187 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5188 if ((insn
& 0xff00) == 0xc700)
5190 BFD_ASSERT (offset
>= 2);
5192 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5195 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5196 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5197 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5198 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5199 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5200 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5201 BFD_ASSERT (insn
== 0x310c);
5202 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5203 BFD_ASSERT (insn
== 0x410b);
5204 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5205 BFD_ASSERT (insn
== 0x34cc);
5207 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
5208 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
5209 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5210 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5211 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5217 /* IE->LE transition:
5218 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5219 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5221 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5224 offset
= rel
->r_offset
;
5225 BFD_ASSERT (offset
>= 16);
5226 /* Size of IE instructions is 10 or 12. */
5228 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5229 if ((insn
& 0xf0ff) == 0x0012)
5231 BFD_ASSERT (offset
>= 2);
5233 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5236 BFD_ASSERT ((insn
& 0xff00) == 0xd000);
5237 target
= insn
& 0x00ff;
5238 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5239 BFD_ASSERT ((insn
& 0xf0ff) == 0x0012);
5240 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5241 BFD_ASSERT ((insn
& 0xf0ff) == 0x00ce);
5242 insn
= 0xd000 | (insn
& 0x0f00) | target
;
5243 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
5244 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5247 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
5248 contents
+ rel
->r_offset
);
5252 if (sgot
== NULL
|| sgotplt
== NULL
)
5256 off
= h
->got
.offset
;
5259 if (local_got_offsets
== NULL
)
5262 off
= local_got_offsets
[r_symndx
];
5265 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5266 if (r_type
== R_SH_TLS_IE_32
5267 && ! htab
->root
.dynamic_sections_created
)
5270 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
5271 sgot
->contents
+ off
);
5272 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
5273 contents
+ rel
->r_offset
);
5281 Elf_Internal_Rela outrel
;
5285 if (srelgot
== NULL
)
5287 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
5288 BFD_ASSERT (srelgot
!= NULL
);
5291 outrel
.r_offset
= (sgot
->output_section
->vma
5292 + sgot
->output_offset
+ off
);
5294 if (h
== NULL
|| h
->dynindx
== -1)
5299 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
5301 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
5302 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5304 outrel
.r_addend
= 0;
5305 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
5306 loc
= srelgot
->contents
;
5307 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5308 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5310 if (r_type
== R_SH_TLS_GD_32
)
5314 bfd_put_32 (output_bfd
,
5315 relocation
- dtpoff_base (info
),
5316 sgot
->contents
+ off
+ 4);
5320 outrel
.r_info
= ELF32_R_INFO (indx
,
5322 outrel
.r_offset
+= 4;
5323 outrel
.r_addend
= 0;
5324 srelgot
->reloc_count
++;
5325 loc
+= sizeof (Elf32_External_Rela
);
5326 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5333 local_got_offsets
[r_symndx
] |= 1;
5336 if (off
>= (bfd_vma
) -2)
5339 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
5340 relocation
= sh_elf_got_offset (htab
) + off
;
5344 unsigned short insn
;
5346 /* GD->IE transition:
5347 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5348 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5349 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5351 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5352 nop; nop; bra 3f; nop; .align 2;
5353 1: .long x@TPOFF; 2:...; 3:. */
5355 offset
= rel
->r_offset
;
5356 BFD_ASSERT (offset
>= 16);
5357 /* Size of GD instructions is 16 or 18. */
5359 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5360 if ((insn
& 0xff00) == 0xc700)
5362 BFD_ASSERT (offset
>= 2);
5364 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5367 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5369 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5370 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
5372 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5373 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5374 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5375 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5376 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5377 BFD_ASSERT (insn
== 0x310c);
5378 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5379 BFD_ASSERT (insn
== 0x410b);
5380 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5381 BFD_ASSERT (insn
== 0x34cc);
5383 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
5384 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
5385 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
5386 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5387 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5389 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
5390 contents
+ rel
->r_offset
);
5395 addend
= rel
->r_addend
;
5397 goto final_link_relocate
;
5399 case R_SH_TLS_LD_32
:
5401 check_segment
[0] = check_segment
[1] = -1;
5405 unsigned short insn
;
5407 /* LD->LE transition:
5408 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5409 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5410 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5412 stc gbr,r0; nop; nop; nop;
5413 nop; nop; bra 3f; ...; 3:. */
5415 offset
= rel
->r_offset
;
5416 BFD_ASSERT (offset
>= 16);
5417 /* Size of LD instructions is 16 or 18. */
5419 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5420 if ((insn
& 0xff00) == 0xc700)
5422 BFD_ASSERT (offset
>= 2);
5424 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5427 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5428 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5429 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5430 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5431 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5432 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5433 BFD_ASSERT (insn
== 0x310c);
5434 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5435 BFD_ASSERT (insn
== 0x410b);
5436 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5437 BFD_ASSERT (insn
== 0x34cc);
5439 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
5440 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
5441 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5442 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5443 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5444 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5449 if (sgot
== NULL
|| sgotplt
== NULL
)
5452 off
= htab
->tls_ldm_got
.offset
;
5457 Elf_Internal_Rela outrel
;
5460 srelgot
= htab
->srelgot
;
5461 if (srelgot
== NULL
)
5464 outrel
.r_offset
= (sgot
->output_section
->vma
5465 + sgot
->output_offset
+ off
);
5466 outrel
.r_addend
= 0;
5467 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
5468 loc
= srelgot
->contents
;
5469 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5470 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5471 htab
->tls_ldm_got
.offset
|= 1;
5474 relocation
= sh_elf_got_offset (htab
) + off
;
5475 addend
= rel
->r_addend
;
5477 goto final_link_relocate
;
5479 case R_SH_TLS_LDO_32
:
5480 check_segment
[0] = check_segment
[1] = -1;
5482 relocation
= tpoff (info
, relocation
);
5484 relocation
-= dtpoff_base (info
);
5486 addend
= rel
->r_addend
;
5487 goto final_link_relocate
;
5489 case R_SH_TLS_LE_32
:
5492 Elf_Internal_Rela outrel
;
5495 check_segment
[0] = check_segment
[1] = -1;
5497 if (! info
->shared
|| info
->pie
)
5499 relocation
= tpoff (info
, relocation
);
5500 addend
= rel
->r_addend
;
5501 goto final_link_relocate
;
5506 sreloc
= _bfd_elf_get_dynamic_reloc_section
5507 (input_bfd
, input_section
, /*rela?*/ TRUE
);
5512 if (h
== NULL
|| h
->dynindx
== -1)
5517 outrel
.r_offset
= (input_section
->output_section
->vma
5518 + input_section
->output_offset
5520 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
5522 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5524 outrel
.r_addend
= 0;
5526 loc
= sreloc
->contents
;
5527 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5528 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5534 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5535 && check_segment
[0] != check_segment
[1])
5537 /* We don't want duplicate errors for undefined symbols. */
5538 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5542 info
->callbacks
->einfo
5543 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5544 input_bfd
, input_section
, rel
->r_offset
, symname
);
5548 info
->callbacks
->einfo
5549 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5550 input_bfd
, input_section
, rel
->r_offset
, symname
);
5553 elf_elfheader (output_bfd
)->e_flags
&= ~EF_SH_PIC
;
5556 if (r
!= bfd_reloc_ok
)
5561 case bfd_reloc_outofrange
:
5563 case bfd_reloc_overflow
:
5571 name
= (bfd_elf_string_from_elf_section
5572 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5576 name
= bfd_section_name (input_bfd
, sec
);
5578 if (! ((*info
->callbacks
->reloc_overflow
)
5579 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5580 (bfd_vma
) 0, input_bfd
, input_section
,
5592 /* This is a version of bfd_generic_get_relocated_section_contents
5593 which uses sh_elf_relocate_section. */
5596 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5597 struct bfd_link_info
*link_info
,
5598 struct bfd_link_order
*link_order
,
5600 bfd_boolean relocatable
,
5603 Elf_Internal_Shdr
*symtab_hdr
;
5604 asection
*input_section
= link_order
->u
.indirect
.section
;
5605 bfd
*input_bfd
= input_section
->owner
;
5606 asection
**sections
= NULL
;
5607 Elf_Internal_Rela
*internal_relocs
= NULL
;
5608 Elf_Internal_Sym
*isymbuf
= NULL
;
5610 /* We only need to handle the case of relaxing, or of having a
5611 particular set of section contents, specially. */
5613 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5614 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5619 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5621 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5622 (size_t) input_section
->size
);
5624 if ((input_section
->flags
& SEC_RELOC
) != 0
5625 && input_section
->reloc_count
> 0)
5628 Elf_Internal_Sym
*isym
, *isymend
;
5631 internal_relocs
= (_bfd_elf_link_read_relocs
5632 (input_bfd
, input_section
, NULL
,
5633 (Elf_Internal_Rela
*) NULL
, FALSE
));
5634 if (internal_relocs
== NULL
)
5637 if (symtab_hdr
->sh_info
!= 0)
5639 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5640 if (isymbuf
== NULL
)
5641 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5642 symtab_hdr
->sh_info
, 0,
5644 if (isymbuf
== NULL
)
5648 amt
= symtab_hdr
->sh_info
;
5649 amt
*= sizeof (asection
*);
5650 sections
= (asection
**) bfd_malloc (amt
);
5651 if (sections
== NULL
&& amt
!= 0)
5654 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5655 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5659 if (isym
->st_shndx
== SHN_UNDEF
)
5660 isec
= bfd_und_section_ptr
;
5661 else if (isym
->st_shndx
== SHN_ABS
)
5662 isec
= bfd_abs_section_ptr
;
5663 else if (isym
->st_shndx
== SHN_COMMON
)
5664 isec
= bfd_com_section_ptr
;
5666 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5671 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5672 input_section
, data
, internal_relocs
,
5676 if (sections
!= NULL
)
5679 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5681 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5682 free (internal_relocs
);
5688 if (sections
!= NULL
)
5691 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5693 if (internal_relocs
!= NULL
5694 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
5695 free (internal_relocs
);
5699 /* Return the base VMA address which should be subtracted from real addresses
5700 when resolving @dtpoff relocation.
5701 This is PT_TLS segment p_vaddr. */
5704 dtpoff_base (struct bfd_link_info
*info
)
5706 /* If tls_sec is NULL, we should have signalled an error already. */
5707 if (elf_hash_table (info
)->tls_sec
== NULL
)
5709 return elf_hash_table (info
)->tls_sec
->vma
;
5712 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5715 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5717 /* If tls_sec is NULL, we should have signalled an error already. */
5718 if (elf_hash_table (info
)->tls_sec
== NULL
)
5720 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5721 structure which has 2 pointer fields. */
5722 return (address
- elf_hash_table (info
)->tls_sec
->vma
5723 + align_power ((bfd_vma
) 8,
5724 elf_hash_table (info
)->tls_sec
->alignment_power
));
5728 sh_elf_gc_mark_hook (asection
*sec
,
5729 struct bfd_link_info
*info
,
5730 Elf_Internal_Rela
*rel
,
5731 struct elf_link_hash_entry
*h
,
5732 Elf_Internal_Sym
*sym
)
5735 switch (ELF32_R_TYPE (rel
->r_info
))
5737 case R_SH_GNU_VTINHERIT
:
5738 case R_SH_GNU_VTENTRY
:
5742 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5745 /* Update the got entry reference counts for the section being removed. */
5748 sh_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5749 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5751 Elf_Internal_Shdr
*symtab_hdr
;
5752 struct elf_link_hash_entry
**sym_hashes
;
5753 bfd_signed_vma
*local_got_refcounts
;
5754 union gotref
*local_funcdesc
;
5755 const Elf_Internal_Rela
*rel
, *relend
;
5757 if (info
->relocatable
)
5760 elf_section_data (sec
)->local_dynrel
= NULL
;
5762 symtab_hdr
= &elf_symtab_hdr (abfd
);
5763 sym_hashes
= elf_sym_hashes (abfd
);
5764 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5765 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5767 relend
= relocs
+ sec
->reloc_count
;
5768 for (rel
= relocs
; rel
< relend
; rel
++)
5770 unsigned long r_symndx
;
5771 unsigned int r_type
;
5772 struct elf_link_hash_entry
*h
= NULL
;
5773 #ifdef INCLUDE_SHMEDIA
5774 int seen_stt_datalabel
= 0;
5777 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5778 if (r_symndx
>= symtab_hdr
->sh_info
)
5780 struct elf_sh_link_hash_entry
*eh
;
5781 struct elf_sh_dyn_relocs
**pp
;
5782 struct elf_sh_dyn_relocs
*p
;
5784 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5785 while (h
->root
.type
== bfd_link_hash_indirect
5786 || h
->root
.type
== bfd_link_hash_warning
)
5788 #ifdef INCLUDE_SHMEDIA
5789 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
5791 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5793 eh
= (struct elf_sh_link_hash_entry
*) h
;
5794 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
5797 /* Everything must go for SEC. */
5803 r_type
= ELF32_R_TYPE (rel
->r_info
);
5804 switch (sh_elf_optimized_tls_reloc (info
, r_type
, h
!= NULL
))
5806 case R_SH_TLS_LD_32
:
5807 if (sh_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
5808 sh_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
5816 #ifdef INCLUDE_SHMEDIA
5817 case R_SH_GOT_LOW16
:
5818 case R_SH_GOT_MEDLOW16
:
5819 case R_SH_GOT_MEDHI16
:
5823 case R_SH_GOTOFF_LOW16
:
5824 case R_SH_GOTOFF_MEDLOW16
:
5825 case R_SH_GOTOFF_MEDHI16
:
5826 case R_SH_GOTOFF_HI16
:
5827 case R_SH_GOTPC_LOW16
:
5828 case R_SH_GOTPC_MEDLOW16
:
5829 case R_SH_GOTPC_MEDHI16
:
5830 case R_SH_GOTPC_HI16
:
5832 case R_SH_TLS_GD_32
:
5833 case R_SH_TLS_IE_32
:
5834 case R_SH_GOTFUNCDESC
:
5835 case R_SH_GOTFUNCDESC20
:
5838 #ifdef INCLUDE_SHMEDIA
5839 if (seen_stt_datalabel
)
5841 struct elf_sh_link_hash_entry
*eh
;
5842 eh
= (struct elf_sh_link_hash_entry
*) h
;
5843 if (eh
->datalabel_got
.refcount
> 0)
5844 eh
->datalabel_got
.refcount
-= 1;
5848 if (h
->got
.refcount
> 0)
5849 h
->got
.refcount
-= 1;
5851 else if (local_got_refcounts
!= NULL
)
5853 #ifdef INCLUDE_SHMEDIA
5854 if (rel
->r_addend
& 1)
5856 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
5857 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
5861 if (local_got_refcounts
[r_symndx
] > 0)
5862 local_got_refcounts
[r_symndx
] -= 1;
5868 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
-= 1;
5869 else if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->shared
)
5870 sh_elf_hash_table (info
)->srofixup
->size
-= 4;
5874 case R_SH_GOTOFFFUNCDESC
:
5875 case R_SH_GOTOFFFUNCDESC20
:
5877 sh_elf_hash_entry (h
)->funcdesc
.refcount
-= 1;
5879 local_funcdesc
[r_symndx
].refcount
-= 1;
5883 if (sh_elf_hash_table (info
)->fdpic_p
&& !info
->shared
5884 && (sec
->flags
& SEC_ALLOC
) != 0)
5885 sh_elf_hash_table (info
)->srofixup
->size
-= 4;
5894 #ifdef INCLUDE_SHMEDIA
5895 case R_SH_PLT_LOW16
:
5896 case R_SH_PLT_MEDLOW16
:
5897 case R_SH_PLT_MEDHI16
:
5902 if (h
->plt
.refcount
> 0)
5903 h
->plt
.refcount
-= 1;
5908 #ifdef INCLUDE_SHMEDIA
5909 case R_SH_GOTPLT_LOW16
:
5910 case R_SH_GOTPLT_MEDLOW16
:
5911 case R_SH_GOTPLT_MEDHI16
:
5912 case R_SH_GOTPLT_HI16
:
5913 case R_SH_GOTPLT10BY4
:
5914 case R_SH_GOTPLT10BY8
:
5918 struct elf_sh_link_hash_entry
*eh
;
5919 eh
= (struct elf_sh_link_hash_entry
*) h
;
5920 if (eh
->gotplt_refcount
> 0)
5922 eh
->gotplt_refcount
-= 1;
5923 if (h
->plt
.refcount
> 0)
5924 h
->plt
.refcount
-= 1;
5926 #ifdef INCLUDE_SHMEDIA
5927 else if (seen_stt_datalabel
)
5929 if (eh
->datalabel_got
.refcount
> 0)
5930 eh
->datalabel_got
.refcount
-= 1;
5933 else if (h
->got
.refcount
> 0)
5934 h
->got
.refcount
-= 1;
5936 else if (local_got_refcounts
!= NULL
)
5938 #ifdef INCLUDE_SHMEDIA
5939 if (rel
->r_addend
& 1)
5941 if (local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] > 0)
5942 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] -= 1;
5946 if (local_got_refcounts
[r_symndx
] > 0)
5947 local_got_refcounts
[r_symndx
] -= 1;
5959 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5962 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
5963 struct elf_link_hash_entry
*dir
,
5964 struct elf_link_hash_entry
*ind
)
5966 struct elf_sh_link_hash_entry
*edir
, *eind
;
5968 edir
= (struct elf_sh_link_hash_entry
*) dir
;
5969 eind
= (struct elf_sh_link_hash_entry
*) ind
;
5971 if (eind
->dyn_relocs
!= NULL
)
5973 if (edir
->dyn_relocs
!= NULL
)
5975 struct elf_sh_dyn_relocs
**pp
;
5976 struct elf_sh_dyn_relocs
*p
;
5978 /* Add reloc counts against the indirect sym to the direct sym
5979 list. Merge any entries against the same section. */
5980 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
5982 struct elf_sh_dyn_relocs
*q
;
5984 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
5985 if (q
->sec
== p
->sec
)
5987 q
->pc_count
+= p
->pc_count
;
5988 q
->count
+= p
->count
;
5995 *pp
= edir
->dyn_relocs
;
5998 edir
->dyn_relocs
= eind
->dyn_relocs
;
5999 eind
->dyn_relocs
= NULL
;
6001 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
6002 eind
->gotplt_refcount
= 0;
6003 #ifdef INCLUDE_SHMEDIA
6004 edir
->datalabel_got
.refcount
+= eind
->datalabel_got
.refcount
;
6005 eind
->datalabel_got
.refcount
= 0;
6007 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
6008 eind
->funcdesc
.refcount
= 0;
6009 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
6010 eind
->abs_funcdesc_refcount
= 0;
6012 if (ind
->root
.type
== bfd_link_hash_indirect
6013 && dir
->got
.refcount
<= 0)
6015 edir
->got_type
= eind
->got_type
;
6016 eind
->got_type
= GOT_UNKNOWN
;
6019 if (ind
->root
.type
!= bfd_link_hash_indirect
6020 && dir
->dynamic_adjusted
)
6022 /* If called to transfer flags for a weakdef during processing
6023 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6024 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6025 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6026 dir
->ref_regular
|= ind
->ref_regular
;
6027 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6028 dir
->needs_plt
|= ind
->needs_plt
;
6031 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
6035 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
6043 case R_SH_TLS_GD_32
:
6044 case R_SH_TLS_IE_32
:
6046 return R_SH_TLS_LE_32
;
6047 return R_SH_TLS_IE_32
;
6048 case R_SH_TLS_LD_32
:
6049 return R_SH_TLS_LE_32
;
6055 /* Look through the relocs for a section during the first phase.
6056 Since we don't do .gots or .plts, we just need to consider the
6057 virtual table relocs for gc. */
6060 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
6061 const Elf_Internal_Rela
*relocs
)
6063 Elf_Internal_Shdr
*symtab_hdr
;
6064 struct elf_link_hash_entry
**sym_hashes
;
6065 struct elf_sh_link_hash_table
*htab
;
6066 const Elf_Internal_Rela
*rel
;
6067 const Elf_Internal_Rela
*rel_end
;
6069 unsigned int r_type
;
6070 enum got_type got_type
, old_got_type
;
6074 if (info
->relocatable
)
6077 BFD_ASSERT (is_sh_elf (abfd
));
6079 symtab_hdr
= &elf_symtab_hdr (abfd
);
6080 sym_hashes
= elf_sym_hashes (abfd
);
6082 htab
= sh_elf_hash_table (info
);
6086 rel_end
= relocs
+ sec
->reloc_count
;
6087 for (rel
= relocs
; rel
< rel_end
; rel
++)
6089 struct elf_link_hash_entry
*h
;
6090 unsigned long r_symndx
;
6091 #ifdef INCLUDE_SHMEDIA
6092 int seen_stt_datalabel
= 0;
6095 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6096 r_type
= ELF32_R_TYPE (rel
->r_info
);
6098 if (r_symndx
< symtab_hdr
->sh_info
)
6102 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6103 while (h
->root
.type
== bfd_link_hash_indirect
6104 || h
->root
.type
== bfd_link_hash_warning
)
6106 #ifdef INCLUDE_SHMEDIA
6107 seen_stt_datalabel
|= h
->type
== STT_DATALABEL
;
6109 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6113 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
6115 && r_type
== R_SH_TLS_IE_32
6117 && h
->root
.type
!= bfd_link_hash_undefined
6118 && h
->root
.type
!= bfd_link_hash_undefweak
6119 && (h
->dynindx
== -1
6121 r_type
= R_SH_TLS_LE_32
;
6126 case R_SH_GOTOFFFUNCDESC
:
6127 case R_SH_GOTOFFFUNCDESC20
:
6129 case R_SH_GOTFUNCDESC
:
6130 case R_SH_GOTFUNCDESC20
:
6133 if (h
->dynindx
== -1)
6134 switch (ELF_ST_VISIBILITY (h
->other
))
6140 bfd_elf_link_record_dynamic_symbol (info
, h
);
6147 /* Some relocs require a global offset table. */
6148 if (htab
->sgot
== NULL
)
6153 /* This may require an rofixup. */
6162 case R_SH_GOTFUNCDESC
:
6163 case R_SH_GOTFUNCDESC20
:
6164 case R_SH_GOTOFFFUNCDESC
:
6165 case R_SH_GOTOFFFUNCDESC20
:
6167 #ifdef INCLUDE_SHMEDIA
6168 case R_SH_GOTPLT_LOW16
:
6169 case R_SH_GOTPLT_MEDLOW16
:
6170 case R_SH_GOTPLT_MEDHI16
:
6171 case R_SH_GOTPLT_HI16
:
6172 case R_SH_GOTPLT10BY4
:
6173 case R_SH_GOTPLT10BY8
:
6174 case R_SH_GOT_LOW16
:
6175 case R_SH_GOT_MEDLOW16
:
6176 case R_SH_GOT_MEDHI16
:
6180 case R_SH_GOTOFF_LOW16
:
6181 case R_SH_GOTOFF_MEDLOW16
:
6182 case R_SH_GOTOFF_MEDHI16
:
6183 case R_SH_GOTOFF_HI16
:
6184 case R_SH_GOTPC_LOW16
:
6185 case R_SH_GOTPC_MEDLOW16
:
6186 case R_SH_GOTPC_MEDHI16
:
6187 case R_SH_GOTPC_HI16
:
6189 case R_SH_TLS_GD_32
:
6190 case R_SH_TLS_LD_32
:
6191 case R_SH_TLS_IE_32
:
6192 if (htab
->root
.dynobj
== NULL
)
6193 htab
->root
.dynobj
= abfd
;
6194 if (!create_got_section (htab
->root
.dynobj
, info
))
6205 /* This relocation describes the C++ object vtable hierarchy.
6206 Reconstruct it for later use during GC. */
6207 case R_SH_GNU_VTINHERIT
:
6208 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6212 /* This relocation describes which C++ vtable entries are actually
6213 used. Record for later use during GC. */
6214 case R_SH_GNU_VTENTRY
:
6215 BFD_ASSERT (h
!= NULL
);
6217 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
6221 case R_SH_TLS_IE_32
:
6223 info
->flags
|= DF_STATIC_TLS
;
6227 case R_SH_TLS_GD_32
:
6230 #ifdef INCLUDE_SHMEDIA
6231 case R_SH_GOT_LOW16
:
6232 case R_SH_GOT_MEDLOW16
:
6233 case R_SH_GOT_MEDHI16
:
6238 case R_SH_GOTFUNCDESC
:
6239 case R_SH_GOTFUNCDESC20
:
6243 got_type
= GOT_NORMAL
;
6245 case R_SH_TLS_GD_32
:
6246 got_type
= GOT_TLS_GD
;
6248 case R_SH_TLS_IE_32
:
6249 got_type
= GOT_TLS_IE
;
6251 case R_SH_GOTFUNCDESC
:
6252 case R_SH_GOTFUNCDESC20
:
6253 got_type
= GOT_FUNCDESC
;
6259 #ifdef INCLUDE_SHMEDIA
6260 if (seen_stt_datalabel
)
6262 struct elf_sh_link_hash_entry
*eh
6263 = (struct elf_sh_link_hash_entry
*) h
;
6265 eh
->datalabel_got
.refcount
+= 1;
6269 h
->got
.refcount
+= 1;
6270 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
6274 bfd_signed_vma
*local_got_refcounts
;
6276 /* This is a global offset table entry for a local
6278 local_got_refcounts
= elf_local_got_refcounts (abfd
);
6279 if (local_got_refcounts
== NULL
)
6283 size
= symtab_hdr
->sh_info
;
6284 size
*= sizeof (bfd_signed_vma
);
6285 #ifdef INCLUDE_SHMEDIA
6286 /* Reserve space for both the datalabel and
6287 codelabel local GOT offsets. */
6290 size
+= symtab_hdr
->sh_info
;
6291 local_got_refcounts
= ((bfd_signed_vma
*)
6292 bfd_zalloc (abfd
, size
));
6293 if (local_got_refcounts
== NULL
)
6295 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
6296 #ifdef INCLUDE_SHMEDIA
6297 /* Take care of both the datalabel and codelabel local
6299 sh_elf_local_got_type (abfd
)
6300 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
6302 sh_elf_local_got_type (abfd
)
6303 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
6306 #ifdef INCLUDE_SHMEDIA
6307 if (rel
->r_addend
& 1)
6308 local_got_refcounts
[symtab_hdr
->sh_info
+ r_symndx
] += 1;
6311 local_got_refcounts
[r_symndx
] += 1;
6312 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
6315 /* If a TLS symbol is accessed using IE at least once,
6316 there is no point to use dynamic model for it. */
6317 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
6318 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
6320 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
6321 got_type
= GOT_TLS_IE
;
6324 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
6325 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
6326 (*_bfd_error_handler
)
6327 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6328 abfd
, h
->root
.root
.string
);
6329 else if (old_got_type
== GOT_FUNCDESC
6330 || got_type
== GOT_FUNCDESC
)
6331 (*_bfd_error_handler
)
6332 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6333 abfd
, h
->root
.root
.string
);
6335 (*_bfd_error_handler
)
6336 (_("%B: `%s' accessed both as normal and thread local symbol"),
6337 abfd
, h
->root
.root
.string
);
6342 if (old_got_type
!= got_type
)
6345 sh_elf_hash_entry (h
)->got_type
= got_type
;
6347 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
6352 case R_SH_TLS_LD_32
:
6353 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
6357 case R_SH_GOTOFFFUNCDESC
:
6358 case R_SH_GOTOFFFUNCDESC20
:
6361 (*_bfd_error_handler
)
6362 (_("%B: Function descriptor relocation with non-zero addend"),
6369 union gotref
*local_funcdesc
;
6371 /* We need a function descriptor for a local symbol. */
6372 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
6373 if (local_funcdesc
== NULL
)
6377 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
6378 #ifdef INCLUDE_SHMEDIA
6379 /* Count datalabel local GOT. */
6382 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
6383 if (local_funcdesc
== NULL
)
6385 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
6387 local_funcdesc
[r_symndx
].refcount
+= 1;
6389 if (r_type
== R_SH_FUNCDESC
)
6392 htab
->srofixup
->size
+= 4;
6394 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
6399 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
6400 if (r_type
== R_SH_FUNCDESC
)
6401 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
6403 /* If there is a function descriptor reference, then
6404 there should not be any non-FDPIC references. */
6405 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
6406 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
6408 if (old_got_type
== GOT_NORMAL
)
6409 (*_bfd_error_handler
)
6410 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6411 abfd
, h
->root
.root
.string
);
6413 (*_bfd_error_handler
)
6414 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6415 abfd
, h
->root
.root
.string
);
6421 #ifdef INCLUDE_SHMEDIA
6422 case R_SH_GOTPLT_LOW16
:
6423 case R_SH_GOTPLT_MEDLOW16
:
6424 case R_SH_GOTPLT_MEDHI16
:
6425 case R_SH_GOTPLT_HI16
:
6426 case R_SH_GOTPLT10BY4
:
6427 case R_SH_GOTPLT10BY8
:
6429 /* If this is a local symbol, we resolve it directly without
6430 creating a procedure linkage table entry. */
6436 || h
->dynindx
== -1)
6440 h
->plt
.refcount
+= 1;
6441 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
6446 #ifdef INCLUDE_SHMEDIA
6447 case R_SH_PLT_LOW16
:
6448 case R_SH_PLT_MEDLOW16
:
6449 case R_SH_PLT_MEDHI16
:
6452 /* This symbol requires a procedure linkage table entry. We
6453 actually build the entry in adjust_dynamic_symbol,
6454 because this might be a case of linking PIC code which is
6455 never referenced by a dynamic object, in which case we
6456 don't need to generate a procedure linkage table entry
6459 /* If this is a local symbol, we resolve it directly without
6460 creating a procedure linkage table entry. */
6464 if (h
->forced_local
)
6468 h
->plt
.refcount
+= 1;
6473 #ifdef INCLUDE_SHMEDIA
6474 case R_SH_IMM_LOW16_PCREL
:
6475 case R_SH_IMM_MEDLOW16_PCREL
:
6476 case R_SH_IMM_MEDHI16_PCREL
:
6477 case R_SH_IMM_HI16_PCREL
:
6479 if (h
!= NULL
&& ! info
->shared
)
6482 h
->plt
.refcount
+= 1;
6485 /* If we are creating a shared library, and this is a reloc
6486 against a global symbol, or a non PC relative reloc
6487 against a local symbol, then we need to copy the reloc
6488 into the shared library. However, if we are linking with
6489 -Bsymbolic, we do not need to copy a reloc against a
6490 global symbol which is defined in an object we are
6491 including in the link (i.e., DEF_REGULAR is set). At
6492 this point we have not seen all the input files, so it is
6493 possible that DEF_REGULAR is not set now but will be set
6494 later (it is never cleared). We account for that
6495 possibility below by storing information in the
6496 dyn_relocs field of the hash table entry. A similar
6497 situation occurs when creating shared libraries and symbol
6498 visibility changes render the symbol local.
6500 If on the other hand, we are creating an executable, we
6501 may need to keep relocations for symbols satisfied by a
6502 dynamic library if we manage to avoid copy relocs for the
6505 && (sec
->flags
& SEC_ALLOC
) != 0
6506 && (r_type
!= R_SH_REL32
6508 && (! info
->symbolic
6509 || h
->root
.type
== bfd_link_hash_defweak
6510 || !h
->def_regular
))))
6512 && (sec
->flags
& SEC_ALLOC
) != 0
6514 && (h
->root
.type
== bfd_link_hash_defweak
6515 || !h
->def_regular
)))
6517 struct elf_sh_dyn_relocs
*p
;
6518 struct elf_sh_dyn_relocs
**head
;
6520 if (htab
->root
.dynobj
== NULL
)
6521 htab
->root
.dynobj
= abfd
;
6523 /* When creating a shared object, we must copy these
6524 reloc types into the output file. We create a reloc
6525 section in dynobj and make room for this reloc. */
6528 sreloc
= _bfd_elf_make_dynamic_reloc_section
6529 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
6535 /* If this is a global symbol, we count the number of
6536 relocations we need for this symbol. */
6538 head
= &((struct elf_sh_link_hash_entry
*) h
)->dyn_relocs
;
6541 /* Track dynamic relocs needed for local syms too. */
6544 Elf_Internal_Sym
*isym
;
6546 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
6551 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
6555 vpp
= &elf_section_data (s
)->local_dynrel
;
6556 head
= (struct elf_sh_dyn_relocs
**) vpp
;
6560 if (p
== NULL
|| p
->sec
!= sec
)
6562 bfd_size_type amt
= sizeof (*p
);
6563 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
6574 if (r_type
== R_SH_REL32
6575 #ifdef INCLUDE_SHMEDIA
6576 || r_type
== R_SH_IMM_LOW16_PCREL
6577 || r_type
== R_SH_IMM_MEDLOW16_PCREL
6578 || r_type
== R_SH_IMM_MEDHI16_PCREL
6579 || r_type
== R_SH_IMM_HI16_PCREL
6585 /* Allocate the fixup regardless of whether we need a relocation.
6586 If we end up generating the relocation, we'll unallocate the
6588 if (htab
->fdpic_p
&& !info
->shared
6589 && r_type
== R_SH_DIR32
6590 && (sec
->flags
& SEC_ALLOC
) != 0)
6591 htab
->srofixup
->size
+= 4;
6594 case R_SH_TLS_LE_32
:
6595 if (info
->shared
&& !info
->pie
)
6597 (*_bfd_error_handler
)
6598 (_("%B: TLS local exec code cannot be linked into shared objects"),
6605 case R_SH_TLS_LDO_32
:
6606 /* Nothing to do. */
6617 #ifndef sh_elf_set_mach_from_flags
6618 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
6621 sh_elf_set_mach_from_flags (bfd
*abfd
)
6623 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
6625 if (flags
>= sizeof(sh_ef_bfd_table
))
6628 if (sh_ef_bfd_table
[flags
] == 0)
6631 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
6637 /* Reverse table lookup for sh_ef_bfd_table[].
6638 Given a bfd MACH value from archures.c
6639 return the equivalent ELF flags from the table.
6640 Return -1 if no match is found. */
6643 sh_elf_get_flags_from_mach (unsigned long mach
)
6645 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
6648 if (sh_ef_bfd_table
[i
] == mach
)
6651 /* shouldn't get here */
6656 #endif /* not sh_elf_set_mach_from_flags */
6658 #ifndef sh_elf_set_private_flags
6659 /* Function to keep SH specific file flags. */
6662 sh_elf_set_private_flags (bfd
*abfd
, flagword flags
)
6664 BFD_ASSERT (! elf_flags_init (abfd
)
6665 || elf_elfheader (abfd
)->e_flags
== flags
);
6667 elf_elfheader (abfd
)->e_flags
= flags
;
6668 elf_flags_init (abfd
) = TRUE
;
6669 return sh_elf_set_mach_from_flags (abfd
);
6671 #endif /* not sh_elf_set_private_flags */
6673 #ifndef sh_elf_copy_private_data
6674 /* Copy backend specific data from one object module to another */
6677 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
6679 /* Copy object attributes. */
6680 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
6682 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6685 /* Copy the stack size. */
6686 if (elf_tdata (ibfd
)->phdr
&& elf_tdata (obfd
)->phdr
6687 && fdpic_object_p (ibfd
) && fdpic_object_p (obfd
))
6691 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
6692 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
6694 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
6696 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
6697 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
6699 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
6701 /* Rewrite the phdrs, since we're only called after they
6702 were first written. */
6704 (bfd_signed_vma
) get_elf_backend_data (obfd
)
6705 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
6706 || get_elf_backend_data (obfd
)->s
6707 ->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
6708 elf_elfheader (obfd
)->e_phnum
) != 0)
6717 return sh_elf_set_private_flags (obfd
, elf_elfheader (ibfd
)->e_flags
);
6719 #endif /* not sh_elf_copy_private_data */
6721 #ifndef sh_elf_merge_private_data
6723 /* This function returns the ELF architecture number that
6724 corresponds to the given arch_sh* flags. */
6727 sh_find_elf_flags (unsigned int arch_set
)
6729 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
6730 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
6732 return sh_elf_get_flags_from_mach (bfd_mach
);
6735 /* This routine initialises the elf flags when required and
6736 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6739 sh_elf_merge_private_data (bfd
*ibfd
, bfd
*obfd
)
6741 extern bfd_boolean
sh_merge_bfd_arch (bfd
*, bfd
*);
6743 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6746 if (! elf_flags_init (obfd
))
6748 /* This happens when ld starts out with a 'blank' output file. */
6749 elf_flags_init (obfd
) = TRUE
;
6750 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
6751 sh_elf_set_mach_from_flags (obfd
);
6752 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
6753 elf_elfheader (obfd
)->e_flags
|= EF_SH_PIC
;
6756 if (! sh_merge_bfd_arch (ibfd
, obfd
))
6758 _bfd_error_handler ("%B: uses instructions which are incompatible "
6759 "with instructions used in previous modules",
6761 bfd_set_error (bfd_error_bad_value
);
6765 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
6766 elf_elfheader (obfd
)->e_flags
|=
6767 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
6769 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
6771 _bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects",
6773 bfd_set_error (bfd_error_bad_value
);
6779 #endif /* not sh_elf_merge_private_data */
6781 /* Override the generic function because we need to store sh_elf_obj_tdata
6782 as the specific tdata. We set also the machine architecture from flags
6786 sh_elf_object_p (bfd
*abfd
)
6788 if (! sh_elf_set_mach_from_flags (abfd
))
6791 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
6792 == fdpic_object_p (abfd
));
6795 /* Finish up dynamic symbol handling. We set the contents of various
6796 dynamic sections here. */
6799 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
6800 struct elf_link_hash_entry
*h
,
6801 Elf_Internal_Sym
*sym
)
6803 struct elf_sh_link_hash_table
*htab
;
6805 htab
= sh_elf_hash_table (info
);
6809 if (h
->plt
.offset
!= (bfd_vma
) -1)
6817 Elf_Internal_Rela rel
;
6819 const struct elf_sh_plt_info
*plt_info
;
6821 /* This symbol has an entry in the procedure linkage table. Set
6824 BFD_ASSERT (h
->dynindx
!= -1);
6827 sgotplt
= htab
->sgotplt
;
6828 srelplt
= htab
->srelplt
;
6829 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
6831 /* Get the index in the procedure linkage table which
6832 corresponds to this symbol. This is the index of this symbol
6833 in all the symbols for which we are making plt entries. The
6834 first entry in the procedure linkage table is reserved. */
6835 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
6837 plt_info
= htab
->plt_info
;
6838 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
6839 plt_info
= plt_info
->short_plt
;
6841 /* Get the offset into the .got table of the entry that
6842 corresponds to this function. */
6844 /* The offset must be relative to the GOT symbol, twelve bytes
6845 before the end of .got.plt. Each descriptor is eight
6847 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
6849 /* Each .got entry is 4 bytes. The first three are
6851 got_offset
= (plt_index
+ 3) * 4;
6855 got_offset
-= GOT_BIAS
;
6858 /* Fill in the entry in the procedure linkage table. */
6859 memcpy (splt
->contents
+ h
->plt
.offset
,
6860 plt_info
->symbol_entry
,
6861 plt_info
->symbol_entry_size
);
6863 if (info
->shared
|| htab
->fdpic_p
)
6865 if (plt_info
->symbol_fields
.got20
)
6867 bfd_reloc_status_type r
;
6868 r
= install_movi20_field (output_bfd
, got_offset
,
6869 splt
->owner
, splt
, splt
->contents
,
6871 + plt_info
->symbol_fields
.got_entry
);
6872 BFD_ASSERT (r
== bfd_reloc_ok
);
6875 install_plt_field (output_bfd
, FALSE
, got_offset
,
6878 + plt_info
->symbol_fields
.got_entry
));
6882 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6884 install_plt_field (output_bfd
, FALSE
,
6885 (sgotplt
->output_section
->vma
6886 + sgotplt
->output_offset
6890 + plt_info
->symbol_fields
.got_entry
));
6891 if (htab
->vxworks_p
)
6893 unsigned int reachable_plts
, plts_per_4k
;
6896 /* Divide the PLT into groups. The first group contains
6897 REACHABLE_PLTS entries and the other groups contain
6898 PLTS_PER_4K entries. Entries in the first group can
6899 branch directly to .plt; those in later groups branch
6900 to the last element of the previous group. */
6901 /* ??? It would be better to create multiple copies of
6902 the common resolver stub. */
6903 reachable_plts
= ((4096
6904 - plt_info
->plt0_entry_size
6905 - (plt_info
->symbol_fields
.plt
+ 4))
6906 / plt_info
->symbol_entry_size
) + 1;
6907 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6908 if (plt_index
< reachable_plts
)
6909 distance
= -(h
->plt
.offset
6910 + plt_info
->symbol_fields
.plt
);
6912 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6913 * plt_info
->symbol_entry_size
);
6915 /* Install the 'bra' with this offset. */
6916 bfd_put_16 (output_bfd
,
6917 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6920 + plt_info
->symbol_fields
.plt
));
6923 install_plt_field (output_bfd
, TRUE
,
6924 splt
->output_section
->vma
+ splt
->output_offset
,
6927 + plt_info
->symbol_fields
.plt
));
6930 /* Make got_offset relative to the start of .got.plt. */
6933 got_offset
+= GOT_BIAS
;
6936 got_offset
= plt_index
* 8;
6938 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6939 install_plt_field (output_bfd
, FALSE
,
6940 plt_index
* sizeof (Elf32_External_Rela
),
6943 + plt_info
->symbol_fields
.reloc_offset
));
6945 /* Fill in the entry in the global offset table. */
6946 bfd_put_32 (output_bfd
,
6947 (splt
->output_section
->vma
6948 + splt
->output_offset
6950 + plt_info
->symbol_resolve_offset
),
6951 sgotplt
->contents
+ got_offset
);
6953 bfd_put_32 (output_bfd
,
6954 sh_elf_osec_to_segment (output_bfd
,
6955 htab
->splt
->output_section
),
6956 sgotplt
->contents
+ got_offset
+ 4);
6958 /* Fill in the entry in the .rela.plt section. */
6959 rel
.r_offset
= (sgotplt
->output_section
->vma
6960 + sgotplt
->output_offset
6963 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
6965 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
6968 rel
.r_addend
= GOT_BIAS
;
6970 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
6971 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6973 if (htab
->vxworks_p
&& !info
->shared
)
6975 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6976 Begin by pointing LOC to the first such relocation. */
6977 loc
= (htab
->srelplt2
->contents
6978 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
6980 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6981 for the PLT entry's pointer to the .got.plt entry. */
6982 rel
.r_offset
= (htab
->splt
->output_section
->vma
6983 + htab
->splt
->output_offset
6985 + plt_info
->symbol_fields
.got_entry
);
6986 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6987 rel
.r_addend
= got_offset
;
6988 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6989 loc
+= sizeof (Elf32_External_Rela
);
6991 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6992 the .got.plt entry, which initially points to .plt. */
6993 rel
.r_offset
= (sgotplt
->output_section
->vma
6994 + sgotplt
->output_offset
6996 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
6998 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7001 if (!h
->def_regular
)
7003 /* Mark the symbol as undefined, rather than as defined in
7004 the .plt section. Leave the value alone. */
7005 sym
->st_shndx
= SHN_UNDEF
;
7009 if (h
->got
.offset
!= (bfd_vma
) -1
7010 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
7011 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
7012 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
7016 Elf_Internal_Rela rel
;
7019 /* This symbol has an entry in the global offset table. Set it
7023 srelgot
= htab
->srelgot
;
7024 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
7026 rel
.r_offset
= (sgot
->output_section
->vma
7027 + sgot
->output_offset
7028 + (h
->got
.offset
&~ (bfd_vma
) 1));
7030 /* If this is a static link, or it is a -Bsymbolic link and the
7031 symbol is defined locally or was forced to be local because
7032 of a version file, we just want to emit a RELATIVE reloc.
7033 The entry in the global offset table will already have been
7034 initialized in the relocate_section function. */
7036 && SYMBOL_REFERENCES_LOCAL (info
, h
))
7040 asection
*sec
= h
->root
.u
.def
.section
;
7042 = elf_section_data (sec
->output_section
)->dynindx
;
7044 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
7045 rel
.r_addend
= (h
->root
.u
.def
.value
7046 + h
->root
.u
.def
.section
->output_offset
);
7050 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
7051 rel
.r_addend
= (h
->root
.u
.def
.value
7052 + h
->root
.u
.def
.section
->output_section
->vma
7053 + h
->root
.u
.def
.section
->output_offset
);
7058 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
7059 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
7063 loc
= srelgot
->contents
;
7064 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7065 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7068 #ifdef INCLUDE_SHMEDIA
7070 struct elf_sh_link_hash_entry
*eh
;
7072 eh
= (struct elf_sh_link_hash_entry
*) h
;
7073 if (eh
->datalabel_got
.offset
!= (bfd_vma
) -1)
7077 Elf_Internal_Rela rel
;
7080 /* This symbol has a datalabel entry in the global offset table.
7084 srelgot
= htab
->srelgot
;
7085 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
7087 rel
.r_offset
= (sgot
->output_section
->vma
7088 + sgot
->output_offset
7089 + (eh
->datalabel_got
.offset
&~ (bfd_vma
) 1));
7091 /* If this is a static link, or it is a -Bsymbolic link and the
7092 symbol is defined locally or was forced to be local because
7093 of a version file, we just want to emit a RELATIVE reloc.
7094 The entry in the global offset table will already have been
7095 initialized in the relocate_section function. */
7097 && SYMBOL_REFERENCES_LOCAL (info
, h
))
7101 asection
*sec
= h
->root
.u
.def
.section
;
7103 = elf_section_data (sec
->output_section
)->dynindx
;
7105 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
7106 rel
.r_addend
= (h
->root
.u
.def
.value
7107 + h
->root
.u
.def
.section
->output_offset
);
7111 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
7112 rel
.r_addend
= (h
->root
.u
.def
.value
7113 + h
->root
.u
.def
.section
->output_section
->vma
7114 + h
->root
.u
.def
.section
->output_offset
);
7119 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
7120 + eh
->datalabel_got
.offset
);
7121 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
7125 loc
= srelgot
->contents
;
7126 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7127 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7135 Elf_Internal_Rela rel
;
7138 /* This symbol needs a copy reloc. Set it up. */
7140 BFD_ASSERT (h
->dynindx
!= -1
7141 && (h
->root
.type
== bfd_link_hash_defined
7142 || h
->root
.type
== bfd_link_hash_defweak
));
7144 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
7146 BFD_ASSERT (s
!= NULL
);
7148 rel
.r_offset
= (h
->root
.u
.def
.value
7149 + h
->root
.u
.def
.section
->output_section
->vma
7150 + h
->root
.u
.def
.section
->output_offset
);
7151 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
7153 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
7154 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7157 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7158 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7160 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
7161 || (!htab
->vxworks_p
&& h
== htab
->root
.hgot
))
7162 sym
->st_shndx
= SHN_ABS
;
7167 /* Finish up the dynamic sections. */
7170 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
7172 struct elf_sh_link_hash_table
*htab
;
7176 htab
= sh_elf_hash_table (info
);
7180 sgotplt
= htab
->sgotplt
;
7181 sdyn
= bfd_get_section_by_name (htab
->root
.dynobj
, ".dynamic");
7183 if (htab
->root
.dynamic_sections_created
)
7186 Elf32_External_Dyn
*dyncon
, *dynconend
;
7188 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
7190 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
7191 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
7192 for (; dyncon
< dynconend
; dyncon
++)
7194 Elf_Internal_Dyn dyn
;
7196 #ifdef INCLUDE_SHMEDIA
7200 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
7206 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
7207 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7210 #ifdef INCLUDE_SHMEDIA
7212 name
= info
->init_function
;
7216 name
= info
->fini_function
;
7218 if (dyn
.d_un
.d_val
!= 0)
7220 struct elf_link_hash_entry
*h
;
7222 h
= elf_link_hash_lookup (&htab
->root
, name
,
7223 FALSE
, FALSE
, TRUE
);
7224 if (h
!= NULL
&& (h
->other
& STO_SH5_ISA32
))
7226 dyn
.d_un
.d_val
|= 1;
7227 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7234 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
7235 s
= htab
->root
.hgot
->root
.u
.def
.section
;
7236 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
7237 + s
->output_section
->vma
+ s
->output_offset
;
7238 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7242 s
= htab
->srelplt
->output_section
;
7243 BFD_ASSERT (s
!= NULL
);
7244 dyn
.d_un
.d_ptr
= s
->vma
;
7245 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7249 s
= htab
->srelplt
->output_section
;
7250 BFD_ASSERT (s
!= NULL
);
7251 dyn
.d_un
.d_val
= s
->size
;
7252 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7256 /* My reading of the SVR4 ABI indicates that the
7257 procedure linkage table relocs (DT_JMPREL) should be
7258 included in the overall relocs (DT_RELA). This is
7259 what Solaris does. However, UnixWare can not handle
7260 that case. Therefore, we override the DT_RELASZ entry
7261 here to make it not include the JMPREL relocs. Since
7262 the linker script arranges for .rela.plt to follow all
7263 other relocation sections, we don't have to worry
7264 about changing the DT_RELA entry. */
7265 if (htab
->srelplt
!= NULL
)
7267 s
= htab
->srelplt
->output_section
;
7268 dyn
.d_un
.d_val
-= s
->size
;
7270 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
7275 /* Fill in the first entry in the procedure linkage table. */
7277 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
7281 memcpy (splt
->contents
,
7282 htab
->plt_info
->plt0_entry
,
7283 htab
->plt_info
->plt0_entry_size
);
7284 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
7285 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
7286 install_plt_field (output_bfd
, FALSE
,
7287 (sgotplt
->output_section
->vma
7288 + sgotplt
->output_offset
7291 + htab
->plt_info
->plt0_got_fields
[i
]));
7293 if (htab
->vxworks_p
)
7295 /* Finalize the .rela.plt.unloaded contents. */
7296 Elf_Internal_Rela rel
;
7299 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7300 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7301 loc
= htab
->srelplt2
->contents
;
7302 rel
.r_offset
= (splt
->output_section
->vma
7303 + splt
->output_offset
7304 + htab
->plt_info
->plt0_got_fields
[2]);
7305 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
7307 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
7308 loc
+= sizeof (Elf32_External_Rela
);
7310 /* Fix up the remaining .rela.plt.unloaded relocations.
7311 They may have the wrong symbol index for _G_O_T_ or
7312 _P_L_T_ depending on the order in which symbols were
7314 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
7316 /* The PLT entry's pointer to the .got.plt slot. */
7317 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
7318 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
7320 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7321 loc
+= sizeof (Elf32_External_Rela
);
7323 /* The .got.plt slot's pointer to .plt. */
7324 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
7325 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
7327 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
7328 loc
+= sizeof (Elf32_External_Rela
);
7332 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7333 really seem like the right value. */
7334 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
7338 /* Fill in the first three entries in the global offset table. */
7339 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
7342 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
7344 bfd_put_32 (output_bfd
,
7345 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
7347 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
7348 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
7351 if (sgotplt
&& sgotplt
->size
> 0)
7352 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
7354 /* At the very end of the .rofixup section is a pointer to the GOT. */
7355 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
7357 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
7358 bfd_vma got_value
= hgot
->root
.u
.def
.value
7359 + hgot
->root
.u
.def
.section
->output_section
->vma
7360 + hgot
->root
.u
.def
.section
->output_offset
;
7362 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
7364 /* Make sure we allocated and generated the same number of fixups. */
7365 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
7368 if (htab
->srelfuncdesc
)
7369 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
7370 == htab
->srelfuncdesc
->size
);
7373 BFD_ASSERT (htab
->srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
7374 == htab
->srelgot
->size
);
7379 static enum elf_reloc_type_class
7380 sh_elf_reloc_type_class (const Elf_Internal_Rela
*rela
)
7382 switch ((int) ELF32_R_TYPE (rela
->r_info
))
7385 return reloc_class_relative
;
7387 return reloc_class_plt
;
7389 return reloc_class_copy
;
7391 return reloc_class_normal
;
7395 #if !defined SH_TARGET_ALREADY_DEFINED
7396 /* Support for Linux core dump NOTE sections. */
7399 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7404 switch (note
->descsz
)
7409 case 168: /* Linux/SH */
7411 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
7414 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
7423 /* Make a ".reg/999" section. */
7424 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7425 size
, note
->descpos
+ offset
);
7429 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7431 switch (note
->descsz
)
7436 case 124: /* Linux/SH elf_prpsinfo */
7437 elf_tdata (abfd
)->core_program
7438 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
7439 elf_tdata (abfd
)->core_command
7440 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
7443 /* Note that for some reason, a spurious space is tacked
7444 onto the end of the args in some (at least one anyway)
7445 implementations, so strip it off if it exists. */
7448 char *command
= elf_tdata (abfd
)->core_command
;
7449 int n
= strlen (command
);
7451 if (0 < n
&& command
[n
- 1] == ' ')
7452 command
[n
- 1] = '\0';
7457 #endif /* not SH_TARGET_ALREADY_DEFINED */
7460 /* Return address for Ith PLT stub in section PLT, for relocation REL
7461 or (bfd_vma) -1 if it should not be included. */
7464 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
7465 const arelent
*rel ATTRIBUTE_UNUSED
)
7467 const struct elf_sh_plt_info
*plt_info
;
7469 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
7470 return plt
->vma
+ get_plt_offset (plt_info
, i
);
7473 /* Decide whether to attempt to turn absptr or lsda encodings in
7474 shared libraries into pcrel within the given input section. */
7477 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
7478 struct bfd_link_info
*info
,
7479 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
7481 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
7483 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7490 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7493 sh_elf_encode_eh_address (bfd
*abfd
,
7494 struct bfd_link_info
*info
,
7495 asection
*osec
, bfd_vma offset
,
7496 asection
*loc_sec
, bfd_vma loc_offset
,
7499 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
7500 struct elf_link_hash_entry
*h
;
7503 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
7504 loc_offset
, encoded
);
7506 h
= htab
->root
.hgot
;
7507 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
7509 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
7510 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
7511 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
7512 loc_sec
, loc_offset
, encoded
);
7514 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
7515 == (sh_elf_osec_to_segment
7516 (abfd
, h
->root
.u
.def
.section
->output_section
)));
7518 *encoded
= osec
->vma
+ offset
7519 - (h
->root
.u
.def
.value
7520 + h
->root
.u
.def
.section
->output_section
->vma
7521 + h
->root
.u
.def
.section
->output_offset
);
7523 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
7526 #if !defined SH_TARGET_ALREADY_DEFINED
7527 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7528 #define TARGET_BIG_NAME "elf32-sh"
7529 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7530 #define TARGET_LITTLE_NAME "elf32-shl"
7533 #define ELF_ARCH bfd_arch_sh
7534 #define ELF_TARGET_ID SH_ELF_DATA
7535 #define ELF_MACHINE_CODE EM_SH
7536 #ifdef __QNXTARGET__
7537 #define ELF_MAXPAGESIZE 0x1000
7539 #define ELF_MAXPAGESIZE 0x80
7542 #define elf_symbol_leading_char '_'
7544 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7545 #define bfd_elf32_bfd_reloc_name_lookup \
7546 sh_elf_reloc_name_lookup
7547 #define elf_info_to_howto sh_elf_info_to_howto
7548 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7549 #define elf_backend_relocate_section sh_elf_relocate_section
7550 #define bfd_elf32_bfd_get_relocated_section_contents \
7551 sh_elf_get_relocated_section_contents
7552 #define bfd_elf32_mkobject sh_elf_mkobject
7553 #define elf_backend_object_p sh_elf_object_p
7554 #define bfd_elf32_bfd_set_private_bfd_flags \
7555 sh_elf_set_private_flags
7556 #define bfd_elf32_bfd_copy_private_bfd_data \
7557 sh_elf_copy_private_data
7558 #define bfd_elf32_bfd_merge_private_bfd_data \
7559 sh_elf_merge_private_data
7561 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7562 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7563 #define elf_backend_check_relocs sh_elf_check_relocs
7564 #define elf_backend_copy_indirect_symbol \
7565 sh_elf_copy_indirect_symbol
7566 #define elf_backend_create_dynamic_sections \
7567 sh_elf_create_dynamic_sections
7568 #define bfd_elf32_bfd_link_hash_table_create \
7569 sh_elf_link_hash_table_create
7570 #define elf_backend_adjust_dynamic_symbol \
7571 sh_elf_adjust_dynamic_symbol
7572 #define elf_backend_always_size_sections \
7573 sh_elf_always_size_sections
7574 #define elf_backend_size_dynamic_sections \
7575 sh_elf_size_dynamic_sections
7576 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7577 #define elf_backend_finish_dynamic_symbol \
7578 sh_elf_finish_dynamic_symbol
7579 #define elf_backend_finish_dynamic_sections \
7580 sh_elf_finish_dynamic_sections
7581 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7582 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7583 #define elf_backend_can_make_relative_eh_frame \
7584 sh_elf_use_relative_eh_frame
7585 #define elf_backend_can_make_lsda_relative_eh_frame \
7586 sh_elf_use_relative_eh_frame
7587 #define elf_backend_encode_eh_address \
7588 sh_elf_encode_eh_address
7590 #define elf_backend_can_gc_sections 1
7591 #define elf_backend_can_refcount 1
7592 #define elf_backend_want_got_plt 1
7593 #define elf_backend_plt_readonly 1
7594 #define elf_backend_want_plt_sym 0
7595 #define elf_backend_got_header_size 12
7597 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7599 #include "elf32-target.h"
7601 /* NetBSD support. */
7602 #undef TARGET_BIG_SYM
7603 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7604 #undef TARGET_BIG_NAME
7605 #define TARGET_BIG_NAME "elf32-sh-nbsd"
7606 #undef TARGET_LITTLE_SYM
7607 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7608 #undef TARGET_LITTLE_NAME
7609 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7610 #undef ELF_MAXPAGESIZE
7611 #define ELF_MAXPAGESIZE 0x10000
7612 #undef ELF_COMMONPAGESIZE
7613 #undef elf_symbol_leading_char
7614 #define elf_symbol_leading_char 0
7616 #define elf32_bed elf32_sh_nbsd_bed
7618 #include "elf32-target.h"
7621 /* Linux support. */
7622 #undef TARGET_BIG_SYM
7623 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7624 #undef TARGET_BIG_NAME
7625 #define TARGET_BIG_NAME "elf32-shbig-linux"
7626 #undef TARGET_LITTLE_SYM
7627 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7628 #undef TARGET_LITTLE_NAME
7629 #define TARGET_LITTLE_NAME "elf32-sh-linux"
7630 #undef ELF_COMMONPAGESIZE
7631 #define ELF_COMMONPAGESIZE 0x1000
7633 #undef elf_backend_grok_prstatus
7634 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7635 #undef elf_backend_grok_psinfo
7636 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7638 #define elf32_bed elf32_sh_lin_bed
7640 #include "elf32-target.h"
7643 /* FDPIC support. */
7644 #undef TARGET_BIG_SYM
7645 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7646 #undef TARGET_BIG_NAME
7647 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
7648 #undef TARGET_LITTLE_SYM
7649 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7650 #undef TARGET_LITTLE_NAME
7651 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
7652 #undef elf_backend_modify_program_headers
7653 #define elf_backend_modify_program_headers \
7654 sh_elf_modify_program_headers
7657 #define elf32_bed elf32_sh_fd_bed
7659 #include "elf32-target.h"
7661 #undef elf_backend_modify_program_headers
7663 /* VxWorks support. */
7664 #undef TARGET_BIG_SYM
7665 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7666 #undef TARGET_BIG_NAME
7667 #define TARGET_BIG_NAME "elf32-sh-vxworks"
7668 #undef TARGET_LITTLE_SYM
7669 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7670 #undef TARGET_LITTLE_NAME
7671 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
7673 #define elf32_bed elf32_sh_vxworks_bed
7675 #undef elf_backend_want_plt_sym
7676 #define elf_backend_want_plt_sym 1
7677 #undef elf_symbol_leading_char
7678 #define elf_symbol_leading_char '_'
7679 #define elf_backend_want_got_underscore 1
7680 #undef elf_backend_grok_prstatus
7681 #undef elf_backend_grok_psinfo
7682 #undef elf_backend_add_symbol_hook
7683 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7684 #undef elf_backend_link_output_symbol_hook
7685 #define elf_backend_link_output_symbol_hook \
7686 elf_vxworks_link_output_symbol_hook
7687 #undef elf_backend_emit_relocs
7688 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7689 #undef elf_backend_final_write_processing
7690 #define elf_backend_final_write_processing \
7691 elf_vxworks_final_write_processing
7692 #undef ELF_MAXPAGESIZE
7693 #define ELF_MAXPAGESIZE 0x1000
7694 #undef ELF_COMMONPAGESIZE
7696 #include "elf32-target.h"
7698 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */