1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright (C) 1996-2019 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
,
170 if (contents
!= NULL
)
172 return bfd_reloc_outofrange
;
176 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
177 start_ptr
= contents
+ start
;
178 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
180 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
183 diff
= (last_ptr
- ptr
) >> 1;
184 cum_diff
+= diff
& 1;
187 /* Calculate the start / end values to load into rs / re minus four -
188 so that will cancel out the four we would otherwise have to add to
189 addr to get the value to subtract in order to get relative addressing. */
193 end
= (ptr
+ cum_diff
* 2) - contents
;
197 bfd_vma start0
= start
- 4;
199 while (start0
&& IS_PPI (contents
+ start0
))
201 start0
= start
- 2 - ((start
- start0
) & 2);
202 start
= start0
- cum_diff
- 2;
207 && elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
210 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
212 x
= (insn
& 0x200 ? end
: start
) - addr
;
213 if (input_section
!= symbol_section
)
214 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
215 - (input_section
->output_section
->vma
216 + input_section
->output_offset
));
218 if (x
< -128 || x
> 127)
219 return bfd_reloc_overflow
;
221 x
= (insn
& ~0xff) | (x
& 0xff);
222 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
227 /* This function is used for normal relocs. This used to be like the COFF
228 function, and is almost certainly incorrect for other ELF targets. */
230 static bfd_reloc_status_type
231 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
232 void *data
, asection
*input_section
, bfd
*output_bfd
,
233 char **error_message ATTRIBUTE_UNUSED
)
237 enum elf_sh_reloc_type r_type
;
238 bfd_vma addr
= reloc_entry
->address
;
239 bfd_size_type octets
= addr
* OCTETS_PER_BYTE (abfd
, input_section
);
240 bfd_byte
*hit_data
= (bfd_byte
*) data
+ octets
;
242 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
244 if (output_bfd
!= NULL
)
246 /* Partial linking--do nothing. */
247 reloc_entry
->address
+= input_section
->output_offset
;
251 /* Almost all relocs have to do with relaxing. If any work must be
252 done for them, it has been done in sh_relax_section. */
253 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
256 if (symbol_in
!= NULL
257 && bfd_is_und_section (symbol_in
->section
))
258 return bfd_reloc_undefined
;
260 /* PR 17512: file: 9891ca98. */
261 if (octets
+ bfd_get_reloc_size (reloc_entry
->howto
)
262 > bfd_get_section_limit_octets (abfd
, input_section
))
263 return bfd_reloc_outofrange
;
265 if (bfd_is_com_section (symbol_in
->section
))
268 sym_value
= (symbol_in
->value
+
269 symbol_in
->section
->output_section
->vma
+
270 symbol_in
->section
->output_offset
);
275 insn
= bfd_get_32 (abfd
, hit_data
);
276 insn
+= sym_value
+ reloc_entry
->addend
;
277 bfd_put_32 (abfd
, (bfd_vma
) insn
, hit_data
);
280 insn
= bfd_get_16 (abfd
, hit_data
);
281 sym_value
+= reloc_entry
->addend
;
282 sym_value
-= (input_section
->output_section
->vma
283 + input_section
->output_offset
286 sym_value
+= (insn
& 0xfff) << 1;
289 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
290 bfd_put_16 (abfd
, (bfd_vma
) insn
, hit_data
);
291 if ((bfd_signed_vma
) sym_value
< -0x1000 || sym_value
>= 0x1000)
292 return bfd_reloc_overflow
;
302 /* This function is used for relocs which are only used for relaxing,
303 which the linker should otherwise ignore. */
305 static bfd_reloc_status_type
306 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
307 asymbol
*symbol ATTRIBUTE_UNUSED
,
308 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
310 char **error_message ATTRIBUTE_UNUSED
)
312 if (output_bfd
!= NULL
)
313 reloc_entry
->address
+= input_section
->output_offset
;
317 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
321 bfd_reloc_code_real_type bfd_reloc_val
;
322 unsigned char elf_reloc_val
;
325 /* An array mapping BFD reloc codes to SH ELF relocs. */
327 static const struct elf_reloc_map sh_reloc_map
[] =
329 { BFD_RELOC_NONE
, R_SH_NONE
},
330 { BFD_RELOC_32
, R_SH_DIR32
},
331 { BFD_RELOC_16
, R_SH_DIR16
},
332 { BFD_RELOC_8
, R_SH_DIR8
},
333 { BFD_RELOC_CTOR
, R_SH_DIR32
},
334 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
335 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
336 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
337 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
338 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
339 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
340 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
341 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
342 { BFD_RELOC_SH_USES
, R_SH_USES
},
343 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
344 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
345 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
346 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
347 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
348 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
349 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
350 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
351 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
352 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
353 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
354 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
355 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
356 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
357 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
358 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
359 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
360 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
361 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
362 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
363 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
364 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
365 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
366 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
367 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
368 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
369 { BFD_RELOC_SH_GOT20
, R_SH_GOT20
},
370 { BFD_RELOC_SH_GOTOFF20
, R_SH_GOTOFF20
},
371 { BFD_RELOC_SH_GOTFUNCDESC
, R_SH_GOTFUNCDESC
},
372 { BFD_RELOC_SH_GOTFUNCDESC20
, R_SH_GOTFUNCDESC20
},
373 { BFD_RELOC_SH_GOTOFFFUNCDESC
, R_SH_GOTOFFFUNCDESC
},
374 { BFD_RELOC_SH_GOTOFFFUNCDESC20
, R_SH_GOTOFFFUNCDESC20
},
375 { BFD_RELOC_SH_FUNCDESC
, R_SH_FUNCDESC
},
378 /* Given a BFD reloc code, return the howto structure for the
379 corresponding SH ELF reloc. */
381 static reloc_howto_type
*
382 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
386 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
388 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
389 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
395 static reloc_howto_type
*
396 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
400 if (vxworks_object_p (abfd
))
403 i
< (sizeof (sh_vxworks_howto_table
)
404 / sizeof (sh_vxworks_howto_table
[0]));
406 if (sh_vxworks_howto_table
[i
].name
!= NULL
407 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
408 return &sh_vxworks_howto_table
[i
];
413 i
< (sizeof (sh_elf_howto_table
)
414 / sizeof (sh_elf_howto_table
[0]));
416 if (sh_elf_howto_table
[i
].name
!= NULL
417 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
418 return &sh_elf_howto_table
[i
];
424 /* Given an ELF reloc, fill in the howto field of a relent. */
427 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
431 r
= ELF32_R_TYPE (dst
->r_info
);
434 || (r
>= R_SH_FIRST_INVALID_RELOC
&& r
<= R_SH_LAST_INVALID_RELOC
)
435 || (r
>= R_SH_FIRST_INVALID_RELOC_2
&& r
<= R_SH_LAST_INVALID_RELOC_2
)
436 || (r
>= R_SH_FIRST_INVALID_RELOC_3
&& r
<= R_SH_LAST_INVALID_RELOC_3
)
437 || (r
>= R_SH_FIRST_INVALID_RELOC_4
&& r
<= R_SH_LAST_INVALID_RELOC_4
)
438 || (r
>= R_SH_FIRST_INVALID_RELOC_5
&& r
<= R_SH_LAST_INVALID_RELOC_5
)
439 || (r
>= R_SH_FIRST_INVALID_RELOC_6
&& r
<= R_SH_LAST_INVALID_RELOC_6
))
441 /* xgettext:c-format */
442 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
444 bfd_set_error (bfd_error_bad_value
);
448 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
452 /* This function handles relaxing for SH ELF. See the corresponding
453 function in coff-sh.c for a description of what this does. FIXME:
454 There is a lot of duplication here between this code and the COFF
455 specific code. The format of relocs and symbols is wound deeply
456 into this code, but it would still be better if the duplication
457 could be eliminated somehow. Note in particular that although both
458 functions use symbols like R_SH_CODE, those symbols have different
459 values; in coff-sh.c they come from include/coff/sh.h, whereas here
460 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
463 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
464 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
466 Elf_Internal_Shdr
*symtab_hdr
;
467 Elf_Internal_Rela
*internal_relocs
;
468 bfd_boolean have_code
;
469 Elf_Internal_Rela
*irel
, *irelend
;
470 bfd_byte
*contents
= NULL
;
471 Elf_Internal_Sym
*isymbuf
= NULL
;
475 if (bfd_link_relocatable (link_info
)
476 || (sec
->flags
& SEC_RELOC
) == 0
477 || sec
->reloc_count
== 0)
480 symtab_hdr
= &elf_symtab_hdr (abfd
);
482 internal_relocs
= (_bfd_elf_link_read_relocs
483 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
484 link_info
->keep_memory
));
485 if (internal_relocs
== NULL
)
490 irelend
= internal_relocs
+ sec
->reloc_count
;
491 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
493 bfd_vma laddr
, paddr
, symval
;
495 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
498 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
501 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
504 /* Get the section contents. */
505 if (contents
== NULL
)
507 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
508 contents
= elf_section_data (sec
)->this_hdr
.contents
;
511 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
516 /* The r_addend field of the R_SH_USES reloc will point us to
517 the register load. The 4 is because the r_addend field is
518 computed as though it were a jump offset, which are based
519 from 4 bytes after the jump instruction. */
520 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
521 if (laddr
>= sec
->size
)
523 /* xgettext:c-format */
525 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES offset"),
526 abfd
, (uint64_t) irel
->r_offset
);
529 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
531 /* If the instruction is not mov.l NN,rN, we don't know what to
533 if ((insn
& 0xf000) != 0xd000)
536 /* xgettext:c-format */
537 (_("%pB: %#" PRIx64
": warning: "
538 "R_SH_USES points to unrecognized insn 0x%x"),
539 abfd
, (uint64_t) irel
->r_offset
, insn
);
543 /* Get the address from which the register is being loaded. The
544 displacement in the mov.l instruction is quadrupled. It is a
545 displacement from four bytes after the movl instruction, but,
546 before adding in the PC address, two least significant bits
547 of the PC are cleared. We assume that the section is aligned
548 on a four byte boundary. */
551 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
552 if (paddr
>= sec
->size
)
555 /* xgettext:c-format */
556 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES load offset"),
557 abfd
, (uint64_t) irel
->r_offset
);
561 /* Get the reloc for the address from which the register is
562 being loaded. This reloc will tell us which function is
563 actually being called. */
564 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
565 if (irelfn
->r_offset
== paddr
566 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
568 if (irelfn
>= irelend
)
571 /* xgettext:c-format */
572 (_("%pB: %#" PRIx64
": warning: could not find expected reloc"),
573 abfd
, (uint64_t) paddr
);
577 /* Read this BFD's symbols if we haven't done so already. */
578 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
580 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
582 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
583 symtab_hdr
->sh_info
, 0,
589 /* Get the value of the symbol referred to by the reloc. */
590 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
592 /* A local symbol. */
593 Elf_Internal_Sym
*isym
;
595 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
597 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
600 /* xgettext:c-format */
601 (_("%pB: %#" PRIx64
": warning: symbol in unexpected section"),
602 abfd
, (uint64_t) paddr
);
606 symval
= (isym
->st_value
607 + sec
->output_section
->vma
608 + sec
->output_offset
);
613 struct elf_link_hash_entry
*h
;
615 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
616 h
= elf_sym_hashes (abfd
)[indx
];
617 BFD_ASSERT (h
!= NULL
);
618 if (h
->root
.type
!= bfd_link_hash_defined
619 && h
->root
.type
!= bfd_link_hash_defweak
)
621 /* This appears to be a reference to an undefined
622 symbol. Just ignore it--it will be caught by the
623 regular reloc processing. */
627 symval
= (h
->root
.u
.def
.value
628 + h
->root
.u
.def
.section
->output_section
->vma
629 + h
->root
.u
.def
.section
->output_offset
);
632 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
633 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
635 symval
+= irelfn
->r_addend
;
637 /* See if this function call can be shortened. */
640 + sec
->output_section
->vma
643 /* A branch to an address beyond ours might be increased by an
644 .align that doesn't move when bytes behind us are deleted.
645 So, we add some slop in this calculation to allow for
647 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
649 /* After all that work, we can't shorten this function call. */
653 /* Shorten the function call. */
655 /* For simplicity of coding, we are going to modify the section
656 contents, the section relocs, and the BFD symbol table. We
657 must tell the rest of the code not to free up this
658 information. It would be possible to instead create a table
659 of changes which have to be made, as is done in coff-mips.c;
660 that would be more work, but would require less memory when
661 the linker is run. */
663 elf_section_data (sec
)->relocs
= internal_relocs
;
664 elf_section_data (sec
)->this_hdr
.contents
= contents
;
665 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
667 /* Replace the jmp/jsr with a bra/bsr. */
669 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
670 replace the jmp/jsr with a bra/bsr. */
671 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
672 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
673 here, but that only checks if the symbol is an external symbol,
674 not if the symbol is in a different section. Besides, we need
675 a consistent meaning for the relocation, so we just assume here that
676 the value of the symbol is not available. */
678 /* We can't fully resolve this yet, because the external
679 symbol value may be changed by future relaxing. We let
680 the final link phase handle it. */
681 if (bfd_get_16 (abfd
, contents
+ irel
->r_offset
) & 0x0020)
682 bfd_put_16 (abfd
, (bfd_vma
) 0xa000, contents
+ irel
->r_offset
);
684 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
688 /* When we calculated the symbol "value" we had an offset in the
689 DIR32's word in memory (we read and add it above). However,
690 the jsr we create does NOT have this offset encoded, so we
691 have to add it to the addend to preserve it. */
692 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
694 /* See if there is another R_SH_USES reloc referring to the same
696 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
697 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
698 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
700 if (irelscan
< irelend
)
702 /* Some other function call depends upon this register load,
703 and we have not yet converted that function call.
704 Indeed, we may never be able to convert it. There is
705 nothing else we can do at this point. */
709 /* Look for a R_SH_COUNT reloc on the location where the
710 function address is stored. Do this before deleting any
711 bytes, to avoid confusion about the address. */
712 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
713 if (irelcount
->r_offset
== paddr
714 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
717 /* Delete the register load. */
718 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
721 /* That will change things, so, just in case it permits some
722 other function call to come within range, we should relax
723 again. Note that this is not required, and it may be slow. */
726 /* Now check whether we got a COUNT reloc. */
727 if (irelcount
>= irelend
)
730 /* xgettext:c-format */
731 (_("%pB: %#" PRIx64
": warning: "
732 "could not find expected COUNT reloc"),
733 abfd
, (uint64_t) paddr
);
737 /* The number of uses is stored in the r_addend field. We've
739 if (irelcount
->r_addend
== 0)
741 /* xgettext:c-format */
742 _bfd_error_handler (_("%pB: %#" PRIx64
": warning: bad count"),
743 abfd
, (uint64_t) paddr
);
747 --irelcount
->r_addend
;
749 /* If there are no more uses, we can delete the address. Reload
750 the address from irelfn, in case it was changed by the
751 previous call to sh_elf_relax_delete_bytes. */
752 if (irelcount
->r_addend
== 0)
754 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
758 /* We've done all we can with that function call. */
761 /* Look for load and store instructions that we can align on four
763 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
768 /* Get the section contents. */
769 if (contents
== NULL
)
771 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
772 contents
= elf_section_data (sec
)->this_hdr
.contents
;
775 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
780 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
786 elf_section_data (sec
)->relocs
= internal_relocs
;
787 elf_section_data (sec
)->this_hdr
.contents
= contents
;
788 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
793 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
795 if (! link_info
->keep_memory
)
799 /* Cache the symbols for elf_link_input_bfd. */
800 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
805 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
807 if (! link_info
->keep_memory
)
811 /* Cache the section contents for elf_link_input_bfd. */
812 elf_section_data (sec
)->this_hdr
.contents
= contents
;
816 if (internal_relocs
!= NULL
817 && elf_section_data (sec
)->relocs
!= internal_relocs
)
818 free (internal_relocs
);
824 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
827 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
829 if (internal_relocs
!= NULL
830 && elf_section_data (sec
)->relocs
!= internal_relocs
)
831 free (internal_relocs
);
836 /* Delete some bytes from a section while relaxing. FIXME: There is a
837 lot of duplication between this function and sh_relax_delete_bytes
841 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
844 Elf_Internal_Shdr
*symtab_hdr
;
845 unsigned int sec_shndx
;
847 Elf_Internal_Rela
*irel
, *irelend
;
848 Elf_Internal_Rela
*irelalign
;
850 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
851 struct elf_link_hash_entry
**sym_hashes
;
852 struct elf_link_hash_entry
**end_hashes
;
853 unsigned int symcount
;
856 symtab_hdr
= &elf_symtab_hdr (abfd
);
857 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
859 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
861 contents
= elf_section_data (sec
)->this_hdr
.contents
;
863 /* The deletion must stop at the next ALIGN reloc for an alignment
864 power larger than the number of bytes we are deleting. */
869 irel
= elf_section_data (sec
)->relocs
;
870 irelend
= irel
+ sec
->reloc_count
;
871 for (; irel
< irelend
; irel
++)
873 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
874 && irel
->r_offset
> addr
875 && count
< (1 << irel
->r_addend
))
878 toaddr
= irel
->r_offset
;
883 /* Actually delete the bytes. */
884 memmove (contents
+ addr
, contents
+ addr
+ count
,
885 (size_t) (toaddr
- addr
- count
));
886 if (irelalign
== NULL
)
892 #define NOP_OPCODE (0x0009)
894 BFD_ASSERT ((count
& 1) == 0);
895 for (i
= 0; i
< count
; i
+= 2)
896 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
899 /* Adjust all the relocs. */
900 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
902 bfd_vma nraddr
, stop
;
905 int off
, adjust
, oinsn
;
906 bfd_signed_vma voff
= 0;
907 bfd_boolean overflow
;
909 /* Get the new reloc address. */
910 nraddr
= irel
->r_offset
;
911 if ((irel
->r_offset
> addr
912 && irel
->r_offset
< toaddr
)
913 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
914 && irel
->r_offset
== toaddr
))
917 /* See if this reloc was for the bytes we have deleted, in which
918 case we no longer care about it. Don't delete relocs which
919 represent addresses, though. */
920 if (irel
->r_offset
>= addr
921 && irel
->r_offset
< addr
+ count
922 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
923 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
924 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
925 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
926 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
929 /* If this is a PC relative reloc, see if the range it covers
930 includes the bytes we have deleted. */
931 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
940 start
= irel
->r_offset
;
941 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
945 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
952 /* If this reloc is against a symbol defined in this
953 section, and the symbol will not be adjusted below, we
954 must check the addend to see it will put the value in
955 range to be adjusted, and hence must be changed. */
956 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
958 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
959 if (isym
->st_shndx
== sec_shndx
960 && (isym
->st_value
<= addr
961 || isym
->st_value
>= toaddr
))
965 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
967 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
968 val
+= isym
->st_value
;
969 if (val
> addr
&& val
< toaddr
)
970 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
974 val
= isym
->st_value
+ irel
->r_addend
;
975 if (val
> addr
&& val
< toaddr
)
976 irel
->r_addend
-= count
;
987 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
994 /* This has been made by previous relaxation. Since the
995 relocation will be against an external symbol, the
996 final relocation will just do the right thing. */
1003 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1005 /* The addend will be against the section symbol, thus
1006 for adjusting the addend, the relevant start is the
1007 start of the section.
1008 N.B. If we want to abandon in-place changes here and
1009 test directly using symbol + addend, we have to take into
1010 account that the addend has already been adjusted by -4. */
1011 if (stop
> addr
&& stop
< toaddr
)
1012 irel
->r_addend
-= count
;
1018 stop
= start
+ 4 + off
* 2;
1023 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1029 /* These relocs types represent
1031 The r_addend field holds the difference between the reloc
1032 address and L1. That is the start of the reloc, and
1033 adding in the contents gives us the top. We must adjust
1034 both the r_offset field and the section contents.
1035 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1036 and the elf bfd r_offset is called r_vaddr. */
1038 stop
= irel
->r_offset
;
1039 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1043 && (stop
<= addr
|| stop
>= toaddr
))
1044 irel
->r_addend
+= count
;
1045 else if (stop
> addr
1047 && (start
<= addr
|| start
>= toaddr
))
1048 irel
->r_addend
-= count
;
1050 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1051 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1052 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1053 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1055 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1056 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1061 start
= irel
->r_offset
;
1062 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1063 + (long) irel
->r_addend
1070 && (stop
<= addr
|| stop
>= toaddr
))
1072 else if (stop
> addr
1074 && (start
<= addr
|| start
>= toaddr
))
1083 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1092 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1094 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1099 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1101 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1105 BFD_ASSERT (adjust
== count
|| count
>= 4);
1110 if ((irel
->r_offset
& 3) == 0)
1113 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1115 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1120 if (voff
< 0 || voff
>= 0xff)
1122 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1127 if (voff
< - 0x8000 || voff
>= 0x8000)
1129 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1134 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1138 irel
->r_addend
+= adjust
;
1145 /* xgettext:c-format */
1146 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1147 abfd
, (uint64_t) irel
->r_offset
);
1148 bfd_set_error (bfd_error_bad_value
);
1153 irel
->r_offset
= nraddr
;
1156 /* Look through all the other sections. If there contain any IMM32
1157 relocs against internal symbols which we are not going to adjust
1158 below, we may need to adjust the addends. */
1159 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1161 Elf_Internal_Rela
*internal_relocs
;
1162 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1163 bfd_byte
*ocontents
;
1166 || (o
->flags
& SEC_RELOC
) == 0
1167 || o
->reloc_count
== 0)
1170 /* We always cache the relocs. Perhaps, if info->keep_memory is
1171 FALSE, we should free them, if we are permitted to, when we
1172 leave sh_coff_relax_section. */
1173 internal_relocs
= (_bfd_elf_link_read_relocs
1174 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
));
1175 if (internal_relocs
== NULL
)
1179 irelscanend
= internal_relocs
+ o
->reloc_count
;
1180 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1182 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1183 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1185 bfd_vma start
, stop
;
1186 bfd_signed_vma voff
;
1188 if (ocontents
== NULL
)
1190 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1191 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1194 /* We always cache the section contents.
1195 Perhaps, if info->keep_memory is FALSE, we
1196 should free them, if we are permitted to,
1197 when we leave sh_coff_relax_section. */
1198 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1200 if (ocontents
!= NULL
)
1205 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1209 stop
= irelscan
->r_offset
;
1211 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1213 /* STOP is in a different section, so it won't change. */
1214 if (start
> addr
&& start
< toaddr
)
1215 irelscan
->r_addend
+= count
;
1217 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1218 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1222 && (stop
<= addr
|| stop
>= toaddr
))
1223 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1224 ocontents
+ irelscan
->r_offset
);
1225 else if (stop
> addr
1227 && (start
<= addr
|| start
>= toaddr
))
1228 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1229 ocontents
+ irelscan
->r_offset
);
1232 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1235 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1239 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1240 if (isym
->st_shndx
== sec_shndx
1241 && (isym
->st_value
<= addr
1242 || isym
->st_value
>= toaddr
))
1246 if (ocontents
== NULL
)
1248 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1249 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1252 /* We always cache the section contents.
1253 Perhaps, if info->keep_memory is FALSE, we
1254 should free them, if we are permitted to,
1255 when we leave sh_coff_relax_section. */
1256 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1258 if (ocontents
!= NULL
)
1263 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1267 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1268 val
+= isym
->st_value
;
1269 if (val
> addr
&& val
< toaddr
)
1270 bfd_put_32 (abfd
, val
- count
,
1271 ocontents
+ irelscan
->r_offset
);
1276 /* Adjust the local symbols defined in this section. */
1277 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1278 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1280 if (isym
->st_shndx
== sec_shndx
1281 && isym
->st_value
> addr
1282 && isym
->st_value
< toaddr
)
1283 isym
->st_value
-= count
;
1286 /* Now adjust the global symbols defined in this section. */
1287 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1288 - symtab_hdr
->sh_info
);
1289 sym_hashes
= elf_sym_hashes (abfd
);
1290 end_hashes
= sym_hashes
+ symcount
;
1291 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1293 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1294 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1295 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1296 && sym_hash
->root
.u
.def
.section
== sec
1297 && sym_hash
->root
.u
.def
.value
> addr
1298 && sym_hash
->root
.u
.def
.value
< toaddr
)
1300 sym_hash
->root
.u
.def
.value
-= count
;
1304 /* See if we can move the ALIGN reloc forward. We have adjusted
1305 r_offset for it already. */
1306 if (irelalign
!= NULL
)
1308 bfd_vma alignto
, alignaddr
;
1310 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1311 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1312 1 << irelalign
->r_addend
);
1313 if (alignto
!= alignaddr
)
1315 /* Tail recursion. */
1316 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1317 (int) (alignto
- alignaddr
));
1324 /* Look for loads and stores which we can align to four byte
1325 boundaries. This is like sh_align_loads in coff-sh.c. */
1328 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1329 Elf_Internal_Rela
*internal_relocs
,
1330 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1331 bfd_boolean
*pswapped
)
1333 Elf_Internal_Rela
*irel
, *irelend
;
1334 bfd_vma
*labels
= NULL
;
1335 bfd_vma
*label
, *label_end
;
1340 irelend
= internal_relocs
+ sec
->reloc_count
;
1342 /* Get all the addresses with labels on them. */
1343 amt
= sec
->reloc_count
;
1344 amt
*= sizeof (bfd_vma
);
1345 labels
= (bfd_vma
*) bfd_malloc (amt
);
1349 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1351 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1353 *label_end
= irel
->r_offset
;
1358 /* Note that the assembler currently always outputs relocs in
1359 address order. If that ever changes, this code will need to sort
1360 the label values and the relocs. */
1364 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1366 bfd_vma start
, stop
;
1368 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1371 start
= irel
->r_offset
;
1373 for (irel
++; irel
< irelend
; irel
++)
1374 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1377 stop
= irel
->r_offset
;
1381 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1382 internal_relocs
, &label
,
1383 label_end
, start
, stop
, pswapped
))
1397 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1400 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1401 bfd_byte
*contents
, bfd_vma addr
)
1403 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1404 unsigned short i1
, i2
;
1405 Elf_Internal_Rela
*irel
, *irelend
;
1407 /* Swap the instructions themselves. */
1408 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1409 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1410 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1411 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1413 /* Adjust all reloc addresses. */
1414 irelend
= internal_relocs
+ sec
->reloc_count
;
1415 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1417 enum elf_sh_reloc_type type
;
1420 /* There are a few special types of relocs that we don't want to
1421 adjust. These relocs do not apply to the instruction itself,
1422 but are only associated with the address. */
1423 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1424 if (type
== R_SH_ALIGN
1425 || type
== R_SH_CODE
1426 || type
== R_SH_DATA
1427 || type
== R_SH_LABEL
)
1430 /* If an R_SH_USES reloc points to one of the addresses being
1431 swapped, we must adjust it. It would be incorrect to do this
1432 for a jump, though, since we want to execute both
1433 instructions after the jump. (We have avoided swapping
1434 around a label, so the jump will not wind up executing an
1435 instruction it shouldn't). */
1436 if (type
== R_SH_USES
)
1440 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1442 irel
->r_offset
+= 2;
1443 else if (off
== addr
+ 2)
1444 irel
->r_offset
-= 2;
1447 if (irel
->r_offset
== addr
)
1449 irel
->r_offset
+= 2;
1452 else if (irel
->r_offset
== addr
+ 2)
1454 irel
->r_offset
-= 2;
1463 unsigned short insn
, oinsn
;
1464 bfd_boolean overflow
;
1466 loc
= contents
+ irel
->r_offset
;
1475 insn
= bfd_get_16 (abfd
, loc
);
1478 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1480 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1484 insn
= bfd_get_16 (abfd
, loc
);
1487 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1489 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1493 /* This reloc ignores the least significant 3 bits of
1494 the program counter before adding in the offset.
1495 This means that if ADDR is at an even address, the
1496 swap will not affect the offset. If ADDR is an at an
1497 odd address, then the instruction will be crossing a
1498 four byte boundary, and must be adjusted. */
1499 if ((addr
& 3) != 0)
1501 insn
= bfd_get_16 (abfd
, loc
);
1504 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1506 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1515 /* xgettext:c-format */
1516 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1517 abfd
, (uint64_t) irel
->r_offset
);
1518 bfd_set_error (bfd_error_bad_value
);
1527 /* Describes one of the various PLT styles. */
1529 struct elf_sh_plt_info
1531 /* The template for the first PLT entry, or NULL if there is no special
1533 const bfd_byte
*plt0_entry
;
1535 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1536 bfd_vma plt0_entry_size
;
1538 /* Index I is the offset into PLT0_ENTRY of a pointer to
1539 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1540 if there is no such pointer. */
1541 bfd_vma plt0_got_fields
[3];
1543 /* The template for a symbol's PLT entry. */
1544 const bfd_byte
*symbol_entry
;
1546 /* The size of SYMBOL_ENTRY in bytes. */
1547 bfd_vma symbol_entry_size
;
1549 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1550 on all targets. The comments by each member indicate the value
1551 that the field must hold. */
1553 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1554 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1555 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1556 bfd_boolean got20
; /* TRUE if got_entry points to a movi20
1557 instruction (instead of a constant pool
1561 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1562 bfd_vma symbol_resolve_offset
;
1564 /* A different PLT layout which can be used for the first
1565 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1567 const struct elf_sh_plt_info
*short_plt
;
1570 /* The size in bytes of an entry in the procedure linkage table. */
1572 #define ELF_PLT_ENTRY_SIZE 28
1574 /* First entry in an absolute procedure linkage table look like this. */
1576 /* Note - this code has been "optimised" not to use r2. r2 is used by
1577 GCC to return the address of large structures, so it should not be
1578 corrupted here. This does mean however, that this PLT does not conform
1579 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1580 and r2 contains the GOT id. This version stores the GOT id in r0 and
1581 ignores the type. Loaders can easily detect this difference however,
1582 since the type will always be 0 or 8, and the GOT ids will always be
1583 greater than or equal to 12. */
1584 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1586 0xd0, 0x05, /* mov.l 2f,r0 */
1587 0x60, 0x02, /* mov.l @r0,r0 */
1588 0x2f, 0x06, /* mov.l r0,@-r15 */
1589 0xd0, 0x03, /* mov.l 1f,r0 */
1590 0x60, 0x02, /* mov.l @r0,r0 */
1591 0x40, 0x2b, /* jmp @r0 */
1592 0x60, 0xf6, /* mov.l @r15+,r0 */
1593 0x00, 0x09, /* nop */
1594 0x00, 0x09, /* nop */
1595 0x00, 0x09, /* nop */
1596 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1597 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1600 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1602 0x05, 0xd0, /* mov.l 2f,r0 */
1603 0x02, 0x60, /* mov.l @r0,r0 */
1604 0x06, 0x2f, /* mov.l r0,@-r15 */
1605 0x03, 0xd0, /* mov.l 1f,r0 */
1606 0x02, 0x60, /* mov.l @r0,r0 */
1607 0x2b, 0x40, /* jmp @r0 */
1608 0xf6, 0x60, /* mov.l @r15+,r0 */
1609 0x09, 0x00, /* nop */
1610 0x09, 0x00, /* nop */
1611 0x09, 0x00, /* nop */
1612 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1613 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1616 /* Sebsequent entries in an absolute procedure linkage table look like
1619 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1621 0xd0, 0x04, /* mov.l 1f,r0 */
1622 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1623 0xd1, 0x02, /* mov.l 0f,r1 */
1624 0x40, 0x2b, /* jmp @r0 */
1625 0x60, 0x13, /* mov r1,r0 */
1626 0xd1, 0x03, /* mov.l 2f,r1 */
1627 0x40, 0x2b, /* jmp @r0 */
1628 0x00, 0x09, /* nop */
1629 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1630 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1631 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1634 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1636 0x04, 0xd0, /* mov.l 1f,r0 */
1637 0x02, 0x60, /* mov.l @r0,r0 */
1638 0x02, 0xd1, /* mov.l 0f,r1 */
1639 0x2b, 0x40, /* jmp @r0 */
1640 0x13, 0x60, /* mov r1,r0 */
1641 0x03, 0xd1, /* mov.l 2f,r1 */
1642 0x2b, 0x40, /* jmp @r0 */
1643 0x09, 0x00, /* nop */
1644 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1645 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1646 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1649 /* Entries in a PIC procedure linkage table look like this. */
1651 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1653 0xd0, 0x04, /* mov.l 1f,r0 */
1654 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1655 0x40, 0x2b, /* jmp @r0 */
1656 0x00, 0x09, /* nop */
1657 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1658 0xd1, 0x03, /* mov.l 2f,r1 */
1659 0x40, 0x2b, /* jmp @r0 */
1660 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1661 0x00, 0x09, /* nop */
1662 0x00, 0x09, /* nop */
1663 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1664 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1667 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1669 0x04, 0xd0, /* mov.l 1f,r0 */
1670 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1671 0x2b, 0x40, /* jmp @r0 */
1672 0x09, 0x00, /* nop */
1673 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1674 0x03, 0xd1, /* mov.l 2f,r1 */
1675 0x2b, 0x40, /* jmp @r0 */
1676 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1677 0x09, 0x00, /* nop */
1678 0x09, 0x00, /* nop */
1679 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1680 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1683 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1686 /* Big-endian non-PIC. */
1687 elf_sh_plt0_entry_be
,
1689 { MINUS_ONE
, 24, 20 },
1690 elf_sh_plt_entry_be
,
1692 { 20, 16, 24, FALSE
},
1697 /* Little-endian non-PIC. */
1698 elf_sh_plt0_entry_le
,
1700 { MINUS_ONE
, 24, 20 },
1701 elf_sh_plt_entry_le
,
1703 { 20, 16, 24, FALSE
},
1710 /* Big-endian PIC. */
1711 elf_sh_plt0_entry_be
,
1713 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1714 elf_sh_pic_plt_entry_be
,
1716 { 20, MINUS_ONE
, 24, FALSE
},
1721 /* Little-endian PIC. */
1722 elf_sh_plt0_entry_le
,
1724 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1725 elf_sh_pic_plt_entry_le
,
1727 { 20, MINUS_ONE
, 24, FALSE
},
1734 #define VXWORKS_PLT_HEADER_SIZE 12
1735 #define VXWORKS_PLT_ENTRY_SIZE 24
1737 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1739 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1740 0x61, 0x12, /* mov.l @r1,r1 */
1741 0x41, 0x2b, /* jmp @r1 */
1742 0x00, 0x09, /* nop */
1743 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1746 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1748 0x01, 0xd1, /* mov.l @(8,pc),r1 */
1749 0x12, 0x61, /* mov.l @r1,r1 */
1750 0x2b, 0x41, /* jmp @r1 */
1751 0x09, 0x00, /* nop */
1752 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1755 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1757 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1758 0x60, 0x02, /* mov.l @r0,r0 */
1759 0x40, 0x2b, /* jmp @r0 */
1760 0x00, 0x09, /* nop */
1761 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1762 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1763 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
1764 0x00, 0x09, /* nop */
1765 0x00, 0x09, /* nop */
1766 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1769 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1771 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1772 0x02, 0x60, /* mov.l @r0,r0 */
1773 0x2b, 0x40, /* jmp @r0 */
1774 0x09, 0x00, /* nop */
1775 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1776 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1777 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
1778 0x09, 0x00, /* nop */
1779 0x09, 0x00, /* nop */
1780 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1783 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1785 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1786 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1787 0x40, 0x2b, /* jmp @r0 */
1788 0x00, 0x09, /* nop */
1789 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1790 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1791 0x51, 0xc2, /* mov.l @(8,r12),r1 */
1792 0x41, 0x2b, /* jmp @r1 */
1793 0x00, 0x09, /* nop */
1794 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1797 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1799 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1800 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1801 0x2b, 0x40, /* jmp @r0 */
1802 0x09, 0x00, /* nop */
1803 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1804 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1805 0xc2, 0x51, /* mov.l @(8,r12),r1 */
1806 0x2b, 0x41, /* jmp @r1 */
1807 0x09, 0x00, /* nop */
1808 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1811 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
1814 /* Big-endian non-PIC. */
1815 vxworks_sh_plt0_entry_be
,
1816 VXWORKS_PLT_HEADER_SIZE
,
1817 { MINUS_ONE
, MINUS_ONE
, 8 },
1818 vxworks_sh_plt_entry_be
,
1819 VXWORKS_PLT_ENTRY_SIZE
,
1820 { 8, 14, 20, FALSE
},
1825 /* Little-endian non-PIC. */
1826 vxworks_sh_plt0_entry_le
,
1827 VXWORKS_PLT_HEADER_SIZE
,
1828 { MINUS_ONE
, MINUS_ONE
, 8 },
1829 vxworks_sh_plt_entry_le
,
1830 VXWORKS_PLT_ENTRY_SIZE
,
1831 { 8, 14, 20, FALSE
},
1838 /* Big-endian PIC. */
1841 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1842 vxworks_sh_pic_plt_entry_be
,
1843 VXWORKS_PLT_ENTRY_SIZE
,
1844 { 8, MINUS_ONE
, 20, FALSE
},
1849 /* Little-endian PIC. */
1852 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1853 vxworks_sh_pic_plt_entry_le
,
1854 VXWORKS_PLT_ENTRY_SIZE
,
1855 { 8, MINUS_ONE
, 20, FALSE
},
1862 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
1863 binding are to omit the lazy binding stub when linking with -z now
1864 and to move lazy binding stubs into a separate region for better
1867 #define FDPIC_PLT_ENTRY_SIZE 28
1868 #define FDPIC_PLT_LAZY_OFFSET 20
1870 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
1871 duplicated if it is out of range, or which can be inlined. So
1872 right now it is always inlined, which wastes a word per stub. It
1873 might be easier to handle the duplication if we put the lazy
1874 stubs separately. */
1876 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
1878 0xd0, 0x02, /* mov.l @(12,pc),r0 */
1879 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1880 0x70, 0x04, /* add #4, r0 */
1881 0x41, 0x2b, /* jmp @r1 */
1882 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1883 0x00, 0x09, /* nop */
1884 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1885 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1886 0x60, 0xc2, /* mov.l @r12,r0 */
1887 0x40, 0x2b, /* jmp @r0 */
1888 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1889 0x00, 0x09, /* nop */
1892 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
1894 0x02, 0xd0, /* mov.l @(12,pc),r0 */
1895 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1896 0x04, 0x70, /* add #4, r0 */
1897 0x2b, 0x41, /* jmp @r1 */
1898 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1899 0x09, 0x00, /* nop */
1900 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1901 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1902 0xc2, 0x60, /* mov.l @r12,r0 */
1903 0x2b, 0x40, /* jmp @r0 */
1904 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1905 0x09, 0x00, /* nop */
1908 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
1910 /* Big-endian PIC. */
1913 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1914 fdpic_sh_plt_entry_be
,
1915 FDPIC_PLT_ENTRY_SIZE
,
1916 { 12, MINUS_ONE
, 16, FALSE
},
1917 FDPIC_PLT_LAZY_OFFSET
,
1921 /* Little-endian PIC. */
1924 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1925 fdpic_sh_plt_entry_le
,
1926 FDPIC_PLT_ENTRY_SIZE
,
1927 { 12, MINUS_ONE
, 16, FALSE
},
1928 FDPIC_PLT_LAZY_OFFSET
,
1933 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
1934 entries for the first 64K slots. We use the normal FDPIC PLT entry
1935 past that point; we could also use movi20s, which might be faster,
1936 but would not be any smaller. */
1938 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
1939 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
1941 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1943 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1944 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1945 0x70, 0x04, /* add #4, r0 */
1946 0x41, 0x2b, /* jmp @r1 */
1947 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1948 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1949 0x60, 0xc2, /* mov.l @r12,r0 */
1950 0x40, 0x2b, /* jmp @r0 */
1951 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1952 0x00, 0x09, /* nop */
1955 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1957 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1958 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1959 0x04, 0x70, /* add #4, r0 */
1960 0x2b, 0x41, /* jmp @r1 */
1961 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1962 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1963 0xc2, 0x60, /* mov.l @r12,r0 */
1964 0x2b, 0x40, /* jmp @r0 */
1965 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1966 0x09, 0x00, /* nop */
1969 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
1970 /* Big-endian FDPIC, max index 64K. */
1973 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1974 fdpic_sh2a_plt_entry_be
,
1975 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1976 { 0, MINUS_ONE
, 12, TRUE
},
1977 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1981 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
1982 /* Little-endian FDPIC, max index 64K. */
1985 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1986 fdpic_sh2a_plt_entry_le
,
1987 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1988 { 0, MINUS_ONE
, 12, TRUE
},
1989 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1993 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
1995 /* Big-endian PIC. */
1998 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1999 fdpic_sh_plt_entry_be
,
2000 FDPIC_PLT_ENTRY_SIZE
,
2001 { 12, MINUS_ONE
, 16, FALSE
},
2002 FDPIC_PLT_LAZY_OFFSET
,
2003 &fdpic_sh2a_short_plt_be
2006 /* Little-endian PIC. */
2009 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
2010 fdpic_sh_plt_entry_le
,
2011 FDPIC_PLT_ENTRY_SIZE
,
2012 { 12, MINUS_ONE
, 16, FALSE
},
2013 FDPIC_PLT_LAZY_OFFSET
,
2014 &fdpic_sh2a_short_plt_le
2018 /* Return the type of PLT associated with ABFD. PIC_P is true if
2019 the object is position-independent. */
2021 static const struct elf_sh_plt_info
*
2022 get_plt_info (bfd
*abfd
, bfd_boolean pic_p
)
2024 if (fdpic_object_p (abfd
))
2026 /* If any input file requires SH2A we can use a shorter PLT
2028 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2029 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2031 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2033 if (vxworks_object_p (abfd
))
2034 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2035 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2038 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2039 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2043 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2044 unsigned long value
, bfd_byte
*addr
)
2046 bfd_put_32 (output_bfd
, value
, addr
);
2049 /* The number of PLT entries which can use a shorter PLT, if any.
2050 Currently always 64K, since only SH-2A FDPIC uses this; a
2051 20-bit movi20 can address that many function descriptors below
2052 _GLOBAL_OFFSET_TABLE_. */
2053 #define MAX_SHORT_PLT 65536
2055 /* Return the index of the PLT entry at byte offset OFFSET. */
2058 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2060 bfd_vma plt_index
= 0;
2062 offset
-= info
->plt0_entry_size
;
2063 if (info
->short_plt
!= NULL
)
2065 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2067 plt_index
= MAX_SHORT_PLT
;
2068 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2071 info
= info
->short_plt
;
2073 return plt_index
+ offset
/ info
->symbol_entry_size
;
2076 /* Do the inverse operation. */
2079 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2083 if (info
->short_plt
!= NULL
)
2085 if (plt_index
> MAX_SHORT_PLT
)
2087 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2088 plt_index
-= MAX_SHORT_PLT
;
2091 info
= info
->short_plt
;
2093 return (offset
+ info
->plt0_entry_size
2094 + (plt_index
* info
->symbol_entry_size
));
2099 bfd_signed_vma refcount
;
2103 /* sh ELF linker hash entry. */
2105 struct elf_sh_link_hash_entry
2107 struct elf_link_hash_entry root
;
2109 /* Track dynamic relocs copied for this symbol. */
2110 struct elf_dyn_relocs
*dyn_relocs
;
2112 bfd_signed_vma gotplt_refcount
;
2114 /* A local function descriptor, for FDPIC. The refcount counts
2115 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2116 relocations; the PLT and GOT entry are accounted
2117 for separately. After adjust_dynamic_symbol, the offset is
2118 MINUS_ONE if there is no local descriptor (dynamic linker
2119 managed and no PLT entry, or undefined weak non-dynamic).
2120 During check_relocs we do not yet know whether the local
2121 descriptor will be canonical. */
2122 union gotref funcdesc
;
2124 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2125 and thus require fixups or relocations. */
2126 bfd_signed_vma abs_funcdesc_refcount
;
2129 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2133 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2135 struct sh_elf_obj_tdata
2137 struct elf_obj_tdata root
;
2139 /* got_type for each local got entry. */
2140 char *local_got_type
;
2142 /* Function descriptor refcount and offset for each local symbol. */
2143 union gotref
*local_funcdesc
;
2146 #define sh_elf_tdata(abfd) \
2147 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2149 #define sh_elf_local_got_type(abfd) \
2150 (sh_elf_tdata (abfd)->local_got_type)
2152 #define sh_elf_local_funcdesc(abfd) \
2153 (sh_elf_tdata (abfd)->local_funcdesc)
2155 #define is_sh_elf(bfd) \
2156 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2157 && elf_tdata (bfd) != NULL \
2158 && elf_object_id (bfd) == SH_ELF_DATA)
2160 /* Override the generic function because we need to store sh_elf_obj_tdata
2161 as the specific tdata. */
2164 sh_elf_mkobject (bfd
*abfd
)
2166 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2170 /* sh ELF linker hash table. */
2172 struct elf_sh_link_hash_table
2174 struct elf_link_hash_table root
;
2176 /* Short-cuts to get to dynamic linker sections. */
2179 asection
*sfuncdesc
;
2180 asection
*srelfuncdesc
;
2183 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2186 /* Small local sym cache. */
2187 struct sym_cache sym_cache
;
2189 /* A counter or offset to track a TLS got entry. */
2192 bfd_signed_vma refcount
;
2196 /* The type of PLT to use. */
2197 const struct elf_sh_plt_info
*plt_info
;
2199 /* True if the target system is VxWorks. */
2200 bfd_boolean vxworks_p
;
2202 /* True if the target system uses FDPIC. */
2203 bfd_boolean fdpic_p
;
2206 /* Traverse an sh ELF linker hash table. */
2208 #define sh_elf_link_hash_traverse(table, func, info) \
2209 (elf_link_hash_traverse \
2211 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2214 /* Get the sh ELF linker hash table from a link_info structure. */
2216 #define sh_elf_hash_table(p) \
2217 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2218 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2220 /* Create an entry in an sh ELF linker hash table. */
2222 static struct bfd_hash_entry
*
2223 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2224 struct bfd_hash_table
*table
,
2227 struct elf_sh_link_hash_entry
*ret
=
2228 (struct elf_sh_link_hash_entry
*) entry
;
2230 /* Allocate the structure if it has not already been allocated by a
2232 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2233 ret
= ((struct elf_sh_link_hash_entry
*)
2234 bfd_hash_allocate (table
,
2235 sizeof (struct elf_sh_link_hash_entry
)));
2236 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2237 return (struct bfd_hash_entry
*) ret
;
2239 /* Call the allocation method of the superclass. */
2240 ret
= ((struct elf_sh_link_hash_entry
*)
2241 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2243 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2245 ret
->dyn_relocs
= NULL
;
2246 ret
->gotplt_refcount
= 0;
2247 ret
->funcdesc
.refcount
= 0;
2248 ret
->abs_funcdesc_refcount
= 0;
2249 ret
->got_type
= GOT_UNKNOWN
;
2252 return (struct bfd_hash_entry
*) ret
;
2255 /* Create an sh ELF linker hash table. */
2257 static struct bfd_link_hash_table
*
2258 sh_elf_link_hash_table_create (bfd
*abfd
)
2260 struct elf_sh_link_hash_table
*ret
;
2261 bfd_size_type amt
= sizeof (struct elf_sh_link_hash_table
);
2263 ret
= (struct elf_sh_link_hash_table
*) bfd_zmalloc (amt
);
2264 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2267 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2268 sh_elf_link_hash_newfunc
,
2269 sizeof (struct elf_sh_link_hash_entry
),
2276 ret
->vxworks_p
= vxworks_object_p (abfd
);
2277 ret
->fdpic_p
= fdpic_object_p (abfd
);
2279 return &ret
->root
.root
;
2283 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2284 struct bfd_link_info
*info
, asection
*p
)
2286 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2288 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2292 /* We need dynamic symbols for every section, since segments can
2293 relocate independently. */
2294 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2298 /* If sh_type is yet undecided, assume it could be
2299 SHT_PROGBITS/SHT_NOBITS. */
2303 /* There shouldn't be section relative relocations
2304 against any other section. */
2310 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2311 shortcuts to them in our hash table. */
2314 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2316 struct elf_sh_link_hash_table
*htab
;
2318 if (! _bfd_elf_create_got_section (dynobj
, info
))
2321 htab
= sh_elf_hash_table (info
);
2325 htab
->sfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.funcdesc",
2326 (SEC_ALLOC
| SEC_LOAD
2329 | SEC_LINKER_CREATED
));
2330 if (htab
->sfuncdesc
== NULL
2331 || !bfd_set_section_alignment (htab
->sfuncdesc
, 2))
2334 htab
->srelfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
,
2335 ".rela.got.funcdesc",
2336 (SEC_ALLOC
| SEC_LOAD
2339 | SEC_LINKER_CREATED
2341 if (htab
->srelfuncdesc
== NULL
2342 || !bfd_set_section_alignment (htab
->srelfuncdesc
, 2))
2345 /* Also create .rofixup. */
2346 htab
->srofixup
= bfd_make_section_anyway_with_flags (dynobj
, ".rofixup",
2347 (SEC_ALLOC
| SEC_LOAD
2350 | SEC_LINKER_CREATED
2352 if (htab
->srofixup
== NULL
2353 || !bfd_set_section_alignment (htab
->srofixup
, 2))
2359 /* Create dynamic sections when linking against a dynamic object. */
2362 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2364 struct elf_sh_link_hash_table
*htab
;
2365 flagword flags
, pltflags
;
2367 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2370 switch (bed
->s
->arch_size
)
2381 bfd_set_error (bfd_error_bad_value
);
2385 htab
= sh_elf_hash_table (info
);
2389 if (htab
->root
.dynamic_sections_created
)
2392 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2393 .rel[a].bss sections. */
2395 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2396 | SEC_LINKER_CREATED
);
2399 pltflags
|= SEC_CODE
;
2400 if (bed
->plt_not_loaded
)
2401 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2402 if (bed
->plt_readonly
)
2403 pltflags
|= SEC_READONLY
;
2405 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2406 htab
->root
.splt
= s
;
2408 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2411 if (bed
->want_plt_sym
)
2413 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2415 struct elf_link_hash_entry
*h
;
2416 struct bfd_link_hash_entry
*bh
= NULL
;
2418 if (! (_bfd_generic_link_add_one_symbol
2419 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2420 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2421 get_elf_backend_data (abfd
)->collect
, &bh
)))
2424 h
= (struct elf_link_hash_entry
*) bh
;
2426 h
->type
= STT_OBJECT
;
2427 htab
->root
.hplt
= h
;
2429 if (bfd_link_pic (info
)
2430 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2434 s
= bfd_make_section_anyway_with_flags (abfd
,
2435 bed
->default_use_rela_p
2436 ? ".rela.plt" : ".rel.plt",
2437 flags
| SEC_READONLY
);
2438 htab
->root
.srelplt
= s
;
2440 || !bfd_set_section_alignment (s
, ptralign
))
2443 if (htab
->root
.sgot
== NULL
2444 && !create_got_section (abfd
, info
))
2447 if (bed
->want_dynbss
)
2449 /* The .dynbss section is a place to put symbols which are defined
2450 by dynamic objects, are referenced by regular objects, and are
2451 not functions. We must allocate space for them in the process
2452 image and use a R_*_COPY reloc to tell the dynamic linker to
2453 initialize them at run time. The linker script puts the .dynbss
2454 section into the .bss section of the final image. */
2455 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2456 SEC_ALLOC
| SEC_LINKER_CREATED
);
2461 /* The .rel[a].bss section holds copy relocs. This section is not
2462 normally needed. We need to create it here, though, so that the
2463 linker will map it to an output section. We can't just create it
2464 only if we need it, because we will not know whether we need it
2465 until we have seen all the input files, and the first time the
2466 main linker code calls BFD after examining all the input files
2467 (size_dynamic_sections) the input sections have already been
2468 mapped to the output sections. If the section turns out not to
2469 be needed, we can discard it later. We will never need this
2470 section when generating a shared object, since they do not use
2472 if (! bfd_link_pic (info
))
2474 s
= bfd_make_section_anyway_with_flags (abfd
,
2475 (bed
->default_use_rela_p
2476 ? ".rela.bss" : ".rel.bss"),
2477 flags
| SEC_READONLY
);
2480 || !bfd_set_section_alignment (s
, ptralign
))
2485 if (htab
->vxworks_p
)
2487 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2494 /* Find dynamic relocs for H that apply to read-only sections. */
2497 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
2499 struct elf_dyn_relocs
*p
;
2501 for (p
= sh_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2503 asection
*s
= p
->sec
->output_section
;
2505 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2511 /* Adjust a symbol defined by a dynamic object and referenced by a
2512 regular object. The current definition is in some section of the
2513 dynamic object, but we're not including those sections. We have to
2514 change the definition to something the rest of the link can
2518 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2519 struct elf_link_hash_entry
*h
)
2521 struct elf_sh_link_hash_table
*htab
;
2524 htab
= sh_elf_hash_table (info
);
2528 /* Make sure we know what is going on here. */
2529 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2534 && !h
->def_regular
)));
2536 /* If this is a function, put it in the procedure linkage table. We
2537 will fill in the contents of the procedure linkage table later,
2538 when we know the address of the .got section. */
2539 if (h
->type
== STT_FUNC
2542 if (h
->plt
.refcount
<= 0
2543 || SYMBOL_CALLS_LOCAL (info
, h
)
2544 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2545 && h
->root
.type
== bfd_link_hash_undefweak
))
2547 /* This case can occur if we saw a PLT reloc in an input
2548 file, but the symbol was never referred to by a dynamic
2549 object. In such a case, we don't actually need to build
2550 a procedure linkage table, and we can just do a REL32
2552 h
->plt
.offset
= (bfd_vma
) -1;
2559 h
->plt
.offset
= (bfd_vma
) -1;
2561 /* If this is a weak symbol, and there is a real definition, the
2562 processor independent code will have arranged for us to see the
2563 real definition first, and we can just use the same value. */
2564 if (h
->is_weakalias
)
2566 struct elf_link_hash_entry
*def
= weakdef (h
);
2567 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2568 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2569 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2570 if (info
->nocopyreloc
)
2571 h
->non_got_ref
= def
->non_got_ref
;
2575 /* This is a reference to a symbol defined by a dynamic object which
2576 is not a function. */
2578 /* If we are creating a shared library, we must presume that the
2579 only references to the symbol are via the global offset table.
2580 For such cases we need not do anything here; the relocations will
2581 be handled correctly by relocate_section. */
2582 if (bfd_link_pic (info
))
2585 /* If there are no references to this symbol that do not use the
2586 GOT, we don't need to generate a copy reloc. */
2587 if (!h
->non_got_ref
)
2590 /* If -z nocopyreloc was given, we won't generate them either. */
2591 if (0 && info
->nocopyreloc
)
2597 /* If we don't find any dynamic relocs in read-only sections, then
2598 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2599 if (0 && !readonly_dynrelocs (h
))
2605 /* We must allocate the symbol in our .dynbss section, which will
2606 become part of the .bss section of the executable. There will be
2607 an entry for this symbol in the .dynsym section. The dynamic
2608 object will contain position independent code, so all references
2609 from the dynamic object to this symbol will go through the global
2610 offset table. The dynamic linker will use the .dynsym entry to
2611 determine the address it must put in the global offset table, so
2612 both the dynamic object and the regular object will refer to the
2613 same memory location for the variable. */
2616 BFD_ASSERT (s
!= NULL
);
2618 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2619 copy the initial value out of the dynamic object and into the
2620 runtime process image. We need to remember the offset into the
2621 .rela.bss section we are going to use. */
2622 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2626 srel
= htab
->srelbss
;
2627 BFD_ASSERT (srel
!= NULL
);
2628 srel
->size
+= sizeof (Elf32_External_Rela
);
2632 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2635 /* Allocate space in .plt, .got and associated reloc sections for
2639 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2641 struct bfd_link_info
*info
;
2642 struct elf_sh_link_hash_table
*htab
;
2643 struct elf_sh_link_hash_entry
*eh
;
2644 struct elf_dyn_relocs
*p
;
2646 if (h
->root
.type
== bfd_link_hash_indirect
)
2649 info
= (struct bfd_link_info
*) inf
;
2650 htab
= sh_elf_hash_table (info
);
2654 eh
= (struct elf_sh_link_hash_entry
*) h
;
2655 if ((h
->got
.refcount
> 0
2657 && eh
->gotplt_refcount
> 0)
2659 /* The symbol has been forced local, or we have some direct got refs,
2660 so treat all the gotplt refs as got refs. */
2661 h
->got
.refcount
+= eh
->gotplt_refcount
;
2662 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2663 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2666 if (htab
->root
.dynamic_sections_created
2667 && h
->plt
.refcount
> 0
2668 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2669 || h
->root
.type
!= bfd_link_hash_undefweak
))
2671 /* Make sure this symbol is output as a dynamic symbol.
2672 Undefined weak syms won't yet be marked as dynamic. */
2673 if (h
->dynindx
== -1
2674 && !h
->forced_local
)
2676 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2680 if (bfd_link_pic (info
)
2681 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2683 asection
*s
= htab
->root
.splt
;
2684 const struct elf_sh_plt_info
*plt_info
;
2686 /* If this is the first .plt entry, make room for the special
2689 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2691 h
->plt
.offset
= s
->size
;
2693 /* If this symbol is not defined in a regular file, and we are
2694 not generating a shared library, then set the symbol to this
2695 location in the .plt. This is required to make function
2696 pointers compare as equal between the normal executable and
2697 the shared library. Skip this for FDPIC, since the
2698 function's address will be the address of the canonical
2699 function descriptor. */
2700 if (!htab
->fdpic_p
&& !bfd_link_pic (info
) && !h
->def_regular
)
2702 h
->root
.u
.def
.section
= s
;
2703 h
->root
.u
.def
.value
= h
->plt
.offset
;
2706 /* Make room for this entry. */
2707 plt_info
= htab
->plt_info
;
2708 if (plt_info
->short_plt
!= NULL
2709 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
2710 plt_info
= plt_info
->short_plt
;
2711 s
->size
+= plt_info
->symbol_entry_size
;
2713 /* We also need to make an entry in the .got.plt section, which
2714 will be placed in the .got section by the linker script. */
2716 htab
->root
.sgotplt
->size
+= 4;
2718 htab
->root
.sgotplt
->size
+= 8;
2720 /* We also need to make an entry in the .rel.plt section. */
2721 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
2723 if (htab
->vxworks_p
&& !bfd_link_pic (info
))
2725 /* VxWorks executables have a second set of relocations
2726 for each PLT entry. They go in a separate relocation
2727 section, which is processed by the kernel loader. */
2729 /* There is a relocation for the initial PLT entry:
2730 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
2731 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
2732 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
2734 /* There are two extra relocations for each subsequent
2735 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2736 and an R_SH_DIR32 relocation for the PLT entry. */
2737 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
2742 h
->plt
.offset
= (bfd_vma
) -1;
2748 h
->plt
.offset
= (bfd_vma
) -1;
2752 if (h
->got
.refcount
> 0)
2756 enum got_type got_type
= sh_elf_hash_entry (h
)->got_type
;
2758 /* Make sure this symbol is output as a dynamic symbol.
2759 Undefined weak syms won't yet be marked as dynamic. */
2760 if (h
->dynindx
== -1
2761 && !h
->forced_local
)
2763 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2767 s
= htab
->root
.sgot
;
2768 h
->got
.offset
= s
->size
;
2770 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
2771 if (got_type
== GOT_TLS_GD
)
2773 dyn
= htab
->root
.dynamic_sections_created
;
2776 /* No dynamic relocations required. */
2777 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
2778 && h
->root
.type
!= bfd_link_hash_undefweak
2779 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
2780 htab
->srofixup
->size
+= 4;
2782 /* No dynamic relocations required when IE->LE conversion happens. */
2783 else if (got_type
== GOT_TLS_IE
2785 && !bfd_link_pic (info
))
2787 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2788 R_SH_TLS_GD needs one if local symbol and two if global. */
2789 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2790 || got_type
== GOT_TLS_IE
)
2791 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2792 else if (got_type
== GOT_TLS_GD
)
2793 htab
->root
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2794 else if (got_type
== GOT_FUNCDESC
)
2796 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2797 htab
->srofixup
->size
+= 4;
2799 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2801 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2802 || h
->root
.type
!= bfd_link_hash_undefweak
)
2803 && (bfd_link_pic (info
)
2804 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2805 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2806 else if (htab
->fdpic_p
2807 && !bfd_link_pic (info
)
2808 && got_type
== GOT_NORMAL
2809 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2810 || h
->root
.type
!= bfd_link_hash_undefweak
))
2811 htab
->srofixup
->size
+= 4;
2814 h
->got
.offset
= (bfd_vma
) -1;
2816 /* Allocate space for any dynamic relocations to function
2817 descriptors, canonical or otherwise. We need to relocate the
2818 reference unless it resolves to zero, which only happens for
2819 undefined weak symbols (either non-default visibility, or when
2820 static linking). Any GOT slot is accounted for elsewhere. */
2821 if (eh
->abs_funcdesc_refcount
> 0
2822 && (h
->root
.type
!= bfd_link_hash_undefweak
2823 || (htab
->root
.dynamic_sections_created
2824 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
2826 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2827 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
2829 htab
->root
.srelgot
->size
2830 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
2833 /* We must allocate a function descriptor if there are references to
2834 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
2835 the dynamic linker isn't going to allocate it. None of this
2836 applies if we already created one in .got.plt, but if the
2837 canonical function descriptor can be in this object, there
2838 won't be a PLT entry at all. */
2839 if ((eh
->funcdesc
.refcount
> 0
2840 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
2841 && h
->root
.type
!= bfd_link_hash_undefweak
2842 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2844 /* Make room for this function descriptor. */
2845 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
2846 htab
->sfuncdesc
->size
+= 8;
2848 /* We will need a relocation or two fixups to initialize the
2849 function descriptor, so allocate those too. */
2850 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
2851 htab
->srofixup
->size
+= 8;
2853 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
2856 if (eh
->dyn_relocs
== NULL
)
2859 /* In the shared -Bsymbolic case, discard space allocated for
2860 dynamic pc-relative relocs against symbols which turn out to be
2861 defined in regular objects. For the normal shared case, discard
2862 space for pc-relative relocs that have become local due to symbol
2863 visibility changes. */
2865 if (bfd_link_pic (info
))
2867 if (SYMBOL_CALLS_LOCAL (info
, h
))
2869 struct elf_dyn_relocs
**pp
;
2871 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2873 p
->count
-= p
->pc_count
;
2882 if (htab
->vxworks_p
)
2884 struct elf_dyn_relocs
**pp
;
2886 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2888 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2895 /* Also discard relocs on undefined weak syms with non-default
2897 if (eh
->dyn_relocs
!= NULL
2898 && h
->root
.type
== bfd_link_hash_undefweak
)
2900 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2901 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2902 eh
->dyn_relocs
= NULL
;
2904 /* Make sure undefined weak symbols are output as a dynamic
2906 else if (h
->dynindx
== -1
2907 && !h
->forced_local
)
2909 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2916 /* For the non-shared case, discard space for relocs against
2917 symbols which turn out to need copy relocs or are not
2923 || (htab
->root
.dynamic_sections_created
2924 && (h
->root
.type
== bfd_link_hash_undefweak
2925 || h
->root
.type
== bfd_link_hash_undefined
))))
2927 /* Make sure this symbol is output as a dynamic symbol.
2928 Undefined weak syms won't yet be marked as dynamic. */
2929 if (h
->dynindx
== -1
2930 && !h
->forced_local
)
2932 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2936 /* If that succeeded, we know we'll be keeping all the
2938 if (h
->dynindx
!= -1)
2942 eh
->dyn_relocs
= NULL
;
2947 /* Finally, allocate space. */
2948 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2950 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2951 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2953 /* If we need relocations, we do not need fixups. */
2954 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
2955 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
2961 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2962 read-only sections. */
2965 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
2969 if (h
->root
.type
== bfd_link_hash_indirect
)
2972 sec
= readonly_dynrelocs (h
);
2975 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
2977 info
->flags
|= DF_TEXTREL
;
2978 info
->callbacks
->minfo
2979 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2980 sec
->owner
, h
->root
.root
.string
, sec
);
2982 /* Not an error, just cut short the traversal. */
2988 /* This function is called after all the input files have been read,
2989 and the input sections have been assigned to output sections.
2990 It's a convenient place to determine the PLT style. */
2993 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2995 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
,
2996 bfd_link_pic (info
));
2998 if (sh_elf_hash_table (info
)->fdpic_p
&& !bfd_link_relocatable (info
)
2999 && !bfd_elf_stack_segment_size (output_bfd
, info
,
3000 "__stacksize", DEFAULT_STACK_SIZE
))
3005 /* Set the sizes of the dynamic sections. */
3008 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3009 struct bfd_link_info
*info
)
3011 struct elf_sh_link_hash_table
*htab
;
3017 htab
= sh_elf_hash_table (info
);
3021 dynobj
= htab
->root
.dynobj
;
3022 BFD_ASSERT (dynobj
!= NULL
);
3024 if (htab
->root
.dynamic_sections_created
)
3026 /* Set the contents of the .interp section to the interpreter. */
3027 if (bfd_link_executable (info
) && !info
->nointerp
)
3029 s
= bfd_get_linker_section (dynobj
, ".interp");
3030 BFD_ASSERT (s
!= NULL
);
3031 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3032 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3036 /* Set up .got offsets for local syms, and space for local dynamic
3038 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3040 bfd_signed_vma
*local_got
;
3041 bfd_signed_vma
*end_local_got
;
3042 union gotref
*local_funcdesc
, *end_local_funcdesc
;
3043 char *local_got_type
;
3044 bfd_size_type locsymcount
;
3045 Elf_Internal_Shdr
*symtab_hdr
;
3048 if (! is_sh_elf (ibfd
))
3051 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3053 struct elf_dyn_relocs
*p
;
3055 for (p
= ((struct elf_dyn_relocs
*)
3056 elf_section_data (s
)->local_dynrel
);
3060 if (! bfd_is_abs_section (p
->sec
)
3061 && bfd_is_abs_section (p
->sec
->output_section
))
3063 /* Input section has been discarded, either because
3064 it is a copy of a linkonce section or due to
3065 linker script /DISCARD/, so we'll be discarding
3068 else if (htab
->vxworks_p
3069 && strcmp (p
->sec
->output_section
->name
,
3072 /* Relocations in vxworks .tls_vars sections are
3073 handled specially by the loader. */
3075 else if (p
->count
!= 0)
3077 srel
= elf_section_data (p
->sec
)->sreloc
;
3078 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3079 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3081 info
->flags
|= DF_TEXTREL
;
3082 info
->callbacks
->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
3083 p
->sec
->owner
, p
->sec
);
3086 /* If we need relocations, we do not need fixups. */
3087 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
3088 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3093 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3094 locsymcount
= symtab_hdr
->sh_info
;
3095 s
= htab
->root
.sgot
;
3096 srel
= htab
->root
.srelgot
;
3098 local_got
= elf_local_got_refcounts (ibfd
);
3101 end_local_got
= local_got
+ locsymcount
;
3102 local_got_type
= sh_elf_local_got_type (ibfd
);
3103 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3104 for (; local_got
< end_local_got
; ++local_got
)
3108 *local_got
= s
->size
;
3110 if (*local_got_type
== GOT_TLS_GD
)
3112 if (bfd_link_pic (info
))
3113 srel
->size
+= sizeof (Elf32_External_Rela
);
3115 htab
->srofixup
->size
+= 4;
3117 if (*local_got_type
== GOT_FUNCDESC
)
3119 if (local_funcdesc
== NULL
)
3123 size
= locsymcount
* sizeof (union gotref
);
3124 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3126 if (local_funcdesc
== NULL
)
3128 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3129 local_funcdesc
+= (local_got
3130 - elf_local_got_refcounts (ibfd
));
3132 local_funcdesc
->refcount
++;
3137 *local_got
= (bfd_vma
) -1;
3142 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3145 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3147 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3149 if (local_funcdesc
->refcount
> 0)
3151 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3152 htab
->sfuncdesc
->size
+= 8;
3153 if (!bfd_link_pic (info
))
3154 htab
->srofixup
->size
+= 8;
3156 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3159 local_funcdesc
->offset
= MINUS_ONE
;
3165 if (htab
->tls_ldm_got
.refcount
> 0)
3167 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3169 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
3170 htab
->root
.sgot
->size
+= 8;
3171 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
3174 htab
->tls_ldm_got
.offset
= -1;
3176 /* Only the reserved entries should be present. For FDPIC, they go at
3177 the end of .got.plt. */
3180 BFD_ASSERT (htab
->root
.sgotplt
&& htab
->root
.sgotplt
->size
== 12);
3181 htab
->root
.sgotplt
->size
= 0;
3184 /* Allocate global sym .plt and .got entries, and space for global
3185 sym dynamic relocs. */
3186 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3188 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3189 end of the FDPIC .got.plt. */
3192 htab
->root
.hgot
->root
.u
.def
.value
= htab
->root
.sgotplt
->size
;
3193 htab
->root
.sgotplt
->size
+= 12;
3196 /* At the very end of the .rofixup section is a pointer to the GOT. */
3197 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3198 htab
->srofixup
->size
+= 4;
3200 /* We now have determined the sizes of the various dynamic sections.
3201 Allocate memory for them. */
3203 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3205 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3208 if (s
== htab
->root
.splt
3209 || s
== htab
->root
.sgot
3210 || s
== htab
->root
.sgotplt
3211 || s
== htab
->sfuncdesc
3212 || s
== htab
->srofixup
3213 || s
== htab
->sdynbss
)
3215 /* Strip this section if we don't need it; see the
3218 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
3220 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
&& s
!= htab
->srelplt2
)
3223 /* We use the reloc_count field as a counter if we need
3224 to copy relocs into the output file. */
3229 /* It's not one of our sections, so don't allocate space. */
3235 /* If we don't need this section, strip it from the
3236 output file. This is mostly to handle .rela.bss and
3237 .rela.plt. We must create both sections in
3238 create_dynamic_sections, because they must be created
3239 before the linker maps input sections to output
3240 sections. The linker does that before
3241 adjust_dynamic_symbol is called, and it is that
3242 function which decides whether anything needs to go
3243 into these sections. */
3245 s
->flags
|= SEC_EXCLUDE
;
3249 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3252 /* Allocate memory for the section contents. We use bfd_zalloc
3253 here in case unused entries are not reclaimed before the
3254 section's contents are written out. This should not happen,
3255 but this way if it does, we get a R_SH_NONE reloc instead
3257 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3258 if (s
->contents
== NULL
)
3262 if (htab
->root
.dynamic_sections_created
)
3264 /* Add some entries to the .dynamic section. We fill in the
3265 values later, in sh_elf_finish_dynamic_sections, but we
3266 must add the entries now so that we get the correct size for
3267 the .dynamic section. The DT_DEBUG entry is filled in by the
3268 dynamic linker and used by the debugger. */
3269 #define add_dynamic_entry(TAG, VAL) \
3270 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3272 if (bfd_link_executable (info
))
3274 if (! add_dynamic_entry (DT_DEBUG
, 0))
3278 if (htab
->root
.splt
->size
!= 0)
3280 if (! add_dynamic_entry (DT_PLTGOT
, 0)
3281 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
3282 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3283 || ! add_dynamic_entry (DT_JMPREL
, 0))
3286 else if ((elf_elfheader (output_bfd
)->e_flags
& EF_SH_FDPIC
))
3288 if (! add_dynamic_entry (DT_PLTGOT
, 0))
3294 if (! add_dynamic_entry (DT_RELA
, 0)
3295 || ! add_dynamic_entry (DT_RELASZ
, 0)
3296 || ! add_dynamic_entry (DT_RELAENT
,
3297 sizeof (Elf32_External_Rela
)))
3300 /* If any dynamic relocs apply to a read-only section,
3301 then we need a DT_TEXTREL entry. */
3302 if ((info
->flags
& DF_TEXTREL
) == 0)
3303 elf_link_hash_traverse (&htab
->root
, maybe_set_textrel
, info
);
3305 if ((info
->flags
& DF_TEXTREL
) != 0)
3307 if (! add_dynamic_entry (DT_TEXTREL
, 0))
3312 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3315 #undef add_dynamic_entry
3320 /* Add a dynamic relocation to the SRELOC section. */
3322 inline static bfd_vma
3323 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3324 int reloc_type
, long dynindx
, bfd_vma addend
)
3326 Elf_Internal_Rela outrel
;
3327 bfd_vma reloc_offset
;
3329 outrel
.r_offset
= offset
;
3330 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3331 outrel
.r_addend
= addend
;
3333 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3334 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3335 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3336 sreloc
->contents
+ reloc_offset
);
3337 sreloc
->reloc_count
++;
3339 return reloc_offset
;
3342 /* Add an FDPIC read-only fixup. */
3345 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3347 bfd_vma fixup_offset
;
3349 fixup_offset
= srofixup
->reloc_count
++ * 4;
3350 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3351 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3354 /* Return the offset of the generated .got section from the
3355 _GLOBAL_OFFSET_TABLE_ symbol. */
3357 static bfd_signed_vma
3358 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3360 return (htab
->root
.sgot
->output_offset
- htab
->root
.sgotplt
->output_offset
3361 - htab
->root
.hgot
->root
.u
.def
.value
);
3364 /* Find the segment number in which OSEC, and output section, is
3368 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3370 Elf_Internal_Phdr
*p
= NULL
;
3372 if (output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
3373 /* PR ld/17110: Do not look for output segments in an input bfd. */
3374 && output_bfd
->direction
!= read_direction
)
3375 p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
3377 /* FIXME: Nothing ever says what this index is relative to. The kernel
3378 supplies data in terms of the number of load segments but this is
3379 a phdr index and the first phdr may not be a load segment. */
3380 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3384 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3386 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3388 return (seg
!= (unsigned) -1
3389 && ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
));
3392 /* Generate the initial contents of a local function descriptor, along
3393 with any relocations or fixups required. */
3395 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3396 struct bfd_link_info
*info
,
3397 struct elf_link_hash_entry
*h
,
3402 struct elf_sh_link_hash_table
*htab
;
3406 htab
= sh_elf_hash_table (info
);
3408 /* FIXME: The ABI says that the offset to the function goes in the
3409 descriptor, along with the segment index. We're RELA, so it could
3410 go in the reloc instead... */
3412 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3414 section
= h
->root
.u
.def
.section
;
3415 value
= h
->root
.u
.def
.value
;
3418 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3420 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3421 addr
= value
+ section
->output_offset
;
3422 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3426 BFD_ASSERT (h
->dynindx
!= -1);
3427 dynindx
= h
->dynindx
;
3431 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
3433 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3435 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3437 + htab
->sfuncdesc
->output_section
->vma
3438 + htab
->sfuncdesc
->output_offset
);
3439 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3441 + htab
->sfuncdesc
->output_section
->vma
3442 + htab
->sfuncdesc
->output_offset
);
3445 /* There are no dynamic relocations so fill in the final
3446 address and gp value (barring fixups). */
3447 addr
+= section
->output_section
->vma
;
3448 seg
= htab
->root
.hgot
->root
.u
.def
.value
3449 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3450 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3453 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3455 + htab
->sfuncdesc
->output_section
->vma
3456 + htab
->sfuncdesc
->output_offset
,
3457 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3459 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3460 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3465 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3466 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3469 static bfd_reloc_status_type
3470 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3471 bfd
*input_bfd
, asection
*input_section
,
3472 bfd_byte
*contents
, bfd_vma offset
)
3474 unsigned long cur_val
;
3476 bfd_reloc_status_type r
;
3478 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3479 return bfd_reloc_outofrange
;
3481 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3482 bfd_arch_bits_per_address (input_bfd
), relocation
);
3483 if (r
!= bfd_reloc_ok
)
3486 addr
= contents
+ offset
;
3487 cur_val
= bfd_get_16 (output_bfd
, addr
);
3488 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3489 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3491 return bfd_reloc_ok
;
3494 /* Relocate an SH ELF section. */
3497 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3498 bfd
*input_bfd
, asection
*input_section
,
3499 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3500 Elf_Internal_Sym
*local_syms
,
3501 asection
**local_sections
)
3503 struct elf_sh_link_hash_table
*htab
;
3504 Elf_Internal_Shdr
*symtab_hdr
;
3505 struct elf_link_hash_entry
**sym_hashes
;
3506 Elf_Internal_Rela
*rel
, *relend
;
3507 bfd_vma
*local_got_offsets
;
3508 asection
*sgot
= NULL
;
3509 asection
*sgotplt
= NULL
;
3510 asection
*splt
= NULL
;
3511 asection
*sreloc
= NULL
;
3512 asection
*srelgot
= NULL
;
3513 bfd_boolean is_vxworks_tls
;
3514 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3515 bfd_boolean fdpic_p
= FALSE
;
3517 if (!is_sh_elf (input_bfd
))
3519 bfd_set_error (bfd_error_wrong_format
);
3523 htab
= sh_elf_hash_table (info
);
3526 sgot
= htab
->root
.sgot
;
3527 sgotplt
= htab
->root
.sgotplt
;
3528 srelgot
= htab
->root
.srelgot
;
3529 splt
= htab
->root
.splt
;
3530 fdpic_p
= htab
->fdpic_p
;
3532 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3533 sym_hashes
= elf_sym_hashes (input_bfd
);
3534 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3536 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3537 input_section
->output_section
);
3538 if (fdpic_p
&& sgot
)
3539 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3540 sgot
->output_section
);
3543 if (fdpic_p
&& splt
)
3544 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3545 splt
->output_section
);
3549 /* We have to handle relocations in vxworks .tls_vars sections
3550 specially, because the dynamic loader is 'weird'. */
3551 is_vxworks_tls
= (htab
&& htab
->vxworks_p
&& bfd_link_pic (info
)
3552 && !strcmp (input_section
->output_section
->name
,
3556 relend
= relocs
+ input_section
->reloc_count
;
3557 for (; rel
< relend
; rel
++)
3560 reloc_howto_type
*howto
;
3561 unsigned long r_symndx
;
3562 Elf_Internal_Sym
*sym
;
3564 struct elf_link_hash_entry
*h
;
3566 bfd_vma addend
= (bfd_vma
) 0;
3567 bfd_reloc_status_type r
;
3568 int seen_stt_datalabel
= 0;
3570 enum got_type got_type
;
3571 const char *symname
= NULL
;
3572 bfd_boolean resolved_to_zero
;
3574 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3576 r_type
= ELF32_R_TYPE (rel
->r_info
);
3578 /* Many of the relocs are only used for relaxing, and are
3579 handled entirely by the relaxation code. */
3580 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3581 && r_type
<= (int) R_SH_LABEL
)
3583 if (r_type
== (int) R_SH_NONE
)
3587 || r_type
>= R_SH_max
3588 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3589 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3590 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3591 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
3592 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3593 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3594 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3595 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3596 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3597 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3598 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
3599 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
3601 bfd_set_error (bfd_error_bad_value
);
3605 howto
= get_howto_table (output_bfd
) + r_type
;
3607 /* For relocs that aren't partial_inplace, we get the addend from
3609 if (! howto
->partial_inplace
)
3610 addend
= rel
->r_addend
;
3612 resolved_to_zero
= FALSE
;
3616 check_segment
[0] = -1;
3617 check_segment
[1] = -1;
3618 if (r_symndx
< symtab_hdr
->sh_info
)
3620 sym
= local_syms
+ r_symndx
;
3621 sec
= local_sections
[r_symndx
];
3623 symname
= bfd_elf_string_from_elf_section
3624 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
3625 if (symname
== NULL
|| *symname
== '\0')
3626 symname
= bfd_section_name (sec
);
3628 relocation
= (sec
->output_section
->vma
3629 + sec
->output_offset
3631 /* A local symbol never has STO_SH5_ISA32, so we don't need
3632 datalabel processing here. Make sure this does not change
3634 if ((sym
->st_other
& STO_SH5_ISA32
) != 0)
3635 (*info
->callbacks
->reloc_dangerous
)
3637 _("unexpected STO_SH5_ISA32 on local symbol is not handled"),
3638 input_bfd
, input_section
, rel
->r_offset
);
3640 if (sec
!= NULL
&& discarded_section (sec
))
3641 /* Handled below. */
3643 else if (bfd_link_relocatable (info
))
3645 /* This is a relocatable link. We don't have to change
3646 anything, unless the reloc is against a section symbol,
3647 in which case we have to adjust according to where the
3648 section symbol winds up in the output section. */
3649 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3651 if (! howto
->partial_inplace
)
3653 /* For relocations with the addend in the
3654 relocation, we need just to update the addend.
3655 All real relocs are of type partial_inplace; this
3656 code is mostly for completeness. */
3657 rel
->r_addend
+= sec
->output_offset
;
3662 /* Relocs of type partial_inplace need to pick up the
3663 contents in the contents and add the offset resulting
3664 from the changed location of the section symbol.
3665 Using _bfd_final_link_relocate (e.g. goto
3666 final_link_relocate) here would be wrong, because
3667 relocations marked pc_relative would get the current
3668 location subtracted, and we must only do that at the
3670 r
= _bfd_relocate_contents (howto
, input_bfd
,
3673 contents
+ rel
->r_offset
);
3674 goto relocation_done
;
3679 else if (! howto
->partial_inplace
)
3681 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3682 addend
= rel
->r_addend
;
3684 else if ((sec
->flags
& SEC_MERGE
)
3685 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3689 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
3692 /* xgettext:c-format */
3693 (_("%pB(%pA+%#" PRIx64
"): "
3694 "%s relocation against SEC_MERGE section"),
3695 input_bfd
, input_section
,
3696 (uint64_t) rel
->r_offset
, howto
->name
);
3700 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3703 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
3705 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3706 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
3712 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
3715 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3716 symname
= h
->root
.root
.string
;
3717 while (h
->root
.type
== bfd_link_hash_indirect
3718 || h
->root
.type
== bfd_link_hash_warning
)
3719 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3720 if (h
->root
.type
== bfd_link_hash_defined
3721 || h
->root
.type
== bfd_link_hash_defweak
)
3725 dyn
= htab
? htab
->root
.dynamic_sections_created
: FALSE
;
3726 sec
= h
->root
.u
.def
.section
;
3727 /* In these cases, we don't need the relocation value.
3728 We check specially because in some obscure cases
3729 sec->output_section will be NULL. */
3730 if (r_type
== R_SH_GOTPC
3731 || r_type
== R_SH_GOTPC_LOW16
3732 || r_type
== R_SH_GOTPC_MEDLOW16
3733 || r_type
== R_SH_GOTPC_MEDHI16
3734 || r_type
== R_SH_GOTPC_HI16
3735 || ((r_type
== R_SH_PLT32
3736 || r_type
== R_SH_PLT_LOW16
3737 || r_type
== R_SH_PLT_MEDLOW16
3738 || r_type
== R_SH_PLT_MEDHI16
3739 || r_type
== R_SH_PLT_HI16
)
3740 && h
->plt
.offset
!= (bfd_vma
) -1)
3741 || ((r_type
== R_SH_GOT32
3742 || r_type
== R_SH_GOT20
3743 || r_type
== R_SH_GOTFUNCDESC
3744 || r_type
== R_SH_GOTFUNCDESC20
3745 || r_type
== R_SH_GOTOFFFUNCDESC
3746 || r_type
== R_SH_GOTOFFFUNCDESC20
3747 || r_type
== R_SH_FUNCDESC
3748 || r_type
== R_SH_GOT_LOW16
3749 || r_type
== R_SH_GOT_MEDLOW16
3750 || r_type
== R_SH_GOT_MEDHI16
3751 || r_type
== R_SH_GOT_HI16
)
3752 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3753 bfd_link_pic (info
),
3755 && (! bfd_link_pic (info
)
3756 || (! info
->symbolic
&& h
->dynindx
!= -1)
3757 || !h
->def_regular
))
3758 /* The cases above are those in which relocation is
3759 overwritten in the switch block below. The cases
3760 below are those in which we must defer relocation
3761 to run-time, because we can't resolve absolute
3762 addresses when creating a shared library. */
3763 || (bfd_link_pic (info
)
3764 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3766 && ((r_type
== R_SH_DIR32
3767 && !h
->forced_local
)
3768 || (r_type
== R_SH_REL32
3769 && !SYMBOL_CALLS_LOCAL (info
, h
)))
3770 && ((input_section
->flags
& SEC_ALLOC
) != 0
3771 /* DWARF will emit R_SH_DIR32 relocations in its
3772 sections against symbols defined externally
3773 in shared libraries. We can't do anything
3775 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
3776 && h
->def_dynamic
)))
3777 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3778 sections because such sections are not SEC_ALLOC and
3779 thus ld.so will not process them. */
3780 || (sec
->output_section
== NULL
3781 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
3783 || (sec
->output_section
== NULL
3784 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
3785 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
3787 else if (sec
->output_section
!= NULL
)
3788 relocation
= ((h
->root
.u
.def
.value
3789 + sec
->output_section
->vma
3790 + sec
->output_offset
)
3791 /* A STO_SH5_ISA32 causes a "bitor 1" to the
3792 symbol value, unless we've seen
3793 STT_DATALABEL on the way to it. */
3794 | ((h
->other
& STO_SH5_ISA32
) != 0
3795 && ! seen_stt_datalabel
));
3796 else if (!bfd_link_relocatable (info
)
3797 && (_bfd_elf_section_offset (output_bfd
, info
,
3803 /* xgettext:c-format */
3804 (_("%pB(%pA+%#" PRIx64
"): "
3805 "unresolvable %s relocation against symbol `%s'"),
3808 (uint64_t) rel
->r_offset
,
3810 h
->root
.root
.string
);
3814 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3815 resolved_to_zero
= UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
);
3816 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3817 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3819 else if (!bfd_link_relocatable (info
))
3820 (*info
->callbacks
->undefined_symbol
)
3821 (info
, h
->root
.root
.string
, input_bfd
,
3822 input_section
, rel
->r_offset
,
3823 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
3824 || ELF_ST_VISIBILITY (h
->other
)));
3827 if (sec
!= NULL
&& discarded_section (sec
))
3828 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3829 rel
, 1, relend
, howto
, 0, contents
);
3831 if (bfd_link_relocatable (info
))
3834 /* Check for inter-segment relocations in FDPIC files. Most
3835 relocations connect the relocation site to the location of
3836 the target symbol, but there are some exceptions below. */
3837 check_segment
[0] = isec_segment
;
3839 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
3840 sec
->output_section
);
3842 check_segment
[1] = -1;
3844 switch ((int) r_type
)
3846 final_link_relocate
:
3847 /* COFF relocs don't use the addend. The addend is used for
3848 R_SH_DIR32 to be compatible with other compilers. */
3849 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3850 contents
, rel
->r_offset
,
3851 relocation
, addend
);
3855 goto final_link_relocate
;
3860 /* If the reloc is against the start of this section, then
3861 the assembler has already taken care of it and the reloc
3862 is here only to assist in relaxing. If the reloc is not
3863 against the start of this section, then it's against an
3864 external symbol and we must deal with it ourselves. */
3865 if (input_section
->output_section
->vma
+ input_section
->output_offset
3868 int disp
= (relocation
3869 - input_section
->output_section
->vma
3870 - input_section
->output_offset
3876 case R_SH_DIR8WPZ
: mask
= 1; break;
3877 case R_SH_DIR8WPL
: mask
= 3; break;
3878 default: mask
= 0; break;
3883 /* xgettext:c-format */
3884 (_("%pB: %#" PRIx64
": fatal: "
3885 "unaligned branch target for relax-support relocation"),
3886 input_section
->owner
,
3887 (uint64_t) rel
->r_offset
);
3888 bfd_set_error (bfd_error_bad_value
);
3892 goto final_link_relocate
;
3898 bfd_set_error (bfd_error_bad_value
);
3906 goto final_link_relocate
;
3913 /* xgettext:c-format */
3914 (_("%pB: %#" PRIx64
": fatal: "
3915 "unaligned %s relocation %#" PRIx64
),
3916 input_section
->owner
, (uint64_t) rel
->r_offset
,
3917 howto
->name
, (uint64_t) relocation
);
3918 bfd_set_error (bfd_error_bad_value
);
3921 goto final_link_relocate
;
3929 /* xgettext:c-format */
3930 (_("%pB: %#" PRIx64
": fatal: "
3931 "unaligned %s relocation %#" PRIx64
""),
3932 input_section
->owner
,
3933 (uint64_t) rel
->r_offset
, howto
->name
,
3934 (uint64_t) relocation
);
3935 bfd_set_error (bfd_error_bad_value
);
3938 goto final_link_relocate
;
3941 if ((signed int)relocation
< -32
3942 || (signed int)relocation
> 32)
3945 /* xgettext:c-format */
3946 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHA relocation %" PRId64
3947 " not in range -32..32"),
3948 input_section
->owner
,
3949 (uint64_t) rel
->r_offset
,
3950 (int64_t) relocation
);
3951 bfd_set_error (bfd_error_bad_value
);
3954 goto final_link_relocate
;
3957 if ((signed int)relocation
< -16
3958 || (signed int)relocation
> 16)
3961 /* xgettext:c-format */
3962 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHL relocation %" PRId64
3963 " not in range -32..32"),
3964 input_section
->owner
,
3965 (uint64_t) rel
->r_offset
,
3966 (int64_t) relocation
);
3967 bfd_set_error (bfd_error_bad_value
);
3970 goto final_link_relocate
;
3974 if (bfd_link_pic (info
)
3976 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3977 && !resolved_to_zero
)
3978 || h
->root
.type
!= bfd_link_hash_undefweak
)
3979 && r_symndx
!= STN_UNDEF
3980 && (input_section
->flags
& SEC_ALLOC
) != 0
3982 && (r_type
== R_SH_DIR32
3983 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3985 Elf_Internal_Rela outrel
;
3987 bfd_boolean skip
, relocate
;
3989 /* When generating a shared object, these relocations
3990 are copied into the output file to be resolved at run
3995 sreloc
= _bfd_elf_get_dynamic_reloc_section
3996 (input_bfd
, input_section
, /*rela?*/ TRUE
);
4005 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4007 if (outrel
.r_offset
== (bfd_vma
) -1)
4009 else if (outrel
.r_offset
== (bfd_vma
) -2)
4010 skip
= TRUE
, relocate
= TRUE
;
4011 outrel
.r_offset
+= (input_section
->output_section
->vma
4012 + input_section
->output_offset
);
4015 memset (&outrel
, 0, sizeof outrel
);
4016 else if (r_type
== R_SH_REL32
)
4018 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
4019 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
4021 = (howto
->partial_inplace
4022 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4027 || ((info
->symbolic
|| h
->dynindx
== -1)
4028 && h
->def_regular
)))
4032 BFD_ASSERT (sec
!= NULL
);
4033 BFD_ASSERT (sec
->output_section
!= NULL
);
4034 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
4035 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4036 outrel
.r_addend
= relocation
;
4038 += (howto
->partial_inplace
4039 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4041 outrel
.r_addend
-= sec
->output_section
->vma
;
4045 /* h->dynindx may be -1 if this symbol was marked to
4048 || ((info
->symbolic
|| h
->dynindx
== -1)
4051 relocate
= howto
->partial_inplace
;
4052 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4056 BFD_ASSERT (h
->dynindx
!= -1);
4057 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
4059 outrel
.r_addend
= relocation
;
4061 += (howto
->partial_inplace
4062 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
4066 loc
= sreloc
->contents
;
4067 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4068 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4070 check_segment
[0] = check_segment
[1] = -1;
4072 /* If this reloc is against an external symbol, we do
4073 not want to fiddle with the addend. Otherwise, we
4074 need to include the symbol value so that it becomes
4075 an addend for the dynamic reloc. */
4079 else if (fdpic_p
&& !bfd_link_pic (info
)
4080 && r_type
== R_SH_DIR32
4081 && (input_section
->flags
& SEC_ALLOC
) != 0)
4087 if (sh_elf_osec_readonly_p (output_bfd
,
4088 input_section
->output_section
))
4091 /* xgettext:c-format */
4092 (_("%pB(%pA+%#" PRIx64
"): "
4093 "cannot emit fixup to `%s' in read-only section"),
4096 (uint64_t) rel
->r_offset
,
4101 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4102 input_section
, rel
->r_offset
);
4103 if (offset
!= (bfd_vma
)-1)
4104 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4105 input_section
->output_section
->vma
4106 + input_section
->output_offset
4109 check_segment
[0] = check_segment
[1] = -1;
4111 /* We don't want warnings for non-NULL tests on undefined weak
4113 else if (r_type
== R_SH_REL32
4115 && h
->root
.type
== bfd_link_hash_undefweak
)
4116 check_segment
[0] = check_segment
[1] = -1;
4117 goto final_link_relocate
;
4120 /* Relocation is to the entry for this symbol in the
4121 procedure linkage table. */
4125 || ! bfd_link_pic (info
)
4128 || h
->plt
.offset
== (bfd_vma
) -1
4129 || h
->got
.offset
!= (bfd_vma
) -1)
4132 /* Relocation is to the entry for this symbol in the global
4133 offset table extension for the procedure linkage table. */
4136 BFD_ASSERT (sgotplt
!= NULL
);
4137 relocation
= (sgotplt
->output_offset
4138 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4142 relocation
-= GOT_BIAS
;
4145 goto final_link_relocate
;
4150 /* Relocation is to the entry for this symbol in the global
4154 BFD_ASSERT (sgot
!= NULL
);
4155 check_segment
[0] = check_segment
[1] = -1;
4161 off
= h
->got
.offset
;
4162 BFD_ASSERT (off
!= (bfd_vma
) -1);
4164 dyn
= htab
->root
.dynamic_sections_created
;
4165 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4166 bfd_link_pic (info
),
4168 || (bfd_link_pic (info
)
4169 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4170 || ((ELF_ST_VISIBILITY (h
->other
)
4171 || resolved_to_zero
)
4172 && h
->root
.type
== bfd_link_hash_undefweak
))
4174 /* This is actually a static link, or it is a
4175 -Bsymbolic link and the symbol is defined
4176 locally, or the symbol was forced to be local
4177 because of a version file. We must initialize
4178 this entry in the global offset table. Since the
4179 offset must always be a multiple of 4, we use the
4180 least significant bit to record whether we have
4181 initialized it already.
4183 When doing a dynamic link, we create a .rela.got
4184 relocation entry to initialize the value. This
4185 is done in the finish_dynamic_symbol routine. */
4190 bfd_put_32 (output_bfd
, relocation
,
4191 sgot
->contents
+ off
);
4194 /* If we initialize the GOT entry here with a valid
4195 symbol address, also add a fixup. */
4196 if (fdpic_p
&& !bfd_link_pic (info
)
4197 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4198 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4199 || h
->root
.type
!= bfd_link_hash_undefweak
))
4200 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4201 sgot
->output_section
->vma
4202 + sgot
->output_offset
4207 relocation
= sh_elf_got_offset (htab
) + off
;
4211 BFD_ASSERT (local_got_offsets
!= NULL
4212 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4214 off
= local_got_offsets
[r_symndx
];
4216 /* The offset must always be a multiple of 4. We use
4217 the least significant bit to record whether we have
4218 already generated the necessary reloc. */
4223 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4225 if (bfd_link_pic (info
))
4227 Elf_Internal_Rela outrel
;
4230 outrel
.r_offset
= (sgot
->output_section
->vma
4231 + sgot
->output_offset
4236 = elf_section_data (sec
->output_section
)->dynindx
;
4237 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4238 outrel
.r_addend
= relocation
;
4239 outrel
.r_addend
-= sec
->output_section
->vma
;
4243 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4244 outrel
.r_addend
= relocation
;
4246 loc
= srelgot
->contents
;
4247 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4248 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4251 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4253 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4254 sgot
->output_section
->vma
4255 + sgot
->output_offset
4258 local_got_offsets
[r_symndx
] |= 1;
4261 relocation
= sh_elf_got_offset (htab
) + off
;
4265 relocation
-= GOT_BIAS
;
4268 if (r_type
== R_SH_GOT20
)
4270 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4271 input_bfd
, input_section
, contents
,
4276 goto final_link_relocate
;
4280 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4281 we place at the start of the .got.plt section. This is the same
4282 as the start of the output .got section, unless there are function
4283 descriptors in front of it. */
4285 BFD_ASSERT (sgotplt
!= NULL
);
4286 check_segment
[0] = got_segment
;
4287 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4288 + htab
->root
.hgot
->root
.u
.def
.value
;
4291 relocation
-= GOT_BIAS
;
4294 addend
= rel
->r_addend
;
4296 if (r_type
== R_SH_GOTOFF20
)
4298 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4299 input_bfd
, input_section
, contents
,
4304 goto final_link_relocate
;
4307 /* Use global offset table as symbol value. */
4309 BFD_ASSERT (sgotplt
!= NULL
);
4310 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4313 relocation
+= GOT_BIAS
;
4316 addend
= rel
->r_addend
;
4318 goto final_link_relocate
;
4321 /* Relocation is to the entry for this symbol in the
4322 procedure linkage table. */
4324 /* Resolve a PLT reloc against a local symbol directly,
4325 without using the procedure linkage table. */
4327 goto final_link_relocate
;
4329 /* We don't want to warn on calls to undefined weak symbols,
4330 as calls to them must be protected by non-NULL tests
4331 anyway, and unprotected calls would invoke undefined
4333 if (h
->root
.type
== bfd_link_hash_undefweak
)
4334 check_segment
[0] = check_segment
[1] = -1;
4336 if (h
->forced_local
)
4337 goto final_link_relocate
;
4339 if (h
->plt
.offset
== (bfd_vma
) -1)
4341 /* We didn't make a PLT entry for this symbol. This
4342 happens when statically linking PIC code, or when
4343 using -Bsymbolic. */
4344 goto final_link_relocate
;
4347 BFD_ASSERT (splt
!= NULL
);
4348 check_segment
[1] = plt_segment
;
4349 relocation
= (splt
->output_section
->vma
4350 + splt
->output_offset
4353 addend
= rel
->r_addend
;
4355 goto final_link_relocate
;
4357 /* Relocation is to the canonical function descriptor for this
4358 symbol, possibly via the GOT. Initialize the GOT
4359 entry and function descriptor if necessary. */
4360 case R_SH_GOTFUNCDESC
:
4361 case R_SH_GOTFUNCDESC20
:
4365 asection
*reloc_section
;
4366 bfd_vma reloc_offset
;
4367 int reloc_type
= R_SH_FUNCDESC
;
4371 check_segment
[0] = check_segment
[1] = -1;
4373 /* FIXME: See what FRV does for global symbols in the
4374 executable, with --export-dynamic. Do they need ld.so
4375 to allocate official descriptors? See what this code
4381 if (r_type
== R_SH_FUNCDESC
)
4383 reloc_section
= input_section
;
4384 reloc_offset
= rel
->r_offset
;
4388 reloc_section
= sgot
;
4391 reloc_offset
= h
->got
.offset
;
4394 BFD_ASSERT (local_got_offsets
!= NULL
);
4395 reloc_offset
= local_got_offsets
[r_symndx
];
4397 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4399 if (reloc_offset
& 1)
4402 goto funcdesc_done_got
;
4406 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4407 && (SYMBOL_CALLS_LOCAL (info
, h
)
4408 || !htab
->root
.dynamic_sections_created
))
4409 /* Undefined weak symbol which will not be dynamically
4410 resolved later; leave it at zero. */
4411 goto funcdesc_leave_zero
;
4412 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4413 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4415 /* If the symbol needs a non-local function descriptor
4416 but binds locally (i.e., its visibility is
4417 protected), emit a dynamic relocation decayed to
4418 section+offset. This is an optimization; the dynamic
4419 linker would resolve our function descriptor request
4420 to our copy of the function anyway. */
4421 dynindx
= elf_section_data (h
->root
.u
.def
.section
4422 ->output_section
)->dynindx
;
4423 relocation
+= h
->root
.u
.def
.section
->output_offset
4424 + h
->root
.u
.def
.value
;
4426 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4428 /* If the symbol is dynamic and there will be dynamic
4429 symbol resolution because we are or are linked with a
4430 shared library, emit a FUNCDESC relocation such that
4431 the dynamic linker will allocate the function
4433 BFD_ASSERT (h
->dynindx
!= -1);
4434 dynindx
= h
->dynindx
;
4440 /* Otherwise, we know we have a private function
4441 descriptor, so reference it directly. */
4442 reloc_type
= R_SH_DIR32
;
4443 dynindx
= elf_section_data (htab
->sfuncdesc
4444 ->output_section
)->dynindx
;
4448 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4449 BFD_ASSERT (offset
!= MINUS_ONE
);
4450 if ((offset
& 1) == 0)
4452 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4455 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4460 union gotref
*local_funcdesc
;
4462 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4463 offset
= local_funcdesc
[r_symndx
].offset
;
4464 BFD_ASSERT (offset
!= MINUS_ONE
);
4465 if ((offset
& 1) == 0)
4467 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4471 local_funcdesc
[r_symndx
].offset
|= 1;
4475 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4478 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
4482 if (sh_elf_osec_readonly_p (output_bfd
,
4483 reloc_section
->output_section
))
4486 /* xgettext:c-format */
4487 (_("%pB(%pA+%#" PRIx64
"): "
4488 "cannot emit fixup to `%s' in read-only section"),
4491 (uint64_t) rel
->r_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_rofixup (output_bfd
, htab
->srofixup
,
4502 + reloc_section
->output_section
->vma
4503 + reloc_section
->output_offset
);
4505 else if ((reloc_section
->output_section
->flags
4506 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
4510 if (sh_elf_osec_readonly_p (output_bfd
,
4511 reloc_section
->output_section
))
4513 info
->callbacks
->warning
4515 _("cannot emit dynamic relocations in read-only section"),
4516 symname
, input_bfd
, reloc_section
, reloc_offset
);
4520 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4521 reloc_section
, reloc_offset
);
4523 if (offset
!= (bfd_vma
)-1)
4524 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
4526 + reloc_section
->output_section
->vma
4527 + reloc_section
->output_offset
,
4528 reloc_type
, dynindx
, relocation
);
4530 if (r_type
== R_SH_FUNCDESC
)
4538 goto funcdesc_leave_zero
;
4542 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
4543 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
4544 funcdesc_leave_zero
:
4545 if (r_type
!= R_SH_FUNCDESC
)
4547 bfd_put_32 (output_bfd
, relocation
,
4548 reloc_section
->contents
+ reloc_offset
);
4552 local_got_offsets
[r_symndx
] |= 1;
4556 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
4558 relocation
-= GOT_BIAS
;
4561 if (r_type
== R_SH_GOTFUNCDESC20
)
4563 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4564 input_bfd
, input_section
, contents
,
4569 goto final_link_relocate
;
4573 case R_SH_GOTOFFFUNCDESC
:
4574 case R_SH_GOTOFFFUNCDESC20
:
4575 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4576 executable and --export-dynamic. If such symbols get
4577 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4581 check_segment
[0] = check_segment
[1] = -1;
4583 addend
= rel
->r_addend
;
4585 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
4586 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
4589 /* xgettext:c-format */
4590 (_("%pB(%pA+%#" PRIx64
"): "
4591 "%s relocation against external symbol \"%s\""),
4592 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
4593 howto
->name
, h
->root
.root
.string
);
4600 /* Otherwise, we know we have a private function
4601 descriptor, so reference it directly. */
4604 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4605 BFD_ASSERT (offset
!= MINUS_ONE
);
4606 if ((offset
& 1) == 0)
4608 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4611 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4616 union gotref
*local_funcdesc
;
4618 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4619 offset
= local_funcdesc
[r_symndx
].offset
;
4620 BFD_ASSERT (offset
!= MINUS_ONE
);
4621 if ((offset
& 1) == 0)
4623 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4627 local_funcdesc
[r_symndx
].offset
|= 1;
4631 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4634 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
4635 + sgotplt
->output_offset
);
4637 relocation
-= GOT_BIAS
;
4640 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
4642 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4643 input_bfd
, input_section
, contents
,
4648 goto final_link_relocate
;
4650 case R_SH_LOOP_START
:
4652 static bfd_vma start
, end
;
4654 start
= (relocation
+ rel
->r_addend
4655 - (sec
->output_section
->vma
+ sec
->output_offset
));
4656 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4657 rel
->r_offset
, sec
, start
, end
);
4661 end
= (relocation
+ rel
->r_addend
4662 - (sec
->output_section
->vma
+ sec
->output_offset
));
4663 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4664 rel
->r_offset
, sec
, start
, end
);
4668 case R_SH_TLS_GD_32
:
4669 case R_SH_TLS_IE_32
:
4671 check_segment
[0] = check_segment
[1] = -1;
4672 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
4673 got_type
= GOT_UNKNOWN
;
4674 if (h
== NULL
&& local_got_offsets
)
4675 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
4678 got_type
= sh_elf_hash_entry (h
)->got_type
;
4679 if (! bfd_link_pic (info
)
4680 && (h
->dynindx
== -1
4682 r_type
= R_SH_TLS_LE_32
;
4685 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
4686 r_type
= R_SH_TLS_IE_32
;
4688 if (r_type
== R_SH_TLS_LE_32
)
4691 unsigned short insn
;
4693 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
4695 /* GD->LE transition:
4696 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4697 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4698 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4700 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4702 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
4704 offset
= rel
->r_offset
;
4708 /* xgettext:c-format */
4709 (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64
),
4710 input_bfd
, input_section
, (uint64_t) offset
);
4714 /* Size of GD instructions is 16 or 18. */
4716 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4717 if ((insn
& 0xff00) == 0xc700)
4719 BFD_ASSERT (offset
>= 2);
4721 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4724 if ((insn
& 0xff00) != 0xd400)
4726 /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */
4727 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd4?\?)"),
4728 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4730 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4732 if ((insn
& 0xff00) != 0xc700)
4734 /* xgettext:c-format */
4735 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xc7?\?)"),
4736 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4738 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4739 if ((insn
& 0xff00) != 0xd100)
4741 /* xgettext:c-format */
4742 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd1?\?)"),
4743 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4745 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4748 /* xgettext:c-format */
4749 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x310c)"),
4750 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4752 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4755 /* xgettext:c-format */
4756 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x410b)"),
4757 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4759 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4762 /* xgettext:c-format */
4763 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x34cc)"),
4764 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4766 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
4767 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
4768 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4769 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4770 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4776 /* IE->LE transition:
4793 offset
= rel
->r_offset
;
4797 /* xgettext:c-format */
4798 (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64
),
4799 input_bfd
, input_section
, (uint64_t) offset
);
4803 /* Size of IE instructions is 10 or 12. */
4805 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4806 if ((insn
& 0xf0ff) == 0x0012)
4808 BFD_ASSERT (offset
>= 2);
4810 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4813 if ((insn
& 0xff00) != 0xd000)
4815 /* xgettext:c-format */
4816 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
4817 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4819 target
= insn
& 0x00ff;
4821 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4822 if ((insn
& 0xf0ff) != 0x0012)
4824 /* xgettext:c-format */
4825 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?12: stc)"),
4826 input_bfd
, input_section
, (uint64_t) (offset
+ 2), (int) insn
);
4828 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4829 if ((insn
& 0xf0ff) != 0x00ce)
4831 /* xgettext:c-format */
4832 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
4833 input_bfd
, input_section
, (uint64_t) (offset
+ 4), (int) insn
);
4835 insn
= 0xd000 | (insn
& 0x0f00) | target
;
4836 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
4837 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4840 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4841 contents
+ rel
->r_offset
);
4845 if (sgot
== NULL
|| sgotplt
== NULL
)
4849 off
= h
->got
.offset
;
4852 if (local_got_offsets
== NULL
)
4855 off
= local_got_offsets
[r_symndx
];
4858 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
4859 if (r_type
== R_SH_TLS_IE_32
4860 && ! htab
->root
.dynamic_sections_created
)
4863 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4864 sgot
->contents
+ off
);
4865 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4866 contents
+ rel
->r_offset
);
4874 Elf_Internal_Rela outrel
;
4878 outrel
.r_offset
= (sgot
->output_section
->vma
4879 + sgot
->output_offset
+ off
);
4881 if (h
== NULL
|| h
->dynindx
== -1)
4886 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
4888 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
4889 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4891 outrel
.r_addend
= 0;
4892 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4893 loc
= srelgot
->contents
;
4894 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4895 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4897 if (r_type
== R_SH_TLS_GD_32
)
4901 bfd_put_32 (output_bfd
,
4902 relocation
- dtpoff_base (info
),
4903 sgot
->contents
+ off
+ 4);
4907 outrel
.r_info
= ELF32_R_INFO (indx
,
4909 outrel
.r_offset
+= 4;
4910 outrel
.r_addend
= 0;
4911 srelgot
->reloc_count
++;
4912 loc
+= sizeof (Elf32_External_Rela
);
4913 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4920 local_got_offsets
[r_symndx
] |= 1;
4923 if (off
>= (bfd_vma
) -2)
4926 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
4927 relocation
= sh_elf_got_offset (htab
) + off
;
4931 unsigned short insn
;
4933 /* GD->IE transition:
4934 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4935 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4936 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4938 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4939 nop; nop; bra 3f; nop; .align 2;
4940 1: .long x@TPOFF; 2:...; 3:. */
4942 offset
= rel
->r_offset
;
4946 /* xgettext:c-format */
4947 (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64
),
4948 input_bfd
, input_section
, (uint64_t) offset
);
4952 /* Size of GD instructions is 16 or 18. */
4954 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4955 if ((insn
& 0xff00) == 0xc700)
4957 BFD_ASSERT (offset
>= 2);
4959 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4962 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4964 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
4965 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
4967 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4968 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4969 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4970 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4971 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4972 BFD_ASSERT (insn
== 0x310c);
4973 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4974 BFD_ASSERT (insn
== 0x410b);
4975 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4976 BFD_ASSERT (insn
== 0x34cc);
4978 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
4979 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
4980 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
4981 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4982 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4984 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4985 contents
+ rel
->r_offset
);
4990 addend
= rel
->r_addend
;
4992 goto final_link_relocate
;
4994 case R_SH_TLS_LD_32
:
4996 check_segment
[0] = check_segment
[1] = -1;
4997 if (! bfd_link_pic (info
))
5000 unsigned short insn
;
5002 /* LD->LE transition:
5003 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5004 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5005 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5007 stc gbr,r0; nop; nop; nop;
5008 nop; nop; bra 3f; ...; 3:. */
5010 offset
= rel
->r_offset
;
5014 /* xgettext:c-format */
5015 (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64
),
5016 input_bfd
, input_section
, (uint64_t) offset
);
5020 /* Size of LD instructions is 16 or 18. */
5022 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5023 if ((insn
& 0xff00) == 0xc700)
5025 BFD_ASSERT (offset
>= 2);
5027 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
5030 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
5031 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
5032 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
5033 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
5034 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
5035 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
5036 BFD_ASSERT (insn
== 0x310c);
5037 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
5038 BFD_ASSERT (insn
== 0x410b);
5039 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
5040 BFD_ASSERT (insn
== 0x34cc);
5042 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
5043 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
5044 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
5045 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
5046 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
5047 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
5052 if (sgot
== NULL
|| sgotplt
== NULL
)
5055 off
= htab
->tls_ldm_got
.offset
;
5060 Elf_Internal_Rela outrel
;
5063 outrel
.r_offset
= (sgot
->output_section
->vma
5064 + sgot
->output_offset
+ off
);
5065 outrel
.r_addend
= 0;
5066 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
5067 loc
= srelgot
->contents
;
5068 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5069 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5070 htab
->tls_ldm_got
.offset
|= 1;
5073 relocation
= sh_elf_got_offset (htab
) + off
;
5074 addend
= rel
->r_addend
;
5076 goto final_link_relocate
;
5078 case R_SH_TLS_LDO_32
:
5079 check_segment
[0] = check_segment
[1] = -1;
5080 if (! bfd_link_pic (info
))
5081 relocation
= tpoff (info
, relocation
);
5083 relocation
-= dtpoff_base (info
);
5085 addend
= rel
->r_addend
;
5086 goto final_link_relocate
;
5088 case R_SH_TLS_LE_32
:
5091 Elf_Internal_Rela outrel
;
5094 check_segment
[0] = check_segment
[1] = -1;
5096 if (!bfd_link_dll (info
))
5098 relocation
= tpoff (info
, relocation
);
5099 addend
= rel
->r_addend
;
5100 goto final_link_relocate
;
5105 sreloc
= _bfd_elf_get_dynamic_reloc_section
5106 (input_bfd
, input_section
, /*rela?*/ TRUE
);
5111 if (h
== NULL
|| h
->dynindx
== -1)
5116 outrel
.r_offset
= (input_section
->output_section
->vma
5117 + input_section
->output_offset
5119 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
5121 outrel
.r_addend
= relocation
- dtpoff_base (info
);
5123 outrel
.r_addend
= 0;
5125 loc
= sreloc
->contents
;
5126 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5127 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5133 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5134 && check_segment
[0] != check_segment
[1])
5136 /* We don't want duplicate errors for undefined symbols. */
5137 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5139 if (bfd_link_pic (info
))
5141 info
->callbacks
->einfo
5142 /* xgettext:c-format */
5143 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5144 input_bfd
, input_section
, rel
->r_offset
, symname
);
5148 info
->callbacks
->einfo
5149 /* xgettext:c-format */
5150 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5151 input_bfd
, input_section
, rel
->r_offset
, symname
);
5154 elf_elfheader (output_bfd
)->e_flags
|= EF_SH_PIC
;
5157 if (r
!= bfd_reloc_ok
)
5162 case bfd_reloc_outofrange
:
5164 case bfd_reloc_overflow
:
5172 name
= (bfd_elf_string_from_elf_section
5173 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5177 name
= bfd_section_name (sec
);
5179 (*info
->callbacks
->reloc_overflow
)
5180 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5181 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5191 /* This is a version of bfd_generic_get_relocated_section_contents
5192 which uses sh_elf_relocate_section. */
5195 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5196 struct bfd_link_info
*link_info
,
5197 struct bfd_link_order
*link_order
,
5199 bfd_boolean relocatable
,
5202 Elf_Internal_Shdr
*symtab_hdr
;
5203 asection
*input_section
= link_order
->u
.indirect
.section
;
5204 bfd
*input_bfd
= input_section
->owner
;
5205 asection
**sections
= NULL
;
5206 Elf_Internal_Rela
*internal_relocs
= NULL
;
5207 Elf_Internal_Sym
*isymbuf
= NULL
;
5209 /* We only need to handle the case of relaxing, or of having a
5210 particular set of section contents, specially. */
5212 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5213 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5218 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5220 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5221 (size_t) input_section
->size
);
5223 if ((input_section
->flags
& SEC_RELOC
) != 0
5224 && input_section
->reloc_count
> 0)
5227 Elf_Internal_Sym
*isym
, *isymend
;
5230 internal_relocs
= (_bfd_elf_link_read_relocs
5231 (input_bfd
, input_section
, NULL
,
5232 (Elf_Internal_Rela
*) NULL
, FALSE
));
5233 if (internal_relocs
== NULL
)
5236 if (symtab_hdr
->sh_info
!= 0)
5238 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5239 if (isymbuf
== NULL
)
5240 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5241 symtab_hdr
->sh_info
, 0,
5243 if (isymbuf
== NULL
)
5247 amt
= symtab_hdr
->sh_info
;
5248 amt
*= sizeof (asection
*);
5249 sections
= (asection
**) bfd_malloc (amt
);
5250 if (sections
== NULL
&& amt
!= 0)
5253 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5254 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5258 if (isym
->st_shndx
== SHN_UNDEF
)
5259 isec
= bfd_und_section_ptr
;
5260 else if (isym
->st_shndx
== SHN_ABS
)
5261 isec
= bfd_abs_section_ptr
;
5262 else if (isym
->st_shndx
== SHN_COMMON
)
5263 isec
= bfd_com_section_ptr
;
5265 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5270 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5271 input_section
, data
, internal_relocs
,
5275 if (sections
!= NULL
)
5278 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5280 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5281 free (internal_relocs
);
5287 if (sections
!= NULL
)
5290 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5292 if (internal_relocs
!= NULL
5293 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
5294 free (internal_relocs
);
5298 /* Return the base VMA address which should be subtracted from real addresses
5299 when resolving @dtpoff relocation.
5300 This is PT_TLS segment p_vaddr. */
5303 dtpoff_base (struct bfd_link_info
*info
)
5305 /* If tls_sec is NULL, we should have signalled an error already. */
5306 if (elf_hash_table (info
)->tls_sec
== NULL
)
5308 return elf_hash_table (info
)->tls_sec
->vma
;
5311 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5314 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5316 /* If tls_sec is NULL, we should have signalled an error already. */
5317 if (elf_hash_table (info
)->tls_sec
== NULL
)
5319 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5320 structure which has 2 pointer fields. */
5321 return (address
- elf_hash_table (info
)->tls_sec
->vma
5322 + align_power ((bfd_vma
) 8,
5323 elf_hash_table (info
)->tls_sec
->alignment_power
));
5327 sh_elf_gc_mark_hook (asection
*sec
,
5328 struct bfd_link_info
*info
,
5329 Elf_Internal_Rela
*rel
,
5330 struct elf_link_hash_entry
*h
,
5331 Elf_Internal_Sym
*sym
)
5334 switch (ELF32_R_TYPE (rel
->r_info
))
5336 case R_SH_GNU_VTINHERIT
:
5337 case R_SH_GNU_VTENTRY
:
5341 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5344 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5347 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
5348 struct elf_link_hash_entry
*dir
,
5349 struct elf_link_hash_entry
*ind
)
5351 struct elf_sh_link_hash_entry
*edir
, *eind
;
5353 edir
= (struct elf_sh_link_hash_entry
*) dir
;
5354 eind
= (struct elf_sh_link_hash_entry
*) ind
;
5356 if (eind
->dyn_relocs
!= NULL
)
5358 if (edir
->dyn_relocs
!= NULL
)
5360 struct elf_dyn_relocs
**pp
;
5361 struct elf_dyn_relocs
*p
;
5363 /* Add reloc counts against the indirect sym to the direct sym
5364 list. Merge any entries against the same section. */
5365 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
5367 struct elf_dyn_relocs
*q
;
5369 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
5370 if (q
->sec
== p
->sec
)
5372 q
->pc_count
+= p
->pc_count
;
5373 q
->count
+= p
->count
;
5380 *pp
= edir
->dyn_relocs
;
5383 edir
->dyn_relocs
= eind
->dyn_relocs
;
5384 eind
->dyn_relocs
= NULL
;
5386 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
5387 eind
->gotplt_refcount
= 0;
5388 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
5389 eind
->funcdesc
.refcount
= 0;
5390 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
5391 eind
->abs_funcdesc_refcount
= 0;
5393 if (ind
->root
.type
== bfd_link_hash_indirect
5394 && dir
->got
.refcount
<= 0)
5396 edir
->got_type
= eind
->got_type
;
5397 eind
->got_type
= GOT_UNKNOWN
;
5400 if (ind
->root
.type
!= bfd_link_hash_indirect
5401 && dir
->dynamic_adjusted
)
5403 /* If called to transfer flags for a weakdef during processing
5404 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5405 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5406 if (dir
->versioned
!= versioned_hidden
)
5407 dir
->ref_dynamic
|= ind
->ref_dynamic
;
5408 dir
->ref_regular
|= ind
->ref_regular
;
5409 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
5410 dir
->needs_plt
|= ind
->needs_plt
;
5413 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
5417 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
5420 if (bfd_link_pic (info
))
5425 case R_SH_TLS_GD_32
:
5426 case R_SH_TLS_IE_32
:
5428 return R_SH_TLS_LE_32
;
5429 return R_SH_TLS_IE_32
;
5430 case R_SH_TLS_LD_32
:
5431 return R_SH_TLS_LE_32
;
5437 /* Look through the relocs for a section during the first phase.
5438 Since we don't do .gots or .plts, we just need to consider the
5439 virtual table relocs for gc. */
5442 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
5443 const Elf_Internal_Rela
*relocs
)
5445 Elf_Internal_Shdr
*symtab_hdr
;
5446 struct elf_link_hash_entry
**sym_hashes
;
5447 struct elf_sh_link_hash_table
*htab
;
5448 const Elf_Internal_Rela
*rel
;
5449 const Elf_Internal_Rela
*rel_end
;
5451 unsigned int r_type
;
5452 enum got_type got_type
, old_got_type
;
5456 if (bfd_link_relocatable (info
))
5459 /* Don't do anything special with non-loaded, non-alloced sections.
5460 In particular, any relocs in such sections should not affect GOT
5461 and PLT reference counting (ie. we don't allow them to create GOT
5462 or PLT entries), there's no possibility or desire to optimize TLS
5463 relocs, and there's not much point in propagating relocs to shared
5464 libs that the dynamic linker won't relocate. */
5465 if ((sec
->flags
& SEC_ALLOC
) == 0)
5468 BFD_ASSERT (is_sh_elf (abfd
));
5470 symtab_hdr
= &elf_symtab_hdr (abfd
);
5471 sym_hashes
= elf_sym_hashes (abfd
);
5473 htab
= sh_elf_hash_table (info
);
5477 rel_end
= relocs
+ sec
->reloc_count
;
5478 for (rel
= relocs
; rel
< rel_end
; rel
++)
5480 struct elf_link_hash_entry
*h
;
5481 unsigned long r_symndx
;
5483 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5484 r_type
= ELF32_R_TYPE (rel
->r_info
);
5486 if (r_symndx
< symtab_hdr
->sh_info
)
5490 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5491 while (h
->root
.type
== bfd_link_hash_indirect
5492 || h
->root
.type
== bfd_link_hash_warning
)
5493 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5496 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5497 if (! bfd_link_pic (info
)
5498 && r_type
== R_SH_TLS_IE_32
5500 && h
->root
.type
!= bfd_link_hash_undefined
5501 && h
->root
.type
!= bfd_link_hash_undefweak
5502 && (h
->dynindx
== -1
5504 r_type
= R_SH_TLS_LE_32
;
5509 case R_SH_GOTOFFFUNCDESC
:
5510 case R_SH_GOTOFFFUNCDESC20
:
5512 case R_SH_GOTFUNCDESC
:
5513 case R_SH_GOTFUNCDESC20
:
5516 if (h
->dynindx
== -1)
5517 switch (ELF_ST_VISIBILITY (h
->other
))
5523 bfd_elf_link_record_dynamic_symbol (info
, h
);
5530 /* Some relocs require a global offset table. */
5531 if (htab
->root
.sgot
== NULL
)
5536 /* This may require an rofixup. */
5546 case R_SH_GOTFUNCDESC
:
5547 case R_SH_GOTFUNCDESC20
:
5548 case R_SH_GOTOFFFUNCDESC
:
5549 case R_SH_GOTOFFFUNCDESC20
:
5551 case R_SH_TLS_GD_32
:
5552 case R_SH_TLS_LD_32
:
5553 case R_SH_TLS_IE_32
:
5554 if (htab
->root
.dynobj
== NULL
)
5555 htab
->root
.dynobj
= abfd
;
5556 if (!create_got_section (htab
->root
.dynobj
, info
))
5567 /* This relocation describes the C++ object vtable hierarchy.
5568 Reconstruct it for later use during GC. */
5569 case R_SH_GNU_VTINHERIT
:
5570 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5574 /* This relocation describes which C++ vtable entries are actually
5575 used. Record for later use during GC. */
5576 case R_SH_GNU_VTENTRY
:
5577 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
5581 case R_SH_TLS_IE_32
:
5582 if (bfd_link_pic (info
))
5583 info
->flags
|= DF_STATIC_TLS
;
5587 case R_SH_TLS_GD_32
:
5590 case R_SH_GOTFUNCDESC
:
5591 case R_SH_GOTFUNCDESC20
:
5595 got_type
= GOT_NORMAL
;
5597 case R_SH_TLS_GD_32
:
5598 got_type
= GOT_TLS_GD
;
5600 case R_SH_TLS_IE_32
:
5601 got_type
= GOT_TLS_IE
;
5603 case R_SH_GOTFUNCDESC
:
5604 case R_SH_GOTFUNCDESC20
:
5605 got_type
= GOT_FUNCDESC
;
5611 h
->got
.refcount
+= 1;
5612 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5616 bfd_signed_vma
*local_got_refcounts
;
5618 /* This is a global offset table entry for a local
5620 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5621 if (local_got_refcounts
== NULL
)
5625 size
= symtab_hdr
->sh_info
;
5626 size
*= sizeof (bfd_signed_vma
);
5627 size
+= symtab_hdr
->sh_info
;
5628 local_got_refcounts
= ((bfd_signed_vma
*)
5629 bfd_zalloc (abfd
, size
));
5630 if (local_got_refcounts
== NULL
)
5632 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
5633 sh_elf_local_got_type (abfd
)
5634 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
5636 local_got_refcounts
[r_symndx
] += 1;
5637 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
5640 /* If a TLS symbol is accessed using IE at least once,
5641 there is no point to use dynamic model for it. */
5642 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
5643 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
5645 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
5646 got_type
= GOT_TLS_IE
;
5649 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
5650 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
5652 /* xgettext:c-format */
5653 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5654 abfd
, h
->root
.root
.string
);
5655 else if (old_got_type
== GOT_FUNCDESC
5656 || got_type
== GOT_FUNCDESC
)
5658 /* xgettext:c-format */
5659 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5660 abfd
, h
->root
.root
.string
);
5663 /* xgettext:c-format */
5664 (_("%pB: `%s' accessed both as normal and thread local symbol"),
5665 abfd
, h
->root
.root
.string
);
5670 if (old_got_type
!= got_type
)
5673 sh_elf_hash_entry (h
)->got_type
= got_type
;
5675 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
5680 case R_SH_TLS_LD_32
:
5681 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
5685 case R_SH_GOTOFFFUNCDESC
:
5686 case R_SH_GOTOFFFUNCDESC20
:
5690 (_("%pB: Function descriptor relocation with non-zero addend"),
5697 union gotref
*local_funcdesc
;
5699 /* We need a function descriptor for a local symbol. */
5700 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5701 if (local_funcdesc
== NULL
)
5705 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
5706 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
5707 if (local_funcdesc
== NULL
)
5709 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
5711 local_funcdesc
[r_symndx
].refcount
+= 1;
5713 if (r_type
== R_SH_FUNCDESC
)
5715 if (!bfd_link_pic (info
))
5716 htab
->srofixup
->size
+= 4;
5718 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5723 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
5724 if (r_type
== R_SH_FUNCDESC
)
5725 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
5727 /* If there is a function descriptor reference, then
5728 there should not be any non-FDPIC references. */
5729 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5730 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
5732 if (old_got_type
== GOT_NORMAL
)
5734 /* xgettext:c-format */
5735 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5736 abfd
, h
->root
.root
.string
);
5739 /* xgettext:c-format */
5740 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5741 abfd
, h
->root
.root
.string
);
5747 /* If this is a local symbol, we resolve it directly without
5748 creating a procedure linkage table entry. */
5752 || ! bfd_link_pic (info
)
5754 || h
->dynindx
== -1)
5758 h
->plt
.refcount
+= 1;
5759 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
5764 /* This symbol requires a procedure linkage table entry. We
5765 actually build the entry in adjust_dynamic_symbol,
5766 because this might be a case of linking PIC code which is
5767 never referenced by a dynamic object, in which case we
5768 don't need to generate a procedure linkage table entry
5771 /* If this is a local symbol, we resolve it directly without
5772 creating a procedure linkage table entry. */
5776 if (h
->forced_local
)
5780 h
->plt
.refcount
+= 1;
5785 if (h
!= NULL
&& ! bfd_link_pic (info
))
5788 h
->plt
.refcount
+= 1;
5791 /* If we are creating a shared library, and this is a reloc
5792 against a global symbol, or a non PC relative reloc
5793 against a local symbol, then we need to copy the reloc
5794 into the shared library. However, if we are linking with
5795 -Bsymbolic, we do not need to copy a reloc against a
5796 global symbol which is defined in an object we are
5797 including in the link (i.e., DEF_REGULAR is set). At
5798 this point we have not seen all the input files, so it is
5799 possible that DEF_REGULAR is not set now but will be set
5800 later (it is never cleared). We account for that
5801 possibility below by storing information in the
5802 dyn_relocs field of the hash table entry. A similar
5803 situation occurs when creating shared libraries and symbol
5804 visibility changes render the symbol local.
5806 If on the other hand, we are creating an executable, we
5807 may need to keep relocations for symbols satisfied by a
5808 dynamic library if we manage to avoid copy relocs for the
5810 if ((bfd_link_pic (info
)
5811 && (sec
->flags
& SEC_ALLOC
) != 0
5812 && (r_type
!= R_SH_REL32
5814 && (! info
->symbolic
5815 || h
->root
.type
== bfd_link_hash_defweak
5816 || !h
->def_regular
))))
5817 || (! bfd_link_pic (info
)
5818 && (sec
->flags
& SEC_ALLOC
) != 0
5820 && (h
->root
.type
== bfd_link_hash_defweak
5821 || !h
->def_regular
)))
5823 struct elf_dyn_relocs
*p
;
5824 struct elf_dyn_relocs
**head
;
5826 if (htab
->root
.dynobj
== NULL
)
5827 htab
->root
.dynobj
= abfd
;
5829 /* When creating a shared object, we must copy these
5830 reloc types into the output file. We create a reloc
5831 section in dynobj and make room for this reloc. */
5834 sreloc
= _bfd_elf_make_dynamic_reloc_section
5835 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
5841 /* If this is a global symbol, we count the number of
5842 relocations we need for this symbol. */
5844 head
= &((struct elf_sh_link_hash_entry
*) h
)->dyn_relocs
;
5847 /* Track dynamic relocs needed for local syms too. */
5850 Elf_Internal_Sym
*isym
;
5852 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5857 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5861 vpp
= &elf_section_data (s
)->local_dynrel
;
5862 head
= (struct elf_dyn_relocs
**) vpp
;
5866 if (p
== NULL
|| p
->sec
!= sec
)
5868 bfd_size_type amt
= sizeof (*p
);
5869 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
5880 if (r_type
== R_SH_REL32
)
5884 /* Allocate the fixup regardless of whether we need a relocation.
5885 If we end up generating the relocation, we'll unallocate the
5887 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
5888 && r_type
== R_SH_DIR32
5889 && (sec
->flags
& SEC_ALLOC
) != 0)
5890 htab
->srofixup
->size
+= 4;
5893 case R_SH_TLS_LE_32
:
5894 if (bfd_link_dll (info
))
5897 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5904 case R_SH_TLS_LDO_32
:
5905 /* Nothing to do. */
5916 #ifndef sh_elf_set_mach_from_flags
5917 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
5920 sh_elf_set_mach_from_flags (bfd
*abfd
)
5922 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
5924 if (flags
>= ARRAY_SIZE (sh_ef_bfd_table
))
5927 if (sh_ef_bfd_table
[flags
] == 0)
5930 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
5936 /* Reverse table lookup for sh_ef_bfd_table[].
5937 Given a bfd MACH value from archures.c
5938 return the equivalent ELF flags from the table.
5939 Return -1 if no match is found. */
5942 sh_elf_get_flags_from_mach (unsigned long mach
)
5944 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
5947 if (sh_ef_bfd_table
[i
] == mach
)
5950 /* shouldn't get here */
5955 #endif /* not sh_elf_set_mach_from_flags */
5957 #ifndef sh_elf_copy_private_data
5958 /* Copy backend specific data from one object module to another */
5961 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
5963 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5966 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
5969 return sh_elf_set_mach_from_flags (obfd
);
5971 #endif /* not sh_elf_copy_private_data */
5973 #ifndef sh_elf_merge_private_data
5975 /* This function returns the ELF architecture number that
5976 corresponds to the given arch_sh* flags. */
5979 sh_find_elf_flags (unsigned int arch_set
)
5981 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5982 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
5984 return sh_elf_get_flags_from_mach (bfd_mach
);
5987 /* Merge the architecture type of two BFD files, such that the
5988 resultant architecture supports all the features required
5989 by the two input BFDs.
5990 If the input BFDs are multually incompatible - i.e. one uses
5991 DSP while the other uses FPU - or there is no known architecture
5992 that fits the requirements then an error is emitted. */
5995 sh_merge_bfd_arch (bfd
*ibfd
, struct bfd_link_info
*info
)
5997 bfd
*obfd
= info
->output_bfd
;
5998 unsigned int old_arch
, new_arch
, merged_arch
;
6000 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
6003 old_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd
));
6004 new_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd
));
6006 merged_arch
= SH_MERGE_ARCH_SET (old_arch
, new_arch
);
6008 if (!SH_VALID_CO_ARCH_SET (merged_arch
))
6011 /* xgettext:c-format */
6012 (_("%pB: uses %s instructions while previous modules "
6013 "use %s instructions"),
6015 SH_ARCH_SET_HAS_DSP (new_arch
) ? "dsp" : "floating point",
6016 SH_ARCH_SET_HAS_DSP (new_arch
) ? "floating point" : "dsp");
6017 bfd_set_error (bfd_error_bad_value
);
6020 else if (!SH_VALID_ARCH_SET (merged_arch
))
6023 /* xgettext:c-format */
6024 (_("internal error: merge of architecture '%s' with "
6025 "architecture '%s' produced unknown architecture"),
6026 bfd_printable_name (obfd
),
6027 bfd_printable_name (ibfd
));
6028 bfd_set_error (bfd_error_bad_value
);
6032 bfd_default_set_arch_mach (obfd
, bfd_arch_sh
,
6033 sh_get_bfd_mach_from_arch_set (merged_arch
));
6038 /* This routine initialises the elf flags when required and
6039 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6042 sh_elf_merge_private_data (bfd
*ibfd
, struct bfd_link_info
*info
)
6044 bfd
*obfd
= info
->output_bfd
;
6046 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
6049 if (! elf_flags_init (obfd
))
6051 /* This happens when ld starts out with a 'blank' output file. */
6052 elf_flags_init (obfd
) = TRUE
;
6053 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
6054 sh_elf_set_mach_from_flags (obfd
);
6055 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
6056 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_PIC
;
6059 if (! sh_merge_bfd_arch (ibfd
, info
))
6061 _bfd_error_handler (_("%pB: uses instructions which are incompatible "
6062 "with instructions used in previous modules"),
6064 bfd_set_error (bfd_error_bad_value
);
6068 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
6069 elf_elfheader (obfd
)->e_flags
|=
6070 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
6072 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
6074 _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
6076 bfd_set_error (bfd_error_bad_value
);
6082 #endif /* not sh_elf_merge_private_data */
6084 /* Override the generic function because we need to store sh_elf_obj_tdata
6085 as the specific tdata. We set also the machine architecture from flags
6089 sh_elf_object_p (bfd
*abfd
)
6091 if (! sh_elf_set_mach_from_flags (abfd
))
6094 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
6095 == fdpic_object_p (abfd
));
6098 /* Finish up dynamic symbol handling. We set the contents of various
6099 dynamic sections here. */
6102 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
6103 struct elf_link_hash_entry
*h
,
6104 Elf_Internal_Sym
*sym
)
6106 struct elf_sh_link_hash_table
*htab
;
6108 htab
= sh_elf_hash_table (info
);
6112 if (h
->plt
.offset
!= (bfd_vma
) -1)
6120 Elf_Internal_Rela rel
;
6122 const struct elf_sh_plt_info
*plt_info
;
6124 /* This symbol has an entry in the procedure linkage table. Set
6127 BFD_ASSERT (h
->dynindx
!= -1);
6129 splt
= htab
->root
.splt
;
6130 sgotplt
= htab
->root
.sgotplt
;
6131 srelplt
= htab
->root
.srelplt
;
6132 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
6134 /* Get the index in the procedure linkage table which
6135 corresponds to this symbol. This is the index of this symbol
6136 in all the symbols for which we are making plt entries. The
6137 first entry in the procedure linkage table is reserved. */
6138 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
6140 plt_info
= htab
->plt_info
;
6141 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
6142 plt_info
= plt_info
->short_plt
;
6144 /* Get the offset into the .got table of the entry that
6145 corresponds to this function. */
6147 /* The offset must be relative to the GOT symbol, twelve bytes
6148 before the end of .got.plt. Each descriptor is eight
6150 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
6152 /* Each .got entry is 4 bytes. The first three are
6154 got_offset
= (plt_index
+ 3) * 4;
6157 if (bfd_link_pic (info
))
6158 got_offset
-= GOT_BIAS
;
6161 /* Fill in the entry in the procedure linkage table. */
6162 memcpy (splt
->contents
+ h
->plt
.offset
,
6163 plt_info
->symbol_entry
,
6164 plt_info
->symbol_entry_size
);
6166 if (bfd_link_pic (info
) || htab
->fdpic_p
)
6168 if (plt_info
->symbol_fields
.got20
)
6170 bfd_reloc_status_type r
;
6171 r
= install_movi20_field (output_bfd
, got_offset
,
6172 splt
->owner
, splt
, splt
->contents
,
6174 + plt_info
->symbol_fields
.got_entry
);
6175 BFD_ASSERT (r
== bfd_reloc_ok
);
6178 install_plt_field (output_bfd
, FALSE
, got_offset
,
6181 + plt_info
->symbol_fields
.got_entry
));
6185 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6187 install_plt_field (output_bfd
, FALSE
,
6188 (sgotplt
->output_section
->vma
6189 + sgotplt
->output_offset
6193 + plt_info
->symbol_fields
.got_entry
));
6194 if (htab
->vxworks_p
)
6196 unsigned int reachable_plts
, plts_per_4k
;
6199 /* Divide the PLT into groups. The first group contains
6200 REACHABLE_PLTS entries and the other groups contain
6201 PLTS_PER_4K entries. Entries in the first group can
6202 branch directly to .plt; those in later groups branch
6203 to the last element of the previous group. */
6204 /* ??? It would be better to create multiple copies of
6205 the common resolver stub. */
6206 reachable_plts
= ((4096
6207 - plt_info
->plt0_entry_size
6208 - (plt_info
->symbol_fields
.plt
+ 4))
6209 / plt_info
->symbol_entry_size
) + 1;
6210 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6211 if (plt_index
< reachable_plts
)
6212 distance
= -(h
->plt
.offset
6213 + plt_info
->symbol_fields
.plt
);
6215 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6216 * plt_info
->symbol_entry_size
);
6218 /* Install the 'bra' with this offset. */
6219 bfd_put_16 (output_bfd
,
6220 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6223 + plt_info
->symbol_fields
.plt
));
6226 install_plt_field (output_bfd
, TRUE
,
6227 splt
->output_section
->vma
+ splt
->output_offset
,
6230 + plt_info
->symbol_fields
.plt
));
6233 /* Make got_offset relative to the start of .got.plt. */
6235 if (bfd_link_pic (info
))
6236 got_offset
+= GOT_BIAS
;
6239 got_offset
= plt_index
* 8;
6241 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6242 install_plt_field (output_bfd
, FALSE
,
6243 plt_index
* sizeof (Elf32_External_Rela
),
6246 + plt_info
->symbol_fields
.reloc_offset
));
6248 /* Fill in the entry in the global offset table. */
6249 bfd_put_32 (output_bfd
,
6250 (splt
->output_section
->vma
6251 + splt
->output_offset
6253 + plt_info
->symbol_resolve_offset
),
6254 sgotplt
->contents
+ got_offset
);
6256 bfd_put_32 (output_bfd
,
6257 sh_elf_osec_to_segment (output_bfd
, splt
->output_section
),
6258 sgotplt
->contents
+ got_offset
+ 4);
6260 /* Fill in the entry in the .rela.plt section. */
6261 rel
.r_offset
= (sgotplt
->output_section
->vma
6262 + sgotplt
->output_offset
6265 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
6267 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
6270 rel
.r_addend
= GOT_BIAS
;
6272 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
6273 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6275 if (htab
->vxworks_p
&& !bfd_link_pic (info
))
6277 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6278 Begin by pointing LOC to the first such relocation. */
6279 loc
= (htab
->srelplt2
->contents
6280 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
6282 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6283 for the PLT entry's pointer to the .got.plt entry. */
6284 rel
.r_offset
= (splt
->output_section
->vma
6285 + splt
->output_offset
6287 + plt_info
->symbol_fields
.got_entry
);
6288 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6289 rel
.r_addend
= got_offset
;
6290 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6291 loc
+= sizeof (Elf32_External_Rela
);
6293 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6294 the .got.plt entry, which initially points to .plt. */
6295 rel
.r_offset
= (sgotplt
->output_section
->vma
6296 + sgotplt
->output_offset
6298 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
6300 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6303 if (!h
->def_regular
)
6305 /* Mark the symbol as undefined, rather than as defined in
6306 the .plt section. Leave the value alone. */
6307 sym
->st_shndx
= SHN_UNDEF
;
6311 if (h
->got
.offset
!= (bfd_vma
) -1
6312 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
6313 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
6314 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
6318 Elf_Internal_Rela rel
;
6321 /* This symbol has an entry in the global offset table. Set it
6324 sgot
= htab
->root
.sgot
;
6325 srelgot
= htab
->root
.srelgot
;
6326 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
6328 rel
.r_offset
= (sgot
->output_section
->vma
6329 + sgot
->output_offset
6330 + (h
->got
.offset
&~ (bfd_vma
) 1));
6332 /* If this is a static link, or it is a -Bsymbolic link and the
6333 symbol is defined locally or was forced to be local because
6334 of a version file, we just want to emit a RELATIVE reloc.
6335 The entry in the global offset table will already have been
6336 initialized in the relocate_section function. */
6337 if (bfd_link_pic (info
)
6338 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6342 asection
*sec
= h
->root
.u
.def
.section
;
6344 = elf_section_data (sec
->output_section
)->dynindx
;
6346 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
6347 rel
.r_addend
= (h
->root
.u
.def
.value
6348 + h
->root
.u
.def
.section
->output_offset
);
6352 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
6353 rel
.r_addend
= (h
->root
.u
.def
.value
6354 + h
->root
.u
.def
.section
->output_section
->vma
6355 + h
->root
.u
.def
.section
->output_offset
);
6360 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
6361 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
6365 loc
= srelgot
->contents
;
6366 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6367 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6373 Elf_Internal_Rela rel
;
6376 /* This symbol needs a copy reloc. Set it up. */
6378 BFD_ASSERT (h
->dynindx
!= -1
6379 && (h
->root
.type
== bfd_link_hash_defined
6380 || h
->root
.type
== bfd_link_hash_defweak
));
6382 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
6383 BFD_ASSERT (s
!= NULL
);
6385 rel
.r_offset
= (h
->root
.u
.def
.value
6386 + h
->root
.u
.def
.section
->output_section
->vma
6387 + h
->root
.u
.def
.section
->output_offset
);
6388 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
6390 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6391 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6394 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
6395 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6397 if (h
== htab
->root
.hdynamic
6398 || (!htab
->vxworks_p
&& h
== htab
->root
.hgot
))
6399 sym
->st_shndx
= SHN_ABS
;
6404 /* Finish up the dynamic sections. */
6407 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6409 struct elf_sh_link_hash_table
*htab
;
6413 htab
= sh_elf_hash_table (info
);
6417 sgotplt
= htab
->root
.sgotplt
;
6418 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
6420 if (htab
->root
.dynamic_sections_created
)
6423 Elf32_External_Dyn
*dyncon
, *dynconend
;
6425 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
6427 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
6428 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
6429 for (; dyncon
< dynconend
; dyncon
++)
6431 Elf_Internal_Dyn dyn
;
6434 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
6440 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
6441 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6445 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
6446 s
= htab
->root
.hgot
->root
.u
.def
.section
;
6447 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
6448 + s
->output_section
->vma
+ s
->output_offset
;
6449 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6453 s
= htab
->root
.srelplt
->output_section
;
6454 BFD_ASSERT (s
!= NULL
);
6455 dyn
.d_un
.d_ptr
= s
->vma
;
6456 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6460 s
= htab
->root
.srelplt
->output_section
;
6461 BFD_ASSERT (s
!= NULL
);
6462 dyn
.d_un
.d_val
= s
->size
;
6463 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6468 /* Fill in the first entry in the procedure linkage table. */
6469 splt
= htab
->root
.splt
;
6470 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
6474 memcpy (splt
->contents
,
6475 htab
->plt_info
->plt0_entry
,
6476 htab
->plt_info
->plt0_entry_size
);
6477 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
6478 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
6479 install_plt_field (output_bfd
, FALSE
,
6480 (sgotplt
->output_section
->vma
6481 + sgotplt
->output_offset
6484 + htab
->plt_info
->plt0_got_fields
[i
]));
6486 if (htab
->vxworks_p
)
6488 /* Finalize the .rela.plt.unloaded contents. */
6489 Elf_Internal_Rela rel
;
6492 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6493 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
6494 loc
= htab
->srelplt2
->contents
;
6495 rel
.r_offset
= (splt
->output_section
->vma
6496 + splt
->output_offset
6497 + htab
->plt_info
->plt0_got_fields
[2]);
6498 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6500 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6501 loc
+= sizeof (Elf32_External_Rela
);
6503 /* Fix up the remaining .rela.plt.unloaded relocations.
6504 They may have the wrong symbol index for _G_O_T_ or
6505 _P_L_T_ depending on the order in which symbols were
6507 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
6509 /* The PLT entry's pointer to the .got.plt slot. */
6510 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6511 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
6513 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6514 loc
+= sizeof (Elf32_External_Rela
);
6516 /* The .got.plt slot's pointer to .plt. */
6517 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6518 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
6520 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6521 loc
+= sizeof (Elf32_External_Rela
);
6525 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6526 really seem like the right value. */
6527 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
6531 /* Fill in the first three entries in the global offset table. */
6532 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
6535 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
6537 bfd_put_32 (output_bfd
,
6538 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6540 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
6541 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
6544 if (sgotplt
&& sgotplt
->size
> 0)
6545 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
6547 /* At the very end of the .rofixup section is a pointer to the GOT. */
6548 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
6550 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
6551 bfd_vma got_value
= hgot
->root
.u
.def
.value
6552 + hgot
->root
.u
.def
.section
->output_section
->vma
6553 + hgot
->root
.u
.def
.section
->output_offset
;
6555 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
6557 /* Make sure we allocated and generated the same number of fixups. */
6558 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
6561 if (htab
->srelfuncdesc
)
6562 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
6563 == htab
->srelfuncdesc
->size
);
6565 if (htab
->root
.srelgot
)
6566 BFD_ASSERT (htab
->root
.srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
6567 == htab
->root
.srelgot
->size
);
6572 static enum elf_reloc_type_class
6573 sh_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6574 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6575 const Elf_Internal_Rela
*rela
)
6577 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6580 return reloc_class_relative
;
6582 return reloc_class_plt
;
6584 return reloc_class_copy
;
6586 return reloc_class_normal
;
6590 #if !defined SH_TARGET_ALREADY_DEFINED
6591 /* Support for Linux core dump NOTE sections. */
6594 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6599 switch (note
->descsz
)
6604 case 168: /* Linux/SH */
6606 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
6609 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
6618 /* Make a ".reg/999" section. */
6619 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6620 size
, note
->descpos
+ offset
);
6624 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6626 switch (note
->descsz
)
6631 case 124: /* Linux/SH elf_prpsinfo */
6632 elf_tdata (abfd
)->core
->program
6633 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
6634 elf_tdata (abfd
)->core
->command
6635 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
6638 /* Note that for some reason, a spurious space is tacked
6639 onto the end of the args in some (at least one anyway)
6640 implementations, so strip it off if it exists. */
6643 char *command
= elf_tdata (abfd
)->core
->command
;
6644 int n
= strlen (command
);
6646 if (0 < n
&& command
[n
- 1] == ' ')
6647 command
[n
- 1] = '\0';
6652 #endif /* not SH_TARGET_ALREADY_DEFINED */
6655 /* Return address for Ith PLT stub in section PLT, for relocation REL
6656 or (bfd_vma) -1 if it should not be included. */
6659 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
6660 const arelent
*rel ATTRIBUTE_UNUSED
)
6662 const struct elf_sh_plt_info
*plt_info
;
6664 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
6665 return plt
->vma
+ get_plt_offset (plt_info
, i
);
6668 /* Decide whether to attempt to turn absptr or lsda encodings in
6669 shared libraries into pcrel within the given input section. */
6672 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6673 struct bfd_link_info
*info
,
6674 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
6676 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6678 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
6685 /* Adjust the contents of an eh_frame_hdr section before they're output. */
6688 sh_elf_encode_eh_address (bfd
*abfd
,
6689 struct bfd_link_info
*info
,
6690 asection
*osec
, bfd_vma offset
,
6691 asection
*loc_sec
, bfd_vma loc_offset
,
6694 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6695 struct elf_link_hash_entry
*h
;
6698 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
6699 loc_offset
, encoded
);
6701 h
= htab
->root
.hgot
;
6702 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
6704 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
6705 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
6706 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
6707 loc_sec
, loc_offset
, encoded
);
6709 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
6710 == (sh_elf_osec_to_segment
6711 (abfd
, h
->root
.u
.def
.section
->output_section
)));
6713 *encoded
= osec
->vma
+ offset
6714 - (h
->root
.u
.def
.value
6715 + h
->root
.u
.def
.section
->output_section
->vma
6716 + h
->root
.u
.def
.section
->output_offset
);
6718 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
6721 #if !defined SH_TARGET_ALREADY_DEFINED
6722 #define TARGET_BIG_SYM sh_elf32_vec
6723 #define TARGET_BIG_NAME "elf32-sh"
6724 #define TARGET_LITTLE_SYM sh_elf32_le_vec
6725 #define TARGET_LITTLE_NAME "elf32-shl"
6728 #define ELF_ARCH bfd_arch_sh
6729 #define ELF_TARGET_ID SH_ELF_DATA
6730 #define ELF_MACHINE_CODE EM_SH
6731 #ifdef __QNXTARGET__
6732 #define ELF_MAXPAGESIZE 0x1000
6734 #define ELF_MAXPAGESIZE 0x80
6737 #define elf_symbol_leading_char '_'
6739 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6740 #define bfd_elf32_bfd_reloc_name_lookup \
6741 sh_elf_reloc_name_lookup
6742 #define elf_info_to_howto sh_elf_info_to_howto
6743 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
6744 #define elf_backend_relocate_section sh_elf_relocate_section
6745 #define bfd_elf32_bfd_get_relocated_section_contents \
6746 sh_elf_get_relocated_section_contents
6747 #define bfd_elf32_mkobject sh_elf_mkobject
6748 #define elf_backend_object_p sh_elf_object_p
6749 #define bfd_elf32_bfd_copy_private_bfd_data \
6750 sh_elf_copy_private_data
6751 #define bfd_elf32_bfd_merge_private_bfd_data \
6752 sh_elf_merge_private_data
6754 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
6755 #define elf_backend_check_relocs sh_elf_check_relocs
6756 #define elf_backend_copy_indirect_symbol \
6757 sh_elf_copy_indirect_symbol
6758 #define elf_backend_create_dynamic_sections \
6759 sh_elf_create_dynamic_sections
6760 #define bfd_elf32_bfd_link_hash_table_create \
6761 sh_elf_link_hash_table_create
6762 #define elf_backend_adjust_dynamic_symbol \
6763 sh_elf_adjust_dynamic_symbol
6764 #define elf_backend_always_size_sections \
6765 sh_elf_always_size_sections
6766 #define elf_backend_size_dynamic_sections \
6767 sh_elf_size_dynamic_sections
6768 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6769 #define elf_backend_finish_dynamic_symbol \
6770 sh_elf_finish_dynamic_symbol
6771 #define elf_backend_finish_dynamic_sections \
6772 sh_elf_finish_dynamic_sections
6773 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
6774 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
6775 #define elf_backend_can_make_relative_eh_frame \
6776 sh_elf_use_relative_eh_frame
6777 #define elf_backend_can_make_lsda_relative_eh_frame \
6778 sh_elf_use_relative_eh_frame
6779 #define elf_backend_encode_eh_address \
6780 sh_elf_encode_eh_address
6782 #define elf_backend_stack_align 8
6783 #define elf_backend_can_gc_sections 1
6784 #define elf_backend_can_refcount 1
6785 #define elf_backend_want_got_plt 1
6786 #define elf_backend_plt_readonly 1
6787 #define elf_backend_want_plt_sym 0
6788 #define elf_backend_got_header_size 12
6789 #define elf_backend_dtrel_excludes_plt 1
6791 #define elf_backend_linux_prpsinfo32_ugid16 TRUE
6793 #if !defined SH_TARGET_ALREADY_DEFINED
6795 #include "elf32-target.h"
6797 /* NetBSD support. */
6798 #undef TARGET_BIG_SYM
6799 #define TARGET_BIG_SYM sh_elf32_nbsd_vec
6800 #undef TARGET_BIG_NAME
6801 #define TARGET_BIG_NAME "elf32-sh-nbsd"
6802 #undef TARGET_LITTLE_SYM
6803 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
6804 #undef TARGET_LITTLE_NAME
6805 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
6806 #undef ELF_MAXPAGESIZE
6807 #define ELF_MAXPAGESIZE 0x10000
6808 #undef ELF_COMMONPAGESIZE
6809 #undef elf_symbol_leading_char
6810 #define elf_symbol_leading_char 0
6812 #define elf32_bed elf32_sh_nbsd_bed
6814 #include "elf32-target.h"
6817 /* Linux support. */
6818 #undef TARGET_BIG_SYM
6819 #define TARGET_BIG_SYM sh_elf32_linux_be_vec
6820 #undef TARGET_BIG_NAME
6821 #define TARGET_BIG_NAME "elf32-shbig-linux"
6822 #undef TARGET_LITTLE_SYM
6823 #define TARGET_LITTLE_SYM sh_elf32_linux_vec
6824 #undef TARGET_LITTLE_NAME
6825 #define TARGET_LITTLE_NAME "elf32-sh-linux"
6826 #undef ELF_COMMONPAGESIZE
6827 #define ELF_COMMONPAGESIZE 0x1000
6829 #undef elf_backend_grok_prstatus
6830 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
6831 #undef elf_backend_grok_psinfo
6832 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
6834 #define elf32_bed elf32_sh_lin_bed
6836 #include "elf32-target.h"
6839 /* FDPIC support. */
6840 #undef TARGET_BIG_SYM
6841 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
6842 #undef TARGET_BIG_NAME
6843 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
6844 #undef TARGET_LITTLE_SYM
6845 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
6846 #undef TARGET_LITTLE_NAME
6847 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
6850 #define elf32_bed elf32_sh_fd_bed
6852 #include "elf32-target.h"
6854 /* VxWorks support. */
6855 #undef TARGET_BIG_SYM
6856 #define TARGET_BIG_SYM sh_elf32_vxworks_vec
6857 #undef TARGET_BIG_NAME
6858 #define TARGET_BIG_NAME "elf32-sh-vxworks"
6859 #undef TARGET_LITTLE_SYM
6860 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
6861 #undef TARGET_LITTLE_NAME
6862 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
6864 #define elf32_bed elf32_sh_vxworks_bed
6866 #undef elf_backend_want_plt_sym
6867 #define elf_backend_want_plt_sym 1
6868 #undef elf_symbol_leading_char
6869 #define elf_symbol_leading_char '_'
6870 #define elf_backend_want_got_underscore 1
6871 #undef elf_backend_grok_prstatus
6872 #undef elf_backend_grok_psinfo
6873 #undef elf_backend_add_symbol_hook
6874 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
6875 #undef elf_backend_link_output_symbol_hook
6876 #define elf_backend_link_output_symbol_hook \
6877 elf_vxworks_link_output_symbol_hook
6878 #undef elf_backend_emit_relocs
6879 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6880 #undef elf_backend_final_write_processing
6881 #define elf_backend_final_write_processing \
6882 elf_vxworks_final_write_processing
6883 #undef ELF_MAXPAGESIZE
6884 #define ELF_MAXPAGESIZE 0x1000
6885 #undef ELF_COMMONPAGESIZE
6887 #include "elf32-target.h"
6889 #endif /* not SH_TARGET_ALREADY_DEFINED */