_rel.r_addend = ADDEND; \
_rel.r_offset = (_htab->s##SECTION)->output_section->vma \
+ (_htab->s##SECTION)->output_offset + OFFSET; \
+ BFD_ASSERT ((long) SYM_IDX != -1); \
_rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
}
#define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
#define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
+#define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
#define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
#define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
+#define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
-static long
-arc_bfd_get_32 (bfd * abfd, void *loc, asection * input_section)
-{
- long insn = bfd_get_32 (abfd, loc);
-
- if (!bfd_big_endian (abfd)
- && input_section
- && (input_section->flags & SEC_CODE))
- insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16);
-
- return insn;
-}
-
-static void
-arc_bfd_put_32 (bfd * abfd, long insn, void *loc, asection * input_section)
-{
- if (!bfd_big_endian (abfd)
- && input_section
- && (input_section->flags & SEC_CODE))
- insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16);
-
- bfd_put_32 (abfd, insn, loc);
-}
static bfd_reloc_status_type
arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
elf_arc_howto_table[TYPE].pc_relative = \
(strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
- elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0);
+ elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
+ /* Only 32 bit data relocations should be marked as ME. */ \
+ if (strstr (#FORMULA, " ME ") != NULL) \
+ { \
+ BFD_ASSERT (SIZE == 2); \
+ }
#include "elf/arc-reloc.def"
+
}
#undef ARC_RELOC_HOWTO
};
#undef ARC_RELOC_HOWTO
+typedef ATTRIBUTE_UNUSED bfd_vma (*replace_func) (unsigned, int ATTRIBUTE_UNUSED);
+
+#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
+ case TYPE: \
+ func = (void *) RELOC_FUNCTION; \
+ break;
+static replace_func
+get_replace_function (bfd *abfd, unsigned int r_type)
+{
+ void *func = NULL;
+
+ switch (r_type)
+ {
+ #include "elf/arc-reloc.def"
+ }
+
+ if (func == replace_bits24 && bfd_big_endian (abfd))
+ return (replace_func) replace_bits24_be;
+
+ return (replace_func) func;
+}
+#undef ARC_RELOC_HOWTO
+
static reloc_howto_type *
arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
bfd_reloc_code_real_type code)
switch (flags & EF_ARC_MACH_MSK)
{
- case EF_ARC_CPU_GENERIC : fprintf (file, " -mcpu=generic"); break;
case EF_ARC_CPU_ARCV2HS : fprintf (file, " -mcpu=ARCv2HS"); break;
case EF_ARC_CPU_ARCV2EM : fprintf (file, " -mcpu=ARCv2EM"); break;
case E_ARC_MACH_ARC600 : fprintf (file, " -mcpu=ARC600"); break;
case E_ARC_MACH_ARC700:
mach = bfd_mach_arc_arc700;
break;
+ case E_ARC_MACH_NPS400:
+ mach = bfd_mach_arc_nps400;
+ break;
case EF_ARC_CPU_ARCV2HS:
case EF_ARC_CPU_ARCV2EM:
mach = bfd_mach_arc_arcv2;
arc_elf_final_write_processing (bfd * abfd,
bfd_boolean linker ATTRIBUTE_UNUSED)
{
- unsigned long val;
unsigned long emf;
switch (bfd_get_mach (abfd))
{
case bfd_mach_arc_arc600:
- val = E_ARC_MACH_ARC600;
emf = EM_ARC_COMPACT;
break;
case bfd_mach_arc_arc601:
- val = E_ARC_MACH_ARC601;
emf = EM_ARC_COMPACT;
break;
case bfd_mach_arc_arc700:
- val = E_ARC_MACH_ARC700;
+ emf = EM_ARC_COMPACT;
+ break;
+ case bfd_mach_arc_nps400:
emf = EM_ARC_COMPACT;
break;
case bfd_mach_arc_arcv2:
- val = EF_ARC_CPU_GENERIC;
emf = EM_ARC_COMPACT2;
- /* TODO: Check validity of this. It can also be ARCV2EM here.
- Previous version sets the e_machine here. */
break;
default:
abort ();
}
- elf_elfheader (abfd)->e_flags &= ~EF_ARC_MACH;
- elf_elfheader (abfd)->e_flags |= val;
elf_elfheader (abfd)->e_machine = emf;
+
/* Record whatever is the current syscall ABI version. */
elf_elfheader (abfd)->e_flags |= E_ARC_OSABI_CURRENT;
}
struct arc_relocation_data
{
- bfd_vma reloc_offset;
- bfd_vma reloc_addend;
- bfd_vma got_offset_value;
+ bfd_signed_vma reloc_offset;
+ bfd_signed_vma reloc_addend;
+ bfd_signed_vma got_offset_value;
- bfd_vma sym_value;
+ bfd_signed_vma sym_value;
asection * sym_section;
reloc_howto_type *howto;
asection * input_section;
- bfd_vma sdata_begin_symbol_vma;
+ bfd_signed_vma sdata_begin_symbol_vma;
bfd_boolean sdata_begin_symbol_vma_set;
- bfd_vma got_symbol_vma;
+ bfd_signed_vma got_symbol_vma;
bfd_boolean should_relocate;
};
}
}
-static ATTRIBUTE_UNUSED bfd_vma
-get_middle_endian_relocation (bfd_vma reloc)
+static bfd_vma
+middle_endian_convert (bfd_vma insn, bfd_boolean do_it)
{
- bfd_vma ret = ((reloc & 0xffff0000) >> 16) |
- ((reloc & 0xffff) << 16);
- return ret;
+ if (do_it)
+ {
+ insn =
+ ((insn & 0xffff0000) >> 16) |
+ ((insn & 0xffff) << 16);
+ }
+ return insn;
}
-#define S (reloc_data.sym_value \
+#define ME(reloc) (reloc)
+
+#define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
+ && (!bfd_big_endian (BFD)))
+
+#define S ((bfd_signed_vma) (reloc_data.sym_value \
+ (reloc_data.sym_section->output_section != NULL ? \
(reloc_data.sym_section->output_offset \
- + reloc_data.sym_section->output_section->vma) : 0) \
- )
-#define L (reloc_data.sym_value \
+ + reloc_data.sym_section->output_section->vma) : 0)))
+#define L ((bfd_signed_vma) (reloc_data.sym_value \
+ (reloc_data.sym_section->output_section != NULL ? \
(reloc_data.sym_section->output_offset \
- + reloc_data.sym_section->output_section->vma) : 0) \
- )
+ + reloc_data.sym_section->output_section->vma) : 0)))
#define A (reloc_data.reloc_addend)
#define B (0)
#define G (reloc_data.got_offset_value)
#define MES (0)
/* P: relative offset to PCL The offset should be to the
current location aligned to 32 bits. */
-#define P ( \
+#define P ((bfd_signed_vma) ( \
( \
(reloc_data.input_section->output_section != NULL ? \
reloc_data.input_section->output_section->vma : 0) \
+ reloc_data.input_section->output_offset \
- + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0)) \
- ) & ~0x3)
-#define PDATA ( \
+ + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
+ & ~0x3))
+#define PDATA ((bfd_signed_vma) ( \
(reloc_data.input_section->output_section->vma \
+ reloc_data.input_section->output_offset \
- + (reloc_data.reloc_offset) \
- ))
-#define SECTSTAR (reloc_data.input_section->output_offset)
-#define SECTSTART (reloc_data.input_section->output_offset)
-#define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
-#define TLS_REL ((elf_hash_table (info))->tls_sec->output_section->vma)
-#define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
+ + (reloc_data.reloc_offset))))
+#define SECTSTART (bfd_signed_vma) (reloc_data.input_section->output_offset)
+#define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
+#define TLS_REL (bfd_signed_vma) \
+ ((elf_hash_table (info))->tls_sec->output_section->vma)
#define TLS_TBSS (8)
#define TCB_SIZE (8)
-#define NON_ME(VALUE) (reverse_me (reloc_data, VALUE))
-
#define none (0)
-#define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
+#define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
{\
asection *sym_section = reloc_data.sym_section; \
asection *input_section = reloc_data.input_section; \
- ARC_DEBUG ("FORMULA = " #FORMULA "\n"); \
+ ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
+ ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
ARC_DEBUG ("S = 0x%x\n", S); \
ARC_DEBUG ("A = 0x%x\n", A); \
ARC_DEBUG ("L = 0x%x\n", L); \
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
case R_##TYPE: \
{ \
- bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
+ bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
relocation = FORMULA ; \
- PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
- insn = RELOC_FUNCTION (insn, relocation); \
+ PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
+ insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
+ insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
+ insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
PRINT_DEBUG_RELOC_INFO_AFTER \
} \
break;
-static bfd_vma
-reverse_me (struct arc_relocation_data reloc_data, bfd_vma reloc)
-{
- if (reloc_data.input_section && reloc_data.input_section->flags & SEC_CODE)
- return ((0x0000fffff & reloc) << 16) | ((0xffff0000 & reloc) >> 16);
- else
- return reloc;
-}
-
static bfd_reloc_status_type
arc_do_relocation (bfd_byte * contents,
struct arc_relocation_data reloc_data,
struct bfd_link_info *info)
{
- bfd_vma relocation = 0;
+ bfd_signed_vma relocation = 0;
bfd_vma insn;
bfd_vma orig_insn ATTRIBUTE_UNUSED;
+ bfd * abfd = reloc_data.input_section->owner;
struct elf_link_hash_table *htab ATTRIBUTE_UNUSED = elf_hash_table (info);
if (reloc_data.should_relocate == FALSE)
switch (reloc_data.howto->size)
{
case 2:
- insn = arc_bfd_get_32 (reloc_data.input_section->owner,
+ insn = arc_bfd_get_32 (abfd,
contents + reloc_data.reloc_offset,
reloc_data.input_section);
break;
case 1:
+ insn = arc_bfd_get_16 (abfd,
+ contents + reloc_data.reloc_offset,
+ reloc_data.input_section);
+ break;
case 0:
- insn = arc_bfd_get_16 (reloc_data.input_section->owner,
+ insn = arc_bfd_get_8 (abfd,
contents + reloc_data.reloc_offset,
reloc_data.input_section);
break;
flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow,
reloc_data.howto->bitsize,
reloc_data.howto->rightshift,
- bfd_arch_bits_per_address (reloc_data.input_section->owner),
+ bfd_arch_bits_per_address (abfd),
relocation);
#undef DEBUG_ARC_RELOC
switch (reloc_data.howto->size)
{
case 2:
- arc_bfd_put_32 (reloc_data.input_section->owner, insn,
+ arc_bfd_put_32 (abfd, insn,
contents + reloc_data.reloc_offset,
reloc_data.input_section);
break;
case 1:
+ arc_bfd_put_16 (abfd, insn,
+ contents + reloc_data.reloc_offset,
+ reloc_data.input_section);
+ break;
case 0:
- arc_bfd_put_16 (reloc_data.input_section->owner, insn,
+ arc_bfd_put_8 (abfd, insn,
contents + reloc_data.reloc_offset,
reloc_data.input_section);
break;
reloc_data.sym_value = sym->st_value;
reloc_data.sym_section = sec;
+ /* Mergeable section handling. */
+ if ((sec->flags & SEC_MERGE)
+ && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+ {
+ asection *msec;
+ msec = sec;
+ rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym,
+ &msec, rel->r_addend);
+ rel->r_addend -= (sec->output_section->vma
+ + sec->output_offset
+ + sym->st_value);
+ rel->r_addend += msec->output_section->vma + msec->output_offset;
+
+ reloc_data.reloc_addend = rel->r_addend;
+ }
+
if ((is_reloc_for_GOT (howto)
|| is_reloc_for_TLS (howto)) && entry != NULL)
{
}
else if (is_reloc_for_PLT (howto))
{
+ /* Fail if it is linking for PIE and the symbol is
+ undefined. */
+ if (bfd_link_executable (info)
+ && !(*info->callbacks->undefined_symbol)
+ (info, h->root.root.string, input_bfd, input_section,
+ rel->r_offset, TRUE))
+ {
+ return FALSE;
+ }
reloc_data.sym_value = h->plt.offset;
reloc_data.sym_section = htab->splt;
reloc_data.should_relocate = TRUE;
}
- else if (!(*info->callbacks->undefined_symbol)
+ else if (!bfd_link_pic (info)
+ && !(*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd, input_section,
- rel->r_offset,!bfd_link_pic (info)))
+ rel->r_offset, TRUE))
{
return FALSE;
}
case R_ARC_32_ME:
case R_ARC_PC32:
case R_ARC_32_PCREL:
- if (bfd_link_pic (info)
+ if (bfd_link_pic (info) && !bfd_link_pie (info)
&& ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
|| (h != NULL
&& h->dynindx != -1
else if (r_type == R_ARC_PC32
|| r_type == R_ARC_32_PCREL)
{
- BFD_ASSERT (h != NULL && h->dynindx != -1);
+ BFD_ASSERT (h != NULL);
if ((input_section->flags & SEC_ALLOC) != 0)
relocate = FALSE;
else
relocate = TRUE;
+
+ BFD_ASSERT (h->dynindx != -1);
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
}
else
else
{
BFD_ASSERT (h->dynindx != -1);
+
+ /* This type of dynamic relocation cannot be created
+ for code sections. */
+ BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
+
if ((input_section->flags & SEC_ALLOC) != 0)
relocate = FALSE;
else
relocate = TRUE;
+
+ BFD_ASSERT (h->dynindx != -1);
outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_32);
}
}
non-readonly sections. */
if (bfd_link_dll (info) && !bfd_link_pie (info)
&& (sec->flags & SEC_ALLOC) != 0
- && (sec->flags & SEC_READONLY) != 0)
+ && (sec->flags & SEC_READONLY) == 0
+ && (sec->flags & SEC_CODE) != 0)
{
const char *name;
if (h)
/* FALLTHROUGH */
case R_ARC_PC32:
case R_ARC_32_PCREL:
- if (bfd_link_pic (info)
+ if (bfd_link_pic (info) && !bfd_link_pie (info)
&& ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
|| (h != NULL
&& h->dynindx != -1
/* TODO: being ME is not a property of the relocation but of the
section of which is applying the relocation. */
- if (IS_MIDDLE_ENDIAN (reloc->symbol) || bfd_big_endian (abfd))
+ if (IS_MIDDLE_ENDIAN (reloc->symbol) && !bfd_big_endian (abfd))
{
relocation =
((relocation & 0xffff0000) >> 16) |
+ got_offset,
h->root.root.string);
- memcpy (htab->splt->contents + h->plt.offset,
- plt_data->elem,
- plt_data->elem_size);
+
+ {
+ bfd_vma i = 0;
+ uint16_t *ptr = (uint16_t *) plt_data->elem;
+ for (i = 0; i < plt_data->elem_size/2; i++)
+ {
+ uint16_t data = ptr[i];
+ bfd_put_16 (output_bfd,
+ (bfd_vma) data,
+ htab->splt->contents + h->plt.offset + (i*2));
+ }
+ }
+
plt_do_relocs_for_symbol (output_bfd, htab,
plt_data->elem_relocs,
h->plt.offset,
+ htab->sgotplt->output_offset
+ got_offset);
rel.r_addend = 0;
+
+ BFD_ASSERT (h->dynindx != -1);
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
loc = htab->srelplt->contents;
struct plt_version_t *plt_data = arc_get_plt_version (info);
struct elf_link_hash_table *htab = elf_hash_table (info);
- memcpy (htab->splt->contents, plt_data->entry,
- plt_data->entry_size);
+ {
+ bfd_vma i = 0;
+ uint16_t *ptr = (uint16_t *) plt_data->entry;
+ for (i = 0; i < plt_data->entry_size/2; i++)
+ {
+ uint16_t data = ptr[i];
+ bfd_put_16 (abfd,
+ (bfd_vma) data,
+ htab->splt->contents + (i*2));
+ }
+ }
PLT_DO_RELOCS_FOR_ENTRY (abfd, htab, plt_data->entry_relocs);
}
{
ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
}
- else
+ /* Do not fully understand the side effects of this condition.
+ The relocation space might still being reserved. Perhaps
+ I should clear its value. */
+ else if (h->dynindx != -1)
{
ADD_RELA (output_bfd, got, got_offset, h->dynindx,
R_ARC_GLOB_DAT, 0);
BFD_ASSERT (list->type != GOT_TLS_GD
|| list->existing_entries == MOD_AND_OFF);
- bfd_vma index = h->dynindx == -1 ? 0 : h->dynindx;
+ bfd_vma dynindx = h->dynindx == -1 ? 0 : h->dynindx;
if (e == MOD_AND_OFF || e == MOD)
{
- ADD_RELA (output_bfd, got, got_offset, index,
+ ADD_RELA (output_bfd, got, got_offset, dynindx,
R_ARC_TLS_DTPMOD, 0);
ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
got_offset,
htab->sgot->output_section->vma
+ htab->sgot->output_offset + got_offset,
- index, 0);
+ dynindx, 0);
}
if (e == MOD_AND_OFF || e == OFF)
{
ADD_RELA (output_bfd, got,
got_offset + (e == MOD_AND_OFF ? 4 : 0),
- index,
+ dynindx,
(list->type == GOT_TLS_IE ?
R_ARC_TLS_TPOFF : R_ARC_TLS_DTPOFF),
addend);
got_offset,
htab->sgot->output_section->vma
+ htab->sgot->output_offset + got_offset,
- index, addend);
+ dynindx, addend);
}
}
Elf_Internal_Rela rel;
rel.r_addend = 0;
rel.r_offset = rel_offset;
+
+ BFD_ASSERT (h->dynindx != -1);
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY);
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
projects / deliverable / binutils-gdb.git / blobdiff