1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Ian Lance Taylor, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "elf-vxworks.h"
31 #include "libiberty.h"
32 #include "../opcodes/sh-opc.h"
34 static bfd_reloc_status_type sh_elf_reloc
35 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
36 static bfd_reloc_status_type sh_elf_ignore_reloc
37 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
38 static bfd_boolean sh_elf_relax_delete_bytes
39 (bfd *, asection *, bfd_vma, int);
40 static bfd_boolean sh_elf_align_loads
41 (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
43 static bfd_boolean sh_elf_swap_insns
44 (bfd *, asection *, void *, bfd_byte *, bfd_vma);
46 static int sh_elf_optimized_tls_reloc
47 (struct bfd_link_info *, int, int);
48 static bfd_vma dtpoff_base
49 (struct bfd_link_info *);
51 (struct bfd_link_info *, bfd_vma);
53 /* The name of the dynamic interpreter. This is put in the .interp
56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
58 /* FDPIC binaries have a default 128K stack. */
59 #define DEFAULT_STACK_SIZE 0x20000
61 #define MINUS_ONE ((bfd_vma) 0 - 1)
63 /* Decide whether a reference to a symbol can be resolved locally or
64 not. If the symbol is protected, we want the local address, but
65 its function descriptor must be assigned by the dynamic linker. */
66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
68 || ! elf_hash_table (INFO)->dynamic_sections_created)
70 #define SH_PARTIAL32 TRUE
71 #define SH_SRC_MASK32 0xffffffff
72 #define SH_ELF_RELOC sh_elf_reloc
73 static reloc_howto_type sh_elf_howto_table[] =
75 #include "elf32-sh-relocs.h"
78 #define SH_PARTIAL32 FALSE
79 #define SH_SRC_MASK32 0
80 #define SH_ELF_RELOC bfd_elf_generic_reloc
81 static reloc_howto_type sh_vxworks_howto_table[] =
83 #include "elf32-sh-relocs.h"
86 /* Return true if OUTPUT_BFD is a VxWorks object. */
89 vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
91 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
92 extern const bfd_target bfd_elf32_shlvxworks_vec;
93 extern const bfd_target bfd_elf32_shvxworks_vec;
95 return (abfd->xvec == &bfd_elf32_shlvxworks_vec
96 || abfd->xvec == &bfd_elf32_shvxworks_vec);
102 /* Return true if OUTPUT_BFD is an FDPIC object. */
105 fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
107 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
108 extern const bfd_target bfd_elf32_shfd_vec;
109 extern const bfd_target bfd_elf32_shbfd_vec;
111 return (abfd->xvec == &bfd_elf32_shfd_vec
112 || abfd->xvec == &bfd_elf32_shbfd_vec);
118 /* Return the howto table for ABFD. */
120 static reloc_howto_type *
121 get_howto_table (bfd *abfd)
123 if (vxworks_object_p (abfd))
124 return sh_vxworks_howto_table;
125 return sh_elf_howto_table;
128 static bfd_reloc_status_type
129 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED, bfd *input_bfd,
130 asection *input_section, bfd_byte *contents,
131 bfd_vma addr, asection *symbol_section,
132 bfd_vma start, bfd_vma end)
134 static bfd_vma last_addr;
135 static asection *last_symbol_section;
136 bfd_byte *start_ptr, *ptr, *last_ptr;
141 /* Sanity check the address. */
142 if (addr > bfd_get_section_limit (input_bfd, input_section))
143 return bfd_reloc_outofrange;
145 /* We require the start and end relocations to be processed consecutively -
146 although we allow then to be processed forwards or backwards. */
150 last_symbol_section = symbol_section;
153 if (last_addr != addr)
157 if (! symbol_section || last_symbol_section != symbol_section || end < start)
158 return bfd_reloc_outofrange;
160 /* Get the symbol_section contents. */
161 if (symbol_section != input_section)
163 if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
164 contents = elf_section_data (symbol_section)->this_hdr.contents;
167 if (!bfd_malloc_and_get_section (input_bfd, symbol_section,
170 if (contents != NULL)
172 return bfd_reloc_outofrange;
176 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
177 start_ptr = contents + start;
178 for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
180 for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
183 diff = (last_ptr - ptr) >> 1;
184 cum_diff += diff & 1;
187 /* Calculate the start / end values to load into rs / re minus four -
188 so that will cancel out the four we would otherwise have to add to
189 addr to get the value to subtract in order to get relative addressing. */
193 end = (ptr + cum_diff * 2) - contents;
197 bfd_vma start0 = start - 4;
199 while (start0 && IS_PPI (contents + start0))
201 start0 = start - 2 - ((start - start0) & 2);
202 start = start0 - cum_diff - 2;
207 && elf_section_data (symbol_section)->this_hdr.contents != contents)
210 insn = bfd_get_16 (input_bfd, contents + addr);
212 x = (insn & 0x200 ? end : start) - addr;
213 if (input_section != symbol_section)
214 x += ((symbol_section->output_section->vma + symbol_section->output_offset)
215 - (input_section->output_section->vma
216 + input_section->output_offset));
218 if (x < -128 || x > 127)
219 return bfd_reloc_overflow;
221 x = (insn & ~0xff) | (x & 0xff);
222 bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
227 /* This function is used for normal relocs. This used to be like the COFF
228 function, and is almost certainly incorrect for other ELF targets. */
230 static bfd_reloc_status_type
231 sh_elf_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
232 void *data, asection *input_section, bfd *output_bfd,
233 char **error_message ATTRIBUTE_UNUSED)
237 enum elf_sh_reloc_type r_type;
238 bfd_vma addr = reloc_entry->address;
239 bfd_byte *hit_data = addr + (bfd_byte *) data;
241 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
243 if (output_bfd != NULL)
245 /* Partial linking--do nothing. */
246 reloc_entry->address += input_section->output_offset;
250 /* Almost all relocs have to do with relaxing. If any work must be
251 done for them, it has been done in sh_relax_section. */
252 if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
255 if (symbol_in != NULL
256 && bfd_is_und_section (symbol_in->section))
257 return bfd_reloc_undefined;
259 if (bfd_is_com_section (symbol_in->section))
262 sym_value = (symbol_in->value +
263 symbol_in->section->output_section->vma +
264 symbol_in->section->output_offset);
269 insn = bfd_get_32 (abfd, hit_data);
270 insn += sym_value + reloc_entry->addend;
271 bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
274 insn = bfd_get_16 (abfd, hit_data);
275 sym_value += reloc_entry->addend;
276 sym_value -= (input_section->output_section->vma
277 + input_section->output_offset
280 sym_value += (insn & 0xfff) << 1;
283 insn = (insn & 0xf000) | (sym_value & 0xfff);
284 bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
285 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
286 return bfd_reloc_overflow;
296 /* This function is used for relocs which are only used for relaxing,
297 which the linker should otherwise ignore. */
299 static bfd_reloc_status_type
300 sh_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
301 asymbol *symbol ATTRIBUTE_UNUSED,
302 void *data ATTRIBUTE_UNUSED, asection *input_section,
304 char **error_message ATTRIBUTE_UNUSED)
306 if (output_bfd != NULL)
307 reloc_entry->address += input_section->output_offset;
311 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
315 bfd_reloc_code_real_type bfd_reloc_val;
316 unsigned char elf_reloc_val;
319 /* An array mapping BFD reloc codes to SH ELF relocs. */
321 static const struct elf_reloc_map sh_reloc_map[] =
323 { BFD_RELOC_NONE, R_SH_NONE },
324 { BFD_RELOC_32, R_SH_DIR32 },
325 { BFD_RELOC_16, R_SH_DIR16 },
326 { BFD_RELOC_8, R_SH_DIR8 },
327 { BFD_RELOC_CTOR, R_SH_DIR32 },
328 { BFD_RELOC_32_PCREL, R_SH_REL32 },
329 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
330 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
331 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
332 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
333 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
334 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
335 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
336 { BFD_RELOC_SH_USES, R_SH_USES },
337 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
338 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
339 { BFD_RELOC_SH_CODE, R_SH_CODE },
340 { BFD_RELOC_SH_DATA, R_SH_DATA },
341 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
342 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
343 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
344 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
345 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
346 { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
347 { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
348 { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
349 { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
350 { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
351 { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
352 { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
353 { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
354 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
355 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
356 { BFD_RELOC_SH_COPY, R_SH_COPY },
357 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
358 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
359 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
360 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
361 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
362 { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
363 { BFD_RELOC_SH_GOT20, R_SH_GOT20 },
364 { BFD_RELOC_SH_GOTOFF20, R_SH_GOTOFF20 },
365 { BFD_RELOC_SH_GOTFUNCDESC, R_SH_GOTFUNCDESC },
366 { BFD_RELOC_SH_GOTFUNCDESC20, R_SH_GOTFUNCDESC20 },
367 { BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC },
368 { BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 },
369 { BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC },
370 #ifdef INCLUDE_SHMEDIA
371 { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
372 { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
373 { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
374 { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
375 { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
376 { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
377 { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
378 { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
379 { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
380 { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
381 { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
382 { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
383 { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
384 { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
385 { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
386 { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
387 { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
388 { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
389 { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
390 { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
391 { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
392 { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
393 { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
394 { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
395 { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
396 { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
397 { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
398 { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
399 { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
400 { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
401 { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
402 { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
403 { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
404 { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
405 { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
406 { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
407 { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
408 { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
409 { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
410 { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
411 { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
412 { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
413 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
414 { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
415 { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
416 { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
417 { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
418 { BFD_RELOC_64, R_SH_64 },
419 { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
420 #endif /* not INCLUDE_SHMEDIA */
423 /* Given a BFD reloc code, return the howto structure for the
424 corresponding SH ELF reloc. */
426 static reloc_howto_type *
427 sh_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
431 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
433 if (sh_reloc_map[i].bfd_reloc_val == code)
434 return get_howto_table (abfd) + (int) sh_reloc_map[i].elf_reloc_val;
440 static reloc_howto_type *
441 sh_elf_reloc_name_lookup (bfd *abfd, const char *r_name)
445 if (vxworks_object_p (abfd))
448 i < (sizeof (sh_vxworks_howto_table)
449 / sizeof (sh_vxworks_howto_table[0]));
451 if (sh_vxworks_howto_table[i].name != NULL
452 && strcasecmp (sh_vxworks_howto_table[i].name, r_name) == 0)
453 return &sh_vxworks_howto_table[i];
458 i < (sizeof (sh_elf_howto_table)
459 / sizeof (sh_elf_howto_table[0]));
461 if (sh_elf_howto_table[i].name != NULL
462 && strcasecmp (sh_elf_howto_table[i].name, r_name) == 0)
463 return &sh_elf_howto_table[i];
469 /* Given an ELF reloc, fill in the howto field of a relent. */
472 sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
476 r = ELF32_R_TYPE (dst->r_info);
478 BFD_ASSERT (r < (unsigned int) R_SH_max);
479 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
480 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
481 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
482 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
483 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
484 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_6 || r > R_SH_LAST_INVALID_RELOC_6);
486 cache_ptr->howto = get_howto_table (abfd) + r;
489 /* This function handles relaxing for SH ELF. See the corresponding
490 function in coff-sh.c for a description of what this does. FIXME:
491 There is a lot of duplication here between this code and the COFF
492 specific code. The format of relocs and symbols is wound deeply
493 into this code, but it would still be better if the duplication
494 could be eliminated somehow. Note in particular that although both
495 functions use symbols like R_SH_CODE, those symbols have different
496 values; in coff-sh.c they come from include/coff/sh.h, whereas here
497 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
500 sh_elf_relax_section (bfd *abfd, asection *sec,
501 struct bfd_link_info *link_info, bfd_boolean *again)
503 Elf_Internal_Shdr *symtab_hdr;
504 Elf_Internal_Rela *internal_relocs;
505 bfd_boolean have_code;
506 Elf_Internal_Rela *irel, *irelend;
507 bfd_byte *contents = NULL;
508 Elf_Internal_Sym *isymbuf = NULL;
512 if (link_info->relocatable
513 || (sec->flags & SEC_RELOC) == 0
514 || sec->reloc_count == 0)
517 #ifdef INCLUDE_SHMEDIA
518 if (elf_section_data (sec)->this_hdr.sh_flags
519 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
525 symtab_hdr = &elf_symtab_hdr (abfd);
527 internal_relocs = (_bfd_elf_link_read_relocs
528 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
529 link_info->keep_memory));
530 if (internal_relocs == NULL)
535 irelend = internal_relocs + sec->reloc_count;
536 for (irel = internal_relocs; irel < irelend; irel++)
538 bfd_vma laddr, paddr, symval;
540 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
543 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
546 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
549 /* Get the section contents. */
550 if (contents == NULL)
552 if (elf_section_data (sec)->this_hdr.contents != NULL)
553 contents = elf_section_data (sec)->this_hdr.contents;
556 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
561 /* The r_addend field of the R_SH_USES reloc will point us to
562 the register load. The 4 is because the r_addend field is
563 computed as though it were a jump offset, which are based
564 from 4 bytes after the jump instruction. */
565 laddr = irel->r_offset + 4 + irel->r_addend;
566 if (laddr >= sec->size)
568 (*_bfd_error_handler) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
570 (unsigned long) irel->r_offset);
573 insn = bfd_get_16 (abfd, contents + laddr);
575 /* If the instruction is not mov.l NN,rN, we don't know what to
577 if ((insn & 0xf000) != 0xd000)
579 ((*_bfd_error_handler)
580 (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
581 abfd, (unsigned long) irel->r_offset, insn));
585 /* Get the address from which the register is being loaded. The
586 displacement in the mov.l instruction is quadrupled. It is a
587 displacement from four bytes after the movl instruction, but,
588 before adding in the PC address, two least significant bits
589 of the PC are cleared. We assume that the section is aligned
590 on a four byte boundary. */
593 paddr += (laddr + 4) &~ (bfd_vma) 3;
594 if (paddr >= sec->size)
596 ((*_bfd_error_handler)
597 (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
598 abfd, (unsigned long) irel->r_offset));
602 /* Get the reloc for the address from which the register is
603 being loaded. This reloc will tell us which function is
604 actually being called. */
605 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
606 if (irelfn->r_offset == paddr
607 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
609 if (irelfn >= irelend)
611 ((*_bfd_error_handler)
612 (_("%B: 0x%lx: warning: could not find expected reloc"),
613 abfd, (unsigned long) paddr));
617 /* Read this BFD's symbols if we haven't done so already. */
618 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
620 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
622 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
623 symtab_hdr->sh_info, 0,
629 /* Get the value of the symbol referred to by the reloc. */
630 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
632 /* A local symbol. */
633 Elf_Internal_Sym *isym;
635 isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
637 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
639 ((*_bfd_error_handler)
640 (_("%B: 0x%lx: warning: symbol in unexpected section"),
641 abfd, (unsigned long) paddr));
645 symval = (isym->st_value
646 + sec->output_section->vma
647 + sec->output_offset);
652 struct elf_link_hash_entry *h;
654 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
655 h = elf_sym_hashes (abfd)[indx];
656 BFD_ASSERT (h != NULL);
657 if (h->root.type != bfd_link_hash_defined
658 && h->root.type != bfd_link_hash_defweak)
660 /* This appears to be a reference to an undefined
661 symbol. Just ignore it--it will be caught by the
662 regular reloc processing. */
666 symval = (h->root.u.def.value
667 + h->root.u.def.section->output_section->vma
668 + h->root.u.def.section->output_offset);
671 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
672 symval += bfd_get_32 (abfd, contents + paddr);
674 symval += irelfn->r_addend;
676 /* See if this function call can be shortened. */
679 + sec->output_section->vma
682 /* A branch to an address beyond ours might be increased by an
683 .align that doesn't move when bytes behind us are deleted.
684 So, we add some slop in this calculation to allow for
686 if (foff < -0x1000 || foff >= 0x1000 - 8)
688 /* After all that work, we can't shorten this function call. */
692 /* Shorten the function call. */
694 /* For simplicity of coding, we are going to modify the section
695 contents, the section relocs, and the BFD symbol table. We
696 must tell the rest of the code not to free up this
697 information. It would be possible to instead create a table
698 of changes which have to be made, as is done in coff-mips.c;
699 that would be more work, but would require less memory when
700 the linker is run. */
702 elf_section_data (sec)->relocs = internal_relocs;
703 elf_section_data (sec)->this_hdr.contents = contents;
704 symtab_hdr->contents = (unsigned char *) isymbuf;
706 /* Replace the jsr with a bsr. */
708 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
709 replace the jsr with a bsr. */
710 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
711 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
712 here, but that only checks if the symbol is an external symbol,
713 not if the symbol is in a different section. Besides, we need
714 a consistent meaning for the relocation, so we just assume here that
715 the value of the symbol is not available. */
717 /* We can't fully resolve this yet, because the external
718 symbol value may be changed by future relaxing. We let
719 the final link phase handle it. */
720 bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
724 /* When we calculated the symbol "value" we had an offset in the
725 DIR32's word in memory (we read and add it above). However,
726 the jsr we create does NOT have this offset encoded, so we
727 have to add it to the addend to preserve it. */
728 irel->r_addend += bfd_get_32 (abfd, contents + paddr);
730 /* See if there is another R_SH_USES reloc referring to the same
732 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
733 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
734 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
736 if (irelscan < irelend)
738 /* Some other function call depends upon this register load,
739 and we have not yet converted that function call.
740 Indeed, we may never be able to convert it. There is
741 nothing else we can do at this point. */
745 /* Look for a R_SH_COUNT reloc on the location where the
746 function address is stored. Do this before deleting any
747 bytes, to avoid confusion about the address. */
748 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
749 if (irelcount->r_offset == paddr
750 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
753 /* Delete the register load. */
754 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
757 /* That will change things, so, just in case it permits some
758 other function call to come within range, we should relax
759 again. Note that this is not required, and it may be slow. */
762 /* Now check whether we got a COUNT reloc. */
763 if (irelcount >= irelend)
765 ((*_bfd_error_handler)
766 (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
767 abfd, (unsigned long) paddr));
771 /* The number of uses is stored in the r_addend field. We've
773 if (irelcount->r_addend == 0)
775 ((*_bfd_error_handler) (_("%B: 0x%lx: warning: bad count"),
777 (unsigned long) paddr));
781 --irelcount->r_addend;
783 /* If there are no more uses, we can delete the address. Reload
784 the address from irelfn, in case it was changed by the
785 previous call to sh_elf_relax_delete_bytes. */
786 if (irelcount->r_addend == 0)
788 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
792 /* We've done all we can with that function call. */
795 /* Look for load and store instructions that we can align on four
797 if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
802 /* Get the section contents. */
803 if (contents == NULL)
805 if (elf_section_data (sec)->this_hdr.contents != NULL)
806 contents = elf_section_data (sec)->this_hdr.contents;
809 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
814 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
820 elf_section_data (sec)->relocs = internal_relocs;
821 elf_section_data (sec)->this_hdr.contents = contents;
822 symtab_hdr->contents = (unsigned char *) isymbuf;
827 && symtab_hdr->contents != (unsigned char *) isymbuf)
829 if (! link_info->keep_memory)
833 /* Cache the symbols for elf_link_input_bfd. */
834 symtab_hdr->contents = (unsigned char *) isymbuf;
839 && elf_section_data (sec)->this_hdr.contents != contents)
841 if (! link_info->keep_memory)
845 /* Cache the section contents for elf_link_input_bfd. */
846 elf_section_data (sec)->this_hdr.contents = contents;
850 if (internal_relocs != NULL
851 && elf_section_data (sec)->relocs != internal_relocs)
852 free (internal_relocs);
858 && symtab_hdr->contents != (unsigned char *) isymbuf)
861 && elf_section_data (sec)->this_hdr.contents != contents)
863 if (internal_relocs != NULL
864 && elf_section_data (sec)->relocs != internal_relocs)
865 free (internal_relocs);
870 /* Delete some bytes from a section while relaxing. FIXME: There is a
871 lot of duplication between this function and sh_relax_delete_bytes
875 sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr,
878 Elf_Internal_Shdr *symtab_hdr;
879 unsigned int sec_shndx;
881 Elf_Internal_Rela *irel, *irelend;
882 Elf_Internal_Rela *irelalign;
884 Elf_Internal_Sym *isymbuf, *isym, *isymend;
885 struct elf_link_hash_entry **sym_hashes;
886 struct elf_link_hash_entry **end_hashes;
887 unsigned int symcount;
890 symtab_hdr = &elf_symtab_hdr (abfd);
891 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
893 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
895 contents = elf_section_data (sec)->this_hdr.contents;
897 /* The deletion must stop at the next ALIGN reloc for an aligment
898 power larger than the number of bytes we are deleting. */
903 irel = elf_section_data (sec)->relocs;
904 irelend = irel + sec->reloc_count;
905 for (; irel < irelend; irel++)
907 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
908 && irel->r_offset > addr
909 && count < (1 << irel->r_addend))
912 toaddr = irel->r_offset;
917 /* Actually delete the bytes. */
918 memmove (contents + addr, contents + addr + count,
919 (size_t) (toaddr - addr - count));
920 if (irelalign == NULL)
926 #define NOP_OPCODE (0x0009)
928 BFD_ASSERT ((count & 1) == 0);
929 for (i = 0; i < count; i += 2)
930 bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
933 /* Adjust all the relocs. */
934 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
936 bfd_vma nraddr, stop;
939 int off, adjust, oinsn;
940 bfd_signed_vma voff = 0;
941 bfd_boolean overflow;
943 /* Get the new reloc address. */
944 nraddr = irel->r_offset;
945 if ((irel->r_offset > addr
946 && irel->r_offset < toaddr)
947 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
948 && irel->r_offset == toaddr))
951 /* See if this reloc was for the bytes we have deleted, in which
952 case we no longer care about it. Don't delete relocs which
953 represent addresses, though. */
954 if (irel->r_offset >= addr
955 && irel->r_offset < addr + count
956 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
957 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
958 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
959 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
960 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
963 /* If this is a PC relative reloc, see if the range it covers
964 includes the bytes we have deleted. */
965 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
974 start = irel->r_offset;
975 insn = bfd_get_16 (abfd, contents + nraddr);
979 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
986 /* If this reloc is against a symbol defined in this
987 section, and the symbol will not be adjusted below, we
988 must check the addend to see it will put the value in
989 range to be adjusted, and hence must be changed. */
990 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
992 isym = isymbuf + ELF32_R_SYM (irel->r_info);
993 if (isym->st_shndx == sec_shndx
994 && (isym->st_value <= addr
995 || isym->st_value >= toaddr))
999 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
1001 val = bfd_get_32 (abfd, contents + nraddr);
1002 val += isym->st_value;
1003 if (val > addr && val < toaddr)
1004 bfd_put_32 (abfd, val - count, contents + nraddr);
1008 val = isym->st_value + irel->r_addend;
1009 if (val > addr && val < toaddr)
1010 irel->r_addend -= count;
1014 start = stop = addr;
1021 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1028 /* This has been made by previous relaxation. Since the
1029 relocation will be against an external symbol, the
1030 final relocation will just do the right thing. */
1031 start = stop = addr;
1037 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1039 /* The addend will be against the section symbol, thus
1040 for adjusting the addend, the relevant start is the
1041 start of the section.
1042 N.B. If we want to abandon in-place changes here and
1043 test directly using symbol + addend, we have to take into
1044 account that the addend has already been adjusted by -4. */
1045 if (stop > addr && stop < toaddr)
1046 irel->r_addend -= count;
1052 stop = start + 4 + off * 2;
1057 stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1063 /* These relocs types represent
1065 The r_addend field holds the difference between the reloc
1066 address and L1. That is the start of the reloc, and
1067 adding in the contents gives us the top. We must adjust
1068 both the r_offset field and the section contents.
1069 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1070 and the elf bfd r_offset is called r_vaddr. */
1072 stop = irel->r_offset;
1073 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1077 && (stop <= addr || stop >= toaddr))
1078 irel->r_addend += count;
1079 else if (stop > addr
1081 && (start <= addr || start >= toaddr))
1082 irel->r_addend -= count;
1084 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1085 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1086 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1087 voff = bfd_get_8 (abfd, contents + nraddr);
1089 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1090 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1095 start = irel->r_offset;
1096 stop = (bfd_vma) ((bfd_signed_vma) start
1097 + (long) irel->r_addend
1104 && (stop <= addr || stop >= toaddr))
1106 else if (stop > addr
1108 && (start <= addr || start >= toaddr))
1117 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1126 if ((oinsn & 0xff00) != (insn & 0xff00))
1128 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1133 if ((oinsn & 0xf000) != (insn & 0xf000))
1135 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1139 BFD_ASSERT (adjust == count || count >= 4);
1144 if ((irel->r_offset & 3) == 0)
1147 if ((oinsn & 0xff00) != (insn & 0xff00))
1149 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1154 if (voff < 0 || voff >= 0xff)
1156 bfd_put_8 (abfd, voff, contents + nraddr);
1161 if (voff < - 0x8000 || voff >= 0x8000)
1163 bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
1168 bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
1172 irel->r_addend += adjust;
1178 ((*_bfd_error_handler)
1179 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1180 abfd, (unsigned long) irel->r_offset));
1181 bfd_set_error (bfd_error_bad_value);
1186 irel->r_offset = nraddr;
1189 /* Look through all the other sections. If there contain any IMM32
1190 relocs against internal symbols which we are not going to adjust
1191 below, we may need to adjust the addends. */
1192 for (o = abfd->sections; o != NULL; o = o->next)
1194 Elf_Internal_Rela *internal_relocs;
1195 Elf_Internal_Rela *irelscan, *irelscanend;
1196 bfd_byte *ocontents;
1199 || (o->flags & SEC_RELOC) == 0
1200 || o->reloc_count == 0)
1203 /* We always cache the relocs. Perhaps, if info->keep_memory is
1204 FALSE, we should free them, if we are permitted to, when we
1205 leave sh_coff_relax_section. */
1206 internal_relocs = (_bfd_elf_link_read_relocs
1207 (abfd, o, NULL, (Elf_Internal_Rela *) NULL, TRUE));
1208 if (internal_relocs == NULL)
1212 irelscanend = internal_relocs + o->reloc_count;
1213 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1215 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1216 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1218 bfd_vma start, stop;
1219 bfd_signed_vma voff;
1221 if (ocontents == NULL)
1223 if (elf_section_data (o)->this_hdr.contents != NULL)
1224 ocontents = elf_section_data (o)->this_hdr.contents;
1227 /* We always cache the section contents.
1228 Perhaps, if info->keep_memory is FALSE, we
1229 should free them, if we are permitted to,
1230 when we leave sh_coff_relax_section. */
1231 if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1233 if (ocontents != NULL)
1238 elf_section_data (o)->this_hdr.contents = ocontents;
1242 stop = irelscan->r_offset;
1244 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1246 /* STOP is in a different section, so it won't change. */
1247 if (start > addr && start < toaddr)
1248 irelscan->r_addend += count;
1250 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1251 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1255 && (stop <= addr || stop >= toaddr))
1256 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
1257 ocontents + irelscan->r_offset);
1258 else if (stop > addr
1260 && (start <= addr || start >= toaddr))
1261 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
1262 ocontents + irelscan->r_offset);
1265 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1268 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1272 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1273 if (isym->st_shndx == sec_shndx
1274 && (isym->st_value <= addr
1275 || isym->st_value >= toaddr))
1279 if (ocontents == NULL)
1281 if (elf_section_data (o)->this_hdr.contents != NULL)
1282 ocontents = elf_section_data (o)->this_hdr.contents;
1285 /* We always cache the section contents.
1286 Perhaps, if info->keep_memory is FALSE, we
1287 should free them, if we are permitted to,
1288 when we leave sh_coff_relax_section. */
1289 if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1291 if (ocontents != NULL)
1296 elf_section_data (o)->this_hdr.contents = ocontents;
1300 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1301 val += isym->st_value;
1302 if (val > addr && val < toaddr)
1303 bfd_put_32 (abfd, val - count,
1304 ocontents + irelscan->r_offset);
1309 /* Adjust the local symbols defined in this section. */
1310 isymend = isymbuf + symtab_hdr->sh_info;
1311 for (isym = isymbuf; isym < isymend; isym++)
1313 if (isym->st_shndx == sec_shndx
1314 && isym->st_value > addr
1315 && isym->st_value < toaddr)
1316 isym->st_value -= count;
1319 /* Now adjust the global symbols defined in this section. */
1320 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1321 - symtab_hdr->sh_info);
1322 sym_hashes = elf_sym_hashes (abfd);
1323 end_hashes = sym_hashes + symcount;
1324 for (; sym_hashes < end_hashes; sym_hashes++)
1326 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1327 if ((sym_hash->root.type == bfd_link_hash_defined
1328 || sym_hash->root.type == bfd_link_hash_defweak)
1329 && sym_hash->root.u.def.section == sec
1330 && sym_hash->root.u.def.value > addr
1331 && sym_hash->root.u.def.value < toaddr)
1333 sym_hash->root.u.def.value -= count;
1337 /* See if we can move the ALIGN reloc forward. We have adjusted
1338 r_offset for it already. */
1339 if (irelalign != NULL)
1341 bfd_vma alignto, alignaddr;
1343 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1344 alignaddr = BFD_ALIGN (irelalign->r_offset,
1345 1 << irelalign->r_addend);
1346 if (alignto != alignaddr)
1348 /* Tail recursion. */
1349 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1350 (int) (alignto - alignaddr));
1357 /* Look for loads and stores which we can align to four byte
1358 boundaries. This is like sh_align_loads in coff-sh.c. */
1361 sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
1362 Elf_Internal_Rela *internal_relocs,
1363 bfd_byte *contents ATTRIBUTE_UNUSED,
1364 bfd_boolean *pswapped)
1366 Elf_Internal_Rela *irel, *irelend;
1367 bfd_vma *labels = NULL;
1368 bfd_vma *label, *label_end;
1373 irelend = internal_relocs + sec->reloc_count;
1375 /* Get all the addresses with labels on them. */
1376 amt = sec->reloc_count;
1377 amt *= sizeof (bfd_vma);
1378 labels = (bfd_vma *) bfd_malloc (amt);
1382 for (irel = internal_relocs; irel < irelend; irel++)
1384 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1386 *label_end = irel->r_offset;
1391 /* Note that the assembler currently always outputs relocs in
1392 address order. If that ever changes, this code will need to sort
1393 the label values and the relocs. */
1397 for (irel = internal_relocs; irel < irelend; irel++)
1399 bfd_vma start, stop;
1401 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1404 start = irel->r_offset;
1406 for (irel++; irel < irelend; irel++)
1407 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1410 stop = irel->r_offset;
1414 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1415 internal_relocs, &label,
1416 label_end, start, stop, pswapped))
1431 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1434 sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs,
1435 bfd_byte *contents, bfd_vma addr)
1437 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1438 unsigned short i1, i2;
1439 Elf_Internal_Rela *irel, *irelend;
1441 /* Swap the instructions themselves. */
1442 i1 = bfd_get_16 (abfd, contents + addr);
1443 i2 = bfd_get_16 (abfd, contents + addr + 2);
1444 bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
1445 bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
1447 /* Adjust all reloc addresses. */
1448 irelend = internal_relocs + sec->reloc_count;
1449 for (irel = internal_relocs; irel < irelend; irel++)
1451 enum elf_sh_reloc_type type;
1454 /* There are a few special types of relocs that we don't want to
1455 adjust. These relocs do not apply to the instruction itself,
1456 but are only associated with the address. */
1457 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1458 if (type == R_SH_ALIGN
1459 || type == R_SH_CODE
1460 || type == R_SH_DATA
1461 || type == R_SH_LABEL)
1464 /* If an R_SH_USES reloc points to one of the addresses being
1465 swapped, we must adjust it. It would be incorrect to do this
1466 for a jump, though, since we want to execute both
1467 instructions after the jump. (We have avoided swapping
1468 around a label, so the jump will not wind up executing an
1469 instruction it shouldn't). */
1470 if (type == R_SH_USES)
1474 off = irel->r_offset + 4 + irel->r_addend;
1476 irel->r_offset += 2;
1477 else if (off == addr + 2)
1478 irel->r_offset -= 2;
1481 if (irel->r_offset == addr)
1483 irel->r_offset += 2;
1486 else if (irel->r_offset == addr + 2)
1488 irel->r_offset -= 2;
1497 unsigned short insn, oinsn;
1498 bfd_boolean overflow;
1500 loc = contents + irel->r_offset;
1509 insn = bfd_get_16 (abfd, loc);
1512 if ((oinsn & 0xff00) != (insn & 0xff00))
1514 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1518 insn = bfd_get_16 (abfd, loc);
1521 if ((oinsn & 0xf000) != (insn & 0xf000))
1523 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1527 /* This reloc ignores the least significant 3 bits of
1528 the program counter before adding in the offset.
1529 This means that if ADDR is at an even address, the
1530 swap will not affect the offset. If ADDR is an at an
1531 odd address, then the instruction will be crossing a
1532 four byte boundary, and must be adjusted. */
1533 if ((addr & 3) != 0)
1535 insn = bfd_get_16 (abfd, loc);
1538 if ((oinsn & 0xff00) != (insn & 0xff00))
1540 bfd_put_16 (abfd, (bfd_vma) insn, loc);
1548 ((*_bfd_error_handler)
1549 (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
1550 abfd, (unsigned long) irel->r_offset));
1551 bfd_set_error (bfd_error_bad_value);
1559 #endif /* defined SH64_ELF */
1561 /* Describes one of the various PLT styles. */
1563 struct elf_sh_plt_info
1565 /* The template for the first PLT entry, or NULL if there is no special
1567 const bfd_byte *plt0_entry;
1569 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1570 bfd_vma plt0_entry_size;
1572 /* Index I is the offset into PLT0_ENTRY of a pointer to
1573 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1574 if there is no such pointer. */
1575 bfd_vma plt0_got_fields[3];
1577 /* The template for a symbol's PLT entry. */
1578 const bfd_byte *symbol_entry;
1580 /* The size of SYMBOL_ENTRY in bytes. */
1581 bfd_vma symbol_entry_size;
1583 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1584 on all targets. The comments by each member indicate the value
1585 that the field must hold. */
1587 bfd_vma got_entry; /* the address of the symbol's .got.plt entry */
1588 bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */
1589 bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */
1590 bfd_boolean got20; /* TRUE if got_entry points to a movi20
1591 instruction (instead of a constant pool
1595 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1596 bfd_vma symbol_resolve_offset;
1598 /* A different PLT layout which can be used for the first
1599 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1601 const struct elf_sh_plt_info *short_plt;
1604 #ifdef INCLUDE_SHMEDIA
1606 /* The size in bytes of an entry in the procedure linkage table. */
1608 #define ELF_PLT_ENTRY_SIZE 64
1610 /* First entry in an absolute procedure linkage table look like this. */
1612 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1614 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
1615 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
1616 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1617 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1618 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1619 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1620 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1621 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1622 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1623 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1624 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1625 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1626 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1627 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1628 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1629 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1632 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1634 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
1635 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
1636 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1637 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1638 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1639 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1640 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1641 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1642 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1643 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1644 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1645 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1646 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1647 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1648 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1649 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1652 /* Sebsequent entries in an absolute procedure linkage table look like
1655 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1657 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
1658 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
1659 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
1660 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1661 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1662 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1663 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1664 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1665 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
1666 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
1667 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1668 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1669 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1670 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1671 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1672 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1675 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1677 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
1678 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
1679 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
1680 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1681 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1682 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1683 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1684 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1685 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
1686 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
1687 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1688 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1689 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1690 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1691 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1692 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1695 /* Entries in a PIC procedure linkage table look like this. */
1697 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1699 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
1700 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
1701 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
1702 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1703 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1704 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1705 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1706 0x6f, 0xf0, 0xff, 0xf0, /* nop */
1707 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
1708 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
1709 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
1710 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
1711 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
1712 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
1713 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
1714 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
1717 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1719 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
1720 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
1721 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
1722 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1723 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1724 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1725 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1726 0xf0, 0xff, 0xf0, 0x6f, /* nop */
1727 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
1728 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
1729 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
1730 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
1731 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
1732 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
1733 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
1734 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
1737 static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1740 /* Big-endian non-PIC. */
1741 elf_sh_plt0_entry_be,
1743 { 0, MINUS_ONE, MINUS_ONE },
1744 elf_sh_plt_entry_be,
1746 { 0, 32, 48, FALSE },
1747 33, /* includes ISA encoding */
1751 /* Little-endian non-PIC. */
1752 elf_sh_plt0_entry_le,
1754 { 0, MINUS_ONE, MINUS_ONE },
1755 elf_sh_plt_entry_le,
1757 { 0, 32, 48, FALSE },
1758 33, /* includes ISA encoding */
1764 /* Big-endian PIC. */
1765 elf_sh_plt0_entry_be,
1767 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1768 elf_sh_pic_plt_entry_be,
1770 { 0, MINUS_ONE, 52, FALSE },
1771 33, /* includes ISA encoding */
1775 /* Little-endian PIC. */
1776 elf_sh_plt0_entry_le,
1778 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1779 elf_sh_pic_plt_entry_le,
1781 { 0, MINUS_ONE, 52, FALSE },
1782 33, /* includes ISA encoding */
1788 /* Return offset of the linker in PLT0 entry. */
1789 #define elf_sh_plt0_gotplt_offset(info) 0
1791 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1792 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1795 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1798 install_plt_field (bfd *output_bfd, bfd_boolean code_p,
1799 unsigned long value, bfd_byte *addr)
1802 bfd_put_32 (output_bfd,
1803 bfd_get_32 (output_bfd, addr)
1804 | ((value >> 6) & 0x3fffc00),
1806 bfd_put_32 (output_bfd,
1807 bfd_get_32 (output_bfd, addr + 4)
1808 | ((value << 10) & 0x3fffc00),
1812 /* Return the type of PLT associated with ABFD. PIC_P is true if
1813 the object is position-independent. */
1815 static const struct elf_sh_plt_info *
1816 get_plt_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean pic_p)
1818 return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
1821 /* The size in bytes of an entry in the procedure linkage table. */
1823 #define ELF_PLT_ENTRY_SIZE 28
1825 /* First entry in an absolute procedure linkage table look like this. */
1827 /* Note - this code has been "optimised" not to use r2. r2 is used by
1828 GCC to return the address of large structures, so it should not be
1829 corrupted here. This does mean however, that this PLT does not conform
1830 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1831 and r2 contains the GOT id. This version stores the GOT id in r0 and
1832 ignores the type. Loaders can easily detect this difference however,
1833 since the type will always be 0 or 8, and the GOT ids will always be
1834 greater than or equal to 12. */
1835 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1837 0xd0, 0x05, /* mov.l 2f,r0 */
1838 0x60, 0x02, /* mov.l @r0,r0 */
1839 0x2f, 0x06, /* mov.l r0,@-r15 */
1840 0xd0, 0x03, /* mov.l 1f,r0 */
1841 0x60, 0x02, /* mov.l @r0,r0 */
1842 0x40, 0x2b, /* jmp @r0 */
1843 0x60, 0xf6, /* mov.l @r15+,r0 */
1844 0x00, 0x09, /* nop */
1845 0x00, 0x09, /* nop */
1846 0x00, 0x09, /* nop */
1847 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1848 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1851 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1853 0x05, 0xd0, /* mov.l 2f,r0 */
1854 0x02, 0x60, /* mov.l @r0,r0 */
1855 0x06, 0x2f, /* mov.l r0,@-r15 */
1856 0x03, 0xd0, /* mov.l 1f,r0 */
1857 0x02, 0x60, /* mov.l @r0,r0 */
1858 0x2b, 0x40, /* jmp @r0 */
1859 0xf6, 0x60, /* mov.l @r15+,r0 */
1860 0x09, 0x00, /* nop */
1861 0x09, 0x00, /* nop */
1862 0x09, 0x00, /* nop */
1863 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
1864 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
1867 /* Sebsequent entries in an absolute procedure linkage table look like
1870 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1872 0xd0, 0x04, /* mov.l 1f,r0 */
1873 0x60, 0x02, /* mov.l @(r0,r12),r0 */
1874 0xd1, 0x02, /* mov.l 0f,r1 */
1875 0x40, 0x2b, /* jmp @r0 */
1876 0x60, 0x13, /* mov r1,r0 */
1877 0xd1, 0x03, /* mov.l 2f,r1 */
1878 0x40, 0x2b, /* jmp @r0 */
1879 0x00, 0x09, /* nop */
1880 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1881 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1882 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1885 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1887 0x04, 0xd0, /* mov.l 1f,r0 */
1888 0x02, 0x60, /* mov.l @r0,r0 */
1889 0x02, 0xd1, /* mov.l 0f,r1 */
1890 0x2b, 0x40, /* jmp @r0 */
1891 0x13, 0x60, /* mov r1,r0 */
1892 0x03, 0xd1, /* mov.l 2f,r1 */
1893 0x2b, 0x40, /* jmp @r0 */
1894 0x09, 0x00, /* nop */
1895 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
1896 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1897 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
1900 /* Entries in a PIC procedure linkage table look like this. */
1902 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1904 0xd0, 0x04, /* mov.l 1f,r0 */
1905 0x00, 0xce, /* mov.l @(r0,r12),r0 */
1906 0x40, 0x2b, /* jmp @r0 */
1907 0x00, 0x09, /* nop */
1908 0x50, 0xc2, /* mov.l @(8,r12),r0 */
1909 0xd1, 0x03, /* mov.l 2f,r1 */
1910 0x40, 0x2b, /* jmp @r0 */
1911 0x50, 0xc1, /* mov.l @(4,r12),r0 */
1912 0x00, 0x09, /* nop */
1913 0x00, 0x09, /* nop */
1914 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1915 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1918 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1920 0x04, 0xd0, /* mov.l 1f,r0 */
1921 0xce, 0x00, /* mov.l @(r0,r12),r0 */
1922 0x2b, 0x40, /* jmp @r0 */
1923 0x09, 0x00, /* nop */
1924 0xc2, 0x50, /* mov.l @(8,r12),r0 */
1925 0x03, 0xd1, /* mov.l 2f,r1 */
1926 0x2b, 0x40, /* jmp @r0 */
1927 0xc1, 0x50, /* mov.l @(4,r12),r0 */
1928 0x09, 0x00, /* nop */
1929 0x09, 0x00, /* nop */
1930 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
1931 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
1934 static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1937 /* Big-endian non-PIC. */
1938 elf_sh_plt0_entry_be,
1940 { MINUS_ONE, 24, 20 },
1941 elf_sh_plt_entry_be,
1943 { 20, 16, 24, FALSE },
1948 /* Little-endian non-PIC. */
1949 elf_sh_plt0_entry_le,
1951 { MINUS_ONE, 24, 20 },
1952 elf_sh_plt_entry_le,
1954 { 20, 16, 24, FALSE },
1961 /* Big-endian PIC. */
1962 elf_sh_plt0_entry_be,
1964 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1965 elf_sh_pic_plt_entry_be,
1967 { 20, MINUS_ONE, 24, FALSE },
1972 /* Little-endian PIC. */
1973 elf_sh_plt0_entry_le,
1975 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1976 elf_sh_pic_plt_entry_le,
1978 { 20, MINUS_ONE, 24, FALSE },
1985 #define VXWORKS_PLT_HEADER_SIZE 12
1986 #define VXWORKS_PLT_ENTRY_SIZE 24
1988 static const bfd_byte vxworks_sh_plt0_entry_be[VXWORKS_PLT_HEADER_SIZE] =
1990 0xd1, 0x01, /* mov.l @(8,pc),r1 */
1991 0x61, 0x12, /* mov.l @r1,r1 */
1992 0x41, 0x2b, /* jmp @r1 */
1993 0x00, 0x09, /* nop */
1994 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
1997 static const bfd_byte vxworks_sh_plt0_entry_le[VXWORKS_PLT_HEADER_SIZE] =
1999 0x01, 0xd1, /* mov.l @(8,pc),r1 */
2000 0x12, 0x61, /* mov.l @r1,r1 */
2001 0x2b, 0x41, /* jmp @r1 */
2002 0x09, 0x00, /* nop */
2003 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */
2006 static const bfd_byte vxworks_sh_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2008 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2009 0x60, 0x02, /* mov.l @r0,r0 */
2010 0x40, 0x2b, /* jmp @r0 */
2011 0x00, 0x09, /* nop */
2012 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2013 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2014 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */
2015 0x00, 0x09, /* nop */
2016 0x00, 0x09, /* nop */
2017 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2020 static const bfd_byte vxworks_sh_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2022 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2023 0x02, 0x60, /* mov.l @r0,r0 */
2024 0x2b, 0x40, /* jmp @r0 */
2025 0x09, 0x00, /* nop */
2026 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */
2027 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2028 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */
2029 0x09, 0x00, /* nop */
2030 0x09, 0x00, /* nop */
2031 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2034 static const bfd_byte vxworks_sh_pic_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
2036 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2037 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2038 0x40, 0x2b, /* jmp @r0 */
2039 0x00, 0x09, /* nop */
2040 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2041 0xd0, 0x01, /* mov.l @(8,pc),r0 */
2042 0x51, 0xc2, /* mov.l @(8,r12),r1 */
2043 0x41, 0x2b, /* jmp @r1 */
2044 0x00, 0x09, /* nop */
2045 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2048 static const bfd_byte vxworks_sh_pic_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
2050 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2051 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2052 0x2b, 0x40, /* jmp @r0 */
2053 0x09, 0x00, /* nop */
2054 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */
2055 0x01, 0xd0, /* mov.l @(8,pc),r0 */
2056 0xc2, 0x51, /* mov.l @(8,r12),r1 */
2057 0x2b, 0x41, /* jmp @r1 */
2058 0x09, 0x00, /* nop */
2059 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2062 static const struct elf_sh_plt_info vxworks_sh_plts[2][2] = {
2065 /* Big-endian non-PIC. */
2066 vxworks_sh_plt0_entry_be,
2067 VXWORKS_PLT_HEADER_SIZE,
2068 { MINUS_ONE, MINUS_ONE, 8 },
2069 vxworks_sh_plt_entry_be,
2070 VXWORKS_PLT_ENTRY_SIZE,
2071 { 8, 14, 20, FALSE },
2076 /* Little-endian non-PIC. */
2077 vxworks_sh_plt0_entry_le,
2078 VXWORKS_PLT_HEADER_SIZE,
2079 { MINUS_ONE, MINUS_ONE, 8 },
2080 vxworks_sh_plt_entry_le,
2081 VXWORKS_PLT_ENTRY_SIZE,
2082 { 8, 14, 20, FALSE },
2089 /* Big-endian PIC. */
2092 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2093 vxworks_sh_pic_plt_entry_be,
2094 VXWORKS_PLT_ENTRY_SIZE,
2095 { 8, MINUS_ONE, 20, FALSE },
2100 /* Little-endian PIC. */
2103 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2104 vxworks_sh_pic_plt_entry_le,
2105 VXWORKS_PLT_ENTRY_SIZE,
2106 { 8, MINUS_ONE, 20, FALSE },
2113 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2114 binding are to omit the lazy binding stub when linking with -z now
2115 and to move lazy binding stubs into a separate region for better
2118 #define FDPIC_PLT_ENTRY_SIZE 28
2119 #define FDPIC_PLT_LAZY_OFFSET 20
2121 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2122 duplicated if it is out of range, or which can be inlined. So
2123 right now it is always inlined, which wastes a word per stub. It
2124 might be easier to handle the duplication if we put the lazy
2125 stubs separately. */
2127 static const bfd_byte fdpic_sh_plt_entry_be[FDPIC_PLT_ENTRY_SIZE] =
2129 0xd0, 0x02, /* mov.l @(12,pc),r0 */
2130 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2131 0x70, 0x04, /* add #4, r0 */
2132 0x41, 0x2b, /* jmp @r1 */
2133 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2134 0x00, 0x09, /* nop */
2135 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2136 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2137 0x60, 0xc2, /* mov.l @r12,r0 */
2138 0x40, 0x2b, /* jmp @r0 */
2139 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2140 0x00, 0x09, /* nop */
2143 static const bfd_byte fdpic_sh_plt_entry_le[FDPIC_PLT_ENTRY_SIZE] =
2145 0x02, 0xd0, /* mov.l @(12,pc),r0 */
2146 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2147 0x04, 0x70, /* add #4, r0 */
2148 0x2b, 0x41, /* jmp @r1 */
2149 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2150 0x09, 0x00, /* nop */
2151 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */
2152 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2153 0xc2, 0x60, /* mov.l @r12,r0 */
2154 0x2b, 0x40, /* jmp @r0 */
2155 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2156 0x09, 0x00, /* nop */
2159 static const struct elf_sh_plt_info fdpic_sh_plts[2] = {
2161 /* Big-endian PIC. */
2164 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2165 fdpic_sh_plt_entry_be,
2166 FDPIC_PLT_ENTRY_SIZE,
2167 { 12, MINUS_ONE, 16, FALSE },
2168 FDPIC_PLT_LAZY_OFFSET,
2172 /* Little-endian PIC. */
2175 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2176 fdpic_sh_plt_entry_le,
2177 FDPIC_PLT_ENTRY_SIZE,
2178 { 12, MINUS_ONE, 16, FALSE },
2179 FDPIC_PLT_LAZY_OFFSET,
2184 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2185 entries for the first 64K slots. We use the normal FDPIC PLT entry
2186 past that point; we could also use movi20s, which might be faster,
2187 but would not be any smaller. */
2189 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2190 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2192 static const bfd_byte fdpic_sh2a_plt_entry_be[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2194 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2195 0x01, 0xce, /* mov.l @(r0,r12),r1 */
2196 0x70, 0x04, /* add #4, r0 */
2197 0x41, 0x2b, /* jmp @r1 */
2198 0x0c, 0xce, /* mov.l @(r0,r12),r12 */
2199 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2200 0x60, 0xc2, /* mov.l @r12,r0 */
2201 0x40, 0x2b, /* jmp @r0 */
2202 0x53, 0xc1, /* mov.l @(4,r12),r3 */
2203 0x00, 0x09, /* nop */
2206 static const bfd_byte fdpic_sh2a_plt_entry_le[FDPIC_SH2A_PLT_ENTRY_SIZE] =
2208 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */
2209 0xce, 0x01, /* mov.l @(r0,r12),r1 */
2210 0x04, 0x70, /* add #4, r0 */
2211 0x2b, 0x41, /* jmp @r1 */
2212 0xce, 0x0c, /* mov.l @(r0,r12),r12 */
2213 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */
2214 0xc2, 0x60, /* mov.l @r12,r0 */
2215 0x2b, 0x40, /* jmp @r0 */
2216 0xc1, 0x53, /* mov.l @(4,r12),r3 */
2217 0x09, 0x00, /* nop */
2220 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be = {
2221 /* Big-endian FDPIC, max index 64K. */
2224 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2225 fdpic_sh2a_plt_entry_be,
2226 FDPIC_SH2A_PLT_ENTRY_SIZE,
2227 { 0, MINUS_ONE, 12, TRUE },
2228 FDPIC_SH2A_PLT_LAZY_OFFSET,
2232 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le = {
2233 /* Little-endian FDPIC, max index 64K. */
2236 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2237 fdpic_sh2a_plt_entry_le,
2238 FDPIC_SH2A_PLT_ENTRY_SIZE,
2239 { 0, MINUS_ONE, 12, TRUE },
2240 FDPIC_SH2A_PLT_LAZY_OFFSET,
2244 static const struct elf_sh_plt_info fdpic_sh2a_plts[2] = {
2246 /* Big-endian PIC. */
2249 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2250 fdpic_sh_plt_entry_be,
2251 FDPIC_PLT_ENTRY_SIZE,
2252 { 12, MINUS_ONE, 16, FALSE },
2253 FDPIC_PLT_LAZY_OFFSET,
2254 &fdpic_sh2a_short_plt_be
2257 /* Little-endian PIC. */
2260 { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2261 fdpic_sh_plt_entry_le,
2262 FDPIC_PLT_ENTRY_SIZE,
2263 { 12, MINUS_ONE, 16, FALSE },
2264 FDPIC_PLT_LAZY_OFFSET,
2265 &fdpic_sh2a_short_plt_le
2269 /* Return the type of PLT associated with ABFD. PIC_P is true if
2270 the object is position-independent. */
2272 static const struct elf_sh_plt_info *
2273 get_plt_info (bfd *abfd, bfd_boolean pic_p)
2275 if (fdpic_object_p (abfd))
2277 /* If any input file requires SH2A we can use a shorter PLT
2279 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd)) & arch_sh2a_base)
2280 return &fdpic_sh2a_plts[!bfd_big_endian (abfd)];
2282 return &fdpic_sh_plts[!bfd_big_endian (abfd)];
2284 if (vxworks_object_p (abfd))
2285 return &vxworks_sh_plts[pic_p][!bfd_big_endian (abfd)];
2286 return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
2289 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2290 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2294 install_plt_field (bfd *output_bfd, bfd_boolean code_p ATTRIBUTE_UNUSED,
2295 unsigned long value, bfd_byte *addr)
2297 bfd_put_32 (output_bfd, value, addr);
2301 /* The number of PLT entries which can use a shorter PLT, if any.
2302 Currently always 64K, since only SH-2A FDPIC uses this; a
2303 20-bit movi20 can address that many function descriptors below
2304 _GLOBAL_OFFSET_TABLE_. */
2305 #define MAX_SHORT_PLT 65536
2307 /* Return the index of the PLT entry at byte offset OFFSET. */
2310 get_plt_index (const struct elf_sh_plt_info *info, bfd_vma offset)
2312 bfd_vma plt_index = 0;
2314 offset -= info->plt0_entry_size;
2315 if (info->short_plt != NULL)
2317 if (offset > MAX_SHORT_PLT * info->short_plt->symbol_entry_size)
2319 plt_index = MAX_SHORT_PLT;
2320 offset -= MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2323 info = info->short_plt;
2325 return plt_index + offset / info->symbol_entry_size;
2328 /* Do the inverse operation. */
2331 get_plt_offset (const struct elf_sh_plt_info *info, bfd_vma plt_index)
2335 if (info->short_plt != NULL)
2337 if (plt_index > MAX_SHORT_PLT)
2339 offset = MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2340 plt_index -= MAX_SHORT_PLT;
2343 info = info->short_plt;
2345 return (offset + info->plt0_entry_size
2346 + (plt_index * info->symbol_entry_size));
2349 /* The sh linker needs to keep track of the number of relocs that it
2350 decides to copy as dynamic relocs in check_relocs for each symbol.
2351 This is so that it can later discard them if they are found to be
2352 unnecessary. We store the information in a field extending the
2353 regular ELF linker hash table. */
2355 struct elf_sh_dyn_relocs
2357 struct elf_sh_dyn_relocs *next;
2359 /* The input section of the reloc. */
2362 /* Total number of relocs copied for the input section. */
2363 bfd_size_type count;
2365 /* Number of pc-relative relocs copied for the input section. */
2366 bfd_size_type pc_count;
2371 bfd_signed_vma refcount;
2375 /* sh ELF linker hash entry. */
2377 struct elf_sh_link_hash_entry
2379 struct elf_link_hash_entry root;
2381 #ifdef INCLUDE_SHMEDIA
2384 bfd_signed_vma refcount;
2389 /* Track dynamic relocs copied for this symbol. */
2390 struct elf_sh_dyn_relocs *dyn_relocs;
2392 bfd_signed_vma gotplt_refcount;
2394 /* A local function descriptor, for FDPIC. The refcount counts
2395 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2396 relocations; the PLT and GOT entry are accounted
2397 for separately. After adjust_dynamic_symbol, the offset is
2398 MINUS_ONE if there is no local descriptor (dynamic linker
2399 managed and no PLT entry, or undefined weak non-dynamic).
2400 During check_relocs we do not yet know whether the local
2401 descriptor will be canonical. */
2402 union gotref funcdesc;
2404 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2405 and thus require fixups or relocations. */
2406 bfd_signed_vma abs_funcdesc_refcount;
2409 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC
2413 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2415 struct sh_elf_obj_tdata
2417 struct elf_obj_tdata root;
2419 /* got_type for each local got entry. */
2420 char *local_got_type;
2422 /* Function descriptor refcount and offset for each local symbol. */
2423 union gotref *local_funcdesc;
2426 #define sh_elf_tdata(abfd) \
2427 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2429 #define sh_elf_local_got_type(abfd) \
2430 (sh_elf_tdata (abfd)->local_got_type)
2432 #define sh_elf_local_funcdesc(abfd) \
2433 (sh_elf_tdata (abfd)->local_funcdesc)
2435 #define is_sh_elf(bfd) \
2436 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2437 && elf_tdata (bfd) != NULL \
2438 && elf_object_id (bfd) == SH_ELF_DATA)
2440 /* Override the generic function because we need to store sh_elf_obj_tdata
2441 as the specific tdata. */
2444 sh_elf_mkobject (bfd *abfd)
2446 return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata),
2450 /* sh ELF linker hash table. */
2452 struct elf_sh_link_hash_table
2454 struct elf_link_hash_table root;
2456 /* Short-cuts to get to dynamic linker sections. */
2464 asection *sfuncdesc;
2465 asection *srelfuncdesc;
2468 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2471 /* Small local sym cache. */
2472 struct sym_cache sym_cache;
2474 /* A counter or offset to track a TLS got entry. */
2477 bfd_signed_vma refcount;
2481 /* The type of PLT to use. */
2482 const struct elf_sh_plt_info *plt_info;
2484 /* True if the target system is VxWorks. */
2485 bfd_boolean vxworks_p;
2487 /* True if the target system uses FDPIC. */
2488 bfd_boolean fdpic_p;
2491 /* Traverse an sh ELF linker hash table. */
2493 #define sh_elf_link_hash_traverse(table, func, info) \
2494 (elf_link_hash_traverse \
2496 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2499 /* Get the sh ELF linker hash table from a link_info structure. */
2501 #define sh_elf_hash_table(p) \
2502 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2503 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2505 /* Create an entry in an sh ELF linker hash table. */
2507 static struct bfd_hash_entry *
2508 sh_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2509 struct bfd_hash_table *table,
2512 struct elf_sh_link_hash_entry *ret =
2513 (struct elf_sh_link_hash_entry *) entry;
2515 /* Allocate the structure if it has not already been allocated by a
2517 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2518 ret = ((struct elf_sh_link_hash_entry *)
2519 bfd_hash_allocate (table,
2520 sizeof (struct elf_sh_link_hash_entry)));
2521 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2522 return (struct bfd_hash_entry *) ret;
2524 /* Call the allocation method of the superclass. */
2525 ret = ((struct elf_sh_link_hash_entry *)
2526 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2528 if (ret != (struct elf_sh_link_hash_entry *) NULL)
2530 ret->dyn_relocs = NULL;
2531 ret->gotplt_refcount = 0;
2532 #ifdef INCLUDE_SHMEDIA
2533 ret->datalabel_got.refcount = ret->root.got.refcount;
2535 ret->funcdesc.refcount = 0;
2536 ret->abs_funcdesc_refcount = 0;
2537 ret->got_type = GOT_UNKNOWN;
2540 return (struct bfd_hash_entry *) ret;
2543 /* Create an sh ELF linker hash table. */
2545 static struct bfd_link_hash_table *
2546 sh_elf_link_hash_table_create (bfd *abfd)
2548 struct elf_sh_link_hash_table *ret;
2549 bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
2551 ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
2552 if (ret == (struct elf_sh_link_hash_table *) NULL)
2555 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
2556 sh_elf_link_hash_newfunc,
2557 sizeof (struct elf_sh_link_hash_entry),
2565 ret->sgotplt = NULL;
2566 ret->srelgot = NULL;
2568 ret->srelplt = NULL;
2569 ret->sdynbss = NULL;
2570 ret->srelbss = NULL;
2571 ret->srelplt2 = NULL;
2572 ret->sym_cache.abfd = NULL;
2573 ret->tls_ldm_got.refcount = 0;
2574 ret->plt_info = NULL;
2575 ret->vxworks_p = vxworks_object_p (abfd);
2576 ret->fdpic_p = fdpic_object_p (abfd);
2578 return &ret->root.root;
2582 sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2583 struct bfd_link_info *info, asection *p)
2585 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
2587 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2591 /* We need dynamic symbols for every section, since segments can
2592 relocate independently. */
2593 switch (elf_section_data (p)->this_hdr.sh_type)
2597 /* If sh_type is yet undecided, assume it could be
2598 SHT_PROGBITS/SHT_NOBITS. */
2602 /* There shouldn't be section relative relocations
2603 against any other section. */
2609 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2610 shortcuts to them in our hash table. */
2613 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2615 struct elf_sh_link_hash_table *htab;
2617 if (! _bfd_elf_create_got_section (dynobj, info))
2620 htab = sh_elf_hash_table (info);
2624 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2625 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2626 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2627 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
2630 htab->sfuncdesc = bfd_make_section_with_flags (dynobj, ".got.funcdesc",
2631 (SEC_ALLOC | SEC_LOAD
2634 | SEC_LINKER_CREATED));
2635 if (htab->sfuncdesc == NULL
2636 || ! bfd_set_section_alignment (dynobj, htab->sfuncdesc, 2))
2639 htab->srelfuncdesc = bfd_make_section_with_flags (dynobj,
2640 ".rela.got.funcdesc",
2641 (SEC_ALLOC | SEC_LOAD
2644 | SEC_LINKER_CREATED
2646 if (htab->srelfuncdesc == NULL
2647 || ! bfd_set_section_alignment (dynobj, htab->srelfuncdesc, 2))
2650 /* Also create .rofixup. */
2651 htab->srofixup = bfd_make_section_with_flags (dynobj, ".rofixup",
2652 (SEC_ALLOC | SEC_LOAD
2655 | SEC_LINKER_CREATED
2657 if (htab->srofixup == NULL
2658 || ! bfd_set_section_alignment (dynobj, htab->srofixup, 2))
2664 /* Create dynamic sections when linking against a dynamic object. */
2667 sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2669 struct elf_sh_link_hash_table *htab;
2670 flagword flags, pltflags;
2672 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2675 switch (bed->s->arch_size)
2686 bfd_set_error (bfd_error_bad_value);
2690 htab = sh_elf_hash_table (info);
2694 if (htab->root.dynamic_sections_created)
2697 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2698 .rel[a].bss sections. */
2700 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2701 | SEC_LINKER_CREATED);
2704 pltflags |= SEC_CODE;
2705 if (bed->plt_not_loaded)
2706 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2707 if (bed->plt_readonly)
2708 pltflags |= SEC_READONLY;
2710 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
2713 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2716 if (bed->want_plt_sym)
2718 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2720 struct elf_link_hash_entry *h;
2721 struct bfd_link_hash_entry *bh = NULL;
2723 if (! (_bfd_generic_link_add_one_symbol
2724 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2725 (bfd_vma) 0, (const char *) NULL, FALSE,
2726 get_elf_backend_data (abfd)->collect, &bh)))
2729 h = (struct elf_link_hash_entry *) bh;
2731 h->type = STT_OBJECT;
2732 htab->root.hplt = h;
2735 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2739 s = bfd_make_section_with_flags (abfd,
2740 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
2741 flags | SEC_READONLY);
2744 || ! bfd_set_section_alignment (abfd, s, ptralign))
2747 if (htab->sgot == NULL
2748 && !create_got_section (abfd, info))
2752 const char *secname;
2757 for (sec = abfd->sections; sec; sec = sec->next)
2759 secflags = bfd_get_section_flags (abfd, sec);
2760 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2761 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2763 secname = bfd_get_section_name (abfd, sec);
2764 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
2765 strcpy (relname, ".rela");
2766 strcat (relname, secname);
2767 if (bfd_get_section_by_name (abfd, secname))
2769 s = bfd_make_section_with_flags (abfd, relname,
2770 flags | SEC_READONLY);
2772 || ! bfd_set_section_alignment (abfd, s, ptralign))
2777 if (bed->want_dynbss)
2779 /* The .dynbss section is a place to put symbols which are defined
2780 by dynamic objects, are referenced by regular objects, and are
2781 not functions. We must allocate space for them in the process
2782 image and use a R_*_COPY reloc to tell the dynamic linker to
2783 initialize them at run time. The linker script puts the .dynbss
2784 section into the .bss section of the final image. */
2785 s = bfd_make_section_with_flags (abfd, ".dynbss",
2786 SEC_ALLOC | SEC_LINKER_CREATED);
2791 /* The .rel[a].bss section holds copy relocs. This section is not
2792 normally needed. We need to create it here, though, so that the
2793 linker will map it to an output section. We can't just create it
2794 only if we need it, because we will not know whether we need it
2795 until we have seen all the input files, and the first time the
2796 main linker code calls BFD after examining all the input files
2797 (size_dynamic_sections) the input sections have already been
2798 mapped to the output sections. If the section turns out not to
2799 be needed, we can discard it later. We will never need this
2800 section when generating a shared object, since they do not use
2804 s = bfd_make_section_with_flags (abfd,
2805 (bed->default_use_rela_p
2806 ? ".rela.bss" : ".rel.bss"),
2807 flags | SEC_READONLY);
2810 || ! bfd_set_section_alignment (abfd, s, ptralign))
2815 if (htab->vxworks_p)
2817 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2824 /* Adjust a symbol defined by a dynamic object and referenced by a
2825 regular object. The current definition is in some section of the
2826 dynamic object, but we're not including those sections. We have to
2827 change the definition to something the rest of the link can
2831 sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2832 struct elf_link_hash_entry *h)
2834 struct elf_sh_link_hash_table *htab;
2835 struct elf_sh_link_hash_entry *eh;
2836 struct elf_sh_dyn_relocs *p;
2839 htab = sh_elf_hash_table (info);
2843 /* Make sure we know what is going on here. */
2844 BFD_ASSERT (htab->root.dynobj != NULL
2846 || h->u.weakdef != NULL
2849 && !h->def_regular)));
2851 /* If this is a function, put it in the procedure linkage table. We
2852 will fill in the contents of the procedure linkage table later,
2853 when we know the address of the .got section. */
2854 if (h->type == STT_FUNC
2857 if (h->plt.refcount <= 0
2858 || SYMBOL_CALLS_LOCAL (info, h)
2859 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2860 && h->root.type == bfd_link_hash_undefweak))
2862 /* This case can occur if we saw a PLT reloc in an input
2863 file, but the symbol was never referred to by a dynamic
2864 object. In such a case, we don't actually need to build
2865 a procedure linkage table, and we can just do a REL32
2867 h->plt.offset = (bfd_vma) -1;
2874 h->plt.offset = (bfd_vma) -1;
2876 /* If this is a weak symbol, and there is a real definition, the
2877 processor independent code will have arranged for us to see the
2878 real definition first, and we can just use the same value. */
2879 if (h->u.weakdef != NULL)
2881 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2882 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2883 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2884 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2885 if (info->nocopyreloc)
2886 h->non_got_ref = h->u.weakdef->non_got_ref;
2890 /* This is a reference to a symbol defined by a dynamic object which
2891 is not a function. */
2893 /* If we are creating a shared library, we must presume that the
2894 only references to the symbol are via the global offset table.
2895 For such cases we need not do anything here; the relocations will
2896 be handled correctly by relocate_section. */
2900 /* If there are no references to this symbol that do not use the
2901 GOT, we don't need to generate a copy reloc. */
2902 if (!h->non_got_ref)
2905 /* If -z nocopyreloc was given, we won't generate them either. */
2906 if (info->nocopyreloc)
2912 eh = (struct elf_sh_link_hash_entry *) h;
2913 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2915 s = p->sec->output_section;
2916 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
2920 /* If we didn't find any dynamic relocs in sections which needs the
2921 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2931 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2932 h->root.root.string);
2936 /* We must allocate the symbol in our .dynbss section, which will
2937 become part of the .bss section of the executable. There will be
2938 an entry for this symbol in the .dynsym section. The dynamic
2939 object will contain position independent code, so all references
2940 from the dynamic object to this symbol will go through the global
2941 offset table. The dynamic linker will use the .dynsym entry to
2942 determine the address it must put in the global offset table, so
2943 both the dynamic object and the regular object will refer to the
2944 same memory location for the variable. */
2947 BFD_ASSERT (s != NULL);
2949 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2950 copy the initial value out of the dynamic object and into the
2951 runtime process image. We need to remember the offset into the
2952 .rela.bss section we are going to use. */
2953 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2957 srel = htab->srelbss;
2958 BFD_ASSERT (srel != NULL);
2959 srel->size += sizeof (Elf32_External_Rela);
2963 return _bfd_elf_adjust_dynamic_copy (h, s);
2966 /* Allocate space in .plt, .got and associated reloc sections for
2970 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2972 struct bfd_link_info *info;
2973 struct elf_sh_link_hash_table *htab;
2974 struct elf_sh_link_hash_entry *eh;
2975 struct elf_sh_dyn_relocs *p;
2977 if (h->root.type == bfd_link_hash_indirect)
2980 if (h->root.type == bfd_link_hash_warning)
2981 /* When warning symbols are created, they **replace** the "real"
2982 entry in the hash table, thus we never get to see the real
2983 symbol in a hash traversal. So look at it now. */
2984 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2986 info = (struct bfd_link_info *) inf;
2987 htab = sh_elf_hash_table (info);
2991 eh = (struct elf_sh_link_hash_entry *) h;
2992 if ((h->got.refcount > 0
2994 && eh->gotplt_refcount > 0)
2996 /* The symbol has been forced local, or we have some direct got refs,
2997 so treat all the gotplt refs as got refs. */
2998 h->got.refcount += eh->gotplt_refcount;
2999 if (h->plt.refcount >= eh->gotplt_refcount)
3000 h->plt.refcount -= eh->gotplt_refcount;
3003 if (htab->root.dynamic_sections_created
3004 && h->plt.refcount > 0
3005 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3006 || h->root.type != bfd_link_hash_undefweak))
3008 /* Make sure this symbol is output as a dynamic symbol.
3009 Undefined weak syms won't yet be marked as dynamic. */
3010 if (h->dynindx == -1
3011 && !h->forced_local)
3013 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3018 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3020 asection *s = htab->splt;
3021 const struct elf_sh_plt_info *plt_info;
3023 /* If this is the first .plt entry, make room for the special
3026 s->size += htab->plt_info->plt0_entry_size;
3028 h->plt.offset = s->size;
3030 /* If this symbol is not defined in a regular file, and we are
3031 not generating a shared library, then set the symbol to this
3032 location in the .plt. This is required to make function
3033 pointers compare as equal between the normal executable and
3034 the shared library. Skip this for FDPIC, since the
3035 function's address will be the address of the canonical
3036 function descriptor. */
3037 if (!htab->fdpic_p && !info->shared && !h->def_regular)
3039 h->root.u.def.section = s;
3040 h->root.u.def.value = h->plt.offset;
3043 /* Make room for this entry. */
3044 plt_info = htab->plt_info;
3045 if (plt_info->short_plt != NULL
3046 && (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT))
3047 plt_info = plt_info->short_plt;
3048 s->size += plt_info->symbol_entry_size;
3050 /* We also need to make an entry in the .got.plt section, which
3051 will be placed in the .got section by the linker script. */
3053 htab->sgotplt->size += 4;
3055 htab->sgotplt->size += 8;
3057 /* We also need to make an entry in the .rel.plt section. */
3058 htab->srelplt->size += sizeof (Elf32_External_Rela);
3060 if (htab->vxworks_p && !info->shared)
3062 /* VxWorks executables have a second set of relocations
3063 for each PLT entry. They go in a separate relocation
3064 section, which is processed by the kernel loader. */
3066 /* There is a relocation for the initial PLT entry:
3067 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3068 if (h->plt.offset == htab->plt_info->plt0_entry_size)
3069 htab->srelplt2->size += sizeof (Elf32_External_Rela);
3071 /* There are two extra relocations for each subsequent
3072 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3073 and an R_SH_DIR32 relocation for the PLT entry. */
3074 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2;
3079 h->plt.offset = (bfd_vma) -1;
3085 h->plt.offset = (bfd_vma) -1;
3089 if (h->got.refcount > 0)
3093 int got_type = sh_elf_hash_entry (h)->got_type;
3095 /* Make sure this symbol is output as a dynamic symbol.
3096 Undefined weak syms won't yet be marked as dynamic. */
3097 if (h->dynindx == -1
3098 && !h->forced_local)
3100 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3105 h->got.offset = s->size;
3107 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3108 if (got_type == GOT_TLS_GD)
3110 dyn = htab->root.dynamic_sections_created;
3113 /* No dynamic relocations required. */
3114 if (htab->fdpic_p && !info->shared
3115 && h->root.type != bfd_link_hash_undefweak
3116 && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
3117 htab->srofixup->size += 4;
3119 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3120 R_SH_TLS_GD needs one if local symbol and two if global. */
3121 else if ((got_type == GOT_TLS_GD && h->dynindx == -1)
3122 || got_type == GOT_TLS_IE)
3123 htab->srelgot->size += sizeof (Elf32_External_Rela);
3124 else if (got_type == GOT_TLS_GD)
3125 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
3126 else if (got_type == GOT_FUNCDESC)
3128 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
3129 htab->srofixup->size += 4;
3131 htab->srelgot->size += sizeof (Elf32_External_Rela);
3133 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3134 || h->root.type != bfd_link_hash_undefweak)
3136 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3137 htab->srelgot->size += sizeof (Elf32_External_Rela);
3138 else if (htab->fdpic_p && !info->shared && got_type == GOT_NORMAL
3139 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3140 || h->root.type != bfd_link_hash_undefweak))
3141 htab->srofixup->size += 4;
3144 h->got.offset = (bfd_vma) -1;
3146 #ifdef INCLUDE_SHMEDIA
3147 if (eh->datalabel_got.refcount > 0)
3152 /* Make sure this symbol is output as a dynamic symbol.
3153 Undefined weak syms won't yet be marked as dynamic. */
3154 if (h->dynindx == -1
3155 && !h->forced_local)
3157 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3162 eh->datalabel_got.offset = s->size;
3164 dyn = htab->root.dynamic_sections_created;
3165 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
3166 htab->srelgot->size += sizeof (Elf32_External_Rela);
3169 eh->datalabel_got.offset = (bfd_vma) -1;
3172 /* Allocate space for any dynamic relocations to function
3173 descriptors, canonical or otherwise. We need to relocate the
3174 reference unless it resolves to zero, which only happens for
3175 undefined weak symbols (either non-default visibility, or when
3176 static linking). Any GOT slot is accounted for elsewhere. */
3177 if (eh->abs_funcdesc_refcount > 0
3178 && (h->root.type != bfd_link_hash_undefweak
3179 || (htab->root.dynamic_sections_created
3180 && ! SYMBOL_CALLS_LOCAL (info, h))))
3182 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
3183 htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
3186 += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
3189 /* We must allocate a function descriptor if there are references to
3190 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3191 the dynamic linker isn't going to allocate it. None of this
3192 applies if we already created one in .got.plt, but if the
3193 canonical function descriptor can be in this object, there
3194 won't be a PLT entry at all. */
3195 if ((eh->funcdesc.refcount > 0
3196 || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC))
3197 && h->root.type != bfd_link_hash_undefweak
3198 && SYMBOL_FUNCDESC_LOCAL (info, h))
3200 /* Make room for this function descriptor. */
3201 eh->funcdesc.offset = htab->sfuncdesc->size;
3202 htab->sfuncdesc->size += 8;
3204 /* We will need a relocation or two fixups to initialize the
3205 function descriptor, so allocate those too. */
3206 if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
3207 htab->srofixup->size += 8;
3209 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3212 if (eh->dyn_relocs == NULL)
3215 /* In the shared -Bsymbolic case, discard space allocated for
3216 dynamic pc-relative relocs against symbols which turn out to be
3217 defined in regular objects. For the normal shared case, discard
3218 space for pc-relative relocs that have become local due to symbol
3219 visibility changes. */
3223 if (SYMBOL_CALLS_LOCAL (info, h))
3225 struct elf_sh_dyn_relocs **pp;
3227 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3229 p->count -= p->pc_count;
3238 if (htab->vxworks_p)
3240 struct elf_sh_dyn_relocs **pp;
3242 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3244 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
3251 /* Also discard relocs on undefined weak syms with non-default
3253 if (eh->dyn_relocs != NULL
3254 && h->root.type == bfd_link_hash_undefweak)
3256 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3257 eh->dyn_relocs = NULL;
3259 /* Make sure undefined weak symbols are output as a dynamic
3261 else if (h->dynindx == -1
3262 && !h->forced_local)
3264 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3271 /* For the non-shared case, discard space for relocs against
3272 symbols which turn out to need copy relocs or are not
3278 || (htab->root.dynamic_sections_created
3279 && (h->root.type == bfd_link_hash_undefweak
3280 || h->root.type == bfd_link_hash_undefined))))
3282 /* Make sure this symbol is output as a dynamic symbol.
3283 Undefined weak syms won't yet be marked as dynamic. */
3284 if (h->dynindx == -1
3285 && !h->forced_local)
3287 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3291 /* If that succeeded, we know we'll be keeping all the
3293 if (h->dynindx != -1)
3297 eh->dyn_relocs = NULL;
3302 /* Finally, allocate space. */
3303 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3305 asection *sreloc = elf_section_data (p->sec)->sreloc;
3306 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3308 /* If we need relocations, we do not need fixups. */
3309 if (htab->fdpic_p && !info->shared)
3310 htab->srofixup->size -= 4 * (p->count - p->pc_count);
3316 /* Find any dynamic relocs that apply to read-only sections. */
3319 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3321 struct elf_sh_link_hash_entry *eh;
3322 struct elf_sh_dyn_relocs *p;
3324 if (h->root.type == bfd_link_hash_warning)
3325 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3327 eh = (struct elf_sh_link_hash_entry *) h;
3328 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3330 asection *s = p->sec->output_section;
3332 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3334 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3336 info->flags |= DF_TEXTREL;
3338 /* Not an error, just cut short the traversal. */
3345 /* This function is called after all the input files have been read,
3346 and the input sections have been assigned to output sections.
3347 It's a convenient place to determine the PLT style. */
3350 sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3352 sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd, info->shared);
3354 if (sh_elf_hash_table (info)->fdpic_p && !info->relocatable)
3356 struct elf_link_hash_entry *h;
3358 /* Force a PT_GNU_STACK segment to be created. */
3359 if (! elf_tdata (output_bfd)->stack_flags)
3360 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
3362 /* Define __stacksize if it's not defined yet. */
3363 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3364 FALSE, FALSE, FALSE);
3365 if (! h || h->root.type != bfd_link_hash_defined
3366 || h->type != STT_OBJECT
3369 struct bfd_link_hash_entry *bh = NULL;
3371 if (!(_bfd_generic_link_add_one_symbol
3372 (info, output_bfd, "__stacksize",
3373 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
3374 (const char *) NULL, FALSE,
3375 get_elf_backend_data (output_bfd)->collect, &bh)))
3378 h = (struct elf_link_hash_entry *) bh;
3380 h->type = STT_OBJECT;
3386 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
3389 sh_elf_modify_program_headers (bfd *output_bfd, struct bfd_link_info *info)
3391 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
3392 struct elf_segment_map *m;
3393 Elf_Internal_Phdr *p;
3395 /* objcopy and strip preserve what's already there using
3396 sh_elf_copy_private_bfd_data (). */
3400 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
3401 if (m->p_type == PT_GNU_STACK)
3406 struct elf_link_hash_entry *h;
3408 /* Obtain the pointer to the __stacksize symbol. */
3409 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3410 FALSE, FALSE, FALSE);
3413 while (h->root.type == bfd_link_hash_indirect
3414 || h->root.type == bfd_link_hash_warning)
3415 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3416 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
3419 /* Set the header p_memsz from the symbol value. We
3420 intentionally ignore the symbol section. */
3421 if (h && h->root.type == bfd_link_hash_defined)
3422 p->p_memsz = h->root.u.def.value;
3424 p->p_memsz = DEFAULT_STACK_SIZE;
3434 /* Set the sizes of the dynamic sections. */
3437 sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3438 struct bfd_link_info *info)
3440 struct elf_sh_link_hash_table *htab;
3446 htab = sh_elf_hash_table (info);
3450 dynobj = htab->root.dynobj;
3451 BFD_ASSERT (dynobj != NULL);
3453 if (htab->root.dynamic_sections_created)
3455 /* Set the contents of the .interp section to the interpreter. */
3456 if (info->executable)
3458 s = bfd_get_section_by_name (dynobj, ".interp");
3459 BFD_ASSERT (s != NULL);
3460 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3461 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3465 /* Set up .got offsets for local syms, and space for local dynamic
3467 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3469 bfd_signed_vma *local_got;
3470 bfd_signed_vma *end_local_got;
3471 union gotref *local_funcdesc, *end_local_funcdesc;
3472 char *local_got_type;
3473 bfd_size_type locsymcount;
3474 Elf_Internal_Shdr *symtab_hdr;
3477 if (! is_sh_elf (ibfd))
3480 for (s = ibfd->sections; s != NULL; s = s->next)
3482 struct elf_sh_dyn_relocs *p;
3484 for (p = ((struct elf_sh_dyn_relocs *)
3485 elf_section_data (s)->local_dynrel);
3489 if (! bfd_is_abs_section (p->sec)
3490 && bfd_is_abs_section (p->sec->output_section))
3492 /* Input section has been discarded, either because
3493 it is a copy of a linkonce section or due to
3494 linker script /DISCARD/, so we'll be discarding
3497 else if (htab->vxworks_p
3498 && strcmp (p->sec->output_section->name,
3501 /* Relocations in vxworks .tls_vars sections are
3502 handled specially by the loader. */
3504 else if (p->count != 0)
3506 srel = elf_section_data (p->sec)->sreloc;
3507 srel->size += p->count * sizeof (Elf32_External_Rela);
3508 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3509 info->flags |= DF_TEXTREL;
3511 /* If we need relocations, we do not need fixups. */
3512 if (htab->fdpic_p && !info->shared)
3513 htab->srofixup->size -= 4 * (p->count - p->pc_count);
3518 symtab_hdr = &elf_symtab_hdr (ibfd);
3519 locsymcount = symtab_hdr->sh_info;
3520 #ifdef INCLUDE_SHMEDIA
3521 /* Count datalabel local GOT. */
3525 srel = htab->srelgot;
3527 local_got = elf_local_got_refcounts (ibfd);
3530 end_local_got = local_got + locsymcount;
3531 local_got_type = sh_elf_local_got_type (ibfd);
3532 local_funcdesc = sh_elf_local_funcdesc (ibfd);
3533 for (; local_got < end_local_got; ++local_got)
3537 *local_got = s->size;
3539 if (*local_got_type == GOT_TLS_GD)
3542 srel->size += sizeof (Elf32_External_Rela);
3544 htab->srofixup->size += 4;
3546 if (*local_got_type == GOT_FUNCDESC)
3548 if (local_funcdesc == NULL)
3552 size = locsymcount * sizeof (union gotref);
3553 local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
3555 if (local_funcdesc == NULL)
3557 sh_elf_local_funcdesc (ibfd) = local_funcdesc;
3558 local_funcdesc += (local_got
3559 - elf_local_got_refcounts (ibfd));
3561 local_funcdesc->refcount++;
3566 *local_got = (bfd_vma) -1;
3571 local_funcdesc = sh_elf_local_funcdesc (ibfd);
3574 end_local_funcdesc = local_funcdesc + locsymcount;
3576 for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc)
3578 if (local_funcdesc->refcount > 0)
3580 local_funcdesc->offset = htab->sfuncdesc->size;
3581 htab->sfuncdesc->size += 8;
3583 htab->srofixup->size += 8;
3585 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3588 local_funcdesc->offset = MINUS_ONE;
3594 if (htab->tls_ldm_got.refcount > 0)
3596 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3598 htab->tls_ldm_got.offset = htab->sgot->size;
3599 htab->sgot->size += 8;
3600 htab->srelgot->size += sizeof (Elf32_External_Rela);
3603 htab->tls_ldm_got.offset = -1;
3605 /* Only the reserved entries should be present. For FDPIC, they go at
3606 the end of .got.plt. */
3609 BFD_ASSERT (htab->sgotplt && htab->sgotplt->size == 12);
3610 htab->sgotplt->size = 0;
3613 /* Allocate global sym .plt and .got entries, and space for global
3614 sym dynamic relocs. */
3615 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
3617 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3618 end of the FDPIC .got.plt. */
3621 htab->root.hgot->root.u.def.value = htab->sgotplt->size;
3622 htab->sgotplt->size += 12;
3625 /* At the very end of the .rofixup section is a pointer to the GOT. */
3626 if (htab->fdpic_p && htab->srofixup != NULL)
3627 htab->srofixup->size += 4;
3629 /* We now have determined the sizes of the various dynamic sections.
3630 Allocate memory for them. */
3632 for (s = dynobj->sections; s != NULL; s = s->next)
3634 if ((s->flags & SEC_LINKER_CREATED) == 0)
3639 || s == htab->sgotplt
3640 || s == htab->sfuncdesc
3641 || s == htab->srofixup
3642 || s == htab->sdynbss)
3644 /* Strip this section if we don't need it; see the
3647 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3649 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
3652 /* We use the reloc_count field as a counter if we need
3653 to copy relocs into the output file. */
3658 /* It's not one of our sections, so don't allocate space. */
3664 /* If we don't need this section, strip it from the
3665 output file. This is mostly to handle .rela.bss and
3666 .rela.plt. We must create both sections in
3667 create_dynamic_sections, because they must be created
3668 before the linker maps input sections to output
3669 sections. The linker does that before
3670 adjust_dynamic_symbol is called, and it is that
3671 function which decides whether anything needs to go
3672 into these sections. */
3674 s->flags |= SEC_EXCLUDE;
3678 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3681 /* Allocate memory for the section contents. We use bfd_zalloc
3682 here in case unused entries are not reclaimed before the
3683 section's contents are written out. This should not happen,
3684 but this way if it does, we get a R_SH_NONE reloc instead
3686 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3687 if (s->contents == NULL)
3691 if (htab->root.dynamic_sections_created)
3693 /* Add some entries to the .dynamic section. We fill in the
3694 values later, in sh_elf_finish_dynamic_sections, but we
3695 must add the entries now so that we get the correct size for
3696 the .dynamic section. The DT_DEBUG entry is filled in by the
3697 dynamic linker and used by the debugger. */
3698 #define add_dynamic_entry(TAG, VAL) \
3699 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3701 if (info->executable)
3703 if (! add_dynamic_entry (DT_DEBUG, 0))
3707 if (htab->splt->size != 0)
3709 if (! add_dynamic_entry (DT_PLTGOT, 0)
3710 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
3711 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
3712 || ! add_dynamic_entry (DT_JMPREL, 0))
3715 else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC)
3716 && htab->sgot->size != 0)
3718 if (! add_dynamic_entry (DT_PLTGOT, 0))
3724 if (! add_dynamic_entry (DT_RELA, 0)
3725 || ! add_dynamic_entry (DT_RELASZ, 0)
3726 || ! add_dynamic_entry (DT_RELAENT,
3727 sizeof (Elf32_External_Rela)))
3730 /* If any dynamic relocs apply to a read-only section,
3731 then we need a DT_TEXTREL entry. */
3732 if ((info->flags & DF_TEXTREL) == 0)
3733 elf_link_hash_traverse (&htab->root, readonly_dynrelocs, info);
3735 if ((info->flags & DF_TEXTREL) != 0)
3737 if (! add_dynamic_entry (DT_TEXTREL, 0))
3742 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3745 #undef add_dynamic_entry
3750 /* Add a dynamic relocation to the SRELOC section. */
3752 inline static bfd_vma
3753 sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
3754 int reloc_type, long dynindx, bfd_vma addend)
3756 Elf_Internal_Rela outrel;
3757 bfd_vma reloc_offset;
3759 outrel.r_offset = offset;
3760 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
3761 outrel.r_addend = addend;
3763 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela);
3764 BFD_ASSERT (reloc_offset < sreloc->size);
3765 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3766 sreloc->contents + reloc_offset);
3767 sreloc->reloc_count++;
3769 return reloc_offset;
3772 /* Add an FDPIC read-only fixup. */
3775 sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset)
3777 bfd_vma fixup_offset;
3779 fixup_offset = srofixup->reloc_count++ * 4;
3780 BFD_ASSERT (fixup_offset < srofixup->size);
3781 bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset);
3784 /* Return the offset of the generated .got section from the
3785 _GLOBAL_OFFSET_TABLE_ symbol. */
3787 static bfd_signed_vma
3788 sh_elf_got_offset (struct elf_sh_link_hash_table *htab)
3790 return (htab->sgot->output_offset - htab->sgotplt->output_offset
3791 - htab->root.hgot->root.u.def.value);
3794 /* Find the segment number in which OSEC, and output section, is
3798 sh_elf_osec_to_segment (bfd *output_bfd, asection *osec)
3800 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd,
3803 /* FIXME: Nothing ever says what this index is relative to. The kernel
3804 supplies data in terms of the number of load segments but this is
3805 a phdr index and the first phdr may not be a load segment. */
3806 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
3810 sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
3812 unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
3814 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
3817 /* Generate the initial contents of a local function descriptor, along
3818 with any relocations or fixups required. */
3820 sh_elf_initialize_funcdesc (bfd *output_bfd,
3821 struct bfd_link_info *info,
3822 struct elf_link_hash_entry *h,
3827 struct elf_sh_link_hash_table *htab;
3831 htab = sh_elf_hash_table (info);
3833 /* FIXME: The ABI says that the offset to the function goes in the
3834 descriptor, along with the segment index. We're RELA, so it could
3835 go in the reloc instead... */
3837 if (h != NULL && SYMBOL_CALLS_LOCAL (info, h))
3839 section = h->root.u.def.section;
3840 value = h->root.u.def.value;
3843 if (h == NULL || SYMBOL_CALLS_LOCAL (info, h))
3845 dynindx = elf_section_data (section->output_section)->dynindx;
3846 addr = value + section->output_offset;
3847 seg = sh_elf_osec_to_segment (output_bfd, section->output_section);
3851 BFD_ASSERT (h->dynindx != -1);
3852 dynindx = h->dynindx;
3856 if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
3858 if (h == NULL || h->root.type != bfd_link_hash_undefweak)
3860 sh_elf_add_rofixup (output_bfd, htab->srofixup,
3862 + htab->sfuncdesc->output_section->vma
3863 + htab->sfuncdesc->output_offset);
3864 sh_elf_add_rofixup (output_bfd, htab->srofixup,
3866 + htab->sfuncdesc->output_section->vma
3867 + htab->sfuncdesc->output_offset);
3870 /* There are no dynamic relocations so fill in the final
3871 address and gp value (barring fixups). */
3872 addr += section->output_section->vma;
3873 seg = htab->root.hgot->root.u.def.value
3874 + htab->root.hgot->root.u.def.section->output_section->vma
3875 + htab->root.hgot->root.u.def.section->output_offset;
3878 sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc,
3880 + htab->sfuncdesc->output_section->vma
3881 + htab->sfuncdesc->output_offset,
3882 R_SH_FUNCDESC_VALUE, dynindx, 0);
3884 bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
3885 bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
3890 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3891 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3894 static bfd_reloc_status_type
3895 install_movi20_field (bfd *output_bfd, unsigned long relocation,
3896 bfd *input_bfd, asection *input_section,
3897 bfd_byte *contents, bfd_vma offset)
3899 unsigned long cur_val;
3901 bfd_reloc_status_type r;
3903 if (offset > bfd_get_section_limit (input_bfd, input_section))
3904 return bfd_reloc_outofrange;
3906 r = bfd_check_overflow (complain_overflow_signed, 20, 0,
3907 bfd_arch_bits_per_address (input_bfd), relocation);
3908 if (r != bfd_reloc_ok)
3911 addr = contents + offset;
3912 cur_val = bfd_get_16 (output_bfd, addr);
3913 bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr);
3914 bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2);
3916 return bfd_reloc_ok;
3919 /* Relocate an SH ELF section. */
3922 sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
3923 bfd *input_bfd, asection *input_section,
3924 bfd_byte *contents, Elf_Internal_Rela *relocs,
3925 Elf_Internal_Sym *local_syms,
3926 asection **local_sections)
3928 struct elf_sh_link_hash_table *htab;
3929 Elf_Internal_Shdr *symtab_hdr;
3930 struct elf_link_hash_entry **sym_hashes;
3931 Elf_Internal_Rela *rel, *relend;
3933 bfd_vma *local_got_offsets;
3939 bfd_boolean is_vxworks_tls;
3940 unsigned isec_segment, got_segment, plt_segment, check_segment[2];
3942 BFD_ASSERT (is_sh_elf (input_bfd));
3944 htab = sh_elf_hash_table (info);
3947 symtab_hdr = &elf_symtab_hdr (input_bfd);
3948 sym_hashes = elf_sym_hashes (input_bfd);
3949 dynobj = htab->root.dynobj;
3950 local_got_offsets = elf_local_got_offsets (input_bfd);
3952 isec_segment = sh_elf_osec_to_segment (output_bfd,
3953 input_section->output_section);
3954 if (htab->fdpic_p && htab->sgot)
3955 got_segment = sh_elf_osec_to_segment (output_bfd,
3956 htab->sgot->output_section);
3959 if (htab->fdpic_p && htab->splt)
3960 plt_segment = sh_elf_osec_to_segment (output_bfd,
3961 htab->splt->output_section);
3966 sgotplt = htab->sgotplt;
3970 /* We have to handle relocations in vxworks .tls_vars sections
3971 specially, because the dynamic loader is 'weird'. */
3972 is_vxworks_tls = (htab->vxworks_p && info->shared
3973 && !strcmp (input_section->output_section->name,
3977 relend = relocs + input_section->reloc_count;
3978 for (; rel < relend; rel++)
3981 reloc_howto_type *howto;
3982 unsigned long r_symndx;
3983 Elf_Internal_Sym *sym;
3985 struct elf_link_hash_entry *h;
3987 bfd_vma addend = (bfd_vma) 0;
3988 bfd_reloc_status_type r;
3989 int seen_stt_datalabel = 0;
3992 const char *symname = NULL;
3994 r_symndx = ELF32_R_SYM (rel->r_info);
3996 r_type = ELF32_R_TYPE (rel->r_info);
3998 /* Many of the relocs are only used for relaxing, and are
3999 handled entirely by the relaxation code. */
4000 if (r_type >= (int) R_SH_GNU_VTINHERIT
4001 && r_type <= (int) R_SH_LABEL)
4003 if (r_type == (int) R_SH_NONE)
4007 || r_type >= R_SH_max
4008 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
4009 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
4010 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
4011 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2)
4012 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
4013 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
4014 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
4015 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
4016 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
4017 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
4018 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_6
4019 && r_type <= (int) R_SH_LAST_INVALID_RELOC_6))
4021 bfd_set_error (bfd_error_bad_value);
4025 howto = get_howto_table (output_bfd) + r_type;
4027 /* For relocs that aren't partial_inplace, we get the addend from
4029 if (! howto->partial_inplace)
4030 addend = rel->r_addend;
4035 check_segment[0] = -1;
4036 check_segment[1] = -1;
4037 if (r_symndx < symtab_hdr->sh_info)
4039 sym = local_syms + r_symndx;
4040 sec = local_sections[r_symndx];
4042 symname = bfd_elf_string_from_elf_section
4043 (input_bfd, symtab_hdr->sh_link, sym->st_name);
4044 if (symname == NULL || *symname == '\0')
4045 symname = bfd_section_name (input_bfd, sec);
4047 relocation = (sec->output_section->vma
4048 + sec->output_offset
4050 /* A local symbol never has STO_SH5_ISA32, so we don't need
4051 datalabel processing here. Make sure this does not change
4053 if ((sym->st_other & STO_SH5_ISA32) != 0)
4054 ((*info->callbacks->reloc_dangerous)
4056 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4057 input_bfd, input_section, rel->r_offset));
4059 if (sec != NULL && elf_discarded_section (sec))
4060 /* Handled below. */
4062 else if (info->relocatable)
4064 /* This is a relocatable link. We don't have to change
4065 anything, unless the reloc is against a section symbol,
4066 in which case we have to adjust according to where the
4067 section symbol winds up in the output section. */
4068 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4070 if (! howto->partial_inplace)
4072 /* For relocations with the addend in the
4073 relocation, we need just to update the addend.
4074 All real relocs are of type partial_inplace; this
4075 code is mostly for completeness. */
4076 rel->r_addend += sec->output_offset;
4081 /* Relocs of type partial_inplace need to pick up the
4082 contents in the contents and add the offset resulting
4083 from the changed location of the section symbol.
4084 Using _bfd_final_link_relocate (e.g. goto
4085 final_link_relocate) here would be wrong, because
4086 relocations marked pc_relative would get the current
4087 location subtracted, and we must only do that at the
4089 r = _bfd_relocate_contents (howto, input_bfd,
4092 contents + rel->r_offset);
4093 goto relocation_done;
4098 else if (! howto->partial_inplace)
4100 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4101 addend = rel->r_addend;
4103 else if ((sec->flags & SEC_MERGE)
4104 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4108 if (howto->rightshift || howto->src_mask != 0xffffffff)
4110 (*_bfd_error_handler)
4111 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4112 input_bfd, input_section,
4113 (long) rel->r_offset, howto->name);
4117 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4120 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4122 addend += msec->output_section->vma + msec->output_offset;
4123 bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4129 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4132 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4133 symname = h->root.root.string;
4134 while (h->root.type == bfd_link_hash_indirect
4135 || h->root.type == bfd_link_hash_warning)
4137 #ifdef INCLUDE_SHMEDIA
4138 /* If the reference passes a symbol marked with
4139 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4141 seen_stt_datalabel |= h->type == STT_DATALABEL;
4143 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4145 if (h->root.type == bfd_link_hash_defined
4146 || h->root.type == bfd_link_hash_defweak)
4150 dyn = htab->root.dynamic_sections_created;
4151 sec = h->root.u.def.section;
4152 /* In these cases, we don't need the relocation value.
4153 We check specially because in some obscure cases
4154 sec->output_section will be NULL. */
4155 if (r_type == R_SH_GOTPC
4156 || r_type == R_SH_GOTPC_LOW16
4157 || r_type == R_SH_GOTPC_MEDLOW16
4158 || r_type == R_SH_GOTPC_MEDHI16
4159 || r_type == R_SH_GOTPC_HI16
4160 || ((r_type == R_SH_PLT32
4161 || r_type == R_SH_PLT_LOW16
4162 || r_type == R_SH_PLT_MEDLOW16
4163 || r_type == R_SH_PLT_MEDHI16
4164 || r_type == R_SH_PLT_HI16)
4165 && h->plt.offset != (bfd_vma) -1)
4166 || ((r_type == R_SH_GOT32
4167 || r_type == R_SH_GOT20
4168 || r_type == R_SH_GOTFUNCDESC
4169 || r_type == R_SH_GOTFUNCDESC20
4170 || r_type == R_SH_GOTOFFFUNCDESC
4171 || r_type == R_SH_GOTOFFFUNCDESC20
4172 || r_type == R_SH_FUNCDESC
4173 || r_type == R_SH_GOT_LOW16
4174 || r_type == R_SH_GOT_MEDLOW16
4175 || r_type == R_SH_GOT_MEDHI16
4176 || r_type == R_SH_GOT_HI16)
4177 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4179 || (! info->symbolic && h->dynindx != -1)
4180 || !h->def_regular))
4181 /* The cases above are those in which relocation is
4182 overwritten in the switch block below. The cases
4183 below are those in which we must defer relocation
4184 to run-time, because we can't resolve absolute
4185 addresses when creating a shared library. */
4187 && ((! info->symbolic && h->dynindx != -1)
4189 && ((r_type == R_SH_DIR32
4190 && !h->forced_local)
4191 || (r_type == R_SH_REL32
4192 && !SYMBOL_CALLS_LOCAL (info, h)))
4193 && ((input_section->flags & SEC_ALLOC) != 0
4194 /* DWARF will emit R_SH_DIR32 relocations in its
4195 sections against symbols defined externally
4196 in shared libraries. We can't do anything
4198 || ((input_section->flags & SEC_DEBUGGING) != 0
4199 && h->def_dynamic)))
4200 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4201 sections because such sections are not SEC_ALLOC and
4202 thus ld.so will not process them. */
4203 || (sec->output_section == NULL
4204 && ((input_section->flags & SEC_DEBUGGING) != 0
4206 || (sec->output_section == NULL
4207 && (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE
4208 || sh_elf_hash_entry (h)->got_type == GOT_TLS_GD)))
4210 else if (sec->output_section != NULL)
4211 relocation = ((h->root.u.def.value
4212 + sec->output_section->vma
4213 + sec->output_offset)
4214 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4215 symbol value, unless we've seen
4216 STT_DATALABEL on the way to it. */
4217 | ((h->other & STO_SH5_ISA32) != 0
4218 && ! seen_stt_datalabel));
4219 else if (!info->relocatable)
4221 (*_bfd_error_handler)
4222 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4225 (long) rel->r_offset,
4227 h->root.root.string);
4231 else if (h->root.type == bfd_link_hash_undefweak)
4233 else if (info->unresolved_syms_in_objects == RM_IGNORE
4234 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4236 else if (!info->relocatable)
4238 if (! info->callbacks->undefined_symbol
4239 (info, h->root.root.string, input_bfd,
4240 input_section, rel->r_offset,
4241 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4242 || ELF_ST_VISIBILITY (h->other))))
4247 if (sec != NULL && elf_discarded_section (sec))
4249 /* For relocs against symbols from removed linkonce sections,
4250 or sections discarded by a linker script, we just want the
4251 section contents zeroed. Avoid any special processing. */
4252 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4258 if (info->relocatable)
4261 /* Check for inter-segment relocations in FDPIC files. Most
4262 relocations connect the relocation site to the location of
4263 the target symbol, but there are some exceptions below. */
4264 check_segment[0] = isec_segment;
4266 check_segment[1] = sh_elf_osec_to_segment (output_bfd,
4267 sec->output_section);
4269 check_segment[1] = -1;
4271 switch ((int) r_type)
4273 final_link_relocate:
4274 /* COFF relocs don't use the addend. The addend is used for
4275 R_SH_DIR32 to be compatible with other compilers. */
4276 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4277 contents, rel->r_offset,
4278 relocation, addend);
4282 goto final_link_relocate;
4287 /* If the reloc is against the start of this section, then
4288 the assembler has already taken care of it and the reloc
4289 is here only to assist in relaxing. If the reloc is not
4290 against the start of this section, then it's against an
4291 external symbol and we must deal with it ourselves. */
4292 if (input_section->output_section->vma + input_section->output_offset
4295 int disp = (relocation
4296 - input_section->output_section->vma
4297 - input_section->output_offset
4303 case R_SH_DIR8WPZ: mask = 1; break;
4304 case R_SH_DIR8WPL: mask = 3; break;
4305 default: mask = 0; break;
4309 ((*_bfd_error_handler)
4310 (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4311 input_section->owner,
4312 (unsigned long) rel->r_offset));
4313 bfd_set_error (bfd_error_bad_value);
4317 goto final_link_relocate;
4323 #ifdef INCLUDE_SHMEDIA
4324 if (shmedia_prepare_reloc (info, input_bfd, input_section,
4325 contents, rel, &relocation))
4326 goto final_link_relocate;
4328 bfd_set_error (bfd_error_bad_value);
4336 goto final_link_relocate;
4342 ((*_bfd_error_handler)
4343 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4344 input_section->owner,
4345 (unsigned long) rel->r_offset, howto->name,
4346 (unsigned long) relocation));
4347 bfd_set_error (bfd_error_bad_value);
4350 goto final_link_relocate;
4357 ((*_bfd_error_handler)
4358 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
4359 input_section->owner,
4360 (unsigned long) rel->r_offset, howto->name,
4361 (unsigned long) relocation));
4362 bfd_set_error (bfd_error_bad_value);
4365 goto final_link_relocate;
4368 if ((signed int)relocation < -32
4369 || (signed int)relocation > 32)
4371 ((*_bfd_error_handler)
4372 (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
4373 input_section->owner,
4374 (unsigned long) rel->r_offset,
4375 (unsigned long) relocation));
4376 bfd_set_error (bfd_error_bad_value);
4379 goto final_link_relocate;
4382 if ((signed int)relocation < -16
4383 || (signed int)relocation > 16)
4385 ((*_bfd_error_handler)
4386 (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
4387 input_section->owner,
4388 (unsigned long) rel->r_offset,
4389 (unsigned long) relocation));
4390 bfd_set_error (bfd_error_bad_value);
4393 goto final_link_relocate;
4397 #ifdef INCLUDE_SHMEDIA
4398 case R_SH_IMM_LOW16_PCREL:
4399 case R_SH_IMM_MEDLOW16_PCREL:
4400 case R_SH_IMM_MEDHI16_PCREL:
4401 case R_SH_IMM_HI16_PCREL:
4405 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4406 || h->root.type != bfd_link_hash_undefweak)
4408 && (input_section->flags & SEC_ALLOC) != 0
4410 && (r_type == R_SH_DIR32
4411 || !SYMBOL_CALLS_LOCAL (info, h)))
4413 Elf_Internal_Rela outrel;
4415 bfd_boolean skip, relocate;
4417 /* When generating a shared object, these relocations
4418 are copied into the output file to be resolved at run
4423 sreloc = _bfd_elf_get_dynamic_reloc_section
4424 (input_bfd, input_section, /*rela?*/ TRUE);
4433 _bfd_elf_section_offset (output_bfd, info, input_section,
4435 if (outrel.r_offset == (bfd_vma) -1)
4437 else if (outrel.r_offset == (bfd_vma) -2)
4438 skip = TRUE, relocate = TRUE;
4439 outrel.r_offset += (input_section->output_section->vma
4440 + input_section->output_offset);
4443 memset (&outrel, 0, sizeof outrel);
4444 else if (r_type == R_SH_REL32)
4446 BFD_ASSERT (h != NULL && h->dynindx != -1);
4447 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4449 = (howto->partial_inplace
4450 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4453 #ifdef INCLUDE_SHMEDIA
4454 else if (r_type == R_SH_IMM_LOW16_PCREL
4455 || r_type == R_SH_IMM_MEDLOW16_PCREL
4456 || r_type == R_SH_IMM_MEDHI16_PCREL
4457 || r_type == R_SH_IMM_HI16_PCREL)
4459 BFD_ASSERT (h != NULL && h->dynindx != -1);
4460 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4461 outrel.r_addend = addend;
4464 else if (htab->fdpic_p
4466 || ((info->symbolic || h->dynindx == -1)
4467 && h->def_regular)))
4471 BFD_ASSERT (sec != NULL);
4472 BFD_ASSERT (sec->output_section != NULL);
4473 dynindx = elf_section_data (sec->output_section)->dynindx;
4474 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4475 outrel.r_addend = relocation;
4477 += (howto->partial_inplace
4478 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4480 outrel.r_addend -= sec->output_section->vma;
4484 /* h->dynindx may be -1 if this symbol was marked to
4487 || ((info->symbolic || h->dynindx == -1)
4490 relocate = howto->partial_inplace;
4491 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4495 BFD_ASSERT (h->dynindx != -1);
4496 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4498 outrel.r_addend = relocation;
4500 += (howto->partial_inplace
4501 ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4505 loc = sreloc->contents;
4506 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4507 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4509 check_segment[0] = check_segment[1] = -1;
4511 /* If this reloc is against an external symbol, we do
4512 not want to fiddle with the addend. Otherwise, we
4513 need to include the symbol value so that it becomes
4514 an addend for the dynamic reloc. */
4518 else if (htab->fdpic_p && !info->shared
4519 && r_type == R_SH_DIR32
4520 && (input_section->flags & SEC_ALLOC) != 0)
4524 if (sh_elf_osec_readonly_p (output_bfd,
4525 input_section->output_section))
4527 (*_bfd_error_handler)
4528 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4531 (long) rel->r_offset,
4536 offset = _bfd_elf_section_offset (output_bfd, info,
4537 input_section, rel->r_offset);
4538 if (offset != (bfd_vma)-1)
4539 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4540 input_section->output_section->vma
4541 + input_section->output_offset
4544 check_segment[0] = check_segment[1] = -1;
4546 goto final_link_relocate;
4549 #ifdef INCLUDE_SHMEDIA
4550 case R_SH_GOTPLT_LOW16:
4551 case R_SH_GOTPLT_MEDLOW16:
4552 case R_SH_GOTPLT_MEDHI16:
4553 case R_SH_GOTPLT_HI16:
4554 case R_SH_GOTPLT10BY4:
4555 case R_SH_GOTPLT10BY8:
4557 /* Relocation is to the entry for this symbol in the
4558 procedure linkage table. */
4565 || h->plt.offset == (bfd_vma) -1
4566 || h->got.offset != (bfd_vma) -1)
4569 /* Relocation is to the entry for this symbol in the global
4570 offset table extension for the procedure linkage table. */
4572 BFD_ASSERT (sgotplt != NULL);
4573 relocation = (sgotplt->output_offset
4574 + (get_plt_index (htab->plt_info, h->plt.offset)
4578 relocation -= GOT_BIAS;
4581 goto final_link_relocate;
4586 #ifdef INCLUDE_SHMEDIA
4587 case R_SH_GOT_LOW16:
4588 case R_SH_GOT_MEDLOW16:
4589 case R_SH_GOT_MEDHI16:
4594 /* Relocation is to the entry for this symbol in the global
4597 BFD_ASSERT (sgot != NULL);
4598 check_segment[0] = check_segment[1] = -1;
4604 off = h->got.offset;
4605 #ifdef INCLUDE_SHMEDIA
4606 if (seen_stt_datalabel)
4608 struct elf_sh_link_hash_entry *hsh;
4610 hsh = (struct elf_sh_link_hash_entry *)h;
4611 off = hsh->datalabel_got.offset;
4614 BFD_ASSERT (off != (bfd_vma) -1);
4616 dyn = htab->root.dynamic_sections_created;
4617 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4619 && SYMBOL_REFERENCES_LOCAL (info, h))
4620 || (ELF_ST_VISIBILITY (h->other)
4621 && h->root.type == bfd_link_hash_undefweak))
4623 /* This is actually a static link, or it is a
4624 -Bsymbolic link and the symbol is defined
4625 locally, or the symbol was forced to be local
4626 because of a version file. We must initialize
4627 this entry in the global offset table. Since the
4628 offset must always be a multiple of 4, we use the
4629 least significant bit to record whether we have
4630 initialized it already.
4632 When doing a dynamic link, we create a .rela.got
4633 relocation entry to initialize the value. This
4634 is done in the finish_dynamic_symbol routine. */
4639 bfd_put_32 (output_bfd, relocation,
4640 sgot->contents + off);
4641 #ifdef INCLUDE_SHMEDIA
4642 if (seen_stt_datalabel)
4644 struct elf_sh_link_hash_entry *hsh;
4646 hsh = (struct elf_sh_link_hash_entry *)h;
4647 hsh->datalabel_got.offset |= 1;
4653 /* If we initialize the GOT entry here with a valid
4654 symbol address, also add a fixup. */
4655 if (htab->fdpic_p && !info->shared
4656 && sh_elf_hash_entry (h)->got_type == GOT_NORMAL
4657 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4658 || h->root.type != bfd_link_hash_undefweak))
4659 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4660 sgot->output_section->vma
4661 + sgot->output_offset
4666 relocation = sh_elf_got_offset (htab) + off;
4670 #ifdef INCLUDE_SHMEDIA
4673 BFD_ASSERT (local_got_offsets != NULL
4674 && (local_got_offsets[symtab_hdr->sh_info
4678 off = local_got_offsets[symtab_hdr->sh_info
4684 BFD_ASSERT (local_got_offsets != NULL
4685 && local_got_offsets[r_symndx] != (bfd_vma) -1);
4687 off = local_got_offsets[r_symndx];
4688 #ifdef INCLUDE_SHMEDIA
4692 /* The offset must always be a multiple of 4. We use
4693 the least significant bit to record whether we have
4694 already generated the necessary reloc. */
4699 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4703 Elf_Internal_Rela outrel;
4706 if (srelgot == NULL)
4708 srelgot = bfd_get_section_by_name (dynobj,
4710 BFD_ASSERT (srelgot != NULL);
4713 outrel.r_offset = (sgot->output_section->vma
4714 + sgot->output_offset
4719 = elf_section_data (sec->output_section)->dynindx;
4720 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4721 outrel.r_addend = relocation;
4722 outrel.r_addend -= sec->output_section->vma;
4726 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4727 outrel.r_addend = relocation;
4729 loc = srelgot->contents;
4730 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4731 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4733 else if (htab->fdpic_p
4734 && (sh_elf_local_got_type (input_bfd) [r_symndx]
4736 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4737 sgot->output_section->vma
4738 + sgot->output_offset
4741 #ifdef INCLUDE_SHMEDIA
4743 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
4746 local_got_offsets[r_symndx] |= 1;
4749 relocation = sh_elf_got_offset (htab) + off;
4753 relocation -= GOT_BIAS;
4756 if (r_type == R_SH_GOT20)
4758 r = install_movi20_field (output_bfd, relocation + addend,
4759 input_bfd, input_section, contents,
4764 goto final_link_relocate;
4768 #ifdef INCLUDE_SHMEDIA
4769 case R_SH_GOTOFF_LOW16:
4770 case R_SH_GOTOFF_MEDLOW16:
4771 case R_SH_GOTOFF_MEDHI16:
4772 case R_SH_GOTOFF_HI16:
4774 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4775 we place at the start of the .got.plt section. This is the same
4776 as the start of the output .got section, unless there are function
4777 descriptors in front of it. */
4778 BFD_ASSERT (sgotplt != NULL);
4779 check_segment[0] = got_segment;
4780 relocation -= sgotplt->output_section->vma + sgotplt->output_offset
4781 + htab->root.hgot->root.u.def.value;
4784 relocation -= GOT_BIAS;
4787 addend = rel->r_addend;
4789 if (r_type == R_SH_GOTOFF20)
4791 r = install_movi20_field (output_bfd, relocation + addend,
4792 input_bfd, input_section, contents,
4797 goto final_link_relocate;
4800 #ifdef INCLUDE_SHMEDIA
4801 case R_SH_GOTPC_LOW16:
4802 case R_SH_GOTPC_MEDLOW16:
4803 case R_SH_GOTPC_MEDHI16:
4804 case R_SH_GOTPC_HI16:
4806 /* Use global offset table as symbol value. */
4808 BFD_ASSERT (sgotplt != NULL);
4809 relocation = sgotplt->output_section->vma + sgotplt->output_offset;
4812 relocation += GOT_BIAS;
4815 addend = rel->r_addend;
4817 goto final_link_relocate;
4820 #ifdef INCLUDE_SHMEDIA
4821 case R_SH_PLT_LOW16:
4822 case R_SH_PLT_MEDLOW16:
4823 case R_SH_PLT_MEDHI16:
4826 /* Relocation is to the entry for this symbol in the
4827 procedure linkage table. */
4829 /* Resolve a PLT reloc against a local symbol directly,
4830 without using the procedure linkage table. */
4832 goto final_link_relocate;
4834 /* We don't want to warn on calls to undefined weak symbols,
4835 as calls to them must be protected by non-NULL tests
4836 anyway, and unprotected calls would invoke undefined
4838 if (h->root.type == bfd_link_hash_undefweak)
4839 check_segment[0] = check_segment[1] = -1;
4841 if (h->forced_local)
4842 goto final_link_relocate;
4844 if (h->plt.offset == (bfd_vma) -1)
4846 /* We didn't make a PLT entry for this symbol. This
4847 happens when statically linking PIC code, or when
4848 using -Bsymbolic. */
4849 goto final_link_relocate;
4852 BFD_ASSERT (splt != NULL);
4853 check_segment[1] = plt_segment;
4854 relocation = (splt->output_section->vma
4855 + splt->output_offset
4858 #ifdef INCLUDE_SHMEDIA
4862 addend = rel->r_addend;
4864 goto final_link_relocate;
4866 /* Relocation is to the canonical function descriptor for this
4867 symbol, possibly via the GOT. Initialize the GOT
4868 entry and function descriptor if necessary. */
4869 case R_SH_GOTFUNCDESC:
4870 case R_SH_GOTFUNCDESC20:
4874 asection *reloc_section;
4875 bfd_vma reloc_offset;
4876 int reloc_type = R_SH_FUNCDESC;
4878 check_segment[0] = check_segment[1] = -1;
4880 /* FIXME: See what FRV does for global symbols in the
4881 executable, with --export-dynamic. Do they need ld.so
4882 to allocate official descriptors? See what this code
4888 if (r_type == R_SH_FUNCDESC)
4890 reloc_section = input_section;
4891 reloc_offset = rel->r_offset;
4895 reloc_section = htab->sgot;
4898 reloc_offset = h->got.offset;
4901 BFD_ASSERT (local_got_offsets != NULL);
4902 reloc_offset = local_got_offsets[r_symndx];
4904 BFD_ASSERT (reloc_offset != MINUS_ONE);
4906 if (reloc_offset & 1)
4909 goto funcdesc_done_got;
4913 if (h && h->root.type == bfd_link_hash_undefweak
4914 && (SYMBOL_CALLS_LOCAL (info, h)
4915 || !htab->root.dynamic_sections_created))
4916 /* Undefined weak symbol which will not be dynamically
4917 resolved later; leave it at zero. */
4918 goto funcdesc_leave_zero;
4919 else if (SYMBOL_CALLS_LOCAL (info, h)
4920 && ! SYMBOL_FUNCDESC_LOCAL (info, h))
4922 /* If the symbol needs a non-local function descriptor
4923 but binds locally (i.e., its visibility is
4924 protected), emit a dynamic relocation decayed to
4925 section+offset. This is an optimization; the dynamic
4926 linker would resolve our function descriptor request
4927 to our copy of the function anyway. */
4928 dynindx = elf_section_data (h->root.u.def.section
4929 ->output_section)->dynindx;
4930 relocation += h->root.u.def.section->output_offset
4931 + h->root.u.def.value;
4933 else if (! SYMBOL_FUNCDESC_LOCAL (info, h))
4935 /* If the symbol is dynamic and there will be dynamic
4936 symbol resolution because we are or are linked with a
4937 shared library, emit a FUNCDESC relocation such that
4938 the dynamic linker will allocate the function
4940 BFD_ASSERT (h->dynindx != -1);
4941 dynindx = h->dynindx;
4947 /* Otherwise, we know we have a private function
4948 descriptor, so reference it directly. */
4949 reloc_type = R_SH_DIR32;
4950 dynindx = elf_section_data (htab->sfuncdesc
4951 ->output_section)->dynindx;
4955 offset = sh_elf_hash_entry (h)->funcdesc.offset;
4956 BFD_ASSERT (offset != MINUS_ONE);
4957 if ((offset & 1) == 0)
4959 if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
4962 sh_elf_hash_entry (h)->funcdesc.offset |= 1;
4967 union gotref *local_funcdesc;
4969 local_funcdesc = sh_elf_local_funcdesc (input_bfd);
4970 offset = local_funcdesc[r_symndx].offset;
4971 BFD_ASSERT (offset != MINUS_ONE);
4972 if ((offset & 1) == 0)
4974 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
4978 local_funcdesc[r_symndx].offset |= 1;
4982 relocation = htab->sfuncdesc->output_offset + (offset & ~1);
4985 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
4989 if (sh_elf_osec_readonly_p (output_bfd,
4990 reloc_section->output_section))
4992 (*_bfd_error_handler)
4993 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
4996 (long) rel->r_offset,
5001 offset = _bfd_elf_section_offset (output_bfd, info,
5002 reloc_section, reloc_offset);
5004 if (offset != (bfd_vma)-1)
5005 sh_elf_add_rofixup (output_bfd, htab->srofixup,
5007 + reloc_section->output_section->vma
5008 + reloc_section->output_offset);
5010 else if ((reloc_section->output_section->flags
5011 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
5015 if (sh_elf_osec_readonly_p (output_bfd,
5016 reloc_section->output_section))
5018 info->callbacks->warning
5020 _("cannot emit dynamic relocations in read-only section"),
5021 symname, input_bfd, reloc_section, reloc_offset);
5025 if (srelgot == NULL)
5027 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5028 BFD_ASSERT (srelgot != NULL);
5031 offset = _bfd_elf_section_offset (output_bfd, info,
5032 reloc_section, reloc_offset);
5034 if (offset != (bfd_vma)-1)
5035 sh_elf_add_dyn_reloc (output_bfd, srelgot,
5037 + reloc_section->output_section->vma
5038 + reloc_section->output_offset,
5039 reloc_type, dynindx, relocation);
5041 if (r_type == R_SH_FUNCDESC)
5049 goto funcdesc_leave_zero;
5053 if (SYMBOL_FUNCDESC_LOCAL (info, h))
5054 relocation += htab->sfuncdesc->output_section->vma;
5055 funcdesc_leave_zero:
5056 if (r_type != R_SH_FUNCDESC)
5058 bfd_put_32 (output_bfd, relocation,
5059 reloc_section->contents + reloc_offset);
5063 local_got_offsets[r_symndx] |= 1;
5067 relocation = sh_elf_got_offset (htab) + reloc_offset;
5069 relocation -= GOT_BIAS;
5072 if (r_type == R_SH_GOTFUNCDESC20)
5074 r = install_movi20_field (output_bfd, relocation + addend,
5075 input_bfd, input_section, contents,
5080 goto final_link_relocate;
5084 case R_SH_GOTOFFFUNCDESC:
5085 case R_SH_GOTOFFFUNCDESC20:
5086 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5087 executable and --export-dynamic. If such symbols get
5088 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5091 check_segment[0] = check_segment[1] = -1;
5093 addend = rel->r_addend;
5095 if (h && (h->root.type == bfd_link_hash_undefweak
5096 || !SYMBOL_FUNCDESC_LOCAL (info, h)))
5099 (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
5100 input_bfd, input_section, (long) rel->r_offset, howto->name,
5101 h->root.root.string);
5108 /* Otherwise, we know we have a private function
5109 descriptor, so reference it directly. */
5112 offset = sh_elf_hash_entry (h)->funcdesc.offset;
5113 BFD_ASSERT (offset != MINUS_ONE);
5114 if ((offset & 1) == 0)
5116 if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
5119 sh_elf_hash_entry (h)->funcdesc.offset |= 1;
5124 union gotref *local_funcdesc;
5126 local_funcdesc = sh_elf_local_funcdesc (input_bfd);
5127 offset = local_funcdesc[r_symndx].offset;
5128 BFD_ASSERT (offset != MINUS_ONE);
5129 if ((offset & 1) == 0)
5131 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
5135 local_funcdesc[r_symndx].offset |= 1;
5139 relocation = htab->sfuncdesc->output_offset + (offset & ~1);
5142 relocation -= htab->root.hgot->root.u.def.value
5143 + htab->sgotplt->output_offset;
5145 relocation -= GOT_BIAS;
5148 if (r_type == R_SH_GOTOFFFUNCDESC20)
5150 r = install_movi20_field (output_bfd, relocation + addend,
5151 input_bfd, input_section, contents,
5156 goto final_link_relocate;
5158 case R_SH_LOOP_START:
5160 static bfd_vma start, end;
5162 start = (relocation + rel->r_addend
5163 - (sec->output_section->vma + sec->output_offset));
5164 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5165 rel->r_offset, sec, start, end);
5169 end = (relocation + rel->r_addend
5170 - (sec->output_section->vma + sec->output_offset));
5171 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5172 rel->r_offset, sec, start, end);
5176 case R_SH_TLS_GD_32:
5177 case R_SH_TLS_IE_32:
5178 check_segment[0] = check_segment[1] = -1;
5179 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5180 got_type = GOT_UNKNOWN;
5181 if (h == NULL && local_got_offsets)
5182 got_type = sh_elf_local_got_type (input_bfd) [r_symndx];
5185 got_type = sh_elf_hash_entry (h)->got_type;
5187 && (h->dynindx == -1
5189 r_type = R_SH_TLS_LE_32;
5192 if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE)
5193 r_type = R_SH_TLS_IE_32;
5195 if (r_type == R_SH_TLS_LE_32)
5198 unsigned short insn;
5200 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5202 /* GD->LE transition:
5203 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5204 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5205 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5207 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5209 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5211 offset = rel->r_offset;
5212 BFD_ASSERT (offset >= 16);
5213 /* Size of GD instructions is 16 or 18. */
5215 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5216 if ((insn & 0xff00) == 0xc700)
5218 BFD_ASSERT (offset >= 2);
5220 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5223 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5224 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5225 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5226 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5227 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5228 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5229 BFD_ASSERT (insn == 0x310c);
5230 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5231 BFD_ASSERT (insn == 0x410b);
5232 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5233 BFD_ASSERT (insn == 0x34cc);
5235 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5236 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5237 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5238 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5239 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5245 /* IE->LE transition:
5246 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5247 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5249 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5252 offset = rel->r_offset;
5253 BFD_ASSERT (offset >= 16);
5254 /* Size of IE instructions is 10 or 12. */
5256 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5257 if ((insn & 0xf0ff) == 0x0012)
5259 BFD_ASSERT (offset >= 2);
5261 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5264 BFD_ASSERT ((insn & 0xff00) == 0xd000);
5265 target = insn & 0x00ff;
5266 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5267 BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5268 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5269 BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5270 insn = 0xd000 | (insn & 0x0f00) | target;
5271 bfd_put_16 (output_bfd, insn, contents + offset + 0);
5272 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5275 bfd_put_32 (output_bfd, tpoff (info, relocation),
5276 contents + rel->r_offset);
5280 if (sgot == NULL || sgotplt == NULL)
5284 off = h->got.offset;
5287 if (local_got_offsets == NULL)
5290 off = local_got_offsets[r_symndx];
5293 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5294 if (r_type == R_SH_TLS_IE_32
5295 && ! htab->root.dynamic_sections_created)
5298 bfd_put_32 (output_bfd, tpoff (info, relocation),
5299 sgot->contents + off);
5300 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5301 contents + rel->r_offset);
5309 Elf_Internal_Rela outrel;
5313 if (srelgot == NULL)
5315 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5316 BFD_ASSERT (srelgot != NULL);
5319 outrel.r_offset = (sgot->output_section->vma
5320 + sgot->output_offset + off);
5322 if (h == NULL || h->dynindx == -1)
5327 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5329 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5330 outrel.r_addend = relocation - dtpoff_base (info);
5332 outrel.r_addend = 0;
5333 outrel.r_info = ELF32_R_INFO (indx, dr_type);
5334 loc = srelgot->contents;
5335 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5336 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5338 if (r_type == R_SH_TLS_GD_32)
5342 bfd_put_32 (output_bfd,
5343 relocation - dtpoff_base (info),
5344 sgot->contents + off + 4);
5348 outrel.r_info = ELF32_R_INFO (indx,
5350 outrel.r_offset += 4;
5351 outrel.r_addend = 0;
5352 srelgot->reloc_count++;
5353 loc += sizeof (Elf32_External_Rela);
5354 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5361 local_got_offsets[r_symndx] |= 1;
5364 if (off >= (bfd_vma) -2)
5367 if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5368 relocation = sh_elf_got_offset (htab) + off;
5372 unsigned short insn;
5374 /* GD->IE transition:
5375 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5376 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5377 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5379 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5380 nop; nop; bra 3f; nop; .align 2;
5381 1: .long x@TPOFF; 2:...; 3:. */
5383 offset = rel->r_offset;
5384 BFD_ASSERT (offset >= 16);
5385 /* Size of GD instructions is 16 or 18. */
5387 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5388 if ((insn & 0xff00) == 0xc700)
5390 BFD_ASSERT (offset >= 2);
5392 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5395 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5397 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5398 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5400 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5401 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5402 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5403 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5404 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5405 BFD_ASSERT (insn == 0x310c);
5406 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5407 BFD_ASSERT (insn == 0x410b);
5408 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5409 BFD_ASSERT (insn == 0x34cc);
5411 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5412 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5413 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5414 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5415 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5417 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
5418 contents + rel->r_offset);
5423 addend = rel->r_addend;
5425 goto final_link_relocate;
5427 case R_SH_TLS_LD_32:
5428 check_segment[0] = check_segment[1] = -1;
5432 unsigned short insn;
5434 /* LD->LE transition:
5435 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5436 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5437 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5439 stc gbr,r0; nop; nop; nop;
5440 nop; nop; bra 3f; ...; 3:. */
5442 offset = rel->r_offset;
5443 BFD_ASSERT (offset >= 16);
5444 /* Size of LD instructions is 16 or 18. */
5446 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5447 if ((insn & 0xff00) == 0xc700)
5449 BFD_ASSERT (offset >= 2);
5451 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5454 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5455 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5456 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5457 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5458 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5459 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5460 BFD_ASSERT (insn == 0x310c);
5461 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5462 BFD_ASSERT (insn == 0x410b);
5463 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5464 BFD_ASSERT (insn == 0x34cc);
5466 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5467 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5468 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5469 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5470 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5471 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5476 if (sgot == NULL || sgotplt == NULL)
5479 off = htab->tls_ldm_got.offset;
5484 Elf_Internal_Rela outrel;
5487 srelgot = htab->srelgot;
5488 if (srelgot == NULL)
5491 outrel.r_offset = (sgot->output_section->vma
5492 + sgot->output_offset + off);
5493 outrel.r_addend = 0;
5494 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5495 loc = srelgot->contents;
5496 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5497 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5498 htab->tls_ldm_got.offset |= 1;
5501 relocation = sh_elf_got_offset (htab) + off;
5502 addend = rel->r_addend;
5504 goto final_link_relocate;
5506 case R_SH_TLS_LDO_32:
5507 check_segment[0] = check_segment[1] = -1;
5509 relocation = tpoff (info, relocation);
5511 relocation -= dtpoff_base (info);
5513 addend = rel->r_addend;
5514 goto final_link_relocate;
5516 case R_SH_TLS_LE_32:
5519 Elf_Internal_Rela outrel;
5522 check_segment[0] = check_segment[1] = -1;
5526 relocation = tpoff (info, relocation);
5527 addend = rel->r_addend;
5528 goto final_link_relocate;
5533 sreloc = _bfd_elf_get_dynamic_reloc_section
5534 (input_bfd, input_section, /*rela?*/ TRUE);
5539 if (h == NULL || h->dynindx == -1)
5544 outrel.r_offset = (input_section->output_section->vma
5545 + input_section->output_offset
5547 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5549 outrel.r_addend = relocation - dtpoff_base (info);
5551 outrel.r_addend = 0;
5553 loc = sreloc->contents;
5554 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5555 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5561 if (htab->fdpic_p && check_segment[0] != (unsigned) -1
5562 && check_segment[0] != check_segment[1])
5564 /* We don't want duplicate errors for undefined symbols. */
5565 if (!h || h->root.type != bfd_link_hash_undefined)
5569 info->callbacks->einfo
5570 (_("%X%C: relocation to \"%s\" references a different segment\n"),
5571 input_bfd, input_section, rel->r_offset, symname);
5575 info->callbacks->einfo
5576 (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5577 input_bfd, input_section, rel->r_offset, symname);
5580 elf_elfheader (output_bfd)->e_flags &= ~EF_SH_PIC;
5583 if (r != bfd_reloc_ok)
5588 case bfd_reloc_outofrange:
5590 case bfd_reloc_overflow:
5598 name = (bfd_elf_string_from_elf_section
5599 (input_bfd, symtab_hdr->sh_link, sym->st_name));
5603 name = bfd_section_name (input_bfd, sec);
5605 if (! ((*info->callbacks->reloc_overflow)
5606 (info, (h ? &h->root : NULL), name, howto->name,
5607 (bfd_vma) 0, input_bfd, input_section,
5619 /* This is a version of bfd_generic_get_relocated_section_contents
5620 which uses sh_elf_relocate_section. */
5623 sh_elf_get_relocated_section_contents (bfd *output_bfd,
5624 struct bfd_link_info *link_info,
5625 struct bfd_link_order *link_order,
5627 bfd_boolean relocatable,
5630 Elf_Internal_Shdr *symtab_hdr;
5631 asection *input_section = link_order->u.indirect.section;
5632 bfd *input_bfd = input_section->owner;
5633 asection **sections = NULL;
5634 Elf_Internal_Rela *internal_relocs = NULL;
5635 Elf_Internal_Sym *isymbuf = NULL;
5637 /* We only need to handle the case of relaxing, or of having a
5638 particular set of section contents, specially. */
5640 || elf_section_data (input_section)->this_hdr.contents == NULL)
5641 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5646 symtab_hdr = &elf_symtab_hdr (input_bfd);
5648 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5649 (size_t) input_section->size);
5651 if ((input_section->flags & SEC_RELOC) != 0
5652 && input_section->reloc_count > 0)
5655 Elf_Internal_Sym *isym, *isymend;
5658 internal_relocs = (_bfd_elf_link_read_relocs
5659 (input_bfd, input_section, NULL,
5660 (Elf_Internal_Rela *) NULL, FALSE));
5661 if (internal_relocs == NULL)
5664 if (symtab_hdr->sh_info != 0)
5666 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5667 if (isymbuf == NULL)
5668 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5669 symtab_hdr->sh_info, 0,
5671 if (isymbuf == NULL)
5675 amt = symtab_hdr->sh_info;
5676 amt *= sizeof (asection *);
5677 sections = (asection **) bfd_malloc (amt);
5678 if (sections == NULL && amt != 0)
5681 isymend = isymbuf + symtab_hdr->sh_info;
5682 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5686 if (isym->st_shndx == SHN_UNDEF)
5687 isec = bfd_und_section_ptr;
5688 else if (isym->st_shndx == SHN_ABS)
5689 isec = bfd_abs_section_ptr;
5690 else if (isym->st_shndx == SHN_COMMON)
5691 isec = bfd_com_section_ptr;
5693 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5698 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5699 input_section, data, internal_relocs,
5703 if (sections != NULL)
5706 && symtab_hdr->contents != (unsigned char *) isymbuf)
5708 if (elf_section_data (input_section)->relocs != internal_relocs)
5709 free (internal_relocs);
5715 if (sections != NULL)
5718 && symtab_hdr->contents != (unsigned char *) isymbuf)
5720 if (internal_relocs != NULL
5721 && elf_section_data (input_section)->relocs != internal_relocs)
5722 free (internal_relocs);
5726 /* Return the base VMA address which should be subtracted from real addresses
5727 when resolving @dtpoff relocation.
5728 This is PT_TLS segment p_vaddr. */
5731 dtpoff_base (struct bfd_link_info *info)
5733 /* If tls_sec is NULL, we should have signalled an error already. */
5734 if (elf_hash_table (info)->tls_sec == NULL)
5736 return elf_hash_table (info)->tls_sec->vma;
5739 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5742 tpoff (struct bfd_link_info *info, bfd_vma address)
5744 /* If tls_sec is NULL, we should have signalled an error already. */
5745 if (elf_hash_table (info)->tls_sec == NULL)
5747 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5748 structure which has 2 pointer fields. */
5749 return (address - elf_hash_table (info)->tls_sec->vma
5750 + align_power ((bfd_vma) 8,
5751 elf_hash_table (info)->tls_sec->alignment_power));
5755 sh_elf_gc_mark_hook (asection *sec,
5756 struct bfd_link_info *info,
5757 Elf_Internal_Rela *rel,
5758 struct elf_link_hash_entry *h,
5759 Elf_Internal_Sym *sym)
5762 switch (ELF32_R_TYPE (rel->r_info))
5764 case R_SH_GNU_VTINHERIT:
5765 case R_SH_GNU_VTENTRY:
5769 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5772 /* Update the got entry reference counts for the section being removed. */
5775 sh_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5776 asection *sec, const Elf_Internal_Rela *relocs)
5778 Elf_Internal_Shdr *symtab_hdr;
5779 struct elf_link_hash_entry **sym_hashes;
5780 bfd_signed_vma *local_got_refcounts;
5781 union gotref *local_funcdesc;
5782 const Elf_Internal_Rela *rel, *relend;
5784 if (info->relocatable)
5787 elf_section_data (sec)->local_dynrel = NULL;
5789 symtab_hdr = &elf_symtab_hdr (abfd);
5790 sym_hashes = elf_sym_hashes (abfd);
5791 local_got_refcounts = elf_local_got_refcounts (abfd);
5792 local_funcdesc = sh_elf_local_funcdesc (abfd);
5794 relend = relocs + sec->reloc_count;
5795 for (rel = relocs; rel < relend; rel++)
5797 unsigned long r_symndx;
5798 unsigned int r_type;
5799 struct elf_link_hash_entry *h = NULL;
5800 #ifdef INCLUDE_SHMEDIA
5801 int seen_stt_datalabel = 0;
5804 r_symndx = ELF32_R_SYM (rel->r_info);
5805 if (r_symndx >= symtab_hdr->sh_info)
5807 struct elf_sh_link_hash_entry *eh;
5808 struct elf_sh_dyn_relocs **pp;
5809 struct elf_sh_dyn_relocs *p;
5811 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5812 while (h->root.type == bfd_link_hash_indirect
5813 || h->root.type == bfd_link_hash_warning)
5815 #ifdef INCLUDE_SHMEDIA
5816 seen_stt_datalabel |= h->type == STT_DATALABEL;
5818 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5820 eh = (struct elf_sh_link_hash_entry *) h;
5821 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5824 /* Everything must go for SEC. */
5830 r_type = ELF32_R_TYPE (rel->r_info);
5831 switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
5833 case R_SH_TLS_LD_32:
5834 if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5835 sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5843 #ifdef INCLUDE_SHMEDIA
5844 case R_SH_GOT_LOW16:
5845 case R_SH_GOT_MEDLOW16:
5846 case R_SH_GOT_MEDHI16:
5850 case R_SH_GOTOFF_LOW16:
5851 case R_SH_GOTOFF_MEDLOW16:
5852 case R_SH_GOTOFF_MEDHI16:
5853 case R_SH_GOTOFF_HI16:
5854 case R_SH_GOTPC_LOW16:
5855 case R_SH_GOTPC_MEDLOW16:
5856 case R_SH_GOTPC_MEDHI16:
5857 case R_SH_GOTPC_HI16:
5859 case R_SH_TLS_GD_32:
5860 case R_SH_TLS_IE_32:
5861 case R_SH_GOTFUNCDESC:
5862 case R_SH_GOTFUNCDESC20:
5865 #ifdef INCLUDE_SHMEDIA
5866 if (seen_stt_datalabel)
5868 struct elf_sh_link_hash_entry *eh;
5869 eh = (struct elf_sh_link_hash_entry *) h;
5870 if (eh->datalabel_got.refcount > 0)
5871 eh->datalabel_got.refcount -= 1;
5875 if (h->got.refcount > 0)
5876 h->got.refcount -= 1;
5878 else if (local_got_refcounts != NULL)
5880 #ifdef INCLUDE_SHMEDIA
5881 if (rel->r_addend & 1)
5883 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5884 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5888 if (local_got_refcounts[r_symndx] > 0)
5889 local_got_refcounts[r_symndx] -= 1;
5895 sh_elf_hash_entry (h)->abs_funcdesc_refcount -= 1;
5896 else if (sh_elf_hash_table (info)->fdpic_p && !info->shared)
5897 sh_elf_hash_table (info)->srofixup->size -= 4;
5901 case R_SH_GOTOFFFUNCDESC:
5902 case R_SH_GOTOFFFUNCDESC20:
5904 sh_elf_hash_entry (h)->funcdesc.refcount -= 1;
5906 local_funcdesc[r_symndx].refcount -= 1;
5910 if (sh_elf_hash_table (info)->fdpic_p && !info->shared
5911 && (sec->flags & SEC_ALLOC) != 0)
5912 sh_elf_hash_table (info)->srofixup->size -= 4;
5921 #ifdef INCLUDE_SHMEDIA
5922 case R_SH_PLT_LOW16:
5923 case R_SH_PLT_MEDLOW16:
5924 case R_SH_PLT_MEDHI16:
5929 if (h->plt.refcount > 0)
5930 h->plt.refcount -= 1;
5935 #ifdef INCLUDE_SHMEDIA
5936 case R_SH_GOTPLT_LOW16:
5937 case R_SH_GOTPLT_MEDLOW16:
5938 case R_SH_GOTPLT_MEDHI16:
5939 case R_SH_GOTPLT_HI16:
5940 case R_SH_GOTPLT10BY4:
5941 case R_SH_GOTPLT10BY8:
5945 struct elf_sh_link_hash_entry *eh;
5946 eh = (struct elf_sh_link_hash_entry *) h;
5947 if (eh->gotplt_refcount > 0)
5949 eh->gotplt_refcount -= 1;
5950 if (h->plt.refcount > 0)
5951 h->plt.refcount -= 1;
5953 #ifdef INCLUDE_SHMEDIA
5954 else if (seen_stt_datalabel)
5956 if (eh->datalabel_got.refcount > 0)
5957 eh->datalabel_got.refcount -= 1;
5960 else if (h->got.refcount > 0)
5961 h->got.refcount -= 1;
5963 else if (local_got_refcounts != NULL)
5965 #ifdef INCLUDE_SHMEDIA
5966 if (rel->r_addend & 1)
5968 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5969 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5973 if (local_got_refcounts[r_symndx] > 0)
5974 local_got_refcounts[r_symndx] -= 1;
5986 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5989 sh_elf_copy_indirect_symbol (struct bfd_link_info *info,
5990 struct elf_link_hash_entry *dir,
5991 struct elf_link_hash_entry *ind)
5993 struct elf_sh_link_hash_entry *edir, *eind;
5995 edir = (struct elf_sh_link_hash_entry *) dir;
5996 eind = (struct elf_sh_link_hash_entry *) ind;
5998 if (eind->dyn_relocs != NULL)
6000 if (edir->dyn_relocs != NULL)
6002 struct elf_sh_dyn_relocs **pp;
6003 struct elf_sh_dyn_relocs *p;
6005 /* Add reloc counts against the indirect sym to the direct sym
6006 list. Merge any entries against the same section. */
6007 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6009 struct elf_sh_dyn_relocs *q;
6011 for (q = edir->dyn_relocs; q != NULL; q = q->next)
6012 if (q->sec == p->sec)
6014 q->pc_count += p->pc_count;
6015 q->count += p->count;
6022 *pp = edir->dyn_relocs;
6025 edir->dyn_relocs = eind->dyn_relocs;
6026 eind->dyn_relocs = NULL;
6028 edir->gotplt_refcount = eind->gotplt_refcount;
6029 eind->gotplt_refcount = 0;
6030 #ifdef INCLUDE_SHMEDIA
6031 edir->datalabel_got.refcount += eind->datalabel_got.refcount;
6032 eind->datalabel_got.refcount = 0;
6034 edir->funcdesc.refcount += eind->funcdesc.refcount;
6035 eind->funcdesc.refcount = 0;
6036 edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
6037 eind->abs_funcdesc_refcount = 0;
6039 if (ind->root.type == bfd_link_hash_indirect
6040 && dir->got.refcount <= 0)
6042 edir->got_type = eind->got_type;
6043 eind->got_type = GOT_UNKNOWN;
6046 if (ind->root.type != bfd_link_hash_indirect
6047 && dir->dynamic_adjusted)
6049 /* If called to transfer flags for a weakdef during processing
6050 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6051 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6052 dir->ref_dynamic |= ind->ref_dynamic;
6053 dir->ref_regular |= ind->ref_regular;
6054 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6055 dir->needs_plt |= ind->needs_plt;
6058 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
6062 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
6070 case R_SH_TLS_GD_32:
6071 case R_SH_TLS_IE_32:
6073 return R_SH_TLS_LE_32;
6074 return R_SH_TLS_IE_32;
6075 case R_SH_TLS_LD_32:
6076 return R_SH_TLS_LE_32;
6082 /* Look through the relocs for a section during the first phase.
6083 Since we don't do .gots or .plts, we just need to consider the
6084 virtual table relocs for gc. */
6087 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
6088 const Elf_Internal_Rela *relocs)
6090 Elf_Internal_Shdr *symtab_hdr;
6091 struct elf_link_hash_entry **sym_hashes;
6092 struct elf_sh_link_hash_table *htab;
6093 const Elf_Internal_Rela *rel;
6094 const Elf_Internal_Rela *rel_end;
6095 bfd_vma *local_got_offsets;
6099 unsigned int r_type;
6100 int got_type, old_got_type;
6106 if (info->relocatable)
6109 BFD_ASSERT (is_sh_elf (abfd));
6111 symtab_hdr = &elf_symtab_hdr (abfd);
6112 sym_hashes = elf_sym_hashes (abfd);
6114 htab = sh_elf_hash_table (info);
6118 local_got_offsets = elf_local_got_offsets (abfd);
6120 rel_end = relocs + sec->reloc_count;
6121 for (rel = relocs; rel < rel_end; rel++)
6123 struct elf_link_hash_entry *h;
6124 unsigned long r_symndx;
6125 #ifdef INCLUDE_SHMEDIA
6126 int seen_stt_datalabel = 0;
6129 r_symndx = ELF32_R_SYM (rel->r_info);
6130 r_type = ELF32_R_TYPE (rel->r_info);
6132 if (r_symndx < symtab_hdr->sh_info)
6136 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6137 while (h->root.type == bfd_link_hash_indirect
6138 || h->root.type == bfd_link_hash_warning)
6140 #ifdef INCLUDE_SHMEDIA
6141 seen_stt_datalabel |= h->type == STT_DATALABEL;
6143 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6147 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6149 && r_type == R_SH_TLS_IE_32
6151 && h->root.type != bfd_link_hash_undefined
6152 && h->root.type != bfd_link_hash_undefweak
6153 && (h->dynindx == -1
6155 r_type = R_SH_TLS_LE_32;
6160 case R_SH_GOTOFFFUNCDESC:
6161 case R_SH_GOTOFFFUNCDESC20:
6163 case R_SH_GOTFUNCDESC:
6164 case R_SH_GOTFUNCDESC20:
6167 if (h->dynindx == -1)
6168 switch (ELF_ST_VISIBILITY (h->other))
6174 bfd_elf_link_record_dynamic_symbol (info, h);
6181 /* Some relocs require a global offset table. */
6182 if (htab->sgot == NULL)
6187 /* This may require an rofixup. */
6196 case R_SH_GOTFUNCDESC:
6197 case R_SH_GOTFUNCDESC20:
6198 case R_SH_GOTOFFFUNCDESC:
6199 case R_SH_GOTOFFFUNCDESC20:
6201 #ifdef INCLUDE_SHMEDIA
6202 case R_SH_GOTPLT_LOW16:
6203 case R_SH_GOTPLT_MEDLOW16:
6204 case R_SH_GOTPLT_MEDHI16:
6205 case R_SH_GOTPLT_HI16:
6206 case R_SH_GOTPLT10BY4:
6207 case R_SH_GOTPLT10BY8:
6208 case R_SH_GOT_LOW16:
6209 case R_SH_GOT_MEDLOW16:
6210 case R_SH_GOT_MEDHI16:
6214 case R_SH_GOTOFF_LOW16:
6215 case R_SH_GOTOFF_MEDLOW16:
6216 case R_SH_GOTOFF_MEDHI16:
6217 case R_SH_GOTOFF_HI16:
6218 case R_SH_GOTPC_LOW16:
6219 case R_SH_GOTPC_MEDLOW16:
6220 case R_SH_GOTPC_MEDHI16:
6221 case R_SH_GOTPC_HI16:
6223 case R_SH_TLS_GD_32:
6224 case R_SH_TLS_LD_32:
6225 case R_SH_TLS_IE_32:
6226 if (htab->root.dynobj == NULL)
6227 htab->root.dynobj = abfd;
6228 if (!create_got_section (htab->root.dynobj, info))
6239 /* This relocation describes the C++ object vtable hierarchy.
6240 Reconstruct it for later use during GC. */
6241 case R_SH_GNU_VTINHERIT:
6242 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6246 /* This relocation describes which C++ vtable entries are actually
6247 used. Record for later use during GC. */
6248 case R_SH_GNU_VTENTRY:
6249 BFD_ASSERT (h != NULL);
6251 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6255 case R_SH_TLS_IE_32:
6257 info->flags |= DF_STATIC_TLS;
6261 case R_SH_TLS_GD_32:
6264 #ifdef INCLUDE_SHMEDIA
6265 case R_SH_GOT_LOW16:
6266 case R_SH_GOT_MEDLOW16:
6267 case R_SH_GOT_MEDHI16:
6272 case R_SH_GOTFUNCDESC:
6273 case R_SH_GOTFUNCDESC20:
6277 got_type = GOT_NORMAL;
6279 case R_SH_TLS_GD_32:
6280 got_type = GOT_TLS_GD;
6282 case R_SH_TLS_IE_32:
6283 got_type = GOT_TLS_IE;
6285 case R_SH_GOTFUNCDESC:
6286 case R_SH_GOTFUNCDESC20:
6287 got_type = GOT_FUNCDESC;
6293 #ifdef INCLUDE_SHMEDIA
6294 if (seen_stt_datalabel)
6296 struct elf_sh_link_hash_entry *eh
6297 = (struct elf_sh_link_hash_entry *) h;
6299 eh->datalabel_got.refcount += 1;
6303 h->got.refcount += 1;
6304 old_got_type = sh_elf_hash_entry (h)->got_type;
6308 bfd_signed_vma *local_got_refcounts;
6310 /* This is a global offset table entry for a local
6312 local_got_refcounts = elf_local_got_refcounts (abfd);
6313 if (local_got_refcounts == NULL)
6317 size = symtab_hdr->sh_info;
6318 size *= sizeof (bfd_signed_vma);
6319 #ifdef INCLUDE_SHMEDIA
6320 /* Reserve space for both the datalabel and
6321 codelabel local GOT offsets. */
6324 size += symtab_hdr->sh_info;
6325 local_got_refcounts = ((bfd_signed_vma *)
6326 bfd_zalloc (abfd, size));
6327 if (local_got_refcounts == NULL)
6329 elf_local_got_refcounts (abfd) = local_got_refcounts;
6330 #ifdef INCLUDE_SHMEDIA
6331 /* Take care of both the datalabel and codelabel local
6333 sh_elf_local_got_type (abfd)
6334 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6336 sh_elf_local_got_type (abfd)
6337 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6340 #ifdef INCLUDE_SHMEDIA
6341 if (rel->r_addend & 1)
6342 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6345 local_got_refcounts[r_symndx] += 1;
6346 old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
6349 /* If a TLS symbol is accessed using IE at least once,
6350 there is no point to use dynamic model for it. */
6351 if (old_got_type != got_type && old_got_type != GOT_UNKNOWN
6352 && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE))
6354 if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD)
6355 got_type = GOT_TLS_IE;
6358 if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
6359 && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
6360 (*_bfd_error_handler)
6361 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6362 abfd, h->root.root.string);
6363 else if (old_got_type == GOT_FUNCDESC
6364 || got_type == GOT_FUNCDESC)
6365 (*_bfd_error_handler)
6366 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6367 abfd, h->root.root.string);
6369 (*_bfd_error_handler)
6370 (_("%B: `%s' accessed both as normal and thread local symbol"),
6371 abfd, h->root.root.string);
6376 if (old_got_type != got_type)
6379 sh_elf_hash_entry (h)->got_type = got_type;
6381 sh_elf_local_got_type (abfd) [r_symndx] = got_type;
6386 case R_SH_TLS_LD_32:
6387 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6391 case R_SH_GOTOFFFUNCDESC:
6392 case R_SH_GOTOFFFUNCDESC20:
6395 (*_bfd_error_handler)
6396 (_("%B: Function descriptor relocation with non-zero addend"),
6403 union gotref *local_funcdesc;
6405 /* We need a function descriptor for a local symbol. */
6406 local_funcdesc = sh_elf_local_funcdesc (abfd);
6407 if (local_funcdesc == NULL)
6411 size = symtab_hdr->sh_info * sizeof (union gotref);
6412 #ifdef INCLUDE_SHMEDIA
6413 /* Count datalabel local GOT. */
6416 local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
6417 if (local_funcdesc == NULL)
6419 sh_elf_local_funcdesc (abfd) = local_funcdesc;
6421 local_funcdesc[r_symndx].refcount += 1;
6423 if (r_type == R_SH_FUNCDESC)
6426 htab->srofixup->size += 4;
6428 htab->srelgot->size += sizeof (Elf32_External_Rela);
6433 sh_elf_hash_entry (h)->funcdesc.refcount++;
6434 if (r_type == R_SH_FUNCDESC)
6435 sh_elf_hash_entry (h)->abs_funcdesc_refcount++;
6437 /* If there is a function descriptor reference, then
6438 there should not be any non-FDPIC references. */
6439 old_got_type = sh_elf_hash_entry (h)->got_type;
6440 if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
6442 if (old_got_type == GOT_NORMAL)
6443 (*_bfd_error_handler)
6444 (_("%B: `%s' accessed both as normal and FDPIC symbol"),
6445 abfd, h->root.root.string);
6447 (*_bfd_error_handler)
6448 (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
6449 abfd, h->root.root.string);
6455 #ifdef INCLUDE_SHMEDIA
6456 case R_SH_GOTPLT_LOW16:
6457 case R_SH_GOTPLT_MEDLOW16:
6458 case R_SH_GOTPLT_MEDHI16:
6459 case R_SH_GOTPLT_HI16:
6460 case R_SH_GOTPLT10BY4:
6461 case R_SH_GOTPLT10BY8:
6463 /* If this is a local symbol, we resolve it directly without
6464 creating a procedure linkage table entry. */
6470 || h->dynindx == -1)
6474 h->plt.refcount += 1;
6475 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6480 #ifdef INCLUDE_SHMEDIA
6481 case R_SH_PLT_LOW16:
6482 case R_SH_PLT_MEDLOW16:
6483 case R_SH_PLT_MEDHI16:
6486 /* This symbol requires a procedure linkage table entry. We
6487 actually build the entry in adjust_dynamic_symbol,
6488 because this might be a case of linking PIC code which is
6489 never referenced by a dynamic object, in which case we
6490 don't need to generate a procedure linkage table entry
6493 /* If this is a local symbol, we resolve it directly without
6494 creating a procedure linkage table entry. */
6498 if (h->forced_local)
6502 h->plt.refcount += 1;
6507 #ifdef INCLUDE_SHMEDIA
6508 case R_SH_IMM_LOW16_PCREL:
6509 case R_SH_IMM_MEDLOW16_PCREL:
6510 case R_SH_IMM_MEDHI16_PCREL:
6511 case R_SH_IMM_HI16_PCREL:
6513 if (h != NULL && ! info->shared)
6516 h->plt.refcount += 1;
6519 /* If we are creating a shared library, and this is a reloc
6520 against a global symbol, or a non PC relative reloc
6521 against a local symbol, then we need to copy the reloc
6522 into the shared library. However, if we are linking with
6523 -Bsymbolic, we do not need to copy a reloc against a
6524 global symbol which is defined in an object we are
6525 including in the link (i.e., DEF_REGULAR is set). At
6526 this point we have not seen all the input files, so it is
6527 possible that DEF_REGULAR is not set now but will be set
6528 later (it is never cleared). We account for that
6529 possibility below by storing information in the
6530 dyn_relocs field of the hash table entry. A similar
6531 situation occurs when creating shared libraries and symbol
6532 visibility changes render the symbol local.
6534 If on the other hand, we are creating an executable, we
6535 may need to keep relocations for symbols satisfied by a
6536 dynamic library if we manage to avoid copy relocs for the
6539 && (sec->flags & SEC_ALLOC) != 0
6540 && (r_type != R_SH_REL32
6542 && (! info->symbolic
6543 || h->root.type == bfd_link_hash_defweak
6544 || !h->def_regular))))
6546 && (sec->flags & SEC_ALLOC) != 0
6548 && (h->root.type == bfd_link_hash_defweak
6549 || !h->def_regular)))
6551 struct elf_sh_dyn_relocs *p;
6552 struct elf_sh_dyn_relocs **head;
6554 if (htab->root.dynobj == NULL)
6555 htab->root.dynobj = abfd;
6557 /* When creating a shared object, we must copy these
6558 reloc types into the output file. We create a reloc
6559 section in dynobj and make room for this reloc. */
6562 sreloc = _bfd_elf_make_dynamic_reloc_section
6563 (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
6569 /* If this is a global symbol, we count the number of
6570 relocations we need for this symbol. */
6572 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6575 /* Track dynamic relocs needed for local syms too. */
6578 Elf_Internal_Sym *isym;
6580 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6585 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6589 vpp = &elf_section_data (s)->local_dynrel;
6590 head = (struct elf_sh_dyn_relocs **) vpp;
6594 if (p == NULL || p->sec != sec)
6596 bfd_size_type amt = sizeof (*p);
6597 p = bfd_alloc (htab->root.dynobj, amt);
6608 if (r_type == R_SH_REL32
6609 #ifdef INCLUDE_SHMEDIA
6610 || r_type == R_SH_IMM_LOW16_PCREL
6611 || r_type == R_SH_IMM_MEDLOW16_PCREL
6612 || r_type == R_SH_IMM_MEDHI16_PCREL
6613 || r_type == R_SH_IMM_HI16_PCREL
6619 /* Allocate the fixup regardless of whether we need a relocation.
6620 If we end up generating the relocation, we'll unallocate the
6622 if (htab->fdpic_p && !info->shared
6623 && r_type == R_SH_DIR32
6624 && (sec->flags & SEC_ALLOC) != 0)
6625 htab->srofixup->size += 4;
6628 case R_SH_TLS_LE_32:
6631 (*_bfd_error_handler)
6632 (_("%B: TLS local exec code cannot be linked into shared objects"),
6639 case R_SH_TLS_LDO_32:
6640 /* Nothing to do. */
6651 #ifndef sh_elf_set_mach_from_flags
6652 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
6655 sh_elf_set_mach_from_flags (bfd *abfd)
6657 flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
6659 if (flags >= sizeof(sh_ef_bfd_table))
6662 if (sh_ef_bfd_table[flags] == 0)
6665 bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
6671 /* Reverse table lookup for sh_ef_bfd_table[].
6672 Given a bfd MACH value from archures.c
6673 return the equivalent ELF flags from the table.
6674 Return -1 if no match is found. */
6677 sh_elf_get_flags_from_mach (unsigned long mach)
6679 int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
6682 if (sh_ef_bfd_table[i] == mach)
6685 /* shouldn't get here */
6690 #endif /* not sh_elf_set_mach_from_flags */
6692 #ifndef sh_elf_set_private_flags
6693 /* Function to keep SH specific file flags. */
6696 sh_elf_set_private_flags (bfd *abfd, flagword flags)
6698 BFD_ASSERT (! elf_flags_init (abfd)
6699 || elf_elfheader (abfd)->e_flags == flags);
6701 elf_elfheader (abfd)->e_flags = flags;
6702 elf_flags_init (abfd) = TRUE;
6703 return sh_elf_set_mach_from_flags (abfd);
6705 #endif /* not sh_elf_set_private_flags */
6707 #ifndef sh_elf_copy_private_data
6708 /* Copy backend specific data from one object module to another */
6711 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
6713 /* Copy object attributes. */
6714 _bfd_elf_copy_obj_attributes (ibfd, obfd);
6716 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6719 /* Copy the stack size. */
6720 if (elf_tdata (ibfd)->phdr && elf_tdata (obfd)->phdr
6721 && fdpic_object_p (ibfd) && fdpic_object_p (obfd))
6725 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6726 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6728 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6730 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6731 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6733 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6735 /* Rewrite the phdrs, since we're only called after they
6736 were first written. */
6738 (bfd_signed_vma) get_elf_backend_data (obfd)
6739 ->s->sizeof_ehdr, SEEK_SET) != 0
6740 || get_elf_backend_data (obfd)->s
6741 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6742 elf_elfheader (obfd)->e_phnum) != 0)
6751 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6753 #endif /* not sh_elf_copy_private_data */
6755 #ifndef sh_elf_merge_private_data
6757 /* This function returns the ELF architecture number that
6758 corresponds to the given arch_sh* flags. */
6761 sh_find_elf_flags (unsigned int arch_set)
6763 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
6764 unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set);
6766 return sh_elf_get_flags_from_mach (bfd_mach);
6769 /* This routine initialises the elf flags when required and
6770 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6773 sh_elf_merge_private_data (bfd *ibfd, bfd *obfd)
6775 extern bfd_boolean sh_merge_bfd_arch (bfd *, bfd *);
6777 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6780 if (! elf_flags_init (obfd))
6782 /* This happens when ld starts out with a 'blank' output file. */
6783 elf_flags_init (obfd) = TRUE;
6784 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6785 sh_elf_set_mach_from_flags (obfd);
6786 if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
6787 elf_elfheader (obfd)->e_flags |= EF_SH_PIC;
6790 if (! sh_merge_bfd_arch (ibfd, obfd))
6792 _bfd_error_handler ("%B: uses instructions which are incompatible "
6793 "with instructions used in previous modules",
6795 bfd_set_error (bfd_error_bad_value);
6799 elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
6800 elf_elfheader (obfd)->e_flags |=
6801 sh_elf_get_flags_from_mach (bfd_get_mach (obfd));
6803 if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
6805 _bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects",
6807 bfd_set_error (bfd_error_bad_value);
6813 #endif /* not sh_elf_merge_private_data */
6815 /* Override the generic function because we need to store sh_elf_obj_tdata
6816 as the specific tdata. We set also the machine architecture from flags
6820 sh_elf_object_p (bfd *abfd)
6822 if (! sh_elf_set_mach_from_flags (abfd))
6825 return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
6826 == fdpic_object_p (abfd));
6829 /* Finish up dynamic symbol handling. We set the contents of various
6830 dynamic sections here. */
6833 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6834 struct elf_link_hash_entry *h,
6835 Elf_Internal_Sym *sym)
6837 struct elf_sh_link_hash_table *htab;
6839 htab = sh_elf_hash_table (info);
6843 if (h->plt.offset != (bfd_vma) -1)
6851 Elf_Internal_Rela rel;
6853 const struct elf_sh_plt_info *plt_info;
6855 /* This symbol has an entry in the procedure linkage table. Set
6858 BFD_ASSERT (h->dynindx != -1);
6861 sgotplt = htab->sgotplt;
6862 srelplt = htab->srelplt;
6863 BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
6865 /* Get the index in the procedure linkage table which
6866 corresponds to this symbol. This is the index of this symbol
6867 in all the symbols for which we are making plt entries. The
6868 first entry in the procedure linkage table is reserved. */
6869 plt_index = get_plt_index (htab->plt_info, h->plt.offset);
6871 plt_info = htab->plt_info;
6872 if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT)
6873 plt_info = plt_info->short_plt;
6875 /* Get the offset into the .got table of the entry that
6876 corresponds to this function. */
6878 /* The offset must be relative to the GOT symbol, twelve bytes
6879 before the end of .got.plt. Each descriptor is eight
6881 got_offset = plt_index * 8 + 12 - sgotplt->size;
6883 /* Each .got entry is 4 bytes. The first three are
6885 got_offset = (plt_index + 3) * 4;
6889 got_offset -= GOT_BIAS;
6892 /* Fill in the entry in the procedure linkage table. */
6893 memcpy (splt->contents + h->plt.offset,
6894 plt_info->symbol_entry,
6895 plt_info->symbol_entry_size);
6897 if (info->shared || htab->fdpic_p)
6899 if (plt_info->symbol_fields.got20)
6901 bfd_reloc_status_type r;
6902 r = install_movi20_field (output_bfd, got_offset,
6903 splt->owner, splt, splt->contents,
6905 + plt_info->symbol_fields.got_entry);
6906 BFD_ASSERT (r == bfd_reloc_ok);
6909 install_plt_field (output_bfd, FALSE, got_offset,
6912 + plt_info->symbol_fields.got_entry));
6916 BFD_ASSERT (!plt_info->symbol_fields.got20);
6918 install_plt_field (output_bfd, FALSE,
6919 (sgotplt->output_section->vma
6920 + sgotplt->output_offset
6924 + plt_info->symbol_fields.got_entry));
6925 if (htab->vxworks_p)
6927 unsigned int reachable_plts, plts_per_4k;
6930 /* Divide the PLT into groups. The first group contains
6931 REACHABLE_PLTS entries and the other groups contain
6932 PLTS_PER_4K entries. Entries in the first group can
6933 branch directly to .plt; those in later groups branch
6934 to the last element of the previous group. */
6935 /* ??? It would be better to create multiple copies of
6936 the common resolver stub. */
6937 reachable_plts = ((4096
6938 - plt_info->plt0_entry_size
6939 - (plt_info->symbol_fields.plt + 4))
6940 / plt_info->symbol_entry_size) + 1;
6941 plts_per_4k = (4096 / plt_info->symbol_entry_size);
6942 if (plt_index < reachable_plts)
6943 distance = -(h->plt.offset
6944 + plt_info->symbol_fields.plt);
6946 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1)
6947 * plt_info->symbol_entry_size);
6949 /* Install the 'bra' with this offset. */
6950 bfd_put_16 (output_bfd,
6951 0xa000 | (0x0fff & ((distance - 4) / 2)),
6954 + plt_info->symbol_fields.plt));
6957 install_plt_field (output_bfd, TRUE,
6958 splt->output_section->vma + splt->output_offset,
6961 + plt_info->symbol_fields.plt));
6964 /* Make got_offset relative to the start of .got.plt. */
6967 got_offset += GOT_BIAS;
6970 got_offset = plt_index * 8;
6972 if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
6973 install_plt_field (output_bfd, FALSE,
6974 plt_index * sizeof (Elf32_External_Rela),
6977 + plt_info->symbol_fields.reloc_offset));
6979 /* Fill in the entry in the global offset table. */
6980 bfd_put_32 (output_bfd,
6981 (splt->output_section->vma
6982 + splt->output_offset
6984 + plt_info->symbol_resolve_offset),
6985 sgotplt->contents + got_offset);
6987 bfd_put_32 (output_bfd,
6988 sh_elf_osec_to_segment (output_bfd,
6989 htab->splt->output_section),
6990 sgotplt->contents + got_offset + 4);
6992 /* Fill in the entry in the .rela.plt section. */
6993 rel.r_offset = (sgotplt->output_section->vma
6994 + sgotplt->output_offset
6997 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE);
6999 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
7002 rel.r_addend = GOT_BIAS;
7004 loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
7005 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7007 if (htab->vxworks_p && !info->shared)
7009 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7010 Begin by pointing LOC to the first such relocation. */
7011 loc = (htab->srelplt2->contents
7012 + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela));
7014 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7015 for the PLT entry's pointer to the .got.plt entry. */
7016 rel.r_offset = (htab->splt->output_section->vma
7017 + htab->splt->output_offset
7019 + plt_info->symbol_fields.got_entry);
7020 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
7021 rel.r_addend = got_offset;
7022 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7023 loc += sizeof (Elf32_External_Rela);
7025 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7026 the .got.plt entry, which initially points to .plt. */
7027 rel.r_offset = (sgotplt->output_section->vma
7028 + sgotplt->output_offset
7030 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32);
7032 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7035 if (!h->def_regular)
7037 /* Mark the symbol as undefined, rather than as defined in
7038 the .plt section. Leave the value alone. */
7039 sym->st_shndx = SHN_UNDEF;
7043 if (h->got.offset != (bfd_vma) -1
7044 && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD
7045 && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE
7046 && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
7050 Elf_Internal_Rela rel;
7053 /* This symbol has an entry in the global offset table. Set it
7057 srelgot = htab->srelgot;
7058 BFD_ASSERT (sgot != NULL && srelgot != NULL);
7060 rel.r_offset = (sgot->output_section->vma
7061 + sgot->output_offset
7062 + (h->got.offset &~ (bfd_vma) 1));
7064 /* If this is a static link, or it is a -Bsymbolic link and the
7065 symbol is defined locally or was forced to be local because
7066 of a version file, we just want to emit a RELATIVE reloc.
7067 The entry in the global offset table will already have been
7068 initialized in the relocate_section function. */
7070 && SYMBOL_REFERENCES_LOCAL (info, h))
7074 asection *sec = h->root.u.def.section;
7076 = elf_section_data (sec->output_section)->dynindx;
7078 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
7079 rel.r_addend = (h->root.u.def.value
7080 + h->root.u.def.section->output_offset);
7084 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7085 rel.r_addend = (h->root.u.def.value
7086 + h->root.u.def.section->output_section->vma
7087 + h->root.u.def.section->output_offset);
7092 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
7093 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7097 loc = srelgot->contents;
7098 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
7099 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7102 #ifdef INCLUDE_SHMEDIA
7104 struct elf_sh_link_hash_entry *eh;
7106 eh = (struct elf_sh_link_hash_entry *) h;
7107 if (eh->datalabel_got.offset != (bfd_vma) -1)
7111 Elf_Internal_Rela rel;
7114 /* This symbol has a datalabel entry in the global offset table.
7118 srelgot = htab->srelgot;
7119 BFD_ASSERT (sgot != NULL && srelgot != NULL);
7121 rel.r_offset = (sgot->output_section->vma
7122 + sgot->output_offset
7123 + (eh->datalabel_got.offset &~ (bfd_vma) 1));
7125 /* If this is a static link, or it is a -Bsymbolic link and the
7126 symbol is defined locally or was forced to be local because
7127 of a version file, we just want to emit a RELATIVE reloc.
7128 The entry in the global offset table will already have been
7129 initialized in the relocate_section function. */
7131 && SYMBOL_REFERENCES_LOCAL (info, h))
7135 asection *sec = h->root.u.def.section;
7137 = elf_section_data (sec->output_section)->dynindx;
7139 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
7140 rel.r_addend = (h->root.u.def.value
7141 + h->root.u.def.section->output_offset);
7145 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7146 rel.r_addend = (h->root.u.def.value
7147 + h->root.u.def.section->output_section->vma
7148 + h->root.u.def.section->output_offset);
7153 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7154 + eh->datalabel_got.offset);
7155 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7159 loc = srelgot->contents;
7160 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
7161 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7169 Elf_Internal_Rela rel;
7172 /* This symbol needs a copy reloc. Set it up. */
7174 BFD_ASSERT (h->dynindx != -1
7175 && (h->root.type == bfd_link_hash_defined
7176 || h->root.type == bfd_link_hash_defweak));
7178 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7180 BFD_ASSERT (s != NULL);
7182 rel.r_offset = (h->root.u.def.value
7183 + h->root.u.def.section->output_section->vma
7184 + h->root.u.def.section->output_offset);
7185 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7187 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7188 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7191 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7192 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7194 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7195 || (!htab->vxworks_p && h == htab->root.hgot))
7196 sym->st_shndx = SHN_ABS;
7201 /* Finish up the dynamic sections. */
7204 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
7206 struct elf_sh_link_hash_table *htab;
7210 htab = sh_elf_hash_table (info);
7214 sgotplt = htab->sgotplt;
7215 sdyn = bfd_get_section_by_name (htab->root.dynobj, ".dynamic");
7217 if (htab->root.dynamic_sections_created)
7220 Elf32_External_Dyn *dyncon, *dynconend;
7222 BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
7224 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7225 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7226 for (; dyncon < dynconend; dyncon++)
7228 Elf_Internal_Dyn dyn;
7230 #ifdef INCLUDE_SHMEDIA
7234 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
7240 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7241 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7244 #ifdef INCLUDE_SHMEDIA
7246 name = info->init_function;
7250 name = info->fini_function;
7252 if (dyn.d_un.d_val != 0)
7254 struct elf_link_hash_entry *h;
7256 h = elf_link_hash_lookup (&htab->root, name,
7257 FALSE, FALSE, TRUE);
7258 if (h != NULL && (h->other & STO_SH5_ISA32))
7260 dyn.d_un.d_val |= 1;
7261 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7268 BFD_ASSERT (htab->root.hgot != NULL);
7269 s = htab->root.hgot->root.u.def.section;
7270 dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value
7271 + s->output_section->vma + s->output_offset;
7272 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7276 s = htab->srelplt->output_section;
7277 BFD_ASSERT (s != NULL);
7278 dyn.d_un.d_ptr = s->vma;
7279 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7283 s = htab->srelplt->output_section;
7284 BFD_ASSERT (s != NULL);
7285 dyn.d_un.d_val = s->size;
7286 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7290 /* My reading of the SVR4 ABI indicates that the
7291 procedure linkage table relocs (DT_JMPREL) should be
7292 included in the overall relocs (DT_RELA). This is
7293 what Solaris does. However, UnixWare can not handle
7294 that case. Therefore, we override the DT_RELASZ entry
7295 here to make it not include the JMPREL relocs. Since
7296 the linker script arranges for .rela.plt to follow all
7297 other relocation sections, we don't have to worry
7298 about changing the DT_RELA entry. */
7299 if (htab->srelplt != NULL)
7301 s = htab->srelplt->output_section;
7302 dyn.d_un.d_val -= s->size;
7304 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7309 /* Fill in the first entry in the procedure linkage table. */
7311 if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
7315 memcpy (splt->contents,
7316 htab->plt_info->plt0_entry,
7317 htab->plt_info->plt0_entry_size);
7318 for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
7319 if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
7320 install_plt_field (output_bfd, FALSE,
7321 (sgotplt->output_section->vma
7322 + sgotplt->output_offset
7325 + htab->plt_info->plt0_got_fields[i]));
7327 if (htab->vxworks_p)
7329 /* Finalize the .rela.plt.unloaded contents. */
7330 Elf_Internal_Rela rel;
7333 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7334 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7335 loc = htab->srelplt2->contents;
7336 rel.r_offset = (splt->output_section->vma
7337 + splt->output_offset
7338 + htab->plt_info->plt0_got_fields[2]);
7339 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
7341 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7342 loc += sizeof (Elf32_External_Rela);
7344 /* Fix up the remaining .rela.plt.unloaded relocations.
7345 They may have the wrong symbol index for _G_O_T_ or
7346 _P_L_T_ depending on the order in which symbols were
7348 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
7350 /* The PLT entry's pointer to the .got.plt slot. */
7351 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7352 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx,
7354 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7355 loc += sizeof (Elf32_External_Rela);
7357 /* The .got.plt slot's pointer to .plt. */
7358 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
7359 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx,
7361 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
7362 loc += sizeof (Elf32_External_Rela);
7366 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7367 really seem like the right value. */
7368 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7372 /* Fill in the first three entries in the global offset table. */
7373 if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p)
7376 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
7378 bfd_put_32 (output_bfd,
7379 sdyn->output_section->vma + sdyn->output_offset,
7381 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
7382 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
7385 if (sgotplt && sgotplt->size > 0)
7386 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
7388 /* At the very end of the .rofixup section is a pointer to the GOT. */
7389 if (htab->fdpic_p && htab->srofixup != NULL)
7391 struct elf_link_hash_entry *hgot = htab->root.hgot;
7392 bfd_vma got_value = hgot->root.u.def.value
7393 + hgot->root.u.def.section->output_section->vma
7394 + hgot->root.u.def.section->output_offset;
7396 sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
7398 /* Make sure we allocated and generated the same number of fixups. */
7399 BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
7402 if (htab->srelfuncdesc)
7403 BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
7404 == htab->srelfuncdesc->size);
7407 BFD_ASSERT (htab->srelgot->reloc_count * sizeof (Elf32_External_Rela)
7408 == htab->srelgot->size);
7413 static enum elf_reloc_type_class
7414 sh_elf_reloc_type_class (const Elf_Internal_Rela *rela)
7416 switch ((int) ELF32_R_TYPE (rela->r_info))
7419 return reloc_class_relative;
7421 return reloc_class_plt;
7423 return reloc_class_copy;
7425 return reloc_class_normal;
7429 #if !defined SH_TARGET_ALREADY_DEFINED
7430 /* Support for Linux core dump NOTE sections. */
7433 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7438 switch (note->descsz)
7443 case 168: /* Linux/SH */
7445 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7448 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7457 /* Make a ".reg/999" section. */
7458 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7459 size, note->descpos + offset);
7463 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7465 switch (note->descsz)
7470 case 124: /* Linux/SH elf_prpsinfo */
7471 elf_tdata (abfd)->core_program
7472 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7473 elf_tdata (abfd)->core_command
7474 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7477 /* Note that for some reason, a spurious space is tacked
7478 onto the end of the args in some (at least one anyway)
7479 implementations, so strip it off if it exists. */
7482 char *command = elf_tdata (abfd)->core_command;
7483 int n = strlen (command);
7485 if (0 < n && command[n - 1] == ' ')
7486 command[n - 1] = '\0';
7491 #endif /* not SH_TARGET_ALREADY_DEFINED */
7494 /* Return address for Ith PLT stub in section PLT, for relocation REL
7495 or (bfd_vma) -1 if it should not be included. */
7498 sh_elf_plt_sym_val (bfd_vma i, const asection *plt,
7499 const arelent *rel ATTRIBUTE_UNUSED)
7501 const struct elf_sh_plt_info *plt_info;
7503 plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0);
7504 return plt->vma + get_plt_offset (plt_info, i);
7507 /* Decide whether to attempt to turn absptr or lsda encodings in
7508 shared libraries into pcrel within the given input section. */
7511 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
7512 struct bfd_link_info *info,
7513 asection *eh_frame_section ATTRIBUTE_UNUSED)
7515 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7517 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7524 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7527 sh_elf_encode_eh_address (bfd *abfd,
7528 struct bfd_link_info *info,
7529 asection *osec, bfd_vma offset,
7530 asection *loc_sec, bfd_vma loc_offset,
7533 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
7534 struct elf_link_hash_entry *h;
7537 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec,
7538 loc_offset, encoded);
7540 h = htab->root.hgot;
7541 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
7543 if (! h || (sh_elf_osec_to_segment (abfd, osec)
7544 == sh_elf_osec_to_segment (abfd, loc_sec->output_section)))
7545 return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
7546 loc_sec, loc_offset, encoded);
7548 BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec)
7549 == (sh_elf_osec_to_segment
7550 (abfd, h->root.u.def.section->output_section)));
7552 *encoded = osec->vma + offset
7553 - (h->root.u.def.value
7554 + h->root.u.def.section->output_section->vma
7555 + h->root.u.def.section->output_offset);
7557 return DW_EH_PE_datarel | DW_EH_PE_sdata4;
7560 #if !defined SH_TARGET_ALREADY_DEFINED
7561 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7562 #define TARGET_BIG_NAME "elf32-sh"
7563 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7564 #define TARGET_LITTLE_NAME "elf32-shl"
7567 #define ELF_ARCH bfd_arch_sh
7568 #define ELF_MACHINE_CODE EM_SH
7569 #ifdef __QNXTARGET__
7570 #define ELF_MAXPAGESIZE 0x1000
7572 #define ELF_MAXPAGESIZE 0x80
7575 #define elf_symbol_leading_char '_'
7577 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7578 #define bfd_elf32_bfd_reloc_name_lookup \
7579 sh_elf_reloc_name_lookup
7580 #define elf_info_to_howto sh_elf_info_to_howto
7581 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7582 #define elf_backend_relocate_section sh_elf_relocate_section
7583 #define bfd_elf32_bfd_get_relocated_section_contents \
7584 sh_elf_get_relocated_section_contents
7585 #define bfd_elf32_mkobject sh_elf_mkobject
7586 #define elf_backend_object_p sh_elf_object_p
7587 #define bfd_elf32_bfd_set_private_bfd_flags \
7588 sh_elf_set_private_flags
7589 #define bfd_elf32_bfd_copy_private_bfd_data \
7590 sh_elf_copy_private_data
7591 #define bfd_elf32_bfd_merge_private_bfd_data \
7592 sh_elf_merge_private_data
7594 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7595 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7596 #define elf_backend_check_relocs sh_elf_check_relocs
7597 #define elf_backend_copy_indirect_symbol \
7598 sh_elf_copy_indirect_symbol
7599 #define elf_backend_create_dynamic_sections \
7600 sh_elf_create_dynamic_sections
7601 #define bfd_elf32_bfd_link_hash_table_create \
7602 sh_elf_link_hash_table_create
7603 #define elf_backend_adjust_dynamic_symbol \
7604 sh_elf_adjust_dynamic_symbol
7605 #define elf_backend_always_size_sections \
7606 sh_elf_always_size_sections
7607 #define elf_backend_size_dynamic_sections \
7608 sh_elf_size_dynamic_sections
7609 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7610 #define elf_backend_finish_dynamic_symbol \
7611 sh_elf_finish_dynamic_symbol
7612 #define elf_backend_finish_dynamic_sections \
7613 sh_elf_finish_dynamic_sections
7614 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7615 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7616 #define elf_backend_can_make_relative_eh_frame \
7617 sh_elf_use_relative_eh_frame
7618 #define elf_backend_can_make_lsda_relative_eh_frame \
7619 sh_elf_use_relative_eh_frame
7620 #define elf_backend_encode_eh_address \
7621 sh_elf_encode_eh_address
7623 #define elf_backend_can_gc_sections 1
7624 #define elf_backend_can_refcount 1
7625 #define elf_backend_want_got_plt 1
7626 #define elf_backend_plt_readonly 1
7627 #define elf_backend_want_plt_sym 0
7628 #define elf_backend_got_header_size 12
7630 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7632 #include "elf32-target.h"
7634 /* NetBSD support. */
7635 #undef TARGET_BIG_SYM
7636 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7637 #undef TARGET_BIG_NAME
7638 #define TARGET_BIG_NAME "elf32-sh-nbsd"
7639 #undef TARGET_LITTLE_SYM
7640 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7641 #undef TARGET_LITTLE_NAME
7642 #define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7643 #undef ELF_MAXPAGESIZE
7644 #define ELF_MAXPAGESIZE 0x10000
7645 #undef ELF_COMMONPAGESIZE
7646 #undef elf_symbol_leading_char
7647 #define elf_symbol_leading_char 0
7649 #define elf32_bed elf32_sh_nbsd_bed
7651 #include "elf32-target.h"
7654 /* Linux support. */
7655 #undef TARGET_BIG_SYM
7656 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7657 #undef TARGET_BIG_NAME
7658 #define TARGET_BIG_NAME "elf32-shbig-linux"
7659 #undef TARGET_LITTLE_SYM
7660 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7661 #undef TARGET_LITTLE_NAME
7662 #define TARGET_LITTLE_NAME "elf32-sh-linux"
7663 #undef ELF_COMMONPAGESIZE
7664 #define ELF_COMMONPAGESIZE 0x1000
7666 #undef elf_backend_grok_prstatus
7667 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7668 #undef elf_backend_grok_psinfo
7669 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7671 #define elf32_bed elf32_sh_lin_bed
7673 #include "elf32-target.h"
7676 /* FDPIC support. */
7677 #undef TARGET_BIG_SYM
7678 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7679 #undef TARGET_BIG_NAME
7680 #define TARGET_BIG_NAME "elf32-shbig-fdpic"
7681 #undef TARGET_LITTLE_SYM
7682 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7683 #undef TARGET_LITTLE_NAME
7684 #define TARGET_LITTLE_NAME "elf32-sh-fdpic"
7685 #undef elf_backend_modify_program_headers
7686 #define elf_backend_modify_program_headers \
7687 sh_elf_modify_program_headers
7690 #define elf32_bed elf32_sh_fd_bed
7692 #include "elf32-target.h"
7694 #undef elf_backend_modify_program_headers
7696 /* VxWorks support. */
7697 #undef TARGET_BIG_SYM
7698 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7699 #undef TARGET_BIG_NAME
7700 #define TARGET_BIG_NAME "elf32-sh-vxworks"
7701 #undef TARGET_LITTLE_SYM
7702 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7703 #undef TARGET_LITTLE_NAME
7704 #define TARGET_LITTLE_NAME "elf32-shl-vxworks"
7706 #define elf32_bed elf32_sh_vxworks_bed
7708 #undef elf_backend_want_plt_sym
7709 #define elf_backend_want_plt_sym 1
7710 #undef elf_symbol_leading_char
7711 #define elf_symbol_leading_char '_'
7712 #define elf_backend_want_got_underscore 1
7713 #undef elf_backend_grok_prstatus
7714 #undef elf_backend_grok_psinfo
7715 #undef elf_backend_add_symbol_hook
7716 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7717 #undef elf_backend_link_output_symbol_hook
7718 #define elf_backend_link_output_symbol_hook \
7719 elf_vxworks_link_output_symbol_hook
7720 #undef elf_backend_emit_relocs
7721 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7722 #undef elf_backend_final_write_processing
7723 #define elf_backend_final_write_processing \
7724 elf_vxworks_final_write_processing
7725 #undef ELF_MAXPAGESIZE
7726 #define ELF_MAXPAGESIZE 0x1000
7727 #undef ELF_COMMONPAGESIZE
7729 #include "elf32-target.h"
7731 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */