/* 32-bit ELF support for TI C6X
- Copyright (C) 2010-2018 Free Software Foundation, Inc.
+ Copyright (C) 2010-2021 Free Software Foundation, Inc.
Contributed by Joseph Myers <joseph@codesourcery.com>
Bernd Schmidt <bernds@codesourcery.com>
/* C6X specific command line arguments. */
struct elf32_tic6x_params params;
- /* Small local sym cache. */
- struct sym_cache sym_cache;
-
/* The output BFD, for convenience. */
bfd *obfd;
#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,
faster assembler code. This is what we use for the small common
section. This approach is copied from ecoff.c. */
static asection tic6x_elf_scom_section;
-static asymbol tic6x_elf_scom_symbol;
-static asymbol *tic6x_elf_scom_symbol_ptr;
+static const asymbol tic6x_elf_scom_symbol =
+ GLOBAL_SYM_INIT (".scommon", &tic6x_elf_scom_section);
+static asection tic6x_elf_scom_section =
+ BFD_FAKE_SECTION (tic6x_elf_scom_section, &tic6x_elf_scom_symbol,
+ ".scommon", 0, SEC_IS_COMMON | SEC_SMALL_DATA);
static reloc_howto_type elf32_tic6x_howto_table[] =
{
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;
{
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;
default:
/* Unknown relocation. */
/* xgettext:c-format */
- _bfd_error_handler (_("%pB: 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 < symtab_hdr->sh_info)
{
/* A local symbol. */
- isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
abfd, r_symndx);
if (isym == NULL)
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
{
case SHN_TIC6X_SCOMMON:
*secp = bfd_make_section_old_way (abfd, ".scommon");
- (*secp)->flags |= SEC_IS_COMMON;
+ (*secp)->flags |= SEC_IS_COMMON | SEC_SMALL_DATA;
*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;
}
switch (elfsym->internal_elf_sym.st_shndx)
{
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;
- }
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
- (_("%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;
- }
- 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)
#define add_dynamic_entry(TAG, VAL) \
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
- if (bfd_link_executable (info))
- {
- if (!add_dynamic_entry (DT_DEBUG, 0))
- return FALSE;
- }
+ if (!_bfd_elf_add_dynamic_tags (output_bfd, info, relocs))
+ return FALSE;
if (!add_dynamic_entry (DT_C6000_DSBT_BASE, 0)
|| !add_dynamic_entry (DT_C6000_DSBT_SIZE, htab->params.dsbt_size)
htab->params.dsbt_index))
return FALSE;
- if (htab->elf.splt->size != 0)
- {
- if (!add_dynamic_entry (DT_PLTGOT, 0)
- || !add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_RELA)
- || !add_dynamic_entry (DT_JMPREL, 0))
- return FALSE;
- }
-
- if (relocs)
- {
- if (!add_dynamic_entry (DT_RELA, 0)
- || !add_dynamic_entry (DT_RELASZ, 0)
- || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
- 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->elf, maybe_set_textrel, info);
-
- if ((info->flags & DF_TEXTREL) != 0)
- {
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- }
- }
}
#undef add_dynamic_entry
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. */
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. */
return TRUE;
}
+#define elf32_bed elf32_tic6x_bed
+
#define TARGET_LITTLE_SYM tic6x_elf32_le_vec
#define TARGET_LITTLE_NAME "elf32-tic6x-le"
#define TARGET_BIG_SYM tic6x_elf32_be_vec
projects / deliverable / binutils-gdb.git / blobdiff