/* Meta support for 32-bit ELF
- Copyright (C) 2013-2018 Free Software Foundation, Inc.
+ Copyright (C) 2013-2020 Free Software Foundation, Inc.
Contributed by Imagination Technologies Ltd.
This file is part of BFD, the Binary File Descriptor library.
symbol. */
struct elf_metag_stub_hash_entry *hsh_cache;
- /* Used to count relocations for delayed sizing of relocation
- sections. */
- struct elf_dyn_relocs *dyn_relocs;
-
enum
{
GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_IE = 2, GOT_TLS_LDM = 4, GOT_TLS_GD = 8
elf_hash_table (info)->tls_sec->alignment_power));
}
-static void
-metag_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
+static bfd_boolean
+metag_info_to_howto_rela (bfd *abfd,
arelent *cache_ptr,
Elf_Internal_Rela *dst)
{
if (r_type >= (unsigned int) R_METAG_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid METAG reloc number: %d"), abfd, r_type);
- r_type = 0;
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
}
cache_ptr->howto = & elf_metag_howto_table [r_type];
+ return TRUE;
}
static reloc_howto_type *
/* Initialize the local fields. */
hh = (struct elf_metag_link_hash_entry *) entry;
hh->hsh_cache = NULL;
- hh->dyn_relocs = NULL;
hh->tls_type = GOT_UNKNOWN;
}
elf_metag_link_hash_table_create (bfd *abfd)
{
struct elf_metag_link_hash_table *htab;
- bfd_size_type amt = sizeof (*htab);
+ size_t amt = sizeof (*htab);
htab = bfd_zmalloc (amt);
if (htab == NULL)
if (hsh == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
rel, relend, howto, contents) \
{ \
_bfd_clear_contents (howto, input_bfd, input_section, \
- contents + rel->r_offset); \
+ contents, rel->r_offset); \
\
if (bfd_link_relocatable (info) \
&& (input_section->flags & SEC_DEBUGGING)) \
name = bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name);
- name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
+ name = name == NULL ? bfd_section_name (sec) : name;
}
else
{
/* We don't support changing the TLS model. */
/* PR 20675 */
if (bfd_link_pic (info))
- _bfd_error_handler (_("%B(%A): multiple TLS models are not supported"),
+ _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
input_bfd, input_section);
else
- _bfd_error_handler (_("%B(%A): shared library symbol %s encountered whilst performing a static link"),
+ _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
input_bfd, input_section, name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not permitted in shared object"),
- input_bfd, input_section, rel->r_offset, howto->name);
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "%s relocation not permitted in shared object"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ howto->name);
return FALSE;
}
else
name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
+ (_("%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd, elf_metag_howto_table[r_type].name, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
/* If this is a global symbol, we count the number of
relocations we need for this symbol. */
if (hh != NULL)
- hdh_head = &((struct elf_metag_link_hash_entry *) hh)->dyn_relocs;
+ hdh_head = &hh->eh.dyn_relocs;
else
{
/* Track dynamic relocs needed for local syms too. */
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_METAG_GNU_VTENTRY:
- BFD_ASSERT (hh != NULL);
- if (hh != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
return FALSE;
break;
}
hh_dir = metag_elf_hash_entry (eh_dir);
hh_ind = metag_elf_hash_entry (eh_ind);
- if (hh_ind->dyn_relocs != NULL)
- {
- if (hh_dir->dyn_relocs != NULL)
- {
- struct elf_dyn_relocs **hdh_pp;
- struct elf_dyn_relocs *hdh_p;
-
- if (eh_ind->root.type == bfd_link_hash_indirect)
- abort ();
-
- /* Add reloc counts against the weak sym to the strong sym
- list. Merge any entries against the same section. */
- for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
- {
- struct elf_dyn_relocs *hdh_q;
-
- for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
- hdh_q = hdh_q->next)
- if (hdh_q->sec == hdh_p->sec)
- {
- hdh_q->pc_count += hdh_p->pc_count;
- hdh_q->count += hdh_p->count;
- *hdh_pp = hdh_p->next;
- break;
- }
- if (hdh_q == NULL)
- hdh_pp = &hdh_p->next;
- }
- *hdh_pp = hh_dir->dyn_relocs;
- }
-
- hh_dir->dyn_relocs = hh_ind->dyn_relocs;
- hh_ind->dyn_relocs = NULL;
- }
-
if (eh_ind->root.type == bfd_link_hash_indirect
&& eh_dir->got.refcount <= 0)
{
_bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
}
-/* 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 = metag_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
/* 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 (!readonly_dynrelocs (eh))
+ if (!_bfd_elf_readonly_dynrelocs (eh))
{
eh->non_got_ref = 0;
return TRUE;
{
struct bfd_link_info *info;
struct elf_metag_link_hash_table *htab;
- struct elf_metag_link_hash_entry *hh;
struct elf_dyn_relocs *hdh_p;
if (eh->root.type == bfd_link_hash_indirect)
else
eh->got.offset = (bfd_vma) -1;
- hh = (struct elf_metag_link_hash_entry *) eh;
- if (hh->dyn_relocs == NULL)
+ if (eh->dyn_relocs == NULL)
return TRUE;
/* If this is a -Bsymbolic shared link, then we need to discard all
{
struct elf_dyn_relocs **hdh_pp;
- for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
+ for (hdh_pp = &eh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
hdh_p->count -= hdh_p->pc_count;
hdh_p->pc_count = 0;
/* Also discard relocs on undefined weak syms with non-default
visibility. */
- if (hh->dyn_relocs != NULL
+ if (eh->dyn_relocs != NULL
&& eh->root.type == bfd_link_hash_undefweak)
{
if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
- hh->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
/* Make sure undefined weak symbols are output as a dynamic
symbol in PIEs. */
goto keep;
}
- hh->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
return TRUE;
keep: ;
}
/* Finally, allocate space. */
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
+ for (hdh_p = eh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
return TRUE;
}
-/* Set DF_TEXTREL if we find any dynamic relocs that apply to
- read-only sections. */
-
-static bfd_boolean
-maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
-{
- asection *sec;
-
- if (h->root.type == bfd_link_hash_indirect)
- return TRUE;
-
- sec = readonly_dynrelocs (h);
- if (sec != NULL)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) info_p;
-
- 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;
- }
- return TRUE;
-}
-
/* Set the sizes of the dynamic sections. */
static bfd_boolean
/* 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->etab.srelplt)
relocs = TRUE;
/* 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->etab, maybe_set_textrel, info);
+ elf_link_hash_traverse (&htab->etab,
+ _bfd_elf_maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
/* Set the Meta ELF ABI version. */
-static void
-elf_metag_post_process_headers (bfd * abfd, struct bfd_link_info * link_info)
+static bfd_boolean
+elf_metag_init_file_header (bfd *abfd, struct bfd_link_info *link_info)
{
Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
- _bfd_elf_post_process_headers (abfd, link_info);
+ if (!_bfd_elf_init_file_header (abfd, link_info))
+ return FALSE;
+
i_ehdrp = elf_elfheader (abfd);
i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
+ return TRUE;
}
/* Used to decide how to sort relocs in an optimal manner for the
#define MOV_PC_A0_3 0xa3180ca0
static bfd_boolean
-metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
+metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
{
struct elf_metag_stub_hash_entry *hsh;
asection *stub_sec;
bfd_byte *loc;
bfd_vma sym_value;
int size;
+ struct bfd_link_info *info;
/* Massage our args to the form they really have. */
hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
+ info = (struct bfd_link_info *) in_arg;
+
+ /* Fail if the target section could not be assigned to an output
+ section. The user should fix his linker script. */
+ if (hsh->target_section->output_section == NULL
+ && info->non_contiguous_regions)
+ info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
+ "Retry without --enable-non-contiguous-regions.\n"),
+ hsh->target_section);
stub_sec = hsh->stub_sec;
unsigned int top_id, top_index;
asection *section;
asection **input_list, **list;
- bfd_size_type amt;
+ size_t amt;
struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
/* Count the number of input BFDs and find the top input section id. */
/* We want to read in symbol extension records only once. To do this
we need to read in the local symbols in parallel and save them for
later use; so hold pointers to the local symbols in an array. */
- bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
+ size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
all_local_syms = bfd_zmalloc (amt);
htab->all_local_syms = all_local_syms;
if (all_local_syms == NULL)
#define elf_backend_size_dynamic_sections elf_metag_size_dynamic_sections
#define elf_backend_omit_section_dynsym \
_bfd_elf_omit_section_dynsym_all
-#define elf_backend_post_process_headers elf_metag_post_process_headers
+#define elf_backend_init_file_header elf_metag_init_file_header
#define elf_backend_reloc_type_class elf_metag_reloc_type_class
#define elf_backend_copy_indirect_symbol elf_metag_copy_indirect_symbol
#define elf_backend_plt_sym_val elf_metag_plt_sym_val