1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright (C) 1996-2020 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 bfd_boolean sh_elf_relax_delete_bytes
41 (bfd
*, asection
*, bfd_vma
, int);
42 static bfd_boolean sh_elf_align_loads
43 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_boolean
*);
44 static bfd_boolean sh_elf_swap_insns
45 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
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
, bfd_boolean
*again
)
462 Elf_Internal_Shdr
*symtab_hdr
;
463 Elf_Internal_Rela
*internal_relocs
;
464 bfd_boolean have_code
;
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;
899 bfd_boolean overflow
;
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
,
1321 bfd_boolean
*pswapped
)
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
;
1453 bfd_boolean overflow
;
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 bfd_boolean got20
; /* TRUE if got_entry points to a movi20
1546 instruction (instead of a constant pool
1550 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1551 bfd_vma symbol_resolve_offset
;
1553 /* A different PLT layout which can be used for the first
1554 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1556 const struct elf_sh_plt_info
*short_plt
;
1559 /* The size in bytes of an entry in the procedure linkage table. */
1561 #define ELF_PLT_ENTRY_SIZE 28
1563 /* First entry in an absolute procedure linkage table look like this. */
1565 /* Note - this code has been "optimised" not to use r2. r2 is used by
1566 GCC to return the address of large structures, so it should not be
1567 corrupted here. This does mean however, that this PLT does not conform
1568 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1569 and r2 contains the GOT id. This version stores the GOT id in r0 and
1570 ignores the type. Loaders can easily detect this difference however,
1571 since the type will always be 0 or 8, and the GOT ids will always be
1572 greater than or equal to 12. */
1573 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1575 0xd0, 0x05, /* mov.l 2f,r0 */
1576 0x60, 0x02, /* mov.l @r0,r0 */
1577 0x2f, 0x06, /* mov.l r0,@-r15 */
1578 0xd0, 0x03, /* mov.l 1f,r0 */
1579 0x60, 0x02, /* mov.l @r0,r0 */
1580 0x40, 0x2b, /* jmp @r0 */
1581 0x60, 0xf6, /* mov.l @r15+,r0 */
1582 0x00, 0x09, /* nop */
1583 0x00, 0x09, /* nop */
1584 0x00, 0x09, /* nop */
1585 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1586 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1589 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1591 0x05, 0xd0, /* mov.l 2f,r0 */
1592 0x02, 0x60, /* mov.l @r0,r0 */
1593 0x06, 0x2f, /* mov.l r0,@-r15 */
1594 0x03, 0xd0, /* mov.l 1f,r0 */
1595 0x02, 0x60, /* mov.l @r0,r0 */
1596 0x2b, 0x40, /* jmp @r0 */
1597 0xf6, 0x60, /* mov.l @r15+,r0 */
1598 0x09, 0x00, /* nop */
1599 0x09, 0x00, /* nop */
1600 0x09, 0x00, /* nop */
1601 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1602 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1605 /* Sebsequent entries in an absolute procedure linkage table look like
1608 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1610 0xd0, 0x04, /* mov.l 1f,r0 */
1611 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1612 0xd1, 0x02, /* mov.l 0f,r1 */
1613 0x40, 0x2b, /* jmp @r0 */
1614 0x60, 0x13, /* mov r1,r0 */
1615 0xd1, 0x03, /* mov.l 2f,r1 */
1616 0x40, 0x2b, /* jmp @r0 */
1617 0x00, 0x09, /* nop */
1618 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1619 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1620 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1623 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1625 0x04, 0xd0, /* mov.l 1f,r0 */
1626 0x02, 0x60, /* mov.l @r0,r0 */
1627 0x02, 0xd1, /* mov.l 0f,r1 */
1628 0x2b, 0x40, /* jmp @r0 */
1629 0x13, 0x60, /* mov r1,r0 */
1630 0x03, 0xd1, /* mov.l 2f,r1 */
1631 0x2b, 0x40, /* jmp @r0 */
1632 0x09, 0x00, /* nop */
1633 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1634 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1635 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1638 /* Entries in a PIC procedure linkage table look like this. */
1640 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1642 0xd0, 0x04, /* mov.l 1f,r0 */
1643 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1644 0x40, 0x2b, /* jmp @r0 */
1645 0x00, 0x09, /* nop */
1646 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1647 0xd1, 0x03, /* mov.l 2f,r1 */
1648 0x40, 0x2b, /* jmp @r0 */
1649 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1650 0x00, 0x09, /* nop */
1651 0x00, 0x09, /* nop */
1652 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1653 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1656 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1658 0x04, 0xd0, /* mov.l 1f,r0 */
1659 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1660 0x2b, 0x40, /* jmp @r0 */
1661 0x09, 0x00, /* nop */
1662 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1663 0x03, 0xd1, /* mov.l 2f,r1 */
1664 0x2b, 0x40, /* jmp @r0 */
1665 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1666 0x09, 0x00, /* nop */
1667 0x09, 0x00, /* nop */
1668 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1669 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1672 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1675 /* Big-endian non-PIC. */
1676 elf_sh_plt0_entry_be
,
1678 { MINUS_ONE
, 24, 20 },
1679 elf_sh_plt_entry_be
,
1681 { 20, 16, 24, FALSE
},
1686 /* Little-endian non-PIC. */
1687 elf_sh_plt0_entry_le
,
1689 { MINUS_ONE
, 24, 20 },
1690 elf_sh_plt_entry_le
,
1692 { 20, 16, 24, FALSE
},
1699 /* Big-endian PIC. */
1700 elf_sh_plt0_entry_be
,
1702 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1703 elf_sh_pic_plt_entry_be
,
1705 { 20, MINUS_ONE
, 24, FALSE
},
1710 /* Little-endian PIC. */
1711 elf_sh_plt0_entry_le
,
1713 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1714 elf_sh_pic_plt_entry_le
,
1716 { 20, MINUS_ONE
, 24, FALSE
},
1723 #define VXWORKS_PLT_HEADER_SIZE 12
1724 #define VXWORKS_PLT_ENTRY_SIZE 24
1726 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1728 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1729 0x61, 0x12, /* mov.l @r1,r1 */
1730 0x41, 0x2b, /* jmp @r1 */
1731 0x00, 0x09, /* nop */
1732 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1735 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1737 0x01, 0xd1, /* mov.l @(8,pc),r1 */
1738 0x12, 0x61, /* mov.l @r1,r1 */
1739 0x2b, 0x41, /* jmp @r1 */
1740 0x09, 0x00, /* nop */
1741 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1744 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1746 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1747 0x60, 0x02, /* mov.l @r0,r0 */
1748 0x40, 0x2b, /* jmp @r0 */
1749 0x00, 0x09, /* nop */
1750 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1751 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1752 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
1753 0x00, 0x09, /* nop */
1754 0x00, 0x09, /* nop */
1755 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1758 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1760 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1761 0x02, 0x60, /* mov.l @r0,r0 */
1762 0x2b, 0x40, /* jmp @r0 */
1763 0x09, 0x00, /* nop */
1764 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1765 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1766 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
1767 0x09, 0x00, /* nop */
1768 0x09, 0x00, /* nop */
1769 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1772 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1774 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1775 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1776 0x40, 0x2b, /* jmp @r0 */
1777 0x00, 0x09, /* nop */
1778 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1779 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1780 0x51, 0xc2, /* mov.l @(8,r12),r1 */
1781 0x41, 0x2b, /* jmp @r1 */
1782 0x00, 0x09, /* nop */
1783 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1786 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1788 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1789 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1790 0x2b, 0x40, /* jmp @r0 */
1791 0x09, 0x00, /* nop */
1792 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1793 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1794 0xc2, 0x51, /* mov.l @(8,r12),r1 */
1795 0x2b, 0x41, /* jmp @r1 */
1796 0x09, 0x00, /* nop */
1797 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1800 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
1803 /* Big-endian non-PIC. */
1804 vxworks_sh_plt0_entry_be
,
1805 VXWORKS_PLT_HEADER_SIZE
,
1806 { MINUS_ONE
, MINUS_ONE
, 8 },
1807 vxworks_sh_plt_entry_be
,
1808 VXWORKS_PLT_ENTRY_SIZE
,
1809 { 8, 14, 20, FALSE
},
1814 /* Little-endian non-PIC. */
1815 vxworks_sh_plt0_entry_le
,
1816 VXWORKS_PLT_HEADER_SIZE
,
1817 { MINUS_ONE
, MINUS_ONE
, 8 },
1818 vxworks_sh_plt_entry_le
,
1819 VXWORKS_PLT_ENTRY_SIZE
,
1820 { 8, 14, 20, FALSE
},
1827 /* Big-endian PIC. */
1830 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1831 vxworks_sh_pic_plt_entry_be
,
1832 VXWORKS_PLT_ENTRY_SIZE
,
1833 { 8, MINUS_ONE
, 20, FALSE
},
1838 /* Little-endian PIC. */
1841 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1842 vxworks_sh_pic_plt_entry_le
,
1843 VXWORKS_PLT_ENTRY_SIZE
,
1844 { 8, MINUS_ONE
, 20, FALSE
},
1851 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
1852 binding are to omit the lazy binding stub when linking with -z now
1853 and to move lazy binding stubs into a separate region for better
1856 #define FDPIC_PLT_ENTRY_SIZE 28
1857 #define FDPIC_PLT_LAZY_OFFSET 20
1859 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
1860 duplicated if it is out of range, or which can be inlined. So
1861 right now it is always inlined, which wastes a word per stub. It
1862 might be easier to handle the duplication if we put the lazy
1863 stubs separately. */
1865 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
1867 0xd0, 0x02, /* mov.l @(12,pc),r0 */
1868 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1869 0x70, 0x04, /* add #4, r0 */
1870 0x41, 0x2b, /* jmp @r1 */
1871 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1872 0x00, 0x09, /* nop */
1873 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1874 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1875 0x60, 0xc2, /* mov.l @r12,r0 */
1876 0x40, 0x2b, /* jmp @r0 */
1877 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1878 0x00, 0x09, /* nop */
1881 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
1883 0x02, 0xd0, /* mov.l @(12,pc),r0 */
1884 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1885 0x04, 0x70, /* add #4, r0 */
1886 0x2b, 0x41, /* jmp @r1 */
1887 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1888 0x09, 0x00, /* nop */
1889 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1890 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1891 0xc2, 0x60, /* mov.l @r12,r0 */
1892 0x2b, 0x40, /* jmp @r0 */
1893 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1894 0x09, 0x00, /* nop */
1897 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
1899 /* Big-endian PIC. */
1902 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1903 fdpic_sh_plt_entry_be
,
1904 FDPIC_PLT_ENTRY_SIZE
,
1905 { 12, MINUS_ONE
, 16, FALSE
},
1906 FDPIC_PLT_LAZY_OFFSET
,
1910 /* Little-endian PIC. */
1913 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1914 fdpic_sh_plt_entry_le
,
1915 FDPIC_PLT_ENTRY_SIZE
,
1916 { 12, MINUS_ONE
, 16, FALSE
},
1917 FDPIC_PLT_LAZY_OFFSET
,
1922 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
1923 entries for the first 64K slots. We use the normal FDPIC PLT entry
1924 past that point; we could also use movi20s, which might be faster,
1925 but would not be any smaller. */
1927 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
1928 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
1930 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1932 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1933 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1934 0x70, 0x04, /* add #4, r0 */
1935 0x41, 0x2b, /* jmp @r1 */
1936 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1937 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1938 0x60, 0xc2, /* mov.l @r12,r0 */
1939 0x40, 0x2b, /* jmp @r0 */
1940 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1941 0x00, 0x09, /* nop */
1944 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1946 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1947 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1948 0x04, 0x70, /* add #4, r0 */
1949 0x2b, 0x41, /* jmp @r1 */
1950 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1951 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1952 0xc2, 0x60, /* mov.l @r12,r0 */
1953 0x2b, 0x40, /* jmp @r0 */
1954 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1955 0x09, 0x00, /* nop */
1958 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
1959 /* Big-endian FDPIC, max index 64K. */
1962 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1963 fdpic_sh2a_plt_entry_be
,
1964 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1965 { 0, MINUS_ONE
, 12, TRUE
},
1966 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1970 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
1971 /* Little-endian FDPIC, max index 64K. */
1974 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1975 fdpic_sh2a_plt_entry_le
,
1976 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1977 { 0, MINUS_ONE
, 12, TRUE
},
1978 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1982 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
1984 /* Big-endian PIC. */
1987 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1988 fdpic_sh_plt_entry_be
,
1989 FDPIC_PLT_ENTRY_SIZE
,
1990 { 12, MINUS_ONE
, 16, FALSE
},
1991 FDPIC_PLT_LAZY_OFFSET
,
1992 &fdpic_sh2a_short_plt_be
1995 /* Little-endian PIC. */
1998 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1999 fdpic_sh_plt_entry_le
,
2000 FDPIC_PLT_ENTRY_SIZE
,
2001 { 12, MINUS_ONE
, 16, FALSE
},
2002 FDPIC_PLT_LAZY_OFFSET
,
2003 &fdpic_sh2a_short_plt_le
2007 /* Return the type of PLT associated with ABFD. PIC_P is true if
2008 the object is position-independent. */
2010 static const struct elf_sh_plt_info
*
2011 get_plt_info (bfd
*abfd
, bfd_boolean pic_p
)
2013 if (fdpic_object_p (abfd
))
2015 /* If any input file requires SH2A we can use a shorter PLT
2017 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2018 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2020 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2022 if (vxworks_object_p (abfd
))
2023 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2024 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2027 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2028 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2032 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2033 unsigned long value
, bfd_byte
*addr
)
2035 bfd_put_32 (output_bfd
, value
, addr
);
2038 /* The number of PLT entries which can use a shorter PLT, if any.
2039 Currently always 64K, since only SH-2A FDPIC uses this; a
2040 20-bit movi20 can address that many function descriptors below
2041 _GLOBAL_OFFSET_TABLE_. */
2042 #define MAX_SHORT_PLT 65536
2044 /* Return the index of the PLT entry at byte offset OFFSET. */
2047 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2049 bfd_vma plt_index
= 0;
2051 offset
-= info
->plt0_entry_size
;
2052 if (info
->short_plt
!= NULL
)
2054 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2056 plt_index
= MAX_SHORT_PLT
;
2057 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2060 info
= info
->short_plt
;
2062 return plt_index
+ offset
/ info
->symbol_entry_size
;
2065 /* Do the inverse operation. */
2068 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2072 if (info
->short_plt
!= NULL
)
2074 if (plt_index
> MAX_SHORT_PLT
)
2076 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2077 plt_index
-= MAX_SHORT_PLT
;
2080 info
= info
->short_plt
;
2082 return (offset
+ info
->plt0_entry_size
2083 + (plt_index
* info
->symbol_entry_size
));
2088 bfd_signed_vma refcount
;
2092 /* sh ELF linker hash entry. */
2094 struct elf_sh_link_hash_entry
2096 struct elf_link_hash_entry root
;
2098 /* Track dynamic relocs copied for this symbol. */
2099 struct elf_dyn_relocs
*dyn_relocs
;
2101 bfd_signed_vma gotplt_refcount
;
2103 /* A local function descriptor, for FDPIC. The refcount counts
2104 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2105 relocations; the PLT and GOT entry are accounted
2106 for separately. After adjust_dynamic_symbol, the offset is
2107 MINUS_ONE if there is no local descriptor (dynamic linker
2108 managed and no PLT entry, or undefined weak non-dynamic).
2109 During check_relocs we do not yet know whether the local
2110 descriptor will be canonical. */
2111 union gotref funcdesc
;
2113 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2114 and thus require fixups or relocations. */
2115 bfd_signed_vma abs_funcdesc_refcount
;
2118 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2122 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2124 struct sh_elf_obj_tdata
2126 struct elf_obj_tdata root
;
2128 /* got_type for each local got entry. */
2129 char *local_got_type
;
2131 /* Function descriptor refcount and offset for each local symbol. */
2132 union gotref
*local_funcdesc
;
2135 #define sh_elf_tdata(abfd) \
2136 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2138 #define sh_elf_local_got_type(abfd) \
2139 (sh_elf_tdata (abfd)->local_got_type)
2141 #define sh_elf_local_funcdesc(abfd) \
2142 (sh_elf_tdata (abfd)->local_funcdesc)
2144 #define is_sh_elf(bfd) \
2145 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2146 && elf_tdata (bfd) != NULL \
2147 && elf_object_id (bfd) == SH_ELF_DATA)
2149 /* Override the generic function because we need to store sh_elf_obj_tdata
2150 as the specific tdata. */
2153 sh_elf_mkobject (bfd
*abfd
)
2155 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2159 /* sh ELF linker hash table. */
2161 struct elf_sh_link_hash_table
2163 struct elf_link_hash_table root
;
2165 /* Short-cuts to get to dynamic linker sections. */
2168 asection
*sfuncdesc
;
2169 asection
*srelfuncdesc
;
2172 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2175 /* Small local sym cache. */
2176 struct sym_cache sym_cache
;
2178 /* A counter or offset to track a TLS got entry. */
2181 bfd_signed_vma refcount
;
2185 /* The type of PLT to use. */
2186 const struct elf_sh_plt_info
*plt_info
;
2188 /* True if the target system is VxWorks. */
2189 bfd_boolean vxworks_p
;
2191 /* True if the target system uses FDPIC. */
2192 bfd_boolean fdpic_p
;
2195 /* Traverse an sh ELF linker hash table. */
2197 #define sh_elf_link_hash_traverse(table, func, info) \
2198 (elf_link_hash_traverse \
2200 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2203 /* Get the sh ELF linker hash table from a link_info structure. */
2205 #define sh_elf_hash_table(p) \
2206 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2207 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2209 /* Create an entry in an sh ELF linker hash table. */
2211 static struct bfd_hash_entry
*
2212 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2213 struct bfd_hash_table
*table
,
2216 struct elf_sh_link_hash_entry
*ret
=
2217 (struct elf_sh_link_hash_entry
*) entry
;
2219 /* Allocate the structure if it has not already been allocated by a
2221 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2222 ret
= ((struct elf_sh_link_hash_entry
*)
2223 bfd_hash_allocate (table
,
2224 sizeof (struct elf_sh_link_hash_entry
)));
2225 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2226 return (struct bfd_hash_entry
*) ret
;
2228 /* Call the allocation method of the superclass. */
2229 ret
= ((struct elf_sh_link_hash_entry
*)
2230 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2232 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2234 ret
->dyn_relocs
= NULL
;
2235 ret
->gotplt_refcount
= 0;
2236 ret
->funcdesc
.refcount
= 0;
2237 ret
->abs_funcdesc_refcount
= 0;
2238 ret
->got_type
= GOT_UNKNOWN
;
2241 return (struct bfd_hash_entry
*) ret
;
2244 /* Create an sh ELF linker hash table. */
2246 static struct bfd_link_hash_table
*
2247 sh_elf_link_hash_table_create (bfd
*abfd
)
2249 struct elf_sh_link_hash_table
*ret
;
2250 size_t amt
= sizeof (struct elf_sh_link_hash_table
);
2252 ret
= (struct elf_sh_link_hash_table
*) bfd_zmalloc (amt
);
2253 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2256 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2257 sh_elf_link_hash_newfunc
,
2258 sizeof (struct elf_sh_link_hash_entry
),
2265 ret
->vxworks_p
= vxworks_object_p (abfd
);
2266 ret
->fdpic_p
= fdpic_object_p (abfd
);
2268 return &ret
->root
.root
;
2272 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2273 struct bfd_link_info
*info
, asection
*p
)
2275 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2277 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2281 /* We need dynamic symbols for every section, since segments can
2282 relocate independently. */
2283 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2287 /* If sh_type is yet undecided, assume it could be
2288 SHT_PROGBITS/SHT_NOBITS. */
2292 /* There shouldn't be section relative relocations
2293 against any other section. */
2299 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2300 shortcuts to them in our hash table. */
2303 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2305 struct elf_sh_link_hash_table
*htab
;
2307 if (! _bfd_elf_create_got_section (dynobj
, info
))
2310 htab
= sh_elf_hash_table (info
);
2314 htab
->sfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.funcdesc",
2315 (SEC_ALLOC
| SEC_LOAD
2318 | SEC_LINKER_CREATED
));
2319 if (htab
->sfuncdesc
== NULL
2320 || !bfd_set_section_alignment (htab
->sfuncdesc
, 2))
2323 htab
->srelfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
,
2324 ".rela.got.funcdesc",
2325 (SEC_ALLOC
| SEC_LOAD
2328 | SEC_LINKER_CREATED
2330 if (htab
->srelfuncdesc
== NULL
2331 || !bfd_set_section_alignment (htab
->srelfuncdesc
, 2))
2334 /* Also create .rofixup. */
2335 htab
->srofixup
= bfd_make_section_anyway_with_flags (dynobj
, ".rofixup",
2336 (SEC_ALLOC
| SEC_LOAD
2339 | SEC_LINKER_CREATED
2341 if (htab
->srofixup
== NULL
2342 || !bfd_set_section_alignment (htab
->srofixup
, 2))
2348 /* Create dynamic sections when linking against a dynamic object. */
2351 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2353 struct elf_sh_link_hash_table
*htab
;
2354 flagword flags
, pltflags
;
2356 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2359 switch (bed
->s
->arch_size
)
2370 bfd_set_error (bfd_error_bad_value
);
2374 htab
= sh_elf_hash_table (info
);
2378 if (htab
->root
.dynamic_sections_created
)
2381 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2382 .rel[a].bss sections. */
2384 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2385 | SEC_LINKER_CREATED
);
2388 pltflags
|= SEC_CODE
;
2389 if (bed
->plt_not_loaded
)
2390 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2391 if (bed
->plt_readonly
)
2392 pltflags
|= SEC_READONLY
;
2394 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2395 htab
->root
.splt
= s
;
2397 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2400 if (bed
->want_plt_sym
)
2402 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2404 struct elf_link_hash_entry
*h
;
2405 struct bfd_link_hash_entry
*bh
= NULL
;
2407 if (! (_bfd_generic_link_add_one_symbol
2408 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2409 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2410 get_elf_backend_data (abfd
)->collect
, &bh
)))
2413 h
= (struct elf_link_hash_entry
*) bh
;
2415 h
->type
= STT_OBJECT
;
2416 htab
->root
.hplt
= h
;
2418 if (bfd_link_pic (info
)
2419 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2423 s
= bfd_make_section_anyway_with_flags (abfd
,
2424 bed
->default_use_rela_p
2425 ? ".rela.plt" : ".rel.plt",
2426 flags
| SEC_READONLY
);
2427 htab
->root
.srelplt
= s
;
2429 || !bfd_set_section_alignment (s
, ptralign
))
2432 if (htab
->root
.sgot
== NULL
2433 && !create_got_section (abfd
, info
))
2436 if (bed
->want_dynbss
)
2438 /* The .dynbss section is a place to put symbols which are defined
2439 by dynamic objects, are referenced by regular objects, and are
2440 not functions. We must allocate space for them in the process
2441 image and use a R_*_COPY reloc to tell the dynamic linker to
2442 initialize them at run time. The linker script puts the .dynbss
2443 section into the .bss section of the final image. */
2444 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2445 SEC_ALLOC
| SEC_LINKER_CREATED
);
2450 /* The .rel[a].bss section holds copy relocs. This section is not
2451 normally needed. We need to create it here, though, so that the
2452 linker will map it to an output section. We can't just create it
2453 only if we need it, because we will not know whether we need it
2454 until we have seen all the input files, and the first time the
2455 main linker code calls BFD after examining all the input files
2456 (size_dynamic_sections) the input sections have already been
2457 mapped to the output sections. If the section turns out not to
2458 be needed, we can discard it later. We will never need this
2459 section when generating a shared object, since they do not use
2461 if (! bfd_link_pic (info
))
2463 s
= bfd_make_section_anyway_with_flags (abfd
,
2464 (bed
->default_use_rela_p
2465 ? ".rela.bss" : ".rel.bss"),
2466 flags
| SEC_READONLY
);
2469 || !bfd_set_section_alignment (s
, ptralign
))
2474 if (htab
->vxworks_p
)
2476 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2483 /* Find dynamic relocs for H that apply to read-only sections. */
2486 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
2488 struct elf_dyn_relocs
*p
;
2490 for (p
= sh_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2492 asection
*s
= p
->sec
->output_section
;
2494 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2500 /* Adjust a symbol defined by a dynamic object and referenced by a
2501 regular object. The current definition is in some section of the
2502 dynamic object, but we're not including those sections. We have to
2503 change the definition to something the rest of the link can
2507 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2508 struct elf_link_hash_entry
*h
)
2510 struct elf_sh_link_hash_table
*htab
;
2513 htab
= sh_elf_hash_table (info
);
2517 /* Make sure we know what is going on here. */
2518 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2523 && !h
->def_regular
)));
2525 /* If this is a function, put it in the procedure linkage table. We
2526 will fill in the contents of the procedure linkage table later,
2527 when we know the address of the .got section. */
2528 if (h
->type
== STT_FUNC
2531 if (h
->plt
.refcount
<= 0
2532 || SYMBOL_CALLS_LOCAL (info
, h
)
2533 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2534 && h
->root
.type
== bfd_link_hash_undefweak
))
2536 /* This case can occur if we saw a PLT reloc in an input
2537 file, but the symbol was never referred to by a dynamic
2538 object. In such a case, we don't actually need to build
2539 a procedure linkage table, and we can just do a REL32
2541 h
->plt
.offset
= (bfd_vma
) -1;
2548 h
->plt
.offset
= (bfd_vma
) -1;
2550 /* If this is a weak symbol, and there is a real definition, the
2551 processor independent code will have arranged for us to see the
2552 real definition first, and we can just use the same value. */
2553 if (h
->is_weakalias
)
2555 struct elf_link_hash_entry
*def
= weakdef (h
);
2556 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2557 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2558 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2559 if (info
->nocopyreloc
)
2560 h
->non_got_ref
= def
->non_got_ref
;
2564 /* This is a reference to a symbol defined by a dynamic object which
2565 is not a function. */
2567 /* If we are creating a shared library, we must presume that the
2568 only references to the symbol are via the global offset table.
2569 For such cases we need not do anything here; the relocations will
2570 be handled correctly by relocate_section. */
2571 if (bfd_link_pic (info
))
2574 /* If there are no references to this symbol that do not use the
2575 GOT, we don't need to generate a copy reloc. */
2576 if (!h
->non_got_ref
)
2579 /* If -z nocopyreloc was given, we won't generate them either. */
2580 if (0 && info
->nocopyreloc
)
2586 /* If we don't find any dynamic relocs in read-only sections, then
2587 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2588 if (0 && !readonly_dynrelocs (h
))
2594 /* We must allocate the symbol in our .dynbss section, which will
2595 become part of the .bss section of the executable. There will be
2596 an entry for this symbol in the .dynsym section. The dynamic
2597 object will contain position independent code, so all references
2598 from the dynamic object to this symbol will go through the global
2599 offset table. The dynamic linker will use the .dynsym entry to
2600 determine the address it must put in the global offset table, so
2601 both the dynamic object and the regular object will refer to the
2602 same memory location for the variable. */
2605 BFD_ASSERT (s
!= NULL
);
2607 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2608 copy the initial value out of the dynamic object and into the
2609 runtime process image. We need to remember the offset into the
2610 .rela.bss section we are going to use. */
2611 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2615 srel
= htab
->srelbss
;
2616 BFD_ASSERT (srel
!= NULL
);
2617 srel
->size
+= sizeof (Elf32_External_Rela
);
2621 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2624 /* Allocate space in .plt, .got and associated reloc sections for
2628 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2630 struct bfd_link_info
*info
;
2631 struct elf_sh_link_hash_table
*htab
;
2632 struct elf_sh_link_hash_entry
*eh
;
2633 struct elf_dyn_relocs
*p
;
2635 if (h
->root
.type
== bfd_link_hash_indirect
)
2638 info
= (struct bfd_link_info
*) inf
;
2639 htab
= sh_elf_hash_table (info
);
2643 eh
= (struct elf_sh_link_hash_entry
*) h
;
2644 if ((h
->got
.refcount
> 0
2646 && eh
->gotplt_refcount
> 0)
2648 /* The symbol has been forced local, or we have some direct got refs,
2649 so treat all the gotplt refs as got refs. */
2650 h
->got
.refcount
+= eh
->gotplt_refcount
;
2651 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2652 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2655 if (htab
->root
.dynamic_sections_created
2656 && h
->plt
.refcount
> 0
2657 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2658 || h
->root
.type
!= bfd_link_hash_undefweak
))
2660 /* Make sure this symbol is output as a dynamic symbol.
2661 Undefined weak syms won't yet be marked as dynamic. */
2662 if (h
->dynindx
== -1
2663 && !h
->forced_local
)
2665 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2669 if (bfd_link_pic (info
)
2670 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2672 asection
*s
= htab
->root
.splt
;
2673 const struct elf_sh_plt_info
*plt_info
;
2675 /* If this is the first .plt entry, make room for the special
2678 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2680 h
->plt
.offset
= s
->size
;
2682 /* If this symbol is not defined in a regular file, and we are
2683 not generating a shared library, then set the symbol to this
2684 location in the .plt. This is required to make function
2685 pointers compare as equal between the normal executable and
2686 the shared library. Skip this for FDPIC, since the
2687 function's address will be the address of the canonical
2688 function descriptor. */
2689 if (!htab
->fdpic_p
&& !bfd_link_pic (info
) && !h
->def_regular
)
2691 h
->root
.u
.def
.section
= s
;
2692 h
->root
.u
.def
.value
= h
->plt
.offset
;
2695 /* Make room for this entry. */
2696 plt_info
= htab
->plt_info
;
2697 if (plt_info
->short_plt
!= NULL
2698 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
2699 plt_info
= plt_info
->short_plt
;
2700 s
->size
+= plt_info
->symbol_entry_size
;
2702 /* We also need to make an entry in the .got.plt section, which
2703 will be placed in the .got section by the linker script. */
2705 htab
->root
.sgotplt
->size
+= 4;
2707 htab
->root
.sgotplt
->size
+= 8;
2709 /* We also need to make an entry in the .rel.plt section. */
2710 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
2712 if (htab
->vxworks_p
&& !bfd_link_pic (info
))
2714 /* VxWorks executables have a second set of relocations
2715 for each PLT entry. They go in a separate relocation
2716 section, which is processed by the kernel loader. */
2718 /* There is a relocation for the initial PLT entry:
2719 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
2720 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
2721 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
2723 /* There are two extra relocations for each subsequent
2724 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2725 and an R_SH_DIR32 relocation for the PLT entry. */
2726 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
2731 h
->plt
.offset
= (bfd_vma
) -1;
2737 h
->plt
.offset
= (bfd_vma
) -1;
2741 if (h
->got
.refcount
> 0)
2745 enum got_type got_type
= sh_elf_hash_entry (h
)->got_type
;
2747 /* Make sure this symbol is output as a dynamic symbol.
2748 Undefined weak syms won't yet be marked as dynamic. */
2749 if (h
->dynindx
== -1
2750 && !h
->forced_local
)
2752 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2756 s
= htab
->root
.sgot
;
2757 h
->got
.offset
= s
->size
;
2759 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
2760 if (got_type
== GOT_TLS_GD
)
2762 dyn
= htab
->root
.dynamic_sections_created
;
2765 /* No dynamic relocations required. */
2766 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
2767 && h
->root
.type
!= bfd_link_hash_undefweak
2768 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
2769 htab
->srofixup
->size
+= 4;
2771 /* No dynamic relocations required when IE->LE conversion happens. */
2772 else if (got_type
== GOT_TLS_IE
2774 && !bfd_link_pic (info
))
2776 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2777 R_SH_TLS_GD needs one if local symbol and two if global. */
2778 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2779 || got_type
== GOT_TLS_IE
)
2780 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2781 else if (got_type
== GOT_TLS_GD
)
2782 htab
->root
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2783 else if (got_type
== GOT_FUNCDESC
)
2785 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2786 htab
->srofixup
->size
+= 4;
2788 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2790 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2791 || h
->root
.type
!= bfd_link_hash_undefweak
)
2792 && (bfd_link_pic (info
)
2793 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2794 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2795 else if (htab
->fdpic_p
2796 && !bfd_link_pic (info
)
2797 && got_type
== GOT_NORMAL
2798 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2799 || h
->root
.type
!= bfd_link_hash_undefweak
))
2800 htab
->srofixup
->size
+= 4;
2803 h
->got
.offset
= (bfd_vma
) -1;
2805 /* Allocate space for any dynamic relocations to function
2806 descriptors, canonical or otherwise. We need to relocate the
2807 reference unless it resolves to zero, which only happens for
2808 undefined weak symbols (either non-default visibility, or when
2809 static linking). Any GOT slot is accounted for elsewhere. */
2810 if (eh
->abs_funcdesc_refcount
> 0
2811 && (h
->root
.type
!= bfd_link_hash_undefweak
2812 || (htab
->root
.dynamic_sections_created
2813 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
2815 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2816 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
2818 htab
->root
.srelgot
->size
2819 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
2822 /* We must allocate a function descriptor if there are references to
2823 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
2824 the dynamic linker isn't going to allocate it. None of this
2825 applies if we already created one in .got.plt, but if the
2826 canonical function descriptor can be in this object, there
2827 won't be a PLT entry at all. */
2828 if ((eh
->funcdesc
.refcount
> 0
2829 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
2830 && h
->root
.type
!= bfd_link_hash_undefweak
2831 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2833 /* Make room for this function descriptor. */
2834 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
2835 htab
->sfuncdesc
->size
+= 8;
2837 /* We will need a relocation or two fixups to initialize the
2838 function descriptor, so allocate those too. */
2839 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
2840 htab
->srofixup
->size
+= 8;
2842 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
2845 if (eh
->dyn_relocs
== NULL
)
2848 /* In the shared -Bsymbolic case, discard space allocated for
2849 dynamic pc-relative relocs against symbols which turn out to be
2850 defined in regular objects. For the normal shared case, discard
2851 space for pc-relative relocs that have become local due to symbol
2852 visibility changes. */
2854 if (bfd_link_pic (info
))
2856 if (SYMBOL_CALLS_LOCAL (info
, h
))
2858 struct elf_dyn_relocs
**pp
;
2860 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2862 p
->count
-= p
->pc_count
;
2871 if (htab
->vxworks_p
)
2873 struct elf_dyn_relocs
**pp
;
2875 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2877 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2884 /* Also discard relocs on undefined weak syms with non-default
2886 if (eh
->dyn_relocs
!= NULL
2887 && h
->root
.type
== bfd_link_hash_undefweak
)
2889 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2890 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2891 eh
->dyn_relocs
= NULL
;
2893 /* Make sure undefined weak symbols are output as a dynamic
2895 else if (h
->dynindx
== -1
2896 && !h
->forced_local
)
2898 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2905 /* For the non-shared case, discard space for relocs against
2906 symbols which turn out to need copy relocs or are not
2912 || (htab
->root
.dynamic_sections_created
2913 && (h
->root
.type
== bfd_link_hash_undefweak
2914 || h
->root
.type
== bfd_link_hash_undefined
))))
2916 /* Make sure this symbol is output as a dynamic symbol.
2917 Undefined weak syms won't yet be marked as dynamic. */
2918 if (h
->dynindx
== -1
2919 && !h
->forced_local
)
2921 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2925 /* If that succeeded, we know we'll be keeping all the
2927 if (h
->dynindx
!= -1)
2931 eh
->dyn_relocs
= NULL
;
2936 /* Finally, allocate space. */
2937 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2939 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2940 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2942 /* If we need relocations, we do not need fixups. */
2943 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
2944 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
2950 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2951 read-only sections. */
2954 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
2958 if (h
->root
.type
== bfd_link_hash_indirect
)
2961 sec
= readonly_dynrelocs (h
);
2964 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
2966 info
->flags
|= DF_TEXTREL
;
2967 info
->callbacks
->minfo
2968 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2969 sec
->owner
, h
->root
.root
.string
, sec
);
2971 /* Not an error, just cut short the traversal. */
2977 /* This function is called after all the input files have been read,
2978 and the input sections have been assigned to output sections.
2979 It's a convenient place to determine the PLT style. */
2982 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2984 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
,
2985 bfd_link_pic (info
));
2987 if (sh_elf_hash_table (info
)->fdpic_p
&& !bfd_link_relocatable (info
)
2988 && !bfd_elf_stack_segment_size (output_bfd
, info
,
2989 "__stacksize", DEFAULT_STACK_SIZE
))
2994 /* Set the sizes of the dynamic sections. */
2997 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2998 struct bfd_link_info
*info
)
3000 struct elf_sh_link_hash_table
*htab
;
3006 htab
= sh_elf_hash_table (info
);
3010 dynobj
= htab
->root
.dynobj
;
3011 BFD_ASSERT (dynobj
!= NULL
);
3013 if (htab
->root
.dynamic_sections_created
)
3015 /* Set the contents of the .interp section to the interpreter. */
3016 if (bfd_link_executable (info
) && !info
->nointerp
)
3018 s
= bfd_get_linker_section (dynobj
, ".interp");
3019 BFD_ASSERT (s
!= NULL
);
3020 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3021 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3025 /* Set up .got offsets for local syms, and space for local dynamic
3027 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3029 bfd_signed_vma
*local_got
;
3030 bfd_signed_vma
*end_local_got
;
3031 union gotref
*local_funcdesc
, *end_local_funcdesc
;
3032 char *local_got_type
;
3033 bfd_size_type locsymcount
;
3034 Elf_Internal_Shdr
*symtab_hdr
;
3037 if (! is_sh_elf (ibfd
))
3040 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3042 struct elf_dyn_relocs
*p
;
3044 for (p
= ((struct elf_dyn_relocs
*)
3045 elf_section_data (s
)->local_dynrel
);
3049 if (! bfd_is_abs_section (p
->sec
)
3050 && bfd_is_abs_section (p
->sec
->output_section
))
3052 /* Input section has been discarded, either because
3053 it is a copy of a linkonce section or due to
3054 linker script /DISCARD/, so we'll be discarding
3057 else if (htab
->vxworks_p
3058 && strcmp (p
->sec
->output_section
->name
,
3061 /* Relocations in vxworks .tls_vars sections are
3062 handled specially by the loader. */
3064 else if (p
->count
!= 0)
3066 srel
= elf_section_data (p
->sec
)->sreloc
;
3067 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3068 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3070 info
->flags
|= DF_TEXTREL
;
3071 info
->callbacks
->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
3072 p
->sec
->owner
, p
->sec
);
3075 /* If we need relocations, we do not need fixups. */
3076 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
3077 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3082 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3083 locsymcount
= symtab_hdr
->sh_info
;
3084 s
= htab
->root
.sgot
;
3085 srel
= htab
->root
.srelgot
;
3087 local_got
= elf_local_got_refcounts (ibfd
);
3090 end_local_got
= local_got
+ locsymcount
;
3091 local_got_type
= sh_elf_local_got_type (ibfd
);
3092 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3093 for (; local_got
< end_local_got
; ++local_got
)
3097 *local_got
= s
->size
;
3099 if (*local_got_type
== GOT_TLS_GD
)
3101 if (bfd_link_pic (info
))
3102 srel
->size
+= sizeof (Elf32_External_Rela
);
3104 htab
->srofixup
->size
+= 4;
3106 if (*local_got_type
== GOT_FUNCDESC
)
3108 if (local_funcdesc
== NULL
)
3112 size
= locsymcount
* sizeof (union gotref
);
3113 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3115 if (local_funcdesc
== NULL
)
3117 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3118 local_funcdesc
+= (local_got
3119 - elf_local_got_refcounts (ibfd
));
3121 local_funcdesc
->refcount
++;
3126 *local_got
= (bfd_vma
) -1;
3131 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3134 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3136 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3138 if (local_funcdesc
->refcount
> 0)
3140 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3141 htab
->sfuncdesc
->size
+= 8;
3142 if (!bfd_link_pic (info
))
3143 htab
->srofixup
->size
+= 8;
3145 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3148 local_funcdesc
->offset
= MINUS_ONE
;
3154 if (htab
->tls_ldm_got
.refcount
> 0)
3156 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3158 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
3159 htab
->root
.sgot
->size
+= 8;
3160 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
3163 htab
->tls_ldm_got
.offset
= -1;
3165 /* Only the reserved entries should be present. For FDPIC, they go at
3166 the end of .got.plt. */
3169 BFD_ASSERT (htab
->root
.sgotplt
&& htab
->root
.sgotplt
->size
== 12);
3170 htab
->root
.sgotplt
->size
= 0;
3173 /* Allocate global sym .plt and .got entries, and space for global
3174 sym dynamic relocs. */
3175 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3177 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3178 end of the FDPIC .got.plt. */
3181 htab
->root
.hgot
->root
.u
.def
.value
= htab
->root
.sgotplt
->size
;
3182 htab
->root
.sgotplt
->size
+= 12;
3185 /* At the very end of the .rofixup section is a pointer to the GOT. */
3186 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3187 htab
->srofixup
->size
+= 4;
3189 /* We now have determined the sizes of the various dynamic sections.
3190 Allocate memory for them. */
3192 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3194 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3197 if (s
== htab
->root
.splt
3198 || s
== htab
->root
.sgot
3199 || s
== htab
->root
.sgotplt
3200 || s
== htab
->sfuncdesc
3201 || s
== htab
->srofixup
3202 || s
== htab
->sdynbss
)
3204 /* Strip this section if we don't need it; see the
3207 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
3209 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
&& s
!= htab
->srelplt2
)
3212 /* We use the reloc_count field as a counter if we need
3213 to copy relocs into the output file. */
3218 /* It's not one of our sections, so don't allocate space. */
3224 /* If we don't need this section, strip it from the
3225 output file. This is mostly to handle .rela.bss and
3226 .rela.plt. We must create both sections in
3227 create_dynamic_sections, because they must be created
3228 before the linker maps input sections to output
3229 sections. The linker does that before
3230 adjust_dynamic_symbol is called, and it is that
3231 function which decides whether anything needs to go
3232 into these sections. */
3234 s
->flags
|= SEC_EXCLUDE
;
3238 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3241 /* Allocate memory for the section contents. We use bfd_zalloc
3242 here in case unused entries are not reclaimed before the
3243 section's contents are written out. This should not happen,
3244 but this way if it does, we get a R_SH_NONE reloc instead
3246 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3247 if (s
->contents
== NULL
)
3251 if (htab
->root
.dynamic_sections_created
)
3253 /* Add some entries to the .dynamic section. We fill in the
3254 values later, in sh_elf_finish_dynamic_sections, but we
3255 must add the entries now so that we get the correct size for
3256 the .dynamic section. The DT_DEBUG entry is filled in by the
3257 dynamic linker and used by the debugger. */
3258 #define add_dynamic_entry(TAG, VAL) \
3259 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3261 if (bfd_link_executable (info
))
3263 if (! add_dynamic_entry (DT_DEBUG
, 0))
3267 if (htab
->root
.splt
->size
!= 0)
3269 if (! add_dynamic_entry (DT_PLTGOT
, 0)
3270 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
3271 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3272 || ! add_dynamic_entry (DT_JMPREL
, 0))
3275 else if ((elf_elfheader (output_bfd
)->e_flags
& EF_SH_FDPIC
))
3277 if (! add_dynamic_entry (DT_PLTGOT
, 0))
3283 if (! add_dynamic_entry (DT_RELA
, 0)
3284 || ! add_dynamic_entry (DT_RELASZ
, 0)
3285 || ! add_dynamic_entry (DT_RELAENT
,
3286 sizeof (Elf32_External_Rela
)))
3289 /* If any dynamic relocs apply to a read-only section,
3290 then we need a DT_TEXTREL entry. */
3291 if ((info
->flags
& DF_TEXTREL
) == 0)
3292 elf_link_hash_traverse (&htab
->root
, maybe_set_textrel
, info
);
3294 if ((info
->flags
& DF_TEXTREL
) != 0)
3296 if (! add_dynamic_entry (DT_TEXTREL
, 0))
3301 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3304 #undef add_dynamic_entry
3309 /* Add a dynamic relocation to the SRELOC section. */
3311 inline static bfd_vma
3312 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3313 int reloc_type
, long dynindx
, bfd_vma addend
)
3315 Elf_Internal_Rela outrel
;
3316 bfd_vma reloc_offset
;
3318 outrel
.r_offset
= offset
;
3319 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3320 outrel
.r_addend
= addend
;
3322 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3323 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3324 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3325 sreloc
->contents
+ reloc_offset
);
3326 sreloc
->reloc_count
++;
3328 return reloc_offset
;
3331 /* Add an FDPIC read-only fixup. */
3334 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3336 bfd_vma fixup_offset
;
3338 fixup_offset
= srofixup
->reloc_count
++ * 4;
3339 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3340 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3343 /* Return the offset of the generated .got section from the
3344 _GLOBAL_OFFSET_TABLE_ symbol. */
3346 static bfd_signed_vma
3347 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3349 return (htab
->root
.sgot
->output_offset
- htab
->root
.sgotplt
->output_offset
3350 - htab
->root
.hgot
->root
.u
.def
.value
);
3353 /* Find the segment number in which OSEC, and output section, is
3357 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3359 Elf_Internal_Phdr
*p
= NULL
;
3361 if (output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
3362 /* PR ld/17110: Do not look for output segments in an input bfd. */
3363 && output_bfd
->direction
!= read_direction
)
3364 p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
3366 /* FIXME: Nothing ever says what this index is relative to. The kernel
3367 supplies data in terms of the number of load segments but this is
3368 a phdr index and the first phdr may not be a load segment. */
3369 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3373 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3375 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3377 return (seg
!= (unsigned) -1
3378 && ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
));
3381 /* Generate the initial contents of a local function descriptor, along
3382 with any relocations or fixups required. */
3384 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3385 struct bfd_link_info
*info
,
3386 struct elf_link_hash_entry
*h
,
3391 struct elf_sh_link_hash_table
*htab
;
3395 htab
= sh_elf_hash_table (info
);
3397 /* FIXME: The ABI says that the offset to the function goes in the
3398 descriptor, along with the segment index. We're RELA, so it could
3399 go in the reloc instead... */
3401 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3403 section
= h
->root
.u
.def
.section
;
3404 value
= h
->root
.u
.def
.value
;
3407 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3409 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3410 addr
= value
+ section
->output_offset
;
3411 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3415 BFD_ASSERT (h
->dynindx
!= -1);
3416 dynindx
= h
->dynindx
;
3420 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
3422 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3424 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3426 + htab
->sfuncdesc
->output_section
->vma
3427 + htab
->sfuncdesc
->output_offset
);
3428 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3430 + htab
->sfuncdesc
->output_section
->vma
3431 + htab
->sfuncdesc
->output_offset
);
3434 /* There are no dynamic relocations so fill in the final
3435 address and gp value (barring fixups). */
3436 addr
+= section
->output_section
->vma
;
3437 seg
= htab
->root
.hgot
->root
.u
.def
.value
3438 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3439 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3442 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3444 + htab
->sfuncdesc
->output_section
->vma
3445 + htab
->sfuncdesc
->output_offset
,
3446 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3448 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3449 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3454 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3455 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3458 static bfd_reloc_status_type
3459 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3460 bfd
*input_bfd
, asection
*input_section
,
3461 bfd_byte
*contents
, bfd_vma offset
)
3463 unsigned long cur_val
;
3465 bfd_reloc_status_type r
;
3467 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3468 return bfd_reloc_outofrange
;
3470 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3471 bfd_arch_bits_per_address (input_bfd
), relocation
);
3472 if (r
!= bfd_reloc_ok
)
3475 addr
= contents
+ offset
;
3476 cur_val
= bfd_get_16 (output_bfd
, addr
);
3477 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3478 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3480 return bfd_reloc_ok
;
3483 /* Relocate an SH ELF section. */
3486 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3487 bfd
*input_bfd
, asection
*input_section
,
3488 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3489 Elf_Internal_Sym
*local_syms
,
3490 asection
**local_sections
)
3492 struct elf_sh_link_hash_table
*htab
;
3493 Elf_Internal_Shdr
*symtab_hdr
;
3494 struct elf_link_hash_entry
**sym_hashes
;
3495 Elf_Internal_Rela
*rel
, *relend
;
3496 bfd_vma
*local_got_offsets
;
3497 asection
*sgot
= NULL
;
3498 asection
*sgotplt
= NULL
;
3499 asection
*splt
= NULL
;
3500 asection
*sreloc
= NULL
;
3501 asection
*srelgot
= NULL
;
3502 bfd_boolean is_vxworks_tls
;
3503 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3504 bfd_boolean fdpic_p
= FALSE
;
3506 if (!is_sh_elf (input_bfd
))
3508 bfd_set_error (bfd_error_wrong_format
);
3512 htab
= sh_elf_hash_table (info
);
3515 sgot
= htab
->root
.sgot
;
3516 sgotplt
= htab
->root
.sgotplt
;
3517 srelgot
= htab
->root
.srelgot
;
3518 splt
= htab
->root
.splt
;
3519 fdpic_p
= htab
->fdpic_p
;
3521 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3522 sym_hashes
= elf_sym_hashes (input_bfd
);
3523 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3525 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3526 input_section
->output_section
);
3527 if (fdpic_p
&& sgot
)
3528 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3529 sgot
->output_section
);
3532 if (fdpic_p
&& splt
)
3533 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3534 splt
->output_section
);
3538 /* We have to handle relocations in vxworks .tls_vars sections
3539 specially, because the dynamic loader is 'weird'. */
3540 is_vxworks_tls
= (htab
&& htab
->vxworks_p
&& bfd_link_pic (info
)
3541 && !strcmp (input_section
->output_section
->name
,
3545 relend
= relocs
+ input_section
->reloc_count
;
3546 for (; rel
< relend
; rel
++)
3549 reloc_howto_type
*howto
;
3550 unsigned long r_symndx
;
3551 Elf_Internal_Sym
*sym
;
3553 struct elf_link_hash_entry
*h
;
3555 bfd_vma addend
= (bfd_vma
) 0;
3556 bfd_reloc_status_type r
;
3558 enum got_type got_type
;
3559 const char *symname
= NULL
;
3560 bfd_boolean resolved_to_zero
;
3562 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3564 r_type
= ELF32_R_TYPE (rel
->r_info
);
3566 /* Many of the relocs are only used for relaxing, and are
3567 handled entirely by the relaxation code. */
3568 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3569 && r_type
<= (int) R_SH_LABEL
)
3571 if (r_type
== (int) R_SH_NONE
)
3575 || r_type
>= R_SH_max
3576 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3577 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3578 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3579 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
3580 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3581 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3582 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3583 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3584 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3585 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3586 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
3587 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
3589 bfd_set_error (bfd_error_bad_value
);
3593 howto
= get_howto_table (output_bfd
) + r_type
;
3595 /* For relocs that aren't partial_inplace, we get the addend from
3597 if (! howto
->partial_inplace
)
3598 addend
= rel
->r_addend
;
3600 resolved_to_zero
= FALSE
;
3604 check_segment
[0] = -1;
3605 check_segment
[1] = -1;
3606 if (r_symndx
< symtab_hdr
->sh_info
)
3608 sym
= local_syms
+ r_symndx
;
3609 sec
= local_sections
[r_symndx
];
3611 symname
= bfd_elf_string_from_elf_section
3612 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
3613 if (symname
== NULL
|| *symname
== '\0')
3614 symname
= bfd_section_name (sec
);
3616 relocation
= (sec
->output_section
->vma
3617 + sec
->output_offset
3620 if (sec
!= NULL
&& discarded_section (sec
))
3621 /* Handled below. */
3623 else if (bfd_link_relocatable (info
))
3625 /* This is a relocatable link. We don't have to change
3626 anything, unless the reloc is against a section symbol,
3627 in which case we have to adjust according to where the
3628 section symbol winds up in the output section. */
3629 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3631 if (! howto
->partial_inplace
)
3633 /* For relocations with the addend in the
3634 relocation, we need just to update the addend.
3635 All real relocs are of type partial_inplace; this
3636 code is mostly for completeness. */
3637 rel
->r_addend
+= sec
->output_offset
;
3642 /* Relocs of type partial_inplace need to pick up the
3643 contents in the contents and add the offset resulting
3644 from the changed location of the section symbol.
3645 Using _bfd_final_link_relocate (e.g. goto
3646 final_link_relocate) here would be wrong, because
3647 relocations marked pc_relative would get the current
3648 location subtracted, and we must only do that at the
3650 r
= _bfd_relocate_contents (howto
, input_bfd
,
3653 contents
+ rel
->r_offset
);
3654 goto relocation_done
;
3659 else if (! howto
->partial_inplace
)
3661 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3662 addend
= rel
->r_addend
;
3664 else if ((sec
->flags
& SEC_MERGE
)
3665 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3669 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
3672 /* xgettext:c-format */
3673 (_("%pB(%pA+%#" PRIx64
"): "
3674 "%s relocation against SEC_MERGE section"),
3675 input_bfd
, input_section
,
3676 (uint64_t) rel
->r_offset
, howto
->name
);
3680 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3683 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
3685 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3686 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
3692 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
3695 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3696 symname
= h
->root
.root
.string
;
3697 while (h
->root
.type
== bfd_link_hash_indirect
3698 || h
->root
.type
== bfd_link_hash_warning
)
3699 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3700 if (h
->root
.type
== bfd_link_hash_defined
3701 || h
->root
.type
== bfd_link_hash_defweak
)
3705 dyn
= htab
? htab
->root
.dynamic_sections_created
: FALSE
;
3706 sec
= h
->root
.u
.def
.section
;
3707 /* In these cases, we don't need the relocation value.
3708 We check specially because in some obscure cases
3709 sec->output_section will be NULL. */
3710 if (r_type
== R_SH_GOTPC
3711 || r_type
== R_SH_GOTPC_LOW16
3712 || r_type
== R_SH_GOTPC_MEDLOW16
3713 || r_type
== R_SH_GOTPC_MEDHI16
3714 || r_type
== R_SH_GOTPC_HI16
3715 || ((r_type
== R_SH_PLT32
3716 || r_type
== R_SH_PLT_LOW16
3717 || r_type
== R_SH_PLT_MEDLOW16
3718 || r_type
== R_SH_PLT_MEDHI16
3719 || r_type
== R_SH_PLT_HI16
)
3720 && h
->plt
.offset
!= (bfd_vma
) -1)
3721 || ((r_type
== R_SH_GOT32
3722 || r_type
== R_SH_GOT20
3723 || r_type
== R_SH_GOTFUNCDESC
3724 || r_type
== R_SH_GOTFUNCDESC20
3725 || r_type
== R_SH_GOTOFFFUNCDESC
3726 || r_type
== R_SH_GOTOFFFUNCDESC20
3727 || r_type
== R_SH_FUNCDESC
3728 || r_type
== R_SH_GOT_LOW16
3729 || r_type
== R_SH_GOT_MEDLOW16
3730 || r_type
== R_SH_GOT_MEDHI16
3731 || r_type
== R_SH_GOT_HI16
)
3732 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3733 bfd_link_pic (info
),
3735 && (! bfd_link_pic (info
)
3736 || (! info
->symbolic
&& h
->dynindx
!= -1)
3737 || !h
->def_regular
))
3738 /* The cases above are those in which relocation is
3739 overwritten in the switch block below. The cases
3740 below are those in which we must defer relocation
3741 to run-time, because we can't resolve absolute
3742 addresses when creating a shared library. */
3743 || (bfd_link_pic (info
)
3744 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3746 && ((r_type
== R_SH_DIR32
3747 && !h
->forced_local
)
3748 || (r_type
== R_SH_REL32
3749 && !SYMBOL_CALLS_LOCAL (info
, h
)))
3750 && ((input_section
->flags
& SEC_ALLOC
) != 0
3751 /* DWARF will emit R_SH_DIR32 relocations in its
3752 sections against symbols defined externally
3753 in shared libraries. We can't do anything
3755 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
3756 && h
->def_dynamic
)))
3757 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3758 sections because such sections are not SEC_ALLOC and
3759 thus ld.so will not process them. */
3760 || (sec
->output_section
== NULL
3761 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
3763 || (sec
->output_section
== NULL
3764 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
3765 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
3767 else if (sec
->output_section
!= NULL
)
3768 relocation
= (h
->root
.u
.def
.value
3769 + sec
->output_section
->vma
3770 + sec
->output_offset
);
3771 else if (!bfd_link_relocatable (info
)
3772 && (_bfd_elf_section_offset (output_bfd
, info
,
3778 /* xgettext:c-format */
3779 (_("%pB(%pA+%#" PRIx64
"): "
3780 "unresolvable %s relocation against symbol `%s'"),
3783 (uint64_t) rel
->r_offset
,
3785 h
->root
.root
.string
);
3789 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3790 resolved_to_zero
= UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
);
3791 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3792 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3794 else if (!bfd_link_relocatable (info
))
3795 info
->callbacks
->undefined_symbol
3796 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
3798 (info
->unresolved_syms_in_objects
== RM_DIAGNOSE
3799 && !info
->warn_unresolved_syms
)
3800 || ELF_ST_VISIBILITY (h
->other
));
3803 if (sec
!= NULL
&& discarded_section (sec
))
3804 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3805 rel
, 1, relend
, howto
, 0, contents
);
3807 if (bfd_link_relocatable (info
))
3810 /* Check for inter-segment relocations in FDPIC files. Most
3811 relocations connect the relocation site to the location of
3812 the target symbol, but there are some exceptions below. */
3813 check_segment
[0] = isec_segment
;
3815 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
3816 sec
->output_section
);
3818 check_segment
[1] = -1;
3820 switch ((int) r_type
)
3822 final_link_relocate
:
3823 /* COFF relocs don't use the addend. The addend is used for
3824 R_SH_DIR32 to be compatible with other compilers. */
3825 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3826 contents
, rel
->r_offset
,
3827 relocation
, addend
);
3831 goto final_link_relocate
;
3836 /* If the reloc is against the start of this section, then
3837 the assembler has already taken care of it and the reloc
3838 is here only to assist in relaxing. If the reloc is not
3839 against the start of this section, then it's against an
3840 external symbol and we must deal with it ourselves. */
3841 if (input_section
->output_section
->vma
+ input_section
->output_offset
3844 int disp
= (relocation
3845 - input_section
->output_section
->vma
3846 - input_section
->output_offset
3852 case R_SH_DIR8WPZ
: mask
= 1; break;
3853 case R_SH_DIR8WPL
: mask
= 3; break;
3854 default: mask
= 0; break;
3859 /* xgettext:c-format */
3860 (_("%pB: %#" PRIx64
": fatal: "
3861 "unaligned branch target for relax-support relocation"),
3862 input_section
->owner
,
3863 (uint64_t) rel
->r_offset
);
3864 bfd_set_error (bfd_error_bad_value
);
3868 goto final_link_relocate
;
3874 bfd_set_error (bfd_error_bad_value
);
3882 goto final_link_relocate
;
3889 /* xgettext:c-format */
3890 (_("%pB: %#" PRIx64
": fatal: "
3891 "unaligned %s relocation %#" PRIx64
),
3892 input_section
->owner
, (uint64_t) rel
->r_offset
,
3893 howto
->name
, (uint64_t) relocation
);
3894 bfd_set_error (bfd_error_bad_value
);
3897 goto final_link_relocate
;
3905 /* xgettext:c-format */
3906 (_("%pB: %#" PRIx64
": fatal: "
3907 "unaligned %s relocation %#" PRIx64
""),
3908 input_section
->owner
,
3909 (uint64_t) rel
->r_offset
, howto
->name
,
3910 (uint64_t) relocation
);
3911 bfd_set_error (bfd_error_bad_value
);
3914 goto final_link_relocate
;
3917 if ((signed int)relocation
< -32
3918 || (signed int)relocation
> 32)
3921 /* xgettext:c-format */
3922 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHA relocation %" PRId64
3923 " not in range -32..32"),
3924 input_section
->owner
,
3925 (uint64_t) rel
->r_offset
,
3926 (int64_t) relocation
);
3927 bfd_set_error (bfd_error_bad_value
);
3930 goto final_link_relocate
;
3933 if ((signed int)relocation
< -16
3934 || (signed int)relocation
> 16)
3937 /* xgettext:c-format */
3938 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHL relocation %" PRId64
3939 " not in range -32..32"),
3940 input_section
->owner
,
3941 (uint64_t) rel
->r_offset
,
3942 (int64_t) relocation
);
3943 bfd_set_error (bfd_error_bad_value
);
3946 goto final_link_relocate
;
3950 if (bfd_link_pic (info
)
3952 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3953 && !resolved_to_zero
)
3954 || h
->root
.type
!= bfd_link_hash_undefweak
)
3955 && r_symndx
!= STN_UNDEF
3956 && (input_section
->flags
& SEC_ALLOC
) != 0
3958 && (r_type
== R_SH_DIR32
3959 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3961 Elf_Internal_Rela outrel
;
3963 bfd_boolean skip
, relocate
;
3965 /* When generating a shared object, these relocations
3966 are copied into the output file to be resolved at run
3971 sreloc
= _bfd_elf_get_dynamic_reloc_section
3972 (input_bfd
, input_section
, /*rela?*/ TRUE
);
3981 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3983 if (outrel
.r_offset
== (bfd_vma
) -1)
3985 else if (outrel
.r_offset
== (bfd_vma
) -2)
3986 skip
= TRUE
, relocate
= TRUE
;
3987 outrel
.r_offset
+= (input_section
->output_section
->vma
3988 + input_section
->output_offset
);
3991 memset (&outrel
, 0, sizeof outrel
);
3992 else if (r_type
== R_SH_REL32
)
3994 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3995 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
3997 = (howto
->partial_inplace
3998 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4003 || ((info
->symbolic
|| h
->dynindx
== -1)
4004 && h
->def_regular
)))
4008 BFD_ASSERT (sec
!= NULL
);
4009 BFD_ASSERT (sec
->output_section
!= NULL
);
4010 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
4011 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4012 outrel
.r_addend
= relocation
;
4014 += (howto
->partial_inplace
4015 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4017 outrel
.r_addend
-= sec
->output_section
->vma
;
4021 /* h->dynindx may be -1 if this symbol was marked to
4024 || ((info
->symbolic
|| h
->dynindx
== -1)
4027 relocate
= howto
->partial_inplace
;
4028 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4032 BFD_ASSERT (h
->dynindx
!= -1);
4033 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
4035 outrel
.r_addend
= relocation
;
4037 += (howto
->partial_inplace
4038 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4042 loc
= sreloc
->contents
;
4043 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4044 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4046 check_segment
[0] = check_segment
[1] = -1;
4048 /* If this reloc is against an external symbol, we do
4049 not want to fiddle with the addend. Otherwise, we
4050 need to include the symbol value so that it becomes
4051 an addend for the dynamic reloc. */
4055 else if (fdpic_p
&& !bfd_link_pic (info
)
4056 && r_type
== R_SH_DIR32
4057 && (input_section
->flags
& SEC_ALLOC
) != 0)
4063 if (sh_elf_osec_readonly_p (output_bfd
,
4064 input_section
->output_section
))
4067 /* xgettext:c-format */
4068 (_("%pB(%pA+%#" PRIx64
"): "
4069 "cannot emit fixup to `%s' in read-only section"),
4072 (uint64_t) rel
->r_offset
,
4077 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4078 input_section
, rel
->r_offset
);
4079 if (offset
!= (bfd_vma
)-1)
4080 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4081 input_section
->output_section
->vma
4082 + input_section
->output_offset
4085 check_segment
[0] = check_segment
[1] = -1;
4087 /* We don't want warnings for non-NULL tests on undefined weak
4089 else if (r_type
== R_SH_REL32
4091 && h
->root
.type
== bfd_link_hash_undefweak
)
4092 check_segment
[0] = check_segment
[1] = -1;
4093 goto final_link_relocate
;
4096 /* Relocation is to the entry for this symbol in the
4097 procedure linkage table. */
4101 || ! bfd_link_pic (info
)
4104 || h
->plt
.offset
== (bfd_vma
) -1
4105 || h
->got
.offset
!= (bfd_vma
) -1)
4108 /* Relocation is to the entry for this symbol in the global
4109 offset table extension for the procedure linkage table. */
4112 BFD_ASSERT (sgotplt
!= NULL
);
4113 relocation
= (sgotplt
->output_offset
4114 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4118 relocation
-= GOT_BIAS
;
4121 goto final_link_relocate
;
4126 /* Relocation is to the entry for this symbol in the global
4130 BFD_ASSERT (sgot
!= NULL
);
4131 check_segment
[0] = check_segment
[1] = -1;
4137 off
= h
->got
.offset
;
4138 BFD_ASSERT (off
!= (bfd_vma
) -1);
4140 dyn
= htab
->root
.dynamic_sections_created
;
4141 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4142 bfd_link_pic (info
),
4144 || (bfd_link_pic (info
)
4145 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4146 || ((ELF_ST_VISIBILITY (h
->other
)
4147 || resolved_to_zero
)
4148 && h
->root
.type
== bfd_link_hash_undefweak
))
4150 /* This is actually a static link, or it is a
4151 -Bsymbolic link and the symbol is defined
4152 locally, or the symbol was forced to be local
4153 because of a version file. We must initialize
4154 this entry in the global offset table. Since the
4155 offset must always be a multiple of 4, we use the
4156 least significant bit to record whether we have
4157 initialized it already.
4159 When doing a dynamic link, we create a .rela.got
4160 relocation entry to initialize the value. This
4161 is done in the finish_dynamic_symbol routine. */
4166 bfd_put_32 (output_bfd
, relocation
,
4167 sgot
->contents
+ off
);
4170 /* If we initialize the GOT entry here with a valid
4171 symbol address, also add a fixup. */
4172 if (fdpic_p
&& !bfd_link_pic (info
)
4173 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4174 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4175 || h
->root
.type
!= bfd_link_hash_undefweak
))
4176 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4177 sgot
->output_section
->vma
4178 + sgot
->output_offset
4183 relocation
= sh_elf_got_offset (htab
) + off
;
4187 BFD_ASSERT (local_got_offsets
!= NULL
4188 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4190 off
= local_got_offsets
[r_symndx
];
4192 /* The offset must always be a multiple of 4. We use
4193 the least significant bit to record whether we have
4194 already generated the necessary reloc. */
4199 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4201 if (bfd_link_pic (info
))
4203 Elf_Internal_Rela outrel
;
4206 outrel
.r_offset
= (sgot
->output_section
->vma
4207 + sgot
->output_offset
4212 = elf_section_data (sec
->output_section
)->dynindx
;
4213 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4214 outrel
.r_addend
= relocation
;
4215 outrel
.r_addend
-= sec
->output_section
->vma
;
4219 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4220 outrel
.r_addend
= relocation
;
4222 loc
= srelgot
->contents
;
4223 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4224 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4227 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4229 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4230 sgot
->output_section
->vma
4231 + sgot
->output_offset
4234 local_got_offsets
[r_symndx
] |= 1;
4237 relocation
= sh_elf_got_offset (htab
) + off
;
4241 relocation
-= GOT_BIAS
;
4244 if (r_type
== R_SH_GOT20
)
4246 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4247 input_bfd
, input_section
, contents
,
4252 goto final_link_relocate
;
4256 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4257 we place at the start of the .got.plt section. This is the same
4258 as the start of the output .got section, unless there are function
4259 descriptors in front of it. */
4261 BFD_ASSERT (sgotplt
!= NULL
);
4262 check_segment
[0] = got_segment
;
4263 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4264 + htab
->root
.hgot
->root
.u
.def
.value
;
4267 relocation
-= GOT_BIAS
;
4270 addend
= rel
->r_addend
;
4272 if (r_type
== R_SH_GOTOFF20
)
4274 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4275 input_bfd
, input_section
, contents
,
4280 goto final_link_relocate
;
4283 /* Use global offset table as symbol value. */
4285 BFD_ASSERT (sgotplt
!= NULL
);
4286 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4289 relocation
+= GOT_BIAS
;
4292 addend
= rel
->r_addend
;
4294 goto final_link_relocate
;
4297 /* Relocation is to the entry for this symbol in the
4298 procedure linkage table. */
4300 /* Resolve a PLT reloc against a local symbol directly,
4301 without using the procedure linkage table. */
4303 goto final_link_relocate
;
4305 /* We don't want to warn on calls to undefined weak symbols,
4306 as calls to them must be protected by non-NULL tests
4307 anyway, and unprotected calls would invoke undefined
4309 if (h
->root
.type
== bfd_link_hash_undefweak
)
4310 check_segment
[0] = check_segment
[1] = -1;
4312 if (h
->forced_local
)
4313 goto final_link_relocate
;
4315 if (h
->plt
.offset
== (bfd_vma
) -1)
4317 /* We didn't make a PLT entry for this symbol. This
4318 happens when statically linking PIC code, or when
4319 using -Bsymbolic. */
4320 goto final_link_relocate
;
4323 BFD_ASSERT (splt
!= NULL
);
4324 check_segment
[1] = plt_segment
;
4325 relocation
= (splt
->output_section
->vma
4326 + splt
->output_offset
4329 addend
= rel
->r_addend
;
4331 goto final_link_relocate
;
4333 /* Relocation is to the canonical function descriptor for this
4334 symbol, possibly via the GOT. Initialize the GOT
4335 entry and function descriptor if necessary. */
4336 case R_SH_GOTFUNCDESC
:
4337 case R_SH_GOTFUNCDESC20
:
4341 asection
*reloc_section
;
4342 bfd_vma reloc_offset
;
4343 int reloc_type
= R_SH_FUNCDESC
;
4347 check_segment
[0] = check_segment
[1] = -1;
4349 /* FIXME: See what FRV does for global symbols in the
4350 executable, with --export-dynamic. Do they need ld.so
4351 to allocate official descriptors? See what this code
4357 if (r_type
== R_SH_FUNCDESC
)
4359 reloc_section
= input_section
;
4360 reloc_offset
= rel
->r_offset
;
4364 reloc_section
= sgot
;
4367 reloc_offset
= h
->got
.offset
;
4370 BFD_ASSERT (local_got_offsets
!= NULL
);
4371 reloc_offset
= local_got_offsets
[r_symndx
];
4373 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4375 if (reloc_offset
& 1)
4378 goto funcdesc_done_got
;
4382 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4383 && (SYMBOL_CALLS_LOCAL (info
, h
)
4384 || !htab
->root
.dynamic_sections_created
))
4385 /* Undefined weak symbol which will not be dynamically
4386 resolved later; leave it at zero. */
4387 goto funcdesc_leave_zero
;
4388 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4389 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4391 /* If the symbol needs a non-local function descriptor
4392 but binds locally (i.e., its visibility is
4393 protected), emit a dynamic relocation decayed to
4394 section+offset. This is an optimization; the dynamic
4395 linker would resolve our function descriptor request
4396 to our copy of the function anyway. */
4397 dynindx
= elf_section_data (h
->root
.u
.def
.section
4398 ->output_section
)->dynindx
;
4399 relocation
+= h
->root
.u
.def
.section
->output_offset
4400 + h
->root
.u
.def
.value
;
4402 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4404 /* If the symbol is dynamic and there will be dynamic
4405 symbol resolution because we are or are linked with a
4406 shared library, emit a FUNCDESC relocation such that
4407 the dynamic linker will allocate the function
4409 BFD_ASSERT (h
->dynindx
!= -1);
4410 dynindx
= h
->dynindx
;
4416 /* Otherwise, we know we have a private function
4417 descriptor, so reference it directly. */
4418 reloc_type
= R_SH_DIR32
;
4419 dynindx
= elf_section_data (htab
->sfuncdesc
4420 ->output_section
)->dynindx
;
4424 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4425 BFD_ASSERT (offset
!= MINUS_ONE
);
4426 if ((offset
& 1) == 0)
4428 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4431 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4436 union gotref
*local_funcdesc
;
4438 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4439 offset
= local_funcdesc
[r_symndx
].offset
;
4440 BFD_ASSERT (offset
!= MINUS_ONE
);
4441 if ((offset
& 1) == 0)
4443 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4447 local_funcdesc
[r_symndx
].offset
|= 1;
4451 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4454 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
4458 if (sh_elf_osec_readonly_p (output_bfd
,
4459 reloc_section
->output_section
))
4462 /* xgettext:c-format */
4463 (_("%pB(%pA+%#" PRIx64
"): "
4464 "cannot emit fixup to `%s' in read-only section"),
4467 (uint64_t) rel
->r_offset
,
4472 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4473 reloc_section
, reloc_offset
);
4475 if (offset
!= (bfd_vma
)-1)
4476 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4478 + reloc_section
->output_section
->vma
4479 + reloc_section
->output_offset
);
4481 else if ((reloc_section
->output_section
->flags
4482 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
4486 if (sh_elf_osec_readonly_p (output_bfd
,
4487 reloc_section
->output_section
))
4489 info
->callbacks
->warning
4491 _("cannot emit dynamic relocations in read-only section"),
4492 symname
, input_bfd
, reloc_section
, reloc_offset
);
4496 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4497 reloc_section
, reloc_offset
);
4499 if (offset
!= (bfd_vma
)-1)
4500 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
4502 + reloc_section
->output_section
->vma
4503 + reloc_section
->output_offset
,
4504 reloc_type
, dynindx
, relocation
);
4506 if (r_type
== R_SH_FUNCDESC
)
4514 goto funcdesc_leave_zero
;
4518 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
4519 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
4520 funcdesc_leave_zero
:
4521 if (r_type
!= R_SH_FUNCDESC
)
4523 bfd_put_32 (output_bfd
, relocation
,
4524 reloc_section
->contents
+ reloc_offset
);
4528 local_got_offsets
[r_symndx
] |= 1;
4532 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
4534 relocation
-= GOT_BIAS
;
4537 if (r_type
== R_SH_GOTFUNCDESC20
)
4539 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4540 input_bfd
, input_section
, contents
,
4545 goto final_link_relocate
;
4549 case R_SH_GOTOFFFUNCDESC
:
4550 case R_SH_GOTOFFFUNCDESC20
:
4551 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4552 executable and --export-dynamic. If such symbols get
4553 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4557 check_segment
[0] = check_segment
[1] = -1;
4559 addend
= rel
->r_addend
;
4561 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
4562 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
4565 /* xgettext:c-format */
4566 (_("%pB(%pA+%#" PRIx64
"): "
4567 "%s relocation against external symbol \"%s\""),
4568 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
4569 howto
->name
, h
->root
.root
.string
);
4576 /* Otherwise, we know we have a private function
4577 descriptor, so reference it directly. */
4580 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4581 BFD_ASSERT (offset
!= MINUS_ONE
);
4582 if ((offset
& 1) == 0)
4584 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4587 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4592 union gotref
*local_funcdesc
;
4594 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4595 offset
= local_funcdesc
[r_symndx
].offset
;
4596 BFD_ASSERT (offset
!= MINUS_ONE
);
4597 if ((offset
& 1) == 0)
4599 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4603 local_funcdesc
[r_symndx
].offset
|= 1;
4607 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4610 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
4611 + sgotplt
->output_offset
);
4613 relocation
-= GOT_BIAS
;
4616 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
4618 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4619 input_bfd
, input_section
, contents
,
4624 goto final_link_relocate
;
4626 case R_SH_LOOP_START
:
4628 static bfd_vma start
, end
;
4630 start
= (relocation
+ rel
->r_addend
4631 - (sec
->output_section
->vma
+ sec
->output_offset
));
4632 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4633 rel
->r_offset
, sec
, start
, end
);
4637 end
= (relocation
+ rel
->r_addend
4638 - (sec
->output_section
->vma
+ sec
->output_offset
));
4639 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4640 rel
->r_offset
, sec
, start
, end
);
4644 case R_SH_TLS_GD_32
:
4645 case R_SH_TLS_IE_32
:
4647 check_segment
[0] = check_segment
[1] = -1;
4648 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
4649 got_type
= GOT_UNKNOWN
;
4650 if (h
== NULL
&& local_got_offsets
)
4651 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
4654 got_type
= sh_elf_hash_entry (h
)->got_type
;
4655 if (! bfd_link_pic (info
)
4656 && (h
->dynindx
== -1
4658 r_type
= R_SH_TLS_LE_32
;
4661 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
4662 r_type
= R_SH_TLS_IE_32
;
4664 if (r_type
== R_SH_TLS_LE_32
)
4667 unsigned short insn
;
4669 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
4671 /* GD->LE transition:
4672 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4673 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4674 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4676 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4678 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
4680 offset
= rel
->r_offset
;
4684 /* xgettext:c-format */
4685 (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64
),
4686 input_bfd
, input_section
, (uint64_t) offset
);
4690 /* Size of GD instructions is 16 or 18. */
4692 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4693 if ((insn
& 0xff00) == 0xc700)
4695 BFD_ASSERT (offset
>= 2);
4697 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4700 if ((insn
& 0xff00) != 0xd400)
4702 /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */
4703 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd4?\?)"),
4704 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4706 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4708 if ((insn
& 0xff00) != 0xc700)
4710 /* xgettext:c-format */
4711 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xc7?\?)"),
4712 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4714 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4715 if ((insn
& 0xff00) != 0xd100)
4717 /* xgettext:c-format */
4718 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd1?\?)"),
4719 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4721 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4724 /* xgettext:c-format */
4725 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x310c)"),
4726 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4728 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4731 /* xgettext:c-format */
4732 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x410b)"),
4733 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4735 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4738 /* xgettext:c-format */
4739 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x34cc)"),
4740 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4742 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
4743 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
4744 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4745 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4746 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4752 /* IE->LE transition:
4769 offset
= rel
->r_offset
;
4773 /* xgettext:c-format */
4774 (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64
),
4775 input_bfd
, input_section
, (uint64_t) offset
);
4779 /* Size of IE instructions is 10 or 12. */
4781 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4782 if ((insn
& 0xf0ff) == 0x0012)
4784 BFD_ASSERT (offset
>= 2);
4786 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4789 if ((insn
& 0xff00) != 0xd000)
4791 /* xgettext:c-format */
4792 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
4793 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4795 target
= insn
& 0x00ff;
4797 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4798 if ((insn
& 0xf0ff) != 0x0012)
4800 /* xgettext:c-format */
4801 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?12: stc)"),
4802 input_bfd
, input_section
, (uint64_t) (offset
+ 2), (int) insn
);
4804 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4805 if ((insn
& 0xf0ff) != 0x00ce)
4807 /* xgettext:c-format */
4808 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
4809 input_bfd
, input_section
, (uint64_t) (offset
+ 4), (int) insn
);
4811 insn
= 0xd000 | (insn
& 0x0f00) | target
;
4812 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
4813 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4816 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4817 contents
+ rel
->r_offset
);
4821 if (sgot
== NULL
|| sgotplt
== NULL
)
4825 off
= h
->got
.offset
;
4828 if (local_got_offsets
== NULL
)
4831 off
= local_got_offsets
[r_symndx
];
4834 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
4835 if (r_type
== R_SH_TLS_IE_32
4836 && ! htab
->root
.dynamic_sections_created
)
4839 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4840 sgot
->contents
+ off
);
4841 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4842 contents
+ rel
->r_offset
);
4850 Elf_Internal_Rela outrel
;
4854 outrel
.r_offset
= (sgot
->output_section
->vma
4855 + sgot
->output_offset
+ off
);
4857 if (h
== NULL
|| h
->dynindx
== -1)
4862 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
4864 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
4865 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4867 outrel
.r_addend
= 0;
4868 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4869 loc
= srelgot
->contents
;
4870 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4871 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4873 if (r_type
== R_SH_TLS_GD_32
)
4877 bfd_put_32 (output_bfd
,
4878 relocation
- dtpoff_base (info
),
4879 sgot
->contents
+ off
+ 4);
4883 outrel
.r_info
= ELF32_R_INFO (indx
,
4885 outrel
.r_offset
+= 4;
4886 outrel
.r_addend
= 0;
4887 srelgot
->reloc_count
++;
4888 loc
+= sizeof (Elf32_External_Rela
);
4889 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4896 local_got_offsets
[r_symndx
] |= 1;
4899 if (off
>= (bfd_vma
) -2)
4902 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
4903 relocation
= sh_elf_got_offset (htab
) + off
;
4907 unsigned short insn
;
4909 /* GD->IE transition:
4910 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4911 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4912 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4914 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4915 nop; nop; bra 3f; nop; .align 2;
4916 1: .long x@TPOFF; 2:...; 3:. */
4918 offset
= rel
->r_offset
;
4922 /* xgettext:c-format */
4923 (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64
),
4924 input_bfd
, input_section
, (uint64_t) offset
);
4928 /* Size of GD instructions is 16 or 18. */
4930 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4931 if ((insn
& 0xff00) == 0xc700)
4933 BFD_ASSERT (offset
>= 2);
4935 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4938 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4940 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
4941 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
4943 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4944 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4945 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4946 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4947 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4948 BFD_ASSERT (insn
== 0x310c);
4949 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4950 BFD_ASSERT (insn
== 0x410b);
4951 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4952 BFD_ASSERT (insn
== 0x34cc);
4954 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
4955 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
4956 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
4957 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4958 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4960 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4961 contents
+ rel
->r_offset
);
4966 addend
= rel
->r_addend
;
4968 goto final_link_relocate
;
4970 case R_SH_TLS_LD_32
:
4972 check_segment
[0] = check_segment
[1] = -1;
4973 if (! bfd_link_pic (info
))
4976 unsigned short insn
;
4978 /* LD->LE transition:
4979 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4980 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4981 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4983 stc gbr,r0; nop; nop; nop;
4984 nop; nop; bra 3f; ...; 3:. */
4986 offset
= rel
->r_offset
;
4990 /* xgettext:c-format */
4991 (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64
),
4992 input_bfd
, input_section
, (uint64_t) offset
);
4996 /* Size of LD instructions is 16 or 18. */
4998 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4999 if ((insn
& 0xff00) == 0xc700)
5001 BFD_ASSERT (offset
>= 2);
5003 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5006 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5007 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5008 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5009 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5010 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5011 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5012 BFD_ASSERT (insn
== 0x310c);
5013 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5014 BFD_ASSERT (insn
== 0x410b);
5015 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5016 BFD_ASSERT (insn
== 0x34cc);
5018 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
5019 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
5020 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5021 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5022 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5023 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5028 if (sgot
== NULL
|| sgotplt
== NULL
)
5031 off
= htab
->tls_ldm_got
.offset
;
5036 Elf_Internal_Rela outrel
;
5039 outrel
.r_offset
= (sgot
->output_section
->vma
5040 + sgot
->output_offset
+ off
);
5041 outrel
.r_addend
= 0;
5042 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
5043 loc
= srelgot
->contents
;
5044 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5045 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5046 htab
->tls_ldm_got
.offset
|= 1;
5049 relocation
= sh_elf_got_offset (htab
) + off
;
5050 addend
= rel
->r_addend
;
5052 goto final_link_relocate
;
5054 case R_SH_TLS_LDO_32
:
5055 check_segment
[0] = check_segment
[1] = -1;
5056 if (! bfd_link_pic (info
))
5057 relocation
= tpoff (info
, relocation
);
5059 relocation
-= dtpoff_base (info
);
5061 addend
= rel
->r_addend
;
5062 goto final_link_relocate
;
5064 case R_SH_TLS_LE_32
:
5067 Elf_Internal_Rela outrel
;
5070 check_segment
[0] = check_segment
[1] = -1;
5072 if (!bfd_link_dll (info
))
5074 relocation
= tpoff (info
, relocation
);
5075 addend
= rel
->r_addend
;
5076 goto final_link_relocate
;
5081 sreloc
= _bfd_elf_get_dynamic_reloc_section
5082 (input_bfd
, input_section
, /*rela?*/ TRUE
);
5087 if (h
== NULL
|| h
->dynindx
== -1)
5092 outrel
.r_offset
= (input_section
->output_section
->vma
5093 + input_section
->output_offset
5095 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
5097 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5099 outrel
.r_addend
= 0;
5101 loc
= sreloc
->contents
;
5102 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5103 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5109 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5110 && check_segment
[0] != check_segment
[1])
5112 /* We don't want duplicate errors for undefined symbols. */
5113 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5115 if (bfd_link_pic (info
))
5117 info
->callbacks
->einfo
5118 /* xgettext:c-format */
5119 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5120 input_bfd
, input_section
, rel
->r_offset
, symname
);
5124 info
->callbacks
->einfo
5125 /* xgettext:c-format */
5126 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5127 input_bfd
, input_section
, rel
->r_offset
, symname
);
5130 elf_elfheader (output_bfd
)->e_flags
|= EF_SH_PIC
;
5133 if (r
!= bfd_reloc_ok
)
5138 case bfd_reloc_outofrange
:
5140 case bfd_reloc_overflow
:
5148 name
= (bfd_elf_string_from_elf_section
5149 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5153 name
= bfd_section_name (sec
);
5155 (*info
->callbacks
->reloc_overflow
)
5156 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5157 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5167 /* This is a version of bfd_generic_get_relocated_section_contents
5168 which uses sh_elf_relocate_section. */
5171 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5172 struct bfd_link_info
*link_info
,
5173 struct bfd_link_order
*link_order
,
5175 bfd_boolean relocatable
,
5178 Elf_Internal_Shdr
*symtab_hdr
;
5179 asection
*input_section
= link_order
->u
.indirect
.section
;
5180 bfd
*input_bfd
= input_section
->owner
;
5181 asection
**sections
= NULL
;
5182 Elf_Internal_Rela
*internal_relocs
= NULL
;
5183 Elf_Internal_Sym
*isymbuf
= NULL
;
5185 /* We only need to handle the case of relaxing, or of having a
5186 particular set of section contents, specially. */
5188 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5189 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5194 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5196 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5197 (size_t) input_section
->size
);
5199 if ((input_section
->flags
& SEC_RELOC
) != 0
5200 && input_section
->reloc_count
> 0)
5203 Elf_Internal_Sym
*isym
, *isymend
;
5206 internal_relocs
= (_bfd_elf_link_read_relocs
5207 (input_bfd
, input_section
, NULL
,
5208 (Elf_Internal_Rela
*) NULL
, FALSE
));
5209 if (internal_relocs
== NULL
)
5212 if (symtab_hdr
->sh_info
!= 0)
5214 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5215 if (isymbuf
== NULL
)
5216 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5217 symtab_hdr
->sh_info
, 0,
5219 if (isymbuf
== NULL
)
5223 amt
= symtab_hdr
->sh_info
;
5224 amt
*= sizeof (asection
*);
5225 sections
= (asection
**) bfd_malloc (amt
);
5226 if (sections
== NULL
&& amt
!= 0)
5229 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5230 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5234 if (isym
->st_shndx
== SHN_UNDEF
)
5235 isec
= bfd_und_section_ptr
;
5236 else if (isym
->st_shndx
== SHN_ABS
)
5237 isec
= bfd_abs_section_ptr
;
5238 else if (isym
->st_shndx
== SHN_COMMON
)
5239 isec
= bfd_com_section_ptr
;
5241 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5246 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5247 input_section
, data
, internal_relocs
,
5252 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5254 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5255 free (internal_relocs
);
5262 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5264 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5265 free (internal_relocs
);
5269 /* Return the base VMA address which should be subtracted from real addresses
5270 when resolving @dtpoff relocation.
5271 This is PT_TLS segment p_vaddr. */
5274 dtpoff_base (struct bfd_link_info
*info
)
5276 /* If tls_sec is NULL, we should have signalled an error already. */
5277 if (elf_hash_table (info
)->tls_sec
== NULL
)
5279 return elf_hash_table (info
)->tls_sec
->vma
;
5282 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5285 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5287 /* If tls_sec is NULL, we should have signalled an error already. */
5288 if (elf_hash_table (info
)->tls_sec
== NULL
)
5290 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5291 structure which has 2 pointer fields. */
5292 return (address
- elf_hash_table (info
)->tls_sec
->vma
5293 + align_power ((bfd_vma
) 8,
5294 elf_hash_table (info
)->tls_sec
->alignment_power
));
5298 sh_elf_gc_mark_hook (asection
*sec
,
5299 struct bfd_link_info
*info
,
5300 Elf_Internal_Rela
*rel
,
5301 struct elf_link_hash_entry
*h
,
5302 Elf_Internal_Sym
*sym
)
5305 switch (ELF32_R_TYPE (rel
->r_info
))
5307 case R_SH_GNU_VTINHERIT
:
5308 case R_SH_GNU_VTENTRY
:
5312 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5315 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5318 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
5319 struct elf_link_hash_entry
*dir
,
5320 struct elf_link_hash_entry
*ind
)
5322 struct elf_sh_link_hash_entry
*edir
, *eind
;
5324 edir
= (struct elf_sh_link_hash_entry
*) dir
;
5325 eind
= (struct elf_sh_link_hash_entry
*) ind
;
5327 if (eind
->dyn_relocs
!= NULL
)
5329 if (edir
->dyn_relocs
!= NULL
)
5331 struct elf_dyn_relocs
**pp
;
5332 struct elf_dyn_relocs
*p
;
5334 /* Add reloc counts against the indirect sym to the direct sym
5335 list. Merge any entries against the same section. */
5336 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
5338 struct elf_dyn_relocs
*q
;
5340 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
5341 if (q
->sec
== p
->sec
)
5343 q
->pc_count
+= p
->pc_count
;
5344 q
->count
+= p
->count
;
5351 *pp
= edir
->dyn_relocs
;
5354 edir
->dyn_relocs
= eind
->dyn_relocs
;
5355 eind
->dyn_relocs
= NULL
;
5357 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
5358 eind
->gotplt_refcount
= 0;
5359 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
5360 eind
->funcdesc
.refcount
= 0;
5361 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
5362 eind
->abs_funcdesc_refcount
= 0;
5364 if (ind
->root
.type
== bfd_link_hash_indirect
5365 && dir
->got
.refcount
<= 0)
5367 edir
->got_type
= eind
->got_type
;
5368 eind
->got_type
= GOT_UNKNOWN
;
5371 if (ind
->root
.type
!= bfd_link_hash_indirect
5372 && dir
->dynamic_adjusted
)
5374 /* If called to transfer flags for a weakdef during processing
5375 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5376 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5377 if (dir
->versioned
!= versioned_hidden
)
5378 dir
->ref_dynamic
|= ind
->ref_dynamic
;
5379 dir
->ref_regular
|= ind
->ref_regular
;
5380 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
5381 dir
->needs_plt
|= ind
->needs_plt
;
5384 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
5388 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
5391 if (bfd_link_pic (info
))
5396 case R_SH_TLS_GD_32
:
5397 case R_SH_TLS_IE_32
:
5399 return R_SH_TLS_LE_32
;
5400 return R_SH_TLS_IE_32
;
5401 case R_SH_TLS_LD_32
:
5402 return R_SH_TLS_LE_32
;
5408 /* Look through the relocs for a section during the first phase.
5409 Since we don't do .gots or .plts, we just need to consider the
5410 virtual table relocs for gc. */
5413 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
5414 const Elf_Internal_Rela
*relocs
)
5416 Elf_Internal_Shdr
*symtab_hdr
;
5417 struct elf_link_hash_entry
**sym_hashes
;
5418 struct elf_sh_link_hash_table
*htab
;
5419 const Elf_Internal_Rela
*rel
;
5420 const Elf_Internal_Rela
*rel_end
;
5422 unsigned int r_type
;
5423 enum got_type got_type
, old_got_type
;
5427 if (bfd_link_relocatable (info
))
5430 /* Don't do anything special with non-loaded, non-alloced sections.
5431 In particular, any relocs in such sections should not affect GOT
5432 and PLT reference counting (ie. we don't allow them to create GOT
5433 or PLT entries), there's no possibility or desire to optimize TLS
5434 relocs, and there's not much point in propagating relocs to shared
5435 libs that the dynamic linker won't relocate. */
5436 if ((sec
->flags
& SEC_ALLOC
) == 0)
5439 BFD_ASSERT (is_sh_elf (abfd
));
5441 symtab_hdr
= &elf_symtab_hdr (abfd
);
5442 sym_hashes
= elf_sym_hashes (abfd
);
5444 htab
= sh_elf_hash_table (info
);
5448 rel_end
= relocs
+ sec
->reloc_count
;
5449 for (rel
= relocs
; rel
< rel_end
; rel
++)
5451 struct elf_link_hash_entry
*h
;
5452 unsigned long r_symndx
;
5454 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5455 r_type
= ELF32_R_TYPE (rel
->r_info
);
5457 if (r_symndx
< symtab_hdr
->sh_info
)
5461 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5462 while (h
->root
.type
== bfd_link_hash_indirect
5463 || h
->root
.type
== bfd_link_hash_warning
)
5464 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5467 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5468 if (! bfd_link_pic (info
)
5469 && r_type
== R_SH_TLS_IE_32
5471 && h
->root
.type
!= bfd_link_hash_undefined
5472 && h
->root
.type
!= bfd_link_hash_undefweak
5473 && (h
->dynindx
== -1
5475 r_type
= R_SH_TLS_LE_32
;
5480 case R_SH_GOTOFFFUNCDESC
:
5481 case R_SH_GOTOFFFUNCDESC20
:
5483 case R_SH_GOTFUNCDESC
:
5484 case R_SH_GOTFUNCDESC20
:
5487 if (h
->dynindx
== -1)
5488 switch (ELF_ST_VISIBILITY (h
->other
))
5494 bfd_elf_link_record_dynamic_symbol (info
, h
);
5501 /* Some relocs require a global offset table. */
5502 if (htab
->root
.sgot
== NULL
)
5507 /* This may require an rofixup. */
5517 case R_SH_GOTFUNCDESC
:
5518 case R_SH_GOTFUNCDESC20
:
5519 case R_SH_GOTOFFFUNCDESC
:
5520 case R_SH_GOTOFFFUNCDESC20
:
5522 case R_SH_TLS_GD_32
:
5523 case R_SH_TLS_LD_32
:
5524 case R_SH_TLS_IE_32
:
5525 if (htab
->root
.dynobj
== NULL
)
5526 htab
->root
.dynobj
= abfd
;
5527 if (!create_got_section (htab
->root
.dynobj
, info
))
5538 /* This relocation describes the C++ object vtable hierarchy.
5539 Reconstruct it for later use during GC. */
5540 case R_SH_GNU_VTINHERIT
:
5541 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5545 /* This relocation describes which C++ vtable entries are actually
5546 used. Record for later use during GC. */
5547 case R_SH_GNU_VTENTRY
:
5548 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
5552 case R_SH_TLS_IE_32
:
5553 if (bfd_link_pic (info
))
5554 info
->flags
|= DF_STATIC_TLS
;
5558 case R_SH_TLS_GD_32
:
5561 case R_SH_GOTFUNCDESC
:
5562 case R_SH_GOTFUNCDESC20
:
5566 got_type
= GOT_NORMAL
;
5568 case R_SH_TLS_GD_32
:
5569 got_type
= GOT_TLS_GD
;
5571 case R_SH_TLS_IE_32
:
5572 got_type
= GOT_TLS_IE
;
5574 case R_SH_GOTFUNCDESC
:
5575 case R_SH_GOTFUNCDESC20
:
5576 got_type
= GOT_FUNCDESC
;
5582 h
->got
.refcount
+= 1;
5583 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5587 bfd_signed_vma
*local_got_refcounts
;
5589 /* This is a global offset table entry for a local
5591 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5592 if (local_got_refcounts
== NULL
)
5596 size
= symtab_hdr
->sh_info
;
5597 size
*= sizeof (bfd_signed_vma
);
5598 size
+= symtab_hdr
->sh_info
;
5599 local_got_refcounts
= ((bfd_signed_vma
*)
5600 bfd_zalloc (abfd
, size
));
5601 if (local_got_refcounts
== NULL
)
5603 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
5604 sh_elf_local_got_type (abfd
)
5605 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
5607 local_got_refcounts
[r_symndx
] += 1;
5608 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
5611 /* If a TLS symbol is accessed using IE at least once,
5612 there is no point to use dynamic model for it. */
5613 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
5614 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
5616 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
5617 got_type
= GOT_TLS_IE
;
5620 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
5621 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
5623 /* xgettext:c-format */
5624 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5625 abfd
, h
->root
.root
.string
);
5626 else if (old_got_type
== GOT_FUNCDESC
5627 || got_type
== GOT_FUNCDESC
)
5629 /* xgettext:c-format */
5630 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5631 abfd
, h
->root
.root
.string
);
5634 /* xgettext:c-format */
5635 (_("%pB: `%s' accessed both as normal and thread local symbol"),
5636 abfd
, h
->root
.root
.string
);
5641 if (old_got_type
!= got_type
)
5644 sh_elf_hash_entry (h
)->got_type
= got_type
;
5646 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
5651 case R_SH_TLS_LD_32
:
5652 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
5656 case R_SH_GOTOFFFUNCDESC
:
5657 case R_SH_GOTOFFFUNCDESC20
:
5661 (_("%pB: Function descriptor relocation with non-zero addend"),
5668 union gotref
*local_funcdesc
;
5670 /* We need a function descriptor for a local symbol. */
5671 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5672 if (local_funcdesc
== NULL
)
5676 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
5677 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
5678 if (local_funcdesc
== NULL
)
5680 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
5682 local_funcdesc
[r_symndx
].refcount
+= 1;
5684 if (r_type
== R_SH_FUNCDESC
)
5686 if (!bfd_link_pic (info
))
5687 htab
->srofixup
->size
+= 4;
5689 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5694 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
5695 if (r_type
== R_SH_FUNCDESC
)
5696 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
5698 /* If there is a function descriptor reference, then
5699 there should not be any non-FDPIC references. */
5700 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5701 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
5703 if (old_got_type
== GOT_NORMAL
)
5705 /* xgettext:c-format */
5706 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5707 abfd
, h
->root
.root
.string
);
5710 /* xgettext:c-format */
5711 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5712 abfd
, h
->root
.root
.string
);
5718 /* If this is a local symbol, we resolve it directly without
5719 creating a procedure linkage table entry. */
5723 || ! bfd_link_pic (info
)
5725 || h
->dynindx
== -1)
5729 h
->plt
.refcount
+= 1;
5730 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
5735 /* This symbol requires a procedure linkage table entry. We
5736 actually build the entry in adjust_dynamic_symbol,
5737 because this might be a case of linking PIC code which is
5738 never referenced by a dynamic object, in which case we
5739 don't need to generate a procedure linkage table entry
5742 /* If this is a local symbol, we resolve it directly without
5743 creating a procedure linkage table entry. */
5747 if (h
->forced_local
)
5751 h
->plt
.refcount
+= 1;
5756 if (h
!= NULL
&& ! bfd_link_pic (info
))
5759 h
->plt
.refcount
+= 1;
5762 /* If we are creating a shared library, and this is a reloc
5763 against a global symbol, or a non PC relative reloc
5764 against a local symbol, then we need to copy the reloc
5765 into the shared library. However, if we are linking with
5766 -Bsymbolic, we do not need to copy a reloc against a
5767 global symbol which is defined in an object we are
5768 including in the link (i.e., DEF_REGULAR is set). At
5769 this point we have not seen all the input files, so it is
5770 possible that DEF_REGULAR is not set now but will be set
5771 later (it is never cleared). We account for that
5772 possibility below by storing information in the
5773 dyn_relocs field of the hash table entry. A similar
5774 situation occurs when creating shared libraries and symbol
5775 visibility changes render the symbol local.
5777 If on the other hand, we are creating an executable, we
5778 may need to keep relocations for symbols satisfied by a
5779 dynamic library if we manage to avoid copy relocs for the
5781 if ((bfd_link_pic (info
)
5782 && (sec
->flags
& SEC_ALLOC
) != 0
5783 && (r_type
!= R_SH_REL32
5785 && (! info
->symbolic
5786 || h
->root
.type
== bfd_link_hash_defweak
5787 || !h
->def_regular
))))
5788 || (! bfd_link_pic (info
)
5789 && (sec
->flags
& SEC_ALLOC
) != 0
5791 && (h
->root
.type
== bfd_link_hash_defweak
5792 || !h
->def_regular
)))
5794 struct elf_dyn_relocs
*p
;
5795 struct elf_dyn_relocs
**head
;
5797 if (htab
->root
.dynobj
== NULL
)
5798 htab
->root
.dynobj
= abfd
;
5800 /* When creating a shared object, we must copy these
5801 reloc types into the output file. We create a reloc
5802 section in dynobj and make room for this reloc. */
5805 sreloc
= _bfd_elf_make_dynamic_reloc_section
5806 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
5812 /* If this is a global symbol, we count the number of
5813 relocations we need for this symbol. */
5815 head
= &((struct elf_sh_link_hash_entry
*) h
)->dyn_relocs
;
5818 /* Track dynamic relocs needed for local syms too. */
5821 Elf_Internal_Sym
*isym
;
5823 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5828 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5832 vpp
= &elf_section_data (s
)->local_dynrel
;
5833 head
= (struct elf_dyn_relocs
**) vpp
;
5837 if (p
== NULL
|| p
->sec
!= sec
)
5839 size_t amt
= sizeof (*p
);
5840 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
5851 if (r_type
== R_SH_REL32
)
5855 /* Allocate the fixup regardless of whether we need a relocation.
5856 If we end up generating the relocation, we'll unallocate the
5858 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
5859 && r_type
== R_SH_DIR32
5860 && (sec
->flags
& SEC_ALLOC
) != 0)
5861 htab
->srofixup
->size
+= 4;
5864 case R_SH_TLS_LE_32
:
5865 if (bfd_link_dll (info
))
5868 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5875 case R_SH_TLS_LDO_32
:
5876 /* Nothing to do. */
5887 #ifndef sh_elf_set_mach_from_flags
5888 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
5891 sh_elf_set_mach_from_flags (bfd
*abfd
)
5893 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
5895 if (flags
>= ARRAY_SIZE (sh_ef_bfd_table
))
5898 if (sh_ef_bfd_table
[flags
] == 0)
5901 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
5907 /* Reverse table lookup for sh_ef_bfd_table[].
5908 Given a bfd MACH value from archures.c
5909 return the equivalent ELF flags from the table.
5910 Return -1 if no match is found. */
5913 sh_elf_get_flags_from_mach (unsigned long mach
)
5915 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
5918 if (sh_ef_bfd_table
[i
] == mach
)
5921 /* shouldn't get here */
5926 #endif /* not sh_elf_set_mach_from_flags */
5928 #ifndef sh_elf_copy_private_data
5929 /* Copy backend specific data from one object module to another */
5932 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
5934 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5937 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
5940 return sh_elf_set_mach_from_flags (obfd
);
5942 #endif /* not sh_elf_copy_private_data */
5944 #ifndef sh_elf_merge_private_data
5946 /* This function returns the ELF architecture number that
5947 corresponds to the given arch_sh* flags. */
5950 sh_find_elf_flags (unsigned int arch_set
)
5952 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5953 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
5955 return sh_elf_get_flags_from_mach (bfd_mach
);
5958 /* Merge the architecture type of two BFD files, such that the
5959 resultant architecture supports all the features required
5960 by the two input BFDs.
5961 If the input BFDs are multually incompatible - i.e. one uses
5962 DSP while the other uses FPU - or there is no known architecture
5963 that fits the requirements then an error is emitted. */
5966 sh_merge_bfd_arch (bfd
*ibfd
, struct bfd_link_info
*info
)
5968 bfd
*obfd
= info
->output_bfd
;
5969 unsigned int old_arch
, new_arch
, merged_arch
;
5971 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
5974 old_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd
));
5975 new_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd
));
5977 merged_arch
= SH_MERGE_ARCH_SET (old_arch
, new_arch
);
5979 if (!SH_VALID_CO_ARCH_SET (merged_arch
))
5982 /* xgettext:c-format */
5983 (_("%pB: uses %s instructions while previous modules "
5984 "use %s instructions"),
5986 SH_ARCH_SET_HAS_DSP (new_arch
) ? "dsp" : "floating point",
5987 SH_ARCH_SET_HAS_DSP (new_arch
) ? "floating point" : "dsp");
5988 bfd_set_error (bfd_error_bad_value
);
5991 else if (!SH_VALID_ARCH_SET (merged_arch
))
5994 /* xgettext:c-format */
5995 (_("internal error: merge of architecture '%s' with "
5996 "architecture '%s' produced unknown architecture"),
5997 bfd_printable_name (obfd
),
5998 bfd_printable_name (ibfd
));
5999 bfd_set_error (bfd_error_bad_value
);
6003 bfd_default_set_arch_mach (obfd
, bfd_arch_sh
,
6004 sh_get_bfd_mach_from_arch_set (merged_arch
));
6009 /* This routine initialises the elf flags when required and
6010 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6013 sh_elf_merge_private_data (bfd
*ibfd
, struct bfd_link_info
*info
)
6015 bfd
*obfd
= info
->output_bfd
;
6017 /* FIXME: What should be checked when linking shared libraries? */
6018 if ((ibfd
->flags
& DYNAMIC
) != 0)
6021 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6024 if (! elf_flags_init (obfd
))
6026 /* This happens when ld starts out with a 'blank' output file. */
6027 elf_flags_init (obfd
) = TRUE
;
6028 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
6029 sh_elf_set_mach_from_flags (obfd
);
6030 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
6031 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_PIC
;
6034 if (! sh_merge_bfd_arch (ibfd
, info
))
6036 _bfd_error_handler (_("%pB: uses instructions which are incompatible "
6037 "with instructions used in previous modules"),
6039 bfd_set_error (bfd_error_bad_value
);
6043 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
6044 elf_elfheader (obfd
)->e_flags
|=
6045 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
6047 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
6049 _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
6051 bfd_set_error (bfd_error_bad_value
);
6057 #endif /* not sh_elf_merge_private_data */
6059 /* Override the generic function because we need to store sh_elf_obj_tdata
6060 as the specific tdata. We set also the machine architecture from flags
6064 sh_elf_object_p (bfd
*abfd
)
6066 if (! sh_elf_set_mach_from_flags (abfd
))
6069 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
6070 == fdpic_object_p (abfd
));
6073 /* Finish up dynamic symbol handling. We set the contents of various
6074 dynamic sections here. */
6077 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
6078 struct elf_link_hash_entry
*h
,
6079 Elf_Internal_Sym
*sym
)
6081 struct elf_sh_link_hash_table
*htab
;
6083 htab
= sh_elf_hash_table (info
);
6087 if (h
->plt
.offset
!= (bfd_vma
) -1)
6095 Elf_Internal_Rela rel
;
6097 const struct elf_sh_plt_info
*plt_info
;
6099 /* This symbol has an entry in the procedure linkage table. Set
6102 BFD_ASSERT (h
->dynindx
!= -1);
6104 splt
= htab
->root
.splt
;
6105 sgotplt
= htab
->root
.sgotplt
;
6106 srelplt
= htab
->root
.srelplt
;
6107 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
6109 /* Get the index in the procedure linkage table which
6110 corresponds to this symbol. This is the index of this symbol
6111 in all the symbols for which we are making plt entries. The
6112 first entry in the procedure linkage table is reserved. */
6113 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
6115 plt_info
= htab
->plt_info
;
6116 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
6117 plt_info
= plt_info
->short_plt
;
6119 /* Get the offset into the .got table of the entry that
6120 corresponds to this function. */
6122 /* The offset must be relative to the GOT symbol, twelve bytes
6123 before the end of .got.plt. Each descriptor is eight
6125 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
6127 /* Each .got entry is 4 bytes. The first three are
6129 got_offset
= (plt_index
+ 3) * 4;
6132 if (bfd_link_pic (info
))
6133 got_offset
-= GOT_BIAS
;
6136 /* Fill in the entry in the procedure linkage table. */
6137 memcpy (splt
->contents
+ h
->plt
.offset
,
6138 plt_info
->symbol_entry
,
6139 plt_info
->symbol_entry_size
);
6141 if (bfd_link_pic (info
) || htab
->fdpic_p
)
6143 if (plt_info
->symbol_fields
.got20
)
6145 bfd_reloc_status_type r
;
6146 r
= install_movi20_field (output_bfd
, got_offset
,
6147 splt
->owner
, splt
, splt
->contents
,
6149 + plt_info
->symbol_fields
.got_entry
);
6150 BFD_ASSERT (r
== bfd_reloc_ok
);
6153 install_plt_field (output_bfd
, FALSE
, got_offset
,
6156 + plt_info
->symbol_fields
.got_entry
));
6160 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6162 install_plt_field (output_bfd
, FALSE
,
6163 (sgotplt
->output_section
->vma
6164 + sgotplt
->output_offset
6168 + plt_info
->symbol_fields
.got_entry
));
6169 if (htab
->vxworks_p
)
6171 unsigned int reachable_plts
, plts_per_4k
;
6174 /* Divide the PLT into groups. The first group contains
6175 REACHABLE_PLTS entries and the other groups contain
6176 PLTS_PER_4K entries. Entries in the first group can
6177 branch directly to .plt; those in later groups branch
6178 to the last element of the previous group. */
6179 /* ??? It would be better to create multiple copies of
6180 the common resolver stub. */
6181 reachable_plts
= ((4096
6182 - plt_info
->plt0_entry_size
6183 - (plt_info
->symbol_fields
.plt
+ 4))
6184 / plt_info
->symbol_entry_size
) + 1;
6185 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6186 if (plt_index
< reachable_plts
)
6187 distance
= -(h
->plt
.offset
6188 + plt_info
->symbol_fields
.plt
);
6190 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6191 * plt_info
->symbol_entry_size
);
6193 /* Install the 'bra' with this offset. */
6194 bfd_put_16 (output_bfd
,
6195 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6198 + plt_info
->symbol_fields
.plt
));
6201 install_plt_field (output_bfd
, TRUE
,
6202 splt
->output_section
->vma
+ splt
->output_offset
,
6205 + plt_info
->symbol_fields
.plt
));
6208 /* Make got_offset relative to the start of .got.plt. */
6210 if (bfd_link_pic (info
))
6211 got_offset
+= GOT_BIAS
;
6214 got_offset
= plt_index
* 8;
6216 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6217 install_plt_field (output_bfd
, FALSE
,
6218 plt_index
* sizeof (Elf32_External_Rela
),
6221 + plt_info
->symbol_fields
.reloc_offset
));
6223 /* Fill in the entry in the global offset table. */
6224 bfd_put_32 (output_bfd
,
6225 (splt
->output_section
->vma
6226 + splt
->output_offset
6228 + plt_info
->symbol_resolve_offset
),
6229 sgotplt
->contents
+ got_offset
);
6231 bfd_put_32 (output_bfd
,
6232 sh_elf_osec_to_segment (output_bfd
, splt
->output_section
),
6233 sgotplt
->contents
+ got_offset
+ 4);
6235 /* Fill in the entry in the .rela.plt section. */
6236 rel
.r_offset
= (sgotplt
->output_section
->vma
6237 + sgotplt
->output_offset
6240 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
6242 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
6245 rel
.r_addend
= GOT_BIAS
;
6247 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
6248 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6250 if (htab
->vxworks_p
&& !bfd_link_pic (info
))
6252 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6253 Begin by pointing LOC to the first such relocation. */
6254 loc
= (htab
->srelplt2
->contents
6255 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
6257 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6258 for the PLT entry's pointer to the .got.plt entry. */
6259 rel
.r_offset
= (splt
->output_section
->vma
6260 + splt
->output_offset
6262 + plt_info
->symbol_fields
.got_entry
);
6263 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6264 rel
.r_addend
= got_offset
;
6265 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6266 loc
+= sizeof (Elf32_External_Rela
);
6268 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6269 the .got.plt entry, which initially points to .plt. */
6270 rel
.r_offset
= (sgotplt
->output_section
->vma
6271 + sgotplt
->output_offset
6273 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
6275 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6278 if (!h
->def_regular
)
6280 /* Mark the symbol as undefined, rather than as defined in
6281 the .plt section. Leave the value alone. */
6282 sym
->st_shndx
= SHN_UNDEF
;
6286 if (h
->got
.offset
!= (bfd_vma
) -1
6287 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
6288 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
6289 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
6293 Elf_Internal_Rela rel
;
6296 /* This symbol has an entry in the global offset table. Set it
6299 sgot
= htab
->root
.sgot
;
6300 srelgot
= htab
->root
.srelgot
;
6301 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
6303 rel
.r_offset
= (sgot
->output_section
->vma
6304 + sgot
->output_offset
6305 + (h
->got
.offset
&~ (bfd_vma
) 1));
6307 /* If this is a static link, or it is a -Bsymbolic link and the
6308 symbol is defined locally or was forced to be local because
6309 of a version file, we just want to emit a RELATIVE reloc.
6310 The entry in the global offset table will already have been
6311 initialized in the relocate_section function. */
6312 if (bfd_link_pic (info
)
6313 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6317 asection
*sec
= h
->root
.u
.def
.section
;
6319 = elf_section_data (sec
->output_section
)->dynindx
;
6321 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
6322 rel
.r_addend
= (h
->root
.u
.def
.value
6323 + h
->root
.u
.def
.section
->output_offset
);
6327 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
6328 rel
.r_addend
= (h
->root
.u
.def
.value
6329 + h
->root
.u
.def
.section
->output_section
->vma
6330 + h
->root
.u
.def
.section
->output_offset
);
6335 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
6336 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
6340 loc
= srelgot
->contents
;
6341 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6342 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6348 Elf_Internal_Rela rel
;
6351 /* This symbol needs a copy reloc. Set it up. */
6353 BFD_ASSERT (h
->dynindx
!= -1
6354 && (h
->root
.type
== bfd_link_hash_defined
6355 || h
->root
.type
== bfd_link_hash_defweak
));
6357 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
6358 BFD_ASSERT (s
!= NULL
);
6360 rel
.r_offset
= (h
->root
.u
.def
.value
6361 + h
->root
.u
.def
.section
->output_section
->vma
6362 + h
->root
.u
.def
.section
->output_offset
);
6363 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
6365 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6366 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6369 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
6370 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6372 if (h
== htab
->root
.hdynamic
6373 || (!htab
->vxworks_p
&& h
== htab
->root
.hgot
))
6374 sym
->st_shndx
= SHN_ABS
;
6379 /* Finish up the dynamic sections. */
6382 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6384 struct elf_sh_link_hash_table
*htab
;
6388 htab
= sh_elf_hash_table (info
);
6392 sgotplt
= htab
->root
.sgotplt
;
6393 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
6395 if (htab
->root
.dynamic_sections_created
)
6398 Elf32_External_Dyn
*dyncon
, *dynconend
;
6400 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
6402 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
6403 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
6404 for (; dyncon
< dynconend
; dyncon
++)
6406 Elf_Internal_Dyn dyn
;
6409 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
6415 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
6416 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6420 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
6421 s
= htab
->root
.hgot
->root
.u
.def
.section
;
6422 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
6423 + s
->output_section
->vma
+ s
->output_offset
;
6424 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6428 s
= htab
->root
.srelplt
->output_section
;
6429 BFD_ASSERT (s
!= NULL
);
6430 dyn
.d_un
.d_ptr
= s
->vma
;
6431 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6435 s
= htab
->root
.srelplt
->output_section
;
6436 BFD_ASSERT (s
!= NULL
);
6437 dyn
.d_un
.d_val
= s
->size
;
6438 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6443 /* Fill in the first entry in the procedure linkage table. */
6444 splt
= htab
->root
.splt
;
6445 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
6449 memcpy (splt
->contents
,
6450 htab
->plt_info
->plt0_entry
,
6451 htab
->plt_info
->plt0_entry_size
);
6452 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
6453 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
6454 install_plt_field (output_bfd
, FALSE
,
6455 (sgotplt
->output_section
->vma
6456 + sgotplt
->output_offset
6459 + htab
->plt_info
->plt0_got_fields
[i
]));
6461 if (htab
->vxworks_p
)
6463 /* Finalize the .rela.plt.unloaded contents. */
6464 Elf_Internal_Rela rel
;
6467 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6468 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
6469 loc
= htab
->srelplt2
->contents
;
6470 rel
.r_offset
= (splt
->output_section
->vma
6471 + splt
->output_offset
6472 + htab
->plt_info
->plt0_got_fields
[2]);
6473 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6475 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6476 loc
+= sizeof (Elf32_External_Rela
);
6478 /* Fix up the remaining .rela.plt.unloaded relocations.
6479 They may have the wrong symbol index for _G_O_T_ or
6480 _P_L_T_ depending on the order in which symbols were
6482 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
6484 /* The PLT entry's pointer to the .got.plt slot. */
6485 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6486 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
6488 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6489 loc
+= sizeof (Elf32_External_Rela
);
6491 /* The .got.plt slot's pointer to .plt. */
6492 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6493 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
6495 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6496 loc
+= sizeof (Elf32_External_Rela
);
6500 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6501 really seem like the right value. */
6502 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
6506 /* Fill in the first three entries in the global offset table. */
6507 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
6510 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
6512 bfd_put_32 (output_bfd
,
6513 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6515 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
6516 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
6519 if (sgotplt
&& sgotplt
->size
> 0)
6520 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
6522 /* At the very end of the .rofixup section is a pointer to the GOT. */
6523 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
6525 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
6526 bfd_vma got_value
= hgot
->root
.u
.def
.value
6527 + hgot
->root
.u
.def
.section
->output_section
->vma
6528 + hgot
->root
.u
.def
.section
->output_offset
;
6530 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
6532 /* Make sure we allocated and generated the same number of fixups. */
6533 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
6536 if (htab
->srelfuncdesc
)
6537 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
6538 == htab
->srelfuncdesc
->size
);
6540 if (htab
->root
.srelgot
)
6541 BFD_ASSERT (htab
->root
.srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
6542 == htab
->root
.srelgot
->size
);
6547 static enum elf_reloc_type_class
6548 sh_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6549 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6550 const Elf_Internal_Rela
*rela
)
6552 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6555 return reloc_class_relative
;
6557 return reloc_class_plt
;
6559 return reloc_class_copy
;
6561 return reloc_class_normal
;
6565 #if !defined SH_TARGET_ALREADY_DEFINED
6566 /* Support for Linux core dump NOTE sections. */
6569 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6574 switch (note
->descsz
)
6579 case 168: /* Linux/SH */
6581 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
6584 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
6593 /* Make a ".reg/999" section. */
6594 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6595 size
, note
->descpos
+ offset
);
6599 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6601 switch (note
->descsz
)
6606 case 124: /* Linux/SH elf_prpsinfo */
6607 elf_tdata (abfd
)->core
->program
6608 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
6609 elf_tdata (abfd
)->core
->command
6610 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
6613 /* Note that for some reason, a spurious space is tacked
6614 onto the end of the args in some (at least one anyway)
6615 implementations, so strip it off if it exists. */
6618 char *command
= elf_tdata (abfd
)->core
->command
;
6619 int n
= strlen (command
);
6621 if (0 < n
&& command
[n
- 1] == ' ')
6622 command
[n
- 1] = '\0';
6627 #endif /* not SH_TARGET_ALREADY_DEFINED */
6630 /* Return address for Ith PLT stub in section PLT, for relocation REL
6631 or (bfd_vma) -1 if it should not be included. */
6634 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
6635 const arelent
*rel ATTRIBUTE_UNUSED
)
6637 const struct elf_sh_plt_info
*plt_info
;
6639 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
6640 return plt
->vma
+ get_plt_offset (plt_info
, i
);
6643 /* Decide whether to attempt to turn absptr or lsda encodings in
6644 shared libraries into pcrel within the given input section. */
6647 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6648 struct bfd_link_info
*info
,
6649 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
6651 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6653 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
6660 /* Adjust the contents of an eh_frame_hdr section before they're output. */
6663 sh_elf_encode_eh_address (bfd
*abfd
,
6664 struct bfd_link_info
*info
,
6665 asection
*osec
, bfd_vma offset
,
6666 asection
*loc_sec
, bfd_vma loc_offset
,
6669 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6670 struct elf_link_hash_entry
*h
;
6673 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
6674 loc_offset
, encoded
);
6676 h
= htab
->root
.hgot
;
6677 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
6679 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
6680 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
6681 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
6682 loc_sec
, loc_offset
, encoded
);
6684 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
6685 == (sh_elf_osec_to_segment
6686 (abfd
, h
->root
.u
.def
.section
->output_section
)));
6688 *encoded
= osec
->vma
+ offset
6689 - (h
->root
.u
.def
.value
6690 + h
->root
.u
.def
.section
->output_section
->vma
6691 + h
->root
.u
.def
.section
->output_offset
);
6693 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
6696 #if !defined SH_TARGET_ALREADY_DEFINED
6697 #define TARGET_BIG_SYM sh_elf32_vec
6698 #define TARGET_BIG_NAME "elf32-sh"
6699 #define TARGET_LITTLE_SYM sh_elf32_le_vec
6700 #define TARGET_LITTLE_NAME "elf32-shl"
6703 #define ELF_ARCH bfd_arch_sh
6704 #define ELF_TARGET_ID SH_ELF_DATA
6705 #define ELF_MACHINE_CODE EM_SH
6706 #ifdef __QNXTARGET__
6707 #define ELF_MAXPAGESIZE 0x1000
6709 #define ELF_MAXPAGESIZE 0x80
6712 #define elf_symbol_leading_char '_'
6714 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6715 #define bfd_elf32_bfd_reloc_name_lookup \
6716 sh_elf_reloc_name_lookup
6717 #define elf_info_to_howto sh_elf_info_to_howto
6718 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
6719 #define elf_backend_relocate_section sh_elf_relocate_section
6720 #define bfd_elf32_bfd_get_relocated_section_contents \
6721 sh_elf_get_relocated_section_contents
6722 #define bfd_elf32_mkobject sh_elf_mkobject
6723 #define elf_backend_object_p sh_elf_object_p
6724 #define bfd_elf32_bfd_copy_private_bfd_data \
6725 sh_elf_copy_private_data
6726 #define bfd_elf32_bfd_merge_private_bfd_data \
6727 sh_elf_merge_private_data
6729 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
6730 #define elf_backend_check_relocs sh_elf_check_relocs
6731 #define elf_backend_copy_indirect_symbol \
6732 sh_elf_copy_indirect_symbol
6733 #define elf_backend_create_dynamic_sections \
6734 sh_elf_create_dynamic_sections
6735 #define bfd_elf32_bfd_link_hash_table_create \
6736 sh_elf_link_hash_table_create
6737 #define elf_backend_adjust_dynamic_symbol \
6738 sh_elf_adjust_dynamic_symbol
6739 #define elf_backend_always_size_sections \
6740 sh_elf_always_size_sections
6741 #define elf_backend_size_dynamic_sections \
6742 sh_elf_size_dynamic_sections
6743 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6744 #define elf_backend_finish_dynamic_symbol \
6745 sh_elf_finish_dynamic_symbol
6746 #define elf_backend_finish_dynamic_sections \
6747 sh_elf_finish_dynamic_sections
6748 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
6749 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
6750 #define elf_backend_can_make_relative_eh_frame \
6751 sh_elf_use_relative_eh_frame
6752 #define elf_backend_can_make_lsda_relative_eh_frame \
6753 sh_elf_use_relative_eh_frame
6754 #define elf_backend_encode_eh_address \
6755 sh_elf_encode_eh_address
6757 #define elf_backend_stack_align 8
6758 #define elf_backend_can_gc_sections 1
6759 #define elf_backend_can_refcount 1
6760 #define elf_backend_want_got_plt 1
6761 #define elf_backend_plt_readonly 1
6762 #define elf_backend_want_plt_sym 0
6763 #define elf_backend_got_header_size 12
6764 #define elf_backend_dtrel_excludes_plt 1
6766 #define elf_backend_linux_prpsinfo32_ugid16 TRUE
6768 #if !defined SH_TARGET_ALREADY_DEFINED
6770 #include "elf32-target.h"
6772 /* NetBSD support. */
6773 #undef TARGET_BIG_SYM
6774 #define TARGET_BIG_SYM sh_elf32_nbsd_vec
6775 #undef TARGET_BIG_NAME
6776 #define TARGET_BIG_NAME "elf32-sh-nbsd"
6777 #undef TARGET_LITTLE_SYM
6778 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
6779 #undef TARGET_LITTLE_NAME
6780 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
6781 #undef ELF_MAXPAGESIZE
6782 #define ELF_MAXPAGESIZE 0x10000
6783 #undef ELF_COMMONPAGESIZE
6784 #undef elf_symbol_leading_char
6785 #define elf_symbol_leading_char 0
6787 #define elf32_bed elf32_sh_nbsd_bed
6789 #include "elf32-target.h"
6792 /* Linux support. */
6793 #undef TARGET_BIG_SYM
6794 #define TARGET_BIG_SYM sh_elf32_linux_be_vec
6795 #undef TARGET_BIG_NAME
6796 #define TARGET_BIG_NAME "elf32-shbig-linux"
6797 #undef TARGET_LITTLE_SYM
6798 #define TARGET_LITTLE_SYM sh_elf32_linux_vec
6799 #undef TARGET_LITTLE_NAME
6800 #define TARGET_LITTLE_NAME "elf32-sh-linux"
6801 #undef ELF_COMMONPAGESIZE
6802 #define ELF_COMMONPAGESIZE 0x1000
6804 #undef elf_backend_grok_prstatus
6805 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
6806 #undef elf_backend_grok_psinfo
6807 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
6809 #define elf32_bed elf32_sh_lin_bed
6811 #include "elf32-target.h"
6814 /* FDPIC support. */
6815 #undef TARGET_BIG_SYM
6816 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
6817 #undef TARGET_BIG_NAME
6818 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
6819 #undef TARGET_LITTLE_SYM
6820 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
6821 #undef TARGET_LITTLE_NAME
6822 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
6825 #define elf32_bed elf32_sh_fd_bed
6827 #include "elf32-target.h"
6829 /* VxWorks support. */
6830 #undef TARGET_BIG_SYM
6831 #define TARGET_BIG_SYM sh_elf32_vxworks_vec
6832 #undef TARGET_BIG_NAME
6833 #define TARGET_BIG_NAME "elf32-sh-vxworks"
6834 #undef TARGET_LITTLE_SYM
6835 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
6836 #undef TARGET_LITTLE_NAME
6837 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
6839 #define elf32_bed elf32_sh_vxworks_bed
6841 #undef elf_backend_want_plt_sym
6842 #define elf_backend_want_plt_sym 1
6843 #undef elf_symbol_leading_char
6844 #define elf_symbol_leading_char '_'
6845 #define elf_backend_want_got_underscore 1
6846 #undef elf_backend_grok_prstatus
6847 #undef elf_backend_grok_psinfo
6848 #undef elf_backend_add_symbol_hook
6849 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
6850 #undef elf_backend_link_output_symbol_hook
6851 #define elf_backend_link_output_symbol_hook \
6852 elf_vxworks_link_output_symbol_hook
6853 #undef elf_backend_emit_relocs
6854 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6855 #undef elf_backend_final_write_processing
6856 #define elf_backend_final_write_processing \
6857 elf_vxworks_final_write_processing
6858 #undef ELF_MAXPAGESIZE
6859 #define ELF_MAXPAGESIZE 0x1000
6860 #undef ELF_COMMONPAGESIZE
6862 #include "elf32-target.h"
6864 #endif /* not SH_TARGET_ALREADY_DEFINED */