/* 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.
if (laddr >= sec->size)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
- abfd, (unsigned long) irel->r_offset);
+ _bfd_error_handler (_("%B: %#Lx: warning: bad R_SH_USES offset"),
+ abfd, irel->r_offset);
continue;
}
insn = bfd_get_16 (abfd, contents + laddr);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
- abfd, (unsigned long) irel->r_offset, insn);
+ (_("%B: %#Lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
+ abfd, irel->r_offset, insn);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
- abfd, (unsigned long) irel->r_offset);
+ (_("%B: %#Lx: warning: bad R_SH_USES load offset"),
+ abfd, irel->r_offset);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: warning: could not find expected reloc"),
- abfd, (unsigned long) paddr);
+ (_("%B: %#Lx: warning: could not find expected reloc"),
+ abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: warning: symbol in unexpected section"),
- abfd, (unsigned long) paddr);
+ (_("%B: %#Lx: warning: symbol in unexpected section"),
+ abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
- abfd, (unsigned long) paddr);
+ (_("%B: %#Lx: warning: could not find expected COUNT reloc"),
+ abfd, paddr);
continue;
}
if (irelcount->r_addend == 0)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: 0x%lx: warning: bad count"),
- abfd, (unsigned long) paddr);
+ _bfd_error_handler (_("%B: %#Lx: warning: bad count"),
+ abfd, paddr);
continue;
}
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;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset);
+ (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ abfd, irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset);
+ (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ abfd, 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);
/* 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;
}
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; )
{
if (eh->dyn_relocs != NULL
&& h->root.type == bfd_link_hash_undefweak)
{
- if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
+ if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
eh->dyn_relocs = NULL;
/* Make sure undefined weak symbols are output as a dynamic
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;
+ asection *sec;
- 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 (h->root.type == bfd_link_hash_indirect)
+ return TRUE;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) inf;
+ sec = readonly_dynrelocs (h);
+ if (sec != NULL)
+ {
+ struct bfd_link_info *info = (struct bfd_link_info *) info_p;
- info->flags |= DF_TEXTREL;
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo
+ (_("%B: dynamic relocation against `%T' in read-only section `%A'\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)
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 (_("%B: dynamic relocation in read-only section `%A'\n"),
+ p->sec->owner, p->sec);
+ }
/* If we need relocations, we do not need fixups. */
if (htab->fdpic_p && !bfd_link_pic (info))
/* 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)
{
bfd_vma off;
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;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
+ (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
- (long) rel->r_offset, howto->name);
+ rel->r_offset, howto->name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ 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)
;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
+ (_("%B: %#Lx: fatal: unaligned branch target for relax-support relocation"),
input_section->owner,
- (unsigned long) rel->r_offset);
+ rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
+ (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation);
+ rel->r_offset, howto->name,
+ relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
+ (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation);
+ rel->r_offset, howto->name,
+ relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
+ (_("%B: %#Lx: fatal: R_SH_PSHA relocation %Ld not in range -32..32"),
input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation);
+ rel->r_offset,
+ relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
+ (_("%B: %#Lx: fatal: R_SH_PSHL relocation %Ld not in range -32..32"),
input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation);
+ rel->r_offset,
+ relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
#endif
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 != STN_UNDEF
&& (input_section->flags & SEC_ALLOC) != 0
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ rel->r_offset,
symname);
return FALSE;
}
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_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ rel->r_offset,
symname);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""),
- input_bfd, input_section, (long) rel->r_offset, howto->name,
+ (_("%B(%A+%#Lx): %s relocation against external symbol \"%s\""),
+ input_bfd, input_section, rel->r_offset, howto->name,
h->root.root.string);
return FALSE;
}
{
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);
#endif
h = (struct elf_link_hash_entry *) h->root.u.i.link;
}
-
- /* PR15323, ref flags aren't set for references in the same
- object. */
- h->root.non_ir_ref_regular = 1;
}
r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
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)
&& (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;
#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
#include "elf32-target.h"
projects / deliverable / binutils-gdb.git / blobdiff