URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [gdb-5.0/] [bfd/] [elf32-sh.c] - Rev 1765
Compare with Previous | Blame | View Log
/* Hitachi SH specific support for 32-bit ELF Copyright 1996, 97, 98, 1999, 2000 Free Software Foundation, Inc. Contributed by Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" #include "bfdlink.h" #include "libbfd.h" #include "elf-bfd.h" #include "elf/sh.h" static bfd_reloc_status_type sh_elf_reloc PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); static bfd_reloc_status_type sh_elf_ignore_reloc PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); static reloc_howto_type *sh_elf_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type)); static void sh_elf_info_to_howto PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); static boolean sh_elf_set_private_flags PARAMS ((bfd *, flagword)); static boolean sh_elf_copy_private_data PARAMS ((bfd *, bfd *)); static boolean sh_elf_merge_private_data PARAMS ((bfd *, bfd *)); boolean sh_elf_set_mach_from_flags PARAMS ((bfd *)); static boolean sh_elf_relax_section PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *)); static boolean sh_elf_relax_delete_bytes PARAMS ((bfd *, asection *, bfd_vma, int)); static boolean sh_elf_align_loads PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *)); static boolean sh_elf_swap_insns PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma)); static boolean sh_elf_relocate_section PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); static bfd_byte *sh_elf_get_relocated_section_contents PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, boolean, asymbol **)); static reloc_howto_type sh_elf_howto_table[] = { /* No relocation. */ HOWTO (R_SH_NONE, /* type */ 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_NONE", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ false), /* pcrel_offset */ /* 32 bit absolute relocation. Setting partial_inplace to true and src_mask to a non-zero value is similar to the COFF toolchain. */ HOWTO (R_SH_DIR32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ sh_elf_reloc, /* special_function */ "R_SH_DIR32", /* name */ true, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ false), /* pcrel_offset */ /* 32 bit PC relative relocation. */ HOWTO (R_SH_REL32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_REL32", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xffffffff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit PC relative branch divided by 2. */ HOWTO (R_SH_DIR8WPN, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPN", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 12 bit PC relative branch divided by 2. */ HOWTO (R_SH_IND12W, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 12, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ sh_elf_reloc, /* special_function */ "R_SH_IND12W", /* name */ true, /* partial_inplace */ 0xfff, /* src_mask */ 0xfff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit unsigned PC relative divided by 4. */ HOWTO (R_SH_DIR8WPL, /* type */ 2, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPL", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit unsigned PC relative divided by 2. */ HOWTO (R_SH_DIR8WPZ, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPZ", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit GBR relative. FIXME: This only makes sense if we have some special symbol for the GBR relative area, and that is not implemented. */ HOWTO (R_SH_DIR8BP, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8BP", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if we have some special symbol for the GBR relative area, and that is not implemented. */ HOWTO (R_SH_DIR8W, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8W", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if we have some special symbol for the GBR relative area, and that is not implemented. */ HOWTO (R_SH_DIR8L, /* type */ 2, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8L", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ EMPTY_HOWTO (10), EMPTY_HOWTO (11), EMPTY_HOWTO (12), EMPTY_HOWTO (13), EMPTY_HOWTO (14), EMPTY_HOWTO (15), EMPTY_HOWTO (16), EMPTY_HOWTO (17), EMPTY_HOWTO (18), EMPTY_HOWTO (19), EMPTY_HOWTO (20), EMPTY_HOWTO (21), EMPTY_HOWTO (22), EMPTY_HOWTO (23), EMPTY_HOWTO (24), /* The remaining relocs are a GNU extension used for relaxing. The final pass of the linker never needs to do anything with any of these relocs. Any required operations are handled by the relaxation code. */ /* A 16 bit switch table entry. This is generated for an expression such as ``.word L1 - L2''. The offset holds the difference between the reloc address and L2. */ HOWTO (R_SH_SWITCH16, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_SWITCH16", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* A 32 bit switch table entry. This is generated for an expression such as ``.long L1 - L2''. The offset holds the difference between the reloc address and L2. */ HOWTO (R_SH_SWITCH32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_SWITCH32", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* Indicates a .uses pseudo-op. The compiler will generate .uses pseudo-ops when it finds a function call which can be relaxed. The offset field holds the PC relative offset to the instruction which loads the register used in the function call. */ HOWTO (R_SH_USES, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_USES", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* The assembler will generate this reloc for addresses referred to by the register loads associated with USES relocs. The offset field holds the number of times the address is referenced in the object file. */ HOWTO (R_SH_COUNT, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_COUNT", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* Indicates an alignment statement. The offset field is the power of 2 to which subsequent portions of the object file must be aligned. */ HOWTO (R_SH_ALIGN, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_ALIGN", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* The assembler will generate this reloc before a block of instructions. A section should be processed as assumining it contains data, unless this reloc is seen. */ HOWTO (R_SH_CODE, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_CODE", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* The assembler will generate this reloc after a block of instructions when it sees data that is not instructions. */ HOWTO (R_SH_DATA, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_DATA", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* The assembler generates this reloc for each label within a block of instructions. This permits the linker to avoid swapping instructions which are the targets of branches. */ HOWTO (R_SH_LABEL, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_LABEL", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* An 8 bit switch table entry. This is generated for an expression such as ``.word L1 - L2''. The offset holds the difference between the reloc address and L2. */ HOWTO (R_SH_SWITCH8, /* type */ 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_SWITCH8", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ true), /* pcrel_offset */ /* GNU extension to record C++ vtable hierarchy */ HOWTO (R_SH_GNU_VTINHERIT, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ NULL, /* special_function */ "R_SH_GNU_VTINHERIT", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ false), /* pcrel_offset */ /* GNU extension to record C++ vtable member usage */ HOWTO (R_SH_GNU_VTENTRY, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ _bfd_elf_rel_vtable_reloc_fn, /* special_function */ "R_SH_GNU_VTENTRY", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ false), /* pcrel_offset */ /* 8 bit PC relative divided by 2 - but specified in a very odd way. */ HOWTO (R_SH_LOOP_START, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_LOOP_START", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* 8 bit PC relative divided by 2 - but specified in a very odd way. */ HOWTO (R_SH_LOOP_END, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ sh_elf_ignore_reloc, /* special_function */ "R_SH_LOOP_END", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ }; static bfd_reloc_status_type sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr, symbol_section, start, end) int r_type; bfd *input_bfd; asection *input_section; bfd_byte *contents; bfd_vma addr; asection *symbol_section; bfd_vma start, end; { static bfd_vma last_addr; asection *last_symbol_section; bfd_byte *free_contents = NULL; bfd_byte *start_ptr, *ptr, *last_ptr; int diff, cum_diff; bfd_signed_vma x; int insn; /* Sanity check the address. */ if (addr > input_section->_raw_size) return bfd_reloc_outofrange; /* We require the start and end relocations to be processed consecutively - although we allow then to be processed forwards or backwards. */ if (! last_addr) { last_addr = addr; last_symbol_section = symbol_section; return bfd_reloc_ok; } if (last_addr != addr) abort (); last_addr = 0; if (! symbol_section || last_symbol_section != symbol_section || end < start) return bfd_reloc_outofrange; /* Get the symbol_section contents. */ if (symbol_section != input_section) { if (elf_section_data (symbol_section)->this_hdr.contents != NULL) contents = elf_section_data (symbol_section)->this_hdr.contents; else { free_contents = contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size); if (contents == NULL) return bfd_reloc_outofrange; if (! bfd_get_section_contents (input_bfd, symbol_section, contents, (file_ptr) 0, symbol_section->_raw_size)) { free (contents); return bfd_reloc_outofrange; } } } #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800) start_ptr = contents + start; for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;) { for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);) ptr -= 2; ptr += 2; diff = last_ptr - ptr >> 1; cum_diff += diff & 1; cum_diff += diff; } /* Calculate the start / end values to load into rs / re minus four - so that will cancel out the four we would otherwise have to add to addr to get the value to subtract in order to get relative addressing. */ if (cum_diff >= 0) { start -= 4; end = (ptr + cum_diff * 2) - contents; } else { bfd_vma start0 = start - 4; while (start0 >= 0 && IS_PPI (contents + start0)) start0 -= 2; start0 = start - 2 - ((start - start0) & 2); start = start0 - cum_diff - 2; end = start0; } if (free_contents) free (free_contents); insn = bfd_get_16 (input_bfd, contents + addr); x = (insn & 0x200 ? end : start) - addr; if (input_section != symbol_section) x += ((symbol_section->output_section->vma + symbol_section->output_offset) - (input_section->output_section->vma + input_section->output_offset)); x >>= 1; if (x < -128 || x > 127) return bfd_reloc_overflow; x = insn & ~0xff | x & 0xff; bfd_put_16 (input_bfd, x, contents + addr); return bfd_reloc_ok; } /* This function is used for normal relocs. This used to be like the COFF function, and is almost certainly incorrect for other ELF targets. */ static bfd_reloc_status_type sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, error_message) bfd *abfd; arelent *reloc_entry; asymbol *symbol_in; PTR data; asection *input_section; bfd *output_bfd; char **error_message ATTRIBUTE_UNUSED; { unsigned long insn; bfd_vma sym_value; enum elf_sh_reloc_type r_type; bfd_vma addr = reloc_entry->address; bfd_byte *hit_data = addr + (bfd_byte *) data; r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type; if (output_bfd != NULL) { /* Partial linking--do nothing. */ reloc_entry->address += input_section->output_offset; return bfd_reloc_ok; } /* Almost all relocs have to do with relaxing. If any work must be done for them, it has been done in sh_relax_section. */ if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0) return bfd_reloc_ok; if (symbol_in != NULL && bfd_is_und_section (symbol_in->section)) return bfd_reloc_undefined; if (bfd_is_com_section (symbol_in->section)) sym_value = 0; else sym_value = (symbol_in->value + symbol_in->section->output_section->vma + symbol_in->section->output_offset); switch (r_type) { case R_SH_DIR32: insn = bfd_get_32 (abfd, hit_data); insn += sym_value + reloc_entry->addend; bfd_put_32 (abfd, insn, hit_data); break; case R_SH_IND12W: insn = bfd_get_16 (abfd, hit_data); sym_value += reloc_entry->addend; sym_value -= (input_section->output_section->vma + input_section->output_offset + addr + 4); sym_value += (insn & 0xfff) << 1; if (insn & 0x800) sym_value -= 0x1000; insn = (insn & 0xf000) | (sym_value & 0xfff); bfd_put_16 (abfd, insn, hit_data); if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000) return bfd_reloc_overflow; break; default: abort (); break; } return bfd_reloc_ok; } /* This function is used for relocs which are only used for relaxing, which the linker should otherwise ignore. */ static bfd_reloc_status_type sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd, error_message) bfd *abfd ATTRIBUTE_UNUSED; arelent *reloc_entry; asymbol *symbol ATTRIBUTE_UNUSED; PTR data ATTRIBUTE_UNUSED; asection *input_section; bfd *output_bfd; char **error_message ATTRIBUTE_UNUSED; { if (output_bfd != NULL) reloc_entry->address += input_section->output_offset; return bfd_reloc_ok; } /* This structure is used to map BFD reloc codes to SH ELF relocs. */ struct elf_reloc_map { bfd_reloc_code_real_type bfd_reloc_val; unsigned char elf_reloc_val; }; /* An array mapping BFD reloc codes to SH ELF relocs. */ static const struct elf_reloc_map sh_reloc_map[] = { { BFD_RELOC_NONE, R_SH_NONE }, { BFD_RELOC_32, R_SH_DIR32 }, { BFD_RELOC_CTOR, R_SH_DIR32 }, { BFD_RELOC_32_PCREL, R_SH_REL32 }, { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN }, { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W }, { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ }, { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL }, { BFD_RELOC_8_PCREL, R_SH_SWITCH8 }, { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 }, { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 }, { BFD_RELOC_SH_USES, R_SH_USES }, { BFD_RELOC_SH_COUNT, R_SH_COUNT }, { BFD_RELOC_SH_ALIGN, R_SH_ALIGN }, { BFD_RELOC_SH_CODE, R_SH_CODE }, { BFD_RELOC_SH_DATA, R_SH_DATA }, { BFD_RELOC_SH_LABEL, R_SH_LABEL }, { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT }, { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY }, { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START }, { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END }, }; /* Given a BFD reloc code, return the howto structure for the corresponding SH ELf reloc. */ static reloc_howto_type * sh_elf_reloc_type_lookup (abfd, code) bfd *abfd ATTRIBUTE_UNUSED; bfd_reloc_code_real_type code; { unsigned int i; for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++) { if (sh_reloc_map[i].bfd_reloc_val == code) return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val]; } return NULL; } /* Given an ELF reloc, fill in the howto field of a relent. */ static void sh_elf_info_to_howto (abfd, cache_ptr, dst) bfd *abfd ATTRIBUTE_UNUSED; arelent *cache_ptr; Elf_Internal_Rela *dst; { unsigned int r; r = ELF32_R_TYPE (dst->r_info); BFD_ASSERT (r < (unsigned int) R_SH_max); BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC); cache_ptr->howto = &sh_elf_howto_table[r]; } /* This function handles relaxing for SH ELF. See the corresponding function in coff-sh.c for a description of what this does. FIXME: There is a lot of duplication here between this code and the COFF specific code. The format of relocs and symbols is wound deeply into this code, but it would still be better if the duplication could be eliminated somehow. Note in particular that although both functions use symbols like R_SH_CODE, those symbols have different values; in coff-sh.c they come from include/coff/sh.h, whereas here they come from enum elf_sh_reloc_type in include/elf/sh.h. */ static boolean sh_elf_relax_section (abfd, sec, link_info, again) bfd *abfd; asection *sec; struct bfd_link_info *link_info; boolean *again; { Elf_Internal_Shdr *symtab_hdr; Elf_Internal_Rela *internal_relocs; Elf_Internal_Rela *free_relocs = NULL; boolean have_code; Elf_Internal_Rela *irel, *irelend; bfd_byte *contents = NULL; bfd_byte *free_contents = NULL; Elf32_External_Sym *extsyms = NULL; Elf32_External_Sym *free_extsyms = NULL; *again = false; if (link_info->relocateable || (sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0) return true; /* If this is the first time we have been called for this section, initialize the cooked size. */ if (sec->_cooked_size == 0) sec->_cooked_size = sec->_raw_size; symtab_hdr = &elf_tdata (abfd)->symtab_hdr; internal_relocs = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, link_info->keep_memory)); if (internal_relocs == NULL) goto error_return; if (! link_info->keep_memory) free_relocs = internal_relocs; have_code = false; irelend = internal_relocs + sec->reloc_count; for (irel = internal_relocs; irel < irelend; irel++) { bfd_vma laddr, paddr, symval; unsigned short insn; Elf_Internal_Rela *irelfn, *irelscan, *irelcount; bfd_signed_vma foff; if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE) have_code = true; if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES) continue; /* Get the section contents. */ if (contents == NULL) { if (elf_section_data (sec)->this_hdr.contents != NULL) contents = elf_section_data (sec)->this_hdr.contents; else { contents = (bfd_byte *) bfd_malloc (sec->_raw_size); if (contents == NULL) goto error_return; free_contents = contents; if (! bfd_get_section_contents (abfd, sec, contents, (file_ptr) 0, sec->_raw_size)) goto error_return; } } /* The r_addend field of the R_SH_USES reloc will point us to the register load. The 4 is because the r_addend field is computed as though it were a jump offset, which are based from 4 bytes after the jump instruction. */ laddr = irel->r_offset + 4 + irel->r_addend; if (laddr >= sec->_raw_size) { (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"), bfd_get_filename (abfd), (unsigned long) irel->r_offset); continue; } insn = bfd_get_16 (abfd, contents + laddr); /* If the instruction is not mov.l NN,rN, we don't know what to do. */ if ((insn & 0xf000) != 0xd000) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"), bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn)); continue; } /* Get the address from which the register is being loaded. The displacement in the mov.l instruction is quadrupled. It is a displacement from four bytes after the movl instruction, but, before adding in the PC address, two least significant bits of the PC are cleared. We assume that the section is aligned on a four byte boundary. */ paddr = insn & 0xff; paddr *= 4; paddr += (laddr + 4) &~ 3; if (paddr >= sec->_raw_size) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES load offset"), bfd_get_filename (abfd), (unsigned long) irel->r_offset)); continue; } /* Get the reloc for the address from which the register is being loaded. This reloc will tell us which function is actually being called. */ for (irelfn = internal_relocs; irelfn < irelend; irelfn++) if (irelfn->r_offset == paddr && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32) break; if (irelfn >= irelend) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: could not find expected reloc"), bfd_get_filename (abfd), (unsigned long) paddr)); continue; } /* Read this BFD's symbols if we haven't done so already. */ if (extsyms == NULL) { if (symtab_hdr->contents != NULL) extsyms = (Elf32_External_Sym *) symtab_hdr->contents; else { extsyms = ((Elf32_External_Sym *) bfd_malloc (symtab_hdr->sh_size)); if (extsyms == NULL) goto error_return; free_extsyms = extsyms; if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd) != symtab_hdr->sh_size)) goto error_return; } } /* Get the value of the symbol referred to by the reloc. */ if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info) { Elf_Internal_Sym isym; /* A local symbol. */ bfd_elf32_swap_symbol_in (abfd, extsyms + ELF32_R_SYM (irelfn->r_info), &isym); if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec)) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: symbol in unexpected section"), bfd_get_filename (abfd), (unsigned long) paddr)); continue; } symval = (isym.st_value + sec->output_section->vma + sec->output_offset); } else { unsigned long indx; struct elf_link_hash_entry *h; indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info; h = elf_sym_hashes (abfd)[indx]; BFD_ASSERT (h != NULL); if (h->root.type != bfd_link_hash_defined && h->root.type != bfd_link_hash_defweak) { /* This appears to be a reference to an undefined symbol. Just ignore it--it will be caught by the regular reloc processing. */ continue; } symval = (h->root.u.def.value + h->root.u.def.section->output_section->vma + h->root.u.def.section->output_offset); } symval += bfd_get_32 (abfd, contents + paddr); /* See if this function call can be shortened. */ foff = (symval - (irel->r_offset + sec->output_section->vma + sec->output_offset + 4)); if (foff < -0x1000 || foff >= 0x1000) { /* After all that work, we can't shorten this function call. */ continue; } /* Shorten the function call. */ /* For simplicity of coding, we are going to modify the section contents, the section relocs, and the BFD symbol table. We must tell the rest of the code not to free up this information. It would be possible to instead create a table of changes which have to be made, as is done in coff-mips.c; that would be more work, but would require less memory when the linker is run. */ elf_section_data (sec)->relocs = internal_relocs; free_relocs = NULL; elf_section_data (sec)->this_hdr.contents = contents; free_contents = NULL; symtab_hdr->contents = (bfd_byte *) extsyms; free_extsyms = NULL; /* Replace the jsr with a bsr. */ /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and replace the jsr with a bsr. */ irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W); if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info) { /* If this needs to be changed because of future relaxing, it will be handled here like other internal IND12W relocs. */ bfd_put_16 (abfd, 0xb000 | ((foff >> 1) & 0xfff), contents + irel->r_offset); } else { /* We can't fully resolve this yet, because the external symbol value may be changed by future relaxing. We let the final link phase handle it. */ bfd_put_16 (abfd, 0xb000, contents + irel->r_offset); } /* See if there is another R_SH_USES reloc referring to the same register load. */ for (irelscan = internal_relocs; irelscan < irelend; irelscan++) if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES && laddr == irelscan->r_offset + 4 + irelscan->r_addend) break; if (irelscan < irelend) { /* Some other function call depends upon this register load, and we have not yet converted that function call. Indeed, we may never be able to convert it. There is nothing else we can do at this point. */ continue; } /* Look for a R_SH_COUNT reloc on the location where the function address is stored. Do this before deleting any bytes, to avoid confusion about the address. */ for (irelcount = internal_relocs; irelcount < irelend; irelcount++) if (irelcount->r_offset == paddr && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT) break; /* Delete the register load. */ if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2)) goto error_return; /* That will change things, so, just in case it permits some other function call to come within range, we should relax again. Note that this is not required, and it may be slow. */ *again = true; /* Now check whether we got a COUNT reloc. */ if (irelcount >= irelend) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: could not find expected COUNT reloc"), bfd_get_filename (abfd), (unsigned long) paddr)); continue; } /* The number of uses is stored in the r_addend field. We've just deleted one. */ if (irelcount->r_addend == 0) { ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"), bfd_get_filename (abfd), (unsigned long) paddr)); continue; } --irelcount->r_addend; /* If there are no more uses, we can delete the address. Reload the address from irelfn, in case it was changed by the previous call to sh_elf_relax_delete_bytes. */ if (irelcount->r_addend == 0) { if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4)) goto error_return; } /* We've done all we can with that function call. */ } /* Look for load and store instructions that we can align on four byte boundaries. */ if (have_code) { boolean swapped; /* Get the section contents. */ if (contents == NULL) { if (elf_section_data (sec)->this_hdr.contents != NULL) contents = elf_section_data (sec)->this_hdr.contents; else { contents = (bfd_byte *) bfd_malloc (sec->_raw_size); if (contents == NULL) goto error_return; free_contents = contents; if (! bfd_get_section_contents (abfd, sec, contents, (file_ptr) 0, sec->_raw_size)) goto error_return; } } if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents, &swapped)) goto error_return; if (swapped) { elf_section_data (sec)->relocs = internal_relocs; free_relocs = NULL; elf_section_data (sec)->this_hdr.contents = contents; free_contents = NULL; symtab_hdr->contents = (bfd_byte *) extsyms; free_extsyms = NULL; } } if (free_relocs != NULL) { free (free_relocs); free_relocs = NULL; } if (free_contents != NULL) { if (! link_info->keep_memory) free (free_contents); else { /* Cache the section contents for elf_link_input_bfd. */ elf_section_data (sec)->this_hdr.contents = contents; } free_contents = NULL; } if (free_extsyms != NULL) { if (! link_info->keep_memory) free (free_extsyms); else { /* Cache the symbols for elf_link_input_bfd. */ symtab_hdr->contents = extsyms; } free_extsyms = NULL; } return true; error_return: if (free_relocs != NULL) free (free_relocs); if (free_contents != NULL) free (free_contents); if (free_extsyms != NULL) free (free_extsyms); return false; } /* Delete some bytes from a section while relaxing. FIXME: There is a lot of duplication between this function and sh_relax_delete_bytes in coff-sh.c. */ static boolean sh_elf_relax_delete_bytes (abfd, sec, addr, count) bfd *abfd; asection *sec; bfd_vma addr; int count; { Elf_Internal_Shdr *symtab_hdr; Elf32_External_Sym *extsyms; int shndx, index; bfd_byte *contents; Elf_Internal_Rela *irel, *irelend; Elf_Internal_Rela *irelalign; bfd_vma toaddr; Elf32_External_Sym *esym, *esymend; struct elf_link_hash_entry *sym_hash; asection *o; symtab_hdr = &elf_tdata (abfd)->symtab_hdr; extsyms = (Elf32_External_Sym *) symtab_hdr->contents; shndx = _bfd_elf_section_from_bfd_section (abfd, sec); contents = elf_section_data (sec)->this_hdr.contents; /* The deletion must stop at the next ALIGN reloc for an aligment power larger than the number of bytes we are deleting. */ irelalign = NULL; toaddr = sec->_cooked_size; irel = elf_section_data (sec)->relocs; irelend = irel + sec->reloc_count; for (; irel < irelend; irel++) { if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN && irel->r_offset > addr && count < (1 << irel->r_addend)) { irelalign = irel; toaddr = irel->r_offset; break; } } /* Actually delete the bytes. */ memmove (contents + addr, contents + addr + count, toaddr - addr - count); if (irelalign == NULL) sec->_cooked_size -= count; else { int i; #define NOP_OPCODE (0x0009) BFD_ASSERT ((count & 1) == 0); for (i = 0; i < count; i += 2) bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i); } /* Adjust all the relocs. */ for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) { bfd_vma nraddr, stop; bfd_vma start = 0; int insn = 0; Elf_Internal_Sym sym; int off, adjust, oinsn; bfd_signed_vma voff = 0; boolean overflow; /* Get the new reloc address. */ nraddr = irel->r_offset; if ((irel->r_offset > addr && irel->r_offset < toaddr) || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN && irel->r_offset == toaddr)) nraddr -= count; /* See if this reloc was for the bytes we have deleted, in which case we no longer care about it. Don't delete relocs which represent addresses, though. */ if (irel->r_offset >= addr && irel->r_offset < addr + count && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL) irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), (int) R_SH_NONE); /* If this is a PC relative reloc, see if the range it covers includes the bytes we have deleted. */ switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) { default: break; case R_SH_DIR8WPN: case R_SH_IND12W: case R_SH_DIR8WPZ: case R_SH_DIR8WPL: start = irel->r_offset; insn = bfd_get_16 (abfd, contents + nraddr); break; } switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) { default: start = stop = addr; break; case R_SH_DIR32: /* If this reloc is against a symbol defined in this section, and the symbol will not be adjusted below, we must check the addend to see it will put the value in range to be adjusted, and hence must be changed. */ if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) { bfd_elf32_swap_symbol_in (abfd, extsyms + ELF32_R_SYM (irel->r_info), &sym); if (sym.st_shndx == shndx && (sym.st_value <= addr || sym.st_value >= toaddr)) { bfd_vma val; val = bfd_get_32 (abfd, contents + nraddr); val += sym.st_value; if (val > addr && val < toaddr) bfd_put_32 (abfd, val - count, contents + nraddr); } } start = stop = addr; break; case R_SH_DIR8WPN: off = insn & 0xff; if (off & 0x80) off -= 0x100; stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); break; case R_SH_IND12W: if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info) start = stop = addr; else { off = insn & 0xfff; if (off & 0x800) off -= 0x1000; stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); } break; case R_SH_DIR8WPZ: off = insn & 0xff; stop = start + 4 + off * 2; break; case R_SH_DIR8WPL: off = insn & 0xff; stop = (start &~ (bfd_vma) 3) + 4 + off * 4; break; case R_SH_SWITCH8: case R_SH_SWITCH16: case R_SH_SWITCH32: /* These relocs types represent .word L2-L1 The r_addend field holds the difference between the reloc address and L1. That is the start of the reloc, and adding in the contents gives us the top. We must adjust both the r_offset field and the section contents. N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset, and the elf bfd r_offset is called r_vaddr. */ stop = irel->r_offset; start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend); if (start > addr && start < toaddr && (stop <= addr || stop >= toaddr)) irel->r_addend += count; else if (stop > addr && stop < toaddr && (start <= addr || start >= toaddr)) irel->r_addend -= count; if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16) voff = bfd_get_signed_16 (abfd, contents + nraddr); else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8) voff = bfd_get_8 (abfd, contents + nraddr); else voff = bfd_get_signed_32 (abfd, contents + nraddr); stop = (bfd_vma) ((bfd_signed_vma) start + voff); break; case R_SH_USES: start = irel->r_offset; stop = (bfd_vma) ((bfd_signed_vma) start + (long) irel->r_addend + 4); break; } if (start > addr && start < toaddr && (stop <= addr || stop >= toaddr)) adjust = count; else if (stop > addr && stop < toaddr && (start <= addr || start >= toaddr)) adjust = - count; else adjust = 0; if (adjust != 0) { oinsn = insn; overflow = false; switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) { default: abort (); break; case R_SH_DIR8WPN: case R_SH_DIR8WPZ: insn += adjust / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; bfd_put_16 (abfd, insn, contents + nraddr); break; case R_SH_IND12W: insn += adjust / 2; if ((oinsn & 0xf000) != (insn & 0xf000)) overflow = true; bfd_put_16 (abfd, insn, contents + nraddr); break; case R_SH_DIR8WPL: BFD_ASSERT (adjust == count || count >= 4); if (count >= 4) insn += adjust / 4; else { if ((irel->r_offset & 3) == 0) ++insn; } if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; bfd_put_16 (abfd, insn, contents + nraddr); break; case R_SH_SWITCH16: voff += adjust; if (voff < - 0x8000 || voff >= 0x8000) overflow = true; bfd_put_signed_16 (abfd, voff, contents + nraddr); break; case R_SH_SWITCH32: voff += adjust; bfd_put_signed_32 (abfd, voff, contents + nraddr); break; case R_SH_USES: irel->r_addend += adjust; break; } if (overflow) { ((*_bfd_error_handler) (_("%s: 0x%lx: fatal: reloc overflow while relaxing"), bfd_get_filename (abfd), (unsigned long) irel->r_offset)); bfd_set_error (bfd_error_bad_value); return false; } } irel->r_offset = nraddr; } /* Look through all the other sections. If there contain any IMM32 relocs against internal symbols which we are not going to adjust below, we may need to adjust the addends. */ for (o = abfd->sections; o != NULL; o = o->next) { Elf_Internal_Rela *internal_relocs; Elf_Internal_Rela *irelscan, *irelscanend; bfd_byte *ocontents; if (o == sec || (o->flags & SEC_RELOC) == 0 || o->reloc_count == 0) continue; /* We always cache the relocs. Perhaps, if info->keep_memory is false, we should free them, if we are permitted to, when we leave sh_coff_relax_section. */ internal_relocs = (_bfd_elf32_link_read_relocs (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL, true)); if (internal_relocs == NULL) return false; ocontents = NULL; irelscanend = internal_relocs + o->reloc_count; for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++) { Elf_Internal_Sym sym; /* Dwarf line numbers use R_SH_SWITCH32 relocs. */ if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32) { bfd_vma start, stop; bfd_signed_vma voff; if (ocontents == NULL) { if (elf_section_data (o)->this_hdr.contents != NULL) ocontents = elf_section_data (o)->this_hdr.contents; else { /* We always cache the section contents. Perhaps, if info->keep_memory is false, we should free them, if we are permitted to, when we leave sh_coff_relax_section. */ ocontents = (bfd_byte *) bfd_malloc (o->_raw_size); if (ocontents == NULL) return false; if (! bfd_get_section_contents (abfd, o, ocontents, (file_ptr) 0, o->_raw_size)) return false; elf_section_data (o)->this_hdr.contents = ocontents; } } stop = irelscan->r_offset; start = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend); /* STOP is in a different section, so it won't change. */ if (start > addr && start < toaddr) irelscan->r_addend += count; voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset); stop = (bfd_vma) ((bfd_signed_vma) start + voff); if (start > addr && start < toaddr && (stop <= addr || stop >= toaddr)) bfd_put_signed_32 (abfd, voff + count, ocontents + irelscan->r_offset); else if (stop > addr && stop < toaddr && (start <= addr || start >= toaddr)) bfd_put_signed_32 (abfd, voff - count, ocontents + irelscan->r_offset); } if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32) continue; if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info) continue; bfd_elf32_swap_symbol_in (abfd, extsyms + ELF32_R_SYM (irelscan->r_info), &sym); if (sym.st_shndx == shndx && (sym.st_value <= addr || sym.st_value >= toaddr)) { bfd_vma val; if (ocontents == NULL) { if (elf_section_data (o)->this_hdr.contents != NULL) ocontents = elf_section_data (o)->this_hdr.contents; else { /* We always cache the section contents. Perhaps, if info->keep_memory is false, we should free them, if we are permitted to, when we leave sh_coff_relax_section. */ ocontents = (bfd_byte *) bfd_malloc (o->_raw_size); if (ocontents == NULL) return false; if (! bfd_get_section_contents (abfd, o, ocontents, (file_ptr) 0, o->_raw_size)) return false; elf_section_data (o)->this_hdr.contents = ocontents; } } val = bfd_get_32 (abfd, ocontents + irelscan->r_offset); val += sym.st_value; if (val > addr && val < toaddr) bfd_put_32 (abfd, val - count, ocontents + irelscan->r_offset); } } } /* Adjust the local symbols defined in this section. */ esym = extsyms; esymend = esym + symtab_hdr->sh_info; for (; esym < esymend; esym++) { Elf_Internal_Sym isym; bfd_elf32_swap_symbol_in (abfd, esym, &isym); if (isym.st_shndx == shndx && isym.st_value > addr && isym.st_value < toaddr) { isym.st_value -= count; bfd_elf32_swap_symbol_out (abfd, &isym, esym); } } /* Now adjust the global symbols defined in this section. */ esym = extsyms + symtab_hdr->sh_info; esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)); for (index = 0; esym < esymend; esym++, index++) { Elf_Internal_Sym isym; bfd_elf32_swap_symbol_in (abfd, esym, &isym); sym_hash = elf_sym_hashes (abfd)[index]; if (isym.st_shndx == shndx && ((sym_hash)->root.type == bfd_link_hash_defined || (sym_hash)->root.type == bfd_link_hash_defweak) && (sym_hash)->root.u.def.section == sec && (sym_hash)->root.u.def.value > addr && (sym_hash)->root.u.def.value < toaddr) { (sym_hash)->root.u.def.value -= count; } } /* See if we can move the ALIGN reloc forward. We have adjusted r_offset for it already. */ if (irelalign != NULL) { bfd_vma alignto, alignaddr; alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend); alignaddr = BFD_ALIGN (irelalign->r_offset, 1 << irelalign->r_addend); if (alignto != alignaddr) { /* Tail recursion. */ return sh_elf_relax_delete_bytes (abfd, sec, alignaddr, alignto - alignaddr); } } return true; } /* Look for loads and stores which we can align to four byte boundaries. This is like sh_align_loads in coff-sh.c. */ static boolean sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped) bfd *abfd; asection *sec; Elf_Internal_Rela *internal_relocs; bfd_byte *contents; boolean *pswapped; { Elf_Internal_Rela *irel, *irelend; bfd_vma *labels = NULL; bfd_vma *label, *label_end; *pswapped = false; irelend = internal_relocs + sec->reloc_count; /* Get all the addresses with labels on them. */ labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma)); if (labels == NULL) goto error_return; label_end = labels; for (irel = internal_relocs; irel < irelend; irel++) { if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL) { *label_end = irel->r_offset; ++label_end; } } /* Note that the assembler currently always outputs relocs in address order. If that ever changes, this code will need to sort the label values and the relocs. */ label = labels; for (irel = internal_relocs; irel < irelend; irel++) { bfd_vma start, stop; if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE) continue; start = irel->r_offset; for (irel++; irel < irelend; irel++) if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA) break; if (irel < irelend) stop = irel->r_offset; else stop = sec->_cooked_size; if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns, (PTR) internal_relocs, &label, label_end, start, stop, pswapped)) goto error_return; } free (labels); return true; error_return: if (labels != NULL) free (labels); return false; } /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */ static boolean sh_elf_swap_insns (abfd, sec, relocs, contents, addr) bfd *abfd; asection *sec; PTR relocs; bfd_byte *contents; bfd_vma addr; { Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs; unsigned short i1, i2; Elf_Internal_Rela *irel, *irelend; /* Swap the instructions themselves. */ i1 = bfd_get_16 (abfd, contents + addr); i2 = bfd_get_16 (abfd, contents + addr + 2); bfd_put_16 (abfd, i2, contents + addr); bfd_put_16 (abfd, i1, contents + addr + 2); /* Adjust all reloc addresses. */ irelend = internal_relocs + sec->reloc_count; for (irel = internal_relocs; irel < irelend; irel++) { enum elf_sh_reloc_type type; int add; /* There are a few special types of relocs that we don't want to adjust. These relocs do not apply to the instruction itself, but are only associated with the address. */ type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info); if (type == R_SH_ALIGN || type == R_SH_CODE || type == R_SH_DATA || type == R_SH_LABEL) continue; /* If an R_SH_USES reloc points to one of the addresses being swapped, we must adjust it. It would be incorrect to do this for a jump, though, since we want to execute both instructions after the jump. (We have avoided swapping around a label, so the jump will not wind up executing an instruction it shouldn't). */ if (type == R_SH_USES) { bfd_vma off; off = irel->r_offset + 4 + irel->r_addend; if (off == addr) irel->r_offset += 2; else if (off == addr + 2) irel->r_offset -= 2; } if (irel->r_offset == addr) { irel->r_offset += 2; add = -2; } else if (irel->r_offset == addr + 2) { irel->r_offset -= 2; add = 2; } else add = 0; if (add != 0) { bfd_byte *loc; unsigned short insn, oinsn; boolean overflow; loc = contents + irel->r_offset; overflow = false; switch (type) { default: break; case R_SH_DIR8WPN: case R_SH_DIR8WPZ: insn = bfd_get_16 (abfd, loc); oinsn = insn; insn += add / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; bfd_put_16 (abfd, insn, loc); break; case R_SH_IND12W: insn = bfd_get_16 (abfd, loc); oinsn = insn; insn += add / 2; if ((oinsn & 0xf000) != (insn & 0xf000)) overflow = true; bfd_put_16 (abfd, insn, loc); break; case R_SH_DIR8WPL: /* This reloc ignores the least significant 3 bits of the program counter before adding in the offset. This means that if ADDR is at an even address, the swap will not affect the offset. If ADDR is an at an odd address, then the instruction will be crossing a four byte boundary, and must be adjusted. */ if ((addr & 3) != 0) { insn = bfd_get_16 (abfd, loc); oinsn = insn; insn += add / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; bfd_put_16 (abfd, insn, loc); } break; } if (overflow) { ((*_bfd_error_handler) (_("%s: 0x%lx: fatal: reloc overflow while relaxing"), bfd_get_filename (abfd), (unsigned long) irel->r_offset)); bfd_set_error (bfd_error_bad_value); return false; } } } return true; } /* Relocate an SH ELF section. */ static boolean sh_elf_relocate_section (output_bfd, info, input_bfd, input_section, contents, relocs, local_syms, local_sections) bfd *output_bfd ATTRIBUTE_UNUSED; struct bfd_link_info *info; bfd *input_bfd; asection *input_section; bfd_byte *contents; Elf_Internal_Rela *relocs; Elf_Internal_Sym *local_syms; asection **local_sections; { Elf_Internal_Shdr *symtab_hdr; struct elf_link_hash_entry **sym_hashes; Elf_Internal_Rela *rel, *relend; symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; sym_hashes = elf_sym_hashes (input_bfd); rel = relocs; relend = relocs + input_section->reloc_count; for (; rel < relend; rel++) { int r_type; reloc_howto_type *howto; unsigned long r_symndx; Elf_Internal_Sym *sym; asection *sec; struct elf_link_hash_entry *h; bfd_vma relocation; bfd_vma addend = (bfd_vma)0; bfd_reloc_status_type r; r_symndx = ELF32_R_SYM (rel->r_info); if (info->relocateable) { /* This is a relocateable link. We don't have to change anything, unless the reloc is against a section symbol, in which case we have to adjust according to where the section symbol winds up in the output section. */ if (r_symndx < symtab_hdr->sh_info) { sym = local_syms + r_symndx; if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) { sec = local_sections[r_symndx]; rel->r_addend += sec->output_offset + sym->st_value; } } continue; } r_type = ELF32_R_TYPE (rel->r_info); /* Many of the relocs are only used for relaxing, and are handled entirely by the relaxation code. */ if (r_type > (int) R_SH_LAST_INVALID_RELOC && r_type < (int) R_SH_LOOP_START) continue; if (r_type < 0 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC && r_type <= (int) R_SH_LAST_INVALID_RELOC)) { bfd_set_error (bfd_error_bad_value); return false; } /* FIXME: This is certainly incorrect. However, it is how the COFF linker works. */ if (r_type != (int) R_SH_DIR32 && r_type != (int) R_SH_IND12W && r_type != (int) R_SH_LOOP_START && r_type != (int) R_SH_LOOP_END) continue; howto = sh_elf_howto_table + r_type; /* This is a final link. */ h = NULL; sym = NULL; sec = NULL; if (r_symndx < symtab_hdr->sh_info) { /* There is nothing to be done for an internal IND12W relocation. FIXME: This is probably wrong, but it's how the COFF relocations work. */ if (r_type == (int) R_SH_IND12W) continue; sym = local_syms + r_symndx; sec = local_sections[r_symndx]; relocation = (sec->output_section->vma + sec->output_offset + sym->st_value); } else { h = sym_hashes[r_symndx - symtab_hdr->sh_info]; while (h->root.type == bfd_link_hash_indirect || h->root.type == bfd_link_hash_warning) h = (struct elf_link_hash_entry *) h->root.u.i.link; if (h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak) { sec = h->root.u.def.section; relocation = (h->root.u.def.value + sec->output_section->vma + sec->output_offset); } else if (h->root.type == bfd_link_hash_undefweak) relocation = 0; else { if (! ((*info->callbacks->undefined_symbol) (info, h->root.root.string, input_bfd, input_section, rel->r_offset, true))) return false; relocation = 0; } } /* FIXME: This is how the COFF relocations work. */ if (r_type == (int) R_SH_IND12W) relocation -= 4; switch ((int)r_type) { case (int)R_SH_DIR32: addend = rel->r_addend; /* Fall through. */ default: /* COFF relocs don't use the addend. The addend is used for R_SH_DIR32 to be compatible with other compilers. */ r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, rel->r_offset, relocation, addend); break; case R_SH_LOOP_START: { static bfd_vma start, end; start = (relocation + rel->r_addend - (sec->output_section->vma + sec->output_offset)); r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, rel->r_offset, sec, start, end); break; case R_SH_LOOP_END: end = (relocation + rel->r_addend - (sec->output_section->vma + sec->output_offset)); r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, rel->r_offset, sec, start, end); break; } } if (r != bfd_reloc_ok) { switch (r) { default: case bfd_reloc_outofrange: abort (); case bfd_reloc_overflow: { const char *name; if (h != NULL) name = h->root.root.string; else { name = (bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name)); if (name == NULL) return false; if (*name == '\0') name = bfd_section_name (input_bfd, sec); } if (! ((*info->callbacks->reloc_overflow) (info, name, howto->name, (bfd_vma) 0, input_bfd, input_section, rel->r_offset))) return false; } break; } } } return true; } /* This is a version of bfd_generic_get_relocated_section_contents which uses sh_elf_relocate_section. */ static bfd_byte * sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order, data, relocateable, symbols) bfd *output_bfd; struct bfd_link_info *link_info; struct bfd_link_order *link_order; bfd_byte *data; boolean relocateable; asymbol **symbols; { Elf_Internal_Shdr *symtab_hdr; asection *input_section = link_order->u.indirect.section; bfd *input_bfd = input_section->owner; asection **sections = NULL; Elf_Internal_Rela *internal_relocs = NULL; Elf32_External_Sym *external_syms = NULL; Elf_Internal_Sym *internal_syms = NULL; /* We only need to handle the case of relaxing, or of having a particular set of section contents, specially. */ if (relocateable || elf_section_data (input_section)->this_hdr.contents == NULL) return bfd_generic_get_relocated_section_contents (output_bfd, link_info, link_order, data, relocateable, symbols); symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; memcpy (data, elf_section_data (input_section)->this_hdr.contents, input_section->_raw_size); if ((input_section->flags & SEC_RELOC) != 0 && input_section->reloc_count > 0) { Elf_Internal_Sym *isymp; asection **secpp; Elf32_External_Sym *esym, *esymend; if (symtab_hdr->contents != NULL) external_syms = (Elf32_External_Sym *) symtab_hdr->contents; else { external_syms = ((Elf32_External_Sym *) bfd_malloc (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))); if (external_syms == NULL && symtab_hdr->sh_info > 0) goto error_return; if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0 || (bfd_read (external_syms, sizeof (Elf32_External_Sym), symtab_hdr->sh_info, input_bfd) != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym)))) goto error_return; } internal_relocs = (_bfd_elf32_link_read_relocs (input_bfd, input_section, (PTR) NULL, (Elf_Internal_Rela *) NULL, false)); if (internal_relocs == NULL) goto error_return; internal_syms = ((Elf_Internal_Sym *) bfd_malloc (symtab_hdr->sh_info * sizeof (Elf_Internal_Sym))); if (internal_syms == NULL && symtab_hdr->sh_info > 0) goto error_return; sections = (asection **) bfd_malloc (symtab_hdr->sh_info * sizeof (asection *)); if (sections == NULL && symtab_hdr->sh_info > 0) goto error_return; isymp = internal_syms; secpp = sections; esym = external_syms; esymend = esym + symtab_hdr->sh_info; for (; esym < esymend; ++esym, ++isymp, ++secpp) { asection *isec; bfd_elf32_swap_symbol_in (input_bfd, esym, isymp); if (isymp->st_shndx == SHN_UNDEF) isec = bfd_und_section_ptr; else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE) isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx); else if (isymp->st_shndx == SHN_ABS) isec = bfd_abs_section_ptr; else if (isymp->st_shndx == SHN_COMMON) isec = bfd_com_section_ptr; else { /* Who knows? */ isec = NULL; } *secpp = isec; } if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd, input_section, data, internal_relocs, internal_syms, sections)) goto error_return; if (sections != NULL) free (sections); sections = NULL; if (internal_syms != NULL) free (internal_syms); internal_syms = NULL; if (external_syms != NULL && symtab_hdr->contents == NULL) free (external_syms); external_syms = NULL; if (internal_relocs != elf_section_data (input_section)->relocs) free (internal_relocs); internal_relocs = NULL; } return data; error_return: if (internal_relocs != NULL && internal_relocs != elf_section_data (input_section)->relocs) free (internal_relocs); if (external_syms != NULL && symtab_hdr->contents == NULL) free (external_syms); if (internal_syms != NULL) free (internal_syms); if (sections != NULL) free (sections); return NULL; } static asection * sh_elf_gc_mark_hook (abfd, info, rel, h, sym) bfd *abfd; struct bfd_link_info *info ATTRIBUTE_UNUSED; Elf_Internal_Rela *rel; struct elf_link_hash_entry *h; Elf_Internal_Sym *sym; { if (h != NULL) { switch (ELF32_R_TYPE (rel->r_info)) { case R_SH_GNU_VTINHERIT: case R_SH_GNU_VTENTRY: break; default: switch (h->root.type) { case bfd_link_hash_defined: case bfd_link_hash_defweak: return h->root.u.def.section; case bfd_link_hash_common: return h->root.u.c.p->section; default: break; } } } else { if (!(elf_bad_symtab (abfd) && ELF_ST_BIND (sym->st_info) != STB_LOCAL) && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE) && sym->st_shndx != SHN_COMMON)) { return bfd_section_from_elf_index (abfd, sym->st_shndx); } } return NULL; } static boolean sh_elf_gc_sweep_hook (abfd, info, sec, relocs) bfd *abfd ATTRIBUTE_UNUSED; struct bfd_link_info *info ATTRIBUTE_UNUSED; asection *sec ATTRIBUTE_UNUSED; const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED; { /* we don't use got and plt entries for sh. */ return true; } /* Look through the relocs for a section during the first phase. Since we don't do .gots or .plts, we just need to consider the virtual table relocs for gc. */ static boolean sh_elf_check_relocs (abfd, info, sec, relocs) bfd *abfd; struct bfd_link_info *info; asection *sec; const Elf_Internal_Rela *relocs; { Elf_Internal_Shdr *symtab_hdr; struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; const Elf_Internal_Rela *rel; const Elf_Internal_Rela *rel_end; if (info->relocateable) return true; symtab_hdr = &elf_tdata (abfd)->symtab_hdr; sym_hashes = elf_sym_hashes (abfd); sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym); if (!elf_bad_symtab (abfd)) sym_hashes_end -= symtab_hdr->sh_info; rel_end = relocs + sec->reloc_count; for (rel = relocs; rel < rel_end; rel++) { struct elf_link_hash_entry *h; unsigned long r_symndx; r_symndx = ELF32_R_SYM (rel->r_info); if (r_symndx < symtab_hdr->sh_info) h = NULL; else h = sym_hashes[r_symndx - symtab_hdr->sh_info]; switch (ELF32_R_TYPE (rel->r_info)) { /* This relocation describes the C++ object vtable hierarchy. Reconstruct it for later use during GC. */ case R_SH_GNU_VTINHERIT: if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) return false; break; /* This relocation describes which C++ vtable entries are actually used. Record for later use during GC. */ case R_SH_GNU_VTENTRY: if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend)) return false; break; } } return true; } boolean sh_elf_set_mach_from_flags (abfd) bfd * abfd; { flagword flags = elf_elfheader (abfd)->e_flags; switch (flags & EF_SH_MACH_MASK) { case EF_SH1: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh); break; case EF_SH2: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2); break; case EF_SH_DSP: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp); break; case EF_SH3: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3); break; case EF_SH3_DSP: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp); break; case EF_SH3E: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e); break; case EF_SH_UNKNOWN: case EF_SH4: bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4); break; default: return false; } return true; } /* Function to keep SH specific file flags. */ static boolean sh_elf_set_private_flags (abfd, flags) bfd * abfd; flagword flags; { BFD_ASSERT (! elf_flags_init (abfd) || elf_elfheader (abfd)->e_flags == flags); elf_elfheader (abfd)->e_flags = flags; elf_flags_init (abfd) = true; return sh_elf_set_mach_from_flags (abfd); } /* Copy backend specific data from one object module to another */ static boolean sh_elf_copy_private_data (ibfd, obfd) bfd * ibfd; bfd * obfd; { if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) return true; return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags); } /* This routine checks for linking big and little endian objects together, and for linking sh-dsp with sh3e / sh4 objects. */ static boolean sh_elf_merge_private_data (ibfd, obfd) bfd *ibfd; bfd *obfd; { flagword old_flags, new_flags; if (_bfd_generic_verify_endian_match (ibfd, obfd) == false) return false; if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) return true; if (! elf_flags_init (obfd)) { elf_flags_init (obfd) = true; elf_elfheader (obfd)->e_flags = 0; } old_flags = elf_elfheader (obfd)->e_flags; new_flags = elf_elfheader (ibfd)->e_flags; if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags)) || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags))) { (*_bfd_error_handler) ("%s: uses %s instructions while previous modules use %s instructions", bfd_get_filename (ibfd), EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point", EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp"); bfd_set_error (bfd_error_bad_value); return false; } elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags); return sh_elf_set_mach_from_flags (obfd); } #define TARGET_BIG_SYM bfd_elf32_sh_vec #define TARGET_BIG_NAME "elf32-sh" #define TARGET_LITTLE_SYM bfd_elf32_shl_vec #define TARGET_LITTLE_NAME "elf32-shl" #define ELF_ARCH bfd_arch_sh #define ELF_MACHINE_CODE EM_SH #define ELF_MAXPAGESIZE 0x1 #define elf_symbol_leading_char '_' #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup #define elf_info_to_howto sh_elf_info_to_howto #define bfd_elf32_bfd_relax_section sh_elf_relax_section #define elf_backend_relocate_section sh_elf_relocate_section #define bfd_elf32_bfd_get_relocated_section_contents \ sh_elf_get_relocated_section_contents #define elf_backend_object_p sh_elf_set_mach_from_flags #define bfd_elf32_bfd_set_private_bfd_flags \ sh_elf_set_private_flags #define bfd_elf32_bfd_copy_private_bfd_data \ sh_elf_copy_private_data #define bfd_elf32_bfd_merge_private_bfd_data \ sh_elf_merge_private_data #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook #define elf_backend_check_relocs sh_elf_check_relocs #define elf_backend_can_gc_sections 1 #include "elf32-target.h"