/* Renesas / SuperH SH specific support for 32-bit ELF
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1996-2020 Free Software Foundation, Inc.
Contributed by Ian Lance Taylor, Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
#include "libiberty.h"
#include "../opcodes/sh-opc.h"
+/* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
+#define OCTETS_PER_BYTE(ABFD, SEC) 1
+
static bfd_reloc_status_type sh_elf_reloc
(bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
static bfd_reloc_status_type sh_elf_ignore_reloc
(bfd *, asection *, bfd_vma, int);
static bfd_boolean sh_elf_align_loads
(bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
-#ifndef SH64_ELF
static bfd_boolean sh_elf_swap_insns
(bfd *, asection *, void *, bfd_byte *, bfd_vma);
-#endif
static int sh_elf_optimized_tls_reloc
(struct bfd_link_info *, int, int);
static bfd_vma dtpoff_base
static bfd_boolean
vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
{
-#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
- extern const bfd_target bfd_elf32_shlvxworks_vec;
- extern const bfd_target bfd_elf32_shvxworks_vec;
+#if !defined SH_TARGET_ALREADY_DEFINED
+ extern const bfd_target sh_elf32_vxworks_le_vec;
+ extern const bfd_target sh_elf32_vxworks_vec;
- return (abfd->xvec == &bfd_elf32_shlvxworks_vec
- || abfd->xvec == &bfd_elf32_shvxworks_vec);
+ return (abfd->xvec == &sh_elf32_vxworks_le_vec
+ || abfd->xvec == &sh_elf32_vxworks_vec);
#else
return FALSE;
#endif
static bfd_boolean
fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
{
-#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
- extern const bfd_target bfd_elf32_shfd_vec;
- extern const bfd_target bfd_elf32_shbfd_vec;
+#if !defined SH_TARGET_ALREADY_DEFINED
+ extern const bfd_target sh_elf32_fdpic_le_vec;
+ extern const bfd_target sh_elf32_fdpic_be_vec;
- return (abfd->xvec == &bfd_elf32_shfd_vec
- || abfd->xvec == &bfd_elf32_shbfd_vec);
+ return (abfd->xvec == &sh_elf32_fdpic_le_vec
+ || abfd->xvec == &sh_elf32_fdpic_be_vec);
#else
return FALSE;
#endif
if (!bfd_malloc_and_get_section (input_bfd, symbol_section,
&contents))
{
- if (contents != NULL)
- free (contents);
+ free (contents);
return bfd_reloc_outofrange;
}
}
end = start0;
}
- if (contents != NULL
- && elf_section_data (symbol_section)->this_hdr.contents != contents)
+ if (elf_section_data (symbol_section)->this_hdr.contents != contents)
free (contents);
insn = bfd_get_16 (input_bfd, contents + addr);
void *data, asection *input_section, bfd *output_bfd,
char **error_message ATTRIBUTE_UNUSED)
{
- unsigned long insn;
+ bfd_vma 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;
+ bfd_size_type octets = addr * OCTETS_PER_BYTE (abfd, input_section);
+ bfd_byte *hit_data = (bfd_byte *) data + octets;
r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
&& bfd_is_und_section (symbol_in->section))
return bfd_reloc_undefined;
+ /* PR 17512: file: 9891ca98. */
+ if (octets + bfd_get_reloc_size (reloc_entry->howto)
+ > bfd_get_section_limit_octets (abfd, input_section))
+ return bfd_reloc_outofrange;
+
if (bfd_is_com_section (symbol_in->section))
sym_value = 0;
else
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);
+ bfd_put_32 (abfd, insn, hit_data);
break;
case R_SH_IND12W:
insn = bfd_get_16 (abfd, hit_data);
+ 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)
+ sym_value += (((insn & 0xfff) ^ 0x800) - 0x800) << 1;
+ insn = (insn & 0xf000) | ((sym_value >> 1) & 0xfff);
+ bfd_put_16 (abfd, insn, hit_data);
+ if (sym_value + 0x1000 >= 0x2000 || (sym_value & 1) != 0)
return bfd_reloc_overflow;
break;
default:
{ BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC },
{ BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 },
{ BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC },
-#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
/* Given an ELF reloc, fill in the howto field of a relent. */
-static void
+static bfd_boolean
sh_elf_info_to_howto (bfd *abfd, 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);
- BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
- BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_6 || r > R_SH_LAST_INVALID_RELOC_6);
+ if (r >= R_SH_max
+ || (r >= R_SH_FIRST_INVALID_RELOC && r <= R_SH_LAST_INVALID_RELOC)
+ || (r >= R_SH_FIRST_INVALID_RELOC_2 && r <= R_SH_LAST_INVALID_RELOC_2)
+ || (r >= R_SH_FIRST_INVALID_RELOC_3 && r <= R_SH_LAST_INVALID_RELOC_3)
+ || (r >= R_SH_FIRST_INVALID_RELOC_4 && r <= R_SH_LAST_INVALID_RELOC_4)
+ || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)
+ || (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
cache_ptr->howto = get_howto_table (abfd) + r;
+ return TRUE;
}
\f
/* This function handles relaxing for SH ELF. See the corresponding
*again = FALSE;
- if (link_info->relocatable
+ if (bfd_link_relocatable (link_info)
|| (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
-
symtab_hdr = &elf_symtab_hdr (abfd);
internal_relocs = (_bfd_elf_link_read_relocs
laddr = irel->r_offset + 4 + irel->r_addend;
if (laddr >= sec->size)
{
- (*_bfd_error_handler) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
- abfd,
- (unsigned long) irel->r_offset);
+ /* xgettext:c-format */
+ _bfd_error_handler
+ (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES offset"),
+ abfd, (uint64_t) irel->r_offset);
continue;
}
insn = bfd_get_16 (abfd, contents + laddr);
do. */
if ((insn & 0xf000) != 0xd000)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
- abfd, (unsigned long) irel->r_offset, insn));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": warning: "
+ "R_SH_USES points to unrecognized insn 0x%x"),
+ abfd, (uint64_t) irel->r_offset, insn);
continue;
}
paddr += (laddr + 4) &~ (bfd_vma) 3;
if (paddr >= sec->size)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES load offset"),
+ abfd, (uint64_t) irel->r_offset);
continue;
}
break;
if (irelfn >= irelend)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: could not find expected reloc"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": warning: could not find expected reloc"),
+ abfd, (uint64_t) paddr);
continue;
}
if (isym->st_shndx
!= (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: symbol in unexpected section"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": warning: symbol in unexpected section"),
+ abfd, (uint64_t) paddr);
continue;
}
elf_section_data (sec)->this_hdr.contents = contents;
symtab_hdr->contents = (unsigned char *) isymbuf;
- /* Replace the jsr with a bsr. */
+ /* Replace the jmp/jsr with a bra/bsr. */
/* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
- replace the jsr with a bsr. */
+ replace the jmp/jsr with a bra/bsr. */
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
/* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
here, but that only checks if the symbol is an external symbol,
/* 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);
+ if (bfd_get_16 (abfd, contents + irel->r_offset) & 0x0020)
+ bfd_put_16 (abfd, (bfd_vma) 0xa000, contents + irel->r_offset);
+ else
+ bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
irel->r_addend = -4;
/* Now check whether we got a COUNT reloc. */
if (irelcount >= irelend)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": warning: "
+ "could not find expected COUNT reloc"),
+ abfd, (uint64_t) paddr);
continue;
}
just deleted one. */
if (irelcount->r_addend == 0)
{
- ((*_bfd_error_handler) (_("%B: 0x%lx: warning: bad count"),
- abfd,
- (unsigned long) paddr));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: %#" PRIx64 ": warning: bad count"),
+ abfd, (uint64_t) paddr);
continue;
}
}
}
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
+ if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
return TRUE;
error_return:
- if (isymbuf != NULL
- && symtab_hdr->contents != (unsigned char *) isymbuf)
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (contents != NULL
- && elf_section_data (sec)->this_hdr.contents != contents)
+ if (elf_section_data (sec)->this_hdr.contents != contents)
free (contents);
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
+ if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
return FALSE;
contents = elf_section_data (sec)->this_hdr.contents;
- /* The deletion must stop at the next ALIGN reloc for an aligment
+ /* The deletion must stop at the next ALIGN reloc for an alignment
power larger than the number of bytes we are deleting. */
irelalign = NULL;
if (overflow)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
+ abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
when we leave sh_coff_relax_section. */
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
{
- if (ocontents != NULL)
- free (ocontents);
+ free (ocontents);
return FALSE;
}
when we leave sh_coff_relax_section. */
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
{
- if (ocontents != NULL)
- free (ocontents);
+ free (ocontents);
return FALSE;
}
return TRUE;
error_return:
- if (labels != NULL)
- free (labels);
+ free (labels);
return FALSE;
}
-#ifndef SH64_ELF
/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
static bfd_boolean
if (overflow)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
+ abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
return TRUE;
}
-#endif /* defined SH64_ELF */
\f
/* Describes one of the various PLT styles. */
const struct elf_sh_plt_info *short_plt;
};
-#ifdef INCLUDE_SHMEDIA
-
-/* The size in bytes of an entry in the procedure linkage table. */
-
-#define ELF_PLT_ENTRY_SIZE 64
-
-/* First entry in an absolute procedure linkage table look like this. */
-
-static const bfd_byte elf_sh_plt0_entry_be[ELF_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, 0x66, 0x00, /* ptabs r25, 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[ELF_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, 0x66, 0xf1, 0x6b, /* ptabs r25, 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[ELF_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[ELF_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[ELF_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, 0xc8, 0x45, 0x10, /* add.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[ELF_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, 0xc8, 0x00, /* add.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 struct elf_sh_plt_info elf_sh_plts[2][2] = {
- {
- {
- /* Big-endian non-PIC. */
- elf_sh_plt0_entry_be,
- ELF_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, MINUS_ONE },
- elf_sh_plt_entry_be,
- ELF_PLT_ENTRY_SIZE,
- { 0, 32, 48, FALSE },
- 33, /* includes ISA encoding */
- NULL
- },
- {
- /* Little-endian non-PIC. */
- elf_sh_plt0_entry_le,
- ELF_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, MINUS_ONE },
- elf_sh_plt_entry_le,
- ELF_PLT_ENTRY_SIZE,
- { 0, 32, 48, FALSE },
- 33, /* includes ISA encoding */
- NULL
- },
- },
- {
- {
- /* Big-endian PIC. */
- elf_sh_plt0_entry_be,
- ELF_PLT_ENTRY_SIZE,
- { MINUS_ONE, MINUS_ONE, MINUS_ONE },
- elf_sh_pic_plt_entry_be,
- ELF_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, 52, FALSE },
- 33, /* includes ISA encoding */
- NULL
- },
- {
- /* Little-endian PIC. */
- elf_sh_plt0_entry_le,
- ELF_PLT_ENTRY_SIZE,
- { MINUS_ONE, MINUS_ONE, MINUS_ONE },
- elf_sh_pic_plt_entry_le,
- ELF_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, 52, FALSE },
- 33, /* includes ISA encoding */
- NULL
- },
- }
-};
-
-/* Return offset of the linker in PLT0 entry. */
-#define elf_sh_plt0_gotplt_offset(info) 0
-
-/* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
- VALUE is the field's value and CODE_P is true if VALUE refers to code,
- not data.
-
- On SH64, each 32-bit field is loaded by a movi/shori pair. */
-
-inline static void
-install_plt_field (bfd *output_bfd, bfd_boolean code_p,
- unsigned long value, bfd_byte *addr)
-{
- value |= code_p;
- 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);
-}
-
-/* Return the type of PLT associated with ABFD. PIC_P is true if
- the object is position-independent. */
-
-static const struct elf_sh_plt_info *
-get_plt_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean pic_p)
-{
- return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
-}
-#else
/* The size in bytes of an entry in the procedure linkage table. */
#define ELF_PLT_ENTRY_SIZE 28
{
bfd_put_32 (output_bfd, value, addr);
}
-#endif
/* The number of PLT entries which can use a shorter PLT, if any.
Currently always 64K, since only SH-2A FDPIC uses this; a
+ (plt_index * info->symbol_entry_size));
}
-/* The sh linker needs to keep track of the number of relocs that it
- decides to copy as dynamic relocs in check_relocs for each symbol.
- This is so that it can later discard them if they are found to be
- unnecessary. We store the information in a field extending the
- regular ELF linker hash table. */
-
-struct elf_sh_dyn_relocs
-{
- struct elf_sh_dyn_relocs *next;
-
- /* The input section of the reloc. */
- asection *sec;
-
- /* Total number of relocs copied for the input section. */
- bfd_size_type count;
-
- /* Number of pc-relative relocs copied for the input section. */
- bfd_size_type pc_count;
-};
-
union gotref
{
bfd_signed_vma refcount;
{
struct elf_link_hash_entry root;
-#ifdef INCLUDE_SHMEDIA
- union
- {
- bfd_signed_vma refcount;
- bfd_vma offset;
- } datalabel_got;
-#endif
-
- /* Track dynamic relocs copied for this symbol. */
- struct elf_sh_dyn_relocs *dyn_relocs;
-
bfd_signed_vma gotplt_refcount;
/* A local function descriptor, for FDPIC. The refcount counts
and thus require fixups or relocations. */
bfd_signed_vma abs_funcdesc_refcount;
- enum {
+ enum got_type {
GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC
} got_type;
};
struct elf_link_hash_table root;
/* Short-cuts to get to dynamic linker sections. */
- asection *sgot;
- asection *sgotplt;
- asection *srelgot;
- asection *splt;
- asection *srelplt;
asection *sdynbss;
asection *srelbss;
asection *sfuncdesc;
table, string));
if (ret != (struct elf_sh_link_hash_entry *) NULL)
{
- ret->dyn_relocs = NULL;
ret->gotplt_refcount = 0;
-#ifdef INCLUDE_SHMEDIA
- ret->datalabel_got.refcount = ret->root.got.refcount;
-#endif
ret->funcdesc.refcount = 0;
ret->abs_funcdesc_refcount = 0;
ret->got_type = GOT_UNKNOWN;
sh_elf_link_hash_table_create (bfd *abfd)
{
struct elf_sh_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
+ size_t amt = sizeof (struct elf_sh_link_hash_table);
- ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
+ ret = (struct elf_sh_link_hash_table *) bfd_zmalloc (amt);
if (ret == (struct elf_sh_link_hash_table *) NULL)
return NULL;
return NULL;
}
- ret->sgot = NULL;
- ret->sgotplt = NULL;
- ret->srelgot = NULL;
- ret->splt = NULL;
- ret->srelplt = NULL;
- ret->sdynbss = NULL;
- ret->srelbss = NULL;
- ret->srelplt2 = NULL;
- ret->sym_cache.abfd = NULL;
- ret->tls_ldm_got.refcount = 0;
- ret->plt_info = NULL;
ret->vxworks_p = vxworks_object_p (abfd);
ret->fdpic_p = fdpic_object_p (abfd);
if (htab == NULL)
return FALSE;
- htab->sgot = bfd_get_section_by_name (dynobj, ".got");
- htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
- htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
- if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
- abort ();
-
- htab->sfuncdesc = bfd_make_section_with_flags (dynobj, ".got.funcdesc",
- (SEC_ALLOC | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED));
+ htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
+ (SEC_ALLOC | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED));
if (htab->sfuncdesc == NULL
- || ! bfd_set_section_alignment (dynobj, htab->sfuncdesc, 2))
+ || !bfd_set_section_alignment (htab->sfuncdesc, 2))
return FALSE;
- htab->srelfuncdesc = bfd_make_section_with_flags (dynobj,
- ".rela.got.funcdesc",
- (SEC_ALLOC | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
+ htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
+ ".rela.got.funcdesc",
+ (SEC_ALLOC | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED
+ | SEC_READONLY));
if (htab->srelfuncdesc == NULL
- || ! bfd_set_section_alignment (dynobj, htab->srelfuncdesc, 2))
+ || !bfd_set_section_alignment (htab->srelfuncdesc, 2))
return FALSE;
/* Also create .rofixup. */
- htab->srofixup = bfd_make_section_with_flags (dynobj, ".rofixup",
- (SEC_ALLOC | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
+ htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
+ (SEC_ALLOC | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED
+ | SEC_READONLY));
if (htab->srofixup == NULL
- || ! bfd_set_section_alignment (dynobj, htab->srofixup, 2))
+ || !bfd_set_section_alignment (htab->srofixup, 2))
return FALSE;
return TRUE;
if (bed->plt_readonly)
pltflags |= SEC_READONLY;
- s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
- htab->splt = s;
+ s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
+ htab->root.splt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+ || !bfd_set_section_alignment (s, bed->plt_alignment))
return FALSE;
if (bed->want_plt_sym)
h->type = STT_OBJECT;
htab->root.hplt = h;
- if (info->shared
+ if (bfd_link_pic (info)
&& ! bfd_elf_link_record_dynamic_symbol (info, h))
return FALSE;
}
- s = bfd_make_section_with_flags (abfd,
- bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
- flags | SEC_READONLY);
- htab->srelplt = s;
+ s = bfd_make_section_anyway_with_flags (abfd,
+ bed->default_use_rela_p
+ ? ".rela.plt" : ".rel.plt",
+ flags | SEC_READONLY);
+ htab->root.srelplt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
- if (htab->sgot == NULL
+ if (htab->root.sgot == NULL
&& !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);
- if (bfd_get_section_by_name (abfd, secname))
- continue;
- s = bfd_make_section_with_flags (abfd, relname,
- flags | SEC_READONLY);
- if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
- }
- }
-
if (bed->want_dynbss)
{
/* The .dynbss section is a place to put symbols which are defined
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_with_flags (abfd, ".dynbss",
- SEC_ALLOC | SEC_LINKER_CREATED);
+ s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
+ SEC_ALLOC | SEC_LINKER_CREATED);
htab->sdynbss = s;
if (s == NULL)
return FALSE;
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)
+ if (! bfd_link_pic (info))
{
- s = bfd_make_section_with_flags (abfd,
- (bed->default_use_rela_p
- ? ".rela.bss" : ".rel.bss"),
- flags | SEC_READONLY);
+ s = bfd_make_section_anyway_with_flags (abfd,
+ (bed->default_use_rela_p
+ ? ".rela.bss" : ".rel.bss"),
+ flags | SEC_READONLY);
htab->srelbss = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
}
}
struct elf_link_hash_entry *h)
{
struct elf_sh_link_hash_table *htab;
- struct elf_sh_link_hash_entry *eh;
- struct elf_sh_dyn_relocs *p;
asection *s;
htab = sh_elf_hash_table (info);
/* Make sure we know what is going on here. */
BFD_ASSERT (htab->root.dynobj != NULL
&& (h->needs_plt
- || h->u.weakdef != NULL
+ || h->is_weakalias
|| (h->def_dynamic
&& h->ref_regular
&& !h->def_regular)));
/* 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->u.weakdef != NULL)
+ if (h->is_weakalias)
{
- BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
- || h->u.weakdef->root.type == bfd_link_hash_defweak);
- h->root.u.def.section = h->u.weakdef->root.u.def.section;
- h->root.u.def.value = h->u.weakdef->root.u.def.value;
+ struct elf_link_hash_entry *def = weakdef (h);
+ BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+ h->root.u.def.section = def->root.u.def.section;
+ h->root.u.def.value = def->root.u.def.value;
if (info->nocopyreloc)
- h->non_got_ref = h->u.weakdef->non_got_ref;
+ h->non_got_ref = def->non_got_ref;
return TRUE;
}
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)
+ if (bfd_link_pic (info))
return TRUE;
/* If there are no references to this symbol that do not use the
return TRUE;
/* If -z nocopyreloc was given, we won't generate them either. */
- if (info->nocopyreloc)
+ if (0 && info->nocopyreloc)
{
h->non_got_ref = 0;
return TRUE;
}
- eh = (struct elf_sh_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- s = p->sec->output_section;
- if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
- break;
- }
-
- /* If we didn't find any dynamic relocs in sections which needs the
- copy reloc, then we'll be keeping the dynamic relocs and avoiding
- the copy reloc. */
- if (p == NULL)
+ /* If we don't find any dynamic relocs in read-only sections, then
+ we'll be keeping the dynamic relocs and avoiding the copy reloc. */
+ if (0 && !_bfd_elf_readonly_dynrelocs (h))
{
h->non_got_ref = 0;
return TRUE;
}
- if (h->size == 0)
- {
- (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
- h->root.root.string);
- 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
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)
+ if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
{
asection *srel;
h->needs_copy = 1;
}
- return _bfd_elf_adjust_dynamic_copy (h, s);
+ return _bfd_elf_adjust_dynamic_copy (info, h, s);
}
/* Allocate space in .plt, .got and associated reloc sections for
struct bfd_link_info *info;
struct elf_sh_link_hash_table *htab;
struct elf_sh_link_hash_entry *eh;
- struct elf_sh_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
- if (h->root.type == bfd_link_hash_warning)
- /* When warning symbols are created, they **replace** the "real"
- entry in the hash table, thus we never get to see the real
- symbol in a hash traversal. So look at it now. */
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
info = (struct bfd_link_info *) inf;
htab = sh_elf_hash_table (info);
if (htab == NULL)
return FALSE;
}
- if (info->shared
+ if (bfd_link_pic (info)
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
{
- asection *s = htab->splt;
+ asection *s = htab->root.splt;
const struct elf_sh_plt_info *plt_info;
/* If this is the first .plt entry, make room for the special
the shared library. Skip this for FDPIC, since the
function's address will be the address of the canonical
function descriptor. */
- if (!htab->fdpic_p && !info->shared && !h->def_regular)
+ if (!htab->fdpic_p && !bfd_link_pic (info) && !h->def_regular)
{
h->root.u.def.section = s;
h->root.u.def.value = h->plt.offset;
/* We also need to make an entry in the .got.plt section, which
will be placed in the .got section by the linker script. */
if (!htab->fdpic_p)
- htab->sgotplt->size += 4;
+ htab->root.sgotplt->size += 4;
else
- htab->sgotplt->size += 8;
+ htab->root.sgotplt->size += 8;
/* We also need to make an entry in the .rel.plt section. */
- htab->srelplt->size += sizeof (Elf32_External_Rela);
+ htab->root.srelplt->size += sizeof (Elf32_External_Rela);
- if (htab->vxworks_p && !info->shared)
+ if (htab->vxworks_p && !bfd_link_pic (info))
{
/* VxWorks executables have a second set of relocations
for each PLT entry. They go in a separate relocation
{
asection *s;
bfd_boolean dyn;
- int got_type = sh_elf_hash_entry (h)->got_type;
+ enum got_type got_type = sh_elf_hash_entry (h)->got_type;
/* Make sure this symbol is output as a dynamic symbol.
Undefined weak syms won't yet be marked as dynamic. */
return FALSE;
}
- s = htab->sgot;
+ s = htab->root.sgot;
h->got.offset = s->size;
s->size += 4;
/* R_SH_TLS_GD needs 2 consecutive GOT slots. */
if (!dyn)
{
/* No dynamic relocations required. */
- if (htab->fdpic_p && !info->shared
+ if (htab->fdpic_p && !bfd_link_pic (info)
&& h->root.type != bfd_link_hash_undefweak
&& (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
htab->srofixup->size += 4;
}
+ /* No dynamic relocations required when IE->LE conversion happens. */
+ else if (got_type == GOT_TLS_IE
+ && !h->def_dynamic
+ && !bfd_link_pic (info))
+ ;
/* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
R_SH_TLS_GD needs one if local symbol and two if global. */
else if ((got_type == GOT_TLS_GD && h->dynindx == -1)
|| got_type == GOT_TLS_IE)
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ htab->root.srelgot->size += sizeof (Elf32_External_Rela);
else if (got_type == GOT_TLS_GD)
- htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
+ htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela);
else if (got_type == GOT_FUNCDESC)
{
- if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
+ if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
htab->srofixup->size += 4;
else
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ htab->root.srelgot->size += sizeof (Elf32_External_Rela);
}
else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
- && (info->shared
+ && (bfd_link_pic (info)
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
- htab->srelgot->size += sizeof (Elf32_External_Rela);
- else if (htab->fdpic_p && !info->shared && got_type == GOT_NORMAL
+ htab->root.srelgot->size += sizeof (Elf32_External_Rela);
+ else if (htab->fdpic_p
+ && !bfd_link_pic (info)
+ && got_type == GOT_NORMAL
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak))
htab->srofixup->size += 4;
else
h->got.offset = (bfd_vma) -1;
-#ifdef INCLUDE_SHMEDIA
- if (eh->datalabel_got.refcount > 0)
- {
- asection *s;
- bfd_boolean dyn;
-
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
-
- s = htab->sgot;
- eh->datalabel_got.offset = s->size;
- s->size += 4;
- dyn = htab->root.dynamic_sections_created;
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
- htab->srelgot->size += sizeof (Elf32_External_Rela);
- }
- else
- eh->datalabel_got.offset = (bfd_vma) -1;
-#endif
-
/* Allocate space for any dynamic relocations to function
descriptors, canonical or otherwise. We need to relocate the
reference unless it resolves to zero, which only happens for
|| (htab->root.dynamic_sections_created
&& ! SYMBOL_CALLS_LOCAL (info, h))))
{
- if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
+ if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
else
- htab->srelgot->size
+ htab->root.srelgot->size
+= eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
}
/* We will need a relocation or two fixups to initialize the
function descriptor, so allocate those too. */
- if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
+ if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
htab->srofixup->size += 8;
else
htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
}
- if (eh->dyn_relocs == NULL)
+ if (h->dyn_relocs == NULL)
return TRUE;
/* In the shared -Bsymbolic case, discard space allocated for
space for pc-relative relocs that have become local due to symbol
visibility changes. */
- if (info->shared)
+ if (bfd_link_pic (info))
{
if (SYMBOL_CALLS_LOCAL (info, h))
{
- struct elf_sh_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+ for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
{
p->count -= p->pc_count;
p->pc_count = 0;
if (htab->vxworks_p)
{
- struct elf_sh_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+ for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
{
if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
*pp = p->next;
/* Also discard relocs on undefined weak syms with non-default
visibility. */
- if (eh->dyn_relocs != NULL
+ if (h->dyn_relocs != NULL
&& h->root.type == bfd_link_hash_undefweak)
{
- if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
- eh->dyn_relocs = NULL;
+ if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ h->dyn_relocs = NULL;
/* Make sure undefined weak symbols are output as a dynamic
symbol in PIEs. */
goto keep;
}
- eh->dyn_relocs = NULL;
+ h->dyn_relocs = NULL;
keep: ;
}
/* Finally, allocate space. */
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ for (p = h->dyn_relocs; p != NULL; p = p->next)
{
asection *sreloc = elf_section_data (p->sec)->sreloc;
sreloc->size += p->count * sizeof (Elf32_External_Rela);
/* If we need relocations, we do not need fixups. */
- if (htab->fdpic_p && !info->shared)
+ if (htab->fdpic_p && !bfd_link_pic (info))
htab->srofixup->size -= 4 * (p->count - p->pc_count);
}
return TRUE;
}
-/* Find any dynamic relocs that apply to read-only sections. */
-
-static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
-{
- struct elf_sh_link_hash_entry *eh;
- struct elf_sh_dyn_relocs *p;
-
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
- eh = (struct elf_sh_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- asection *s = p->sec->output_section;
-
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) inf;
-
- info->flags |= DF_TEXTREL;
-
- /* Not an error, just cut short the traversal. */
- return FALSE;
- }
- }
- return TRUE;
-}
-
/* This function is called after all the input files have been read,
and the input sections have been assigned to output sections.
It's a convenient place to determine the PLT style. */
static bfd_boolean
sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
{
- sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd, info->shared);
-
- if (sh_elf_hash_table (info)->fdpic_p && !info->relocatable)
- {
- struct elf_link_hash_entry *h;
-
- /* Force a PT_GNU_STACK segment to be created. */
- if (! elf_tdata (output_bfd)->stack_flags)
- elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
-
- /* Define __stacksize if it's not defined yet. */
- h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
- FALSE, FALSE, FALSE);
- if (! h || h->root.type != bfd_link_hash_defined
- || h->type != STT_OBJECT
- || !h->def_regular)
- {
- struct bfd_link_hash_entry *bh = NULL;
-
- if (!(_bfd_generic_link_add_one_symbol
- (info, output_bfd, "__stacksize",
- BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
- (const char *) NULL, FALSE,
- get_elf_backend_data (output_bfd)->collect, &bh)))
- return FALSE;
-
- h = (struct elf_link_hash_entry *) bh;
- h->def_regular = 1;
- h->type = STT_OBJECT;
- }
- }
- return TRUE;
-}
-
-#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
-
-static bfd_boolean
-sh_elf_modify_program_headers (bfd *output_bfd, struct bfd_link_info *info)
-{
- struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
- struct elf_segment_map *m;
- Elf_Internal_Phdr *p;
-
- /* objcopy and strip preserve what's already there using
- sh_elf_copy_private_bfd_data (). */
- if (! info)
- return TRUE;
-
- for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
- if (m->p_type == PT_GNU_STACK)
- break;
-
- if (m)
- {
- struct elf_link_hash_entry *h;
-
- /* Obtain the pointer to the __stacksize symbol. */
- h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
- FALSE, FALSE, FALSE);
- if (h)
- {
- 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;
- BFD_ASSERT (h->root.type == bfd_link_hash_defined);
- }
-
- /* Set the header p_memsz from the symbol value. We
- intentionally ignore the symbol section. */
- if (h && h->root.type == bfd_link_hash_defined)
- p->p_memsz = h->root.u.def.value;
- else
- p->p_memsz = DEFAULT_STACK_SIZE;
-
- p->p_align = 8;
- }
+ sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd,
+ bfd_link_pic (info));
+ if (sh_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info)
+ && !bfd_elf_stack_segment_size (output_bfd, info,
+ "__stacksize", DEFAULT_STACK_SIZE))
+ return FALSE;
return TRUE;
}
-#endif
-
/* Set the sizes of the dynamic sections. */
static bfd_boolean
if (htab->root.dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info) && !info->nointerp)
{
- s = bfd_get_section_by_name (dynobj, ".interp");
+ s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
s->size = sizeof ELF_DYNAMIC_INTERPRETER;
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
/* Set up .got offsets for local syms, and space for local dynamic
relocs. */
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
bfd_signed_vma *local_got;
bfd_signed_vma *end_local_got;
for (s = ibfd->sections; s != NULL; s = s->next)
{
- struct elf_sh_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
- for (p = ((struct elf_sh_dyn_relocs *)
+ for (p = ((struct elf_dyn_relocs *)
elf_section_data (s)->local_dynrel);
p != NULL;
p = p->next)
srel = elf_section_data (p->sec)->sreloc;
srel->size += p->count * sizeof (Elf32_External_Rela);
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
- info->flags |= DF_TEXTREL;
+ {
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
+ p->sec->owner, p->sec);
+ }
/* If we need relocations, we do not need fixups. */
- if (htab->fdpic_p && !info->shared)
+ if (htab->fdpic_p && !bfd_link_pic (info))
htab->srofixup->size -= 4 * (p->count - p->pc_count);
}
}
symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
-#ifdef INCLUDE_SHMEDIA
- /* Count datalabel local GOT. */
- locsymcount *= 2;
-#endif
- s = htab->sgot;
- srel = htab->srelgot;
+ s = htab->root.sgot;
+ srel = htab->root.srelgot;
local_got = elf_local_got_refcounts (ibfd);
if (local_got)
s->size += 4;
if (*local_got_type == GOT_TLS_GD)
s->size += 4;
- if (info->shared)
+ if (bfd_link_pic (info))
srel->size += sizeof (Elf32_External_Rela);
else
htab->srofixup->size += 4;
{
local_funcdesc->offset = htab->sfuncdesc->size;
htab->sfuncdesc->size += 8;
- if (!info->shared)
+ if (!bfd_link_pic (info))
htab->srofixup->size += 8;
else
htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
{
/* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
relocs. */
- htab->tls_ldm_got.offset = htab->sgot->size;
- htab->sgot->size += 8;
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ htab->tls_ldm_got.offset = htab->root.sgot->size;
+ htab->root.sgot->size += 8;
+ htab->root.srelgot->size += sizeof (Elf32_External_Rela);
}
else
htab->tls_ldm_got.offset = -1;
the end of .got.plt. */
if (htab->fdpic_p)
{
- BFD_ASSERT (htab->sgotplt && htab->sgotplt->size == 12);
- htab->sgotplt->size = 0;
+ BFD_ASSERT (htab->root.sgotplt && htab->root.sgotplt->size == 12);
+ htab->root.sgotplt->size = 0;
}
/* Allocate global sym .plt and .got entries, and space for global
end of the FDPIC .got.plt. */
if (htab->fdpic_p)
{
- htab->root.hgot->root.u.def.value = htab->sgotplt->size;
- htab->sgotplt->size += 12;
+ htab->root.hgot->root.u.def.value = htab->root.sgotplt->size;
+ htab->root.sgotplt->size += 12;
}
/* At the very end of the .rofixup section is a pointer to the GOT. */
if ((s->flags & SEC_LINKER_CREATED) == 0)
continue;
- if (s == htab->splt
- || s == htab->sgot
- || s == htab->sgotplt
+ if (s == htab->root.splt
+ || s == htab->root.sgot
+ || s == htab->root.sgotplt
|| s == htab->sfuncdesc
|| s == htab->srofixup
|| s == htab->sdynbss)
/* Strip this section if we don't need it; see the
comment below. */
}
- else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
+ else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
{
- if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
+ if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2)
relocs = TRUE;
/* We use the reloc_count field as a counter if we need
#define add_dynamic_entry(TAG, VAL) \
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
- if (info->executable)
+ if (bfd_link_executable (info))
{
if (! add_dynamic_entry (DT_DEBUG, 0))
return FALSE;
}
- if (htab->splt->size != 0)
+ if (htab->root.splt->size != 0)
{
if (! add_dynamic_entry (DT_PLTGOT, 0)
|| ! add_dynamic_entry (DT_PLTRELSZ, 0)
|| ! add_dynamic_entry (DT_JMPREL, 0))
return FALSE;
}
- else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC)
- && htab->sgot->size != 0)
+ else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC))
{
if (! add_dynamic_entry (DT_PLTGOT, 0))
return FALSE;
/* If any dynamic relocs apply to a read-only section,
then we need a DT_TEXTREL entry. */
if ((info->flags & DF_TEXTREL) == 0)
- elf_link_hash_traverse (&htab->root, readonly_dynrelocs, info);
+ elf_link_hash_traverse (&htab->root,
+ _bfd_elf_maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
static bfd_signed_vma
sh_elf_got_offset (struct elf_sh_link_hash_table *htab)
{
- return (htab->sgot->output_offset - htab->sgotplt->output_offset
+ return (htab->root.sgot->output_offset - htab->root.sgotplt->output_offset
- htab->root.hgot->root.u.def.value);
}
static unsigned
sh_elf_osec_to_segment (bfd *output_bfd, asection *osec)
{
- Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd,
- osec);
+ Elf_Internal_Phdr *p = NULL;
+
+ if (output_bfd->xvec->flavour == bfd_target_elf_flavour
+ /* PR ld/17110: Do not look for output segments in an input bfd. */
+ && output_bfd->direction != read_direction)
+ p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
/* FIXME: Nothing ever says what this index is relative to. The kernel
supplies data in terms of the number of load segments but this is
{
unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
- return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
+ return (seg != (unsigned) -1
+ && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W));
}
/* Generate the initial contents of a local function descriptor, along
addr = seg = 0;
}
- if (!info->shared && SYMBOL_CALLS_LOCAL (info, h))
+ if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
{
if (h == NULL || h->root.type != bfd_link_hash_undefweak)
{
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;
- asection *srelgot;
+ asection *sgot = NULL;
+ asection *sgotplt = NULL;
+ asection *splt = NULL;
+ asection *sreloc = NULL;
+ asection *srelgot = NULL;
bfd_boolean is_vxworks_tls;
unsigned isec_segment, got_segment, plt_segment, check_segment[2];
+ bfd_boolean fdpic_p = FALSE;
- BFD_ASSERT (is_sh_elf (input_bfd));
+ if (!is_sh_elf (input_bfd))
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return FALSE;
+ }
htab = sh_elf_hash_table (info);
- if (htab == NULL)
- return FALSE;
+ if (htab != NULL)
+ {
+ sgot = htab->root.sgot;
+ sgotplt = htab->root.sgotplt;
+ srelgot = htab->root.srelgot;
+ splt = htab->root.splt;
+ fdpic_p = htab->fdpic_p;
+ }
symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
- dynobj = htab->root.dynobj;
local_got_offsets = elf_local_got_offsets (input_bfd);
isec_segment = sh_elf_osec_to_segment (output_bfd,
input_section->output_section);
- if (htab->fdpic_p && htab->sgot)
+ if (fdpic_p && sgot)
got_segment = sh_elf_osec_to_segment (output_bfd,
- htab->sgot->output_section);
+ sgot->output_section);
else
got_segment = -1;
- if (htab->fdpic_p && htab->splt)
+ if (fdpic_p && splt)
plt_segment = sh_elf_osec_to_segment (output_bfd,
- htab->splt->output_section);
+ splt->output_section);
else
plt_segment = -1;
- sgot = htab->sgot;
- sgotplt = htab->sgotplt;
- splt = htab->splt;
- sreloc = NULL;
- srelgot = NULL;
/* We have to handle relocations in vxworks .tls_vars sections
specially, because the dynamic loader is 'weird'. */
- is_vxworks_tls = (htab->vxworks_p && info->shared
+ is_vxworks_tls = (htab && htab->vxworks_p && bfd_link_pic (info)
&& !strcmp (input_section->output_section->name,
".tls_vars"));
bfd_vma relocation;
bfd_vma addend = (bfd_vma) 0;
bfd_reloc_status_type r;
- int seen_stt_datalabel = 0;
bfd_vma off;
- int got_type;
+ enum got_type got_type;
const char *symname = NULL;
+ bfd_boolean resolved_to_zero;
r_symndx = ELF32_R_SYM (rel->r_info);
if (! howto->partial_inplace)
addend = rel->r_addend;
+ resolved_to_zero = FALSE;
h = NULL;
sym = NULL;
sec = NULL;
symname = bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name);
if (symname == NULL || *symname == '\0')
- symname = bfd_section_name (input_bfd, sec);
+ symname = bfd_section_name (sec);
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 (sec != NULL && elf_discarded_section (sec))
+
+ if (sec != NULL && discarded_section (sec))
/* Handled below. */
;
- else if (info->relocatable)
+ else if (bfd_link_relocatable (info))
{
/* This is a relocatable link. We don't have to change
anything, unless the reloc is against a section symbol,
if (howto->rightshift || howto->src_mask != 0xffffffff)
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "%s relocation against SEC_MERGE section"),
input_bfd, input_section,
- (long) rel->r_offset, howto->name);
+ (uint64_t) rel->r_offset, howto->name);
return FALSE;
}
symname = h->root.root.string;
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
- {
-#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;
- }
+ 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)
{
bfd_boolean dyn;
- dyn = htab->root.dynamic_sections_created;
+ dyn = htab ? htab->root.dynamic_sections_created : FALSE;
sec = h->root.u.def.section;
/* In these cases, we don't need the relocation value.
We check specially because in some obscure cases
|| r_type == R_SH_GOT_MEDLOW16
|| r_type == R_SH_GOT_MEDHI16
|| r_type == R_SH_GOT_HI16)
- && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
- && (! info->shared
+ && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ h)
+ && (! bfd_link_pic (info)
|| (! info->symbolic && h->dynindx != -1)
|| !h->def_regular))
/* The cases above are those in which relocation is
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
+ || (bfd_link_pic (info)
&& ((! info->symbolic && h->dynindx != -1)
|| !h->def_regular)
&& ((r_type == R_SH_DIR32
|| sh_elf_hash_entry (h)->got_type == GOT_TLS_GD)))
;
else if (sec->output_section != NULL)
- relocation = ((h->root.u.def.value
+ 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));
- else if (!info->relocatable)
+ + sec->output_offset);
+ else if (!bfd_link_relocatable (info)
+ && (_bfd_elf_section_offset (output_bfd, info,
+ input_section,
+ rel->r_offset)
+ != (bfd_vma) -1))
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
h->root.root.string);
return FALSE;
}
}
else if (h->root.type == bfd_link_hash_undefweak)
- ;
+ resolved_to_zero = UNDEFWEAK_NO_DYNAMIC_RELOC (info, h);
else if (info->unresolved_syms_in_objects == RM_IGNORE
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
;
- else if (!info->relocatable)
- {
- if (! info->callbacks->undefined_symbol
- (info, h->root.root.string, input_bfd,
- input_section, rel->r_offset,
- (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
- || ELF_ST_VISIBILITY (h->other))))
- return FALSE;
- }
- }
-
- if (sec != NULL && elf_discarded_section (sec))
- {
- /* For relocs against symbols from removed linkonce sections,
- or sections discarded by a linker script, we just want the
- section contents zeroed. Avoid any special processing. */
- _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
- rel->r_info = 0;
- rel->r_addend = 0;
- continue;
- }
-
- if (info->relocatable)
+ else if (!bfd_link_relocatable (info))
+ info->callbacks->undefined_symbol
+ (info, h->root.root.string, input_bfd, input_section,
+ rel->r_offset,
+ (info->unresolved_syms_in_objects == RM_DIAGNOSE
+ && !info->warn_unresolved_syms)
+ || ELF_ST_VISIBILITY (h->other));
+ }
+
+ if (sec != NULL && discarded_section (sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rel, 1, relend, howto, 0, contents);
+
+ if (bfd_link_relocatable (info))
continue;
/* Check for inter-segment relocations in FDPIC files. Most
}
if (disp & mask)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
- input_section->owner,
- (unsigned long) rel->r_offset));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: "
+ "unaligned branch target for relax-support relocation"),
+ input_section->owner,
+ (uint64_t) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
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_DIR4UL:
if (relocation & 3)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
- input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: "
+ "unaligned %s relocation %#" PRIx64),
+ input_section->owner, (uint64_t) rel->r_offset,
+ howto->name, (uint64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SH_DIR4UW:
if (relocation & 1)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
- input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: "
+ "unaligned %s relocation %#" PRIx64 ""),
+ input_section->owner,
+ (uint64_t) rel->r_offset, howto->name,
+ (uint64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((signed int)relocation < -32
|| (signed int)relocation > 32)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
- input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHA relocation %" PRId64
+ " not in range -32..32"),
+ input_section->owner,
+ (uint64_t) rel->r_offset,
+ (int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((signed int)relocation < -16
|| (signed int)relocation > 16)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
- input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHL relocation %" PRId64
+ " not in range -32..32"),
+ input_section->owner,
+ (uint64_t) rel->r_offset,
+ (int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SH_DIR32:
case R_SH_REL32:
-#ifdef INCLUDE_SHMEDIA
- case R_SH_IMM_LOW16_PCREL:
- case R_SH_IMM_MEDLOW16_PCREL:
- case R_SH_IMM_MEDHI16_PCREL:
- case R_SH_IMM_HI16_PCREL:
-#endif
- if (info->shared
+ if (bfd_link_pic (info)
&& (h == NULL
- || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ && !resolved_to_zero)
|| h->root.type != bfd_link_hash_undefweak)
- && r_symndx != 0
+ && r_symndx != STN_UNDEF
&& (input_section->flags & SEC_ALLOC) != 0
&& !is_vxworks_tls
&& (r_type == R_SH_DIR32
? bfd_get_32 (input_bfd, contents + rel->r_offset)
: addend);
}
-#ifdef INCLUDE_SHMEDIA
- else if (r_type == R_SH_IMM_LOW16_PCREL
- || r_type == R_SH_IMM_MEDLOW16_PCREL
- || r_type == R_SH_IMM_MEDHI16_PCREL
- || r_type == R_SH_IMM_HI16_PCREL)
- {
- BFD_ASSERT (h != NULL && h->dynindx != -1);
- outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
- outrel.r_addend = addend;
- }
-#endif
- else if (htab->fdpic_p
+ else if (fdpic_p
&& (h == NULL
|| ((info->symbolic || h->dynindx == -1)
&& h->def_regular)))
if (! relocate)
continue;
}
- else if (htab->fdpic_p && !info->shared
+ else if (fdpic_p && !bfd_link_pic (info)
&& r_type == R_SH_DIR32
&& (input_section->flags & SEC_ALLOC) != 0)
{
bfd_vma offset;
+ BFD_ASSERT (htab);
+
if (sh_elf_osec_readonly_p (output_bfd,
input_section->output_section))
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rel->r_offset,
symname);
return FALSE;
}
check_segment[0] = check_segment[1] = -1;
}
+ /* We don't want warnings for non-NULL tests on undefined weak
+ symbols. */
+ else if (r_type == R_SH_REL32
+ && h
+ && h->root.type == bfd_link_hash_undefweak)
+ check_segment[0] = check_segment[1] = -1;
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
|| h->forced_local
- || ! info->shared
+ || ! bfd_link_pic (info)
|| info->symbolic
|| h->dynindx == -1
|| h->plt.offset == (bfd_vma) -1
/* Relocation is to the entry for this symbol in the global
offset table extension for the procedure linkage table. */
+ BFD_ASSERT (htab);
BFD_ASSERT (sgotplt != NULL);
relocation = (sgotplt->output_offset
+ (get_plt_index (htab->plt_info, h->plt.offset)
force_got:
case R_SH_GOT32:
case R_SH_GOT20:
-#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. */
+ BFD_ASSERT (htab);
BFD_ASSERT (sgot != NULL);
check_segment[0] = check_segment[1] = -1;
bfd_boolean dyn;
off = h->got.offset;
-#ifdef INCLUDE_SHMEDIA
- if (seen_stt_datalabel)
- {
- struct elf_sh_link_hash_entry *hsh;
-
- hsh = (struct elf_sh_link_hash_entry *)h;
- off = hsh->datalabel_got.offset;
- }
-#endif
BFD_ASSERT (off != (bfd_vma) -1);
dyn = htab->root.dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
- || (info->shared
+ if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ h)
+ || (bfd_link_pic (info)
&& SYMBOL_REFERENCES_LOCAL (info, h))
- || (ELF_ST_VISIBILITY (h->other)
+ || ((ELF_ST_VISIBILITY (h->other)
+ || resolved_to_zero)
&& h->root.type == bfd_link_hash_undefweak))
{
/* This is actually a static link, or it is a
{
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;
+ h->got.offset |= 1;
/* If we initialize the GOT entry here with a valid
symbol address, also add a fixup. */
- if (htab->fdpic_p && !info->shared
+ if (fdpic_p && !bfd_link_pic (info)
&& sh_elf_hash_entry (h)->got_type == GOT_NORMAL
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak))
}
else
{
-#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));
-
- 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);
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
{
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
- if (info->shared)
+ if (bfd_link_pic (info))
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
- if (srelgot == NULL)
- {
- srelgot = bfd_get_section_by_name (dynobj,
- ".rela.got");
- BFD_ASSERT (srelgot != NULL);
- }
-
outrel.r_offset = (sgot->output_section->vma
+ sgot->output_offset
+ off);
- if (htab->fdpic_p)
+ if (fdpic_p)
{
int dynindx
= elf_section_data (sec->output_section)->dynindx;
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
- else if (htab->fdpic_p
+ else if (fdpic_p
&& (sh_elf_local_got_type (input_bfd) [r_symndx]
== GOT_NORMAL))
sh_elf_add_rofixup (output_bfd, htab->srofixup,
+ sgot->output_offset
+ off);
-#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;
+ local_got_offsets[r_symndx] |= 1;
}
relocation = sh_elf_got_offset (htab) + off;
case R_SH_GOTOFF:
case R_SH_GOTOFF20:
-#ifdef INCLUDE_SHMEDIA
- case R_SH_GOTOFF_LOW16:
- case R_SH_GOTOFF_MEDLOW16:
- case R_SH_GOTOFF_MEDHI16:
- case R_SH_GOTOFF_HI16:
-#endif
/* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
we place at the start of the .got.plt section. This is the same
as the start of the output .got section, unless there are function
descriptors in front of it. */
+ BFD_ASSERT (htab);
BFD_ASSERT (sgotplt != NULL);
check_segment[0] = got_segment;
relocation -= sgotplt->output_section->vma + sgotplt->output_offset
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. */
BFD_ASSERT (sgotplt != NULL);
goto final_link_relocate;
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. */
+ splt->output_offset
+ h->plt.offset);
-#ifdef INCLUDE_SHMEDIA
- relocation++;
-#endif
-
addend = rel->r_addend;
goto final_link_relocate;
bfd_vma reloc_offset;
int reloc_type = R_SH_FUNCDESC;
+ BFD_ASSERT (htab);
+
check_segment[0] = check_segment[1] = -1;
/* FIXME: See what FRV does for global symbols in the
}
else
{
- reloc_section = htab->sgot;
+ reloc_section = sgot;
if (h != NULL)
reloc_offset = h->got.offset;
relocation = htab->sfuncdesc->output_offset + (offset & ~1);
}
- if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h))
+ if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
{
bfd_vma offset;
if (sh_elf_osec_readonly_p (output_bfd,
reloc_section->output_section))
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rel->r_offset,
symname);
return FALSE;
}
return FALSE;
}
- if (srelgot == NULL)
- {
- srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
- BFD_ASSERT (srelgot != NULL);
- }
-
offset = _bfd_elf_section_offset (output_bfd, info,
reloc_section, reloc_offset);
executable and --export-dynamic. If such symbols get
ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
for them. */
+ BFD_ASSERT (htab);
check_segment[0] = check_segment[1] = -1;
relocation = 0;
|| !SYMBOL_FUNCDESC_LOCAL (info, h)))
{
_bfd_error_handler
- (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
- input_bfd, input_section, (long) rel->r_offset, howto->name,
- h->root.root.string);
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "%s relocation against external symbol \"%s\""),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ howto->name, h->root.root.string);
return FALSE;
}
else
relocation = htab->sfuncdesc->output_offset + (offset & ~1);
}
- relocation -= htab->root.hgot->root.u.def.value
- + htab->sgotplt->output_offset;
+ relocation -= (htab->root.hgot->root.u.def.value
+ + sgotplt->output_offset);
#ifdef GOT_BIAS
relocation -= GOT_BIAS;
#endif
case R_SH_TLS_GD_32:
case R_SH_TLS_IE_32:
+ BFD_ASSERT (htab);
check_segment[0] = check_segment[1] = -1;
r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
got_type = GOT_UNKNOWN;
else if (h != NULL)
{
got_type = sh_elf_hash_entry (h)->got_type;
- if (! info->shared
+ if (! bfd_link_pic (info)
&& (h->dynindx == -1
|| h->def_regular))
r_type = R_SH_TLS_LE_32;
1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
offset = rel->r_offset;
- BFD_ASSERT (offset >= 16);
+ if (offset < 16)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64),
+ input_bfd, input_section, (uint64_t) offset);
+ return FALSE;
+ }
+
/* Size of GD instructions is 16 or 18. */
offset -= 16;
insn = bfd_get_16 (input_bfd, contents + offset + 0);
insn = bfd_get_16 (input_bfd, contents + offset + 0);
}
- BFD_ASSERT ((insn & 0xff00) == 0xd400);
+ if ((insn & 0xff00) != 0xd400)
+ _bfd_error_handler
+ /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd4?\?)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 2);
- BFD_ASSERT ((insn & 0xff00) == 0xc700);
+
+ if ((insn & 0xff00) != 0xc700)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xc7?\?)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 4);
- BFD_ASSERT ((insn & 0xff00) == 0xd100);
+ if ((insn & 0xff00) != 0xd100)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd1?\?)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 6);
- BFD_ASSERT (insn == 0x310c);
+ if (insn != 0x310c)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x310c)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 8);
- BFD_ASSERT (insn == 0x410b);
+ if (insn != 0x410b)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x410b)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 10);
- BFD_ASSERT (insn == 0x34cc);
+ if (insn != 0x34cc)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x34cc)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
int target;
/* IE->LE transition:
- mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
- bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
+ mov.l 1f,r0;
+ stc gbr,rN;
+ mov.l @(r0,r12),rM;
+ bra 2f;
+ add ...;
+ .align 2;
+ 1: x@GOTTPOFF;
+ 2:
We change it into:
- mov.l .Ln,rM; stc gbr,rN; nop; ...;
- 1: x@TPOFF; 2:. */
+ mov.l .Ln,rM;
+ stc gbr,rN;
+ nop;
+ ...;
+ 1: x@TPOFF;
+ 2:. */
offset = rel->r_offset;
- BFD_ASSERT (offset >= 16);
+ if (offset < 16)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64),
+ input_bfd, input_section, (uint64_t) offset);
+ return FALSE;
+ }
+
/* Size of IE instructions is 10 or 12. */
offset -= 10;
insn = bfd_get_16 (input_bfd, contents + offset + 0);
insn = bfd_get_16 (input_bfd, contents + offset + 0);
}
- BFD_ASSERT ((insn & 0xff00) == 0xd000);
+ if ((insn & 0xff00) != 0xd000)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
+ input_bfd, input_section, (uint64_t) offset, (int) insn);
+
target = insn & 0x00ff;
+
insn = bfd_get_16 (input_bfd, contents + offset + 2);
- BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
+ if ((insn & 0xf0ff) != 0x0012)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?12: stc)"),
+ input_bfd, input_section, (uint64_t) (offset + 2), (int) insn);
+
insn = bfd_get_16 (input_bfd, contents + offset + 4);
- BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
+ if ((insn & 0xf0ff) != 0x00ce)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
+ input_bfd, input_section, (uint64_t) (offset + 4), (int) insn);
+
insn = 0xd000 | (insn & 0x0f00) | target;
bfd_put_16 (output_bfd, insn, contents + offset + 0);
bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
bfd_byte *loc;
int dr_type, indx;
- if (srelgot == NULL)
- {
- srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
- BFD_ASSERT (srelgot != NULL);
- }
-
outrel.r_offset = (sgot->output_section->vma
+ sgot->output_offset + off);
1: .long x@TPOFF; 2:...; 3:. */
offset = rel->r_offset;
- BFD_ASSERT (offset >= 16);
+ if (offset < 16)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64),
+ input_bfd, input_section, (uint64_t) offset);
+ return FALSE;
+ }
+
/* Size of GD instructions is 16 or 18. */
offset -= 16;
insn = bfd_get_16 (input_bfd, contents + offset + 0);
goto final_link_relocate;
case R_SH_TLS_LD_32:
+ BFD_ASSERT (htab);
check_segment[0] = check_segment[1] = -1;
- if (! info->shared)
+ if (! bfd_link_pic (info))
{
bfd_vma offset;
unsigned short insn;
nop; nop; bra 3f; ...; 3:. */
offset = rel->r_offset;
- BFD_ASSERT (offset >= 16);
+ if (offset < 16)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64),
+ input_bfd, input_section, (uint64_t) offset);
+ return FALSE;
+ }
+
/* Size of LD instructions is 16 or 18. */
offset -= 16;
insn = bfd_get_16 (input_bfd, contents + offset + 0);
Elf_Internal_Rela outrel;
bfd_byte *loc;
- srelgot = htab->srelgot;
- if (srelgot == NULL)
- abort ();
-
outrel.r_offset = (sgot->output_section->vma
+ sgot->output_offset + off);
outrel.r_addend = 0;
case R_SH_TLS_LDO_32:
check_segment[0] = check_segment[1] = -1;
- if (! info->shared)
+ if (! bfd_link_pic (info))
relocation = tpoff (info, relocation);
else
relocation -= dtpoff_base (info);
check_segment[0] = check_segment[1] = -1;
- if (! info->shared)
+ if (!bfd_link_dll (info))
{
relocation = tpoff (info, relocation);
addend = rel->r_addend;
}
relocation_done:
- if (htab->fdpic_p && check_segment[0] != (unsigned) -1
+ if (fdpic_p && check_segment[0] != (unsigned) -1
&& check_segment[0] != check_segment[1])
{
/* We don't want duplicate errors for undefined symbols. */
if (!h || h->root.type != bfd_link_hash_undefined)
{
- if (info->shared)
+ if (bfd_link_pic (info))
{
info->callbacks->einfo
+ /* xgettext:c-format */
(_("%X%C: relocation to \"%s\" references a different segment\n"),
input_bfd, input_section, rel->r_offset, symname);
return FALSE;
}
else
info->callbacks->einfo
+ /* xgettext:c-format */
(_("%C: warning: relocation to \"%s\" references a different segment\n"),
input_bfd, input_section, rel->r_offset, symname);
}
- elf_elfheader (output_bfd)->e_flags &= ~EF_SH_PIC;
+ elf_elfheader (output_bfd)->e_flags |= EF_SH_PIC;
}
if (r != bfd_reloc_ok)
if (name == NULL)
return FALSE;
if (*name == '\0')
- name = bfd_section_name (input_bfd, sec);
+ name = bfd_section_name (sec);
}
- if (! ((*info->callbacks->reloc_overflow)
- (info, (h ? &h->root : NULL), name, howto->name,
- (bfd_vma) 0, input_bfd, input_section,
- rel->r_offset)))
- return FALSE;
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root : NULL), name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
}
break;
}
isymbuf, sections))
goto error_return;
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL
- && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
if (elf_section_data (input_section)->relocs != internal_relocs)
free (internal_relocs);
return data;
error_return:
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL
- && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (internal_relocs != NULL
- && elf_section_data (input_section)->relocs != internal_relocs)
+ if (elf_section_data (input_section)->relocs != internal_relocs)
free (internal_relocs);
return NULL;
}
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}
-/* Update the got entry reference counts for the section being removed. */
-
-static bfd_boolean
-sh_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
- asection *sec, const Elf_Internal_Rela *relocs)
-{
- Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
- bfd_signed_vma *local_got_refcounts;
- union gotref *local_funcdesc;
- const Elf_Internal_Rela *rel, *relend;
-
- if (info->relocatable)
- return TRUE;
-
- elf_section_data (sec)->local_dynrel = NULL;
-
- symtab_hdr = &elf_symtab_hdr (abfd);
- sym_hashes = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
- local_funcdesc = sh_elf_local_funcdesc (abfd);
-
- relend = relocs + sec->reloc_count;
- for (rel = relocs; rel < relend; rel++)
- {
- unsigned long r_symndx;
- unsigned int r_type;
- struct elf_link_hash_entry *h = NULL;
-#ifdef INCLUDE_SHMEDIA
- int seen_stt_datalabel = 0;
-#endif
-
- r_symndx = ELF32_R_SYM (rel->r_info);
- if (r_symndx >= symtab_hdr->sh_info)
- {
- struct elf_sh_link_hash_entry *eh;
- struct elf_sh_dyn_relocs **pp;
- struct elf_sh_dyn_relocs *p;
-
- h = sym_hashes[r_symndx - symtab_hdr->sh_info];
- while (h->root.type == bfd_link_hash_indirect
- || h->root.type == bfd_link_hash_warning)
- {
-#ifdef INCLUDE_SHMEDIA
- seen_stt_datalabel |= h->type == STT_DATALABEL;
-#endif
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
- }
- eh = (struct elf_sh_link_hash_entry *) h;
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
- if (p->sec == sec)
- {
- /* Everything must go for SEC. */
- *pp = p->next;
- break;
- }
- }
-
- r_type = ELF32_R_TYPE (rel->r_info);
- switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
- {
- case R_SH_TLS_LD_32:
- if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
- sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
- break;
-
- case R_SH_GOT32:
- case R_SH_GOT20:
- case R_SH_GOTOFF:
- case R_SH_GOTOFF20:
- case R_SH_GOTPC:
-#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:
- 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
- case R_SH_TLS_GD_32:
- case R_SH_TLS_IE_32:
- case R_SH_GOTFUNCDESC:
- case R_SH_GOTFUNCDESC20:
- if (h != NULL)
- {
-#ifdef INCLUDE_SHMEDIA
- if (seen_stt_datalabel)
- {
- struct elf_sh_link_hash_entry *eh;
- eh = (struct elf_sh_link_hash_entry *) h;
- if (eh->datalabel_got.refcount > 0)
- eh->datalabel_got.refcount -= 1;
- }
- else
-#endif
- if (h->got.refcount > 0)
- h->got.refcount -= 1;
- }
- else if (local_got_refcounts != NULL)
- {
-#ifdef INCLUDE_SHMEDIA
- if (rel->r_addend & 1)
- {
- if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
- local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
- }
- else
-#endif
- if (local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- }
- break;
-
- case R_SH_FUNCDESC:
- if (h != NULL)
- sh_elf_hash_entry (h)->abs_funcdesc_refcount -= 1;
- else if (sh_elf_hash_table (info)->fdpic_p && !info->shared)
- sh_elf_hash_table (info)->srofixup->size -= 4;
-
- /* Fall through. */
-
- case R_SH_GOTOFFFUNCDESC:
- case R_SH_GOTOFFFUNCDESC20:
- if (h != NULL)
- sh_elf_hash_entry (h)->funcdesc.refcount -= 1;
- else
- local_funcdesc[r_symndx].refcount -= 1;
- break;
-
- case R_SH_DIR32:
- if (sh_elf_hash_table (info)->fdpic_p && !info->shared
- && (sec->flags & SEC_ALLOC) != 0)
- sh_elf_hash_table (info)->srofixup->size -= 4;
- /* Fall thru */
-
- case R_SH_REL32:
- if (info->shared)
- break;
- /* Fall thru */
-
- 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
- if (h != NULL)
- {
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
- }
- break;
-
- 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 (h != NULL)
- {
- struct elf_sh_link_hash_entry *eh;
- eh = (struct elf_sh_link_hash_entry *) h;
- if (eh->gotplt_refcount > 0)
- {
- eh->gotplt_refcount -= 1;
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
- }
-#ifdef INCLUDE_SHMEDIA
- else if (seen_stt_datalabel)
- {
- if (eh->datalabel_got.refcount > 0)
- eh->datalabel_got.refcount -= 1;
- }
-#endif
- else if (h->got.refcount > 0)
- h->got.refcount -= 1;
- }
- else if (local_got_refcounts != NULL)
- {
-#ifdef INCLUDE_SHMEDIA
- if (rel->r_addend & 1)
- {
- if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
- local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
- }
- else
-#endif
- if (local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- }
- break;
-
- default:
- break;
- }
- }
-
- return TRUE;
-}
-
/* Copy the extra info we tack onto an elf_link_hash_entry. */
static void
edir = (struct elf_sh_link_hash_entry *) dir;
eind = (struct elf_sh_link_hash_entry *) ind;
- if (eind->dyn_relocs != NULL)
- {
- if (edir->dyn_relocs != NULL)
- {
- struct elf_sh_dyn_relocs **pp;
- struct elf_sh_dyn_relocs *p;
-
- /* Add reloc counts against the indirect sym to the direct sym
- list. Merge any entries against the same section. */
- for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
- {
- struct elf_sh_dyn_relocs *q;
-
- for (q = edir->dyn_relocs; q != NULL; q = q->next)
- if (q->sec == p->sec)
- {
- q->pc_count += p->pc_count;
- q->count += p->count;
- *pp = p->next;
- break;
- }
- if (q == NULL)
- pp = &p->next;
- }
- *pp = edir->dyn_relocs;
- }
-
- edir->dyn_relocs = eind->dyn_relocs;
- eind->dyn_relocs = NULL;
- }
edir->gotplt_refcount = eind->gotplt_refcount;
eind->gotplt_refcount = 0;
-#ifdef INCLUDE_SHMEDIA
- edir->datalabel_got.refcount += eind->datalabel_got.refcount;
- eind->datalabel_got.refcount = 0;
-#endif
edir->funcdesc.refcount += eind->funcdesc.refcount;
- eind->funcdesc.refcount = 0;
+ eind->funcdesc.refcount = 0;
edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
- eind->abs_funcdesc_refcount = 0;
+ eind->abs_funcdesc_refcount = 0;
if (ind->root.type == bfd_link_hash_indirect
&& dir->got.refcount <= 0)
/* If called to transfer flags for a weakdef during processing
of elf_adjust_dynamic_symbol, don't copy non_got_ref.
We clear it ourselves for ELIMINATE_COPY_RELOCS. */
- dir->ref_dynamic |= ind->ref_dynamic;
+ if (dir->versioned != versioned_hidden)
+ dir->ref_dynamic |= ind->ref_dynamic;
dir->ref_regular |= ind->ref_regular;
dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
dir->needs_plt |= ind->needs_plt;
sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
int is_local)
{
- if (info->shared)
+ if (bfd_link_pic (info))
return r_type;
switch (r_type)
struct elf_sh_link_hash_table *htab;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
- bfd_vma *local_got_offsets;
- asection *sgot;
- asection *srelgot;
asection *sreloc;
unsigned int r_type;
- int got_type, old_got_type;
+ enum got_type got_type, old_got_type;
- sgot = NULL;
- srelgot = NULL;
sreloc = NULL;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
+ return TRUE;
+
+ /* Don't do anything special with non-loaded, non-alloced sections.
+ In particular, any relocs in such sections should not affect GOT
+ and PLT reference counting (ie. we don't allow them to create GOT
+ or PLT entries), there's no possibility or desire to optimize TLS
+ relocs, and there's not much point in propagating relocs to shared
+ libs that the dynamic linker won't relocate. */
+ if ((sec->flags & SEC_ALLOC) == 0)
return TRUE;
BFD_ASSERT (is_sh_elf (abfd));
if (htab == NULL)
return FALSE;
- local_got_offsets = elf_local_got_offsets (abfd);
-
rel_end = relocs + sec->reloc_count;
for (rel = relocs; rel < rel_end; rel++)
{
struct elf_link_hash_entry *h;
unsigned long r_symndx;
-#ifdef INCLUDE_SHMEDIA
- int seen_stt_datalabel = 0;
-#endif
r_symndx = ELF32_R_SYM (rel->r_info);
r_type = ELF32_R_TYPE (rel->r_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)
- {
-#ifdef INCLUDE_SHMEDIA
- seen_stt_datalabel |= h->type == STT_DATALABEL;
-#endif
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
- }
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
}
r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
- if (! info->shared
+ if (! bfd_link_pic (info)
&& r_type == R_SH_TLS_IE_32
&& h != NULL
&& h->root.type != bfd_link_hash_undefined
}
/* Some relocs require a global offset table. */
- if (htab->sgot == NULL)
+ if (htab->root.sgot == NULL)
{
switch (r_type)
{
/* This may require an rofixup. */
if (!htab->fdpic_p)
break;
+ /* Fall through. */
case R_SH_GOTPLT32:
case R_SH_GOT32:
case R_SH_GOT20:
case R_SH_GOTOFFFUNCDESC:
case R_SH_GOTOFFFUNCDESC20:
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
case R_SH_TLS_GD_32:
case R_SH_TLS_LD_32:
case R_SH_TLS_IE_32:
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_SH_GNU_VTENTRY:
- BFD_ASSERT (h != NULL);
- if (h != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
return FALSE;
break;
case R_SH_TLS_IE_32:
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
/* FALLTHROUGH */
case R_SH_TLS_GD_32:
case R_SH_GOT32:
case R_SH_GOT20:
-#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
case R_SH_GOTFUNCDESC:
case R_SH_GOTFUNCDESC20:
switch (r_type)
if (h != NULL)
{
-#ifdef INCLUDE_SHMEDIA
- if (seen_stt_datalabel)
- {
- struct elf_sh_link_hash_entry *eh
- = (struct elf_sh_link_hash_entry *) h;
-
- eh->datalabel_got.refcount += 1;
- }
- else
-#endif
- h->got.refcount += 1;
+ h->got.refcount += 1;
old_got_type = sh_elf_hash_entry (h)->got_type;
}
else
size = symtab_hdr->sh_info;
size *= sizeof (bfd_signed_vma);
-#ifdef INCLUDE_SHMEDIA
- /* Reserve space for both the datalabel and
- codelabel local GOT offsets. */
- size *= 2;
-#endif
size += symtab_hdr->sh_info;
local_got_refcounts = ((bfd_signed_vma *)
bfd_zalloc (abfd, size));
if (local_got_refcounts == NULL)
return FALSE;
elf_local_got_refcounts (abfd) = local_got_refcounts;
-#ifdef INCLUDE_SHMEDIA
- /* Take care of both the datalabel and codelabel local
- GOT offsets. */
- sh_elf_local_got_type (abfd)
- = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
-#else
sh_elf_local_got_type (abfd)
= (char *) (local_got_refcounts + symtab_hdr->sh_info);
-#endif
}
-#ifdef INCLUDE_SHMEDIA
- if (rel->r_addend & 1)
- local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
- else
-#endif
- local_got_refcounts[r_symndx] += 1;
+ local_got_refcounts[r_symndx] += 1;
old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
}
{
if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
&& (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else if (old_got_type == GOT_FUNCDESC
|| got_type == GOT_FUNCDESC)
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
else
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as normal and thread local symbol"),
- abfd, h->root.root.string);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
+ abfd, h->root.root.string);
return FALSE;
}
}
case R_SH_GOTOFFFUNCDESC20:
if (rel->r_addend)
{
- (*_bfd_error_handler)
- (_("%B: Function descriptor relocation with non-zero addend"),
+ _bfd_error_handler
+ (_("%pB: Function descriptor relocation with non-zero addend"),
abfd);
return FALSE;
}
bfd_size_type size;
size = symtab_hdr->sh_info * sizeof (union gotref);
-#ifdef INCLUDE_SHMEDIA
- /* Count datalabel local GOT. */
- size *= 2;
-#endif
local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
if (local_funcdesc == NULL)
return FALSE;
if (r_type == R_SH_FUNCDESC)
{
- if (!info->shared)
+ if (!bfd_link_pic (info))
htab->srofixup->size += 4;
else
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ htab->root.srelgot->size += sizeof (Elf32_External_Rela);
}
}
else
if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
{
if (old_got_type == GOT_NORMAL)
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
}
}
break;
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
|| h->forced_local
- || ! info->shared
+ || ! bfd_link_pic (info)
|| info->symbolic
|| h->dynindx == -1)
goto force_got;
break;
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
case R_SH_DIR32:
case R_SH_REL32:
-#ifdef INCLUDE_SHMEDIA
- case R_SH_IMM_LOW16_PCREL:
- case R_SH_IMM_MEDLOW16_PCREL:
- case R_SH_IMM_MEDHI16_PCREL:
- case R_SH_IMM_HI16_PCREL:
-#endif
- if (h != NULL && ! info->shared)
+ if (h != NULL && ! bfd_link_pic (info))
{
h->non_got_ref = 1;
h->plt.refcount += 1;
may need to keep relocations for symbols satisfied by a
dynamic library if we manage to avoid copy relocs for the
symbol. */
- if ((info->shared
+ if ((bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& (r_type != R_SH_REL32
|| (h != NULL
&& (! info->symbolic
|| h->root.type == bfd_link_hash_defweak
|| !h->def_regular))))
- || (! info->shared
+ || (! bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& h != NULL
&& (h->root.type == bfd_link_hash_defweak
|| !h->def_regular)))
{
- struct elf_sh_dyn_relocs *p;
- struct elf_sh_dyn_relocs **head;
+ struct elf_dyn_relocs *p;
+ struct elf_dyn_relocs **head;
if (htab->root.dynobj == NULL)
htab->root.dynobj = abfd;
/* If this is a global symbol, we count the number of
relocations we need for this symbol. */
if (h != NULL)
- head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
+ head = &h->dyn_relocs;
else
{
/* Track dynamic relocs needed for local syms too. */
s = sec;
vpp = &elf_section_data (s)->local_dynrel;
- head = (struct elf_sh_dyn_relocs **) vpp;
+ head = (struct elf_dyn_relocs **) vpp;
}
p = *head;
if (p == NULL || p->sec != sec)
{
- bfd_size_type amt = sizeof (*p);
+ size_t amt = sizeof (*p);
p = bfd_alloc (htab->root.dynobj, amt);
if (p == NULL)
return FALSE;
}
p->count += 1;
- if (r_type == R_SH_REL32
-#ifdef INCLUDE_SHMEDIA
- || r_type == R_SH_IMM_LOW16_PCREL
- || r_type == R_SH_IMM_MEDLOW16_PCREL
- || r_type == R_SH_IMM_MEDHI16_PCREL
- || r_type == R_SH_IMM_HI16_PCREL
-#endif
- )
+ if (r_type == R_SH_REL32)
p->pc_count += 1;
}
/* Allocate the fixup regardless of whether we need a relocation.
If we end up generating the relocation, we'll unallocate the
fixup. */
- if (htab->fdpic_p && !info->shared
+ if (htab->fdpic_p && !bfd_link_pic (info)
&& r_type == R_SH_DIR32
&& (sec->flags & SEC_ALLOC) != 0)
htab->srofixup->size += 4;
break;
case R_SH_TLS_LE_32:
- if (info->shared)
+ if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
- (_("%B: TLS local exec code cannot be linked into shared objects"),
+ _bfd_error_handler
+ (_("%pB: TLS local exec code cannot be linked into shared objects"),
abfd);
return FALSE;
}
{
flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
- if (flags >= sizeof(sh_ef_bfd_table))
+ if (flags >= ARRAY_SIZE (sh_ef_bfd_table))
return FALSE;
if (sh_ef_bfd_table[flags] == 0)
return FALSE;
-
+
bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
return TRUE;
sh_elf_get_flags_from_mach (unsigned long mach)
{
int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
-
+
for (; i>0; i--)
if (sh_ef_bfd_table[i] == mach)
return i;
-
+
/* shouldn't get here */
BFD_FAIL();
}
#endif /* not sh_elf_set_mach_from_flags */
-#ifndef sh_elf_set_private_flags
-/* Function to keep SH specific file flags. */
-
-static bfd_boolean
-sh_elf_set_private_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 */
static bfd_boolean
sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
{
- /* Copy object attributes. */
- _bfd_elf_copy_obj_attributes (ibfd, obfd);
-
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
return TRUE;
- /* Copy the stack size. */
- if (elf_tdata (ibfd)->phdr && elf_tdata (obfd)->phdr
- && fdpic_object_p (ibfd) && fdpic_object_p (obfd))
- {
- unsigned i;
-
- for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
- if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
- {
- Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
-
- for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
- if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
- {
- memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
-
- /* Rewrite the phdrs, since we're only called after they
- were first written. */
- if (bfd_seek (obfd,
- (bfd_signed_vma) get_elf_backend_data (obfd)
- ->s->sizeof_ehdr, SEEK_SET) != 0
- || get_elf_backend_data (obfd)->s
- ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
- elf_elfheader (obfd)->e_phnum) != 0)
- return FALSE;
- break;
- }
-
- break;
- }
- }
+ if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
+ return FALSE;
- return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
+ return sh_elf_set_mach_from_flags (obfd);
}
#endif /* not sh_elf_copy_private_data */
return sh_elf_get_flags_from_mach (bfd_mach);
}
+/* Merge the architecture type of two BFD files, such that the
+ resultant architecture supports all the features required
+ by the two input BFDs.
+ If the input BFDs are multually incompatible - i.e. one uses
+ DSP while the other uses FPU - or there is no known architecture
+ that fits the requirements then an error is emitted. */
+
+static bfd_boolean
+sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info)
+{
+ bfd *obfd = info->output_bfd;
+ unsigned int old_arch, new_arch, merged_arch;
+
+ if (! _bfd_generic_verify_endian_match (ibfd, info))
+ return FALSE;
+
+ old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd));
+ new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd));
+
+ merged_arch = SH_MERGE_ARCH_SET (old_arch, new_arch);
+
+ if (!SH_VALID_CO_ARCH_SET (merged_arch))
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: uses %s instructions while previous modules "
+ "use %s instructions"),
+ ibfd,
+ SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
+ SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp");
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+ else if (!SH_VALID_ARCH_SET (merged_arch))
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("internal error: merge of architecture '%s' with "
+ "architecture '%s' produced unknown architecture"),
+ bfd_printable_name (obfd),
+ bfd_printable_name (ibfd));
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
+ bfd_default_set_arch_mach (obfd, bfd_arch_sh,
+ sh_get_bfd_mach_from_arch_set (merged_arch));
+
+ return TRUE;
+}
+
/* This routine initialises the elf flags when required and
calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
static bfd_boolean
-sh_elf_merge_private_data (bfd *ibfd, bfd *obfd)
+sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info)
{
- extern bfd_boolean sh_merge_bfd_arch (bfd *, bfd *);
+ bfd *obfd = info->output_bfd;
+
+ /* FIXME: What should be checked when linking shared libraries? */
+ if ((ibfd->flags & DYNAMIC) != 0)
+ return TRUE;
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
return TRUE;
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
sh_elf_set_mach_from_flags (obfd);
if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
- elf_elfheader (obfd)->e_flags |= EF_SH_PIC;
+ elf_elfheader (obfd)->e_flags &= ~EF_SH_PIC;
}
- if (! sh_merge_bfd_arch (ibfd, obfd))
+ if (! sh_merge_bfd_arch (ibfd, info))
{
- _bfd_error_handler ("%B: uses instructions which are incompatible "
- "with instructions used in previous modules",
+ _bfd_error_handler (_("%pB: uses instructions which are incompatible "
+ "with instructions used in previous modules"),
ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
{
- _bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects",
+ _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
BFD_ASSERT (h->dynindx != -1);
- splt = htab->splt;
- sgotplt = htab->sgotplt;
- srelplt = htab->srelplt;
+ splt = htab->root.splt;
+ sgotplt = htab->root.sgotplt;
+ srelplt = htab->root.srelplt;
BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
/* Get the index in the procedure linkage table which
got_offset = (plt_index + 3) * 4;
#ifdef GOT_BIAS
- if (info->shared)
+ if (bfd_link_pic (info))
got_offset -= GOT_BIAS;
#endif
plt_info->symbol_entry,
plt_info->symbol_entry_size);
- if (info->shared || htab->fdpic_p)
+ if (bfd_link_pic (info) || htab->fdpic_p)
{
if (plt_info->symbol_fields.got20)
{
/* Make got_offset relative to the start of .got.plt. */
#ifdef GOT_BIAS
- if (info->shared)
+ if (bfd_link_pic (info))
got_offset += GOT_BIAS;
#endif
if (htab->fdpic_p)
sgotplt->contents + got_offset);
if (htab->fdpic_p)
bfd_put_32 (output_bfd,
- sh_elf_osec_to_segment (output_bfd,
- htab->splt->output_section),
+ sh_elf_osec_to_segment (output_bfd, splt->output_section),
sgotplt->contents + got_offset + 4);
/* Fill in the entry in the .rela.plt section. */
loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
- if (htab->vxworks_p && !info->shared)
+ if (htab->vxworks_p && !bfd_link_pic (info))
{
/* Create the .rela.plt.unloaded relocations for this PLT entry.
Begin by pointing LOC to the first such relocation. */
/* Create a .rela.plt.unloaded R_SH_DIR32 relocation
for the PLT entry's pointer to the .got.plt entry. */
- rel.r_offset = (htab->splt->output_section->vma
- + htab->splt->output_offset
+ rel.r_offset = (splt->output_section->vma
+ + splt->output_offset
+ h->plt.offset
+ plt_info->symbol_fields.got_entry);
rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
/* This symbol has an entry in the global offset table. Set it
up. */
- sgot = htab->sgot;
- srelgot = htab->srelgot;
+ sgot = htab->root.sgot;
+ srelgot = htab->root.srelgot;
BFD_ASSERT (sgot != NULL && srelgot != NULL);
rel.r_offset = (sgot->output_section->vma
of a version file, we just want to emit a RELATIVE reloc.
The entry in the global offset table will already have been
initialized in the relocate_section function. */
- if (info->shared
+ if (bfd_link_pic (info)
&& SYMBOL_REFERENCES_LOCAL (info, h))
{
if (htab->fdpic_p)
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
}
-#ifdef INCLUDE_SHMEDIA
- {
- struct elf_sh_link_hash_entry *eh;
-
- eh = (struct elf_sh_link_hash_entry *) h;
- if (eh->datalabel_got.offset != (bfd_vma) -1)
- {
- asection *sgot;
- asection *srelgot;
- Elf_Internal_Rela rel;
- bfd_byte *loc;
-
- /* This symbol has a datalabel entry in the global offset table.
- Set it up. */
-
- sgot = htab->sgot;
- srelgot = htab->srelgot;
- BFD_ASSERT (sgot != NULL && srelgot != NULL);
-
- rel.r_offset = (sgot->output_section->vma
- + sgot->output_offset
- + (eh->datalabel_got.offset &~ (bfd_vma) 1));
-
- /* If this is a static link, or it is a -Bsymbolic link and the
- symbol is defined locally or was forced to be local because
- of a version file, we just want to emit a RELATIVE reloc.
- The entry in the global offset table will already have been
- initialized in the relocate_section function. */
- if (info->shared
- && SYMBOL_REFERENCES_LOCAL (info, h))
- {
- if (htab->fdpic_p)
- {
- asection *sec = h->root.u.def.section;
- int dynindx
- = elf_section_data (sec->output_section)->dynindx;
-
- rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
- rel.r_addend = (h->root.u.def.value
- + h->root.u.def.section->output_offset);
- }
- else
- {
- 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
- + eh->datalabel_got.offset);
- rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
- rel.r_addend = 0;
- }
-
- loc = srelgot->contents;
- loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
- }
- }
-#endif
-
if (h->needs_copy)
{
asection *s;
&& (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");
+ s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
BFD_ASSERT (s != NULL);
rel.r_offset = (h->root.u.def.value
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
_GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
".got" section. */
- if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+ if (h == htab->root.hdynamic
|| (!htab->vxworks_p && h == htab->root.hgot))
sym->st_shndx = SHN_ABS;
if (htab == NULL)
return FALSE;
- sgotplt = htab->sgotplt;
- sdyn = bfd_get_section_by_name (htab->root.dynobj, ".dynamic");
+ sgotplt = htab->root.sgotplt;
+ sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
if (htab->root.dynamic_sections_created)
{
{
Elf_Internal_Dyn dyn;
asection *s;
-#ifdef INCLUDE_SHMEDIA
- const char *name;
-#endif
bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
-#ifdef INCLUDE_SHMEDIA
- case DT_INIT:
- name = info->init_function;
- goto get_sym;
-
- case DT_FINI:
- name = info->fini_function;
- get_sym:
- if (dyn.d_un.d_val != 0)
- {
- struct elf_link_hash_entry *h;
-
- h = elf_link_hash_lookup (&htab->root, name,
- FALSE, FALSE, TRUE);
- if (h != NULL && (h->other & STO_SH5_ISA32))
- {
- dyn.d_un.d_val |= 1;
- bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
- }
- }
- break;
-#endif
-
case DT_PLTGOT:
BFD_ASSERT (htab->root.hgot != NULL);
s = htab->root.hgot->root.u.def.section;
break;
case DT_JMPREL:
- s = htab->srelplt->output_section;
+ s = htab->root.srelplt->output_section;
BFD_ASSERT (s != NULL);
dyn.d_un.d_ptr = s->vma;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_PLTRELSZ:
- s = htab->srelplt->output_section;
+ s = htab->root.srelplt->output_section;
BFD_ASSERT (s != NULL);
dyn.d_un.d_val = s->size;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
-
- 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. */
- if (htab->srelplt != NULL)
- {
- s = htab->srelplt->output_section;
- dyn.d_un.d_val -= s->size;
- }
- bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
- break;
}
}
/* Fill in the first entry in the procedure linkage table. */
- splt = htab->splt;
+ splt = htab->root.splt;
if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
{
unsigned int i;
if (sgotplt && sgotplt->size > 0)
elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
-
+
/* At the very end of the .rofixup section is a pointer to the GOT. */
if (htab->fdpic_p && htab->srofixup != NULL)
{
BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
== htab->srelfuncdesc->size);
- if (htab->srelgot)
- BFD_ASSERT (htab->srelgot->reloc_count * sizeof (Elf32_External_Rela)
- == htab->srelgot->size);
+ if (htab->root.srelgot)
+ BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
+ == htab->root.srelgot->size);
return TRUE;
}
static enum elf_reloc_type_class
-sh_elf_reloc_type_class (const Elf_Internal_Rela *rela)
+sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
switch ((int) ELF32_R_TYPE (rela->r_info))
{
case 168: /* Linux/SH */
/* pr_cursig */
- elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+ elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
/* pr_pid */
- elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
+ elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
/* pr_reg */
offset = 72;
return FALSE;
case 124: /* Linux/SH elf_prpsinfo */
- elf_tdata (abfd)->core_program
+ elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
- elf_tdata (abfd)->core_command
+ elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
}
implementations, so strip it off if it exists. */
{
- char *command = elf_tdata (abfd)->core_command;
+ char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
}
#endif /* not SH_TARGET_ALREADY_DEFINED */
-
+
/* Return address for Ith PLT stub in section PLT, for relocation REL
or (bfd_vma) -1 if it should not be included. */
}
#if !defined SH_TARGET_ALREADY_DEFINED
-#define TARGET_BIG_SYM bfd_elf32_sh_vec
+#define TARGET_BIG_SYM sh_elf32_vec
#define TARGET_BIG_NAME "elf32-sh"
-#define TARGET_LITTLE_SYM bfd_elf32_shl_vec
+#define TARGET_LITTLE_SYM sh_elf32_le_vec
#define TARGET_LITTLE_NAME "elf32-shl"
#endif
#define ELF_ARCH bfd_arch_sh
+#define ELF_TARGET_ID SH_ELF_DATA
#define ELF_MACHINE_CODE EM_SH
#ifdef __QNXTARGET__
#define ELF_MAXPAGESIZE 0x1000
sh_elf_get_relocated_section_contents
#define bfd_elf32_mkobject sh_elf_mkobject
#define elf_backend_object_p sh_elf_object_p
-#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_copy_indirect_symbol \
sh_elf_copy_indirect_symbol
#define elf_backend_encode_eh_address \
sh_elf_encode_eh_address
+#define elf_backend_stack_align 8
#define elf_backend_can_gc_sections 1
#define elf_backend_can_refcount 1
#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_dtrel_excludes_plt 1
+
+#define elf_backend_linux_prpsinfo32_ugid16 TRUE
-#if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
+#if !defined SH_TARGET_ALREADY_DEFINED
#include "elf32-target.h"
/* NetBSD support. */
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
+#define TARGET_BIG_SYM sh_elf32_nbsd_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-sh-nbsd"
#undef TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
+#define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-shl-nbsd"
#undef ELF_MAXPAGESIZE
/* Linux support. */
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_shblin_vec
+#define TARGET_BIG_SYM sh_elf32_linux_be_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-shbig-linux"
#undef TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
+#define TARGET_LITTLE_SYM sh_elf32_linux_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-sh-linux"
#undef ELF_COMMONPAGESIZE
/* FDPIC support. */
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_shbfd_vec
+#define TARGET_BIG_SYM sh_elf32_fdpic_be_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-shbig-fdpic"
#undef TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
+#define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-sh-fdpic"
-#undef elf_backend_modify_program_headers
-#define elf_backend_modify_program_headers \
- sh_elf_modify_program_headers
#undef elf32_bed
#define elf32_bed elf32_sh_fd_bed
#include "elf32-target.h"
-#undef elf_backend_modify_program_headers
-
/* VxWorks support. */
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
+#define TARGET_BIG_SYM sh_elf32_vxworks_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-sh-vxworks"
#undef TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
+#define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec
#undef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "elf32-shl-vxworks"
#undef elf32_bed
#include "elf32-target.h"
-#endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */
+#endif /* not SH_TARGET_ALREADY_DEFINED */
projects / deliverable / binutils-gdb.git / blobdiff