/* Renesas / SuperH SH specific support for 32-bit ELF
- Copyright (C) 1996-2017 Free Software Foundation, Inc.
+ Copyright (C) 1996-2018 Free Software Foundation, Inc.
Contributed by Ian Lance Taylor, Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
/* 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 >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised SH reloc number: %d"),
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
abfd, r);
bfd_set_error (bfd_error_bad_value);
- r = R_SH_NONE;
+ return FALSE;
}
cache_ptr->howto = get_howto_table (abfd) + r;
+ return TRUE;
}
\f
/* This function handles relaxing for SH ELF. See the corresponding
if (laddr >= sec->size)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad R_SH_USES offset"),
- abfd, irel->r_offset);
+ _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);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
- abfd, irel->r_offset, insn);
+ (_("%pB: %#" PRIx64 ": warning: "
+ "R_SH_USES points to unrecognized insn 0x%x"),
+ abfd, (uint64_t) irel->r_offset, insn);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: bad R_SH_USES load offset"),
- abfd, irel->r_offset);
+ (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES load offset"),
+ abfd, (uint64_t) irel->r_offset);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: could not find expected reloc"),
- abfd, paddr);
+ (_("%pB: %#" PRIx64 ": warning: could not find expected reloc"),
+ abfd, (uint64_t) paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: symbol in unexpected section"),
- abfd, paddr);
+ (_("%pB: %#" PRIx64 ": warning: symbol in unexpected section"),
+ abfd, (uint64_t) paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: could not find expected COUNT reloc"),
- abfd, paddr);
+ (_("%pB: %#" PRIx64 ": warning: "
+ "could not find expected COUNT reloc"),
+ abfd, (uint64_t) paddr);
continue;
}
if (irelcount->r_addend == 0)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad count"),
- abfd, paddr);
+ _bfd_error_handler (_("%pB: %#" PRIx64 ": warning: bad count"),
+ abfd, (uint64_t) paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
- abfd, irel->r_offset);
+ (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
+ abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
- abfd, irel->r_offset);
+ (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
+ abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
+ (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;
#endif
/* Track dynamic relocs copied for this symbol. */
- struct elf_sh_dyn_relocs *dyn_relocs;
+ struct elf_dyn_relocs *dyn_relocs;
bfd_signed_vma gotplt_refcount;
return TRUE;
}
\f
+/* Find dynamic relocs for H that apply to read-only sections. */
+
+static asection *
+readonly_dynrelocs (struct elf_link_hash_entry *h)
+{
+ struct elf_dyn_relocs *p;
+
+ for (p = sh_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
+ {
+ asection *s = p->sec->output_section;
+
+ if (s != NULL && (s->flags & SEC_READONLY) != 0)
+ return p->sec;
+ }
+ return NULL;
+}
+
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
dynamic object, but we're not including those sections. We have to
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);
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 && !readonly_dynrelocs (h))
{
h->non_got_ref = 0;
return TRUE;
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 (SYMBOL_CALLS_LOCAL (info, h))
{
- struct elf_sh_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
{
if (htab->vxworks_p)
{
- struct elf_sh_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
{
return TRUE;
}
-/* Find any dynamic relocs that apply to read-only sections. */
+/* Set DF_TEXTREL if we find any dynamic relocs that apply to
+ read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
{
- struct elf_sh_link_hash_entry *eh;
- struct elf_sh_dyn_relocs *p;
-
- eh = (struct elf_sh_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- asection *s = p->sec->output_section;
+ asection *sec;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) inf;
+ if (h->root.type == bfd_link_hash_indirect)
+ return TRUE;
- info->flags |= DF_TEXTREL;
+ sec = readonly_dynrelocs (h);
+ if (sec != NULL)
+ {
+ struct bfd_link_info *info = (struct bfd_link_info *) info_p;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
- p->sec->owner, p->sec);
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo
+ (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
+ sec->owner, h->root.root.string, sec);
- /* Not an error, just cut short the traversal. */
- return FALSE;
- }
+ /* Not an error, just cut short the traversal. */
+ return FALSE;
}
return TRUE;
}
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)
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
/* 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, maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
if ((sym->st_other & STO_SH5_ISA32) != 0)
(*info->callbacks->reloc_dangerous)
(info,
- _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
+ _("unexpected STO_SH5_ISA32 on local symbol is not handled"),
input_bfd, input_section, rel->r_offset);
if (sec != NULL && discarded_section (sec))
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "%s relocation against SEC_MERGE section"),
input_bfd, input_section,
- rel->r_offset, howto->name);
+ (uint64_t) rel->r_offset, howto->name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
h->root.root.string);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned branch target for relax-support relocation"),
+ (_("%pB: %#" PRIx64 ": fatal: "
+ "unaligned branch target for relax-support relocation"),
input_section->owner,
- rel->r_offset);
+ (uint64_t) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
- input_section->owner,
- rel->r_offset, howto->name,
- relocation);
+ (_("%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;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
+ (_("%pB: %#" PRIx64 ": fatal: "
+ "unaligned %s relocation %#" PRIx64 ""),
input_section->owner,
- rel->r_offset, howto->name,
- relocation);
+ (uint64_t) rel->r_offset, howto->name,
+ (uint64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: R_SH_PSHA relocation %Ld not in range -32..32"),
+ (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHA relocation %" PRId64
+ " not in range -32..32"),
input_section->owner,
- rel->r_offset,
- relocation);
+ (uint64_t) rel->r_offset,
+ (int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: R_SH_PSHL relocation %Ld not in range -32..32"),
+ (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHL relocation %" PRId64
+ " not in range -32..32"),
input_section->owner,
- rel->r_offset,
- relocation);
+ (uint64_t) rel->r_offset,
+ (int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- rel->r_offset,
+ (uint64_t) rel->r_offset,
symname);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- rel->r_offset,
+ (uint64_t) rel->r_offset,
symname);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against external symbol \"%s\""),
- input_bfd, input_section, rel->r_offset, howto->name,
- h->root.root.string);
+ (_("%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
{
if (edir->dyn_relocs != NULL)
{
- struct elf_sh_dyn_relocs **pp;
- struct elf_sh_dyn_relocs *p;
+ struct elf_dyn_relocs **pp;
+ struct elf_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;
+ struct elf_dyn_relocs *q;
for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec)
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));
symtab_hdr = &elf_symtab_hdr (abfd);
if (local_got_refcounts == NULL)
return FALSE;
elf_local_got_refcounts (abfd) = local_got_refcounts;
-#ifdef INCLUDE_SHMEDIA
+#ifdef INCLUDE_SHMEDIA
/* Take care of both the datalabel and codelabel local
GOT offsets. */
sh_elf_local_got_type (abfd)
&& (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ (_("%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
/* xgettext:c-format */
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
}
if (rel->r_addend)
{
_bfd_error_handler
- (_("%B: Function descriptor relocation with non-zero addend"),
+ (_("%pB: Function descriptor relocation with non-zero addend"),
abfd);
return FALSE;
}
if (old_got_type == GOT_NORMAL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
}
}
&& (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;
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 (bfd_link_dll (info))
{
_bfd_error_handler
- (_("%B: TLS local exec code cannot be linked into shared objects"),
+ (_("%pB: TLS local exec code cannot be linked into shared objects"),
abfd);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses %s instructions while previous modules "
+ (_("%pB: uses %s instructions while previous modules "
"use %s instructions"),
ibfd,
SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
if (! sh_merge_bfd_arch (ibfd, info))
{
- _bfd_error_handler (_("%B: uses instructions which are incompatible "
+ _bfd_error_handler (_("%pB: uses instructions which are incompatible "
"with instructions used in previous modules"),
ibfd);
bfd_set_error (bfd_error_bad_value);
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;
projects / deliverable / binutils-gdb.git / blobdiff