1 /* Hitachi SH specific support for 32-bit ELF
2 Copyright 1996, 97, 98, 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 static bfd_reloc_status_type sh_elf_reloc
29 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
30 static bfd_reloc_status_type sh_elf_ignore_reloc
31 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
32 static reloc_howto_type *sh_elf_reloc_type_lookup
33 PARAMS ((bfd *, bfd_reloc_code_real_type));
34 static void sh_elf_info_to_howto
35 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
36 static boolean sh_elf_set_private_flags
37 PARAMS ((bfd *, flagword));
38 static boolean sh_elf_copy_private_data
39 PARAMS ((bfd *, bfd *));
40 static boolean sh_elf_merge_private_data
41 PARAMS ((bfd *, bfd *));
42 boolean sh_elf_set_mach_from_flags
44 static boolean sh_elf_relax_section
45 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
46 static boolean sh_elf_relax_delete_bytes
47 PARAMS ((bfd *, asection *, bfd_vma, int));
48 static boolean sh_elf_align_loads
49 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *));
50 static boolean sh_elf_swap_insns
51 PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
52 static boolean sh_elf_relocate_section
53 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
54 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
55 static bfd_byte *sh_elf_get_relocated_section_contents
56 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
57 bfd_byte *, boolean, asymbol **));
59 static reloc_howto_type sh_elf_howto_table[] =
62 HOWTO (R_SH_NONE, /* type */
64 0, /* size (0 = byte, 1 = short, 2 = long) */
66 false, /* pc_relative */
68 complain_overflow_dont, /* complain_on_overflow */
69 sh_elf_reloc, /* special_function */
70 "R_SH_NONE", /* name */
71 false, /* partial_inplace */
74 false), /* pcrel_offset */
76 /* 32 bit absolute relocation. Setting partial_inplace to true and
77 src_mask to a non-zero value is similar to the COFF toolchain. */
78 HOWTO (R_SH_DIR32, /* type */
80 2, /* size (0 = byte, 1 = short, 2 = long) */
82 false, /* pc_relative */
84 complain_overflow_bitfield, /* complain_on_overflow */
85 sh_elf_reloc, /* special_function */
86 "R_SH_DIR32", /* name */
87 true, /* partial_inplace */
88 0xffffffff, /* src_mask */
89 0xffffffff, /* dst_mask */
90 false), /* pcrel_offset */
92 /* 32 bit PC relative relocation. */
93 HOWTO (R_SH_REL32, /* type */
95 2, /* size (0 = byte, 1 = short, 2 = long) */
97 true, /* pc_relative */
99 complain_overflow_signed, /* complain_on_overflow */
100 sh_elf_reloc, /* special_function */
101 "R_SH_REL32", /* name */
102 false, /* partial_inplace */
104 0xffffffff, /* dst_mask */
105 true), /* pcrel_offset */
107 /* 8 bit PC relative branch divided by 2. */
108 HOWTO (R_SH_DIR8WPN, /* type */
110 1, /* size (0 = byte, 1 = short, 2 = long) */
112 true, /* pc_relative */
114 complain_overflow_signed, /* complain_on_overflow */
115 sh_elf_reloc, /* special_function */
116 "R_SH_DIR8WPN", /* name */
117 true, /* partial_inplace */
120 true), /* pcrel_offset */
122 /* 12 bit PC relative branch divided by 2. */
123 HOWTO (R_SH_IND12W, /* type */
125 1, /* size (0 = byte, 1 = short, 2 = long) */
127 true, /* pc_relative */
129 complain_overflow_signed, /* complain_on_overflow */
130 sh_elf_reloc, /* special_function */
131 "R_SH_IND12W", /* name */
132 true, /* partial_inplace */
133 0xfff, /* src_mask */
134 0xfff, /* dst_mask */
135 true), /* pcrel_offset */
137 /* 8 bit unsigned PC relative divided by 4. */
138 HOWTO (R_SH_DIR8WPL, /* type */
140 1, /* size (0 = byte, 1 = short, 2 = long) */
142 true, /* pc_relative */
144 complain_overflow_unsigned, /* complain_on_overflow */
145 sh_elf_reloc, /* special_function */
146 "R_SH_DIR8WPL", /* name */
147 true, /* partial_inplace */
150 true), /* pcrel_offset */
152 /* 8 bit unsigned PC relative divided by 2. */
153 HOWTO (R_SH_DIR8WPZ, /* type */
155 1, /* size (0 = byte, 1 = short, 2 = long) */
157 true, /* pc_relative */
159 complain_overflow_unsigned, /* complain_on_overflow */
160 sh_elf_reloc, /* special_function */
161 "R_SH_DIR8WPZ", /* name */
162 true, /* partial_inplace */
165 true), /* pcrel_offset */
167 /* 8 bit GBR relative. FIXME: This only makes sense if we have some
168 special symbol for the GBR relative area, and that is not
170 HOWTO (R_SH_DIR8BP, /* type */
172 1, /* size (0 = byte, 1 = short, 2 = long) */
174 false, /* pc_relative */
176 complain_overflow_unsigned, /* complain_on_overflow */
177 sh_elf_reloc, /* special_function */
178 "R_SH_DIR8BP", /* name */
179 false, /* partial_inplace */
182 true), /* pcrel_offset */
184 /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if
185 we have some special symbol for the GBR relative area, and that
186 is not implemented. */
187 HOWTO (R_SH_DIR8W, /* type */
189 1, /* size (0 = byte, 1 = short, 2 = long) */
191 false, /* pc_relative */
193 complain_overflow_unsigned, /* complain_on_overflow */
194 sh_elf_reloc, /* special_function */
195 "R_SH_DIR8W", /* name */
196 false, /* partial_inplace */
199 true), /* pcrel_offset */
201 /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if
202 we have some special symbol for the GBR relative area, and that
203 is not implemented. */
204 HOWTO (R_SH_DIR8L, /* type */
206 1, /* size (0 = byte, 1 = short, 2 = long) */
208 false, /* pc_relative */
210 complain_overflow_unsigned, /* complain_on_overflow */
211 sh_elf_reloc, /* special_function */
212 "R_SH_DIR8L", /* name */
213 false, /* partial_inplace */
216 true), /* pcrel_offset */
234 /* The remaining relocs are a GNU extension used for relaxing. The
235 final pass of the linker never needs to do anything with any of
236 these relocs. Any required operations are handled by the
239 /* A 16 bit switch table entry. This is generated for an expression
240 such as ``.word L1 - L2''. The offset holds the difference
241 between the reloc address and L2. */
242 HOWTO (R_SH_SWITCH16, /* type */
244 1, /* size (0 = byte, 1 = short, 2 = long) */
246 false, /* pc_relative */
248 complain_overflow_unsigned, /* complain_on_overflow */
249 sh_elf_ignore_reloc, /* special_function */
250 "R_SH_SWITCH16", /* name */
251 false, /* partial_inplace */
254 true), /* pcrel_offset */
256 /* A 32 bit switch table entry. This is generated for an expression
257 such as ``.long L1 - L2''. The offset holds the difference
258 between the reloc address and L2. */
259 HOWTO (R_SH_SWITCH32, /* type */
261 2, /* size (0 = byte, 1 = short, 2 = long) */
263 false, /* pc_relative */
265 complain_overflow_unsigned, /* complain_on_overflow */
266 sh_elf_ignore_reloc, /* special_function */
267 "R_SH_SWITCH32", /* name */
268 false, /* partial_inplace */
271 true), /* pcrel_offset */
273 /* Indicates a .uses pseudo-op. The compiler will generate .uses
274 pseudo-ops when it finds a function call which can be relaxed.
275 The offset field holds the PC relative offset to the instruction
276 which loads the register used in the function call. */
277 HOWTO (R_SH_USES, /* type */
279 1, /* size (0 = byte, 1 = short, 2 = long) */
281 false, /* pc_relative */
283 complain_overflow_unsigned, /* complain_on_overflow */
284 sh_elf_ignore_reloc, /* special_function */
285 "R_SH_USES", /* name */
286 false, /* partial_inplace */
289 true), /* pcrel_offset */
291 /* The assembler will generate this reloc for addresses referred to
292 by the register loads associated with USES relocs. The offset
293 field holds the number of times the address is referenced in the
295 HOWTO (R_SH_COUNT, /* type */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
299 false, /* pc_relative */
301 complain_overflow_unsigned, /* complain_on_overflow */
302 sh_elf_ignore_reloc, /* special_function */
303 "R_SH_COUNT", /* name */
304 false, /* partial_inplace */
307 true), /* pcrel_offset */
309 /* Indicates an alignment statement. The offset field is the power
310 of 2 to which subsequent portions of the object file must be
312 HOWTO (R_SH_ALIGN, /* type */
314 1, /* size (0 = byte, 1 = short, 2 = long) */
316 false, /* pc_relative */
318 complain_overflow_unsigned, /* complain_on_overflow */
319 sh_elf_ignore_reloc, /* special_function */
320 "R_SH_ALIGN", /* name */
321 false, /* partial_inplace */
324 true), /* pcrel_offset */
326 /* The assembler will generate this reloc before a block of
327 instructions. A section should be processed as assumining it
328 contains data, unless this reloc is seen. */
329 HOWTO (R_SH_CODE, /* type */
331 1, /* size (0 = byte, 1 = short, 2 = long) */
333 false, /* pc_relative */
335 complain_overflow_unsigned, /* complain_on_overflow */
336 sh_elf_ignore_reloc, /* special_function */
337 "R_SH_CODE", /* name */
338 false, /* partial_inplace */
341 true), /* pcrel_offset */
343 /* The assembler will generate this reloc after a block of
344 instructions when it sees data that is not instructions. */
345 HOWTO (R_SH_DATA, /* type */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
349 false, /* pc_relative */
351 complain_overflow_unsigned, /* complain_on_overflow */
352 sh_elf_ignore_reloc, /* special_function */
353 "R_SH_DATA", /* name */
354 false, /* partial_inplace */
357 true), /* pcrel_offset */
359 /* The assembler generates this reloc for each label within a block
360 of instructions. This permits the linker to avoid swapping
361 instructions which are the targets of branches. */
362 HOWTO (R_SH_LABEL, /* type */
364 1, /* size (0 = byte, 1 = short, 2 = long) */
366 false, /* pc_relative */
368 complain_overflow_unsigned, /* complain_on_overflow */
369 sh_elf_ignore_reloc, /* special_function */
370 "R_SH_LABEL", /* name */
371 false, /* partial_inplace */
374 true), /* pcrel_offset */
376 /* An 8 bit switch table entry. This is generated for an expression
377 such as ``.word L1 - L2''. The offset holds the difference
378 between the reloc address and L2. */
379 HOWTO (R_SH_SWITCH8, /* type */
381 0, /* size (0 = byte, 1 = short, 2 = long) */
383 false, /* pc_relative */
385 complain_overflow_unsigned, /* complain_on_overflow */
386 sh_elf_ignore_reloc, /* special_function */
387 "R_SH_SWITCH8", /* name */
388 false, /* partial_inplace */
391 true), /* pcrel_offset */
393 /* GNU extension to record C++ vtable hierarchy */
394 HOWTO (R_SH_GNU_VTINHERIT, /* type */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
398 false, /* pc_relative */
400 complain_overflow_dont, /* complain_on_overflow */
401 NULL, /* special_function */
402 "R_SH_GNU_VTINHERIT", /* name */
403 false, /* partial_inplace */
406 false), /* pcrel_offset */
408 /* GNU extension to record C++ vtable member usage */
409 HOWTO (R_SH_GNU_VTENTRY, /* type */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
413 false, /* pc_relative */
415 complain_overflow_dont, /* complain_on_overflow */
416 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
417 "R_SH_GNU_VTENTRY", /* name */
418 false, /* partial_inplace */
421 false), /* pcrel_offset */
425 /* This function is used for normal relocs. This is like the COFF
426 function, and is almost certainly incorrect for other ELF targets. */
428 static bfd_reloc_status_type
429 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
432 arelent *reloc_entry;
435 asection *input_section;
437 char **error_message ATTRIBUTE_UNUSED;
441 enum elf_sh_reloc_type r_type;
442 bfd_vma addr = reloc_entry->address;
443 bfd_byte *hit_data = addr + (bfd_byte *) data;
445 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
447 if (output_bfd != NULL)
449 /* Partial linking--do nothing. */
450 reloc_entry->address += input_section->output_offset;
454 /* Almost all relocs have to do with relaxing. If any work must be
455 done for them, it has been done in sh_relax_section. */
456 if (r_type != R_SH_DIR32
457 && (r_type != R_SH_IND12W
458 || (symbol_in->flags & BSF_LOCAL) != 0))
461 if (symbol_in != NULL
462 && bfd_is_und_section (symbol_in->section))
463 return bfd_reloc_undefined;
465 if (bfd_is_com_section (symbol_in->section))
468 sym_value = (symbol_in->value +
469 symbol_in->section->output_section->vma +
470 symbol_in->section->output_offset);
475 insn = bfd_get_32 (abfd, hit_data);
476 insn += sym_value + reloc_entry->addend;
477 bfd_put_32 (abfd, insn, hit_data);
480 insn = bfd_get_16 (abfd, hit_data);
481 sym_value += reloc_entry->addend;
482 sym_value -= (input_section->output_section->vma
483 + input_section->output_offset
486 sym_value += (insn & 0xfff) << 1;
489 insn = (insn & 0xf000) | (sym_value & 0xfff);
490 bfd_put_16 (abfd, insn, hit_data);
491 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
492 return bfd_reloc_overflow;
502 /* This function is used for relocs which are only used for relaxing,
503 which the linker should otherwise ignore. */
505 static bfd_reloc_status_type
506 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
507 output_bfd, error_message)
508 bfd *abfd ATTRIBUTE_UNUSED;
509 arelent *reloc_entry;
510 asymbol *symbol ATTRIBUTE_UNUSED;
511 PTR data ATTRIBUTE_UNUSED;
512 asection *input_section;
514 char **error_message ATTRIBUTE_UNUSED;
516 if (output_bfd != NULL)
517 reloc_entry->address += input_section->output_offset;
521 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
525 bfd_reloc_code_real_type bfd_reloc_val;
526 unsigned char elf_reloc_val;
529 /* An array mapping BFD reloc codes to SH ELF relocs. */
531 static const struct elf_reloc_map sh_reloc_map[] =
533 { BFD_RELOC_NONE, R_SH_NONE },
534 { BFD_RELOC_32, R_SH_DIR32 },
535 { BFD_RELOC_CTOR, R_SH_DIR32 },
536 { BFD_RELOC_32_PCREL, R_SH_REL32 },
537 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
538 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
539 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
540 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
541 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
542 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
543 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
544 { BFD_RELOC_SH_USES, R_SH_USES },
545 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
546 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
547 { BFD_RELOC_SH_CODE, R_SH_CODE },
548 { BFD_RELOC_SH_DATA, R_SH_DATA },
549 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
550 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
551 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
554 /* Given a BFD reloc code, return the howto structure for the
555 corresponding SH ELf reloc. */
557 static reloc_howto_type *
558 sh_elf_reloc_type_lookup (abfd, code)
559 bfd *abfd ATTRIBUTE_UNUSED;
560 bfd_reloc_code_real_type code;
564 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
566 if (sh_reloc_map[i].bfd_reloc_val == code)
567 return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
573 /* Given an ELF reloc, fill in the howto field of a relent. */
576 sh_elf_info_to_howto (abfd, cache_ptr, dst)
577 bfd *abfd ATTRIBUTE_UNUSED;
579 Elf_Internal_Rela *dst;
583 r = ELF32_R_TYPE (dst->r_info);
585 BFD_ASSERT (r < (unsigned int) R_SH_max);
586 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
588 cache_ptr->howto = &sh_elf_howto_table[r];
591 /* This function handles relaxing for SH ELF. See the corresponding
592 function in coff-sh.c for a description of what this does. FIXME:
593 There is a lot of duplication here between this code and the COFF
594 specific code. The format of relocs and symbols is wound deeply
595 into this code, but it would still be better if the duplication
596 could be eliminated somehow. Note in particular that although both
597 functions use symbols like R_SH_CODE, those symbols have different
598 values; in coff-sh.c they come from include/coff/sh.h, whereas here
599 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
602 sh_elf_relax_section (abfd, sec, link_info, again)
605 struct bfd_link_info *link_info;
608 Elf_Internal_Shdr *symtab_hdr;
609 Elf_Internal_Rela *internal_relocs;
610 Elf_Internal_Rela *free_relocs = NULL;
612 Elf_Internal_Rela *irel, *irelend;
613 bfd_byte *contents = NULL;
614 bfd_byte *free_contents = NULL;
615 Elf32_External_Sym *extsyms = NULL;
616 Elf32_External_Sym *free_extsyms = NULL;
620 if (link_info->relocateable
621 || (sec->flags & SEC_RELOC) == 0
622 || sec->reloc_count == 0)
625 /* If this is the first time we have been called for this section,
626 initialize the cooked size. */
627 if (sec->_cooked_size == 0)
628 sec->_cooked_size = sec->_raw_size;
630 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
632 internal_relocs = (_bfd_elf32_link_read_relocs
633 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
634 link_info->keep_memory));
635 if (internal_relocs == NULL)
637 if (! link_info->keep_memory)
638 free_relocs = internal_relocs;
642 irelend = internal_relocs + sec->reloc_count;
643 for (irel = internal_relocs; irel < irelend; irel++)
645 bfd_vma laddr, paddr, symval;
647 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
650 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
653 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
656 /* Get the section contents. */
657 if (contents == NULL)
659 if (elf_section_data (sec)->this_hdr.contents != NULL)
660 contents = elf_section_data (sec)->this_hdr.contents;
663 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
664 if (contents == NULL)
666 free_contents = contents;
668 if (! bfd_get_section_contents (abfd, sec, contents,
669 (file_ptr) 0, sec->_raw_size))
674 /* The r_addend field of the R_SH_USES reloc will point us to
675 the register load. The 4 is because the r_addend field is
676 computed as though it were a jump offset, which are based
677 from 4 bytes after the jump instruction. */
678 laddr = irel->r_offset + 4 + irel->r_addend;
679 if (laddr >= sec->_raw_size)
681 (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
682 bfd_get_filename (abfd),
683 (unsigned long) irel->r_offset);
686 insn = bfd_get_16 (abfd, contents + laddr);
688 /* If the instruction is not mov.l NN,rN, we don't know what to
690 if ((insn & 0xf000) != 0xd000)
692 ((*_bfd_error_handler)
693 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
694 bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn));
698 /* Get the address from which the register is being loaded. The
699 displacement in the mov.l instruction is quadrupled. It is a
700 displacement from four bytes after the movl instruction, but,
701 before adding in the PC address, two least significant bits
702 of the PC are cleared. We assume that the section is aligned
703 on a four byte boundary. */
706 paddr += (laddr + 4) &~ 3;
707 if (paddr >= sec->_raw_size)
709 ((*_bfd_error_handler)
710 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
711 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
715 /* Get the reloc for the address from which the register is
716 being loaded. This reloc will tell us which function is
717 actually being called. */
718 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
719 if (irelfn->r_offset == paddr
720 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
722 if (irelfn >= irelend)
724 ((*_bfd_error_handler)
725 (_("%s: 0x%lx: warning: could not find expected reloc"),
726 bfd_get_filename (abfd), (unsigned long) paddr));
730 /* Read this BFD's symbols if we haven't done so already. */
733 if (symtab_hdr->contents != NULL)
734 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
737 extsyms = ((Elf32_External_Sym *)
738 bfd_malloc (symtab_hdr->sh_size));
741 free_extsyms = extsyms;
742 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
743 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
744 != symtab_hdr->sh_size))
749 /* Get the value of the symbol referred to by the reloc. */
750 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
752 Elf_Internal_Sym isym;
754 /* A local symbol. */
755 bfd_elf32_swap_symbol_in (abfd,
756 extsyms + ELF32_R_SYM (irelfn->r_info),
759 if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
761 ((*_bfd_error_handler)
762 (_("%s: 0x%lx: warning: symbol in unexpected section"),
763 bfd_get_filename (abfd), (unsigned long) paddr));
767 symval = (isym.st_value
768 + sec->output_section->vma
769 + sec->output_offset);
774 struct elf_link_hash_entry *h;
776 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
777 h = elf_sym_hashes (abfd)[indx];
778 BFD_ASSERT (h != NULL);
779 if (h->root.type != bfd_link_hash_defined
780 && h->root.type != bfd_link_hash_defweak)
782 /* This appears to be a reference to an undefined
783 symbol. Just ignore it--it will be caught by the
784 regular reloc processing. */
788 symval = (h->root.u.def.value
789 + h->root.u.def.section->output_section->vma
790 + h->root.u.def.section->output_offset);
793 symval += bfd_get_32 (abfd, contents + paddr);
795 /* See if this function call can be shortened. */
798 + sec->output_section->vma
801 if (foff < -0x1000 || foff >= 0x1000)
803 /* After all that work, we can't shorten this function call. */
807 /* Shorten the function call. */
809 /* For simplicity of coding, we are going to modify the section
810 contents, the section relocs, and the BFD symbol table. We
811 must tell the rest of the code not to free up this
812 information. It would be possible to instead create a table
813 of changes which have to be made, as is done in coff-mips.c;
814 that would be more work, but would require less memory when
815 the linker is run. */
817 elf_section_data (sec)->relocs = internal_relocs;
820 elf_section_data (sec)->this_hdr.contents = contents;
821 free_contents = NULL;
823 symtab_hdr->contents = (bfd_byte *) extsyms;
826 /* Replace the jsr with a bsr. */
828 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
829 replace the jsr with a bsr. */
830 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
831 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
833 /* If this needs to be changed because of future relaxing,
834 it will be handled here like other internal IND12W
837 0xb000 | ((foff >> 1) & 0xfff),
838 contents + irel->r_offset);
842 /* We can't fully resolve this yet, because the external
843 symbol value may be changed by future relaxing. We let
844 the final link phase handle it. */
845 bfd_put_16 (abfd, 0xb000, contents + irel->r_offset);
848 /* See if there is another R_SH_USES reloc referring to the same
850 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
851 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
852 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
854 if (irelscan < irelend)
856 /* Some other function call depends upon this register load,
857 and we have not yet converted that function call.
858 Indeed, we may never be able to convert it. There is
859 nothing else we can do at this point. */
863 /* Look for a R_SH_COUNT reloc on the location where the
864 function address is stored. Do this before deleting any
865 bytes, to avoid confusion about the address. */
866 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
867 if (irelcount->r_offset == paddr
868 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
871 /* Delete the register load. */
872 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
875 /* That will change things, so, just in case it permits some
876 other function call to come within range, we should relax
877 again. Note that this is not required, and it may be slow. */
880 /* Now check whether we got a COUNT reloc. */
881 if (irelcount >= irelend)
883 ((*_bfd_error_handler)
884 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
885 bfd_get_filename (abfd), (unsigned long) paddr));
889 /* The number of uses is stored in the r_addend field. We've
891 if (irelcount->r_addend == 0)
893 ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
894 bfd_get_filename (abfd),
895 (unsigned long) paddr));
899 --irelcount->r_addend;
901 /* If there are no more uses, we can delete the address. Reload
902 the address from irelfn, in case it was changed by the
903 previous call to sh_elf_relax_delete_bytes. */
904 if (irelcount->r_addend == 0)
906 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
910 /* We've done all we can with that function call. */
913 /* Look for load and store instructions that we can align on four
919 /* Get the section contents. */
920 if (contents == NULL)
922 if (elf_section_data (sec)->this_hdr.contents != NULL)
923 contents = elf_section_data (sec)->this_hdr.contents;
926 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
927 if (contents == NULL)
929 free_contents = contents;
931 if (! bfd_get_section_contents (abfd, sec, contents,
932 (file_ptr) 0, sec->_raw_size))
937 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
943 elf_section_data (sec)->relocs = internal_relocs;
946 elf_section_data (sec)->this_hdr.contents = contents;
947 free_contents = NULL;
949 symtab_hdr->contents = (bfd_byte *) extsyms;
954 if (free_relocs != NULL)
960 if (free_contents != NULL)
962 if (! link_info->keep_memory)
963 free (free_contents);
966 /* Cache the section contents for elf_link_input_bfd. */
967 elf_section_data (sec)->this_hdr.contents = contents;
969 free_contents = NULL;
972 if (free_extsyms != NULL)
974 if (! link_info->keep_memory)
978 /* Cache the symbols for elf_link_input_bfd. */
979 symtab_hdr->contents = extsyms;
987 if (free_relocs != NULL)
989 if (free_contents != NULL)
990 free (free_contents);
991 if (free_extsyms != NULL)
996 /* Delete some bytes from a section while relaxing. FIXME: There is a
997 lot of duplication between this function and sh_relax_delete_bytes
1001 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
1007 Elf_Internal_Shdr *symtab_hdr;
1008 Elf32_External_Sym *extsyms;
1011 Elf_Internal_Rela *irel, *irelend;
1012 Elf_Internal_Rela *irelalign;
1014 Elf32_External_Sym *esym, *esymend;
1015 struct elf_link_hash_entry *sym_hash;
1018 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1019 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1021 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1023 contents = elf_section_data (sec)->this_hdr.contents;
1025 /* The deletion must stop at the next ALIGN reloc for an aligment
1026 power larger than the number of bytes we are deleting. */
1029 toaddr = sec->_cooked_size;
1031 irel = elf_section_data (sec)->relocs;
1032 irelend = irel + sec->reloc_count;
1033 for (; irel < irelend; irel++)
1035 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1036 && irel->r_offset > addr
1037 && count < (1 << irel->r_addend))
1040 toaddr = irel->r_offset;
1045 /* Actually delete the bytes. */
1046 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1047 if (irelalign == NULL)
1048 sec->_cooked_size -= count;
1053 #define NOP_OPCODE (0x0009)
1055 BFD_ASSERT ((count & 1) == 0);
1056 for (i = 0; i < count; i += 2)
1057 bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
1060 /* Adjust all the relocs. */
1061 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1063 bfd_vma nraddr, stop;
1066 Elf_Internal_Sym sym;
1067 int off, adjust, oinsn;
1068 bfd_signed_vma voff = 0;
1071 /* Get the new reloc address. */
1072 nraddr = irel->r_offset;
1073 if ((irel->r_offset > addr
1074 && irel->r_offset < toaddr)
1075 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1076 && irel->r_offset == toaddr))
1079 /* See if this reloc was for the bytes we have deleted, in which
1080 case we no longer care about it. Don't delete relocs which
1081 represent addresses, though. */
1082 if (irel->r_offset >= addr
1083 && irel->r_offset < addr + count
1084 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
1085 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
1086 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
1087 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
1088 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1091 /* If this is a PC relative reloc, see if the range it covers
1092 includes the bytes we have deleted. */
1093 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1102 start = irel->r_offset;
1103 insn = bfd_get_16 (abfd, contents + nraddr);
1107 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1110 start = stop = addr;
1114 /* If this reloc is against a symbol defined in this
1115 section, and the symbol will not be adjusted below, we
1116 must check the addend to see it will put the value in
1117 range to be adjusted, and hence must be changed. */
1118 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1120 bfd_elf32_swap_symbol_in (abfd,
1121 extsyms + ELF32_R_SYM (irel->r_info),
1123 if (sym.st_shndx == shndx
1124 && (sym.st_value <= addr
1125 || sym.st_value >= toaddr))
1129 val = bfd_get_32 (abfd, contents + nraddr);
1130 val += sym.st_value;
1131 if (val > addr && val < toaddr)
1132 bfd_put_32 (abfd, val - count, contents + nraddr);
1135 start = stop = addr;
1142 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1146 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
1147 start = stop = addr;
1153 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1159 stop = start + 4 + off * 2;
1164 stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
1170 /* These relocs types represent
1172 The r_addend field holds the difference between the reloc
1173 address and L1. That is the start of the reloc, and
1174 adding in the contents gives us the top. We must adjust
1175 both the r_offset field and the section contents.
1176 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1177 and the elf bfd r_offset is called r_vaddr. */
1179 stop = irel->r_offset;
1180 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1184 && (stop <= addr || stop >= toaddr))
1185 irel->r_addend += count;
1186 else if (stop > addr
1188 && (start <= addr || start >= toaddr))
1189 irel->r_addend -= count;
1191 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1192 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1193 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1194 voff = bfd_get_8 (abfd, contents + nraddr);
1196 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1197 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1202 start = irel->r_offset;
1203 stop = (bfd_vma) ((bfd_signed_vma) start
1204 + (long) irel->r_addend
1211 && (stop <= addr || stop >= toaddr))
1213 else if (stop > addr
1215 && (start <= addr || start >= toaddr))
1224 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1233 if ((oinsn & 0xff00) != (insn & 0xff00))
1235 bfd_put_16 (abfd, insn, contents + nraddr);
1240 if ((oinsn & 0xf000) != (insn & 0xf000))
1242 bfd_put_16 (abfd, insn, contents + nraddr);
1246 BFD_ASSERT (adjust == count || count >= 4);
1251 if ((irel->r_offset & 3) == 0)
1254 if ((oinsn & 0xff00) != (insn & 0xff00))
1256 bfd_put_16 (abfd, insn, contents + nraddr);
1261 if (voff < - 0x8000 || voff >= 0x8000)
1263 bfd_put_signed_16 (abfd, voff, contents + nraddr);
1268 bfd_put_signed_32 (abfd, voff, contents + nraddr);
1272 irel->r_addend += adjust;
1278 ((*_bfd_error_handler)
1279 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1280 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1281 bfd_set_error (bfd_error_bad_value);
1286 irel->r_offset = nraddr;
1289 /* Look through all the other sections. If there contain any IMM32
1290 relocs against internal symbols which we are not going to adjust
1291 below, we may need to adjust the addends. */
1292 for (o = abfd->sections; o != NULL; o = o->next)
1294 Elf_Internal_Rela *internal_relocs;
1295 Elf_Internal_Rela *irelscan, *irelscanend;
1296 bfd_byte *ocontents;
1299 || (o->flags & SEC_RELOC) == 0
1300 || o->reloc_count == 0)
1303 /* We always cache the relocs. Perhaps, if info->keep_memory is
1304 false, we should free them, if we are permitted to, when we
1305 leave sh_coff_relax_section. */
1306 internal_relocs = (_bfd_elf32_link_read_relocs
1307 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1309 if (internal_relocs == NULL)
1313 irelscanend = internal_relocs + o->reloc_count;
1314 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1316 Elf_Internal_Sym sym;
1318 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1319 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1321 bfd_vma start, stop;
1322 bfd_signed_vma voff;
1324 if (ocontents == NULL)
1326 if (elf_section_data (o)->this_hdr.contents != NULL)
1327 ocontents = elf_section_data (o)->this_hdr.contents;
1330 /* We always cache the section contents.
1331 Perhaps, if info->keep_memory is false, we
1332 should free them, if we are permitted to,
1333 when we leave sh_coff_relax_section. */
1334 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1335 if (ocontents == NULL)
1337 if (! bfd_get_section_contents (abfd, o, ocontents,
1341 elf_section_data (o)->this_hdr.contents = ocontents;
1345 stop = irelscan->r_offset;
1347 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1349 /* STOP is in a different section, so it won't change. */
1350 if (start > addr && start < toaddr)
1351 irelscan->r_addend += count;
1353 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1354 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1358 && (stop <= addr || stop >= toaddr))
1359 bfd_put_signed_32 (abfd, voff + count,
1360 ocontents + irelscan->r_offset);
1361 else if (stop > addr
1363 && (start <= addr || start >= toaddr))
1364 bfd_put_signed_32 (abfd, voff - count,
1365 ocontents + irelscan->r_offset);
1368 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1371 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1374 bfd_elf32_swap_symbol_in (abfd,
1375 extsyms + ELF32_R_SYM (irelscan->r_info),
1378 if (sym.st_shndx == shndx
1379 && (sym.st_value <= addr
1380 || sym.st_value >= toaddr))
1384 if (ocontents == NULL)
1386 if (elf_section_data (o)->this_hdr.contents != NULL)
1387 ocontents = elf_section_data (o)->this_hdr.contents;
1390 /* We always cache the section contents.
1391 Perhaps, if info->keep_memory is false, we
1392 should free them, if we are permitted to,
1393 when we leave sh_coff_relax_section. */
1394 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1395 if (ocontents == NULL)
1397 if (! bfd_get_section_contents (abfd, o, ocontents,
1401 elf_section_data (o)->this_hdr.contents = ocontents;
1405 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1406 val += sym.st_value;
1407 if (val > addr && val < toaddr)
1408 bfd_put_32 (abfd, val - count,
1409 ocontents + irelscan->r_offset);
1414 /* Adjust the local symbols defined in this section. */
1416 esymend = esym + symtab_hdr->sh_info;
1417 for (; esym < esymend; esym++)
1419 Elf_Internal_Sym isym;
1421 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1423 if (isym.st_shndx == shndx
1424 && isym.st_value > addr
1425 && isym.st_value < toaddr)
1427 isym.st_value -= count;
1428 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1432 /* Now adjust the global symbols defined in this section. */
1433 esym = extsyms + symtab_hdr->sh_info;
1434 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1435 for (index = 0; esym < esymend; esym++, index++)
1437 Elf_Internal_Sym isym;
1439 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1440 sym_hash = elf_sym_hashes (abfd)[index];
1441 if (isym.st_shndx == shndx
1442 && ((sym_hash)->root.type == bfd_link_hash_defined
1443 || (sym_hash)->root.type == bfd_link_hash_defweak)
1444 && (sym_hash)->root.u.def.section == sec
1445 && (sym_hash)->root.u.def.value > addr
1446 && (sym_hash)->root.u.def.value < toaddr)
1448 (sym_hash)->root.u.def.value -= count;
1452 /* See if we can move the ALIGN reloc forward. We have adjusted
1453 r_offset for it already. */
1454 if (irelalign != NULL)
1456 bfd_vma alignto, alignaddr;
1458 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1459 alignaddr = BFD_ALIGN (irelalign->r_offset,
1460 1 << irelalign->r_addend);
1461 if (alignto != alignaddr)
1463 /* Tail recursion. */
1464 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1465 alignto - alignaddr);
1472 /* Look for loads and stores which we can align to four byte
1473 boundaries. This is like sh_align_loads in coff-sh.c. */
1476 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
1479 Elf_Internal_Rela *internal_relocs;
1483 Elf_Internal_Rela *irel, *irelend;
1484 bfd_vma *labels = NULL;
1485 bfd_vma *label, *label_end;
1489 irelend = internal_relocs + sec->reloc_count;
1491 /* Get all the addresses with labels on them. */
1492 labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
1496 for (irel = internal_relocs; irel < irelend; irel++)
1498 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1500 *label_end = irel->r_offset;
1505 /* Note that the assembler currently always outputs relocs in
1506 address order. If that ever changes, this code will need to sort
1507 the label values and the relocs. */
1511 for (irel = internal_relocs; irel < irelend; irel++)
1513 bfd_vma start, stop;
1515 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1518 start = irel->r_offset;
1520 for (irel++; irel < irelend; irel++)
1521 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1524 stop = irel->r_offset;
1526 stop = sec->_cooked_size;
1528 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1529 (PTR) internal_relocs, &label,
1530 label_end, start, stop, pswapped))
1544 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1547 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
1554 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1555 unsigned short i1, i2;
1556 Elf_Internal_Rela *irel, *irelend;
1558 /* Swap the instructions themselves. */
1559 i1 = bfd_get_16 (abfd, contents + addr);
1560 i2 = bfd_get_16 (abfd, contents + addr + 2);
1561 bfd_put_16 (abfd, i2, contents + addr);
1562 bfd_put_16 (abfd, i1, contents + addr + 2);
1564 /* Adjust all reloc addresses. */
1565 irelend = internal_relocs + sec->reloc_count;
1566 for (irel = internal_relocs; irel < irelend; irel++)
1568 enum elf_sh_reloc_type type;
1571 /* There are a few special types of relocs that we don't want to
1572 adjust. These relocs do not apply to the instruction itself,
1573 but are only associated with the address. */
1574 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1575 if (type == R_SH_ALIGN
1576 || type == R_SH_CODE
1577 || type == R_SH_DATA
1578 || type == R_SH_LABEL)
1581 /* If an R_SH_USES reloc points to one of the addresses being
1582 swapped, we must adjust it. It would be incorrect to do this
1583 for a jump, though, since we want to execute both
1584 instructions after the jump. (We have avoided swapping
1585 around a label, so the jump will not wind up executing an
1586 instruction it shouldn't). */
1587 if (type == R_SH_USES)
1591 off = irel->r_offset + 4 + irel->r_addend;
1593 irel->r_offset += 2;
1594 else if (off == addr + 2)
1595 irel->r_offset -= 2;
1598 if (irel->r_offset == addr)
1600 irel->r_offset += 2;
1603 else if (irel->r_offset == addr + 2)
1605 irel->r_offset -= 2;
1614 unsigned short insn, oinsn;
1617 loc = contents + irel->r_offset;
1626 insn = bfd_get_16 (abfd, loc);
1629 if ((oinsn & 0xff00) != (insn & 0xff00))
1631 bfd_put_16 (abfd, insn, loc);
1635 insn = bfd_get_16 (abfd, loc);
1638 if ((oinsn & 0xf000) != (insn & 0xf000))
1640 bfd_put_16 (abfd, insn, loc);
1644 /* This reloc ignores the least significant 3 bits of
1645 the program counter before adding in the offset.
1646 This means that if ADDR is at an even address, the
1647 swap will not affect the offset. If ADDR is an at an
1648 odd address, then the instruction will be crossing a
1649 four byte boundary, and must be adjusted. */
1650 if ((addr & 3) != 0)
1652 insn = bfd_get_16 (abfd, loc);
1655 if ((oinsn & 0xff00) != (insn & 0xff00))
1657 bfd_put_16 (abfd, insn, loc);
1665 ((*_bfd_error_handler)
1666 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1667 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1668 bfd_set_error (bfd_error_bad_value);
1677 /* Relocate an SH ELF section. */
1680 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1681 contents, relocs, local_syms, local_sections)
1682 bfd *output_bfd ATTRIBUTE_UNUSED;
1683 struct bfd_link_info *info;
1685 asection *input_section;
1687 Elf_Internal_Rela *relocs;
1688 Elf_Internal_Sym *local_syms;
1689 asection **local_sections;
1691 Elf_Internal_Shdr *symtab_hdr;
1692 struct elf_link_hash_entry **sym_hashes;
1693 Elf_Internal_Rela *rel, *relend;
1695 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1696 sym_hashes = elf_sym_hashes (input_bfd);
1699 relend = relocs + input_section->reloc_count;
1700 for (; rel < relend; rel++)
1703 reloc_howto_type *howto;
1704 unsigned long r_symndx;
1705 Elf_Internal_Sym *sym;
1707 struct elf_link_hash_entry *h;
1709 bfd_vma addend = (bfd_vma)0;
1710 bfd_reloc_status_type r;
1712 r_symndx = ELF32_R_SYM (rel->r_info);
1714 if (info->relocateable)
1716 /* This is a relocateable link. We don't have to change
1717 anything, unless the reloc is against a section symbol,
1718 in which case we have to adjust according to where the
1719 section symbol winds up in the output section. */
1720 if (r_symndx < symtab_hdr->sh_info)
1722 sym = local_syms + r_symndx;
1723 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1725 sec = local_sections[r_symndx];
1726 rel->r_addend += sec->output_offset + sym->st_value;
1733 r_type = ELF32_R_TYPE (rel->r_info);
1735 /* Many of the relocs are only used for relaxing, and are
1736 handled entirely by the relaxation code. */
1737 if (r_type > (int) R_SH_LAST_INVALID_RELOC)
1741 || r_type >= (int) R_SH_FIRST_INVALID_RELOC)
1743 bfd_set_error (bfd_error_bad_value);
1747 /* FIXME: This is certainly incorrect. However, it is how the
1748 COFF linker works. */
1749 if (r_type != (int) R_SH_DIR32
1750 && r_type != (int) R_SH_IND12W)
1753 howto = sh_elf_howto_table + r_type;
1755 /* This is a final link. */
1759 if (r_symndx < symtab_hdr->sh_info)
1761 /* There is nothing to be done for an internal IND12W
1762 relocation. FIXME: This is probably wrong, but it's how
1763 the COFF relocations work. */
1764 if (r_type == (int) R_SH_IND12W)
1766 sym = local_syms + r_symndx;
1767 sec = local_sections[r_symndx];
1768 relocation = (sec->output_section->vma
1769 + sec->output_offset
1774 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1775 while (h->root.type == bfd_link_hash_indirect
1776 || h->root.type == bfd_link_hash_warning)
1777 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1778 if (h->root.type == bfd_link_hash_defined
1779 || h->root.type == bfd_link_hash_defweak)
1781 sec = h->root.u.def.section;
1782 relocation = (h->root.u.def.value
1783 + sec->output_section->vma
1784 + sec->output_offset);
1786 else if (h->root.type == bfd_link_hash_undefweak)
1790 if (! ((*info->callbacks->undefined_symbol)
1791 (info, h->root.root.string, input_bfd,
1792 input_section, rel->r_offset)))
1798 /* FIXME: This is how the COFF relocations work. */
1799 if (r_type == (int) R_SH_IND12W)
1802 switch ((int)r_type)
1804 case (int)R_SH_DIR32:
1805 addend = rel->r_addend;
1809 /* COFF relocs don't use the addend. The addend is used for R_SH_DIR32
1810 to be compatible with other compilers. */
1811 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1812 contents, rel->r_offset,
1813 relocation, addend);
1815 if (r != bfd_reloc_ok)
1820 case bfd_reloc_outofrange:
1822 case bfd_reloc_overflow:
1827 name = h->root.root.string;
1830 name = (bfd_elf_string_from_elf_section
1831 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1835 name = bfd_section_name (input_bfd, sec);
1837 if (! ((*info->callbacks->reloc_overflow)
1838 (info, name, howto->name, (bfd_vma) 0,
1839 input_bfd, input_section, rel->r_offset)))
1850 /* This is a version of bfd_generic_get_relocated_section_contents
1851 which uses sh_elf_relocate_section. */
1854 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1855 data, relocateable, symbols)
1857 struct bfd_link_info *link_info;
1858 struct bfd_link_order *link_order;
1860 boolean relocateable;
1863 Elf_Internal_Shdr *symtab_hdr;
1864 asection *input_section = link_order->u.indirect.section;
1865 bfd *input_bfd = input_section->owner;
1866 asection **sections = NULL;
1867 Elf_Internal_Rela *internal_relocs = NULL;
1868 Elf32_External_Sym *external_syms = NULL;
1869 Elf_Internal_Sym *internal_syms = NULL;
1871 /* We only need to handle the case of relaxing, or of having a
1872 particular set of section contents, specially. */
1874 || elf_section_data (input_section)->this_hdr.contents == NULL)
1875 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1880 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1882 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1883 input_section->_raw_size);
1885 if ((input_section->flags & SEC_RELOC) != 0
1886 && input_section->reloc_count > 0)
1888 Elf_Internal_Sym *isymp;
1890 Elf32_External_Sym *esym, *esymend;
1892 if (symtab_hdr->contents != NULL)
1893 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1896 external_syms = ((Elf32_External_Sym *)
1897 bfd_malloc (symtab_hdr->sh_info
1898 * sizeof (Elf32_External_Sym)));
1899 if (external_syms == NULL && symtab_hdr->sh_info > 0)
1901 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1902 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
1903 symtab_hdr->sh_info, input_bfd)
1904 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
1908 internal_relocs = (_bfd_elf32_link_read_relocs
1909 (input_bfd, input_section, (PTR) NULL,
1910 (Elf_Internal_Rela *) NULL, false));
1911 if (internal_relocs == NULL)
1914 internal_syms = ((Elf_Internal_Sym *)
1915 bfd_malloc (symtab_hdr->sh_info
1916 * sizeof (Elf_Internal_Sym)));
1917 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1920 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
1921 * sizeof (asection *));
1922 if (sections == NULL && symtab_hdr->sh_info > 0)
1925 isymp = internal_syms;
1927 esym = external_syms;
1928 esymend = esym + symtab_hdr->sh_info;
1929 for (; esym < esymend; ++esym, ++isymp, ++secpp)
1933 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1935 if (isymp->st_shndx == SHN_UNDEF)
1936 isec = bfd_und_section_ptr;
1937 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1938 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1939 else if (isymp->st_shndx == SHN_ABS)
1940 isec = bfd_abs_section_ptr;
1941 else if (isymp->st_shndx == SHN_COMMON)
1942 isec = bfd_com_section_ptr;
1952 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
1953 input_section, data, internal_relocs,
1954 internal_syms, sections))
1957 if (sections != NULL)
1960 if (internal_syms != NULL)
1961 free (internal_syms);
1962 internal_syms = NULL;
1963 if (external_syms != NULL && symtab_hdr->contents == NULL)
1964 free (external_syms);
1965 external_syms = NULL;
1966 if (internal_relocs != elf_section_data (input_section)->relocs)
1967 free (internal_relocs);
1968 internal_relocs = NULL;
1974 if (internal_relocs != NULL
1975 && internal_relocs != elf_section_data (input_section)->relocs)
1976 free (internal_relocs);
1977 if (external_syms != NULL && symtab_hdr->contents == NULL)
1978 free (external_syms);
1979 if (internal_syms != NULL)
1980 free (internal_syms);
1981 if (sections != NULL)
1986 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
1988 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1989 Elf_Internal_Rela *rel;
1990 struct elf_link_hash_entry *h;
1991 Elf_Internal_Sym *sym;
1995 switch (ELF32_R_TYPE (rel->r_info))
1997 case R_SH_GNU_VTINHERIT:
1998 case R_SH_GNU_VTENTRY:
2002 switch (h->root.type)
2004 case bfd_link_hash_defined:
2005 case bfd_link_hash_defweak:
2006 return h->root.u.def.section;
2008 case bfd_link_hash_common:
2009 return h->root.u.c.p->section;
2018 if (!(elf_bad_symtab (abfd)
2019 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2020 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2021 && sym->st_shndx != SHN_COMMON))
2023 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2030 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
2031 bfd *abfd ATTRIBUTE_UNUSED;
2032 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2033 asection *sec ATTRIBUTE_UNUSED;
2034 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2036 /* we don't use got and plt entries for sh. */
2040 /* Look through the relocs for a section during the first phase.
2041 Since we don't do .gots or .plts, we just need to consider the
2042 virtual table relocs for gc. */
2045 sh_elf_check_relocs (abfd, info, sec, relocs)
2047 struct bfd_link_info *info;
2049 const Elf_Internal_Rela *relocs;
2051 Elf_Internal_Shdr *symtab_hdr;
2052 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2053 const Elf_Internal_Rela *rel;
2054 const Elf_Internal_Rela *rel_end;
2056 if (info->relocateable)
2059 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2060 sym_hashes = elf_sym_hashes (abfd);
2061 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2062 if (!elf_bad_symtab (abfd))
2063 sym_hashes_end -= symtab_hdr->sh_info;
2065 rel_end = relocs + sec->reloc_count;
2066 for (rel = relocs; rel < rel_end; rel++)
2068 struct elf_link_hash_entry *h;
2069 unsigned long r_symndx;
2071 r_symndx = ELF32_R_SYM (rel->r_info);
2072 if (r_symndx < symtab_hdr->sh_info)
2075 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2077 switch (ELF32_R_TYPE (rel->r_info))
2079 /* This relocation describes the C++ object vtable hierarchy.
2080 Reconstruct it for later use during GC. */
2081 case R_SH_GNU_VTINHERIT:
2082 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2086 /* This relocation describes which C++ vtable entries are actually
2087 used. Record for later use during GC. */
2088 case R_SH_GNU_VTENTRY:
2089 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2099 sh_elf_set_mach_from_flags (abfd)
2102 flagword flags = elf_elfheader (abfd)->e_flags;
2104 switch (elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK)
2107 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
2110 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
2113 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
2116 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
2119 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
2122 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
2126 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
2134 /* Function to keep SH specific file flags. */
2136 sh_elf_set_private_flags (abfd, flags)
2140 BFD_ASSERT (! elf_flags_init (abfd)
2141 || elf_elfheader (abfd)->e_flags == flags);
2143 elf_elfheader (abfd)->e_flags = flags;
2144 elf_flags_init (abfd) = true;
2145 return sh_elf_set_mach_from_flags (abfd);
2148 /* Copy backend specific data from one object module to another */
2150 sh_elf_copy_private_data (ibfd, obfd)
2154 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2155 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2158 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2161 /* This routine checks for linking big and little endian objects
2162 together, and for linking sh-dsp with sh3e / sh4 objects. */
2165 sh_elf_merge_private_data (ibfd, obfd)
2169 flagword old_flags, new_flags;
2171 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2174 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2175 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2178 if (! elf_flags_init (obfd))
2180 elf_flags_init (obfd) = true;
2181 elf_elfheader (obfd)->e_flags = 0;
2183 old_flags = elf_elfheader (obfd)->e_flags;
2184 new_flags = elf_elfheader (ibfd)->e_flags;
2185 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
2186 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
2188 (*_bfd_error_handler)
2189 ("%s: uses %s instructions while previous modules use %s instructions",
2190 bfd_get_filename (ibfd),
2191 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
2192 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
2193 bfd_set_error (bfd_error_bad_value);
2196 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
2198 return sh_elf_set_mach_from_flags (obfd);
2201 #define TARGET_BIG_SYM bfd_elf32_sh_vec
2202 #define TARGET_BIG_NAME "elf32-sh"
2203 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
2204 #define TARGET_LITTLE_NAME "elf32-shl"
2205 #define ELF_ARCH bfd_arch_sh
2206 #define ELF_MACHINE_CODE EM_SH
2207 #define ELF_MAXPAGESIZE 0x1
2209 #define elf_symbol_leading_char '_'
2211 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
2212 #define elf_info_to_howto sh_elf_info_to_howto
2213 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
2214 #define elf_backend_relocate_section sh_elf_relocate_section
2215 #define bfd_elf32_bfd_get_relocated_section_contents \
2216 sh_elf_get_relocated_section_contents
2217 #define elf_backend_object_p sh_elf_set_mach_from_flags
2218 #define bfd_elf32_bfd_set_private_bfd_flags \
2219 sh_elf_set_private_flags
2220 #define bfd_elf32_bfd_copy_private_bfd_data \
2221 sh_elf_copy_private_data
2222 #define bfd_elf32_bfd_merge_private_bfd_data \
2223 sh_elf_merge_private_data
2225 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
2226 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
2227 #define elf_backend_check_relocs sh_elf_check_relocs
2229 #define elf_backend_can_gc_sections 1
2230 #include "elf32-target.h"