1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright (C) 1996-2017 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 static bfd_reloc_status_type sh_elf_reloc
34 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
35 static bfd_reloc_status_type sh_elf_ignore_reloc
36 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
37 static bfd_boolean sh_elf_relax_delete_bytes
38 (bfd *, asection *, bfd_vma, int);
39 static bfd_boolean sh_elf_align_loads
40 (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
42 static bfd_boolean sh_elf_swap_insns
43 (bfd *, asection *, void *, bfd_byte *, bfd_vma);
45 static int sh_elf_optimized_tls_reloc
46 (struct bfd_link_info *, int, int);
47 static bfd_vma dtpoff_base
48 (struct bfd_link_info *);
50 (struct bfd_link_info *, bfd_vma);
52 /* The name of the dynamic interpreter. This is put in the .interp
55 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
57 /* FDPIC binaries have a default 128K stack. */
58 #define DEFAULT_STACK_SIZE 0x20000
60 #define MINUS_ONE ((bfd_vma) 0 - 1)
62 /* Decide whether a reference to a symbol can be resolved locally or
63 not. If the symbol is protected, we want the local address, but
64 its function descriptor must be assigned by the dynamic linker. */
65 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
66 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
67 || ! elf_hash_table (INFO)->dynamic_sections_created)
69 #define SH_PARTIAL32 TRUE
70 #define SH_SRC_MASK32 0xffffffff
71 #define SH_ELF_RELOC sh_elf_reloc
72 static reloc_howto_type sh_elf_howto_table[] =
74 #include "elf32-sh-relocs.h"
77 #define SH_PARTIAL32 FALSE
78 #define SH_SRC_MASK32 0
79 #define SH_ELF_RELOC bfd_elf_generic_reloc
80 static reloc_howto_type sh_vxworks_howto_table[] =
82 #include "elf32-sh-relocs.h"
85 /* Return true if OUTPUT_BFD is a VxWorks object. */
88 vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
90 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
91 extern const bfd_target sh_elf32_vxworks_le_vec;
92 extern const bfd_target sh_elf32_vxworks_vec;
94 return (abfd->xvec == &sh_elf32_vxworks_le_vec
95 || abfd->xvec == &sh_elf32_vxworks_vec);
101 /* Return true if OUTPUT_BFD is an FDPIC object. */
104 fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
106 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
107 extern const bfd_target sh_elf32_fdpic_le_vec;
108 extern const bfd_target sh_elf32_fdpic_be_vec;
110 return (abfd->xvec == &sh_elf32_fdpic_le_vec
111 || abfd->xvec == &sh_elf32_fdpic_be_vec);
117 /* Return the howto table for ABFD. */
119 static reloc_howto_type *
120 get_howto_table (bfd *abfd)
122 if (vxworks_object_p (abfd))
123 return sh_vxworks_howto_table;
124 return sh_elf_howto_table;
127 static bfd_reloc_status_type
128 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED, bfd *input_bfd,
129 asection *input_section, bfd_byte *contents,
130 bfd_vma addr, asection *symbol_section,
131 bfd_vma start, bfd_vma end)
133 static bfd_vma last_addr;
134 static asection *last_symbol_section;
135 bfd_byte *start_ptr, *ptr, *last_ptr;
140 /* Sanity check the address. */
141 if (addr > bfd_get_section_limit (input_bfd, input_section))
142 return bfd_reloc_outofrange;
144 /* We require the start and end relocations to be processed consecutively -
145 although we allow then to be processed forwards or backwards. */
149 last_symbol_section = symbol_section;
152 if (last_addr != addr)
156 if (! symbol_section || last_symbol_section != symbol_section || end < start)
157 return bfd_reloc_outofrange;
159 /* Get the symbol_section contents. */
160 if (symbol_section != input_section)
162 if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
163 contents = elf_section_data (symbol_section)->this_hdr.contents;
166 if (!bfd_malloc_and_get_section (input_bfd, symbol_section,
169 if (contents != NULL)
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;
206 && elf_section_data (symbol_section)->this_hdr.contents != contents)
209 insn = bfd_get_16 (input_bfd, contents + addr);
211 x = (insn & 0x200 ? end : start) - addr;
212 if (input_section != symbol_section)
213 x += ((symbol_section->output_section->vma + symbol_section->output_offset)
214 - (input_section->output_section->vma
215 + input_section->output_offset));
217 if (x < -128 || x > 127)
218 return bfd_reloc_overflow;
220 x = (insn & ~0xff) | (x & 0xff);
221 bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
226 /* This function is used for normal relocs. This used to be like the COFF
227 function, and is almost certainly incorrect for other ELF targets. */
229 static bfd_reloc_status_type
230 sh_elf_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
231 void *data, asection *input_section, bfd *output_bfd,
232 char **error_message ATTRIBUTE_UNUSED)
236 enum elf_sh_reloc_type r_type;
237 bfd_vma addr = reloc_entry->address;
238 bfd_byte *hit_data = addr + (bfd_byte *) data;
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 (addr * bfd_octets_per_byte (abfd) + 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, (bfd_vma) 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) << 1;
287 insn = (insn & 0xf000) | (sym_value & 0xfff);
288 bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
289 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
290 return bfd_reloc_overflow;
300 /* This function is used for relocs which are only used for relaxing,
301 which the linker should otherwise ignore. */
303 static bfd_reloc_status_type
304 sh_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
305 asymbol *symbol ATTRIBUTE_UNUSED,
306 void *data ATTRIBUTE_UNUSED, asection *input_section,
308 char **error_message ATTRIBUTE_UNUSED)
310 if (output_bfd != NULL)
311 reloc_entry->address += input_section->output_offset;
315 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
319 bfd_reloc_code_real_type bfd_reloc_val;
320 unsigned char elf_reloc_val;
323 /* An array mapping BFD reloc codes to SH ELF relocs. */
325 static const struct elf_reloc_map sh_reloc_map[] =
327 { BFD_RELOC_NONE, R_SH_NONE },
328 { BFD_RELOC_32, R_SH_DIR32 },
329 { BFD_RELOC_16, R_SH_DIR16 },
330 { BFD_RELOC_8, R_SH_DIR8 },
331 { BFD_RELOC_CTOR, R_SH_DIR32 },
332 { BFD_RELOC_32_PCREL, R_SH_REL32 },
333 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
334 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
335 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
336 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
337 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
338 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
339 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
340 { BFD_RELOC_SH_USES, R_SH_USES },
341 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
342 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
343 { BFD_RELOC_SH_CODE, R_SH_CODE },
344 { BFD_RELOC_SH_DATA, R_SH_DATA },
345 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
346 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
347 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
348 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
349 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
350 { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
351 { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
352 { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
353 { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
354 { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
355 { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
356 { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
357 { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
358 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
359 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
360 { BFD_RELOC_SH_COPY, R_SH_COPY },
361 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
362 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
363 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
364 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
365 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
366 { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
367 { BFD_RELOC_SH_GOT20, R_SH_GOT20 },
368 { BFD_RELOC_SH_GOTOFF20, R_SH_GOTOFF20 },
369 { BFD_RELOC_SH_GOTFUNCDESC, R_SH_GOTFUNCDESC },
370 { BFD_RELOC_SH_GOTFUNCDESC20, R_SH_GOTFUNCDESC20 },
371 { BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC },
372 { BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 },
373 { BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC },
374 #ifdef INCLUDE_SHMEDIA
375 { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
376 { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
377 { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
378 { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
379 { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
380 { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
381 { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
382 { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
383 { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
384 { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
385 { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
386 { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
387 { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
388 { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
389 { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
390 { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
391 { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
392 { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
393 { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
394 { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
395 { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
396 { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
397 { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
398 { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
399 { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
400 { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
401 { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
402 { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
403 { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
404 { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
405 { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
406 { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
407 { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
408 { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
409 { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
410 { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
411 { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
412 { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
413 { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
414 { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
415 { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
416 { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
417 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
418 { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
419 { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
420 { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
421 { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
422 { BFD_RELOC_64, R_SH_64 },
423 { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
424 #endif /* not INCLUDE_SHMEDIA */
427 /* Given a BFD reloc code, return the howto structure for the
428 corresponding SH ELF reloc. */
430 static reloc_howto_type *
431 sh_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
435 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
437 if (sh_reloc_map[i].bfd_reloc_val == code)
438 return get_howto_table (abfd) + (int) sh_reloc_map[i].elf_reloc_val;
444 static reloc_howto_type *
445 sh_elf_reloc_name_lookup (bfd *abfd, const char *r_name)
449 if (vxworks_object_p (abfd))
452 i < (sizeof (sh_vxworks_howto_table)
453 / sizeof (sh_vxworks_howto_table[0]));
455 if (sh_vxworks_howto_table[i].name != NULL
456 && strcasecmp (sh_vxworks_howto_table[i].name, r_name) == 0)
457 return &sh_vxworks_howto_table[i];
462 i < (sizeof (sh_elf_howto_table)
463 / sizeof (sh_elf_howto_table[0]));
465 if (sh_elf_howto_table[i].name != NULL
466 && strcasecmp (sh_elf_howto_table[i].name, r_name) == 0)
467 return &sh_elf_howto_table[i];
473 /* Given an ELF reloc, fill in the howto field of a relent. */
476 sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
480 r = ELF32_R_TYPE (dst->r_info);
483 || (r >= R_SH_FIRST_INVALID_RELOC && r <= R_SH_LAST_INVALID_RELOC)
484 || (r >= R_SH_FIRST_INVALID_RELOC_2 && r <= R_SH_LAST_INVALID_RELOC_2)
485 || (r >= R_SH_FIRST_INVALID_RELOC_3 && r <= R_SH_LAST_INVALID_RELOC_3)
486 || (r >= R_SH_FIRST_INVALID_RELOC_4 && r <= R_SH_LAST_INVALID_RELOC_4)
487 || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)
488 || (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
490 /* xgettext:c-format */
491 _bfd_error_handler (_("%B: unrecognised SH reloc number: %d"),
493 bfd_set_error (bfd_error_bad_value);
497 cache_ptr->howto = get_howto_table (abfd) + r;
500 /* This function handles relaxing for SH ELF. See the corresponding
501 function in coff-sh.c for a description of what this does. FIXME:
502 There is a lot of duplication here between this code and the COFF
503 specific code. The format of relocs and symbols is wound deeply
504 into this code, but it would still be better if the duplication
505 could be eliminated somehow. Note in particular that although both
506 functions use symbols like R_SH_CODE, those symbols have different
507 values; in coff-sh.c they come from include/coff/sh.h, whereas here
508 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
511 sh_elf_relax_section (bfd *abfd, asection *sec,
512 struct bfd_link_info *link_info, bfd_boolean *again)
514 Elf_Internal_Shdr *symtab_hdr;
515 Elf_Internal_Rela *internal_relocs;
516 bfd_boolean have_code;
517 Elf_Internal_Rela *irel, *irelend;
518 bfd_byte *contents = NULL;
519 Elf_Internal_Sym *isymbuf = NULL;
523 if (bfd_link_relocatable (link_info)
524 || (sec->flags & SEC_RELOC) == 0
525 || sec->reloc_count == 0)
528 #ifdef INCLUDE_SHMEDIA
529 if (elf_section_data (sec)->this_hdr.sh_flags
530 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
536 symtab_hdr = &elf_symtab_hdr (abfd);
538 internal_relocs = (_bfd_elf_link_read_relocs
539 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
540 link_info->keep_memory));
541 if (internal_relocs == NULL)
546 irelend = internal_relocs + sec->reloc_count;
547 for (irel = internal_relocs; irel < irelend; irel++)
549 bfd_vma laddr, paddr, symval;
551 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
554 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
557 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
560 /* Get the section contents. */
561 if (contents == NULL)
563 if (elf_section_data (sec)->this_hdr.contents != NULL)
564 contents = elf_section_data (sec)->this_hdr.contents;
567 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
572 /* The r_addend field of the R_SH_USES reloc will point us to
573 the register load. The 4 is because the r_addend field is
574 computed as though it were a jump offset, which are based
575 from 4 bytes after the jump instruction. */
576 laddr = irel->r_offset + 4 + irel->r_addend;
577 if (laddr >= sec->size)
579 /* xgettext:c-format */
580 _bfd_error_handler (_("%B: %#Lx: warning: bad R_SH_USES offset"),
581 abfd, irel->r_offset);
584 insn = bfd_get_16 (abfd, contents + laddr);
586 /* If the instruction is not mov.l NN,rN, we don't know what to
588 if ((insn & 0xf000) != 0xd000)
591 /* xgettext:c-format */
592 (_("%B: %#Lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
593 abfd, irel->r_offset, insn);
597 /* Get the address from which the register is being loaded. The
598 displacement in the mov.l instruction is quadrupled. It is a
599 displacement from four bytes after the movl instruction, but,
600 before adding in the PC address, two least significant bits
601 of the PC are cleared. We assume that the section is aligned
602 on a four byte boundary. */
605 paddr += (laddr + 4) &~ (bfd_vma) 3;
606 if (paddr >= sec->size)
609 /* xgettext:c-format */
610 (_("%B: %#Lx: warning: bad R_SH_USES load offset"),
611 abfd, irel->r_offset);
615 /* Get the reloc for the address from which the register is
616 being loaded. This reloc will tell us which function is
617 actually being called. */
618 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
619 if (irelfn->r_offset == paddr
620 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
622 if (irelfn >= irelend)
625 /* xgettext:c-format */
626 (_("%B: %#Lx: warning: could not find expected reloc"),
631 /* Read this BFD's symbols if we haven't done so already. */
632 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
634 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
636 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
637 symtab_hdr->sh_info, 0,
643 /* Get the value of the symbol referred to by the reloc. */
644 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
646 /* A local symbol. */
647 Elf_Internal_Sym *isym;
649 isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
651 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
654 /* xgettext:c-format */
655 (_("%B: %#Lx: warning: symbol in unexpected section"),
660 symval = (isym->st_value
661 + sec->output_section->vma
662 + sec->output_offset);
667 struct elf_link_hash_entry *h;
669 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
670 h = elf_sym_hashes (abfd)[indx];
671 BFD_ASSERT (h != NULL);
672 if (h->root.type != bfd_link_hash_defined
673 && h->root.type != bfd_link_hash_defweak)
675 /* This appears to be a reference to an undefined
676 symbol. Just ignore it--it will be caught by the
677 regular reloc processing. */
681 symval = (h->root.u.def.value
682 + h->root.u.def.section->output_section->vma
683 + h->root.u.def.section->output_offset);
686 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
687 symval += bfd_get_32 (abfd, contents + paddr);
689 symval += irelfn->r_addend;
691 /* See if this function call can be shortened. */
694 + sec->output_section->vma
697 /* A branch to an address beyond ours might be increased by an
698 .align that doesn't move when bytes behind us are deleted.
699 So, we add some slop in this calculation to allow for
701 if (foff < -0x1000 || foff >= 0x1000 - 8)
703 /* After all that work, we can't shorten this function call. */
707 /* Shorten the function call. */
709 /* For simplicity of coding, we are going to modify the section
710 contents, the section relocs, and the BFD symbol table. We
711 must tell the rest of the code not to free up this
712 information. It would be possible to instead create a table
713 of changes which have to be made, as is done in coff-mips.c;
714 that would be more work, but would require less memory when
715 the linker is run. */
717 elf_section_data (sec)->relocs = internal_relocs;
718 elf_section_data (sec)->this_hdr.contents = contents;
719 symtab_hdr->contents = (unsigned char *) isymbuf;
721 /* Replace the jmp/jsr with a bra/bsr. */
723 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
724 replace the jmp/jsr with a bra/bsr. */
725 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
726 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
727 here, but that only checks if the symbol is an external symbol,
728 not if the symbol is in a different section. Besides, we need
729 a consistent meaning for the relocation, so we just assume here that
730 the value of the symbol is not available. */
732 /* We can't fully resolve this yet, because the external
733 symbol value may be changed by future relaxing. We let
734 the final link phase handle it. */
735 if (bfd_get_16 (abfd, contents + irel->r_offset) & 0x0020)
736 bfd_put_16 (abfd, (bfd_vma) 0xa000, contents + irel->r_offset);
738 bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
742 /* When we calculated the symbol "value" we had an offset in the
743 DIR32's word in memory (we read and add it above). However,
744 the jsr we create does NOT have this offset encoded, so we
745 have to add it to the addend to preserve it. */
746 irel->r_addend += bfd_get_32 (abfd, contents + paddr);
748 /* See if there is another R_SH_USES reloc referring to the same
750 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
751 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
752 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
754 if (irelscan < irelend)
756 /* Some other function call depends upon this register load,
757 and we have not yet converted that function call.
758 Indeed, we may never be able to convert it. There is
759 nothing else we can do at this point. */
763 /* Look for a R_SH_COUNT reloc on the location where the
764 function address is stored. Do this before deleting any
765 bytes, to avoid confusion about the address. */
766 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
767 if (irelcount->r_offset == paddr
768 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
771 /* Delete the register load. */
772 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
775 /* That will change things, so, just in case it permits some
776 other function call to come within range, we should relax
777 again. Note that this is not required, and it may be slow. */
780 /* Now check whether we got a COUNT reloc. */
781 if (irelcount >= irelend)
784 /* xgettext:c-format */
785 (_("%B: %#Lx: warning: could not find expected COUNT reloc"),
790 /* The number of uses is stored in the r_addend field. We've
792 if (irelcount->r_addend == 0)
794 /* xgettext:c-format */
795 _bfd_error_handler (_("%B: %#Lx: warning: bad count"),
800 --irelcount->r_addend;
802 /* If there are no more uses, we can delete the address. Reload
803 the address from irelfn, in case it was changed by the
804 previous call to sh_elf_relax_delete_bytes. */
805 if (irelcount->r_addend == 0)
807 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
811 /* We've done all we can with that function call. */
814 /* Look for load and store instructions that we can align on four
816 if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
821 /* Get the section contents. */
822 if (contents == NULL)
824 if (elf_section_data (sec)->this_hdr.contents != NULL)
825 contents = elf_section_data (sec)->this_hdr.contents;
828 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
833 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
839 elf_section_data (sec)->relocs = internal_relocs;
840 elf_section_data (sec)->this_hdr.contents = contents;
841 symtab_hdr->contents = (unsigned char *) isymbuf;
846 && symtab_hdr->contents != (unsigned char *) isymbuf)
848 if (! link_info->keep_memory)
852 /* Cache the symbols for elf_link_input_bfd. */
853 symtab_hdr->contents = (unsigned char *) isymbuf;
858 && elf_section_data (sec)->this_hdr.contents != contents)
860 if (! link_info->keep_memory)
864 /* Cache the section contents for elf_link_input_bfd. */
865 elf_section_data (sec)->this_hdr.contents = contents;
869 if (internal_relocs != NULL
870 && elf_section_data (sec)->relocs != internal_relocs)
871 free (internal_relocs);
877 && symtab_hdr->contents != (unsigned char *) isymbuf)
880 && elf_section_data (sec)->this_hdr.contents != contents)
882 if (internal_relocs != NULL
883 && elf_section_data (sec)->relocs != internal_relocs)
884 free (internal_relocs);
889 /* Delete some bytes from a section while relaxing. FIXME: There is a
890 lot of duplication between this function and sh_relax_delete_bytes
894 sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr,
897 Elf_Internal_Shdr *symtab_hdr;
898 unsigned int sec_shndx;
900 Elf_Internal_Rela *irel, *irelend;
901 Elf_Internal_Rela *irelalign;
903 Elf_Internal_Sym *isymbuf, *isym, *isymend;
904 struct elf_link_hash_entry **sym_hashes;
905 struct elf_link_hash_entry **end_hashes;
906 unsigned int symcount;
909 symtab_hdr = &elf_symtab_hdr (abfd);
910 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
912 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
914 contents = elf_section_data (sec)->this_hdr.contents;
916 /* The deletion must stop at the next ALIGN reloc for an aligment
917 power larger than the number of bytes we are deleting. */
922 irel = elf_section_data (sec)->relocs;
923 irelend = irel + sec->reloc_count;
924 for (; irel < irelend; irel++)
926 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
927 && irel->r_offset > addr
928 && count < (1 << irel->r_addend))
931 toaddr = irel->r_offset;
936 /* Actually delete the bytes. */
937 memmove (contents + addr, contents + addr + count,
938 (size_t) (toaddr - addr - count));
939 if (irelalign == NULL)
945 #define NOP_OPCODE (0x0009)
947 BFD_ASSERT ((count & 1) == 0);
948 for (i = 0; i < count; i += 2)
949 bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
952 /* Adjust all the relocs. */
953 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
955 bfd_vma nraddr, stop;
958 int off, adjust, oinsn;
959 bfd_signed_vma voff = 0;
960 bfd_boolean overflow;
962 /* Get the new reloc address. */
963 nraddr = irel->r_offset;
964 if ((irel->r_offset > addr
965 && irel->r_offset < toaddr)
966 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
967 && irel->r_offset == toaddr))
970 /* See if this reloc was for the bytes we have deleted, in which
971 case we no longer care about it. Don't delete relocs which
972 represent addresses, though. */
973 if (irel->r_offset >= addr
974 && irel->r_offset < addr + count
975 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
976 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
977 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
978 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
979 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
982 /* If this is a PC relative reloc, see if the range it covers
983 includes the bytes we have deleted. */
984 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
993 start = irel->r_offset;
994 insn = bfd_get_16 (abfd, contents + nraddr);
998 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1001 start = stop = addr;
1005 /* If this reloc is against a symbol defined in this
1006 section, and the symbol will not be adjusted below, we
1007 must check the addend to see it will put the value in
1008 range to be adjusted, and hence must be changed. */
1009 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1011 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1012 if (isym->st_shndx == sec_shndx
1013 && (isym->st_value <= addr
1014 || isym->st_value >= toaddr))
1018 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
1020 val = bfd_get_32 (abfd, contents + nraddr);
1021 val += isym->st_value;
1022 if (val > addr && val < toaddr)
1023 bfd_put_32 (abfd, val - count, contents + nraddr);
1027 val = isym->st_value + irel->r_addend;
1028 if (val > addr && val < toaddr)
1029 irel->r_addend -= count;
1033 start = stop = addr;
1040 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1047 /* This has been made by previous relaxation. Since the
1048 relocation will be against an external symbol, the
1049 final relocation will just do the right thing. */
1050 start = stop = addr;
1056 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1058 /* The addend will be against the section symbol, thus
1059 for adjusting the addend, the relevant start is the
1060 start of the section.
1061 N.B. If we want to abandon in-place changes here and
1062 test directly using symbol + addend, we have to take into
1063 account that the addend has already been adjusted by -4. */
1064 if (stop > addr && stop < toaddr)
1065 irel->r_addend -= count;
1071 stop = start + 4 + off * 2;
1076 stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1082 /* These relocs types represent
1084 The r_addend field holds the difference between the reloc
1085 address and L1. That is the start of the reloc, and
1086 adding in the contents gives us the top. We must adjust
1087 both the r_offset field and the section contents.
1088 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1089 and the elf bfd r_offset is called r_vaddr. */
1091 stop = irel->r_offset;
1092 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1096 && (stop <= addr || stop >= toaddr))
1097 irel->r_addend += count;
1098 else if (stop > addr
1100 && (start <= addr || start >= toaddr))
1101 irel->r_addend -= count;
1103 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1104 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1105 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1106 voff = bfd_get_8 (abfd, contents + nraddr);
1108 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1109 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1114 start = irel->r_offset;
1115 stop = (bfd_vma) ((bfd_signed_vma) start
1116 + (long) irel->r_addend
1123 && (stop <= addr || stop >= toaddr))
1125 else if (stop > addr
1127 && (start <= addr || start >= toaddr))
1136 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1145 if ((oinsn & 0xff00) != (insn & 0xff00))
1147 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1152 if ((oinsn & 0xf000) != (insn & 0xf000))
1154 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1158 BFD_ASSERT (adjust == count || count >= 4);
1163 if ((irel->r_offset & 3) == 0)
1166 if ((oinsn & 0xff00) != (insn & 0xff00))
1168 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1173 if (voff < 0 || voff >= 0xff)
1175 bfd_put_8 (abfd, voff, contents + nraddr);
1180 if (voff < - 0x8000 || voff >= 0x8000)
1182 bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
1187 bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
1191 irel->r_addend += adjust;
1198 /* xgettext:c-format */
1199 (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
1200 abfd, irel->r_offset);
1201 bfd_set_error (bfd_error_bad_value);
1206 irel->r_offset = nraddr;
1209 /* Look through all the other sections. If there contain any IMM32
1210 relocs against internal symbols which we are not going to adjust
1211 below, we may need to adjust the addends. */
1212 for (o = abfd->sections; o != NULL; o = o->next)
1214 Elf_Internal_Rela *internal_relocs;
1215 Elf_Internal_Rela *irelscan, *irelscanend;
1216 bfd_byte *ocontents;
1219 || (o->flags & SEC_RELOC) == 0
1220 || o->reloc_count == 0)
1223 /* We always cache the relocs. Perhaps, if info->keep_memory is
1224 FALSE, we should free them, if we are permitted to, when we
1225 leave sh_coff_relax_section. */
1226 internal_relocs = (_bfd_elf_link_read_relocs
1227 (abfd, o, NULL, (Elf_Internal_Rela *) NULL, TRUE));
1228 if (internal_relocs == NULL)
1232 irelscanend = internal_relocs + o->reloc_count;
1233 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1235 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1236 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1238 bfd_vma start, stop;
1239 bfd_signed_vma voff;
1241 if (ocontents == NULL)
1243 if (elf_section_data (o)->this_hdr.contents != NULL)
1244 ocontents = elf_section_data (o)->this_hdr.contents;
1247 /* We always cache the section contents.
1248 Perhaps, if info->keep_memory is FALSE, we
1249 should free them, if we are permitted to,
1250 when we leave sh_coff_relax_section. */
1251 if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1253 if (ocontents != NULL)
1258 elf_section_data (o)->this_hdr.contents = ocontents;
1262 stop = irelscan->r_offset;
1264 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1266 /* STOP is in a different section, so it won't change. */
1267 if (start > addr && start < toaddr)
1268 irelscan->r_addend += count;
1270 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1271 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1275 && (stop <= addr || stop >= toaddr))
1276 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
1277 ocontents + irelscan->r_offset);
1278 else if (stop > addr
1280 && (start <= addr || start >= toaddr))
1281 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
1282 ocontents + irelscan->r_offset);
1285 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1288 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1292 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1293 if (isym->st_shndx == sec_shndx
1294 && (isym->st_value <= addr
1295 || isym->st_value >= toaddr))
1299 if (ocontents == NULL)
1301 if (elf_section_data (o)->this_hdr.contents != NULL)
1302 ocontents = elf_section_data (o)->this_hdr.contents;
1305 /* We always cache the section contents.
1306 Perhaps, if info->keep_memory is FALSE, we
1307 should free them, if we are permitted to,
1308 when we leave sh_coff_relax_section. */
1309 if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1311 if (ocontents != NULL)
1316 elf_section_data (o)->this_hdr.contents = ocontents;
1320 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1321 val += isym->st_value;
1322 if (val > addr && val < toaddr)
1323 bfd_put_32 (abfd, val - count,
1324 ocontents + irelscan->r_offset);
1329 /* Adjust the local symbols defined in this section. */
1330 isymend = isymbuf + symtab_hdr->sh_info;
1331 for (isym = isymbuf; isym < isymend; isym++)
1333 if (isym->st_shndx == sec_shndx
1334 && isym->st_value > addr
1335 && isym->st_value < toaddr)
1336 isym->st_value -= count;
1339 /* Now adjust the global symbols defined in this section. */
1340 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1341 - symtab_hdr->sh_info);
1342 sym_hashes = elf_sym_hashes (abfd);
1343 end_hashes = sym_hashes + symcount;
1344 for (; sym_hashes < end_hashes; sym_hashes++)
1346 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1347 if ((sym_hash->root.type == bfd_link_hash_defined
1348 || sym_hash->root.type == bfd_link_hash_defweak)
1349 && sym_hash->root.u.def.section == sec
1350 && sym_hash->root.u.def.value > addr
1351 && sym_hash->root.u.def.value < toaddr)
1353 sym_hash->root.u.def.value -= count;
1357 /* See if we can move the ALIGN reloc forward. We have adjusted
1358 r_offset for it already. */
1359 if (irelalign != NULL)
1361 bfd_vma alignto, alignaddr;
1363 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1364 alignaddr = BFD_ALIGN (irelalign->r_offset,
1365 1 << irelalign->r_addend);
1366 if (alignto != alignaddr)
1368 /* Tail recursion. */
1369 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1370 (int) (alignto - alignaddr));
1377 /* Look for loads and stores which we can align to four byte
1378 boundaries. This is like sh_align_loads in coff-sh.c. */
1381 sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
1382 Elf_Internal_Rela *internal_relocs,
1383 bfd_byte *contents ATTRIBUTE_UNUSED,
1384 bfd_boolean *pswapped)
1386 Elf_Internal_Rela *irel, *irelend;
1387 bfd_vma *labels = NULL;
1388 bfd_vma *label, *label_end;
1393 irelend = internal_relocs + sec->reloc_count;
1395 /* Get all the addresses with labels on them. */
1396 amt = sec->reloc_count;
1397 amt *= sizeof (bfd_vma);
1398 labels = (bfd_vma *) bfd_malloc (amt);
1402 for (irel = internal_relocs; irel < irelend; irel++)
1404 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1406 *label_end = irel->r_offset;
1411 /* Note that the assembler currently always outputs relocs in
1412 address order. If that ever changes, this code will need to sort
1413 the label values and the relocs. */
1417 for (irel = internal_relocs; irel < irelend; irel++)
1419 bfd_vma start, stop;
1421 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1424 start = irel->r_offset;
1426 for (irel++; irel < irelend; irel++)
1427 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1430 stop = irel->r_offset;
1434 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1435 internal_relocs, &label,
1436 label_end, start, stop, pswapped))
1451 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1454 sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs,
1455 bfd_byte *contents, bfd_vma addr)
1457 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1458 unsigned short i1, i2;
1459 Elf_Internal_Rela *irel, *irelend;
1461 /* Swap the instructions themselves. */
1462 i1 = bfd_get_16 (abfd, contents + addr);
1463 i2 = bfd_get_16 (abfd, contents + addr + 2);
1464 bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
1465 bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
1467 /* Adjust all reloc addresses. */
1468 irelend = internal_relocs + sec->reloc_count;
1469 for (irel = internal_relocs; irel < irelend; irel++)
1471 enum elf_sh_reloc_type type;
1474 /* There are a few special types of relocs that we don't want to
1475 adjust. These relocs do not apply to the instruction itself,
1476 but are only associated with the address. */
1477 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1478 if (type == R_SH_ALIGN
1479 || type == R_SH_CODE
1480 || type == R_SH_DATA
1481 || type == R_SH_LABEL)
1484 /* If an R_SH_USES reloc points to one of the addresses being
1485 swapped, we must adjust it. It would be incorrect to do this
1486 for a jump, though, since we want to execute both
1487 instructions after the jump. (We have avoided swapping
1488 around a label, so the jump will not wind up executing an
1489 instruction it shouldn't). */
1490 if (type == R_SH_USES)
1494 off = irel->r_offset + 4 + irel->r_addend;
1496 irel->r_offset += 2;
1497 else if (off == addr + 2)
1498 irel->r_offset -= 2;
1501 if (irel->r_offset == addr)
1503 irel->r_offset += 2;
1506 else if (irel->r_offset == addr + 2)
1508 irel->r_offset -= 2;
1517 unsigned short insn, oinsn;
1518 bfd_boolean overflow;
1520 loc = contents + irel->r_offset;
1529 insn = bfd_get_16 (abfd, loc);
1532 if ((oinsn & 0xff00) != (insn & 0xff00))
1534 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1538 insn = bfd_get_16 (abfd, loc);
1541 if ((oinsn & 0xf000) != (insn & 0xf000))
1543 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1547 /* This reloc ignores the least significant 3 bits of
1548 the program counter before adding in the offset.
1549 This means that if ADDR is at an even address, the
1550 swap will not affect the offset. If ADDR is an at an
1551 odd address, then the instruction will be crossing a
1552 four byte boundary, and must be adjusted. */
1553 if ((addr & 3) != 0)
1555 insn = bfd_get_16 (abfd, loc);
1558 if ((oinsn & 0xff00) != (insn & 0xff00))
1560 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1569 /* xgettext:c-format */
1570 (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
1571 abfd, irel->r_offset);
1572 bfd_set_error (bfd_error_bad_value);
1580 #endif /* defined SH64_ELF */
1582 /* Describes one of the various PLT styles. */
1584 struct elf_sh_plt_info
1586 /* The template for the first PLT entry, or NULL if there is no special
1588 const bfd_byte *plt0_entry;
1590 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1591 bfd_vma plt0_entry_size;
1593 /* Index I is the offset into PLT0_ENTRY of a pointer to
1594 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1595 if there is no such pointer. */
1596 bfd_vma plt0_got_fields[3];
1598 /* The template for a symbol's PLT entry. */
1599 const bfd_byte *symbol_entry;
1601 /* The size of SYMBOL_ENTRY in bytes. */
1602 bfd_vma symbol_entry_size;
1604 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1605 on all targets. The comments by each member indicate the value
1606 that the field must hold. */
1608 bfd_vma got_entry; /* the address of the symbol's .got.plt entry */
1609 bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */
1610 bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */
1611 bfd_boolean got20; /* TRUE if got_entry points to a movi20
1612 instruction (instead of a constant pool
1616 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1617 bfd_vma symbol_resolve_offset;
1619 /* A different PLT layout which can be used for the first
1620 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1622 const struct elf_sh_plt_info *short_plt;
1625 #ifdef INCLUDE_SHMEDIA
1627 /* The size in bytes of an entry in the procedure linkage table. */
1629 #define ELF_PLT_ENTRY_SIZE 64
1631 /* First entry in an absolute procedure linkage table look like this. */
1633 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1635 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1636 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1637 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1638 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1639 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1640 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1641 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1642 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1643 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1644 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1645 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1646 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1647 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1648 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1649 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1650 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1653 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1655 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1656 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1657 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1658 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1659 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1660 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1661 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1662 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1663 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1664 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1665 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1666 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1667 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1668 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1669 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1670 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1673 /* Sebsequent entries in an absolute procedure linkage table look like
1676 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1678 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1679 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1680 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1681 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1682 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1683 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1684 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1685 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1686 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1687 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1688 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1689 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1690 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1691 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1692 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1693 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1696 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1698 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1699 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1700 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1701 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1702 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1703 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1704 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1705 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1706 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1707 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1708 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1709 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1710 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1711 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1712 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1713 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1716 /* Entries in a PIC procedure linkage table look like this. */
1718 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1720 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1721 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1722 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1723 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1724 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1725 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1726 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1727 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1728 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1729 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1730 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1731 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1732 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1733 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1734 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1735 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1738 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1740 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1741 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1742 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1743 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1744 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1745 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1746 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1747 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1748 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1749 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1750 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1751 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1752 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1753 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1754 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1755 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1758 static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1761 /* Big-endian non-PIC. */
1762 elf_sh_plt0_entry_be,
1764 { 0, MINUS_ONE, MINUS_ONE },
1765 elf_sh_plt_entry_be,
1767 { 0, 32, 48, FALSE },
1768 33, /* includes ISA encoding */
1772 /* Little-endian non-PIC. */
1773 elf_sh_plt0_entry_le,
1775 { 0, MINUS_ONE, MINUS_ONE },
1776 elf_sh_plt_entry_le,
1778 { 0, 32, 48, FALSE },
1779 33, /* includes ISA encoding */
1785 /* Big-endian PIC. */
1786 elf_sh_plt0_entry_be,
1788 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1789 elf_sh_pic_plt_entry_be,
1791 { 0, MINUS_ONE, 52, FALSE },
1792 33, /* includes ISA encoding */
1796 /* Little-endian PIC. */
1797 elf_sh_plt0_entry_le,
1799 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1800 elf_sh_pic_plt_entry_le,
1802 { 0, MINUS_ONE, 52, FALSE },
1803 33, /* includes ISA encoding */
1809 /* Return offset of the linker in PLT0 entry. */
1810 #define elf_sh_plt0_gotplt_offset(info) 0
1812 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1813 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1816 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1819 install_plt_field (bfd *output_bfd, bfd_boolean code_p,
1820 unsigned long value, bfd_byte *addr)
1823 bfd_put_32 (output_bfd,
1824 bfd_get_32 (output_bfd, addr)
1825 | ((value >> 6) & 0x3fffc00),
1827 bfd_put_32 (output_bfd,
1828 bfd_get_32 (output_bfd, addr + 4)
1829 | ((value << 10) & 0x3fffc00),
1833 /* Return the type of PLT associated with ABFD. PIC_P is true if
1834 the object is position-independent. */
1836 static const struct elf_sh_plt_info *
1837 get_plt_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean pic_p)
1839 return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
1842 /* The size in bytes of an entry in the procedure linkage table. */
1844 #define ELF_PLT_ENTRY_SIZE 28
1846 /* First entry in an absolute procedure linkage table look like this. */
1848 /* Note - this code has been "optimised" not to use r2. r2 is used by
1849 GCC to return the address of large structures, so it should not be
1850 corrupted here. This does mean however, that this PLT does not conform
1851 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1852 and r2 contains the GOT id. This version stores the GOT id in r0 and
1853 ignores the type. Loaders can easily detect this difference however,
1854 since the type will always be 0 or 8, and the GOT ids will always be
1855 greater than or equal to 12. */
1856 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1858 0xd0, 0x05, /* mov.l 2f,r0 */
1859 0x60, 0x02, /* mov.l @r0,r0 */
1860 0x2f, 0x06, /* mov.l r0,@-r15 */
1861 0xd0, 0x03, /* mov.l 1f,r0 */
1862 0x60, 0x02, /* mov.l @r0,r0 */
1863 0x40, 0x2b, /* jmp @r0 */
1864 0x60, 0xf6, /* mov.l @r15+,r0 */
1865 0x00, 0x09, /* nop */
1866 0x00, 0x09, /* nop */
1867 0x00, 0x09, /* nop */
1868 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1869 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1872 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1874 0x05, 0xd0, /* mov.l 2f,r0 */
1875 0x02, 0x60, /* mov.l @r0,r0 */
1876 0x06, 0x2f, /* mov.l r0,@-r15 */
1877 0x03, 0xd0, /* mov.l 1f,r0 */
1878 0x02, 0x60, /* mov.l @r0,r0 */
1879 0x2b, 0x40, /* jmp @r0 */
1880 0xf6, 0x60, /* mov.l @r15+,r0 */
1881 0x09, 0x00, /* nop */
1882 0x09, 0x00, /* nop */
1883 0x09, 0x00, /* nop */
1884 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1885 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1888 /* Sebsequent entries in an absolute procedure linkage table look like
1891 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1893 0xd0, 0x04, /* mov.l 1f,r0 */
1894 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1895 0xd1, 0x02, /* mov.l 0f,r1 */
1896 0x40, 0x2b, /* jmp @r0 */
1897 0x60, 0x13, /* mov r1,r0 */
1898 0xd1, 0x03, /* mov.l 2f,r1 */
1899 0x40, 0x2b, /* jmp @r0 */
1900 0x00, 0x09, /* nop */
1901 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1902 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1903 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1906 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1908 0x04, 0xd0, /* mov.l 1f,r0 */
1909 0x02, 0x60, /* mov.l @r0,r0 */
1910 0x02, 0xd1, /* mov.l 0f,r1 */
1911 0x2b, 0x40, /* jmp @r0 */
1912 0x13, 0x60, /* mov r1,r0 */
1913 0x03, 0xd1, /* mov.l 2f,r1 */
1914 0x2b, 0x40, /* jmp @r0 */
1915 0x09, 0x00, /* nop */
1916 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1917 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1918 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1921 /* Entries in a PIC procedure linkage table look like this. */
1923 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1925 0xd0, 0x04, /* mov.l 1f,r0 */
1926 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1927 0x40, 0x2b, /* jmp @r0 */
1928 0x00, 0x09, /* nop */
1929 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1930 0xd1, 0x03, /* mov.l 2f,r1 */
1931 0x40, 0x2b, /* jmp @r0 */
1932 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1933 0x00, 0x09, /* nop */
1934 0x00, 0x09, /* nop */
1935 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1936 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1939 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1941 0x04, 0xd0, /* mov.l 1f,r0 */
1942 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1943 0x2b, 0x40, /* jmp @r0 */
1944 0x09, 0x00, /* nop */
1945 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1946 0x03, 0xd1, /* mov.l 2f,r1 */
1947 0x2b, 0x40, /* jmp @r0 */
1948 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1949 0x09, 0x00, /* nop */
1950 0x09, 0x00, /* nop */
1951 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1952 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1955 static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1958 /* Big-endian non-PIC. */
1959 elf_sh_plt0_entry_be,
1961 { MINUS_ONE, 24, 20 },
1962 elf_sh_plt_entry_be,
1964 { 20, 16, 24, FALSE },
1969 /* Little-endian non-PIC. */
1970 elf_sh_plt0_entry_le,
1972 { MINUS_ONE, 24, 20 },
1973 elf_sh_plt_entry_le,
1975 { 20, 16, 24, FALSE },
1982 /* Big-endian PIC. */
1983 elf_sh_plt0_entry_be,
1985 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1986 elf_sh_pic_plt_entry_be,
1988 { 20, MINUS_ONE, 24, FALSE },
1993 /* Little-endian PIC. */
1994 elf_sh_plt0_entry_le,
1996 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1997 elf_sh_pic_plt_entry_le,
1999 { 20, MINUS_ONE, 24, FALSE },
2006 #define VXWORKS_PLT_HEADER_SIZE 12
2007 #define VXWORKS_PLT_ENTRY_SIZE 24
2009 static const bfd_byte vxworks_sh_plt0_entry_be[VXWORKS_PLT_HEADER_SIZE] =
2011 0xd1, 0x01, /* mov.l @(8,pc),r1 */
2012 0x61, 0x12, /* mov.l @r1,r1 */
2013 0x41, 0x2b, /* jmp @r1 */
2014 0x00, 0x09, /* nop */
2015 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2018 static const bfd_byte vxworks_sh_plt0_entry_le[VXWORKS_PLT_HEADER_SIZE] =
2020 0x01, 0xd1, /* mov.l @(8,pc),r1 */
2021 0x12, 0x61, /* mov.l @r1,r1 */
2022 0x2b, 0x41, /* jmp @r1 */
2023 0x09, 0x00, /* nop */
2024 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2027 static const bfd_byte vxworks_sh_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2029 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2030 0x60, 0x02, /* mov.l @r0,r0 */
2031 0x40, 0x2b, /* jmp @r0 */
2032 0x00, 0x09, /* nop */
2033 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2034 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2035 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
2036 0x00, 0x09, /* nop */
2037 0x00, 0x09, /* nop */
2038 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2041 static const bfd_byte vxworks_sh_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2043 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2044 0x02, 0x60, /* mov.l @r0,r0 */
2045 0x2b, 0x40, /* jmp @r0 */
2046 0x09, 0x00, /* nop */
2047 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2048 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2049 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
2050 0x09, 0x00, /* nop */
2051 0x09, 0x00, /* nop */
2052 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2055 static const bfd_byte vxworks_sh_pic_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2057 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2058 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2059 0x40, 0x2b, /* jmp @r0 */
2060 0x00, 0x09, /* nop */
2061 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2062 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2063 0x51, 0xc2, /* mov.l @(8,r12),r1 */
2064 0x41, 0x2b, /* jmp @r1 */
2065 0x00, 0x09, /* nop */
2066 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2069 static const bfd_byte vxworks_sh_pic_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2071 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2072 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2073 0x2b, 0x40, /* jmp @r0 */
2074 0x09, 0x00, /* nop */
2075 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2076 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2077 0xc2, 0x51, /* mov.l @(8,r12),r1 */
2078 0x2b, 0x41, /* jmp @r1 */
2079 0x09, 0x00, /* nop */
2080 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2083 static const struct elf_sh_plt_info vxworks_sh_plts[2][2] = {
2086 /* Big-endian non-PIC. */
2087 vxworks_sh_plt0_entry_be,
2088 VXWORKS_PLT_HEADER_SIZE,
2089 { MINUS_ONE, MINUS_ONE, 8 },
2090 vxworks_sh_plt_entry_be,
2091 VXWORKS_PLT_ENTRY_SIZE,
2092 { 8, 14, 20, FALSE },
2097 /* Little-endian non-PIC. */
2098 vxworks_sh_plt0_entry_le,
2099 VXWORKS_PLT_HEADER_SIZE,
2100 { MINUS_ONE, MINUS_ONE, 8 },
2101 vxworks_sh_plt_entry_le,
2102 VXWORKS_PLT_ENTRY_SIZE,
2103 { 8, 14, 20, FALSE },
2110 /* Big-endian PIC. */
2113 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2114 vxworks_sh_pic_plt_entry_be,
2115 VXWORKS_PLT_ENTRY_SIZE,
2116 { 8, MINUS_ONE, 20, FALSE },
2121 /* Little-endian PIC. */
2124 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2125 vxworks_sh_pic_plt_entry_le,
2126 VXWORKS_PLT_ENTRY_SIZE,
2127 { 8, MINUS_ONE, 20, FALSE },
2134 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2135 binding are to omit the lazy binding stub when linking with -z now
2136 and to move lazy binding stubs into a separate region for better
2139 #define FDPIC_PLT_ENTRY_SIZE 28
2140 #define FDPIC_PLT_LAZY_OFFSET 20
2142 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2143 duplicated if it is out of range, or which can be inlined. So
2144 right now it is always inlined, which wastes a word per stub. It
2145 might be easier to handle the duplication if we put the lazy
2146 stubs separately. */
2148 static const bfd_byte fdpic_sh_plt_entry_be[FDPIC_PLT_ENTRY_SIZE] =
2150 0xd0, 0x02, /* mov.l @(12,pc),r0 */
2151 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2152 0x70, 0x04, /* add #4, r0 */
2153 0x41, 0x2b, /* jmp @r1 */
2154 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2155 0x00, 0x09, /* nop */
2156 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2157 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2158 0x60, 0xc2, /* mov.l @r12,r0 */
2159 0x40, 0x2b, /* jmp @r0 */
2160 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2161 0x00, 0x09, /* nop */
2164 static const bfd_byte fdpic_sh_plt_entry_le[FDPIC_PLT_ENTRY_SIZE] =
2166 0x02, 0xd0, /* mov.l @(12,pc),r0 */
2167 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2168 0x04, 0x70, /* add #4, r0 */
2169 0x2b, 0x41, /* jmp @r1 */
2170 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2171 0x09, 0x00, /* nop */
2172 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2173 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2174 0xc2, 0x60, /* mov.l @r12,r0 */
2175 0x2b, 0x40, /* jmp @r0 */
2176 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2177 0x09, 0x00, /* nop */
2180 static const struct elf_sh_plt_info fdpic_sh_plts[2] = {
2182 /* Big-endian PIC. */
2185 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2186 fdpic_sh_plt_entry_be,
2187 FDPIC_PLT_ENTRY_SIZE,
2188 { 12, MINUS_ONE, 16, FALSE },
2189 FDPIC_PLT_LAZY_OFFSET,
2193 /* Little-endian PIC. */
2196 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2197 fdpic_sh_plt_entry_le,
2198 FDPIC_PLT_ENTRY_SIZE,
2199 { 12, MINUS_ONE, 16, FALSE },
2200 FDPIC_PLT_LAZY_OFFSET,
2205 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2206 entries for the first 64K slots. We use the normal FDPIC PLT entry
2207 past that point; we could also use movi20s, which might be faster,
2208 but would not be any smaller. */
2210 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2211 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2213 static const bfd_byte fdpic_sh2a_plt_entry_be[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2215 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2216 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2217 0x70, 0x04, /* add #4, r0 */
2218 0x41, 0x2b, /* jmp @r1 */
2219 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2220 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2221 0x60, 0xc2, /* mov.l @r12,r0 */
2222 0x40, 0x2b, /* jmp @r0 */
2223 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2224 0x00, 0x09, /* nop */
2227 static const bfd_byte fdpic_sh2a_plt_entry_le[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2229 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2230 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2231 0x04, 0x70, /* add #4, r0 */
2232 0x2b, 0x41, /* jmp @r1 */
2233 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2234 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2235 0xc2, 0x60, /* mov.l @r12,r0 */
2236 0x2b, 0x40, /* jmp @r0 */
2237 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2238 0x09, 0x00, /* nop */
2241 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be = {
2242 /* Big-endian FDPIC, max index 64K. */
2245 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2246 fdpic_sh2a_plt_entry_be,
2247 FDPIC_SH2A_PLT_ENTRY_SIZE,
2248 { 0, MINUS_ONE, 12, TRUE },
2249 FDPIC_SH2A_PLT_LAZY_OFFSET,
2253 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le = {
2254 /* Little-endian FDPIC, max index 64K. */
2257 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2258 fdpic_sh2a_plt_entry_le,
2259 FDPIC_SH2A_PLT_ENTRY_SIZE,
2260 { 0, MINUS_ONE, 12, TRUE },
2261 FDPIC_SH2A_PLT_LAZY_OFFSET,
2265 static const struct elf_sh_plt_info fdpic_sh2a_plts[2] = {
2267 /* Big-endian PIC. */
2270 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2271 fdpic_sh_plt_entry_be,
2272 FDPIC_PLT_ENTRY_SIZE,
2273 { 12, MINUS_ONE, 16, FALSE },
2274 FDPIC_PLT_LAZY_OFFSET,
2275 &fdpic_sh2a_short_plt_be
2278 /* Little-endian PIC. */
2281 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2282 fdpic_sh_plt_entry_le,
2283 FDPIC_PLT_ENTRY_SIZE,
2284 { 12, MINUS_ONE, 16, FALSE },
2285 FDPIC_PLT_LAZY_OFFSET,
2286 &fdpic_sh2a_short_plt_le
2290 /* Return the type of PLT associated with ABFD. PIC_P is true if
2291 the object is position-independent. */
2293 static const struct elf_sh_plt_info *
2294 get_plt_info (bfd *abfd, bfd_boolean pic_p)
2296 if (fdpic_object_p (abfd))
2298 /* If any input file requires SH2A we can use a shorter PLT
2300 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd)) & arch_sh2a_base)
2301 return &fdpic_sh2a_plts[!bfd_big_endian (abfd)];
2303 return &fdpic_sh_plts[!bfd_big_endian (abfd)];
2305 if (vxworks_object_p (abfd))
2306 return &vxworks_sh_plts[pic_p][!bfd_big_endian (abfd)];
2307 return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
2310 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2311 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2315 install_plt_field (bfd *output_bfd, bfd_boolean code_p ATTRIBUTE_UNUSED,
2316 unsigned long value, bfd_byte *addr)
2318 bfd_put_32 (output_bfd, value, addr);
2322 /* The number of PLT entries which can use a shorter PLT, if any.
2323 Currently always 64K, since only SH-2A FDPIC uses this; a
2324 20-bit movi20 can address that many function descriptors below
2325 _GLOBAL_OFFSET_TABLE_. */
2326 #define MAX_SHORT_PLT 65536
2328 /* Return the index of the PLT entry at byte offset OFFSET. */
2331 get_plt_index (const struct elf_sh_plt_info *info, bfd_vma offset)
2333 bfd_vma plt_index = 0;
2335 offset -= info->plt0_entry_size;
2336 if (info->short_plt != NULL)
2338 if (offset > MAX_SHORT_PLT * info->short_plt->symbol_entry_size)
2340 plt_index = MAX_SHORT_PLT;
2341 offset -= MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2344 info = info->short_plt;
2346 return plt_index + offset / info->symbol_entry_size;
2349 /* Do the inverse operation. */
2352 get_plt_offset (const struct elf_sh_plt_info *info, bfd_vma plt_index)
2356 if (info->short_plt != NULL)
2358 if (plt_index > MAX_SHORT_PLT)
2360 offset = MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2361 plt_index -= MAX_SHORT_PLT;
2364 info = info->short_plt;
2366 return (offset + info->plt0_entry_size
2367 + (plt_index * info->symbol_entry_size));
2370 /* The sh linker needs to keep track of the number of relocs that it
2371 decides to copy as dynamic relocs in check_relocs for each symbol.
2372 This is so that it can later discard them if they are found to be
2373 unnecessary. We store the information in a field extending the
2374 regular ELF linker hash table. */
2376 struct elf_sh_dyn_relocs
2378 struct elf_sh_dyn_relocs *next;
2380 /* The input section of the reloc. */
2383 /* Total number of relocs copied for the input section. */
2384 bfd_size_type count;
2386 /* Number of pc-relative relocs copied for the input section. */
2387 bfd_size_type pc_count;
2392 bfd_signed_vma refcount;
2396 /* sh ELF linker hash entry. */
2398 struct elf_sh_link_hash_entry
2400 struct elf_link_hash_entry root;
2402 #ifdef INCLUDE_SHMEDIA
2405 bfd_signed_vma refcount;
2410 /* Track dynamic relocs copied for this symbol. */
2411 struct elf_sh_dyn_relocs *dyn_relocs;
2413 bfd_signed_vma gotplt_refcount;
2415 /* A local function descriptor, for FDPIC. The refcount counts
2416 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2417 relocations; the PLT and GOT entry are accounted
2418 for separately. After adjust_dynamic_symbol, the offset is
2419 MINUS_ONE if there is no local descriptor (dynamic linker
2420 managed and no PLT entry, or undefined weak non-dynamic).
2421 During check_relocs we do not yet know whether the local
2422 descriptor will be canonical. */
2423 union gotref funcdesc;
2425 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2426 and thus require fixups or relocations. */
2427 bfd_signed_vma abs_funcdesc_refcount;
2430 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC
2434 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2436 struct sh_elf_obj_tdata
2438 struct elf_obj_tdata root;
2440 /* got_type for each local got entry. */
2441 char *local_got_type;
2443 /* Function descriptor refcount and offset for each local symbol. */
2444 union gotref *local_funcdesc;
2447 #define sh_elf_tdata(abfd) \
2448 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2450 #define sh_elf_local_got_type(abfd) \
2451 (sh_elf_tdata (abfd)->local_got_type)
2453 #define sh_elf_local_funcdesc(abfd) \
2454 (sh_elf_tdata (abfd)->local_funcdesc)
2456 #define is_sh_elf(bfd) \
2457 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2458 && elf_tdata (bfd) != NULL \
2459 && elf_object_id (bfd) == SH_ELF_DATA)
2461 /* Override the generic function because we need to store sh_elf_obj_tdata
2462 as the specific tdata. */
2465 sh_elf_mkobject (bfd *abfd)
2467 return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata),
2471 /* sh ELF linker hash table. */
2473 struct elf_sh_link_hash_table
2475 struct elf_link_hash_table root;
2477 /* Short-cuts to get to dynamic linker sections. */
2480 asection *sfuncdesc;
2481 asection *srelfuncdesc;
2484 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2487 /* Small local sym cache. */
2488 struct sym_cache sym_cache;
2490 /* A counter or offset to track a TLS got entry. */
2493 bfd_signed_vma refcount;
2497 /* The type of PLT to use. */
2498 const struct elf_sh_plt_info *plt_info;
2500 /* True if the target system is VxWorks. */
2501 bfd_boolean vxworks_p;
2503 /* True if the target system uses FDPIC. */
2504 bfd_boolean fdpic_p;
2507 /* Traverse an sh ELF linker hash table. */
2509 #define sh_elf_link_hash_traverse(table, func, info) \
2510 (elf_link_hash_traverse \
2512 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2515 /* Get the sh ELF linker hash table from a link_info structure. */
2517 #define sh_elf_hash_table(p) \
2518 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2519 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2521 /* Create an entry in an sh ELF linker hash table. */
2523 static struct bfd_hash_entry *
2524 sh_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2525 struct bfd_hash_table *table,
2528 struct elf_sh_link_hash_entry *ret =
2529 (struct elf_sh_link_hash_entry *) entry;
2531 /* Allocate the structure if it has not already been allocated by a
2533 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2534 ret = ((struct elf_sh_link_hash_entry *)
2535 bfd_hash_allocate (table,
2536 sizeof (struct elf_sh_link_hash_entry)));
2537 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2538 return (struct bfd_hash_entry *) ret;
2540 /* Call the allocation method of the superclass. */
2541 ret = ((struct elf_sh_link_hash_entry *)
2542 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2544 if (ret != (struct elf_sh_link_hash_entry *) NULL)
2546 ret->dyn_relocs = NULL;
2547 ret->gotplt_refcount = 0;
2548 #ifdef INCLUDE_SHMEDIA
2549 ret->datalabel_got.refcount = ret->root.got.refcount;
2551 ret->funcdesc.refcount = 0;
2552 ret->abs_funcdesc_refcount = 0;
2553 ret->got_type = GOT_UNKNOWN;
2556 return (struct bfd_hash_entry *) ret;
2559 /* Create an sh ELF linker hash table. */
2561 static struct bfd_link_hash_table *
2562 sh_elf_link_hash_table_create (bfd *abfd)
2564 struct elf_sh_link_hash_table *ret;
2565 bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
2567 ret = (struct elf_sh_link_hash_table *) bfd_zmalloc (amt);
2568 if (ret == (struct elf_sh_link_hash_table *) NULL)
2571 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
2572 sh_elf_link_hash_newfunc,
2573 sizeof (struct elf_sh_link_hash_entry),
2580 ret->vxworks_p = vxworks_object_p (abfd);
2581 ret->fdpic_p = fdpic_object_p (abfd);
2583 return &ret->root.root;
2587 sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2588 struct bfd_link_info *info, asection *p)
2590 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
2592 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2596 /* We need dynamic symbols for every section, since segments can
2597 relocate independently. */
2598 switch (elf_section_data (p)->this_hdr.sh_type)
2602 /* If sh_type is yet undecided, assume it could be
2603 SHT_PROGBITS/SHT_NOBITS. */
2607 /* There shouldn't be section relative relocations
2608 against any other section. */
2614 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2615 shortcuts to them in our hash table. */
2618 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2620 struct elf_sh_link_hash_table *htab;
2622 if (! _bfd_elf_create_got_section (dynobj, info))
2625 htab = sh_elf_hash_table (info);
2629 htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
2630 (SEC_ALLOC | SEC_LOAD
2633 | SEC_LINKER_CREATED));
2634 if (htab->sfuncdesc == NULL
2635 || ! bfd_set_section_alignment (dynobj, htab->sfuncdesc, 2))
2638 htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
2639 ".rela.got.funcdesc",
2640 (SEC_ALLOC | SEC_LOAD
2643 | SEC_LINKER_CREATED
2645 if (htab->srelfuncdesc == NULL
2646 || ! bfd_set_section_alignment (dynobj, htab->srelfuncdesc, 2))
2649 /* Also create .rofixup. */
2650 htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
2651 (SEC_ALLOC | SEC_LOAD
2654 | SEC_LINKER_CREATED
2656 if (htab->srofixup == NULL
2657 || ! bfd_set_section_alignment (dynobj, htab->srofixup, 2))
2663 /* Create dynamic sections when linking against a dynamic object. */
2666 sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2668 struct elf_sh_link_hash_table *htab;
2669 flagword flags, pltflags;
2671 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2674 switch (bed->s->arch_size)
2685 bfd_set_error (bfd_error_bad_value);
2689 htab = sh_elf_hash_table (info);
2693 if (htab->root.dynamic_sections_created)
2696 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2697 .rel[a].bss sections. */
2699 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2700 | SEC_LINKER_CREATED);
2703 pltflags |= SEC_CODE;
2704 if (bed->plt_not_loaded)
2705 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2706 if (bed->plt_readonly)
2707 pltflags |= SEC_READONLY;
2709 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2710 htab->root.splt = s;
2712 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2715 if (bed->want_plt_sym)
2717 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2719 struct elf_link_hash_entry *h;
2720 struct bfd_link_hash_entry *bh = NULL;
2722 if (! (_bfd_generic_link_add_one_symbol
2723 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2724 (bfd_vma) 0, (const char *) NULL, FALSE,
2725 get_elf_backend_data (abfd)->collect, &bh)))
2728 h = (struct elf_link_hash_entry *) bh;
2730 h->type = STT_OBJECT;
2731 htab->root.hplt = h;
2733 if (bfd_link_pic (info)
2734 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2738 s = bfd_make_section_anyway_with_flags (abfd,
2739 bed->default_use_rela_p
2740 ? ".rela.plt" : ".rel.plt",
2741 flags | SEC_READONLY);
2742 htab->root.srelplt = s;
2744 || ! bfd_set_section_alignment (abfd, s, ptralign))
2747 if (htab->root.sgot == NULL
2748 && !create_got_section (abfd, info))
2751 if (bed->want_dynbss)
2753 /* The .dynbss section is a place to put symbols which are defined
2754 by dynamic objects, are referenced by regular objects, and are
2755 not functions. We must allocate space for them in the process
2756 image and use a R_*_COPY reloc to tell the dynamic linker to
2757 initialize them at run time. The linker script puts the .dynbss
2758 section into the .bss section of the final image. */
2759 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2760 SEC_ALLOC | SEC_LINKER_CREATED);
2765 /* The .rel[a].bss section holds copy relocs. This section is not
2766 normally needed. We need to create it here, though, so that the
2767 linker will map it to an output section. We can't just create it
2768 only if we need it, because we will not know whether we need it
2769 until we have seen all the input files, and the first time the
2770 main linker code calls BFD after examining all the input files
2771 (size_dynamic_sections) the input sections have already been
2772 mapped to the output sections. If the section turns out not to
2773 be needed, we can discard it later. We will never need this
2774 section when generating a shared object, since they do not use
2776 if (! bfd_link_pic (info))
2778 s = bfd_make_section_anyway_with_flags (abfd,
2779 (bed->default_use_rela_p
2780 ? ".rela.bss" : ".rel.bss"),
2781 flags | SEC_READONLY);
2784 || ! bfd_set_section_alignment (abfd, s, ptralign))
2789 if (htab->vxworks_p)
2791 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2798 /* Adjust a symbol defined by a dynamic object and referenced by a
2799 regular object. The current definition is in some section of the
2800 dynamic object, but we're not including those sections. We have to
2801 change the definition to something the rest of the link can
2805 sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2806 struct elf_link_hash_entry *h)
2808 struct elf_sh_link_hash_table *htab;
2809 struct elf_sh_link_hash_entry *eh;
2810 struct elf_sh_dyn_relocs *p;
2813 htab = sh_elf_hash_table (info);
2817 /* Make sure we know what is going on here. */
2818 BFD_ASSERT (htab->root.dynobj != NULL
2820 || h->u.weakdef != NULL
2823 && !h->def_regular)));
2825 /* If this is a function, put it in the procedure linkage table. We
2826 will fill in the contents of the procedure linkage table later,
2827 when we know the address of the .got section. */
2828 if (h->type == STT_FUNC
2831 if (h->plt.refcount <= 0
2832 || SYMBOL_CALLS_LOCAL (info, h)
2833 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2834 && h->root.type == bfd_link_hash_undefweak))
2836 /* This case can occur if we saw a PLT reloc in an input
2837 file, but the symbol was never referred to by a dynamic
2838 object. In such a case, we don't actually need to build
2839 a procedure linkage table, and we can just do a REL32
2841 h->plt.offset = (bfd_vma) -1;
2848 h->plt.offset = (bfd_vma) -1;
2850 /* If this is a weak symbol, and there is a real definition, the
2851 processor independent code will have arranged for us to see the
2852 real definition first, and we can just use the same value. */
2853 if (h->u.weakdef != NULL)
2855 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2856 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2857 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2858 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2859 if (info->nocopyreloc)
2860 h->non_got_ref = h->u.weakdef->non_got_ref;
2864 /* This is a reference to a symbol defined by a dynamic object which
2865 is not a function. */
2867 /* If we are creating a shared library, we must presume that the
2868 only references to the symbol are via the global offset table.
2869 For such cases we need not do anything here; the relocations will
2870 be handled correctly by relocate_section. */
2871 if (bfd_link_pic (info))
2874 /* If there are no references to this symbol that do not use the
2875 GOT, we don't need to generate a copy reloc. */
2876 if (!h->non_got_ref)
2879 /* If -z nocopyreloc was given, we won't generate them either. */
2880 if (info->nocopyreloc)
2886 eh = (struct elf_sh_link_hash_entry *) h;
2887 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2889 s = p->sec->output_section;
2890 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
2894 /* If we didn't find any dynamic relocs in sections which needs the
2895 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2903 /* We must allocate the symbol in our .dynbss section, which will
2904 become part of the .bss section of the executable. There will be
2905 an entry for this symbol in the .dynsym section. The dynamic
2906 object will contain position independent code, so all references
2907 from the dynamic object to this symbol will go through the global
2908 offset table. The dynamic linker will use the .dynsym entry to
2909 determine the address it must put in the global offset table, so
2910 both the dynamic object and the regular object will refer to the
2911 same memory location for the variable. */
2914 BFD_ASSERT (s != NULL);
2916 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2917 copy the initial value out of the dynamic object and into the
2918 runtime process image. We need to remember the offset into the
2919 .rela.bss section we are going to use. */
2920 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2924 srel = htab->srelbss;
2925 BFD_ASSERT (srel != NULL);
2926 srel->size += sizeof (Elf32_External_Rela);
2930 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2933 /* Allocate space in .plt, .got and associated reloc sections for
2937 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2939 struct bfd_link_info *info;
2940 struct elf_sh_link_hash_table *htab;
2941 struct elf_sh_link_hash_entry *eh;
2942 struct elf_sh_dyn_relocs *p;
2944 if (h->root.type == bfd_link_hash_indirect)
2947 info = (struct bfd_link_info *) inf;
2948 htab = sh_elf_hash_table (info);
2952 eh = (struct elf_sh_link_hash_entry *) h;
2953 if ((h->got.refcount > 0
2955 && eh->gotplt_refcount > 0)
2957 /* The symbol has been forced local, or we have some direct got refs,
2958 so treat all the gotplt refs as got refs. */
2959 h->got.refcount += eh->gotplt_refcount;
2960 if (h->plt.refcount >= eh->gotplt_refcount)
2961 h->plt.refcount -= eh->gotplt_refcount;
2964 if (htab->root.dynamic_sections_created
2965 && h->plt.refcount > 0
2966 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2967 || h->root.type != bfd_link_hash_undefweak))
2969 /* Make sure this symbol is output as a dynamic symbol.
2970 Undefined weak syms won't yet be marked as dynamic. */
2971 if (h->dynindx == -1
2972 && !h->forced_local)
2974 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2978 if (bfd_link_pic (info)
2979 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2981 asection *s = htab->root.splt;
2982 const struct elf_sh_plt_info *plt_info;
2984 /* If this is the first .plt entry, make room for the special
2987 s->size += htab->plt_info->plt0_entry_size;
2989 h->plt.offset = s->size;
2991 /* If this symbol is not defined in a regular file, and we are
2992 not generating a shared library, then set the symbol to this
2993 location in the .plt. This is required to make function
2994 pointers compare as equal between the normal executable and
2995 the shared library. Skip this for FDPIC, since the
2996 function's address will be the address of the canonical
2997 function descriptor. */
2998 if (!htab->fdpic_p && !bfd_link_pic (info) && !h->def_regular)
3000 h->root.u.def.section = s;
3001 h->root.u.def.value = h->plt.offset;
3004 /* Make room for this entry. */
3005 plt_info = htab->plt_info;
3006 if (plt_info->short_plt != NULL
3007 && (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT))
3008 plt_info = plt_info->short_plt;
3009 s->size += plt_info->symbol_entry_size;
3011 /* We also need to make an entry in the .got.plt section, which
3012 will be placed in the .got section by the linker script. */
3014 htab->root.sgotplt->size += 4;
3016 htab->root.sgotplt->size += 8;
3018 /* We also need to make an entry in the .rel.plt section. */
3019 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
3021 if (htab->vxworks_p && !bfd_link_pic (info))
3023 /* VxWorks executables have a second set of relocations
3024 for each PLT entry. They go in a separate relocation
3025 section, which is processed by the kernel loader. */
3027 /* There is a relocation for the initial PLT entry:
3028 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3029 if (h->plt.offset == htab->plt_info->plt0_entry_size)
3030 htab->srelplt2->size += sizeof (Elf32_External_Rela);
3032 /* There are two extra relocations for each subsequent
3033 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3034 and an R_SH_DIR32 relocation for the PLT entry. */
3035 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2;
3040 h->plt.offset = (bfd_vma) -1;
3046 h->plt.offset = (bfd_vma) -1;
3050 if (h->got.refcount > 0)
3054 enum got_type got_type = sh_elf_hash_entry (h)->got_type;
3056 /* Make sure this symbol is output as a dynamic symbol.
3057 Undefined weak syms won't yet be marked as dynamic. */
3058 if (h->dynindx == -1
3059 && !h->forced_local)
3061 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3065 s = htab->root.sgot;
3066 h->got.offset = s->size;
3068 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3069 if (got_type == GOT_TLS_GD)
3071 dyn = htab->root.dynamic_sections_created;
3074 /* No dynamic relocations required. */
3075 if (htab->fdpic_p && !bfd_link_pic (info)
3076 && h->root.type != bfd_link_hash_undefweak
3077 && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
3078 htab->srofixup->size += 4;
3080 /* No dynamic relocations required when IE->LE conversion happens. */
3081 else if (got_type == GOT_TLS_IE
3083 && !bfd_link_pic (info))
3085 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3086 R_SH_TLS_GD needs one if local symbol and two if global. */
3087 else if ((got_type == GOT_TLS_GD && h->dynindx == -1)
3088 || got_type == GOT_TLS_IE)
3089 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3090 else if (got_type == GOT_TLS_GD)
3091 htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela);
3092 else if (got_type == GOT_FUNCDESC)
3094 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
3095 htab->srofixup->size += 4;
3097 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3099 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3100 || h->root.type != bfd_link_hash_undefweak)
3101 && (bfd_link_pic (info)
3102 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3103 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3104 else if (htab->fdpic_p
3105 && !bfd_link_pic (info)
3106 && got_type == GOT_NORMAL
3107 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3108 || h->root.type != bfd_link_hash_undefweak))
3109 htab->srofixup->size += 4;
3112 h->got.offset = (bfd_vma) -1;
3114 #ifdef INCLUDE_SHMEDIA
3115 if (eh->datalabel_got.refcount > 0)
3120 /* Make sure this symbol is output as a dynamic symbol.
3121 Undefined weak syms won't yet be marked as dynamic. */
3122 if (h->dynindx == -1
3123 && !h->forced_local)
3125 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3129 s = htab->root.sgot;
3130 eh->datalabel_got.offset = s->size;
3132 dyn = htab->root.dynamic_sections_created;
3133 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
3134 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3137 eh->datalabel_got.offset = (bfd_vma) -1;
3140 /* Allocate space for any dynamic relocations to function
3141 descriptors, canonical or otherwise. We need to relocate the
3142 reference unless it resolves to zero, which only happens for
3143 undefined weak symbols (either non-default visibility, or when
3144 static linking). Any GOT slot is accounted for elsewhere. */
3145 if (eh->abs_funcdesc_refcount > 0
3146 && (h->root.type != bfd_link_hash_undefweak
3147 || (htab->root.dynamic_sections_created
3148 && ! SYMBOL_CALLS_LOCAL (info, h))))
3150 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
3151 htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
3153 htab->root.srelgot->size
3154 += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
3157 /* We must allocate a function descriptor if there are references to
3158 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3159 the dynamic linker isn't going to allocate it. None of this
3160 applies if we already created one in .got.plt, but if the
3161 canonical function descriptor can be in this object, there
3162 won't be a PLT entry at all. */
3163 if ((eh->funcdesc.refcount > 0
3164 || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC))
3165 && h->root.type != bfd_link_hash_undefweak
3166 && SYMBOL_FUNCDESC_LOCAL (info, h))
3168 /* Make room for this function descriptor. */
3169 eh->funcdesc.offset = htab->sfuncdesc->size;
3170 htab->sfuncdesc->size += 8;
3172 /* We will need a relocation or two fixups to initialize the
3173 function descriptor, so allocate those too. */
3174 if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
3175 htab->srofixup->size += 8;
3177 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3180 if (eh->dyn_relocs == NULL)
3183 /* In the shared -Bsymbolic case, discard space allocated for
3184 dynamic pc-relative relocs against symbols which turn out to be
3185 defined in regular objects. For the normal shared case, discard
3186 space for pc-relative relocs that have become local due to symbol
3187 visibility changes. */
3189 if (bfd_link_pic (info))
3191 if (SYMBOL_CALLS_LOCAL (info, h))
3193 struct elf_sh_dyn_relocs **pp;
3195 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3197 p->count -= p->pc_count;
3206 if (htab->vxworks_p)
3208 struct elf_sh_dyn_relocs **pp;
3210 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3212 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
3219 /* Also discard relocs on undefined weak syms with non-default
3221 if (eh->dyn_relocs != NULL
3222 && h->root.type == bfd_link_hash_undefweak)
3224 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3225 eh->dyn_relocs = NULL;
3227 /* Make sure undefined weak symbols are output as a dynamic
3229 else if (h->dynindx == -1
3230 && !h->forced_local)
3232 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3239 /* For the non-shared case, discard space for relocs against
3240 symbols which turn out to need copy relocs or are not
3246 || (htab->root.dynamic_sections_created
3247 && (h->root.type == bfd_link_hash_undefweak
3248 || h->root.type == bfd_link_hash_undefined))))
3250 /* Make sure this symbol is output as a dynamic symbol.
3251 Undefined weak syms won't yet be marked as dynamic. */
3252 if (h->dynindx == -1
3253 && !h->forced_local)
3255 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3259 /* If that succeeded, we know we'll be keeping all the
3261 if (h->dynindx != -1)
3265 eh->dyn_relocs = NULL;
3270 /* Finally, allocate space. */
3271 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3273 asection *sreloc = elf_section_data (p->sec)->sreloc;
3274 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3276 /* If we need relocations, we do not need fixups. */
3277 if (htab->fdpic_p && !bfd_link_pic (info))
3278 htab->srofixup->size -= 4 * (p->count - p->pc_count);
3284 /* Find any dynamic relocs that apply to read-only sections. */
3287 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3289 struct elf_sh_link_hash_entry *eh;
3290 struct elf_sh_dyn_relocs *p;
3292 eh = (struct elf_sh_link_hash_entry *) h;
3293 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3295 asection *s = p->sec->output_section;
3297 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3299 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3301 info->flags |= DF_TEXTREL;
3303 /* Not an error, just cut short the traversal. */
3310 /* This function is called after all the input files have been read,
3311 and the input sections have been assigned to output sections.
3312 It's a convenient place to determine the PLT style. */
3315 sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3317 sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd,
3318 bfd_link_pic (info));
3320 if (sh_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info)
3321 && !bfd_elf_stack_segment_size (output_bfd, info,
3322 "__stacksize", DEFAULT_STACK_SIZE))
3327 /* Set the sizes of the dynamic sections. */
3330 sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3331 struct bfd_link_info *info)
3333 struct elf_sh_link_hash_table *htab;
3339 htab = sh_elf_hash_table (info);
3343 dynobj = htab->root.dynobj;
3344 BFD_ASSERT (dynobj != NULL);
3346 if (htab->root.dynamic_sections_created)
3348 /* Set the contents of the .interp section to the interpreter. */
3349 if (bfd_link_executable (info) && !info->nointerp)
3351 s = bfd_get_linker_section (dynobj, ".interp");
3352 BFD_ASSERT (s != NULL);
3353 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3354 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3358 /* Set up .got offsets for local syms, and space for local dynamic
3360 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3362 bfd_signed_vma *local_got;
3363 bfd_signed_vma *end_local_got;
3364 union gotref *local_funcdesc, *end_local_funcdesc;
3365 char *local_got_type;
3366 bfd_size_type locsymcount;
3367 Elf_Internal_Shdr *symtab_hdr;
3370 if (! is_sh_elf (ibfd))
3373 for (s = ibfd->sections; s != NULL; s = s->next)
3375 struct elf_sh_dyn_relocs *p;
3377 for (p = ((struct elf_sh_dyn_relocs *)
3378 elf_section_data (s)->local_dynrel);
3382 if (! bfd_is_abs_section (p->sec)
3383 && bfd_is_abs_section (p->sec->output_section))
3385 /* Input section has been discarded, either because
3386 it is a copy of a linkonce section or due to
3387 linker script /DISCARD/, so we'll be discarding
3390 else if (htab->vxworks_p
3391 && strcmp (p->sec->output_section->name,
3394 /* Relocations in vxworks .tls_vars sections are
3395 handled specially by the loader. */
3397 else if (p->count != 0)
3399 srel = elf_section_data (p->sec)->sreloc;
3400 srel->size += p->count * sizeof (Elf32_External_Rela);
3401 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3402 info->flags |= DF_TEXTREL;
3404 /* If we need relocations, we do not need fixups. */
3405 if (htab->fdpic_p && !bfd_link_pic (info))
3406 htab->srofixup->size -= 4 * (p->count - p->pc_count);
3411 symtab_hdr = &elf_symtab_hdr (ibfd);
3412 locsymcount = symtab_hdr->sh_info;
3413 #ifdef INCLUDE_SHMEDIA
3414 /* Count datalabel local GOT. */
3417 s = htab->root.sgot;
3418 srel = htab->root.srelgot;
3420 local_got = elf_local_got_refcounts (ibfd);
3423 end_local_got = local_got + locsymcount;
3424 local_got_type = sh_elf_local_got_type (ibfd);
3425 local_funcdesc = sh_elf_local_funcdesc (ibfd);
3426 for (; local_got < end_local_got; ++local_got)
3430 *local_got = s->size;
3432 if (*local_got_type == GOT_TLS_GD)
3434 if (bfd_link_pic (info))
3435 srel->size += sizeof (Elf32_External_Rela);
3437 htab->srofixup->size += 4;
3439 if (*local_got_type == GOT_FUNCDESC)
3441 if (local_funcdesc == NULL)
3445 size = locsymcount * sizeof (union gotref);
3446 local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
3448 if (local_funcdesc == NULL)
3450 sh_elf_local_funcdesc (ibfd) = local_funcdesc;
3451 local_funcdesc += (local_got
3452 - elf_local_got_refcounts (ibfd));
3454 local_funcdesc->refcount++;
3459 *local_got = (bfd_vma) -1;
3464 local_funcdesc = sh_elf_local_funcdesc (ibfd);
3467 end_local_funcdesc = local_funcdesc + locsymcount;
3469 for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc)
3471 if (local_funcdesc->refcount > 0)
3473 local_funcdesc->offset = htab->sfuncdesc->size;
3474 htab->sfuncdesc->size += 8;
3475 if (!bfd_link_pic (info))
3476 htab->srofixup->size += 8;
3478 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3481 local_funcdesc->offset = MINUS_ONE;
3487 if (htab->tls_ldm_got.refcount > 0)
3489 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3491 htab->tls_ldm_got.offset = htab->root.sgot->size;
3492 htab->root.sgot->size += 8;
3493 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3496 htab->tls_ldm_got.offset = -1;
3498 /* Only the reserved entries should be present. For FDPIC, they go at
3499 the end of .got.plt. */
3502 BFD_ASSERT (htab->root.sgotplt && htab->root.sgotplt->size == 12);
3503 htab->root.sgotplt->size = 0;
3506 /* Allocate global sym .plt and .got entries, and space for global
3507 sym dynamic relocs. */
3508 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
3510 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3511 end of the FDPIC .got.plt. */
3514 htab->root.hgot->root.u.def.value = htab->root.sgotplt->size;
3515 htab->root.sgotplt->size += 12;
3518 /* At the very end of the .rofixup section is a pointer to the GOT. */
3519 if (htab->fdpic_p && htab->srofixup != NULL)
3520 htab->srofixup->size += 4;
3522 /* We now have determined the sizes of the various dynamic sections.
3523 Allocate memory for them. */
3525 for (s = dynobj->sections; s != NULL; s = s->next)
3527 if ((s->flags & SEC_LINKER_CREATED) == 0)
3530 if (s == htab->root.splt
3531 || s == htab->root.sgot
3532 || s == htab->root.sgotplt
3533 || s == htab->sfuncdesc
3534 || s == htab->srofixup
3535 || s == htab->sdynbss)
3537 /* Strip this section if we don't need it; see the
3540 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3542 if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2)
3545 /* We use the reloc_count field as a counter if we need
3546 to copy relocs into the output file. */
3551 /* It's not one of our sections, so don't allocate space. */
3557 /* If we don't need this section, strip it from the
3558 output file. This is mostly to handle .rela.bss and
3559 .rela.plt. We must create both sections in
3560 create_dynamic_sections, because they must be created
3561 before the linker maps input sections to output
3562 sections. The linker does that before
3563 adjust_dynamic_symbol is called, and it is that
3564 function which decides whether anything needs to go
3565 into these sections. */
3567 s->flags |= SEC_EXCLUDE;
3571 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3574 /* Allocate memory for the section contents. We use bfd_zalloc
3575 here in case unused entries are not reclaimed before the
3576 section's contents are written out. This should not happen,
3577 but this way if it does, we get a R_SH_NONE reloc instead
3579 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3580 if (s->contents == NULL)
3584 if (htab->root.dynamic_sections_created)
3586 /* Add some entries to the .dynamic section. We fill in the
3587 values later, in sh_elf_finish_dynamic_sections, but we
3588 must add the entries now so that we get the correct size for
3589 the .dynamic section. The DT_DEBUG entry is filled in by the
3590 dynamic linker and used by the debugger. */
3591 #define add_dynamic_entry(TAG, VAL) \
3592 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3594 if (bfd_link_executable (info))
3596 if (! add_dynamic_entry (DT_DEBUG, 0))
3600 if (htab->root.splt->size != 0)
3602 if (! add_dynamic_entry (DT_PLTGOT, 0)
3603 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
3604 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
3605 || ! add_dynamic_entry (DT_JMPREL, 0))
3608 else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC))
3610 if (! add_dynamic_entry (DT_PLTGOT, 0))
3616 if (! add_dynamic_entry (DT_RELA, 0)
3617 || ! add_dynamic_entry (DT_RELASZ, 0)
3618 || ! add_dynamic_entry (DT_RELAENT,
3619 sizeof (Elf32_External_Rela)))
3622 /* If any dynamic relocs apply to a read-only section,
3623 then we need a DT_TEXTREL entry. */
3624 if ((info->flags & DF_TEXTREL) == 0)
3625 elf_link_hash_traverse (&htab->root, readonly_dynrelocs, info);
3627 if ((info->flags & DF_TEXTREL) != 0)
3629 if (! add_dynamic_entry (DT_TEXTREL, 0))
3634 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3637 #undef add_dynamic_entry
3642 /* Add a dynamic relocation to the SRELOC section. */
3644 inline static bfd_vma
3645 sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
3646 int reloc_type, long dynindx, bfd_vma addend)
3648 Elf_Internal_Rela outrel;
3649 bfd_vma reloc_offset;
3651 outrel.r_offset = offset;
3652 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
3653 outrel.r_addend = addend;
3655 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela);
3656 BFD_ASSERT (reloc_offset < sreloc->size);
3657 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3658 sreloc->contents + reloc_offset);
3659 sreloc->reloc_count++;
3661 return reloc_offset;
3664 /* Add an FDPIC read-only fixup. */
3667 sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset)
3669 bfd_vma fixup_offset;
3671 fixup_offset = srofixup->reloc_count++ * 4;
3672 BFD_ASSERT (fixup_offset < srofixup->size);
3673 bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset);
3676 /* Return the offset of the generated .got section from the
3677 _GLOBAL_OFFSET_TABLE_ symbol. */
3679 static bfd_signed_vma
3680 sh_elf_got_offset (struct elf_sh_link_hash_table *htab)
3682 return (htab->root.sgot->output_offset - htab->root.sgotplt->output_offset
3683 - htab->root.hgot->root.u.def.value);
3686 /* Find the segment number in which OSEC, and output section, is
3690 sh_elf_osec_to_segment (bfd *output_bfd, asection *osec)
3692 Elf_Internal_Phdr *p = NULL;
3694 if (output_bfd->xvec->flavour == bfd_target_elf_flavour
3695 /* PR ld/17110: Do not look for output segments in an input bfd. */
3696 && output_bfd->direction != read_direction)
3697 p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
3699 /* FIXME: Nothing ever says what this index is relative to. The kernel
3700 supplies data in terms of the number of load segments but this is
3701 a phdr index and the first phdr may not be a load segment. */
3702 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
3706 sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
3708 unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
3710 return (seg != (unsigned) -1
3711 && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W));
3714 /* Generate the initial contents of a local function descriptor, along
3715 with any relocations or fixups required. */
3717 sh_elf_initialize_funcdesc (bfd *output_bfd,
3718 struct bfd_link_info *info,
3719 struct elf_link_hash_entry *h,
3724 struct elf_sh_link_hash_table *htab;
3728 htab = sh_elf_hash_table (info);
3730 /* FIXME: The ABI says that the offset to the function goes in the
3731 descriptor, along with the segment index. We're RELA, so it could
3732 go in the reloc instead... */
3734 if (h != NULL && SYMBOL_CALLS_LOCAL (info, h))
3736 section = h->root.u.def.section;
3737 value = h->root.u.def.value;
3740 if (h == NULL || SYMBOL_CALLS_LOCAL (info, h))
3742 dynindx = elf_section_data (section->output_section)->dynindx;
3743 addr = value + section->output_offset;
3744 seg = sh_elf_osec_to_segment (output_bfd, section->output_section);
3748 BFD_ASSERT (h->dynindx != -1);
3749 dynindx = h->dynindx;
3753 if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
3755 if (h == NULL || h->root.type != bfd_link_hash_undefweak)
3757 sh_elf_add_rofixup (output_bfd, htab->srofixup,
3759 + htab->sfuncdesc->output_section->vma
3760 + htab->sfuncdesc->output_offset);
3761 sh_elf_add_rofixup (output_bfd, htab->srofixup,
3763 + htab->sfuncdesc->output_section->vma
3764 + htab->sfuncdesc->output_offset);
3767 /* There are no dynamic relocations so fill in the final
3768 address and gp value (barring fixups). */
3769 addr += section->output_section->vma;
3770 seg = htab->root.hgot->root.u.def.value
3771 + htab->root.hgot->root.u.def.section->output_section->vma
3772 + htab->root.hgot->root.u.def.section->output_offset;
3775 sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc,
3777 + htab->sfuncdesc->output_section->vma
3778 + htab->sfuncdesc->output_offset,
3779 R_SH_FUNCDESC_VALUE, dynindx, 0);
3781 bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
3782 bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
3787 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3788 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3791 static bfd_reloc_status_type
3792 install_movi20_field (bfd *output_bfd, unsigned long relocation,
3793 bfd *input_bfd, asection *input_section,
3794 bfd_byte *contents, bfd_vma offset)
3796 unsigned long cur_val;
3798 bfd_reloc_status_type r;
3800 if (offset > bfd_get_section_limit (input_bfd, input_section))
3801 return bfd_reloc_outofrange;
3803 r = bfd_check_overflow (complain_overflow_signed, 20, 0,
3804 bfd_arch_bits_per_address (input_bfd), relocation);
3805 if (r != bfd_reloc_ok)
3808 addr = contents + offset;
3809 cur_val = bfd_get_16 (output_bfd, addr);
3810 bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr);
3811 bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2);
3813 return bfd_reloc_ok;
3816 /* Relocate an SH ELF section. */
3819 sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
3820 bfd *input_bfd, asection *input_section,
3821 bfd_byte *contents, Elf_Internal_Rela *relocs,
3822 Elf_Internal_Sym *local_syms,
3823 asection **local_sections)
3825 struct elf_sh_link_hash_table *htab;
3826 Elf_Internal_Shdr *symtab_hdr;
3827 struct elf_link_hash_entry **sym_hashes;
3828 Elf_Internal_Rela *rel, *relend;
3829 bfd_vma *local_got_offsets;
3830 asection *sgot = NULL;
3831 asection *sgotplt = NULL;
3832 asection *splt = NULL;
3833 asection *sreloc = NULL;
3834 asection *srelgot = NULL;
3835 bfd_boolean is_vxworks_tls;
3836 unsigned isec_segment, got_segment, plt_segment, check_segment[2];
3837 bfd_boolean fdpic_p = FALSE;
3839 BFD_ASSERT (is_sh_elf (input_bfd));
3841 htab = sh_elf_hash_table (info);
3844 sgot = htab->root.sgot;
3845 sgotplt = htab->root.sgotplt;
3846 srelgot = htab->root.srelgot;
3847 splt = htab->root.splt;
3848 fdpic_p = htab->fdpic_p;
3850 symtab_hdr = &elf_symtab_hdr (input_bfd);
3851 sym_hashes = elf_sym_hashes (input_bfd);
3852 local_got_offsets = elf_local_got_offsets (input_bfd);
3854 isec_segment = sh_elf_osec_to_segment (output_bfd,
3855 input_section->output_section);
3856 if (fdpic_p && sgot)
3857 got_segment = sh_elf_osec_to_segment (output_bfd,
3858 sgot->output_section);
3861 if (fdpic_p && splt)
3862 plt_segment = sh_elf_osec_to_segment (output_bfd,
3863 splt->output_section);
3867 /* We have to handle relocations in vxworks .tls_vars sections
3868 specially, because the dynamic loader is 'weird'. */
3869 is_vxworks_tls = (htab && htab->vxworks_p && bfd_link_pic (info)
3870 && !strcmp (input_section->output_section->name,
3874 relend = relocs + input_section->reloc_count;
3875 for (; rel < relend; rel++)
3878 reloc_howto_type *howto;
3879 unsigned long r_symndx;
3880 Elf_Internal_Sym *sym;
3882 struct elf_link_hash_entry *h;
3884 bfd_vma addend = (bfd_vma) 0;
3885 bfd_reloc_status_type r;
3886 int seen_stt_datalabel = 0;
3888 enum got_type got_type;
3889 const char *symname = NULL;
3891 r_symndx = ELF32_R_SYM (rel->r_info);
3893 r_type = ELF32_R_TYPE (rel->r_info);
3895 /* Many of the relocs are only used for relaxing, and are
3896 handled entirely by the relaxation code. */
3897 if (r_type >= (int) R_SH_GNU_VTINHERIT
3898 && r_type <= (int) R_SH_LABEL)
3900 if (r_type == (int) R_SH_NONE)
3904 || r_type >= R_SH_max
3905 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
3906 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
3907 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
3908 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2)
3909 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
3910 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
3911 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
3912 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
3913 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
3914 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
3915 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_6
3916 && r_type <= (int) R_SH_LAST_INVALID_RELOC_6))
3918 bfd_set_error (bfd_error_bad_value);
3922 howto = get_howto_table (output_bfd) + r_type;
3924 /* For relocs that aren't partial_inplace, we get the addend from
3926 if (! howto->partial_inplace)
3927 addend = rel->r_addend;
3932 check_segment[0] = -1;
3933 check_segment[1] = -1;
3934 if (r_symndx < symtab_hdr->sh_info)
3936 sym = local_syms + r_symndx;
3937 sec = local_sections[r_symndx];
3939 symname = bfd_elf_string_from_elf_section
3940 (input_bfd, symtab_hdr->sh_link, sym->st_name);
3941 if (symname == NULL || *symname == '\0')
3942 symname = bfd_section_name (input_bfd, sec);
3944 relocation = (sec->output_section->vma
3945 + sec->output_offset
3947 /* A local symbol never has STO_SH5_ISA32, so we don't need
3948 datalabel processing here. Make sure this does not change
3950 if ((sym->st_other & STO_SH5_ISA32) != 0)
3951 (*info->callbacks->reloc_dangerous)
3953 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
3954 input_bfd, input_section, rel->r_offset);
3956 if (sec != NULL && discarded_section (sec))
3957 /* Handled below. */
3959 else if (bfd_link_relocatable (info))
3961 /* This is a relocatable link. We don't have to change
3962 anything, unless the reloc is against a section symbol,
3963 in which case we have to adjust according to where the
3964 section symbol winds up in the output section. */
3965 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3967 if (! howto->partial_inplace)
3969 /* For relocations with the addend in the
3970 relocation, we need just to update the addend.
3971 All real relocs are of type partial_inplace; this
3972 code is mostly for completeness. */
3973 rel->r_addend += sec->output_offset;
3978 /* Relocs of type partial_inplace need to pick up the
3979 contents in the contents and add the offset resulting
3980 from the changed location of the section symbol.
3981 Using _bfd_final_link_relocate (e.g. goto
3982 final_link_relocate) here would be wrong, because
3983 relocations marked pc_relative would get the current
3984 location subtracted, and we must only do that at the
3986 r = _bfd_relocate_contents (howto, input_bfd,
3989 contents + rel->r_offset);
3990 goto relocation_done;
3995 else if (! howto->partial_inplace)
3997 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3998 addend = rel->r_addend;
4000 else if ((sec->flags & SEC_MERGE)
4001 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4005 if (howto->rightshift || howto->src_mask != 0xffffffff)
4008 /* xgettext:c-format */
4009 (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
4010 input_bfd, input_section,
4011 rel->r_offset, howto->name);
4015 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4018 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4020 addend += msec->output_section->vma + msec->output_offset;
4021 bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4027 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4030 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4031 symname = h->root.root.string;
4032 while (h->root.type == bfd_link_hash_indirect
4033 || h->root.type == bfd_link_hash_warning)
4035 #ifdef INCLUDE_SHMEDIA
4036 /* If the reference passes a symbol marked with
4037 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4039 seen_stt_datalabel |= h->type == STT_DATALABEL;
4041 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4043 if (h->root.type == bfd_link_hash_defined
4044 || h->root.type == bfd_link_hash_defweak)
4048 dyn = htab ? htab->root.dynamic_sections_created : FALSE;
4049 sec = h->root.u.def.section;
4050 /* In these cases, we don't need the relocation value.
4051 We check specially because in some obscure cases
4052 sec->output_section will be NULL. */
4053 if (r_type == R_SH_GOTPC
4054 || r_type == R_SH_GOTPC_LOW16
4055 || r_type == R_SH_GOTPC_MEDLOW16
4056 || r_type == R_SH_GOTPC_MEDHI16
4057 || r_type == R_SH_GOTPC_HI16
4058 || ((r_type == R_SH_PLT32
4059 || r_type == R_SH_PLT_LOW16
4060 || r_type == R_SH_PLT_MEDLOW16
4061 || r_type == R_SH_PLT_MEDHI16
4062 || r_type == R_SH_PLT_HI16)
4063 && h->plt.offset != (bfd_vma) -1)
4064 || ((r_type == R_SH_GOT32
4065 || r_type == R_SH_GOT20
4066 || r_type == R_SH_GOTFUNCDESC
4067 || r_type == R_SH_GOTFUNCDESC20
4068 || r_type == R_SH_GOTOFFFUNCDESC
4069 || r_type == R_SH_GOTOFFFUNCDESC20
4070 || r_type == R_SH_FUNCDESC
4071 || r_type == R_SH_GOT_LOW16
4072 || r_type == R_SH_GOT_MEDLOW16
4073 || r_type == R_SH_GOT_MEDHI16
4074 || r_type == R_SH_GOT_HI16)
4075 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4076 bfd_link_pic (info),
4078 && (! bfd_link_pic (info)
4079 || (! info->symbolic && h->dynindx != -1)
4080 || !h->def_regular))
4081 /* The cases above are those in which relocation is
4082 overwritten in the switch block below. The cases
4083 below are those in which we must defer relocation
4084 to run-time, because we can't resolve absolute
4085 addresses when creating a shared library. */
4086 || (bfd_link_pic (info)
4087 && ((! info->symbolic && h->dynindx != -1)
4089 && ((r_type == R_SH_DIR32
4090 && !h->forced_local)
4091 || (r_type == R_SH_REL32
4092 && !SYMBOL_CALLS_LOCAL (info, h)))
4093 && ((input_section->flags & SEC_ALLOC) != 0
4094 /* DWARF will emit R_SH_DIR32 relocations in its
4095 sections against symbols defined externally
4096 in shared libraries. We can't do anything
4098 || ((input_section->flags & SEC_DEBUGGING) != 0
4099 && h->def_dynamic)))
4100 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4101 sections because such sections are not SEC_ALLOC and
4102 thus ld.so will not process them. */
4103 || (sec->output_section == NULL
4104 && ((input_section->flags & SEC_DEBUGGING) != 0
4106 || (sec->output_section == NULL
4107 && (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE
4108 || sh_elf_hash_entry (h)->got_type == GOT_TLS_GD)))
4110 else if (sec->output_section != NULL)
4111 relocation = ((h->root.u.def.value
4112 + sec->output_section->vma
4113 + sec->output_offset)
4114 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4115 symbol value, unless we've seen
4116 STT_DATALABEL on the way to it. */
4117 | ((h->other & STO_SH5_ISA32) != 0
4118 && ! seen_stt_datalabel));
4119 else if (!bfd_link_relocatable (info)
4120 && (_bfd_elf_section_offset (output_bfd, info,
4126 /* xgettext:c-format */
4127 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
4132 h->root.root.string);
4136 else if (h->root.type == bfd_link_hash_undefweak)
4138 else if (info->unresolved_syms_in_objects == RM_IGNORE
4139 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4141 else if (!bfd_link_relocatable (info))
4142 (*info->callbacks->undefined_symbol)
4143 (info, h->root.root.string, input_bfd,
4144 input_section, rel->r_offset,
4145 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4146 || ELF_ST_VISIBILITY (h->other)));
4149 if (sec != NULL && discarded_section (sec))
4150 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4151 rel, 1, relend, howto, 0, contents);
4153 if (bfd_link_relocatable (info))
4156 /* Check for inter-segment relocations in FDPIC files. Most
4157 relocations connect the relocation site to the location of
4158 the target symbol, but there are some exceptions below. */
4159 check_segment[0] = isec_segment;
4161 check_segment[1] = sh_elf_osec_to_segment (output_bfd,
4162 sec->output_section);
4164 check_segment[1] = -1;
4166 switch ((int) r_type)
4168 final_link_relocate:
4169 /* COFF relocs don't use the addend. The addend is used for
4170 R_SH_DIR32 to be compatible with other compilers. */
4171 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4172 contents, rel->r_offset,
4173 relocation, addend);
4177 goto final_link_relocate;
4182 /* If the reloc is against the start of this section, then
4183 the assembler has already taken care of it and the reloc
4184 is here only to assist in relaxing. If the reloc is not
4185 against the start of this section, then it's against an
4186 external symbol and we must deal with it ourselves. */
4187 if (input_section->output_section->vma + input_section->output_offset
4190 int disp = (relocation
4191 - input_section->output_section->vma
4192 - input_section->output_offset
4198 case R_SH_DIR8WPZ: mask = 1; break;
4199 case R_SH_DIR8WPL: mask = 3; break;
4200 default: mask = 0; break;
4205 /* xgettext:c-format */
4206 (_("%B: %#Lx: fatal: unaligned branch target for relax-support relocation"),
4207 input_section->owner,
4209 bfd_set_error (bfd_error_bad_value);
4213 goto final_link_relocate;
4219 #ifdef INCLUDE_SHMEDIA
4220 if (shmedia_prepare_reloc (info, input_bfd, input_section,
4221 contents, rel, &relocation))
4222 goto final_link_relocate;
4224 bfd_set_error (bfd_error_bad_value);
4232 goto final_link_relocate;
4239 /* xgettext:c-format */
4240 (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
4241 input_section->owner,
4242 rel->r_offset, howto->name,
4244 bfd_set_error (bfd_error_bad_value);
4247 goto final_link_relocate;
4255 /* xgettext:c-format */
4256 (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
4257 input_section->owner,
4258 rel->r_offset, howto->name,
4260 bfd_set_error (bfd_error_bad_value);
4263 goto final_link_relocate;
4266 if ((signed int)relocation < -32
4267 || (signed int)relocation > 32)
4270 /* xgettext:c-format */
4271 (_("%B: %#Lx: fatal: R_SH_PSHA relocation %Ld not in range -32..32"),
4272 input_section->owner,
4275 bfd_set_error (bfd_error_bad_value);
4278 goto final_link_relocate;
4281 if ((signed int)relocation < -16
4282 || (signed int)relocation > 16)
4285 /* xgettext:c-format */
4286 (_("%B: %#Lx: fatal: R_SH_PSHL relocation %Ld not in range -32..32"),
4287 input_section->owner,
4290 bfd_set_error (bfd_error_bad_value);
4293 goto final_link_relocate;
4297 #ifdef INCLUDE_SHMEDIA
4298 case R_SH_IMM_LOW16_PCREL:
4299 case R_SH_IMM_MEDLOW16_PCREL:
4300 case R_SH_IMM_MEDHI16_PCREL:
4301 case R_SH_IMM_HI16_PCREL:
4303 if (bfd_link_pic (info)
4305 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4306 || h->root.type != bfd_link_hash_undefweak)
4307 && r_symndx != STN_UNDEF
4308 && (input_section->flags & SEC_ALLOC) != 0
4310 && (r_type == R_SH_DIR32
4311 || !SYMBOL_CALLS_LOCAL (info, h)))
4313 Elf_Internal_Rela outrel;
4315 bfd_boolean skip, relocate;
4317 /* When generating a shared object, these relocations
4318 are copied into the output file to be resolved at run
4323 sreloc = _bfd_elf_get_dynamic_reloc_section
4324 (input_bfd, input_section, /*rela?*/ TRUE);
4333 _bfd_elf_section_offset (output_bfd, info, input_section,
4335 if (outrel.r_offset == (bfd_vma) -1)
4337 else if (outrel.r_offset == (bfd_vma) -2)
4338 skip = TRUE, relocate = TRUE;
4339 outrel.r_offset += (input_section->output_section->vma
4340 + input_section->output_offset);
4343 memset (&outrel, 0, sizeof outrel);
4344 else if (r_type == R_SH_REL32)
4346 BFD_ASSERT (h != NULL && h->dynindx != -1);
4347 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4349 = (howto->partial_inplace
4350 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4353 #ifdef INCLUDE_SHMEDIA
4354 else if (r_type == R_SH_IMM_LOW16_PCREL
4355 || r_type == R_SH_IMM_MEDLOW16_PCREL
4356 || r_type == R_SH_IMM_MEDHI16_PCREL
4357 || r_type == R_SH_IMM_HI16_PCREL)
4359 BFD_ASSERT (h != NULL && h->dynindx != -1);
4360 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4361 outrel.r_addend = addend;
4366 || ((info->symbolic || h->dynindx == -1)
4367 && h->def_regular)))
4371 BFD_ASSERT (sec != NULL);
4372 BFD_ASSERT (sec->output_section != NULL);
4373 dynindx = elf_section_data (sec->output_section)->dynindx;
4374 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4375 outrel.r_addend = relocation;
4377 += (howto->partial_inplace
4378 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4380 outrel.r_addend -= sec->output_section->vma;
4384 /* h->dynindx may be -1 if this symbol was marked to
4387 || ((info->symbolic || h->dynindx == -1)
4390 relocate = howto->partial_inplace;
4391 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4395 BFD_ASSERT (h->dynindx != -1);
4396 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4398 outrel.r_addend = relocation;
4400 += (howto->partial_inplace
4401 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4405 loc = sreloc->contents;
4406 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4407 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4409 check_segment[0] = check_segment[1] = -1;
4411 /* If this reloc is against an external symbol, we do
4412 not want to fiddle with the addend. Otherwise, we
4413 need to include the symbol value so that it becomes
4414 an addend for the dynamic reloc. */
4418 else if (fdpic_p && !bfd_link_pic (info)
4419 && r_type == R_SH_DIR32
4420 && (input_section->flags & SEC_ALLOC) != 0)
4426 if (sh_elf_osec_readonly_p (output_bfd,
4427 input_section->output_section))
4430 /* xgettext:c-format */
4431 (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
4439 offset = _bfd_elf_section_offset (output_bfd, info,
4440 input_section, rel->r_offset);
4441 if (offset != (bfd_vma)-1)
4442 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4443 input_section->output_section->vma
4444 + input_section->output_offset
4447 check_segment[0] = check_segment[1] = -1;
4449 /* We don't want warnings for non-NULL tests on undefined weak
4451 else if (r_type == R_SH_REL32
4453 && h->root.type == bfd_link_hash_undefweak)
4454 check_segment[0] = check_segment[1] = -1;
4455 goto final_link_relocate;
4458 #ifdef INCLUDE_SHMEDIA
4459 case R_SH_GOTPLT_LOW16:
4460 case R_SH_GOTPLT_MEDLOW16:
4461 case R_SH_GOTPLT_MEDHI16:
4462 case R_SH_GOTPLT_HI16:
4463 case R_SH_GOTPLT10BY4:
4464 case R_SH_GOTPLT10BY8:
4466 /* Relocation is to the entry for this symbol in the
4467 procedure linkage table. */
4471 || ! bfd_link_pic (info)
4474 || h->plt.offset == (bfd_vma) -1
4475 || h->got.offset != (bfd_vma) -1)
4478 /* Relocation is to the entry for this symbol in the global
4479 offset table extension for the procedure linkage table. */
4482 BFD_ASSERT (sgotplt != NULL);
4483 relocation = (sgotplt->output_offset
4484 + (get_plt_index (htab->plt_info, h->plt.offset)
4488 relocation -= GOT_BIAS;
4491 goto final_link_relocate;
4496 #ifdef INCLUDE_SHMEDIA
4497 case R_SH_GOT_LOW16:
4498 case R_SH_GOT_MEDLOW16:
4499 case R_SH_GOT_MEDHI16:
4504 /* Relocation is to the entry for this symbol in the global
4508 BFD_ASSERT (sgot != NULL);
4509 check_segment[0] = check_segment[1] = -1;
4515 off = h->got.offset;
4516 #ifdef INCLUDE_SHMEDIA
4517 if (seen_stt_datalabel)
4519 struct elf_sh_link_hash_entry *hsh;
4521 hsh = (struct elf_sh_link_hash_entry *)h;
4522 off = hsh->datalabel_got.offset;
4525 BFD_ASSERT (off != (bfd_vma) -1);
4527 dyn = htab->root.dynamic_sections_created;
4528 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4529 bfd_link_pic (info),
4531 || (bfd_link_pic (info)
4532 && SYMBOL_REFERENCES_LOCAL (info, h))
4533 || (ELF_ST_VISIBILITY (h->other)
4534 && h->root.type == bfd_link_hash_undefweak))
4536 /* This is actually a static link, or it is a
4537 -Bsymbolic link and the symbol is defined
4538 locally, or the symbol was forced to be local
4539 because of a version file. We must initialize
4540 this entry in the global offset table. Since the
4541 offset must always be a multiple of 4, we use the
4542 least significant bit to record whether we have
4543 initialized it already.
4545 When doing a dynamic link, we create a .rela.got
4546 relocation entry to initialize the value. This
4547 is done in the finish_dynamic_symbol routine. */
4552 bfd_put_32 (output_bfd, relocation,
4553 sgot->contents + off);
4554 #ifdef INCLUDE_SHMEDIA
4555 if (seen_stt_datalabel)
4557 struct elf_sh_link_hash_entry *hsh;
4559 hsh = (struct elf_sh_link_hash_entry *)h;
4560 hsh->datalabel_got.offset |= 1;
4566 /* If we initialize the GOT entry here with a valid
4567 symbol address, also add a fixup. */
4568 if (fdpic_p && !bfd_link_pic (info)
4569 && sh_elf_hash_entry (h)->got_type == GOT_NORMAL
4570 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4571 || h->root.type != bfd_link_hash_undefweak))
4572 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4573 sgot->output_section->vma
4574 + sgot->output_offset
4579 relocation = sh_elf_got_offset (htab) + off;
4583 #ifdef INCLUDE_SHMEDIA
4586 BFD_ASSERT (local_got_offsets != NULL
4587 && (local_got_offsets[symtab_hdr->sh_info
4591 off = local_got_offsets[symtab_hdr->sh_info
4597 BFD_ASSERT (local_got_offsets != NULL
4598 && local_got_offsets[r_symndx] != (bfd_vma) -1);
4600 off = local_got_offsets[r_symndx];
4601 #ifdef INCLUDE_SHMEDIA
4605 /* The offset must always be a multiple of 4. We use
4606 the least significant bit to record whether we have
4607 already generated the necessary reloc. */
4612 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4614 if (bfd_link_pic (info))
4616 Elf_Internal_Rela outrel;
4619 outrel.r_offset = (sgot->output_section->vma
4620 + sgot->output_offset
4625 = elf_section_data (sec->output_section)->dynindx;
4626 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4627 outrel.r_addend = relocation;
4628 outrel.r_addend -= sec->output_section->vma;
4632 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4633 outrel.r_addend = relocation;
4635 loc = srelgot->contents;
4636 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4637 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4640 && (sh_elf_local_got_type (input_bfd) [r_symndx]
4642 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4643 sgot->output_section->vma
4644 + sgot->output_offset
4647 #ifdef INCLUDE_SHMEDIA
4649 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
4652 local_got_offsets[r_symndx] |= 1;
4655 relocation = sh_elf_got_offset (htab) + off;
4659 relocation -= GOT_BIAS;
4662 if (r_type == R_SH_GOT20)
4664 r = install_movi20_field (output_bfd, relocation + addend,
4665 input_bfd, input_section, contents,
4670 goto final_link_relocate;
4674 #ifdef INCLUDE_SHMEDIA
4675 case R_SH_GOTOFF_LOW16:
4676 case R_SH_GOTOFF_MEDLOW16:
4677 case R_SH_GOTOFF_MEDHI16:
4678 case R_SH_GOTOFF_HI16:
4680 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4681 we place at the start of the .got.plt section. This is the same
4682 as the start of the output .got section, unless there are function
4683 descriptors in front of it. */
4685 BFD_ASSERT (sgotplt != NULL);
4686 check_segment[0] = got_segment;
4687 relocation -= sgotplt->output_section->vma + sgotplt->output_offset
4688 + htab->root.hgot->root.u.def.value;
4691 relocation -= GOT_BIAS;
4694 addend = rel->r_addend;
4696 if (r_type == R_SH_GOTOFF20)
4698 r = install_movi20_field (output_bfd, relocation + addend,
4699 input_bfd, input_section, contents,
4704 goto final_link_relocate;
4707 #ifdef INCLUDE_SHMEDIA
4708 case R_SH_GOTPC_LOW16:
4709 case R_SH_GOTPC_MEDLOW16:
4710 case R_SH_GOTPC_MEDHI16:
4711 case R_SH_GOTPC_HI16:
4713 /* Use global offset table as symbol value. */
4715 BFD_ASSERT (sgotplt != NULL);
4716 relocation = sgotplt->output_section->vma + sgotplt->output_offset;
4719 relocation += GOT_BIAS;
4722 addend = rel->r_addend;
4724 goto final_link_relocate;
4727 #ifdef INCLUDE_SHMEDIA
4728 case R_SH_PLT_LOW16:
4729 case R_SH_PLT_MEDLOW16:
4730 case R_SH_PLT_MEDHI16:
4733 /* Relocation is to the entry for this symbol in the
4734 procedure linkage table. */
4736 /* Resolve a PLT reloc against a local symbol directly,
4737 without using the procedure linkage table. */
4739 goto final_link_relocate;
4741 /* We don't want to warn on calls to undefined weak symbols,
4742 as calls to them must be protected by non-NULL tests
4743 anyway, and unprotected calls would invoke undefined
4745 if (h->root.type == bfd_link_hash_undefweak)
4746 check_segment[0] = check_segment[1] = -1;
4748 if (h->forced_local)
4749 goto final_link_relocate;
4751 if (h->plt.offset == (bfd_vma) -1)
4753 /* We didn't make a PLT entry for this symbol. This
4754 happens when statically linking PIC code, or when
4755 using -Bsymbolic. */
4756 goto final_link_relocate;
4759 BFD_ASSERT (splt != NULL);
4760 check_segment[1] = plt_segment;
4761 relocation = (splt->output_section->vma
4762 + splt->output_offset
4765 #ifdef INCLUDE_SHMEDIA
4769 addend = rel->r_addend;
4771 goto final_link_relocate;
4773 /* Relocation is to the canonical function descriptor for this
4774 symbol, possibly via the GOT. Initialize the GOT
4775 entry and function descriptor if necessary. */
4776 case R_SH_GOTFUNCDESC:
4777 case R_SH_GOTFUNCDESC20:
4781 asection *reloc_section;
4782 bfd_vma reloc_offset;
4783 int reloc_type = R_SH_FUNCDESC;
4787 check_segment[0] = check_segment[1] = -1;
4789 /* FIXME: See what FRV does for global symbols in the
4790 executable, with --export-dynamic. Do they need ld.so
4791 to allocate official descriptors? See what this code
4797 if (r_type == R_SH_FUNCDESC)
4799 reloc_section = input_section;
4800 reloc_offset = rel->r_offset;
4804 reloc_section = sgot;
4807 reloc_offset = h->got.offset;
4810 BFD_ASSERT (local_got_offsets != NULL);
4811 reloc_offset = local_got_offsets[r_symndx];
4813 BFD_ASSERT (reloc_offset != MINUS_ONE);
4815 if (reloc_offset & 1)
4818 goto funcdesc_done_got;
4822 if (h && h->root.type == bfd_link_hash_undefweak
4823 && (SYMBOL_CALLS_LOCAL (info, h)
4824 || !htab->root.dynamic_sections_created))
4825 /* Undefined weak symbol which will not be dynamically
4826 resolved later; leave it at zero. */
4827 goto funcdesc_leave_zero;
4828 else if (SYMBOL_CALLS_LOCAL (info, h)
4829 && ! SYMBOL_FUNCDESC_LOCAL (info, h))
4831 /* If the symbol needs a non-local function descriptor
4832 but binds locally (i.e., its visibility is
4833 protected), emit a dynamic relocation decayed to
4834 section+offset. This is an optimization; the dynamic
4835 linker would resolve our function descriptor request
4836 to our copy of the function anyway. */
4837 dynindx = elf_section_data (h->root.u.def.section
4838 ->output_section)->dynindx;
4839 relocation += h->root.u.def.section->output_offset
4840 + h->root.u.def.value;
4842 else if (! SYMBOL_FUNCDESC_LOCAL (info, h))
4844 /* If the symbol is dynamic and there will be dynamic
4845 symbol resolution because we are or are linked with a
4846 shared library, emit a FUNCDESC relocation such that
4847 the dynamic linker will allocate the function
4849 BFD_ASSERT (h->dynindx != -1);
4850 dynindx = h->dynindx;
4856 /* Otherwise, we know we have a private function
4857 descriptor, so reference it directly. */
4858 reloc_type = R_SH_DIR32;
4859 dynindx = elf_section_data (htab->sfuncdesc
4860 ->output_section)->dynindx;
4864 offset = sh_elf_hash_entry (h)->funcdesc.offset;
4865 BFD_ASSERT (offset != MINUS_ONE);
4866 if ((offset & 1) == 0)
4868 if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
4871 sh_elf_hash_entry (h)->funcdesc.offset |= 1;
4876 union gotref *local_funcdesc;
4878 local_funcdesc = sh_elf_local_funcdesc (input_bfd);
4879 offset = local_funcdesc[r_symndx].offset;
4880 BFD_ASSERT (offset != MINUS_ONE);
4881 if ((offset & 1) == 0)
4883 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
4887 local_funcdesc[r_symndx].offset |= 1;
4891 relocation = htab->sfuncdesc->output_offset + (offset & ~1);
4894 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
4898 if (sh_elf_osec_readonly_p (output_bfd,
4899 reloc_section->output_section))
4902 /* xgettext:c-format */
4903 (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
4911 offset = _bfd_elf_section_offset (output_bfd, info,
4912 reloc_section, reloc_offset);
4914 if (offset != (bfd_vma)-1)
4915 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4917 + reloc_section->output_section->vma
4918 + reloc_section->output_offset);
4920 else if ((reloc_section->output_section->flags
4921 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
4925 if (sh_elf_osec_readonly_p (output_bfd,
4926 reloc_section->output_section))
4928 info->callbacks->warning
4930 _("cannot emit dynamic relocations in read-only section"),
4931 symname, input_bfd, reloc_section, reloc_offset);
4935 offset = _bfd_elf_section_offset (output_bfd, info,
4936 reloc_section, reloc_offset);
4938 if (offset != (bfd_vma)-1)
4939 sh_elf_add_dyn_reloc (output_bfd, srelgot,
4941 + reloc_section->output_section->vma
4942 + reloc_section->output_offset,
4943 reloc_type, dynindx, relocation);
4945 if (r_type == R_SH_FUNCDESC)
4953 goto funcdesc_leave_zero;
4957 if (SYMBOL_FUNCDESC_LOCAL (info, h))
4958 relocation += htab->sfuncdesc->output_section->vma;
4959 funcdesc_leave_zero:
4960 if (r_type != R_SH_FUNCDESC)
4962 bfd_put_32 (output_bfd, relocation,
4963 reloc_section->contents + reloc_offset);
4967 local_got_offsets[r_symndx] |= 1;
4971 relocation = sh_elf_got_offset (htab) + reloc_offset;
4973 relocation -= GOT_BIAS;
4976 if (r_type == R_SH_GOTFUNCDESC20)
4978 r = install_movi20_field (output_bfd, relocation + addend,
4979 input_bfd, input_section, contents,
4984 goto final_link_relocate;
4988 case R_SH_GOTOFFFUNCDESC:
4989 case R_SH_GOTOFFFUNCDESC20:
4990 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4991 executable and --export-dynamic. If such symbols get
4992 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4996 check_segment[0] = check_segment[1] = -1;
4998 addend = rel->r_addend;
5000 if (h && (h->root.type == bfd_link_hash_undefweak
5001 || !SYMBOL_FUNCDESC_LOCAL (info, h)))
5004 /* xgettext:c-format */
5005 (_("%B(%A+%#Lx): %s relocation against external symbol \"%s\""),
5006 input_bfd, input_section, rel->r_offset, howto->name,
5007 h->root.root.string);
5014 /* Otherwise, we know we have a private function
5015 descriptor, so reference it directly. */
5018 offset = sh_elf_hash_entry (h)->funcdesc.offset;
5019 BFD_ASSERT (offset != MINUS_ONE);
5020 if ((offset & 1) == 0)
5022 if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
5025 sh_elf_hash_entry (h)->funcdesc.offset |= 1;
5030 union gotref *local_funcdesc;
5032 local_funcdesc = sh_elf_local_funcdesc (input_bfd);
5033 offset = local_funcdesc[r_symndx].offset;
5034 BFD_ASSERT (offset != MINUS_ONE);
5035 if ((offset & 1) == 0)
5037 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
5041 local_funcdesc[r_symndx].offset |= 1;
5045 relocation = htab->sfuncdesc->output_offset + (offset & ~1);
5048 relocation -= (htab->root.hgot->root.u.def.value
5049 + sgotplt->output_offset);
5051 relocation -= GOT_BIAS;
5054 if (r_type == R_SH_GOTOFFFUNCDESC20)
5056 r = install_movi20_field (output_bfd, relocation + addend,
5057 input_bfd, input_section, contents,
5062 goto final_link_relocate;
5064 case R_SH_LOOP_START:
5066 static bfd_vma start, end;
5068 start = (relocation + rel->r_addend
5069 - (sec->output_section->vma + sec->output_offset));
5070 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5071 rel->r_offset, sec, start, end);
5075 end = (relocation + rel->r_addend
5076 - (sec->output_section->vma + sec->output_offset));
5077 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5078 rel->r_offset, sec, start, end);
5082 case R_SH_TLS_GD_32:
5083 case R_SH_TLS_IE_32:
5085 check_segment[0] = check_segment[1] = -1;
5086 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5087 got_type = GOT_UNKNOWN;
5088 if (h == NULL && local_got_offsets)
5089 got_type = sh_elf_local_got_type (input_bfd) [r_symndx];
5092 got_type = sh_elf_hash_entry (h)->got_type;
5093 if (! bfd_link_pic (info)
5094 && (h->dynindx == -1
5096 r_type = R_SH_TLS_LE_32;
5099 if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE)
5100 r_type = R_SH_TLS_IE_32;
5102 if (r_type == R_SH_TLS_LE_32)
5105 unsigned short insn;
5107 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5109 /* GD->LE transition:
5110 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5111 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5112 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5114 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5116 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5118 offset = rel->r_offset;
5119 BFD_ASSERT (offset >= 16);
5120 /* Size of GD instructions is 16 or 18. */
5122 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5123 if ((insn & 0xff00) == 0xc700)
5125 BFD_ASSERT (offset >= 2);
5127 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5130 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5131 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5132 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5133 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5134 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5135 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5136 BFD_ASSERT (insn == 0x310c);
5137 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5138 BFD_ASSERT (insn == 0x410b);
5139 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5140 BFD_ASSERT (insn == 0x34cc);
5142 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5143 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5144 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5145 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5146 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5152 /* IE->LE transition:
5153 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5154 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5156 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5159 offset = rel->r_offset;
5160 BFD_ASSERT (offset >= 16);
5161 /* Size of IE instructions is 10 or 12. */
5163 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5164 if ((insn & 0xf0ff) == 0x0012)
5166 BFD_ASSERT (offset >= 2);
5168 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5171 BFD_ASSERT ((insn & 0xff00) == 0xd000);
5172 target = insn & 0x00ff;
5173 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5174 BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5175 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5176 BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5177 insn = 0xd000 | (insn & 0x0f00) | target;
5178 bfd_put_16 (output_bfd, insn, contents + offset + 0);
5179 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5182 bfd_put_32 (output_bfd, tpoff (info, relocation),
5183 contents + rel->r_offset);
5187 if (sgot == NULL || sgotplt == NULL)
5191 off = h->got.offset;
5194 if (local_got_offsets == NULL)
5197 off = local_got_offsets[r_symndx];
5200 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5201 if (r_type == R_SH_TLS_IE_32
5202 && ! htab->root.dynamic_sections_created)
5205 bfd_put_32 (output_bfd, tpoff (info, relocation),
5206 sgot->contents + off);
5207 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5208 contents + rel->r_offset);
5216 Elf_Internal_Rela outrel;
5220 outrel.r_offset = (sgot->output_section->vma
5221 + sgot->output_offset + off);
5223 if (h == NULL || h->dynindx == -1)
5228 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5230 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5231 outrel.r_addend = relocation - dtpoff_base (info);
5233 outrel.r_addend = 0;
5234 outrel.r_info = ELF32_R_INFO (indx, dr_type);
5235 loc = srelgot->contents;
5236 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5237 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5239 if (r_type == R_SH_TLS_GD_32)
5243 bfd_put_32 (output_bfd,
5244 relocation - dtpoff_base (info),
5245 sgot->contents + off + 4);
5249 outrel.r_info = ELF32_R_INFO (indx,
5251 outrel.r_offset += 4;
5252 outrel.r_addend = 0;
5253 srelgot->reloc_count++;
5254 loc += sizeof (Elf32_External_Rela);
5255 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5262 local_got_offsets[r_symndx] |= 1;
5265 if (off >= (bfd_vma) -2)
5268 if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5269 relocation = sh_elf_got_offset (htab) + off;
5273 unsigned short insn;
5275 /* GD->IE transition:
5276 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5277 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5278 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5280 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5281 nop; nop; bra 3f; nop; .align 2;
5282 1: .long x@TPOFF; 2:...; 3:. */
5284 offset = rel->r_offset;
5285 BFD_ASSERT (offset >= 16);
5286 /* Size of GD instructions is 16 or 18. */
5288 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5289 if ((insn & 0xff00) == 0xc700)
5291 BFD_ASSERT (offset >= 2);
5293 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5296 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5298 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5299 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5301 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5302 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5303 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5304 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5305 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5306 BFD_ASSERT (insn == 0x310c);
5307 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5308 BFD_ASSERT (insn == 0x410b);
5309 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5310 BFD_ASSERT (insn == 0x34cc);
5312 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5313 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5314 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5315 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5316 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5318 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5319 contents + rel->r_offset);
5324 addend = rel->r_addend;
5326 goto final_link_relocate;
5328 case R_SH_TLS_LD_32:
5330 check_segment[0] = check_segment[1] = -1;
5331 if (! bfd_link_pic (info))
5334 unsigned short insn;
5336 /* LD->LE transition:
5337 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5338 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5339 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5341 stc gbr,r0; nop; nop; nop;
5342 nop; nop; bra 3f; ...; 3:. */
5344 offset = rel->r_offset;
5345 BFD_ASSERT (offset >= 16);
5346 /* Size of LD instructions is 16 or 18. */
5348 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5349 if ((insn & 0xff00) == 0xc700)
5351 BFD_ASSERT (offset >= 2);
5353 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5356 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5357 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5358 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5359 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5360 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5361 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5362 BFD_ASSERT (insn == 0x310c);
5363 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5364 BFD_ASSERT (insn == 0x410b);
5365 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5366 BFD_ASSERT (insn == 0x34cc);
5368 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5369 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5370 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5371 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5372 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5373 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5378 if (sgot == NULL || sgotplt == NULL)
5381 off = htab->tls_ldm_got.offset;
5386 Elf_Internal_Rela outrel;
5389 outrel.r_offset = (sgot->output_section->vma
5390 + sgot->output_offset + off);
5391 outrel.r_addend = 0;
5392 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5393 loc = srelgot->contents;
5394 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5395 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5396 htab->tls_ldm_got.offset |= 1;
5399 relocation = sh_elf_got_offset (htab) + off;
5400 addend = rel->r_addend;
5402 goto final_link_relocate;
5404 case R_SH_TLS_LDO_32:
5405 check_segment[0] = check_segment[1] = -1;
5406 if (! bfd_link_pic (info))
5407 relocation = tpoff (info, relocation);
5409 relocation -= dtpoff_base (info);
5411 addend = rel->r_addend;
5412 goto final_link_relocate;
5414 case R_SH_TLS_LE_32:
5417 Elf_Internal_Rela outrel;
5420 check_segment[0] = check_segment[1] = -1;
5422 if (!bfd_link_dll (info))
5424 relocation = tpoff (info, relocation);
5425 addend = rel->r_addend;
5426 goto final_link_relocate;
5431 sreloc = _bfd_elf_get_dynamic_reloc_section
5432 (input_bfd, input_section, /*rela?*/ TRUE);
5437 if (h == NULL || h->dynindx == -1)
5442 outrel.r_offset = (input_section->output_section->vma
5443 + input_section->output_offset
5445 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5447 outrel.r_addend = relocation - dtpoff_base (info);
5449 outrel.r_addend = 0;
5451 loc = sreloc->contents;
5452 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5453 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5459 if (fdpic_p && check_segment[0] != (unsigned) -1
5460 && check_segment[0] != check_segment[1])
5462 /* We don't want duplicate errors for undefined symbols. */
5463 if (!h || h->root.type != bfd_link_hash_undefined)
5465 if (bfd_link_pic (info))
5467 info->callbacks->einfo
5468 /* xgettext:c-format */
5469 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5470 input_bfd, input_section, rel->r_offset, symname);
5474 info->callbacks->einfo
5475 /* xgettext:c-format */
5476 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5477 input_bfd, input_section, rel->r_offset, symname);
5480 elf_elfheader (output_bfd)->e_flags |= EF_SH_PIC;
5483 if (r != bfd_reloc_ok)
5488 case bfd_reloc_outofrange:
5490 case bfd_reloc_overflow:
5498 name = (bfd_elf_string_from_elf_section
5499 (input_bfd, symtab_hdr->sh_link, sym->st_name));
5503 name = bfd_section_name (input_bfd, sec);
5505 (*info->callbacks->reloc_overflow)
5506 (info, (h ? &h->root : NULL), name, howto->name,
5507 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5517 /* This is a version of bfd_generic_get_relocated_section_contents
5518 which uses sh_elf_relocate_section. */
5521 sh_elf_get_relocated_section_contents (bfd *output_bfd,
5522 struct bfd_link_info *link_info,
5523 struct bfd_link_order *link_order,
5525 bfd_boolean relocatable,
5528 Elf_Internal_Shdr *symtab_hdr;
5529 asection *input_section = link_order->u.indirect.section;
5530 bfd *input_bfd = input_section->owner;
5531 asection **sections = NULL;
5532 Elf_Internal_Rela *internal_relocs = NULL;
5533 Elf_Internal_Sym *isymbuf = NULL;
5535 /* We only need to handle the case of relaxing, or of having a
5536 particular set of section contents, specially. */
5538 || elf_section_data (input_section)->this_hdr.contents == NULL)
5539 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5544 symtab_hdr = &elf_symtab_hdr (input_bfd);
5546 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5547 (size_t) input_section->size);
5549 if ((input_section->flags & SEC_RELOC) != 0
5550 && input_section->reloc_count > 0)
5553 Elf_Internal_Sym *isym, *isymend;
5556 internal_relocs = (_bfd_elf_link_read_relocs
5557 (input_bfd, input_section, NULL,
5558 (Elf_Internal_Rela *) NULL, FALSE));
5559 if (internal_relocs == NULL)
5562 if (symtab_hdr->sh_info != 0)
5564 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5565 if (isymbuf == NULL)
5566 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5567 symtab_hdr->sh_info, 0,
5569 if (isymbuf == NULL)
5573 amt = symtab_hdr->sh_info;
5574 amt *= sizeof (asection *);
5575 sections = (asection **) bfd_malloc (amt);
5576 if (sections == NULL && amt != 0)
5579 isymend = isymbuf + symtab_hdr->sh_info;
5580 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5584 if (isym->st_shndx == SHN_UNDEF)
5585 isec = bfd_und_section_ptr;
5586 else if (isym->st_shndx == SHN_ABS)
5587 isec = bfd_abs_section_ptr;
5588 else if (isym->st_shndx == SHN_COMMON)
5589 isec = bfd_com_section_ptr;
5591 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5596 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5597 input_section, data, internal_relocs,
5601 if (sections != NULL)
5604 && symtab_hdr->contents != (unsigned char *) isymbuf)
5606 if (elf_section_data (input_section)->relocs != internal_relocs)
5607 free (internal_relocs);
5613 if (sections != NULL)
5616 && symtab_hdr->contents != (unsigned char *) isymbuf)
5618 if (internal_relocs != NULL
5619 && elf_section_data (input_section)->relocs != internal_relocs)
5620 free (internal_relocs);
5624 /* Return the base VMA address which should be subtracted from real addresses
5625 when resolving @dtpoff relocation.
5626 This is PT_TLS segment p_vaddr. */
5629 dtpoff_base (struct bfd_link_info *info)
5631 /* If tls_sec is NULL, we should have signalled an error already. */
5632 if (elf_hash_table (info)->tls_sec == NULL)
5634 return elf_hash_table (info)->tls_sec->vma;
5637 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5640 tpoff (struct bfd_link_info *info, bfd_vma address)
5642 /* If tls_sec is NULL, we should have signalled an error already. */
5643 if (elf_hash_table (info)->tls_sec == NULL)
5645 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5646 structure which has 2 pointer fields. */
5647 return (address - elf_hash_table (info)->tls_sec->vma
5648 + align_power ((bfd_vma) 8,
5649 elf_hash_table (info)->tls_sec->alignment_power));
5653 sh_elf_gc_mark_hook (asection *sec,
5654 struct bfd_link_info *info,
5655 Elf_Internal_Rela *rel,
5656 struct elf_link_hash_entry *h,
5657 Elf_Internal_Sym *sym)
5660 switch (ELF32_R_TYPE (rel->r_info))
5662 case R_SH_GNU_VTINHERIT:
5663 case R_SH_GNU_VTENTRY:
5667 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5670 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5673 sh_elf_copy_indirect_symbol (struct bfd_link_info *info,
5674 struct elf_link_hash_entry *dir,
5675 struct elf_link_hash_entry *ind)
5677 struct elf_sh_link_hash_entry *edir, *eind;
5679 edir = (struct elf_sh_link_hash_entry *) dir;
5680 eind = (struct elf_sh_link_hash_entry *) ind;
5682 if (eind->dyn_relocs != NULL)
5684 if (edir->dyn_relocs != NULL)
5686 struct elf_sh_dyn_relocs **pp;
5687 struct elf_sh_dyn_relocs *p;
5689 /* Add reloc counts against the indirect sym to the direct sym
5690 list. Merge any entries against the same section. */
5691 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5693 struct elf_sh_dyn_relocs *q;
5695 for (q = edir->dyn_relocs; q != NULL; q = q->next)
5696 if (q->sec == p->sec)
5698 q->pc_count += p->pc_count;
5699 q->count += p->count;
5706 *pp = edir->dyn_relocs;
5709 edir->dyn_relocs = eind->dyn_relocs;
5710 eind->dyn_relocs = NULL;
5712 edir->gotplt_refcount = eind->gotplt_refcount;
5713 eind->gotplt_refcount = 0;
5714 #ifdef INCLUDE_SHMEDIA
5715 edir->datalabel_got.refcount += eind->datalabel_got.refcount;
5716 eind->datalabel_got.refcount = 0;
5718 edir->funcdesc.refcount += eind->funcdesc.refcount;
5719 eind->funcdesc.refcount = 0;
5720 edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
5721 eind->abs_funcdesc_refcount = 0;
5723 if (ind->root.type == bfd_link_hash_indirect
5724 && dir->got.refcount <= 0)
5726 edir->got_type = eind->got_type;
5727 eind->got_type = GOT_UNKNOWN;
5730 if (ind->root.type != bfd_link_hash_indirect
5731 && dir->dynamic_adjusted)
5733 /* If called to transfer flags for a weakdef during processing
5734 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5735 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5736 if (dir->versioned != versioned_hidden)
5737 dir->ref_dynamic |= ind->ref_dynamic;
5738 dir->ref_regular |= ind->ref_regular;
5739 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
5740 dir->needs_plt |= ind->needs_plt;
5743 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
5747 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
5750 if (bfd_link_pic (info))
5755 case R_SH_TLS_GD_32:
5756 case R_SH_TLS_IE_32:
5758 return R_SH_TLS_LE_32;
5759 return R_SH_TLS_IE_32;
5760 case R_SH_TLS_LD_32:
5761 return R_SH_TLS_LE_32;
5767 /* Look through the relocs for a section during the first phase.
5768 Since we don't do .gots or .plts, we just need to consider the
5769 virtual table relocs for gc. */
5772 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
5773 const Elf_Internal_Rela *relocs)
5775 Elf_Internal_Shdr *symtab_hdr;
5776 struct elf_link_hash_entry **sym_hashes;
5777 struct elf_sh_link_hash_table *htab;
5778 const Elf_Internal_Rela *rel;
5779 const Elf_Internal_Rela *rel_end;
5781 unsigned int r_type;
5782 enum got_type got_type, old_got_type;
5786 if (bfd_link_relocatable (info))
5789 BFD_ASSERT (is_sh_elf (abfd));
5791 symtab_hdr = &elf_symtab_hdr (abfd);
5792 sym_hashes = elf_sym_hashes (abfd);
5794 htab = sh_elf_hash_table (info);
5798 rel_end = relocs + sec->reloc_count;
5799 for (rel = relocs; rel < rel_end; rel++)
5801 struct elf_link_hash_entry *h;
5802 unsigned long r_symndx;
5803 #ifdef INCLUDE_SHMEDIA
5804 int seen_stt_datalabel = 0;
5807 r_symndx = ELF32_R_SYM (rel->r_info);
5808 r_type = ELF32_R_TYPE (rel->r_info);
5810 if (r_symndx < symtab_hdr->sh_info)
5814 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5815 while (h->root.type == bfd_link_hash_indirect
5816 || h->root.type == bfd_link_hash_warning)
5818 #ifdef INCLUDE_SHMEDIA
5819 seen_stt_datalabel |= h->type == STT_DATALABEL;
5821 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5824 /* PR15323, ref flags aren't set for references in the same
5826 h->root.non_ir_ref_regular = 1;
5829 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5830 if (! bfd_link_pic (info)
5831 && r_type == R_SH_TLS_IE_32
5833 && h->root.type != bfd_link_hash_undefined
5834 && h->root.type != bfd_link_hash_undefweak
5835 && (h->dynindx == -1
5837 r_type = R_SH_TLS_LE_32;
5842 case R_SH_GOTOFFFUNCDESC:
5843 case R_SH_GOTOFFFUNCDESC20:
5845 case R_SH_GOTFUNCDESC:
5846 case R_SH_GOTFUNCDESC20:
5849 if (h->dynindx == -1)
5850 switch (ELF_ST_VISIBILITY (h->other))
5856 bfd_elf_link_record_dynamic_symbol (info, h);
5863 /* Some relocs require a global offset table. */
5864 if (htab->root.sgot == NULL)
5869 /* This may require an rofixup. */
5879 case R_SH_GOTFUNCDESC:
5880 case R_SH_GOTFUNCDESC20:
5881 case R_SH_GOTOFFFUNCDESC:
5882 case R_SH_GOTOFFFUNCDESC20:
5884 #ifdef INCLUDE_SHMEDIA
5885 case R_SH_GOTPLT_LOW16:
5886 case R_SH_GOTPLT_MEDLOW16:
5887 case R_SH_GOTPLT_MEDHI16:
5888 case R_SH_GOTPLT_HI16:
5889 case R_SH_GOTPLT10BY4:
5890 case R_SH_GOTPLT10BY8:
5891 case R_SH_GOT_LOW16:
5892 case R_SH_GOT_MEDLOW16:
5893 case R_SH_GOT_MEDHI16:
5897 case R_SH_GOTOFF_LOW16:
5898 case R_SH_GOTOFF_MEDLOW16:
5899 case R_SH_GOTOFF_MEDHI16:
5900 case R_SH_GOTOFF_HI16:
5901 case R_SH_GOTPC_LOW16:
5902 case R_SH_GOTPC_MEDLOW16:
5903 case R_SH_GOTPC_MEDHI16:
5904 case R_SH_GOTPC_HI16:
5906 case R_SH_TLS_GD_32:
5907 case R_SH_TLS_LD_32:
5908 case R_SH_TLS_IE_32:
5909 if (htab->root.dynobj == NULL)
5910 htab->root.dynobj = abfd;
5911 if (!create_got_section (htab->root.dynobj, info))
5922 /* This relocation describes the C++ object vtable hierarchy.
5923 Reconstruct it for later use during GC. */
5924 case R_SH_GNU_VTINHERIT:
5925 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5929 /* This relocation describes which C++ vtable entries are actually
5930 used. Record for later use during GC. */
5931 case R_SH_GNU_VTENTRY:
5932 BFD_ASSERT (h != NULL);
5934 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5938 case R_SH_TLS_IE_32:
5939 if (bfd_link_pic (info))
5940 info->flags |= DF_STATIC_TLS;
5944 case R_SH_TLS_GD_32:
5947 #ifdef INCLUDE_SHMEDIA
5948 case R_SH_GOT_LOW16:
5949 case R_SH_GOT_MEDLOW16:
5950 case R_SH_GOT_MEDHI16:
5955 case R_SH_GOTFUNCDESC:
5956 case R_SH_GOTFUNCDESC20:
5960 got_type = GOT_NORMAL;
5962 case R_SH_TLS_GD_32:
5963 got_type = GOT_TLS_GD;
5965 case R_SH_TLS_IE_32:
5966 got_type = GOT_TLS_IE;
5968 case R_SH_GOTFUNCDESC:
5969 case R_SH_GOTFUNCDESC20:
5970 got_type = GOT_FUNCDESC;
5976 #ifdef INCLUDE_SHMEDIA
5977 if (seen_stt_datalabel)
5979 struct elf_sh_link_hash_entry *eh
5980 = (struct elf_sh_link_hash_entry *) h;
5982 eh->datalabel_got.refcount += 1;
5986 h->got.refcount += 1;
5987 old_got_type = sh_elf_hash_entry (h)->got_type;
5991 bfd_signed_vma *local_got_refcounts;
5993 /* This is a global offset table entry for a local
5995 local_got_refcounts = elf_local_got_refcounts (abfd);
5996 if (local_got_refcounts == NULL)
6000 size = symtab_hdr->sh_info;
6001 size *= sizeof (bfd_signed_vma);
6002 #ifdef INCLUDE_SHMEDIA
6003 /* Reserve space for both the datalabel and
6004 codelabel local GOT offsets. */
6007 size += symtab_hdr->sh_info;
6008 local_got_refcounts = ((bfd_signed_vma *)
6009 bfd_zalloc (abfd, size));
6010 if (local_got_refcounts == NULL)
6012 elf_local_got_refcounts (abfd) = local_got_refcounts;
6013 #ifdef INCLUDE_SHMEDIA
6014 /* Take care of both the datalabel and codelabel local
6016 sh_elf_local_got_type (abfd)
6017 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6019 sh_elf_local_got_type (abfd)
6020 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6023 #ifdef INCLUDE_SHMEDIA
6024 if (rel->r_addend & 1)
6025 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6028 local_got_refcounts[r_symndx] += 1;
6029 old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
6032 /* If a TLS symbol is accessed using IE at least once,
6033 there is no point to use dynamic model for it. */
6034 if (old_got_type != got_type && old_got_type != GOT_UNKNOWN
6035 && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE))
6037 if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD)
6038 got_type = GOT_TLS_IE;
6041 if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
6042 && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
6044 /* xgettext:c-format */
6045 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6046 abfd, h->root.root.string);
6047 else if (old_got_type == GOT_FUNCDESC
6048 || got_type == GOT_FUNCDESC)
6050 /* xgettext:c-format */
6051 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6052 abfd, h->root.root.string);
6055 /* xgettext:c-format */
6056 (_("%B: `%s' accessed both as normal and thread local symbol"),
6057 abfd, h->root.root.string);
6062 if (old_got_type != got_type)
6065 sh_elf_hash_entry (h)->got_type = got_type;
6067 sh_elf_local_got_type (abfd) [r_symndx] = got_type;
6072 case R_SH_TLS_LD_32:
6073 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6077 case R_SH_GOTOFFFUNCDESC:
6078 case R_SH_GOTOFFFUNCDESC20:
6082 (_("%B: Function descriptor relocation with non-zero addend"),
6089 union gotref *local_funcdesc;
6091 /* We need a function descriptor for a local symbol. */
6092 local_funcdesc = sh_elf_local_funcdesc (abfd);
6093 if (local_funcdesc == NULL)
6097 size = symtab_hdr->sh_info * sizeof (union gotref);
6098 #ifdef INCLUDE_SHMEDIA
6099 /* Count datalabel local GOT. */
6102 local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
6103 if (local_funcdesc == NULL)
6105 sh_elf_local_funcdesc (abfd) = local_funcdesc;
6107 local_funcdesc[r_symndx].refcount += 1;
6109 if (r_type == R_SH_FUNCDESC)
6111 if (!bfd_link_pic (info))
6112 htab->srofixup->size += 4;
6114 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
6119 sh_elf_hash_entry (h)->funcdesc.refcount++;
6120 if (r_type == R_SH_FUNCDESC)
6121 sh_elf_hash_entry (h)->abs_funcdesc_refcount++;
6123 /* If there is a function descriptor reference, then
6124 there should not be any non-FDPIC references. */
6125 old_got_type = sh_elf_hash_entry (h)->got_type;
6126 if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
6128 if (old_got_type == GOT_NORMAL)
6130 /* xgettext:c-format */
6131 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6132 abfd, h->root.root.string);
6135 /* xgettext:c-format */
6136 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6137 abfd, h->root.root.string);
6143 #ifdef INCLUDE_SHMEDIA
6144 case R_SH_GOTPLT_LOW16:
6145 case R_SH_GOTPLT_MEDLOW16:
6146 case R_SH_GOTPLT_MEDHI16:
6147 case R_SH_GOTPLT_HI16:
6148 case R_SH_GOTPLT10BY4:
6149 case R_SH_GOTPLT10BY8:
6151 /* If this is a local symbol, we resolve it directly without
6152 creating a procedure linkage table entry. */
6156 || ! bfd_link_pic (info)
6158 || h->dynindx == -1)
6162 h->plt.refcount += 1;
6163 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6168 #ifdef INCLUDE_SHMEDIA
6169 case R_SH_PLT_LOW16:
6170 case R_SH_PLT_MEDLOW16:
6171 case R_SH_PLT_MEDHI16:
6174 /* This symbol requires a procedure linkage table entry. We
6175 actually build the entry in adjust_dynamic_symbol,
6176 because this might be a case of linking PIC code which is
6177 never referenced by a dynamic object, in which case we
6178 don't need to generate a procedure linkage table entry
6181 /* If this is a local symbol, we resolve it directly without
6182 creating a procedure linkage table entry. */
6186 if (h->forced_local)
6190 h->plt.refcount += 1;
6195 #ifdef INCLUDE_SHMEDIA
6196 case R_SH_IMM_LOW16_PCREL:
6197 case R_SH_IMM_MEDLOW16_PCREL:
6198 case R_SH_IMM_MEDHI16_PCREL:
6199 case R_SH_IMM_HI16_PCREL:
6201 if (h != NULL && ! bfd_link_pic (info))
6204 h->plt.refcount += 1;
6207 /* If we are creating a shared library, and this is a reloc
6208 against a global symbol, or a non PC relative reloc
6209 against a local symbol, then we need to copy the reloc
6210 into the shared library. However, if we are linking with
6211 -Bsymbolic, we do not need to copy a reloc against a
6212 global symbol which is defined in an object we are
6213 including in the link (i.e., DEF_REGULAR is set). At
6214 this point we have not seen all the input files, so it is
6215 possible that DEF_REGULAR is not set now but will be set
6216 later (it is never cleared). We account for that
6217 possibility below by storing information in the
6218 dyn_relocs field of the hash table entry. A similar
6219 situation occurs when creating shared libraries and symbol
6220 visibility changes render the symbol local.
6222 If on the other hand, we are creating an executable, we
6223 may need to keep relocations for symbols satisfied by a
6224 dynamic library if we manage to avoid copy relocs for the
6226 if ((bfd_link_pic (info)
6227 && (sec->flags & SEC_ALLOC) != 0
6228 && (r_type != R_SH_REL32
6230 && (! info->symbolic
6231 || h->root.type == bfd_link_hash_defweak
6232 || !h->def_regular))))
6233 || (! bfd_link_pic (info)
6234 && (sec->flags & SEC_ALLOC) != 0
6236 && (h->root.type == bfd_link_hash_defweak
6237 || !h->def_regular)))
6239 struct elf_sh_dyn_relocs *p;
6240 struct elf_sh_dyn_relocs **head;
6242 if (htab->root.dynobj == NULL)
6243 htab->root.dynobj = abfd;
6245 /* When creating a shared object, we must copy these
6246 reloc types into the output file. We create a reloc
6247 section in dynobj and make room for this reloc. */
6250 sreloc = _bfd_elf_make_dynamic_reloc_section
6251 (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
6257 /* If this is a global symbol, we count the number of
6258 relocations we need for this symbol. */
6260 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6263 /* Track dynamic relocs needed for local syms too. */
6266 Elf_Internal_Sym *isym;
6268 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6273 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6277 vpp = &elf_section_data (s)->local_dynrel;
6278 head = (struct elf_sh_dyn_relocs **) vpp;
6282 if (p == NULL || p->sec != sec)
6284 bfd_size_type amt = sizeof (*p);
6285 p = bfd_alloc (htab->root.dynobj, amt);
6296 if (r_type == R_SH_REL32
6297 #ifdef INCLUDE_SHMEDIA
6298 || r_type == R_SH_IMM_LOW16_PCREL
6299 || r_type == R_SH_IMM_MEDLOW16_PCREL
6300 || r_type == R_SH_IMM_MEDHI16_PCREL
6301 || r_type == R_SH_IMM_HI16_PCREL
6307 /* Allocate the fixup regardless of whether we need a relocation.
6308 If we end up generating the relocation, we'll unallocate the
6310 if (htab->fdpic_p && !bfd_link_pic (info)
6311 && r_type == R_SH_DIR32
6312 && (sec->flags & SEC_ALLOC) != 0)
6313 htab->srofixup->size += 4;
6316 case R_SH_TLS_LE_32:
6317 if (bfd_link_dll (info))
6320 (_("%B: TLS local exec code cannot be linked into shared objects"),
6327 case R_SH_TLS_LDO_32:
6328 /* Nothing to do. */
6339 #ifndef sh_elf_set_mach_from_flags
6340 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
6343 sh_elf_set_mach_from_flags (bfd *abfd)
6345 flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
6347 if (flags >= ARRAY_SIZE (sh_ef_bfd_table))
6350 if (sh_ef_bfd_table[flags] == 0)
6353 bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
6359 /* Reverse table lookup for sh_ef_bfd_table[].
6360 Given a bfd MACH value from archures.c
6361 return the equivalent ELF flags from the table.
6362 Return -1 if no match is found. */
6365 sh_elf_get_flags_from_mach (unsigned long mach)
6367 int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
6370 if (sh_ef_bfd_table[i] == mach)
6373 /* shouldn't get here */
6378 #endif /* not sh_elf_set_mach_from_flags */
6380 #ifndef sh_elf_copy_private_data
6381 /* Copy backend specific data from one object module to another */
6384 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
6386 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6389 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
6392 return sh_elf_set_mach_from_flags (obfd);
6394 #endif /* not sh_elf_copy_private_data */
6396 #ifndef sh_elf_merge_private_data
6398 /* This function returns the ELF architecture number that
6399 corresponds to the given arch_sh* flags. */
6402 sh_find_elf_flags (unsigned int arch_set)
6404 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
6405 unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set);
6407 return sh_elf_get_flags_from_mach (bfd_mach);
6410 /* Merge the architecture type of two BFD files, such that the
6411 resultant architecture supports all the features required
6412 by the two input BFDs.
6413 If the input BFDs are multually incompatible - i.e. one uses
6414 DSP while the other uses FPU - or there is no known architecture
6415 that fits the requirements then an error is emitted. */
6418 sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info)
6420 bfd *obfd = info->output_bfd;
6421 unsigned int old_arch, new_arch, merged_arch;
6423 if (! _bfd_generic_verify_endian_match (ibfd, info))
6426 old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd));
6427 new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd));
6429 merged_arch = SH_MERGE_ARCH_SET (old_arch, new_arch);
6431 if (!SH_VALID_CO_ARCH_SET (merged_arch))
6434 /* xgettext:c-format */
6435 (_("%B: uses %s instructions while previous modules "
6436 "use %s instructions"),
6438 SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
6439 SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp");
6440 bfd_set_error (bfd_error_bad_value);
6443 else if (!SH_VALID_ARCH_SET (merged_arch))
6446 /* xgettext:c-format */
6447 (_("internal error: merge of architecture '%s' with "
6448 "architecture '%s' produced unknown architecture"),
6449 bfd_printable_name (obfd),
6450 bfd_printable_name (ibfd));
6451 bfd_set_error (bfd_error_bad_value);
6455 bfd_default_set_arch_mach (obfd, bfd_arch_sh,
6456 sh_get_bfd_mach_from_arch_set (merged_arch));
6461 /* This routine initialises the elf flags when required and
6462 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6465 sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info)
6467 bfd *obfd = info->output_bfd;
6469 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6472 if (! elf_flags_init (obfd))
6474 /* This happens when ld starts out with a 'blank' output file. */
6475 elf_flags_init (obfd) = TRUE;
6476 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6477 sh_elf_set_mach_from_flags (obfd);
6478 if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
6479 elf_elfheader (obfd)->e_flags &= ~EF_SH_PIC;
6482 if (! sh_merge_bfd_arch (ibfd, info))
6484 _bfd_error_handler (_("%B: uses instructions which are incompatible "
6485 "with instructions used in previous modules"),
6487 bfd_set_error (bfd_error_bad_value);
6491 elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
6492 elf_elfheader (obfd)->e_flags |=
6493 sh_elf_get_flags_from_mach (bfd_get_mach (obfd));
6495 if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
6497 _bfd_error_handler (_("%B: attempt to mix FDPIC and non-FDPIC objects"),
6499 bfd_set_error (bfd_error_bad_value);
6505 #endif /* not sh_elf_merge_private_data */
6507 /* Override the generic function because we need to store sh_elf_obj_tdata
6508 as the specific tdata. We set also the machine architecture from flags
6512 sh_elf_object_p (bfd *abfd)
6514 if (! sh_elf_set_mach_from_flags (abfd))
6517 return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
6518 == fdpic_object_p (abfd));
6521 /* Finish up dynamic symbol handling. We set the contents of various
6522 dynamic sections here. */
6525 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6526 struct elf_link_hash_entry *h,
6527 Elf_Internal_Sym *sym)
6529 struct elf_sh_link_hash_table *htab;
6531 htab = sh_elf_hash_table (info);
6535 if (h->plt.offset != (bfd_vma) -1)
6543 Elf_Internal_Rela rel;
6545 const struct elf_sh_plt_info *plt_info;
6547 /* This symbol has an entry in the procedure linkage table. Set
6550 BFD_ASSERT (h->dynindx != -1);
6552 splt = htab->root.splt;
6553 sgotplt = htab->root.sgotplt;
6554 srelplt = htab->root.srelplt;
6555 BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
6557 /* Get the index in the procedure linkage table which
6558 corresponds to this symbol. This is the index of this symbol
6559 in all the symbols for which we are making plt entries. The
6560 first entry in the procedure linkage table is reserved. */
6561 plt_index = get_plt_index (htab->plt_info, h->plt.offset);
6563 plt_info = htab->plt_info;
6564 if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT)
6565 plt_info = plt_info->short_plt;
6567 /* Get the offset into the .got table of the entry that
6568 corresponds to this function. */
6570 /* The offset must be relative to the GOT symbol, twelve bytes
6571 before the end of .got.plt. Each descriptor is eight
6573 got_offset = plt_index * 8 + 12 - sgotplt->size;
6575 /* Each .got entry is 4 bytes. The first three are
6577 got_offset = (plt_index + 3) * 4;
6580 if (bfd_link_pic (info))
6581 got_offset -= GOT_BIAS;
6584 /* Fill in the entry in the procedure linkage table. */
6585 memcpy (splt->contents + h->plt.offset,
6586 plt_info->symbol_entry,
6587 plt_info->symbol_entry_size);
6589 if (bfd_link_pic (info) || htab->fdpic_p)
6591 if (plt_info->symbol_fields.got20)
6593 bfd_reloc_status_type r;
6594 r = install_movi20_field (output_bfd, got_offset,
6595 splt->owner, splt, splt->contents,
6597 + plt_info->symbol_fields.got_entry);
6598 BFD_ASSERT (r == bfd_reloc_ok);
6601 install_plt_field (output_bfd, FALSE, got_offset,
6604 + plt_info->symbol_fields.got_entry));
6608 BFD_ASSERT (!plt_info->symbol_fields.got20);
6610 install_plt_field (output_bfd, FALSE,
6611 (sgotplt->output_section->vma
6612 + sgotplt->output_offset
6616 + plt_info->symbol_fields.got_entry));
6617 if (htab->vxworks_p)
6619 unsigned int reachable_plts, plts_per_4k;
6622 /* Divide the PLT into groups. The first group contains
6623 REACHABLE_PLTS entries and the other groups contain
6624 PLTS_PER_4K entries. Entries in the first group can
6625 branch directly to .plt; those in later groups branch
6626 to the last element of the previous group. */
6627 /* ??? It would be better to create multiple copies of
6628 the common resolver stub. */
6629 reachable_plts = ((4096
6630 - plt_info->plt0_entry_size
6631 - (plt_info->symbol_fields.plt + 4))
6632 / plt_info->symbol_entry_size) + 1;
6633 plts_per_4k = (4096 / plt_info->symbol_entry_size);
6634 if (plt_index < reachable_plts)
6635 distance = -(h->plt.offset
6636 + plt_info->symbol_fields.plt);
6638 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1)
6639 * plt_info->symbol_entry_size);
6641 /* Install the 'bra' with this offset. */
6642 bfd_put_16 (output_bfd,
6643 0xa000 | (0x0fff & ((distance - 4) / 2)),
6646 + plt_info->symbol_fields.plt));
6649 install_plt_field (output_bfd, TRUE,
6650 splt->output_section->vma + splt->output_offset,
6653 + plt_info->symbol_fields.plt));
6656 /* Make got_offset relative to the start of .got.plt. */
6658 if (bfd_link_pic (info))
6659 got_offset += GOT_BIAS;
6662 got_offset = plt_index * 8;
6664 if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
6665 install_plt_field (output_bfd, FALSE,
6666 plt_index * sizeof (Elf32_External_Rela),
6669 + plt_info->symbol_fields.reloc_offset));
6671 /* Fill in the entry in the global offset table. */
6672 bfd_put_32 (output_bfd,
6673 (splt->output_section->vma
6674 + splt->output_offset
6676 + plt_info->symbol_resolve_offset),
6677 sgotplt->contents + got_offset);
6679 bfd_put_32 (output_bfd,
6680 sh_elf_osec_to_segment (output_bfd, splt->output_section),
6681 sgotplt->contents + got_offset + 4);
6683 /* Fill in the entry in the .rela.plt section. */
6684 rel.r_offset = (sgotplt->output_section->vma
6685 + sgotplt->output_offset
6688 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE);
6690 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6693 rel.r_addend = GOT_BIAS;
6695 loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
6696 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6698 if (htab->vxworks_p && !bfd_link_pic (info))
6700 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6701 Begin by pointing LOC to the first such relocation. */
6702 loc = (htab->srelplt2->contents
6703 + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela));
6705 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6706 for the PLT entry's pointer to the .got.plt entry. */
6707 rel.r_offset = (splt->output_section->vma
6708 + splt->output_offset
6710 + plt_info->symbol_fields.got_entry);
6711 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6712 rel.r_addend = got_offset;
6713 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6714 loc += sizeof (Elf32_External_Rela);
6716 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6717 the .got.plt entry, which initially points to .plt. */
6718 rel.r_offset = (sgotplt->output_section->vma
6719 + sgotplt->output_offset
6721 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32);
6723 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6726 if (!h->def_regular)
6728 /* Mark the symbol as undefined, rather than as defined in
6729 the .plt section. Leave the value alone. */
6730 sym->st_shndx = SHN_UNDEF;
6734 if (h->got.offset != (bfd_vma) -1
6735 && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD
6736 && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE
6737 && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
6741 Elf_Internal_Rela rel;
6744 /* This symbol has an entry in the global offset table. Set it
6747 sgot = htab->root.sgot;
6748 srelgot = htab->root.srelgot;
6749 BFD_ASSERT (sgot != NULL && srelgot != NULL);
6751 rel.r_offset = (sgot->output_section->vma
6752 + sgot->output_offset
6753 + (h->got.offset &~ (bfd_vma) 1));
6755 /* If this is a static link, or it is a -Bsymbolic link and the
6756 symbol is defined locally or was forced to be local because
6757 of a version file, we just want to emit a RELATIVE reloc.
6758 The entry in the global offset table will already have been
6759 initialized in the relocate_section function. */
6760 if (bfd_link_pic (info)
6761 && SYMBOL_REFERENCES_LOCAL (info, h))
6765 asection *sec = h->root.u.def.section;
6767 = elf_section_data (sec->output_section)->dynindx;
6769 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
6770 rel.r_addend = (h->root.u.def.value
6771 + h->root.u.def.section->output_offset);
6775 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6776 rel.r_addend = (h->root.u.def.value
6777 + h->root.u.def.section->output_section->vma
6778 + h->root.u.def.section->output_offset);
6783 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6784 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6788 loc = srelgot->contents;
6789 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
6790 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6793 #ifdef INCLUDE_SHMEDIA
6795 struct elf_sh_link_hash_entry *eh;
6797 eh = (struct elf_sh_link_hash_entry *) h;
6798 if (eh->datalabel_got.offset != (bfd_vma) -1)
6802 Elf_Internal_Rela rel;
6805 /* This symbol has a datalabel entry in the global offset table.
6808 sgot = htab->root.sgot;
6809 srelgot = htab->root.srelgot;
6810 BFD_ASSERT (sgot != NULL && srelgot != NULL);
6812 rel.r_offset = (sgot->output_section->vma
6813 + sgot->output_offset
6814 + (eh->datalabel_got.offset &~ (bfd_vma) 1));
6816 /* If this is a static link, or it is a -Bsymbolic link and the
6817 symbol is defined locally or was forced to be local because
6818 of a version file, we just want to emit a RELATIVE reloc.
6819 The entry in the global offset table will already have been
6820 initialized in the relocate_section function. */
6821 if (bfd_link_pic (info)
6822 && SYMBOL_REFERENCES_LOCAL (info, h))
6826 asection *sec = h->root.u.def.section;
6828 = elf_section_data (sec->output_section)->dynindx;
6830 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
6831 rel.r_addend = (h->root.u.def.value
6832 + h->root.u.def.section->output_offset);
6836 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6837 rel.r_addend = (h->root.u.def.value
6838 + h->root.u.def.section->output_section->vma
6839 + h->root.u.def.section->output_offset);
6844 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
6845 + eh->datalabel_got.offset);
6846 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6850 loc = srelgot->contents;
6851 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
6852 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6860 Elf_Internal_Rela rel;
6863 /* This symbol needs a copy reloc. Set it up. */
6865 BFD_ASSERT (h->dynindx != -1
6866 && (h->root.type == bfd_link_hash_defined
6867 || h->root.type == bfd_link_hash_defweak));
6869 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
6870 BFD_ASSERT (s != NULL);
6872 rel.r_offset = (h->root.u.def.value
6873 + h->root.u.def.section->output_section->vma
6874 + h->root.u.def.section->output_offset);
6875 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
6877 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
6878 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6881 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
6882 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6884 if (h == htab->root.hdynamic
6885 || (!htab->vxworks_p && h == htab->root.hgot))
6886 sym->st_shndx = SHN_ABS;
6891 /* Finish up the dynamic sections. */
6894 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6896 struct elf_sh_link_hash_table *htab;
6900 htab = sh_elf_hash_table (info);
6904 sgotplt = htab->root.sgotplt;
6905 sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
6907 if (htab->root.dynamic_sections_created)
6910 Elf32_External_Dyn *dyncon, *dynconend;
6912 BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6914 dyncon = (Elf32_External_Dyn *) sdyn->contents;
6915 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6916 for (; dyncon < dynconend; dyncon++)
6918 Elf_Internal_Dyn dyn;
6920 #ifdef INCLUDE_SHMEDIA
6924 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
6930 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
6931 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6934 #ifdef INCLUDE_SHMEDIA
6936 name = info->init_function;
6940 name = info->fini_function;
6942 if (dyn.d_un.d_val != 0)
6944 struct elf_link_hash_entry *h;
6946 h = elf_link_hash_lookup (&htab->root, name,
6947 FALSE, FALSE, TRUE);
6948 if (h != NULL && (h->other & STO_SH5_ISA32))
6950 dyn.d_un.d_val |= 1;
6951 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6958 BFD_ASSERT (htab->root.hgot != NULL);
6959 s = htab->root.hgot->root.u.def.section;
6960 dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value
6961 + s->output_section->vma + s->output_offset;
6962 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6966 s = htab->root.srelplt->output_section;
6967 BFD_ASSERT (s != NULL);
6968 dyn.d_un.d_ptr = s->vma;
6969 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6973 s = htab->root.srelplt->output_section;
6974 BFD_ASSERT (s != NULL);
6975 dyn.d_un.d_val = s->size;
6976 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6981 /* Fill in the first entry in the procedure linkage table. */
6982 splt = htab->root.splt;
6983 if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
6987 memcpy (splt->contents,
6988 htab->plt_info->plt0_entry,
6989 htab->plt_info->plt0_entry_size);
6990 for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
6991 if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
6992 install_plt_field (output_bfd, FALSE,
6993 (sgotplt->output_section->vma
6994 + sgotplt->output_offset
6997 + htab->plt_info->plt0_got_fields[i]));
6999 if (htab->vxworks_p)
7001 /* Finalize the .rela.plt.unloaded contents. */
7002 Elf_Internal_Rela rel;
7005 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7006 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7007 loc = htab->srelplt2->contents;
7008 rel.r_offset = (splt->output_section->vma
7009 + splt->output_offset
7010 + htab->plt_info->plt0_got_fields[2]);
7011 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
7013 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7014 loc += sizeof (Elf32_External_Rela);
7016 /* Fix up the remaining .rela.plt.unloaded relocations.
7017 They may have the wrong symbol index for _G_O_T_ or
7018 _P_L_T_ depending on the order in which symbols were
7020 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
7022 /* The PLT entry's pointer to the .got.plt slot. */
7023 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7024 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx,
7026 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7027 loc += sizeof (Elf32_External_Rela);
7029 /* The .got.plt slot's pointer to .plt. */
7030 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7031 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx,
7033 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7034 loc += sizeof (Elf32_External_Rela);
7038 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7039 really seem like the right value. */
7040 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7044 /* Fill in the first three entries in the global offset table. */
7045 if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p)
7048 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
7050 bfd_put_32 (output_bfd,
7051 sdyn->output_section->vma + sdyn->output_offset,
7053 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
7054 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
7057 if (sgotplt && sgotplt->size > 0)
7058 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
7060 /* At the very end of the .rofixup section is a pointer to the GOT. */
7061 if (htab->fdpic_p && htab->srofixup != NULL)
7063 struct elf_link_hash_entry *hgot = htab->root.hgot;
7064 bfd_vma got_value = hgot->root.u.def.value
7065 + hgot->root.u.def.section->output_section->vma
7066 + hgot->root.u.def.section->output_offset;
7068 sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
7070 /* Make sure we allocated and generated the same number of fixups. */
7071 BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
7074 if (htab->srelfuncdesc)
7075 BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
7076 == htab->srelfuncdesc->size);
7078 if (htab->root.srelgot)
7079 BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
7080 == htab->root.srelgot->size);
7085 static enum elf_reloc_type_class
7086 sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
7087 const asection *rel_sec ATTRIBUTE_UNUSED,
7088 const Elf_Internal_Rela *rela)
7090 switch ((int) ELF32_R_TYPE (rela->r_info))
7093 return reloc_class_relative;
7095 return reloc_class_plt;
7097 return reloc_class_copy;
7099 return reloc_class_normal;
7103 #if !defined SH_TARGET_ALREADY_DEFINED
7104 /* Support for Linux core dump NOTE sections. */
7107 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7112 switch (note->descsz)
7117 case 168: /* Linux/SH */
7119 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
7122 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
7131 /* Make a ".reg/999" section. */
7132 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7133 size, note->descpos + offset);
7137 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7139 switch (note->descsz)
7144 case 124: /* Linux/SH elf_prpsinfo */
7145 elf_tdata (abfd)->core->program
7146 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7147 elf_tdata (abfd)->core->command
7148 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7151 /* Note that for some reason, a spurious space is tacked
7152 onto the end of the args in some (at least one anyway)
7153 implementations, so strip it off if it exists. */
7156 char *command = elf_tdata (abfd)->core->command;
7157 int n = strlen (command);
7159 if (0 < n && command[n - 1] == ' ')
7160 command[n - 1] = '\0';
7165 #endif /* not SH_TARGET_ALREADY_DEFINED */
7168 /* Return address for Ith PLT stub in section PLT, for relocation REL
7169 or (bfd_vma) -1 if it should not be included. */
7172 sh_elf_plt_sym_val (bfd_vma i, const asection *plt,
7173 const arelent *rel ATTRIBUTE_UNUSED)
7175 const struct elf_sh_plt_info *plt_info;
7177 plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0);
7178 return plt->vma + get_plt_offset (plt_info, i);
7181 /* Decide whether to attempt to turn absptr or lsda encodings in
7182 shared libraries into pcrel within the given input section. */
7185 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
7186 struct bfd_link_info *info,
7187 asection *eh_frame_section ATTRIBUTE_UNUSED)
7189 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7191 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7198 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7201 sh_elf_encode_eh_address (bfd *abfd,
7202 struct bfd_link_info *info,
7203 asection *osec, bfd_vma offset,
7204 asection *loc_sec, bfd_vma loc_offset,
7207 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7208 struct elf_link_hash_entry *h;
7211 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec,
7212 loc_offset, encoded);
7214 h = htab->root.hgot;
7215 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
7217 if (! h || (sh_elf_osec_to_segment (abfd, osec)
7218 == sh_elf_osec_to_segment (abfd, loc_sec->output_section)))
7219 return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
7220 loc_sec, loc_offset, encoded);
7222 BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec)
7223 == (sh_elf_osec_to_segment
7224 (abfd, h->root.u.def.section->output_section)));
7226 *encoded = osec->vma + offset
7227 - (h->root.u.def.value
7228 + h->root.u.def.section->output_section->vma
7229 + h->root.u.def.section->output_offset);
7231 return DW_EH_PE_datarel | DW_EH_PE_sdata4;
7234 #if !defined SH_TARGET_ALREADY_DEFINED
7235 #define TARGET_BIG_SYM sh_elf32_vec
7236 #define TARGET_BIG_NAME "elf32-sh"
7237 #define TARGET_LITTLE_SYM sh_elf32_le_vec
7238 #define TARGET_LITTLE_NAME "elf32-shl"
7241 #define ELF_ARCH bfd_arch_sh
7242 #define ELF_TARGET_ID SH_ELF_DATA
7243 #define ELF_MACHINE_CODE EM_SH
7244 #ifdef __QNXTARGET__
7245 #define ELF_MAXPAGESIZE 0x1000
7247 #define ELF_MAXPAGESIZE 0x80
7250 #define elf_symbol_leading_char '_'
7252 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7253 #define bfd_elf32_bfd_reloc_name_lookup \
7254 sh_elf_reloc_name_lookup
7255 #define elf_info_to_howto sh_elf_info_to_howto
7256 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7257 #define elf_backend_relocate_section sh_elf_relocate_section
7258 #define bfd_elf32_bfd_get_relocated_section_contents \
7259 sh_elf_get_relocated_section_contents
7260 #define bfd_elf32_mkobject sh_elf_mkobject
7261 #define elf_backend_object_p sh_elf_object_p
7262 #define bfd_elf32_bfd_copy_private_bfd_data \
7263 sh_elf_copy_private_data
7264 #define bfd_elf32_bfd_merge_private_bfd_data \
7265 sh_elf_merge_private_data
7267 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7268 #define elf_backend_check_relocs sh_elf_check_relocs
7269 #define elf_backend_copy_indirect_symbol \
7270 sh_elf_copy_indirect_symbol
7271 #define elf_backend_create_dynamic_sections \
7272 sh_elf_create_dynamic_sections
7273 #define bfd_elf32_bfd_link_hash_table_create \
7274 sh_elf_link_hash_table_create
7275 #define elf_backend_adjust_dynamic_symbol \
7276 sh_elf_adjust_dynamic_symbol
7277 #define elf_backend_always_size_sections \
7278 sh_elf_always_size_sections
7279 #define elf_backend_size_dynamic_sections \
7280 sh_elf_size_dynamic_sections
7281 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7282 #define elf_backend_finish_dynamic_symbol \
7283 sh_elf_finish_dynamic_symbol
7284 #define elf_backend_finish_dynamic_sections \
7285 sh_elf_finish_dynamic_sections
7286 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7287 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7288 #define elf_backend_can_make_relative_eh_frame \
7289 sh_elf_use_relative_eh_frame
7290 #define elf_backend_can_make_lsda_relative_eh_frame \
7291 sh_elf_use_relative_eh_frame
7292 #define elf_backend_encode_eh_address \
7293 sh_elf_encode_eh_address
7295 #define elf_backend_stack_align 8
7296 #define elf_backend_can_gc_sections 1
7297 #define elf_backend_can_refcount 1
7298 #define elf_backend_want_got_plt 1
7299 #define elf_backend_plt_readonly 1
7300 #define elf_backend_want_plt_sym 0
7301 #define elf_backend_got_header_size 12
7302 #define elf_backend_dtrel_excludes_plt 1
7304 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7306 #include "elf32-target.h"
7308 /* NetBSD support. */
7309 #undef TARGET_BIG_SYM
7310 #define TARGET_BIG_SYM sh_elf32_nbsd_vec
7311 #undef TARGET_BIG_NAME
7312 #define TARGET_BIG_NAME "elf32-sh-nbsd"
7313 #undef TARGET_LITTLE_SYM
7314 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
7315 #undef TARGET_LITTLE_NAME
7316 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7317 #undef ELF_MAXPAGESIZE
7318 #define ELF_MAXPAGESIZE 0x10000
7319 #undef ELF_COMMONPAGESIZE
7320 #undef elf_symbol_leading_char
7321 #define elf_symbol_leading_char 0
7323 #define elf32_bed elf32_sh_nbsd_bed
7325 #include "elf32-target.h"
7328 /* Linux support. */
7329 #undef TARGET_BIG_SYM
7330 #define TARGET_BIG_SYM sh_elf32_linux_be_vec
7331 #undef TARGET_BIG_NAME
7332 #define TARGET_BIG_NAME "elf32-shbig-linux"
7333 #undef TARGET_LITTLE_SYM
7334 #define TARGET_LITTLE_SYM sh_elf32_linux_vec
7335 #undef TARGET_LITTLE_NAME
7336 #define TARGET_LITTLE_NAME "elf32-sh-linux"
7337 #undef ELF_COMMONPAGESIZE
7338 #define ELF_COMMONPAGESIZE 0x1000
7340 #undef elf_backend_grok_prstatus
7341 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7342 #undef elf_backend_grok_psinfo
7343 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7345 #define elf32_bed elf32_sh_lin_bed
7347 #include "elf32-target.h"
7350 /* FDPIC support. */
7351 #undef TARGET_BIG_SYM
7352 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
7353 #undef TARGET_BIG_NAME
7354 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
7355 #undef TARGET_LITTLE_SYM
7356 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
7357 #undef TARGET_LITTLE_NAME
7358 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
7361 #define elf32_bed elf32_sh_fd_bed
7363 #include "elf32-target.h"
7365 #undef elf_backend_modify_program_headers
7367 /* VxWorks support. */
7368 #undef TARGET_BIG_SYM
7369 #define TARGET_BIG_SYM sh_elf32_vxworks_vec
7370 #undef TARGET_BIG_NAME
7371 #define TARGET_BIG_NAME "elf32-sh-vxworks"
7372 #undef TARGET_LITTLE_SYM
7373 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
7374 #undef TARGET_LITTLE_NAME
7375 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
7377 #define elf32_bed elf32_sh_vxworks_bed
7379 #undef elf_backend_want_plt_sym
7380 #define elf_backend_want_plt_sym 1
7381 #undef elf_symbol_leading_char
7382 #define elf_symbol_leading_char '_'
7383 #define elf_backend_want_got_underscore 1
7384 #undef elf_backend_grok_prstatus
7385 #undef elf_backend_grok_psinfo
7386 #undef elf_backend_add_symbol_hook
7387 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7388 #undef elf_backend_link_output_symbol_hook
7389 #define elf_backend_link_output_symbol_hook \
7390 elf_vxworks_link_output_symbol_hook
7391 #undef elf_backend_emit_relocs
7392 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7393 #undef elf_backend_final_write_processing
7394 #define elf_backend_final_write_processing \
7395 elf_vxworks_final_write_processing
7396 #undef ELF_MAXPAGESIZE
7397 #define ELF_MAXPAGESIZE 0x1000
7398 #undef ELF_COMMONPAGESIZE
7400 #include "elf32-target.h"
7402 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */