/* 32-bit ELF support for TI C6X
- Copyright (C) 2010-2017 Free Software Foundation, Inc.
+ Copyright (C) 2010-2020 Free Software Foundation, Inc.
Contributed by Joseph Myers <joseph@codesourcery.com>
- Bernd Schmidt <bernds@codesourcery.com>
+ Bernd Schmidt <bernds@codesourcery.com>
This file is part of BFD, the Binary File Descriptor library.
#define elf32_tic6x_hash_table(p) \
((struct elf32_tic6x_link_hash_table *) ((p)->hash))
-/* TI C6X ELF linker hash entry. */
-
-struct elf32_tic6x_link_hash_entry
-{
- struct elf_link_hash_entry elf;
-
- /* Track dynamic relocs copied for this symbol. */
- struct elf_dyn_relocs *dyn_relocs;
-};
-
typedef enum
{
DELETE_EXIDX_ENTRY,
return NULL;
}
-static void
+static bfd_boolean
elf32_tic6x_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
Elf_Internal_Rela *elf_reloc)
{
r_type = ELF32_R_TYPE (elf_reloc->r_info);
if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table))
- bfd_reloc->howto = NULL;
- else
- bfd_reloc->howto = &elf32_tic6x_howto_table[r_type];
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
+ bfd_reloc->howto = &elf32_tic6x_howto_table[r_type];
+ if (bfd_reloc->howto == NULL || bfd_reloc->howto->name == NULL)
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
+ return TRUE;
}
-static void
+static bfd_boolean
elf32_tic6x_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
Elf_Internal_Rela *elf_reloc)
{
r_type = ELF32_R_TYPE (elf_reloc->r_info);
if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table_rel))
- bfd_reloc->howto = NULL;
- else
- bfd_reloc->howto = &elf32_tic6x_howto_table_rel[r_type];
-}
-
-void
-elf32_tic6x_set_use_rela_p (bfd *abfd, bfd_boolean use_rela_p)
-{
- elf32_tic6x_tdata (abfd)->use_rela_p = use_rela_p;
-}
-
-/* Create an entry in a C6X ELF linker hash table. */
-
-static struct bfd_hash_entry *
-elf32_tic6x_link_hash_newfunc (struct bfd_hash_entry *entry,
- struct bfd_hash_table *table,
- const char *string)
-{
- /* Allocate the structure if it has not already been allocated by a
- subclass. */
- if (entry == NULL)
{
- entry = bfd_hash_allocate (table,
- sizeof (struct elf32_tic6x_link_hash_entry));
- if (entry == NULL)
- return entry;
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
}
- /* Call the allocation method of the superclass. */
- entry = _bfd_elf_link_hash_newfunc (entry, table, string);
- if (entry != NULL)
+ bfd_reloc->howto = &elf32_tic6x_howto_table_rel[r_type];
+ if (bfd_reloc->howto == NULL || bfd_reloc->howto->name == NULL)
{
- struct elf32_tic6x_link_hash_entry *eh;
-
- eh = (struct elf32_tic6x_link_hash_entry *) entry;
- eh->dyn_relocs = NULL;
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
}
- return entry;
+ return TRUE;
+}
+
+void
+elf32_tic6x_set_use_rela_p (bfd *abfd, bfd_boolean use_rela_p)
+{
+ elf32_tic6x_tdata (abfd)->use_rela_p = use_rela_p;
}
/* Create a C6X ELF linker hash table. */
elf32_tic6x_link_hash_table_create (bfd *abfd)
{
struct elf32_tic6x_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct elf32_tic6x_link_hash_table);
+ size_t amt = sizeof (struct elf32_tic6x_link_hash_table);
ret = bfd_zmalloc (amt);
if (ret == NULL)
return NULL;
if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
- elf32_tic6x_link_hash_newfunc,
- sizeof (struct elf32_tic6x_link_hash_entry),
+ _bfd_elf_link_hash_newfunc,
+ sizeof (struct elf_link_hash_entry),
TIC6X_ELF_DATA))
{
free (ret);
htab->dsbt = bfd_make_section_anyway_with_flags (dynobj, ".dsbt",
flags);
if (htab->dsbt == NULL
- || ! bfd_set_section_alignment (dynobj, htab->dsbt, 2)
- || ! bfd_set_section_alignment (dynobj, htab->elf.splt, 5))
+ || !bfd_set_section_alignment (htab->dsbt, 2)
+ || !bfd_set_section_alignment (htab->elf.splt, 5))
return FALSE;
return TRUE;
asection *srela;
/* This symbol has an entry in the global offset table.
- Set it up. */
+ Set it up. */
sgot = htab->elf.sgot;
srela = htab->elf.srelgot;
BFD_ASSERT (sgot != NULL && srela != NULL);
/* If this is a -Bsymbolic link, and the symbol is defined
- locally, we just want to emit a RELATIVE reloc. Likewise if
- the symbol was forced to be local because of a version file.
- The entry in the global offset table will already have been
- initialized in the relocate_section function. */
+ locally, we just want to emit a RELATIVE reloc. Likewise if
+ the symbol was forced to be local because of a version file.
+ The entry in the global offset table will already have been
+ initialized in the relocate_section function. */
if (bfd_link_pic (info)
&& (SYMBOLIC_BIND (info, h)
|| h->dynindx == -1 || h->forced_local) && h->def_regular)
{
const char * name;
- name = bfd_get_section_name (abfd, sec);
+ name = bfd_section_name (sec);
if (is_tic6x_elf_unwind_section_name (name))
{
return TRUE;
}
-/* 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;
- struct elf32_tic6x_link_hash_entry *eh
- = (struct elf32_tic6x_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)
- 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 (!sec->used_by_bfd)
{
_tic6x_elf_section_data *sdata;
- bfd_size_type amt = sizeof (*sdata);
+ size_t amt = sizeof (*sdata);
sdata = (_tic6x_elf_section_data *) bfd_zalloc (abfd, amt);
if (sdata == NULL)
bfd_reloc_status_type r;
struct bfd_link_hash_entry *sbh;
bfd_boolean is_rel;
+ bfd_boolean res;
r_type = ELF32_R_TYPE (rel->r_info);
r_symndx = ELF32_R_SYM (rel->r_info);
relocs, rel);
if (is_rel)
- elf32_tic6x_info_to_howto_rel (input_bfd, &bfd_reloc, rel);
+ res = elf32_tic6x_info_to_howto_rel (input_bfd, &bfd_reloc, rel);
else
- elf32_tic6x_info_to_howto (input_bfd, &bfd_reloc, rel);
- howto = bfd_reloc.howto;
- if (howto == NULL)
+ res = elf32_tic6x_info_to_howto (input_bfd, &bfd_reloc, rel);
+
+ if (!res || (howto = bfd_reloc.howto) == NULL)
{
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
else
{
- _bfd_error_handler (_("%B: SB-relative relocation but "
+ _bfd_error_handler (_("%pB: SB-relative relocation but "
"__c6xabi_DSBT_BASE not defined"),
input_bfd);
ok = FALSE;
if (h == NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
- " against local symbol"),
+ (_("%pB, section %pA: relocation %s with non-zero addend %"
+ PRId64 " against local symbol"),
input_bfd,
input_section,
elf32_tic6x_howto_table[r_type].name,
- rel->r_addend);
+ (int64_t) rel->r_addend);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
- " against symbol `%s'"),
+ (_("%pB, section %pA: relocation %s with non-zero addend %"
+ PRId64 " against symbol `%s'"),
input_bfd,
input_section,
elf32_tic6x_howto_table[r_type].name,
- rel->r_addend,
+ (int64_t) rel->r_addend,
h->root.root.string[0] != '\0' ? h->root.root.string
: _("[whose name is lost]"));
default:
/* Unknown relocation. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
input_bfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
ok = FALSE;
continue;
}
if (name == NULL)
return FALSE;
if (*name == '\0')
- name = bfd_section_name (input_bfd, sec);
+ name = bfd_section_name (sec);
}
switch (r)
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
relocations we need for this symbol. */
if (h != NULL)
{
- head = &((struct elf32_tic6x_link_hash_entry *) h)->dyn_relocs;
+ head = &h->dyn_relocs;
}
else
{
p = *head;
if (p == NULL || p->sec != sec)
{
- bfd_size_type amt = sizeof *p;
+ size_t amt = sizeof *p;
p = bfd_alloc (htab->elf.dynobj, amt);
if (p == NULL)
return FALSE;
case R_C6000_SBR_H16_B:
case R_C6000_SBR_H16_H:
case R_C6000_SBR_H16_W:
+ {
+ /* These relocations implicitly reference __c6xabi_DSBT_BASE.
+ Add an explicit reference so that the symbol will be
+ provided by a linker script. */
+ struct bfd_link_hash_entry *bh = NULL;
+ if (!_bfd_generic_link_add_one_symbol (info, abfd,
+ "__c6xabi_DSBT_BASE",
+ BSF_GLOBAL,
+ bfd_und_section_ptr, 0,
+ NULL, FALSE, FALSE, &bh))
+ return FALSE;
+ ((struct elf_link_hash_entry *) bh)->non_elf = 0;
+ }
if (h != NULL && bfd_link_executable (info))
{
/* For B14-relative addresses, we might need a copy
*secp = bfd_make_section_old_way (abfd, ".scommon");
(*secp)->flags |= SEC_IS_COMMON;
*valp = sym->st_size;
- (void) bfd_set_section_alignment (abfd, *secp, bfd_log2 (sym->st_value));
+ bfd_set_section_alignment (*secp, bfd_log2 (sym->st_value));
break;
}
{
case SHN_TIC6X_SCOMMON:
if (tic6x_elf_scom_section.name == NULL)
- {
- /* Initialize the small common section. */
- tic6x_elf_scom_section.name = ".scommon";
- tic6x_elf_scom_section.flags = SEC_IS_COMMON;
- tic6x_elf_scom_section.output_section = &tic6x_elf_scom_section;
- tic6x_elf_scom_section.symbol = &tic6x_elf_scom_symbol;
- tic6x_elf_scom_section.symbol_ptr_ptr = &tic6x_elf_scom_symbol_ptr;
- tic6x_elf_scom_symbol.name = ".scommon";
- tic6x_elf_scom_symbol.flags = BSF_SECTION_SYM;
- tic6x_elf_scom_symbol.section = &tic6x_elf_scom_section;
- tic6x_elf_scom_symbol_ptr = &tic6x_elf_scom_symbol;
- }
+ {
+ /* Initialize the small common section. */
+ tic6x_elf_scom_section.name = ".scommon";
+ tic6x_elf_scom_section.flags = SEC_IS_COMMON;
+ tic6x_elf_scom_section.output_section = &tic6x_elf_scom_section;
+ tic6x_elf_scom_section.symbol = &tic6x_elf_scom_symbol;
+ tic6x_elf_scom_section.symbol_ptr_ptr = &tic6x_elf_scom_symbol_ptr;
+ tic6x_elf_scom_symbol.name = ".scommon";
+ tic6x_elf_scom_symbol.flags = BSF_SECTION_SYM;
+ tic6x_elf_scom_symbol.section = &tic6x_elf_scom_section;
+ tic6x_elf_scom_symbol_ptr = &tic6x_elf_scom_symbol;
+ }
asym->section = &tic6x_elf_scom_section;
asym->value = elfsym->internal_elf_sym.st_size;
break;
asection *sec,
int *retval)
{
- if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
+ if (strcmp (bfd_section_name (sec), ".scommon") == 0)
{
*retval = SHN_TIC6X_SCOMMON;
return TRUE;
{
struct bfd_link_info *info;
struct elf32_tic6x_link_hash_table *htab;
- struct elf32_tic6x_link_hash_entry *eh;
struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
- eh = (struct elf32_tic6x_link_hash_entry *) h;
info = (struct bfd_link_info *) inf;
htab = elf32_tic6x_hash_table (info);
else
h->got.offset = (bfd_vma) -1;
- if (eh->dyn_relocs == NULL)
+ if (h->dyn_relocs == NULL)
return TRUE;
/* Discard relocs on undefined weak syms with non-default
{
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 (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;
+ h->dyn_relocs = NULL;
/* Make sure undefined weak symbols are output as a dynamic
symbol in PIEs. */
}
/* 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;
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
if (s == htab->elf.splt && s->size > 0)
s->size = (s->size + 31) & ~(bfd_vma)31;
}
- 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->elf.srelplt)
/* 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->elf, maybe_set_textrel, info);
+ elf_link_hash_traverse (&htab->elf,
+ _bfd_elf_maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: error: unknown mandatory EABI object attribute %d"),
+ (_("%pB: error: unknown mandatory EABI object attribute %d"),
abfd, tag);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: unknown EABI object attribute %d"),
+ (_("%pB: warning: unknown EABI object attribute %d"),
abfd, tag);
return TRUE;
}
int i;
int array_align_in, array_align_out, array_expect_in, array_expect_out;
+ /* FIXME: What should be checked when linking shared libraries? */
+ if ((ibfd->flags & DYNAMIC) != 0)
+ return TRUE;
+
if (!elf_known_obj_attributes_proc (obfd)[0].i)
{
/* This is the first object. Copy the attributes. */
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more stack alignment than %B preserves"),
+ (_("error: %pB requires more stack alignment than %pB preserves"),
ibfd, obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more stack alignment than %B preserves"),
+ (_("error: %pB requires more stack alignment than %pB preserves"),
obfd, ibfd);
result = FALSE;
}
if (array_align_in == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
+ (_("error: unknown Tag_ABI_array_object_alignment value in %pB"),
ibfd);
result = FALSE;
}
if (array_align_out == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
+ (_("error: unknown Tag_ABI_array_object_alignment value in %pB"),
obfd);
result = FALSE;
}
if (array_expect_in == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
+ (_("error: unknown Tag_ABI_array_object_align_expected value in %pB"),
ibfd);
result = FALSE;
}
if (array_expect_out == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
+ (_("error: unknown Tag_ABI_array_object_align_expected value in %pB"),
obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more array alignment than %B preserves"),
+ (_("error: %pB requires more array alignment than %pB preserves"),
ibfd, obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more array alignment than %B preserves"),
+ (_("error: %pB requires more array alignment than %pB preserves"),
obfd, ibfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B and %B differ in wchar_t size"), obfd, ibfd);
+ (_("warning: %pB and %pB differ in wchar_t size"), obfd, ibfd);
}
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B and %B differ in whether code is "
+ (_("warning: %pB and %pB differ in whether code is "
"compiled for DSBT"),
obfd, ibfd);
}
case Tag_ABI_PIC:
case Tag_ABI_PID:
+ /* Don't transfer these tags from dynamic objects. */
+ if ((ibfd->flags & DYNAMIC) != 0)
+ continue;
if (out_attr[i].i > in_attr[i].i)
out_attr[i].i = in_attr[i].i;
break;
if (!exidx_sec->rawsize)
exidx_sec->rawsize = exidx_sec->size;
- bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
+ bfd_set_section_size (exidx_sec, exidx_sec->size + adjust);
out_sec = exidx_sec->output_section;
/* Adjust size of output section. */
- bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
+ bfd_set_section_size (out_sec, out_sec->size +adjust);
}
/* Insert an EXIDX_CANTUNWIND marker at the end of a section. */
1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
- codes which have been inlined into the index).
+ codes which have been inlined into the index).
If MERGE_EXIDX_ENTRIES is false, duplicate entries are not merged.
asection *sec;
for (sec = inp->sections; sec != NULL; sec = sec->next)
- {
+ {
struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
if (elf_sec->linked_to)
{
Elf_Internal_Shdr *linked_hdr
- = &elf_section_data (elf_sec->linked_to)->this_hdr;
+ = &elf_section_data (elf_sec->linked_to)->this_hdr;
struct _tic6x_elf_section_data *linked_sec_tic6x_data
- = get_tic6x_elf_section_data (linked_hdr->bfd_section);
+ = get_tic6x_elf_section_data (linked_hdr->bfd_section);
if (linked_sec_tic6x_data == NULL)
- continue;
+ continue;
/* Link this .c6xabi.exidx section back from the
text section it describes. */
asection *sec = text_section_order[i];
asection *exidx_sec;
struct _tic6x_elf_section_data *tic6x_data
- = get_tic6x_elf_section_data (sec);
+ = get_tic6x_elf_section_data (sec);
struct _tic6x_elf_section_data *exidx_data;
bfd_byte *contents = NULL;
int deleted_exidx_bytes = 0;
bfd *ibfd;
if (tic6x_data == NULL)
- continue;
+ continue;
exidx_sec = tic6x_data->u.text.tic6x_exidx_sec;
if (exidx_sec == NULL)
hdr = &elf_section_data (exidx_sec)->this_hdr;
if (hdr->sh_type != SHT_C6000_UNWIND)
- continue;
+ continue;
exidx_data = get_tic6x_elf_section_data (exidx_sec);
if (exidx_data == NULL)
- continue;
+ continue;
ibfd = exidx_sec->owner;
/* Free contents if we allocated it ourselves. */
if (contents != hdr->contents)
- free (contents);
+ free (contents);
/* Record edits to be applied later (in elf32_tic6x_write_section). */
exidx_data->u.exidx.unwind_edit_list = unwind_edit_head;
elf32_tic6x_create_dynamic_sections
#define elf_backend_adjust_dynamic_symbol \
elf32_tic6x_adjust_dynamic_symbol
-#define elf_backend_check_relocs elf32_tic6x_check_relocs
+#define elf_backend_check_relocs elf32_tic6x_check_relocs
#define elf_backend_add_symbol_hook elf32_tic6x_add_symbol_hook
#define elf_backend_symbol_processing elf32_tic6x_symbol_processing
#define elf_backend_link_output_symbol_hook \
projects / deliverable / binutils-gdb.git / blobdiff