/* Matsushita 10300 specific support for 32-bit ELF
- Copyright (C) 1996-2016 Free Software Foundation, Inc.
+ Copyright (C) 1996-2020 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
struct
{
bfd_signed_vma refcount;
- bfd_vma offset;
- char got_allocated;
- char rel_emitted;
+ bfd_vma offset;
+ char got_allocated;
+ char rel_emitted;
} tls_ldm_got;
};
FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont,/* complain_on_overflow */
- NULL, /* special handler. */
+ NULL, /* special handler. */
"R_MN10300_SYM_DIFF", /* name */
FALSE, /* partial_inplace */
0xffffffff, /* src_mask */
FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont,/* complain_on_overflow */
- NULL, /* special handler. */
+ NULL, /* special handler. */
"R_MN10300_ALIGN", /* name */
FALSE, /* partial_inplace */
0, /* src_mask */
s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
htab->splt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+ || !bfd_set_section_alignment (s, bed->plt_alignment))
return FALSE;
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
htab->sgot = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
if (bed->want_got_plt)
s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
htab->sgotplt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
}
/* Set the howto pointer for an MN10300 ELF reloc. */
-static void
-mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
+static bfd_boolean
+mn10300_info_to_howto (bfd *abfd,
arelent *cache_ptr,
Elf_Internal_Rela *dst)
{
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_MN10300_MAX)
{
- (*_bfd_error_handler) (_("%B: unrecognised MN10300 reloc number: %d"),
- abfd, r_type);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
- r_type = R_MN10300_NONE;
+ return FALSE;
}
cache_ptr->howto = elf_mn10300_howto_table + r_type;
+ return TRUE;
}
static int
-elf_mn10300_tls_transition (struct bfd_link_info * info,
- int r_type,
+elf_mn10300_tls_transition (struct bfd_link_info * info,
+ int r_type,
struct elf_link_hash_entry * h,
- asection * sec,
- bfd_boolean counting)
+ asection * sec,
+ bfd_boolean counting)
{
bfd_boolean is_local;
this reloc and the PLT reloc. */
static int
-mn10300_do_tls_transition (bfd * input_bfd,
- unsigned int r_type,
- unsigned int tls_r_type,
- bfd_byte * contents,
- bfd_vma offset)
+mn10300_do_tls_transition (bfd * input_bfd,
+ unsigned int r_type,
+ unsigned int tls_r_type,
+ bfd_byte * contents,
+ bfd_vma offset)
{
bfd_byte *op = contents + offset;
int gotreg = 0;
accordingly, copying the operands as needed. The conversions
we do are as follows (IE,GOTIE,LE):
- 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
- 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
- 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
+ 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
+ 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
+ 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
- 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
- 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
- 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
+ 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
+ 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
+ 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
1111 1110 0000 1110 Rnnn Xxxx [-- abs32 --] MOV (x@indntpoff),Rn
1111 1110 0000 1010 Rnnn Rmmm [-- abs32 --] MOV (x@indntpoff,Rm),Rn
break;
default:
- (*_bfd_error_handler)
- (_("%s: Unsupported transition from %s to %s"),
- bfd_get_filename (input_bfd),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: unsupported transition from %s to %s"),
+ input_bfd,
elf_mn10300_howto_table[r_type].name,
elf_mn10300_howto_table[tls_r_type].name);
break;
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
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 = 1;
}
r_type = ELF32_R_TYPE (rel->r_info);
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_MN10300_GNU_VTENTRY:
- BFD_ASSERT (h != NULL);
- if (h != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
goto fail;
break;
case R_MN10300_TLS_IE:
case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break;
case R_MN10300_TLS_GD: tls_type = GOT_TLS_GD; break;
- default: tls_type = GOT_NORMAL; break;
+ default: tls_type = GOT_NORMAL; break;
}
- if (sgot == NULL)
- {
- sgot = htab->root.sgot;
- BFD_ASSERT (sgot != NULL);
- }
-
- if (srelgot == NULL
- && (h != NULL || bfd_link_pic (info)))
- {
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
- if (srelgot == NULL)
- {
- flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY | SEC_LINKER_CREATED
- | SEC_READONLY);
- srelgot = bfd_make_section_anyway_with_flags (dynobj,
- ".rela.got",
- flags);
- if (srelgot == NULL
- || ! bfd_set_section_alignment (dynobj, srelgot, 2))
- goto fail;
- }
- }
+ sgot = htab->root.sgot;
+ srelgot = htab->root.srelgot;
+ BFD_ASSERT (sgot != NULL && srelgot != NULL);
if (r_type == R_MN10300_TLS_LD)
{
/* Transition GD->IE. */
tls_type = GOT_TLS_IE;
else
- (*_bfd_error_handler)
- (_("%B: %s' accessed both as normal and thread local symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
}
result = TRUE;
fail:
- if (isymbuf != NULL)
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
return result;
&& h != NULL
&& ! SYMBOL_REFERENCES_LOCAL (info, h))
return bfd_reloc_dangerous;
+ /* Fall through. */
case R_MN10300_GOT32:
/* Issue 2052223:
Taking the address of a protected function in a shared library
/* Do not generate relocs when an R_MN10300_32 has been used
with an R_MN10300_SYM_DIFF to compute a difference of two
symbols. */
- && is_sym_diff_reloc == FALSE
+ && !is_sym_diff_reloc
/* Also, do not generate a reloc when the symbol associated
with the R_MN10300_32 reloc is absolute - there is no
need for a run time computation in this case. */
if (!htab->tls_ldm_got.rel_emitted)
{
- asection * srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ asection *srelgot = htab->root.srelgot;
Elf_Internal_Rela rel;
BFD_ASSERT (srelgot != NULL);
if (bfd_link_pic (info))
{
- asection * srelgot;
+ asection *srelgot = htab->root.srelgot;;
Elf_Internal_Rela outrel;
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
BFD_ASSERT (srelgot != NULL);
outrel.r_offset = (sgot->output_section->vma
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
h->root.root.root.string);
}
name = (bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name));
if (name == NULL || *name == '\0')
- name = bfd_section_name (input_bfd, sec);
+ name = bfd_section_name (sec);
}
switch (r)
{
case bfd_reloc_overflow:
- if (! ((*info->callbacks->reloc_overflow)
- (info, (h ? &h->root.root : NULL), name,
- howto->name, (bfd_vma) 0, input_bfd,
- input_section, rel->r_offset)))
- return FALSE;
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root.root : NULL), name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- if (! ((*info->callbacks->undefined_symbol)
- (info, name, input_bfd, input_section,
- rel->r_offset, TRUE)))
- return FALSE;
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_outofrange:
msg = _("error: inappropriate relocation type for shared"
" library (did you forget -fpic?)");
else if (r_type == R_MN10300_GOT32)
- msg = _("%B: taking the address of protected function"
+ /* xgettext:c-format */
+ msg = _("%pB: taking the address of protected function"
" '%s' cannot be done when making a shared library");
else
msg = _("internal error: suspicious relocation type used"
if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
--irelend;
- /* 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, or not a multiple of, the number of bytes we
are deleting. */
for (; irel < irelend; irel++)
There are quite a few relaxing opportunities available on the mn10300:
- * calls:32 -> calls:16 2 bytes
+ * calls:32 -> calls:16 2 bytes
* call:32 -> call:16 2 bytes
* call:32 -> calls:32 1 byte
/* A local symbol. */
Elf_Internal_Sym *isym;
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
isym = isymbuf + r_index;
if (isym->st_shndx == SHN_UNDEF)
&& ELF_ST_TYPE (isym->st_info) == STT_FUNC)
{
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
struct elf_link_hash_entry **lhashes = hashes;
/* Skip a local symbol if it aliases a
}
/* Cache or free any memory we allocated for the relocs. */
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
internal_relocs = NULL;
const char *sym_name;
char *new_name;
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
if (isym->st_shndx != sec_shndx)
continue;
}
/* Cache or free any memory we allocated for the relocs. */
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
internal_relocs = NULL;
}
}
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
+ if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
return TRUE;
error_return:
- if (isymbuf != NULL
- && symtab_hdr->contents != (unsigned char *) isymbuf)
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (contents != NULL
- && elf_section_data (section)->this_hdr.contents != contents)
+ if (elf_section_data (section)->this_hdr.contents != contents)
free (contents);
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
return FALSE;
isymbuf, sections))
goto error_return;
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
if (internal_relocs != elf_section_data (input_section)->relocs)
free (internal_relocs);
return data;
error_return:
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (internal_relocs != NULL
- && internal_relocs != elf_section_data (input_section)->relocs)
+ if (internal_relocs != elf_section_data (input_section)->relocs)
free (internal_relocs);
return NULL;
}
}
static void
-_bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
- struct elf_link_hash_entry * dir,
- struct elf_link_hash_entry * ind)
+_bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
+ struct elf_link_hash_entry * dir,
+ struct elf_link_hash_entry * ind)
{
struct elf32_mn10300_link_hash_entry * edir;
struct elf32_mn10300_link_hash_entry * eind;
elf32_mn10300_link_hash_table_create (bfd *abfd)
{
struct elf32_mn10300_link_hash_table *ret;
- bfd_size_type amt = sizeof (* ret);
+ size_t amt = sizeof (* ret);
ret = bfd_zmalloc (amt);
if (ret == NULL)
file. This gets the MN10300 architecture right based on the machine
number. */
-static void
-_bfd_mn10300_elf_final_write_processing (bfd *abfd,
- bfd_boolean linker ATTRIBUTE_UNUSED)
+static bfd_boolean
+_bfd_mn10300_elf_final_write_processing (bfd *abfd)
{
unsigned long val;
elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
elf_elfheader (abfd)->e_flags |= val;
+ return _bfd_elf_final_write_processing (abfd);
}
static bfd_boolean
object file when linking. */
static bfd_boolean
-_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
+
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return TRUE;
flags | SEC_READONLY);
htab->root.srelplt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
if (! _bfd_mn10300_elf_create_got_section (abfd, info))
? ".rela.bss" : ".rel.bss"),
flags | SEC_READONLY);
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
}
}
/* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL
&& (h->needs_plt
- || h->u.weakdef != NULL
+ || h->is_weakalias
|| (h->def_dynamic
&& h->ref_regular
&& !h->def_regular)));
s->size += 4;
/* We also need to make an entry in the .rela.plt section. */
- s = bfd_get_linker_section (dynobj, ".rela.plt");
+ s = htab->root.srelplt;
BFD_ASSERT (s != NULL);
s->size += sizeof (Elf32_External_Rela);
/* 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;
return TRUE;
}
if (elf_hash_table (info)->dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (bfd_link_executable (info))
+ if (bfd_link_executable (info) && !info->nointerp)
{
s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
if (htab->tls_ldm_got.refcount > 0)
{
- s = bfd_get_linker_section (dynobj, ".rela.got");
+ s = htab->root.srelgot;
BFD_ASSERT (s != NULL);
s->size += sizeof (Elf32_External_Rela);
}
/* It's OK to base decisions on the section name, because none
of the dynobj section names depend upon the input files. */
- name = bfd_get_section_name (dynobj, s);
+ name = bfd_section_name (s);
if (streq (name, ".plt"))
{
entry. The entries in the .rela.plt section
really apply to the .got section, which we
created ourselves and so know is not readonly. */
- outname = bfd_get_section_name (output_bfd,
- s->output_section);
+ outname = bfd_section_name (s->output_section);
target = bfd_get_section_by_name (output_bfd, outname + 5);
if (target != NULL
&& (target->flags & SEC_READONLY) != 0
if (h->plt.offset != (bfd_vma) -1)
{
- asection * splt;
- asection * sgot;
- asection * srel;
- bfd_vma plt_index;
- bfd_vma got_offset;
+ asection * splt;
+ asection * sgot;
+ asection * srel;
+ bfd_vma plt_index;
+ bfd_vma got_offset;
Elf_Internal_Rela rel;
/* This symbol has an entry in the procedure linkage table. Set
splt = htab->root.splt;
sgot = htab->root.sgotplt;
- srel = bfd_get_linker_section (dynobj, ".rela.plt");
+ srel = htab->root.srelplt;
BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
/* Get the index in the procedure linkage table which
if (h->got.offset != (bfd_vma) -1)
{
- asection * sgot;
- asection * srel;
+ asection * sgot;
+ asection * srel;
Elf_Internal_Rela rel;
/* This symbol has an entry in the global offset table. Set it up. */
sgot = htab->root.sgot;
- srel = bfd_get_linker_section (dynobj, ".rela.got");
+ srel = htab->root.srelgot;
BFD_ASSERT (sgot != NULL && srel != NULL);
rel.r_offset = (sgot->output_section->vma
if (h->needs_copy)
{
- asection * s;
+ asection * s;
Elf_Internal_Rela rel;
/* This symbol needs a copy reloc. Set it up. */
if (elf_hash_table (info)->dynamic_sections_created)
{
- asection * splt;
+ asection * splt;
Elf32_External_Dyn * dyncon;
Elf32_External_Dyn * dynconend;
for (; dyncon < dynconend; dyncon++)
{
Elf_Internal_Dyn dyn;
- const char * name;
asection * s;
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
break;
case DT_PLTGOT:
- name = ".got";
+ s = htab->root.sgot;
goto get_vma;
case DT_JMPREL:
- name = ".rela.plt";
+ s = htab->root.srelplt;
get_vma:
- s = bfd_get_linker_section (dynobj, name);
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_PLTRELSZ:
- s = bfd_get_linker_section (dynobj, ".rela.plt");
+ s = htab->root.srelplt;
dyn.d_un.d_val = s->size;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
-
- case DT_RELASZ:
- /* My reading of the SVR4 ABI indicates that the
- procedure linkage table relocs (DT_JMPREL) should be
- included in the overall relocs (DT_RELA). This is
- what Solaris does. However, UnixWare can not handle
- that case. Therefore, we override the DT_RELASZ entry
- here to make it not include the JMPREL relocs. Since
- the linker script arranges for .rela.plt to follow all
- other relocation sections, we don't have to worry
- about changing the DT_RELA entry. */
- s = bfd_get_linker_section (dynobj, ".rela.plt");
- if (s != NULL)
- dyn.d_un.d_val -= s->size;
- bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
- break;
}
}
#endif
#define elf_info_to_howto mn10300_info_to_howto
-#define elf_info_to_howto_rel 0
+#define elf_info_to_howto_rel NULL
#define elf_backend_can_gc_sections 1
#define elf_backend_rela_normal 1
#define elf_backend_check_relocs mn10300_elf_check_relocs
_bfd_mn10300_elf_adjust_dynamic_symbol
#define elf_backend_size_dynamic_sections \
_bfd_mn10300_elf_size_dynamic_sections
-#define elf_backend_omit_section_dynsym \
- ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
+#define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
#define elf_backend_finish_dynamic_symbol \
_bfd_mn10300_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections \
#define elf_backend_plt_readonly 1
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 12
+#define elf_backend_dtrel_excludes_plt 1
#include "elf32-target.h"
projects / thirdparty / binutils-gdb.git / blobdiff