From 0570468a60eb57b3c504db2cc606350167341bc1 Mon Sep 17 00:00:00 2001 From: obrien Date: Sat, 31 Aug 2002 20:20:07 +0000 Subject: Import of Binutils from the FSF 2.12 branch (post-.1 release). --- contrib/binutils/bfd/ChangeLog | 5 + contrib/binutils/bfd/coff-sh.c | 881 +++-- contrib/binutils/bfd/cpu-sh.c | 80 +- contrib/binutils/bfd/elf32-sh.c | 6600 ++++++++++++++++++++++++++------ contrib/binutils/bfd/elf64-alpha.c | 6 +- contrib/binutils/bfd/version.h | 2 +- contrib/binutils/binutils/configure.in | 2 +- contrib/binutils/etc/ChangeLog | 8 + contrib/binutils/etc/Makefile.in | 3 +- contrib/binutils/gas/config/tc-sh.c | 2810 +++++++++++--- contrib/binutils/gas/config/tc-sh.h | 139 +- contrib/binutils/gprof/po/Make-in | 251 ++ contrib/binutils/gprof/po/POTFILES.in | 38 + contrib/binutils/gprof/po/gprof.pot | 505 +++ contrib/binutils/include/coff/tic30.h | 179 +- contrib/binutils/include/coff/z8k.h | 183 +- contrib/binutils/ld/ChangeLog | 6 + contrib/binutils/ld/ldlang.c | 8 +- 18 files changed, 9256 insertions(+), 2450 deletions(-) create mode 100644 contrib/binutils/gprof/po/Make-in create mode 100644 contrib/binutils/gprof/po/POTFILES.in create mode 100644 contrib/binutils/gprof/po/gprof.pot (limited to 'contrib') diff --git a/contrib/binutils/bfd/ChangeLog b/contrib/binutils/bfd/ChangeLog index 987bd68..b0c0d9b 100644 --- a/contrib/binutils/bfd/ChangeLog +++ b/contrib/binutils/bfd/ChangeLog @@ -1,3 +1,8 @@ +2002-07-20 Jason Thorpe + + * elf64-alpha.c (elf64_alpha_size_dynamic_sections): Only insert + DT_PLTGOT into the dynamic section if there is a PLT. + 2002-05-14 Daniel Jacobowitz * configure.in: Set is_release=y for 2.12.1 release. diff --git a/contrib/binutils/bfd/coff-sh.c b/contrib/binutils/bfd/coff-sh.c index fd4f218..d1dc4fd 100644 --- a/contrib/binutils/bfd/coff-sh.c +++ b/contrib/binutils/bfd/coff-sh.c @@ -1,5 +1,6 @@ /* BFD back-end for Hitachi Super-H COFF binaries. - Copyright 1993, 94, 95, 96, 97, 1998 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. Contributed by Cygnus Support. Written by Steve Chamberlain, . Relaxing code written by Ian Lance Taylor, . @@ -22,22 +23,38 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" +#include "libiberty.h" #include "libbfd.h" #include "bfdlink.h" #include "coff/sh.h" #include "coff/internal.h" + +#ifdef COFF_WITH_PE +#include "coff/pe.h" + +#ifndef COFF_IMAGE_WITH_PE +static boolean sh_align_load_span + PARAMS ((bfd *, asection *, bfd_byte *, + boolean (*) (bfd *, asection *, PTR, bfd_byte *, bfd_vma), + PTR, bfd_vma **, bfd_vma *, bfd_vma, bfd_vma, boolean *)); + +#define _bfd_sh_align_load_span sh_align_load_span +#endif +#endif + #include "libcoff.h" /* Internal functions. */ static bfd_reloc_status_type sh_reloc PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); static long get_symbol_value PARAMS ((asymbol *)); -static boolean sh_merge_private_data PARAMS ((bfd *, bfd *)); static boolean sh_relax_section PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *)); static boolean sh_relax_delete_bytes PARAMS ((bfd *, asection *, bfd_vma, int)); +#ifndef COFF_IMAGE_WITH_PE static const struct sh_opcode *sh_insn_info PARAMS ((unsigned int)); +#endif static boolean sh_align_loads PARAMS ((bfd *, asection *, struct internal_reloc *, bfd_byte *, boolean *)); static boolean sh_swap_insns @@ -48,27 +65,67 @@ static boolean sh_relocate_section static bfd_byte *sh_coff_get_relocated_section_contents PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, boolean, asymbol **)); +static reloc_howto_type * sh_coff_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type)); +#ifdef COFF_WITH_PE +/* Can't build import tables with 2**4 alignment. */ +#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2 +#else /* Default section alignment to 2**4. */ -#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (4) +#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 4 +#endif + +#ifdef COFF_IMAGE_WITH_PE +/* Align PE executables. */ +#define COFF_PAGE_SIZE 0x1000 +#endif /* Generate long file names. */ #define COFF_LONG_FILENAMES +#ifdef COFF_WITH_PE +static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *)); +/* Return true if this relocation should + appear in the output .reloc section. */ +static boolean in_reloc_p (abfd, howto) + bfd * abfd ATTRIBUTE_UNUSED; + reloc_howto_type * howto; +{ + return ! howto->pc_relative && howto->type != R_SH_IMAGEBASE; +} +#endif + /* The supported relocations. There are a lot of relocations defined in coff/internal.h which we do not expect to ever see. */ static reloc_howto_type sh_coff_howtos[] = { - { 0 }, - { 1 }, - { 2 }, - { 3 }, /* R_SH_PCREL8 */ - { 4 }, /* R_SH_PCREL16 */ - { 5 }, /* R_SH_HIGH8 */ - { 6 }, /* R_SH_IMM24 */ - { 7 }, /* R_SH_LOW16 */ - { 8 }, - { 9 }, /* R_SH_PCDISP8BY4 */ + EMPTY_HOWTO (0), + EMPTY_HOWTO (1), +#ifdef COFF_WITH_PE + /* Windows CE */ + HOWTO (R_SH_IMM32CE, /* 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_reloc, /* special_function */ + "r_imm32ce", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ +#else + EMPTY_HOWTO (2), +#endif + EMPTY_HOWTO (3), /* R_SH_PCREL8 */ + EMPTY_HOWTO (4), /* R_SH_PCREL16 */ + EMPTY_HOWTO (5), /* R_SH_HIGH8 */ + EMPTY_HOWTO (6), /* R_SH_IMM24 */ + EMPTY_HOWTO (7), /* R_SH_LOW16 */ + EMPTY_HOWTO (8), + EMPTY_HOWTO (9), /* R_SH_PCDISP8BY4 */ HOWTO (R_SH_PCDISP8BY2, /* type */ 1, /* rightshift */ @@ -84,7 +141,7 @@ static reloc_howto_type sh_coff_howtos[] = 0xff, /* dst_mask */ true), /* pcrel_offset */ - { 11 }, /* R_SH_PCDISP8 */ + EMPTY_HOWTO (11), /* R_SH_PCDISP8 */ HOWTO (R_SH_PCDISP, /* type */ 1, /* rightshift */ @@ -100,7 +157,7 @@ static reloc_howto_type sh_coff_howtos[] = 0xfff, /* dst_mask */ true), /* pcrel_offset */ - { 13 }, + EMPTY_HOWTO (13), HOWTO (R_SH_IMM32, /* type */ 0, /* rightshift */ @@ -116,13 +173,29 @@ static reloc_howto_type sh_coff_howtos[] = 0xffffffff, /* dst_mask */ false), /* pcrel_offset */ - { 15 }, - { 16 }, /* R_SH_IMM8 */ - { 17 }, /* R_SH_IMM8BY2 */ - { 18 }, /* R_SH_IMM8BY4 */ - { 19 }, /* R_SH_IMM4 */ - { 20 }, /* R_SH_IMM4BY2 */ - { 21 }, /* R_SH_IMM4BY4 */ + EMPTY_HOWTO (15), +#ifdef COFF_WITH_PE + HOWTO (R_SH_IMAGEBASE, /* 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_reloc, /* special_function */ + "rva32", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ +#else + EMPTY_HOWTO (16), /* R_SH_IMM8 */ +#endif + EMPTY_HOWTO (17), /* R_SH_IMM8BY2 */ + EMPTY_HOWTO (18), /* R_SH_IMM8BY4 */ + EMPTY_HOWTO (19), /* R_SH_IMM4 */ + EMPTY_HOWTO (20), /* R_SH_IMM4BY2 */ + EMPTY_HOWTO (21), /* R_SH_IMM4BY4 */ HOWTO (R_SH_PCRELIMM8BY2, /* type */ 1, /* rightshift */ @@ -304,9 +377,10 @@ static reloc_howto_type sh_coff_howtos[] = /* FIXME: This should not be set here. */ #define __A_MAGIC_SET__ +#ifndef COFF_WITH_PE /* Swap the r_offset field in and out. */ -#define SWAP_IN_RELOC_OFFSET bfd_h_get_32 -#define SWAP_OUT_RELOC_OFFSET bfd_h_put_32 +#define SWAP_IN_RELOC_OFFSET H_GET_32 +#define SWAP_OUT_RELOC_OFFSET H_PUT_32 /* Swap out extra information in the reloc structure. */ #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \ @@ -316,18 +390,19 @@ static reloc_howto_type sh_coff_howtos[] = dst->r_stuff[1] = 'C'; \ } \ while (0) +#endif /* Get the value of a symbol, when performing a relocation. */ static long -get_symbol_value (symbol) +get_symbol_value (symbol) asymbol *symbol; -{ +{ bfd_vma relocation; if (bfd_is_com_section (symbol->section)) - relocation = 0; - else + relocation = 0; + else relocation = (symbol->value + symbol->section->output_section->vma + symbol->section->output_offset); @@ -335,6 +410,105 @@ get_symbol_value (symbol) return relocation; } +#ifdef COFF_WITH_PE +/* Convert an rtype to howto for the COFF backend linker. + Copied from coff-i386. */ +#define coff_rtype_to_howto coff_sh_rtype_to_howto +static reloc_howto_type * coff_sh_rtype_to_howto PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *)); + +static reloc_howto_type * +coff_sh_rtype_to_howto (abfd, sec, rel, h, sym, addendp) + bfd * abfd ATTRIBUTE_UNUSED; + asection * sec; + struct internal_reloc * rel; + struct coff_link_hash_entry * h; + struct internal_syment * sym; + bfd_vma * addendp; +{ + reloc_howto_type * howto; + + howto = sh_coff_howtos + rel->r_type; + + *addendp = 0; + + if (howto->pc_relative) + *addendp += sec->vma; + + if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0) + { + /* This is a common symbol. The section contents include the + size (sym->n_value) as an addend. The relocate_section + function will be adding in the final value of the symbol. We + need to subtract out the current size in order to get the + correct result. */ + BFD_ASSERT (h != NULL); + } + + if (howto->pc_relative) + { + *addendp -= 4; + + /* If the symbol is defined, then the generic code is going to + add back the symbol value in order to cancel out an + adjustment it made to the addend. However, we set the addend + to 0 at the start of this function. We need to adjust here, + to avoid the adjustment the generic code will make. FIXME: + This is getting a bit hackish. */ + if (sym != NULL && sym->n_scnum != 0) + *addendp -= sym->n_value; + } + + if (rel->r_type == R_SH_IMAGEBASE) + *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase; + + return howto; +} + +#endif /* COFF_WITH_PE */ + +/* This structure is used to map BFD reloc codes to SH PE relocs. */ +struct shcoff_reloc_map +{ + bfd_reloc_code_real_type bfd_reloc_val; + unsigned char shcoff_reloc_val; +}; + +#ifdef COFF_WITH_PE +/* An array mapping BFD reloc codes to SH PE relocs. */ +static const struct shcoff_reloc_map sh_reloc_map[] = +{ + { BFD_RELOC_32, R_SH_IMM32CE }, + { BFD_RELOC_RVA, R_SH_IMAGEBASE }, + { BFD_RELOC_CTOR, R_SH_IMM32CE }, +}; +#else +/* An array mapping BFD reloc codes to SH PE relocs. */ +static const struct shcoff_reloc_map sh_reloc_map[] = +{ + { BFD_RELOC_32, R_SH_IMM32 }, + { BFD_RELOC_CTOR, R_SH_IMM32 }, +}; +#endif + +/* Given a BFD reloc code, return the howto structure for the + corresponding SH PE reloc. */ +#define coff_bfd_reloc_type_lookup sh_coff_reloc_type_lookup + +static reloc_howto_type * +sh_coff_reloc_type_lookup (abfd, code) + bfd * abfd ATTRIBUTE_UNUSED; + bfd_reloc_code_real_type code; +{ + unsigned int i; + + for (i = ARRAY_SIZE (sh_reloc_map); i--;) + if (sh_reloc_map[i].bfd_reloc_val == code) + return &sh_coff_howtos[(int) sh_reloc_map[i].shcoff_reloc_val]; + + fprintf (stderr, "SH Error: unknown reloc type %d\n", code); + return NULL; +} + /* This macro is used in coffcode.h to get the howto corresponding to an internal reloc. */ @@ -382,7 +556,7 @@ sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, PTR data; asection *input_section; bfd *output_bfd; - char **error_message; + char **error_message ATTRIBUTE_UNUSED; { unsigned long insn; bfd_vma sym_value; @@ -402,6 +576,10 @@ sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, /* 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_IMM32 +#ifdef COFF_WITH_PE + && r_type != R_SH_IMM32CE + && r_type != R_SH_IMAGEBASE +#endif && (r_type != R_SH_PCDISP || (symbol_in->flags & BSF_LOCAL) != 0)) return bfd_reloc_ok; @@ -415,10 +593,21 @@ sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, switch (r_type) { case R_SH_IMM32: +#ifdef COFF_WITH_PE + case R_SH_IMM32CE: +#endif + insn = bfd_get_32 (abfd, hit_data); + insn += sym_value + reloc_entry->addend; + bfd_put_32 (abfd, (bfd_vma) insn, hit_data); + break; +#ifdef COFF_WITH_PE + case R_SH_IMAGEBASE: insn = bfd_get_32 (abfd, hit_data); insn += sym_value + reloc_entry->addend; - bfd_put_32 (abfd, insn, hit_data); + insn -= pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase; + bfd_put_32 (abfd, (bfd_vma) insn, hit_data); break; +#endif case R_SH_PCDISP: insn = bfd_get_16 (abfd, hit_data); sym_value += reloc_entry->addend; @@ -430,7 +619,7 @@ sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, if (insn & 0x800) sym_value -= 0x1000; insn = (insn & 0xf000) | (sym_value & 0xfff); - bfd_put_16 (abfd, insn, hit_data); + bfd_put_16 (abfd, (bfd_vma) insn, hit_data); if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000) return bfd_reloc_overflow; break; @@ -442,31 +631,7 @@ sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, return bfd_reloc_ok; } -/* This routine checks for linking big and little endian objects - together. */ - -static boolean -sh_merge_private_data (ibfd, obfd) - bfd *ibfd; - bfd *obfd; -{ - if (ibfd->xvec->byteorder != obfd->xvec->byteorder - && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) - { - (*_bfd_error_handler) - ("%s: compiled for a %s endian system and target is %s endian", - bfd_get_filename (ibfd), - bfd_big_endian (ibfd) ? "big" : "little", - bfd_big_endian (obfd) ? "big" : "little"); - - bfd_set_error (bfd_error_wrong_format); - return false; - } - - return true; -} - -#define coff_bfd_merge_private_bfd_data sh_merge_private_data +#define coff_bfd_merge_private_bfd_data _bfd_generic_verify_endian_match /* We can do relaxing. */ #define coff_bfd_relax_section sh_relax_section @@ -524,7 +689,7 @@ sh_merge_private_data (ibfd, obfd) align load and store instructions on four byte boundaries if we can, by swapping them with one of the adjacent instructions. */ -static boolean +static boolean sh_relax_section (abfd, sec, link_info, again) bfd *abfd; asection *sec; @@ -605,7 +770,7 @@ sh_relax_section (abfd, sec, link_info, again) if (laddr >= sec->_raw_size) { (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset", - bfd_get_filename (abfd), + bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr); continue; } @@ -616,7 +781,7 @@ sh_relax_section (abfd, sec, link_info, again) { ((*_bfd_error_handler) ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x", - bfd_get_filename (abfd), (unsigned long) irel->r_vaddr, insn)); + bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr, insn)); continue; } @@ -628,12 +793,12 @@ sh_relax_section (abfd, sec, link_info, again) on a four byte boundary. */ paddr = insn & 0xff; paddr *= 4; - paddr += (laddr + 4) &~ 3; + paddr += (laddr + 4) &~ (bfd_vma) 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_vaddr)); + bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr)); continue; } @@ -643,13 +808,20 @@ sh_relax_section (abfd, sec, link_info, again) paddr += sec->vma; for (irelfn = internal_relocs; irelfn < irelend; irelfn++) if (irelfn->r_vaddr == paddr +#ifdef COFF_WITH_PE + && (irelfn->r_type == R_SH_IMM32 + || irelfn->r_type == R_SH_IMM32CE + || irelfn->r_type == R_SH_IMAGEBASE)) + +#else && irelfn->r_type == R_SH_IMM32) +#endif break; if (irelfn >= irelend) { ((*_bfd_error_handler) ("%s: 0x%lx: warning: could not find expected reloc", - bfd_get_filename (abfd), (unsigned long) paddr)); + bfd_archive_filename (abfd), (unsigned long) paddr)); continue; } @@ -665,7 +837,7 @@ sh_relax_section (abfd, sec, link_info, again) { ((*_bfd_error_handler) ("%s: 0x%lx: warning: symbol in unexpected section", - bfd_get_filename (abfd), (unsigned long) paddr)); + bfd_archive_filename (abfd), (unsigned long) paddr)); continue; } @@ -723,8 +895,8 @@ sh_relax_section (abfd, sec, link_info, again) if (coff_section_data (abfd, sec) == NULL) { - sec->used_by_bfd = - ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata))); + bfd_size_type amt = sizeof (struct coff_section_tdata); + sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); if (sec->used_by_bfd == NULL) goto error_return; } @@ -751,7 +923,7 @@ sh_relax_section (abfd, sec, link_info, again) it will be handled here like other internal PCDISP relocs. */ bfd_put_16 (abfd, - 0xb000 | ((foff >> 1) & 0xfff), + (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff), contents + irel->r_vaddr - sec->vma); } else @@ -759,7 +931,8 @@ sh_relax_section (abfd, sec, link_info, again) /* 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_vaddr - sec->vma); + bfd_put_16 (abfd, (bfd_vma) 0xb000, + contents + irel->r_vaddr - sec->vma); } /* See if there is another R_SH_USES reloc referring to the same @@ -799,7 +972,7 @@ sh_relax_section (abfd, sec, link_info, again) { ((*_bfd_error_handler) ("%s: 0x%lx: warning: could not find expected COUNT reloc", - bfd_get_filename (abfd), (unsigned long) paddr)); + bfd_archive_filename (abfd), (unsigned long) paddr)); continue; } @@ -808,7 +981,7 @@ sh_relax_section (abfd, sec, link_info, again) if (irelcount->r_offset == 0) { ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count", - bfd_get_filename (abfd), + bfd_archive_filename (abfd), (unsigned long) paddr)); continue; } @@ -860,8 +1033,8 @@ sh_relax_section (abfd, sec, link_info, again) { if (coff_section_data (abfd, sec) == NULL) { - sec->used_by_bfd = - ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata))); + bfd_size_type amt = sizeof (struct coff_section_tdata); + sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); if (sec->used_by_bfd == NULL) goto error_return; } @@ -893,8 +1066,8 @@ sh_relax_section (abfd, sec, link_info, again) /* Cache the section contents for coff_link_input_bfd. */ if (coff_section_data (abfd, sec) == NULL) { - sec->used_by_bfd = - ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata))); + bfd_size_type amt = sizeof (struct coff_section_tdata); + sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); if (sec->used_by_bfd == NULL) goto error_return; coff_section_data (abfd, sec)->relocs = NULL; @@ -954,7 +1127,8 @@ sh_relax_delete_bytes (abfd, sec, addr, count) } /* Actually delete the bytes. */ - memmove (contents + addr, contents + addr + count, toaddr - addr - count); + memmove (contents + addr, contents + addr + count, + (size_t) (toaddr - addr - count)); if (irelalign == NULL) sec->_cooked_size -= count; else @@ -965,7 +1139,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) BFD_ASSERT ((count & 1) == 0); for (i = 0; i < count; i += 2) - bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i); + bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i); } /* Adjust all the relocs. */ @@ -1021,6 +1195,10 @@ sh_relax_delete_bytes (abfd, sec, addr, count) break; case R_SH_IMM32: +#ifdef COFF_WITH_PE + case R_SH_IMM32CE: + case R_SH_IMAGEBASE: +#endif /* 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 @@ -1039,7 +1217,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) val = bfd_get_32 (abfd, contents + nraddr); val += sym.n_value; - if (val >= addr && val < toaddr) + if (val > addr && val < toaddr) bfd_put_32 (abfd, val - count, contents + nraddr); } start = stop = addr; @@ -1147,14 +1325,14 @@ sh_relax_delete_bytes (abfd, sec, addr, count) insn += adjust / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; - bfd_put_16 (abfd, insn, contents + nraddr); + bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); break; case R_SH_PCDISP: insn += adjust / 2; if ((oinsn & 0xf000) != (insn & 0xf000)) overflow = true; - bfd_put_16 (abfd, insn, contents + nraddr); + bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); break; case R_SH_PCRELIMM8BY4: @@ -1168,26 +1346,26 @@ sh_relax_delete_bytes (abfd, sec, addr, count) } if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; - bfd_put_16 (abfd, insn, contents + nraddr); + bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); break; case R_SH_SWITCH8: voff += adjust; if (voff < 0 || voff >= 0xff) overflow = true; - bfd_put_8 (abfd, voff, contents + nraddr); + bfd_put_8 (abfd, (bfd_vma) voff, contents + nraddr); break; case R_SH_SWITCH16: voff += adjust; if (voff < - 0x8000 || voff >= 0x8000) overflow = true; - bfd_put_signed_16 (abfd, voff, contents + nraddr); + bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr); break; case R_SH_SWITCH32: voff += adjust; - bfd_put_signed_32 (abfd, voff, contents + nraddr); + bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr); break; case R_SH_USES: @@ -1199,7 +1377,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) { ((*_bfd_error_handler) ("%s: 0x%lx: fatal: reloc overflow while relaxing", - bfd_get_filename (abfd), (unsigned long) irel->r_vaddr)); + bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr)); bfd_set_error (bfd_error_bad_value); return false; } @@ -1237,7 +1415,13 @@ sh_relax_delete_bytes (abfd, sec, addr, count) { struct internal_syment sym; +#ifdef COFF_WITH_PE + if (irelscan->r_type != R_SH_IMM32 + && irelscan->r_type != R_SH_IMAGEBASE + && irelscan->r_type != R_SH_IMM32CE) +#else if (irelscan->r_type != R_SH_IMM32) +#endif continue; bfd_coff_swap_sym_in (abfd, @@ -1275,7 +1459,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) val = bfd_get_32 (abfd, ocontents + irelscan->r_vaddr - o->vma); val += sym.n_value; - if (val >= addr && val < toaddr) + if (val > addr && val < toaddr) bfd_put_32 (abfd, val - count, ocontents + irelscan->r_vaddr - o->vma); @@ -1293,7 +1477,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) { ((*_bfd_error_handler) ("%s: fatal: generic symbols retrieved before relaxing", - bfd_get_filename (abfd))); + bfd_archive_filename (abfd))); bfd_set_error (bfd_error_invalid_operation); return false; } @@ -1344,7 +1528,7 @@ sh_relax_delete_bytes (abfd, sec, addr, count) { /* Tail recursion. */ return sh_relax_delete_bytes (abfd, sec, alignaddr, - alignto - alignaddr); + (int) (alignto - alignaddr)); } } @@ -1389,7 +1573,7 @@ struct sh_opcode mask value in the sh_major_opcode structure. */ unsigned short opcode; /* Flags for this instruction. */ - unsigned short flags; + unsigned long flags; }; /* Flag which appear in the sh_opcode structure. */ @@ -1409,10 +1593,12 @@ struct sh_opcode /* This instruction uses the value in the register in the field at mask 0x0f00 of the instruction. */ #define USES1 (0x10) +#define USES1_REG(x) ((x & 0x0f00) >> 8) /* This instruction uses the value in the register in the field at mask 0x00f0 of the instruction. */ #define USES2 (0x20) +#define USES2_REG(x) ((x & 0x00f0) >> 4) /* This instruction uses the value in register 0. */ #define USESR0 (0x40) @@ -1420,10 +1606,12 @@ struct sh_opcode /* This instruction sets the value in the register in the field at mask 0x0f00 of the instruction. */ #define SETS1 (0x80) +#define SETS1_REG(x) ((x & 0x0f00) >> 8) /* This instruction sets the value in the register in the field at mask 0x00f0 of the instruction. */ #define SETS2 (0x100) +#define SETS2_REG(x) ((x & 0x00f0) >> 4) /* This instruction sets register 0. */ #define SETSR0 (0x200) @@ -1437,10 +1625,12 @@ struct sh_opcode /* This instruction uses the floating point register in the field at mask 0x0f00 of the instruction. */ #define USESF1 (0x1000) +#define USESF1_REG(x) ((x & 0x0f00) >> 8) /* This instruction uses the floating point register in the field at mask 0x00f0 of the instruction. */ #define USESF2 (0x2000) +#define USESF2_REG(x) ((x & 0x00f0) >> 4) /* This instruction uses floating point register 0. */ #define USESF0 (0x4000) @@ -1448,18 +1638,34 @@ struct sh_opcode /* This instruction sets the floating point register in the field at mask 0x0f00 of the instruction. */ #define SETSF1 (0x8000) +#define SETSF1_REG(x) ((x & 0x0f00) >> 8) +#define USESAS (0x10000) +#define USESAS_REG(x) (((((x) >> 8) - 2) & 3) + 2) +#define USESR8 (0x20000) +#define SETSAS (0x40000) +#define SETSAS_REG(x) USESAS_REG (x) + +#ifndef COFF_IMAGE_WITH_PE static boolean sh_insn_uses_reg PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); +static boolean sh_insn_sets_reg + PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); +static boolean sh_insn_uses_or_sets_reg + PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); static boolean sh_insn_uses_freg PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); +static boolean sh_insn_sets_freg + PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); +static boolean sh_insn_uses_or_sets_freg + PARAMS ((unsigned int, const struct sh_opcode *, unsigned int)); static boolean sh_insns_conflict PARAMS ((unsigned int, const struct sh_opcode *, unsigned int, const struct sh_opcode *)); static boolean sh_load_use PARAMS ((unsigned int, const struct sh_opcode *, unsigned int, const struct sh_opcode *)); - +#endif /* The opcode maps. */ #define MAP(a) a, sizeof a / sizeof a[0] @@ -1481,21 +1687,33 @@ static const struct sh_opcode sh_opcode00[] = static const struct sh_opcode sh_opcode01[] = { - { 0x0002, SETS1 | USESSP }, /* stc sr,rn */ { 0x0003, BRANCH | DELAY | USES1 | SETSSP }, /* bsrf rn */ { 0x000a, SETS1 | USESSP }, /* sts mach,rn */ - { 0x0012, SETS1 | USESSP }, /* stc gbr,rn */ { 0x001a, SETS1 | USESSP }, /* sts macl,rn */ - { 0x0022, SETS1 | USESSP }, /* stc vbr,rn */ { 0x0023, BRANCH | DELAY | USES1 }, /* braf rn */ { 0x0029, SETS1 | USESSP }, /* movt rn */ { 0x002a, SETS1 | USESSP }, /* sts pr,rn */ + { 0x005a, SETS1 | USESSP }, /* sts fpul,rn */ + { 0x006a, SETS1 | USESSP }, /* sts fpscr,rn / sts dsr,rn */ + { 0x0083, LOAD | USES1 }, /* pref @rn */ + { 0x007a, SETS1 | USESSP }, /* sts a0,rn */ + { 0x008a, SETS1 | USESSP }, /* sts x0,rn */ + { 0x009a, SETS1 | USESSP }, /* sts x1,rn */ + { 0x00aa, SETS1 | USESSP }, /* sts y0,rn */ + { 0x00ba, SETS1 | USESSP } /* sts y1,rn */ +}; + +/* These sixteen instructions can be handled with one table entry below. */ +#if 0 + { 0x0002, SETS1 | USESSP }, /* stc sr,rn */ + { 0x0012, SETS1 | USESSP }, /* stc gbr,rn */ + { 0x0022, SETS1 | USESSP }, /* stc vbr,rn */ { 0x0032, SETS1 | USESSP }, /* stc ssr,rn */ { 0x0042, SETS1 | USESSP }, /* stc spc,rn */ - { 0x005a, SETS1 | USESSP }, /* sts fpul,rn */ - { 0x006a, SETS1 | USESSP }, /* sts fpscr,rn */ + { 0x0052, SETS1 | USESSP }, /* stc mod,rn */ + { 0x0062, SETS1 | USESSP }, /* stc rs,rn */ + { 0x0072, SETS1 | USESSP }, /* stc re,rn */ { 0x0082, SETS1 | USESSP }, /* stc r0_bank,rn */ - { 0x0083, LOAD | USES1 }, /* pref @rn */ { 0x0092, SETS1 | USESSP }, /* stc r1_bank,rn */ { 0x00a2, SETS1 | USESSP }, /* stc r2_bank,rn */ { 0x00b2, SETS1 | USESSP }, /* stc r3_bank,rn */ @@ -1503,10 +1721,11 @@ static const struct sh_opcode sh_opcode01[] = { 0x00d2, SETS1 | USESSP }, /* stc r5_bank,rn */ { 0x00e2, SETS1 | USESSP }, /* stc r6_bank,rn */ { 0x00f2, SETS1 | USESSP } /* stc r7_bank,rn */ -}; +#endif static const struct sh_opcode sh_opcode02[] = { + { 0x0002, SETS1 | USESSP }, /* stc ,rn */ { 0x0004, STORE | USES1 | USES2 | USESR0 }, /* mov.b rm,@(r0,rn) */ { 0x0005, STORE | USES1 | USES2 | USESR0 }, /* mov.w rm,@(r0,rn) */ { 0x0006, STORE | USES1 | USES2 | USESR0 }, /* mov.l rm,@(r0,rn) */ @@ -1586,74 +1805,108 @@ static const struct sh_opcode sh_opcode40[] = { 0x4000, SETS1 | SETSSP | USES1 }, /* shll rn */ { 0x4001, SETS1 | SETSSP | USES1 }, /* shlr rn */ { 0x4002, STORE | SETS1 | USES1 | USESSP }, /* sts.l mach,@-rn */ - { 0x4003, STORE | SETS1 | USES1 | USESSP }, /* stc.l sr,@-rn */ { 0x4004, SETS1 | SETSSP | USES1 }, /* rotl rn */ { 0x4005, SETS1 | SETSSP | USES1 }, /* rotr rn */ { 0x4006, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,mach */ - { 0x4007, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,sr */ { 0x4008, SETS1 | USES1 }, /* shll2 rn */ { 0x4009, SETS1 | USES1 }, /* shlr2 rn */ { 0x400a, SETSSP | USES1 }, /* lds rm,mach */ { 0x400b, BRANCH | DELAY | USES1 }, /* jsr @rn */ - { 0x400e, SETSSP | USES1 }, /* ldc rm,sr */ { 0x4010, SETS1 | SETSSP | USES1 }, /* dt rn */ { 0x4011, SETSSP | USES1 }, /* cmp/pz rn */ { 0x4012, STORE | SETS1 | USES1 | USESSP }, /* sts.l macl,@-rn */ - { 0x4013, STORE | SETS1 | USES1 | USESSP }, /* stc.l gbr,@-rn */ + { 0x4014, SETSSP | USES1 }, /* setrc rm */ { 0x4015, SETSSP | USES1 }, /* cmp/pl rn */ { 0x4016, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,macl */ - { 0x4017, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,gbr */ { 0x4018, SETS1 | USES1 }, /* shll8 rn */ { 0x4019, SETS1 | USES1 }, /* shlr8 rn */ { 0x401a, SETSSP | USES1 }, /* lds rm,macl */ { 0x401b, LOAD | SETSSP | USES1 }, /* tas.b @rn */ - { 0x401e, SETSSP | USES1 }, /* ldc rm,gbr */ { 0x4020, SETS1 | SETSSP | USES1 }, /* shal rn */ { 0x4021, SETS1 | SETSSP | USES1 }, /* shar rn */ { 0x4022, STORE | SETS1 | USES1 | USESSP }, /* sts.l pr,@-rn */ - { 0x4023, STORE | SETS1 | USES1 | USESSP }, /* stc.l vbr,@-rn */ { 0x4024, SETS1 | SETSSP | USES1 | USESSP }, /* rotcl rn */ { 0x4025, SETS1 | SETSSP | USES1 | USESSP }, /* rotcr rn */ { 0x4026, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,pr */ - { 0x4027, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,vbr */ { 0x4028, SETS1 | USES1 }, /* shll16 rn */ { 0x4029, SETS1 | USES1 }, /* shlr16 rn */ { 0x402a, SETSSP | USES1 }, /* lds rm,pr */ { 0x402b, BRANCH | DELAY | USES1 }, /* jmp @rn */ - { 0x402e, SETSSP | USES1 }, /* ldc rm,vbr */ + { 0x4052, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpul,@-rn */ + { 0x4056, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpul */ + { 0x405a, SETSSP | USES1 }, /* lds.l rm,fpul */ + { 0x4062, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpscr / dsr,@-rn */ + { 0x4066, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpscr / dsr */ + { 0x406a, SETSSP | USES1 }, /* lds rm,fpscr / lds rm,dsr */ + { 0x4072, STORE | SETS1 | USES1 | USESSP }, /* sts.l a0,@-rn */ + { 0x4076, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,a0 */ + { 0x407a, SETSSP | USES1 }, /* lds.l rm,a0 */ + { 0x4082, STORE | SETS1 | USES1 | USESSP }, /* sts.l x0,@-rn */ + { 0x4086, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,x0 */ + { 0x408a, SETSSP | USES1 }, /* lds.l rm,x0 */ + { 0x4092, STORE | SETS1 | USES1 | USESSP }, /* sts.l x1,@-rn */ + { 0x4096, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,x1 */ + { 0x409a, SETSSP | USES1 }, /* lds.l rm,x1 */ + { 0x40a2, STORE | SETS1 | USES1 | USESSP }, /* sts.l y0,@-rn */ + { 0x40a6, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,y0 */ + { 0x40aa, SETSSP | USES1 }, /* lds.l rm,y0 */ + { 0x40b2, STORE | SETS1 | USES1 | USESSP }, /* sts.l y1,@-rn */ + { 0x40b6, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,y1 */ + { 0x40ba, SETSSP | USES1 } /* lds.l rm,y1 */ +#if 0 /* These groups sixteen insns can be + handled with one table entry each below. */ + { 0x4003, STORE | SETS1 | USES1 | USESSP }, /* stc.l sr,@-rn */ + { 0x4013, STORE | SETS1 | USES1 | USESSP }, /* stc.l gbr,@-rn */ + { 0x4023, STORE | SETS1 | USES1 | USESSP }, /* stc.l vbr,@-rn */ { 0x4033, STORE | SETS1 | USES1 | USESSP }, /* stc.l ssr,@-rn */ - { 0x4037, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,ssr */ - { 0x403e, SETSSP | USES1 }, /* ldc rm,ssr */ { 0x4043, STORE | SETS1 | USES1 | USESSP }, /* stc.l spc,@-rn */ + { 0x4053, STORE | SETS1 | USES1 | USESSP }, /* stc.l mod,@-rn */ + { 0x4063, STORE | SETS1 | USES1 | USESSP }, /* stc.l rs,@-rn */ + { 0x4073, STORE | SETS1 | USES1 | USESSP }, /* stc.l re,@-rn */ + { 0x4083, STORE | SETS1 | USES1 | USESSP }, /* stc.l r0_bank,@-rn */ + .. + { 0x40f3, STORE | SETS1 | USES1 | USESSP }, /* stc.l r7_bank,@-rn */ + + { 0x4007, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,sr */ + { 0x4017, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,gbr */ + { 0x4027, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,vbr */ + { 0x4037, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,ssr */ { 0x4047, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,spc */ + { 0x4057, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,mod */ + { 0x4067, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,rs */ + { 0x4077, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,re */ + { 0x4087, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,r0_bank */ + .. + { 0x40f7, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,r7_bank */ + + { 0x400e, SETSSP | USES1 }, /* ldc rm,sr */ + { 0x401e, SETSSP | USES1 }, /* ldc rm,gbr */ + { 0x402e, SETSSP | USES1 }, /* ldc rm,vbr */ + { 0x403e, SETSSP | USES1 }, /* ldc rm,ssr */ { 0x404e, SETSSP | USES1 }, /* ldc rm,spc */ - { 0x4052, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpul,@-rn */ - { 0x4056, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpul */ - { 0x405a, SETSSP | USES1 }, /* lds.l rm,fpul */ - { 0x4062, STORE | SETS1 | USES1 | USESSP }, /* sts.l fpscr,@-rn */ - { 0x4066, LOAD | SETS1 | SETSSP | USES1 }, /* lds.l @rm+,fpscr */ - { 0x406a, SETSSP | USES1 } /* lds rm,fpscr */ + { 0x405e, SETSSP | USES1 }, /* ldc rm,mod */ + { 0x406e, SETSSP | USES1 }, /* ldc rm,rs */ + { 0x407e, SETSSP | USES1 } /* ldc rm,re */ + { 0x408e, SETSSP | USES1 } /* ldc rm,r0_bank */ + .. + { 0x40fe, SETSSP | USES1 } /* ldc rm,r7_bank */ +#endif }; static const struct sh_opcode sh_opcode41[] = { - { 0x4083, STORE | SETS1 | USES1 | USESSP }, /* stc.l rx_bank,@-rn */ - { 0x4087, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+,rx_bank */ - { 0x408e, SETSSP | USES1 } /* ldc rm,rx_bank */ -}; - -static const struct sh_opcode sh_opcode42[] = -{ - { 0x400c, SETS1 | USES1 | USES2 }, /* shad rm,rn */ - { 0x400d, SETS1 | USES1 | USES2 }, /* shld rm,rn */ + { 0x4003, STORE | SETS1 | USES1 | USESSP }, /* stc.l ,@-rn */ + { 0x4007, LOAD | SETS1 | SETSSP | USES1 }, /* ldc.l @rm+, */ + { 0x400c, SETS1 | USES1 | USES2 }, /* shad rm,rn */ + { 0x400d, SETS1 | USES1 | USES2 }, /* shld rm,rn */ + { 0x400e, SETSSP | USES1 }, /* ldc rm, */ { 0x400f, LOAD|SETS1|SETS2|SETSSP|USES1|USES2|USESSP }, /* mac.w @rm+,@rn+ */ }; static const struct sh_minor_opcode sh_opcode4[] = { { MAP (sh_opcode40), 0xf0ff }, - { MAP (sh_opcode41), 0xf08f }, - { MAP (sh_opcode42), 0xf00f } + { MAP (sh_opcode41), 0xf00f } }; static const struct sh_opcode sh_opcode50[] = @@ -1705,12 +1958,15 @@ static const struct sh_opcode sh_opcode80[] = { { 0x8000, STORE | USES2 | USESR0 }, /* mov.b r0,@(disp,rn) */ { 0x8100, STORE | USES2 | USESR0 }, /* mov.w r0,@(disp,rn) */ + { 0x8200, SETSSP }, /* setrc #imm */ { 0x8400, LOAD | SETSR0 | USES2 }, /* mov.b @(disp,rm),r0 */ { 0x8500, LOAD | SETSR0 | USES2 }, /* mov.w @(disp,rn),r0 */ { 0x8800, SETSSP | USESR0 }, /* cmp/eq #imm,r0 */ { 0x8900, BRANCH | USESSP }, /* bt label */ { 0x8b00, BRANCH | USESSP }, /* bf label */ + { 0x8c00, SETSSP }, /* ldrs @(disp,pc) */ { 0x8d00, BRANCH | DELAY | USESSP }, /* bt/s label */ + { 0x8e00, SETSSP }, /* ldre @(disp,pc) */ { 0x8f00, BRANCH | DELAY | USESSP } /* bf/s label */ }; @@ -1832,7 +2088,8 @@ static const struct sh_minor_opcode sh_opcodef[] = { MAP (sh_opcodef1), 0xf0ff } }; -static const struct sh_major_opcode sh_opcodes[] = +#ifndef COFF_IMAGE_WITH_PE +static struct sh_major_opcode sh_opcodes[] = { { MAP (sh_opcode0) }, { MAP (sh_opcode1) }, @@ -1851,7 +2108,29 @@ static const struct sh_major_opcode sh_opcodes[] = { MAP (sh_opcodee) }, { MAP (sh_opcodef) } }; +#endif + +/* The double data transfer / parallel processing insns are not + described here. This will cause sh_align_load_span to leave them alone. */ + +static const struct sh_opcode sh_dsp_opcodef0[] = +{ + { 0xf400, USESAS | SETSAS | LOAD | SETSSP }, /* movs.x @-as,ds */ + { 0xf401, USESAS | SETSAS | STORE | USESSP }, /* movs.x ds,@-as */ + { 0xf404, USESAS | LOAD | SETSSP }, /* movs.x @as,ds */ + { 0xf405, USESAS | STORE | USESSP }, /* movs.x ds,@as */ + { 0xf408, USESAS | SETSAS | LOAD | SETSSP }, /* movs.x @as+,ds */ + { 0xf409, USESAS | SETSAS | STORE | USESSP }, /* movs.x ds,@as+ */ + { 0xf40c, USESAS | SETSAS | LOAD | SETSSP | USESR8 }, /* movs.x @as+r8,ds */ + { 0xf40d, USESAS | SETSAS | STORE | USESSP | USESR8 } /* movs.x ds,@as+r8 */ +}; + +static const struct sh_minor_opcode sh_dsp_opcodef[] = +{ + { MAP (sh_dsp_opcodef0), 0xfc0d } +}; +#ifndef COFF_IMAGE_WITH_PE /* Given an instruction, return a pointer to the corresponding sh_opcode structure. Return NULL if the instruction is not recognized. */ @@ -1882,7 +2161,21 @@ sh_insn_info (insn) return op; } - return NULL; + return NULL; +} + +/* See whether an instruction uses or sets a general purpose register */ + +static boolean +sh_insn_uses_or_sets_reg (insn, op, reg) + unsigned int insn; + const struct sh_opcode *op; + unsigned int reg; +{ + if (sh_insn_uses_reg (insn, op, reg)) + return true; + + return sh_insn_sets_reg (insn, op, reg); } /* See whether an instruction uses a general purpose register. */ @@ -1898,18 +2191,63 @@ sh_insn_uses_reg (insn, op, reg) f = op->flags; if ((f & USES1) != 0 - && ((insn & 0x0f00) >> 8) == reg) + && USES1_REG (insn) == reg) return true; if ((f & USES2) != 0 - && ((insn & 0x00f0) >> 4) == reg) + && USES2_REG (insn) == reg) return true; if ((f & USESR0) != 0 && reg == 0) return true; + if ((f & USESAS) && reg == USESAS_REG (insn)) + return true; + if ((f & USESR8) && reg == 8) + return true; return false; } +/* See whether an instruction sets a general purpose register. */ + +static boolean +sh_insn_sets_reg (insn, op, reg) + unsigned int insn; + const struct sh_opcode *op; + unsigned int reg; +{ + unsigned int f; + + f = op->flags; + + if ((f & SETS1) != 0 + && SETS1_REG (insn) == reg) + return true; + if ((f & SETS2) != 0 + && SETS2_REG (insn) == reg) + return true; + if ((f & SETSR0) != 0 + && reg == 0) + return true; + if ((f & SETSAS) && reg == SETSAS_REG (insn)) + return true; + + return false; +} + +/* See whether an instruction uses or sets a floating point register */ + +static boolean +sh_insn_uses_or_sets_freg (insn, op, reg) + unsigned int insn; + const struct sh_opcode *op; + unsigned int reg; +{ + if (sh_insn_uses_freg (insn, op, reg)) + return true; + + return sh_insn_sets_freg (insn, op, reg); +} + /* See whether an instruction uses a floating point register. */ static boolean @@ -1922,11 +2260,20 @@ sh_insn_uses_freg (insn, op, freg) f = op->flags; + /* We can't tell if this is a double-precision insn, so just play safe + and assume that it might be. So not only have we test FREG against + itself, but also even FREG against FREG+1 - if the using insn uses + just the low part of a double precision value - but also an odd + FREG against FREG-1 - if the setting insn sets just the low part + of a double precision value. + So what this all boils down to is that we have to ignore the lowest + bit of the register number. */ + if ((f & USESF1) != 0 - && ((insn & 0x0f00) >> 8) == freg) + && (USESF1_REG (insn) & 0xe) == (freg & 0xe)) return true; if ((f & USESF2) != 0 - && ((insn & 0x00f0) >> 4) == freg) + && (USESF2_REG (insn) & 0xe) == (freg & 0xe)) return true; if ((f & USESF0) != 0 && freg == 0) @@ -1935,6 +2282,34 @@ sh_insn_uses_freg (insn, op, freg) return false; } +/* See whether an instruction sets a floating point register. */ + +static boolean +sh_insn_sets_freg (insn, op, freg) + unsigned int insn; + const struct sh_opcode *op; + unsigned int freg; +{ + unsigned int f; + + f = op->flags; + + /* We can't tell if this is a double-precision insn, so just play safe + and assume that it might be. So not only have we test FREG against + itself, but also even FREG against FREG+1 - if the using insn uses + just the low part of a double precision value - but also an odd + FREG against FREG-1 - if the setting insn sets just the low part + of a double precision value. + So what this all boils down to is that we have to ignore the lowest + bit of the register number. */ + + if ((f & SETSF1) != 0 + && (SETSF1_REG (insn) & 0xe) == (freg & 0xe)) + return true; + + return false; +} + /* See whether instructions I1 and I2 conflict, assuming I1 comes before I2. OP1 and OP2 are the corresponding sh_opcode structures. This should return true if there is a conflict, or false if the @@ -1952,39 +2327,51 @@ sh_insns_conflict (i1, op1, i2, op2) f1 = op1->flags; f2 = op2->flags; + /* Load of fpscr conflicts with floating point operations. + FIXME: shouldn't test raw opcodes here. */ + if (((i1 & 0xf0ff) == 0x4066 && (i2 & 0xf000) == 0xf000) + || ((i2 & 0xf0ff) == 0x4066 && (i1 & 0xf000) == 0xf000)) + return true; + if ((f1 & (BRANCH | DELAY)) != 0 || (f2 & (BRANCH | DELAY)) != 0) return true; - if ((f1 & SETSSP) != 0 && (f2 & USESSP) != 0) - return true; - if ((f2 & SETSSP) != 0 && (f1 & USESSP) != 0) + if (((f1 | f2) & SETSSP) + && (f1 & (SETSSP | USESSP)) + && (f2 & (SETSSP | USESSP))) return true; if ((f1 & SETS1) != 0 - && sh_insn_uses_reg (i2, op2, (i1 & 0x0f00) >> 8)) + && sh_insn_uses_or_sets_reg (i2, op2, SETS1_REG (i1))) return true; if ((f1 & SETS2) != 0 - && sh_insn_uses_reg (i2, op2, (i1 & 0x00f0) >> 4)) + && sh_insn_uses_or_sets_reg (i2, op2, SETS2_REG (i1))) return true; if ((f1 & SETSR0) != 0 - && sh_insn_uses_reg (i2, op2, 0)) + && sh_insn_uses_or_sets_reg (i2, op2, 0)) + return true; + if ((f1 & SETSAS) + && sh_insn_uses_or_sets_reg (i2, op2, SETSAS_REG (i1))) return true; if ((f1 & SETSF1) != 0 - && sh_insn_uses_freg (i2, op2, (i1 & 0x0f00) >> 8)) + && sh_insn_uses_or_sets_freg (i2, op2, SETSF1_REG (i1))) return true; if ((f2 & SETS1) != 0 - && sh_insn_uses_reg (i1, op1, (i2 & 0x0f00) >> 8)) + && sh_insn_uses_or_sets_reg (i1, op1, SETS1_REG (i2))) return true; if ((f2 & SETS2) != 0 - && sh_insn_uses_reg (i1, op1, (i2 & 0x00f0) >> 4)) + && sh_insn_uses_or_sets_reg (i1, op1, SETS2_REG (i2))) return true; if ((f2 & SETSR0) != 0 - && sh_insn_uses_reg (i1, op1, 0)) + && sh_insn_uses_or_sets_reg (i1, op1, 0)) + return true; + if ((f2 & SETSAS) + && sh_insn_uses_or_sets_reg (i1, op1, SETSAS_REG (i2))) return true; if ((f2 & SETSF1) != 0 - && sh_insn_uses_freg (i1, op1, (i2 & 0x0f00) >> 8)) + && sh_insn_uses_or_sets_freg (i1, op1, SETSF1_REG (i2))) return true; /* The instructions do not conflict. */ @@ -2037,6 +2424,9 @@ sh_load_use (i1, op1, i2, op2) STOP are the range of memory to examine. If a swap is made, *PSWAPPED is set to true. */ +#ifdef COFF_WITH_PE +static +#endif boolean _bfd_sh_align_load_span (abfd, sec, contents, swap, relocs, plabel, label_end, start, stop, pswapped) @@ -2051,8 +2441,24 @@ _bfd_sh_align_load_span (abfd, sec, contents, swap, relocs, bfd_vma stop; boolean *pswapped; { + int dsp = (abfd->arch_info->mach == bfd_mach_sh_dsp + || abfd->arch_info->mach == bfd_mach_sh3_dsp); bfd_vma i; + /* The SH4 has a Harvard architecture, hence aligning loads is not + desirable. In fact, it is counter-productive, since it interferes + with the schedules generated by the compiler. */ + if (abfd->arch_info->mach == bfd_mach_sh4) + return true; + + /* If we are linking sh[3]-dsp code, swap the FPU instructions for DSP + instructions. */ + if (dsp) + { + sh_opcodes[0xf].minor_opcodes = sh_dsp_opcodef; + sh_opcodes[0xf].count = sizeof sh_dsp_opcodef / sizeof sh_dsp_opcodef; + } + /* Instructions should be aligned on 2 byte boundaries. */ if ((start & 1) == 1) ++start; @@ -2082,7 +2488,28 @@ _bfd_sh_align_load_span (abfd, sec, contents, swap, relocs, if (i > start) { prev_insn = bfd_get_16 (abfd, contents + i - 2); - prev_op = sh_insn_info (prev_insn); + /* If INSN is the field b of a parallel processing insn, it is not + a load / store after all. Note that the test here might mistake + the field_b of a pcopy insn for the starting code of a parallel + processing insn; this might miss a swapping opportunity, but at + least we're on the safe side. */ + if (dsp && (prev_insn & 0xfc00) == 0xf800) + continue; + + /* Check if prev_insn is actually the field b of a parallel + processing insn. Again, this can give a spurious match + after a pcopy. */ + if (dsp && i - 2 > start) + { + unsigned pprev_insn = bfd_get_16 (abfd, contents + i - 4); + + if ((pprev_insn & 0xfc00) == 0xf800) + prev_op = NULL; + else + prev_op = sh_insn_info (prev_insn); + } + else + prev_op = sh_insn_info (prev_insn); /* If the load/store instruction is in a delay slot, we can't swap. */ @@ -2209,6 +2636,7 @@ _bfd_sh_align_load_span (abfd, sec, contents, swap, relocs, return true; } +#endif /* not COFF_IMAGE_WITH_PE */ /* Look for loads and stores which we can align to four byte boundaries. See the longer comment above sh_relax_section for why @@ -2226,13 +2654,15 @@ sh_align_loads (abfd, sec, internal_relocs, contents, pswapped) struct internal_reloc *irel, *irelend; bfd_vma *labels = NULL; bfd_vma *label, *label_end; + bfd_size_type amt; *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)); + amt = (bfd_size_type) sec->reloc_count * sizeof (bfd_vma); + labels = (bfd_vma *) bfd_malloc (amt); if (labels == NULL) goto error_return; label_end = labels; @@ -2301,8 +2731,8 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) /* 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); + bfd_put_16 (abfd, (bfd_vma) i2, contents + addr); + bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2); /* Adjust all reloc addresses. */ irelend = internal_relocs + sec->reloc_count; @@ -2370,7 +2800,7 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) insn += add / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; - bfd_put_16 (abfd, insn, loc); + bfd_put_16 (abfd, (bfd_vma) insn, loc); break; case R_SH_PCDISP: @@ -2379,7 +2809,7 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) insn += add / 2; if ((oinsn & 0xf000) != (insn & 0xf000)) overflow = true; - bfd_put_16 (abfd, insn, loc); + bfd_put_16 (abfd, (bfd_vma) insn, loc); break; case R_SH_PCRELIMM8BY4: @@ -2396,7 +2826,7 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) insn += add / 2; if ((oinsn & 0xff00) != (insn & 0xff00)) overflow = true; - bfd_put_16 (abfd, insn, loc); + bfd_put_16 (abfd, (bfd_vma) insn, loc); } break; @@ -2406,7 +2836,7 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) { ((*_bfd_error_handler) ("%s: 0x%lx: fatal: reloc overflow while relaxing", - bfd_get_filename (abfd), (unsigned long) irel->r_vaddr)); + bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr)); bfd_set_error (bfd_error_bad_value); return false; } @@ -2422,7 +2852,7 @@ sh_swap_insns (abfd, sec, relocs, contents, addr) static boolean sh_relocate_section (output_bfd, info, input_bfd, input_section, contents, relocs, syms, sections) - bfd *output_bfd; + bfd *output_bfd ATTRIBUTE_UNUSED; struct bfd_link_info *info; bfd *input_bfd; asection *input_section; @@ -2449,6 +2879,10 @@ sh_relocate_section (output_bfd, info, input_bfd, input_section, contents, /* 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 (rel->r_type != R_SH_IMM32 +#ifdef COFF_WITH_PE + && rel->r_type != R_SH_IMM32CE + && rel->r_type != R_SH_IMAGEBASE +#endif && rel->r_type != R_SH_PCDISP) continue; @@ -2460,13 +2894,13 @@ sh_relocate_section (output_bfd, info, input_bfd, input_section, contents, sym = NULL; } else - { + { if (symndx < 0 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd)) { (*_bfd_error_handler) ("%s: illegal symbol index %ld in relocs", - bfd_get_filename (input_bfd), symndx); + bfd_archive_filename (input_bfd), symndx); bfd_set_error (bfd_error_bad_value); return false; } @@ -2493,6 +2927,11 @@ sh_relocate_section (output_bfd, info, input_bfd, input_section, contents, return false; } +#ifdef COFF_WITH_PE + if (rel->r_type == R_SH_IMAGEBASE) + addend -= pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase; +#endif + val = 0; if (h == NULL) @@ -2533,7 +2972,7 @@ sh_relocate_section (output_bfd, info, input_bfd, input_section, contents, { if (! ((*info->callbacks->undefined_symbol) (info, h->root.root.string, input_bfd, input_section, - rel->r_vaddr - input_section->vma))) + rel->r_vaddr - input_section->vma, true))) return false; } } @@ -2609,7 +3048,7 @@ sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order, symbols); memcpy (data, coff_section_data (input_bfd, input_section)->contents, - input_section->_raw_size); + (size_t) input_section->_raw_size); if ((input_section->flags & SEC_RELOC) != 0 && input_section->reloc_count > 0) @@ -2618,6 +3057,7 @@ sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order, bfd_byte *esym, *esymend; struct internal_syment *isymp; asection **secpp; + bfd_size_type amt; if (! _bfd_coff_get_external_symbols (input_bfd)) goto error_return; @@ -2628,14 +3068,15 @@ sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order, if (internal_relocs == NULL) goto error_return; - internal_syms = ((struct internal_syment *) - bfd_malloc (obj_raw_syment_count (input_bfd) - * sizeof (struct internal_syment))); + amt = obj_raw_syment_count (input_bfd); + amt *= sizeof (struct internal_syment); + internal_syms = (struct internal_syment *) bfd_malloc (amt); if (internal_syms == NULL) goto error_return; - sections = (asection **) bfd_malloc (obj_raw_syment_count (input_bfd) - * sizeof (asection *)); + amt = obj_raw_syment_count (input_bfd); + amt *= sizeof (asection *); + sections = (asection **) bfd_malloc (amt); if (sections == NULL) goto error_return; @@ -2689,90 +3130,31 @@ sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order, /* The target vectors. */ -const bfd_target shcoff_vec = -{ - "coff-sh", /* name */ - bfd_target_coff_flavour, - BFD_ENDIAN_BIG, /* data byte order is big */ - BFD_ENDIAN_BIG, /* header byte order is big */ - - (HAS_RELOC | EXEC_P | /* object flags */ - HAS_LINENO | HAS_DEBUG | - HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE), - - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), - '_', /* leading symbol underscore */ - '/', /* ar_pad_char */ - 15, /* ar_max_namelen */ - bfd_getb64, bfd_getb_signed_64, bfd_putb64, - bfd_getb32, bfd_getb_signed_32, bfd_putb32, - bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ - bfd_getb64, bfd_getb_signed_64, bfd_putb64, - bfd_getb32, bfd_getb_signed_32, bfd_putb32, - bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ - - {_bfd_dummy_target, coff_object_p, /* bfd_check_format */ - bfd_generic_archive_p, _bfd_dummy_target}, - {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ - bfd_false}, - {bfd_false, coff_write_object_contents, /* bfd_write_contents */ - _bfd_write_archive_contents, bfd_false}, - - BFD_JUMP_TABLE_GENERIC (coff), - BFD_JUMP_TABLE_COPY (coff), - BFD_JUMP_TABLE_CORE (_bfd_nocore), - BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), - BFD_JUMP_TABLE_SYMBOLS (coff), - BFD_JUMP_TABLE_RELOCS (coff), - BFD_JUMP_TABLE_WRITE (coff), - BFD_JUMP_TABLE_LINK (coff), - BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), - - COFF_SWAP_TABLE, -}; - -const bfd_target shlcoff_vec = -{ - "coff-shl", /* name */ - bfd_target_coff_flavour, - BFD_ENDIAN_LITTLE, /* data byte order is little */ - BFD_ENDIAN_LITTLE, /* header byte order is little endian too*/ - - (HAS_RELOC | EXEC_P | /* object flags */ - HAS_LINENO | HAS_DEBUG | - HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE), - - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), - '_', /* leading symbol underscore */ - '/', /* ar_pad_char */ - 15, /* ar_max_namelen */ - bfd_getl64, bfd_getl_signed_64, bfd_putl64, - bfd_getl32, bfd_getl_signed_32, bfd_putl32, - bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ - bfd_getl64, bfd_getl_signed_64, bfd_putl64, - bfd_getl32, bfd_getl_signed_32, bfd_putl32, - bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ +#ifndef TARGET_SHL_SYM +CREATE_BIG_COFF_TARGET_VEC (shcoff_vec, "coff-sh", BFD_IS_RELAXABLE, 0, '_', NULL) +#endif - {_bfd_dummy_target, coff_object_p, /* bfd_check_format */ - bfd_generic_archive_p, _bfd_dummy_target}, - {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ - bfd_false}, - {bfd_false, coff_write_object_contents, /* bfd_write_contents */ - _bfd_write_archive_contents, bfd_false}, +#ifdef TARGET_SHL_SYM +#define TARGET_SYM TARGET_SHL_SYM +#else +#define TARGET_SYM shlcoff_vec +#endif - BFD_JUMP_TABLE_GENERIC (coff), - BFD_JUMP_TABLE_COPY (coff), - BFD_JUMP_TABLE_CORE (_bfd_nocore), - BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), - BFD_JUMP_TABLE_SYMBOLS (coff), - BFD_JUMP_TABLE_RELOCS (coff), - BFD_JUMP_TABLE_WRITE (coff), - BFD_JUMP_TABLE_LINK (coff), - BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), +#ifndef TARGET_SHL_NAME +#define TARGET_SHL_NAME "coff-shl" +#endif - COFF_SWAP_TABLE, -}; +#ifdef COFF_WITH_PE +CREATE_LITTLE_COFF_TARGET_VEC (TARGET_SYM, TARGET_SHL_NAME, BFD_IS_RELAXABLE, + SEC_CODE | SEC_DATA, '_', NULL); +#else +CREATE_LITTLE_COFF_TARGET_VEC (TARGET_SYM, TARGET_SHL_NAME, BFD_IS_RELAXABLE, + 0, '_', NULL) +#endif +#ifndef TARGET_SHL_SYM +static const bfd_target * coff_small_object_p PARAMS ((bfd *)); +static boolean coff_small_new_section_hook PARAMS ((bfd *, asection *)); /* Some people want versions of the SH COFF target which do not align to 16 byte boundaries. We implement that by adding a couple of new target vectors. These are just like the ones above, but they @@ -2827,7 +3209,7 @@ static const bfd_coff_backend_data bfd_coff_small_swap_table = coff_swap_lineno_out, coff_swap_reloc_out, coff_swap_filehdr_out, coff_swap_aouthdr_out, coff_swap_scnhdr_out, - FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, + FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, #ifdef COFF_LONG_FILENAMES true, #else @@ -2839,12 +3221,22 @@ static const bfd_coff_backend_data bfd_coff_small_swap_table = false, #endif 2, +#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS + true, +#else + false, +#endif +#ifdef COFF_DEBUG_STRING_WIDE_PREFIX + 4, +#else + 2, +#endif coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in, coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, - coff_sym_is_global, coff_compute_section_file_positions, + coff_classify_symbol, coff_compute_section_file_positions, coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, coff_adjust_symndx, coff_link_add_one_symbol, coff_link_output_has_begun, coff_final_link_postscript @@ -2859,6 +3251,8 @@ static const bfd_coff_backend_data bfd_coff_small_swap_table = #define coff_small_get_section_contents_in_window \ coff_get_section_contents_in_window +extern const bfd_target shlcoff_small_vec; + const bfd_target shcoff_small_vec = { "coff-sh-small", /* name */ @@ -2898,6 +3292,8 @@ const bfd_target shcoff_small_vec = BFD_JUMP_TABLE_LINK (coff), BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + & shlcoff_small_vec, + (PTR) &bfd_coff_small_swap_table }; @@ -2924,7 +3320,7 @@ const bfd_target shlcoff_small_vec = bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ {_bfd_dummy_target, coff_small_object_p, /* bfd_check_format */ - bfd_generic_archive_p, _bfd_dummy_target}, + bfd_generic_archive_p, _bfd_dummy_target}, {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ bfd_false}, {bfd_false, coff_write_object_contents, /* bfd_write_contents */ @@ -2940,5 +3336,8 @@ const bfd_target shlcoff_small_vec = BFD_JUMP_TABLE_LINK (coff), BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + & shcoff_small_vec, + (PTR) &bfd_coff_small_swap_table }; +#endif diff --git a/contrib/binutils/bfd/cpu-sh.c b/contrib/binutils/bfd/cpu-sh.c index 9f7ef20..30cd141 100644 --- a/contrib/binutils/bfd/cpu-sh.c +++ b/contrib/binutils/bfd/cpu-sh.c @@ -1,5 +1,6 @@ /* BFD library support routines for the Hitachi-SH architecture. - Copyright (C) 1993 Free Software Foundation, Inc. + Copyright 1993, 1994, 1997, 1998, 2000, 2001 + Free Software Foundation, Inc. Hacked by Steve Chamberlain of Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -22,8 +23,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "sysdep.h" #include "libbfd.h" +static boolean scan_mach + PARAMS ((const struct bfd_arch_info *, const char *)); -static boolean +static boolean scan_mach (info, string) const struct bfd_arch_info *info; const char *string; @@ -33,7 +36,6 @@ scan_mach (info, string) return false; } - #if 0 /* This routine is provided two arch_infos and returns whether they'd be compatible */ @@ -49,18 +51,52 @@ compatible (a,b) } #endif -#define SH_NEXT &arch_info_struct[0] -#define SH3_NEXT &arch_info_struct[1] -#define SH3E_NEXT &arch_info_struct[2] -#define SH4_NEXT NULL +#define SH_NEXT &arch_info_struct[0] +#define SH2_NEXT &arch_info_struct[1] +#define SH_DSP_NEXT &arch_info_struct[2] +#define SH3_NEXT &arch_info_struct[3] +#define SH3_DSP_NEXT &arch_info_struct[4] +#define SH3E_NEXT &arch_info_struct[5] +#define SH4_NEXT NULL +#undef SH4_NEXT +#define SH4_NEXT &arch_info_struct[6] +#define SH64_NEXT NULL -static const bfd_arch_info_type arch_info_struct[] = +static const bfd_arch_info_type arch_info_struct[] = { { 32, /* 32 bits in a word */ 32, /* 32 bits in an address */ 8, /* 8 bits in a byte */ bfd_arch_sh, + bfd_mach_sh2, + "sh", /* arch_name */ + "sh2", /* printable name */ + 1, + false, /* not the default */ + bfd_default_compatible, + scan_mach, + SH2_NEXT + }, + { + 32, /* 32 bits in a word */ + 32, /* 32 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_sh, + bfd_mach_sh_dsp, + "sh", /* arch_name */ + "sh-dsp", /* printable name */ + 1, + false, /* not the default */ + bfd_default_compatible, + scan_mach, + SH_DSP_NEXT + }, + { + 32, /* 32 bits in a word */ + 32, /* 32 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_sh, bfd_mach_sh3, "sh", /* arch_name */ "sh3", /* printable name */ @@ -75,6 +111,20 @@ static const bfd_arch_info_type arch_info_struct[] = 32, /* 32 bits in an address */ 8, /* 8 bits in a byte */ bfd_arch_sh, + bfd_mach_sh3_dsp, + "sh", /* arch_name */ + "sh3-dsp", /* printable name */ + 1, + false, /* not the default */ + bfd_default_compatible, + scan_mach, + SH3_DSP_NEXT + }, + { + 32, /* 32 bits in a word */ + 32, /* 32 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_sh, bfd_mach_sh3e, "sh", /* arch_name */ "sh3e", /* printable name */ @@ -98,6 +148,20 @@ static const bfd_arch_info_type arch_info_struct[] = scan_mach, SH4_NEXT }, + { + 64, /* 64 bits in a word */ + 64, /* 64 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_sh, + bfd_mach_sh5, + "sh", /* arch_name */ + "sh5", /* printable name */ + 1, + false, /* not the default */ + bfd_default_compatible, + scan_mach, + SH64_NEXT + }, }; const bfd_arch_info_type bfd_sh_arch = diff --git a/contrib/binutils/bfd/elf32-sh.c b/contrib/binutils/bfd/elf32-sh.c index 7153803..74f276b 100644 --- a/contrib/binutils/bfd/elf32-sh.c +++ b/contrib/binutils/bfd/elf32-sh.c @@ -1,5 +1,6 @@ /* Hitachi SH specific support for 32-bit ELF - Copyright 1996, 1997, 1998 Free Software Foundation, Inc. + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. Contributed by Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -23,6 +24,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #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 **)); @@ -32,6 +34,14 @@ 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 *)); +static 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 @@ -46,33 +56,43 @@ static boolean sh_elf_relocate_section static bfd_byte *sh_elf_get_relocated_section_contents PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, boolean, asymbol **)); - -enum sh_reloc_type -{ - R_SH_NONE = 0, - R_SH_DIR32, - R_SH_REL32, - R_SH_DIR8WPN, - R_SH_IND12W, - R_SH_DIR8WPL, - R_SH_DIR8WPZ, - R_SH_DIR8BP, - R_SH_DIR8W, - R_SH_DIR8L, - FIRST_INVALID_RELOC, - LAST_INVALID_RELOC = 24, - /* The remaining relocs are a GNU extension used for relaxation. We - use the same constants as COFF uses, not that it really matters. */ - R_SH_SWITCH16 = 25, - R_SH_SWITCH32, - R_SH_USES, - R_SH_COUNT, - R_SH_ALIGN, - R_SH_CODE, - R_SH_DATA, - R_SH_LABEL, - R_SH_max -}; +static boolean sh_elf_check_relocs + PARAMS ((bfd *, struct bfd_link_info *, asection *, + const Elf_Internal_Rela *)); +static struct bfd_hash_entry *sh_elf_link_hash_newfunc + PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); +static struct bfd_link_hash_table *sh_elf_link_hash_table_create + PARAMS ((bfd *)); +static boolean sh_elf_adjust_dynamic_symbol + PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); +static boolean sh_elf_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +static boolean sh_elf_finish_dynamic_symbol + PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, + Elf_Internal_Sym *)); +static boolean sh_elf_finish_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +static bfd_reloc_status_type sh_elf_reloc_loop + PARAMS ((int, bfd *, asection *, bfd_byte *, bfd_vma, asection *, + bfd_vma, bfd_vma)); +static boolean sh_elf_create_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +static asection * sh_elf_gc_mark_hook + PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, + struct elf_link_hash_entry *, Elf_Internal_Sym *)); +static boolean sh_elf_gc_sweep_hook + PARAMS ((bfd *, struct bfd_link_info *, asection *, + const Elf_Internal_Rela *)); +static enum elf_reloc_type_class sh_elf_reloc_type_class + PARAMS ((const Elf_Internal_Rela *)); +#ifdef INCLUDE_SHMEDIA +inline static void movi_shori_putval PARAMS ((bfd *, unsigned long, char *)); +#endif + +/* The name of the dynamic interpreter. This is put in the .interp + section. */ + +#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" static reloc_howto_type sh_elf_howto_table[] = { @@ -84,7 +104,7 @@ static reloc_howto_type sh_elf_howto_table[] = false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_NONE", /* name */ false, /* partial_inplace */ 0, /* src_mask */ @@ -115,10 +135,10 @@ static reloc_howto_type sh_elf_howto_table[] = true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_REL32", /* name */ - false, /* partial_inplace */ - 0, /* src_mask */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ true), /* pcrel_offset */ @@ -130,7 +150,7 @@ static reloc_howto_type sh_elf_howto_table[] = true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPN", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ @@ -160,7 +180,7 @@ static reloc_howto_type sh_elf_howto_table[] = true, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPL", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ @@ -175,7 +195,7 @@ static reloc_howto_type sh_elf_howto_table[] = true, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8WPZ", /* name */ true, /* partial_inplace */ 0xff, /* src_mask */ @@ -192,7 +212,7 @@ static reloc_howto_type sh_elf_howto_table[] = false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8BP", /* name */ false, /* partial_inplace */ 0, /* src_mask */ @@ -209,7 +229,7 @@ static reloc_howto_type sh_elf_howto_table[] = false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8W", /* name */ false, /* partial_inplace */ 0, /* src_mask */ @@ -226,28 +246,28 @@ static reloc_howto_type sh_elf_howto_table[] = false, /* pc_relative */ 0, /* bitpos */ complain_overflow_unsigned, /* complain_on_overflow */ - sh_elf_reloc, /* special_function */ + sh_elf_ignore_reloc, /* special_function */ "R_SH_DIR8L", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ - { 10 }, - { 11 }, - { 12 }, - { 13 }, - { 14 }, - { 15 }, - { 16 }, - { 17 }, - { 18 }, - { 19 }, - { 20 }, - { 21 }, - { 22 }, - { 23 }, - { 24 }, + 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 @@ -389,1515 +409,5554 @@ static reloc_howto_type sh_elf_howto_table[] = false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - true) /* pcrel_offset */ -}; - -/* This function is used for normal relocs. This is 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; -{ - unsigned long insn; - bfd_vma sym_value; - enum sh_reloc_type r_type; - bfd_vma addr = reloc_entry->address; - bfd_byte *hit_data = addr + (bfd_byte *) data; + true), /* pcrel_offset */ - r_type = (enum sh_reloc_type) reloc_entry->howto->type; + /* 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 */ - if (output_bfd != NULL) - { - /* Partial linking--do nothing. */ - reloc_entry->address += input_section->output_offset; - return bfd_reloc_ok; - } + /* 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 */ - /* 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_DIR32 - && (r_type != R_SH_IND12W - || (symbol_in->flags & BSF_LOCAL) != 0)) - return bfd_reloc_ok; + /* 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 */ - if (symbol_in != NULL - && bfd_is_und_section (symbol_in->section)) - return bfd_reloc_undefined; + EMPTY_HOWTO (38), + EMPTY_HOWTO (39), + EMPTY_HOWTO (40), + EMPTY_HOWTO (41), + EMPTY_HOWTO (42), + EMPTY_HOWTO (43), + EMPTY_HOWTO (44), + +#ifdef INCLUDE_SHMEDIA + /* Used in SHLLI.L and SHLRI.L. */ + HOWTO (R_SH_DIR5U, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 5, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_unsigned, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR5U", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xfc00, /* dst_mask */ + false), /* pcrel_offset */ - 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); + /* Used in SHARI, SHLLI et al. */ + HOWTO (R_SH_DIR6U, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 6, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_unsigned, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR6U", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xfc00, /* dst_mask */ + false), /* pcrel_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; - } + /* Used in BxxI, LDHI.L et al. */ + HOWTO (R_SH_DIR6S, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 6, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR6S", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xfc00, /* dst_mask */ + false), /* pcrel_offset */ - return bfd_reloc_ok; -} + /* Used in ADDI, ANDI et al. */ + HOWTO (R_SH_DIR10S, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 10, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR10S", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ -/* This function is used for relocs which are only used for relaxing, - which the linker should otherwise ignore. */ + /* Used in LD.UW, ST.W et al. */ + HOWTO (R_SH_DIR10SW, /* type */ + 1, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 11, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR10SW", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ -static bfd_reloc_status_type -sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section, - output_bfd, error_message) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - char **error_message; -{ - if (output_bfd != NULL) - reloc_entry->address += input_section->output_offset; - return bfd_reloc_ok; -} + /* Used in LD.L, FLD.S et al. */ + HOWTO (R_SH_DIR10SL, /* type */ + 2, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 12, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR10SL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ -/* This structure is used to map BFD reloc codes to SH ELF relocs. */ + /* Used in FLD.D, FST.P et al. */ + HOWTO (R_SH_DIR10SQ, /* type */ + 3, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 13, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_DIR10SQ", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ + +#else + EMPTY_HOWTO (45), + EMPTY_HOWTO (46), + EMPTY_HOWTO (47), + EMPTY_HOWTO (48), + EMPTY_HOWTO (49), + EMPTY_HOWTO (50), + EMPTY_HOWTO (51), +#endif + + EMPTY_HOWTO (52), + EMPTY_HOWTO (53), + EMPTY_HOWTO (54), + EMPTY_HOWTO (55), + EMPTY_HOWTO (56), + EMPTY_HOWTO (57), + EMPTY_HOWTO (58), + EMPTY_HOWTO (59), + EMPTY_HOWTO (60), + EMPTY_HOWTO (61), + EMPTY_HOWTO (62), + EMPTY_HOWTO (63), + EMPTY_HOWTO (64), + EMPTY_HOWTO (65), + EMPTY_HOWTO (66), + EMPTY_HOWTO (67), + EMPTY_HOWTO (68), + EMPTY_HOWTO (69), + EMPTY_HOWTO (70), + EMPTY_HOWTO (71), + EMPTY_HOWTO (72), + EMPTY_HOWTO (73), + EMPTY_HOWTO (74), + EMPTY_HOWTO (75), + EMPTY_HOWTO (76), + EMPTY_HOWTO (77), + EMPTY_HOWTO (78), + EMPTY_HOWTO (79), + EMPTY_HOWTO (80), + EMPTY_HOWTO (81), + EMPTY_HOWTO (82), + EMPTY_HOWTO (83), + EMPTY_HOWTO (84), + EMPTY_HOWTO (85), + EMPTY_HOWTO (86), + EMPTY_HOWTO (87), + EMPTY_HOWTO (88), + EMPTY_HOWTO (89), + EMPTY_HOWTO (90), + EMPTY_HOWTO (91), + EMPTY_HOWTO (92), + EMPTY_HOWTO (93), + EMPTY_HOWTO (94), + EMPTY_HOWTO (95), + EMPTY_HOWTO (96), + EMPTY_HOWTO (97), + EMPTY_HOWTO (98), + EMPTY_HOWTO (99), + EMPTY_HOWTO (100), + EMPTY_HOWTO (101), + EMPTY_HOWTO (102), + EMPTY_HOWTO (103), + EMPTY_HOWTO (104), + EMPTY_HOWTO (105), + EMPTY_HOWTO (106), + EMPTY_HOWTO (107), + EMPTY_HOWTO (108), + EMPTY_HOWTO (109), + EMPTY_HOWTO (110), + EMPTY_HOWTO (111), + EMPTY_HOWTO (112), + EMPTY_HOWTO (113), + EMPTY_HOWTO (114), + EMPTY_HOWTO (115), + EMPTY_HOWTO (116), + EMPTY_HOWTO (117), + EMPTY_HOWTO (118), + EMPTY_HOWTO (119), + EMPTY_HOWTO (120), + EMPTY_HOWTO (121), + EMPTY_HOWTO (122), + EMPTY_HOWTO (123), + EMPTY_HOWTO (124), + EMPTY_HOWTO (125), + EMPTY_HOWTO (126), + EMPTY_HOWTO (127), + EMPTY_HOWTO (128), + EMPTY_HOWTO (129), + EMPTY_HOWTO (130), + EMPTY_HOWTO (131), + EMPTY_HOWTO (132), + EMPTY_HOWTO (133), + EMPTY_HOWTO (134), + EMPTY_HOWTO (135), + EMPTY_HOWTO (136), + EMPTY_HOWTO (137), + EMPTY_HOWTO (138), + EMPTY_HOWTO (139), + EMPTY_HOWTO (140), + EMPTY_HOWTO (141), + EMPTY_HOWTO (142), + EMPTY_HOWTO (143), + EMPTY_HOWTO (144), + EMPTY_HOWTO (145), + EMPTY_HOWTO (146), + EMPTY_HOWTO (147), + EMPTY_HOWTO (148), + EMPTY_HOWTO (149), + EMPTY_HOWTO (150), + EMPTY_HOWTO (151), + EMPTY_HOWTO (152), + EMPTY_HOWTO (153), + EMPTY_HOWTO (154), + EMPTY_HOWTO (155), + EMPTY_HOWTO (156), + EMPTY_HOWTO (157), + EMPTY_HOWTO (158), + EMPTY_HOWTO (159), + + HOWTO (R_SH_GOT32, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_GOT32", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ -struct elf_reloc_map -{ - unsigned char bfd_reloc_val; - unsigned char elf_reloc_val; -}; + HOWTO (R_SH_PLT32, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + true, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_PLT32", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + true), /* pcrel_offset */ -/* An array mapping BFD reloc codes to SH ELF relocs. */ + HOWTO (R_SH_COPY, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_COPY", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ -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_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 } -}; + HOWTO (R_SH_GLOB_DAT, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_GLOB_DAT", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ -/* Given a BFD reloc code, return the howto structure for the - corresponding SH ELf reloc. */ + HOWTO (R_SH_JMP_SLOT, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_JMP_SLOT", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ -static reloc_howto_type * -sh_elf_reloc_type_lookup (abfd, code) - bfd *abfd; - bfd_reloc_code_real_type code; -{ + HOWTO (R_SH_RELATIVE, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_RELATIVE", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_GOTOFF, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_GOTOFF", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_GOTPC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + true, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_GOTPC", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + true), /* pcrel_offset */ + + HOWTO (R_SH_GOTPLT32, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* */ + "R_SH_GOTPLT32", /* name */ + false, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + false), /* pcrel_offset */ + +#ifdef INCLUDE_SHMEDIA + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_GOT_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_GOT_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_GOT_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_GOT_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_GOTPLT_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_GOTPLT_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_GOTPLT_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_GOTPLT_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_PLT_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_PLT_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_PLT_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_PLT_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_PLT_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_PLT_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_PLT_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_PLT_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_GOTOFF_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTOFF_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_GOTOFF_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTOFF_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_GOTOFF_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTOFF_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_GOTOFF_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTOFF_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_GOTPC_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPC_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_GOTPC_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPC_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_GOTPC_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPC_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_GOTPC_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPC_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in LD.L, FLD.S et al. */ + HOWTO (R_SH_GOT10BY4, /* type */ + 2, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 12, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT10BY4", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in LD.L, FLD.S et al. */ + HOWTO (R_SH_GOTPLT10BY4, /* type */ + 2, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 12, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT10BY4", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in FLD.D, FST.P et al. */ + HOWTO (R_SH_GOT10BY8, /* type */ + 3, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 13, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOT10BY8", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in FLD.D, FST.P et al. */ + HOWTO (R_SH_GOTPLT10BY8, /* type */ + 3, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 13, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GOTPLT10BY8", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0xffc00, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_COPY64, /* type */ + 0, /* rightshift */ + 4, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_COPY64", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_GLOB_DAT64, /* type */ + 0, /* rightshift */ + 4, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_GLOB_DAT64", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_JMP_SLOT64, /* type */ + 0, /* rightshift */ + 4, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_JMP_SLOT64", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + false), /* pcrel_offset */ + + HOWTO (R_SH_RELATIVE64, /* type */ + 0, /* rightshift */ + 4, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_RELATIVE64", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + false), /* pcrel_offset */ + + EMPTY_HOWTO (197), + EMPTY_HOWTO (198), + EMPTY_HOWTO (199), + EMPTY_HOWTO (200), + EMPTY_HOWTO (201), + EMPTY_HOWTO (202), + EMPTY_HOWTO (203), + EMPTY_HOWTO (204), + EMPTY_HOWTO (205), + EMPTY_HOWTO (206), + EMPTY_HOWTO (207), + EMPTY_HOWTO (208), + EMPTY_HOWTO (209), + EMPTY_HOWTO (210), + EMPTY_HOWTO (211), + EMPTY_HOWTO (212), + EMPTY_HOWTO (213), + EMPTY_HOWTO (214), + EMPTY_HOWTO (215), + EMPTY_HOWTO (216), + EMPTY_HOWTO (217), + EMPTY_HOWTO (218), + EMPTY_HOWTO (219), + EMPTY_HOWTO (220), + EMPTY_HOWTO (221), + EMPTY_HOWTO (222), + EMPTY_HOWTO (223), + EMPTY_HOWTO (224), + EMPTY_HOWTO (225), + EMPTY_HOWTO (226), + EMPTY_HOWTO (227), + EMPTY_HOWTO (228), + EMPTY_HOWTO (229), + EMPTY_HOWTO (230), + EMPTY_HOWTO (231), + EMPTY_HOWTO (232), + EMPTY_HOWTO (233), + EMPTY_HOWTO (234), + EMPTY_HOWTO (235), + EMPTY_HOWTO (236), + EMPTY_HOWTO (237), + EMPTY_HOWTO (238), + EMPTY_HOWTO (239), + EMPTY_HOWTO (240), + EMPTY_HOWTO (241), + + /* Relocations for SHmedia code. None of these are partial_inplace or + use the field being relocated (except R_SH_PT_16). */ + + /* The assembler will generate this reloc before a block of SHmedia + instructions. A section should be processed as assuming it contains + data, unless this reloc is seen. Note that a block of SHcompact + instructions are instead preceded by R_SH_CODE. + This is currently not implemented, but should be used for SHmedia + linker relaxation. */ + HOWTO (R_SH_SHMEDIA_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_SHMEDIA_CODE", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0, /* dst_mask */ + false), /* pcrel_offset */ + + /* The assembler will generate this reloc at a PTA or PTB instruction, + and the linker checks the right type of target, or changes a PTA to a + PTB, if the original insn was PT. */ + HOWTO (R_SH_PT_16, /* type */ + 2, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 18, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_PT_16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in unexpanded MOVI. */ + HOWTO (R_SH_IMMS16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMMS16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in SHORI. */ + HOWTO (R_SH_IMMU16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 16, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_unsigned, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMMU16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (x & 65536). */ + HOWTO (R_SH_IMM_LOW16, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_LOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x - $) & 65536). */ + HOWTO (R_SH_IMM_LOW16_PCREL, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_LOW16_PCREL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 16) & 65536). */ + HOWTO (R_SH_IMM_MEDLOW16, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_MEDLOW16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (((x - $) >> 16) & 65536). */ + HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */ + 16, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_MEDLOW16_PCREL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 32) & 65536). */ + HOWTO (R_SH_IMM_MEDHI16, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_MEDHI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (((x - $) >> 32) & 65536). */ + HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */ + 32, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_MEDHI16_PCREL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* Used in MOVI and SHORI ((x >> 48) & 65536). */ + HOWTO (R_SH_IMM_HI16, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_HI16", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + false), /* pcrel_offset */ + + /* Used in MOVI and SHORI (((x - $) >> 48) & 65536). */ + HOWTO (R_SH_IMM_HI16_PCREL, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_IMM_HI16_PCREL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + 0x3fffc00, /* dst_mask */ + true), /* pcrel_offset */ + + /* For the .uaquad pseudo. */ + HOWTO (R_SH_64, /* type */ + 0, /* rightshift */ + 4, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + false, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_64", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + false), /* pcrel_offset */ + + /* For the .uaquad pseudo, (x - $). */ + HOWTO (R_SH_64_PCREL, /* type */ + 48, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + true, /* pc_relative */ + 10, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_SH_64_PCREL", /* name */ + false, /* partial_inplace */ + 0, /* src_mask */ + ((bfd_vma) 0) - 1, /* dst_mask */ + true), /* pcrel_offset */ + +#endif +}; + +static bfd_reloc_status_type +sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr, + symbol_section, start, end) + int r_type ATTRIBUTE_UNUSED; + bfd *input_bfd; + asection *input_section; + bfd_byte *contents; + bfd_vma addr; + asection *symbol_section; + bfd_vma start, end; +{ + static bfd_vma last_addr; + static 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 + { + contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size); + if (contents == NULL) + return bfd_reloc_outofrange; + free_contents = contents; + 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 && 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, (bfd_vma) 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, (bfd_vma) 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, (bfd_vma) 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 }, + { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 }, + { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 }, + { BFD_RELOC_SH_COPY, R_SH_COPY }, + { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT }, + { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT }, + { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE }, + { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF }, + { BFD_RELOC_SH_GOTPC, R_SH_GOTPC }, + { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 }, +#ifdef INCLUDE_SHMEDIA + { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 }, + { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 }, + { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 }, + { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 }, + { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 }, + { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 }, + { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 }, + { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 }, + { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 }, + { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 }, + { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 }, + { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 }, + { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 }, + { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 }, + { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 }, + { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 }, + { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 }, + { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 }, + { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 }, + { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 }, + { BFD_RELOC_SH_COPY64, R_SH_COPY64 }, + { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 }, + { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 }, + { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 }, + { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 }, + { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 }, + { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 }, + { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 }, + { BFD_RELOC_SH_PT_16, R_SH_PT_16 }, + { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE }, + { BFD_RELOC_SH_IMMU5, R_SH_DIR5U }, + { BFD_RELOC_SH_IMMS6, R_SH_DIR6S }, + { BFD_RELOC_SH_IMMU6, R_SH_DIR6U }, + { BFD_RELOC_SH_IMMS10, R_SH_DIR10S }, + { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW }, + { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL }, + { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ }, + { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 }, + { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 }, + { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 }, + { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL }, + { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 }, + { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL }, + { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 }, + { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL }, + { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 }, + { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL }, + { BFD_RELOC_64, R_SH_64 }, + { BFD_RELOC_64_PCREL, R_SH_64_PCREL }, +#endif /* not INCLUDE_SHMEDIA */ +}; + +/* 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++) + 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); + BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2); + BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3); + BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4); + + 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_Shdr *shndx_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; + Elf_External_Sym_Shndx *shndx_buf = NULL; + + *again = false; + + if (link_info->relocateable + || (sec->flags & SEC_RELOC) == 0 + || sec->reloc_count == 0) + return true; + +#ifdef INCLUDE_SHMEDIA + if (elf_section_data (sec)->this_hdr.sh_flags + & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) + { + return true; + } +#endif + + /* 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; + shndx_hdr = &elf_tdata (abfd)->symtab_shndx_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_archive_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_archive_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) &~ (bfd_vma) 3; + if (paddr >= sec->_raw_size) + { + ((*_bfd_error_handler) + (_("%s: 0x%lx: warning: bad R_SH_USES load offset"), + bfd_archive_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_archive_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 + { + bfd_size_type amt; + + amt = symtab_hdr->sh_info; + amt *= sizeof (Elf32_External_Sym); + extsyms = (Elf32_External_Sym *) bfd_malloc (amt); + if (extsyms == NULL) + goto error_return; + free_extsyms = extsyms; + if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0 + || bfd_bread ((PTR) extsyms, amt, abfd) != amt) + goto error_return; + symtab_hdr->contents = (bfd_byte *) extsyms; + } + + if (shndx_hdr->sh_size != 0) + { + bfd_size_type amt; + + amt = symtab_hdr->sh_info; + amt *= sizeof (Elf_External_Sym_Shndx); + shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); + if (shndx_buf == NULL) + goto error_return; + if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0 + || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt) + goto error_return; + shndx_hdr->contents = (bfd_byte *) shndx_buf; + } + } + + /* Get the value of the symbol referred to by the reloc. */ + if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info) + { + /* A local symbol. */ + Elf32_External_Sym *esym; + Elf_External_Sym_Shndx *shndx; + Elf_Internal_Sym isym; + + esym = extsyms + ELF32_R_SYM (irelfn->r_info); + shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (irelfn->r_info) : 0); + bfd_elf32_swap_symbol_in (abfd, esym, shndx, &isym); + + if (isym.st_shndx + != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec)) + { + ((*_bfd_error_handler) + (_("%s: 0x%lx: warning: symbol in unexpected section"), + bfd_archive_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; + + 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, + (bfd_vma) 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, (bfd_vma) 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_archive_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_archive_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; + + free_extsyms = NULL; + } + } + + if (free_relocs != NULL) + free (free_relocs); + + 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; + } + } + + if (shndx_buf != NULL) + { + shndx_hdr->contents = NULL; + free (shndx_buf); + } + + if (free_extsyms != NULL) + { + if (! link_info->keep_memory) + { + symtab_hdr->contents = NULL; + free (free_extsyms); + } + } + + return true; + + error_return: + if (free_relocs != NULL) + free (free_relocs); + if (free_contents != NULL) + free (free_contents); + if (shndx_buf != NULL) + { + shndx_hdr->contents = NULL; + free (shndx_buf); + } + if (free_extsyms != NULL) + { + symtab_hdr->contents = 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; + Elf_Internal_Shdr *shndx_hdr; + Elf32_External_Sym *extsyms; + unsigned int sec_shndx; + bfd_byte *contents; + Elf_Internal_Rela *irel, *irelend; + Elf_Internal_Rela *irelalign; + bfd_vma toaddr; + Elf32_External_Sym *esym, *esymend; + Elf_External_Sym_Shndx *shndx_buf, *shndx; + struct elf_link_hash_entry **sym_hashes; + struct elf_link_hash_entry **end_hashes; + unsigned int symcount; + asection *o; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + extsyms = (Elf32_External_Sym *) symtab_hdr->contents; + + shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; + shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents; + + sec_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, + (size_t) (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, (bfd_vma) 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) + { + esym = extsyms + ELF32_R_SYM (irel->r_info); + shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (irel->r_info) : 0); + bfd_elf32_swap_symbol_in (abfd, esym, shndx, &sym); + + if (sym.st_shndx == sec_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, (bfd_vma) insn, contents + nraddr); + break; + + case R_SH_IND12W: + insn += adjust / 2; + if ((oinsn & 0xf000) != (insn & 0xf000)) + overflow = true; + bfd_put_16 (abfd, (bfd_vma) 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, (bfd_vma) insn, contents + nraddr); + break; + + case R_SH_SWITCH8: + voff += adjust; + if (voff < 0 || voff >= 0xff) + overflow = true; + bfd_put_8 (abfd, voff, contents + nraddr); + break; + + case R_SH_SWITCH16: + voff += adjust; + if (voff < - 0x8000 || voff >= 0x8000) + overflow = true; + bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr); + break; + + case R_SH_SWITCH32: + voff += adjust; + bfd_put_signed_32 (abfd, (bfd_vma) 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_archive_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, (bfd_vma) voff + count, + ocontents + irelscan->r_offset); + else if (stop > addr + && stop < toaddr + && (start <= addr || start >= toaddr)) + bfd_put_signed_32 (abfd, (bfd_vma) 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; + + + esym = extsyms + ELF32_R_SYM (irelscan->r_info); + shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (irelscan->r_info) : 0); + bfd_elf32_swap_symbol_in (abfd, esym, shndx, &sym); + + if (sym.st_shndx == sec_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. */ + shndx = shndx_buf; + esym = extsyms; + esymend = esym + symtab_hdr->sh_info; + for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL)) + { + Elf_Internal_Sym isym; + Elf_External_Sym_Shndx dummy; + + bfd_elf32_swap_symbol_in (abfd, esym, shndx, &isym); + + if (isym.st_shndx == sec_shndx + && isym.st_value > addr + && isym.st_value < toaddr) + { + isym.st_value -= count; + bfd_elf32_swap_symbol_out (abfd, &isym, (PTR) esym, (PTR) &dummy); + } + } + + /* Now adjust the global symbols defined in this section. */ + symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) + - symtab_hdr->sh_info); + sym_hashes = elf_sym_hashes (abfd); + end_hashes = sym_hashes + symcount; + for (; sym_hashes < end_hashes; sym_hashes++) + { + struct elf_link_hash_entry *sym_hash = *sym_hashes; + if ((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, + (int) (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 ATTRIBUTE_UNUSED; + asection *sec; + Elf_Internal_Rela *internal_relocs; + bfd_byte *contents ATTRIBUTE_UNUSED; + boolean *pswapped; +{ + Elf_Internal_Rela *irel, *irelend; + bfd_vma *labels = NULL; + bfd_vma *label, *label_end; + bfd_size_type amt; + + *pswapped = false; + + irelend = internal_relocs + sec->reloc_count; + + /* Get all the addresses with labels on them. */ + amt = sec->reloc_count; + amt *= sizeof (bfd_vma); + labels = (bfd_vma *) bfd_malloc (amt); + 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, (bfd_vma) i2, contents + addr); + bfd_put_16 (abfd, (bfd_vma) 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, (bfd_vma) 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, (bfd_vma) 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, (bfd_vma) insn, loc); + } + + break; + } + + if (overflow) + { + ((*_bfd_error_handler) + (_("%s: 0x%lx: fatal: reloc overflow while relaxing"), + bfd_archive_filename (abfd), (unsigned long) irel->r_offset)); + bfd_set_error (bfd_error_bad_value); + return false; + } + } + } + + return true; +} + +#ifdef INCLUDE_SHMEDIA + +/* The size in bytes of an entry in the procedure linkage table. */ + +#define PLT_ENTRY_SIZE 64 + +/* First entry in an absolute procedure linkage table look like this. */ + +static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] = +{ + 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */ + 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */ + 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */ + 0x6b, 0xf1, 0x46, 0x00, /* ptabs r17, tr0 */ + 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */ + 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ +}; + +static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] = +{ + 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */ + 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */ + 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */ + 0x00, 0x46, 0xf1, 0x6b, /* ptabs r17, tr0 */ + 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */ + 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ +}; + +/* Sebsequent entries in an absolute procedure linkage table look like + this. */ + +static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */ + 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */ + 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */ + 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */ + 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */ + 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */ + 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */ + 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */ + 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */ + 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ +}; + +static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */ + 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */ + 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */ + 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */ + 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */ + 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */ + 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */ + 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */ + 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */ + 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ +}; + +/* Entries in a PIC procedure linkage table look like this. */ + +static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */ + 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */ + 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */ + 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */ + 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0x6f, 0xf0, 0xff, 0xf0, /* nop */ + 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */ + 0x00, 0xca, 0x45, 0x10, /* sub.l r12, r17, r17 */ + 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */ + 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */ + 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */ + 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */ + 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */ + 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */ +}; + +static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */ + 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */ + 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */ + 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */ + 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0xf0, 0xff, 0xf0, 0x6f, /* nop */ + 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */ + 0x10, 0x45, 0xca, 0x00, /* sub.l r12, r17, r17 */ + 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */ + 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */ + 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */ + 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */ + 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */ + 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */ +}; + +static const bfd_byte *elf_sh_plt0_entry; +static const bfd_byte *elf_sh_plt_entry; +static const bfd_byte *elf_sh_pic_plt_entry; + +/* Return size of a PLT entry. */ +#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE + +/* Return offset of the PLT0 address in an absolute PLT entry. */ +#define elf_sh_plt_plt0_offset(info) 32 + +/* Return offset of the linker in PLT0 entry. */ +#define elf_sh_plt0_gotplt_offset(info) 0 + +/* Return offset of the trampoline in PLT entry */ +#define elf_sh_plt_temp_offset(info) 33 /* Add one because it's SHmedia. */ + +/* Return offset of the symbol in PLT entry. */ +#define elf_sh_plt_symbol_offset(info) 0 + +/* Return offset of the relocation in PLT entry. */ +#define elf_sh_plt_reloc_offset(info) (info->shared ? 52 : 44) + +inline static void +movi_shori_putval (output_bfd, value, addr) + bfd *output_bfd; + unsigned long value; + char *addr; +{ + bfd_put_32 (output_bfd, + bfd_get_32 (output_bfd, addr) + | ((value >> 6) & 0x3fffc00), + addr); + bfd_put_32 (output_bfd, + bfd_get_32 (output_bfd, addr + 4) + | ((value << 10) & 0x3fffc00), + addr + 4); +} + +#else +/* The size in bytes of an entry in the procedure linkage table. */ + +#define PLT_ENTRY_SIZE 28 + +/* First entry in an absolute procedure linkage table look like this. */ + +#if 1 +/* Note - this code has been "optimised" not to use r2. r2 is used by + GCC to return the address of large strutcures, so it should not be + corrupted here. This does mean however, that this PLT does not conform + to the SH PIC ABI. That spec says that r0 contains the type of the PLT + and r2 contains the GOT id. This version stores the GOT id in r0 and + ignores the type. Loaders can easily detect this difference however, + since the type will always be 0 or 8, and the GOT ids will always be + greater than or equal to 12. */ +static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x05, /* mov.l 2f,r0 */ + 0x60, 0x02, /* mov.l @r0,r0 */ + 0x2f, 0x06, /* mov.l r0,@-r15 */ + 0xd0, 0x03, /* mov.l 1f,r0 */ + 0x60, 0x02, /* mov.l @r0,r0 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x60, 0xf6, /* mov.l @r15+,r0 */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ + 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ +}; + +static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] = +{ + 0x05, 0xd0, /* mov.l 2f,r0 */ + 0x02, 0x60, /* mov.l @r0,r0 */ + 0x06, 0x2f, /* mov.l r0,@-r15 */ + 0x03, 0xd0, /* mov.l 1f,r0 */ + 0x02, 0x60, /* mov.l @r0,r0 */ + 0x2b, 0x40, /* jmp @r0 */ + 0xf6, 0x60, /* mov.l @r15+,r0 */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ + 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ +}; + +/* Sebsequent entries in an absolute procedure linkage table look like + this. */ + +static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x04, /* mov.l 1f,r0 */ + 0x60, 0x02, /* mov.l @r0,r0 */ + 0xd1, 0x02, /* mov.l 0f,r1 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x60, 0x13, /* mov r1,r0 */ + 0xd1, 0x03, /* mov.l 2f,r1 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ +}; + +static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x04, 0xd0, /* mov.l 1f,r0 */ + 0x02, 0x60, /* mov.l @r0,r0 */ + 0x02, 0xd1, /* mov.l 0f,r1 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x13, 0x60, /* mov r1,r0 */ + 0x03, 0xd1, /* mov.l 2f,r1 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ +}; + +/* Entries in a PIC procedure linkage table look like this. */ + +static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x04, /* mov.l 1f,r0 */ + 0x00, 0xce, /* mov.l @(r0,r12),r0 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x00, 0x09, /* nop */ + 0x50, 0xc2, /* mov.l @(8,r12),r0 */ + 0xd1, 0x03, /* mov.l 2f,r1 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x50, 0xc1, /* mov.l @(4,r12),r0 */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ +}; + +static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x04, 0xd0, /* mov.l 1f,r0 */ + 0xce, 0x00, /* mov.l @(r0,r12),r0 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x09, 0x00, /* nop */ + 0xc2, 0x50, /* mov.l @(8,r12),r0 */ + 0x03, 0xd1, /* mov.l 2f,r1 */ + 0x2b, 0x40, /* jmp @r0 */ + 0xc1, 0x50, /* mov.l @(4,r12),r0 */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ +}; + +#else /* These are the old style PLT entries. */ +static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x04, /* mov.l 1f,r0 */ + 0xd2, 0x05, /* mov.l 2f,r2 */ + 0x60, 0x02, /* mov.l @r0,r0 */ + 0x62, 0x22, /* mov.l @r2,r2 */ + 0x40, 0x2b, /* jmp @r0 */ + 0xe0, 0x00, /* mov #0,r0 */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ + 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ +}; + +static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] = +{ + 0x04, 0xd0, /* mov.l 1f,r0 */ + 0x05, 0xd2, /* mov.l 2f,r2 */ + 0x02, 0x60, /* mov.l @r0,r0 */ + 0x22, 0x62, /* mov.l @r2,r2 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x00, 0xe0, /* mov #0,r0 */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ + 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ +}; + +/* Sebsequent entries in an absolute procedure linkage table look like + this. */ + +static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x04, /* mov.l 1f,r0 */ + 0x60, 0x02, /* mov.l @r0,r0 */ + 0xd2, 0x02, /* mov.l 0f,r2 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x60, 0x23, /* mov r2,r0 */ + 0xd1, 0x03, /* mov.l 2f,r1 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ +}; + +static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x04, 0xd0, /* mov.l 1f,r0 */ + 0x02, 0x60, /* mov.l @r0,r0 */ + 0x02, 0xd2, /* mov.l 0f,r2 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x23, 0x60, /* mov r2,r0 */ + 0x03, 0xd1, /* mov.l 2f,r1 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 0: replaced with address of .PLT. */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ +}; + +/* Entries in a PIC procedure linkage table look like this. */ + +static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] = +{ + 0xd0, 0x04, /* mov.l 1f,r0 */ + 0x00, 0xce, /* mov.l @(r0,r12),r0 */ + 0x40, 0x2b, /* jmp @r0 */ + 0x00, 0x09, /* nop */ + 0x50, 0xc2, /* 0: mov.l @(8,r12),r0 */ + 0x52, 0xc1, /* 1: mov.l @(4,r12),r2 */ + 0xd1, 0x02, /* mov.l 2f,r1 */ + 0x40, 0x2b, /* jmp @r0 */ + 0xe0, 0x00, /* mov #0,r0 ! shows the type of PLT. */ + 0x00, 0x09, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ +}; + +static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] = +{ + 0x04, 0xd0, /* mov.l 1f,r0 */ + 0xce, 0x00, /* mov.l @(r0,r12),r0 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x09, 0x00, /* nop */ + 0xc2, 0x50, /* 0: mov.l @(8,r12),r0 */ + 0xc1, 0x52, /* 1: mov.l @(4,r12),r2 */ + 0x02, 0xd1, /* mov.l 2f,r1 */ + 0x2b, 0x40, /* jmp @r0 */ + 0x00, 0xe0, /* mov #0,r0 ! shows the type of PLT. */ + 0x09, 0x00, /* nop */ + 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ + 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ +}; +#endif /* old style PLT entries. */ + +static const bfd_byte *elf_sh_plt0_entry; +static const bfd_byte *elf_sh_plt_entry; +static const bfd_byte *elf_sh_pic_plt_entry; + +/* Return size of a PLT entry. */ +#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE + +/* Return offset of the PLT0 address in an absolute PLT entry. */ +#define elf_sh_plt_plt0_offset(info) 16 + +/* Return offset of the linker in PLT0 entry. */ +#define elf_sh_plt0_linker_offset(info) 20 + +/* Return offset of the GOT id in PLT0 entry. */ +#define elf_sh_plt0_gotid_offset(info) 24 + +/* Return offset of the tempoline in PLT entry */ +#define elf_sh_plt_temp_offset(info) 8 + +/* Return offset of the symbol in PLT entry. */ +#define elf_sh_plt_symbol_offset(info) 20 + +/* Return offset of the relocation in PLT entry. */ +#define elf_sh_plt_reloc_offset(info) 24 +#endif + +/* The sh linker needs to keep track of the number of relocs that it + decides to copy in check_relocs for each symbol. This is so that + it can discard PC relative relocs if it doesn't need them when + linking with -Bsymbolic. We store the information in a field + extending the regular ELF linker hash table. */ + +/* This structure keeps track of the number of PC relative relocs we + have copied for a given symbol. */ + +struct elf_sh_pcrel_relocs_copied +{ + /* Next section. */ + struct elf_sh_pcrel_relocs_copied *next; + /* A section in dynobj. */ + asection *section; + /* Number of relocs copied in this section. */ + bfd_size_type count; +}; + +/* sh ELF linker hash entry. */ + +struct elf_sh_link_hash_entry +{ + struct elf_link_hash_entry root; + +#ifdef INCLUDE_SHMEDIA + bfd_vma datalabel_got_offset; +#endif + + /* Number of PC relative relocs copied for this symbol. */ + struct elf_sh_pcrel_relocs_copied *pcrel_relocs_copied; +}; + +/* sh ELF linker hash table. */ + +struct elf_sh_link_hash_table +{ + struct elf_link_hash_table root; +}; + +/* Declare this now that the above structures are defined. */ + +static boolean sh_elf_discard_copies + PARAMS ((struct elf_sh_link_hash_entry *, PTR)); + +/* Traverse an sh ELF linker hash table. */ + +#define sh_elf_link_hash_traverse(table, func, info) \ + (elf_link_hash_traverse \ + (&(table)->root, \ + (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \ + (info))) + +/* Get the sh ELF linker hash table from a link_info structure. */ + +#define sh_elf_hash_table(p) \ + ((struct elf_sh_link_hash_table *) ((p)->hash)) + +/* Create an entry in an sh ELF linker hash table. */ + +static struct bfd_hash_entry * +sh_elf_link_hash_newfunc (entry, table, string) + struct bfd_hash_entry *entry; + struct bfd_hash_table *table; + const char *string; +{ + struct elf_sh_link_hash_entry *ret = + (struct elf_sh_link_hash_entry *) entry; + + /* Allocate the structure if it has not already been allocated by a + subclass. */ + if (ret == (struct elf_sh_link_hash_entry *) NULL) + ret = ((struct elf_sh_link_hash_entry *) + bfd_hash_allocate (table, + sizeof (struct elf_sh_link_hash_entry))); + if (ret == (struct elf_sh_link_hash_entry *) NULL) + return (struct bfd_hash_entry *) ret; + + /* Call the allocation method of the superclass. */ + ret = ((struct elf_sh_link_hash_entry *) + _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, + table, string)); + if (ret != (struct elf_sh_link_hash_entry *) NULL) { - if (sh_reloc_map[i].bfd_reloc_val == code) - return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val]; + ret->pcrel_relocs_copied = NULL; +#ifdef INCLUDE_SHMEDIA + ret->datalabel_got_offset = (bfd_vma) -1; +#endif } - return NULL; + return (struct bfd_hash_entry *) ret; } -/* Given an ELF reloc, fill in the howto field of a relent. */ +/* Create an sh ELF linker hash table. */ -static void -sh_elf_info_to_howto (abfd, cache_ptr, dst) +static struct bfd_link_hash_table * +sh_elf_link_hash_table_create (abfd) bfd *abfd; - arelent *cache_ptr; - Elf_Internal_Rela *dst; { - unsigned int r; + struct elf_sh_link_hash_table *ret; + bfd_size_type amt = sizeof (struct elf_sh_link_hash_table); - r = ELF32_R_TYPE (dst->r_info); + ret = (struct elf_sh_link_hash_table *) bfd_alloc (abfd, amt); + if (ret == (struct elf_sh_link_hash_table *) NULL) + return NULL; - BFD_ASSERT (r < (unsigned int) R_SH_max); - BFD_ASSERT (r < FIRST_INVALID_RELOC || r > LAST_INVALID_RELOC); + if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, + sh_elf_link_hash_newfunc)) + { + bfd_release (abfd, ret); + return NULL; + } - cache_ptr->howto = &sh_elf_howto_table[r]; + return &ret->root.root; } - -/* 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 sh_reloc_type in this file. */ -static boolean -sh_elf_relax_section (abfd, sec, link_info, again) +/* Create dynamic sections when linking against a dynamic object. */ + +static boolean +sh_elf_create_dynamic_sections (abfd, info) bfd *abfd; - asection *sec; - struct bfd_link_info *link_info; - boolean *again; + struct bfd_link_info *info; { - 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; + flagword flags, pltflags; + register asection *s; + struct elf_backend_data *bed = get_elf_backend_data (abfd); + int ptralign = 0; - *again = false; + switch (bed->s->arch_size) + { + case 32: + ptralign = 2; + break; - if (link_info->relocateable - || (sec->flags & SEC_RELOC) == 0 - || sec->reloc_count == 0) - return true; + case 64: + ptralign = 3; + break; - /* 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; + default: + bfd_set_error (bfd_error_bad_value); + return false; + } - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and + .rel[a].bss sections. */ - 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; + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED); - have_code = false; + pltflags = flags; + pltflags |= SEC_CODE; + if (bed->plt_not_loaded) + pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS); + if (bed->plt_readonly) + pltflags |= SEC_READONLY; - 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; + s = bfd_make_section (abfd, ".plt"); + if (s == NULL + || ! bfd_set_section_flags (abfd, s, pltflags) + || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) + return false; - if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE) - have_code = true; + if (bed->want_plt_sym) + { + /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the + .plt section. */ + struct elf_link_hash_entry *h = NULL; + if (! (_bfd_generic_link_add_one_symbol + (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, + (bfd_vma) 0, (const char *) NULL, false, + get_elf_backend_data (abfd)->collect, + (struct bfd_link_hash_entry **) &h))) + return false; + h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; + h->type = STT_OBJECT; - if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES) - continue; + if (info->shared + && ! _bfd_elf_link_record_dynamic_symbol (info, h)) + return false; + } - /* 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; + s = bfd_make_section (abfd, + bed->default_use_rela_p ? ".rela.plt" : ".rel.plt"); + if (s == NULL + || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) + || ! bfd_set_section_alignment (abfd, s, ptralign)) + return false; + + if (! _bfd_elf_create_got_section (abfd, info)) + return false; + + { + const char *secname; + char *relname; + flagword secflags; + asection *sec; + + for (sec = abfd->sections; sec; sec = sec->next) + { + secflags = bfd_get_section_flags (abfd, sec); + if ((secflags & (SEC_DATA | SEC_LINKER_CREATED)) + || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS)) + continue; + secname = bfd_get_section_name (abfd, sec); + relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6); + strcpy (relname, ".rela"); + strcat (relname, secname); + s = bfd_make_section (abfd, relname); + if (s == NULL + || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) + || ! bfd_set_section_alignment (abfd, s, ptralign)) + return false; + } + } - if (! bfd_get_section_contents (abfd, sec, contents, - (file_ptr) 0, sec->_raw_size)) - goto error_return; - } - } + if (bed->want_dynbss) + { + /* The .dynbss section is a place to put symbols which are defined + by dynamic objects, are referenced by regular objects, and are + not functions. We must allocate space for them in the process + image and use a R_*_COPY reloc to tell the dynamic linker to + initialize them at run time. The linker script puts the .dynbss + section into the .bss section of the final image. */ + s = bfd_make_section (abfd, ".dynbss"); + if (s == NULL + || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) + return false; - /* 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) + /* The .rel[a].bss section holds copy relocs. This section is not + normally needed. We need to create it here, though, so that the + linker will map it to an output section. We can't just create it + only if we need it, because we will not know whether we need it + until we have seen all the input files, and the first time the + main linker code calls BFD after examining all the input files + (size_dynamic_sections) the input sections have already been + mapped to the output sections. If the section turns out not to + be needed, we can discard it later. We will never need this + section when generating a shared object, since they do not use + copy relocs. */ + if (! info->shared) { - (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset", - bfd_get_filename (abfd), - (unsigned long) irel->r_offset); - continue; + s = bfd_make_section (abfd, + (bed->default_use_rela_p + ? ".rela.bss" : ".rel.bss")); + if (s == NULL + || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) + || ! bfd_set_section_alignment (abfd, s, ptralign)) + return false; } - 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; - } + return true; +} + +/* Adjust a symbol defined by a dynamic object and referenced by a + regular object. The current definition is in some section of the + dynamic object, but we're not including those sections. We have to + change the definition to something the rest of the link can + understand. */ - /* 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) +static boolean +sh_elf_adjust_dynamic_symbol (info, h) + struct bfd_link_info *info; + struct elf_link_hash_entry *h; +{ + bfd *dynobj; + asection *s; + unsigned int power_of_two; + + dynobj = elf_hash_table (info)->dynobj; + + /* Make sure we know what is going on here. */ + BFD_ASSERT (dynobj != NULL + && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) + || h->weakdef != NULL + || ((h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_DYNAMIC) != 0 + && (h->elf_link_hash_flags + & ELF_LINK_HASH_REF_REGULAR) != 0 + && (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0))); + + /* If this is a function, put it in the procedure linkage table. We + will fill in the contents of the procedure linkage table later, + when we know the address of the .got section. */ + if (h->type == STT_FUNC + || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) + { + if (! info->shared + && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 + && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0) { - ((*_bfd_error_handler) - ("%s: 0x%lx: warning: bad R_SH_USES load offset", - bfd_get_filename (abfd), (unsigned long) irel->r_offset)); - continue; + /* This case can occur if we saw a PLT reloc in an input + file, but the symbol was never referred to by a dynamic + object. In such a case, we don't actually need to build + a procedure linkage table, and we can just do a REL32 + reloc instead. */ + BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0); + return true; } - /* 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) + /* Make sure this symbol is output as a dynamic symbol. */ + if (h->dynindx == -1) { - ((*_bfd_error_handler) - ("%s: 0x%lx: warning: could not find expected reloc", - bfd_get_filename (abfd), (unsigned long) paddr)); - continue; + if (! bfd_elf32_link_record_dynamic_symbol (info, h)) + return false; } - /* Read this BFD's symbols if we haven't done so already. */ - if (extsyms == NULL) + s = bfd_get_section_by_name (dynobj, ".plt"); + BFD_ASSERT (s != NULL); + + /* If this is the first .plt entry, make room for the special + first entry. */ + if (s->_raw_size == 0) + s->_raw_size += PLT_ENTRY_SIZE; + + /* If this symbol is not defined in a regular file, and we are + not generating a shared library, then set the symbol to this + location in the .plt. This is required to make function + pointers compare as equal between the normal executable and + the shared library. */ + if (! info->shared + && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) { - 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; - } + h->root.u.def.section = s; + h->root.u.def.value = s->_raw_size; } - /* 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; + h->plt.offset = s->_raw_size; - /* A local symbol. */ - bfd_elf32_swap_symbol_in (abfd, - extsyms + ELF32_R_SYM (irelfn->r_info), - &isym); + /* Make room for this entry. */ + s->_raw_size += elf_sh_sizeof_plt (info); - 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; - } + /* We also need to make an entry in the .got.plt section, which + will be placed in the .got section by the linker script. */ - symval = (isym.st_value - + sec->output_section->vma - + sec->output_offset); - } - else - { - unsigned long indx; - struct elf_link_hash_entry *h; + s = bfd_get_section_by_name (dynobj, ".got.plt"); + BFD_ASSERT (s != NULL); + s->_raw_size += 4; - 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; - } + /* We also need to make an entry in the .rela.plt section. */ - symval = (h->root.u.def.value - + h->root.u.def.section->output_section->vma - + h->root.u.def.section->output_offset); - } + s = bfd_get_section_by_name (dynobj, ".rela.plt"); + BFD_ASSERT (s != NULL); + s->_raw_size += sizeof (Elf32_External_Rela); - symval += bfd_get_32 (abfd, contents + paddr); + return true; + } + + /* If this is a weak symbol, and there is a real definition, the + processor independent code will have arranged for us to see the + real definition first, and we can just use the same value. */ + if (h->weakdef != NULL) + { + BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined + || h->weakdef->root.type == bfd_link_hash_defweak); + h->root.u.def.section = h->weakdef->root.u.def.section; + h->root.u.def.value = h->weakdef->root.u.def.value; + return true; + } + + /* This is a reference to a symbol defined by a dynamic object which + is not a function. */ + + /* If we are creating a shared library, we must presume that the + only references to the symbol are via the global offset table. + For such cases we need not do anything here; the relocations will + be handled correctly by relocate_section. */ + if (info->shared) + return true; + + /* If there are no references to this symbol that do not use the + GOT, we don't need to generate a copy reloc. */ + if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) + return true; + + /* We must allocate the symbol in our .dynbss section, which will + become part of the .bss section of the executable. There will be + an entry for this symbol in the .dynsym section. The dynamic + object will contain position independent code, so all references + from the dynamic object to this symbol will go through the global + offset table. The dynamic linker will use the .dynsym entry to + determine the address it must put in the global offset table, so + both the dynamic object and the regular object will refer to the + same memory location for the variable. */ + + s = bfd_get_section_by_name (dynobj, ".dynbss"); + BFD_ASSERT (s != NULL); + + /* We must generate a R_SH_COPY reloc to tell the dynamic linker to + copy the initial value out of the dynamic object and into the + runtime process image. We need to remember the offset into the + .rela.bss section we are going to use. */ + if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) + { + asection *srel; + + srel = bfd_get_section_by_name (dynobj, ".rela.bss"); + BFD_ASSERT (srel != NULL); + srel->_raw_size += sizeof (Elf32_External_Rela); + h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; + } + + /* We need to figure out the alignment required for this symbol. I + have no idea how ELF linkers handle this. */ + power_of_two = bfd_log2 (h->size); + if (power_of_two > 3) + power_of_two = 3; - /* 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; - } + /* Apply the required alignment. */ + s->_raw_size = BFD_ALIGN (s->_raw_size, + (bfd_size_type) (1 << power_of_two)); + if (power_of_two > bfd_get_section_alignment (dynobj, s)) + { + if (! bfd_set_section_alignment (dynobj, s, power_of_two)) + return false; + } - /* Shorten the function call. */ + /* Define the symbol as being at this point in the section. */ + h->root.u.def.section = s; + h->root.u.def.value = s->_raw_size; - /* 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. */ + /* Increment the section size to make room for the symbol. */ + s->_raw_size += h->size; - elf_section_data (sec)->relocs = internal_relocs; - free_relocs = NULL; + return true; +} - elf_section_data (sec)->this_hdr.contents = contents; - free_contents = NULL; +/* Set the sizes of the dynamic sections. */ - symtab_hdr->contents = (bfd_byte *) extsyms; - free_extsyms = NULL; +static boolean +sh_elf_size_dynamic_sections (output_bfd, info) + bfd *output_bfd ATTRIBUTE_UNUSED; + struct bfd_link_info *info; +{ + bfd *dynobj; + asection *s; + boolean plt; + boolean relocs; - /* Replace the jsr with a bsr. */ + dynobj = elf_hash_table (info)->dynobj; + BFD_ASSERT (dynobj != NULL); - /* 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 + if (elf_hash_table (info)->dynamic_sections_created) + { + /* Set the contents of the .interp section to the interpreter. */ + if (! info->shared) { - /* 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); + s = bfd_get_section_by_name (dynobj, ".interp"); + BFD_ASSERT (s != NULL); + s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; + s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; } + } + else + { + /* We may have created entries in the .rela.got section. + However, if we are not creating the dynamic sections, we will + not actually use these entries. Reset the size of .rela.got, + which will cause it to get stripped from the output file + below. */ + s = bfd_get_section_by_name (dynobj, ".rela.got"); + if (s != NULL) + s->_raw_size = 0; + } - /* 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; - } + /* If this is a -Bsymbolic shared link, then we need to discard all + PC relative relocs against symbols defined in a regular object. + We allocated space for them in the check_relocs routine, but we + will not fill them in in the relocate_section routine. */ + if (info->shared && info->symbolic) + sh_elf_link_hash_traverse (sh_elf_hash_table (info), + sh_elf_discard_copies, + (PTR) NULL); + + /* The check_relocs and adjust_dynamic_symbol entry points have + determined the sizes of the various dynamic sections. Allocate + memory for them. */ + plt = false; + relocs = false; + for (s = dynobj->sections; s != NULL; s = s->next) + { + const char *name; + boolean strip; - /* 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; + if ((s->flags & SEC_LINKER_CREATED) == 0) + continue; - /* Delete the register load. */ - if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2)) - goto error_return; + /* It's OK to base decisions on the section name, because none + of the dynobj section names depend upon the input files. */ + name = bfd_get_section_name (dynobj, s); - /* 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; + strip = false; - /* Now check whether we got a COUNT reloc. */ - if (irelcount >= irelend) + if (strcmp (name, ".plt") == 0) { - ((*_bfd_error_handler) - ("%s: 0x%lx: warning: could not find expected COUNT reloc", - bfd_get_filename (abfd), (unsigned long) paddr)); - continue; + if (s->_raw_size == 0) + { + /* Strip this section if we don't need it; see the + comment below. */ + strip = true; + } + else + { + /* Remember whether there is a PLT. */ + plt = true; + } } - - /* The number of uses is stored in the r_addend field. We've - just deleted one. */ - if (irelcount->r_addend == 0) + else if (strncmp (name, ".rela", 5) == 0) { - ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count", - bfd_get_filename (abfd), - (unsigned long) paddr)); + if (s->_raw_size == 0) + { + /* If we don't need this section, strip it from the + output file. This is mostly to handle .rela.bss and + .rela.plt. We must create both sections in + create_dynamic_sections, because they must be created + before the linker maps input sections to output + sections. The linker does that before + adjust_dynamic_symbol is called, and it is that + function which decides whether anything needs to go + into these sections. */ + strip = true; + } + else + { + /* Remember whether there are any reloc sections other + than .rela.plt. */ + if (strcmp (name, ".rela.plt") != 0) + relocs = true; + + /* We use the reloc_count field as a counter if we need + to copy relocs into the output file. */ + s->reloc_count = 0; + } + } + else if (strncmp (name, ".got", 4) != 0) + { + /* It's not one of our sections, so don't allocate space. */ 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 (strip) { - if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4)) - goto error_return; + _bfd_strip_section_from_output (info, s); + continue; } - /* We've done all we can with that function call. */ + /* Allocate memory for the section contents. */ + s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size); + if (s->contents == NULL && s->_raw_size != 0) + return false; } - /* Look for load and store instructions that we can align on four - byte boundaries. */ - if (have_code) + if (elf_hash_table (info)->dynamic_sections_created) { - boolean swapped; - - /* Get the section contents. */ - if (contents == NULL) + /* Add some entries to the .dynamic section. We fill in the + values later, in sh_elf_finish_dynamic_sections, but we + must add the entries now so that we get the correct size for + the .dynamic section. The DT_DEBUG entry is filled in by the + dynamic linker and used by the debugger. */ +#define add_dynamic_entry(TAG, VAL) \ + bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) + + if (! info->shared) { - 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 (!add_dynamic_entry (DT_DEBUG, 0)) + return false; } - if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents, - &swapped)) - goto error_return; - - if (swapped) + if (plt) { - 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 (!add_dynamic_entry (DT_PLTGOT, 0) + || !add_dynamic_entry (DT_PLTRELSZ, 0) + || !add_dynamic_entry (DT_PLTREL, DT_RELA) + || !add_dynamic_entry (DT_JMPREL, 0)) + return false; } - } - - if (free_relocs != NULL) - { - free (free_relocs); - free_relocs = NULL; - } - if (free_contents != NULL) - { - if (! link_info->keep_memory) - free (free_contents); - else + if (relocs) { - /* Cache the section contents for elf_link_input_bfd. */ - elf_section_data (sec)->this_hdr.contents = contents; + if (!add_dynamic_entry (DT_RELA, 0) + || !add_dynamic_entry (DT_RELASZ, 0) + || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) + return false; } - free_contents = NULL; - } - if (free_extsyms != NULL) - { - if (! link_info->keep_memory) - free (free_extsyms); - else + if ((info->flags & DF_TEXTREL) != 0) { - /* Cache the symbols for elf_link_input_bfd. */ - symtab_hdr->contents = extsyms; + if (!add_dynamic_entry (DT_TEXTREL, 0)) + return false; } - free_extsyms = NULL; } +#undef add_dynamic_entry 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. */ +/* This function is called via sh_elf_link_hash_traverse if we are + creating a shared object with -Bsymbolic. It discards the space + allocated to copy PC relative relocs against symbols which are + defined in regular objects. We allocated space for them in the + check_relocs routine, but we won't fill them in in the + relocate_section routine. */ static boolean -sh_elf_relax_delete_bytes (abfd, sec, addr, count) - bfd *abfd; - asection *sec; - bfd_vma addr; - int count; +sh_elf_discard_copies (h, ignore) + struct elf_sh_link_hash_entry *h; + PTR ignore ATTRIBUTE_UNUSED; { - 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; + struct elf_sh_pcrel_relocs_copied *s; - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - extsyms = (Elf32_External_Sym *) symtab_hdr->contents; + if (h->root.root.type == bfd_link_hash_warning) + h = (struct elf_sh_link_hash_entry *) h->root.root.u.i.link; - shndx = _bfd_elf_section_from_bfd_section (abfd, sec); + /* We only discard relocs for symbols defined in a regular object. */ + if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) + return true; - contents = elf_section_data (sec)->this_hdr.contents; + for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) + s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela); - /* The deletion must stop at the next ALIGN reloc for an aligment - power larger than the number of bytes we are deleting. */ + return true; +} + +/* Relocate an SH ELF section. */ - irelalign = NULL; - toaddr = sec->_cooked_size; +static boolean +sh_elf_relocate_section (output_bfd, info, input_bfd, input_section, + contents, relocs, local_syms, local_sections) + bfd *output_bfd; + 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; + bfd *dynobj; + bfd_vma *local_got_offsets; + asection *sgot; + asection *sgotplt; + asection *splt; + asection *sreloc; - irel = elf_section_data (sec)->relocs; - irelend = irel + sec->reloc_count; - for (; irel < irelend; irel++) + symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; + sym_hashes = elf_sym_hashes (input_bfd); + dynobj = elf_hash_table (info)->dynobj; + local_got_offsets = elf_local_got_offsets (input_bfd); + + sgot = NULL; + sgotplt = NULL; + splt = NULL; + sreloc = NULL; + + rel = relocs; + relend = relocs + input_section->reloc_count; + for (; rel < relend; rel++) { - if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN - && irel->r_offset > addr - && count < (1 << irel->r_addend)) + 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; + int seen_stt_datalabel = 0; + + r_symndx = ELF32_R_SYM (rel->r_info); + + 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 == (int) R_SH_NONE) + continue; + + if (r_type < 0 + || r_type >= R_SH_max + || (r_type >= (int) R_SH_FIRST_INVALID_RELOC + && r_type <= (int) R_SH_LAST_INVALID_RELOC) + || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3 + && r_type <= (int) R_SH_LAST_INVALID_RELOC_3) + || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4 + && r_type <= (int) R_SH_LAST_INVALID_RELOC_4) + || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2 + && r_type <= (int) R_SH_LAST_INVALID_RELOC_2)) { - irelalign = irel; - toaddr = irel->r_offset; - break; + bfd_set_error (bfd_error_bad_value); + return false; } - } - /* Actually delete the bytes. */ - memmove (contents + addr, contents + addr + count, toaddr - addr - count); - if (irelalign == NULL) - sec->_cooked_size -= count; - else - { - int i; + howto = sh_elf_howto_table + r_type; -#define NOP_OPCODE (0x0009) + /* For relocs that aren't partial_inplace, we get the addend from + the relocation. */ + if (! howto->partial_inplace) + addend = rel->r_addend; - BFD_ASSERT ((count & 1) == 0); - for (i = 0; i < count; i += 2) - bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i); - } + h = NULL; + sym = NULL; + sec = NULL; + if (r_symndx < symtab_hdr->sh_info) + { + sym = local_syms + r_symndx; + sec = local_sections[r_symndx]; + relocation = (sec->output_section->vma + + sec->output_offset + + sym->st_value); + /* A local symbol never has STO_SH5_ISA32, so we don't need + datalabel processing here. Make sure this does not change + without notice. */ + if ((sym->st_other & STO_SH5_ISA32) != 0) + ((*info->callbacks->reloc_dangerous) + (info, + _("Unexpected STO_SH5_ISA32 on local symbol is not handled"), + input_bfd, input_section, rel->r_offset)); + 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. */ + sym = local_syms + r_symndx; + if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) + { + if (! howto->partial_inplace) + { + /* For relocations with the addend in the + relocation, we need just to update the addend. + All real relocs are of type partial_inplace; this + code is mostly for completeness. */ + rel->r_addend += sec->output_offset + sym->st_value; - /* 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; + continue; + } - /* 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; + /* Relocs of type partial_inplace need to pick up the + contents in the contents and add the offset resulting + from the changed location of the section symbol. + Using _bfd_final_link_relocate (e.g. goto + final_link_relocate) here would be wrong, because + relocations marked pc_relative would get the current + location subtracted, and we must only do that at the + final link. */ + r = _bfd_relocate_contents (howto, input_bfd, + sec->output_offset + + sym->st_value, + contents + rel->r_offset); + goto relocation_done; + } - /* 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); + continue; + } + else if (! howto->partial_inplace) + { + relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); + addend = rel->r_addend; + } + else if ((sec->flags & SEC_MERGE) + && ELF_ST_TYPE (sym->st_info) == STT_SECTION) + { + asection *msec; - /* If this is a PC relative reloc, see if the range it covers - includes the bytes we have deleted. */ - switch ((enum sh_reloc_type) ELF32_R_TYPE (irel->r_info)) - { - default: - break; + if (howto->rightshift || howto->src_mask != 0xffffffff) + { + (*_bfd_error_handler) + (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"), + bfd_archive_filename (input_bfd), + bfd_get_section_name (input_bfd, input_section), + (long) rel->r_offset, howto->name); + return false; + } - 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; + addend = bfd_get_32 (input_bfd, contents + rel->r_offset); + msec = sec; + addend = + _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) + - relocation; + addend += msec->output_section->vma + msec->output_offset; + bfd_put_32 (input_bfd, addend, contents + rel->r_offset); + addend = 0; + } } - - switch ((enum sh_reloc_type) ELF32_R_TYPE (irel->r_info)) + else { - default: - start = stop = addr; - break; + /* Section symbol are never (?) placed in the hash table, so + we can just ignore hash relocations when creating a + relocateable object file. */ + if (info->relocateable) + continue; - 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) + h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) { - 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)) +#ifdef INCLUDE_SHMEDIA + /* If the reference passes a symbol marked with + STT_DATALABEL, then any STO_SH5_ISA32 on the final value + doesn't count. */ + seen_stt_datalabel |= h->type == STT_DATALABEL; +#endif + 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; + /* In these cases, we don't need the relocation value. + We check specially because in some obscure cases + sec->output_section will be NULL. */ + if (r_type == R_SH_GOTPC + || r_type == R_SH_GOTPC_LOW16 + || r_type == R_SH_GOTPC_MEDLOW16 + || r_type == R_SH_GOTPC_MEDHI16 + || r_type == R_SH_GOTPC_HI16 + || ((r_type == R_SH_PLT32 + || r_type == R_SH_PLT_LOW16 + || r_type == R_SH_PLT_MEDLOW16 + || r_type == R_SH_PLT_MEDHI16 + || r_type == R_SH_PLT_HI16) + && h->plt.offset != (bfd_vma) -1) + || ((r_type == R_SH_GOT32 + || r_type == R_SH_GOT_LOW16 + || r_type == R_SH_GOT_MEDLOW16 + || r_type == R_SH_GOT_MEDHI16 + || r_type == R_SH_GOT_HI16) + && elf_hash_table (info)->dynamic_sections_created + && (! info->shared + || (! info->symbolic && h->dynindx != -1) + || (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0)) + /* The cases above are those in which relocation is + overwritten in the switch block below. The cases + below are those in which we must defer relocation + to run-time, because we can't resolve absolute + addresses when creating a shared library. */ + || (info->shared + && ((! info->symbolic && h->dynindx != -1) + || (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0) + && ((r_type == R_SH_DIR32 + && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)) + || r_type == R_SH_REL32) + && ((input_section->flags & SEC_ALLOC) != 0 + /* DWARF will emit R_SH_DIR32 relocations in its + sections against symbols defined externally + in shared libraries. We can't do anything + with them here. */ + || (input_section->flags & SEC_DEBUGGING) != 0))) + relocation = 0; + else if (sec->output_section == NULL) { - 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); + (*_bfd_error_handler) + (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"), + bfd_archive_filename (input_bfd), h->root.root.string, + bfd_get_section_name (input_bfd, input_section)); + relocation = 0; } + else + relocation = ((h->root.u.def.value + + sec->output_section->vma + + sec->output_offset) + /* A STO_SH5_ISA32 causes a "bitor 1" to the + symbol value, unless we've seen + STT_DATALABEL on the way to it. */ + | ((h->other & STO_SH5_ISA32) != 0 + && ! seen_stt_datalabel)); } - start = stop = addr; - break; + else if (h->root.type == bfd_link_hash_undefweak) + relocation = 0; + else if (info->shared + && (!info->symbolic || info->allow_shlib_undefined) + && !info->no_undefined) + 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; + } + } - case R_SH_DIR8WPN: - off = insn & 0xff; - if (off & 0x80) - off -= 0x100; - stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); + switch ((int) r_type) + { + final_link_relocate: + /* 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_IND12W: - if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info) - start = stop = addr; - else + relocation -= 4; + goto final_link_relocate; + + case R_SH_DIR8WPN: + case R_SH_DIR8WPZ: + case R_SH_DIR8WPL: + /* If the reloc is against the start of this section, then + the assembler has already taken care of it and the reloc + is here only to assist in relaxing. If the reloc is not + against the start of this section, then it's against an + external symbol and we must deal with it ourselves. */ + if (input_section->output_section->vma + input_section->output_offset + != relocation) { - off = insn & 0xfff; - if (off & 0x800) - off -= 0x1000; - stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); + int disp = (relocation + - input_section->output_section->vma + - input_section->output_offset + - rel->r_offset); + int mask = 0; + switch (r_type) + { + case R_SH_DIR8WPN: + case R_SH_DIR8WPZ: mask = 1; break; + case R_SH_DIR8WPL: mask = 3; break; + default: mask = 0; break; + } + if (disp & mask) + { + ((*_bfd_error_handler) + (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"), + bfd_archive_filename (input_section->owner), + (unsigned long) rel->r_offset)); + bfd_set_error (bfd_error_bad_value); + return false; + } + relocation -= 4; + goto final_link_relocate; } + r = bfd_reloc_ok; break; - case R_SH_DIR8WPZ: - off = insn & 0xff; - stop = start + 4 + off * 2; - break; + default: +#ifdef INCLUDE_SHMEDIA + if (shmedia_prepare_reloc (info, input_bfd, input_section, + contents, rel, &relocation)) + goto final_link_relocate; +#endif + bfd_set_error (bfd_error_bad_value); + return false; - case R_SH_DIR8WPL: - off = insn & 0xff; - stop = (start &~ (bfd_vma) 3) + 4 + off * 4; - break; + case R_SH_DIR32: + case R_SH_REL32: + if (info->shared + && r_symndx != 0 + && (input_section->flags & SEC_ALLOC) != 0 + && (r_type != R_SH_REL32 + || (h != NULL + && h->dynindx != -1 + && (! info->symbolic + || (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0)))) + { + Elf_Internal_Rela outrel; + boolean skip, relocate; - case R_SH_SWITCH16: - case R_SH_SWITCH32: - /* These relocs types represent - .word L2-L1 - The r_offset 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. */ + /* When generating a shared object, these relocations + are copied into the output file to be resolved at run + time. */ - start = irel->r_offset; - stop = (bfd_vma) ((bfd_signed_vma) start - (long) irel->r_addend); + if (sreloc == NULL) + { + const char *name; + + name = (bfd_elf_string_from_elf_section + (input_bfd, + elf_elfheader (input_bfd)->e_shstrndx, + elf_section_data (input_section)->rel_hdr.sh_name)); + if (name == NULL) + return false; + + BFD_ASSERT (strncmp (name, ".rela", 5) == 0 + && strcmp (bfd_get_section_name (input_bfd, + input_section), + name + 5) == 0); + + sreloc = bfd_get_section_by_name (dynobj, name); + BFD_ASSERT (sreloc != NULL); + } - 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; + skip = false; + relocate = false; + + outrel.r_offset = + _bfd_elf_section_offset (output_bfd, info, input_section, + rel->r_offset); + if (outrel.r_offset == (bfd_vma) -1) + skip = true; + else if (outrel.r_offset == (bfd_vma) -2) + skip = true, relocate = true; + outrel.r_offset += (input_section->output_section->vma + + input_section->output_offset); + + if (skip) + memset (&outrel, 0, sizeof outrel); + else if (r_type == R_SH_REL32) + { + BFD_ASSERT (h != NULL && h->dynindx != -1); + outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32); + outrel.r_addend + = bfd_get_32 (input_bfd, contents + rel->r_offset); + } + else + { + /* h->dynindx may be -1 if this symbol was marked to + become local. */ + if (h == NULL + || ((info->symbolic || h->dynindx == -1) + && (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) != 0)) + { + relocate = true; + outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); + outrel.r_addend + = relocation + bfd_get_32 (input_bfd, + contents + rel->r_offset); + } + else + { + BFD_ASSERT (h->dynindx != -1); + outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32); + outrel.r_addend + = relocation + bfd_get_32 (input_bfd, + contents + rel->r_offset); + } + } - start = stop; + bfd_elf32_swap_reloca_out (output_bfd, &outrel, + (((Elf32_External_Rela *) + sreloc->contents) + + sreloc->reloc_count)); + ++sreloc->reloc_count; + + /* If this reloc is against an external symbol, we do + not want to fiddle with the addend. Otherwise, we + need to include the symbol value so that it becomes + an addend for the dynamic reloc. */ + if (! relocate) + continue; + } + goto final_link_relocate; + + case R_SH_GOTPLT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOTPLT_LOW16: + case R_SH_GOTPLT_MEDLOW16: + case R_SH_GOTPLT_MEDHI16: + case R_SH_GOTPLT_HI16: + case R_SH_GOTPLT10BY4: + case R_SH_GOTPLT10BY8: +#endif + /* Relocation is to the entry for this symbol in the + procedure linkage table. */ + + if (h == NULL + || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN + || ! info->shared + || info->symbolic + || h->dynindx == -1 + || h->plt.offset == (bfd_vma) -1 + || h->got.offset != (bfd_vma) -1) + goto force_got; + + /* Relocation is to the entry for this symbol in the global + offset table extension for the procedure linkage table. */ + if (sgotplt == NULL) + { + sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); + BFD_ASSERT (sgotplt != NULL); + } - if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16) - voff = bfd_get_signed_16 (abfd, contents + nraddr); - else - voff = bfd_get_signed_32 (abfd, contents + nraddr); - stop = (bfd_vma) ((bfd_signed_vma) start + voff); + relocation = (sgotplt->output_offset + + ((h->plt.offset / elf_sh_sizeof_plt (info) + - 1 + 3) * 4)); + +#ifdef GOT_BIAS + relocation -= GOT_BIAS; +#endif + + goto final_link_relocate; + + force_got: + case R_SH_GOT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOT_LOW16: + case R_SH_GOT_MEDLOW16: + case R_SH_GOT_MEDHI16: + case R_SH_GOT_HI16: + case R_SH_GOT10BY4: + case R_SH_GOT10BY8: +#endif + /* Relocation is to the entry for this symbol in the global + offset table. */ + if (sgot == NULL) + { + sgot = bfd_get_section_by_name (dynobj, ".got"); + BFD_ASSERT (sgot != NULL); + } - break; + if (h != NULL) + { + bfd_vma off; - case R_SH_USES: - start = irel->r_offset; - stop = (bfd_vma) ((bfd_signed_vma) start - + (long) irel->r_addend - + 4); - break; - } + off = h->got.offset; +#ifdef INCLUDE_SHMEDIA + if (seen_stt_datalabel) + { + struct elf_sh_link_hash_entry *hsh; - 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; + hsh = (struct elf_sh_link_hash_entry *)h; + off = hsh->datalabel_got_offset; + } +#endif + BFD_ASSERT (off != (bfd_vma) -1); + + if (! elf_hash_table (info)->dynamic_sections_created + || (info->shared + && (info->symbolic || h->dynindx == -1 + || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) + && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) + { + /* This is actually a static link, or it is a + -Bsymbolic link and the symbol is defined + locally, or the symbol was forced to be local + because of a version file. We must initialize + this entry in the global offset table. Since the + offset must always be a multiple of 4, we use the + least significant bit to record whether we have + initialized it already. + + When doing a dynamic link, we create a .rela.got + relocation entry to initialize the value. This + is done in the finish_dynamic_symbol routine. */ + if ((off & 1) != 0) + off &= ~1; + else + { + bfd_put_32 (output_bfd, relocation, + sgot->contents + off); +#ifdef INCLUDE_SHMEDIA + if (seen_stt_datalabel) + { + struct elf_sh_link_hash_entry *hsh; + + hsh = (struct elf_sh_link_hash_entry *)h; + hsh->datalabel_got_offset |= 1; + } + else +#endif + h->got.offset |= 1; + } + } - if (adjust != 0) - { - oinsn = insn; - overflow = false; - switch ((enum sh_reloc_type) ELF32_R_TYPE (irel->r_info)) + relocation = sgot->output_offset + off; + } + else { - default: - abort (); - break; + bfd_vma off; - 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; +#ifdef INCLUDE_SHMEDIA + if (rel->r_addend) + { + BFD_ASSERT (local_got_offsets != NULL + && (local_got_offsets[symtab_hdr->sh_info + + r_symndx] + != (bfd_vma) -1)); - case R_SH_IND12W: - insn += adjust / 2; - if ((oinsn & 0xf000) != (insn & 0xf000)) - overflow = true; - bfd_put_16 (abfd, insn, contents + nraddr); - break; + off = local_got_offsets[symtab_hdr->sh_info + + r_symndx]; + } + else + { +#endif + BFD_ASSERT (local_got_offsets != NULL + && local_got_offsets[r_symndx] != (bfd_vma) -1); - case R_SH_DIR8WPL: - BFD_ASSERT (adjust == count || count >= 4); - if (count >= 4) - insn += adjust / 4; + off = local_got_offsets[r_symndx]; +#ifdef INCLUDE_SHMEDIA + } +#endif + + /* The offset must always be a multiple of 4. We use + the least significant bit to record whether we have + already generated the necessary reloc. */ + if ((off & 1) != 0) + off &= ~1; else { - if ((irel->r_offset & 3) == 0) - ++insn; + bfd_put_32 (output_bfd, relocation, sgot->contents + off); + + if (info->shared) + { + asection *srelgot; + Elf_Internal_Rela outrel; + + srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); + BFD_ASSERT (srelgot != NULL); + + outrel.r_offset = (sgot->output_section->vma + + sgot->output_offset + + off); + outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); + outrel.r_addend = relocation; + bfd_elf32_swap_reloca_out (output_bfd, &outrel, + (((Elf32_External_Rela *) + srelgot->contents) + + srelgot->reloc_count)); + ++srelgot->reloc_count; + } + +#ifdef INCLUDE_SHMEDIA + if (rel->r_addend) + local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1; + else +#endif + local_got_offsets[r_symndx] |= 1; } - 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; + relocation = sgot->output_offset + off; + } + +#ifdef GOT_BIAS + relocation -= GOT_BIAS; +#endif - case R_SH_SWITCH32: - voff += adjust; - bfd_put_signed_32 (abfd, voff, contents + nraddr); - break; + goto final_link_relocate; - case R_SH_USES: - irel->r_addend += adjust; - break; + case R_SH_GOTOFF: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOTOFF_LOW16: + case R_SH_GOTOFF_MEDLOW16: + case R_SH_GOTOFF_MEDHI16: + case R_SH_GOTOFF_HI16: +#endif + /* Relocation is relative to the start of the global offset + table. */ + + if (sgot == NULL) + { + sgot = bfd_get_section_by_name (dynobj, ".got"); + BFD_ASSERT (sgot != NULL); } - if (overflow) + /* Note that sgot->output_offset is not involved in this + calculation. We always want the start of .got. If we + defined _GLOBAL_OFFSET_TABLE in a different way, as is + permitted by the ABI, we might have to change this + calculation. */ + relocation -= sgot->output_section->vma; + +#ifdef GOT_BIAS + relocation -= GOT_BIAS; +#endif + + addend = rel->r_addend; + + goto final_link_relocate; + + case R_SH_GOTPC: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOTPC_LOW16: + case R_SH_GOTPC_MEDLOW16: + case R_SH_GOTPC_MEDHI16: + case R_SH_GOTPC_HI16: +#endif + /* Use global offset table as symbol value. */ + + if (sgot == NULL) { - ((*_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; + sgot = bfd_get_section_by_name (dynobj, ".got"); + BFD_ASSERT (sgot != NULL); } - } - irel->r_offset = nraddr; - } + relocation = sgot->output_section->vma; - /* 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; +#ifdef GOT_BIAS + relocation += GOT_BIAS; +#endif - if (o == sec - || (o->flags & SEC_RELOC) == 0 - || o->reloc_count == 0) - continue; + addend = rel->r_addend; - /* 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; + goto final_link_relocate; - ocontents = NULL; - irelscanend = internal_relocs + o->reloc_count; - for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++) - { - Elf_Internal_Sym sym; + case R_SH_PLT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_PLT_LOW16: + case R_SH_PLT_MEDLOW16: + case R_SH_PLT_MEDHI16: + case R_SH_PLT_HI16: +#endif + /* Relocation is to the entry for this symbol in the + procedure linkage table. */ - if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32) - continue; + /* Resolve a PLT reloc against a local symbol directly, + without using the procedure linkage table. */ + if (h == NULL) + goto final_link_relocate; - if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info) - continue; + if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) + goto final_link_relocate; - bfd_elf32_swap_symbol_in (abfd, - extsyms + ELF32_R_SYM (irelscan->r_info), - &sym); + if (h->plt.offset == (bfd_vma) -1) + { + /* We didn't make a PLT entry for this symbol. This + happens when statically linking PIC code, or when + using -Bsymbolic. */ + goto final_link_relocate; + } - if (sym.st_shndx == shndx - && (sym.st_value <= addr - || sym.st_value >= toaddr)) + if (splt == NULL) { - bfd_vma val; + splt = bfd_get_section_by_name (dynobj, ".plt"); + BFD_ASSERT (splt != NULL); + } - 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; - } - } + relocation = (splt->output_section->vma + + splt->output_offset + + h->plt.offset); - 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); +#ifdef INCLUDE_SHMEDIA + relocation++; +#endif + + addend = rel->r_addend; + + goto final_link_relocate; + + 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; + } + } + + relocation_done: + 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; } } } - /* Adjust the local symbols defined in this section. */ - esym = extsyms; - esymend = esym + symtab_hdr->sh_info; - for (; esym < esymend; esym++) + 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; + Elf_Internal_Shdr *shndx_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_External_Sym_Shndx *shndx_buf = NULL; + Elf_External_Sym_Shndx *shndx; + 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; + shndx_hdr = &elf_tdata (input_bfd)->symtab_shndx_hdr; + + memcpy (data, elf_section_data (input_section)->this_hdr.contents, + (size_t) input_section->_raw_size); + + if ((input_section->flags & SEC_RELOC) != 0 + && input_section->reloc_count > 0) { - Elf_Internal_Sym isym; + Elf_Internal_Sym *isymp; + asection **secpp; + Elf32_External_Sym *esym, *esymend; + bfd_size_type amt; - bfd_elf32_swap_symbol_in (abfd, esym, &isym); + if (symtab_hdr->contents != NULL) + external_syms = (Elf32_External_Sym *) symtab_hdr->contents; + else if (symtab_hdr->sh_info != 0) + { + amt = symtab_hdr->sh_info; + amt *= sizeof (Elf32_External_Sym); + external_syms = (Elf32_External_Sym *) bfd_malloc (amt); + if (external_syms == NULL) + goto error_return; + if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0 + || bfd_bread ((PTR) external_syms, amt, input_bfd) != amt) + goto error_return; + } - if (isym.st_shndx == shndx - && isym.st_value > addr - && isym.st_value < toaddr) + if (symtab_hdr->sh_info != 0 && shndx_hdr->sh_size != 0) { - isym.st_value -= count; - bfd_elf32_swap_symbol_out (abfd, &isym, esym); + amt = symtab_hdr->sh_info; + amt *= sizeof (Elf_External_Sym_Shndx); + shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); + if (shndx_buf == NULL) + goto error_return; + if (bfd_seek (input_bfd, shndx_hdr->sh_offset, SEEK_SET) != 0 + || bfd_bread ((PTR) shndx_buf, amt, input_bfd) != amt) + goto error_return; } - } - /* 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; + 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; + + amt = symtab_hdr->sh_info; + amt *= sizeof (Elf_Internal_Sym); + internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt); + if (internal_syms == NULL && amt != 0) + goto error_return; - 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) + amt = symtab_hdr->sh_info; + amt *= sizeof (asection *); + sections = (asection **) bfd_malloc (amt); + if (sections == NULL && amt != 0) + goto error_return; + + for (isymp = internal_syms, secpp = sections, shndx = shndx_buf, + esym = external_syms, esymend = esym + symtab_hdr->sh_info; + esym < esymend; + ++esym, ++isymp, ++secpp, shndx = (shndx ? shndx + 1 : NULL)) { - (sym_hash)->root.u.def.value -= count; + asection *isec; + + bfd_elf32_swap_symbol_in (input_bfd, esym, shndx, isymp); + + if (isymp->st_shndx == SHN_UNDEF) + isec = bfd_und_section_ptr; + 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 + isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx); + + *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); + if (internal_syms != NULL) + free (internal_syms); + if (shndx_buf != NULL) + free (shndx_buf); + if (external_syms != NULL && symtab_hdr->contents == NULL) + free (external_syms); + if (internal_relocs != elf_section_data (input_section)->relocs) + free (internal_relocs); } - /* See if we can move the ALIGN reloc forward. We have adjusted - r_offset for it already. */ - if (irelalign != NULL) - { - bfd_vma alignto, alignaddr; + return data; - alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend); - alignaddr = BFD_ALIGN (irelalign->r_offset, - 1 << irelalign->r_addend); - if (alignto != alignaddr) + error_return: + if (internal_relocs != NULL + && internal_relocs != elf_section_data (input_section)->relocs) + free (internal_relocs); + if (shndx_buf != NULL) + free (shndx_buf); + 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)) { - /* Tail recursion. */ - return sh_elf_relax_delete_bytes (abfd, sec, alignaddr, - alignto - alignaddr); + 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 + { + return bfd_section_from_elf_index (abfd, sym->st_shndx); + } + + return NULL; +} +/* Update the got entry reference counts for the section being removed. */ + +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 use got and plt entries for sh, but it would seem that the + existing SH code does no sort of reference counting or whatnot on + its GOT and PLT entries, so it is not possible to garbage collect + them at this time. */ 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. */ +/* 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_align_loads (abfd, sec, internal_relocs, contents, pswapped) +sh_elf_check_relocs (abfd, info, sec, relocs) bfd *abfd; + struct bfd_link_info *info; asection *sec; - Elf_Internal_Rela *internal_relocs; - bfd_byte *contents; - boolean *pswapped; + const Elf_Internal_Rela *relocs; { - Elf_Internal_Rela *irel, *irelend; - bfd_vma *labels = NULL; - bfd_vma *label, *label_end; + 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; + bfd *dynobj; + bfd_vma *local_got_offsets; + asection *sgot; + asection *srelgot; + asection *sreloc; + + sgot = NULL; + srelgot = NULL; + sreloc = NULL; + + if (info->relocateable) + return true; - *pswapped = false; + 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; - irelend = internal_relocs + sec->reloc_count; + dynobj = elf_hash_table (info)->dynobj; + local_got_offsets = elf_local_got_offsets (abfd); - /* 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++) + rel_end = relocs + sec->reloc_count; + for (rel = relocs; rel < rel_end; rel++) { - if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL) + 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]; + + /* Some relocs require a global offset table. */ + if (dynobj == NULL) { - *label_end = irel->r_offset; - ++label_end; + switch (ELF32_R_TYPE (rel->r_info)) + { + case R_SH_GOTPLT32: + case R_SH_GOT32: + case R_SH_GOTOFF: + case R_SH_GOTPC: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOTPLT_LOW16: + case R_SH_GOTPLT_MEDLOW16: + case R_SH_GOTPLT_MEDHI16: + case R_SH_GOTPLT_HI16: + case R_SH_GOTPLT10BY4: + case R_SH_GOTPLT10BY8: + case R_SH_GOT_LOW16: + case R_SH_GOT_MEDLOW16: + case R_SH_GOT_MEDHI16: + case R_SH_GOT_HI16: + case R_SH_GOT10BY4: + case R_SH_GOT10BY8: + case R_SH_GOTOFF_LOW16: + case R_SH_GOTOFF_MEDLOW16: + case R_SH_GOTOFF_MEDHI16: + case R_SH_GOTOFF_HI16: + case R_SH_GOTPC_LOW16: + case R_SH_GOTPC_MEDLOW16: + case R_SH_GOTPC_MEDHI16: + case R_SH_GOTPC_HI16: +#endif + elf_hash_table (info)->dynobj = dynobj = abfd; + if (! _bfd_elf_create_got_section (dynobj, info)) + return false; + break; + + default: + break; + } } - } - /* 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. */ + 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; - label = labels; + /* 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; - for (irel = internal_relocs; irel < irelend; irel++) - { - bfd_vma start, stop; + force_got: + case R_SH_GOT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOT_LOW16: + case R_SH_GOT_MEDLOW16: + case R_SH_GOT_MEDHI16: + case R_SH_GOT_HI16: + case R_SH_GOT10BY4: + case R_SH_GOT10BY8: +#endif + /* This symbol requires a global offset table entry. */ + + if (sgot == NULL) + { + sgot = bfd_get_section_by_name (dynobj, ".got"); + BFD_ASSERT (sgot != NULL); + } - if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE) - continue; + if (srelgot == NULL + && (h != NULL || info->shared)) + { + srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); + if (srelgot == NULL) + { + srelgot = bfd_make_section (dynobj, ".rela.got"); + if (srelgot == NULL + || ! bfd_set_section_flags (dynobj, srelgot, + (SEC_ALLOC + | SEC_LOAD + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED + | SEC_READONLY)) + || ! bfd_set_section_alignment (dynobj, srelgot, 2)) + return false; + } + } - start = irel->r_offset; + if (h != NULL) + { +#ifdef INCLUDE_SHMEDIA + if (h->type == STT_DATALABEL) + { + struct elf_sh_link_hash_entry *hsh; - 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; + h = (struct elf_link_hash_entry *) h->root.u.i.link; + hsh = (struct elf_sh_link_hash_entry *)h; + if (hsh->datalabel_got_offset != (bfd_vma) -1) + break; - 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; - } + hsh->datalabel_got_offset = sgot->_raw_size; + } + else + { +#endif + if (h->got.offset != (bfd_vma) -1) + { + /* We have already allocated space in the .got. */ + break; + } + h->got.offset = sgot->_raw_size; +#ifdef INCLUDE_SHMEDIA + } +#endif - free (labels); + /* Make sure this symbol is output as a dynamic symbol. */ + if (h->dynindx == -1) + { + if (! bfd_elf32_link_record_dynamic_symbol (info, h)) + return false; + } - return true; + srelgot->_raw_size += sizeof (Elf32_External_Rela); + } + else + { + /* This is a global offset table entry for a local + symbol. */ + if (local_got_offsets == NULL) + { + bfd_size_type size; + register unsigned int i; + + size = symtab_hdr->sh_info; + size *= sizeof (bfd_vma); +#ifdef INCLUDE_SHMEDIA + /* Reserve space for both the datalabel and + codelabel local GOT offsets. */ + size *= 2; +#endif + local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); + if (local_got_offsets == NULL) + return false; + elf_local_got_offsets (abfd) = local_got_offsets; + for (i = 0; i < symtab_hdr->sh_info; i++) + local_got_offsets[i] = (bfd_vma) -1; +#ifdef INCLUDE_SHMEDIA + for (; i < 2 * symtab_hdr->sh_info; i++) + local_got_offsets[i] = (bfd_vma) -1; +#endif + } +#ifdef INCLUDE_SHMEDIA + if ((rel->r_addend & 1) != 0) + { + if (local_got_offsets[symtab_hdr->sh_info + + r_symndx] != (bfd_vma) -1) + { + /* We have already allocated space in the .got. */ + break; + } + local_got_offsets[symtab_hdr->sh_info + + r_symndx] = sgot->_raw_size; + } + else + { +#endif + if (local_got_offsets[r_symndx] != (bfd_vma) -1) + { + /* We have already allocated space in the .got. */ + break; + } + local_got_offsets[r_symndx] = sgot->_raw_size; +#ifdef INCLUDE_SHMEDIA + } +#endif - error_return: - if (labels != NULL) - free (labels); - return false; -} + if (info->shared) + { + /* If we are generating a shared object, we need to + output a R_SH_RELATIVE reloc so that the dynamic + linker can adjust this GOT entry. */ + srelgot->_raw_size += sizeof (Elf32_External_Rela); + } + } -/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */ + sgot->_raw_size += 4; -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; + break; - /* 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); + case R_SH_GOTPLT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_GOTPLT_LOW16: + case R_SH_GOTPLT_MEDLOW16: + case R_SH_GOTPLT_MEDHI16: + case R_SH_GOTPLT_HI16: + case R_SH_GOTPLT10BY4: + case R_SH_GOTPLT10BY8: +#endif + /* If this is a local symbol, we resolve it directly without + creating a procedure linkage table entry. */ + + if (h == NULL + || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN + || ! info->shared + || info->symbolic + || h->dynindx == -1 + || h->got.offset != (bfd_vma) -1) + goto force_got; + + /* Make sure this symbol is output as a dynamic symbol. */ + if (h->dynindx == -1) + { + if (! bfd_elf32_link_record_dynamic_symbol (info, h)) + return false; + } - /* Adjust all reloc addresses. */ - irelend = internal_relocs + sec->reloc_count; - for (irel = internal_relocs; irel < irelend; irel++) - { - enum sh_reloc_type type; - int add; + h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; - /* 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 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; + break; - /* 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; + case R_SH_PLT32: +#ifdef INCLUDE_SHMEDIA + case R_SH_PLT_LOW16: + case R_SH_PLT_MEDLOW16: + case R_SH_PLT_MEDHI16: + case R_SH_PLT_HI16: +#endif + /* This symbol requires a procedure linkage table entry. We + actually build the entry in adjust_dynamic_symbol, + because this might be a case of linking PIC code which is + never referenced by a dynamic object, in which case we + don't need to generate a procedure linkage table entry + after all. */ + + /* If this is a local symbol, we resolve it directly without + creating a procedure linkage table entry. */ + if (h == NULL) + continue; - 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 (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) + break; - 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; + h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; - if (add != 0) - { - bfd_byte *loc; - unsigned short insn, oinsn; - boolean overflow; + break; - loc = contents + irel->r_offset; - overflow = false; - switch (type) + case R_SH_DIR32: + case R_SH_REL32: + if (h != NULL) + h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; + + /* If we are creating a shared library, and this is a reloc + against a global symbol, or a non PC relative reloc + against a local symbol, then we need to copy the reloc + into the shared library. However, if we are linking with + -Bsymbolic, we do not need to copy a reloc against a + global symbol which is defined in an object we are + including in the link (i.e., DEF_REGULAR is set). At + this point we have not seen all the input files, so it is + possible that DEF_REGULAR is not set now but will be set + later (it is never cleared). We account for that + possibility below by storing information in the + pcrel_relocs_copied field of the hash table entry. */ + if (info->shared + && (sec->flags & SEC_ALLOC) != 0 + && (ELF32_R_TYPE (rel->r_info) != R_SH_REL32 + || (h != NULL + && (! info->symbolic + || (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0)))) { - default: - break; + /* When creating a shared object, we must copy these + reloc types into the output file. We create a reloc + section in dynobj and make room for this reloc. */ + if (sreloc == NULL) + { + const char *name; - 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; + name = (bfd_elf_string_from_elf_section + (abfd, + elf_elfheader (abfd)->e_shstrndx, + elf_section_data (sec)->rel_hdr.sh_name)); + if (name == NULL) + return false; - 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; + BFD_ASSERT (strncmp (name, ".rela", 5) == 0 + && strcmp (bfd_get_section_name (abfd, sec), + name + 5) == 0); - 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) + sreloc = bfd_get_section_by_name (dynobj, name); + if (sreloc == NULL) + { + flagword flags; + + sreloc = bfd_make_section (dynobj, name); + flags = (SEC_HAS_CONTENTS | SEC_READONLY + | SEC_IN_MEMORY | SEC_LINKER_CREATED); + if ((sec->flags & SEC_ALLOC) != 0) + flags |= SEC_ALLOC | SEC_LOAD; + if (sreloc == NULL + || ! bfd_set_section_flags (dynobj, sreloc, flags) + || ! bfd_set_section_alignment (dynobj, sreloc, 2)) + return false; + } + if (sec->flags & SEC_READONLY) + info->flags |= DF_TEXTREL; + } + + sreloc->_raw_size += sizeof (Elf32_External_Rela); + + /* If we are linking with -Bsymbolic, and this is a + global symbol, we count the number of PC relative + relocations we have entered for this symbol, so that + we can discard them again if the symbol is later + defined by a regular object. Note that this function + is only called if we are using an elf_sh linker + hash table, which means that h is really a pointer to + an elf_sh_link_hash_entry. */ + if (h != NULL && info->symbolic + && ELF32_R_TYPE (rel->r_info) == R_SH_REL32) { - insn = bfd_get_16 (abfd, loc); - oinsn = insn; - insn += add / 2; - if ((oinsn & 0xff00) != (insn & 0xff00)) - overflow = true; - bfd_put_16 (abfd, insn, loc); + struct elf_sh_link_hash_entry *eh; + struct elf_sh_pcrel_relocs_copied *p; + + eh = (struct elf_sh_link_hash_entry *) h; + + for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next) + if (p->section == sreloc) + break; + + if (p == NULL) + { + p = ((struct elf_sh_pcrel_relocs_copied *) + bfd_alloc (dynobj, (bfd_size_type) sizeof *p)); + if (p == NULL) + return false; + p->next = eh->pcrel_relocs_copied; + eh->pcrel_relocs_copied = p; + p->section = sreloc; + p->count = 0; + } + + ++p->count; } + } + + break; + } + } + + return true; +} + +#ifndef sh_elf_set_mach_from_flags +static 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; +} +#endif /* not sh_elf_set_mach_from_flags */ + +#ifndef sh_elf_set_private_flags +/* 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); +} +#endif /* not sh_elf_set_private_flags */ + +#ifndef sh_elf_copy_private_data +/* Copy backend specific data from one object module to another */ - break; - } +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; - 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 sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags); +} +#endif /* not sh_elf_copy_private_data */ + +#ifndef sh_elf_merge_private_data +/* 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)) + { + /* This happens when ld starts out with a 'blank' output file. */ + elf_flags_init (obfd) = true; + elf_elfheader (obfd)->e_flags = EF_SH1; + } + 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_archive_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 true; + return sh_elf_set_mach_from_flags (obfd); } - -/* Relocate an SH ELF section. */ +#endif /* not sh_elf_merge_private_data */ + +/* Finish up dynamic symbol handling. We set the contents of various + dynamic sections here. */ static boolean -sh_elf_relocate_section (output_bfd, info, input_bfd, input_section, - contents, relocs, local_syms, local_sections) +sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym) bfd *output_bfd; 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; + struct elf_link_hash_entry *h; + Elf_Internal_Sym *sym; { - Elf_Internal_Shdr *symtab_hdr; - struct elf_link_hash_entry **sym_hashes; - Elf_Internal_Rela *rel, *relend; + bfd *dynobj; - symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; - sym_hashes = elf_sym_hashes (input_bfd); + dynobj = elf_hash_table (info)->dynobj; - rel = relocs; - relend = relocs + input_section->reloc_count; - for (; rel < relend; rel++) + if (h->plt.offset != (bfd_vma) -1) { - 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_reloc_status_type r; + asection *splt; + asection *sgot; + asection *srel; - 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; - } - } + bfd_vma plt_index; + bfd_vma got_offset; + Elf_Internal_Rela rel; - continue; - } + /* This symbol has an entry in the procedure linkage table. Set + it up. */ - r_type = ELF32_R_TYPE (rel->r_info); + BFD_ASSERT (h->dynindx != -1); - /* Many of the relocs are only used for relaxing, and are - handled entirely by the relaxation code. */ - if (r_type > (int) LAST_INVALID_RELOC) - continue; + splt = bfd_get_section_by_name (dynobj, ".plt"); + sgot = bfd_get_section_by_name (dynobj, ".got.plt"); + srel = bfd_get_section_by_name (dynobj, ".rela.plt"); + BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); - if (r_type < 0 - || r_type >= (int) FIRST_INVALID_RELOC) - { - bfd_set_error (bfd_error_bad_value); - return false; - } + /* Get the index in the procedure linkage table which + corresponds to this symbol. This is the index of this symbol + in all the symbols for which we are making plt entries. The + first entry in the procedure linkage table is reserved. */ + plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1; - /* 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) - continue; + /* Get the offset into the .got table of the entry that + corresponds to this function. Each .got entry is 4 bytes. + The first three are reserved. */ + got_offset = (plt_index + 3) * 4; - howto = sh_elf_howto_table + r_type; +#ifdef GOT_BIAS + got_offset -= GOT_BIAS; +#endif - /* This is a final link. */ - h = NULL; - sym = NULL; - sec = NULL; - if (r_symndx < symtab_hdr->sh_info) + /* Fill in the entry in the procedure linkage table. */ + if (! info->shared) { - /* 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); + if (elf_sh_plt_entry == NULL) + { + elf_sh_plt_entry = (bfd_big_endian (output_bfd) ? + elf_sh_plt_entry_be : elf_sh_plt_entry_le); + } + memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry, + elf_sh_sizeof_plt (info)); +#ifdef INCLUDE_SHMEDIA + movi_shori_putval (output_bfd, + (sgot->output_section->vma + + sgot->output_offset + + got_offset), + (splt->contents + h->plt.offset + + elf_sh_plt_symbol_offset (info))); + + movi_shori_putval (output_bfd, + (splt->output_section->vma + splt->output_offset), + (splt->contents + h->plt.offset + + elf_sh_plt_plt0_offset (info))); +#else + bfd_put_32 (output_bfd, + (sgot->output_section->vma + + sgot->output_offset + + got_offset), + (splt->contents + h->plt.offset + + elf_sh_plt_symbol_offset (info))); + + bfd_put_32 (output_bfd, + (splt->output_section->vma + splt->output_offset), + (splt->contents + h->plt.offset + + elf_sh_plt_plt0_offset (info))); +#endif } 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 (elf_sh_pic_plt_entry == NULL) { - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.string, input_bfd, - input_section, rel->r_offset))) - return false; - relocation = 0; + elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ? + elf_sh_pic_plt_entry_be : + elf_sh_pic_plt_entry_le); } + memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry, + elf_sh_sizeof_plt (info)); +#ifdef INCLUDE_SHMEDIA + movi_shori_putval (output_bfd, got_offset, + (splt->contents + h->plt.offset + + elf_sh_plt_symbol_offset (info))); +#else + bfd_put_32 (output_bfd, got_offset, + (splt->contents + h->plt.offset + + elf_sh_plt_symbol_offset (info))); +#endif } - /* FIXME: This is how the COFF relocations work. */ - if (r_type == (int) R_SH_IND12W) - relocation -= 4; - - /* FIXME: We should use the addend, but the COFF relocations - don't. */ - r = _bfd_final_link_relocate (howto, input_bfd, input_section, - contents, rel->r_offset, - relocation, 0); - - if (r != bfd_reloc_ok) +#ifdef GOT_BIAS + got_offset += GOT_BIAS; +#endif + +#ifdef INCLUDE_SHMEDIA + movi_shori_putval (output_bfd, + plt_index * sizeof (Elf32_External_Rela), + (splt->contents + h->plt.offset + + elf_sh_plt_reloc_offset (info))); +#else + bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela), + (splt->contents + h->plt.offset + + elf_sh_plt_reloc_offset (info))); +#endif + + /* Fill in the entry in the global offset table. */ + bfd_put_32 (output_bfd, + (splt->output_section->vma + + splt->output_offset + + h->plt.offset + + elf_sh_plt_temp_offset (info)), + sgot->contents + got_offset); + + /* Fill in the entry in the .rela.plt section. */ + rel.r_offset = (sgot->output_section->vma + + sgot->output_offset + + got_offset); + rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT); + rel.r_addend = 0; +#ifdef GOT_BIAS + rel.r_addend = GOT_BIAS; +#endif + bfd_elf32_swap_reloca_out (output_bfd, &rel, + ((Elf32_External_Rela *) srel->contents + + plt_index)); + + if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) { - switch (r) - { - default: - case bfd_reloc_outofrange: - abort (); - case bfd_reloc_overflow: - { - const char *name; + /* Mark the symbol as undefined, rather than as defined in + the .plt section. Leave the value alone. */ + sym->st_shndx = SHN_UNDEF; + } + } - 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; - } + if (h->got.offset != (bfd_vma) -1) + { + asection *sgot; + asection *srel; + Elf_Internal_Rela rel; + + /* This symbol has an entry in the global offset table. Set it + up. */ + + sgot = bfd_get_section_by_name (dynobj, ".got"); + srel = bfd_get_section_by_name (dynobj, ".rela.got"); + BFD_ASSERT (sgot != NULL && srel != NULL); + + rel.r_offset = (sgot->output_section->vma + + sgot->output_offset + + (h->got.offset &~ (bfd_vma) 1)); + + /* If this is a -Bsymbolic link, and the symbol is defined + locally, we just want to emit a RELATIVE reloc. Likewise if + the symbol was forced to be local because of a version file. + The entry in the global offset table will already have been + initialized in the relocate_section function. */ + if (info->shared + && (info->symbolic || h->dynindx == -1) + && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) + { + rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); + rel.r_addend = (h->root.u.def.value + + h->root.u.def.section->output_section->vma + + h->root.u.def.section->output_offset); + } + else + { + bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); + rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT); + rel.r_addend = 0; } + + bfd_elf32_swap_reloca_out (output_bfd, &rel, + ((Elf32_External_Rela *) srel->contents + + srel->reloc_count)); + ++srel->reloc_count; + } + + if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) + { + asection *s; + Elf_Internal_Rela rel; + + /* This symbol needs a copy reloc. Set it up. */ + + BFD_ASSERT (h->dynindx != -1 + && (h->root.type == bfd_link_hash_defined + || h->root.type == bfd_link_hash_defweak)); + + s = bfd_get_section_by_name (h->root.u.def.section->owner, + ".rela.bss"); + BFD_ASSERT (s != NULL); + + rel.r_offset = (h->root.u.def.value + + h->root.u.def.section->output_section->vma + + h->root.u.def.section->output_offset); + rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY); + rel.r_addend = 0; + bfd_elf32_swap_reloca_out (output_bfd, &rel, + ((Elf32_External_Rela *) s->contents + + s->reloc_count)); + ++s->reloc_count; } + /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ + if (strcmp (h->root.root.string, "_DYNAMIC") == 0 + || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) + sym->st_shndx = SHN_ABS; + return true; } -/* This is a version of bfd_generic_get_relocated_section_contents - which uses sh_elf_relocate_section. */ +/* Finish up the dynamic sections. */ -static bfd_byte * -sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order, - data, relocateable, symbols) +static boolean +sh_elf_finish_dynamic_sections (output_bfd, info) bfd *output_bfd; - struct bfd_link_info *link_info; - struct bfd_link_order *link_order; - bfd_byte *data; - boolean relocateable; - asymbol **symbols; + struct bfd_link_info *info; { - 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; + bfd *dynobj; + asection *sgot; + asection *sdyn; - /* 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); + dynobj = elf_hash_table (info)->dynobj; - symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; - - memcpy (data, elf_section_data (input_section)->this_hdr.contents, - input_section->_raw_size); + sgot = bfd_get_section_by_name (dynobj, ".got.plt"); + BFD_ASSERT (sgot != NULL); + sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); - if ((input_section->flags & SEC_RELOC) != 0 - && input_section->reloc_count > 0) + if (elf_hash_table (info)->dynamic_sections_created) { - Elf_Internal_Sym *isymp; - asection **secpp; - Elf32_External_Sym *esym, *esymend; + asection *splt; + Elf32_External_Dyn *dyncon, *dynconend; - if (symtab_hdr->contents != NULL) - external_syms = (Elf32_External_Sym *) symtab_hdr->contents; - else + BFD_ASSERT (sdyn != NULL); + + dyncon = (Elf32_External_Dyn *) sdyn->contents; + dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); + for (; dyncon < dynconend; dyncon++) { - 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; - } + Elf_Internal_Dyn dyn; + const char *name; + asection *s; - 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; + bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); - 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; + switch (dyn.d_tag) + { + default: + break; - sections = (asection **) bfd_malloc (symtab_hdr->sh_info - * sizeof (asection *)); - if (sections == NULL && symtab_hdr->sh_info > 0) - goto error_return; + case DT_PLTGOT: + name = ".got"; + goto get_vma; + + case DT_JMPREL: + name = ".rela.plt"; + get_vma: + s = bfd_get_section_by_name (output_bfd, name); + BFD_ASSERT (s != NULL); + dyn.d_un.d_ptr = s->vma; + bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); + break; - isymp = internal_syms; - secpp = sections; - esym = external_syms; - esymend = esym + symtab_hdr->sh_info; - for (; esym < esymend; ++esym, ++isymp, ++secpp) - { - asection *isec; + case DT_PLTRELSZ: + s = bfd_get_section_by_name (output_bfd, ".rela.plt"); + BFD_ASSERT (s != NULL); + if (s->_cooked_size != 0) + dyn.d_un.d_val = s->_cooked_size; + else + dyn.d_un.d_val = s->_raw_size; + bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); + break; - bfd_elf32_swap_symbol_in (input_bfd, esym, isymp); + case DT_RELASZ: + /* My reading of the SVR4 ABI indicates that the + procedure linkage table relocs (DT_JMPREL) should be + included in the overall relocs (DT_RELA). This is + what Solaris does. However, UnixWare can not handle + that case. Therefore, we override the DT_RELASZ entry + here to make it not include the JMPREL relocs. Since + the linker script arranges for .rela.plt to follow all + other relocation sections, we don't have to worry + about changing the DT_RELA entry. */ + s = bfd_get_section_by_name (output_bfd, ".rela.plt"); + if (s != NULL) + { + if (s->_cooked_size != 0) + dyn.d_un.d_val -= s->_cooked_size; + else + dyn.d_un.d_val -= s->_raw_size; + } + bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); + break; + } + } - 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; + /* Fill in the first entry in the procedure linkage table. */ + splt = bfd_get_section_by_name (dynobj, ".plt"); + if (splt && splt->_raw_size > 0) + { + if (info->shared) + { + if (elf_sh_pic_plt_entry == NULL) + { + elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ? + elf_sh_pic_plt_entry_be : + elf_sh_pic_plt_entry_le); + } + memcpy (splt->contents, elf_sh_pic_plt_entry, + elf_sh_sizeof_plt (info)); + } else { - /* Who knows? */ - isec = NULL; + if (elf_sh_plt0_entry == NULL) + { + elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ? + elf_sh_plt0_entry_be : + elf_sh_plt0_entry_le); + } + memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE); +#ifdef INCLUDE_SHMEDIA + movi_shori_putval (output_bfd, + sgot->output_section->vma + + sgot->output_offset, + splt->contents + + elf_sh_plt0_gotplt_offset (info)); +#else + bfd_put_32 (output_bfd, + sgot->output_section->vma + sgot->output_offset + 4, + splt->contents + elf_sh_plt0_gotid_offset (info)); + bfd_put_32 (output_bfd, + sgot->output_section->vma + sgot->output_offset + 8, + splt->contents + elf_sh_plt0_linker_offset (info)); +#endif } - *secpp = isec; + /* UnixWare sets the entsize of .plt to 4, although that doesn't + really seem like the right value. */ + elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; } + } - 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; + /* Fill in the first three entries in the global offset table. */ + if (sgot->_raw_size > 0) + { + if (sdyn == NULL) + bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); + else + bfd_put_32 (output_bfd, + sdyn->output_section->vma + sdyn->output_offset, + sgot->contents); + bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); + bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); } - return data; + elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; - 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; + return true; +} + +static enum elf_reloc_type_class +sh_elf_reloc_type_class (rela) + const Elf_Internal_Rela *rela; +{ + switch ((int) ELF32_R_TYPE (rela->r_info)) + { + case R_SH_RELATIVE: + return reloc_class_relative; + case R_SH_JMP_SLOT: + return reloc_class_plt; + case R_SH_COPY: + return reloc_class_copy; + default: + return reloc_class_normal; + } } +#ifndef ELF_ARCH #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_MAXPAGESIZE 128 #define elf_symbol_leading_char '_' +#endif /* ELF_ARCH */ #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup #define elf_info_to_howto sh_elf_info_to_howto @@ -1905,5 +5964,36 @@ sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order, #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 +#define elf_backend_create_dynamic_sections \ + sh_elf_create_dynamic_sections +#define bfd_elf32_bfd_link_hash_table_create \ + sh_elf_link_hash_table_create +#define elf_backend_adjust_dynamic_symbol \ + sh_elf_adjust_dynamic_symbol +#define elf_backend_size_dynamic_sections \ + sh_elf_size_dynamic_sections +#define elf_backend_finish_dynamic_symbol \ + sh_elf_finish_dynamic_symbol +#define elf_backend_finish_dynamic_sections \ + sh_elf_finish_dynamic_sections +#define elf_backend_reloc_type_class sh_elf_reloc_type_class + +#define elf_backend_want_got_plt 1 +#define elf_backend_plt_readonly 1 +#define elf_backend_want_plt_sym 0 +#define elf_backend_got_header_size 12 +#define elf_backend_plt_header_size PLT_ENTRY_SIZE #include "elf32-target.h" diff --git a/contrib/binutils/bfd/elf64-alpha.c b/contrib/binutils/bfd/elf64-alpha.c index faf9944..a24a70c 100644 --- a/contrib/binutils/bfd/elf64-alpha.c +++ b/contrib/binutils/bfd/elf64-alpha.c @@ -3237,12 +3237,10 @@ elf64_alpha_size_dynamic_sections (output_bfd, info) return false; } - if (!add_dynamic_entry (DT_PLTGOT, 0)) - return false; - if (relplt) { - if (!add_dynamic_entry (DT_PLTRELSZ, 0) + if (!add_dynamic_entry (DT_PLTGOT, 0) + || !add_dynamic_entry (DT_PLTRELSZ, 0) || !add_dynamic_entry (DT_PLTREL, DT_RELA) || !add_dynamic_entry (DT_JMPREL, 0)) return false; diff --git a/contrib/binutils/bfd/version.h b/contrib/binutils/bfd/version.h index 600c673..652aeb4 100644 --- a/contrib/binutils/bfd/version.h +++ b/contrib/binutils/bfd/version.h @@ -1 +1 @@ -#define BFD_VERSION_DATE 20020622 +#define BFD_VERSION_DATE 20020720 diff --git a/contrib/binutils/binutils/configure.in b/contrib/binutils/binutils/configure.in index 4246185..03ed567 100644 --- a/contrib/binutils/binutils/configure.in +++ b/contrib/binutils/binutils/configure.in @@ -7,7 +7,7 @@ AC_CANONICAL_SYSTEM AC_ISC_POSIX changequote(,)dnl -BFD_VERSION_STRING=`sed -n -e 's/^.._INIT_AUTOMAKE.*,[ ]*\([^ ]*\)[ ]*).*/\1/p' < ${srcdir}/../bfd/configure.in` +BFD_VERSION=`sed -n -e 's/^.._INIT_AUTOMAKE.*,[ ]*\([^ ]*\)[ ]*).*/\1/p' < ${srcdir}/../bfd/configure.in` changequote([,])dnl AM_INIT_AUTOMAKE(binutils, ${BFD_VERSION}) diff --git a/contrib/binutils/etc/ChangeLog b/contrib/binutils/etc/ChangeLog index 0453a3e..ffd021f 100644 --- a/contrib/binutils/etc/ChangeLog +++ b/contrib/binutils/etc/ChangeLog @@ -1,3 +1,11 @@ +2002-01-26 Hans-Peter Nilsson + + * Makefile.in (install): Depend on install-info. + +2001-03-25 Stephane Carrez + + * texi2pod.pl: New file (from gcc/contrib). + 1999-04-01 Jim Blandy * add-log.el, add-log.vi: New files. diff --git a/contrib/binutils/etc/Makefile.in b/contrib/binutils/etc/Makefile.in index eedc8c9..2bc3457 100644 --- a/contrib/binutils/etc/Makefile.in +++ b/contrib/binutils/etc/Makefile.in @@ -51,7 +51,8 @@ DVIFILES = standards.dvi configure.dvi all: -install: +# We want install to imply install-info as per GNU standards. +install: install-info uninstall: diff --git a/contrib/binutils/gas/config/tc-sh.c b/contrib/binutils/gas/config/tc-sh.c index eaa6146..ed5c9e4 100644 --- a/contrib/binutils/gas/config/tc-sh.c +++ b/contrib/binutils/gas/config/tc-sh.c @@ -1,5 +1,6 @@ /* tc-sh.c -- Assemble code for the Hitachi Super-H - Copyright (C) 1993, 94, 95, 96, 1997 Free Software Foundation. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -18,10 +19,7 @@ the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/* - Written By Steve Chamberlain - sac@cygnus.com - */ +/* Written By Steve Chamberlain */ #include #include "as.h" @@ -29,7 +27,23 @@ #include "subsegs.h" #define DEFINE_TABLE #include "opcodes/sh-opc.h" -#include +#include "safe-ctype.h" +#include "struc-symbol.h" + +#ifdef OBJ_ELF +#include "elf/sh.h" +#endif + +#include "dwarf2dbg.h" + +typedef struct + { + sh_arg_type type; + int reg; + expressionS immediate; + } +sh_operand_info; + const char comment_chars[] = "!"; const char line_separator_chars[] = ";"; const char line_comment_chars[] = "!#"; @@ -39,31 +53,75 @@ static void s_uses PARAMS ((int)); static void sh_count_relocs PARAMS ((bfd *, segT, PTR)); static void sh_frob_section PARAMS ((bfd *, segT, PTR)); -/* This table describes all the machine specific pseudo-ops the assembler - has to support. The fields are: - pseudo-op name without dot - function to call to execute this pseudo-op - Integer arg to pass to the function - */ - -void cons (); -void s_align_bytes (); static void s_uacons PARAMS ((int)); +static sh_opcode_info *find_cooked_opcode PARAMS ((char **)); +static unsigned int assemble_ppi PARAMS ((char *, sh_opcode_info *)); +static void little PARAMS ((int)); +static void big PARAMS ((int)); +static int parse_reg PARAMS ((char *, int *, int *)); +static char *parse_exp PARAMS ((char *, sh_operand_info *)); +static char *parse_at PARAMS ((char *, sh_operand_info *)); +static void get_operand PARAMS ((char **, sh_operand_info *)); +static char *get_operands + PARAMS ((sh_opcode_info *, char *, sh_operand_info *)); +static sh_opcode_info *get_specific + PARAMS ((sh_opcode_info *, sh_operand_info *)); +static void insert PARAMS ((char *, int, int, sh_operand_info *)); +static void build_relax PARAMS ((sh_opcode_info *, sh_operand_info *)); +static char *insert_loop_bounds PARAMS ((char *, sh_operand_info *)); +static unsigned int build_Mytes + PARAMS ((sh_opcode_info *, sh_operand_info *)); + +#ifdef OBJ_ELF +static void sh_elf_cons PARAMS ((int)); + +inline static int sh_PIC_related_p PARAMS ((symbolS *)); +static int sh_check_fixup PARAMS ((expressionS *, bfd_reloc_code_real_type *)); +inline static char *sh_end_of_match PARAMS ((char *, char *)); + +symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */ +#endif + +static void +big (ignore) + int ignore ATTRIBUTE_UNUSED; +{ + if (! target_big_endian) + as_bad (_("directive .big encountered when option -big required")); -int shl = 0; + /* Stop further messages. */ + target_big_endian = 1; +} static void little (ignore) - int ignore; + int ignore ATTRIBUTE_UNUSED; { - shl = 1; + if (target_big_endian) + as_bad (_("directive .little encountered when option -little required")); + + /* Stop further messages. */ target_big_endian = 0; } +/* This table describes all the machine specific pseudo-ops the assembler + has to support. The fields are: + pseudo-op name without dot + function to call to execute this pseudo-op + Integer arg to pass to the function. */ + const pseudo_typeS md_pseudo_table[] = { +#ifdef OBJ_ELF + {"long", sh_elf_cons, 4}, + {"int", sh_elf_cons, 4}, + {"word", sh_elf_cons, 2}, + {"short", sh_elf_cons, 2}, +#else {"int", cons, 4}, {"word", cons, 2}, +#endif /* OBJ_ELF */ + {"big", big, 0}, {"form", listing_psize, 0}, {"little", little, 0}, {"heading", listing_title, 0}, @@ -73,6 +131,26 @@ const pseudo_typeS md_pseudo_table[] = {"uses", s_uses, 0}, {"uaword", s_uacons, 2}, {"ualong", s_uacons, 4}, + {"uaquad", s_uacons, 8}, + {"2byte", s_uacons, 2}, + {"4byte", s_uacons, 4}, + {"8byte", s_uacons, 8}, +#ifdef BFD_ASSEMBLER + {"file", dwarf2_directive_file, 0 }, + {"loc", dwarf2_directive_loc, 0 }, +#endif +#ifdef HAVE_SH64 + {"mode", s_sh64_mode, 0 }, + + /* Have the old name too. */ + {"isa", s_sh64_mode, 0 }, + + /* Assert that the right ABI is used. */ + {"abi", s_sh64_abi, 0 }, + + { "vtable_inherit", sh64_vtable_inherit, 0 }, + { "vtable_entry", sh64_vtable_entry, 0 }, +#endif /* HAVE_SH64 */ {0, 0, 0} }; @@ -84,35 +162,85 @@ int sh_relax; /* set if -relax seen */ int sh_small; +/* Whether -dsp was seen. */ + +static int sh_dsp; + +/* The bit mask of architectures that could + accomodate the insns seen so far. */ +static int valid_arch; + const char EXP_CHARS[] = "eE"; -/* Chars that mean this number is a floating point constant */ +/* Chars that mean this number is a floating point constant. */ /* As in 0f12.456 */ /* or 0d1.2345e12 */ const char FLT_CHARS[] = "rRsSfFdDxXpP"; #define C(a,b) ENCODE_RELAX(a,b) -#define JREG 14 /* Register used as a temp when relaxing */ #define ENCODE_RELAX(what,length) (((what) << 4) + (length)) #define GET_WHAT(x) ((x>>4)) -/* These are the two types of relaxable instrction */ +/* These are the three types of relaxable instrction. */ +/* These are the types of relaxable instructions; except for END which is + a marker. */ #define COND_JUMP 1 -#define UNCOND_JUMP 2 +#define COND_JUMP_DELAY 2 +#define UNCOND_JUMP 3 + +#ifdef HAVE_SH64 + +/* A 16-bit (times four) pc-relative operand, at most expanded to 32 bits. */ +#define SH64PCREL16_32 4 +/* A 16-bit (times four) pc-relative operand, at most expanded to 64 bits. */ +#define SH64PCREL16_64 5 + +/* Variants of the above for adjusting the insn to PTA or PTB according to + the label. */ +#define SH64PCREL16PT_32 6 +#define SH64PCREL16PT_64 7 + +/* A MOVI expansion, expanding to at most 32 or 64 bits. */ +#define MOVI_IMM_32 8 +#define MOVI_IMM_32_PCREL 9 +#define MOVI_IMM_64 10 +#define MOVI_IMM_64_PCREL 11 +#define END 12 + +#else /* HAVE_SH64 */ + +#define END 4 + +#endif /* HAVE_SH64 */ #define UNDEF_DISP 0 #define COND8 1 #define COND12 2 #define COND32 3 -#define UNCOND12 1 -#define UNCOND32 2 #define UNDEF_WORD_DISP 4 -#define END 5 #define UNCOND12 1 #define UNCOND32 2 +#ifdef HAVE_SH64 +#define UNDEF_SH64PCREL 0 +#define SH64PCREL16 1 +#define SH64PCREL32 2 +#define SH64PCREL48 3 +#define SH64PCREL64 4 +#define SH64PCRELPLT 5 + +#define UNDEF_MOVI 0 +#define MOVI_16 1 +#define MOVI_32 2 +#define MOVI_48 3 +#define MOVI_64 4 +#define MOVI_PLT 5 +#define MOVI_GOTOFF 6 +#define MOVI_GOTPC 7 +#endif /* HAVE_SH64 */ + /* Branch displacements are from the address of the branch plus four, thus all minimum and maximum values have 4 added to them. */ #define COND8_F 258 @@ -125,6 +253,8 @@ const char FLT_CHARS[] = "rRsSfFdDxXpP"; #define COND12_M -4090 #define COND12_LENGTH 6 +#define COND12_DELAY_LENGTH 4 + /* ??? The minimum and maximum values are wrong, but this does not matter since this relocation type is not supported yet. */ #define COND32_F (1<<30) @@ -141,59 +271,624 @@ const char FLT_CHARS[] = "rRsSfFdDxXpP"; #define UNCOND32_M -(1<<30) #define UNCOND32_LENGTH 14 +#ifdef HAVE_SH64 +/* The trivial expansion of a SH64PCREL16 relaxation is just a "PT label, + TRd" as is the current insn, so no extra length. Note that the "reach" + is calculated from the address *after* that insn, but the offset in the + insn is calculated from the beginning of the insn. We also need to + take into account the implicit 1 coded as the "A" in PTA when counting + forward. If PTB reaches an odd address, we trap that as an error + elsewhere, so we don't have to have different relaxation entries. We + don't add a one to the negative range, since PTB would then have the + farthest backward-reaching value skipped, not generated at relaxation. */ +#define SH64PCREL16_F (32767 * 4 - 4 + 1) +#define SH64PCREL16_M (-32768 * 4 - 4) +#define SH64PCREL16_LENGTH 0 + +/* The next step is to change that PT insn into + MOVI ((label - datalabel Ln) >> 16) & 65535, R25 + SHORI (label - datalabel Ln) & 65535, R25 + Ln: + PTREL R25,TRd + which means two extra insns, 8 extra bytes. This is the limit for the + 32-bit ABI. + + The expressions look a bit bad since we have to adjust this to avoid overflow on a + 32-bit host. */ +#define SH64PCREL32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4) +#define SH64PCREL32_LENGTH (2 * 4) + +/* Similarly, we just change the MOVI and add a SHORI for the 48-bit + expansion. */ +#if BFD_HOST_64BIT_LONG +/* The "reach" type is long, so we can only do this for a 64-bit-long + host. */ +#define SH64PCREL32_M (((long) -1 << 30) * 2 - 4) +#define SH64PCREL48_F ((((long) 1 << 47) - 1) - 4) +#define SH64PCREL48_M (((long) -1 << 47) - 4) +#define SH64PCREL48_LENGTH (3 * 4) +#else +/* If the host does not have 64-bit longs, just make this state identical + in reach to the 32-bit state. Note that we have a slightly incorrect + reach, but the correct one above will overflow a 32-bit number. */ +#define SH64PCREL32_M (((long) -1 << 30) * 2) +#define SH64PCREL48_F SH64PCREL32_F +#define SH64PCREL48_M SH64PCREL32_M +#define SH64PCREL48_LENGTH (3 * 4) +#endif /* BFD_HOST_64BIT_LONG */ + +/* And similarly for the 64-bit expansion; a MOVI + SHORI + SHORI + SHORI + + PTREL sequence. */ +#define SH64PCREL64_LENGTH (4 * 4) + +/* For MOVI, we make the MOVI + SHORI... expansion you can see in the + SH64PCREL expansions. The PCREL one is similar, but the other has no + pc-relative reach; it must be fully expanded in + shmedia_md_estimate_size_before_relax. */ +#define MOVI_16_LENGTH 0 +#define MOVI_16_F (32767 - 4) +#define MOVI_16_M (-32768 - 4) +#define MOVI_32_LENGTH 4 +#define MOVI_32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4) +#define MOVI_48_LENGTH 8 + +#if BFD_HOST_64BIT_LONG +/* The "reach" type is long, so we can only do this for a 64-bit-long + host. */ +#define MOVI_32_M (((long) -1 << 30) * 2 - 4) +#define MOVI_48_F ((((long) 1 << 47) - 1) - 4) +#define MOVI_48_M (((long) -1 << 47) - 4) +#else +/* If the host does not have 64-bit longs, just make this state identical + in reach to the 32-bit state. Note that we have a slightly incorrect + reach, but the correct one above will overflow a 32-bit number. */ +#define MOVI_32_M (((long) -1 << 30) * 2) +#define MOVI_48_F MOVI_32_F +#define MOVI_48_M MOVI_32_M +#endif /* BFD_HOST_64BIT_LONG */ + +#define MOVI_64_LENGTH 12 +#endif /* HAVE_SH64 */ + +#define EMPTY { 0, 0, 0, 0 } + const relax_typeS md_relax_table[C (END, 0)] = { - { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, - { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, - { 0 }, + EMPTY, /* C (COND_JUMP, COND8) */ { COND8_F, COND8_M, COND8_LENGTH, C (COND_JUMP, COND12) }, /* C (COND_JUMP, COND12) */ { COND12_F, COND12_M, COND12_LENGTH, C (COND_JUMP, COND32), }, /* C (COND_JUMP, COND32) */ { COND32_F, COND32_M, COND32_LENGTH, 0, }, - { 0 }, { 0 }, { 0 }, { 0 }, - { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, + /* C (COND_JUMP, UNDEF_WORD_DISP) */ + { 0, 0, COND32_LENGTH, 0, }, + EMPTY, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + EMPTY, + /* C (COND_JUMP_DELAY, COND8) */ + { COND8_F, COND8_M, COND8_LENGTH, C (COND_JUMP_DELAY, COND12) }, + /* C (COND_JUMP_DELAY, COND12) */ + { COND12_F, COND12_M, COND12_DELAY_LENGTH, C (COND_JUMP_DELAY, COND32), }, + /* C (COND_JUMP_DELAY, COND32) */ + { COND32_F, COND32_M, COND32_LENGTH, 0, }, + /* C (COND_JUMP_DELAY, UNDEF_WORD_DISP) */ + { 0, 0, COND32_LENGTH, 0, }, + EMPTY, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, - { 0 }, + EMPTY, /* C (UNCOND_JUMP, UNCOND12) */ { UNCOND12_F, UNCOND12_M, UNCOND12_LENGTH, C (UNCOND_JUMP, UNCOND32), }, /* C (UNCOND_JUMP, UNCOND32) */ { UNCOND32_F, UNCOND32_M, UNCOND32_LENGTH, 0, }, - { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, - { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, + EMPTY, + /* C (UNCOND_JUMP, UNDEF_WORD_DISP) */ + { 0, 0, UNCOND32_LENGTH, 0, }, + EMPTY, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + +#ifdef HAVE_SH64 + /* C (SH64PCREL16_32, SH64PCREL16) */ + EMPTY, + { SH64PCREL16_F, SH64PCREL16_M, SH64PCREL16_LENGTH, C (SH64PCREL16_32, SH64PCREL32) }, + /* C (SH64PCREL16_32, SH64PCREL32) */ + { 0, 0, SH64PCREL32_LENGTH, 0 }, + EMPTY, EMPTY, + /* C (SH64PCREL16_32, SH64PCRELPLT) */ + { 0, 0, SH64PCREL32_LENGTH, 0 }, + EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (SH64PCREL16_64, SH64PCREL16) */ + EMPTY, + { SH64PCREL16_F, SH64PCREL16_M, SH64PCREL16_LENGTH, C (SH64PCREL16_64, SH64PCREL32) }, + /* C (SH64PCREL16_64, SH64PCREL32) */ + { SH64PCREL32_F, SH64PCREL32_M, SH64PCREL32_LENGTH, C (SH64PCREL16_64, SH64PCREL48) }, + /* C (SH64PCREL16_64, SH64PCREL48) */ + { SH64PCREL48_F, SH64PCREL48_M, SH64PCREL48_LENGTH, C (SH64PCREL16_64, SH64PCREL64) }, + /* C (SH64PCREL16_64, SH64PCREL64) */ + { 0, 0, SH64PCREL64_LENGTH, 0 }, + /* C (SH64PCREL16_64, SH64PCRELPLT) */ + { 0, 0, SH64PCREL64_LENGTH, 0 }, + EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (SH64PCREL16PT_32, SH64PCREL16) */ + EMPTY, + { SH64PCREL16_F, SH64PCREL16_M, SH64PCREL16_LENGTH, C (SH64PCREL16PT_32, SH64PCREL32) }, + /* C (SH64PCREL16PT_32, SH64PCREL32) */ + { 0, 0, SH64PCREL32_LENGTH, 0 }, + EMPTY, EMPTY, + /* C (SH64PCREL16PT_32, SH64PCRELPLT) */ + { 0, 0, SH64PCREL32_LENGTH, 0 }, + EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (SH64PCREL16PT_64, SH64PCREL16) */ + EMPTY, + { SH64PCREL16_F, SH64PCREL16_M, SH64PCREL16_LENGTH, C (SH64PCREL16PT_64, SH64PCREL32) }, + /* C (SH64PCREL16PT_64, SH64PCREL32) */ + { SH64PCREL32_F, + SH64PCREL32_M, + SH64PCREL32_LENGTH, + C (SH64PCREL16PT_64, SH64PCREL48) }, + /* C (SH64PCREL16PT_64, SH64PCREL48) */ + { SH64PCREL48_F, SH64PCREL48_M, SH64PCREL48_LENGTH, C (SH64PCREL16PT_64, SH64PCREL64) }, + /* C (SH64PCREL16PT_64, SH64PCREL64) */ + { 0, 0, SH64PCREL64_LENGTH, 0 }, + /* C (SH64PCREL16PT_64, SH64PCRELPLT) */ + { 0, 0, SH64PCREL64_LENGTH, 0}, + EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (MOVI_IMM_32, UNDEF_MOVI) */ + { 0, 0, MOVI_32_LENGTH, 0 }, + /* C (MOVI_IMM_32, MOVI_16) */ + { MOVI_16_F, MOVI_16_M, MOVI_16_LENGTH, C (MOVI_IMM_32, MOVI_32) }, + /* C (MOVI_IMM_32, MOVI_32) */ + { MOVI_32_F, MOVI_32_M, MOVI_32_LENGTH, 0 }, + EMPTY, EMPTY, EMPTY, + /* C (MOVI_IMM_32, MOVI_GOTOFF) */ + { 0, 0, MOVI_32_LENGTH, 0 }, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (MOVI_IMM_32_PCREL, MOVI_16) */ + EMPTY, + { MOVI_16_F, MOVI_16_M, MOVI_16_LENGTH, C (MOVI_IMM_32_PCREL, MOVI_32) }, + /* C (MOVI_IMM_32_PCREL, MOVI_32) */ + { 0, 0, MOVI_32_LENGTH, 0 }, + EMPTY, EMPTY, + /* C (MOVI_IMM_32_PCREL, MOVI_PLT) */ + { 0, 0, MOVI_32_LENGTH, 0 }, + EMPTY, + /* C (MOVI_IMM_32_PCREL, MOVI_GOTPC) */ + { 0, 0, MOVI_32_LENGTH, 0 }, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (MOVI_IMM_64, UNDEF_MOVI) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + /* C (MOVI_IMM_64, MOVI_16) */ + { MOVI_16_F, MOVI_16_M, MOVI_16_LENGTH, C (MOVI_IMM_64, MOVI_32) }, + /* C (MOVI_IMM_64, MOVI_32) */ + { MOVI_32_F, MOVI_32_M, MOVI_32_LENGTH, C (MOVI_IMM_64, MOVI_48) }, + /* C (MOVI_IMM_64, MOVI_48) */ + { MOVI_48_F, MOVI_48_M, MOVI_48_LENGTH, C (MOVI_IMM_64, MOVI_64) }, + /* C (MOVI_IMM_64, MOVI_64) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + EMPTY, + /* C (MOVI_IMM_64, MOVI_GOTOFF) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + + /* C (MOVI_IMM_64_PCREL, MOVI_16) */ + EMPTY, + { MOVI_16_F, MOVI_16_M, MOVI_16_LENGTH, C (MOVI_IMM_64_PCREL, MOVI_32) }, + /* C (MOVI_IMM_64_PCREL, MOVI_32) */ + { MOVI_32_F, MOVI_32_M, MOVI_32_LENGTH, C (MOVI_IMM_64_PCREL, MOVI_48) }, + /* C (MOVI_IMM_64_PCREL, MOVI_48) */ + { MOVI_48_F, MOVI_48_M, MOVI_48_LENGTH, C (MOVI_IMM_64_PCREL, MOVI_64) }, + /* C (MOVI_IMM_64_PCREL, MOVI_64) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + /* C (MOVI_IMM_64_PCREL, MOVI_PLT) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + EMPTY, + /* C (MOVI_IMM_64_PCREL, MOVI_GOTPC) */ + { 0, 0, MOVI_64_LENGTH, 0 }, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, + +#endif /* HAVE_SH64 */ + }; +#undef EMPTY + static struct hash_control *opcode_hash_control; /* Opcode mnemonics */ -/* - This function is called once, at assembler startup time. This should - set up all the tables, etc that the MD part of the assembler needs - */ + +#ifdef OBJ_ELF +/* Determinet whether the symbol needs any kind of PIC relocation. */ + +inline static int +sh_PIC_related_p (sym) + symbolS *sym; +{ + expressionS *exp; + + if (! sym) + return 0; + + if (sym == GOT_symbol) + return 1; + +#ifdef HAVE_SH64 + if (sh_PIC_related_p (*symbol_get_tc (sym))) + return 1; +#endif + + exp = symbol_get_value_expression (sym); + + return (exp->X_op == O_PIC_reloc + || sh_PIC_related_p (exp->X_add_symbol) + || sh_PIC_related_p (exp->X_op_symbol)); +} + +/* Determine the relocation type to be used to represent the + expression, that may be rearranged. */ + +static int +sh_check_fixup (main_exp, r_type_p) + expressionS *main_exp; + bfd_reloc_code_real_type *r_type_p; +{ + expressionS *exp = main_exp; + + /* This is here for backward-compatibility only. GCC used to generated: + + f@PLT + . - (.LPCS# + 2) + + but we'd rather be able to handle this as a PIC-related reference + plus/minus a symbol. However, gas' parser gives us: + + O_subtract (O_add (f@PLT, .), .LPCS#+2) + + so we attempt to transform this into: + + O_subtract (f@PLT, O_subtract (.LPCS#+2, .)) + + which we can handle simply below. */ + if (exp->X_op == O_subtract) + { + if (sh_PIC_related_p (exp->X_op_symbol)) + return 1; + + exp = symbol_get_value_expression (exp->X_add_symbol); + + if (exp && sh_PIC_related_p (exp->X_op_symbol)) + return 1; + + if (exp && exp->X_op == O_add + && sh_PIC_related_p (exp->X_add_symbol)) + { + symbolS *sym = exp->X_add_symbol; + + exp->X_op = O_subtract; + exp->X_add_symbol = main_exp->X_op_symbol; + + main_exp->X_op_symbol = main_exp->X_add_symbol; + main_exp->X_add_symbol = sym; + + main_exp->X_add_number += exp->X_add_number; + exp->X_add_number = 0; + } + + exp = main_exp; + } + else if (exp->X_op == O_add && sh_PIC_related_p (exp->X_op_symbol)) + return 1; + + if (exp->X_op == O_symbol || exp->X_op == O_add || exp->X_op == O_subtract) + { +#ifdef HAVE_SH64 + if (exp->X_add_symbol + && (exp->X_add_symbol == GOT_symbol + || (GOT_symbol + && *symbol_get_tc (exp->X_add_symbol) == GOT_symbol))) + { + switch (*r_type_p) + { + case BFD_RELOC_SH_IMM_LOW16: + *r_type_p = BFD_RELOC_SH_GOTPC_LOW16; + break; + + case BFD_RELOC_SH_IMM_MEDLOW16: + *r_type_p = BFD_RELOC_SH_GOTPC_MEDLOW16; + break; + + case BFD_RELOC_SH_IMM_MEDHI16: + *r_type_p = BFD_RELOC_SH_GOTPC_MEDHI16; + break; + + case BFD_RELOC_SH_IMM_HI16: + *r_type_p = BFD_RELOC_SH_GOTPC_HI16; + break; + + case BFD_RELOC_NONE: + case BFD_RELOC_UNUSED: + *r_type_p = BFD_RELOC_SH_GOTPC; + break; + + default: + abort (); + } + return 0; + } +#else + if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol) + { + *r_type_p = BFD_RELOC_SH_GOTPC; + return 0; + } +#endif + exp = symbol_get_value_expression (exp->X_add_symbol); + if (! exp) + return 0; + } + + if (exp->X_op == O_PIC_reloc) + { +#ifdef HAVE_SH64 + switch (*r_type_p) + { + case BFD_RELOC_NONE: + case BFD_RELOC_UNUSED: + *r_type_p = exp->X_md; + break; + + case BFD_RELOC_SH_IMM_LOW16: + switch (exp->X_md) + { + case BFD_RELOC_32_GOTOFF: + *r_type_p = BFD_RELOC_SH_GOTOFF_LOW16; + break; + + case BFD_RELOC_SH_GOTPLT32: + *r_type_p = BFD_RELOC_SH_GOTPLT_LOW16; + break; + + case BFD_RELOC_32_GOT_PCREL: + *r_type_p = BFD_RELOC_SH_GOT_LOW16; + break; + + case BFD_RELOC_32_PLT_PCREL: + *r_type_p = BFD_RELOC_SH_PLT_LOW16; + break; + + default: + abort (); + } + break; + + case BFD_RELOC_SH_IMM_MEDLOW16: + switch (exp->X_md) + { + case BFD_RELOC_32_GOTOFF: + *r_type_p = BFD_RELOC_SH_GOTOFF_MEDLOW16; + break; + + case BFD_RELOC_SH_GOTPLT32: + *r_type_p = BFD_RELOC_SH_GOTPLT_MEDLOW16; + break; + + case BFD_RELOC_32_GOT_PCREL: + *r_type_p = BFD_RELOC_SH_GOT_MEDLOW16; + break; + + case BFD_RELOC_32_PLT_PCREL: + *r_type_p = BFD_RELOC_SH_PLT_MEDLOW16; + break; + + default: + abort (); + } + break; + + case BFD_RELOC_SH_IMM_MEDHI16: + switch (exp->X_md) + { + case BFD_RELOC_32_GOTOFF: + *r_type_p = BFD_RELOC_SH_GOTOFF_MEDHI16; + break; + + case BFD_RELOC_SH_GOTPLT32: + *r_type_p = BFD_RELOC_SH_GOTPLT_MEDHI16; + break; + + case BFD_RELOC_32_GOT_PCREL: + *r_type_p = BFD_RELOC_SH_GOT_MEDHI16; + break; + + case BFD_RELOC_32_PLT_PCREL: + *r_type_p = BFD_RELOC_SH_PLT_MEDHI16; + break; + + default: + abort (); + } + break; + + case BFD_RELOC_SH_IMM_HI16: + switch (exp->X_md) + { + case BFD_RELOC_32_GOTOFF: + *r_type_p = BFD_RELOC_SH_GOTOFF_HI16; + break; + + case BFD_RELOC_SH_GOTPLT32: + *r_type_p = BFD_RELOC_SH_GOTPLT_HI16; + break; + + case BFD_RELOC_32_GOT_PCREL: + *r_type_p = BFD_RELOC_SH_GOT_HI16; + break; + + case BFD_RELOC_32_PLT_PCREL: + *r_type_p = BFD_RELOC_SH_PLT_HI16; + break; + + default: + abort (); + } + break; + + default: + abort (); + } +#else + *r_type_p = exp->X_md; +#endif + if (exp == main_exp) + exp->X_op = O_symbol; + else + { + main_exp->X_add_symbol = exp->X_add_symbol; + main_exp->X_add_number += exp->X_add_number; + } + } + else + return (sh_PIC_related_p (exp->X_add_symbol) + || sh_PIC_related_p (exp->X_op_symbol)); + + return 0; +} + +/* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG. */ + +void +sh_cons_fix_new (frag, off, size, exp) + fragS *frag; + int off, size; + expressionS *exp; +{ + bfd_reloc_code_real_type r_type = BFD_RELOC_UNUSED; + + if (sh_check_fixup (exp, &r_type)) + as_bad (_("Invalid PIC expression.")); + + if (r_type == BFD_RELOC_UNUSED) + switch (size) + { + case 1: + r_type = BFD_RELOC_8; + break; + + case 2: + r_type = BFD_RELOC_16; + break; + + case 4: + r_type = BFD_RELOC_32; + break; + +#ifdef HAVE_SH64 + case 8: + r_type = BFD_RELOC_64; + break; +#endif + + default: + goto error; + } + else if (size != 4) + { + error: + as_bad (_("unsupported BFD relocation size %u"), size); + r_type = BFD_RELOC_UNUSED; + } + + fix_new_exp (frag, off, size, exp, 0, r_type); +} + +/* The regular cons() function, that reads constants, doesn't support + suffixes such as @GOT, @GOTOFF and @PLT, that generate + machine-specific relocation types. So we must define it here. */ +/* Clobbers input_line_pointer, checks end-of-line. */ +static void +sh_elf_cons (nbytes) + register int nbytes; /* 1=.byte, 2=.word, 4=.long */ +{ + expressionS exp; + +#ifdef HAVE_SH64 + + /* Update existing range to include a previous insn, if there was one. */ + sh64_update_contents_mark (true); + + /* We need to make sure the contents type is set to data. */ + sh64_flag_output (); + +#endif /* HAVE_SH64 */ + + if (is_it_end_of_statement ()) + { + demand_empty_rest_of_line (); + return; + } + + do + { + expression (&exp); + emit_expr (&exp, (unsigned int) nbytes); + } + while (*input_line_pointer++ == ','); + + input_line_pointer--; /* Put terminator back into stream. */ + if (*input_line_pointer == '#' || *input_line_pointer == '!') + { + while (! is_end_of_line[(unsigned char) *input_line_pointer++]); + } + else + demand_empty_rest_of_line (); +} +#endif /* OBJ_ELF */ + + +/* This function is called once, at assembler startup time. This should + set up all the tables, etc that the MD part of the assembler needs. */ void md_begin () { sh_opcode_info *opcode; char *prev_name = ""; + int target_arch; + + target_arch = arch_sh1_up & ~(sh_dsp ? arch_sh3e_up : arch_sh_dsp_up); + valid_arch = target_arch; - if (! shl) - target_big_endian = 1; +#ifdef HAVE_SH64 + shmedia_md_begin (); +#endif opcode_hash_control = hash_new (); - /* Insert unique names into hash table */ + /* Insert unique names into hash table. */ for (opcode = sh_table; opcode->name; opcode++) { if (strcmp (prev_name, opcode->name)) { + if (! (opcode->arch & target_arch)) + continue; prev_name = opcode->name; hash_insert (opcode_hash_control, opcode->name, (char *) opcode); } else { /* Make all the opcodes with the same name point to the same - string */ + string. */ opcode->name = prev_name; } } @@ -201,154 +896,290 @@ md_begin () static int reg_m; static int reg_n; +static int reg_x, reg_y; +static int reg_efg; static int reg_b; -static expressionS immediate; /* absolute expression */ +#define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_') -typedef struct - { - sh_arg_type type; - int reg; - } - -sh_operand_info; +/* Try to parse a reg name. Return the number of chars consumed. */ -/* try and parse a reg name, returns number of chars consumed */ static int parse_reg (src, mode, reg) char *src; int *mode; int *reg; { - /* We use !isalnum for the next character after the register name, to + char l0 = TOLOWER (src[0]); + char l1 = l0 ? TOLOWER (src[1]) : 0; + + /* We use ! IDENT_CHAR for the next character after the register name, to make sure that we won't accidentally recognize a symbol name such as - 'sram' as being a reference to the register 'sr'. */ + 'sram' or sr_ram as being a reference to the register 'sr'. */ - if (src[0] == 'r') + if (l0 == 'r') { - if (src[1] >= '0' && src[1] <= '7' && strncmp(&src[2], "_bank", 5) == 0 - && ! isalnum (src[7])) + if (l1 == '1') + { + if (src[2] >= '0' && src[2] <= '5' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = A_REG_N; + *reg = 10 + src[2] - '0'; + return 3; + } + } + if (l1 >= '0' && l1 <= '9' + && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = A_REG_N; + *reg = (l1 - '0'); + return 2; + } + if (l1 >= '0' && l1 <= '7' && strncasecmp (&src[2], "_bank", 5) == 0 + && ! IDENT_CHAR ((unsigned char) src[7])) { *mode = A_REG_B; - *reg = (src[1] - '0'); + *reg = (l1 - '0'); return 7; } + + if (l1 == 'e' && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = A_RE; + return 2; + } + if (l1 == 's' && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = A_RS; + return 2; + } } - if (src[0] == 'r') + if (l0 == 'a') { - if (src[1] == '1') + if (l1 == '0') { - if (src[2] >= '0' && src[2] <= '5' && ! isalnum (src[3])) + if (! IDENT_CHAR ((unsigned char) src[2])) { - *mode = A_REG_N; - *reg = 10 + src[2] - '0'; + *mode = DSP_REG_N; + *reg = A_A0_NUM; + return 2; + } + if (TOLOWER (src[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = DSP_REG_N; + *reg = A_A0G_NUM; return 3; } } - if (src[1] >= '0' && src[1] <= '9' && ! isalnum (src[2])) + if (l1 == '1') { + if (! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = DSP_REG_N; + *reg = A_A1_NUM; + return 2; + } + if (TOLOWER (src[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = DSP_REG_N; + *reg = A_A1G_NUM; + return 3; + } + } + + if (l1 == 'x' && src[2] >= '0' && src[2] <= '1' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = A_REG_N; + *reg = 4 + (l1 - '0'); + return 3; + } + if (l1 == 'y' && src[2] >= '0' && src[2] <= '1' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = A_REG_N; + *reg = 6 + (l1 - '0'); + return 3; + } + if (l1 == 's' && src[2] >= '0' && src[2] <= '3' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + int n = l1 - '0'; + *mode = A_REG_N; - *reg = (src[1] - '0'); + *reg = n | ((~n & 2) << 1); + return 3; + } + } + + if (l0 == 'i' && l1 && ! IDENT_CHAR ((unsigned char) src[2])) + { + if (l1 == 's') + { + *mode = A_REG_N; + *reg = 8; + return 2; + } + if (l1 == 'x') + { + *mode = A_REG_N; + *reg = 8; + return 2; + } + if (l1 == 'y') + { + *mode = A_REG_N; + *reg = 9; return 2; } } - if (src[0] == 's' && src[1] == 's' && src[2] == 'r' && ! isalnum (src[3])) + if (l0 == 'x' && l1 >= '0' && l1 <= '1' + && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = DSP_REG_N; + *reg = A_X0_NUM + l1 - '0'; + return 2; + } + + if (l0 == 'y' && l1 >= '0' && l1 <= '1' + && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = DSP_REG_N; + *reg = A_Y0_NUM + l1 - '0'; + return 2; + } + + if (l0 == 'm' && l1 >= '0' && l1 <= '1' + && ! IDENT_CHAR ((unsigned char) src[2])) + { + *mode = DSP_REG_N; + *reg = l1 == '0' ? A_M0_NUM : A_M1_NUM; + return 2; + } + + if (l0 == 's' + && l1 == 's' + && TOLOWER (src[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_SSR; return 3; } - if (src[0] == 's' && src[1] == 'p' && src[2] == 'c' && ! isalnum (src[3])) + if (l0 == 's' && l1 == 'p' && TOLOWER (src[2]) == 'c' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_SPC; return 3; } - if (src[0] == 's' && src[1] == 'g' && src[2] == 'r' && ! isalnum (src[3])) + if (l0 == 's' && l1 == 'g' && TOLOWER (src[2]) == 'r' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_SGR; return 3; } - if (src[0] == 'd' && src[1] == 'b' && src[2] == 'r' && ! isalnum (src[3])) + if (l0 == 'd' && l1 == 's' && TOLOWER (src[2]) == 'r' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = A_DSR; + return 3; + } + + if (l0 == 'd' && l1 == 'b' && TOLOWER (src[2]) == 'r' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_DBR; return 3; } - if (src[0] == 's' && src[1] == 'r' && ! isalnum (src[2])) + if (l0 == 's' && l1 == 'r' && ! IDENT_CHAR ((unsigned char) src[2])) { *mode = A_SR; return 2; } - if (src[0] == 's' && src[1] == 'p' && ! isalnum (src[2])) + if (l0 == 's' && l1 == 'p' && ! IDENT_CHAR ((unsigned char) src[2])) { *mode = A_REG_N; *reg = 15; return 2; } - if (src[0] == 'p' && src[1] == 'r' && ! isalnum (src[2])) + if (l0 == 'p' && l1 == 'r' && ! IDENT_CHAR ((unsigned char) src[2])) { *mode = A_PR; return 2; } - if (src[0] == 'p' && src[1] == 'c' && ! isalnum (src[2])) + if (l0 == 'p' && l1 == 'c' && ! IDENT_CHAR ((unsigned char) src[2])) { - *mode = A_DISP_PC; + /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0' + and use an uninitialized immediate. */ + *mode = A_PC; return 2; } - if (src[0] == 'g' && src[1] == 'b' && src[2] == 'r' && ! isalnum (src[3])) + if (l0 == 'g' && l1 == 'b' && TOLOWER (src[2]) == 'r' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_GBR; return 3; } - if (src[0] == 'v' && src[1] == 'b' && src[2] == 'r' && ! isalnum (src[3])) + if (l0 == 'v' && l1 == 'b' && TOLOWER (src[2]) == 'r' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = A_VBR; return 3; } - if (src[0] == 'm' && src[1] == 'a' && src[2] == 'c' && ! isalnum (src[4])) + if (l0 == 'm' && l1 == 'a' && TOLOWER (src[2]) == 'c' + && ! IDENT_CHAR ((unsigned char) src[4])) { - if (src[3] == 'l') + if (TOLOWER (src[3]) == 'l') { *mode = A_MACL; return 4; } - if (src[3] == 'h') + if (TOLOWER (src[3]) == 'h') { *mode = A_MACH; return 4; } } - if (src[0] == 'f' && src[1] == 'r') + if (l0 == 'm' && l1 == 'o' && TOLOWER (src[2]) == 'd' + && ! IDENT_CHAR ((unsigned char) src[3])) + { + *mode = A_MOD; + return 3; + } + if (l0 == 'f' && l1 == 'r') { if (src[2] == '1') { - if (src[3] >= '0' && src[3] <= '5' && ! isalnum (src[4])) + if (src[3] >= '0' && src[3] <= '5' + && ! IDENT_CHAR ((unsigned char) src[4])) { *mode = F_REG_N; *reg = 10 + src[3] - '0'; return 4; } } - if (src[2] >= '0' && src[2] <= '9' && ! isalnum (src[3])) + if (src[2] >= '0' && src[2] <= '9' + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = F_REG_N; *reg = (src[2] - '0'); return 3; } } - if (src[0] == 'd' && src[1] == 'r') + if (l0 == 'd' && l1 == 'r') { if (src[2] == '1') { if (src[3] >= '0' && src[3] <= '4' && ! ((src[3] - '0') & 1) - && ! isalnum (src[4])) + && ! IDENT_CHAR ((unsigned char) src[4])) { *mode = D_REG_N; *reg = 10 + src[3] - '0'; @@ -356,19 +1187,19 @@ parse_reg (src, mode, reg) } } if (src[2] >= '0' && src[2] <= '8' && ! ((src[2] - '0') & 1) - && ! isalnum (src[3])) + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = D_REG_N; *reg = (src[2] - '0'); return 3; } } - if (src[0] == 'x' && src[1] == 'd') + if (l0 == 'x' && l1 == 'd') { if (src[2] == '1') { if (src[3] >= '0' && src[3] <= '4' && ! ((src[3] - '0') & 1) - && ! isalnum (src[4])) + && ! IDENT_CHAR ((unsigned char) src[4])) { *mode = X_REG_N; *reg = 11 + src[3] - '0'; @@ -376,44 +1207,48 @@ parse_reg (src, mode, reg) } } if (src[2] >= '0' && src[2] <= '8' && ! ((src[2] - '0') & 1) - && ! isalnum (src[3])) + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = X_REG_N; *reg = (src[2] - '0') + 1; return 3; } } - if (src[0] == 'f' && src[1] == 'v') + if (l0 == 'f' && l1 == 'v') { - if (src[2] == '1'&& src[3] == '2' && ! isalnum (src[4])) + if (src[2] == '1'&& src[3] == '2' && ! IDENT_CHAR ((unsigned char) src[4])) { *mode = V_REG_N; *reg = 12; return 4; } - if ((src[2] == '0' || src[2] == '4' || src[2] == '8') && ! isalnum (src[3])) + if ((src[2] == '0' || src[2] == '4' || src[2] == '8') + && ! IDENT_CHAR ((unsigned char) src[3])) { *mode = V_REG_N; *reg = (src[2] - '0'); return 3; } } - if (src[0] == 'f' && src[1] == 'p' && src[2] == 'u' && src[3] == 'l' - && ! isalnum (src[4])) + if (l0 == 'f' && l1 == 'p' && TOLOWER (src[2]) == 'u' + && TOLOWER (src[3]) == 'l' + && ! IDENT_CHAR ((unsigned char) src[4])) { *mode = FPUL_N; return 4; } - if (src[0] == 'f' && src[1] == 'p' && src[2] == 's' && src[3] == 'c' - && src[4] == 'r' && ! isalnum (src[5])) + if (l0 == 'f' && l1 == 'p' && TOLOWER (src[2]) == 's' + && TOLOWER (src[3]) == 'c' + && TOLOWER (src[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src[5])) { *mode = FPSCR_N; return 5; } - if (src[0] == 'x' && src[1] == 'm' && src[2] == 't' && src[3] == 'r' - && src[4] == 'x' && ! isalnum (src[5])) + if (l0 == 'x' && l1 == 'm' && TOLOWER (src[2]) == 't' + && TOLOWER (src[3]) == 'r' + && TOLOWER (src[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src[5])) { *mode = XMTRX_M4; return 5; @@ -422,40 +1257,30 @@ parse_reg (src, mode, reg) return 0; } -static symbolS *dot() -{ - const char *fake; - - /* JF: '.' is pseudo symbol with value of current location - in current segment. */ - fake = FAKE_LABEL_NAME; - return symbol_new (fake, - now_seg, - (valueT) frag_now_fix (), - frag_now); - -} - - -static -char * -parse_exp (s) +static char * +parse_exp (s, op) char *s; + sh_operand_info *op; { char *save; char *new; save = input_line_pointer; input_line_pointer = s; - expression (&immediate); - if (immediate.X_op == O_absent) - as_bad ("missing operand"); + expression (&op->immediate); + if (op->immediate.X_op == O_absent) + as_bad (_("missing operand")); +#ifdef OBJ_ELF + else if (op->immediate.X_op == O_PIC_reloc + || sh_PIC_related_p (op->immediate.X_add_symbol) + || sh_PIC_related_p (op->immediate.X_op_symbol)) + as_bad (_("misplaced PIC operand")); +#endif new = input_line_pointer; input_line_pointer = save; return new; } - /* The many forms of operand: Rn Register direct @@ -473,11 +1298,9 @@ parse_exp (s) disp:12 #imm8 pr, gbr, vbr, macl, mach - */ -static -char * +static char * parse_at (src, op) char *src; sh_operand_info *op; @@ -487,12 +1310,12 @@ parse_at (src, op) src++; if (src[0] == '-') { - /* Must be predecrement */ + /* Must be predecrement. */ src++; len = parse_reg (src, &mode, &(op->reg)); if (mode != A_REG_N) - as_bad ("illegal register after @-"); + as_bad (_("illegal register after @-")); op->type = A_DEC_N; src += len; @@ -500,7 +1323,7 @@ parse_at (src, op) else if (src[0] == '(') { /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or - @(r0, rn) */ + @(r0, rn). */ src++; len = parse_reg (src, &mode, &(op->reg)); if (len && mode == A_REG_N) @@ -508,32 +1331,45 @@ parse_at (src, op) src += len; if (op->reg != 0) { - as_bad ("must be @(r0,...)"); + as_bad (_("must be @(r0,...)")); } if (src[0] == ',') - src++; - /* Now can be rn or gbr */ - len = parse_reg (src, &mode, &(op->reg)); - if (mode == A_GBR) { - op->type = A_R0_GBR; + src++; + /* Now can be rn or gbr. */ + len = parse_reg (src, &mode, &(op->reg)); + } + else + { + len = 0; } - else if (mode == A_REG_N) + if (len) { - op->type = A_IND_R0_REG_N; + if (mode == A_GBR) + { + op->type = A_R0_GBR; + } + else if (mode == A_REG_N) + { + op->type = A_IND_R0_REG_N; + } + else + { + as_bad (_("syntax error in @(r0,...)")); + } } else { - as_bad ("syntax error in @(r0,...)"); + as_bad (_("syntax error in @(r0...)")); } } else { - /* Must be an @(disp,.. thing) */ - src = parse_exp (src); + /* Must be an @(disp,.. thing). */ + src = parse_exp (src, op); if (src[0] == ',') src++; - /* Now can be rn, gbr or pc */ + /* Now can be rn, gbr or pc. */ len = parse_reg (src, &mode, &op->reg); if (len) { @@ -545,28 +1381,26 @@ parse_at (src, op) { op->type = A_DISP_GBR; } - else if (mode == A_DISP_PC) + else if (mode == A_PC) { - /* Turn a plain @(4,pc) into @(.+4,pc) */ - if (immediate.X_op == O_constant) { - immediate.X_add_symbol = dot(); - immediate.X_op = O_symbol; - } - op->type = A_DISP_PC; + op->type = A_DISP_PC_ABS; + /* Such operands don't get corrected for PC==.+4, so + make the correction here. */ + op->immediate.X_add_number -= 4; } else { - as_bad ("syntax error in @(disp,[Rn, gbr, pc])"); + as_bad (_("syntax error in @(disp,[Rn, gbr, pc])")); } } else { - as_bad ("syntax error in @(disp,[Rn, gbr, pc])"); + as_bad (_("syntax error in @(disp,[Rn, gbr, pc])")); } } src += len; if (src[0] != ')') - as_bad ("expecting )"); + as_bad (_("expecting )")); else src++; } @@ -574,18 +1408,33 @@ parse_at (src, op) { src += parse_reg (src, &mode, &(op->reg)); if (mode != A_REG_N) - { - as_bad ("illegal register after @"); - } + as_bad (_("illegal register after @")); + if (src[0] == '+') { - op->type = A_INC_N; + char l0, l1; + src++; + l0 = TOLOWER (src[0]); + l1 = TOLOWER (src[1]); + + if ((l0 == 'r' && l1 == '8') + || (l0 == 'i' && (l1 == 'x' || l1 == 's'))) + { + src += 2; + op->type = A_PMOD_N; + } + else if ( (l0 == 'r' && l1 == '9') + || (l0 == 'i' && l1 == 'y')) + { + src += 2; + op->type = A_PMODY_N; + } + else + op->type = A_INC_N; } else - { - op->type = A_IND_N; - } + op->type = A_IND_N; } return src; } @@ -602,7 +1451,7 @@ get_operand (ptr, op) if (src[0] == '#') { src++; - *ptr = parse_exp (src); + *ptr = parse_exp (src, op); op->type = A_IMM; return; } @@ -621,25 +1470,27 @@ get_operand (ptr, op) } else { - /* Not a reg, the only thing left is a displacement */ - *ptr = parse_exp (src); + /* Not a reg, the only thing left is a displacement. */ + *ptr = parse_exp (src, op); op->type = A_DISP_PC; return; } } -static -char * +static char * get_operands (info, args, operand) sh_opcode_info *info; char *args; sh_operand_info *operand; - { char *ptr = args; if (info->arg[0]) { - ptr++; + /* The pre-processor will eliminate whitespace in front of '@' + after the first argument; we may be called multiple times + from assemble_ppi, so don't insist on finding whitespace here. */ + if (*ptr == ' ') + ptr++; get_operand (&ptr, operand + 0); if (info->arg[1]) @@ -649,7 +1500,13 @@ get_operands (info, args, operand) ptr++; } get_operand (&ptr, operand + 1); - if (info->arg[2]) + /* ??? Hack: psha/pshl have a varying operand number depending on + the type of the first operand. We handle this by having the + three-operand version first and reducing the number of operands + parsed to two if we see that the first operand is an immediate. + This works because no insn with three operands has an immediate + as first operand. */ + if (info->arg[2] && operand[0].type != A_IMM) { if (*ptr == ',') { @@ -679,11 +1536,9 @@ get_operands (info, args, operand) /* Passed a pointer to a list of opcodes which use different addressing modes, return the opcode which matches the opcodes - provided - */ + provided. */ -static -sh_opcode_info * +static sh_opcode_info * get_specific (opcode, operands) sh_opcode_info *opcode; sh_operand_info *operands; @@ -691,31 +1546,36 @@ get_specific (opcode, operands) sh_opcode_info *this_try = opcode; char *name = opcode->name; int n = 0; + while (opcode->name) { this_try = opcode++; if (this_try->name != name) { /* We've looked so far down the table that we've run out of - opcodes with the same name */ + opcodes with the same name. */ return 0; } - /* look at both operands needed by the opcodes and provided by + + /* Look at both operands needed by the opcodes and provided by the user - since an arg test will often fail on the same arg again and again, we'll try and test the last failing arg the - first on each opcode try */ - + first on each opcode try. */ for (n = 0; this_try->arg[n]; n++) { sh_operand_info *user = operands + n; sh_arg_type arg = this_try->arg[n]; + switch (arg) { + case A_DISP_PC: + if (user->type == A_DISP_PC_ABS) + break; + /* Fall through. */ case A_IMM: case A_BDISP12: case A_BDISP8: case A_DISP_GBR: - case A_DISP_PC: case A_MACH: case A_PR: case A_MACL: @@ -748,16 +1608,14 @@ get_specific (opcode, operands) case V_REG_N: case FPUL_N: case FPSCR_N: + case A_PMOD_N: + case A_PMODY_N: + case DSP_REG_N: /* Opcode needs rn */ if (user->type != arg) goto fail; reg_n = user->reg; break; - case FD_REG_N: - if (user->type != F_REG_N && user->type != D_REG_N) - goto fail; - reg_n = user->reg; - break; case DX_REG_N: if (user->type != D_REG_N && user->type != X_REG_N) goto fail; @@ -766,6 +1624,10 @@ get_specific (opcode, operands) case A_GBR: case A_SR: case A_VBR: + case A_DSR: + case A_MOD: + case A_RE: + case A_RS: case A_SSR: case A_SPC: case A_SGR: @@ -774,7 +1636,7 @@ get_specific (opcode, operands) goto fail; break; - case A_REG_B: + case A_REG_B: if (user->type != arg) goto fail; reg_b = user->reg; @@ -786,12 +1648,144 @@ get_specific (opcode, operands) case A_IND_M: case A_IND_R0_REG_M: case A_DISP_REG_M: + case DSP_REG_M: /* Opcode needs rn */ if (user->type != arg - A_REG_M + A_REG_N) goto fail; reg_m = user->reg; break; + case DSP_REG_X: + if (user->type != DSP_REG_N) + goto fail; + switch (user->reg) + { + case A_X0_NUM: + reg_x = 0; + break; + case A_X1_NUM: + reg_x = 1; + break; + case A_A0_NUM: + reg_x = 2; + break; + case A_A1_NUM: + reg_x = 3; + break; + default: + goto fail; + } + break; + + case DSP_REG_Y: + if (user->type != DSP_REG_N) + goto fail; + switch (user->reg) + { + case A_Y0_NUM: + reg_y = 0; + break; + case A_Y1_NUM: + reg_y = 1; + break; + case A_M0_NUM: + reg_y = 2; + break; + case A_M1_NUM: + reg_y = 3; + break; + default: + goto fail; + } + break; + + case DSP_REG_E: + if (user->type != DSP_REG_N) + goto fail; + switch (user->reg) + { + case A_X0_NUM: + reg_efg = 0 << 10; + break; + case A_X1_NUM: + reg_efg = 1 << 10; + break; + case A_Y0_NUM: + reg_efg = 2 << 10; + break; + case A_A1_NUM: + reg_efg = 3 << 10; + break; + default: + goto fail; + } + break; + + case DSP_REG_F: + if (user->type != DSP_REG_N) + goto fail; + switch (user->reg) + { + case A_Y0_NUM: + reg_efg |= 0 << 8; + break; + case A_Y1_NUM: + reg_efg |= 1 << 8; + break; + case A_X0_NUM: + reg_efg |= 2 << 8; + break; + case A_A1_NUM: + reg_efg |= 3 << 8; + break; + default: + goto fail; + } + break; + + case DSP_REG_G: + if (user->type != DSP_REG_N) + goto fail; + switch (user->reg) + { + case A_M0_NUM: + reg_efg |= 0 << 2; + break; + case A_M1_NUM: + reg_efg |= 1 << 2; + break; + case A_A0_NUM: + reg_efg |= 2 << 2; + break; + case A_A1_NUM: + reg_efg |= 3 << 2; + break; + default: + goto fail; + } + break; + + case A_A0: + if (user->type != DSP_REG_N || user->reg != A_A0_NUM) + goto fail; + break; + case A_X0: + if (user->type != DSP_REG_N || user->reg != A_X0_NUM) + goto fail; + break; + case A_X1: + if (user->type != DSP_REG_N || user->reg != A_X1_NUM) + goto fail; + break; + case A_Y0: + if (user->type != DSP_REG_N || user->reg != A_Y0_NUM) + goto fail; + break; + case A_Y1: + if (user->type != DSP_REG_N || user->reg != A_Y1_NUM) + goto fail; + break; + case F_REG_M: case D_REG_M: case X_REG_M: @@ -813,64 +1807,55 @@ get_specific (opcode, operands) goto fail; reg_m = 4; break; - + default: - printf ("unhandled %d\n", arg); + printf (_("unhandled %d\n"), arg); goto fail; } } + if ( !(valid_arch & this_try->arch)) + goto fail; + valid_arch &= this_try->arch; return this_try; - fail:; + fail: + ; } return 0; } -int -check (operand, low, high) - expressionS *operand; - int low; - int high; -{ - if (operand->X_op != O_constant - || operand->X_add_number < low - || operand->X_add_number > high) - { - as_bad ("operand must be absolute in range %d..%d", low, high); - } - return operand->X_add_number; -} - - static void -insert (where, how, pcrel) +insert (where, how, pcrel, op) char *where; int how; int pcrel; + sh_operand_info *op; { fix_new_exp (frag_now, where - frag_now->fr_literal, 2, - &immediate, + &op->immediate, pcrel, how); } static void -build_relax (opcode) +build_relax (opcode, op) sh_opcode_info *opcode; + sh_operand_info *op; { int high_byte = target_big_endian ? 0 : 1; char *p; if (opcode->arg[0] == A_BDISP8) { + int what = (opcode->nibbles[1] & 4) ? COND_JUMP_DELAY : COND_JUMP; p = frag_var (rs_machine_dependent, - md_relax_table[C (COND_JUMP, COND32)].rlx_length, - md_relax_table[C (COND_JUMP, COND8)].rlx_length, - C (COND_JUMP, 0), - immediate.X_add_symbol, - immediate.X_add_number, + md_relax_table[C (what, COND32)].rlx_length, + md_relax_table[C (what, COND8)].rlx_length, + C (what, 0), + op->immediate.X_add_symbol, + op->immediate.X_add_number, 0); p[high_byte] = (opcode->nibbles[0] << 4) | (opcode->nibbles[1]); } @@ -880,25 +1865,75 @@ build_relax (opcode) md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length, md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length, C (UNCOND_JUMP, 0), - immediate.X_add_symbol, - immediate.X_add_number, + op->immediate.X_add_symbol, + op->immediate.X_add_number, 0); p[high_byte] = (opcode->nibbles[0] << 4); } } -/* Now we know what sort of opcodes it is, lets build the bytes - - */ -static void +/* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */ + +static char * +insert_loop_bounds (output, operand) + char *output; + sh_operand_info *operand; +{ + char *name; + symbolS *end_sym; + + /* Since the low byte of the opcode will be overwritten by the reloc, we + can just stash the high byte into both bytes and ignore endianness. */ + output[0] = 0x8c; + output[1] = 0x8c; + insert (output, BFD_RELOC_SH_LOOP_START, 1, operand); + insert (output, BFD_RELOC_SH_LOOP_END, 1, operand + 1); + + if (sh_relax) + { + static int count = 0; + + /* If the last loop insn is a two-byte-insn, it is in danger of being + swapped with the insn after it. To prevent this, create a new + symbol - complete with SH_LABEL reloc - after the last loop insn. + If the last loop insn is four bytes long, the symbol will be + right in the middle, but four byte insns are not swapped anyways. */ + /* A REPEAT takes 6 bytes. The SH has a 32 bit address space. + Hence a 9 digit number should be enough to count all REPEATs. */ + name = alloca (11); + sprintf (name, "_R%x", count++ & 0x3fffffff); + end_sym = symbol_new (name, undefined_section, 0, &zero_address_frag); + /* Make this a local symbol. */ +#ifdef OBJ_COFF + SF_SET_LOCAL (end_sym); +#endif /* OBJ_COFF */ + symbol_table_insert (end_sym); + end_sym->sy_value = operand[1].immediate; + end_sym->sy_value.X_add_number += 2; + fix_new (frag_now, frag_now_fix (), 2, end_sym, 0, 1, BFD_RELOC_SH_LABEL); + } + + output = frag_more (2); + output[0] = 0x8e; + output[1] = 0x8e; + insert (output, BFD_RELOC_SH_LOOP_START, 1, operand); + insert (output, BFD_RELOC_SH_LOOP_END, 1, operand + 1); + + return frag_more (2); +} + +/* Now we know what sort of opcodes it is, let's build the bytes. */ + +static unsigned int build_Mytes (opcode, operand) sh_opcode_info *opcode; sh_operand_info *operand; - { int index; char nbuf[4]; char *output = frag_more (2); + unsigned int size = 2; int low_byte = target_big_endian ? 1 : 0; nbuf[0] = 0; nbuf[1] = 0; @@ -922,95 +1957,385 @@ build_Mytes (opcode, operand) case REG_M: nbuf[index] = reg_m; break; + case SDT_REG_N: + if (reg_n < 2 || reg_n > 5) + as_bad (_("Invalid register: 'r%d'"), reg_n); + nbuf[index] = (reg_n & 3) | 4; + break; case REG_NM: nbuf[index] = reg_n | (reg_m >> 2); break; - case REG_B: + case REG_B: nbuf[index] = reg_b | 0x08; break; - case DISP_4: - insert (output + low_byte, BFD_RELOC_SH_IMM4, 0); + case IMM0_4BY4: + insert (output + low_byte, BFD_RELOC_SH_IMM4BY4, 0, operand); + break; + case IMM0_4BY2: + insert (output + low_byte, BFD_RELOC_SH_IMM4BY2, 0, operand); + break; + case IMM0_4: + insert (output + low_byte, BFD_RELOC_SH_IMM4, 0, operand); + break; + case IMM1_4BY4: + insert (output + low_byte, BFD_RELOC_SH_IMM4BY4, 0, operand + 1); break; - case IMM_4BY4: - insert (output + low_byte, BFD_RELOC_SH_IMM4BY4, 0); + case IMM1_4BY2: + insert (output + low_byte, BFD_RELOC_SH_IMM4BY2, 0, operand + 1); break; - case IMM_4BY2: - insert (output + low_byte, BFD_RELOC_SH_IMM4BY2, 0); + case IMM1_4: + insert (output + low_byte, BFD_RELOC_SH_IMM4, 0, operand + 1); break; - case IMM_4: - insert (output + low_byte, BFD_RELOC_SH_IMM4, 0); + case IMM0_8BY4: + insert (output + low_byte, BFD_RELOC_SH_IMM8BY4, 0, operand); break; - case IMM_8BY4: - insert (output + low_byte, BFD_RELOC_SH_IMM8BY4, 0); + case IMM0_8BY2: + insert (output + low_byte, BFD_RELOC_SH_IMM8BY2, 0, operand); break; - case IMM_8BY2: - insert (output + low_byte, BFD_RELOC_SH_IMM8BY2, 0); + case IMM0_8: + insert (output + low_byte, BFD_RELOC_SH_IMM8, 0, operand); break; - case IMM_8: - insert (output + low_byte, BFD_RELOC_SH_IMM8, 0); + case IMM1_8BY4: + insert (output + low_byte, BFD_RELOC_SH_IMM8BY4, 0, operand + 1); + break; + case IMM1_8BY2: + insert (output + low_byte, BFD_RELOC_SH_IMM8BY2, 0, operand + 1); + break; + case IMM1_8: + insert (output + low_byte, BFD_RELOC_SH_IMM8, 0, operand + 1); break; case PCRELIMM_8BY4: - insert (output, BFD_RELOC_SH_PCRELIMM8BY4, 1); + insert (output, BFD_RELOC_SH_PCRELIMM8BY4, + operand->type != A_DISP_PC_ABS, operand); break; case PCRELIMM_8BY2: - insert (output, BFD_RELOC_SH_PCRELIMM8BY2, 1); + insert (output, BFD_RELOC_SH_PCRELIMM8BY2, + operand->type != A_DISP_PC_ABS, operand); + break; + case REPEAT: + output = insert_loop_bounds (output, operand); + nbuf[index] = opcode->nibbles[3]; + operand += 2; break; default: - printf ("failed for %d\n", i); + printf (_("failed for %d\n"), i); } } } - if (! target_big_endian) { - output[1] = (nbuf[0] << 4) | (nbuf[1]); - output[0] = (nbuf[2] << 4) | (nbuf[3]); - } - else { - output[0] = (nbuf[0] << 4) | (nbuf[1]); - output[1] = (nbuf[2] << 4) | (nbuf[3]); - } + if (!target_big_endian) + { + output[1] = (nbuf[0] << 4) | (nbuf[1]); + output[0] = (nbuf[2] << 4) | (nbuf[3]); + } + else + { + output[0] = (nbuf[0] << 4) | (nbuf[1]); + output[1] = (nbuf[2] << 4) | (nbuf[3]); + } + return size; } -/* This is the guts of the machine-dependent assembler. STR points to a - machine dependent instruction. This function is supposed to emit - the frags/bytes it assembles to. - */ +/* Find an opcode at the start of *STR_P in the hash table, and set + *STR_P to the first character after the last one read. */ -void -md_assemble (str) - char *str; +static sh_opcode_info * +find_cooked_opcode (str_p) + char **str_p; { + char *str = *str_p; unsigned char *op_start; unsigned char *op_end; - sh_operand_info operand[3]; - sh_opcode_info *opcode; char name[20]; int nlen = 0; - /* Drop leading whitespace */ + + /* Drop leading whitespace. */ while (*str == ' ') str++; - /* find the op code end */ + /* Find the op code end. + The pre-processor will eliminate whitespace in front of + any '@' after the first argument; we may be called from + assemble_ppi, so the opcode might be terminated by an '@'. */ for (op_start = op_end = (unsigned char *) (str); *op_end && nlen < 20 - && !is_end_of_line[*op_end] && *op_end != ' '; + && !is_end_of_line[*op_end] && *op_end != ' ' && *op_end != '@'; op_end++) { - name[nlen] = op_start[nlen]; + unsigned char c = op_start[nlen]; + + /* The machine independent code will convert CMP/EQ into cmp/EQ + because it thinks the '/' is the end of the symbol. Moreover, + all but the first sub-insn is a parallel processing insn won't + be capitalized. Instead of hacking up the machine independent + code, we just deal with it here. */ + c = TOLOWER (c); + name[nlen] = c; nlen++; } + name[nlen] = 0; + *str_p = op_end; if (nlen == 0) + as_bad (_("can't find opcode ")); + + return (sh_opcode_info *) hash_find (opcode_hash_control, name); +} + +/* Assemble a parallel processing insn. */ +#define DDT_BASE 0xf000 /* Base value for double data transfer insns */ + +static unsigned int +assemble_ppi (op_end, opcode) + char *op_end; + sh_opcode_info *opcode; +{ + int movx = 0; + int movy = 0; + int cond = 0; + int field_b = 0; + char *output; + int move_code; + unsigned int size; + + /* Some insn ignore one or more register fields, e.g. psts machl,a0. + Make sure we encode a defined insn pattern. */ + reg_x = 0; + reg_y = 0; + + for (;;) + { + sh_operand_info operand[3]; + + if (opcode->arg[0] != A_END) + op_end = get_operands (opcode, op_end, operand); + opcode = get_specific (opcode, operand); + if (opcode == 0) + { + /* Couldn't find an opcode which matched the operands. */ + char *where = frag_more (2); + size = 2; + + where[0] = 0x0; + where[1] = 0x0; + as_bad (_("invalid operands for opcode")); + return size; + } + + if (opcode->nibbles[0] != PPI) + as_bad (_("insn can't be combined with parallel processing insn")); + + switch (opcode->nibbles[1]) + { + + case NOPX: + if (movx) + as_bad (_("multiple movx specifications")); + movx = DDT_BASE; + break; + case NOPY: + if (movy) + as_bad (_("multiple movy specifications")); + movy = DDT_BASE; + break; + + case MOVX: + if (movx) + as_bad (_("multiple movx specifications")); + if (reg_n < 4 || reg_n > 5) + as_bad (_("invalid movx address register")); + if (opcode->nibbles[2] & 8) + { + if (reg_m == A_A1_NUM) + movx = 1 << 7; + else if (reg_m != A_A0_NUM) + as_bad (_("invalid movx dsp register")); + } + else + { + if (reg_x > 1) + as_bad (_("invalid movx dsp register")); + movx = reg_x << 7; + } + movx += ((reg_n - 4) << 9) + (opcode->nibbles[2] << 2) + DDT_BASE; + break; + + case MOVY: + if (movy) + as_bad (_("multiple movy specifications")); + if (opcode->nibbles[2] & 8) + { + /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode, + so add 8 more. */ + movy = 8; + if (reg_m == A_A1_NUM) + movy += 1 << 6; + else if (reg_m != A_A0_NUM) + as_bad (_("invalid movy dsp register")); + } + else + { + if (reg_y > 1) + as_bad (_("invalid movy dsp register")); + movy = reg_y << 6; + } + if (reg_n < 6 || reg_n > 7) + as_bad (_("invalid movy address register")); + movy += ((reg_n - 6) << 8) + opcode->nibbles[2] + DDT_BASE; + break; + + case PSH: + if (operand[0].immediate.X_op != O_constant) + as_bad (_("dsp immediate shift value not constant")); + field_b = ((opcode->nibbles[2] << 12) + | (operand[0].immediate.X_add_number & 127) << 4 + | reg_n); + break; + case PPI3: + if (field_b) + as_bad (_("multiple parallel processing specifications")); + field_b = ((opcode->nibbles[2] << 12) + (opcode->nibbles[3] << 8) + + (reg_x << 6) + (reg_y << 4) + reg_n); + break; + case PDC: + if (cond) + as_bad (_("multiple condition specifications")); + cond = opcode->nibbles[2] << 8; + if (*op_end) + goto skip_cond_check; + break; + case PPIC: + if (field_b) + as_bad (_("multiple parallel processing specifications")); + field_b = ((opcode->nibbles[2] << 12) + (opcode->nibbles[3] << 8) + + cond + (reg_x << 6) + (reg_y << 4) + reg_n); + cond = 0; + break; + case PMUL: + if (field_b) + { + if ((field_b & 0xef00) != 0xa100) + as_bad (_("insn cannot be combined with pmuls")); + field_b -= 0x8100; + switch (field_b & 0xf) + { + case A_X0_NUM: + field_b += 0 - A_X0_NUM; + break; + case A_Y0_NUM: + field_b += 1 - A_Y0_NUM; + break; + case A_A0_NUM: + field_b += 2 - A_A0_NUM; + break; + case A_A1_NUM: + field_b += 3 - A_A1_NUM; + break; + default: + as_bad (_("bad padd / psub pmuls output operand")); + } + } + field_b += 0x4000 + reg_efg; + break; + default: + abort (); + } + if (cond) + { + as_bad (_("condition not followed by conditionalizable insn")); + cond = 0; + } + if (! *op_end) + break; + skip_cond_check: + opcode = find_cooked_opcode (&op_end); + if (opcode == NULL) + { + (as_bad + (_("unrecognized characters at end of parallel processing insn"))); + break; + } + } + + move_code = movx | movy; + if (field_b) + { + /* Parallel processing insn. */ + unsigned long ppi_code = (movx | movy | 0xf800) << 16 | field_b; + + output = frag_more (4); + size = 4; + if (! target_big_endian) + { + output[3] = ppi_code >> 8; + output[2] = ppi_code; + } + else + { + output[2] = ppi_code >> 8; + output[3] = ppi_code; + } + move_code |= 0xf800; + } + else + { + /* Just a double data transfer. */ + output = frag_more (2); + size = 2; + } + if (! target_big_endian) + { + output[1] = move_code >> 8; + output[0] = move_code; + } + else + { + output[0] = move_code >> 8; + output[1] = move_code; + } + return size; +} + +/* This is the guts of the machine-dependent assembler. STR points to a + machine dependent instruction. This function is supposed to emit + the frags/bytes it assembles to. */ + +void +md_assemble (str) + char *str; +{ + unsigned char *op_end; + sh_operand_info operand[3]; + sh_opcode_info *opcode; + unsigned int size = 0; + +#ifdef HAVE_SH64 + if (sh64_isa_mode == sh64_isa_shmedia) + { + shmedia_md_assemble (str); + return; + } + else { - as_bad ("can't find opcode "); + /* If we've seen pseudo-directives, make sure any emitted data or + frags are marked as data. */ + if (seen_insn == false) + { + sh64_update_contents_mark (true); + sh64_set_contents_type (CRT_SH5_ISA16); + } + + seen_insn = true; } +#endif /* HAVE_SH64 */ - opcode = (sh_opcode_info *) hash_find (opcode_hash_control, name); + opcode = find_cooked_opcode (&str); + op_end = str; if (opcode == NULL) { - as_bad ("unknown opcode"); + as_bad (_("unknown opcode")); return; } @@ -1024,34 +2349,56 @@ md_assemble (str) seg_info (now_seg)->tc_segment_info_data.in_code = 1; } - if (opcode->arg[0] == A_BDISP12 - || opcode->arg[0] == A_BDISP8) + if (opcode->nibbles[0] == PPI) { - parse_exp (op_end + 1); - build_relax (opcode); + size = assemble_ppi (op_end, opcode); } else { - if (opcode->arg[0] != A_END) + if (opcode->arg[0] == A_BDISP12 + || opcode->arg[0] == A_BDISP8) { - get_operands (opcode, op_end, operand); + parse_exp (op_end + 1, &operand[0]); + build_relax (opcode, &operand[0]); } - opcode = get_specific (opcode, operand); - - if (opcode == 0) + else { - /* Couldn't find an opcode which matched the operands */ - char *where = frag_more (2); + if (opcode->arg[0] == A_END) + { + /* Ignore trailing whitespace. If there is any, it has already + been compressed to a single space. */ + if (*op_end == ' ') + op_end++; + } + else + { + op_end = get_operands (opcode, op_end, operand); + } + opcode = get_specific (opcode, operand); + + if (opcode == 0) + { + /* Couldn't find an opcode which matched the operands. */ + char *where = frag_more (2); + size = 2; - where[0] = 0x0; - where[1] = 0x0; - as_bad ("invalid operands for opcode"); - return; - } + where[0] = 0x0; + where[1] = 0x0; + as_bad (_("invalid operands for opcode")); + } + else + { + if (*op_end) + as_bad (_("excess operands: '%s'"), op_end); - build_Mytes (opcode, operand); + size = build_Mytes (opcode, operand); + } + } } +#ifdef BFD_ASSEMBLER + dwarf2_emit_insn (size); +#endif } /* This routine is called each time a label definition is seen. It @@ -1071,7 +2418,7 @@ sh_frob_label () offset = frag_now_fix (); if (frag_now != last_label_frag || offset != last_label_offset) - { + { fix_new (frag_now, offset, 2, &abs_symbol, 0, 0, BFD_RELOC_SH_LABEL); last_label_frag = frag_now; last_label_offset = offset; @@ -1095,38 +2442,41 @@ sh_flush_pending_output () } symbolS * -DEFUN (md_undefined_symbol, (name), - char *name) +md_undefined_symbol (name) + char *name ATTRIBUTE_UNUSED; { return 0; } #ifdef OBJ_COFF +#ifndef BFD_ASSEMBLER void -DEFUN (tc_crawl_symbol_chain, (headers), - object_headers * headers) +tc_crawl_symbol_chain (headers) + object_headers *headers ATTRIBUTE_UNUSED; { - printf ("call to tc_crawl_symbol_chain \n"); + printf (_("call to tc_crawl_symbol_chain \n")); } void -DEFUN (tc_headers_hook, (headers), - object_headers * headers) +tc_headers_hook (headers) + object_headers *headers ATTRIBUTE_UNUSED; { - printf ("call to tc_headers_hook \n"); + printf (_("call to tc_headers_hook \n")); } #endif +#endif -/* Various routines to kill one day */ -/* Equal to MAX_PRECISION in atof-ieee.c */ +/* Various routines to kill one day. */ +/* Equal to MAX_PRECISION in atof-ieee.c. */ #define MAX_LITTLENUMS 6 -/* Turn a string in input_line_pointer into a floating point constant of type - type, and store the appropriate bytes in *litP. The number of LITTLENUMS - emitted is stored in *sizeP . An error message is returned, or NULL on OK. - */ +/* Turn a string in input_line_pointer into a floating point constant + of type TYPE, and store the appropriate bytes in *LITP. The number + of LITTLENUMS emitted is stored in *SIZEP . An error message is + returned, or NULL on OK. */ + char * md_atof (type, litP, sizeP) int type; @@ -1150,7 +2500,7 @@ md_atof (type, litP, sizeP) default: *sizeP = 0; - return "bad call to md_atof"; + return _("bad call to md_atof"); } t = atof_ieee (input_line_pointer, type, words); @@ -1175,7 +2525,7 @@ md_atof (type, litP, sizeP) litP += 2; } } - + return NULL; } @@ -1186,18 +2536,18 @@ md_atof (type, litP, sizeP) static void s_uses (ignore) - int ignore; + int ignore ATTRIBUTE_UNUSED; { expressionS ex; if (! sh_relax) - as_warn (".uses pseudo-op seen when not relaxing"); + as_warn (_(".uses pseudo-op seen when not relaxing")); expression (&ex); if (ex.X_op != O_symbol || ex.X_add_number != 0) { - as_bad ("bad .uses format"); + as_bad (_("bad .uses format")); ignore_rest_of_line (); return; } @@ -1208,23 +2558,42 @@ s_uses (ignore) } CONST char *md_shortopts = ""; -struct option md_longopts[] = { - +struct option md_longopts[] = +{ #define OPTION_RELAX (OPTION_MD_BASE) -#define OPTION_LITTLE (OPTION_MD_BASE + 1) +#define OPTION_BIG (OPTION_MD_BASE + 1) +#define OPTION_LITTLE (OPTION_BIG + 1) #define OPTION_SMALL (OPTION_LITTLE + 1) +#define OPTION_DSP (OPTION_SMALL + 1) {"relax", no_argument, NULL, OPTION_RELAX}, + {"big", no_argument, NULL, OPTION_BIG}, {"little", no_argument, NULL, OPTION_LITTLE}, {"small", no_argument, NULL, OPTION_SMALL}, + {"dsp", no_argument, NULL, OPTION_DSP}, +#ifdef HAVE_SH64 +#define OPTION_ISA (OPTION_DSP + 1) +#define OPTION_ABI (OPTION_ISA + 1) +#define OPTION_NO_MIX (OPTION_ABI + 1) +#define OPTION_SHCOMPACT_CONST_CRANGE (OPTION_NO_MIX + 1) +#define OPTION_NO_EXPAND (OPTION_SHCOMPACT_CONST_CRANGE + 1) +#define OPTION_PT32 (OPTION_NO_EXPAND + 1) + {"isa", required_argument, NULL, OPTION_ISA}, + {"abi", required_argument, NULL, OPTION_ABI}, + {"no-mix", no_argument, NULL, OPTION_NO_MIX}, + {"shcompact-const-crange", no_argument, NULL, OPTION_SHCOMPACT_CONST_CRANGE}, + {"no-expand", no_argument, NULL, OPTION_NO_EXPAND}, + {"expand-pt32", no_argument, NULL, OPTION_PT32}, +#endif /* HAVE_SH64 */ + {NULL, no_argument, NULL, 0} }; -size_t md_longopts_size = sizeof(md_longopts); +size_t md_longopts_size = sizeof (md_longopts); int md_parse_option (c, arg) int c; - char *arg; + char *arg ATTRIBUTE_UNUSED; { switch (c) { @@ -1232,8 +2601,11 @@ md_parse_option (c, arg) sh_relax = 1; break; + case OPTION_BIG: + target_big_endian = 1; + break; + case OPTION_LITTLE: - shl = 1; target_big_endian = 0; break; @@ -1241,6 +2613,66 @@ md_parse_option (c, arg) sh_small = 1; break; + case OPTION_DSP: + sh_dsp = 1; + break; + +#ifdef HAVE_SH64 + case OPTION_ISA: + if (strcasecmp (arg, "shmedia") == 0) + { + if (sh64_isa_mode == sh64_isa_shcompact) + as_bad (_("Invalid combination: --isa=SHcompact with --isa=SHmedia")); + sh64_isa_mode = sh64_isa_shmedia; + } + else if (strcasecmp (arg, "shcompact") == 0) + { + if (sh64_isa_mode == sh64_isa_shmedia) + as_bad (_("Invalid combination: --isa=SHmedia with --isa=SHcompact")); + if (sh64_abi == sh64_abi_64) + as_bad (_("Invalid combination: --abi=64 with --isa=SHcompact")); + sh64_isa_mode = sh64_isa_shcompact; + } + else + as_bad ("Invalid argument to --isa option: %s", arg); + break; + + case OPTION_ABI: + if (strcmp (arg, "32") == 0) + { + if (sh64_abi == sh64_abi_64) + as_bad (_("Invalid combination: --abi=32 with --abi=64")); + sh64_abi = sh64_abi_32; + } + else if (strcmp (arg, "64") == 0) + { + if (sh64_abi == sh64_abi_32) + as_bad (_("Invalid combination: --abi=64 with --abi=32")); + if (sh64_isa_mode == sh64_isa_shcompact) + as_bad (_("Invalid combination: --isa=SHcompact with --abi=64")); + sh64_abi = sh64_abi_64; + } + else + as_bad ("Invalid argument to --abi option: %s", arg); + break; + + case OPTION_NO_MIX: + sh64_mix = false; + break; + + case OPTION_SHCOMPACT_CONST_CRANGE: + sh64_shcompact_const_crange = true; + break; + + case OPTION_NO_EXPAND: + sh64_expand = false; + break; + + case OPTION_PT32: + sh64_pt32 = true; + break; +#endif /* HAVE_SH64 */ + default: return 0; } @@ -1252,43 +2684,31 @@ void md_show_usage (stream) FILE *stream; { - fprintf(stream, "\ + fprintf (stream, _("\ SH options:\n\ -little generate little endian code\n\ +-big generate big endian code\n\ -relax alter jump instructions for long displacements\n\ --small align sections to 4 byte boundaries, not 16\n"); +-small align sections to 4 byte boundaries, not 16\n\ +-dsp enable sh-dsp insns, and disable sh3e / sh4 insns.\n")); +#ifdef HAVE_SH64 + fprintf (stream, _("\ +-isa=[shmedia set default instruction set for SH64\n\ + | SHmedia\n\ + | shcompact\n\ + | SHcompact]\n\ +-abi=[32|64] set size of expanded SHmedia operands and object\n\ + file type\n\ +-shcompact-const-crange emit code-range descriptors for constants in\n\ + SHcompact code sections\n\ +-no-mix disallow SHmedia code in the same section as\n\ + constants and SHcompact code\n\ +-no-expand do not expand MOVI, PT, PTA or PTB instructions\n\ +-expand-pt32 with -abi=64, expand PT, PTA and PTB instructions\n\ + to 32 bits only")); +#endif /* HAVE_SH64 */ } -int md_short_jump_size; - -void -tc_Nout_fix_to_chars () -{ - printf ("call to tc_Nout_fix_to_chars \n"); - abort (); -} - -void -md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol) - char *ptr; - addressT from_Nddr; - addressT to_Nddr; - fragS *frag; - symbolS *to_symbol; -{ - as_fatal ("failed sanity check."); -} - -void -md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol) - char *ptr; - addressT from_Nddr, to_Nddr; - fragS *frag; - symbolS *to_symbol; -{ - as_fatal ("failed sanity check."); -} - /* This struct is used to pass arguments to sh_count_relocs through bfd_map_over_sections. */ @@ -1304,10 +2724,9 @@ struct sh_count_relocs symbol. When using BFD_ASSEMBLER, this is called via bfd_map_over_sections. */ -/*ARGSUSED*/ static void sh_count_relocs (abfd, sec, data) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; segT sec; PTR data; { @@ -1334,12 +2753,11 @@ sh_count_relocs (abfd, sec, data) /* Handle the count relocs for a particular section. When using BFD_ASSEMBLER, this is called via bfd_map_over_sections. */ -/*ARGSUSED*/ static void sh_frob_section (abfd, sec, ignore) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; segT sec; - PTR ignore; + PTR ignore ATTRIBUTE_UNUSED; { segment_info_type *seginfo; fixS *fix; @@ -1371,7 +2789,7 @@ sh_frob_section (abfd, sec, ignore) || S_IS_EXTERNAL (sym)) { as_warn_where (fix->fx_file, fix->fx_line, - ".uses does not refer to a local symbol in the same section"); + _(".uses does not refer to a local symbol in the same section")); continue; } @@ -1390,7 +2808,7 @@ sh_frob_section (abfd, sec, ignore) if (fscan == NULL) { as_warn_where (fix->fx_file, fix->fx_line, - "can't find fixup pointed to by .uses"); + _("can't find fixup pointed to by .uses")); continue; } @@ -1400,8 +2818,8 @@ sh_frob_section (abfd, sec, ignore) continue; } - /* fscan should also be a fixup to a local symbol in the same - section. */ + /* The variable fscan should also be a fixup to a local symbol + in the same section. */ sym = fscan->fx_addsy; if (sym == NULL || fscan->fx_subsy != NULL @@ -1413,7 +2831,7 @@ sh_frob_section (abfd, sec, ignore) || S_IS_EXTERNAL (sym)) { as_warn_where (fix->fx_file, fix->fx_line, - ".uses target does not refer to a local symbol in the same section"); + _(".uses target does not refer to a local symbol in the same section")); continue; } @@ -1439,7 +2857,8 @@ sh_frob_section (abfd, sec, ignore) We have already adjusted the value of sym to include the fragment address, so we undo that adjustment here. */ subseg_change (sec, 0); - fix_new (sym->sy_frag, S_GET_VALUE (sym) - sym->sy_frag->fr_address, + fix_new (fscan->fx_frag, + S_GET_VALUE (sym) - fscan->fx_frag->fr_address, 4, &abs_symbol, info.count, 0, BFD_RELOC_SH_COUNT); } } @@ -1457,6 +2876,10 @@ sh_frob_section (abfd, sec, ignore) void sh_frob_file () { +#ifdef HAVE_SH64 + shmedia_frob_file_before_adjust (); +#endif + if (! sh_relax) return; @@ -1473,14 +2896,14 @@ sh_frob_file () } /* Called after relaxing. Set the correct sizes of the fragments, and - create relocs so that md_apply_fix will fill in the correct values. */ + create relocs so that md_apply_fix3 will fill in the correct values. */ void md_convert_frag (headers, seg, fragP) #ifdef BFD_ASSEMBLER - bfd *headers; + bfd *headers ATTRIBUTE_UNUSED; #else - object_headers *headers; + object_headers *headers ATTRIBUTE_UNUSED; #endif segT seg; fragS *fragP; @@ -1490,6 +2913,7 @@ md_convert_frag (headers, seg, fragP) switch (fragP->fr_subtype) { case C (COND_JUMP, COND8): + case C (COND_JUMP_DELAY, COND8): subseg_change (seg, 0); fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset, 1, BFD_RELOC_SH_PCDISP8BY2); @@ -1508,68 +2932,52 @@ md_convert_frag (headers, seg, fragP) case C (UNCOND_JUMP, UNCOND32): case C (UNCOND_JUMP, UNDEF_WORD_DISP): if (fragP->fr_symbol == NULL) - as_bad ("at 0x%lx, displacement overflows 12-bit field", - (unsigned long) fragP->fr_address); + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement overflows 12-bit field")); + else if (S_IS_DEFINED (fragP->fr_symbol)) + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement to defined symbol %s overflows 12-bit field"), + S_GET_NAME (fragP->fr_symbol)); else - as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 12-bit field", - (unsigned long) fragP->fr_address, - S_IS_DEFINED (fragP->fr_symbol) ? "" : "un", - S_GET_NAME (fragP->fr_symbol)); - -#if 0 /* This code works, but generates poor code and the compiler - should never produce a sequence that requires it to be used. */ - - /* A jump wont fit in 12 bits, make code which looks like - bra foo - mov.w @(0, PC), r14 - .long disp - foo: bra @r14 - */ - int t = buffer[0] & 0x10; - - buffer[highbyte] = 0xa0; /* branch over move and disp */ - buffer[lowbyte] = 3; - buffer[highbyte+2] = 0xd0 | JREG; /* Build mov insn */ - buffer[lowbyte+2] = 0x00; - - buffer[highbyte+4] = 0; /* space for 32 bit jump disp */ - buffer[lowbyte+4] = 0; - buffer[highbyte+6] = 0; - buffer[lowbyte+6] = 0; - - buffer[highbyte+8] = 0x40 | JREG; /* Build jmp @JREG */ - buffer[lowbyte+8] = t ? 0xb : 0x2b; - - buffer[highbyte+10] = 0x20; /* build nop */ - buffer[lowbyte+10] = 0x0b; - - /* Make reloc for the long disp */ - fix_new (fragP, - fragP->fr_fix + 4, - 4, - fragP->fr_symbol, - fragP->fr_offset, - 0, - BFD_RELOC_32); - fragP->fr_fix += UNCOND32_LENGTH; + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement to undefined symbol %s overflows 12-bit field"), + S_GET_NAME (fragP->fr_symbol)); + /* Stabilize this frag, so we don't trip an assert. */ + fragP->fr_fix += fragP->fr_var; fragP->fr_var = 0; - donerelax = 1; -#endif - break; case C (COND_JUMP, COND12): - /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */ + case C (COND_JUMP_DELAY, COND12): + /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */ + /* I found that a relax failure for gcc.c-torture/execute/930628-1.c + was due to gas incorrectly relaxing an out-of-range conditional + branch with delay slot. It turned: + bf.s L6 (slot mov.l r12,@(44,r0)) + into: + +2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6) +30: 00 09 nop +32: 10 cb mov.l r12,@(44,r0) + Therefore, branches with delay slots have to be handled + differently from ones without delay slots. */ { unsigned char *buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal); int highbyte = target_big_endian ? 0 : 1; int lowbyte = target_big_endian ? 1 : 0; + int delay = fragP->fr_subtype == C (COND_JUMP_DELAY, COND12); /* Toggle the true/false bit of the bcond. */ buffer[highbyte] ^= 0x2; - /* Build a relocation to six bytes farther on. */ + /* If this is a delayed branch, we may not put the bra in the + slot. So we change it to a non-delayed branch, like that: + b! cond slot_label; bra disp; slot_label: slot_insn + ??? We should try if swapping the conditional branch and + its delay-slot insn already makes the branch reach. */ + + /* Build a relocation to six / four bytes farther on. */ subseg_change (seg, 0); fix_new (fragP, fragP->fr_fix, 2, #ifdef BFD_ASSEMBLER @@ -1577,7 +2985,7 @@ md_convert_frag (headers, seg, fragP) #else seg_info (seg)->dot, #endif - fragP->fr_address + fragP->fr_fix + 6, + fragP->fr_address + fragP->fr_fix + (delay ? 4 : 6), 1, BFD_RELOC_SH_PCDISP8BY2); /* Set up a jump instruction. */ @@ -1586,86 +2994,64 @@ md_convert_frag (headers, seg, fragP) fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol, fragP->fr_offset, 1, BFD_RELOC_SH_PCDISP12BY2); - /* Fill in a NOP instruction. */ - buffer[highbyte + 4] = 0x0; - buffer[lowbyte + 4] = 0x9; - - fragP->fr_fix += 6; + if (delay) + { + buffer[highbyte] &= ~0x4; /* Removes delay slot from branch. */ + fragP->fr_fix += 4; + } + else + { + /* Fill in a NOP instruction. */ + buffer[highbyte + 4] = 0x0; + buffer[lowbyte + 4] = 0x9; + + fragP->fr_fix += 6; + } fragP->fr_var = 0; donerelax = 1; } break; case C (COND_JUMP, COND32): + case C (COND_JUMP_DELAY, COND32): case C (COND_JUMP, UNDEF_WORD_DISP): + case C (COND_JUMP_DELAY, UNDEF_WORD_DISP): if (fragP->fr_symbol == NULL) - as_bad ("at 0x%lx, displacement overflows 8-bit field", - (unsigned long) fragP->fr_address); - else - as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 8-bit field ", - (unsigned long) fragP->fr_address, - S_IS_DEFINED (fragP->fr_symbol) ? "" : "un", - S_GET_NAME (fragP->fr_symbol)); - -#if 0 /* This code works, but generates poor code, and the compiler - should never produce a sequence that requires it to be used. */ - - /* A bcond won't fit and it won't go into a 12 bit - displacement either, the code sequence looks like: - b!cond foop - mov.w @(n, PC), r14 - jmp @r14 - nop - .long where - foop: - */ - - buffer[0] ^= 0x2; /* Toggle T/F bit */ -#define JREG 14 - buffer[1] = 5; /* branch over mov, jump, nop and ptr */ - buffer[2] = 0xd0 | JREG; /* Build mov insn */ - buffer[3] = 0x2; - buffer[4] = 0x40 | JREG; /* Build jmp @JREG */ - buffer[5] = 0x0b; - buffer[6] = 0x20; /* build nop */ - buffer[7] = 0x0b; - buffer[8] = 0; /* space for 32 bit jump disp */ - buffer[9] = 0; - buffer[10] = 0; - buffer[11] = 0; - buffer[12] = 0; - buffer[13] = 0; - /* Make reloc for the long disp */ - fix_new (fragP, - fragP->fr_fix + 8, - 4, - fragP->fr_symbol, - fragP->fr_offset, - 0, - BFD_RELOC_32); - fragP->fr_fix += COND32_LENGTH; + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement overflows 8-bit field")); + else if (S_IS_DEFINED (fragP->fr_symbol)) + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement to defined symbol %s overflows 8-bit field"), + S_GET_NAME (fragP->fr_symbol)); + else + as_bad_where (fragP->fr_file, fragP->fr_line, + _("displacement to undefined symbol %s overflows 8-bit field "), + S_GET_NAME (fragP->fr_symbol)); + /* Stabilize this frag, so we don't trip an assert. */ + fragP->fr_fix += fragP->fr_var; fragP->fr_var = 0; - donerelax = 1; -#endif - break; default: +#ifdef HAVE_SH64 + shmedia_md_convert_frag (headers, seg, fragP, true); +#else abort (); +#endif } if (donerelax && !sh_relax) as_warn_where (fragP->fr_file, fragP->fr_line, - "overflow in branch to %s; converted into longer instruction sequence", + _("overflow in branch to %s; converted into longer instruction sequence"), (fragP->fr_symbol != NULL ? S_GET_NAME (fragP->fr_symbol) : "")); } valueT -DEFUN (md_section_align, (seg, size), - segT seg AND - valueT size) +md_section_align (seg, size) + segT seg ATTRIBUTE_UNUSED; + valueT size; { #ifdef BFD_ASSEMBLER #ifdef OBJ_ELF @@ -1731,11 +3117,11 @@ sh_cons_align (nbytes) if (now_seg == absolute_section) { if ((abs_section_offset & ((1 << nalign) - 1)) != 0) - as_warn ("misaligned data"); + as_warn (_("misaligned data")); return; } - p = frag_var (rs_align_code, 1, 1, (relax_substateT) 0, + p = frag_var (rs_align_test, 1, 1, (relax_substateT) 0, (symbolS *) NULL, (offsetT) nalign, (char *) NULL); record_alignment (now_seg, nalign); @@ -1749,17 +3135,47 @@ void sh_handle_align (frag) fragS *frag; { + int bytes = frag->fr_next->fr_address - frag->fr_address - frag->fr_fix; + + if (frag->fr_type == rs_align_code) + { + static const unsigned char big_nop_pattern[] = { 0x00, 0x09 }; + static const unsigned char little_nop_pattern[] = { 0x09, 0x00 }; + + char *p = frag->fr_literal + frag->fr_fix; + + if (bytes & 1) + { + *p++ = 0; + bytes--; + frag->fr_fix += 1; + } + + if (target_big_endian) + { + memcpy (p, big_nop_pattern, sizeof big_nop_pattern); + frag->fr_var = sizeof big_nop_pattern; + } + else + { + memcpy (p, little_nop_pattern, sizeof little_nop_pattern); + frag->fr_var = sizeof little_nop_pattern; + } + } + else if (frag->fr_type == rs_align_test) + { + if (bytes != 0) + as_warn_where (frag->fr_file, frag->fr_line, _("misaligned data")); + } + if (sh_relax - && frag->fr_type == rs_align + && (frag->fr_type == rs_align + || frag->fr_type == rs_align_code) && frag->fr_address + frag->fr_fix > 0 && frag->fr_offset > 1 && now_seg != bss_section) fix_new (frag, frag->fr_fix, 2, &abs_symbol, frag->fr_offset, 0, BFD_RELOC_SH_ALIGN); - - if (frag->fr_type == rs_align_code - && frag->fr_next->fr_address - frag->fr_address - frag->fr_fix != 0) - as_warn_where (frag->fr_file, frag->fr_line, "misaligned data"); } /* This macro decides whether a particular reloc is an entry in a @@ -1795,6 +3211,13 @@ int sh_force_relocation (fix) fixS *fix; { + + if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT + || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY + || fix->fx_r_type == BFD_RELOC_SH_LOOP_START + || fix->fx_r_type == BFD_RELOC_SH_LOOP_END) + return 1; + if (! sh_relax) return 0; @@ -1804,32 +3227,141 @@ sh_force_relocation (fix) || fix->fx_r_type == BFD_RELOC_SH_ALIGN || fix->fx_r_type == BFD_RELOC_SH_CODE || fix->fx_r_type == BFD_RELOC_SH_DATA +#ifdef HAVE_SH64 + || fix->fx_r_type == BFD_RELOC_SH_SHMEDIA_CODE +#endif || fix->fx_r_type == BFD_RELOC_SH_LABEL); } -/* Apply a fixup to the object file. */ +#ifdef OBJ_ELF +boolean +sh_fix_adjustable (fixP) + fixS *fixP; +{ + + if (fixP->fx_addsy == NULL) + return 1; + + if (fixP->fx_r_type == BFD_RELOC_SH_PCDISP8BY2 + || fixP->fx_r_type == BFD_RELOC_SH_PCDISP12BY2 + || fixP->fx_r_type == BFD_RELOC_SH_PCRELIMM8BY2 + || fixP->fx_r_type == BFD_RELOC_SH_PCRELIMM8BY4 + || fixP->fx_r_type == BFD_RELOC_8_PCREL + || fixP->fx_r_type == BFD_RELOC_SH_SWITCH16 + || fixP->fx_r_type == BFD_RELOC_SH_SWITCH32) + return 1; + + if (! TC_RELOC_RTSYM_LOC_FIXUP (fixP) + || fixP->fx_r_type == BFD_RELOC_RVA) + return 0; + + /* We need the symbol name for the VTABLE entries */ + if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT + || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) + return 0; + + return 1; +} -#ifdef BFD_ASSEMBLER -int -md_apply_fix (fixP, valp) - fixS *fixP; - valueT *valp; -#else void -md_apply_fix (fixP, val) - fixS *fixP; - long val; +sh_elf_final_processing () +{ + int val; + + /* Set file-specific flags to indicate if this code needs + a processor with the sh-dsp / sh3e ISA to execute. */ +#ifdef HAVE_SH64 + /* SH5 and above don't know about the valid_arch arch_sh* bits defined + in sh-opc.h, so check SH64 mode before checking valid_arch. */ + if (sh64_isa_mode != sh64_isa_unspecified) + val = EF_SH5; + else +#endif /* HAVE_SH64 */ + if (valid_arch & arch_sh1) + val = EF_SH1; + else if (valid_arch & arch_sh2) + val = EF_SH2; + else if (valid_arch & arch_sh_dsp) + val = EF_SH_DSP; + else if (valid_arch & arch_sh3) + val = EF_SH3; + else if (valid_arch & arch_sh3_dsp) + val = EF_SH_DSP; + else if (valid_arch & arch_sh3e) + val = EF_SH3E; + else if (valid_arch & arch_sh4) + val = EF_SH4; + else + abort (); + + elf_elfheader (stdoutput)->e_flags &= ~EF_SH_MACH_MASK; + elf_elfheader (stdoutput)->e_flags |= val; +} #endif + +/* Apply a fixup to the object file. */ + +void +md_apply_fix3 (fixP, valP, seg) + fixS * fixP; + valueT * valP; + segT seg ATTRIBUTE_UNUSED; { char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; int lowbyte = target_big_endian ? 1 : 0; int highbyte = target_big_endian ? 0 : 1; -#ifdef BFD_ASSEMBLER - long val = *valp; -#endif + long val = (long) *valP; long max, min; int shift; +#ifdef BFD_ASSEMBLER + /* A difference between two symbols, the second of which is in the + current section, is transformed in a PC-relative relocation to + the other symbol. We have to adjust the relocation type here. */ + if (fixP->fx_pcrel) + { + switch (fixP->fx_r_type) + { + default: + break; + + case BFD_RELOC_32: + fixP->fx_r_type = BFD_RELOC_32_PCREL; + break; + + /* Currently, we only support 32-bit PCREL relocations. + We'd need a new reloc type to handle 16_PCREL, and + 8_PCREL is already taken for R_SH_SWITCH8, which + apparently does something completely different than what + we need. FIXME. */ + case BFD_RELOC_16: + bfd_set_error (bfd_error_bad_value); + return; + + case BFD_RELOC_8: + bfd_set_error (bfd_error_bad_value); + return; + } + } + + /* The function adjust_reloc_syms won't convert a reloc against a weak + symbol into a reloc against a section, but bfd_install_relocation + will screw up if the symbol is defined, so we have to adjust val here + to avoid the screw up later. + + For ordinary relocs, this does not happen for ELF, since for ELF, + bfd_install_relocation uses the "special function" field of the + howto, and does not execute the code that needs to be undone, as long + as the special function does not return bfd_reloc_continue. + It can happen for GOT- and PLT-type relocs the way they are + described in elf32-sh.c as they use bfd_elf_generic_reloc, but it + doesn't matter here since those relocs don't use VAL; see below. */ + if (OUTPUT_FLAVOR != bfd_target_elf_flavour + && fixP->fx_addsy != NULL + && S_IS_WEAK (fixP->fx_addsy)) + val -= S_GET_VALUE (fixP->fx_addsy); +#endif + #ifndef BFD_ASSEMBLER if (fixP->fx_r_type == 0) { @@ -1884,7 +3416,7 @@ md_apply_fix (fixP, val) Note that adding further restrictions may invalidate reasonable looking assembly code, such as ``and -0x1,r0''. */ max = 0xff; - min = - 0xff; + min = -0xff; *buf++ = val; break; @@ -1904,60 +3436,39 @@ md_apply_fix (fixP, val) variable val. */ val = (val + 2) / 4; if (val & ~0xff) - as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far"); + as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); buf[lowbyte] = val; break; case BFD_RELOC_SH_PCRELIMM8BY2: val /= 2; if (val & ~0xff) - as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far"); + as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); buf[lowbyte] = val; break; case BFD_RELOC_SH_PCDISP8BY2: val /= 2; if (val < -0x80 || val > 0x7f) - as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far"); + as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); buf[lowbyte] = val; break; case BFD_RELOC_SH_PCDISP12BY2: val /= 2; - if (val < -0x800 || val >= 0x7ff) - as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far"); + if (val < -0x800 || val > 0x7ff) + as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); buf[lowbyte] = val & 0xff; buf[highbyte] |= (val >> 8) & 0xf; break; case BFD_RELOC_32: - if (! target_big_endian) - { - *buf++ = val >> 0; - *buf++ = val >> 8; - *buf++ = val >> 16; - *buf++ = val >> 24; - } - else - { - *buf++ = val >> 24; - *buf++ = val >> 16; - *buf++ = val >> 8; - *buf++ = val >> 0; - } + case BFD_RELOC_32_PCREL: + md_number_to_chars (buf, val, 4); break; case BFD_RELOC_16: - if (! target_big_endian) - { - *buf++ = val >> 0; - *buf++ = val >> 8; - } - else - { - *buf++ = val >> 8; - *buf++ = val >> 0; - } + md_number_to_chars (buf, val, 2); break; case BFD_RELOC_SH_USES: @@ -1973,14 +3484,70 @@ md_apply_fix (fixP, val) /* Nothing to do here. */ break; + case BFD_RELOC_SH_LOOP_START: + case BFD_RELOC_SH_LOOP_END: + + case BFD_RELOC_VTABLE_INHERIT: + case BFD_RELOC_VTABLE_ENTRY: + fixP->fx_done = 0; + return; + +#ifdef OBJ_ELF + case BFD_RELOC_32_PLT_PCREL: + /* Make the jump instruction point to the address of the operand. At + runtime we merely add the offset to the actual PLT entry. */ + * valP = 0xfffffffc; + val = fixP->fx_addnumber; + if (fixP->fx_subsy) + val -= S_GET_VALUE (fixP->fx_subsy); + md_number_to_chars (buf, val, 4); + break; + + case BFD_RELOC_SH_GOTPC: + /* This is tough to explain. We end up with this one if we have + operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]". + The goal here is to obtain the absolute address of the GOT, + and it is strongly preferable from a performance point of + view to avoid using a runtime relocation for this. There are + cases where you have something like: + + .long _GLOBAL_OFFSET_TABLE_+[.-.L66] + + and here no correction would be required. Internally in the + assembler we treat operands of this form as not being pcrel + since the '.' is explicitly mentioned, and I wonder whether + it would simplify matters to do it this way. Who knows. In + earlier versions of the PIC patches, the pcrel_adjust field + was used to store the correction, but since the expression is + not pcrel, I felt it would be confusing to do it this way. */ + * valP -= 1; + md_number_to_chars (buf, val, 4); + break; + + case BFD_RELOC_32_GOT_PCREL: + case BFD_RELOC_SH_GOTPLT32: + * valP = 0; /* Fully resolved at runtime. No addend. */ + md_number_to_chars (buf, 0, 4); + break; + + case BFD_RELOC_32_GOTOFF: + md_number_to_chars (buf, val, 4); + break; +#endif + default: +#ifdef HAVE_SH64 + shmedia_md_apply_fix3 (fixP, valP); + return; +#else abort (); +#endif } if (shift != 0) { if ((val & ((1 << shift) - 1)) != 0) - as_bad_where (fixP->fx_file, fixP->fx_line, "misaligned offset"); + as_bad_where (fixP->fx_file, fixP->fx_line, _("misaligned offset")); if (val >= 0) val >>= shift; else @@ -1988,15 +3555,12 @@ md_apply_fix (fixP, val) | ((long) -1 & ~ ((long) -1 >> shift))); } if (max != 0 && (val < min || val > max)) - as_bad_where (fixP->fx_file, fixP->fx_line, "offset out of range"); + as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range")); -#ifdef BFD_ASSEMBLER - return 0; -#endif + if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) + fixP->fx_done = 1; } -int md_long_jump_size; - /* Called just before address relaxation. Return the length by which a fragment must grow to reach it's destination. */ @@ -2005,60 +3569,78 @@ md_estimate_size_before_relax (fragP, segment_type) register fragS *fragP; register segT segment_type; { + int what; + switch (fragP->fr_subtype) { + default: +#ifdef HAVE_SH64 + return shmedia_md_estimate_size_before_relax (fragP, segment_type); +#else + abort (); +#endif + + case C (UNCOND_JUMP, UNDEF_DISP): - /* used to be a branch to somewhere which was unknown */ + /* Used to be a branch to somewhere which was unknown. */ if (!fragP->fr_symbol) { fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12); - fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length; } else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type) { fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12); - fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length; } else { fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP); - fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length; - return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length; } break; - default: - abort (); case C (COND_JUMP, UNDEF_DISP): - /* used to be a branch to somewhere which was unknown */ + case C (COND_JUMP_DELAY, UNDEF_DISP): + what = GET_WHAT (fragP->fr_subtype); + /* Used to be a branch to somewhere which was unknown. */ if (fragP->fr_symbol && S_GET_SEGMENT (fragP->fr_symbol) == segment_type) { /* Got a symbol and it's defined in this segment, become byte - sized - maybe it will fix up */ - fragP->fr_subtype = C (COND_JUMP, COND8); - fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length; + sized - maybe it will fix up. */ + fragP->fr_subtype = C (what, COND8); } else if (fragP->fr_symbol) { - /* Its got a segment, but its not ours, so it will always be long */ - fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP); - fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length; - return md_relax_table[C (COND_JUMP, COND32)].rlx_length; + /* Its got a segment, but its not ours, so it will always be long. */ + fragP->fr_subtype = C (what, UNDEF_WORD_DISP); } else { - /* We know the abs value */ - fragP->fr_subtype = C (COND_JUMP, COND8); - fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length; + /* We know the abs value. */ + fragP->fr_subtype = C (what, COND8); } + break; + case C (UNCOND_JUMP, UNCOND12): + case C (UNCOND_JUMP, UNCOND32): + case C (UNCOND_JUMP, UNDEF_WORD_DISP): + case C (COND_JUMP, COND8): + case C (COND_JUMP, COND12): + case C (COND_JUMP, COND32): + case C (COND_JUMP, UNDEF_WORD_DISP): + case C (COND_JUMP_DELAY, COND8): + case C (COND_JUMP_DELAY, COND12): + case C (COND_JUMP_DELAY, COND32): + case C (COND_JUMP_DELAY, UNDEF_WORD_DISP): + /* When relaxing a section for the second time, we don't need to + do anything besides return the current size. */ break; } + + fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length; return fragP->fr_var; } -/* Put number into target byte order */ +/* Put number into target byte order. */ void md_number_to_chars (ptr, use, nbytes) @@ -2066,12 +3648,20 @@ md_number_to_chars (ptr, use, nbytes) valueT use; int nbytes; { +#ifdef HAVE_SH64 + /* We might need to set the contents type to data. */ + sh64_flag_output (); +#endif + if (! target_big_endian) number_to_chars_littleendian (ptr, use, nbytes); else number_to_chars_bigendian (ptr, use, nbytes); } +/* This version is used in obj-coff.c when not using BFD_ASSEMBLER. + eg for the sh-hms target. */ + long md_pcrel_from (fixP) fixS *fixP; @@ -2079,6 +3669,27 @@ md_pcrel_from (fixP) return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address + 2; } +long +md_pcrel_from_section (fixP, sec) + fixS *fixP; + segT sec; +{ + if (fixP->fx_addsy != (symbolS *) NULL + && (! S_IS_DEFINED (fixP->fx_addsy) + || S_IS_EXTERN (fixP->fx_addsy) + || S_IS_WEAK (fixP->fx_addsy) + || S_GET_SEGMENT (fixP->fx_addsy) != sec)) + { + /* The symbol is undefined (or is defined but not in this section, + or we're not sure about it being the final definition). Let the + linker figure it out. We need to adjust the subtraction of a + symbol to the position of the relocated data, though. */ + return fixP->fx_subsy ? fixP->fx_where + fixP->fx_frag->fr_address : 0; + } + + return md_pcrel_from (fixP); +} + #ifdef OBJ_COFF int @@ -2090,41 +3701,6 @@ tc_coff_sizemachdep (frag) #endif /* OBJ_COFF */ -/* When we align the .text section, insert the correct NOP pattern. */ - -int -sh_do_align (n, fill, len, max) - int n; - const char *fill; - int len; - int max; -{ - if (fill == NULL -#ifdef BFD_ASSEMBLER - && (now_seg->flags & SEC_CODE) != 0 -#else - && now_seg != data_section - && now_seg != bss_section -#endif - && n > 1) - { - static const unsigned char big_nop_pattern[] = { 0x00, 0x09 }; - static const unsigned char little_nop_pattern[] = { 0x09, 0x00 }; - - /* First align to a 2 byte boundary, in case there is an odd - .byte. */ - frag_align (1, 0, 0); - if (target_big_endian) - frag_align_pattern (n, big_nop_pattern, sizeof big_nop_pattern, max); - else - frag_align_pattern (n, little_nop_pattern, sizeof little_nop_pattern, - max); - return 1; - } - - return 0; -} - #ifndef BFD_ASSEMBLER #ifdef OBJ_COFF @@ -2187,7 +3763,7 @@ sh_coff_reloc_mangle (seg, fix, intr, paddr) break; if (rm->bfd_reloc == BFD_RELOC_UNUSED) as_bad_where (fix->fx_file, fix->fx_line, - "Can not represent %s relocation in this object file format", + _("Can not represent %s relocation in this object file format"), bfd_get_reloc_code_name (fix->fx_r_type)); intr->r_type = rm->sh_reloc; intr->r_offset = 0; @@ -2233,7 +3809,7 @@ sh_coff_reloc_mangle (seg, fix, intr, paddr) { /* We can't store the offset in the object file, since this reloc does not take up any space, so we store it in r_offset. - The fx_addnumber field was set in md_apply_fix. */ + The fx_addnumber field was set in md_apply_fix3. */ intr->r_offset = fix->fx_addnumber; } else if (fix->fx_r_type == BFD_RELOC_SH_COUNT) @@ -2283,16 +3859,24 @@ sh_coff_reloc_mangle (seg, fix, intr, paddr) arelent * tc_gen_reloc (section, fixp) - asection *section; + asection *section ATTRIBUTE_UNUSED; fixS *fixp; { arelent *rel; bfd_reloc_code_real_type r_type; rel = (arelent *) xmalloc (sizeof (arelent)); - rel->sym_ptr_ptr = &fixp->fx_addsy->bsym; + rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); + *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); rel->address = fixp->fx_frag->fr_address + fixp->fx_where; + if (fixp->fx_subsy + && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section) + { + fixp->fx_addnumber -= S_GET_VALUE (fixp->fx_subsy); + fixp->fx_subsy = 0; + } + r_type = fixp->fx_r_type; if (SWITCH_TABLE (fixp)) @@ -2313,16 +3897,33 @@ tc_gen_reloc (section, fixp) rel->addend = fixp->fx_offset; else if (r_type == BFD_RELOC_SH_ALIGN) rel->addend = fixp->fx_offset; + else if (r_type == BFD_RELOC_VTABLE_INHERIT + || r_type == BFD_RELOC_VTABLE_ENTRY) + rel->addend = fixp->fx_offset; + else if (r_type == BFD_RELOC_SH_LOOP_START + || r_type == BFD_RELOC_SH_LOOP_END) + rel->addend = fixp->fx_offset; + else if (r_type == BFD_RELOC_SH_LABEL && fixp->fx_pcrel) + { + rel->addend = 0; + rel->address = rel->addend = fixp->fx_offset; + } +#ifdef HAVE_SH64 + else if (shmedia_init_reloc (rel, fixp)) + ; +#endif else if (fixp->fx_pcrel) rel->addend = fixp->fx_addnumber; + else if (r_type == BFD_RELOC_32 || r_type == BFD_RELOC_32_GOTOFF) + rel->addend = fixp->fx_addnumber; else rel->addend = 0; rel->howto = bfd_reloc_type_lookup (stdoutput, r_type); - if (rel->howto == NULL) + if (rel->howto == NULL || fixp->fx_subsy) { as_bad_where (fixp->fx_file, fixp->fx_line, - "Cannot represent relocation type %s", + _("Cannot represent relocation type %s"), bfd_get_reloc_code_name (r_type)); /* Set howto to a garbage value so that we can keep going. */ rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32); @@ -2332,4 +3933,89 @@ tc_gen_reloc (section, fixp) return rel; } +#ifdef OBJ_ELF +inline static char * +sh_end_of_match (cont, what) + char *cont, *what; +{ + int len = strlen (what); + + if (strncasecmp (cont, what, strlen (what)) == 0 + && ! is_part_of_name (cont[len])) + return cont + len; + + return NULL; +} + +int +sh_parse_name (name, exprP, nextcharP) + char const *name; + expressionS *exprP; + char *nextcharP; +{ + char *next = input_line_pointer; + char *next_end; + int reloc_type; + segT segment; + + exprP->X_op_symbol = NULL; + + if (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0) + { + if (! GOT_symbol) + GOT_symbol = symbol_find_or_make (name); + + exprP->X_add_symbol = GOT_symbol; + no_suffix: + /* If we have an absolute symbol or a reg, then we know its + value now. */ + segment = S_GET_SEGMENT (exprP->X_add_symbol); + if (segment == absolute_section) + { + exprP->X_op = O_constant; + exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol); + exprP->X_add_symbol = NULL; + } + else if (segment == reg_section) + { + exprP->X_op = O_register; + exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol); + exprP->X_add_symbol = NULL; + } + else + { + exprP->X_op = O_symbol; + exprP->X_add_number = 0; + } + + return 1; + } + + exprP->X_add_symbol = symbol_find_or_make (name); + + if (*nextcharP != '@') + goto no_suffix; + else if ((next_end = sh_end_of_match (next + 1, "GOTOFF"))) + reloc_type = BFD_RELOC_32_GOTOFF; + else if ((next_end = sh_end_of_match (next + 1, "GOTPLT"))) + reloc_type = BFD_RELOC_SH_GOTPLT32; + else if ((next_end = sh_end_of_match (next + 1, "GOT"))) + reloc_type = BFD_RELOC_32_GOT_PCREL; + else if ((next_end = sh_end_of_match (next + 1, "PLT"))) + reloc_type = BFD_RELOC_32_PLT_PCREL; + else + goto no_suffix; + + *input_line_pointer = *nextcharP; + input_line_pointer = next_end; + *nextcharP = *input_line_pointer; + *input_line_pointer = '\0'; + + exprP->X_op = O_PIC_reloc; + exprP->X_add_number = 0; + exprP->X_md = reloc_type; + + return 1; +} +#endif #endif /* BFD_ASSEMBLER */ diff --git a/contrib/binutils/gas/config/tc-sh.h b/contrib/binutils/gas/config/tc-sh.h index a18029b..313ac88 100644 --- a/contrib/binutils/gas/config/tc-sh.h +++ b/contrib/binutils/gas/config/tc-sh.h @@ -1,5 +1,6 @@ /* This file is tc-sh.h - Copyright (C) 1993, 94, 95, 96, 1997 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -20,12 +21,12 @@ #define TC_SH -#define TARGET_BYTES_BIG_ENDIAN 0 - #define TARGET_ARCH bfd_arch_sh -/* Whether in little endian mode. */ -extern int shl; +#if ANSI_PROTOTYPES +struct segment_info_struct; +struct internal_reloc; +#endif /* Whether -relax was used. */ extern int sh_relax; @@ -36,6 +37,9 @@ extern int sh_small; /* Don't try to break words. */ #define WORKING_DOT_WORD +/* All SH instructions are multiples of 16 bits. */ +#define DWARF2_LINE_MIN_INSN_LENGTH 2 + /* We require .long, et. al., to be aligned correctly. */ #define md_cons_align(nbytes) sh_cons_align (nbytes) extern void sh_cons_align PARAMS ((int)); @@ -45,24 +49,47 @@ extern void sh_cons_align PARAMS ((int)); #define HANDLE_ALIGN(frag) sh_handle_align (frag) extern void sh_handle_align PARAMS ((fragS *)); +#define MAX_MEM_FOR_RS_ALIGN_CODE (1 + 2) + /* We need to force out some relocations when relaxing. */ #define TC_FORCE_RELOCATION(fix) sh_force_relocation (fix) -extern int sh_force_relocation (); + +/* The type fixS is defined (to struct fix) in write.h, but write.h uses + definitions from this file. To avoid problems with including write.h + after the "right" definitions, don't; just forward-declare struct fix + here. */ +struct fix; +extern int sh_force_relocation PARAMS ((struct fix *)); + +#ifdef OBJ_ELF +#define obj_fix_adjustable(fixP) sh_fix_adjustable(fixP) +struct fix; +extern boolean sh_fix_adjustable PARAMS ((struct fix *)); + +/* This arranges for gas/write.c to not apply a relocation if + obj_fix_adjustable() says it is not adjustable. */ +/* ??? fixups with symbols in SEC_MERGE sections are marked with + obj_fix_adjustable and have a non-section symbol, as in + "vwxyz"+1 in execute/string-opt-6.c . Maybe the test of + (symbol_used_in_reloc_p should be done in the machine-independent code. */ +#define TC_FIX_ADJUSTABLE(fixP) \ + (! symbol_used_in_reloc_p (fixP->fx_addsy) && obj_fix_adjustable (fixP)) +#endif + +#define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from_section (FIXP, SEC) +extern long md_pcrel_from_section PARAMS ((struct fix *, segT)); #define IGNORE_NONSTANDARD_ESCAPES -#define LISTING_HEADER (shl ? "Hitachi Super-H GAS Little Endian" : "Hitachi Super-H GAS Big Endian") +#define LISTING_HEADER \ + (!target_big_endian \ + ? "Hitachi Super-H GAS Little Endian" : "Hitachi Super-H GAS Big Endian") #define md_operand(x) extern const struct relax_type md_relax_table[]; #define TC_GENERIC_RELAX_TABLE md_relax_table -/* We use a special alignment function to insert the correct nop - pattern. */ -extern int sh_do_align PARAMS ((int, const char *, int, int)); -#define md_do_align(n,fill,len,max,l) if (sh_do_align (n,fill,len,max)) goto l - /* We record, for each section, whether we have most recently output a CODE reloc or a DATA reloc. */ struct sh_segment_info_type @@ -98,14 +125,16 @@ extern void sh_frob_file PARAMS ((void)); #define BFD_ARCH TARGET_ARCH -#define COFF_MAGIC (shl ? SH_ARCH_MAGIC_LITTLE : SH_ARCH_MAGIC_BIG) +#define COFF_MAGIC (!target_big_endian ? SH_ARCH_MAGIC_LITTLE : SH_ARCH_MAGIC_BIG) /* We need to write out relocs which have not been completed. */ #define TC_COUNT_RELOC(fix) ((fix)->fx_addsy != NULL) #define TC_RELOC_MANGLE(seg, fix, int, paddr) \ sh_coff_reloc_mangle ((seg), (fix), (int), (paddr)) -extern void sh_coff_reloc_mangle (); +extern void sh_coff_reloc_mangle + PARAMS ((struct segment_info_struct *, struct fix *, + struct internal_reloc *, unsigned int)); #define tc_coff_symbol_emit_hook(a) ; /* not used */ @@ -116,14 +145,20 @@ extern void sh_coff_reloc_mangle (); #define TC_COFF_SIZEMACHDEP(frag) tc_coff_sizemachdep(frag) extern int tc_coff_sizemachdep PARAMS ((fragS *)); +#ifdef BFD_ASSEMBLER +#define SEG_NAME(SEG) segment_name (SEG) +#else +#define SEG_NAME(SEG) obj_segment_name (SEG) +#endif + /* We align most sections to a 16 byte boundary. */ -#define SUB_SEGMENT_ALIGN(SEG) \ - (strncmp (obj_segment_name (SEG), ".stabstr", 8) == 0 \ - ? 0 \ - : ((strncmp (obj_segment_name (SEG), ".stab", 5) == 0 \ - || strcmp (obj_segment_name (SEG), ".ctors") == 0 \ - || strcmp (obj_segment_name (SEG), ".dtors") == 0) \ - ? 2 \ +#define SUB_SEGMENT_ALIGN(SEG) \ + (strncmp (SEG_NAME (SEG), ".stabstr", 8) == 0 \ + ? 0 \ + : ((strncmp (SEG_NAME (SEG), ".stab", 5) == 0 \ + || strcmp (SEG_NAME (SEG), ".ctors") == 0 \ + || strcmp (SEG_NAME (SEG), ".dtors") == 0) \ + ? 2 \ : (sh_small ? 2 : 4))) #endif /* OBJ_COFF */ @@ -133,9 +168,65 @@ extern int tc_coff_sizemachdep PARAMS ((fragS *)); /* Whether or not the target is big endian */ extern int target_big_endian; +#ifdef TE_LINUX +#define TARGET_FORMAT (!target_big_endian ? "elf32-sh-linux" : "elf32-shbig-linux") +#elif defined(TE_NetBSD) +#define TARGET_FORMAT (!target_big_endian ? "elf32-shl-nbsd" : "elf32-sh-nbsd") +#else +#define TARGET_FORMAT (!target_big_endian ? "elf32-shl" : "elf32-sh") +#endif -#define TARGET_FORMAT (shl ? "elf32-shl" : "elf32-sh") +#define elf_tc_final_processing sh_elf_final_processing +extern void sh_elf_final_processing PARAMS ((void)); + +#define DIFF_EXPR_OK /* foo-. gets turned into PC relative relocs */ + +#define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_" + +/* This is the relocation type for direct references to + GLOBAL_OFFSET_TABLE. It comes up in complicated expressions such + as _GLOBAL_OFFSET_TABLE_+[.-.L284], which cannot be expressed + normally with the regular expressions. The fixup specified here + when used at runtime implies that we should add the address of the + GOT to the specified location, and as a result we have simplified + the expression into something we can use. */ +#define TC_RELOC_GLOBAL_OFFSET_TABLE BFD_RELOC_SH_GOTPC + +/* This expression evaluates to false if the relocation is for a local object + for which we still want to do the relocation at runtime. True if we + are willing to perform this relocation while building the .o file. + This is only used for pcrel relocations, so GOTOFF does not need to be + checked here. I am not sure if some of the others are ever used with + pcrel, but it is easier to be safe than sorry. + + We can't resolve references to the GOT or the PLT when creating the + object file, since these tables are only created by the linker. + Also, if the symbol is global, weak, common or not defined, the + assembler can't compute the appropriate reloc, since its location + can only be determined at link time. */ + +#define TC_RELOC_RTSYM_LOC_FIXUP(FIX) \ + ((FIX)->fx_r_type != BFD_RELOC_32_PLT_PCREL \ + && (FIX)->fx_r_type != BFD_RELOC_32_GOT_PCREL \ + && (FIX)->fx_r_type != BFD_RELOC_SH_GOTPC \ + && ((FIX)->fx_addsy == NULL \ + || (! S_IS_EXTERNAL ((FIX)->fx_addsy) \ + && ! S_IS_WEAK ((FIX)->fx_addsy) \ + && S_IS_DEFINED ((FIX)->fx_addsy) \ + && ! S_IS_COMMON ((FIX)->fx_addsy)))) + +#define md_parse_name(name, exprP, nextcharP) \ + sh_parse_name ((name), (exprP), (nextcharP)) +int sh_parse_name PARAMS ((char const *name, + expressionS *exprP, + char *nextchar)); + +#define TC_CONS_FIX_NEW(FRAG, OFF, LEN, EXP) \ + sh_cons_fix_new ((FRAG), (OFF), (LEN), (EXP)) +void sh_cons_fix_new PARAMS ((fragS *, int, int, expressionS *)); + +/* This is used to construct expressions out of @GOTOFF, @PLT and @GOT + symbols. The relocation type is stored in X_md. */ +#define O_PIC_reloc O_md1 #endif /* OBJ_ELF */ - -/* end of tc-sh.h */ diff --git a/contrib/binutils/gprof/po/Make-in b/contrib/binutils/gprof/po/Make-in new file mode 100644 index 0000000..0552db1 --- /dev/null +++ b/contrib/binutils/gprof/po/Make-in @@ -0,0 +1,251 @@ +# Makefile for program source directory in GNU NLS utilities package. +# Copyright (C) 1995, 1996, 1997 by Ulrich Drepper +# +# This file file be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +PACKAGE = @PACKAGE@ +VERSION = @VERSION@ + +SHELL = /bin/sh +@SET_MAKE@ + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ + +prefix = @prefix@ +exec_prefix = @exec_prefix@ +datadir = $(prefix)/@DATADIRNAME@ +localedir = $(datadir)/locale +gnulocaledir = $(prefix)/share/locale +gettextsrcdir = $(prefix)/share/gettext/po +subdir = po + +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +MKINSTALLDIRS = @MKINSTALLDIRS@ + +CC = @CC@ +GENCAT = @GENCAT@ +GMSGFMT = PATH=../src:$$PATH @GMSGFMT@ +MSGFMT = @MSGFMT@ +XGETTEXT = PATH=../src:$$PATH @XGETTEXT@ +MSGMERGE = PATH=../src:$$PATH msgmerge + +DEFS = @DEFS@ +CFLAGS = @CFLAGS@ +CPPFLAGS = @CPPFLAGS@ + +INCLUDES = -I.. -I$(top_srcdir)/intl + +COMPILE = $(CC) -c $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(XCFLAGS) + +SOURCES = cat-id-tbl.c +POFILES = @POFILES@ +GMOFILES = @GMOFILES@ +DISTFILES = ChangeLog Makefile.in.in POTFILES.in $(PACKAGE).pot \ +stamp-cat-id $(POFILES) $(GMOFILES) $(SOURCES) + +POTFILES = \ + +CATALOGS = @CATALOGS@ +CATOBJEXT = @CATOBJEXT@ +INSTOBJEXT = @INSTOBJEXT@ + +.SUFFIXES: +.SUFFIXES: .c .o .po .pox .gmo .mo .msg .cat + +.c.o: + $(COMPILE) $< + +.po.pox: + $(MAKE) $(PACKAGE).pot + $(MSGMERGE) $< $(srcdir)/$(PACKAGE).pot -o $*.pox + +.po.mo: + $(MSGFMT) -o $@ $< + +.po.gmo: + file=$(srcdir)/`echo $* | sed 's,.*/,,'`.gmo \ + && rm -f $$file && $(GMSGFMT) -o $$file $< + +.po.cat: + sed -f ../intl/po2msg.sed < $< > $*.msg \ + && rm -f $@ && $(GENCAT) $@ $*.msg + + +all: all-@USE_NLS@ + +all-yes: $(CATALOGS) @MAINT@ $(PACKAGE).pot +all-no: + +$(srcdir)/$(PACKAGE).pot: $(POTFILES) + $(XGETTEXT) --default-domain=$(PACKAGE) --directory=$(top_srcdir) \ + --add-comments --keyword=_ --keyword=N_ \ + --files-from=$(srcdir)/POTFILES.in + rm -f $(srcdir)/$(PACKAGE).pot + mv $(PACKAGE).po $(srcdir)/$(PACKAGE).pot + +$(srcdir)/cat-id-tbl.c: stamp-cat-id; @: +$(srcdir)/stamp-cat-id: $(PACKAGE).pot + rm -f cat-id-tbl.tmp + sed -f ../intl/po2tbl.sed $(srcdir)/$(PACKAGE).pot \ + | sed -e "s/@PACKAGE NAME@/$(PACKAGE)/" > cat-id-tbl.tmp + if cmp -s cat-id-tbl.tmp $(srcdir)/cat-id-tbl.c; then \ + rm cat-id-tbl.tmp; \ + else \ + echo cat-id-tbl.c changed; \ + rm -f $(srcdir)/cat-id-tbl.c; \ + mv cat-id-tbl.tmp $(srcdir)/cat-id-tbl.c; \ + fi + cd $(srcdir) && rm -f stamp-cat-id && echo timestamp > stamp-cat-id + + +install: install-exec install-data +install-exec: +install-info: +install-data: install-data-@USE_NLS@ +install-data-no: all +install-data-yes: all + if test -r $(MKINSTALLDIRS); then \ + $(MKINSTALLDIRS) $(datadir); \ + else \ + $(top_srcdir)/mkinstalldirs $(datadir); \ + fi + @catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + case "$$cat" in \ + *.gmo) destdir=$(gnulocaledir);; \ + *) destdir=$(localedir);; \ + esac; \ + lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \ + dir=$$destdir/$$lang/LC_MESSAGES; \ + if test -r $(MKINSTALLDIRS); then \ + $(MKINSTALLDIRS) $$dir; \ + else \ + $(top_srcdir)/mkinstalldirs $$dir; \ + fi; \ + if test -r $$cat; then \ + $(INSTALL_DATA) $$cat $$dir/$(PACKAGE)$(INSTOBJEXT); \ + echo "installing $$cat as $$dir/$(PACKAGE)$(INSTOBJEXT)"; \ + else \ + $(INSTALL_DATA) $(srcdir)/$$cat $$dir/$(PACKAGE)$(INSTOBJEXT); \ + echo "installing $(srcdir)/$$cat as" \ + "$$dir/$(PACKAGE)$(INSTOBJEXT)"; \ + fi; \ + if test -r $$cat.m; then \ + $(INSTALL_DATA) $$cat.m $$dir/$(PACKAGE)$(INSTOBJEXT).m; \ + echo "installing $$cat.m as $$dir/$(PACKAGE)$(INSTOBJEXT).m"; \ + else \ + if test -r $(srcdir)/$$cat.m ; then \ + $(INSTALL_DATA) $(srcdir)/$$cat.m \ + $$dir/$(PACKAGE)$(INSTOBJEXT).m; \ + echo "installing $(srcdir)/$$cat as" \ + "$$dir/$(PACKAGE)$(INSTOBJEXT).m"; \ + else \ + true; \ + fi; \ + fi; \ + done + if test "$(PACKAGE)" = "gettext"; then \ + if test -r $(MKINSTALLDIRS); then \ + $(MKINSTALLDIRS) $(gettextsrcdir); \ + else \ + $(top_srcdir)/mkinstalldirs $(gettextsrcdir); \ + fi; \ + $(INSTALL_DATA) $(srcdir)/Makefile.in.in \ + $(gettextsrcdir)/Makefile.in.in; \ + else \ + : ; \ + fi + +# Define this as empty until I found a useful application. +installcheck: + +uninstall: + catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \ + rm -f $(localedir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT); \ + rm -f $(localedir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT).m; \ + rm -f $(gnulocaledir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT); \ + rm -f $(gnulocaledir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT).m; \ + done + rm -f $(gettextsrcdir)/po-Makefile.in.in + +check: all + +cat-id-tbl.o: ../intl/libgettext.h + +dvi info tags TAGS ID: + +mostlyclean: + rm -f core core.* *.pox $(PACKAGE).po *.old.po cat-id-tbl.tmp + rm -fr *.o + +clean: mostlyclean + +distclean: clean + rm -f Makefile Makefile.in POTFILES *.mo *.msg *.cat *.cat.m + +maintainer-clean: distclean + @echo "This command is intended for maintainers to use;" + @echo "it deletes files that may require special tools to rebuild." + rm -f $(GMOFILES) + +distdir = ../$(PACKAGE)-$(VERSION)/$(subdir) +dist distdir: update-po $(DISTFILES) + dists="$(DISTFILES)"; \ + for file in $$dists; do \ + ln $(srcdir)/$$file $(distdir) 2> /dev/null \ + || cp -p $(srcdir)/$$file $(distdir); \ + done + +update-po: Makefile + $(MAKE) $(PACKAGE).pot + PATH=`pwd`/../src:$$PATH; \ + cd $(srcdir); \ + catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \ + mv $$lang.po $$lang.old.po; \ + echo "$$lang:"; \ + if $(MSGMERGE) $$lang.old.po $(PACKAGE).pot -o $$lang.po; then \ + rm -f $$lang.old.po; \ + else \ + echo "msgmerge for $$cat failed!"; \ + rm -f $$lang.po; \ + mv $$lang.old.po $$lang.po; \ + fi; \ + done + +POTFILES: POTFILES.in + ( if test 'x$(srcdir)' != 'x.'; then \ + posrcprefix='$(top_srcdir)/'; \ + else \ + posrcprefix="../"; \ + fi; \ + rm -f $@-t $@ \ + && (sed -e '/^#/d' -e '/^[ ]*$$/d' \ + -e "s@.*@ $$posrcprefix& \\\\@" < $(srcdir)/$@.in \ + | sed -e '$$s/\\$$//') > $@-t \ + && chmod a-w $@-t \ + && mv $@-t $@ ) + +POTFILES.in: @MAINT@ ../Makefile + cd .. && $(MAKE) po/POTFILES.in + +Makefile: Make-in ../config.status POTFILES + cd .. \ + && CONFIG_FILES=$(subdir)/Makefile.in:$(subdir)/Make-in \ + CONFIG_HEADERS= $(SHELL) ./config.status + +# Tell versions [3.59,3.63) of GNU make not to export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/contrib/binutils/gprof/po/POTFILES.in b/contrib/binutils/gprof/po/POTFILES.in new file mode 100644 index 0000000..6ea40f1 --- /dev/null +++ b/contrib/binutils/gprof/po/POTFILES.in @@ -0,0 +1,38 @@ +alpha.c +basic_blocks.c +basic_blocks.h +call_graph.c +call_graph.h +cg_arcs.c +cg_arcs.h +cg_dfn.c +cg_dfn.h +cg_print.c +cg_print.h +corefile.c +corefile.h +gmon.h +gmon_io.c +gmon_io.h +gmon_out.h +gprof.c +gprof.h +hertz.c +hertz.h +hist.c +hist.h +i386.c +mips.c +search_list.c +search_list.h +source.c +source.h +sparc.c +sym_ids.c +sym_ids.h +symtab.c +symtab.h +tahoe.c +utils.c +utils.h +vax.c diff --git a/contrib/binutils/gprof/po/gprof.pot b/contrib/binutils/gprof/po/gprof.pot new file mode 100644 index 0000000..f586066 --- /dev/null +++ b/contrib/binutils/gprof/po/gprof.pot @@ -0,0 +1,505 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR Free Software Foundation, Inc. +# FIRST AUTHOR , YEAR. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"POT-Creation-Date: 2002-01-31 18:32+0000\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=CHARSET\n" +"Content-Transfer-Encoding: 8bit\n" + +#: alpha.c:93 mips.c:47 +msgid "" +msgstr "" + +#: alpha.c:110 mips.c:64 +#, c-format +msgid "[find_call] %s: 0x%lx to 0x%lx\n" +msgstr "" + +#: alpha.c:132 +#, c-format +msgid "[find_call] 0x%lx: jsr%s \n" +msgstr "" + +#: alpha.c:142 +#, c-format +msgid "[find_call] 0x%lx: bsr" +msgstr "" + +#: basic_blocks.c:122 call_graph.c:90 hist.c:93 +#, c-format +msgid "%s: %s: unexpected end of file\n" +msgstr "" + +#: basic_blocks.c:190 +#, c-format +msgid "%s: warning: ignoring basic-block exec counts (use -l or --line)\n" +msgstr "" + +#. FIXME: This only works if bfd_vma is unsigned long. +#: basic_blocks.c:281 basic_blocks.c:291 +#, c-format +msgid "%s:%d: (%s:0x%lx) %lu executions\n" +msgstr "" + +#: basic_blocks.c:282 basic_blocks.c:292 +msgid "" +msgstr "" + +#: basic_blocks.c:536 +#, c-format +msgid "" +"\n" +"\n" +"Top %d Lines:\n" +"\n" +" Line Count\n" +"\n" +msgstr "" + +#: basic_blocks.c:560 +msgid "" +"\n" +"Execution Summary:\n" +"\n" +msgstr "" + +#: basic_blocks.c:561 +#, c-format +msgid "%9ld Executable lines in this file\n" +msgstr "" + +#: basic_blocks.c:563 +#, c-format +msgid "%9ld Lines executed\n" +msgstr "" + +#: basic_blocks.c:564 +#, c-format +msgid "%9.2f Percent of the file executed\n" +msgstr "" + +#: basic_blocks.c:568 +#, c-format +msgid "" +"\n" +"%9lu Total number of line executions\n" +msgstr "" + +#: basic_blocks.c:570 +#, c-format +msgid "%9.2f Average executions per line\n" +msgstr "" + +#: call_graph.c:69 +#, c-format +msgid "[cg_tally] arc from %s to %s traversed %lu times\n" +msgstr "" + +#: cg_print.c:58 +msgid "" +"\t\t Call graph (explanation follows)\n" +"\n" +msgstr "" + +#: cg_print.c:60 +msgid "" +"\t\t\tCall graph\n" +"\n" +msgstr "" + +#: cg_print.c:63 hist.c:355 +#, c-format +msgid "" +"\n" +"granularity: each sample hit covers %ld byte(s)" +msgstr "" + +#: cg_print.c:67 +#, c-format +msgid "" +" for %.2f%% of %.2f seconds\n" +"\n" +msgstr "" + +#: cg_print.c:71 +msgid "" +" no time propagated\n" +"\n" +msgstr "" + +#: cg_print.c:80 cg_print.c:83 cg_print.c:85 +msgid "called" +msgstr "" + +#: cg_print.c:80 cg_print.c:85 +msgid "total" +msgstr "" + +#: cg_print.c:80 +msgid "parents" +msgstr "" + +#: cg_print.c:82 cg_print.c:83 +msgid "index" +msgstr "" + +#: cg_print.c:82 +msgid "%time" +msgstr "" + +#: cg_print.c:82 cg_print.c:83 +msgid "self" +msgstr "" + +#: cg_print.c:82 +msgid "descendants" +msgstr "" + +#: cg_print.c:83 hist.c:381 +msgid "name" +msgstr "" + +#: cg_print.c:85 +msgid "children" +msgstr "" + +#: cg_print.c:90 +#, c-format +msgid "index %% time self children called name\n" +msgstr "" + +#: cg_print.c:113 +#, c-format +msgid " [%d]\n" +msgstr "" + +#: cg_print.c:339 +#, c-format +msgid "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s \n" +msgstr "" + +#: cg_print.c:340 +#, c-format +msgid "%6.6s %5.5s %7.7s %7.7s %7.7s %7.7s \n" +msgstr "" + +#: cg_print.c:574 +msgid "" +"Index by function name\n" +"\n" +msgstr "" + +#: cg_print.c:631 cg_print.c:640 +#, c-format +msgid "" +msgstr "" + +#: corefile.c:64 +#, c-format +msgid "%s: could not open %s.\n" +msgstr "" + +#: corefile.c:78 corefile.c:112 +#, c-format +msgid "%s: unable to parse mapping file %s.\n" +msgstr "" + +#: corefile.c:154 +#, c-format +msgid "%s: %s: not in a.out format\n" +msgstr "" + +#: corefile.c:165 +#, c-format +msgid "%s: can't find .text section in %s\n" +msgstr "" + +#: corefile.c:223 +#, c-format +msgid "%s: ran out room for %lu bytes of text space\n" +msgstr "" + +#: corefile.c:237 +#, c-format +msgid "%s: can't do -c\n" +msgstr "" + +#: corefile.c:272 +#, c-format +msgid "%s: -c not supported on architecture %s\n" +msgstr "" + +#: corefile.c:439 +#, c-format +msgid "%s: file `%s' has no symbols\n" +msgstr "" + +#: corefile.c:739 +#, c-format +msgid "%s: somebody miscounted: ltab.len=%d instead of %ld\n" +msgstr "" + +#: gmon_io.c:83 gmon_io.c:137 gmon_io.c:188 gmon_io.c:216 gmon_io.c:386 +#: gmon_io.c:413 gmon_io.c:609 gmon_io.c:634 +#, c-format +msgid "%s: bits per address has unexpected value of %u\n" +msgstr "" + +#: gmon_io.c:252 gmon_io.c:347 +#, c-format +msgid "%s: file too short to be a gmon file\n" +msgstr "" + +#: gmon_io.c:262 gmon_io.c:396 +#, c-format +msgid "%s: file `%s' has bad magic cookie\n" +msgstr "" + +#: gmon_io.c:273 +#, c-format +msgid "%s: file `%s' has unsupported version %d\n" +msgstr "" + +#: gmon_io.c:303 +#, c-format +msgid "%s: %s: found bad tag %d (file corrupted?)\n" +msgstr "" + +#: gmon_io.c:369 +#, c-format +msgid "%s: profiling rate incompatible with first gmon file\n" +msgstr "" + +#: gmon_io.c:429 +#, c-format +msgid "%s: incompatible with first gmon file\n" +msgstr "" + +#: gmon_io.c:457 +#, c-format +msgid "%s: file '%s' does not appear to be in gmon.out format\n" +msgstr "" + +#: gmon_io.c:478 +#, c-format +msgid "%s: unexpected EOF after reading %d/%d bins\n" +msgstr "" + +#: gmon_io.c:511 +msgid "time is in ticks, not seconds\n" +msgstr "" + +#: gmon_io.c:517 gmon_io.c:704 +#, c-format +msgid "%s: don't know how to deal with file format %d\n" +msgstr "" + +#: gmon_io.c:524 +#, c-format +msgid "File `%s' (version %d) contains:\n" +msgstr "" + +#: gmon_io.c:527 +#, c-format +msgid "\t%d histogram record\n" +msgstr "" + +#: gmon_io.c:528 +#, c-format +msgid "\t%d histogram records\n" +msgstr "" + +#: gmon_io.c:530 +#, c-format +msgid "\t%d call-graph record\n" +msgstr "" + +#: gmon_io.c:531 +#, c-format +msgid "\t%d call-graph records\n" +msgstr "" + +#: gmon_io.c:533 +#, c-format +msgid "\t%d basic-block count record\n" +msgstr "" + +#: gmon_io.c:534 +#, c-format +msgid "\t%d basic-block count records\n" +msgstr "" + +#: gprof.c:147 +#, c-format +msgid "" +"Usage: %s [-[abcDhilLsTvwxyz]] [-[ACeEfFJnNOpPqQZ][name]] [-I dirs]\n" +"\t[-d[num]] [-k from/to] [-m min-count] [-t table-length]\n" +"\t[--[no-]annotated-source[=name]] [--[no-]exec-counts[=name]]\n" +"\t[--[no-]flat-profile[=name]] [--[no-]graph[=name]]\n" +"\t[--[no-]time=name] [--all-lines] [--brief] [--debug[=level]]\n" +"\t[--function-ordering] [--file-ordering]\n" +"\t[--directory-path=dirs] [--display-unused-functions]\n" +"\t[--file-format=name] [--file-info] [--help] [--line] [--min-count=n]\n" +"\t[--no-static] [--print-path] [--separate-files]\n" +"\t[--static-call-graph] [--sum] [--table-length=len] [--traditional]\n" +"\t[--version] [--width=n] [--ignore-non-functions]\n" +"\t[--demangle[=STYLE]] [--no-demangle]\n" +"\t[image-file] [profile-file...]\n" +msgstr "" + +#: gprof.c:163 +#, c-format +msgid "Report bugs to %s\n" +msgstr "" + +#: gprof.c:235 +#, c-format +msgid "%s: debugging not supported; -d ignored\n" +msgstr "" + +#: gprof.c:315 +#, c-format +msgid "%s: unknown file format %s\n" +msgstr "" + +#. This output is intended to follow the GNU standards document. +#: gprof.c:399 +#, c-format +msgid "GNU gprof %s\n" +msgstr "" + +#: gprof.c:400 +msgid "" +"Based on BSD gprof, copyright 1983 Regents of the University of California.\n" +msgstr "" + +#: gprof.c:401 +msgid "" +"This program is free software. This program has absolutely no warranty.\n" +msgstr "" + +#: gprof.c:442 +#, c-format +msgid "%s: unknown demangling style `%s'\n" +msgstr "" + +#: gprof.c:462 +#, c-format +msgid "" +"%s: Only one of --function-ordering and --file-ordering may be specified.\n" +msgstr "" + +#: gprof.c:562 +#, c-format +msgid "%s: sorry, file format `prof' is not yet supported\n" +msgstr "" + +#: gprof.c:623 +#, c-format +msgid "%s: gmon.out file is missing histogram\n" +msgstr "" + +#: gprof.c:630 +#, c-format +msgid "%s: gmon.out file is missing call-graph data\n" +msgstr "" + +#: hist.c:122 +#, c-format +msgid "%s: `%s' is incompatible with first gmon file\n" +msgstr "" + +#: hist.c:138 +#, c-format +msgid "%s: %s: unexpected EOF after reading %d of %d samples\n" +msgstr "" + +#: hist.c:351 +#, c-format +msgid "%c%c/call" +msgstr "" + +#: hist.c:359 +#, c-format +msgid "" +" for %.2f%% of %.2f %s\n" +"\n" +msgstr "" + +#: hist.c:365 +#, c-format +msgid "" +"\n" +"Each sample counts as %g %s.\n" +msgstr "" + +#: hist.c:370 +msgid "" +" no time accumulated\n" +"\n" +msgstr "" + +#: hist.c:377 +msgid "cumulative" +msgstr "" + +#: hist.c:377 +msgid "self " +msgstr "" + +#: hist.c:377 +msgid "total " +msgstr "" + +#: hist.c:380 +msgid "time" +msgstr "" + +#: hist.c:380 +msgid "calls" +msgstr "" + +#: hist.c:469 +msgid "" +"\n" +"\n" +"\n" +"flat profile:\n" +msgstr "" + +#: hist.c:475 +msgid "Flat profile:\n" +msgstr "" + +#: mips.c:75 +#, c-format +msgid "[find_call] 0x%lx: jal" +msgstr "" + +#: mips.c:100 +#, c-format +msgid "[find_call] 0x%lx: jalr\n" +msgstr "" + +#: source.c:163 +#, c-format +msgid "%s: could not locate `%s'\n" +msgstr "" + +#: source.c:238 +#, c-format +msgid "*** File %s:\n" +msgstr "" + +#: utils.c:96 +#, c-format +msgid " " +msgstr "" diff --git a/contrib/binutils/include/coff/tic30.h b/contrib/binutils/include/coff/tic30.h index 1b5b5fd..30bf9dc 100644 --- a/contrib/binutils/include/coff/tic30.h +++ b/contrib/binutils/include/coff/tic30.h @@ -16,181 +16,12 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/********************** FILE HEADER **********************/ - -struct external_filehdr { - char f_magic[2]; /* magic number */ - char f_nscns[2]; /* number of sections */ - char f_timdat[4]; /* time & date stamp */ - char f_symptr[4]; /* file pointer to symtab */ - char f_nsyms[4]; /* number of symtab entries */ - char f_opthdr[2]; /* sizeof(optional hdr) */ - char f_flags[2]; /* flags */ -}; - +#define L_LNNO_SIZE 4 +#include "coff/external.h" #define TIC30MAGIC 0xC000 -#define TIC30BADMAG(x) (((x).f_magic!=TIC30MAGIC)) - -#define FILHDR struct external_filehdr -#define FILHSZ 20 - - -/********************** AOUT "OPTIONAL HEADER" **********************/ - - -typedef struct -{ - char magic[2]; /* type of file */ - char vstamp[2]; /* version stamp */ - char tsize[4]; /* text size in bytes, padded to FW bdry*/ - char dsize[4]; /* initialized data " " */ - char bsize[4]; /* uninitialized data " " */ - char entry[4]; /* entry pt. */ - char text_start[4]; /* base of text used for this file */ - char data_start[4]; /* base of data used for this file */ -} -AOUTHDR; - - -#define AOUTHDRSZ 28 -#define AOUTSZ 28 - - - - -/********************** SECTION HEADER **********************/ - - -struct external_scnhdr { - char s_name[8]; /* section name */ - char s_paddr[4]; /* physical address, aliased s_nlib */ - char s_vaddr[4]; /* virtual address */ - char s_size[4]; /* section size */ - char s_scnptr[4]; /* file ptr to raw data for section */ - char s_relptr[4]; /* file ptr to relocation */ - char s_lnnoptr[4]; /* file ptr to line numbers */ - char s_nreloc[2]; /* number of relocation entries */ - char s_nlnno[2]; /* number of line number entries*/ - char s_flags[4]; /* flags */ -}; - -/* - * names of "special" sections - */ -#define _TEXT ".text" -#define _DATA ".data" -#define _BSS ".bss" - - -#define SCNHDR struct external_scnhdr -#define SCNHSZ 40 - - -/********************** LINE NUMBERS **********************/ - -/* 1 line number entry for every "breakpointable" source line in a section. - * Line numbers are grouped on a per function basis; first entry in a function - * grouping will have l_lnno = 0 and in place of physical address will be the - * symbol table index of the function name. - */ -struct external_lineno { - union { - char l_symndx[4]; /* function name symbol index, iff l_lnno == 0*/ - char l_paddr[4]; /* (physical) address of line number */ - } l_addr; - char l_lnno[4]; /* line number */ -}; - -#define GET_LINENO_LNNO(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) (ext->l_lnno)); -#define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_32(abfd,val, (bfd_byte *) (ext->l_lnno)); - -#define LINENO struct external_lineno -#define LINESZ 8 - - -/********************** SYMBOLS **********************/ - -#define E_SYMNMLEN 8 /* # characters in a symbol name */ -#define E_FILNMLEN 14 /* # characters in a file name */ -#define E_DIMNUM 4 /* # array dimensions in auxiliary entry */ - -struct external_syment -{ - union { - char e_name[E_SYMNMLEN]; - struct { - char e_zeroes[4]; - char e_offset[4]; - } e; - } e; - char e_value[4]; - char e_scnum[2]; - char e_type[2]; - char e_sclass[1]; - char e_numaux[1]; -}; - - - -#define N_BTMASK (017) -#define N_TMASK (060) -#define N_BTSHFT (4) -#define N_TSHIFT (2) - - -union external_auxent { - struct { - char x_tagndx[4]; /* str, un, or enum tag indx */ - union { - struct { - char x_lnno[2]; /* declaration line number */ - char x_size[2]; /* str/union/array size */ - } x_lnsz; - char x_fsize[4]; /* size of function */ - } x_misc; - union { - struct { /* if ISFCN, tag, or .bb */ - char x_lnnoptr[4]; /* ptr to fcn line # */ - char x_endndx[4]; /* entry ndx past block end */ - } x_fcn; - struct { /* if ISARY, up to 4 dimen. */ - char x_dimen[E_DIMNUM][2]; - } x_ary; - } x_fcnary; - char x_tvndx[2]; /* tv index */ - } x_sym; - - union { - char x_fname[E_FILNMLEN]; - struct { - char x_zeroes[4]; - char x_offset[4]; - } x_n; - } x_file; - - struct { - char x_scnlen[4]; /* section length */ - char x_nreloc[2]; /* # relocation entries */ - char x_nlinno[2]; /* # line numbers */ - } x_scn; - - struct { - char x_tvfill[4]; /* tv fill value */ - char x_tvlen[2]; /* length of .tv */ - char x_tvran[2][2]; /* tv range */ - } x_tv; /* info about .tv section (in auxent of symbol .tv)) */ - - -}; - -#define SYMENT struct external_syment -#define SYMESZ 18 -#define AUXENT union external_auxent -#define AUXESZ 18 - - +#define TIC30BADMAG(x) (((x).f_magic != TIC30MAGIC)) /********************** RELOCATION DIRECTIVES **********************/ @@ -198,7 +29,8 @@ union external_auxent { types on the z8k don't have room in the instruction for the entire offset - eg with segments */ -struct external_reloc { +struct external_reloc +{ char r_vaddr[4]; char r_symndx[4]; char r_offset[4]; @@ -206,7 +38,6 @@ struct external_reloc { char r_stuff[2]; }; - #define RELOC struct external_reloc #define RELSZ 16 diff --git a/contrib/binutils/include/coff/z8k.h b/contrib/binutils/include/coff/z8k.h index 88db5c4..50cbd6b 100644 --- a/contrib/binutils/include/coff/z8k.h +++ b/contrib/binutils/include/coff/z8k.h @@ -16,194 +16,26 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/********************** FILE HEADER **********************/ - -struct external_filehdr { - char f_magic[2]; /* magic number */ - char f_nscns[2]; /* number of sections */ - char f_timdat[4]; /* time & date stamp */ - char f_symptr[4]; /* file pointer to symtab */ - char f_nsyms[4]; /* number of symtab entries */ - char f_opthdr[2]; /* sizeof(optional hdr) */ - char f_flags[2]; /* flags */ -}; - +#define L_LNNO_SIZE 4 +#include "coff/external.h" /* Type of cpu is stored in flags */ #define F_Z8001 0x1000 #define F_Z8002 0x2000 #define F_MACHMASK 0xf000 -#define Z8KMAGIC 0x8000 - -#define Z8KBADMAG(x) (((x).f_magic!=Z8KMAGIC)) - -#define FILHDR struct external_filehdr -#define FILHSZ 20 - - -/********************** AOUT "OPTIONAL HEADER" **********************/ - - -typedef struct -{ - char magic[2]; /* type of file */ - char vstamp[2]; /* version stamp */ - char tsize[4]; /* text size in bytes, padded to FW bdry*/ - char dsize[4]; /* initialized data " " */ - char bsize[4]; /* uninitialized data " " */ - char entry[4]; /* entry pt. */ - char text_start[4]; /* base of text used for this file */ - char data_start[4]; /* base of data used for this file */ -} -AOUTHDR; - - -#define AOUTHDRSZ 28 -#define AOUTSZ 28 - +#define Z8KMAGIC 0x8000 - - -/********************** SECTION HEADER **********************/ - - -struct external_scnhdr { - char s_name[8]; /* section name */ - char s_paddr[4]; /* physical address, aliased s_nlib */ - char s_vaddr[4]; /* virtual address */ - char s_size[4]; /* section size */ - char s_scnptr[4]; /* file ptr to raw data for section */ - char s_relptr[4]; /* file ptr to relocation */ - char s_lnnoptr[4]; /* file ptr to line numbers */ - char s_nreloc[2]; /* number of relocation entries */ - char s_nlnno[2]; /* number of line number entries*/ - char s_flags[4]; /* flags */ -}; - -/* - * names of "special" sections - */ -#define _TEXT ".text" -#define _DATA ".data" -#define _BSS ".bss" - - -#define SCNHDR struct external_scnhdr -#define SCNHSZ 40 - - -/********************** LINE NUMBERS **********************/ - -/* 1 line number entry for every "breakpointable" source line in a section. - * Line numbers are grouped on a per function basis; first entry in a function - * grouping will have l_lnno = 0 and in place of physical address will be the - * symbol table index of the function name. - */ -struct external_lineno { - union { - char l_symndx[4]; /* function name symbol index, iff l_lnno == 0*/ - char l_paddr[4]; /* (physical) address of line number */ - } l_addr; - char l_lnno[4]; /* line number */ -}; - -#define GET_LINENO_LNNO(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) (ext->l_lnno)); -#define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_32(abfd,val, (bfd_byte *) (ext->l_lnno)); - -#define LINENO struct external_lineno -#define LINESZ 8 - - -/********************** SYMBOLS **********************/ - -#define E_SYMNMLEN 8 /* # characters in a symbol name */ -#define E_FILNMLEN 14 /* # characters in a file name */ -#define E_DIMNUM 4 /* # array dimensions in auxiliary entry */ - -struct external_syment -{ - union { - char e_name[E_SYMNMLEN]; - struct { - char e_zeroes[4]; - char e_offset[4]; - } e; - } e; - char e_value[4]; - char e_scnum[2]; - char e_type[2]; - char e_sclass[1]; - char e_numaux[1]; -}; - - - -#define N_BTMASK (017) -#define N_TMASK (060) -#define N_BTSHFT (4) -#define N_TSHIFT (2) +#define Z8KBADMAG(x) (((x).f_magic != Z8KMAGIC)) - -union external_auxent { - struct { - char x_tagndx[4]; /* str, un, or enum tag indx */ - union { - struct { - char x_lnno[2]; /* declaration line number */ - char x_size[2]; /* str/union/array size */ - } x_lnsz; - char x_fsize[4]; /* size of function */ - } x_misc; - union { - struct { /* if ISFCN, tag, or .bb */ - char x_lnnoptr[4]; /* ptr to fcn line # */ - char x_endndx[4]; /* entry ndx past block end */ - } x_fcn; - struct { /* if ISARY, up to 4 dimen. */ - char x_dimen[E_DIMNUM][2]; - } x_ary; - } x_fcnary; - char x_tvndx[2]; /* tv index */ - } x_sym; - - union { - char x_fname[E_FILNMLEN]; - struct { - char x_zeroes[4]; - char x_offset[4]; - } x_n; - } x_file; - - struct { - char x_scnlen[4]; /* section length */ - char x_nreloc[2]; /* # relocation entries */ - char x_nlinno[2]; /* # line numbers */ - } x_scn; - - struct { - char x_tvfill[4]; /* tv fill value */ - char x_tvlen[2]; /* length of .tv */ - char x_tvran[2][2]; /* tv range */ - } x_tv; /* info about .tv section (in auxent of symbol .tv)) */ - - -}; - -#define SYMENT struct external_syment -#define SYMESZ 18 -#define AUXENT union external_auxent -#define AUXESZ 18 - - - /********************** RELOCATION DIRECTIVES **********************/ /* The external reloc has an offset field, because some of the reloc types on the z8k don't have room in the instruction for the entire - offset - eg with segments */ + offset - eg with segments. */ -struct external_reloc { +struct external_reloc +{ char r_vaddr[4]; char r_symndx[4]; char r_offset[4]; @@ -211,7 +43,6 @@ struct external_reloc { char r_stuff[2]; }; - #define RELOC struct external_reloc #define RELSZ 16 diff --git a/contrib/binutils/ld/ChangeLog b/contrib/binutils/ld/ChangeLog index 6f6e0d3f..21fbd4b 100644 --- a/contrib/binutils/ld/ChangeLog +++ b/contrib/binutils/ld/ChangeLog @@ -1,3 +1,9 @@ +2002-07-07 Alan Modra + + Merge from mainline. + 2002-07-05 Alan Modra + * ldlang.c (print_wild_statement): Fix output formatting. + 2002-05-09 Alan Modra Merge from mainline. diff --git a/contrib/binutils/ld/ldlang.c b/contrib/binutils/ld/ldlang.c index 414a034..9d33248 100644 --- a/contrib/binutils/ld/ldlang.c +++ b/contrib/binutils/ld/ldlang.c @@ -2492,10 +2492,10 @@ print_wild_statement (w, os) if (sec->spec.exclude_name_list != NULL) { name_list *tmp; - minfo ("EXCLUDE_FILE ( %s", sec->spec.exclude_name_list->name); + minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name); for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next) - minfo (", %s", tmp->name); - minfo (")"); + minfo (" %s", tmp->name); + minfo (") "); } if (sec->spec.name != NULL) minfo ("%s", sec->spec.name); @@ -2503,6 +2503,8 @@ print_wild_statement (w, os) minfo ("*"); if (sec->spec.sorted) minfo (")"); + if (sec->next) + minfo (" "); } minfo (")"); -- cgit v1.1