1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 Contributed by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
30 #include "libiberty.h"
31 #include "../opcodes/sh-opc.h"
33 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
34 #define OCTETS_PER_BYTE(ABFD, SEC) 1
36 static bfd_reloc_status_type sh_elf_reloc
37 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
38 static bfd_reloc_status_type sh_elf_ignore_reloc
39 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
40 static bool sh_elf_relax_delete_bytes
41 (bfd
*, asection
*, bfd_vma
, int);
42 static bool sh_elf_align_loads
43 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bool *);
44 static bool sh_elf_swap_insns
45 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
46 static int sh_elf_optimized_tls_reloc
47 (struct bfd_link_info
*, int, int);
48 static bfd_vma dtpoff_base
49 (struct bfd_link_info
*);
51 (struct bfd_link_info
*, bfd_vma
);
53 /* The name of the dynamic interpreter. This is put in the .interp
56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
58 /* FDPIC binaries have a default 128K stack. */
59 #define DEFAULT_STACK_SIZE 0x20000
61 #define MINUS_ONE ((bfd_vma) 0 - 1)
63 /* Decide whether a reference to a symbol can be resolved locally or
64 not. If the symbol is protected, we want the local address, but
65 its function descriptor must be assigned by the dynamic linker. */
66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
68 || ! elf_hash_table (INFO)->dynamic_sections_created)
70 #define SH_PARTIAL32 true
71 #define SH_SRC_MASK32 0xffffffff
72 #define SH_ELF_RELOC sh_elf_reloc
73 static reloc_howto_type sh_elf_howto_table
[] =
75 #include "elf32-sh-relocs.h"
78 #define SH_PARTIAL32 false
79 #define SH_SRC_MASK32 0
80 #define SH_ELF_RELOC bfd_elf_generic_reloc
81 static reloc_howto_type sh_vxworks_howto_table
[] =
83 #include "elf32-sh-relocs.h"
86 /* Return true if OUTPUT_BFD is a VxWorks object. */
89 vxworks_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
91 #if !defined SH_TARGET_ALREADY_DEFINED
92 extern const bfd_target sh_elf32_vxworks_le_vec
;
93 extern const bfd_target sh_elf32_vxworks_vec
;
95 return (abfd
->xvec
== &sh_elf32_vxworks_le_vec
96 || abfd
->xvec
== &sh_elf32_vxworks_vec
);
102 /* Return true if OUTPUT_BFD is an FDPIC object. */
105 fdpic_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
107 #if !defined SH_TARGET_ALREADY_DEFINED
108 extern const bfd_target sh_elf32_fdpic_le_vec
;
109 extern const bfd_target sh_elf32_fdpic_be_vec
;
111 return (abfd
->xvec
== &sh_elf32_fdpic_le_vec
112 || abfd
->xvec
== &sh_elf32_fdpic_be_vec
);
118 /* Return the howto table for ABFD. */
120 static reloc_howto_type
*
121 get_howto_table (bfd
*abfd
)
123 if (vxworks_object_p (abfd
))
124 return sh_vxworks_howto_table
;
125 return sh_elf_howto_table
;
128 static bfd_reloc_status_type
129 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
130 asection
*input_section
, bfd_byte
*contents
,
131 bfd_vma addr
, asection
*symbol_section
,
132 bfd_vma start
, bfd_vma end
)
134 static bfd_vma last_addr
;
135 static asection
*last_symbol_section
;
136 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
141 /* Sanity check the address. */
142 if (addr
> bfd_get_section_limit (input_bfd
, input_section
))
143 return bfd_reloc_outofrange
;
145 /* We require the start and end relocations to be processed consecutively -
146 although we allow then to be processed forwards or backwards. */
150 last_symbol_section
= symbol_section
;
153 if (last_addr
!= addr
)
157 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
158 return bfd_reloc_outofrange
;
160 /* Get the symbol_section contents. */
161 if (symbol_section
!= input_section
)
163 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
164 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
167 if (!bfd_malloc_and_get_section (input_bfd
, symbol_section
,
171 return bfd_reloc_outofrange
;
175 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
176 start_ptr
= contents
+ start
;
177 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
179 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
182 diff
= (last_ptr
- ptr
) >> 1;
183 cum_diff
+= diff
& 1;
186 /* Calculate the start / end values to load into rs / re minus four -
187 so that will cancel out the four we would otherwise have to add to
188 addr to get the value to subtract in order to get relative addressing. */
192 end
= (ptr
+ cum_diff
* 2) - contents
;
196 bfd_vma start0
= start
- 4;
198 while (start0
&& IS_PPI (contents
+ start0
))
200 start0
= start
- 2 - ((start
- start0
) & 2);
201 start
= start0
- cum_diff
- 2;
205 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
208 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
210 x
= (insn
& 0x200 ? end
: start
) - addr
;
211 if (input_section
!= symbol_section
)
212 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
213 - (input_section
->output_section
->vma
214 + input_section
->output_offset
));
216 if (x
< -128 || x
> 127)
217 return bfd_reloc_overflow
;
219 x
= (insn
& ~0xff) | (x
& 0xff);
220 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
225 /* This function is used for normal relocs. This used to be like the COFF
226 function, and is almost certainly incorrect for other ELF targets. */
228 static bfd_reloc_status_type
229 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
230 void *data
, asection
*input_section
, bfd
*output_bfd
,
231 char **error_message ATTRIBUTE_UNUSED
)
235 enum elf_sh_reloc_type r_type
;
236 bfd_vma addr
= reloc_entry
->address
;
237 bfd_size_type octets
= addr
* OCTETS_PER_BYTE (abfd
, input_section
);
238 bfd_byte
*hit_data
= (bfd_byte
*) data
+ octets
;
240 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
242 if (output_bfd
!= NULL
)
244 /* Partial linking--do nothing. */
245 reloc_entry
->address
+= input_section
->output_offset
;
249 /* Almost all relocs have to do with relaxing. If any work must be
250 done for them, it has been done in sh_relax_section. */
251 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
254 if (symbol_in
!= NULL
255 && bfd_is_und_section (symbol_in
->section
))
256 return bfd_reloc_undefined
;
258 /* PR 17512: file: 9891ca98. */
259 if (octets
+ bfd_get_reloc_size (reloc_entry
->howto
)
260 > bfd_get_section_limit_octets (abfd
, input_section
))
261 return bfd_reloc_outofrange
;
263 if (bfd_is_com_section (symbol_in
->section
))
266 sym_value
= (symbol_in
->value
+
267 symbol_in
->section
->output_section
->vma
+
268 symbol_in
->section
->output_offset
);
273 insn
= bfd_get_32 (abfd
, hit_data
);
274 insn
+= sym_value
+ reloc_entry
->addend
;
275 bfd_put_32 (abfd
, insn
, hit_data
);
278 insn
= bfd_get_16 (abfd
, hit_data
);
279 sym_value
+= reloc_entry
->addend
;
280 sym_value
-= (input_section
->output_section
->vma
281 + input_section
->output_offset
284 sym_value
+= (((insn
& 0xfff) ^ 0x800) - 0x800) << 1;
285 insn
= (insn
& 0xf000) | ((sym_value
>> 1) & 0xfff);
286 bfd_put_16 (abfd
, insn
, hit_data
);
287 if (sym_value
+ 0x1000 >= 0x2000 || (sym_value
& 1) != 0)
288 return bfd_reloc_overflow
;
298 /* This function is used for relocs which are only used for relaxing,
299 which the linker should otherwise ignore. */
301 static bfd_reloc_status_type
302 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
303 asymbol
*symbol ATTRIBUTE_UNUSED
,
304 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
306 char **error_message ATTRIBUTE_UNUSED
)
308 if (output_bfd
!= NULL
)
309 reloc_entry
->address
+= input_section
->output_offset
;
313 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
317 bfd_reloc_code_real_type bfd_reloc_val
;
318 unsigned char elf_reloc_val
;
321 /* An array mapping BFD reloc codes to SH ELF relocs. */
323 static const struct elf_reloc_map sh_reloc_map
[] =
325 { BFD_RELOC_NONE
, R_SH_NONE
},
326 { BFD_RELOC_32
, R_SH_DIR32
},
327 { BFD_RELOC_16
, R_SH_DIR16
},
328 { BFD_RELOC_8
, R_SH_DIR8
},
329 { BFD_RELOC_CTOR
, R_SH_DIR32
},
330 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
331 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
332 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
333 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
334 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
335 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
336 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
337 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
338 { BFD_RELOC_SH_USES
, R_SH_USES
},
339 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
340 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
341 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
342 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
343 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
344 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
345 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
346 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
347 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
348 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
349 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
350 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
351 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
352 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
353 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
354 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
355 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
356 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
357 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
358 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
359 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
360 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
361 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
362 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
363 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
364 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
365 { BFD_RELOC_SH_GOT20
, R_SH_GOT20
},
366 { BFD_RELOC_SH_GOTOFF20
, R_SH_GOTOFF20
},
367 { BFD_RELOC_SH_GOTFUNCDESC
, R_SH_GOTFUNCDESC
},
368 { BFD_RELOC_SH_GOTFUNCDESC20
, R_SH_GOTFUNCDESC20
},
369 { BFD_RELOC_SH_GOTOFFFUNCDESC
, R_SH_GOTOFFFUNCDESC
},
370 { BFD_RELOC_SH_GOTOFFFUNCDESC20
, R_SH_GOTOFFFUNCDESC20
},
371 { BFD_RELOC_SH_FUNCDESC
, R_SH_FUNCDESC
},
374 /* Given a BFD reloc code, return the howto structure for the
375 corresponding SH ELF reloc. */
377 static reloc_howto_type
*
378 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
382 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
384 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
385 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
391 static reloc_howto_type
*
392 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
396 if (vxworks_object_p (abfd
))
399 i
< (sizeof (sh_vxworks_howto_table
)
400 / sizeof (sh_vxworks_howto_table
[0]));
402 if (sh_vxworks_howto_table
[i
].name
!= NULL
403 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
404 return &sh_vxworks_howto_table
[i
];
409 i
< (sizeof (sh_elf_howto_table
)
410 / sizeof (sh_elf_howto_table
[0]));
412 if (sh_elf_howto_table
[i
].name
!= NULL
413 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
414 return &sh_elf_howto_table
[i
];
420 /* Given an ELF reloc, fill in the howto field of a relent. */
423 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
427 r
= ELF32_R_TYPE (dst
->r_info
);
430 || (r
>= R_SH_FIRST_INVALID_RELOC
&& r
<= R_SH_LAST_INVALID_RELOC
)
431 || (r
>= R_SH_FIRST_INVALID_RELOC_2
&& r
<= R_SH_LAST_INVALID_RELOC_2
)
432 || (r
>= R_SH_FIRST_INVALID_RELOC_3
&& r
<= R_SH_LAST_INVALID_RELOC_3
)
433 || (r
>= R_SH_FIRST_INVALID_RELOC_4
&& r
<= R_SH_LAST_INVALID_RELOC_4
)
434 || (r
>= R_SH_FIRST_INVALID_RELOC_5
&& r
<= R_SH_LAST_INVALID_RELOC_5
)
435 || (r
>= R_SH_FIRST_INVALID_RELOC_6
&& r
<= R_SH_LAST_INVALID_RELOC_6
))
437 /* xgettext:c-format */
438 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
440 bfd_set_error (bfd_error_bad_value
);
444 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
448 /* This function handles relaxing for SH ELF. See the corresponding
449 function in coff-sh.c for a description of what this does. FIXME:
450 There is a lot of duplication here between this code and the COFF
451 specific code. The format of relocs and symbols is wound deeply
452 into this code, but it would still be better if the duplication
453 could be eliminated somehow. Note in particular that although both
454 functions use symbols like R_SH_CODE, those symbols have different
455 values; in coff-sh.c they come from include/coff/sh.h, whereas here
456 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
459 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
460 struct bfd_link_info
*link_info
, bool *again
)
462 Elf_Internal_Shdr
*symtab_hdr
;
463 Elf_Internal_Rela
*internal_relocs
;
465 Elf_Internal_Rela
*irel
, *irelend
;
466 bfd_byte
*contents
= NULL
;
467 Elf_Internal_Sym
*isymbuf
= NULL
;
471 if (bfd_link_relocatable (link_info
)
472 || (sec
->flags
& SEC_RELOC
) == 0
473 || sec
->reloc_count
== 0)
476 symtab_hdr
= &elf_symtab_hdr (abfd
);
478 internal_relocs
= (_bfd_elf_link_read_relocs
479 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
480 link_info
->keep_memory
));
481 if (internal_relocs
== NULL
)
486 irelend
= internal_relocs
+ sec
->reloc_count
;
487 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
489 bfd_vma laddr
, paddr
, symval
;
491 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
494 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
497 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
500 /* Get the section contents. */
501 if (contents
== NULL
)
503 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
504 contents
= elf_section_data (sec
)->this_hdr
.contents
;
507 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
512 /* The r_addend field of the R_SH_USES reloc will point us to
513 the register load. The 4 is because the r_addend field is
514 computed as though it were a jump offset, which are based
515 from 4 bytes after the jump instruction. */
516 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
517 if (laddr
>= sec
->size
)
519 /* xgettext:c-format */
521 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES offset"),
522 abfd
, (uint64_t) irel
->r_offset
);
525 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
527 /* If the instruction is not mov.l NN,rN, we don't know what to
529 if ((insn
& 0xf000) != 0xd000)
532 /* xgettext:c-format */
533 (_("%pB: %#" PRIx64
": warning: "
534 "R_SH_USES points to unrecognized insn 0x%x"),
535 abfd
, (uint64_t) irel
->r_offset
, insn
);
539 /* Get the address from which the register is being loaded. The
540 displacement in the mov.l instruction is quadrupled. It is a
541 displacement from four bytes after the movl instruction, but,
542 before adding in the PC address, two least significant bits
543 of the PC are cleared. We assume that the section is aligned
544 on a four byte boundary. */
547 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
548 if (paddr
>= sec
->size
)
551 /* xgettext:c-format */
552 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES load offset"),
553 abfd
, (uint64_t) irel
->r_offset
);
557 /* Get the reloc for the address from which the register is
558 being loaded. This reloc will tell us which function is
559 actually being called. */
560 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
561 if (irelfn
->r_offset
== paddr
562 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
564 if (irelfn
>= irelend
)
567 /* xgettext:c-format */
568 (_("%pB: %#" PRIx64
": warning: could not find expected reloc"),
569 abfd
, (uint64_t) paddr
);
573 /* Read this BFD's symbols if we haven't done so already. */
574 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
576 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
578 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
579 symtab_hdr
->sh_info
, 0,
585 /* Get the value of the symbol referred to by the reloc. */
586 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
588 /* A local symbol. */
589 Elf_Internal_Sym
*isym
;
591 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
593 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
596 /* xgettext:c-format */
597 (_("%pB: %#" PRIx64
": warning: symbol in unexpected section"),
598 abfd
, (uint64_t) paddr
);
602 symval
= (isym
->st_value
603 + sec
->output_section
->vma
604 + sec
->output_offset
);
609 struct elf_link_hash_entry
*h
;
611 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
612 h
= elf_sym_hashes (abfd
)[indx
];
613 BFD_ASSERT (h
!= NULL
);
614 if (h
->root
.type
!= bfd_link_hash_defined
615 && h
->root
.type
!= bfd_link_hash_defweak
)
617 /* This appears to be a reference to an undefined
618 symbol. Just ignore it--it will be caught by the
619 regular reloc processing. */
623 symval
= (h
->root
.u
.def
.value
624 + h
->root
.u
.def
.section
->output_section
->vma
625 + h
->root
.u
.def
.section
->output_offset
);
628 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
629 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
631 symval
+= irelfn
->r_addend
;
633 /* See if this function call can be shortened. */
636 + sec
->output_section
->vma
639 /* A branch to an address beyond ours might be increased by an
640 .align that doesn't move when bytes behind us are deleted.
641 So, we add some slop in this calculation to allow for
643 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
645 /* After all that work, we can't shorten this function call. */
649 /* Shorten the function call. */
651 /* For simplicity of coding, we are going to modify the section
652 contents, the section relocs, and the BFD symbol table. We
653 must tell the rest of the code not to free up this
654 information. It would be possible to instead create a table
655 of changes which have to be made, as is done in coff-mips.c;
656 that would be more work, but would require less memory when
657 the linker is run. */
659 elf_section_data (sec
)->relocs
= internal_relocs
;
660 elf_section_data (sec
)->this_hdr
.contents
= contents
;
661 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
663 /* Replace the jmp/jsr with a bra/bsr. */
665 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
666 replace the jmp/jsr with a bra/bsr. */
667 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
668 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
669 here, but that only checks if the symbol is an external symbol,
670 not if the symbol is in a different section. Besides, we need
671 a consistent meaning for the relocation, so we just assume here that
672 the value of the symbol is not available. */
674 /* We can't fully resolve this yet, because the external
675 symbol value may be changed by future relaxing. We let
676 the final link phase handle it. */
677 if (bfd_get_16 (abfd
, contents
+ irel
->r_offset
) & 0x0020)
678 bfd_put_16 (abfd
, (bfd_vma
) 0xa000, contents
+ irel
->r_offset
);
680 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
684 /* When we calculated the symbol "value" we had an offset in the
685 DIR32's word in memory (we read and add it above). However,
686 the jsr we create does NOT have this offset encoded, so we
687 have to add it to the addend to preserve it. */
688 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
690 /* See if there is another R_SH_USES reloc referring to the same
692 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
693 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
694 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
696 if (irelscan
< irelend
)
698 /* Some other function call depends upon this register load,
699 and we have not yet converted that function call.
700 Indeed, we may never be able to convert it. There is
701 nothing else we can do at this point. */
705 /* Look for a R_SH_COUNT reloc on the location where the
706 function address is stored. Do this before deleting any
707 bytes, to avoid confusion about the address. */
708 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
709 if (irelcount
->r_offset
== paddr
710 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
713 /* Delete the register load. */
714 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
717 /* That will change things, so, just in case it permits some
718 other function call to come within range, we should relax
719 again. Note that this is not required, and it may be slow. */
722 /* Now check whether we got a COUNT reloc. */
723 if (irelcount
>= irelend
)
726 /* xgettext:c-format */
727 (_("%pB: %#" PRIx64
": warning: "
728 "could not find expected COUNT reloc"),
729 abfd
, (uint64_t) paddr
);
733 /* The number of uses is stored in the r_addend field. We've
735 if (irelcount
->r_addend
== 0)
737 /* xgettext:c-format */
738 _bfd_error_handler (_("%pB: %#" PRIx64
": warning: bad count"),
739 abfd
, (uint64_t) paddr
);
743 --irelcount
->r_addend
;
745 /* If there are no more uses, we can delete the address. Reload
746 the address from irelfn, in case it was changed by the
747 previous call to sh_elf_relax_delete_bytes. */
748 if (irelcount
->r_addend
== 0)
750 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
754 /* We've done all we can with that function call. */
757 /* Look for load and store instructions that we can align on four
759 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
764 /* Get the section contents. */
765 if (contents
== NULL
)
767 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
768 contents
= elf_section_data (sec
)->this_hdr
.contents
;
771 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
776 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
782 elf_section_data (sec
)->relocs
= internal_relocs
;
783 elf_section_data (sec
)->this_hdr
.contents
= contents
;
784 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
789 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
791 if (! link_info
->keep_memory
)
795 /* Cache the symbols for elf_link_input_bfd. */
796 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
801 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
803 if (! link_info
->keep_memory
)
807 /* Cache the section contents for elf_link_input_bfd. */
808 elf_section_data (sec
)->this_hdr
.contents
= contents
;
812 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
813 free (internal_relocs
);
818 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
820 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
822 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
823 free (internal_relocs
);
828 /* Delete some bytes from a section while relaxing. FIXME: There is a
829 lot of duplication between this function and sh_relax_delete_bytes
833 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
836 Elf_Internal_Shdr
*symtab_hdr
;
837 unsigned int sec_shndx
;
839 Elf_Internal_Rela
*irel
, *irelend
;
840 Elf_Internal_Rela
*irelalign
;
842 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
843 struct elf_link_hash_entry
**sym_hashes
;
844 struct elf_link_hash_entry
**end_hashes
;
845 unsigned int symcount
;
848 symtab_hdr
= &elf_symtab_hdr (abfd
);
849 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
851 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
853 contents
= elf_section_data (sec
)->this_hdr
.contents
;
855 /* The deletion must stop at the next ALIGN reloc for an alignment
856 power larger than the number of bytes we are deleting. */
861 irel
= elf_section_data (sec
)->relocs
;
862 irelend
= irel
+ sec
->reloc_count
;
863 for (; irel
< irelend
; irel
++)
865 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
866 && irel
->r_offset
> addr
867 && count
< (1 << irel
->r_addend
))
870 toaddr
= irel
->r_offset
;
875 /* Actually delete the bytes. */
876 memmove (contents
+ addr
, contents
+ addr
+ count
,
877 (size_t) (toaddr
- addr
- count
));
878 if (irelalign
== NULL
)
884 #define NOP_OPCODE (0x0009)
886 BFD_ASSERT ((count
& 1) == 0);
887 for (i
= 0; i
< count
; i
+= 2)
888 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
891 /* Adjust all the relocs. */
892 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
894 bfd_vma nraddr
, stop
;
897 int off
, adjust
, oinsn
;
898 bfd_signed_vma voff
= 0;
901 /* Get the new reloc address. */
902 nraddr
= irel
->r_offset
;
903 if ((irel
->r_offset
> addr
904 && irel
->r_offset
< toaddr
)
905 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
906 && irel
->r_offset
== toaddr
))
909 /* See if this reloc was for the bytes we have deleted, in which
910 case we no longer care about it. Don't delete relocs which
911 represent addresses, though. */
912 if (irel
->r_offset
>= addr
913 && irel
->r_offset
< addr
+ count
914 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
915 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
916 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
917 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
918 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
921 /* If this is a PC relative reloc, see if the range it covers
922 includes the bytes we have deleted. */
923 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
932 start
= irel
->r_offset
;
933 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
937 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
944 /* If this reloc is against a symbol defined in this
945 section, and the symbol will not be adjusted below, we
946 must check the addend to see it will put the value in
947 range to be adjusted, and hence must be changed. */
948 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
950 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
951 if (isym
->st_shndx
== sec_shndx
952 && (isym
->st_value
<= addr
953 || isym
->st_value
>= toaddr
))
957 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
959 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
960 val
+= isym
->st_value
;
961 if (val
> addr
&& val
< toaddr
)
962 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
966 val
= isym
->st_value
+ irel
->r_addend
;
967 if (val
> addr
&& val
< toaddr
)
968 irel
->r_addend
-= count
;
979 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
986 /* This has been made by previous relaxation. Since the
987 relocation will be against an external symbol, the
988 final relocation will just do the right thing. */
995 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
997 /* The addend will be against the section symbol, thus
998 for adjusting the addend, the relevant start is the
999 start of the section.
1000 N.B. If we want to abandon in-place changes here and
1001 test directly using symbol + addend, we have to take into
1002 account that the addend has already been adjusted by -4. */
1003 if (stop
> addr
&& stop
< toaddr
)
1004 irel
->r_addend
-= count
;
1010 stop
= start
+ 4 + off
* 2;
1015 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1021 /* These relocs types represent
1023 The r_addend field holds the difference between the reloc
1024 address and L1. That is the start of the reloc, and
1025 adding in the contents gives us the top. We must adjust
1026 both the r_offset field and the section contents.
1027 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1028 and the elf bfd r_offset is called r_vaddr. */
1030 stop
= irel
->r_offset
;
1031 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1035 && (stop
<= addr
|| stop
>= toaddr
))
1036 irel
->r_addend
+= count
;
1037 else if (stop
> addr
1039 && (start
<= addr
|| start
>= toaddr
))
1040 irel
->r_addend
-= count
;
1042 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1043 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1044 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1045 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1047 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1048 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1053 start
= irel
->r_offset
;
1054 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1055 + (long) irel
->r_addend
1062 && (stop
<= addr
|| stop
>= toaddr
))
1064 else if (stop
> addr
1066 && (start
<= addr
|| start
>= toaddr
))
1075 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1084 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1086 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1091 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1093 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1097 BFD_ASSERT (adjust
== count
|| count
>= 4);
1102 if ((irel
->r_offset
& 3) == 0)
1105 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1107 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1112 if (voff
< 0 || voff
>= 0xff)
1114 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1119 if (voff
< - 0x8000 || voff
>= 0x8000)
1121 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1126 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1130 irel
->r_addend
+= adjust
;
1137 /* xgettext:c-format */
1138 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1139 abfd
, (uint64_t) irel
->r_offset
);
1140 bfd_set_error (bfd_error_bad_value
);
1145 irel
->r_offset
= nraddr
;
1148 /* Look through all the other sections. If there contain any IMM32
1149 relocs against internal symbols which we are not going to adjust
1150 below, we may need to adjust the addends. */
1151 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1153 Elf_Internal_Rela
*internal_relocs
;
1154 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1155 bfd_byte
*ocontents
;
1158 || (o
->flags
& SEC_RELOC
) == 0
1159 || o
->reloc_count
== 0)
1162 /* We always cache the relocs. Perhaps, if info->keep_memory is
1163 FALSE, we should free them, if we are permitted to, when we
1164 leave sh_coff_relax_section. */
1165 internal_relocs
= (_bfd_elf_link_read_relocs
1166 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
1167 if (internal_relocs
== NULL
)
1171 irelscanend
= internal_relocs
+ o
->reloc_count
;
1172 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1174 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1175 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1177 bfd_vma start
, stop
;
1178 bfd_signed_vma voff
;
1180 if (ocontents
== NULL
)
1182 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1183 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1186 /* We always cache the section contents.
1187 Perhaps, if info->keep_memory is FALSE, we
1188 should free them, if we are permitted to,
1189 when we leave sh_coff_relax_section. */
1190 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1196 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1200 stop
= irelscan
->r_offset
;
1202 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1204 /* STOP is in a different section, so it won't change. */
1205 if (start
> addr
&& start
< toaddr
)
1206 irelscan
->r_addend
+= count
;
1208 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1209 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1213 && (stop
<= addr
|| stop
>= toaddr
))
1214 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1215 ocontents
+ irelscan
->r_offset
);
1216 else if (stop
> addr
1218 && (start
<= addr
|| start
>= toaddr
))
1219 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1220 ocontents
+ irelscan
->r_offset
);
1223 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1226 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1230 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1231 if (isym
->st_shndx
== sec_shndx
1232 && (isym
->st_value
<= addr
1233 || isym
->st_value
>= toaddr
))
1237 if (ocontents
== NULL
)
1239 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1240 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1243 /* We always cache the section contents.
1244 Perhaps, if info->keep_memory is FALSE, we
1245 should free them, if we are permitted to,
1246 when we leave sh_coff_relax_section. */
1247 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1253 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1257 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1258 val
+= isym
->st_value
;
1259 if (val
> addr
&& val
< toaddr
)
1260 bfd_put_32 (abfd
, val
- count
,
1261 ocontents
+ irelscan
->r_offset
);
1266 /* Adjust the local symbols defined in this section. */
1267 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1268 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1270 if (isym
->st_shndx
== sec_shndx
1271 && isym
->st_value
> addr
1272 && isym
->st_value
< toaddr
)
1273 isym
->st_value
-= count
;
1276 /* Now adjust the global symbols defined in this section. */
1277 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1278 - symtab_hdr
->sh_info
);
1279 sym_hashes
= elf_sym_hashes (abfd
);
1280 end_hashes
= sym_hashes
+ symcount
;
1281 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1283 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1284 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1285 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1286 && sym_hash
->root
.u
.def
.section
== sec
1287 && sym_hash
->root
.u
.def
.value
> addr
1288 && sym_hash
->root
.u
.def
.value
< toaddr
)
1290 sym_hash
->root
.u
.def
.value
-= count
;
1294 /* See if we can move the ALIGN reloc forward. We have adjusted
1295 r_offset for it already. */
1296 if (irelalign
!= NULL
)
1298 bfd_vma alignto
, alignaddr
;
1300 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1301 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1302 1 << irelalign
->r_addend
);
1303 if (alignto
!= alignaddr
)
1305 /* Tail recursion. */
1306 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1307 (int) (alignto
- alignaddr
));
1314 /* Look for loads and stores which we can align to four byte
1315 boundaries. This is like sh_align_loads in coff-sh.c. */
1318 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1319 Elf_Internal_Rela
*internal_relocs
,
1320 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1323 Elf_Internal_Rela
*irel
, *irelend
;
1324 bfd_vma
*labels
= NULL
;
1325 bfd_vma
*label
, *label_end
;
1330 irelend
= internal_relocs
+ sec
->reloc_count
;
1332 /* Get all the addresses with labels on them. */
1333 amt
= sec
->reloc_count
;
1334 amt
*= sizeof (bfd_vma
);
1335 labels
= (bfd_vma
*) bfd_malloc (amt
);
1339 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1341 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1343 *label_end
= irel
->r_offset
;
1348 /* Note that the assembler currently always outputs relocs in
1349 address order. If that ever changes, this code will need to sort
1350 the label values and the relocs. */
1354 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1356 bfd_vma start
, stop
;
1358 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1361 start
= irel
->r_offset
;
1363 for (irel
++; irel
< irelend
; irel
++)
1364 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1367 stop
= irel
->r_offset
;
1371 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1372 internal_relocs
, &label
,
1373 label_end
, start
, stop
, pswapped
))
1386 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1389 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1390 bfd_byte
*contents
, bfd_vma addr
)
1392 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1393 unsigned short i1
, i2
;
1394 Elf_Internal_Rela
*irel
, *irelend
;
1396 /* Swap the instructions themselves. */
1397 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1398 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1399 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1400 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1402 /* Adjust all reloc addresses. */
1403 irelend
= internal_relocs
+ sec
->reloc_count
;
1404 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1406 enum elf_sh_reloc_type type
;
1409 /* There are a few special types of relocs that we don't want to
1410 adjust. These relocs do not apply to the instruction itself,
1411 but are only associated with the address. */
1412 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1413 if (type
== R_SH_ALIGN
1414 || type
== R_SH_CODE
1415 || type
== R_SH_DATA
1416 || type
== R_SH_LABEL
)
1419 /* If an R_SH_USES reloc points to one of the addresses being
1420 swapped, we must adjust it. It would be incorrect to do this
1421 for a jump, though, since we want to execute both
1422 instructions after the jump. (We have avoided swapping
1423 around a label, so the jump will not wind up executing an
1424 instruction it shouldn't). */
1425 if (type
== R_SH_USES
)
1429 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1431 irel
->r_offset
+= 2;
1432 else if (off
== addr
+ 2)
1433 irel
->r_offset
-= 2;
1436 if (irel
->r_offset
== addr
)
1438 irel
->r_offset
+= 2;
1441 else if (irel
->r_offset
== addr
+ 2)
1443 irel
->r_offset
-= 2;
1452 unsigned short insn
, oinsn
;
1455 loc
= contents
+ irel
->r_offset
;
1464 insn
= bfd_get_16 (abfd
, loc
);
1467 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1469 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1473 insn
= bfd_get_16 (abfd
, loc
);
1476 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1478 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1482 /* This reloc ignores the least significant 3 bits of
1483 the program counter before adding in the offset.
1484 This means that if ADDR is at an even address, the
1485 swap will not affect the offset. If ADDR is an at an
1486 odd address, then the instruction will be crossing a
1487 four byte boundary, and must be adjusted. */
1488 if ((addr
& 3) != 0)
1490 insn
= bfd_get_16 (abfd
, loc
);
1493 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1495 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1504 /* xgettext:c-format */
1505 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1506 abfd
, (uint64_t) irel
->r_offset
);
1507 bfd_set_error (bfd_error_bad_value
);
1516 /* Describes one of the various PLT styles. */
1518 struct elf_sh_plt_info
1520 /* The template for the first PLT entry, or NULL if there is no special
1522 const bfd_byte
*plt0_entry
;
1524 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1525 bfd_vma plt0_entry_size
;
1527 /* Index I is the offset into PLT0_ENTRY of a pointer to
1528 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1529 if there is no such pointer. */
1530 bfd_vma plt0_got_fields
[3];
1532 /* The template for a symbol's PLT entry. */
1533 const bfd_byte
*symbol_entry
;
1535 /* The size of SYMBOL_ENTRY in bytes. */
1536 bfd_vma symbol_entry_size
;
1538 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1539 on all targets. The comments by each member indicate the value
1540 that the field must hold. */
1542 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1543 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1544 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1545 bool got20
; /* TRUE if got_entry points to a movi20 instruction
1546 (instead of a constant pool entry). */
1549 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1550 bfd_vma symbol_resolve_offset
;
1552 /* A different PLT layout which can be used for the first
1553 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1555 const struct elf_sh_plt_info
*short_plt
;
1558 /* The size in bytes of an entry in the procedure linkage table. */
1560 #define ELF_PLT_ENTRY_SIZE 28
1562 /* First entry in an absolute procedure linkage table look like this. */
1564 /* Note - this code has been "optimised" not to use r2. r2 is used by
1565 GCC to return the address of large structures, so it should not be
1566 corrupted here. This does mean however, that this PLT does not conform
1567 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1568 and r2 contains the GOT id. This version stores the GOT id in r0 and
1569 ignores the type. Loaders can easily detect this difference however,
1570 since the type will always be 0 or 8, and the GOT ids will always be
1571 greater than or equal to 12. */
1572 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1574 0xd0, 0x05, /* mov.l 2f,r0 */
1575 0x60, 0x02, /* mov.l @r0,r0 */
1576 0x2f, 0x06, /* mov.l r0,@-r15 */
1577 0xd0, 0x03, /* mov.l 1f,r0 */
1578 0x60, 0x02, /* mov.l @r0,r0 */
1579 0x40, 0x2b, /* jmp @r0 */
1580 0x60, 0xf6, /* mov.l @r15+,r0 */
1581 0x00, 0x09, /* nop */
1582 0x00, 0x09, /* nop */
1583 0x00, 0x09, /* nop */
1584 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1585 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1588 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1590 0x05, 0xd0, /* mov.l 2f,r0 */
1591 0x02, 0x60, /* mov.l @r0,r0 */
1592 0x06, 0x2f, /* mov.l r0,@-r15 */
1593 0x03, 0xd0, /* mov.l 1f,r0 */
1594 0x02, 0x60, /* mov.l @r0,r0 */
1595 0x2b, 0x40, /* jmp @r0 */
1596 0xf6, 0x60, /* mov.l @r15+,r0 */
1597 0x09, 0x00, /* nop */
1598 0x09, 0x00, /* nop */
1599 0x09, 0x00, /* nop */
1600 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1601 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1604 /* Sebsequent entries in an absolute procedure linkage table look like
1607 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1609 0xd0, 0x04, /* mov.l 1f,r0 */
1610 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1611 0xd1, 0x02, /* mov.l 0f,r1 */
1612 0x40, 0x2b, /* jmp @r0 */
1613 0x60, 0x13, /* mov r1,r0 */
1614 0xd1, 0x03, /* mov.l 2f,r1 */
1615 0x40, 0x2b, /* jmp @r0 */
1616 0x00, 0x09, /* nop */
1617 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1618 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1619 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1622 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1624 0x04, 0xd0, /* mov.l 1f,r0 */
1625 0x02, 0x60, /* mov.l @r0,r0 */
1626 0x02, 0xd1, /* mov.l 0f,r1 */
1627 0x2b, 0x40, /* jmp @r0 */
1628 0x13, 0x60, /* mov r1,r0 */
1629 0x03, 0xd1, /* mov.l 2f,r1 */
1630 0x2b, 0x40, /* jmp @r0 */
1631 0x09, 0x00, /* nop */
1632 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1633 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1634 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1637 /* Entries in a PIC procedure linkage table look like this. */
1639 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1641 0xd0, 0x04, /* mov.l 1f,r0 */
1642 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1643 0x40, 0x2b, /* jmp @r0 */
1644 0x00, 0x09, /* nop */
1645 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1646 0xd1, 0x03, /* mov.l 2f,r1 */
1647 0x40, 0x2b, /* jmp @r0 */
1648 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1649 0x00, 0x09, /* nop */
1650 0x00, 0x09, /* nop */
1651 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1652 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1655 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1657 0x04, 0xd0, /* mov.l 1f,r0 */
1658 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1659 0x2b, 0x40, /* jmp @r0 */
1660 0x09, 0x00, /* nop */
1661 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1662 0x03, 0xd1, /* mov.l 2f,r1 */
1663 0x2b, 0x40, /* jmp @r0 */
1664 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1665 0x09, 0x00, /* nop */
1666 0x09, 0x00, /* nop */
1667 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1668 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1671 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1674 /* Big-endian non-PIC. */
1675 elf_sh_plt0_entry_be
,
1677 { MINUS_ONE
, 24, 20 },
1678 elf_sh_plt_entry_be
,
1680 { 20, 16, 24, false },
1685 /* Little-endian non-PIC. */
1686 elf_sh_plt0_entry_le
,
1688 { MINUS_ONE
, 24, 20 },
1689 elf_sh_plt_entry_le
,
1691 { 20, 16, 24, false },
1698 /* Big-endian PIC. */
1699 elf_sh_plt0_entry_be
,
1701 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1702 elf_sh_pic_plt_entry_be
,
1704 { 20, MINUS_ONE
, 24, false },
1709 /* Little-endian PIC. */
1710 elf_sh_plt0_entry_le
,
1712 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1713 elf_sh_pic_plt_entry_le
,
1715 { 20, MINUS_ONE
, 24, false },
1722 #define VXWORKS_PLT_HEADER_SIZE 12
1723 #define VXWORKS_PLT_ENTRY_SIZE 24
1725 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1727 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1728 0x61, 0x12, /* mov.l @r1,r1 */
1729 0x41, 0x2b, /* jmp @r1 */
1730 0x00, 0x09, /* nop */
1731 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1734 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1736 0x01, 0xd1, /* mov.l @(8,pc),r1 */
1737 0x12, 0x61, /* mov.l @r1,r1 */
1738 0x2b, 0x41, /* jmp @r1 */
1739 0x09, 0x00, /* nop */
1740 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1743 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1745 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1746 0x60, 0x02, /* mov.l @r0,r0 */
1747 0x40, 0x2b, /* jmp @r0 */
1748 0x00, 0x09, /* nop */
1749 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1750 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1751 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
1752 0x00, 0x09, /* nop */
1753 0x00, 0x09, /* nop */
1754 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1757 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1759 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1760 0x02, 0x60, /* mov.l @r0,r0 */
1761 0x2b, 0x40, /* jmp @r0 */
1762 0x09, 0x00, /* nop */
1763 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1764 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1765 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
1766 0x09, 0x00, /* nop */
1767 0x09, 0x00, /* nop */
1768 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1771 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1773 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1774 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1775 0x40, 0x2b, /* jmp @r0 */
1776 0x00, 0x09, /* nop */
1777 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1778 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1779 0x51, 0xc2, /* mov.l @(8,r12),r1 */
1780 0x41, 0x2b, /* jmp @r1 */
1781 0x00, 0x09, /* nop */
1782 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1785 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1787 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1788 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1789 0x2b, 0x40, /* jmp @r0 */
1790 0x09, 0x00, /* nop */
1791 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1792 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1793 0xc2, 0x51, /* mov.l @(8,r12),r1 */
1794 0x2b, 0x41, /* jmp @r1 */
1795 0x09, 0x00, /* nop */
1796 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1799 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
1802 /* Big-endian non-PIC. */
1803 vxworks_sh_plt0_entry_be
,
1804 VXWORKS_PLT_HEADER_SIZE
,
1805 { MINUS_ONE
, MINUS_ONE
, 8 },
1806 vxworks_sh_plt_entry_be
,
1807 VXWORKS_PLT_ENTRY_SIZE
,
1808 { 8, 14, 20, false },
1813 /* Little-endian non-PIC. */
1814 vxworks_sh_plt0_entry_le
,
1815 VXWORKS_PLT_HEADER_SIZE
,
1816 { MINUS_ONE
, MINUS_ONE
, 8 },
1817 vxworks_sh_plt_entry_le
,
1818 VXWORKS_PLT_ENTRY_SIZE
,
1819 { 8, 14, 20, false },
1826 /* Big-endian PIC. */
1829 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1830 vxworks_sh_pic_plt_entry_be
,
1831 VXWORKS_PLT_ENTRY_SIZE
,
1832 { 8, MINUS_ONE
, 20, false },
1837 /* Little-endian PIC. */
1840 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1841 vxworks_sh_pic_plt_entry_le
,
1842 VXWORKS_PLT_ENTRY_SIZE
,
1843 { 8, MINUS_ONE
, 20, false },
1850 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
1851 binding are to omit the lazy binding stub when linking with -z now
1852 and to move lazy binding stubs into a separate region for better
1855 #define FDPIC_PLT_ENTRY_SIZE 28
1856 #define FDPIC_PLT_LAZY_OFFSET 20
1858 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
1859 duplicated if it is out of range, or which can be inlined. So
1860 right now it is always inlined, which wastes a word per stub. It
1861 might be easier to handle the duplication if we put the lazy
1862 stubs separately. */
1864 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
1866 0xd0, 0x02, /* mov.l @(12,pc),r0 */
1867 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1868 0x70, 0x04, /* add #4, r0 */
1869 0x41, 0x2b, /* jmp @r1 */
1870 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1871 0x00, 0x09, /* nop */
1872 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1873 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1874 0x60, 0xc2, /* mov.l @r12,r0 */
1875 0x40, 0x2b, /* jmp @r0 */
1876 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1877 0x00, 0x09, /* nop */
1880 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
1882 0x02, 0xd0, /* mov.l @(12,pc),r0 */
1883 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1884 0x04, 0x70, /* add #4, r0 */
1885 0x2b, 0x41, /* jmp @r1 */
1886 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1887 0x09, 0x00, /* nop */
1888 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1889 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1890 0xc2, 0x60, /* mov.l @r12,r0 */
1891 0x2b, 0x40, /* jmp @r0 */
1892 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1893 0x09, 0x00, /* nop */
1896 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
1898 /* Big-endian PIC. */
1901 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1902 fdpic_sh_plt_entry_be
,
1903 FDPIC_PLT_ENTRY_SIZE
,
1904 { 12, MINUS_ONE
, 16, false },
1905 FDPIC_PLT_LAZY_OFFSET
,
1909 /* Little-endian PIC. */
1912 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1913 fdpic_sh_plt_entry_le
,
1914 FDPIC_PLT_ENTRY_SIZE
,
1915 { 12, MINUS_ONE
, 16, false },
1916 FDPIC_PLT_LAZY_OFFSET
,
1921 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
1922 entries for the first 64K slots. We use the normal FDPIC PLT entry
1923 past that point; we could also use movi20s, which might be faster,
1924 but would not be any smaller. */
1926 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
1927 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
1929 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1931 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1932 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1933 0x70, 0x04, /* add #4, r0 */
1934 0x41, 0x2b, /* jmp @r1 */
1935 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1936 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1937 0x60, 0xc2, /* mov.l @r12,r0 */
1938 0x40, 0x2b, /* jmp @r0 */
1939 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1940 0x00, 0x09, /* nop */
1943 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1945 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1946 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1947 0x04, 0x70, /* add #4, r0 */
1948 0x2b, 0x41, /* jmp @r1 */
1949 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1950 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1951 0xc2, 0x60, /* mov.l @r12,r0 */
1952 0x2b, 0x40, /* jmp @r0 */
1953 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1954 0x09, 0x00, /* nop */
1957 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
1958 /* Big-endian FDPIC, max index 64K. */
1961 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1962 fdpic_sh2a_plt_entry_be
,
1963 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1964 { 0, MINUS_ONE
, 12, true },
1965 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1969 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
1970 /* Little-endian FDPIC, max index 64K. */
1973 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1974 fdpic_sh2a_plt_entry_le
,
1975 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1976 { 0, MINUS_ONE
, 12, true },
1977 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1981 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
1983 /* Big-endian PIC. */
1986 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1987 fdpic_sh_plt_entry_be
,
1988 FDPIC_PLT_ENTRY_SIZE
,
1989 { 12, MINUS_ONE
, 16, false },
1990 FDPIC_PLT_LAZY_OFFSET
,
1991 &fdpic_sh2a_short_plt_be
1994 /* Little-endian PIC. */
1997 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1998 fdpic_sh_plt_entry_le
,
1999 FDPIC_PLT_ENTRY_SIZE
,
2000 { 12, MINUS_ONE
, 16, false },
2001 FDPIC_PLT_LAZY_OFFSET
,
2002 &fdpic_sh2a_short_plt_le
2006 /* Return the type of PLT associated with ABFD. PIC_P is true if
2007 the object is position-independent. */
2009 static const struct elf_sh_plt_info
*
2010 get_plt_info (bfd
*abfd
, bool pic_p
)
2012 if (fdpic_object_p (abfd
))
2014 /* If any input file requires SH2A we can use a shorter PLT
2016 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2017 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2019 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2021 if (vxworks_object_p (abfd
))
2022 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2023 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2026 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2027 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2031 install_plt_field (bfd
*output_bfd
, bool code_p ATTRIBUTE_UNUSED
,
2032 unsigned long value
, bfd_byte
*addr
)
2034 bfd_put_32 (output_bfd
, value
, addr
);
2037 /* The number of PLT entries which can use a shorter PLT, if any.
2038 Currently always 64K, since only SH-2A FDPIC uses this; a
2039 20-bit movi20 can address that many function descriptors below
2040 _GLOBAL_OFFSET_TABLE_. */
2041 #define MAX_SHORT_PLT 65536
2043 /* Return the index of the PLT entry at byte offset OFFSET. */
2046 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2048 bfd_vma plt_index
= 0;
2050 offset
-= info
->plt0_entry_size
;
2051 if (info
->short_plt
!= NULL
)
2053 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2055 plt_index
= MAX_SHORT_PLT
;
2056 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2059 info
= info
->short_plt
;
2061 return plt_index
+ offset
/ info
->symbol_entry_size
;
2064 /* Do the inverse operation. */
2067 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2071 if (info
->short_plt
!= NULL
)
2073 if (plt_index
> MAX_SHORT_PLT
)
2075 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2076 plt_index
-= MAX_SHORT_PLT
;
2079 info
= info
->short_plt
;
2081 return (offset
+ info
->plt0_entry_size
2082 + (plt_index
* info
->symbol_entry_size
));
2087 bfd_signed_vma refcount
;
2091 /* sh ELF linker hash entry. */
2093 struct elf_sh_link_hash_entry
2095 struct elf_link_hash_entry root
;
2097 bfd_signed_vma gotplt_refcount
;
2099 /* A local function descriptor, for FDPIC. The refcount counts
2100 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2101 relocations; the PLT and GOT entry are accounted
2102 for separately. After adjust_dynamic_symbol, the offset is
2103 MINUS_ONE if there is no local descriptor (dynamic linker
2104 managed and no PLT entry, or undefined weak non-dynamic).
2105 During check_relocs we do not yet know whether the local
2106 descriptor will be canonical. */
2107 union gotref funcdesc
;
2109 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2110 and thus require fixups or relocations. */
2111 bfd_signed_vma abs_funcdesc_refcount
;
2114 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2118 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2120 struct sh_elf_obj_tdata
2122 struct elf_obj_tdata root
;
2124 /* got_type for each local got entry. */
2125 char *local_got_type
;
2127 /* Function descriptor refcount and offset for each local symbol. */
2128 union gotref
*local_funcdesc
;
2131 #define sh_elf_tdata(abfd) \
2132 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2134 #define sh_elf_local_got_type(abfd) \
2135 (sh_elf_tdata (abfd)->local_got_type)
2137 #define sh_elf_local_funcdesc(abfd) \
2138 (sh_elf_tdata (abfd)->local_funcdesc)
2140 #define is_sh_elf(bfd) \
2141 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2142 && elf_tdata (bfd) != NULL \
2143 && elf_object_id (bfd) == SH_ELF_DATA)
2145 /* Override the generic function because we need to store sh_elf_obj_tdata
2146 as the specific tdata. */
2149 sh_elf_mkobject (bfd
*abfd
)
2151 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2155 /* sh ELF linker hash table. */
2157 struct elf_sh_link_hash_table
2159 struct elf_link_hash_table root
;
2161 /* Short-cuts to get to dynamic linker sections. */
2162 asection
*sfuncdesc
;
2163 asection
*srelfuncdesc
;
2166 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2169 /* A counter or offset to track a TLS got entry. */
2172 bfd_signed_vma refcount
;
2176 /* The type of PLT to use. */
2177 const struct elf_sh_plt_info
*plt_info
;
2179 /* True if the target system uses FDPIC. */
2183 /* Traverse an sh ELF linker hash table. */
2185 #define sh_elf_link_hash_traverse(table, func, info) \
2186 (elf_link_hash_traverse \
2188 (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
2191 /* Get the sh ELF linker hash table from a link_info structure. */
2193 #define sh_elf_hash_table(p) \
2194 ((is_elf_hash_table ((p)->hash) \
2195 && elf_hash_table_id (elf_hash_table (p)) == SH_ELF_DATA) \
2196 ? (struct elf_sh_link_hash_table *) (p)->hash : NULL)
2198 /* Create an entry in an sh ELF linker hash table. */
2200 static struct bfd_hash_entry
*
2201 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2202 struct bfd_hash_table
*table
,
2205 struct elf_sh_link_hash_entry
*ret
=
2206 (struct elf_sh_link_hash_entry
*) entry
;
2208 /* Allocate the structure if it has not already been allocated by a
2210 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2211 ret
= ((struct elf_sh_link_hash_entry
*)
2212 bfd_hash_allocate (table
,
2213 sizeof (struct elf_sh_link_hash_entry
)));
2214 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2215 return (struct bfd_hash_entry
*) ret
;
2217 /* Call the allocation method of the superclass. */
2218 ret
= ((struct elf_sh_link_hash_entry
*)
2219 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2221 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2223 ret
->gotplt_refcount
= 0;
2224 ret
->funcdesc
.refcount
= 0;
2225 ret
->abs_funcdesc_refcount
= 0;
2226 ret
->got_type
= GOT_UNKNOWN
;
2229 return (struct bfd_hash_entry
*) ret
;
2232 /* Create an sh ELF linker hash table. */
2234 static struct bfd_link_hash_table
*
2235 sh_elf_link_hash_table_create (bfd
*abfd
)
2237 struct elf_sh_link_hash_table
*ret
;
2238 size_t amt
= sizeof (struct elf_sh_link_hash_table
);
2240 ret
= (struct elf_sh_link_hash_table
*) bfd_zmalloc (amt
);
2241 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2244 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2245 sh_elf_link_hash_newfunc
,
2246 sizeof (struct elf_sh_link_hash_entry
),
2253 if (fdpic_object_p (abfd
))
2255 ret
->root
.dt_pltgot_required
= true;
2256 ret
->fdpic_p
= true;
2259 return &ret
->root
.root
;
2263 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2264 struct bfd_link_info
*info
, asection
*p
)
2266 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2268 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2272 /* We need dynamic symbols for every section, since segments can
2273 relocate independently. */
2274 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2278 /* If sh_type is yet undecided, assume it could be
2279 SHT_PROGBITS/SHT_NOBITS. */
2283 /* There shouldn't be section relative relocations
2284 against any other section. */
2290 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2291 shortcuts to them in our hash table. */
2294 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2296 struct elf_sh_link_hash_table
*htab
;
2298 if (! _bfd_elf_create_got_section (dynobj
, info
))
2301 htab
= sh_elf_hash_table (info
);
2305 htab
->sfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.funcdesc",
2306 (SEC_ALLOC
| SEC_LOAD
2309 | SEC_LINKER_CREATED
));
2310 if (htab
->sfuncdesc
== NULL
2311 || !bfd_set_section_alignment (htab
->sfuncdesc
, 2))
2314 htab
->srelfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
,
2315 ".rela.got.funcdesc",
2316 (SEC_ALLOC
| SEC_LOAD
2319 | SEC_LINKER_CREATED
2321 if (htab
->srelfuncdesc
== NULL
2322 || !bfd_set_section_alignment (htab
->srelfuncdesc
, 2))
2325 /* Also create .rofixup. */
2326 htab
->srofixup
= bfd_make_section_anyway_with_flags (dynobj
, ".rofixup",
2327 (SEC_ALLOC
| SEC_LOAD
2330 | SEC_LINKER_CREATED
2332 if (htab
->srofixup
== NULL
2333 || !bfd_set_section_alignment (htab
->srofixup
, 2))
2339 /* Create dynamic sections when linking against a dynamic object. */
2342 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2344 struct elf_sh_link_hash_table
*htab
;
2345 flagword flags
, pltflags
;
2347 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2350 switch (bed
->s
->arch_size
)
2361 bfd_set_error (bfd_error_bad_value
);
2365 htab
= sh_elf_hash_table (info
);
2369 if (htab
->root
.dynamic_sections_created
)
2372 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2373 .rel[a].bss sections. */
2375 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2376 | SEC_LINKER_CREATED
);
2379 pltflags
|= SEC_CODE
;
2380 if (bed
->plt_not_loaded
)
2381 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2382 if (bed
->plt_readonly
)
2383 pltflags
|= SEC_READONLY
;
2385 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2386 htab
->root
.splt
= s
;
2388 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2391 if (bed
->want_plt_sym
)
2393 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2395 struct elf_link_hash_entry
*h
;
2396 struct bfd_link_hash_entry
*bh
= NULL
;
2398 if (! (_bfd_generic_link_add_one_symbol
2399 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2400 (bfd_vma
) 0, (const char *) NULL
, false,
2401 get_elf_backend_data (abfd
)->collect
, &bh
)))
2404 h
= (struct elf_link_hash_entry
*) bh
;
2406 h
->type
= STT_OBJECT
;
2407 htab
->root
.hplt
= h
;
2409 if (bfd_link_pic (info
)
2410 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2414 s
= bfd_make_section_anyway_with_flags (abfd
,
2415 bed
->default_use_rela_p
2416 ? ".rela.plt" : ".rel.plt",
2417 flags
| SEC_READONLY
);
2418 htab
->root
.srelplt
= s
;
2420 || !bfd_set_section_alignment (s
, ptralign
))
2423 if (htab
->root
.sgot
== NULL
2424 && !create_got_section (abfd
, info
))
2427 if (bed
->want_dynbss
)
2429 /* The .dynbss section is a place to put symbols which are defined
2430 by dynamic objects, are referenced by regular objects, and are
2431 not functions. We must allocate space for them in the process
2432 image and use a R_*_COPY reloc to tell the dynamic linker to
2433 initialize them at run time. The linker script puts the .dynbss
2434 section into the .bss section of the final image. */
2435 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2436 SEC_ALLOC
| SEC_LINKER_CREATED
);
2437 htab
->root
.sdynbss
= s
;
2441 /* The .rel[a].bss section holds copy relocs. This section is not
2442 normally needed. We need to create it here, though, so that the
2443 linker will map it to an output section. We can't just create it
2444 only if we need it, because we will not know whether we need it
2445 until we have seen all the input files, and the first time the
2446 main linker code calls BFD after examining all the input files
2447 (size_dynamic_sections) the input sections have already been
2448 mapped to the output sections. If the section turns out not to
2449 be needed, we can discard it later. We will never need this
2450 section when generating a shared object, since they do not use
2452 if (! bfd_link_pic (info
))
2454 s
= bfd_make_section_anyway_with_flags (abfd
,
2455 (bed
->default_use_rela_p
2456 ? ".rela.bss" : ".rel.bss"),
2457 flags
| SEC_READONLY
);
2458 htab
->root
.srelbss
= s
;
2460 || !bfd_set_section_alignment (s
, ptralign
))
2465 if (htab
->root
.target_os
== is_vxworks
)
2467 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2474 /* Adjust a symbol defined by a dynamic object and referenced by a
2475 regular object. The current definition is in some section of the
2476 dynamic object, but we're not including those sections. We have to
2477 change the definition to something the rest of the link can
2481 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2482 struct elf_link_hash_entry
*h
)
2484 struct elf_sh_link_hash_table
*htab
;
2487 htab
= sh_elf_hash_table (info
);
2491 /* Make sure we know what is going on here. */
2492 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2497 && !h
->def_regular
)));
2499 /* If this is a function, put it in the procedure linkage table. We
2500 will fill in the contents of the procedure linkage table later,
2501 when we know the address of the .got section. */
2502 if (h
->type
== STT_FUNC
2505 if (h
->plt
.refcount
<= 0
2506 || SYMBOL_CALLS_LOCAL (info
, h
)
2507 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2508 && h
->root
.type
== bfd_link_hash_undefweak
))
2510 /* This case can occur if we saw a PLT reloc in an input
2511 file, but the symbol was never referred to by a dynamic
2512 object. In such a case, we don't actually need to build
2513 a procedure linkage table, and we can just do a REL32
2515 h
->plt
.offset
= (bfd_vma
) -1;
2522 h
->plt
.offset
= (bfd_vma
) -1;
2524 /* If this is a weak symbol, and there is a real definition, the
2525 processor independent code will have arranged for us to see the
2526 real definition first, and we can just use the same value. */
2527 if (h
->is_weakalias
)
2529 struct elf_link_hash_entry
*def
= weakdef (h
);
2530 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2531 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2532 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2533 if (info
->nocopyreloc
)
2534 h
->non_got_ref
= def
->non_got_ref
;
2538 /* This is a reference to a symbol defined by a dynamic object which
2539 is not a function. */
2541 /* If we are creating a shared library, we must presume that the
2542 only references to the symbol are via the global offset table.
2543 For such cases we need not do anything here; the relocations will
2544 be handled correctly by relocate_section. */
2545 if (bfd_link_pic (info
))
2548 /* If there are no references to this symbol that do not use the
2549 GOT, we don't need to generate a copy reloc. */
2550 if (!h
->non_got_ref
)
2553 /* If -z nocopyreloc was given, we won't generate them either. */
2554 if (0 && info
->nocopyreloc
)
2560 /* If we don't find any dynamic relocs in read-only sections, then
2561 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2562 if (0 && !_bfd_elf_readonly_dynrelocs (h
))
2568 /* We must allocate the symbol in our .dynbss section, which will
2569 become part of the .bss section of the executable. There will be
2570 an entry for this symbol in the .dynsym section. The dynamic
2571 object will contain position independent code, so all references
2572 from the dynamic object to this symbol will go through the global
2573 offset table. The dynamic linker will use the .dynsym entry to
2574 determine the address it must put in the global offset table, so
2575 both the dynamic object and the regular object will refer to the
2576 same memory location for the variable. */
2578 s
= htab
->root
.sdynbss
;
2579 BFD_ASSERT (s
!= NULL
);
2581 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2582 copy the initial value out of the dynamic object and into the
2583 runtime process image. We need to remember the offset into the
2584 .rela.bss section we are going to use. */
2585 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2589 srel
= htab
->root
.srelbss
;
2590 BFD_ASSERT (srel
!= NULL
);
2591 srel
->size
+= sizeof (Elf32_External_Rela
);
2595 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2598 /* Allocate space in .plt, .got and associated reloc sections for
2602 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2604 struct bfd_link_info
*info
;
2605 struct elf_sh_link_hash_table
*htab
;
2606 struct elf_sh_link_hash_entry
*eh
;
2607 struct elf_dyn_relocs
*p
;
2609 if (h
->root
.type
== bfd_link_hash_indirect
)
2612 info
= (struct bfd_link_info
*) inf
;
2613 htab
= sh_elf_hash_table (info
);
2617 eh
= (struct elf_sh_link_hash_entry
*) h
;
2618 if ((h
->got
.refcount
> 0
2620 && eh
->gotplt_refcount
> 0)
2622 /* The symbol has been forced local, or we have some direct got refs,
2623 so treat all the gotplt refs as got refs. */
2624 h
->got
.refcount
+= eh
->gotplt_refcount
;
2625 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2626 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2629 if (htab
->root
.dynamic_sections_created
2630 && h
->plt
.refcount
> 0
2631 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2632 || h
->root
.type
!= bfd_link_hash_undefweak
))
2634 /* Make sure this symbol is output as a dynamic symbol.
2635 Undefined weak syms won't yet be marked as dynamic. */
2636 if (h
->dynindx
== -1
2637 && !h
->forced_local
)
2639 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2643 if (bfd_link_pic (info
)
2644 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2646 asection
*s
= htab
->root
.splt
;
2647 const struct elf_sh_plt_info
*plt_info
;
2649 /* If this is the first .plt entry, make room for the special
2652 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2654 h
->plt
.offset
= s
->size
;
2656 /* If this symbol is not defined in a regular file, and we are
2657 not generating a shared library, then set the symbol to this
2658 location in the .plt. This is required to make function
2659 pointers compare as equal between the normal executable and
2660 the shared library. Skip this for FDPIC, since the
2661 function's address will be the address of the canonical
2662 function descriptor. */
2663 if (!htab
->fdpic_p
&& !bfd_link_pic (info
) && !h
->def_regular
)
2665 h
->root
.u
.def
.section
= s
;
2666 h
->root
.u
.def
.value
= h
->plt
.offset
;
2669 /* Make room for this entry. */
2670 plt_info
= htab
->plt_info
;
2671 if (plt_info
->short_plt
!= NULL
2672 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
2673 plt_info
= plt_info
->short_plt
;
2674 s
->size
+= plt_info
->symbol_entry_size
;
2676 /* We also need to make an entry in the .got.plt section, which
2677 will be placed in the .got section by the linker script. */
2679 htab
->root
.sgotplt
->size
+= 4;
2681 htab
->root
.sgotplt
->size
+= 8;
2683 /* We also need to make an entry in the .rel.plt section. */
2684 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
2686 if (htab
->root
.target_os
== is_vxworks
&& !bfd_link_pic (info
))
2688 /* VxWorks executables have a second set of relocations
2689 for each PLT entry. They go in a separate relocation
2690 section, which is processed by the kernel loader. */
2692 /* There is a relocation for the initial PLT entry:
2693 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
2694 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
2695 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
2697 /* There are two extra relocations for each subsequent
2698 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2699 and an R_SH_DIR32 relocation for the PLT entry. */
2700 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
2705 h
->plt
.offset
= (bfd_vma
) -1;
2711 h
->plt
.offset
= (bfd_vma
) -1;
2715 if (h
->got
.refcount
> 0)
2719 enum got_type got_type
= sh_elf_hash_entry (h
)->got_type
;
2721 /* Make sure this symbol is output as a dynamic symbol.
2722 Undefined weak syms won't yet be marked as dynamic. */
2723 if (h
->dynindx
== -1
2724 && !h
->forced_local
)
2726 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2730 s
= htab
->root
.sgot
;
2731 h
->got
.offset
= s
->size
;
2733 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
2734 if (got_type
== GOT_TLS_GD
)
2736 dyn
= htab
->root
.dynamic_sections_created
;
2739 /* No dynamic relocations required. */
2740 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
2741 && h
->root
.type
!= bfd_link_hash_undefweak
2742 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
2743 htab
->srofixup
->size
+= 4;
2745 /* No dynamic relocations required when IE->LE conversion happens. */
2746 else if (got_type
== GOT_TLS_IE
2748 && !bfd_link_pic (info
))
2750 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2751 R_SH_TLS_GD needs one if local symbol and two if global. */
2752 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2753 || got_type
== GOT_TLS_IE
)
2754 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2755 else if (got_type
== GOT_TLS_GD
)
2756 htab
->root
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2757 else if (got_type
== GOT_FUNCDESC
)
2759 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2760 htab
->srofixup
->size
+= 4;
2762 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2764 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2765 || h
->root
.type
!= bfd_link_hash_undefweak
)
2766 && (bfd_link_pic (info
)
2767 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2768 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2769 else if (htab
->fdpic_p
2770 && !bfd_link_pic (info
)
2771 && got_type
== GOT_NORMAL
2772 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2773 || h
->root
.type
!= bfd_link_hash_undefweak
))
2774 htab
->srofixup
->size
+= 4;
2777 h
->got
.offset
= (bfd_vma
) -1;
2779 /* Allocate space for any dynamic relocations to function
2780 descriptors, canonical or otherwise. We need to relocate the
2781 reference unless it resolves to zero, which only happens for
2782 undefined weak symbols (either non-default visibility, or when
2783 static linking). Any GOT slot is accounted for elsewhere. */
2784 if (eh
->abs_funcdesc_refcount
> 0
2785 && (h
->root
.type
!= bfd_link_hash_undefweak
2786 || (htab
->root
.dynamic_sections_created
2787 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
2789 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2790 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
2792 htab
->root
.srelgot
->size
2793 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
2796 /* We must allocate a function descriptor if there are references to
2797 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
2798 the dynamic linker isn't going to allocate it. None of this
2799 applies if we already created one in .got.plt, but if the
2800 canonical function descriptor can be in this object, there
2801 won't be a PLT entry at all. */
2802 if ((eh
->funcdesc
.refcount
> 0
2803 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
2804 && h
->root
.type
!= bfd_link_hash_undefweak
2805 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2807 /* Make room for this function descriptor. */
2808 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
2809 htab
->sfuncdesc
->size
+= 8;
2811 /* We will need a relocation or two fixups to initialize the
2812 function descriptor, so allocate those too. */
2813 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
2814 htab
->srofixup
->size
+= 8;
2816 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
2819 if (h
->dyn_relocs
== NULL
)
2822 /* In the shared -Bsymbolic case, discard space allocated for
2823 dynamic pc-relative relocs against symbols which turn out to be
2824 defined in regular objects. For the normal shared case, discard
2825 space for pc-relative relocs that have become local due to symbol
2826 visibility changes. */
2828 if (bfd_link_pic (info
))
2830 if (SYMBOL_CALLS_LOCAL (info
, h
))
2832 struct elf_dyn_relocs
**pp
;
2834 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
2836 p
->count
-= p
->pc_count
;
2845 if (htab
->root
.target_os
== is_vxworks
)
2847 struct elf_dyn_relocs
**pp
;
2849 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
2851 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2858 /* Also discard relocs on undefined weak syms with non-default
2860 if (h
->dyn_relocs
!= NULL
2861 && h
->root
.type
== bfd_link_hash_undefweak
)
2863 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2864 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2865 h
->dyn_relocs
= NULL
;
2867 /* Make sure undefined weak symbols are output as a dynamic
2869 else if (h
->dynindx
== -1
2870 && !h
->forced_local
)
2872 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2879 /* For the non-shared case, discard space for relocs against
2880 symbols which turn out to need copy relocs or are not
2886 || (htab
->root
.dynamic_sections_created
2887 && (h
->root
.type
== bfd_link_hash_undefweak
2888 || h
->root
.type
== bfd_link_hash_undefined
))))
2890 /* Make sure this symbol is output as a dynamic symbol.
2891 Undefined weak syms won't yet be marked as dynamic. */
2892 if (h
->dynindx
== -1
2893 && !h
->forced_local
)
2895 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2899 /* If that succeeded, we know we'll be keeping all the
2901 if (h
->dynindx
!= -1)
2905 h
->dyn_relocs
= NULL
;
2910 /* Finally, allocate space. */
2911 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2913 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2914 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2916 /* If we need relocations, we do not need fixups. */
2917 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
2918 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
2924 /* This function is called after all the input files have been read,
2925 and the input sections have been assigned to output sections.
2926 It's a convenient place to determine the PLT style. */
2929 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2931 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
,
2932 bfd_link_pic (info
));
2934 if (sh_elf_hash_table (info
)->fdpic_p
&& !bfd_link_relocatable (info
)
2935 && !bfd_elf_stack_segment_size (output_bfd
, info
,
2936 "__stacksize", DEFAULT_STACK_SIZE
))
2941 /* Set the sizes of the dynamic sections. */
2944 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2945 struct bfd_link_info
*info
)
2947 struct elf_sh_link_hash_table
*htab
;
2953 htab
= sh_elf_hash_table (info
);
2957 dynobj
= htab
->root
.dynobj
;
2958 BFD_ASSERT (dynobj
!= NULL
);
2960 if (htab
->root
.dynamic_sections_created
)
2962 /* Set the contents of the .interp section to the interpreter. */
2963 if (bfd_link_executable (info
) && !info
->nointerp
)
2965 s
= bfd_get_linker_section (dynobj
, ".interp");
2966 BFD_ASSERT (s
!= NULL
);
2967 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2968 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2972 /* Set up .got offsets for local syms, and space for local dynamic
2974 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2976 bfd_signed_vma
*local_got
;
2977 bfd_signed_vma
*end_local_got
;
2978 union gotref
*local_funcdesc
, *end_local_funcdesc
;
2979 char *local_got_type
;
2980 bfd_size_type locsymcount
;
2981 Elf_Internal_Shdr
*symtab_hdr
;
2984 if (! is_sh_elf (ibfd
))
2987 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2989 struct elf_dyn_relocs
*p
;
2991 for (p
= ((struct elf_dyn_relocs
*)
2992 elf_section_data (s
)->local_dynrel
);
2996 if (! bfd_is_abs_section (p
->sec
)
2997 && bfd_is_abs_section (p
->sec
->output_section
))
2999 /* Input section has been discarded, either because
3000 it is a copy of a linkonce section or due to
3001 linker script /DISCARD/, so we'll be discarding
3004 else if (htab
->root
.target_os
== is_vxworks
3005 && strcmp (p
->sec
->output_section
->name
,
3008 /* Relocations in vxworks .tls_vars sections are
3009 handled specially by the loader. */
3011 else if (p
->count
!= 0)
3013 srel
= elf_section_data (p
->sec
)->sreloc
;
3014 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3015 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3017 info
->flags
|= DF_TEXTREL
;
3018 info
->callbacks
->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
3019 p
->sec
->owner
, p
->sec
);
3022 /* If we need relocations, we do not need fixups. */
3023 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
3024 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3029 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3030 locsymcount
= symtab_hdr
->sh_info
;
3031 s
= htab
->root
.sgot
;
3032 srel
= htab
->root
.srelgot
;
3034 local_got
= elf_local_got_refcounts (ibfd
);
3037 end_local_got
= local_got
+ locsymcount
;
3038 local_got_type
= sh_elf_local_got_type (ibfd
);
3039 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3040 for (; local_got
< end_local_got
; ++local_got
)
3044 *local_got
= s
->size
;
3046 if (*local_got_type
== GOT_TLS_GD
)
3048 if (bfd_link_pic (info
))
3049 srel
->size
+= sizeof (Elf32_External_Rela
);
3051 htab
->srofixup
->size
+= 4;
3053 if (*local_got_type
== GOT_FUNCDESC
)
3055 if (local_funcdesc
== NULL
)
3059 size
= locsymcount
* sizeof (union gotref
);
3060 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3062 if (local_funcdesc
== NULL
)
3064 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3065 local_funcdesc
+= (local_got
3066 - elf_local_got_refcounts (ibfd
));
3068 local_funcdesc
->refcount
++;
3073 *local_got
= (bfd_vma
) -1;
3078 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3081 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3083 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3085 if (local_funcdesc
->refcount
> 0)
3087 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3088 htab
->sfuncdesc
->size
+= 8;
3089 if (!bfd_link_pic (info
))
3090 htab
->srofixup
->size
+= 8;
3092 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3095 local_funcdesc
->offset
= MINUS_ONE
;
3101 if (htab
->tls_ldm_got
.refcount
> 0)
3103 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3105 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
3106 htab
->root
.sgot
->size
+= 8;
3107 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
3110 htab
->tls_ldm_got
.offset
= -1;
3112 /* Only the reserved entries should be present. For FDPIC, they go at
3113 the end of .got.plt. */
3116 BFD_ASSERT (htab
->root
.sgotplt
&& htab
->root
.sgotplt
->size
== 12);
3117 htab
->root
.sgotplt
->size
= 0;
3120 /* Allocate global sym .plt and .got entries, and space for global
3121 sym dynamic relocs. */
3122 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3124 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3125 end of the FDPIC .got.plt. */
3128 htab
->root
.hgot
->root
.u
.def
.value
= htab
->root
.sgotplt
->size
;
3129 htab
->root
.sgotplt
->size
+= 12;
3132 /* At the very end of the .rofixup section is a pointer to the GOT. */
3133 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3134 htab
->srofixup
->size
+= 4;
3136 /* We now have determined the sizes of the various dynamic sections.
3137 Allocate memory for them. */
3139 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3141 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3144 if (s
== htab
->root
.splt
3145 || s
== htab
->root
.sgot
3146 || s
== htab
->root
.sgotplt
3147 || s
== htab
->sfuncdesc
3148 || s
== htab
->srofixup
3149 || s
== htab
->root
.sdynbss
)
3151 /* Strip this section if we don't need it; see the
3154 else if (startswith (bfd_section_name (s
), ".rela"))
3156 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
&& s
!= htab
->srelplt2
)
3159 /* We use the reloc_count field as a counter if we need
3160 to copy relocs into the output file. */
3165 /* It's not one of our sections, so don't allocate space. */
3171 /* If we don't need this section, strip it from the
3172 output file. This is mostly to handle .rela.bss and
3173 .rela.plt. We must create both sections in
3174 create_dynamic_sections, because they must be created
3175 before the linker maps input sections to output
3176 sections. The linker does that before
3177 adjust_dynamic_symbol is called, and it is that
3178 function which decides whether anything needs to go
3179 into these sections. */
3181 s
->flags
|= SEC_EXCLUDE
;
3185 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3188 /* Allocate memory for the section contents. We use bfd_zalloc
3189 here in case unused entries are not reclaimed before the
3190 section's contents are written out. This should not happen,
3191 but this way if it does, we get a R_SH_NONE reloc instead
3193 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3194 if (s
->contents
== NULL
)
3198 return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd
, info
,
3202 /* Add a dynamic relocation to the SRELOC section. */
3204 inline static bfd_vma
3205 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3206 int reloc_type
, long dynindx
, bfd_vma addend
)
3208 Elf_Internal_Rela outrel
;
3209 bfd_vma reloc_offset
;
3211 outrel
.r_offset
= offset
;
3212 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3213 outrel
.r_addend
= addend
;
3215 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3216 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3217 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3218 sreloc
->contents
+ reloc_offset
);
3219 sreloc
->reloc_count
++;
3221 return reloc_offset
;
3224 /* Add an FDPIC read-only fixup. */
3227 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3229 bfd_vma fixup_offset
;
3231 fixup_offset
= srofixup
->reloc_count
++ * 4;
3232 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3233 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3236 /* Return the offset of the generated .got section from the
3237 _GLOBAL_OFFSET_TABLE_ symbol. */
3239 static bfd_signed_vma
3240 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3242 return (htab
->root
.sgot
->output_offset
- htab
->root
.sgotplt
->output_offset
3243 - htab
->root
.hgot
->root
.u
.def
.value
);
3246 /* Find the segment number in which OSEC, and output section, is
3250 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3252 Elf_Internal_Phdr
*p
= NULL
;
3254 if (output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
3255 /* PR ld/17110: Do not look for output segments in an input bfd. */
3256 && output_bfd
->direction
!= read_direction
)
3257 p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
3259 /* FIXME: Nothing ever says what this index is relative to. The kernel
3260 supplies data in terms of the number of load segments but this is
3261 a phdr index and the first phdr may not be a load segment. */
3262 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3266 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3268 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3270 return (seg
!= (unsigned) -1
3271 && ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
));
3274 /* Generate the initial contents of a local function descriptor, along
3275 with any relocations or fixups required. */
3277 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3278 struct bfd_link_info
*info
,
3279 struct elf_link_hash_entry
*h
,
3284 struct elf_sh_link_hash_table
*htab
;
3288 htab
= sh_elf_hash_table (info
);
3290 /* FIXME: The ABI says that the offset to the function goes in the
3291 descriptor, along with the segment index. We're RELA, so it could
3292 go in the reloc instead... */
3294 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3296 section
= h
->root
.u
.def
.section
;
3297 value
= h
->root
.u
.def
.value
;
3300 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3302 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3303 addr
= value
+ section
->output_offset
;
3304 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3308 BFD_ASSERT (h
->dynindx
!= -1);
3309 dynindx
= h
->dynindx
;
3313 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
3315 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3317 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3319 + htab
->sfuncdesc
->output_section
->vma
3320 + htab
->sfuncdesc
->output_offset
);
3321 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3323 + htab
->sfuncdesc
->output_section
->vma
3324 + htab
->sfuncdesc
->output_offset
);
3327 /* There are no dynamic relocations so fill in the final
3328 address and gp value (barring fixups). */
3329 addr
+= section
->output_section
->vma
;
3330 seg
= htab
->root
.hgot
->root
.u
.def
.value
3331 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3332 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3335 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3337 + htab
->sfuncdesc
->output_section
->vma
3338 + htab
->sfuncdesc
->output_offset
,
3339 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3341 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3342 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3347 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3348 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3351 static bfd_reloc_status_type
3352 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3353 bfd
*input_bfd
, asection
*input_section
,
3354 bfd_byte
*contents
, bfd_vma offset
)
3356 unsigned long cur_val
;
3358 bfd_reloc_status_type r
;
3360 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3361 return bfd_reloc_outofrange
;
3363 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3364 bfd_arch_bits_per_address (input_bfd
), relocation
);
3365 if (r
!= bfd_reloc_ok
)
3368 addr
= contents
+ offset
;
3369 cur_val
= bfd_get_16 (output_bfd
, addr
);
3370 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3371 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3373 return bfd_reloc_ok
;
3376 /* Relocate an SH ELF section. */
3379 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3380 bfd
*input_bfd
, asection
*input_section
,
3381 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3382 Elf_Internal_Sym
*local_syms
,
3383 asection
**local_sections
)
3385 struct elf_sh_link_hash_table
*htab
;
3386 Elf_Internal_Shdr
*symtab_hdr
;
3387 struct elf_link_hash_entry
**sym_hashes
;
3388 Elf_Internal_Rela
*rel
, *relend
;
3389 bfd_vma
*local_got_offsets
;
3390 asection
*sgot
= NULL
;
3391 asection
*sgotplt
= NULL
;
3392 asection
*splt
= NULL
;
3393 asection
*sreloc
= NULL
;
3394 asection
*srelgot
= NULL
;
3395 bool is_vxworks_tls
;
3396 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3397 bool fdpic_p
= false;
3399 if (!is_sh_elf (input_bfd
))
3401 bfd_set_error (bfd_error_wrong_format
);
3405 htab
= sh_elf_hash_table (info
);
3408 sgot
= htab
->root
.sgot
;
3409 sgotplt
= htab
->root
.sgotplt
;
3410 srelgot
= htab
->root
.srelgot
;
3411 splt
= htab
->root
.splt
;
3412 fdpic_p
= htab
->fdpic_p
;
3414 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3415 sym_hashes
= elf_sym_hashes (input_bfd
);
3416 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3418 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3419 input_section
->output_section
);
3420 if (fdpic_p
&& sgot
)
3421 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3422 sgot
->output_section
);
3425 if (fdpic_p
&& splt
)
3426 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3427 splt
->output_section
);
3431 /* We have to handle relocations in vxworks .tls_vars sections
3432 specially, because the dynamic loader is 'weird'. */
3433 is_vxworks_tls
= (htab
&& htab
->root
.target_os
== is_vxworks
&& bfd_link_pic (info
)
3434 && !strcmp (input_section
->output_section
->name
,
3438 relend
= relocs
+ input_section
->reloc_count
;
3439 for (; rel
< relend
; rel
++)
3442 reloc_howto_type
*howto
;
3443 unsigned long r_symndx
;
3444 Elf_Internal_Sym
*sym
;
3446 struct elf_link_hash_entry
*h
;
3448 bfd_vma addend
= (bfd_vma
) 0;
3449 bfd_reloc_status_type r
;
3451 enum got_type got_type
;
3452 const char *symname
= NULL
;
3453 bool resolved_to_zero
;
3455 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3457 r_type
= ELF32_R_TYPE (rel
->r_info
);
3459 /* Many of the relocs are only used for relaxing, and are
3460 handled entirely by the relaxation code. */
3461 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3462 && r_type
<= (int) R_SH_LABEL
)
3464 if (r_type
== (int) R_SH_NONE
)
3468 || r_type
>= R_SH_max
3469 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3470 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3471 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3472 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
3473 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3474 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3475 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3476 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3477 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3478 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3479 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
3480 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
3482 bfd_set_error (bfd_error_bad_value
);
3486 howto
= get_howto_table (output_bfd
) + r_type
;
3488 /* For relocs that aren't partial_inplace, we get the addend from
3490 if (! howto
->partial_inplace
)
3491 addend
= rel
->r_addend
;
3493 resolved_to_zero
= false;
3497 check_segment
[0] = -1;
3498 check_segment
[1] = -1;
3499 if (r_symndx
< symtab_hdr
->sh_info
)
3501 sym
= local_syms
+ r_symndx
;
3502 sec
= local_sections
[r_symndx
];
3504 symname
= bfd_elf_string_from_elf_section
3505 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
3506 if (symname
== NULL
|| *symname
== '\0')
3507 symname
= bfd_section_name (sec
);
3509 relocation
= (sec
->output_section
->vma
3510 + sec
->output_offset
3513 if (sec
!= NULL
&& discarded_section (sec
))
3514 /* Handled below. */
3516 else if (bfd_link_relocatable (info
))
3518 /* This is a relocatable link. We don't have to change
3519 anything, unless the reloc is against a section symbol,
3520 in which case we have to adjust according to where the
3521 section symbol winds up in the output section. */
3522 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3524 if (! howto
->partial_inplace
)
3526 /* For relocations with the addend in the
3527 relocation, we need just to update the addend.
3528 All real relocs are of type partial_inplace; this
3529 code is mostly for completeness. */
3530 rel
->r_addend
+= sec
->output_offset
;
3535 /* Relocs of type partial_inplace need to pick up the
3536 contents in the contents and add the offset resulting
3537 from the changed location of the section symbol.
3538 Using _bfd_final_link_relocate (e.g. goto
3539 final_link_relocate) here would be wrong, because
3540 relocations marked pc_relative would get the current
3541 location subtracted, and we must only do that at the
3543 r
= _bfd_relocate_contents (howto
, input_bfd
,
3546 contents
+ rel
->r_offset
);
3547 goto relocation_done
;
3552 else if (! howto
->partial_inplace
)
3554 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3555 addend
= rel
->r_addend
;
3557 else if ((sec
->flags
& SEC_MERGE
)
3558 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3562 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
3565 /* xgettext:c-format */
3566 (_("%pB(%pA+%#" PRIx64
"): "
3567 "%s relocation against SEC_MERGE section"),
3568 input_bfd
, input_section
,
3569 (uint64_t) rel
->r_offset
, howto
->name
);
3573 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3576 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
3578 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3579 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
3585 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
3588 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3589 symname
= h
->root
.root
.string
;
3590 while (h
->root
.type
== bfd_link_hash_indirect
3591 || h
->root
.type
== bfd_link_hash_warning
)
3592 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3593 if (h
->root
.type
== bfd_link_hash_defined
3594 || h
->root
.type
== bfd_link_hash_defweak
)
3598 dyn
= htab
? htab
->root
.dynamic_sections_created
: false;
3599 sec
= h
->root
.u
.def
.section
;
3600 /* In these cases, we don't need the relocation value.
3601 We check specially because in some obscure cases
3602 sec->output_section will be NULL. */
3603 if (r_type
== R_SH_GOTPC
3604 || r_type
== R_SH_GOTPC_LOW16
3605 || r_type
== R_SH_GOTPC_MEDLOW16
3606 || r_type
== R_SH_GOTPC_MEDHI16
3607 || r_type
== R_SH_GOTPC_HI16
3608 || ((r_type
== R_SH_PLT32
3609 || r_type
== R_SH_PLT_LOW16
3610 || r_type
== R_SH_PLT_MEDLOW16
3611 || r_type
== R_SH_PLT_MEDHI16
3612 || r_type
== R_SH_PLT_HI16
)
3613 && h
->plt
.offset
!= (bfd_vma
) -1)
3614 || ((r_type
== R_SH_GOT32
3615 || r_type
== R_SH_GOT20
3616 || r_type
== R_SH_GOTFUNCDESC
3617 || r_type
== R_SH_GOTFUNCDESC20
3618 || r_type
== R_SH_GOTOFFFUNCDESC
3619 || r_type
== R_SH_GOTOFFFUNCDESC20
3620 || r_type
== R_SH_FUNCDESC
3621 || r_type
== R_SH_GOT_LOW16
3622 || r_type
== R_SH_GOT_MEDLOW16
3623 || r_type
== R_SH_GOT_MEDHI16
3624 || r_type
== R_SH_GOT_HI16
)
3625 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3626 bfd_link_pic (info
),
3628 && (! bfd_link_pic (info
)
3629 || (! info
->symbolic
&& h
->dynindx
!= -1)
3630 || !h
->def_regular
))
3631 /* The cases above are those in which relocation is
3632 overwritten in the switch block below. The cases
3633 below are those in which we must defer relocation
3634 to run-time, because we can't resolve absolute
3635 addresses when creating a shared library. */
3636 || (bfd_link_pic (info
)
3637 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3639 && ((r_type
== R_SH_DIR32
3640 && !h
->forced_local
)
3641 || (r_type
== R_SH_REL32
3642 && !SYMBOL_CALLS_LOCAL (info
, h
)))
3643 && ((input_section
->flags
& SEC_ALLOC
) != 0
3644 /* DWARF will emit R_SH_DIR32 relocations in its
3645 sections against symbols defined externally
3646 in shared libraries. We can't do anything
3648 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
3649 && h
->def_dynamic
)))
3650 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3651 sections because such sections are not SEC_ALLOC and
3652 thus ld.so will not process them. */
3653 || (sec
->output_section
== NULL
3654 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
3656 || (sec
->output_section
== NULL
3657 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
3658 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
3660 else if (sec
->output_section
!= NULL
)
3661 relocation
= (h
->root
.u
.def
.value
3662 + sec
->output_section
->vma
3663 + sec
->output_offset
);
3664 else if (!bfd_link_relocatable (info
)
3665 && (_bfd_elf_section_offset (output_bfd
, info
,
3671 /* xgettext:c-format */
3672 (_("%pB(%pA+%#" PRIx64
"): "
3673 "unresolvable %s relocation against symbol `%s'"),
3676 (uint64_t) rel
->r_offset
,
3678 h
->root
.root
.string
);
3682 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3683 resolved_to_zero
= UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
);
3684 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3685 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3687 else if (!bfd_link_relocatable (info
))
3688 info
->callbacks
->undefined_symbol
3689 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
3691 (info
->unresolved_syms_in_objects
== RM_DIAGNOSE
3692 && !info
->warn_unresolved_syms
)
3693 || ELF_ST_VISIBILITY (h
->other
));
3696 if (sec
!= NULL
&& discarded_section (sec
))
3697 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3698 rel
, 1, relend
, howto
, 0, contents
);
3700 if (bfd_link_relocatable (info
))
3703 /* Check for inter-segment relocations in FDPIC files. Most
3704 relocations connect the relocation site to the location of
3705 the target symbol, but there are some exceptions below. */
3706 check_segment
[0] = isec_segment
;
3708 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
3709 sec
->output_section
);
3711 check_segment
[1] = -1;
3713 switch ((int) r_type
)
3715 final_link_relocate
:
3716 /* COFF relocs don't use the addend. The addend is used for
3717 R_SH_DIR32 to be compatible with other compilers. */
3718 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3719 contents
, rel
->r_offset
,
3720 relocation
, addend
);
3724 goto final_link_relocate
;
3729 /* If the reloc is against the start of this section, then
3730 the assembler has already taken care of it and the reloc
3731 is here only to assist in relaxing. If the reloc is not
3732 against the start of this section, then it's against an
3733 external symbol and we must deal with it ourselves. */
3734 if (input_section
->output_section
->vma
+ input_section
->output_offset
3737 int disp
= (relocation
3738 - input_section
->output_section
->vma
3739 - input_section
->output_offset
3745 case R_SH_DIR8WPZ
: mask
= 1; break;
3746 case R_SH_DIR8WPL
: mask
= 3; break;
3747 default: mask
= 0; break;
3752 /* xgettext:c-format */
3753 (_("%pB: %#" PRIx64
": fatal: "
3754 "unaligned branch target for relax-support relocation"),
3755 input_section
->owner
,
3756 (uint64_t) rel
->r_offset
);
3757 bfd_set_error (bfd_error_bad_value
);
3761 goto final_link_relocate
;
3767 bfd_set_error (bfd_error_bad_value
);
3775 goto final_link_relocate
;
3782 /* xgettext:c-format */
3783 (_("%pB: %#" PRIx64
": fatal: "
3784 "unaligned %s relocation %#" PRIx64
),
3785 input_section
->owner
, (uint64_t) rel
->r_offset
,
3786 howto
->name
, (uint64_t) relocation
);
3787 bfd_set_error (bfd_error_bad_value
);
3790 goto final_link_relocate
;
3798 /* xgettext:c-format */
3799 (_("%pB: %#" PRIx64
": fatal: "
3800 "unaligned %s relocation %#" PRIx64
""),
3801 input_section
->owner
,
3802 (uint64_t) rel
->r_offset
, howto
->name
,
3803 (uint64_t) relocation
);
3804 bfd_set_error (bfd_error_bad_value
);
3807 goto final_link_relocate
;
3810 if ((signed int)relocation
< -32
3811 || (signed int)relocation
> 32)
3814 /* xgettext:c-format */
3815 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHA relocation %" PRId64
3816 " not in range -32..32"),
3817 input_section
->owner
,
3818 (uint64_t) rel
->r_offset
,
3819 (int64_t) relocation
);
3820 bfd_set_error (bfd_error_bad_value
);
3823 goto final_link_relocate
;
3826 if ((signed int)relocation
< -16
3827 || (signed int)relocation
> 16)
3830 /* xgettext:c-format */
3831 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHL relocation %" PRId64
3832 " not in range -32..32"),
3833 input_section
->owner
,
3834 (uint64_t) rel
->r_offset
,
3835 (int64_t) relocation
);
3836 bfd_set_error (bfd_error_bad_value
);
3839 goto final_link_relocate
;
3843 if (bfd_link_pic (info
)
3845 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3846 && !resolved_to_zero
)
3847 || h
->root
.type
!= bfd_link_hash_undefweak
)
3848 && r_symndx
!= STN_UNDEF
3849 && (input_section
->flags
& SEC_ALLOC
) != 0
3851 && (r_type
== R_SH_DIR32
3852 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3854 Elf_Internal_Rela outrel
;
3856 bool skip
, relocate
;
3858 /* When generating a shared object, these relocations
3859 are copied into the output file to be resolved at run
3864 sreloc
= _bfd_elf_get_dynamic_reloc_section
3865 (input_bfd
, input_section
, /*rela?*/ true);
3874 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3876 if (outrel
.r_offset
== (bfd_vma
) -1)
3878 else if (outrel
.r_offset
== (bfd_vma
) -2)
3879 skip
= true, relocate
= true;
3880 outrel
.r_offset
+= (input_section
->output_section
->vma
3881 + input_section
->output_offset
);
3884 memset (&outrel
, 0, sizeof outrel
);
3885 else if (r_type
== R_SH_REL32
)
3887 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3888 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
3890 = (howto
->partial_inplace
3891 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3896 || ((info
->symbolic
|| h
->dynindx
== -1)
3897 && h
->def_regular
)))
3901 BFD_ASSERT (sec
!= NULL
);
3902 BFD_ASSERT (sec
->output_section
!= NULL
);
3903 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
3904 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
3905 outrel
.r_addend
= relocation
;
3907 += (howto
->partial_inplace
3908 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3910 outrel
.r_addend
-= sec
->output_section
->vma
;
3914 /* h->dynindx may be -1 if this symbol was marked to
3917 || ((info
->symbolic
|| h
->dynindx
== -1)
3920 relocate
= howto
->partial_inplace
;
3921 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3925 BFD_ASSERT (h
->dynindx
!= -1);
3926 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
3928 outrel
.r_addend
= relocation
;
3930 += (howto
->partial_inplace
3931 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3935 loc
= sreloc
->contents
;
3936 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3937 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3939 check_segment
[0] = check_segment
[1] = -1;
3941 /* If this reloc is against an external symbol, we do
3942 not want to fiddle with the addend. Otherwise, we
3943 need to include the symbol value so that it becomes
3944 an addend for the dynamic reloc. */
3948 else if (fdpic_p
&& !bfd_link_pic (info
)
3949 && r_type
== R_SH_DIR32
3950 && (input_section
->flags
& SEC_ALLOC
) != 0)
3956 if (sh_elf_osec_readonly_p (output_bfd
,
3957 input_section
->output_section
))
3960 /* xgettext:c-format */
3961 (_("%pB(%pA+%#" PRIx64
"): "
3962 "cannot emit fixup to `%s' in read-only section"),
3965 (uint64_t) rel
->r_offset
,
3970 offset
= _bfd_elf_section_offset (output_bfd
, info
,
3971 input_section
, rel
->r_offset
);
3972 if (offset
!= (bfd_vma
)-1)
3973 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3974 input_section
->output_section
->vma
3975 + input_section
->output_offset
3978 check_segment
[0] = check_segment
[1] = -1;
3980 /* We don't want warnings for non-NULL tests on undefined weak
3982 else if (r_type
== R_SH_REL32
3984 && h
->root
.type
== bfd_link_hash_undefweak
)
3985 check_segment
[0] = check_segment
[1] = -1;
3986 goto final_link_relocate
;
3989 /* Relocation is to the entry for this symbol in the
3990 procedure linkage table. */
3994 || ! bfd_link_pic (info
)
3997 || h
->plt
.offset
== (bfd_vma
) -1
3998 || h
->got
.offset
!= (bfd_vma
) -1)
4001 /* Relocation is to the entry for this symbol in the global
4002 offset table extension for the procedure linkage table. */
4005 BFD_ASSERT (sgotplt
!= NULL
);
4006 relocation
= (sgotplt
->output_offset
4007 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4011 relocation
-= GOT_BIAS
;
4014 goto final_link_relocate
;
4019 /* Relocation is to the entry for this symbol in the global
4023 BFD_ASSERT (sgot
!= NULL
);
4024 check_segment
[0] = check_segment
[1] = -1;
4030 off
= h
->got
.offset
;
4031 BFD_ASSERT (off
!= (bfd_vma
) -1);
4033 dyn
= htab
->root
.dynamic_sections_created
;
4034 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4035 bfd_link_pic (info
),
4037 || (bfd_link_pic (info
)
4038 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4039 || ((ELF_ST_VISIBILITY (h
->other
)
4040 || resolved_to_zero
)
4041 && h
->root
.type
== bfd_link_hash_undefweak
))
4043 /* This is actually a static link, or it is a
4044 -Bsymbolic link and the symbol is defined
4045 locally, or the symbol was forced to be local
4046 because of a version file. We must initialize
4047 this entry in the global offset table. Since the
4048 offset must always be a multiple of 4, we use the
4049 least significant bit to record whether we have
4050 initialized it already.
4052 When doing a dynamic link, we create a .rela.got
4053 relocation entry to initialize the value. This
4054 is done in the finish_dynamic_symbol routine. */
4059 bfd_put_32 (output_bfd
, relocation
,
4060 sgot
->contents
+ off
);
4063 /* If we initialize the GOT entry here with a valid
4064 symbol address, also add a fixup. */
4065 if (fdpic_p
&& !bfd_link_pic (info
)
4066 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4067 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4068 || h
->root
.type
!= bfd_link_hash_undefweak
))
4069 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4070 sgot
->output_section
->vma
4071 + sgot
->output_offset
4076 relocation
= sh_elf_got_offset (htab
) + off
;
4080 BFD_ASSERT (local_got_offsets
!= NULL
4081 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4083 off
= local_got_offsets
[r_symndx
];
4085 /* The offset must always be a multiple of 4. We use
4086 the least significant bit to record whether we have
4087 already generated the necessary reloc. */
4092 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4094 if (bfd_link_pic (info
))
4096 Elf_Internal_Rela outrel
;
4099 outrel
.r_offset
= (sgot
->output_section
->vma
4100 + sgot
->output_offset
4105 = elf_section_data (sec
->output_section
)->dynindx
;
4106 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4107 outrel
.r_addend
= relocation
;
4108 outrel
.r_addend
-= sec
->output_section
->vma
;
4112 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4113 outrel
.r_addend
= relocation
;
4115 loc
= srelgot
->contents
;
4116 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4117 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4120 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4122 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4123 sgot
->output_section
->vma
4124 + sgot
->output_offset
4127 local_got_offsets
[r_symndx
] |= 1;
4130 relocation
= sh_elf_got_offset (htab
) + off
;
4134 relocation
-= GOT_BIAS
;
4137 if (r_type
== R_SH_GOT20
)
4139 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4140 input_bfd
, input_section
, contents
,
4145 goto final_link_relocate
;
4149 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4150 we place at the start of the .got.plt section. This is the same
4151 as the start of the output .got section, unless there are function
4152 descriptors in front of it. */
4154 BFD_ASSERT (sgotplt
!= NULL
);
4155 check_segment
[0] = got_segment
;
4156 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4157 + htab
->root
.hgot
->root
.u
.def
.value
;
4160 relocation
-= GOT_BIAS
;
4163 addend
= rel
->r_addend
;
4165 if (r_type
== R_SH_GOTOFF20
)
4167 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4168 input_bfd
, input_section
, contents
,
4173 goto final_link_relocate
;
4176 /* Use global offset table as symbol value. */
4178 BFD_ASSERT (sgotplt
!= NULL
);
4179 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4182 relocation
+= GOT_BIAS
;
4185 addend
= rel
->r_addend
;
4187 goto final_link_relocate
;
4190 /* Relocation is to the entry for this symbol in the
4191 procedure linkage table. */
4193 /* Resolve a PLT reloc against a local symbol directly,
4194 without using the procedure linkage table. */
4196 goto final_link_relocate
;
4198 /* We don't want to warn on calls to undefined weak symbols,
4199 as calls to them must be protected by non-NULL tests
4200 anyway, and unprotected calls would invoke undefined
4202 if (h
->root
.type
== bfd_link_hash_undefweak
)
4203 check_segment
[0] = check_segment
[1] = -1;
4205 if (h
->forced_local
)
4206 goto final_link_relocate
;
4208 if (h
->plt
.offset
== (bfd_vma
) -1)
4210 /* We didn't make a PLT entry for this symbol. This
4211 happens when statically linking PIC code, or when
4212 using -Bsymbolic. */
4213 goto final_link_relocate
;
4216 BFD_ASSERT (splt
!= NULL
);
4217 check_segment
[1] = plt_segment
;
4218 relocation
= (splt
->output_section
->vma
4219 + splt
->output_offset
4222 addend
= rel
->r_addend
;
4224 goto final_link_relocate
;
4226 /* Relocation is to the canonical function descriptor for this
4227 symbol, possibly via the GOT. Initialize the GOT
4228 entry and function descriptor if necessary. */
4229 case R_SH_GOTFUNCDESC
:
4230 case R_SH_GOTFUNCDESC20
:
4234 asection
*reloc_section
;
4235 bfd_vma reloc_offset
;
4236 int reloc_type
= R_SH_FUNCDESC
;
4240 check_segment
[0] = check_segment
[1] = -1;
4242 /* FIXME: See what FRV does for global symbols in the
4243 executable, with --export-dynamic. Do they need ld.so
4244 to allocate official descriptors? See what this code
4250 if (r_type
== R_SH_FUNCDESC
)
4252 reloc_section
= input_section
;
4253 reloc_offset
= rel
->r_offset
;
4257 reloc_section
= sgot
;
4260 reloc_offset
= h
->got
.offset
;
4263 BFD_ASSERT (local_got_offsets
!= NULL
);
4264 reloc_offset
= local_got_offsets
[r_symndx
];
4266 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4268 if (reloc_offset
& 1)
4271 goto funcdesc_done_got
;
4275 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4276 && (SYMBOL_CALLS_LOCAL (info
, h
)
4277 || !htab
->root
.dynamic_sections_created
))
4278 /* Undefined weak symbol which will not be dynamically
4279 resolved later; leave it at zero. */
4280 goto funcdesc_leave_zero
;
4281 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4282 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4284 /* If the symbol needs a non-local function descriptor
4285 but binds locally (i.e., its visibility is
4286 protected), emit a dynamic relocation decayed to
4287 section+offset. This is an optimization; the dynamic
4288 linker would resolve our function descriptor request
4289 to our copy of the function anyway. */
4290 dynindx
= elf_section_data (h
->root
.u
.def
.section
4291 ->output_section
)->dynindx
;
4292 relocation
+= h
->root
.u
.def
.section
->output_offset
4293 + h
->root
.u
.def
.value
;
4295 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4297 /* If the symbol is dynamic and there will be dynamic
4298 symbol resolution because we are or are linked with a
4299 shared library, emit a FUNCDESC relocation such that
4300 the dynamic linker will allocate the function
4302 BFD_ASSERT (h
->dynindx
!= -1);
4303 dynindx
= h
->dynindx
;
4309 /* Otherwise, we know we have a private function
4310 descriptor, so reference it directly. */
4311 reloc_type
= R_SH_DIR32
;
4312 dynindx
= elf_section_data (htab
->sfuncdesc
4313 ->output_section
)->dynindx
;
4317 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4318 BFD_ASSERT (offset
!= MINUS_ONE
);
4319 if ((offset
& 1) == 0)
4321 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4324 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4329 union gotref
*local_funcdesc
;
4331 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4332 offset
= local_funcdesc
[r_symndx
].offset
;
4333 BFD_ASSERT (offset
!= MINUS_ONE
);
4334 if ((offset
& 1) == 0)
4336 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4340 local_funcdesc
[r_symndx
].offset
|= 1;
4344 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4347 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
4351 if (sh_elf_osec_readonly_p (output_bfd
,
4352 reloc_section
->output_section
))
4355 /* xgettext:c-format */
4356 (_("%pB(%pA+%#" PRIx64
"): "
4357 "cannot emit fixup to `%s' in read-only section"),
4360 (uint64_t) rel
->r_offset
,
4365 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4366 reloc_section
, reloc_offset
);
4368 if (offset
!= (bfd_vma
)-1)
4369 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4371 + reloc_section
->output_section
->vma
4372 + reloc_section
->output_offset
);
4374 else if ((reloc_section
->output_section
->flags
4375 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
4379 if (sh_elf_osec_readonly_p (output_bfd
,
4380 reloc_section
->output_section
))
4382 info
->callbacks
->warning
4384 _("cannot emit dynamic relocations in read-only section"),
4385 symname
, input_bfd
, reloc_section
, reloc_offset
);
4389 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4390 reloc_section
, reloc_offset
);
4392 if (offset
!= (bfd_vma
)-1)
4393 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
4395 + reloc_section
->output_section
->vma
4396 + reloc_section
->output_offset
,
4397 reloc_type
, dynindx
, relocation
);
4399 if (r_type
== R_SH_FUNCDESC
)
4407 goto funcdesc_leave_zero
;
4411 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
4412 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
4413 funcdesc_leave_zero
:
4414 if (r_type
!= R_SH_FUNCDESC
)
4416 bfd_put_32 (output_bfd
, relocation
,
4417 reloc_section
->contents
+ reloc_offset
);
4421 local_got_offsets
[r_symndx
] |= 1;
4425 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
4427 relocation
-= GOT_BIAS
;
4430 if (r_type
== R_SH_GOTFUNCDESC20
)
4432 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4433 input_bfd
, input_section
, contents
,
4438 goto final_link_relocate
;
4442 case R_SH_GOTOFFFUNCDESC
:
4443 case R_SH_GOTOFFFUNCDESC20
:
4444 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4445 executable and --export-dynamic. If such symbols get
4446 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4450 check_segment
[0] = check_segment
[1] = -1;
4452 addend
= rel
->r_addend
;
4454 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
4455 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
4458 /* xgettext:c-format */
4459 (_("%pB(%pA+%#" PRIx64
"): "
4460 "%s relocation against external symbol \"%s\""),
4461 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
4462 howto
->name
, h
->root
.root
.string
);
4469 /* Otherwise, we know we have a private function
4470 descriptor, so reference it directly. */
4473 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4474 BFD_ASSERT (offset
!= MINUS_ONE
);
4475 if ((offset
& 1) == 0)
4477 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4480 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4485 union gotref
*local_funcdesc
;
4487 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4488 offset
= local_funcdesc
[r_symndx
].offset
;
4489 BFD_ASSERT (offset
!= MINUS_ONE
);
4490 if ((offset
& 1) == 0)
4492 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4496 local_funcdesc
[r_symndx
].offset
|= 1;
4500 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4503 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
4504 + sgotplt
->output_offset
);
4506 relocation
-= GOT_BIAS
;
4509 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
4511 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4512 input_bfd
, input_section
, contents
,
4517 goto final_link_relocate
;
4519 case R_SH_LOOP_START
:
4521 static bfd_vma start
, end
;
4523 start
= (relocation
+ rel
->r_addend
4524 - (sec
->output_section
->vma
+ sec
->output_offset
));
4525 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4526 rel
->r_offset
, sec
, start
, end
);
4530 end
= (relocation
+ rel
->r_addend
4531 - (sec
->output_section
->vma
+ sec
->output_offset
));
4532 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4533 rel
->r_offset
, sec
, start
, end
);
4537 case R_SH_TLS_GD_32
:
4538 case R_SH_TLS_IE_32
:
4540 check_segment
[0] = check_segment
[1] = -1;
4541 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
4542 got_type
= GOT_UNKNOWN
;
4543 if (h
== NULL
&& local_got_offsets
)
4544 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
4547 got_type
= sh_elf_hash_entry (h
)->got_type
;
4548 if (! bfd_link_pic (info
)
4549 && (h
->dynindx
== -1
4551 r_type
= R_SH_TLS_LE_32
;
4554 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
4555 r_type
= R_SH_TLS_IE_32
;
4557 if (r_type
== R_SH_TLS_LE_32
)
4560 unsigned short insn
;
4562 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
4564 /* GD->LE transition:
4565 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4566 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4567 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4569 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4571 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
4573 offset
= rel
->r_offset
;
4577 /* xgettext:c-format */
4578 (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64
),
4579 input_bfd
, input_section
, (uint64_t) offset
);
4583 /* Size of GD instructions is 16 or 18. */
4585 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4586 if ((insn
& 0xff00) == 0xc700)
4588 BFD_ASSERT (offset
>= 2);
4590 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4593 if ((insn
& 0xff00) != 0xd400)
4595 /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */
4596 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd4?\?)"),
4597 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4599 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4601 if ((insn
& 0xff00) != 0xc700)
4603 /* xgettext:c-format */
4604 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xc7?\?)"),
4605 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4607 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4608 if ((insn
& 0xff00) != 0xd100)
4610 /* xgettext:c-format */
4611 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd1?\?)"),
4612 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4614 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4617 /* xgettext:c-format */
4618 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x310c)"),
4619 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4621 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4624 /* xgettext:c-format */
4625 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x410b)"),
4626 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4628 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4631 /* xgettext:c-format */
4632 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x34cc)"),
4633 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4635 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
4636 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
4637 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4638 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4639 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4645 /* IE->LE transition:
4662 offset
= rel
->r_offset
;
4666 /* xgettext:c-format */
4667 (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64
),
4668 input_bfd
, input_section
, (uint64_t) offset
);
4672 /* Size of IE instructions is 10 or 12. */
4674 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4675 if ((insn
& 0xf0ff) == 0x0012)
4677 BFD_ASSERT (offset
>= 2);
4679 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4682 if ((insn
& 0xff00) != 0xd000)
4684 /* xgettext:c-format */
4685 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
4686 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4688 target
= insn
& 0x00ff;
4690 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4691 if ((insn
& 0xf0ff) != 0x0012)
4693 /* xgettext:c-format */
4694 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?12: stc)"),
4695 input_bfd
, input_section
, (uint64_t) (offset
+ 2), (int) insn
);
4697 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4698 if ((insn
& 0xf0ff) != 0x00ce)
4700 /* xgettext:c-format */
4701 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
4702 input_bfd
, input_section
, (uint64_t) (offset
+ 4), (int) insn
);
4704 insn
= 0xd000 | (insn
& 0x0f00) | target
;
4705 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
4706 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4709 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4710 contents
+ rel
->r_offset
);
4714 if (sgot
== NULL
|| sgotplt
== NULL
)
4718 off
= h
->got
.offset
;
4721 if (local_got_offsets
== NULL
)
4724 off
= local_got_offsets
[r_symndx
];
4727 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
4728 if (r_type
== R_SH_TLS_IE_32
4729 && ! htab
->root
.dynamic_sections_created
)
4732 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4733 sgot
->contents
+ off
);
4734 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4735 contents
+ rel
->r_offset
);
4743 Elf_Internal_Rela outrel
;
4747 outrel
.r_offset
= (sgot
->output_section
->vma
4748 + sgot
->output_offset
+ off
);
4750 if (h
== NULL
|| h
->dynindx
== -1)
4755 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
4757 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
4758 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4760 outrel
.r_addend
= 0;
4761 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4762 loc
= srelgot
->contents
;
4763 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4764 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4766 if (r_type
== R_SH_TLS_GD_32
)
4770 bfd_put_32 (output_bfd
,
4771 relocation
- dtpoff_base (info
),
4772 sgot
->contents
+ off
+ 4);
4776 outrel
.r_info
= ELF32_R_INFO (indx
,
4778 outrel
.r_offset
+= 4;
4779 outrel
.r_addend
= 0;
4780 srelgot
->reloc_count
++;
4781 loc
+= sizeof (Elf32_External_Rela
);
4782 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4789 local_got_offsets
[r_symndx
] |= 1;
4792 if (off
>= (bfd_vma
) -2)
4795 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
4796 relocation
= sh_elf_got_offset (htab
) + off
;
4800 unsigned short insn
;
4802 /* GD->IE transition:
4803 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4804 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4805 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4807 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4808 nop; nop; bra 3f; nop; .align 2;
4809 1: .long x@TPOFF; 2:...; 3:. */
4811 offset
= rel
->r_offset
;
4815 /* xgettext:c-format */
4816 (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64
),
4817 input_bfd
, input_section
, (uint64_t) offset
);
4821 /* Size of GD instructions is 16 or 18. */
4823 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4824 if ((insn
& 0xff00) == 0xc700)
4826 BFD_ASSERT (offset
>= 2);
4828 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4831 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4833 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
4834 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
4836 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4837 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4838 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4839 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4840 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4841 BFD_ASSERT (insn
== 0x310c);
4842 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4843 BFD_ASSERT (insn
== 0x410b);
4844 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4845 BFD_ASSERT (insn
== 0x34cc);
4847 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
4848 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
4849 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
4850 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4851 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4853 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4854 contents
+ rel
->r_offset
);
4859 addend
= rel
->r_addend
;
4861 goto final_link_relocate
;
4863 case R_SH_TLS_LD_32
:
4865 check_segment
[0] = check_segment
[1] = -1;
4866 if (! bfd_link_pic (info
))
4869 unsigned short insn
;
4871 /* LD->LE transition:
4872 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4873 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4874 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4876 stc gbr,r0; nop; nop; nop;
4877 nop; nop; bra 3f; ...; 3:. */
4879 offset
= rel
->r_offset
;
4883 /* xgettext:c-format */
4884 (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64
),
4885 input_bfd
, input_section
, (uint64_t) offset
);
4889 /* Size of LD instructions is 16 or 18. */
4891 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4892 if ((insn
& 0xff00) == 0xc700)
4894 BFD_ASSERT (offset
>= 2);
4896 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4899 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4900 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4901 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4902 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4903 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4904 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4905 BFD_ASSERT (insn
== 0x310c);
4906 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4907 BFD_ASSERT (insn
== 0x410b);
4908 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4909 BFD_ASSERT (insn
== 0x34cc);
4911 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
4912 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
4913 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4914 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4915 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4916 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4921 if (sgot
== NULL
|| sgotplt
== NULL
)
4924 off
= htab
->tls_ldm_got
.offset
;
4929 Elf_Internal_Rela outrel
;
4932 outrel
.r_offset
= (sgot
->output_section
->vma
4933 + sgot
->output_offset
+ off
);
4934 outrel
.r_addend
= 0;
4935 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
4936 loc
= srelgot
->contents
;
4937 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4938 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4939 htab
->tls_ldm_got
.offset
|= 1;
4942 relocation
= sh_elf_got_offset (htab
) + off
;
4943 addend
= rel
->r_addend
;
4945 goto final_link_relocate
;
4947 case R_SH_TLS_LDO_32
:
4948 check_segment
[0] = check_segment
[1] = -1;
4949 if (! bfd_link_pic (info
))
4950 relocation
= tpoff (info
, relocation
);
4952 relocation
-= dtpoff_base (info
);
4954 addend
= rel
->r_addend
;
4955 goto final_link_relocate
;
4957 case R_SH_TLS_LE_32
:
4960 Elf_Internal_Rela outrel
;
4963 check_segment
[0] = check_segment
[1] = -1;
4965 if (!bfd_link_dll (info
))
4967 relocation
= tpoff (info
, relocation
);
4968 addend
= rel
->r_addend
;
4969 goto final_link_relocate
;
4974 sreloc
= _bfd_elf_get_dynamic_reloc_section
4975 (input_bfd
, input_section
, /*rela?*/ true);
4980 if (h
== NULL
|| h
->dynindx
== -1)
4985 outrel
.r_offset
= (input_section
->output_section
->vma
4986 + input_section
->output_offset
4988 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
4990 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4992 outrel
.r_addend
= 0;
4994 loc
= sreloc
->contents
;
4995 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4996 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5002 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5003 && check_segment
[0] != check_segment
[1])
5005 /* We don't want duplicate errors for undefined symbols. */
5006 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5008 if (bfd_link_pic (info
))
5010 info
->callbacks
->einfo
5011 /* xgettext:c-format */
5012 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5013 input_bfd
, input_section
, rel
->r_offset
, symname
);
5017 info
->callbacks
->einfo
5018 /* xgettext:c-format */
5019 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5020 input_bfd
, input_section
, rel
->r_offset
, symname
);
5023 elf_elfheader (output_bfd
)->e_flags
|= EF_SH_PIC
;
5026 if (r
!= bfd_reloc_ok
)
5031 case bfd_reloc_outofrange
:
5033 case bfd_reloc_overflow
:
5041 name
= (bfd_elf_string_from_elf_section
5042 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5046 name
= bfd_section_name (sec
);
5048 (*info
->callbacks
->reloc_overflow
)
5049 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5050 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5060 /* This is a version of bfd_generic_get_relocated_section_contents
5061 which uses sh_elf_relocate_section. */
5064 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5065 struct bfd_link_info
*link_info
,
5066 struct bfd_link_order
*link_order
,
5071 Elf_Internal_Shdr
*symtab_hdr
;
5072 asection
*input_section
= link_order
->u
.indirect
.section
;
5073 bfd
*input_bfd
= input_section
->owner
;
5074 asection
**sections
= NULL
;
5075 Elf_Internal_Rela
*internal_relocs
= NULL
;
5076 Elf_Internal_Sym
*isymbuf
= NULL
;
5078 /* We only need to handle the case of relaxing, or of having a
5079 particular set of section contents, specially. */
5081 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5082 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5087 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5089 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5090 (size_t) input_section
->size
);
5092 if ((input_section
->flags
& SEC_RELOC
) != 0
5093 && input_section
->reloc_count
> 0)
5096 Elf_Internal_Sym
*isym
, *isymend
;
5099 internal_relocs
= (_bfd_elf_link_read_relocs
5100 (input_bfd
, input_section
, NULL
,
5101 (Elf_Internal_Rela
*) NULL
, false));
5102 if (internal_relocs
== NULL
)
5105 if (symtab_hdr
->sh_info
!= 0)
5107 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5108 if (isymbuf
== NULL
)
5109 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5110 symtab_hdr
->sh_info
, 0,
5112 if (isymbuf
== NULL
)
5116 amt
= symtab_hdr
->sh_info
;
5117 amt
*= sizeof (asection
*);
5118 sections
= (asection
**) bfd_malloc (amt
);
5119 if (sections
== NULL
&& amt
!= 0)
5122 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5123 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5127 if (isym
->st_shndx
== SHN_UNDEF
)
5128 isec
= bfd_und_section_ptr
;
5129 else if (isym
->st_shndx
== SHN_ABS
)
5130 isec
= bfd_abs_section_ptr
;
5131 else if (isym
->st_shndx
== SHN_COMMON
)
5132 isec
= bfd_com_section_ptr
;
5134 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5139 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5140 input_section
, data
, internal_relocs
,
5145 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5147 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5148 free (internal_relocs
);
5155 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5157 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5158 free (internal_relocs
);
5162 /* Return the base VMA address which should be subtracted from real addresses
5163 when resolving @dtpoff relocation.
5164 This is PT_TLS segment p_vaddr. */
5167 dtpoff_base (struct bfd_link_info
*info
)
5169 /* If tls_sec is NULL, we should have signalled an error already. */
5170 if (elf_hash_table (info
)->tls_sec
== NULL
)
5172 return elf_hash_table (info
)->tls_sec
->vma
;
5175 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5178 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5180 /* If tls_sec is NULL, we should have signalled an error already. */
5181 if (elf_hash_table (info
)->tls_sec
== NULL
)
5183 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5184 structure which has 2 pointer fields. */
5185 return (address
- elf_hash_table (info
)->tls_sec
->vma
5186 + align_power ((bfd_vma
) 8,
5187 elf_hash_table (info
)->tls_sec
->alignment_power
));
5191 sh_elf_gc_mark_hook (asection
*sec
,
5192 struct bfd_link_info
*info
,
5193 Elf_Internal_Rela
*rel
,
5194 struct elf_link_hash_entry
*h
,
5195 Elf_Internal_Sym
*sym
)
5198 switch (ELF32_R_TYPE (rel
->r_info
))
5200 case R_SH_GNU_VTINHERIT
:
5201 case R_SH_GNU_VTENTRY
:
5205 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5208 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5211 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
5212 struct elf_link_hash_entry
*dir
,
5213 struct elf_link_hash_entry
*ind
)
5215 struct elf_sh_link_hash_entry
*edir
, *eind
;
5217 edir
= (struct elf_sh_link_hash_entry
*) dir
;
5218 eind
= (struct elf_sh_link_hash_entry
*) ind
;
5220 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
5221 eind
->gotplt_refcount
= 0;
5222 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
5223 eind
->funcdesc
.refcount
= 0;
5224 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
5225 eind
->abs_funcdesc_refcount
= 0;
5227 if (ind
->root
.type
== bfd_link_hash_indirect
5228 && dir
->got
.refcount
<= 0)
5230 edir
->got_type
= eind
->got_type
;
5231 eind
->got_type
= GOT_UNKNOWN
;
5234 if (ind
->root
.type
!= bfd_link_hash_indirect
5235 && dir
->dynamic_adjusted
)
5237 /* If called to transfer flags for a weakdef during processing
5238 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5239 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5240 if (dir
->versioned
!= versioned_hidden
)
5241 dir
->ref_dynamic
|= ind
->ref_dynamic
;
5242 dir
->ref_regular
|= ind
->ref_regular
;
5243 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
5244 dir
->needs_plt
|= ind
->needs_plt
;
5247 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
5251 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
5254 if (bfd_link_pic (info
))
5259 case R_SH_TLS_GD_32
:
5260 case R_SH_TLS_IE_32
:
5262 return R_SH_TLS_LE_32
;
5263 return R_SH_TLS_IE_32
;
5264 case R_SH_TLS_LD_32
:
5265 return R_SH_TLS_LE_32
;
5271 /* Look through the relocs for a section during the first phase.
5272 Since we don't do .gots or .plts, we just need to consider the
5273 virtual table relocs for gc. */
5276 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
5277 const Elf_Internal_Rela
*relocs
)
5279 Elf_Internal_Shdr
*symtab_hdr
;
5280 struct elf_link_hash_entry
**sym_hashes
;
5281 struct elf_sh_link_hash_table
*htab
;
5282 const Elf_Internal_Rela
*rel
;
5283 const Elf_Internal_Rela
*rel_end
;
5285 unsigned int r_type
;
5286 enum got_type got_type
, old_got_type
;
5290 if (bfd_link_relocatable (info
))
5293 BFD_ASSERT (is_sh_elf (abfd
));
5295 symtab_hdr
= &elf_symtab_hdr (abfd
);
5296 sym_hashes
= elf_sym_hashes (abfd
);
5298 htab
= sh_elf_hash_table (info
);
5302 rel_end
= relocs
+ sec
->reloc_count
;
5303 for (rel
= relocs
; rel
< rel_end
; rel
++)
5305 struct elf_link_hash_entry
*h
;
5306 unsigned long r_symndx
;
5308 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5309 r_type
= ELF32_R_TYPE (rel
->r_info
);
5311 if (r_symndx
< symtab_hdr
->sh_info
)
5315 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5316 while (h
->root
.type
== bfd_link_hash_indirect
5317 || h
->root
.type
== bfd_link_hash_warning
)
5318 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5321 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5322 if (! bfd_link_pic (info
)
5323 && r_type
== R_SH_TLS_IE_32
5325 && h
->root
.type
!= bfd_link_hash_undefined
5326 && h
->root
.type
!= bfd_link_hash_undefweak
5327 && (h
->dynindx
== -1
5329 r_type
= R_SH_TLS_LE_32
;
5334 case R_SH_GOTOFFFUNCDESC
:
5335 case R_SH_GOTOFFFUNCDESC20
:
5337 case R_SH_GOTFUNCDESC
:
5338 case R_SH_GOTFUNCDESC20
:
5341 if (h
->dynindx
== -1)
5342 switch (ELF_ST_VISIBILITY (h
->other
))
5348 bfd_elf_link_record_dynamic_symbol (info
, h
);
5355 /* Some relocs require a global offset table. */
5356 if (htab
->root
.sgot
== NULL
)
5361 /* This may require an rofixup. */
5371 case R_SH_GOTFUNCDESC
:
5372 case R_SH_GOTFUNCDESC20
:
5373 case R_SH_GOTOFFFUNCDESC
:
5374 case R_SH_GOTOFFFUNCDESC20
:
5376 case R_SH_TLS_GD_32
:
5377 case R_SH_TLS_LD_32
:
5378 case R_SH_TLS_IE_32
:
5379 if (htab
->root
.dynobj
== NULL
)
5380 htab
->root
.dynobj
= abfd
;
5381 if (!create_got_section (htab
->root
.dynobj
, info
))
5392 /* This relocation describes the C++ object vtable hierarchy.
5393 Reconstruct it for later use during GC. */
5394 case R_SH_GNU_VTINHERIT
:
5395 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5399 /* This relocation describes which C++ vtable entries are actually
5400 used. Record for later use during GC. */
5401 case R_SH_GNU_VTENTRY
:
5402 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
5406 case R_SH_TLS_IE_32
:
5407 if (bfd_link_pic (info
))
5408 info
->flags
|= DF_STATIC_TLS
;
5412 case R_SH_TLS_GD_32
:
5415 case R_SH_GOTFUNCDESC
:
5416 case R_SH_GOTFUNCDESC20
:
5420 got_type
= GOT_NORMAL
;
5422 case R_SH_TLS_GD_32
:
5423 got_type
= GOT_TLS_GD
;
5425 case R_SH_TLS_IE_32
:
5426 got_type
= GOT_TLS_IE
;
5428 case R_SH_GOTFUNCDESC
:
5429 case R_SH_GOTFUNCDESC20
:
5430 got_type
= GOT_FUNCDESC
;
5436 h
->got
.refcount
+= 1;
5437 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5441 bfd_signed_vma
*local_got_refcounts
;
5443 /* This is a global offset table entry for a local
5445 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5446 if (local_got_refcounts
== NULL
)
5450 size
= symtab_hdr
->sh_info
;
5451 size
*= sizeof (bfd_signed_vma
);
5452 size
+= symtab_hdr
->sh_info
;
5453 local_got_refcounts
= ((bfd_signed_vma
*)
5454 bfd_zalloc (abfd
, size
));
5455 if (local_got_refcounts
== NULL
)
5457 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
5458 sh_elf_local_got_type (abfd
)
5459 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
5461 local_got_refcounts
[r_symndx
] += 1;
5462 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
5465 /* If a TLS symbol is accessed using IE at least once,
5466 there is no point to use dynamic model for it. */
5467 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
5468 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
5470 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
5471 got_type
= GOT_TLS_IE
;
5474 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
5475 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
5477 /* xgettext:c-format */
5478 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5479 abfd
, h
->root
.root
.string
);
5480 else if (old_got_type
== GOT_FUNCDESC
5481 || got_type
== GOT_FUNCDESC
)
5483 /* xgettext:c-format */
5484 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5485 abfd
, h
->root
.root
.string
);
5488 /* xgettext:c-format */
5489 (_("%pB: `%s' accessed both as normal and thread local symbol"),
5490 abfd
, h
->root
.root
.string
);
5495 if (old_got_type
!= got_type
)
5498 sh_elf_hash_entry (h
)->got_type
= got_type
;
5500 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
5505 case R_SH_TLS_LD_32
:
5506 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
5510 case R_SH_GOTOFFFUNCDESC
:
5511 case R_SH_GOTOFFFUNCDESC20
:
5515 (_("%pB: Function descriptor relocation with non-zero addend"),
5522 union gotref
*local_funcdesc
;
5524 /* We need a function descriptor for a local symbol. */
5525 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5526 if (local_funcdesc
== NULL
)
5530 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
5531 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
5532 if (local_funcdesc
== NULL
)
5534 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
5536 local_funcdesc
[r_symndx
].refcount
+= 1;
5538 if (r_type
== R_SH_FUNCDESC
)
5540 if (!bfd_link_pic (info
))
5541 htab
->srofixup
->size
+= 4;
5543 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5548 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
5549 if (r_type
== R_SH_FUNCDESC
)
5550 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
5552 /* If there is a function descriptor reference, then
5553 there should not be any non-FDPIC references. */
5554 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5555 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
5557 if (old_got_type
== GOT_NORMAL
)
5559 /* xgettext:c-format */
5560 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5561 abfd
, h
->root
.root
.string
);
5564 /* xgettext:c-format */
5565 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5566 abfd
, h
->root
.root
.string
);
5572 /* If this is a local symbol, we resolve it directly without
5573 creating a procedure linkage table entry. */
5577 || ! bfd_link_pic (info
)
5579 || h
->dynindx
== -1)
5583 h
->plt
.refcount
+= 1;
5584 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
5589 /* This symbol requires a procedure linkage table entry. We
5590 actually build the entry in adjust_dynamic_symbol,
5591 because this might be a case of linking PIC code which is
5592 never referenced by a dynamic object, in which case we
5593 don't need to generate a procedure linkage table entry
5596 /* If this is a local symbol, we resolve it directly without
5597 creating a procedure linkage table entry. */
5601 if (h
->forced_local
)
5605 h
->plt
.refcount
+= 1;
5610 if (h
!= NULL
&& ! bfd_link_pic (info
))
5613 h
->plt
.refcount
+= 1;
5616 /* If we are creating a shared library, and this is a reloc
5617 against a global symbol, or a non PC relative reloc
5618 against a local symbol, then we need to copy the reloc
5619 into the shared library. However, if we are linking with
5620 -Bsymbolic, we do not need to copy a reloc against a
5621 global symbol which is defined in an object we are
5622 including in the link (i.e., DEF_REGULAR is set). At
5623 this point we have not seen all the input files, so it is
5624 possible that DEF_REGULAR is not set now but will be set
5625 later (it is never cleared). We account for that
5626 possibility below by storing information in the
5627 dyn_relocs field of the hash table entry. A similar
5628 situation occurs when creating shared libraries and symbol
5629 visibility changes render the symbol local.
5631 If on the other hand, we are creating an executable, we
5632 may need to keep relocations for symbols satisfied by a
5633 dynamic library if we manage to avoid copy relocs for the
5635 if ((bfd_link_pic (info
)
5636 && (sec
->flags
& SEC_ALLOC
) != 0
5637 && (r_type
!= R_SH_REL32
5639 && (! info
->symbolic
5640 || h
->root
.type
== bfd_link_hash_defweak
5641 || !h
->def_regular
))))
5642 || (! bfd_link_pic (info
)
5643 && (sec
->flags
& SEC_ALLOC
) != 0
5645 && (h
->root
.type
== bfd_link_hash_defweak
5646 || !h
->def_regular
)))
5648 struct elf_dyn_relocs
*p
;
5649 struct elf_dyn_relocs
**head
;
5651 if (htab
->root
.dynobj
== NULL
)
5652 htab
->root
.dynobj
= abfd
;
5654 /* When creating a shared object, we must copy these
5655 reloc types into the output file. We create a reloc
5656 section in dynobj and make room for this reloc. */
5659 sreloc
= _bfd_elf_make_dynamic_reloc_section
5660 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ true);
5666 /* If this is a global symbol, we count the number of
5667 relocations we need for this symbol. */
5669 head
= &h
->dyn_relocs
;
5672 /* Track dynamic relocs needed for local syms too. */
5675 Elf_Internal_Sym
*isym
;
5677 isym
= bfd_sym_from_r_symndx (&htab
->root
.sym_cache
,
5682 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5686 vpp
= &elf_section_data (s
)->local_dynrel
;
5687 head
= (struct elf_dyn_relocs
**) vpp
;
5691 if (p
== NULL
|| p
->sec
!= sec
)
5693 size_t amt
= sizeof (*p
);
5694 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
5705 if (r_type
== R_SH_REL32
)
5709 /* Allocate the fixup regardless of whether we need a relocation.
5710 If we end up generating the relocation, we'll unallocate the
5712 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
5713 && r_type
== R_SH_DIR32
5714 && (sec
->flags
& SEC_ALLOC
) != 0)
5715 htab
->srofixup
->size
+= 4;
5718 case R_SH_TLS_LE_32
:
5719 if (bfd_link_dll (info
))
5722 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5729 case R_SH_TLS_LDO_32
:
5730 /* Nothing to do. */
5741 #ifndef sh_elf_set_mach_from_flags
5742 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
5745 sh_elf_set_mach_from_flags (bfd
*abfd
)
5747 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
5749 if (flags
>= ARRAY_SIZE (sh_ef_bfd_table
))
5752 if (sh_ef_bfd_table
[flags
] == 0)
5755 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
5761 /* Reverse table lookup for sh_ef_bfd_table[].
5762 Given a bfd MACH value from archures.c
5763 return the equivalent ELF flags from the table.
5764 Return -1 if no match is found. */
5767 sh_elf_get_flags_from_mach (unsigned long mach
)
5769 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
5772 if (sh_ef_bfd_table
[i
] == mach
)
5775 /* shouldn't get here */
5780 #endif /* not sh_elf_set_mach_from_flags */
5782 #ifndef sh_elf_copy_private_data
5783 /* Copy backend specific data from one object module to another */
5786 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
5788 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5791 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
5794 return sh_elf_set_mach_from_flags (obfd
);
5796 #endif /* not sh_elf_copy_private_data */
5798 #ifndef sh_elf_merge_private_data
5800 /* This function returns the ELF architecture number that
5801 corresponds to the given arch_sh* flags. */
5804 sh_find_elf_flags (unsigned int arch_set
)
5806 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5807 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
5809 return sh_elf_get_flags_from_mach (bfd_mach
);
5812 /* Merge the architecture type of two BFD files, such that the
5813 resultant architecture supports all the features required
5814 by the two input BFDs.
5815 If the input BFDs are multually incompatible - i.e. one uses
5816 DSP while the other uses FPU - or there is no known architecture
5817 that fits the requirements then an error is emitted. */
5820 sh_merge_bfd_arch (bfd
*ibfd
, struct bfd_link_info
*info
)
5822 bfd
*obfd
= info
->output_bfd
;
5823 unsigned int old_arch
, new_arch
, merged_arch
;
5825 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
5828 old_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd
));
5829 new_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd
));
5831 merged_arch
= SH_MERGE_ARCH_SET (old_arch
, new_arch
);
5833 if (!SH_VALID_CO_ARCH_SET (merged_arch
))
5836 /* xgettext:c-format */
5837 (_("%pB: uses %s instructions while previous modules "
5838 "use %s instructions"),
5840 SH_ARCH_SET_HAS_DSP (new_arch
) ? "dsp" : "floating point",
5841 SH_ARCH_SET_HAS_DSP (new_arch
) ? "floating point" : "dsp");
5842 bfd_set_error (bfd_error_bad_value
);
5845 else if (!SH_VALID_ARCH_SET (merged_arch
))
5848 /* xgettext:c-format */
5849 (_("internal error: merge of architecture '%s' with "
5850 "architecture '%s' produced unknown architecture"),
5851 bfd_printable_name (obfd
),
5852 bfd_printable_name (ibfd
));
5853 bfd_set_error (bfd_error_bad_value
);
5857 bfd_default_set_arch_mach (obfd
, bfd_arch_sh
,
5858 sh_get_bfd_mach_from_arch_set (merged_arch
));
5863 /* This routine initialises the elf flags when required and
5864 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
5867 sh_elf_merge_private_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5869 bfd
*obfd
= info
->output_bfd
;
5871 /* FIXME: What should be checked when linking shared libraries? */
5872 if ((ibfd
->flags
& DYNAMIC
) != 0)
5875 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5878 if (! elf_flags_init (obfd
))
5880 /* This happens when ld starts out with a 'blank' output file. */
5881 elf_flags_init (obfd
) = true;
5882 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
5883 sh_elf_set_mach_from_flags (obfd
);
5884 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
5885 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_PIC
;
5888 if (! sh_merge_bfd_arch (ibfd
, info
))
5890 _bfd_error_handler (_("%pB: uses instructions which are incompatible "
5891 "with instructions used in previous modules"),
5893 bfd_set_error (bfd_error_bad_value
);
5897 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
5898 elf_elfheader (obfd
)->e_flags
|=
5899 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
5901 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
5903 _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
5905 bfd_set_error (bfd_error_bad_value
);
5911 #endif /* not sh_elf_merge_private_data */
5913 /* Override the generic function because we need to store sh_elf_obj_tdata
5914 as the specific tdata. We set also the machine architecture from flags
5918 sh_elf_object_p (bfd
*abfd
)
5920 if (! sh_elf_set_mach_from_flags (abfd
))
5923 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
5924 == fdpic_object_p (abfd
));
5927 /* Finish up dynamic symbol handling. We set the contents of various
5928 dynamic sections here. */
5931 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
5932 struct elf_link_hash_entry
*h
,
5933 Elf_Internal_Sym
*sym
)
5935 struct elf_sh_link_hash_table
*htab
;
5937 htab
= sh_elf_hash_table (info
);
5941 if (h
->plt
.offset
!= (bfd_vma
) -1)
5949 Elf_Internal_Rela rel
;
5951 const struct elf_sh_plt_info
*plt_info
;
5953 /* This symbol has an entry in the procedure linkage table. Set
5956 BFD_ASSERT (h
->dynindx
!= -1);
5958 splt
= htab
->root
.splt
;
5959 sgotplt
= htab
->root
.sgotplt
;
5960 srelplt
= htab
->root
.srelplt
;
5961 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
5963 /* Get the index in the procedure linkage table which
5964 corresponds to this symbol. This is the index of this symbol
5965 in all the symbols for which we are making plt entries. The
5966 first entry in the procedure linkage table is reserved. */
5967 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
5969 plt_info
= htab
->plt_info
;
5970 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
5971 plt_info
= plt_info
->short_plt
;
5973 /* Get the offset into the .got table of the entry that
5974 corresponds to this function. */
5976 /* The offset must be relative to the GOT symbol, twelve bytes
5977 before the end of .got.plt. Each descriptor is eight
5979 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
5981 /* Each .got entry is 4 bytes. The first three are
5983 got_offset
= (plt_index
+ 3) * 4;
5986 if (bfd_link_pic (info
))
5987 got_offset
-= GOT_BIAS
;
5990 /* Fill in the entry in the procedure linkage table. */
5991 memcpy (splt
->contents
+ h
->plt
.offset
,
5992 plt_info
->symbol_entry
,
5993 plt_info
->symbol_entry_size
);
5995 if (bfd_link_pic (info
) || htab
->fdpic_p
)
5997 if (plt_info
->symbol_fields
.got20
)
5999 bfd_reloc_status_type r
;
6000 r
= install_movi20_field (output_bfd
, got_offset
,
6001 splt
->owner
, splt
, splt
->contents
,
6003 + plt_info
->symbol_fields
.got_entry
);
6004 BFD_ASSERT (r
== bfd_reloc_ok
);
6007 install_plt_field (output_bfd
, false, got_offset
,
6010 + plt_info
->symbol_fields
.got_entry
));
6014 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6016 install_plt_field (output_bfd
, false,
6017 (sgotplt
->output_section
->vma
6018 + sgotplt
->output_offset
6022 + plt_info
->symbol_fields
.got_entry
));
6023 if (htab
->root
.target_os
== is_vxworks
)
6025 unsigned int reachable_plts
, plts_per_4k
;
6028 /* Divide the PLT into groups. The first group contains
6029 REACHABLE_PLTS entries and the other groups contain
6030 PLTS_PER_4K entries. Entries in the first group can
6031 branch directly to .plt; those in later groups branch
6032 to the last element of the previous group. */
6033 /* ??? It would be better to create multiple copies of
6034 the common resolver stub. */
6035 reachable_plts
= ((4096
6036 - plt_info
->plt0_entry_size
6037 - (plt_info
->symbol_fields
.plt
+ 4))
6038 / plt_info
->symbol_entry_size
) + 1;
6039 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6040 if (plt_index
< reachable_plts
)
6041 distance
= -(h
->plt
.offset
6042 + plt_info
->symbol_fields
.plt
);
6044 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6045 * plt_info
->symbol_entry_size
);
6047 /* Install the 'bra' with this offset. */
6048 bfd_put_16 (output_bfd
,
6049 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6052 + plt_info
->symbol_fields
.plt
));
6055 install_plt_field (output_bfd
, true,
6056 splt
->output_section
->vma
+ splt
->output_offset
,
6059 + plt_info
->symbol_fields
.plt
));
6062 /* Make got_offset relative to the start of .got.plt. */
6064 if (bfd_link_pic (info
))
6065 got_offset
+= GOT_BIAS
;
6068 got_offset
= plt_index
* 8;
6070 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6071 install_plt_field (output_bfd
, false,
6072 plt_index
* sizeof (Elf32_External_Rela
),
6075 + plt_info
->symbol_fields
.reloc_offset
));
6077 /* Fill in the entry in the global offset table. */
6078 bfd_put_32 (output_bfd
,
6079 (splt
->output_section
->vma
6080 + splt
->output_offset
6082 + plt_info
->symbol_resolve_offset
),
6083 sgotplt
->contents
+ got_offset
);
6085 bfd_put_32 (output_bfd
,
6086 sh_elf_osec_to_segment (output_bfd
, splt
->output_section
),
6087 sgotplt
->contents
+ got_offset
+ 4);
6089 /* Fill in the entry in the .rela.plt section. */
6090 rel
.r_offset
= (sgotplt
->output_section
->vma
6091 + sgotplt
->output_offset
6094 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
6096 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
6099 rel
.r_addend
= GOT_BIAS
;
6101 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
6102 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6104 if (htab
->root
.target_os
== is_vxworks
&& !bfd_link_pic (info
))
6106 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6107 Begin by pointing LOC to the first such relocation. */
6108 loc
= (htab
->srelplt2
->contents
6109 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
6111 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6112 for the PLT entry's pointer to the .got.plt entry. */
6113 rel
.r_offset
= (splt
->output_section
->vma
6114 + splt
->output_offset
6116 + plt_info
->symbol_fields
.got_entry
);
6117 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6118 rel
.r_addend
= got_offset
;
6119 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6120 loc
+= sizeof (Elf32_External_Rela
);
6122 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6123 the .got.plt entry, which initially points to .plt. */
6124 rel
.r_offset
= (sgotplt
->output_section
->vma
6125 + sgotplt
->output_offset
6127 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
6129 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6132 if (!h
->def_regular
)
6134 /* Mark the symbol as undefined, rather than as defined in
6135 the .plt section. Leave the value alone. */
6136 sym
->st_shndx
= SHN_UNDEF
;
6140 if (h
->got
.offset
!= (bfd_vma
) -1
6141 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
6142 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
6143 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
6147 Elf_Internal_Rela rel
;
6150 /* This symbol has an entry in the global offset table. Set it
6153 sgot
= htab
->root
.sgot
;
6154 srelgot
= htab
->root
.srelgot
;
6155 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
6157 rel
.r_offset
= (sgot
->output_section
->vma
6158 + sgot
->output_offset
6159 + (h
->got
.offset
&~ (bfd_vma
) 1));
6161 /* If this is a static link, or it is a -Bsymbolic link and the
6162 symbol is defined locally or was forced to be local because
6163 of a version file, we just want to emit a RELATIVE reloc.
6164 The entry in the global offset table will already have been
6165 initialized in the relocate_section function. */
6166 if (bfd_link_pic (info
)
6167 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6171 asection
*sec
= h
->root
.u
.def
.section
;
6173 = elf_section_data (sec
->output_section
)->dynindx
;
6175 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
6176 rel
.r_addend
= (h
->root
.u
.def
.value
6177 + h
->root
.u
.def
.section
->output_offset
);
6181 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
6182 rel
.r_addend
= (h
->root
.u
.def
.value
6183 + h
->root
.u
.def
.section
->output_section
->vma
6184 + h
->root
.u
.def
.section
->output_offset
);
6189 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
6190 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
6194 loc
= srelgot
->contents
;
6195 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6196 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6202 Elf_Internal_Rela rel
;
6205 /* This symbol needs a copy reloc. Set it up. */
6207 BFD_ASSERT (h
->dynindx
!= -1
6208 && (h
->root
.type
== bfd_link_hash_defined
6209 || h
->root
.type
== bfd_link_hash_defweak
));
6211 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
6212 BFD_ASSERT (s
!= NULL
);
6214 rel
.r_offset
= (h
->root
.u
.def
.value
6215 + h
->root
.u
.def
.section
->output_section
->vma
6216 + h
->root
.u
.def
.section
->output_offset
);
6217 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
6219 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6220 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6223 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
6224 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6226 if (h
== htab
->root
.hdynamic
6227 || (htab
->root
.target_os
!= is_vxworks
&& h
== htab
->root
.hgot
))
6228 sym
->st_shndx
= SHN_ABS
;
6233 /* Finish up the dynamic sections. */
6236 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6238 struct elf_sh_link_hash_table
*htab
;
6242 htab
= sh_elf_hash_table (info
);
6246 sgotplt
= htab
->root
.sgotplt
;
6247 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
6249 if (htab
->root
.dynamic_sections_created
)
6252 Elf32_External_Dyn
*dyncon
, *dynconend
;
6254 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
6256 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
6257 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
6258 for (; dyncon
< dynconend
; dyncon
++)
6260 Elf_Internal_Dyn dyn
;
6263 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
6268 if (htab
->root
.target_os
== is_vxworks
6269 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
6270 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6274 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
6275 s
= htab
->root
.hgot
->root
.u
.def
.section
;
6276 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
6277 + s
->output_section
->vma
+ s
->output_offset
;
6278 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6282 s
= htab
->root
.srelplt
->output_section
;
6283 BFD_ASSERT (s
!= NULL
);
6284 dyn
.d_un
.d_ptr
= s
->vma
;
6285 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6289 s
= htab
->root
.srelplt
->output_section
;
6290 BFD_ASSERT (s
!= NULL
);
6291 dyn
.d_un
.d_val
= s
->size
;
6292 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6297 /* Fill in the first entry in the procedure linkage table. */
6298 splt
= htab
->root
.splt
;
6299 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
6303 memcpy (splt
->contents
,
6304 htab
->plt_info
->plt0_entry
,
6305 htab
->plt_info
->plt0_entry_size
);
6306 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
6307 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
6308 install_plt_field (output_bfd
, false,
6309 (sgotplt
->output_section
->vma
6310 + sgotplt
->output_offset
6313 + htab
->plt_info
->plt0_got_fields
[i
]));
6315 if (htab
->root
.target_os
== is_vxworks
)
6317 /* Finalize the .rela.plt.unloaded contents. */
6318 Elf_Internal_Rela rel
;
6321 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6322 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
6323 loc
= htab
->srelplt2
->contents
;
6324 rel
.r_offset
= (splt
->output_section
->vma
6325 + splt
->output_offset
6326 + htab
->plt_info
->plt0_got_fields
[2]);
6327 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6329 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6330 loc
+= sizeof (Elf32_External_Rela
);
6332 /* Fix up the remaining .rela.plt.unloaded relocations.
6333 They may have the wrong symbol index for _G_O_T_ or
6334 _P_L_T_ depending on the order in which symbols were
6336 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
6338 /* The PLT entry's pointer to the .got.plt slot. */
6339 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6340 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
6342 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6343 loc
+= sizeof (Elf32_External_Rela
);
6345 /* The .got.plt slot's pointer to .plt. */
6346 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6347 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
6349 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6350 loc
+= sizeof (Elf32_External_Rela
);
6354 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6355 really seem like the right value. */
6356 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
6360 /* Fill in the first three entries in the global offset table. */
6361 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
6364 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
6366 bfd_put_32 (output_bfd
,
6367 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6369 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
6370 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
6373 if (sgotplt
&& sgotplt
->size
> 0)
6374 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
6376 /* At the very end of the .rofixup section is a pointer to the GOT. */
6377 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
6379 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
6380 bfd_vma got_value
= hgot
->root
.u
.def
.value
6381 + hgot
->root
.u
.def
.section
->output_section
->vma
6382 + hgot
->root
.u
.def
.section
->output_offset
;
6384 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
6386 /* Make sure we allocated and generated the same number of fixups. */
6387 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
6390 if (htab
->srelfuncdesc
)
6391 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
6392 == htab
->srelfuncdesc
->size
);
6394 if (htab
->root
.srelgot
)
6395 BFD_ASSERT (htab
->root
.srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
6396 == htab
->root
.srelgot
->size
);
6401 static enum elf_reloc_type_class
6402 sh_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6403 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6404 const Elf_Internal_Rela
*rela
)
6406 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6409 return reloc_class_relative
;
6411 return reloc_class_plt
;
6413 return reloc_class_copy
;
6415 return reloc_class_normal
;
6419 #if !defined SH_TARGET_ALREADY_DEFINED
6420 /* Support for Linux core dump NOTE sections. */
6423 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6428 switch (note
->descsz
)
6433 case 168: /* Linux/SH */
6435 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
6438 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
6447 /* Make a ".reg/999" section. */
6448 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6449 size
, note
->descpos
+ offset
);
6453 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6455 switch (note
->descsz
)
6460 case 124: /* Linux/SH elf_prpsinfo */
6461 elf_tdata (abfd
)->core
->program
6462 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
6463 elf_tdata (abfd
)->core
->command
6464 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
6467 /* Note that for some reason, a spurious space is tacked
6468 onto the end of the args in some (at least one anyway)
6469 implementations, so strip it off if it exists. */
6472 char *command
= elf_tdata (abfd
)->core
->command
;
6473 int n
= strlen (command
);
6475 if (0 < n
&& command
[n
- 1] == ' ')
6476 command
[n
- 1] = '\0';
6481 #endif /* not SH_TARGET_ALREADY_DEFINED */
6484 /* Return address for Ith PLT stub in section PLT, for relocation REL
6485 or (bfd_vma) -1 if it should not be included. */
6488 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
6489 const arelent
*rel ATTRIBUTE_UNUSED
)
6491 const struct elf_sh_plt_info
*plt_info
;
6493 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
6494 return plt
->vma
+ get_plt_offset (plt_info
, i
);
6497 /* Decide whether to attempt to turn absptr or lsda encodings in
6498 shared libraries into pcrel within the given input section. */
6501 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6502 struct bfd_link_info
*info
,
6503 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
6505 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6507 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
6514 /* Adjust the contents of an eh_frame_hdr section before they're output. */
6517 sh_elf_encode_eh_address (bfd
*abfd
,
6518 struct bfd_link_info
*info
,
6519 asection
*osec
, bfd_vma offset
,
6520 asection
*loc_sec
, bfd_vma loc_offset
,
6523 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6524 struct elf_link_hash_entry
*h
;
6527 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
6528 loc_offset
, encoded
);
6530 h
= htab
->root
.hgot
;
6531 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
6533 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
6534 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
6535 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
6536 loc_sec
, loc_offset
, encoded
);
6538 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
6539 == (sh_elf_osec_to_segment
6540 (abfd
, h
->root
.u
.def
.section
->output_section
)));
6542 *encoded
= osec
->vma
+ offset
6543 - (h
->root
.u
.def
.value
6544 + h
->root
.u
.def
.section
->output_section
->vma
6545 + h
->root
.u
.def
.section
->output_offset
);
6547 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
6550 #if !defined SH_TARGET_ALREADY_DEFINED
6551 #define TARGET_BIG_SYM sh_elf32_vec
6552 #define TARGET_BIG_NAME "elf32-sh"
6553 #define TARGET_LITTLE_SYM sh_elf32_le_vec
6554 #define TARGET_LITTLE_NAME "elf32-shl"
6557 #define ELF_ARCH bfd_arch_sh
6558 #define ELF_TARGET_ID SH_ELF_DATA
6559 #define ELF_MACHINE_CODE EM_SH
6560 #ifdef __QNXTARGET__
6561 #define ELF_MAXPAGESIZE 0x1000
6563 #define ELF_MAXPAGESIZE 0x80
6566 #define elf_symbol_leading_char '_'
6568 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6569 #define bfd_elf32_bfd_reloc_name_lookup \
6570 sh_elf_reloc_name_lookup
6571 #define elf_info_to_howto sh_elf_info_to_howto
6572 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
6573 #define elf_backend_relocate_section sh_elf_relocate_section
6574 #define bfd_elf32_bfd_get_relocated_section_contents \
6575 sh_elf_get_relocated_section_contents
6576 #define bfd_elf32_mkobject sh_elf_mkobject
6577 #define elf_backend_object_p sh_elf_object_p
6578 #define bfd_elf32_bfd_copy_private_bfd_data \
6579 sh_elf_copy_private_data
6580 #define bfd_elf32_bfd_merge_private_bfd_data \
6581 sh_elf_merge_private_data
6583 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
6584 #define elf_backend_check_relocs sh_elf_check_relocs
6585 #define elf_backend_copy_indirect_symbol \
6586 sh_elf_copy_indirect_symbol
6587 #define elf_backend_create_dynamic_sections \
6588 sh_elf_create_dynamic_sections
6589 #define bfd_elf32_bfd_link_hash_table_create \
6590 sh_elf_link_hash_table_create
6591 #define elf_backend_adjust_dynamic_symbol \
6592 sh_elf_adjust_dynamic_symbol
6593 #define elf_backend_always_size_sections \
6594 sh_elf_always_size_sections
6595 #define elf_backend_size_dynamic_sections \
6596 sh_elf_size_dynamic_sections
6597 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6598 #define elf_backend_finish_dynamic_symbol \
6599 sh_elf_finish_dynamic_symbol
6600 #define elf_backend_finish_dynamic_sections \
6601 sh_elf_finish_dynamic_sections
6602 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
6603 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
6604 #define elf_backend_can_make_relative_eh_frame \
6605 sh_elf_use_relative_eh_frame
6606 #define elf_backend_can_make_lsda_relative_eh_frame \
6607 sh_elf_use_relative_eh_frame
6608 #define elf_backend_encode_eh_address \
6609 sh_elf_encode_eh_address
6611 #define elf_backend_stack_align 8
6612 #define elf_backend_can_gc_sections 1
6613 #define elf_backend_can_refcount 1
6614 #define elf_backend_want_got_plt 1
6615 #define elf_backend_plt_readonly 1
6616 #define elf_backend_want_plt_sym 0
6617 #define elf_backend_got_header_size 12
6618 #define elf_backend_dtrel_excludes_plt 1
6620 #define elf_backend_linux_prpsinfo32_ugid16 true
6622 #if !defined SH_TARGET_ALREADY_DEFINED
6624 #include "elf32-target.h"
6626 /* NetBSD support. */
6627 #undef TARGET_BIG_SYM
6628 #define TARGET_BIG_SYM sh_elf32_nbsd_vec
6629 #undef TARGET_BIG_NAME
6630 #define TARGET_BIG_NAME "elf32-sh-nbsd"
6631 #undef TARGET_LITTLE_SYM
6632 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
6633 #undef TARGET_LITTLE_NAME
6634 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
6635 #undef ELF_MAXPAGESIZE
6636 #define ELF_MAXPAGESIZE 0x10000
6637 #undef ELF_COMMONPAGESIZE
6638 #undef elf_symbol_leading_char
6639 #define elf_symbol_leading_char 0
6641 #define elf32_bed elf32_sh_nbsd_bed
6643 #include "elf32-target.h"
6646 /* Linux support. */
6647 #undef TARGET_BIG_SYM
6648 #define TARGET_BIG_SYM sh_elf32_linux_be_vec
6649 #undef TARGET_BIG_NAME
6650 #define TARGET_BIG_NAME "elf32-shbig-linux"
6651 #undef TARGET_LITTLE_SYM
6652 #define TARGET_LITTLE_SYM sh_elf32_linux_vec
6653 #undef TARGET_LITTLE_NAME
6654 #define TARGET_LITTLE_NAME "elf32-sh-linux"
6655 #undef ELF_COMMONPAGESIZE
6656 #define ELF_COMMONPAGESIZE 0x1000
6658 #undef elf_backend_grok_prstatus
6659 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
6660 #undef elf_backend_grok_psinfo
6661 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
6663 #define elf32_bed elf32_sh_lin_bed
6665 #include "elf32-target.h"
6668 /* FDPIC support. */
6669 #undef TARGET_BIG_SYM
6670 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
6671 #undef TARGET_BIG_NAME
6672 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
6673 #undef TARGET_LITTLE_SYM
6674 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
6675 #undef TARGET_LITTLE_NAME
6676 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
6679 #define elf32_bed elf32_sh_fd_bed
6681 #include "elf32-target.h"
6683 /* VxWorks support. */
6684 #undef TARGET_BIG_SYM
6685 #define TARGET_BIG_SYM sh_elf32_vxworks_vec
6686 #undef TARGET_BIG_NAME
6687 #define TARGET_BIG_NAME "elf32-sh-vxworks"
6688 #undef TARGET_LITTLE_SYM
6689 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
6690 #undef TARGET_LITTLE_NAME
6691 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
6693 #define elf32_bed elf32_sh_vxworks_bed
6695 #undef elf_backend_want_plt_sym
6696 #define elf_backend_want_plt_sym 1
6697 #undef elf_symbol_leading_char
6698 #define elf_symbol_leading_char '_'
6699 #define elf_backend_want_got_underscore 1
6700 #undef elf_backend_grok_prstatus
6701 #undef elf_backend_grok_psinfo
6702 #undef elf_backend_add_symbol_hook
6703 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
6704 #undef elf_backend_link_output_symbol_hook
6705 #define elf_backend_link_output_symbol_hook \
6706 elf_vxworks_link_output_symbol_hook
6707 #undef elf_backend_emit_relocs
6708 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6709 #undef elf_backend_final_write_processing
6710 #define elf_backend_final_write_processing \
6711 elf_vxworks_final_write_processing
6712 #undef ELF_MAXPAGESIZE
6713 #define ELF_MAXPAGESIZE 0x1000
6714 #undef ELF_COMMONPAGESIZE
6716 #undef ELF_TARGET_OS
6717 #define ELF_TARGET_OS is_vxworks
6719 #include "elf32-target.h"
6721 #endif /* not SH_TARGET_ALREADY_DEFINED */