/* TILEPro-specific support for 32-bit ELF.
- Copyright 2011 Free Software Foundation, Inc.
+ Copyright (C) 2011-2016 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/tilepro.h"
/* This reloc does nothing. */
HOWTO (R_TILEPRO_NONE, /* type */
0, /* rightshift */
- 2, /* size (0 = byte, 1 = short, 2 = long) */
- 32, /* bitsize */
+ 3, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
FALSE, /* pc_relative */
0, /* bitpos */
- complain_overflow_bitfield, /* complain_on_overflow */
+ complain_overflow_dont, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_TILEPRO_NONE", /* name */
FALSE, /* partial_inplace */
EMPTY_HOWTO (57),
EMPTY_HOWTO (58),
EMPTY_HOWTO (59),
- EMPTY_HOWTO (60),
- EMPTY_HOWTO (61),
- EMPTY_HOWTO (62),
- EMPTY_HOWTO (63),
- EMPTY_HOWTO (64),
- EMPTY_HOWTO (65),
+
+ HOWTO (R_TILEPRO_TLS_GD_CALL, /* type */
+ TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 29, /* bitsize */
+ TRUE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_signed,/* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_TILEPRO_TLS_GD_CALL", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ -1, /* dst_mask */
+ TRUE), /* pcrel_offset */
+
+ TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X0_TLS_GD_ADD, 0, 8),
+ TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X1_TLS_GD_ADD, 0, 8),
+ TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y0_TLS_GD_ADD, 0, 8),
+ TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y1_TLS_GD_ADD, 0, 8),
+ TILEPRO_IMM_HOWTO(R_TILEPRO_TLS_IE_LOAD, 0, 8),
/* Offsets into the GOT of TLS Descriptors. */
-1, /* dst_mask */
TRUE), /* pcrel_offset */
-#define TILEPRO_IMM16_HOWTO_TLS_IE(name, rshift) \
- HOWTO (name, rshift, 1, 16, FALSE, 0, \
- complain_overflow_dont, bfd_elf_generic_reloc, \
- #name, FALSE, 0, 0xffff, TRUE)
-
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_LO, 0),
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_LO, 0),
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_HI, 16),
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_HI, 16),
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_HA, 16),
- TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_HA, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_LO, 0),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_LO, 0),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_HI, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_HI, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_HA, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_HA, 16),
/* These are common with the Solaris TLS implementation. */
HOWTO(R_TILEPRO_TLS_DTPMOD32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
FALSE, 0, 0xFFFFFFFF, TRUE),
HOWTO(R_TILEPRO_TLS_TPOFF32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
bfd_elf_generic_reloc, "R_TILEPRO_TLS_TPOFF32",
- FALSE, 0, 0, TRUE)
+ FALSE, 0, 0, TRUE),
+
+ HOWTO (R_TILEPRO_IMM16_X0_TLS_LE,/* type */
+ 0, /* rightshift */
+ 1, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_signed, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_TILEPRO_IMM16_X0_TLS_LE",/* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ -1, /* dst_mask */
+ TRUE), /* pcrel_offset */
+ HOWTO (R_TILEPRO_IMM16_X1_TLS_LE,/* type */
+ 0, /* rightshift */
+ 1, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_signed, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_TILEPRO_IMM16_X1_TLS_LE",/* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ -1, /* dst_mask */
+ TRUE), /* pcrel_offset */
+
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_LO, 0),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_LO, 0),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_HI, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_HI, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_HA, 16),
+ TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_HA, 16),
};
static reloc_howto_type tilepro_elf_howto_table2 [] =
TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y0, R_TILEPRO_SHAMT_Y0)
TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y1, R_TILEPRO_SHAMT_Y1)
+ TH_REMAP (BFD_RELOC_TILEPRO_TLS_GD_CALL, R_TILEPRO_TLS_GD_CALL)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD, R_TILEPRO_IMM8_X0_TLS_GD_ADD)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD, R_TILEPRO_IMM8_X1_TLS_GD_ADD)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD, R_TILEPRO_IMM8_Y0_TLS_GD_ADD)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD, R_TILEPRO_IMM8_Y1_TLS_GD_ADD)
+ TH_REMAP (BFD_RELOC_TILEPRO_TLS_IE_LOAD, R_TILEPRO_TLS_IE_LOAD)
+
TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD, R_TILEPRO_IMM16_X0_TLS_GD)
TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD, R_TILEPRO_IMM16_X1_TLS_GD)
TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO, R_TILEPRO_IMM16_X0_TLS_GD_LO)
TH_REMAP (BFD_RELOC_TILEPRO_TLS_DTPOFF32, R_TILEPRO_TLS_DTPOFF32)
TH_REMAP (BFD_RELOC_TILEPRO_TLS_TPOFF32, R_TILEPRO_TLS_TPOFF32)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE, R_TILEPRO_IMM16_X0_TLS_LE)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE, R_TILEPRO_IMM16_X1_TLS_LE)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO, R_TILEPRO_IMM16_X0_TLS_LE_LO)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO, R_TILEPRO_IMM16_X1_TLS_LE_LO)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI, R_TILEPRO_IMM16_X0_TLS_LE_HI)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI, R_TILEPRO_IMM16_X1_TLS_LE_HI)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA, R_TILEPRO_IMM16_X0_TLS_LE_HA)
+ TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA, R_TILEPRO_IMM16_X1_TLS_LE_HA)
+
#undef TH_REMAP
{ BFD_RELOC_VTABLE_INHERIT, R_TILEPRO_GNU_VTINHERIT, tilepro_elf_howto_table2 },
&& elf_tdata (bfd) != NULL \
&& elf_object_id (bfd) == TILEPRO_ELF_DATA)
+/* Allocate TILEPro ELF private object data. */
+
+static bfd_boolean
+tilepro_elf_mkobject (bfd *abfd)
+{
+ return bfd_elf_allocate_object (abfd,
+ sizeof (struct _bfd_tilepro_elf_obj_tdata),
+ TILEPRO_ELF_DATA);
+}
+
#include "elf/common.h"
#include "elf/internal.h"
{
unsigned int i;
- for (i = ARRAY_SIZE (tilepro_reloc_map); --i;)
+ for (i = ARRAY_SIZE (tilepro_reloc_map); i--;)
{
const reloc_map * entry;
{
unsigned int r_type = ELF32_R_TYPE (dst->r_info);
- if (r_type <= (unsigned int) R_TILEPRO_TLS_TPOFF32)
+ if (r_type <= (unsigned int) R_TILEPRO_IMM16_X1_TLS_LE_HA)
cache_ptr->howto = &tilepro_elf_howto_table [r_type];
else if (r_type - R_TILEPRO_GNU_VTINHERIT
<= (unsigned int) R_TILEPRO_GNU_VTENTRY)
create_Imm16_X0,
create_Imm16_X1,
create_Imm16_X0,
- create_Imm16_X1
+ create_Imm16_X1,
+
+ NULL,
+ NULL,
+ NULL,
+
+ create_Imm16_X0,
+ create_Imm16_X1,
+ create_Imm16_X0,
+ create_Imm16_X1,
+ create_Imm16_X0,
+ create_Imm16_X1,
+ create_Imm16_X0,
+ create_Imm16_X1,
};
#define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
return FALSE;
/* pr_cursig */
- elf_tdata (abfd)->core_signal =
+ elf_tdata (abfd)->core->signal =
bfd_get_16 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_CURSIG);
/* pr_pid */
- elf_tdata (abfd)->core_pid =
+ elf_tdata (abfd)->core->pid =
bfd_get_32 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_PID);
/* pr_reg */
if (note->descsz != TILEPRO_PRPSINFO_SIZEOF)
return FALSE;
- elf_tdata (abfd)->core_program
+ elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd,
note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_FNAME,
16);
- elf_tdata (abfd)->core_command
+ elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd,
note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_PSARGS,
ELF_PR_PSARGS_SIZE);
onto the end of the args in some (at least one anyway)
implementations, so strip it off if it exists. */
{
- char *command = elf_tdata (abfd)->core_command;
+ char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
tilepro_plt_entry_build (asection *splt, asection *sgotplt, bfd_vma offset,
bfd_vma *r_offset)
{
- int plt_index = (offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
+ int plt_index = (offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
int got_offset = plt_index * GOT_ENTRY_SIZE + GOTPLT_HEADER_SIZE;
tilepro_bundle_bits *pc;
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
- s = bfd_get_section_by_name (abfd, ".got");
- if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
+ if (htab->sgot != NULL)
return TRUE;
flags = bed->dynamic_sec_flags;
if (!_bfd_elf_create_dynamic_sections (dynobj, info))
return FALSE;
- htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
- if (!info->shared)
- htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
+ htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
+ if (!bfd_link_pic (info))
+ htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
- || (!info->shared && !htab->srelbss))
+ || (!bfd_link_pic (info) && !htab->srelbss))
abort ();
return TRUE;
_bfd_elf_link_hash_copy_indirect (info, dir, ind);
}
+static int
+tilepro_tls_translate_to_le (int r_type)
+{
+ switch (r_type)
+ {
+ case R_TILEPRO_IMM16_X0_TLS_GD:
+ case R_TILEPRO_IMM16_X0_TLS_IE:
+ return R_TILEPRO_IMM16_X0_TLS_LE;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD:
+ case R_TILEPRO_IMM16_X1_TLS_IE:
+ return R_TILEPRO_IMM16_X1_TLS_LE;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_LO:
+ case R_TILEPRO_IMM16_X0_TLS_IE_LO:
+ return R_TILEPRO_IMM16_X0_TLS_LE_LO;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_LO:
+ case R_TILEPRO_IMM16_X1_TLS_IE_LO:
+ return R_TILEPRO_IMM16_X1_TLS_LE_LO;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_HI:
+ case R_TILEPRO_IMM16_X0_TLS_IE_HI:
+ return R_TILEPRO_IMM16_X0_TLS_LE_HI;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_HI:
+ case R_TILEPRO_IMM16_X1_TLS_IE_HI:
+ return R_TILEPRO_IMM16_X1_TLS_LE_HI;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X0_TLS_IE_HA:
+ return R_TILEPRO_IMM16_X0_TLS_LE_HA;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X1_TLS_IE_HA:
+ return R_TILEPRO_IMM16_X1_TLS_LE_HA;
+ }
+ return r_type;
+}
+
+static int
+tilepro_tls_translate_to_ie (int r_type)
+{
+ switch (r_type)
+ {
+ case R_TILEPRO_IMM16_X0_TLS_GD:
+ case R_TILEPRO_IMM16_X0_TLS_IE:
+ return R_TILEPRO_IMM16_X0_TLS_IE;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD:
+ case R_TILEPRO_IMM16_X1_TLS_IE:
+ return R_TILEPRO_IMM16_X1_TLS_IE;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_LO:
+ case R_TILEPRO_IMM16_X0_TLS_IE_LO:
+ return R_TILEPRO_IMM16_X0_TLS_IE_LO;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_LO:
+ case R_TILEPRO_IMM16_X1_TLS_IE_LO:
+ return R_TILEPRO_IMM16_X1_TLS_IE_LO;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_HI:
+ case R_TILEPRO_IMM16_X0_TLS_IE_HI:
+ return R_TILEPRO_IMM16_X0_TLS_IE_HI;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_HI:
+ case R_TILEPRO_IMM16_X1_TLS_IE_HI:
+ return R_TILEPRO_IMM16_X1_TLS_IE_HI;
+
+ case R_TILEPRO_IMM16_X0_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X0_TLS_IE_HA:
+ return R_TILEPRO_IMM16_X0_TLS_IE_HA;
+
+ case R_TILEPRO_IMM16_X1_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X1_TLS_IE_HA:
+ return R_TILEPRO_IMM16_X1_TLS_IE_HA;
+ }
+ return r_type;
+}
+
+static int
+tilepro_elf_tls_transition (struct bfd_link_info *info, int r_type,
+ int is_local)
+{
+ if (bfd_link_pic (info))
+ return r_type;
+
+ if (is_local)
+ return tilepro_tls_translate_to_le (r_type);
+ else
+ return tilepro_tls_translate_to_ie (r_type);
+}
+
/* Look through the relocs for a section during the first phase, and
allocate space in the global offset table or procedure linkage
table. */
struct tilepro_elf_link_hash_table *htab;
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
- bfd_vma *local_got_offsets;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
asection *sreloc;
int num_relocs;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
htab = tilepro_elf_hash_table (info);
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
- local_got_offsets = elf_local_got_offsets (abfd);
sreloc = NULL;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
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 = tilepro_elf_tls_transition (info, r_type, h == NULL);
switch (r_type)
{
+ case R_TILEPRO_IMM16_X0_TLS_LE:
+ case R_TILEPRO_IMM16_X1_TLS_LE:
+ case R_TILEPRO_IMM16_X0_TLS_LE_LO:
+ case R_TILEPRO_IMM16_X1_TLS_LE_LO:
+ case R_TILEPRO_IMM16_X0_TLS_LE_HI:
+ case R_TILEPRO_IMM16_X1_TLS_LE_HI:
+ case R_TILEPRO_IMM16_X0_TLS_LE_HA:
+ case R_TILEPRO_IMM16_X1_TLS_LE_HA:
+ if (bfd_link_pic (info))
+ goto r_tilepro_plt32;
+ break;
+
case R_TILEPRO_IMM16_X0_TLS_GD:
case R_TILEPRO_IMM16_X1_TLS_GD:
case R_TILEPRO_IMM16_X0_TLS_GD_LO:
case R_TILEPRO_IMM16_X1_TLS_GD_HI:
case R_TILEPRO_IMM16_X0_TLS_GD_HA:
case R_TILEPRO_IMM16_X1_TLS_GD_HA:
- tls_type = GOT_TLS_GD;
+ BFD_ASSERT (bfd_link_pic (info));
+ tls_type = GOT_TLS_GD;
goto have_got_reference;
case R_TILEPRO_IMM16_X0_TLS_IE:
case R_TILEPRO_IMM16_X0_TLS_IE_HA:
case R_TILEPRO_IMM16_X1_TLS_IE_HA:
tls_type = GOT_TLS_IE;
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
goto have_got_reference;
tls_type = old_tls_type;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
}
break;
+ case R_TILEPRO_TLS_GD_CALL:
+ if (bfd_link_pic (info))
+ {
+ /* These are basically R_TILEPRO_JOFFLONG_X1_PLT relocs
+ against __tls_get_addr. */
+ struct bfd_link_hash_entry *bh = NULL;
+ if (! _bfd_generic_link_add_one_symbol (info, abfd,
+ "__tls_get_addr", 0,
+ bfd_und_section_ptr, 0,
+ NULL, FALSE, FALSE,
+ &bh))
+ return FALSE;
+ h = (struct elf_link_hash_entry *) bh;
+ }
+ else
+ break;
+ /* Fall through */
+
case R_TILEPRO_JOFFLONG_X1_PLT:
/* This symbol requires a procedure linkage table entry. We
actually build the entry in adjust_dynamic_symbol,
case R_TILEPRO_SHAMT_Y0:
case R_TILEPRO_SHAMT_Y1:
if (h != NULL)
- {
h->non_got_ref = 1;
- if (!info->shared)
- {
- /* We may need a .plt entry if the function this reloc
- refers to is in a shared lib. */
- h->plt.refcount += 1;
- }
+ r_tilepro_plt32:
+ if (h != NULL && !bfd_link_pic (info))
+ {
+ /* We may need a .plt entry if the function this reloc
+ refers to is in a shared lib. */
+ h->plt.refcount += 1;
}
/* If we are creating a shared library, and this is a reloc
may need to keep relocations for symbols satisfied by a
dynamic library if we manage to avoid copy relocs for the
symbol. */
- if ((info->shared
+ if ((bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& (! tilepro_elf_howto_table[r_type].pc_relative
|| (h != NULL
&& (! info->symbolic
|| h->root.type == bfd_link_hash_defweak
|| !h->def_regular))))
- || (!info->shared
+ || (!bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& h != NULL
&& (h->root.type == bfd_link_hash_defweak
if (h != NULL)
{
switch (ELF32_R_TYPE (rel->r_info))
- {
- case R_TILEPRO_GNU_VTINHERIT:
- case R_TILEPRO_GNU_VTENTRY:
- break;
- }
+ {
+ case R_TILEPRO_GNU_VTINHERIT:
+ case R_TILEPRO_GNU_VTENTRY:
+ return NULL;
+ }
+ }
+
+ /* FIXME: The test here, in check_relocs and in relocate_section
+ dealing with TLS optimization, ought to be !bfd_link_executable (info). */
+ if (bfd_link_pic (info))
+ {
+ switch (ELF32_R_TYPE (rel->r_info))
+ {
+ case R_TILEPRO_TLS_GD_CALL:
+ /* This reloc implicitly references __tls_get_addr. We know
+ another reloc will reference the same symbol as the one
+ on this reloc, so the real symbol and section will be
+ gc marked when processing the other reloc. That lets
+ us handle __tls_get_addr here. */
+ h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr",
+ FALSE, FALSE, TRUE);
+ BFD_ASSERT (h != NULL);
+ h->mark = 1;
+ if (h->u.weakdef != NULL)
+ h->u.weakdef->mark = 1;
+ sym = NULL;
+ }
}
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
bfd_signed_vma *local_got_refcounts;
const Elf_Internal_Rela *rel, *relend;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
BFD_ASSERT (is_tilepro_elf (abfd) || sec->reloc_count == 0);
}
r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = tilepro_elf_tls_transition (info, r_type, h != NULL);
switch (r_type)
{
case R_TILEPRO_IMM16_X0_GOT:
}
else
{
- if (local_got_refcounts[r_symndx] > 0)
+ if (local_got_refcounts &&
+ local_got_refcounts[r_symndx] > 0)
local_got_refcounts[r_symndx]--;
}
break;
case R_TILEPRO_SHAMT_X1:
case R_TILEPRO_SHAMT_Y0:
case R_TILEPRO_SHAMT_Y1:
- if (info->shared)
+ if (bfd_link_pic (info))
break;
/* Fall through. */
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
- if (info->shared)
+ if (bfd_link_pic (info))
return TRUE;
/* If there are no references to this symbol that do not use the
return TRUE;
}
- if (h->size == 0)
- {
- (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
- h->root.root.string);
- return TRUE;
- }
-
/* We must allocate the symbol in our .dynbss section, which will
become part of the .bss section of the executable. There will be
an entry for this symbol in the .dynsym section. The dynamic
to copy the initial value out of the dynamic object and into the
runtime process image. We need to remember the offset into the
.rel.bss section we are going to use. */
- if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
+ if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
{
htab->srelbss->size += TILEPRO_ELF_RELA_BYTES;
h->needs_copy = 1;
}
- return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
+ return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdynbss);
}
/* Allocate space in .plt, .got and associated reloc sections for
dynamic relocs. */
static bfd_boolean
-allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
+allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
{
struct bfd_link_info *info;
struct tilepro_elf_link_hash_table *htab;
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
- if (h->root.type == bfd_link_hash_warning)
- /* When warning symbols are created, they **replace** the "real"
- entry in the hash table, thus we never get to see the real
- symbol in a hash traversal. So look at it now. */
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
info = (struct bfd_link_info *) inf;
htab = tilepro_elf_hash_table (info);
BFD_ASSERT (htab != NULL);
return FALSE;
}
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
+ if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
{
asection *s = htab->elf.splt;
/* Allocate room for the header. */
if (s->size == 0)
{
- s->size = PLT_HEADER_SIZE;
+ s->size = PLT_ENTRY_SIZE;
}
h->plt.offset = s->size;
location in the .plt. This is required to make function
pointers compare as equal between the normal executable and
the shared library. */
- if (! info->shared
+ if (! bfd_link_pic (info)
&& !h->def_regular)
{
h->root.u.def.section = s;
h->needs_plt = 0;
}
- if (h->got.refcount > 0)
+ /* If a TLS_IE symbol is now local to the binary, make it a TLS_LE
+ requiring no TLS entry. */
+ if (h->got.refcount > 0
+ && !bfd_link_pic (info)
+ && h->dynindx == -1
+ && tilepro_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
+ h->got.offset = (bfd_vma) -1;
+ else if (h->got.refcount > 0)
{
asection *s;
bfd_boolean dyn;
global. */
if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE)
htab->elf.srelgot->size += 2 * TILEPRO_ELF_RELA_BYTES;
- else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
+ else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ h))
htab->elf.srelgot->size += TILEPRO_ELF_RELA_BYTES;
}
else
space for pc-relative relocs that have become local due to symbol
visibility changes. */
- if (info->shared)
+ if (bfd_link_pic (info))
{
if (SYMBOL_CALLS_LOCAL (info, h))
{
/* Find any dynamic relocs that apply to read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
+readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
{
struct tilepro_elf_link_hash_entry *eh;
struct tilepro_elf_dyn_relocs *p;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
eh = (struct tilepro_elf_link_hash_entry *) h;
for (p = eh->dyn_relocs; p != NULL; p = p->next)
{
if (elf_hash_table (info)->dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info) && !info->nointerp)
{
- s = bfd_get_section_by_name (dynobj, ".interp");
+ s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
s->size = sizeof ELF32_DYNAMIC_INTERPRETER;
s->contents = (unsigned char *) ELF32_DYNAMIC_INTERPRETER;
/* Set up .got offsets for local syms, and space for local dynamic
relocs. */
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
bfd_signed_vma *local_got;
bfd_signed_vma *end_local_got;
s->size += TILEPRO_BYTES_PER_WORD;
if (*local_tls_type == GOT_TLS_GD)
s->size += TILEPRO_BYTES_PER_WORD;
- if (info->shared
+ if (bfd_link_pic (info)
|| *local_tls_type == GOT_TLS_GD
|| *local_tls_type == GOT_TLS_IE)
srel->size += TILEPRO_ELF_RELA_BYTES;
/* Allocate global sym .plt and .got entries, and space for global
sym dynamic relocs. */
- elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
+ elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
if (elf_hash_table (info)->dynamic_sections_created)
{
#define add_dynamic_entry(TAG, VAL) \
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
- if (info->executable)
+ if (bfd_link_executable (info))
{
if (!add_dynamic_entry (DT_DEBUG, 0))
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, readonly_dynrelocs,
- (PTR) info);
+ elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
if (info->flags & DF_TEXTREL)
{
return (address - htab->tls_sec->vma);
}
+/* Replace the MASK bits in ADDR with those in INSN, for the next
+ TILEPRO_BUNDLE_SIZE_IN_BYTES bytes. */
+
+static void
+tilepro_replace_insn (bfd_byte *addr, const bfd_byte *mask,
+ const bfd_byte *insn)
+{
+ int i;
+ for (i = 0; i < TILEPRO_BUNDLE_SIZE_IN_BYTES; i++)
+ {
+ addr[i] = (addr[i] & ~mask[i]) | (insn[i] & mask[i]);
+ }
+}
+
+/* Mask to extract the bits corresponding to an instruction in a
+ specific pipe of a bundle. */
+static const bfd_byte insn_mask_X1[] = {
+ 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x7f
+};
+
+/* Mask to extract the bits corresponding to an instruction in a
+ specific pipe of a bundle, minus the destination operand and the
+ first source operand. */
+static const bfd_byte insn_mask_X0_no_dest_no_srca[] = {
+ 0x00, 0xf0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00
+};
+
+static const bfd_byte insn_mask_X1_no_dest_no_srca[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x7f
+};
+
+static const bfd_byte insn_mask_Y0_no_dest_no_srca[] = {
+ 0x00, 0xf0, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00
+};
+
+static const bfd_byte insn_mask_Y1_no_dest_no_srca[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0x78
+};
+
+/* Mask to extract the first source operand of an instruction. */
+static const bfd_byte srca_mask_X0[] = {
+ 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static const bfd_byte srca_mask_X1[] = {
+ 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00
+};
+
+/* Various instructions synthesized to support tls references. */
+
+/* move r0, r0 in the X1 pipe, used for tls le. */
+static const bfd_byte insn_tls_le_move_X1[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x33, 0x08
+};
+
+/* move r0, zero in the X0 and X1 pipe, used for tls le. */
+static const bfd_byte insn_tls_le_move_zero_X0X1[] = {
+ 0xc0, 0xff, 0xcf, 0x00, 0xe0, 0xff, 0x33, 0x08
+};
+
+/* lw r0, r0 in the X1 pipe, used for tls ie. */
+static const bfd_byte insn_tls_ie_lw_X1[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0b, 0x40
+};
+
+/* add r0, r0, tp in various pipes, used for tls ie. */
+static const bfd_byte insn_tls_ie_add_X0X1[] = {
+ 0x00, 0x50, 0x0f, 0x00, 0x00, 0xa8, 0x07, 0x08
+};
+static const bfd_byte insn_tls_ie_add_Y0Y1[] = {
+ 0x00, 0x50, 0x03, 0x08, 0x00, 0xa8, 0x01, 0x8c
+};
+
+/* move r0, r0 in various pipes, used for tls gd. */
+static const bfd_byte insn_tls_gd_add_X0X1[] = {
+ 0x00, 0xf0, 0xcf, 0x00, 0x00, 0xf8, 0x33, 0x08
+};
+static const bfd_byte insn_tls_gd_add_Y0Y1[] = {
+ 0x00, 0xf0, 0x0b, 0x18, 0x00, 0xf8, 0x05, 0x9c
+};
+
/* Relocate an TILEPRO ELF section.
The RELOCATE_SECTION function is called by the new ELF backend linker
for (; rel < relend; rel++)
{
int r_type, tls_type;
+ bfd_boolean is_tls_iele, is_tls_le;
reloc_howto_type *howto;
unsigned long r_symndx;
struct elf_link_hash_entry *h;
if ((unsigned int)r_type >= NELEMS(tilepro_elf_howto_table))
{
/* Not clear if we need to check here, but just be paranoid. */
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, r_type, input_section);
bfd_set_error (bfd_error_bad_value);
}
else
{
- bfd_boolean warned;
+ bfd_boolean warned ATTRIBUTE_UNUSED;
+ bfd_boolean ignored ATTRIBUTE_UNUSED;
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
r_symndx, symtab_hdr, sym_hashes,
h, sec, relocation,
- unresolved_reloc, warned);
+ unresolved_reloc, warned, ignored);
if (warned)
{
/* To avoid generating warning messages about truncated
}
}
- if (sec != NULL && elf_discarded_section (sec))
+ if (sec != NULL && discarded_section (sec))
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
- rel, relend, howto, contents);
+ rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
if (h != NULL)
name = bfd_section_name (input_bfd, sec);
}
+ switch (r_type)
+ {
+ case R_TILEPRO_TLS_GD_CALL:
+ case R_TILEPRO_IMM8_X0_TLS_GD_ADD:
+ case R_TILEPRO_IMM8_Y0_TLS_GD_ADD:
+ case R_TILEPRO_IMM8_X1_TLS_GD_ADD:
+ case R_TILEPRO_IMM8_Y1_TLS_GD_ADD:
+ case R_TILEPRO_IMM16_X0_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X1_TLS_GD_HA:
+ case R_TILEPRO_IMM16_X0_TLS_IE_HA:
+ case R_TILEPRO_IMM16_X1_TLS_IE_HA:
+ tls_type = GOT_UNKNOWN;
+ if (h == NULL && local_got_offsets)
+ tls_type =
+ _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
+ else if (h != NULL)
+ tls_type = tilepro_elf_hash_entry(h)->tls_type;
+
+ is_tls_iele = (! bfd_link_pic (info) || tls_type == GOT_TLS_IE);
+ is_tls_le = is_tls_iele && (!bfd_link_pic (info)
+ && (h == NULL || h->dynindx == -1));
+
+ if (r_type == R_TILEPRO_TLS_GD_CALL)
+ {
+ if (is_tls_le)
+ {
+ /* GD -> LE */
+ tilepro_replace_insn (contents + rel->r_offset,
+ insn_mask_X1, insn_tls_le_move_X1);
+ continue;
+ }
+ else if (is_tls_iele)
+ {
+ /* GD -> IE */
+ tilepro_replace_insn (contents + rel->r_offset,
+ insn_mask_X1, insn_tls_ie_lw_X1);
+ continue;
+ }
+
+ /* GD -> GD */
+ h = (struct elf_link_hash_entry *)
+ bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
+ FALSE, TRUE);
+ BFD_ASSERT (h != NULL);
+ r_type = R_TILEPRO_JOFFLONG_X1_PLT;
+ howto = tilepro_elf_howto_table + r_type;
+ }
+ else if (r_type == R_TILEPRO_IMM16_X0_TLS_GD_HA
+ || r_type == R_TILEPRO_IMM16_X0_TLS_IE_HA)
+ {
+ if (is_tls_le)
+ tilepro_replace_insn (contents + rel->r_offset, srca_mask_X0,
+ insn_tls_le_move_zero_X0X1);
+ }
+ else if (r_type == R_TILEPRO_IMM16_X1_TLS_GD_HA
+ || r_type == R_TILEPRO_IMM16_X1_TLS_IE_HA)
+ {
+ if (is_tls_le)
+ tilepro_replace_insn (contents + rel->r_offset, srca_mask_X1,
+ insn_tls_le_move_zero_X0X1);
+ }
+ else
+ {
+ const bfd_byte *mask = NULL;
+ const bfd_byte *add_insn = NULL;
+
+ switch (r_type)
+ {
+ case R_TILEPRO_IMM8_X0_TLS_GD_ADD:
+ add_insn = is_tls_iele ? insn_tls_ie_add_X0X1
+ : insn_tls_gd_add_X0X1;
+ mask = insn_mask_X0_no_dest_no_srca;
+ break;
+ case R_TILEPRO_IMM8_X1_TLS_GD_ADD:
+ add_insn = is_tls_iele ? insn_tls_ie_add_X0X1
+ : insn_tls_gd_add_X0X1;
+ mask = insn_mask_X1_no_dest_no_srca;
+ break;
+ case R_TILEPRO_IMM8_Y0_TLS_GD_ADD:
+ add_insn = is_tls_iele ? insn_tls_ie_add_Y0Y1
+ : insn_tls_gd_add_Y0Y1;
+ mask = insn_mask_Y0_no_dest_no_srca;
+ break;
+ case R_TILEPRO_IMM8_Y1_TLS_GD_ADD:
+ add_insn = is_tls_iele ? insn_tls_ie_add_Y0Y1
+ : insn_tls_gd_add_Y0Y1;
+ mask = insn_mask_Y1_no_dest_no_srca;
+ break;
+ }
+
+ tilepro_replace_insn (contents + rel->r_offset, mask, add_insn);
+
+ continue;
+ }
+ break;
+ case R_TILEPRO_TLS_IE_LOAD:
+ if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
+ /* IE -> LE */
+ tilepro_replace_insn (contents + rel->r_offset,
+ insn_mask_X1_no_dest_no_srca,
+ insn_tls_le_move_X1);
+ else
+ /* IE -> IE */
+ tilepro_replace_insn (contents + rel->r_offset,
+ insn_mask_X1_no_dest_no_srca,
+ insn_tls_ie_lw_X1);
+ continue;
+ break;
+ default:
+ break;
+ }
+
switch (r_type)
{
case R_TILEPRO_IMM16_X0_GOT:
BFD_ASSERT (off != (bfd_vma) -1);
dyn = elf_hash_table (info)->dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
- || (info->shared
+ if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ h)
+ || (bfd_link_pic (info)
&& SYMBOL_REFERENCES_LOCAL (info, h)))
{
/* This is actually a static link, or it is a
off &= ~1;
else
{
- if (info->shared)
+ if (bfd_link_pic (info))
{
asection *s;
Elf_Internal_Rela outrel;
local_got_offsets[r_symndx] |= 1;
}
}
- relocation = htab->elf.sgot->output_offset + off - got_base;
+ relocation = off - got_base;
break;
case R_TILEPRO_JOFFLONG_X1_PLT:
if ((input_section->flags & SEC_ALLOC) == 0)
break;
- if ((info->shared
+ if ((bfd_link_pic (info)
&& (h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
&& (! howto->pc_relative
|| !SYMBOL_CALLS_LOCAL (info, h)))
- || (!info->shared
+ || (!bfd_link_pic (info)
&& h != NULL
&& h->dynindx != -1
&& !h->non_got_ref
else if (h != NULL &&
h->dynindx != -1
&& (! is_plt
- || !info->shared
+ || !bfd_link_pic (info)
|| !SYMBOLIC_BIND (info, h)
|| !h->def_regular))
{
if (indx == 0)
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
}
break;
+ case R_TILEPRO_IMM16_X0_TLS_LE:
+ case R_TILEPRO_IMM16_X1_TLS_LE:
+ case R_TILEPRO_IMM16_X0_TLS_LE_LO:
+ case R_TILEPRO_IMM16_X1_TLS_LE_LO:
+ case R_TILEPRO_IMM16_X0_TLS_LE_HI:
+ case R_TILEPRO_IMM16_X1_TLS_LE_HI:
+ case R_TILEPRO_IMM16_X0_TLS_LE_HA:
+ case R_TILEPRO_IMM16_X1_TLS_LE_HA:
+ if (bfd_link_pic (info))
+ {
+ Elf_Internal_Rela outrel;
+ bfd_boolean skip;
+
+ BFD_ASSERT (sreloc != NULL);
+ skip = FALSE;
+ outrel.r_offset =
+ _bfd_elf_section_offset (output_bfd, info, input_section,
+ rel->r_offset);
+ if (outrel.r_offset == (bfd_vma) -1)
+ skip = TRUE;
+ else if (outrel.r_offset == (bfd_vma) -2)
+ skip = TRUE;
+ outrel.r_offset += (input_section->output_section->vma
+ + input_section->output_offset);
+ if (skip)
+ memset (&outrel, 0, sizeof outrel);
+ else
+ {
+ outrel.r_info = ELF32_R_INFO (0, r_type);
+ outrel.r_addend = relocation - dtpoff_base (info)
+ + rel->r_addend;
+ }
+
+ tilepro_elf_append_rela_32 (output_bfd, sreloc, &outrel);
+ continue;
+ }
+ relocation = tpoff (info, relocation);
+ break;
+
case R_TILEPRO_IMM16_X0_TLS_GD:
case R_TILEPRO_IMM16_X1_TLS_GD:
case R_TILEPRO_IMM16_X0_TLS_GD_LO:
case R_TILEPRO_IMM16_X1_TLS_GD_HI:
case R_TILEPRO_IMM16_X0_TLS_GD_HA:
case R_TILEPRO_IMM16_X1_TLS_GD_HA:
- tls_type = GOT_TLS_GD;
- goto have_tls_reference;
-
case R_TILEPRO_IMM16_X0_TLS_IE:
case R_TILEPRO_IMM16_X1_TLS_IE:
case R_TILEPRO_IMM16_X0_TLS_IE_LO:
case R_TILEPRO_IMM16_X1_TLS_IE_HI:
case R_TILEPRO_IMM16_X0_TLS_IE_HA:
case R_TILEPRO_IMM16_X1_TLS_IE_HA:
- tls_type = GOT_TLS_IE;
- /* Fall through. */
-
- have_tls_reference:
+ r_type = tilepro_elf_tls_transition (info, r_type, h == NULL);
+ tls_type = GOT_UNKNOWN;
if (h == NULL && local_got_offsets)
tls_type
= _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
else if (h != NULL)
{
tls_type = tilepro_elf_hash_entry(h)->tls_type;
+ if (!bfd_link_pic (info) && h->dynindx == -1 && tls_type == GOT_TLS_IE)
+ r_type = tilepro_tls_translate_to_le (r_type);
}
if (tls_type == GOT_TLS_IE)
- switch (r_type)
- {
- case R_TILEPRO_IMM16_X0_TLS_GD:
- r_type = R_TILEPRO_IMM16_X0_TLS_IE;
- break;
- case R_TILEPRO_IMM16_X1_TLS_GD:
- r_type = R_TILEPRO_IMM16_X1_TLS_IE;
- break;
- case R_TILEPRO_IMM16_X0_TLS_GD_LO:
- r_type = R_TILEPRO_IMM16_X0_TLS_IE_LO;
- break;
- case R_TILEPRO_IMM16_X1_TLS_GD_LO:
- r_type = R_TILEPRO_IMM16_X1_TLS_IE_LO;
- break;
- case R_TILEPRO_IMM16_X0_TLS_GD_HI:
- r_type = R_TILEPRO_IMM16_X0_TLS_IE_HI;
- break;
- case R_TILEPRO_IMM16_X1_TLS_GD_HI:
- r_type = R_TILEPRO_IMM16_X1_TLS_IE_HI;
- break;
- case R_TILEPRO_IMM16_X0_TLS_GD_HA:
- r_type = R_TILEPRO_IMM16_X0_TLS_IE_HA;
- break;
- case R_TILEPRO_IMM16_X1_TLS_GD_HA:
- r_type = R_TILEPRO_IMM16_X1_TLS_IE_HA;
- break;
- }
+ r_type = tilepro_tls_translate_to_ie (r_type);
+
+ if (r_type == R_TILEPRO_IMM16_X0_TLS_LE
+ || r_type == R_TILEPRO_IMM16_X1_TLS_LE
+ || r_type == R_TILEPRO_IMM16_X0_TLS_LE_LO
+ || r_type == R_TILEPRO_IMM16_X1_TLS_LE_LO
+ || r_type == R_TILEPRO_IMM16_X0_TLS_LE_HI
+ || r_type == R_TILEPRO_IMM16_X1_TLS_LE_HI
+ || r_type == R_TILEPRO_IMM16_X0_TLS_LE_HA
+ || r_type == R_TILEPRO_IMM16_X1_TLS_LE_HA)
+ {
+ relocation = tpoff (info, relocation);
+ break;
+ }
if (h != NULL)
{
bfd_boolean dyn;
dyn = htab->elf.dynamic_sections_created;
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
- && (!info->shared
+ if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ h)
+ && (!bfd_link_pic (info)
|| !SYMBOL_REFERENCES_LOCAL (info, h)))
{
indx = h->dynindx;
/* The GOT entries have not been initialized yet. Do it
now, and emit any relocations. */
- if ((info->shared || indx != 0)
+ if ((bfd_link_pic (info) || indx != 0)
&& (h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak))
if (off >= (bfd_vma) -2)
abort ();
- relocation = htab->elf.sgot->output_offset + off - got_base;
+ relocation = off - got_base;
unresolved_reloc = FALSE;
howto = tilepro_elf_howto_table + r_type;
break;
not process them. */
if (unresolved_reloc
&& !((input_section->flags & SEC_DEBUGGING) != 0
- && h->def_dynamic))
- (*_bfd_error_handler)
+ && h->def_dynamic)
+ && _bfd_elf_section_offset (output_bfd, info, input_section,
+ rel->r_offset) != (bfd_vma) -1)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
switch (r)
{
case bfd_reloc_overflow:
- r = info->callbacks->reloc_overflow
+ (*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), name, howto->name,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- r = info->callbacks->undefined_symbol
- (info, name, input_bfd, input_section, rel->r_offset,
- TRUE);
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_outofrange:
}
if (msg)
- r = info->callbacks->warning
- (info, msg, name, input_bfd, input_section, rel->r_offset);
-
- if (! r)
- return FALSE;
+ (*info->callbacks->warning) (info, msg, name, input_bfd,
+ input_section, rel->r_offset);
}
}
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 (info->shared
+ if (bfd_link_pic (info)
&& (info->symbolic || h->dynindx == -1)
&& h->def_regular)
{
/* This symbols needs a copy reloc. Set it up. */
BFD_ASSERT (h->dynindx != -1);
- s = bfd_get_section_by_name (h->root.u.def.section->owner,
- ".rela.bss");
+ s = htab->srelbss;
BFD_ASSERT (s != NULL);
rela.r_offset = (h->root.u.def.value
}
/* Mark some specially defined symbols as absolute. */
- if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+ if (h == htab->elf.hdynamic
|| (h == htab->elf.hgot || h == htab->elf.hplt))
sym->st_shndx = SHN_ABS;
BFD_ASSERT (htab != NULL);
dynobj = htab->elf.dynobj;
- sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+ sdyn = bfd_get_linker_section (dynobj, ".dynamic");
if (elf_hash_table (info)->dynamic_sections_created)
{
asection *splt;
bfd_boolean ret;
- splt = bfd_get_section_by_name (dynobj, ".plt");
+ splt = htab->elf.splt;
BFD_ASSERT (splt != NULL && sdyn != NULL);
ret = tilepro_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
/* Fill in the first entry in the procedure linkage table. */
if (splt->size > 0)
- memcpy (splt->contents, tilepro_plt0_entry, PLT_HEADER_SIZE);
+ {
+ memcpy (splt->contents, tilepro_plt0_entry, PLT_HEADER_SIZE);
+ memset (splt->contents + PLT_HEADER_SIZE, 0,
+ PLT_ENTRY_SIZE - PLT_HEADER_SIZE);
+ }
- elf_section_data (splt->output_section)->this_hdr.sh_entsize
- = PLT_ENTRY_SIZE;
+ if (elf_section_data (splt->output_section) != NULL)
+ elf_section_data (splt->output_section)->this_hdr.sh_entsize
+ = PLT_ENTRY_SIZE;
}
if (htab->elf.sgotplt)
{
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->elf.sgotplt);
return FALSE;
}
tilepro_elf_plt_sym_val (bfd_vma i, const asection *plt,
const arelent *rel ATTRIBUTE_UNUSED)
{
- return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
+ return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
}
static enum elf_reloc_type_class
-tilepro_reloc_type_class (const Elf_Internal_Rela *rela)
+tilepro_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
switch ((int) ELF32_R_TYPE (rela->r_info))
{
#define ELF_MAXPAGESIZE 0x10000
#define ELF_COMMONPAGESIZE 0x10000
-#define TARGET_LITTLE_SYM bfd_elf32_tilepro_vec
+#define TARGET_LITTLE_SYM tilepro_elf32_vec
#define TARGET_LITTLE_NAME "elf32-tilepro"
#define elf_backend_reloc_type_class tilepro_reloc_type_class
#define elf_backend_grok_psinfo tilepro_elf_grok_psinfo
#define elf_backend_additional_program_headers tilepro_additional_program_headers
+#define bfd_elf32_mkobject tilepro_elf_mkobject
+
#define elf_backend_init_index_section _bfd_elf_init_1_index_section
#define elf_backend_can_gc_sections 1