1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright (C) 1996-2020 Free Software Foundation, Inc.
3 Contributed by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
30 #include "libiberty.h"
31 #include "../opcodes/sh-opc.h"
33 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
34 #define OCTETS_PER_BYTE(ABFD, SEC) 1
36 static bfd_reloc_status_type sh_elf_reloc
37 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
38 static bfd_reloc_status_type sh_elf_ignore_reloc
39 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
40 static bfd_boolean sh_elf_relax_delete_bytes
41 (bfd
*, asection
*, bfd_vma
, int);
42 static bfd_boolean sh_elf_align_loads
43 (bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_boolean
*);
44 static bfd_boolean sh_elf_swap_insns
45 (bfd
*, asection
*, void *, bfd_byte
*, bfd_vma
);
46 static int sh_elf_optimized_tls_reloc
47 (struct bfd_link_info
*, int, int);
48 static bfd_vma dtpoff_base
49 (struct bfd_link_info
*);
51 (struct bfd_link_info
*, bfd_vma
);
53 /* The name of the dynamic interpreter. This is put in the .interp
56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
58 /* FDPIC binaries have a default 128K stack. */
59 #define DEFAULT_STACK_SIZE 0x20000
61 #define MINUS_ONE ((bfd_vma) 0 - 1)
63 /* Decide whether a reference to a symbol can be resolved locally or
64 not. If the symbol is protected, we want the local address, but
65 its function descriptor must be assigned by the dynamic linker. */
66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
68 || ! elf_hash_table (INFO)->dynamic_sections_created)
70 #define SH_PARTIAL32 TRUE
71 #define SH_SRC_MASK32 0xffffffff
72 #define SH_ELF_RELOC sh_elf_reloc
73 static reloc_howto_type sh_elf_howto_table
[] =
75 #include "elf32-sh-relocs.h"
78 #define SH_PARTIAL32 FALSE
79 #define SH_SRC_MASK32 0
80 #define SH_ELF_RELOC bfd_elf_generic_reloc
81 static reloc_howto_type sh_vxworks_howto_table
[] =
83 #include "elf32-sh-relocs.h"
86 /* Return true if OUTPUT_BFD is a VxWorks object. */
89 vxworks_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
91 #if !defined SH_TARGET_ALREADY_DEFINED
92 extern const bfd_target sh_elf32_vxworks_le_vec
;
93 extern const bfd_target sh_elf32_vxworks_vec
;
95 return (abfd
->xvec
== &sh_elf32_vxworks_le_vec
96 || abfd
->xvec
== &sh_elf32_vxworks_vec
);
102 /* Return true if OUTPUT_BFD is an FDPIC object. */
105 fdpic_object_p (bfd
*abfd ATTRIBUTE_UNUSED
)
107 #if !defined SH_TARGET_ALREADY_DEFINED
108 extern const bfd_target sh_elf32_fdpic_le_vec
;
109 extern const bfd_target sh_elf32_fdpic_be_vec
;
111 return (abfd
->xvec
== &sh_elf32_fdpic_le_vec
112 || abfd
->xvec
== &sh_elf32_fdpic_be_vec
);
118 /* Return the howto table for ABFD. */
120 static reloc_howto_type
*
121 get_howto_table (bfd
*abfd
)
123 if (vxworks_object_p (abfd
))
124 return sh_vxworks_howto_table
;
125 return sh_elf_howto_table
;
128 static bfd_reloc_status_type
129 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
130 asection
*input_section
, bfd_byte
*contents
,
131 bfd_vma addr
, asection
*symbol_section
,
132 bfd_vma start
, bfd_vma end
)
134 static bfd_vma last_addr
;
135 static asection
*last_symbol_section
;
136 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
141 /* Sanity check the address. */
142 if (addr
> bfd_get_section_limit (input_bfd
, input_section
))
143 return bfd_reloc_outofrange
;
145 /* We require the start and end relocations to be processed consecutively -
146 although we allow then to be processed forwards or backwards. */
150 last_symbol_section
= symbol_section
;
153 if (last_addr
!= addr
)
157 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
158 return bfd_reloc_outofrange
;
160 /* Get the symbol_section contents. */
161 if (symbol_section
!= input_section
)
163 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
164 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
167 if (!bfd_malloc_and_get_section (input_bfd
, symbol_section
,
171 return bfd_reloc_outofrange
;
175 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
176 start_ptr
= contents
+ start
;
177 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
179 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
182 diff
= (last_ptr
- ptr
) >> 1;
183 cum_diff
+= diff
& 1;
186 /* Calculate the start / end values to load into rs / re minus four -
187 so that will cancel out the four we would otherwise have to add to
188 addr to get the value to subtract in order to get relative addressing. */
192 end
= (ptr
+ cum_diff
* 2) - contents
;
196 bfd_vma start0
= start
- 4;
198 while (start0
&& IS_PPI (contents
+ start0
))
200 start0
= start
- 2 - ((start
- start0
) & 2);
201 start
= start0
- cum_diff
- 2;
205 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= contents
)
208 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
210 x
= (insn
& 0x200 ? end
: start
) - addr
;
211 if (input_section
!= symbol_section
)
212 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
213 - (input_section
->output_section
->vma
214 + input_section
->output_offset
));
216 if (x
< -128 || x
> 127)
217 return bfd_reloc_overflow
;
219 x
= (insn
& ~0xff) | (x
& 0xff);
220 bfd_put_16 (input_bfd
, (bfd_vma
) x
, contents
+ addr
);
225 /* This function is used for normal relocs. This used to be like the COFF
226 function, and is almost certainly incorrect for other ELF targets. */
228 static bfd_reloc_status_type
229 sh_elf_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol_in
,
230 void *data
, asection
*input_section
, bfd
*output_bfd
,
231 char **error_message ATTRIBUTE_UNUSED
)
235 enum elf_sh_reloc_type r_type
;
236 bfd_vma addr
= reloc_entry
->address
;
237 bfd_size_type octets
= addr
* OCTETS_PER_BYTE (abfd
, input_section
);
238 bfd_byte
*hit_data
= (bfd_byte
*) data
+ octets
;
240 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
242 if (output_bfd
!= NULL
)
244 /* Partial linking--do nothing. */
245 reloc_entry
->address
+= input_section
->output_offset
;
249 /* Almost all relocs have to do with relaxing. If any work must be
250 done for them, it has been done in sh_relax_section. */
251 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
254 if (symbol_in
!= NULL
255 && bfd_is_und_section (symbol_in
->section
))
256 return bfd_reloc_undefined
;
258 /* PR 17512: file: 9891ca98. */
259 if (octets
+ bfd_get_reloc_size (reloc_entry
->howto
)
260 > bfd_get_section_limit_octets (abfd
, input_section
))
261 return bfd_reloc_outofrange
;
263 if (bfd_is_com_section (symbol_in
->section
))
266 sym_value
= (symbol_in
->value
+
267 symbol_in
->section
->output_section
->vma
+
268 symbol_in
->section
->output_offset
);
273 insn
= bfd_get_32 (abfd
, hit_data
);
274 insn
+= sym_value
+ reloc_entry
->addend
;
275 bfd_put_32 (abfd
, insn
, hit_data
);
278 insn
= bfd_get_16 (abfd
, hit_data
);
279 sym_value
+= reloc_entry
->addend
;
280 sym_value
-= (input_section
->output_section
->vma
281 + input_section
->output_offset
284 sym_value
+= (((insn
& 0xfff) ^ 0x800) - 0x800) << 1;
285 insn
= (insn
& 0xf000) | ((sym_value
>> 1) & 0xfff);
286 bfd_put_16 (abfd
, insn
, hit_data
);
287 if (sym_value
+ 0x1000 >= 0x2000 || (sym_value
& 1) != 0)
288 return bfd_reloc_overflow
;
298 /* This function is used for relocs which are only used for relaxing,
299 which the linker should otherwise ignore. */
301 static bfd_reloc_status_type
302 sh_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
303 asymbol
*symbol ATTRIBUTE_UNUSED
,
304 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
306 char **error_message ATTRIBUTE_UNUSED
)
308 if (output_bfd
!= NULL
)
309 reloc_entry
->address
+= input_section
->output_offset
;
313 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
317 bfd_reloc_code_real_type bfd_reloc_val
;
318 unsigned char elf_reloc_val
;
321 /* An array mapping BFD reloc codes to SH ELF relocs. */
323 static const struct elf_reloc_map sh_reloc_map
[] =
325 { BFD_RELOC_NONE
, R_SH_NONE
},
326 { BFD_RELOC_32
, R_SH_DIR32
},
327 { BFD_RELOC_16
, R_SH_DIR16
},
328 { BFD_RELOC_8
, R_SH_DIR8
},
329 { BFD_RELOC_CTOR
, R_SH_DIR32
},
330 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
331 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
332 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
333 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
334 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
335 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
336 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
337 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
338 { BFD_RELOC_SH_USES
, R_SH_USES
},
339 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
340 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
341 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
342 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
343 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
344 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
345 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
346 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
347 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
348 { BFD_RELOC_SH_TLS_GD_32
, R_SH_TLS_GD_32
},
349 { BFD_RELOC_SH_TLS_LD_32
, R_SH_TLS_LD_32
},
350 { BFD_RELOC_SH_TLS_LDO_32
, R_SH_TLS_LDO_32
},
351 { BFD_RELOC_SH_TLS_IE_32
, R_SH_TLS_IE_32
},
352 { BFD_RELOC_SH_TLS_LE_32
, R_SH_TLS_LE_32
},
353 { BFD_RELOC_SH_TLS_DTPMOD32
, R_SH_TLS_DTPMOD32
},
354 { BFD_RELOC_SH_TLS_DTPOFF32
, R_SH_TLS_DTPOFF32
},
355 { BFD_RELOC_SH_TLS_TPOFF32
, R_SH_TLS_TPOFF32
},
356 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
357 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
358 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
359 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
360 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
361 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
362 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
363 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
364 { BFD_RELOC_SH_GOTPLT32
, R_SH_GOTPLT32
},
365 { BFD_RELOC_SH_GOT20
, R_SH_GOT20
},
366 { BFD_RELOC_SH_GOTOFF20
, R_SH_GOTOFF20
},
367 { BFD_RELOC_SH_GOTFUNCDESC
, R_SH_GOTFUNCDESC
},
368 { BFD_RELOC_SH_GOTFUNCDESC20
, R_SH_GOTFUNCDESC20
},
369 { BFD_RELOC_SH_GOTOFFFUNCDESC
, R_SH_GOTOFFFUNCDESC
},
370 { BFD_RELOC_SH_GOTOFFFUNCDESC20
, R_SH_GOTOFFFUNCDESC20
},
371 { BFD_RELOC_SH_FUNCDESC
, R_SH_FUNCDESC
},
374 /* Given a BFD reloc code, return the howto structure for the
375 corresponding SH ELF reloc. */
377 static reloc_howto_type
*
378 sh_elf_reloc_type_lookup (bfd
*abfd
, bfd_reloc_code_real_type code
)
382 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
384 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
385 return get_howto_table (abfd
) + (int) sh_reloc_map
[i
].elf_reloc_val
;
391 static reloc_howto_type
*
392 sh_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
396 if (vxworks_object_p (abfd
))
399 i
< (sizeof (sh_vxworks_howto_table
)
400 / sizeof (sh_vxworks_howto_table
[0]));
402 if (sh_vxworks_howto_table
[i
].name
!= NULL
403 && strcasecmp (sh_vxworks_howto_table
[i
].name
, r_name
) == 0)
404 return &sh_vxworks_howto_table
[i
];
409 i
< (sizeof (sh_elf_howto_table
)
410 / sizeof (sh_elf_howto_table
[0]));
412 if (sh_elf_howto_table
[i
].name
!= NULL
413 && strcasecmp (sh_elf_howto_table
[i
].name
, r_name
) == 0)
414 return &sh_elf_howto_table
[i
];
420 /* Given an ELF reloc, fill in the howto field of a relent. */
423 sh_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
427 r
= ELF32_R_TYPE (dst
->r_info
);
430 || (r
>= R_SH_FIRST_INVALID_RELOC
&& r
<= R_SH_LAST_INVALID_RELOC
)
431 || (r
>= R_SH_FIRST_INVALID_RELOC_2
&& r
<= R_SH_LAST_INVALID_RELOC_2
)
432 || (r
>= R_SH_FIRST_INVALID_RELOC_3
&& r
<= R_SH_LAST_INVALID_RELOC_3
)
433 || (r
>= R_SH_FIRST_INVALID_RELOC_4
&& r
<= R_SH_LAST_INVALID_RELOC_4
)
434 || (r
>= R_SH_FIRST_INVALID_RELOC_5
&& r
<= R_SH_LAST_INVALID_RELOC_5
)
435 || (r
>= R_SH_FIRST_INVALID_RELOC_6
&& r
<= R_SH_LAST_INVALID_RELOC_6
))
437 /* xgettext:c-format */
438 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
440 bfd_set_error (bfd_error_bad_value
);
444 cache_ptr
->howto
= get_howto_table (abfd
) + r
;
448 /* This function handles relaxing for SH ELF. See the corresponding
449 function in coff-sh.c for a description of what this does. FIXME:
450 There is a lot of duplication here between this code and the COFF
451 specific code. The format of relocs and symbols is wound deeply
452 into this code, but it would still be better if the duplication
453 could be eliminated somehow. Note in particular that although both
454 functions use symbols like R_SH_CODE, those symbols have different
455 values; in coff-sh.c they come from include/coff/sh.h, whereas here
456 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
459 sh_elf_relax_section (bfd
*abfd
, asection
*sec
,
460 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
462 Elf_Internal_Shdr
*symtab_hdr
;
463 Elf_Internal_Rela
*internal_relocs
;
464 bfd_boolean have_code
;
465 Elf_Internal_Rela
*irel
, *irelend
;
466 bfd_byte
*contents
= NULL
;
467 Elf_Internal_Sym
*isymbuf
= NULL
;
471 if (bfd_link_relocatable (link_info
)
472 || (sec
->flags
& SEC_RELOC
) == 0
473 || sec
->reloc_count
== 0)
476 symtab_hdr
= &elf_symtab_hdr (abfd
);
478 internal_relocs
= (_bfd_elf_link_read_relocs
479 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
480 link_info
->keep_memory
));
481 if (internal_relocs
== NULL
)
486 irelend
= internal_relocs
+ sec
->reloc_count
;
487 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
489 bfd_vma laddr
, paddr
, symval
;
491 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
494 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
497 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
500 /* Get the section contents. */
501 if (contents
== NULL
)
503 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
504 contents
= elf_section_data (sec
)->this_hdr
.contents
;
507 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
512 /* The r_addend field of the R_SH_USES reloc will point us to
513 the register load. The 4 is because the r_addend field is
514 computed as though it were a jump offset, which are based
515 from 4 bytes after the jump instruction. */
516 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
517 if (laddr
>= sec
->size
)
519 /* xgettext:c-format */
521 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES offset"),
522 abfd
, (uint64_t) irel
->r_offset
);
525 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
527 /* If the instruction is not mov.l NN,rN, we don't know what to
529 if ((insn
& 0xf000) != 0xd000)
532 /* xgettext:c-format */
533 (_("%pB: %#" PRIx64
": warning: "
534 "R_SH_USES points to unrecognized insn 0x%x"),
535 abfd
, (uint64_t) irel
->r_offset
, insn
);
539 /* Get the address from which the register is being loaded. The
540 displacement in the mov.l instruction is quadrupled. It is a
541 displacement from four bytes after the movl instruction, but,
542 before adding in the PC address, two least significant bits
543 of the PC are cleared. We assume that the section is aligned
544 on a four byte boundary. */
547 paddr
+= (laddr
+ 4) &~ (bfd_vma
) 3;
548 if (paddr
>= sec
->size
)
551 /* xgettext:c-format */
552 (_("%pB: %#" PRIx64
": warning: bad R_SH_USES load offset"),
553 abfd
, (uint64_t) irel
->r_offset
);
557 /* Get the reloc for the address from which the register is
558 being loaded. This reloc will tell us which function is
559 actually being called. */
560 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
561 if (irelfn
->r_offset
== paddr
562 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
564 if (irelfn
>= irelend
)
567 /* xgettext:c-format */
568 (_("%pB: %#" PRIx64
": warning: could not find expected reloc"),
569 abfd
, (uint64_t) paddr
);
573 /* Read this BFD's symbols if we haven't done so already. */
574 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
576 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
578 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
579 symtab_hdr
->sh_info
, 0,
585 /* Get the value of the symbol referred to by the reloc. */
586 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
588 /* A local symbol. */
589 Elf_Internal_Sym
*isym
;
591 isym
= isymbuf
+ ELF32_R_SYM (irelfn
->r_info
);
593 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd
, sec
))
596 /* xgettext:c-format */
597 (_("%pB: %#" PRIx64
": warning: symbol in unexpected section"),
598 abfd
, (uint64_t) paddr
);
602 symval
= (isym
->st_value
603 + sec
->output_section
->vma
604 + sec
->output_offset
);
609 struct elf_link_hash_entry
*h
;
611 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
612 h
= elf_sym_hashes (abfd
)[indx
];
613 BFD_ASSERT (h
!= NULL
);
614 if (h
->root
.type
!= bfd_link_hash_defined
615 && h
->root
.type
!= bfd_link_hash_defweak
)
617 /* This appears to be a reference to an undefined
618 symbol. Just ignore it--it will be caught by the
619 regular reloc processing. */
623 symval
= (h
->root
.u
.def
.value
624 + h
->root
.u
.def
.section
->output_section
->vma
625 + h
->root
.u
.def
.section
->output_offset
);
628 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
629 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
631 symval
+= irelfn
->r_addend
;
633 /* See if this function call can be shortened. */
636 + sec
->output_section
->vma
639 /* A branch to an address beyond ours might be increased by an
640 .align that doesn't move when bytes behind us are deleted.
641 So, we add some slop in this calculation to allow for
643 if (foff
< -0x1000 || foff
>= 0x1000 - 8)
645 /* After all that work, we can't shorten this function call. */
649 /* Shorten the function call. */
651 /* For simplicity of coding, we are going to modify the section
652 contents, the section relocs, and the BFD symbol table. We
653 must tell the rest of the code not to free up this
654 information. It would be possible to instead create a table
655 of changes which have to be made, as is done in coff-mips.c;
656 that would be more work, but would require less memory when
657 the linker is run. */
659 elf_section_data (sec
)->relocs
= internal_relocs
;
660 elf_section_data (sec
)->this_hdr
.contents
= contents
;
661 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
663 /* Replace the jmp/jsr with a bra/bsr. */
665 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
666 replace the jmp/jsr with a bra/bsr. */
667 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
668 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
669 here, but that only checks if the symbol is an external symbol,
670 not if the symbol is in a different section. Besides, we need
671 a consistent meaning for the relocation, so we just assume here that
672 the value of the symbol is not available. */
674 /* We can't fully resolve this yet, because the external
675 symbol value may be changed by future relaxing. We let
676 the final link phase handle it. */
677 if (bfd_get_16 (abfd
, contents
+ irel
->r_offset
) & 0x0020)
678 bfd_put_16 (abfd
, (bfd_vma
) 0xa000, contents
+ irel
->r_offset
);
680 bfd_put_16 (abfd
, (bfd_vma
) 0xb000, contents
+ irel
->r_offset
);
684 /* When we calculated the symbol "value" we had an offset in the
685 DIR32's word in memory (we read and add it above). However,
686 the jsr we create does NOT have this offset encoded, so we
687 have to add it to the addend to preserve it. */
688 irel
->r_addend
+= bfd_get_32 (abfd
, contents
+ paddr
);
690 /* See if there is another R_SH_USES reloc referring to the same
692 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
693 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
694 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
696 if (irelscan
< irelend
)
698 /* Some other function call depends upon this register load,
699 and we have not yet converted that function call.
700 Indeed, we may never be able to convert it. There is
701 nothing else we can do at this point. */
705 /* Look for a R_SH_COUNT reloc on the location where the
706 function address is stored. Do this before deleting any
707 bytes, to avoid confusion about the address. */
708 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
709 if (irelcount
->r_offset
== paddr
710 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
713 /* Delete the register load. */
714 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
717 /* That will change things, so, just in case it permits some
718 other function call to come within range, we should relax
719 again. Note that this is not required, and it may be slow. */
722 /* Now check whether we got a COUNT reloc. */
723 if (irelcount
>= irelend
)
726 /* xgettext:c-format */
727 (_("%pB: %#" PRIx64
": warning: "
728 "could not find expected COUNT reloc"),
729 abfd
, (uint64_t) paddr
);
733 /* The number of uses is stored in the r_addend field. We've
735 if (irelcount
->r_addend
== 0)
737 /* xgettext:c-format */
738 _bfd_error_handler (_("%pB: %#" PRIx64
": warning: bad count"),
739 abfd
, (uint64_t) paddr
);
743 --irelcount
->r_addend
;
745 /* If there are no more uses, we can delete the address. Reload
746 the address from irelfn, in case it was changed by the
747 previous call to sh_elf_relax_delete_bytes. */
748 if (irelcount
->r_addend
== 0)
750 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
754 /* We've done all we can with that function call. */
757 /* Look for load and store instructions that we can align on four
759 if ((elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
) != EF_SH4
764 /* Get the section contents. */
765 if (contents
== NULL
)
767 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
768 contents
= elf_section_data (sec
)->this_hdr
.contents
;
771 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
776 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
782 elf_section_data (sec
)->relocs
= internal_relocs
;
783 elf_section_data (sec
)->this_hdr
.contents
= contents
;
784 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
789 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
791 if (! link_info
->keep_memory
)
795 /* Cache the symbols for elf_link_input_bfd. */
796 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
801 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
803 if (! link_info
->keep_memory
)
807 /* Cache the section contents for elf_link_input_bfd. */
808 elf_section_data (sec
)->this_hdr
.contents
= contents
;
812 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
813 free (internal_relocs
);
818 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
820 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
822 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
823 free (internal_relocs
);
828 /* Delete some bytes from a section while relaxing. FIXME: There is a
829 lot of duplication between this function and sh_relax_delete_bytes
833 sh_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
,
836 Elf_Internal_Shdr
*symtab_hdr
;
837 unsigned int sec_shndx
;
839 Elf_Internal_Rela
*irel
, *irelend
;
840 Elf_Internal_Rela
*irelalign
;
842 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
843 struct elf_link_hash_entry
**sym_hashes
;
844 struct elf_link_hash_entry
**end_hashes
;
845 unsigned int symcount
;
848 symtab_hdr
= &elf_symtab_hdr (abfd
);
849 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
851 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
853 contents
= elf_section_data (sec
)->this_hdr
.contents
;
855 /* The deletion must stop at the next ALIGN reloc for an alignment
856 power larger than the number of bytes we are deleting. */
861 irel
= elf_section_data (sec
)->relocs
;
862 irelend
= irel
+ sec
->reloc_count
;
863 for (; irel
< irelend
; irel
++)
865 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
866 && irel
->r_offset
> addr
867 && count
< (1 << irel
->r_addend
))
870 toaddr
= irel
->r_offset
;
875 /* Actually delete the bytes. */
876 memmove (contents
+ addr
, contents
+ addr
+ count
,
877 (size_t) (toaddr
- addr
- count
));
878 if (irelalign
== NULL
)
884 #define NOP_OPCODE (0x0009)
886 BFD_ASSERT ((count
& 1) == 0);
887 for (i
= 0; i
< count
; i
+= 2)
888 bfd_put_16 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
891 /* Adjust all the relocs. */
892 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
894 bfd_vma nraddr
, stop
;
897 int off
, adjust
, oinsn
;
898 bfd_signed_vma voff
= 0;
899 bfd_boolean overflow
;
901 /* Get the new reloc address. */
902 nraddr
= irel
->r_offset
;
903 if ((irel
->r_offset
> addr
904 && irel
->r_offset
< toaddr
)
905 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
906 && irel
->r_offset
== toaddr
))
909 /* See if this reloc was for the bytes we have deleted, in which
910 case we no longer care about it. Don't delete relocs which
911 represent addresses, though. */
912 if (irel
->r_offset
>= addr
913 && irel
->r_offset
< addr
+ count
914 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
915 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
916 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
917 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
918 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
921 /* If this is a PC relative reloc, see if the range it covers
922 includes the bytes we have deleted. */
923 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
932 start
= irel
->r_offset
;
933 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
937 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
944 /* If this reloc is against a symbol defined in this
945 section, and the symbol will not be adjusted below, we
946 must check the addend to see it will put the value in
947 range to be adjusted, and hence must be changed. */
948 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
950 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
951 if (isym
->st_shndx
== sec_shndx
952 && (isym
->st_value
<= addr
953 || isym
->st_value
>= toaddr
))
957 if (get_howto_table (abfd
)[R_SH_DIR32
].partial_inplace
)
959 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
960 val
+= isym
->st_value
;
961 if (val
> addr
&& val
< toaddr
)
962 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
966 val
= isym
->st_value
+ irel
->r_addend
;
967 if (val
> addr
&& val
< toaddr
)
968 irel
->r_addend
-= count
;
979 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
986 /* This has been made by previous relaxation. Since the
987 relocation will be against an external symbol, the
988 final relocation will just do the right thing. */
995 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
997 /* The addend will be against the section symbol, thus
998 for adjusting the addend, the relevant start is the
999 start of the section.
1000 N.B. If we want to abandon in-place changes here and
1001 test directly using symbol + addend, we have to take into
1002 account that the addend has already been adjusted by -4. */
1003 if (stop
> addr
&& stop
< toaddr
)
1004 irel
->r_addend
-= count
;
1010 stop
= start
+ 4 + off
* 2;
1015 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1021 /* These relocs types represent
1023 The r_addend field holds the difference between the reloc
1024 address and L1. That is the start of the reloc, and
1025 adding in the contents gives us the top. We must adjust
1026 both the r_offset field and the section contents.
1027 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1028 and the elf bfd r_offset is called r_vaddr. */
1030 stop
= irel
->r_offset
;
1031 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1035 && (stop
<= addr
|| stop
>= toaddr
))
1036 irel
->r_addend
+= count
;
1037 else if (stop
> addr
1039 && (start
<= addr
|| start
>= toaddr
))
1040 irel
->r_addend
-= count
;
1042 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1043 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1044 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1045 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1047 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1048 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1053 start
= irel
->r_offset
;
1054 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1055 + (long) irel
->r_addend
1062 && (stop
<= addr
|| stop
>= toaddr
))
1064 else if (stop
> addr
1066 && (start
<= addr
|| start
>= toaddr
))
1075 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1084 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1086 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1091 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1093 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1097 BFD_ASSERT (adjust
== count
|| count
>= 4);
1102 if ((irel
->r_offset
& 3) == 0)
1105 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1107 bfd_put_16 (abfd
, (bfd_vma
) insn
, contents
+ nraddr
);
1112 if (voff
< 0 || voff
>= 0xff)
1114 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1119 if (voff
< - 0x8000 || voff
>= 0x8000)
1121 bfd_put_signed_16 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1126 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
, contents
+ nraddr
);
1130 irel
->r_addend
+= adjust
;
1137 /* xgettext:c-format */
1138 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1139 abfd
, (uint64_t) irel
->r_offset
);
1140 bfd_set_error (bfd_error_bad_value
);
1145 irel
->r_offset
= nraddr
;
1148 /* Look through all the other sections. If there contain any IMM32
1149 relocs against internal symbols which we are not going to adjust
1150 below, we may need to adjust the addends. */
1151 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1153 Elf_Internal_Rela
*internal_relocs
;
1154 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1155 bfd_byte
*ocontents
;
1158 || (o
->flags
& SEC_RELOC
) == 0
1159 || o
->reloc_count
== 0)
1162 /* We always cache the relocs. Perhaps, if info->keep_memory is
1163 FALSE, we should free them, if we are permitted to, when we
1164 leave sh_coff_relax_section. */
1165 internal_relocs
= (_bfd_elf_link_read_relocs
1166 (abfd
, o
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
));
1167 if (internal_relocs
== NULL
)
1171 irelscanend
= internal_relocs
+ o
->reloc_count
;
1172 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1174 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1175 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1177 bfd_vma start
, stop
;
1178 bfd_signed_vma voff
;
1180 if (ocontents
== NULL
)
1182 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1183 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1186 /* We always cache the section contents.
1187 Perhaps, if info->keep_memory is FALSE, we
1188 should free them, if we are permitted to,
1189 when we leave sh_coff_relax_section. */
1190 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1196 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1200 stop
= irelscan
->r_offset
;
1202 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1204 /* STOP is in a different section, so it won't change. */
1205 if (start
> addr
&& start
< toaddr
)
1206 irelscan
->r_addend
+= count
;
1208 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1209 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1213 && (stop
<= addr
|| stop
>= toaddr
))
1214 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
+ count
,
1215 ocontents
+ irelscan
->r_offset
);
1216 else if (stop
> addr
1218 && (start
<= addr
|| start
>= toaddr
))
1219 bfd_put_signed_32 (abfd
, (bfd_vma
) voff
- count
,
1220 ocontents
+ irelscan
->r_offset
);
1223 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1226 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1230 isym
= isymbuf
+ ELF32_R_SYM (irelscan
->r_info
);
1231 if (isym
->st_shndx
== sec_shndx
1232 && (isym
->st_value
<= addr
1233 || isym
->st_value
>= toaddr
))
1237 if (ocontents
== NULL
)
1239 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1240 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1243 /* We always cache the section contents.
1244 Perhaps, if info->keep_memory is FALSE, we
1245 should free them, if we are permitted to,
1246 when we leave sh_coff_relax_section. */
1247 if (!bfd_malloc_and_get_section (abfd
, o
, &ocontents
))
1253 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1257 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1258 val
+= isym
->st_value
;
1259 if (val
> addr
&& val
< toaddr
)
1260 bfd_put_32 (abfd
, val
- count
,
1261 ocontents
+ irelscan
->r_offset
);
1266 /* Adjust the local symbols defined in this section. */
1267 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1268 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1270 if (isym
->st_shndx
== sec_shndx
1271 && isym
->st_value
> addr
1272 && isym
->st_value
< toaddr
)
1273 isym
->st_value
-= count
;
1276 /* Now adjust the global symbols defined in this section. */
1277 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1278 - symtab_hdr
->sh_info
);
1279 sym_hashes
= elf_sym_hashes (abfd
);
1280 end_hashes
= sym_hashes
+ symcount
;
1281 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1283 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1284 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1285 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1286 && sym_hash
->root
.u
.def
.section
== sec
1287 && sym_hash
->root
.u
.def
.value
> addr
1288 && sym_hash
->root
.u
.def
.value
< toaddr
)
1290 sym_hash
->root
.u
.def
.value
-= count
;
1294 /* See if we can move the ALIGN reloc forward. We have adjusted
1295 r_offset for it already. */
1296 if (irelalign
!= NULL
)
1298 bfd_vma alignto
, alignaddr
;
1300 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1301 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1302 1 << irelalign
->r_addend
);
1303 if (alignto
!= alignaddr
)
1305 /* Tail recursion. */
1306 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1307 (int) (alignto
- alignaddr
));
1314 /* Look for loads and stores which we can align to four byte
1315 boundaries. This is like sh_align_loads in coff-sh.c. */
1318 sh_elf_align_loads (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1319 Elf_Internal_Rela
*internal_relocs
,
1320 bfd_byte
*contents ATTRIBUTE_UNUSED
,
1321 bfd_boolean
*pswapped
)
1323 Elf_Internal_Rela
*irel
, *irelend
;
1324 bfd_vma
*labels
= NULL
;
1325 bfd_vma
*label
, *label_end
;
1330 irelend
= internal_relocs
+ sec
->reloc_count
;
1332 /* Get all the addresses with labels on them. */
1333 amt
= sec
->reloc_count
;
1334 amt
*= sizeof (bfd_vma
);
1335 labels
= (bfd_vma
*) bfd_malloc (amt
);
1339 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1341 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1343 *label_end
= irel
->r_offset
;
1348 /* Note that the assembler currently always outputs relocs in
1349 address order. If that ever changes, this code will need to sort
1350 the label values and the relocs. */
1354 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1356 bfd_vma start
, stop
;
1358 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1361 start
= irel
->r_offset
;
1363 for (irel
++; irel
< irelend
; irel
++)
1364 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1367 stop
= irel
->r_offset
;
1371 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1372 internal_relocs
, &label
,
1373 label_end
, start
, stop
, pswapped
))
1386 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1389 sh_elf_swap_insns (bfd
*abfd
, asection
*sec
, void *relocs
,
1390 bfd_byte
*contents
, bfd_vma addr
)
1392 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1393 unsigned short i1
, i2
;
1394 Elf_Internal_Rela
*irel
, *irelend
;
1396 /* Swap the instructions themselves. */
1397 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1398 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1399 bfd_put_16 (abfd
, (bfd_vma
) i2
, contents
+ addr
);
1400 bfd_put_16 (abfd
, (bfd_vma
) i1
, contents
+ addr
+ 2);
1402 /* Adjust all reloc addresses. */
1403 irelend
= internal_relocs
+ sec
->reloc_count
;
1404 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1406 enum elf_sh_reloc_type type
;
1409 /* There are a few special types of relocs that we don't want to
1410 adjust. These relocs do not apply to the instruction itself,
1411 but are only associated with the address. */
1412 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1413 if (type
== R_SH_ALIGN
1414 || type
== R_SH_CODE
1415 || type
== R_SH_DATA
1416 || type
== R_SH_LABEL
)
1419 /* If an R_SH_USES reloc points to one of the addresses being
1420 swapped, we must adjust it. It would be incorrect to do this
1421 for a jump, though, since we want to execute both
1422 instructions after the jump. (We have avoided swapping
1423 around a label, so the jump will not wind up executing an
1424 instruction it shouldn't). */
1425 if (type
== R_SH_USES
)
1429 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
1431 irel
->r_offset
+= 2;
1432 else if (off
== addr
+ 2)
1433 irel
->r_offset
-= 2;
1436 if (irel
->r_offset
== addr
)
1438 irel
->r_offset
+= 2;
1441 else if (irel
->r_offset
== addr
+ 2)
1443 irel
->r_offset
-= 2;
1452 unsigned short insn
, oinsn
;
1453 bfd_boolean overflow
;
1455 loc
= contents
+ irel
->r_offset
;
1464 insn
= bfd_get_16 (abfd
, loc
);
1467 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1469 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1473 insn
= bfd_get_16 (abfd
, loc
);
1476 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1478 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1482 /* This reloc ignores the least significant 3 bits of
1483 the program counter before adding in the offset.
1484 This means that if ADDR is at an even address, the
1485 swap will not affect the offset. If ADDR is an at an
1486 odd address, then the instruction will be crossing a
1487 four byte boundary, and must be adjusted. */
1488 if ((addr
& 3) != 0)
1490 insn
= bfd_get_16 (abfd
, loc
);
1493 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1495 bfd_put_16 (abfd
, (bfd_vma
) insn
, loc
);
1504 /* xgettext:c-format */
1505 (_("%pB: %#" PRIx64
": fatal: reloc overflow while relaxing"),
1506 abfd
, (uint64_t) irel
->r_offset
);
1507 bfd_set_error (bfd_error_bad_value
);
1516 /* Describes one of the various PLT styles. */
1518 struct elf_sh_plt_info
1520 /* The template for the first PLT entry, or NULL if there is no special
1522 const bfd_byte
*plt0_entry
;
1524 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1525 bfd_vma plt0_entry_size
;
1527 /* Index I is the offset into PLT0_ENTRY of a pointer to
1528 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1529 if there is no such pointer. */
1530 bfd_vma plt0_got_fields
[3];
1532 /* The template for a symbol's PLT entry. */
1533 const bfd_byte
*symbol_entry
;
1535 /* The size of SYMBOL_ENTRY in bytes. */
1536 bfd_vma symbol_entry_size
;
1538 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1539 on all targets. The comments by each member indicate the value
1540 that the field must hold. */
1542 bfd_vma got_entry
; /* the address of the symbol's .got.plt entry */
1543 bfd_vma plt
; /* .plt (or a branch to .plt on VxWorks) */
1544 bfd_vma reloc_offset
; /* the offset of the symbol's JMP_SLOT reloc */
1545 bfd_boolean got20
; /* TRUE if got_entry points to a movi20
1546 instruction (instead of a constant pool
1550 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1551 bfd_vma symbol_resolve_offset
;
1553 /* A different PLT layout which can be used for the first
1554 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1556 const struct elf_sh_plt_info
*short_plt
;
1559 /* The size in bytes of an entry in the procedure linkage table. */
1561 #define ELF_PLT_ENTRY_SIZE 28
1563 /* First entry in an absolute procedure linkage table look like this. */
1565 /* Note - this code has been "optimised" not to use r2. r2 is used by
1566 GCC to return the address of large structures, so it should not be
1567 corrupted here. This does mean however, that this PLT does not conform
1568 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1569 and r2 contains the GOT id. This version stores the GOT id in r0 and
1570 ignores the type. Loaders can easily detect this difference however,
1571 since the type will always be 0 or 8, and the GOT ids will always be
1572 greater than or equal to 12. */
1573 static const bfd_byte elf_sh_plt0_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1575 0xd0, 0x05, /* mov.l 2f,r0 */
1576 0x60, 0x02, /* mov.l @r0,r0 */
1577 0x2f, 0x06, /* mov.l r0,@-r15 */
1578 0xd0, 0x03, /* mov.l 1f,r0 */
1579 0x60, 0x02, /* mov.l @r0,r0 */
1580 0x40, 0x2b, /* jmp @r0 */
1581 0x60, 0xf6, /* mov.l @r15+,r0 */
1582 0x00, 0x09, /* nop */
1583 0x00, 0x09, /* nop */
1584 0x00, 0x09, /* nop */
1585 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1586 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1589 static const bfd_byte elf_sh_plt0_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1591 0x05, 0xd0, /* mov.l 2f,r0 */
1592 0x02, 0x60, /* mov.l @r0,r0 */
1593 0x06, 0x2f, /* mov.l r0,@-r15 */
1594 0x03, 0xd0, /* mov.l 1f,r0 */
1595 0x02, 0x60, /* mov.l @r0,r0 */
1596 0x2b, 0x40, /* jmp @r0 */
1597 0xf6, 0x60, /* mov.l @r15+,r0 */
1598 0x09, 0x00, /* nop */
1599 0x09, 0x00, /* nop */
1600 0x09, 0x00, /* nop */
1601 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1602 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1605 /* Sebsequent entries in an absolute procedure linkage table look like
1608 static const bfd_byte elf_sh_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1610 0xd0, 0x04, /* mov.l 1f,r0 */
1611 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1612 0xd1, 0x02, /* mov.l 0f,r1 */
1613 0x40, 0x2b, /* jmp @r0 */
1614 0x60, 0x13, /* mov r1,r0 */
1615 0xd1, 0x03, /* mov.l 2f,r1 */
1616 0x40, 0x2b, /* jmp @r0 */
1617 0x00, 0x09, /* nop */
1618 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1619 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1620 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1623 static const bfd_byte elf_sh_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1625 0x04, 0xd0, /* mov.l 1f,r0 */
1626 0x02, 0x60, /* mov.l @r0,r0 */
1627 0x02, 0xd1, /* mov.l 0f,r1 */
1628 0x2b, 0x40, /* jmp @r0 */
1629 0x13, 0x60, /* mov r1,r0 */
1630 0x03, 0xd1, /* mov.l 2f,r1 */
1631 0x2b, 0x40, /* jmp @r0 */
1632 0x09, 0x00, /* nop */
1633 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1634 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1635 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1638 /* Entries in a PIC procedure linkage table look like this. */
1640 static const bfd_byte elf_sh_pic_plt_entry_be
[ELF_PLT_ENTRY_SIZE
] =
1642 0xd0, 0x04, /* mov.l 1f,r0 */
1643 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1644 0x40, 0x2b, /* jmp @r0 */
1645 0x00, 0x09, /* nop */
1646 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1647 0xd1, 0x03, /* mov.l 2f,r1 */
1648 0x40, 0x2b, /* jmp @r0 */
1649 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1650 0x00, 0x09, /* nop */
1651 0x00, 0x09, /* nop */
1652 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1653 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1656 static const bfd_byte elf_sh_pic_plt_entry_le
[ELF_PLT_ENTRY_SIZE
] =
1658 0x04, 0xd0, /* mov.l 1f,r0 */
1659 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1660 0x2b, 0x40, /* jmp @r0 */
1661 0x09, 0x00, /* nop */
1662 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1663 0x03, 0xd1, /* mov.l 2f,r1 */
1664 0x2b, 0x40, /* jmp @r0 */
1665 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1666 0x09, 0x00, /* nop */
1667 0x09, 0x00, /* nop */
1668 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1669 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1672 static const struct elf_sh_plt_info elf_sh_plts
[2][2] = {
1675 /* Big-endian non-PIC. */
1676 elf_sh_plt0_entry_be
,
1678 { MINUS_ONE
, 24, 20 },
1679 elf_sh_plt_entry_be
,
1681 { 20, 16, 24, FALSE
},
1686 /* Little-endian non-PIC. */
1687 elf_sh_plt0_entry_le
,
1689 { MINUS_ONE
, 24, 20 },
1690 elf_sh_plt_entry_le
,
1692 { 20, 16, 24, FALSE
},
1699 /* Big-endian PIC. */
1700 elf_sh_plt0_entry_be
,
1702 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1703 elf_sh_pic_plt_entry_be
,
1705 { 20, MINUS_ONE
, 24, FALSE
},
1710 /* Little-endian PIC. */
1711 elf_sh_plt0_entry_le
,
1713 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1714 elf_sh_pic_plt_entry_le
,
1716 { 20, MINUS_ONE
, 24, FALSE
},
1723 #define VXWORKS_PLT_HEADER_SIZE 12
1724 #define VXWORKS_PLT_ENTRY_SIZE 24
1726 static const bfd_byte vxworks_sh_plt0_entry_be
[VXWORKS_PLT_HEADER_SIZE
] =
1728 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1729 0x61, 0x12, /* mov.l @r1,r1 */
1730 0x41, 0x2b, /* jmp @r1 */
1731 0x00, 0x09, /* nop */
1732 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1735 static const bfd_byte vxworks_sh_plt0_entry_le
[VXWORKS_PLT_HEADER_SIZE
] =
1737 0x01, 0xd1, /* mov.l @(8,pc),r1 */
1738 0x12, 0x61, /* mov.l @r1,r1 */
1739 0x2b, 0x41, /* jmp @r1 */
1740 0x09, 0x00, /* nop */
1741 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1744 static const bfd_byte vxworks_sh_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1746 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1747 0x60, 0x02, /* mov.l @r0,r0 */
1748 0x40, 0x2b, /* jmp @r0 */
1749 0x00, 0x09, /* nop */
1750 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1751 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1752 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
1753 0x00, 0x09, /* nop */
1754 0x00, 0x09, /* nop */
1755 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1758 static const bfd_byte vxworks_sh_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1760 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1761 0x02, 0x60, /* mov.l @r0,r0 */
1762 0x2b, 0x40, /* jmp @r0 */
1763 0x09, 0x00, /* nop */
1764 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
1765 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1766 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
1767 0x09, 0x00, /* nop */
1768 0x09, 0x00, /* nop */
1769 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1772 static const bfd_byte vxworks_sh_pic_plt_entry_be
[VXWORKS_PLT_ENTRY_SIZE
] =
1774 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1775 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1776 0x40, 0x2b, /* jmp @r0 */
1777 0x00, 0x09, /* nop */
1778 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1779 0xd0, 0x01, /* mov.l @(8,pc),r0 */
1780 0x51, 0xc2, /* mov.l @(8,r12),r1 */
1781 0x41, 0x2b, /* jmp @r1 */
1782 0x00, 0x09, /* nop */
1783 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1786 static const bfd_byte vxworks_sh_pic_plt_entry_le
[VXWORKS_PLT_ENTRY_SIZE
] =
1788 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1789 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1790 0x2b, 0x40, /* jmp @r0 */
1791 0x09, 0x00, /* nop */
1792 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
1793 0x01, 0xd0, /* mov.l @(8,pc),r0 */
1794 0xc2, 0x51, /* mov.l @(8,r12),r1 */
1795 0x2b, 0x41, /* jmp @r1 */
1796 0x09, 0x00, /* nop */
1797 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1800 static const struct elf_sh_plt_info vxworks_sh_plts
[2][2] = {
1803 /* Big-endian non-PIC. */
1804 vxworks_sh_plt0_entry_be
,
1805 VXWORKS_PLT_HEADER_SIZE
,
1806 { MINUS_ONE
, MINUS_ONE
, 8 },
1807 vxworks_sh_plt_entry_be
,
1808 VXWORKS_PLT_ENTRY_SIZE
,
1809 { 8, 14, 20, FALSE
},
1814 /* Little-endian non-PIC. */
1815 vxworks_sh_plt0_entry_le
,
1816 VXWORKS_PLT_HEADER_SIZE
,
1817 { MINUS_ONE
, MINUS_ONE
, 8 },
1818 vxworks_sh_plt_entry_le
,
1819 VXWORKS_PLT_ENTRY_SIZE
,
1820 { 8, 14, 20, FALSE
},
1827 /* Big-endian PIC. */
1830 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1831 vxworks_sh_pic_plt_entry_be
,
1832 VXWORKS_PLT_ENTRY_SIZE
,
1833 { 8, MINUS_ONE
, 20, FALSE
},
1838 /* Little-endian PIC. */
1841 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1842 vxworks_sh_pic_plt_entry_le
,
1843 VXWORKS_PLT_ENTRY_SIZE
,
1844 { 8, MINUS_ONE
, 20, FALSE
},
1851 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
1852 binding are to omit the lazy binding stub when linking with -z now
1853 and to move lazy binding stubs into a separate region for better
1856 #define FDPIC_PLT_ENTRY_SIZE 28
1857 #define FDPIC_PLT_LAZY_OFFSET 20
1859 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
1860 duplicated if it is out of range, or which can be inlined. So
1861 right now it is always inlined, which wastes a word per stub. It
1862 might be easier to handle the duplication if we put the lazy
1863 stubs separately. */
1865 static const bfd_byte fdpic_sh_plt_entry_be
[FDPIC_PLT_ENTRY_SIZE
] =
1867 0xd0, 0x02, /* mov.l @(12,pc),r0 */
1868 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1869 0x70, 0x04, /* add #4, r0 */
1870 0x41, 0x2b, /* jmp @r1 */
1871 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1872 0x00, 0x09, /* nop */
1873 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1874 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1875 0x60, 0xc2, /* mov.l @r12,r0 */
1876 0x40, 0x2b, /* jmp @r0 */
1877 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1878 0x00, 0x09, /* nop */
1881 static const bfd_byte fdpic_sh_plt_entry_le
[FDPIC_PLT_ENTRY_SIZE
] =
1883 0x02, 0xd0, /* mov.l @(12,pc),r0 */
1884 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1885 0x04, 0x70, /* add #4, r0 */
1886 0x2b, 0x41, /* jmp @r1 */
1887 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1888 0x09, 0x00, /* nop */
1889 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
1890 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1891 0xc2, 0x60, /* mov.l @r12,r0 */
1892 0x2b, 0x40, /* jmp @r0 */
1893 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1894 0x09, 0x00, /* nop */
1897 static const struct elf_sh_plt_info fdpic_sh_plts
[2] = {
1899 /* Big-endian PIC. */
1902 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1903 fdpic_sh_plt_entry_be
,
1904 FDPIC_PLT_ENTRY_SIZE
,
1905 { 12, MINUS_ONE
, 16, FALSE
},
1906 FDPIC_PLT_LAZY_OFFSET
,
1910 /* Little-endian PIC. */
1913 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1914 fdpic_sh_plt_entry_le
,
1915 FDPIC_PLT_ENTRY_SIZE
,
1916 { 12, MINUS_ONE
, 16, FALSE
},
1917 FDPIC_PLT_LAZY_OFFSET
,
1922 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
1923 entries for the first 64K slots. We use the normal FDPIC PLT entry
1924 past that point; we could also use movi20s, which might be faster,
1925 but would not be any smaller. */
1927 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
1928 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
1930 static const bfd_byte fdpic_sh2a_plt_entry_be
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1932 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1933 0x01, 0xce, /* mov.l @(r0,r12),r1 */
1934 0x70, 0x04, /* add #4, r0 */
1935 0x41, 0x2b, /* jmp @r1 */
1936 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
1937 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1938 0x60, 0xc2, /* mov.l @r12,r0 */
1939 0x40, 0x2b, /* jmp @r0 */
1940 0x53, 0xc1, /* mov.l @(4,r12),r3 */
1941 0x00, 0x09, /* nop */
1944 static const bfd_byte fdpic_sh2a_plt_entry_le
[FDPIC_SH2A_PLT_ENTRY_SIZE
] =
1946 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
1947 0xce, 0x01, /* mov.l @(r0,r12),r1 */
1948 0x04, 0x70, /* add #4, r0 */
1949 0x2b, 0x41, /* jmp @r1 */
1950 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
1951 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
1952 0xc2, 0x60, /* mov.l @r12,r0 */
1953 0x2b, 0x40, /* jmp @r0 */
1954 0xc1, 0x53, /* mov.l @(4,r12),r3 */
1955 0x09, 0x00, /* nop */
1958 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be
= {
1959 /* Big-endian FDPIC, max index 64K. */
1962 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1963 fdpic_sh2a_plt_entry_be
,
1964 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1965 { 0, MINUS_ONE
, 12, TRUE
},
1966 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1970 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le
= {
1971 /* Little-endian FDPIC, max index 64K. */
1974 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1975 fdpic_sh2a_plt_entry_le
,
1976 FDPIC_SH2A_PLT_ENTRY_SIZE
,
1977 { 0, MINUS_ONE
, 12, TRUE
},
1978 FDPIC_SH2A_PLT_LAZY_OFFSET
,
1982 static const struct elf_sh_plt_info fdpic_sh2a_plts
[2] = {
1984 /* Big-endian PIC. */
1987 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1988 fdpic_sh_plt_entry_be
,
1989 FDPIC_PLT_ENTRY_SIZE
,
1990 { 12, MINUS_ONE
, 16, FALSE
},
1991 FDPIC_PLT_LAZY_OFFSET
,
1992 &fdpic_sh2a_short_plt_be
1995 /* Little-endian PIC. */
1998 { MINUS_ONE
, MINUS_ONE
, MINUS_ONE
},
1999 fdpic_sh_plt_entry_le
,
2000 FDPIC_PLT_ENTRY_SIZE
,
2001 { 12, MINUS_ONE
, 16, FALSE
},
2002 FDPIC_PLT_LAZY_OFFSET
,
2003 &fdpic_sh2a_short_plt_le
2007 /* Return the type of PLT associated with ABFD. PIC_P is true if
2008 the object is position-independent. */
2010 static const struct elf_sh_plt_info
*
2011 get_plt_info (bfd
*abfd
, bfd_boolean pic_p
)
2013 if (fdpic_object_p (abfd
))
2015 /* If any input file requires SH2A we can use a shorter PLT
2017 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd
)) & arch_sh2a_base
)
2018 return &fdpic_sh2a_plts
[!bfd_big_endian (abfd
)];
2020 return &fdpic_sh_plts
[!bfd_big_endian (abfd
)];
2022 if (vxworks_object_p (abfd
))
2023 return &vxworks_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2024 return &elf_sh_plts
[pic_p
][!bfd_big_endian (abfd
)];
2027 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2028 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2032 install_plt_field (bfd
*output_bfd
, bfd_boolean code_p ATTRIBUTE_UNUSED
,
2033 unsigned long value
, bfd_byte
*addr
)
2035 bfd_put_32 (output_bfd
, value
, addr
);
2038 /* The number of PLT entries which can use a shorter PLT, if any.
2039 Currently always 64K, since only SH-2A FDPIC uses this; a
2040 20-bit movi20 can address that many function descriptors below
2041 _GLOBAL_OFFSET_TABLE_. */
2042 #define MAX_SHORT_PLT 65536
2044 /* Return the index of the PLT entry at byte offset OFFSET. */
2047 get_plt_index (const struct elf_sh_plt_info
*info
, bfd_vma offset
)
2049 bfd_vma plt_index
= 0;
2051 offset
-= info
->plt0_entry_size
;
2052 if (info
->short_plt
!= NULL
)
2054 if (offset
> MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
)
2056 plt_index
= MAX_SHORT_PLT
;
2057 offset
-= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2060 info
= info
->short_plt
;
2062 return plt_index
+ offset
/ info
->symbol_entry_size
;
2065 /* Do the inverse operation. */
2068 get_plt_offset (const struct elf_sh_plt_info
*info
, bfd_vma plt_index
)
2072 if (info
->short_plt
!= NULL
)
2074 if (plt_index
> MAX_SHORT_PLT
)
2076 offset
= MAX_SHORT_PLT
* info
->short_plt
->symbol_entry_size
;
2077 plt_index
-= MAX_SHORT_PLT
;
2080 info
= info
->short_plt
;
2082 return (offset
+ info
->plt0_entry_size
2083 + (plt_index
* info
->symbol_entry_size
));
2088 bfd_signed_vma refcount
;
2092 /* sh ELF linker hash entry. */
2094 struct elf_sh_link_hash_entry
2096 struct elf_link_hash_entry root
;
2098 bfd_signed_vma gotplt_refcount
;
2100 /* A local function descriptor, for FDPIC. The refcount counts
2101 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2102 relocations; the PLT and GOT entry are accounted
2103 for separately. After adjust_dynamic_symbol, the offset is
2104 MINUS_ONE if there is no local descriptor (dynamic linker
2105 managed and no PLT entry, or undefined weak non-dynamic).
2106 During check_relocs we do not yet know whether the local
2107 descriptor will be canonical. */
2108 union gotref funcdesc
;
2110 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2111 and thus require fixups or relocations. */
2112 bfd_signed_vma abs_funcdesc_refcount
;
2115 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
, GOT_FUNCDESC
2119 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2121 struct sh_elf_obj_tdata
2123 struct elf_obj_tdata root
;
2125 /* got_type for each local got entry. */
2126 char *local_got_type
;
2128 /* Function descriptor refcount and offset for each local symbol. */
2129 union gotref
*local_funcdesc
;
2132 #define sh_elf_tdata(abfd) \
2133 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2135 #define sh_elf_local_got_type(abfd) \
2136 (sh_elf_tdata (abfd)->local_got_type)
2138 #define sh_elf_local_funcdesc(abfd) \
2139 (sh_elf_tdata (abfd)->local_funcdesc)
2141 #define is_sh_elf(bfd) \
2142 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2143 && elf_tdata (bfd) != NULL \
2144 && elf_object_id (bfd) == SH_ELF_DATA)
2146 /* Override the generic function because we need to store sh_elf_obj_tdata
2147 as the specific tdata. */
2150 sh_elf_mkobject (bfd
*abfd
)
2152 return bfd_elf_allocate_object (abfd
, sizeof (struct sh_elf_obj_tdata
),
2156 /* sh ELF linker hash table. */
2158 struct elf_sh_link_hash_table
2160 struct elf_link_hash_table root
;
2162 /* Short-cuts to get to dynamic linker sections. */
2165 asection
*sfuncdesc
;
2166 asection
*srelfuncdesc
;
2169 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2172 /* Small local sym cache. */
2173 struct sym_cache sym_cache
;
2175 /* A counter or offset to track a TLS got entry. */
2178 bfd_signed_vma refcount
;
2182 /* The type of PLT to use. */
2183 const struct elf_sh_plt_info
*plt_info
;
2185 /* True if the target system uses FDPIC. */
2186 bfd_boolean fdpic_p
;
2189 /* Traverse an sh ELF linker hash table. */
2191 #define sh_elf_link_hash_traverse(table, func, info) \
2192 (elf_link_hash_traverse \
2194 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2197 /* Get the sh ELF linker hash table from a link_info structure. */
2199 #define sh_elf_hash_table(p) \
2200 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2201 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2203 /* Create an entry in an sh ELF linker hash table. */
2205 static struct bfd_hash_entry
*
2206 sh_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
2207 struct bfd_hash_table
*table
,
2210 struct elf_sh_link_hash_entry
*ret
=
2211 (struct elf_sh_link_hash_entry
*) entry
;
2213 /* Allocate the structure if it has not already been allocated by a
2215 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2216 ret
= ((struct elf_sh_link_hash_entry
*)
2217 bfd_hash_allocate (table
,
2218 sizeof (struct elf_sh_link_hash_entry
)));
2219 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2220 return (struct bfd_hash_entry
*) ret
;
2222 /* Call the allocation method of the superclass. */
2223 ret
= ((struct elf_sh_link_hash_entry
*)
2224 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2226 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2228 ret
->gotplt_refcount
= 0;
2229 ret
->funcdesc
.refcount
= 0;
2230 ret
->abs_funcdesc_refcount
= 0;
2231 ret
->got_type
= GOT_UNKNOWN
;
2234 return (struct bfd_hash_entry
*) ret
;
2237 /* Create an sh ELF linker hash table. */
2239 static struct bfd_link_hash_table
*
2240 sh_elf_link_hash_table_create (bfd
*abfd
)
2242 struct elf_sh_link_hash_table
*ret
;
2243 size_t amt
= sizeof (struct elf_sh_link_hash_table
);
2245 ret
= (struct elf_sh_link_hash_table
*) bfd_zmalloc (amt
);
2246 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2249 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2250 sh_elf_link_hash_newfunc
,
2251 sizeof (struct elf_sh_link_hash_entry
),
2258 if (fdpic_object_p (abfd
))
2260 ret
->root
.dt_pltgot_required
= TRUE
;
2261 ret
->fdpic_p
= TRUE
;
2264 return &ret
->root
.root
;
2268 sh_elf_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2269 struct bfd_link_info
*info
, asection
*p
)
2271 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
2273 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2277 /* We need dynamic symbols for every section, since segments can
2278 relocate independently. */
2279 switch (elf_section_data (p
)->this_hdr
.sh_type
)
2283 /* If sh_type is yet undecided, assume it could be
2284 SHT_PROGBITS/SHT_NOBITS. */
2288 /* There shouldn't be section relative relocations
2289 against any other section. */
2295 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2296 shortcuts to them in our hash table. */
2299 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
2301 struct elf_sh_link_hash_table
*htab
;
2303 if (! _bfd_elf_create_got_section (dynobj
, info
))
2306 htab
= sh_elf_hash_table (info
);
2310 htab
->sfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.funcdesc",
2311 (SEC_ALLOC
| SEC_LOAD
2314 | SEC_LINKER_CREATED
));
2315 if (htab
->sfuncdesc
== NULL
2316 || !bfd_set_section_alignment (htab
->sfuncdesc
, 2))
2319 htab
->srelfuncdesc
= bfd_make_section_anyway_with_flags (dynobj
,
2320 ".rela.got.funcdesc",
2321 (SEC_ALLOC
| SEC_LOAD
2324 | SEC_LINKER_CREATED
2326 if (htab
->srelfuncdesc
== NULL
2327 || !bfd_set_section_alignment (htab
->srelfuncdesc
, 2))
2330 /* Also create .rofixup. */
2331 htab
->srofixup
= bfd_make_section_anyway_with_flags (dynobj
, ".rofixup",
2332 (SEC_ALLOC
| SEC_LOAD
2335 | SEC_LINKER_CREATED
2337 if (htab
->srofixup
== NULL
2338 || !bfd_set_section_alignment (htab
->srofixup
, 2))
2344 /* Create dynamic sections when linking against a dynamic object. */
2347 sh_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2349 struct elf_sh_link_hash_table
*htab
;
2350 flagword flags
, pltflags
;
2352 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2355 switch (bed
->s
->arch_size
)
2366 bfd_set_error (bfd_error_bad_value
);
2370 htab
= sh_elf_hash_table (info
);
2374 if (htab
->root
.dynamic_sections_created
)
2377 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2378 .rel[a].bss sections. */
2380 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2381 | SEC_LINKER_CREATED
);
2384 pltflags
|= SEC_CODE
;
2385 if (bed
->plt_not_loaded
)
2386 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2387 if (bed
->plt_readonly
)
2388 pltflags
|= SEC_READONLY
;
2390 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2391 htab
->root
.splt
= s
;
2393 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2396 if (bed
->want_plt_sym
)
2398 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2400 struct elf_link_hash_entry
*h
;
2401 struct bfd_link_hash_entry
*bh
= NULL
;
2403 if (! (_bfd_generic_link_add_one_symbol
2404 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2405 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2406 get_elf_backend_data (abfd
)->collect
, &bh
)))
2409 h
= (struct elf_link_hash_entry
*) bh
;
2411 h
->type
= STT_OBJECT
;
2412 htab
->root
.hplt
= h
;
2414 if (bfd_link_pic (info
)
2415 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2419 s
= bfd_make_section_anyway_with_flags (abfd
,
2420 bed
->default_use_rela_p
2421 ? ".rela.plt" : ".rel.plt",
2422 flags
| SEC_READONLY
);
2423 htab
->root
.srelplt
= s
;
2425 || !bfd_set_section_alignment (s
, ptralign
))
2428 if (htab
->root
.sgot
== NULL
2429 && !create_got_section (abfd
, info
))
2432 if (bed
->want_dynbss
)
2434 /* The .dynbss section is a place to put symbols which are defined
2435 by dynamic objects, are referenced by regular objects, and are
2436 not functions. We must allocate space for them in the process
2437 image and use a R_*_COPY reloc to tell the dynamic linker to
2438 initialize them at run time. The linker script puts the .dynbss
2439 section into the .bss section of the final image. */
2440 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2441 SEC_ALLOC
| SEC_LINKER_CREATED
);
2446 /* The .rel[a].bss section holds copy relocs. This section is not
2447 normally needed. We need to create it here, though, so that the
2448 linker will map it to an output section. We can't just create it
2449 only if we need it, because we will not know whether we need it
2450 until we have seen all the input files, and the first time the
2451 main linker code calls BFD after examining all the input files
2452 (size_dynamic_sections) the input sections have already been
2453 mapped to the output sections. If the section turns out not to
2454 be needed, we can discard it later. We will never need this
2455 section when generating a shared object, since they do not use
2457 if (! bfd_link_pic (info
))
2459 s
= bfd_make_section_anyway_with_flags (abfd
,
2460 (bed
->default_use_rela_p
2461 ? ".rela.bss" : ".rel.bss"),
2462 flags
| SEC_READONLY
);
2465 || !bfd_set_section_alignment (s
, ptralign
))
2470 if (htab
->root
.target_os
== is_vxworks
)
2472 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
2479 /* Adjust a symbol defined by a dynamic object and referenced by a
2480 regular object. The current definition is in some section of the
2481 dynamic object, but we're not including those sections. We have to
2482 change the definition to something the rest of the link can
2486 sh_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2487 struct elf_link_hash_entry
*h
)
2489 struct elf_sh_link_hash_table
*htab
;
2492 htab
= sh_elf_hash_table (info
);
2496 /* Make sure we know what is going on here. */
2497 BFD_ASSERT (htab
->root
.dynobj
!= NULL
2502 && !h
->def_regular
)));
2504 /* If this is a function, put it in the procedure linkage table. We
2505 will fill in the contents of the procedure linkage table later,
2506 when we know the address of the .got section. */
2507 if (h
->type
== STT_FUNC
2510 if (h
->plt
.refcount
<= 0
2511 || SYMBOL_CALLS_LOCAL (info
, h
)
2512 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2513 && h
->root
.type
== bfd_link_hash_undefweak
))
2515 /* This case can occur if we saw a PLT reloc in an input
2516 file, but the symbol was never referred to by a dynamic
2517 object. In such a case, we don't actually need to build
2518 a procedure linkage table, and we can just do a REL32
2520 h
->plt
.offset
= (bfd_vma
) -1;
2527 h
->plt
.offset
= (bfd_vma
) -1;
2529 /* If this is a weak symbol, and there is a real definition, the
2530 processor independent code will have arranged for us to see the
2531 real definition first, and we can just use the same value. */
2532 if (h
->is_weakalias
)
2534 struct elf_link_hash_entry
*def
= weakdef (h
);
2535 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2536 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2537 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2538 if (info
->nocopyreloc
)
2539 h
->non_got_ref
= def
->non_got_ref
;
2543 /* This is a reference to a symbol defined by a dynamic object which
2544 is not a function. */
2546 /* If we are creating a shared library, we must presume that the
2547 only references to the symbol are via the global offset table.
2548 For such cases we need not do anything here; the relocations will
2549 be handled correctly by relocate_section. */
2550 if (bfd_link_pic (info
))
2553 /* If there are no references to this symbol that do not use the
2554 GOT, we don't need to generate a copy reloc. */
2555 if (!h
->non_got_ref
)
2558 /* If -z nocopyreloc was given, we won't generate them either. */
2559 if (0 && info
->nocopyreloc
)
2565 /* If we don't find any dynamic relocs in read-only sections, then
2566 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2567 if (0 && !_bfd_elf_readonly_dynrelocs (h
))
2573 /* We must allocate the symbol in our .dynbss section, which will
2574 become part of the .bss section of the executable. There will be
2575 an entry for this symbol in the .dynsym section. The dynamic
2576 object will contain position independent code, so all references
2577 from the dynamic object to this symbol will go through the global
2578 offset table. The dynamic linker will use the .dynsym entry to
2579 determine the address it must put in the global offset table, so
2580 both the dynamic object and the regular object will refer to the
2581 same memory location for the variable. */
2584 BFD_ASSERT (s
!= NULL
);
2586 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2587 copy the initial value out of the dynamic object and into the
2588 runtime process image. We need to remember the offset into the
2589 .rela.bss section we are going to use. */
2590 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2594 srel
= htab
->srelbss
;
2595 BFD_ASSERT (srel
!= NULL
);
2596 srel
->size
+= sizeof (Elf32_External_Rela
);
2600 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2603 /* Allocate space in .plt, .got and associated reloc sections for
2607 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2609 struct bfd_link_info
*info
;
2610 struct elf_sh_link_hash_table
*htab
;
2611 struct elf_sh_link_hash_entry
*eh
;
2612 struct elf_dyn_relocs
*p
;
2614 if (h
->root
.type
== bfd_link_hash_indirect
)
2617 info
= (struct bfd_link_info
*) inf
;
2618 htab
= sh_elf_hash_table (info
);
2622 eh
= (struct elf_sh_link_hash_entry
*) h
;
2623 if ((h
->got
.refcount
> 0
2625 && eh
->gotplt_refcount
> 0)
2627 /* The symbol has been forced local, or we have some direct got refs,
2628 so treat all the gotplt refs as got refs. */
2629 h
->got
.refcount
+= eh
->gotplt_refcount
;
2630 if (h
->plt
.refcount
>= eh
->gotplt_refcount
)
2631 h
->plt
.refcount
-= eh
->gotplt_refcount
;
2634 if (htab
->root
.dynamic_sections_created
2635 && h
->plt
.refcount
> 0
2636 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2637 || h
->root
.type
!= bfd_link_hash_undefweak
))
2639 /* Make sure this symbol is output as a dynamic symbol.
2640 Undefined weak syms won't yet be marked as dynamic. */
2641 if (h
->dynindx
== -1
2642 && !h
->forced_local
)
2644 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2648 if (bfd_link_pic (info
)
2649 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2651 asection
*s
= htab
->root
.splt
;
2652 const struct elf_sh_plt_info
*plt_info
;
2654 /* If this is the first .plt entry, make room for the special
2657 s
->size
+= htab
->plt_info
->plt0_entry_size
;
2659 h
->plt
.offset
= s
->size
;
2661 /* If this symbol is not defined in a regular file, and we are
2662 not generating a shared library, then set the symbol to this
2663 location in the .plt. This is required to make function
2664 pointers compare as equal between the normal executable and
2665 the shared library. Skip this for FDPIC, since the
2666 function's address will be the address of the canonical
2667 function descriptor. */
2668 if (!htab
->fdpic_p
&& !bfd_link_pic (info
) && !h
->def_regular
)
2670 h
->root
.u
.def
.section
= s
;
2671 h
->root
.u
.def
.value
= h
->plt
.offset
;
2674 /* Make room for this entry. */
2675 plt_info
= htab
->plt_info
;
2676 if (plt_info
->short_plt
!= NULL
2677 && (get_plt_index (plt_info
->short_plt
, s
->size
) < MAX_SHORT_PLT
))
2678 plt_info
= plt_info
->short_plt
;
2679 s
->size
+= plt_info
->symbol_entry_size
;
2681 /* We also need to make an entry in the .got.plt section, which
2682 will be placed in the .got section by the linker script. */
2684 htab
->root
.sgotplt
->size
+= 4;
2686 htab
->root
.sgotplt
->size
+= 8;
2688 /* We also need to make an entry in the .rel.plt section. */
2689 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
2691 if (htab
->root
.target_os
== is_vxworks
&& !bfd_link_pic (info
))
2693 /* VxWorks executables have a second set of relocations
2694 for each PLT entry. They go in a separate relocation
2695 section, which is processed by the kernel loader. */
2697 /* There is a relocation for the initial PLT entry:
2698 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
2699 if (h
->plt
.offset
== htab
->plt_info
->plt0_entry_size
)
2700 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
);
2702 /* There are two extra relocations for each subsequent
2703 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2704 and an R_SH_DIR32 relocation for the PLT entry. */
2705 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 2;
2710 h
->plt
.offset
= (bfd_vma
) -1;
2716 h
->plt
.offset
= (bfd_vma
) -1;
2720 if (h
->got
.refcount
> 0)
2724 enum got_type got_type
= sh_elf_hash_entry (h
)->got_type
;
2726 /* Make sure this symbol is output as a dynamic symbol.
2727 Undefined weak syms won't yet be marked as dynamic. */
2728 if (h
->dynindx
== -1
2729 && !h
->forced_local
)
2731 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2735 s
= htab
->root
.sgot
;
2736 h
->got
.offset
= s
->size
;
2738 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
2739 if (got_type
== GOT_TLS_GD
)
2741 dyn
= htab
->root
.dynamic_sections_created
;
2744 /* No dynamic relocations required. */
2745 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
2746 && h
->root
.type
!= bfd_link_hash_undefweak
2747 && (got_type
== GOT_NORMAL
|| got_type
== GOT_FUNCDESC
))
2748 htab
->srofixup
->size
+= 4;
2750 /* No dynamic relocations required when IE->LE conversion happens. */
2751 else if (got_type
== GOT_TLS_IE
2753 && !bfd_link_pic (info
))
2755 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2756 R_SH_TLS_GD needs one if local symbol and two if global. */
2757 else if ((got_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2758 || got_type
== GOT_TLS_IE
)
2759 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2760 else if (got_type
== GOT_TLS_GD
)
2761 htab
->root
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2762 else if (got_type
== GOT_FUNCDESC
)
2764 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2765 htab
->srofixup
->size
+= 4;
2767 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2769 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2770 || h
->root
.type
!= bfd_link_hash_undefweak
)
2771 && (bfd_link_pic (info
)
2772 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2773 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2774 else if (htab
->fdpic_p
2775 && !bfd_link_pic (info
)
2776 && got_type
== GOT_NORMAL
2777 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2778 || h
->root
.type
!= bfd_link_hash_undefweak
))
2779 htab
->srofixup
->size
+= 4;
2782 h
->got
.offset
= (bfd_vma
) -1;
2784 /* Allocate space for any dynamic relocations to function
2785 descriptors, canonical or otherwise. We need to relocate the
2786 reference unless it resolves to zero, which only happens for
2787 undefined weak symbols (either non-default visibility, or when
2788 static linking). Any GOT slot is accounted for elsewhere. */
2789 if (eh
->abs_funcdesc_refcount
> 0
2790 && (h
->root
.type
!= bfd_link_hash_undefweak
2791 || (htab
->root
.dynamic_sections_created
2792 && ! SYMBOL_CALLS_LOCAL (info
, h
))))
2794 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2795 htab
->srofixup
->size
+= eh
->abs_funcdesc_refcount
* 4;
2797 htab
->root
.srelgot
->size
2798 += eh
->abs_funcdesc_refcount
* sizeof (Elf32_External_Rela
);
2801 /* We must allocate a function descriptor if there are references to
2802 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
2803 the dynamic linker isn't going to allocate it. None of this
2804 applies if we already created one in .got.plt, but if the
2805 canonical function descriptor can be in this object, there
2806 won't be a PLT entry at all. */
2807 if ((eh
->funcdesc
.refcount
> 0
2808 || (h
->got
.offset
!= MINUS_ONE
&& eh
->got_type
== GOT_FUNCDESC
))
2809 && h
->root
.type
!= bfd_link_hash_undefweak
2810 && SYMBOL_FUNCDESC_LOCAL (info
, h
))
2812 /* Make room for this function descriptor. */
2813 eh
->funcdesc
.offset
= htab
->sfuncdesc
->size
;
2814 htab
->sfuncdesc
->size
+= 8;
2816 /* We will need a relocation or two fixups to initialize the
2817 function descriptor, so allocate those too. */
2818 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
2819 htab
->srofixup
->size
+= 8;
2821 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
2824 if (h
->dyn_relocs
== NULL
)
2827 /* In the shared -Bsymbolic case, discard space allocated for
2828 dynamic pc-relative relocs against symbols which turn out to be
2829 defined in regular objects. For the normal shared case, discard
2830 space for pc-relative relocs that have become local due to symbol
2831 visibility changes. */
2833 if (bfd_link_pic (info
))
2835 if (SYMBOL_CALLS_LOCAL (info
, h
))
2837 struct elf_dyn_relocs
**pp
;
2839 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
2841 p
->count
-= p
->pc_count
;
2850 if (htab
->root
.target_os
== is_vxworks
)
2852 struct elf_dyn_relocs
**pp
;
2854 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
2856 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2863 /* Also discard relocs on undefined weak syms with non-default
2865 if (h
->dyn_relocs
!= NULL
2866 && h
->root
.type
== bfd_link_hash_undefweak
)
2868 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2869 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2870 h
->dyn_relocs
= NULL
;
2872 /* Make sure undefined weak symbols are output as a dynamic
2874 else if (h
->dynindx
== -1
2875 && !h
->forced_local
)
2877 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2884 /* For the non-shared case, discard space for relocs against
2885 symbols which turn out to need copy relocs or are not
2891 || (htab
->root
.dynamic_sections_created
2892 && (h
->root
.type
== bfd_link_hash_undefweak
2893 || h
->root
.type
== bfd_link_hash_undefined
))))
2895 /* Make sure this symbol is output as a dynamic symbol.
2896 Undefined weak syms won't yet be marked as dynamic. */
2897 if (h
->dynindx
== -1
2898 && !h
->forced_local
)
2900 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2904 /* If that succeeded, we know we'll be keeping all the
2906 if (h
->dynindx
!= -1)
2910 h
->dyn_relocs
= NULL
;
2915 /* Finally, allocate space. */
2916 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2918 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2919 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2921 /* If we need relocations, we do not need fixups. */
2922 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
2923 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
2929 /* This function is called after all the input files have been read,
2930 and the input sections have been assigned to output sections.
2931 It's a convenient place to determine the PLT style. */
2934 sh_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2936 sh_elf_hash_table (info
)->plt_info
= get_plt_info (output_bfd
,
2937 bfd_link_pic (info
));
2939 if (sh_elf_hash_table (info
)->fdpic_p
&& !bfd_link_relocatable (info
)
2940 && !bfd_elf_stack_segment_size (output_bfd
, info
,
2941 "__stacksize", DEFAULT_STACK_SIZE
))
2946 /* Set the sizes of the dynamic sections. */
2949 sh_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2950 struct bfd_link_info
*info
)
2952 struct elf_sh_link_hash_table
*htab
;
2958 htab
= sh_elf_hash_table (info
);
2962 dynobj
= htab
->root
.dynobj
;
2963 BFD_ASSERT (dynobj
!= NULL
);
2965 if (htab
->root
.dynamic_sections_created
)
2967 /* Set the contents of the .interp section to the interpreter. */
2968 if (bfd_link_executable (info
) && !info
->nointerp
)
2970 s
= bfd_get_linker_section (dynobj
, ".interp");
2971 BFD_ASSERT (s
!= NULL
);
2972 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2973 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2977 /* Set up .got offsets for local syms, and space for local dynamic
2979 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2981 bfd_signed_vma
*local_got
;
2982 bfd_signed_vma
*end_local_got
;
2983 union gotref
*local_funcdesc
, *end_local_funcdesc
;
2984 char *local_got_type
;
2985 bfd_size_type locsymcount
;
2986 Elf_Internal_Shdr
*symtab_hdr
;
2989 if (! is_sh_elf (ibfd
))
2992 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2994 struct elf_dyn_relocs
*p
;
2996 for (p
= ((struct elf_dyn_relocs
*)
2997 elf_section_data (s
)->local_dynrel
);
3001 if (! bfd_is_abs_section (p
->sec
)
3002 && bfd_is_abs_section (p
->sec
->output_section
))
3004 /* Input section has been discarded, either because
3005 it is a copy of a linkonce section or due to
3006 linker script /DISCARD/, so we'll be discarding
3009 else if (htab
->root
.target_os
== is_vxworks
3010 && strcmp (p
->sec
->output_section
->name
,
3013 /* Relocations in vxworks .tls_vars sections are
3014 handled specially by the loader. */
3016 else if (p
->count
!= 0)
3018 srel
= elf_section_data (p
->sec
)->sreloc
;
3019 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
3020 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
3022 info
->flags
|= DF_TEXTREL
;
3023 info
->callbacks
->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
3024 p
->sec
->owner
, p
->sec
);
3027 /* If we need relocations, we do not need fixups. */
3028 if (htab
->fdpic_p
&& !bfd_link_pic (info
))
3029 htab
->srofixup
->size
-= 4 * (p
->count
- p
->pc_count
);
3034 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3035 locsymcount
= symtab_hdr
->sh_info
;
3036 s
= htab
->root
.sgot
;
3037 srel
= htab
->root
.srelgot
;
3039 local_got
= elf_local_got_refcounts (ibfd
);
3042 end_local_got
= local_got
+ locsymcount
;
3043 local_got_type
= sh_elf_local_got_type (ibfd
);
3044 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3045 for (; local_got
< end_local_got
; ++local_got
)
3049 *local_got
= s
->size
;
3051 if (*local_got_type
== GOT_TLS_GD
)
3053 if (bfd_link_pic (info
))
3054 srel
->size
+= sizeof (Elf32_External_Rela
);
3056 htab
->srofixup
->size
+= 4;
3058 if (*local_got_type
== GOT_FUNCDESC
)
3060 if (local_funcdesc
== NULL
)
3064 size
= locsymcount
* sizeof (union gotref
);
3065 local_funcdesc
= (union gotref
*) bfd_zalloc (ibfd
,
3067 if (local_funcdesc
== NULL
)
3069 sh_elf_local_funcdesc (ibfd
) = local_funcdesc
;
3070 local_funcdesc
+= (local_got
3071 - elf_local_got_refcounts (ibfd
));
3073 local_funcdesc
->refcount
++;
3078 *local_got
= (bfd_vma
) -1;
3083 local_funcdesc
= sh_elf_local_funcdesc (ibfd
);
3086 end_local_funcdesc
= local_funcdesc
+ locsymcount
;
3088 for (; local_funcdesc
< end_local_funcdesc
; ++local_funcdesc
)
3090 if (local_funcdesc
->refcount
> 0)
3092 local_funcdesc
->offset
= htab
->sfuncdesc
->size
;
3093 htab
->sfuncdesc
->size
+= 8;
3094 if (!bfd_link_pic (info
))
3095 htab
->srofixup
->size
+= 8;
3097 htab
->srelfuncdesc
->size
+= sizeof (Elf32_External_Rela
);
3100 local_funcdesc
->offset
= MINUS_ONE
;
3106 if (htab
->tls_ldm_got
.refcount
> 0)
3108 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3110 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
3111 htab
->root
.sgot
->size
+= 8;
3112 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
3115 htab
->tls_ldm_got
.offset
= -1;
3117 /* Only the reserved entries should be present. For FDPIC, they go at
3118 the end of .got.plt. */
3121 BFD_ASSERT (htab
->root
.sgotplt
&& htab
->root
.sgotplt
->size
== 12);
3122 htab
->root
.sgotplt
->size
= 0;
3125 /* Allocate global sym .plt and .got entries, and space for global
3126 sym dynamic relocs. */
3127 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
3129 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3130 end of the FDPIC .got.plt. */
3133 htab
->root
.hgot
->root
.u
.def
.value
= htab
->root
.sgotplt
->size
;
3134 htab
->root
.sgotplt
->size
+= 12;
3137 /* At the very end of the .rofixup section is a pointer to the GOT. */
3138 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
3139 htab
->srofixup
->size
+= 4;
3141 /* We now have determined the sizes of the various dynamic sections.
3142 Allocate memory for them. */
3144 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3146 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3149 if (s
== htab
->root
.splt
3150 || s
== htab
->root
.sgot
3151 || s
== htab
->root
.sgotplt
3152 || s
== htab
->sfuncdesc
3153 || s
== htab
->srofixup
3154 || s
== htab
->sdynbss
)
3156 /* Strip this section if we don't need it; see the
3159 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
3161 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
&& s
!= htab
->srelplt2
)
3164 /* We use the reloc_count field as a counter if we need
3165 to copy relocs into the output file. */
3170 /* It's not one of our sections, so don't allocate space. */
3176 /* If we don't need this section, strip it from the
3177 output file. This is mostly to handle .rela.bss and
3178 .rela.plt. We must create both sections in
3179 create_dynamic_sections, because they must be created
3180 before the linker maps input sections to output
3181 sections. The linker does that before
3182 adjust_dynamic_symbol is called, and it is that
3183 function which decides whether anything needs to go
3184 into these sections. */
3186 s
->flags
|= SEC_EXCLUDE
;
3190 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3193 /* Allocate memory for the section contents. We use bfd_zalloc
3194 here in case unused entries are not reclaimed before the
3195 section's contents are written out. This should not happen,
3196 but this way if it does, we get a R_SH_NONE reloc instead
3198 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3199 if (s
->contents
== NULL
)
3203 return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd
, info
,
3207 /* Add a dynamic relocation to the SRELOC section. */
3209 inline static bfd_vma
3210 sh_elf_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
3211 int reloc_type
, long dynindx
, bfd_vma addend
)
3213 Elf_Internal_Rela outrel
;
3214 bfd_vma reloc_offset
;
3216 outrel
.r_offset
= offset
;
3217 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
3218 outrel
.r_addend
= addend
;
3220 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
3221 BFD_ASSERT (reloc_offset
< sreloc
->size
);
3222 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3223 sreloc
->contents
+ reloc_offset
);
3224 sreloc
->reloc_count
++;
3226 return reloc_offset
;
3229 /* Add an FDPIC read-only fixup. */
3232 sh_elf_add_rofixup (bfd
*output_bfd
, asection
*srofixup
, bfd_vma offset
)
3234 bfd_vma fixup_offset
;
3236 fixup_offset
= srofixup
->reloc_count
++ * 4;
3237 BFD_ASSERT (fixup_offset
< srofixup
->size
);
3238 bfd_put_32 (output_bfd
, offset
, srofixup
->contents
+ fixup_offset
);
3241 /* Return the offset of the generated .got section from the
3242 _GLOBAL_OFFSET_TABLE_ symbol. */
3244 static bfd_signed_vma
3245 sh_elf_got_offset (struct elf_sh_link_hash_table
*htab
)
3247 return (htab
->root
.sgot
->output_offset
- htab
->root
.sgotplt
->output_offset
3248 - htab
->root
.hgot
->root
.u
.def
.value
);
3251 /* Find the segment number in which OSEC, and output section, is
3255 sh_elf_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
3257 Elf_Internal_Phdr
*p
= NULL
;
3259 if (output_bfd
->xvec
->flavour
== bfd_target_elf_flavour
3260 /* PR ld/17110: Do not look for output segments in an input bfd. */
3261 && output_bfd
->direction
!= read_direction
)
3262 p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
3264 /* FIXME: Nothing ever says what this index is relative to. The kernel
3265 supplies data in terms of the number of load segments but this is
3266 a phdr index and the first phdr may not be a load segment. */
3267 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
3271 sh_elf_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
3273 unsigned seg
= sh_elf_osec_to_segment (output_bfd
, osec
);
3275 return (seg
!= (unsigned) -1
3276 && ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
));
3279 /* Generate the initial contents of a local function descriptor, along
3280 with any relocations or fixups required. */
3282 sh_elf_initialize_funcdesc (bfd
*output_bfd
,
3283 struct bfd_link_info
*info
,
3284 struct elf_link_hash_entry
*h
,
3289 struct elf_sh_link_hash_table
*htab
;
3293 htab
= sh_elf_hash_table (info
);
3295 /* FIXME: The ABI says that the offset to the function goes in the
3296 descriptor, along with the segment index. We're RELA, so it could
3297 go in the reloc instead... */
3299 if (h
!= NULL
&& SYMBOL_CALLS_LOCAL (info
, h
))
3301 section
= h
->root
.u
.def
.section
;
3302 value
= h
->root
.u
.def
.value
;
3305 if (h
== NULL
|| SYMBOL_CALLS_LOCAL (info
, h
))
3307 dynindx
= elf_section_data (section
->output_section
)->dynindx
;
3308 addr
= value
+ section
->output_offset
;
3309 seg
= sh_elf_osec_to_segment (output_bfd
, section
->output_section
);
3313 BFD_ASSERT (h
->dynindx
!= -1);
3314 dynindx
= h
->dynindx
;
3318 if (!bfd_link_pic (info
) && SYMBOL_CALLS_LOCAL (info
, h
))
3320 if (h
== NULL
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3322 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3324 + htab
->sfuncdesc
->output_section
->vma
3325 + htab
->sfuncdesc
->output_offset
);
3326 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3328 + htab
->sfuncdesc
->output_section
->vma
3329 + htab
->sfuncdesc
->output_offset
);
3332 /* There are no dynamic relocations so fill in the final
3333 address and gp value (barring fixups). */
3334 addr
+= section
->output_section
->vma
;
3335 seg
= htab
->root
.hgot
->root
.u
.def
.value
3336 + htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3337 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
;
3340 sh_elf_add_dyn_reloc (output_bfd
, htab
->srelfuncdesc
,
3342 + htab
->sfuncdesc
->output_section
->vma
3343 + htab
->sfuncdesc
->output_offset
,
3344 R_SH_FUNCDESC_VALUE
, dynindx
, 0);
3346 bfd_put_32 (output_bfd
, addr
, htab
->sfuncdesc
->contents
+ offset
);
3347 bfd_put_32 (output_bfd
, seg
, htab
->sfuncdesc
->contents
+ offset
+ 4);
3352 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3353 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3356 static bfd_reloc_status_type
3357 install_movi20_field (bfd
*output_bfd
, unsigned long relocation
,
3358 bfd
*input_bfd
, asection
*input_section
,
3359 bfd_byte
*contents
, bfd_vma offset
)
3361 unsigned long cur_val
;
3363 bfd_reloc_status_type r
;
3365 if (offset
> bfd_get_section_limit (input_bfd
, input_section
))
3366 return bfd_reloc_outofrange
;
3368 r
= bfd_check_overflow (complain_overflow_signed
, 20, 0,
3369 bfd_arch_bits_per_address (input_bfd
), relocation
);
3370 if (r
!= bfd_reloc_ok
)
3373 addr
= contents
+ offset
;
3374 cur_val
= bfd_get_16 (output_bfd
, addr
);
3375 bfd_put_16 (output_bfd
, cur_val
| ((relocation
& 0xf0000) >> 12), addr
);
3376 bfd_put_16 (output_bfd
, relocation
& 0xffff, addr
+ 2);
3378 return bfd_reloc_ok
;
3381 /* Relocate an SH ELF section. */
3384 sh_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
3385 bfd
*input_bfd
, asection
*input_section
,
3386 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
3387 Elf_Internal_Sym
*local_syms
,
3388 asection
**local_sections
)
3390 struct elf_sh_link_hash_table
*htab
;
3391 Elf_Internal_Shdr
*symtab_hdr
;
3392 struct elf_link_hash_entry
**sym_hashes
;
3393 Elf_Internal_Rela
*rel
, *relend
;
3394 bfd_vma
*local_got_offsets
;
3395 asection
*sgot
= NULL
;
3396 asection
*sgotplt
= NULL
;
3397 asection
*splt
= NULL
;
3398 asection
*sreloc
= NULL
;
3399 asection
*srelgot
= NULL
;
3400 bfd_boolean is_vxworks_tls
;
3401 unsigned isec_segment
, got_segment
, plt_segment
, check_segment
[2];
3402 bfd_boolean fdpic_p
= FALSE
;
3404 if (!is_sh_elf (input_bfd
))
3406 bfd_set_error (bfd_error_wrong_format
);
3410 htab
= sh_elf_hash_table (info
);
3413 sgot
= htab
->root
.sgot
;
3414 sgotplt
= htab
->root
.sgotplt
;
3415 srelgot
= htab
->root
.srelgot
;
3416 splt
= htab
->root
.splt
;
3417 fdpic_p
= htab
->fdpic_p
;
3419 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3420 sym_hashes
= elf_sym_hashes (input_bfd
);
3421 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3423 isec_segment
= sh_elf_osec_to_segment (output_bfd
,
3424 input_section
->output_section
);
3425 if (fdpic_p
&& sgot
)
3426 got_segment
= sh_elf_osec_to_segment (output_bfd
,
3427 sgot
->output_section
);
3430 if (fdpic_p
&& splt
)
3431 plt_segment
= sh_elf_osec_to_segment (output_bfd
,
3432 splt
->output_section
);
3436 /* We have to handle relocations in vxworks .tls_vars sections
3437 specially, because the dynamic loader is 'weird'. */
3438 is_vxworks_tls
= (htab
&& htab
->root
.target_os
== is_vxworks
&& bfd_link_pic (info
)
3439 && !strcmp (input_section
->output_section
->name
,
3443 relend
= relocs
+ input_section
->reloc_count
;
3444 for (; rel
< relend
; rel
++)
3447 reloc_howto_type
*howto
;
3448 unsigned long r_symndx
;
3449 Elf_Internal_Sym
*sym
;
3451 struct elf_link_hash_entry
*h
;
3453 bfd_vma addend
= (bfd_vma
) 0;
3454 bfd_reloc_status_type r
;
3456 enum got_type got_type
;
3457 const char *symname
= NULL
;
3458 bfd_boolean resolved_to_zero
;
3460 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3462 r_type
= ELF32_R_TYPE (rel
->r_info
);
3464 /* Many of the relocs are only used for relaxing, and are
3465 handled entirely by the relaxation code. */
3466 if (r_type
>= (int) R_SH_GNU_VTINHERIT
3467 && r_type
<= (int) R_SH_LABEL
)
3469 if (r_type
== (int) R_SH_NONE
)
3473 || r_type
>= R_SH_max
3474 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3475 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3476 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3477 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
)
3478 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_3
3479 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_3
)
3480 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_4
3481 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_4
)
3482 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_5
3483 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_5
)
3484 || ( r_type
>= (int) R_SH_FIRST_INVALID_RELOC_6
3485 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_6
))
3487 bfd_set_error (bfd_error_bad_value
);
3491 howto
= get_howto_table (output_bfd
) + r_type
;
3493 /* For relocs that aren't partial_inplace, we get the addend from
3495 if (! howto
->partial_inplace
)
3496 addend
= rel
->r_addend
;
3498 resolved_to_zero
= FALSE
;
3502 check_segment
[0] = -1;
3503 check_segment
[1] = -1;
3504 if (r_symndx
< symtab_hdr
->sh_info
)
3506 sym
= local_syms
+ r_symndx
;
3507 sec
= local_sections
[r_symndx
];
3509 symname
= bfd_elf_string_from_elf_section
3510 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
3511 if (symname
== NULL
|| *symname
== '\0')
3512 symname
= bfd_section_name (sec
);
3514 relocation
= (sec
->output_section
->vma
3515 + sec
->output_offset
3518 if (sec
!= NULL
&& discarded_section (sec
))
3519 /* Handled below. */
3521 else if (bfd_link_relocatable (info
))
3523 /* This is a relocatable link. We don't have to change
3524 anything, unless the reloc is against a section symbol,
3525 in which case we have to adjust according to where the
3526 section symbol winds up in the output section. */
3527 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3529 if (! howto
->partial_inplace
)
3531 /* For relocations with the addend in the
3532 relocation, we need just to update the addend.
3533 All real relocs are of type partial_inplace; this
3534 code is mostly for completeness. */
3535 rel
->r_addend
+= sec
->output_offset
;
3540 /* Relocs of type partial_inplace need to pick up the
3541 contents in the contents and add the offset resulting
3542 from the changed location of the section symbol.
3543 Using _bfd_final_link_relocate (e.g. goto
3544 final_link_relocate) here would be wrong, because
3545 relocations marked pc_relative would get the current
3546 location subtracted, and we must only do that at the
3548 r
= _bfd_relocate_contents (howto
, input_bfd
,
3551 contents
+ rel
->r_offset
);
3552 goto relocation_done
;
3557 else if (! howto
->partial_inplace
)
3559 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3560 addend
= rel
->r_addend
;
3562 else if ((sec
->flags
& SEC_MERGE
)
3563 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3567 if (howto
->rightshift
|| howto
->src_mask
!= 0xffffffff)
3570 /* xgettext:c-format */
3571 (_("%pB(%pA+%#" PRIx64
"): "
3572 "%s relocation against SEC_MERGE section"),
3573 input_bfd
, input_section
,
3574 (uint64_t) rel
->r_offset
, howto
->name
);
3578 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3581 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
3583 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3584 bfd_put_32 (input_bfd
, addend
, contents
+ rel
->r_offset
);
3590 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
3593 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3594 symname
= h
->root
.root
.string
;
3595 while (h
->root
.type
== bfd_link_hash_indirect
3596 || h
->root
.type
== bfd_link_hash_warning
)
3597 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3598 if (h
->root
.type
== bfd_link_hash_defined
3599 || h
->root
.type
== bfd_link_hash_defweak
)
3603 dyn
= htab
? htab
->root
.dynamic_sections_created
: FALSE
;
3604 sec
= h
->root
.u
.def
.section
;
3605 /* In these cases, we don't need the relocation value.
3606 We check specially because in some obscure cases
3607 sec->output_section will be NULL. */
3608 if (r_type
== R_SH_GOTPC
3609 || r_type
== R_SH_GOTPC_LOW16
3610 || r_type
== R_SH_GOTPC_MEDLOW16
3611 || r_type
== R_SH_GOTPC_MEDHI16
3612 || r_type
== R_SH_GOTPC_HI16
3613 || ((r_type
== R_SH_PLT32
3614 || r_type
== R_SH_PLT_LOW16
3615 || r_type
== R_SH_PLT_MEDLOW16
3616 || r_type
== R_SH_PLT_MEDHI16
3617 || r_type
== R_SH_PLT_HI16
)
3618 && h
->plt
.offset
!= (bfd_vma
) -1)
3619 || ((r_type
== R_SH_GOT32
3620 || r_type
== R_SH_GOT20
3621 || r_type
== R_SH_GOTFUNCDESC
3622 || r_type
== R_SH_GOTFUNCDESC20
3623 || r_type
== R_SH_GOTOFFFUNCDESC
3624 || r_type
== R_SH_GOTOFFFUNCDESC20
3625 || r_type
== R_SH_FUNCDESC
3626 || r_type
== R_SH_GOT_LOW16
3627 || r_type
== R_SH_GOT_MEDLOW16
3628 || r_type
== R_SH_GOT_MEDHI16
3629 || r_type
== R_SH_GOT_HI16
)
3630 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3631 bfd_link_pic (info
),
3633 && (! bfd_link_pic (info
)
3634 || (! info
->symbolic
&& h
->dynindx
!= -1)
3635 || !h
->def_regular
))
3636 /* The cases above are those in which relocation is
3637 overwritten in the switch block below. The cases
3638 below are those in which we must defer relocation
3639 to run-time, because we can't resolve absolute
3640 addresses when creating a shared library. */
3641 || (bfd_link_pic (info
)
3642 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3644 && ((r_type
== R_SH_DIR32
3645 && !h
->forced_local
)
3646 || (r_type
== R_SH_REL32
3647 && !SYMBOL_CALLS_LOCAL (info
, h
)))
3648 && ((input_section
->flags
& SEC_ALLOC
) != 0
3649 /* DWARF will emit R_SH_DIR32 relocations in its
3650 sections against symbols defined externally
3651 in shared libraries. We can't do anything
3653 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
3654 && h
->def_dynamic
)))
3655 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3656 sections because such sections are not SEC_ALLOC and
3657 thus ld.so will not process them. */
3658 || (sec
->output_section
== NULL
3659 && ((input_section
->flags
& SEC_DEBUGGING
) != 0
3661 || (sec
->output_section
== NULL
3662 && (sh_elf_hash_entry (h
)->got_type
== GOT_TLS_IE
3663 || sh_elf_hash_entry (h
)->got_type
== GOT_TLS_GD
)))
3665 else if (sec
->output_section
!= NULL
)
3666 relocation
= (h
->root
.u
.def
.value
3667 + sec
->output_section
->vma
3668 + sec
->output_offset
);
3669 else if (!bfd_link_relocatable (info
)
3670 && (_bfd_elf_section_offset (output_bfd
, info
,
3676 /* xgettext:c-format */
3677 (_("%pB(%pA+%#" PRIx64
"): "
3678 "unresolvable %s relocation against symbol `%s'"),
3681 (uint64_t) rel
->r_offset
,
3683 h
->root
.root
.string
);
3687 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3688 resolved_to_zero
= UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
);
3689 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3690 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3692 else if (!bfd_link_relocatable (info
))
3693 info
->callbacks
->undefined_symbol
3694 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
3696 (info
->unresolved_syms_in_objects
== RM_DIAGNOSE
3697 && !info
->warn_unresolved_syms
)
3698 || ELF_ST_VISIBILITY (h
->other
));
3701 if (sec
!= NULL
&& discarded_section (sec
))
3702 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3703 rel
, 1, relend
, howto
, 0, contents
);
3705 if (bfd_link_relocatable (info
))
3708 /* Check for inter-segment relocations in FDPIC files. Most
3709 relocations connect the relocation site to the location of
3710 the target symbol, but there are some exceptions below. */
3711 check_segment
[0] = isec_segment
;
3713 check_segment
[1] = sh_elf_osec_to_segment (output_bfd
,
3714 sec
->output_section
);
3716 check_segment
[1] = -1;
3718 switch ((int) r_type
)
3720 final_link_relocate
:
3721 /* COFF relocs don't use the addend. The addend is used for
3722 R_SH_DIR32 to be compatible with other compilers. */
3723 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3724 contents
, rel
->r_offset
,
3725 relocation
, addend
);
3729 goto final_link_relocate
;
3734 /* If the reloc is against the start of this section, then
3735 the assembler has already taken care of it and the reloc
3736 is here only to assist in relaxing. If the reloc is not
3737 against the start of this section, then it's against an
3738 external symbol and we must deal with it ourselves. */
3739 if (input_section
->output_section
->vma
+ input_section
->output_offset
3742 int disp
= (relocation
3743 - input_section
->output_section
->vma
3744 - input_section
->output_offset
3750 case R_SH_DIR8WPZ
: mask
= 1; break;
3751 case R_SH_DIR8WPL
: mask
= 3; break;
3752 default: mask
= 0; break;
3757 /* xgettext:c-format */
3758 (_("%pB: %#" PRIx64
": fatal: "
3759 "unaligned branch target for relax-support relocation"),
3760 input_section
->owner
,
3761 (uint64_t) rel
->r_offset
);
3762 bfd_set_error (bfd_error_bad_value
);
3766 goto final_link_relocate
;
3772 bfd_set_error (bfd_error_bad_value
);
3780 goto final_link_relocate
;
3787 /* xgettext:c-format */
3788 (_("%pB: %#" PRIx64
": fatal: "
3789 "unaligned %s relocation %#" PRIx64
),
3790 input_section
->owner
, (uint64_t) rel
->r_offset
,
3791 howto
->name
, (uint64_t) relocation
);
3792 bfd_set_error (bfd_error_bad_value
);
3795 goto final_link_relocate
;
3803 /* xgettext:c-format */
3804 (_("%pB: %#" PRIx64
": fatal: "
3805 "unaligned %s relocation %#" PRIx64
""),
3806 input_section
->owner
,
3807 (uint64_t) rel
->r_offset
, howto
->name
,
3808 (uint64_t) relocation
);
3809 bfd_set_error (bfd_error_bad_value
);
3812 goto final_link_relocate
;
3815 if ((signed int)relocation
< -32
3816 || (signed int)relocation
> 32)
3819 /* xgettext:c-format */
3820 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHA relocation %" PRId64
3821 " not in range -32..32"),
3822 input_section
->owner
,
3823 (uint64_t) rel
->r_offset
,
3824 (int64_t) relocation
);
3825 bfd_set_error (bfd_error_bad_value
);
3828 goto final_link_relocate
;
3831 if ((signed int)relocation
< -16
3832 || (signed int)relocation
> 16)
3835 /* xgettext:c-format */
3836 (_("%pB: %#" PRIx64
": fatal: R_SH_PSHL relocation %" PRId64
3837 " not in range -32..32"),
3838 input_section
->owner
,
3839 (uint64_t) rel
->r_offset
,
3840 (int64_t) relocation
);
3841 bfd_set_error (bfd_error_bad_value
);
3844 goto final_link_relocate
;
3848 if (bfd_link_pic (info
)
3850 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3851 && !resolved_to_zero
)
3852 || h
->root
.type
!= bfd_link_hash_undefweak
)
3853 && r_symndx
!= STN_UNDEF
3854 && (input_section
->flags
& SEC_ALLOC
) != 0
3856 && (r_type
== R_SH_DIR32
3857 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3859 Elf_Internal_Rela outrel
;
3861 bfd_boolean skip
, relocate
;
3863 /* When generating a shared object, these relocations
3864 are copied into the output file to be resolved at run
3869 sreloc
= _bfd_elf_get_dynamic_reloc_section
3870 (input_bfd
, input_section
, /*rela?*/ TRUE
);
3879 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3881 if (outrel
.r_offset
== (bfd_vma
) -1)
3883 else if (outrel
.r_offset
== (bfd_vma
) -2)
3884 skip
= TRUE
, relocate
= TRUE
;
3885 outrel
.r_offset
+= (input_section
->output_section
->vma
3886 + input_section
->output_offset
);
3889 memset (&outrel
, 0, sizeof outrel
);
3890 else if (r_type
== R_SH_REL32
)
3892 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3893 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
3895 = (howto
->partial_inplace
3896 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3901 || ((info
->symbolic
|| h
->dynindx
== -1)
3902 && h
->def_regular
)))
3906 BFD_ASSERT (sec
!= NULL
);
3907 BFD_ASSERT (sec
->output_section
!= NULL
);
3908 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
3909 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
3910 outrel
.r_addend
= relocation
;
3912 += (howto
->partial_inplace
3913 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3915 outrel
.r_addend
-= sec
->output_section
->vma
;
3919 /* h->dynindx may be -1 if this symbol was marked to
3922 || ((info
->symbolic
|| h
->dynindx
== -1)
3925 relocate
= howto
->partial_inplace
;
3926 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3930 BFD_ASSERT (h
->dynindx
!= -1);
3931 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
3933 outrel
.r_addend
= relocation
;
3935 += (howto
->partial_inplace
3936 ? bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
)
3940 loc
= sreloc
->contents
;
3941 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3942 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3944 check_segment
[0] = check_segment
[1] = -1;
3946 /* If this reloc is against an external symbol, we do
3947 not want to fiddle with the addend. Otherwise, we
3948 need to include the symbol value so that it becomes
3949 an addend for the dynamic reloc. */
3953 else if (fdpic_p
&& !bfd_link_pic (info
)
3954 && r_type
== R_SH_DIR32
3955 && (input_section
->flags
& SEC_ALLOC
) != 0)
3961 if (sh_elf_osec_readonly_p (output_bfd
,
3962 input_section
->output_section
))
3965 /* xgettext:c-format */
3966 (_("%pB(%pA+%#" PRIx64
"): "
3967 "cannot emit fixup to `%s' in read-only section"),
3970 (uint64_t) rel
->r_offset
,
3975 offset
= _bfd_elf_section_offset (output_bfd
, info
,
3976 input_section
, rel
->r_offset
);
3977 if (offset
!= (bfd_vma
)-1)
3978 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
3979 input_section
->output_section
->vma
3980 + input_section
->output_offset
3983 check_segment
[0] = check_segment
[1] = -1;
3985 /* We don't want warnings for non-NULL tests on undefined weak
3987 else if (r_type
== R_SH_REL32
3989 && h
->root
.type
== bfd_link_hash_undefweak
)
3990 check_segment
[0] = check_segment
[1] = -1;
3991 goto final_link_relocate
;
3994 /* Relocation is to the entry for this symbol in the
3995 procedure linkage table. */
3999 || ! bfd_link_pic (info
)
4002 || h
->plt
.offset
== (bfd_vma
) -1
4003 || h
->got
.offset
!= (bfd_vma
) -1)
4006 /* Relocation is to the entry for this symbol in the global
4007 offset table extension for the procedure linkage table. */
4010 BFD_ASSERT (sgotplt
!= NULL
);
4011 relocation
= (sgotplt
->output_offset
4012 + (get_plt_index (htab
->plt_info
, h
->plt
.offset
)
4016 relocation
-= GOT_BIAS
;
4019 goto final_link_relocate
;
4024 /* Relocation is to the entry for this symbol in the global
4028 BFD_ASSERT (sgot
!= NULL
);
4029 check_segment
[0] = check_segment
[1] = -1;
4035 off
= h
->got
.offset
;
4036 BFD_ASSERT (off
!= (bfd_vma
) -1);
4038 dyn
= htab
->root
.dynamic_sections_created
;
4039 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4040 bfd_link_pic (info
),
4042 || (bfd_link_pic (info
)
4043 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4044 || ((ELF_ST_VISIBILITY (h
->other
)
4045 || resolved_to_zero
)
4046 && h
->root
.type
== bfd_link_hash_undefweak
))
4048 /* This is actually a static link, or it is a
4049 -Bsymbolic link and the symbol is defined
4050 locally, or the symbol was forced to be local
4051 because of a version file. We must initialize
4052 this entry in the global offset table. Since the
4053 offset must always be a multiple of 4, we use the
4054 least significant bit to record whether we have
4055 initialized it already.
4057 When doing a dynamic link, we create a .rela.got
4058 relocation entry to initialize the value. This
4059 is done in the finish_dynamic_symbol routine. */
4064 bfd_put_32 (output_bfd
, relocation
,
4065 sgot
->contents
+ off
);
4068 /* If we initialize the GOT entry here with a valid
4069 symbol address, also add a fixup. */
4070 if (fdpic_p
&& !bfd_link_pic (info
)
4071 && sh_elf_hash_entry (h
)->got_type
== GOT_NORMAL
4072 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4073 || h
->root
.type
!= bfd_link_hash_undefweak
))
4074 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4075 sgot
->output_section
->vma
4076 + sgot
->output_offset
4081 relocation
= sh_elf_got_offset (htab
) + off
;
4085 BFD_ASSERT (local_got_offsets
!= NULL
4086 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4088 off
= local_got_offsets
[r_symndx
];
4090 /* The offset must always be a multiple of 4. We use
4091 the least significant bit to record whether we have
4092 already generated the necessary reloc. */
4097 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
4099 if (bfd_link_pic (info
))
4101 Elf_Internal_Rela outrel
;
4104 outrel
.r_offset
= (sgot
->output_section
->vma
4105 + sgot
->output_offset
4110 = elf_section_data (sec
->output_section
)->dynindx
;
4111 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
4112 outrel
.r_addend
= relocation
;
4113 outrel
.r_addend
-= sec
->output_section
->vma
;
4117 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4118 outrel
.r_addend
= relocation
;
4120 loc
= srelgot
->contents
;
4121 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4122 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4125 && (sh_elf_local_got_type (input_bfd
) [r_symndx
]
4127 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4128 sgot
->output_section
->vma
4129 + sgot
->output_offset
4132 local_got_offsets
[r_symndx
] |= 1;
4135 relocation
= sh_elf_got_offset (htab
) + off
;
4139 relocation
-= GOT_BIAS
;
4142 if (r_type
== R_SH_GOT20
)
4144 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4145 input_bfd
, input_section
, contents
,
4150 goto final_link_relocate
;
4154 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4155 we place at the start of the .got.plt section. This is the same
4156 as the start of the output .got section, unless there are function
4157 descriptors in front of it. */
4159 BFD_ASSERT (sgotplt
!= NULL
);
4160 check_segment
[0] = got_segment
;
4161 relocation
-= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
4162 + htab
->root
.hgot
->root
.u
.def
.value
;
4165 relocation
-= GOT_BIAS
;
4168 addend
= rel
->r_addend
;
4170 if (r_type
== R_SH_GOTOFF20
)
4172 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4173 input_bfd
, input_section
, contents
,
4178 goto final_link_relocate
;
4181 /* Use global offset table as symbol value. */
4183 BFD_ASSERT (sgotplt
!= NULL
);
4184 relocation
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4187 relocation
+= GOT_BIAS
;
4190 addend
= rel
->r_addend
;
4192 goto final_link_relocate
;
4195 /* Relocation is to the entry for this symbol in the
4196 procedure linkage table. */
4198 /* Resolve a PLT reloc against a local symbol directly,
4199 without using the procedure linkage table. */
4201 goto final_link_relocate
;
4203 /* We don't want to warn on calls to undefined weak symbols,
4204 as calls to them must be protected by non-NULL tests
4205 anyway, and unprotected calls would invoke undefined
4207 if (h
->root
.type
== bfd_link_hash_undefweak
)
4208 check_segment
[0] = check_segment
[1] = -1;
4210 if (h
->forced_local
)
4211 goto final_link_relocate
;
4213 if (h
->plt
.offset
== (bfd_vma
) -1)
4215 /* We didn't make a PLT entry for this symbol. This
4216 happens when statically linking PIC code, or when
4217 using -Bsymbolic. */
4218 goto final_link_relocate
;
4221 BFD_ASSERT (splt
!= NULL
);
4222 check_segment
[1] = plt_segment
;
4223 relocation
= (splt
->output_section
->vma
4224 + splt
->output_offset
4227 addend
= rel
->r_addend
;
4229 goto final_link_relocate
;
4231 /* Relocation is to the canonical function descriptor for this
4232 symbol, possibly via the GOT. Initialize the GOT
4233 entry and function descriptor if necessary. */
4234 case R_SH_GOTFUNCDESC
:
4235 case R_SH_GOTFUNCDESC20
:
4239 asection
*reloc_section
;
4240 bfd_vma reloc_offset
;
4241 int reloc_type
= R_SH_FUNCDESC
;
4245 check_segment
[0] = check_segment
[1] = -1;
4247 /* FIXME: See what FRV does for global symbols in the
4248 executable, with --export-dynamic. Do they need ld.so
4249 to allocate official descriptors? See what this code
4255 if (r_type
== R_SH_FUNCDESC
)
4257 reloc_section
= input_section
;
4258 reloc_offset
= rel
->r_offset
;
4262 reloc_section
= sgot
;
4265 reloc_offset
= h
->got
.offset
;
4268 BFD_ASSERT (local_got_offsets
!= NULL
);
4269 reloc_offset
= local_got_offsets
[r_symndx
];
4271 BFD_ASSERT (reloc_offset
!= MINUS_ONE
);
4273 if (reloc_offset
& 1)
4276 goto funcdesc_done_got
;
4280 if (h
&& h
->root
.type
== bfd_link_hash_undefweak
4281 && (SYMBOL_CALLS_LOCAL (info
, h
)
4282 || !htab
->root
.dynamic_sections_created
))
4283 /* Undefined weak symbol which will not be dynamically
4284 resolved later; leave it at zero. */
4285 goto funcdesc_leave_zero
;
4286 else if (SYMBOL_CALLS_LOCAL (info
, h
)
4287 && ! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4289 /* If the symbol needs a non-local function descriptor
4290 but binds locally (i.e., its visibility is
4291 protected), emit a dynamic relocation decayed to
4292 section+offset. This is an optimization; the dynamic
4293 linker would resolve our function descriptor request
4294 to our copy of the function anyway. */
4295 dynindx
= elf_section_data (h
->root
.u
.def
.section
4296 ->output_section
)->dynindx
;
4297 relocation
+= h
->root
.u
.def
.section
->output_offset
4298 + h
->root
.u
.def
.value
;
4300 else if (! SYMBOL_FUNCDESC_LOCAL (info
, h
))
4302 /* If the symbol is dynamic and there will be dynamic
4303 symbol resolution because we are or are linked with a
4304 shared library, emit a FUNCDESC relocation such that
4305 the dynamic linker will allocate the function
4307 BFD_ASSERT (h
->dynindx
!= -1);
4308 dynindx
= h
->dynindx
;
4314 /* Otherwise, we know we have a private function
4315 descriptor, so reference it directly. */
4316 reloc_type
= R_SH_DIR32
;
4317 dynindx
= elf_section_data (htab
->sfuncdesc
4318 ->output_section
)->dynindx
;
4322 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4323 BFD_ASSERT (offset
!= MINUS_ONE
);
4324 if ((offset
& 1) == 0)
4326 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4329 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4334 union gotref
*local_funcdesc
;
4336 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4337 offset
= local_funcdesc
[r_symndx
].offset
;
4338 BFD_ASSERT (offset
!= MINUS_ONE
);
4339 if ((offset
& 1) == 0)
4341 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4345 local_funcdesc
[r_symndx
].offset
|= 1;
4349 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4352 if (!bfd_link_pic (info
) && SYMBOL_FUNCDESC_LOCAL (info
, h
))
4356 if (sh_elf_osec_readonly_p (output_bfd
,
4357 reloc_section
->output_section
))
4360 /* xgettext:c-format */
4361 (_("%pB(%pA+%#" PRIx64
"): "
4362 "cannot emit fixup to `%s' in read-only section"),
4365 (uint64_t) rel
->r_offset
,
4370 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4371 reloc_section
, reloc_offset
);
4373 if (offset
!= (bfd_vma
)-1)
4374 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
,
4376 + reloc_section
->output_section
->vma
4377 + reloc_section
->output_offset
);
4379 else if ((reloc_section
->output_section
->flags
4380 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
4384 if (sh_elf_osec_readonly_p (output_bfd
,
4385 reloc_section
->output_section
))
4387 info
->callbacks
->warning
4389 _("cannot emit dynamic relocations in read-only section"),
4390 symname
, input_bfd
, reloc_section
, reloc_offset
);
4394 offset
= _bfd_elf_section_offset (output_bfd
, info
,
4395 reloc_section
, reloc_offset
);
4397 if (offset
!= (bfd_vma
)-1)
4398 sh_elf_add_dyn_reloc (output_bfd
, srelgot
,
4400 + reloc_section
->output_section
->vma
4401 + reloc_section
->output_offset
,
4402 reloc_type
, dynindx
, relocation
);
4404 if (r_type
== R_SH_FUNCDESC
)
4412 goto funcdesc_leave_zero
;
4416 if (SYMBOL_FUNCDESC_LOCAL (info
, h
))
4417 relocation
+= htab
->sfuncdesc
->output_section
->vma
;
4418 funcdesc_leave_zero
:
4419 if (r_type
!= R_SH_FUNCDESC
)
4421 bfd_put_32 (output_bfd
, relocation
,
4422 reloc_section
->contents
+ reloc_offset
);
4426 local_got_offsets
[r_symndx
] |= 1;
4430 relocation
= sh_elf_got_offset (htab
) + reloc_offset
;
4432 relocation
-= GOT_BIAS
;
4435 if (r_type
== R_SH_GOTFUNCDESC20
)
4437 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4438 input_bfd
, input_section
, contents
,
4443 goto final_link_relocate
;
4447 case R_SH_GOTOFFFUNCDESC
:
4448 case R_SH_GOTOFFFUNCDESC20
:
4449 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4450 executable and --export-dynamic. If such symbols get
4451 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4455 check_segment
[0] = check_segment
[1] = -1;
4457 addend
= rel
->r_addend
;
4459 if (h
&& (h
->root
.type
== bfd_link_hash_undefweak
4460 || !SYMBOL_FUNCDESC_LOCAL (info
, h
)))
4463 /* xgettext:c-format */
4464 (_("%pB(%pA+%#" PRIx64
"): "
4465 "%s relocation against external symbol \"%s\""),
4466 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
4467 howto
->name
, h
->root
.root
.string
);
4474 /* Otherwise, we know we have a private function
4475 descriptor, so reference it directly. */
4478 offset
= sh_elf_hash_entry (h
)->funcdesc
.offset
;
4479 BFD_ASSERT (offset
!= MINUS_ONE
);
4480 if ((offset
& 1) == 0)
4482 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, h
,
4485 sh_elf_hash_entry (h
)->funcdesc
.offset
|= 1;
4490 union gotref
*local_funcdesc
;
4492 local_funcdesc
= sh_elf_local_funcdesc (input_bfd
);
4493 offset
= local_funcdesc
[r_symndx
].offset
;
4494 BFD_ASSERT (offset
!= MINUS_ONE
);
4495 if ((offset
& 1) == 0)
4497 if (!sh_elf_initialize_funcdesc (output_bfd
, info
, NULL
,
4501 local_funcdesc
[r_symndx
].offset
|= 1;
4505 relocation
= htab
->sfuncdesc
->output_offset
+ (offset
& ~1);
4508 relocation
-= (htab
->root
.hgot
->root
.u
.def
.value
4509 + sgotplt
->output_offset
);
4511 relocation
-= GOT_BIAS
;
4514 if (r_type
== R_SH_GOTOFFFUNCDESC20
)
4516 r
= install_movi20_field (output_bfd
, relocation
+ addend
,
4517 input_bfd
, input_section
, contents
,
4522 goto final_link_relocate
;
4524 case R_SH_LOOP_START
:
4526 static bfd_vma start
, end
;
4528 start
= (relocation
+ rel
->r_addend
4529 - (sec
->output_section
->vma
+ sec
->output_offset
));
4530 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4531 rel
->r_offset
, sec
, start
, end
);
4535 end
= (relocation
+ rel
->r_addend
4536 - (sec
->output_section
->vma
+ sec
->output_offset
));
4537 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
4538 rel
->r_offset
, sec
, start
, end
);
4542 case R_SH_TLS_GD_32
:
4543 case R_SH_TLS_IE_32
:
4545 check_segment
[0] = check_segment
[1] = -1;
4546 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
4547 got_type
= GOT_UNKNOWN
;
4548 if (h
== NULL
&& local_got_offsets
)
4549 got_type
= sh_elf_local_got_type (input_bfd
) [r_symndx
];
4552 got_type
= sh_elf_hash_entry (h
)->got_type
;
4553 if (! bfd_link_pic (info
)
4554 && (h
->dynindx
== -1
4556 r_type
= R_SH_TLS_LE_32
;
4559 if (r_type
== R_SH_TLS_GD_32
&& got_type
== GOT_TLS_IE
)
4560 r_type
= R_SH_TLS_IE_32
;
4562 if (r_type
== R_SH_TLS_LE_32
)
4565 unsigned short insn
;
4567 if (ELF32_R_TYPE (rel
->r_info
) == R_SH_TLS_GD_32
)
4569 /* GD->LE transition:
4570 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4571 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4572 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4574 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4576 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
4578 offset
= rel
->r_offset
;
4582 /* xgettext:c-format */
4583 (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64
),
4584 input_bfd
, input_section
, (uint64_t) offset
);
4588 /* Size of GD instructions is 16 or 18. */
4590 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4591 if ((insn
& 0xff00) == 0xc700)
4593 BFD_ASSERT (offset
>= 2);
4595 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4598 if ((insn
& 0xff00) != 0xd400)
4600 /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */
4601 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd4?\?)"),
4602 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4604 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4606 if ((insn
& 0xff00) != 0xc700)
4608 /* xgettext:c-format */
4609 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xc7?\?)"),
4610 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4612 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4613 if ((insn
& 0xff00) != 0xd100)
4615 /* xgettext:c-format */
4616 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd1?\?)"),
4617 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4619 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4622 /* xgettext:c-format */
4623 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x310c)"),
4624 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4626 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4629 /* xgettext:c-format */
4630 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x410b)"),
4631 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4633 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4636 /* xgettext:c-format */
4637 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x34cc)"),
4638 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4640 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 2);
4641 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 4);
4642 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4643 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4644 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4650 /* IE->LE transition:
4667 offset
= rel
->r_offset
;
4671 /* xgettext:c-format */
4672 (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64
),
4673 input_bfd
, input_section
, (uint64_t) offset
);
4677 /* Size of IE instructions is 10 or 12. */
4679 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4680 if ((insn
& 0xf0ff) == 0x0012)
4682 BFD_ASSERT (offset
>= 2);
4684 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4687 if ((insn
& 0xff00) != 0xd000)
4689 /* xgettext:c-format */
4690 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
4691 input_bfd
, input_section
, (uint64_t) offset
, (int) insn
);
4693 target
= insn
& 0x00ff;
4695 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4696 if ((insn
& 0xf0ff) != 0x0012)
4698 /* xgettext:c-format */
4699 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?12: stc)"),
4700 input_bfd
, input_section
, (uint64_t) (offset
+ 2), (int) insn
);
4702 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4703 if ((insn
& 0xf0ff) != 0x00ce)
4705 /* xgettext:c-format */
4706 (_("%pB(%pA+%#" PRIx64
"): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
4707 input_bfd
, input_section
, (uint64_t) (offset
+ 4), (int) insn
);
4709 insn
= 0xd000 | (insn
& 0x0f00) | target
;
4710 bfd_put_16 (output_bfd
, insn
, contents
+ offset
+ 0);
4711 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4714 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4715 contents
+ rel
->r_offset
);
4719 if (sgot
== NULL
|| sgotplt
== NULL
)
4723 off
= h
->got
.offset
;
4726 if (local_got_offsets
== NULL
)
4729 off
= local_got_offsets
[r_symndx
];
4732 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
4733 if (r_type
== R_SH_TLS_IE_32
4734 && ! htab
->root
.dynamic_sections_created
)
4737 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4738 sgot
->contents
+ off
);
4739 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4740 contents
+ rel
->r_offset
);
4748 Elf_Internal_Rela outrel
;
4752 outrel
.r_offset
= (sgot
->output_section
->vma
4753 + sgot
->output_offset
+ off
);
4755 if (h
== NULL
|| h
->dynindx
== -1)
4760 dr_type
= (r_type
== R_SH_TLS_GD_32
? R_SH_TLS_DTPMOD32
:
4762 if (dr_type
== R_SH_TLS_TPOFF32
&& indx
== 0)
4763 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4765 outrel
.r_addend
= 0;
4766 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4767 loc
= srelgot
->contents
;
4768 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4769 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4771 if (r_type
== R_SH_TLS_GD_32
)
4775 bfd_put_32 (output_bfd
,
4776 relocation
- dtpoff_base (info
),
4777 sgot
->contents
+ off
+ 4);
4781 outrel
.r_info
= ELF32_R_INFO (indx
,
4783 outrel
.r_offset
+= 4;
4784 outrel
.r_addend
= 0;
4785 srelgot
->reloc_count
++;
4786 loc
+= sizeof (Elf32_External_Rela
);
4787 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4794 local_got_offsets
[r_symndx
] |= 1;
4797 if (off
>= (bfd_vma
) -2)
4800 if (r_type
== (int) ELF32_R_TYPE (rel
->r_info
))
4801 relocation
= sh_elf_got_offset (htab
) + off
;
4805 unsigned short insn
;
4807 /* GD->IE transition:
4808 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4809 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4810 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4812 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4813 nop; nop; bra 3f; nop; .align 2;
4814 1: .long x@TPOFF; 2:...; 3:. */
4816 offset
= rel
->r_offset
;
4820 /* xgettext:c-format */
4821 (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64
),
4822 input_bfd
, input_section
, (uint64_t) offset
);
4826 /* Size of GD instructions is 16 or 18. */
4828 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4829 if ((insn
& 0xff00) == 0xc700)
4831 BFD_ASSERT (offset
>= 2);
4833 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4836 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4838 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
4839 bfd_put_16 (output_bfd
, insn
& 0xf0ff, contents
+ offset
);
4841 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4842 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4843 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4844 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4845 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4846 BFD_ASSERT (insn
== 0x310c);
4847 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4848 BFD_ASSERT (insn
== 0x410b);
4849 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4850 BFD_ASSERT (insn
== 0x34cc);
4852 bfd_put_16 (output_bfd
, 0x0412, contents
+ offset
+ 2);
4853 bfd_put_16 (output_bfd
, 0x00ce, contents
+ offset
+ 4);
4854 bfd_put_16 (output_bfd
, 0x304c, contents
+ offset
+ 6);
4855 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4856 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4858 bfd_put_32 (output_bfd
, sh_elf_got_offset (htab
) + off
,
4859 contents
+ rel
->r_offset
);
4864 addend
= rel
->r_addend
;
4866 goto final_link_relocate
;
4868 case R_SH_TLS_LD_32
:
4870 check_segment
[0] = check_segment
[1] = -1;
4871 if (! bfd_link_pic (info
))
4874 unsigned short insn
;
4876 /* LD->LE transition:
4877 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4878 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4879 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4881 stc gbr,r0; nop; nop; nop;
4882 nop; nop; bra 3f; ...; 3:. */
4884 offset
= rel
->r_offset
;
4888 /* xgettext:c-format */
4889 (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64
),
4890 input_bfd
, input_section
, (uint64_t) offset
);
4894 /* Size of LD instructions is 16 or 18. */
4896 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4897 if ((insn
& 0xff00) == 0xc700)
4899 BFD_ASSERT (offset
>= 2);
4901 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 0);
4904 BFD_ASSERT ((insn
& 0xff00) == 0xd400);
4905 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 2);
4906 BFD_ASSERT ((insn
& 0xff00) == 0xc700);
4907 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 4);
4908 BFD_ASSERT ((insn
& 0xff00) == 0xd100);
4909 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 6);
4910 BFD_ASSERT (insn
== 0x310c);
4911 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 8);
4912 BFD_ASSERT (insn
== 0x410b);
4913 insn
= bfd_get_16 (input_bfd
, contents
+ offset
+ 10);
4914 BFD_ASSERT (insn
== 0x34cc);
4916 bfd_put_16 (output_bfd
, 0x0012, contents
+ offset
+ 0);
4917 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 2);
4918 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 4);
4919 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 6);
4920 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 8);
4921 bfd_put_16 (output_bfd
, 0x0009, contents
+ offset
+ 10);
4926 if (sgot
== NULL
|| sgotplt
== NULL
)
4929 off
= htab
->tls_ldm_got
.offset
;
4934 Elf_Internal_Rela outrel
;
4937 outrel
.r_offset
= (sgot
->output_section
->vma
4938 + sgot
->output_offset
+ off
);
4939 outrel
.r_addend
= 0;
4940 outrel
.r_info
= ELF32_R_INFO (0, R_SH_TLS_DTPMOD32
);
4941 loc
= srelgot
->contents
;
4942 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4943 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4944 htab
->tls_ldm_got
.offset
|= 1;
4947 relocation
= sh_elf_got_offset (htab
) + off
;
4948 addend
= rel
->r_addend
;
4950 goto final_link_relocate
;
4952 case R_SH_TLS_LDO_32
:
4953 check_segment
[0] = check_segment
[1] = -1;
4954 if (! bfd_link_pic (info
))
4955 relocation
= tpoff (info
, relocation
);
4957 relocation
-= dtpoff_base (info
);
4959 addend
= rel
->r_addend
;
4960 goto final_link_relocate
;
4962 case R_SH_TLS_LE_32
:
4965 Elf_Internal_Rela outrel
;
4968 check_segment
[0] = check_segment
[1] = -1;
4970 if (!bfd_link_dll (info
))
4972 relocation
= tpoff (info
, relocation
);
4973 addend
= rel
->r_addend
;
4974 goto final_link_relocate
;
4979 sreloc
= _bfd_elf_get_dynamic_reloc_section
4980 (input_bfd
, input_section
, /*rela?*/ TRUE
);
4985 if (h
== NULL
|| h
->dynindx
== -1)
4990 outrel
.r_offset
= (input_section
->output_section
->vma
4991 + input_section
->output_offset
4993 outrel
.r_info
= ELF32_R_INFO (indx
, R_SH_TLS_TPOFF32
);
4995 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4997 outrel
.r_addend
= 0;
4999 loc
= sreloc
->contents
;
5000 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5001 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
5007 if (fdpic_p
&& check_segment
[0] != (unsigned) -1
5008 && check_segment
[0] != check_segment
[1])
5010 /* We don't want duplicate errors for undefined symbols. */
5011 if (!h
|| h
->root
.type
!= bfd_link_hash_undefined
)
5013 if (bfd_link_pic (info
))
5015 info
->callbacks
->einfo
5016 /* xgettext:c-format */
5017 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5018 input_bfd
, input_section
, rel
->r_offset
, symname
);
5022 info
->callbacks
->einfo
5023 /* xgettext:c-format */
5024 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5025 input_bfd
, input_section
, rel
->r_offset
, symname
);
5028 elf_elfheader (output_bfd
)->e_flags
|= EF_SH_PIC
;
5031 if (r
!= bfd_reloc_ok
)
5036 case bfd_reloc_outofrange
:
5038 case bfd_reloc_overflow
:
5046 name
= (bfd_elf_string_from_elf_section
5047 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
5051 name
= bfd_section_name (sec
);
5053 (*info
->callbacks
->reloc_overflow
)
5054 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5055 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5065 /* This is a version of bfd_generic_get_relocated_section_contents
5066 which uses sh_elf_relocate_section. */
5069 sh_elf_get_relocated_section_contents (bfd
*output_bfd
,
5070 struct bfd_link_info
*link_info
,
5071 struct bfd_link_order
*link_order
,
5073 bfd_boolean relocatable
,
5076 Elf_Internal_Shdr
*symtab_hdr
;
5077 asection
*input_section
= link_order
->u
.indirect
.section
;
5078 bfd
*input_bfd
= input_section
->owner
;
5079 asection
**sections
= NULL
;
5080 Elf_Internal_Rela
*internal_relocs
= NULL
;
5081 Elf_Internal_Sym
*isymbuf
= NULL
;
5083 /* We only need to handle the case of relaxing, or of having a
5084 particular set of section contents, specially. */
5086 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
5087 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
5092 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
5094 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
5095 (size_t) input_section
->size
);
5097 if ((input_section
->flags
& SEC_RELOC
) != 0
5098 && input_section
->reloc_count
> 0)
5101 Elf_Internal_Sym
*isym
, *isymend
;
5104 internal_relocs
= (_bfd_elf_link_read_relocs
5105 (input_bfd
, input_section
, NULL
,
5106 (Elf_Internal_Rela
*) NULL
, FALSE
));
5107 if (internal_relocs
== NULL
)
5110 if (symtab_hdr
->sh_info
!= 0)
5112 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5113 if (isymbuf
== NULL
)
5114 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
5115 symtab_hdr
->sh_info
, 0,
5117 if (isymbuf
== NULL
)
5121 amt
= symtab_hdr
->sh_info
;
5122 amt
*= sizeof (asection
*);
5123 sections
= (asection
**) bfd_malloc (amt
);
5124 if (sections
== NULL
&& amt
!= 0)
5127 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
5128 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
5132 if (isym
->st_shndx
== SHN_UNDEF
)
5133 isec
= bfd_und_section_ptr
;
5134 else if (isym
->st_shndx
== SHN_ABS
)
5135 isec
= bfd_abs_section_ptr
;
5136 else if (isym
->st_shndx
== SHN_COMMON
)
5137 isec
= bfd_com_section_ptr
;
5139 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
5144 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
5145 input_section
, data
, internal_relocs
,
5150 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5152 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5153 free (internal_relocs
);
5160 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5162 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
5163 free (internal_relocs
);
5167 /* Return the base VMA address which should be subtracted from real addresses
5168 when resolving @dtpoff relocation.
5169 This is PT_TLS segment p_vaddr. */
5172 dtpoff_base (struct bfd_link_info
*info
)
5174 /* If tls_sec is NULL, we should have signalled an error already. */
5175 if (elf_hash_table (info
)->tls_sec
== NULL
)
5177 return elf_hash_table (info
)->tls_sec
->vma
;
5180 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5183 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
5185 /* If tls_sec is NULL, we should have signalled an error already. */
5186 if (elf_hash_table (info
)->tls_sec
== NULL
)
5188 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5189 structure which has 2 pointer fields. */
5190 return (address
- elf_hash_table (info
)->tls_sec
->vma
5191 + align_power ((bfd_vma
) 8,
5192 elf_hash_table (info
)->tls_sec
->alignment_power
));
5196 sh_elf_gc_mark_hook (asection
*sec
,
5197 struct bfd_link_info
*info
,
5198 Elf_Internal_Rela
*rel
,
5199 struct elf_link_hash_entry
*h
,
5200 Elf_Internal_Sym
*sym
)
5203 switch (ELF32_R_TYPE (rel
->r_info
))
5205 case R_SH_GNU_VTINHERIT
:
5206 case R_SH_GNU_VTENTRY
:
5210 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5213 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5216 sh_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
5217 struct elf_link_hash_entry
*dir
,
5218 struct elf_link_hash_entry
*ind
)
5220 struct elf_sh_link_hash_entry
*edir
, *eind
;
5222 edir
= (struct elf_sh_link_hash_entry
*) dir
;
5223 eind
= (struct elf_sh_link_hash_entry
*) ind
;
5225 edir
->gotplt_refcount
= eind
->gotplt_refcount
;
5226 eind
->gotplt_refcount
= 0;
5227 edir
->funcdesc
.refcount
+= eind
->funcdesc
.refcount
;
5228 eind
->funcdesc
.refcount
= 0;
5229 edir
->abs_funcdesc_refcount
+= eind
->abs_funcdesc_refcount
;
5230 eind
->abs_funcdesc_refcount
= 0;
5232 if (ind
->root
.type
== bfd_link_hash_indirect
5233 && dir
->got
.refcount
<= 0)
5235 edir
->got_type
= eind
->got_type
;
5236 eind
->got_type
= GOT_UNKNOWN
;
5239 if (ind
->root
.type
!= bfd_link_hash_indirect
5240 && dir
->dynamic_adjusted
)
5242 /* If called to transfer flags for a weakdef during processing
5243 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5244 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5245 if (dir
->versioned
!= versioned_hidden
)
5246 dir
->ref_dynamic
|= ind
->ref_dynamic
;
5247 dir
->ref_regular
|= ind
->ref_regular
;
5248 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
5249 dir
->needs_plt
|= ind
->needs_plt
;
5252 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
5256 sh_elf_optimized_tls_reloc (struct bfd_link_info
*info
, int r_type
,
5259 if (bfd_link_pic (info
))
5264 case R_SH_TLS_GD_32
:
5265 case R_SH_TLS_IE_32
:
5267 return R_SH_TLS_LE_32
;
5268 return R_SH_TLS_IE_32
;
5269 case R_SH_TLS_LD_32
:
5270 return R_SH_TLS_LE_32
;
5276 /* Look through the relocs for a section during the first phase.
5277 Since we don't do .gots or .plts, we just need to consider the
5278 virtual table relocs for gc. */
5281 sh_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
5282 const Elf_Internal_Rela
*relocs
)
5284 Elf_Internal_Shdr
*symtab_hdr
;
5285 struct elf_link_hash_entry
**sym_hashes
;
5286 struct elf_sh_link_hash_table
*htab
;
5287 const Elf_Internal_Rela
*rel
;
5288 const Elf_Internal_Rela
*rel_end
;
5290 unsigned int r_type
;
5291 enum got_type got_type
, old_got_type
;
5295 if (bfd_link_relocatable (info
))
5298 BFD_ASSERT (is_sh_elf (abfd
));
5300 symtab_hdr
= &elf_symtab_hdr (abfd
);
5301 sym_hashes
= elf_sym_hashes (abfd
);
5303 htab
= sh_elf_hash_table (info
);
5307 rel_end
= relocs
+ sec
->reloc_count
;
5308 for (rel
= relocs
; rel
< rel_end
; rel
++)
5310 struct elf_link_hash_entry
*h
;
5311 unsigned long r_symndx
;
5313 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5314 r_type
= ELF32_R_TYPE (rel
->r_info
);
5316 if (r_symndx
< symtab_hdr
->sh_info
)
5320 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5321 while (h
->root
.type
== bfd_link_hash_indirect
5322 || h
->root
.type
== bfd_link_hash_warning
)
5323 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5326 r_type
= sh_elf_optimized_tls_reloc (info
, r_type
, h
== NULL
);
5327 if (! bfd_link_pic (info
)
5328 && r_type
== R_SH_TLS_IE_32
5330 && h
->root
.type
!= bfd_link_hash_undefined
5331 && h
->root
.type
!= bfd_link_hash_undefweak
5332 && (h
->dynindx
== -1
5334 r_type
= R_SH_TLS_LE_32
;
5339 case R_SH_GOTOFFFUNCDESC
:
5340 case R_SH_GOTOFFFUNCDESC20
:
5342 case R_SH_GOTFUNCDESC
:
5343 case R_SH_GOTFUNCDESC20
:
5346 if (h
->dynindx
== -1)
5347 switch (ELF_ST_VISIBILITY (h
->other
))
5353 bfd_elf_link_record_dynamic_symbol (info
, h
);
5360 /* Some relocs require a global offset table. */
5361 if (htab
->root
.sgot
== NULL
)
5366 /* This may require an rofixup. */
5376 case R_SH_GOTFUNCDESC
:
5377 case R_SH_GOTFUNCDESC20
:
5378 case R_SH_GOTOFFFUNCDESC
:
5379 case R_SH_GOTOFFFUNCDESC20
:
5381 case R_SH_TLS_GD_32
:
5382 case R_SH_TLS_LD_32
:
5383 case R_SH_TLS_IE_32
:
5384 if (htab
->root
.dynobj
== NULL
)
5385 htab
->root
.dynobj
= abfd
;
5386 if (!create_got_section (htab
->root
.dynobj
, info
))
5397 /* This relocation describes the C++ object vtable hierarchy.
5398 Reconstruct it for later use during GC. */
5399 case R_SH_GNU_VTINHERIT
:
5400 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5404 /* This relocation describes which C++ vtable entries are actually
5405 used. Record for later use during GC. */
5406 case R_SH_GNU_VTENTRY
:
5407 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
5411 case R_SH_TLS_IE_32
:
5412 if (bfd_link_pic (info
))
5413 info
->flags
|= DF_STATIC_TLS
;
5417 case R_SH_TLS_GD_32
:
5420 case R_SH_GOTFUNCDESC
:
5421 case R_SH_GOTFUNCDESC20
:
5425 got_type
= GOT_NORMAL
;
5427 case R_SH_TLS_GD_32
:
5428 got_type
= GOT_TLS_GD
;
5430 case R_SH_TLS_IE_32
:
5431 got_type
= GOT_TLS_IE
;
5433 case R_SH_GOTFUNCDESC
:
5434 case R_SH_GOTFUNCDESC20
:
5435 got_type
= GOT_FUNCDESC
;
5441 h
->got
.refcount
+= 1;
5442 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5446 bfd_signed_vma
*local_got_refcounts
;
5448 /* This is a global offset table entry for a local
5450 local_got_refcounts
= elf_local_got_refcounts (abfd
);
5451 if (local_got_refcounts
== NULL
)
5455 size
= symtab_hdr
->sh_info
;
5456 size
*= sizeof (bfd_signed_vma
);
5457 size
+= symtab_hdr
->sh_info
;
5458 local_got_refcounts
= ((bfd_signed_vma
*)
5459 bfd_zalloc (abfd
, size
));
5460 if (local_got_refcounts
== NULL
)
5462 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
5463 sh_elf_local_got_type (abfd
)
5464 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
5466 local_got_refcounts
[r_symndx
] += 1;
5467 old_got_type
= sh_elf_local_got_type (abfd
) [r_symndx
];
5470 /* If a TLS symbol is accessed using IE at least once,
5471 there is no point to use dynamic model for it. */
5472 if (old_got_type
!= got_type
&& old_got_type
!= GOT_UNKNOWN
5473 && (old_got_type
!= GOT_TLS_GD
|| got_type
!= GOT_TLS_IE
))
5475 if (old_got_type
== GOT_TLS_IE
&& got_type
== GOT_TLS_GD
)
5476 got_type
= GOT_TLS_IE
;
5479 if ((old_got_type
== GOT_FUNCDESC
|| got_type
== GOT_FUNCDESC
)
5480 && (old_got_type
== GOT_NORMAL
|| got_type
== GOT_NORMAL
))
5482 /* xgettext:c-format */
5483 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5484 abfd
, h
->root
.root
.string
);
5485 else if (old_got_type
== GOT_FUNCDESC
5486 || got_type
== GOT_FUNCDESC
)
5488 /* xgettext:c-format */
5489 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5490 abfd
, h
->root
.root
.string
);
5493 /* xgettext:c-format */
5494 (_("%pB: `%s' accessed both as normal and thread local symbol"),
5495 abfd
, h
->root
.root
.string
);
5500 if (old_got_type
!= got_type
)
5503 sh_elf_hash_entry (h
)->got_type
= got_type
;
5505 sh_elf_local_got_type (abfd
) [r_symndx
] = got_type
;
5510 case R_SH_TLS_LD_32
:
5511 sh_elf_hash_table(info
)->tls_ldm_got
.refcount
+= 1;
5515 case R_SH_GOTOFFFUNCDESC
:
5516 case R_SH_GOTOFFFUNCDESC20
:
5520 (_("%pB: Function descriptor relocation with non-zero addend"),
5527 union gotref
*local_funcdesc
;
5529 /* We need a function descriptor for a local symbol. */
5530 local_funcdesc
= sh_elf_local_funcdesc (abfd
);
5531 if (local_funcdesc
== NULL
)
5535 size
= symtab_hdr
->sh_info
* sizeof (union gotref
);
5536 local_funcdesc
= (union gotref
*) bfd_zalloc (abfd
, size
);
5537 if (local_funcdesc
== NULL
)
5539 sh_elf_local_funcdesc (abfd
) = local_funcdesc
;
5541 local_funcdesc
[r_symndx
].refcount
+= 1;
5543 if (r_type
== R_SH_FUNCDESC
)
5545 if (!bfd_link_pic (info
))
5546 htab
->srofixup
->size
+= 4;
5548 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5553 sh_elf_hash_entry (h
)->funcdesc
.refcount
++;
5554 if (r_type
== R_SH_FUNCDESC
)
5555 sh_elf_hash_entry (h
)->abs_funcdesc_refcount
++;
5557 /* If there is a function descriptor reference, then
5558 there should not be any non-FDPIC references. */
5559 old_got_type
= sh_elf_hash_entry (h
)->got_type
;
5560 if (old_got_type
!= GOT_FUNCDESC
&& old_got_type
!= GOT_UNKNOWN
)
5562 if (old_got_type
== GOT_NORMAL
)
5564 /* xgettext:c-format */
5565 (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5566 abfd
, h
->root
.root
.string
);
5569 /* xgettext:c-format */
5570 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5571 abfd
, h
->root
.root
.string
);
5577 /* If this is a local symbol, we resolve it directly without
5578 creating a procedure linkage table entry. */
5582 || ! bfd_link_pic (info
)
5584 || h
->dynindx
== -1)
5588 h
->plt
.refcount
+= 1;
5589 ((struct elf_sh_link_hash_entry
*) h
)->gotplt_refcount
+= 1;
5594 /* This symbol requires a procedure linkage table entry. We
5595 actually build the entry in adjust_dynamic_symbol,
5596 because this might be a case of linking PIC code which is
5597 never referenced by a dynamic object, in which case we
5598 don't need to generate a procedure linkage table entry
5601 /* If this is a local symbol, we resolve it directly without
5602 creating a procedure linkage table entry. */
5606 if (h
->forced_local
)
5610 h
->plt
.refcount
+= 1;
5615 if (h
!= NULL
&& ! bfd_link_pic (info
))
5618 h
->plt
.refcount
+= 1;
5621 /* If we are creating a shared library, and this is a reloc
5622 against a global symbol, or a non PC relative reloc
5623 against a local symbol, then we need to copy the reloc
5624 into the shared library. However, if we are linking with
5625 -Bsymbolic, we do not need to copy a reloc against a
5626 global symbol which is defined in an object we are
5627 including in the link (i.e., DEF_REGULAR is set). At
5628 this point we have not seen all the input files, so it is
5629 possible that DEF_REGULAR is not set now but will be set
5630 later (it is never cleared). We account for that
5631 possibility below by storing information in the
5632 dyn_relocs field of the hash table entry. A similar
5633 situation occurs when creating shared libraries and symbol
5634 visibility changes render the symbol local.
5636 If on the other hand, we are creating an executable, we
5637 may need to keep relocations for symbols satisfied by a
5638 dynamic library if we manage to avoid copy relocs for the
5640 if ((bfd_link_pic (info
)
5641 && (sec
->flags
& SEC_ALLOC
) != 0
5642 && (r_type
!= R_SH_REL32
5644 && (! info
->symbolic
5645 || h
->root
.type
== bfd_link_hash_defweak
5646 || !h
->def_regular
))))
5647 || (! bfd_link_pic (info
)
5648 && (sec
->flags
& SEC_ALLOC
) != 0
5650 && (h
->root
.type
== bfd_link_hash_defweak
5651 || !h
->def_regular
)))
5653 struct elf_dyn_relocs
*p
;
5654 struct elf_dyn_relocs
**head
;
5656 if (htab
->root
.dynobj
== NULL
)
5657 htab
->root
.dynobj
= abfd
;
5659 /* When creating a shared object, we must copy these
5660 reloc types into the output file. We create a reloc
5661 section in dynobj and make room for this reloc. */
5664 sreloc
= _bfd_elf_make_dynamic_reloc_section
5665 (sec
, htab
->root
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
5671 /* If this is a global symbol, we count the number of
5672 relocations we need for this symbol. */
5674 head
= &h
->dyn_relocs
;
5677 /* Track dynamic relocs needed for local syms too. */
5680 Elf_Internal_Sym
*isym
;
5682 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5687 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5691 vpp
= &elf_section_data (s
)->local_dynrel
;
5692 head
= (struct elf_dyn_relocs
**) vpp
;
5696 if (p
== NULL
|| p
->sec
!= sec
)
5698 size_t amt
= sizeof (*p
);
5699 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
5710 if (r_type
== R_SH_REL32
)
5714 /* Allocate the fixup regardless of whether we need a relocation.
5715 If we end up generating the relocation, we'll unallocate the
5717 if (htab
->fdpic_p
&& !bfd_link_pic (info
)
5718 && r_type
== R_SH_DIR32
5719 && (sec
->flags
& SEC_ALLOC
) != 0)
5720 htab
->srofixup
->size
+= 4;
5723 case R_SH_TLS_LE_32
:
5724 if (bfd_link_dll (info
))
5727 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5734 case R_SH_TLS_LDO_32
:
5735 /* Nothing to do. */
5746 #ifndef sh_elf_set_mach_from_flags
5747 static unsigned int sh_ef_bfd_table
[] = { EF_SH_BFD_TABLE
};
5750 sh_elf_set_mach_from_flags (bfd
*abfd
)
5752 flagword flags
= elf_elfheader (abfd
)->e_flags
& EF_SH_MACH_MASK
;
5754 if (flags
>= ARRAY_SIZE (sh_ef_bfd_table
))
5757 if (sh_ef_bfd_table
[flags
] == 0)
5760 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, sh_ef_bfd_table
[flags
]);
5766 /* Reverse table lookup for sh_ef_bfd_table[].
5767 Given a bfd MACH value from archures.c
5768 return the equivalent ELF flags from the table.
5769 Return -1 if no match is found. */
5772 sh_elf_get_flags_from_mach (unsigned long mach
)
5774 int i
= ARRAY_SIZE (sh_ef_bfd_table
) - 1;
5777 if (sh_ef_bfd_table
[i
] == mach
)
5780 /* shouldn't get here */
5785 #endif /* not sh_elf_set_mach_from_flags */
5787 #ifndef sh_elf_copy_private_data
5788 /* Copy backend specific data from one object module to another */
5791 sh_elf_copy_private_data (bfd
* ibfd
, bfd
* obfd
)
5793 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5796 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
5799 return sh_elf_set_mach_from_flags (obfd
);
5801 #endif /* not sh_elf_copy_private_data */
5803 #ifndef sh_elf_merge_private_data
5805 /* This function returns the ELF architecture number that
5806 corresponds to the given arch_sh* flags. */
5809 sh_find_elf_flags (unsigned int arch_set
)
5811 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5812 unsigned long bfd_mach
= sh_get_bfd_mach_from_arch_set (arch_set
);
5814 return sh_elf_get_flags_from_mach (bfd_mach
);
5817 /* Merge the architecture type of two BFD files, such that the
5818 resultant architecture supports all the features required
5819 by the two input BFDs.
5820 If the input BFDs are multually incompatible - i.e. one uses
5821 DSP while the other uses FPU - or there is no known architecture
5822 that fits the requirements then an error is emitted. */
5825 sh_merge_bfd_arch (bfd
*ibfd
, struct bfd_link_info
*info
)
5827 bfd
*obfd
= info
->output_bfd
;
5828 unsigned int old_arch
, new_arch
, merged_arch
;
5830 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
5833 old_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd
));
5834 new_arch
= sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd
));
5836 merged_arch
= SH_MERGE_ARCH_SET (old_arch
, new_arch
);
5838 if (!SH_VALID_CO_ARCH_SET (merged_arch
))
5841 /* xgettext:c-format */
5842 (_("%pB: uses %s instructions while previous modules "
5843 "use %s instructions"),
5845 SH_ARCH_SET_HAS_DSP (new_arch
) ? "dsp" : "floating point",
5846 SH_ARCH_SET_HAS_DSP (new_arch
) ? "floating point" : "dsp");
5847 bfd_set_error (bfd_error_bad_value
);
5850 else if (!SH_VALID_ARCH_SET (merged_arch
))
5853 /* xgettext:c-format */
5854 (_("internal error: merge of architecture '%s' with "
5855 "architecture '%s' produced unknown architecture"),
5856 bfd_printable_name (obfd
),
5857 bfd_printable_name (ibfd
));
5858 bfd_set_error (bfd_error_bad_value
);
5862 bfd_default_set_arch_mach (obfd
, bfd_arch_sh
,
5863 sh_get_bfd_mach_from_arch_set (merged_arch
));
5868 /* This routine initialises the elf flags when required and
5869 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
5872 sh_elf_merge_private_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5874 bfd
*obfd
= info
->output_bfd
;
5876 /* FIXME: What should be checked when linking shared libraries? */
5877 if ((ibfd
->flags
& DYNAMIC
) != 0)
5880 if (! is_sh_elf (ibfd
) || ! is_sh_elf (obfd
))
5883 if (! elf_flags_init (obfd
))
5885 /* This happens when ld starts out with a 'blank' output file. */
5886 elf_flags_init (obfd
) = TRUE
;
5887 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
5888 sh_elf_set_mach_from_flags (obfd
);
5889 if (elf_elfheader (obfd
)->e_flags
& EF_SH_FDPIC
)
5890 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_PIC
;
5893 if (! sh_merge_bfd_arch (ibfd
, info
))
5895 _bfd_error_handler (_("%pB: uses instructions which are incompatible "
5896 "with instructions used in previous modules"),
5898 bfd_set_error (bfd_error_bad_value
);
5902 elf_elfheader (obfd
)->e_flags
&= ~EF_SH_MACH_MASK
;
5903 elf_elfheader (obfd
)->e_flags
|=
5904 sh_elf_get_flags_from_mach (bfd_get_mach (obfd
));
5906 if (fdpic_object_p (ibfd
) != fdpic_object_p (obfd
))
5908 _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
5910 bfd_set_error (bfd_error_bad_value
);
5916 #endif /* not sh_elf_merge_private_data */
5918 /* Override the generic function because we need to store sh_elf_obj_tdata
5919 as the specific tdata. We set also the machine architecture from flags
5923 sh_elf_object_p (bfd
*abfd
)
5925 if (! sh_elf_set_mach_from_flags (abfd
))
5928 return (((elf_elfheader (abfd
)->e_flags
& EF_SH_FDPIC
) != 0)
5929 == fdpic_object_p (abfd
));
5932 /* Finish up dynamic symbol handling. We set the contents of various
5933 dynamic sections here. */
5936 sh_elf_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
5937 struct elf_link_hash_entry
*h
,
5938 Elf_Internal_Sym
*sym
)
5940 struct elf_sh_link_hash_table
*htab
;
5942 htab
= sh_elf_hash_table (info
);
5946 if (h
->plt
.offset
!= (bfd_vma
) -1)
5954 Elf_Internal_Rela rel
;
5956 const struct elf_sh_plt_info
*plt_info
;
5958 /* This symbol has an entry in the procedure linkage table. Set
5961 BFD_ASSERT (h
->dynindx
!= -1);
5963 splt
= htab
->root
.splt
;
5964 sgotplt
= htab
->root
.sgotplt
;
5965 srelplt
= htab
->root
.srelplt
;
5966 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srelplt
!= NULL
);
5968 /* Get the index in the procedure linkage table which
5969 corresponds to this symbol. This is the index of this symbol
5970 in all the symbols for which we are making plt entries. The
5971 first entry in the procedure linkage table is reserved. */
5972 plt_index
= get_plt_index (htab
->plt_info
, h
->plt
.offset
);
5974 plt_info
= htab
->plt_info
;
5975 if (plt_info
->short_plt
!= NULL
&& plt_index
<= MAX_SHORT_PLT
)
5976 plt_info
= plt_info
->short_plt
;
5978 /* Get the offset into the .got table of the entry that
5979 corresponds to this function. */
5981 /* The offset must be relative to the GOT symbol, twelve bytes
5982 before the end of .got.plt. Each descriptor is eight
5984 got_offset
= plt_index
* 8 + 12 - sgotplt
->size
;
5986 /* Each .got entry is 4 bytes. The first three are
5988 got_offset
= (plt_index
+ 3) * 4;
5991 if (bfd_link_pic (info
))
5992 got_offset
-= GOT_BIAS
;
5995 /* Fill in the entry in the procedure linkage table. */
5996 memcpy (splt
->contents
+ h
->plt
.offset
,
5997 plt_info
->symbol_entry
,
5998 plt_info
->symbol_entry_size
);
6000 if (bfd_link_pic (info
) || htab
->fdpic_p
)
6002 if (plt_info
->symbol_fields
.got20
)
6004 bfd_reloc_status_type r
;
6005 r
= install_movi20_field (output_bfd
, got_offset
,
6006 splt
->owner
, splt
, splt
->contents
,
6008 + plt_info
->symbol_fields
.got_entry
);
6009 BFD_ASSERT (r
== bfd_reloc_ok
);
6012 install_plt_field (output_bfd
, FALSE
, got_offset
,
6015 + plt_info
->symbol_fields
.got_entry
));
6019 BFD_ASSERT (!plt_info
->symbol_fields
.got20
);
6021 install_plt_field (output_bfd
, FALSE
,
6022 (sgotplt
->output_section
->vma
6023 + sgotplt
->output_offset
6027 + plt_info
->symbol_fields
.got_entry
));
6028 if (htab
->root
.target_os
== is_vxworks
)
6030 unsigned int reachable_plts
, plts_per_4k
;
6033 /* Divide the PLT into groups. The first group contains
6034 REACHABLE_PLTS entries and the other groups contain
6035 PLTS_PER_4K entries. Entries in the first group can
6036 branch directly to .plt; those in later groups branch
6037 to the last element of the previous group. */
6038 /* ??? It would be better to create multiple copies of
6039 the common resolver stub. */
6040 reachable_plts
= ((4096
6041 - plt_info
->plt0_entry_size
6042 - (plt_info
->symbol_fields
.plt
+ 4))
6043 / plt_info
->symbol_entry_size
) + 1;
6044 plts_per_4k
= (4096 / plt_info
->symbol_entry_size
);
6045 if (plt_index
< reachable_plts
)
6046 distance
= -(h
->plt
.offset
6047 + plt_info
->symbol_fields
.plt
);
6049 distance
= -(((plt_index
- reachable_plts
) % plts_per_4k
+ 1)
6050 * plt_info
->symbol_entry_size
);
6052 /* Install the 'bra' with this offset. */
6053 bfd_put_16 (output_bfd
,
6054 0xa000 | (0x0fff & ((distance
- 4) / 2)),
6057 + plt_info
->symbol_fields
.plt
));
6060 install_plt_field (output_bfd
, TRUE
,
6061 splt
->output_section
->vma
+ splt
->output_offset
,
6064 + plt_info
->symbol_fields
.plt
));
6067 /* Make got_offset relative to the start of .got.plt. */
6069 if (bfd_link_pic (info
))
6070 got_offset
+= GOT_BIAS
;
6073 got_offset
= plt_index
* 8;
6075 if (plt_info
->symbol_fields
.reloc_offset
!= MINUS_ONE
)
6076 install_plt_field (output_bfd
, FALSE
,
6077 plt_index
* sizeof (Elf32_External_Rela
),
6080 + plt_info
->symbol_fields
.reloc_offset
));
6082 /* Fill in the entry in the global offset table. */
6083 bfd_put_32 (output_bfd
,
6084 (splt
->output_section
->vma
6085 + splt
->output_offset
6087 + plt_info
->symbol_resolve_offset
),
6088 sgotplt
->contents
+ got_offset
);
6090 bfd_put_32 (output_bfd
,
6091 sh_elf_osec_to_segment (output_bfd
, splt
->output_section
),
6092 sgotplt
->contents
+ got_offset
+ 4);
6094 /* Fill in the entry in the .rela.plt section. */
6095 rel
.r_offset
= (sgotplt
->output_section
->vma
6096 + sgotplt
->output_offset
6099 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_FUNCDESC_VALUE
);
6101 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
6104 rel
.r_addend
= GOT_BIAS
;
6106 loc
= srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
6107 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6109 if (htab
->root
.target_os
== is_vxworks
&& !bfd_link_pic (info
))
6111 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6112 Begin by pointing LOC to the first such relocation. */
6113 loc
= (htab
->srelplt2
->contents
6114 + (plt_index
* 2 + 1) * sizeof (Elf32_External_Rela
));
6116 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6117 for the PLT entry's pointer to the .got.plt entry. */
6118 rel
.r_offset
= (splt
->output_section
->vma
6119 + splt
->output_offset
6121 + plt_info
->symbol_fields
.got_entry
);
6122 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6123 rel
.r_addend
= got_offset
;
6124 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6125 loc
+= sizeof (Elf32_External_Rela
);
6127 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6128 the .got.plt entry, which initially points to .plt. */
6129 rel
.r_offset
= (sgotplt
->output_section
->vma
6130 + sgotplt
->output_offset
6132 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_SH_DIR32
);
6134 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6137 if (!h
->def_regular
)
6139 /* Mark the symbol as undefined, rather than as defined in
6140 the .plt section. Leave the value alone. */
6141 sym
->st_shndx
= SHN_UNDEF
;
6145 if (h
->got
.offset
!= (bfd_vma
) -1
6146 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_GD
6147 && sh_elf_hash_entry (h
)->got_type
!= GOT_TLS_IE
6148 && sh_elf_hash_entry (h
)->got_type
!= GOT_FUNCDESC
)
6152 Elf_Internal_Rela rel
;
6155 /* This symbol has an entry in the global offset table. Set it
6158 sgot
= htab
->root
.sgot
;
6159 srelgot
= htab
->root
.srelgot
;
6160 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
6162 rel
.r_offset
= (sgot
->output_section
->vma
6163 + sgot
->output_offset
6164 + (h
->got
.offset
&~ (bfd_vma
) 1));
6166 /* If this is a static link, or it is a -Bsymbolic link and the
6167 symbol is defined locally or was forced to be local because
6168 of a version file, we just want to emit a RELATIVE reloc.
6169 The entry in the global offset table will already have been
6170 initialized in the relocate_section function. */
6171 if (bfd_link_pic (info
)
6172 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6176 asection
*sec
= h
->root
.u
.def
.section
;
6178 = elf_section_data (sec
->output_section
)->dynindx
;
6180 rel
.r_info
= ELF32_R_INFO (dynindx
, R_SH_DIR32
);
6181 rel
.r_addend
= (h
->root
.u
.def
.value
6182 + h
->root
.u
.def
.section
->output_offset
);
6186 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
6187 rel
.r_addend
= (h
->root
.u
.def
.value
6188 + h
->root
.u
.def
.section
->output_section
->vma
6189 + h
->root
.u
.def
.section
->output_offset
);
6194 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
6195 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
6199 loc
= srelgot
->contents
;
6200 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6201 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6207 Elf_Internal_Rela rel
;
6210 /* This symbol needs a copy reloc. Set it up. */
6212 BFD_ASSERT (h
->dynindx
!= -1
6213 && (h
->root
.type
== bfd_link_hash_defined
6214 || h
->root
.type
== bfd_link_hash_defweak
));
6216 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
6217 BFD_ASSERT (s
!= NULL
);
6219 rel
.r_offset
= (h
->root
.u
.def
.value
6220 + h
->root
.u
.def
.section
->output_section
->vma
6221 + h
->root
.u
.def
.section
->output_offset
);
6222 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
6224 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
6225 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6228 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
6229 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6231 if (h
== htab
->root
.hdynamic
6232 || (htab
->root
.target_os
!= is_vxworks
&& h
== htab
->root
.hgot
))
6233 sym
->st_shndx
= SHN_ABS
;
6238 /* Finish up the dynamic sections. */
6241 sh_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6243 struct elf_sh_link_hash_table
*htab
;
6247 htab
= sh_elf_hash_table (info
);
6251 sgotplt
= htab
->root
.sgotplt
;
6252 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
6254 if (htab
->root
.dynamic_sections_created
)
6257 Elf32_External_Dyn
*dyncon
, *dynconend
;
6259 BFD_ASSERT (sgotplt
!= NULL
&& sdyn
!= NULL
);
6261 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
6262 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
6263 for (; dyncon
< dynconend
; dyncon
++)
6265 Elf_Internal_Dyn dyn
;
6268 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
6273 if (htab
->root
.target_os
== is_vxworks
6274 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
6275 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6279 BFD_ASSERT (htab
->root
.hgot
!= NULL
);
6280 s
= htab
->root
.hgot
->root
.u
.def
.section
;
6281 dyn
.d_un
.d_ptr
= htab
->root
.hgot
->root
.u
.def
.value
6282 + s
->output_section
->vma
+ s
->output_offset
;
6283 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6287 s
= htab
->root
.srelplt
->output_section
;
6288 BFD_ASSERT (s
!= NULL
);
6289 dyn
.d_un
.d_ptr
= s
->vma
;
6290 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6294 s
= htab
->root
.srelplt
->output_section
;
6295 BFD_ASSERT (s
!= NULL
);
6296 dyn
.d_un
.d_val
= s
->size
;
6297 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6302 /* Fill in the first entry in the procedure linkage table. */
6303 splt
= htab
->root
.splt
;
6304 if (splt
&& splt
->size
> 0 && htab
->plt_info
->plt0_entry
)
6308 memcpy (splt
->contents
,
6309 htab
->plt_info
->plt0_entry
,
6310 htab
->plt_info
->plt0_entry_size
);
6311 for (i
= 0; i
< ARRAY_SIZE (htab
->plt_info
->plt0_got_fields
); i
++)
6312 if (htab
->plt_info
->plt0_got_fields
[i
] != MINUS_ONE
)
6313 install_plt_field (output_bfd
, FALSE
,
6314 (sgotplt
->output_section
->vma
6315 + sgotplt
->output_offset
6318 + htab
->plt_info
->plt0_got_fields
[i
]));
6320 if (htab
->root
.target_os
== is_vxworks
)
6322 /* Finalize the .rela.plt.unloaded contents. */
6323 Elf_Internal_Rela rel
;
6326 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6327 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
6328 loc
= htab
->srelplt2
->contents
;
6329 rel
.r_offset
= (splt
->output_section
->vma
6330 + splt
->output_offset
6331 + htab
->plt_info
->plt0_got_fields
[2]);
6332 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_SH_DIR32
);
6334 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
6335 loc
+= sizeof (Elf32_External_Rela
);
6337 /* Fix up the remaining .rela.plt.unloaded relocations.
6338 They may have the wrong symbol index for _G_O_T_ or
6339 _P_L_T_ depending on the order in which symbols were
6341 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
6343 /* The PLT entry's pointer to the .got.plt slot. */
6344 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6345 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
,
6347 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6348 loc
+= sizeof (Elf32_External_Rela
);
6350 /* The .got.plt slot's pointer to .plt. */
6351 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
6352 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
,
6354 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
6355 loc
+= sizeof (Elf32_External_Rela
);
6359 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6360 really seem like the right value. */
6361 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
6365 /* Fill in the first three entries in the global offset table. */
6366 if (sgotplt
&& sgotplt
->size
> 0 && !htab
->fdpic_p
)
6369 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
6371 bfd_put_32 (output_bfd
,
6372 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6374 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
6375 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
6378 if (sgotplt
&& sgotplt
->size
> 0)
6379 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
6381 /* At the very end of the .rofixup section is a pointer to the GOT. */
6382 if (htab
->fdpic_p
&& htab
->srofixup
!= NULL
)
6384 struct elf_link_hash_entry
*hgot
= htab
->root
.hgot
;
6385 bfd_vma got_value
= hgot
->root
.u
.def
.value
6386 + hgot
->root
.u
.def
.section
->output_section
->vma
6387 + hgot
->root
.u
.def
.section
->output_offset
;
6389 sh_elf_add_rofixup (output_bfd
, htab
->srofixup
, got_value
);
6391 /* Make sure we allocated and generated the same number of fixups. */
6392 BFD_ASSERT (htab
->srofixup
->reloc_count
* 4 == htab
->srofixup
->size
);
6395 if (htab
->srelfuncdesc
)
6396 BFD_ASSERT (htab
->srelfuncdesc
->reloc_count
* sizeof (Elf32_External_Rela
)
6397 == htab
->srelfuncdesc
->size
);
6399 if (htab
->root
.srelgot
)
6400 BFD_ASSERT (htab
->root
.srelgot
->reloc_count
* sizeof (Elf32_External_Rela
)
6401 == htab
->root
.srelgot
->size
);
6406 static enum elf_reloc_type_class
6407 sh_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6408 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6409 const Elf_Internal_Rela
*rela
)
6411 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6414 return reloc_class_relative
;
6416 return reloc_class_plt
;
6418 return reloc_class_copy
;
6420 return reloc_class_normal
;
6424 #if !defined SH_TARGET_ALREADY_DEFINED
6425 /* Support for Linux core dump NOTE sections. */
6428 elf32_shlin_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6433 switch (note
->descsz
)
6438 case 168: /* Linux/SH */
6440 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
6443 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
6452 /* Make a ".reg/999" section. */
6453 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6454 size
, note
->descpos
+ offset
);
6458 elf32_shlin_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6460 switch (note
->descsz
)
6465 case 124: /* Linux/SH elf_prpsinfo */
6466 elf_tdata (abfd
)->core
->program
6467 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
6468 elf_tdata (abfd
)->core
->command
6469 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
6472 /* Note that for some reason, a spurious space is tacked
6473 onto the end of the args in some (at least one anyway)
6474 implementations, so strip it off if it exists. */
6477 char *command
= elf_tdata (abfd
)->core
->command
;
6478 int n
= strlen (command
);
6480 if (0 < n
&& command
[n
- 1] == ' ')
6481 command
[n
- 1] = '\0';
6486 #endif /* not SH_TARGET_ALREADY_DEFINED */
6489 /* Return address for Ith PLT stub in section PLT, for relocation REL
6490 or (bfd_vma) -1 if it should not be included. */
6493 sh_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
6494 const arelent
*rel ATTRIBUTE_UNUSED
)
6496 const struct elf_sh_plt_info
*plt_info
;
6498 plt_info
= get_plt_info (plt
->owner
, (plt
->owner
->flags
& DYNAMIC
) != 0);
6499 return plt
->vma
+ get_plt_offset (plt_info
, i
);
6502 /* Decide whether to attempt to turn absptr or lsda encodings in
6503 shared libraries into pcrel within the given input section. */
6506 sh_elf_use_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6507 struct bfd_link_info
*info
,
6508 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
6510 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6512 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
6519 /* Adjust the contents of an eh_frame_hdr section before they're output. */
6522 sh_elf_encode_eh_address (bfd
*abfd
,
6523 struct bfd_link_info
*info
,
6524 asection
*osec
, bfd_vma offset
,
6525 asection
*loc_sec
, bfd_vma loc_offset
,
6528 struct elf_sh_link_hash_table
*htab
= sh_elf_hash_table (info
);
6529 struct elf_link_hash_entry
*h
;
6532 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
, loc_sec
,
6533 loc_offset
, encoded
);
6535 h
= htab
->root
.hgot
;
6536 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
6538 if (! h
|| (sh_elf_osec_to_segment (abfd
, osec
)
6539 == sh_elf_osec_to_segment (abfd
, loc_sec
->output_section
)))
6540 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
6541 loc_sec
, loc_offset
, encoded
);
6543 BFD_ASSERT (sh_elf_osec_to_segment (abfd
, osec
)
6544 == (sh_elf_osec_to_segment
6545 (abfd
, h
->root
.u
.def
.section
->output_section
)));
6547 *encoded
= osec
->vma
+ offset
6548 - (h
->root
.u
.def
.value
6549 + h
->root
.u
.def
.section
->output_section
->vma
6550 + h
->root
.u
.def
.section
->output_offset
);
6552 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
6555 #if !defined SH_TARGET_ALREADY_DEFINED
6556 #define TARGET_BIG_SYM sh_elf32_vec
6557 #define TARGET_BIG_NAME "elf32-sh"
6558 #define TARGET_LITTLE_SYM sh_elf32_le_vec
6559 #define TARGET_LITTLE_NAME "elf32-shl"
6562 #define ELF_ARCH bfd_arch_sh
6563 #define ELF_TARGET_ID SH_ELF_DATA
6564 #define ELF_MACHINE_CODE EM_SH
6565 #ifdef __QNXTARGET__
6566 #define ELF_MAXPAGESIZE 0x1000
6568 #define ELF_MAXPAGESIZE 0x80
6571 #define elf_symbol_leading_char '_'
6573 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6574 #define bfd_elf32_bfd_reloc_name_lookup \
6575 sh_elf_reloc_name_lookup
6576 #define elf_info_to_howto sh_elf_info_to_howto
6577 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
6578 #define elf_backend_relocate_section sh_elf_relocate_section
6579 #define bfd_elf32_bfd_get_relocated_section_contents \
6580 sh_elf_get_relocated_section_contents
6581 #define bfd_elf32_mkobject sh_elf_mkobject
6582 #define elf_backend_object_p sh_elf_object_p
6583 #define bfd_elf32_bfd_copy_private_bfd_data \
6584 sh_elf_copy_private_data
6585 #define bfd_elf32_bfd_merge_private_bfd_data \
6586 sh_elf_merge_private_data
6588 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
6589 #define elf_backend_check_relocs sh_elf_check_relocs
6590 #define elf_backend_copy_indirect_symbol \
6591 sh_elf_copy_indirect_symbol
6592 #define elf_backend_create_dynamic_sections \
6593 sh_elf_create_dynamic_sections
6594 #define bfd_elf32_bfd_link_hash_table_create \
6595 sh_elf_link_hash_table_create
6596 #define elf_backend_adjust_dynamic_symbol \
6597 sh_elf_adjust_dynamic_symbol
6598 #define elf_backend_always_size_sections \
6599 sh_elf_always_size_sections
6600 #define elf_backend_size_dynamic_sections \
6601 sh_elf_size_dynamic_sections
6602 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6603 #define elf_backend_finish_dynamic_symbol \
6604 sh_elf_finish_dynamic_symbol
6605 #define elf_backend_finish_dynamic_sections \
6606 sh_elf_finish_dynamic_sections
6607 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
6608 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
6609 #define elf_backend_can_make_relative_eh_frame \
6610 sh_elf_use_relative_eh_frame
6611 #define elf_backend_can_make_lsda_relative_eh_frame \
6612 sh_elf_use_relative_eh_frame
6613 #define elf_backend_encode_eh_address \
6614 sh_elf_encode_eh_address
6616 #define elf_backend_stack_align 8
6617 #define elf_backend_can_gc_sections 1
6618 #define elf_backend_can_refcount 1
6619 #define elf_backend_want_got_plt 1
6620 #define elf_backend_plt_readonly 1
6621 #define elf_backend_want_plt_sym 0
6622 #define elf_backend_got_header_size 12
6623 #define elf_backend_dtrel_excludes_plt 1
6625 #define elf_backend_linux_prpsinfo32_ugid16 TRUE
6627 #if !defined SH_TARGET_ALREADY_DEFINED
6629 #include "elf32-target.h"
6631 /* NetBSD support. */
6632 #undef TARGET_BIG_SYM
6633 #define TARGET_BIG_SYM sh_elf32_nbsd_vec
6634 #undef TARGET_BIG_NAME
6635 #define TARGET_BIG_NAME "elf32-sh-nbsd"
6636 #undef TARGET_LITTLE_SYM
6637 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
6638 #undef TARGET_LITTLE_NAME
6639 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
6640 #undef ELF_MAXPAGESIZE
6641 #define ELF_MAXPAGESIZE 0x10000
6642 #undef ELF_COMMONPAGESIZE
6643 #undef elf_symbol_leading_char
6644 #define elf_symbol_leading_char 0
6646 #define elf32_bed elf32_sh_nbsd_bed
6648 #include "elf32-target.h"
6651 /* Linux support. */
6652 #undef TARGET_BIG_SYM
6653 #define TARGET_BIG_SYM sh_elf32_linux_be_vec
6654 #undef TARGET_BIG_NAME
6655 #define TARGET_BIG_NAME "elf32-shbig-linux"
6656 #undef TARGET_LITTLE_SYM
6657 #define TARGET_LITTLE_SYM sh_elf32_linux_vec
6658 #undef TARGET_LITTLE_NAME
6659 #define TARGET_LITTLE_NAME "elf32-sh-linux"
6660 #undef ELF_COMMONPAGESIZE
6661 #define ELF_COMMONPAGESIZE 0x1000
6663 #undef elf_backend_grok_prstatus
6664 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
6665 #undef elf_backend_grok_psinfo
6666 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
6668 #define elf32_bed elf32_sh_lin_bed
6670 #include "elf32-target.h"
6673 /* FDPIC support. */
6674 #undef TARGET_BIG_SYM
6675 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
6676 #undef TARGET_BIG_NAME
6677 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
6678 #undef TARGET_LITTLE_SYM
6679 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
6680 #undef TARGET_LITTLE_NAME
6681 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
6684 #define elf32_bed elf32_sh_fd_bed
6686 #include "elf32-target.h"
6688 /* VxWorks support. */
6689 #undef TARGET_BIG_SYM
6690 #define TARGET_BIG_SYM sh_elf32_vxworks_vec
6691 #undef TARGET_BIG_NAME
6692 #define TARGET_BIG_NAME "elf32-sh-vxworks"
6693 #undef TARGET_LITTLE_SYM
6694 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
6695 #undef TARGET_LITTLE_NAME
6696 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
6698 #define elf32_bed elf32_sh_vxworks_bed
6700 #undef elf_backend_want_plt_sym
6701 #define elf_backend_want_plt_sym 1
6702 #undef elf_symbol_leading_char
6703 #define elf_symbol_leading_char '_'
6704 #define elf_backend_want_got_underscore 1
6705 #undef elf_backend_grok_prstatus
6706 #undef elf_backend_grok_psinfo
6707 #undef elf_backend_add_symbol_hook
6708 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
6709 #undef elf_backend_link_output_symbol_hook
6710 #define elf_backend_link_output_symbol_hook \
6711 elf_vxworks_link_output_symbol_hook
6712 #undef elf_backend_emit_relocs
6713 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6714 #undef elf_backend_final_write_processing
6715 #define elf_backend_final_write_processing \
6716 elf_vxworks_final_write_processing
6717 #undef ELF_MAXPAGESIZE
6718 #define ELF_MAXPAGESIZE 0x1000
6719 #undef ELF_COMMONPAGESIZE
6721 #undef ELF_TARGET_OS
6722 #define ELF_TARGET_OS is_vxworks
6724 #include "elf32-target.h"
6726 #endif /* not SH_TARGET_ALREADY_DEFINED */