#include "libiberty.h"
#include "opcode/arc-func.h"
#include "opcode/arc.h"
-
-#define RELA_SIZE sizeof(ElfNN_External_Rela)
-
#include "arc-plt.h"
-#define FEATURE_LIST_NAME bfdNN_feature_list
-#define CONFLICT_LIST bfdNN_conflict_list
+#define FEATURE_LIST_NAME bfd_feature_list
+#define CONFLICT_LIST bfd_conflict_list
#include "opcode/arc-attrs.h"
-/* Possible ARC architectures. */
-#define ARC 0
-#define ARC32 1
-#define ARC64 2
-
-/* Arc's architecture size. */
-#define ARCH_SIZE NN
-
-/* Arc's architecture type. */
-#define ARCH_TYPE ARCAA
-
-/* Arc's BFD backend. There are two different backends, one for
- ARCv1/v2 and the second for the ARCv3/64/32. They are
- incompatible. */
-#define ARC_BFD_ARCH bfd_arch_arcAA
-
-/* The name of the dynamic interpreter. This is put in the .interp
- section. */
-
-#define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
-#define ELF32_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
-
-#define LOG_FILE_ALIGN (ARCH_SIZE == 32 ? 2 : 3)
-
-/* Do not enable this unless you know what you are doing.
- Code under this macro is not safe for production.
- #define ARC_ENABLE_DEBUG 1 */
-
+/* #define ARC_ENABLE_DEBUG 1 */
#ifdef ARC_ENABLE_DEBUG
static const char *
name_for_global_symbol (struct elf_link_hash_entry *h)
#define ARC_DEBUG(...)
#endif
+
#define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
{ \
struct elf_link_hash_table *_htab = elf_hash_table (info); \
Elf_Internal_Rela _rel; \
bfd_byte * _loc; \
- const struct elf_backend_data *bed; \
- bed = get_elf_backend_data (BFD); \
\
if (_htab->dynamic_sections_created) \
{ \
BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
_loc = _htab->srel##SECTION->contents \
+ ((_htab->srel##SECTION->reloc_count) \
- * sizeof (ElfNN_External_Rela)); \
+ * sizeof (Elf32_External_Rela)); \
_htab->srel##SECTION->reloc_count++; \
_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 = ELFNN_R_INFO (SYM_IDX, TYPE); \
- bed->s->swap_reloca_out (BFD, &_rel, _loc); \
+ _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_get_64(A,B,C) bfd_get_64(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)
-#define arc_bfd_put_64(A,B,C,D) bfd_put_64(A,B,C)
static bfd_reloc_status_type
TYPE = VALUE,
enum howto_list
- {
+{
#include "elf/arc-reloc.def"
- HOWTO_LIST_LAST
- };
+ HOWTO_LIST_LAST
+};
#undef ARC_RELOC_HOWTO
"R_" #TYPE, false, 0, 0, false),
static struct reloc_howto_struct elf_arc_howto_table[] =
- {
+{
#include "elf/arc-reloc.def"
/* Example of what is generated by the preprocessor. Currently kept as an
example.
}
#undef ARC_RELOC_HOWTO
+
+#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
+ [TYPE] = VALUE,
+
+const int howto_table_lookup[] =
+{
+#include "elf/arc-reloc.def"
+};
+
+#undef ARC_RELOC_HOWTO
+
static reloc_howto_type *
arc_elf_howto (unsigned int r_type)
{
subclass. */
if (ret == NULL)
ret = (struct elf_arc_link_hash_entry *)
- bfd_hash_allocate (table, sizeof (struct elf_arc_link_hash_entry));
+ bfd_hash_allocate (table, sizeof (struct elf_arc_link_hash_entry));
if (ret == NULL)
return (struct bfd_hash_entry *) ret;
arc_elf_link_hash_table_create (bfd *abfd)
{
struct elf_arc_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct elf_arc_link_hash_table);
- ret = (struct elf_arc_link_hash_table *) bfd_zmalloc (amt);
+ ret = (struct elf_arc_link_hash_table *) bfd_zmalloc (sizeof (*ret));
if (ret == NULL)
return NULL;
{ BFD_RELOC_##TYPE, R_##TYPE },
static const struct arc_reloc_map arc_reloc_map[] =
- {
+{
#include "elf/arc-reloc.def"
- {BFD_RELOC_NONE, R_ARC_NONE},
- {BFD_RELOC_8, R_ARC_8},
- {BFD_RELOC_16, R_ARC_16},
- {BFD_RELOC_24, R_ARC_24},
- {BFD_RELOC_32, R_ARC_32},
- {BFD_RELOC_64, R_ARC_64},
- };
+ {BFD_RELOC_NONE, R_ARC_NONE},
+ {BFD_RELOC_8, R_ARC_8},
+ {BFD_RELOC_16, R_ARC_16},
+ {BFD_RELOC_24, R_ARC_24},
+ {BFD_RELOC_32, R_ARC_32},
+};
#undef ARC_RELOC_HOWTO
-typedef ATTRIBUTE_UNUSED
-bfd_vma (*replace_func) (bfd_vma, bfd_vma ATTRIBUTE_UNUSED);
+typedef ATTRIBUTE_UNUSED unsigned (*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;
+#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
+ case TYPE: \
+ func = RELOC_FUNCTION; \
+ break;
static replace_func
get_replace_function (bfd *abfd, unsigned int r_type)
switch (r_type)
{
-#include "elf/arc-reloc.def"
+ #include "elf/arc-reloc.def"
}
if (func == replace_bits24 && bfd_big_endian (abfd))
#undef ARC_RELOC_HOWTO
static reloc_howto_type *
-arc_elfNN_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
+arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
bfd_reloc_code_real_type code)
{
unsigned int i;
}
static reloc_howto_type *
-bfd_elfNN_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED,
+bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED,
const char *r_name)
{
unsigned int i;
{
unsigned int r_type;
- r_type = ELFNN_R_TYPE (dst->r_info);
+ r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= (unsigned int) R_ARC_max)
{
/* xgettext:c-format */
}
cache_ptr->howto = arc_elf_howto (r_type);
- return cache_ptr->howto != NULL;
+ return true;
}
/* Extract CPU features from an NTBS. */
if (!p)
return 0;
- for (i = 0; i < ARRAY_SIZE (FEATURE_LIST_NAME); i++)
+ for (i = 0; i < ARRAY_SIZE (bfd_feature_list); i++)
{
- char *t = strstr (p, FEATURE_LIST_NAME[i].attr);
- unsigned l = strlen (FEATURE_LIST_NAME[i].attr);
+ char *t = strstr (p, bfd_feature_list[i].attr);
+ unsigned l = strlen (bfd_feature_list[i].attr);
if ((t != NULL)
&& (t[l] == ','
|| t[l] == '\0'))
- r |= FEATURE_LIST_NAME[i].feature;
+ r |= bfd_feature_list[i].feature;
}
return r;
case Tag_ARC_PCS_config:
if (out_attr[i].i == 0)
out_attr[i].i = in_attr[i].i;
- else if ((in_attr[i].i & 0xff) != 0
- && ((out_attr[i].i & 0xff) != (in_attr[i].i & 0xff)))
+ else if (in_attr[i].i != 0 && out_attr[i].i != in_attr[i].i)
{
const char *tagval[] = { "Absent", "Bare-metal/mwdt",
- "Bare-metal/newlib", "Linux/uclibc",
- "Linux/glibc" };
- BFD_ASSERT ((in_attr[i].i & 0xff) < 5);
- BFD_ASSERT ((out_attr[i].i & 0xff) < 5);
+ "Bare-metal/newlib", "Linux/uclibc",
+ "Linux/glibc" };
+ BFD_ASSERT (in_attr[i].i < 5);
+ BFD_ASSERT (out_attr[i].i < 5);
/* It's sometimes ok to mix different configs, so this is only
a warning. */
_bfd_error_handler
(_("warning: %pB: conflicting platform configuration "
"%s with %s"), ibfd,
- tagval[in_attr[i].i & 0xff],
- tagval[out_attr[i].i & 0xff]);
+ tagval[in_attr[i].i],
+ tagval[out_attr[i].i]);
}
break;
&& ((out_attr[i].i + in_attr[i].i) < 6))
{
const char *tagval[] = { "Absent", "ARC6xx", "ARC7xx",
- "ARCEM", "ARCHS" };
+ "ARCEM", "ARCHS" };
BFD_ASSERT (in_attr[i].i < 5);
BFD_ASSERT (out_attr[i].i < 5);
/* We cannot mix code for different CPUs. */
/* First, check if a feature is compatible with the
output object chosen CPU. */
- for (j = 0; j < ARRAY_SIZE (FEATURE_LIST_NAME); j++)
- if (((in_feature | out_feature) & FEATURE_LIST_NAME[j].feature)
- && (!(cpu_out & FEATURE_LIST_NAME[j].cpus)))
+ for (j = 0; j < ARRAY_SIZE (bfd_feature_list); j++)
+ if (((in_feature | out_feature) & bfd_feature_list[j].feature)
+ && (!(cpu_out & bfd_feature_list[j].cpus)))
{
_bfd_error_handler
(_("error: %pB: unable to merge ISA extension attributes "
"%s"),
- obfd, FEATURE_LIST_NAME[j].name);
+ obfd, bfd_feature_list[j].name);
result = false;
break;
}
/* Second, if we have compatible features with the
chosen CPU, check if they are compatible among
them. */
- for (j = 0; j < ARRAY_SIZE (CONFLICT_LIST); j++)
- if (((in_feature | out_feature) & CONFLICT_LIST[j])
- == CONFLICT_LIST[j])
+ for (j = 0; j < ARRAY_SIZE (bfd_conflict_list); j++)
+ if (((in_feature | out_feature) & bfd_conflict_list[j])
+ == bfd_conflict_list[j])
{
unsigned k;
- for (k = 0; k < ARRAY_SIZE (FEATURE_LIST_NAME); k++)
+ for (k = 0; k < ARRAY_SIZE (bfd_feature_list); k++)
{
- if (in_feature & FEATURE_LIST_NAME[k].feature
- & CONFLICT_LIST[j])
- p1 = (char *) FEATURE_LIST_NAME[k].name;
- if (out_feature & FEATURE_LIST_NAME[k].feature
- & CONFLICT_LIST[j])
- p2 = (char *) FEATURE_LIST_NAME[k].name;
+ if (in_feature & bfd_feature_list[k].feature
+ & bfd_conflict_list[j])
+ p1 = (char *) bfd_feature_list[k].name;
+ if (out_feature & bfd_feature_list[k].feature
+ & bfd_conflict_list[j])
+ p2 = (char *) bfd_feature_list[k].name;
}
_bfd_error_handler
(_("error: %pB: conflicting ISA extension attributes "
/* Everithing is alright. */
out_feature |= in_feature;
p1 = NULL;
- for (j = 0; j < ARRAY_SIZE (FEATURE_LIST_NAME); j++)
- if (out_feature & FEATURE_LIST_NAME[j].feature)
- p1 = arc_stralloc (p1, FEATURE_LIST_NAME[j].attr);
+ for (j = 0; j < ARRAY_SIZE (bfd_feature_list); j++)
+ if (out_feature & bfd_feature_list[j].feature)
+ p1 = arc_stralloc (p1, bfd_feature_list[j].attr);
if (p1)
out_attr[Tag_ARC_ISA_config].s =
_bfd_elf_attr_strdup (obfd, p1);
if (out_attr[i].i == 0)
out_attr[i].i = in_attr[i].i;
else if (out_attr[i].i != 0 && in_attr[i].i != 0
- && out_attr[i].i != in_attr[i].i)
+ && out_attr[i].i != in_attr[i].i)
{
_bfd_error_handler
(_("error: %pB: conflicting attributes %s: %s with %s"),
if (out_attr[i].i == 0)
out_attr[i].i = in_attr[i].i;
else if (out_attr[i].i != 0 && in_attr[i].i != 0
- && out_attr[i].i != in_attr[i].i)
+ && out_attr[i].i != in_attr[i].i)
{
_bfd_error_handler
(_("error: %pB: conflicting attributes %s"),
flagword in_flags;
asection *sec;
- /* Check if we have the same endianess. */
+ /* Check if we have the same endianess. */
if (! _bfd_generic_verify_endian_match (ibfd, info))
return false;
- if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
- {
- _bfd_error_handler
- (_("%pB: ABI is incompatible with the selected emulation:\n"
- " target emulation '%s' does not match '%s'"),
- ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
- return false;
- }
-
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return true;
if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
{
- return bfd_set_arch_mach (obfd, ARC_BFD_ARCH, bfd_get_mach (ibfd));
+ return bfd_set_arch_mach (obfd, bfd_arch_arc, bfd_get_mach (ibfd));
}
return true;
/* Return a best guess for the machine number based on the attributes. */
-static ATTRIBUTE_UNUSED unsigned int
+static unsigned int
bfd_arc_get_mach_from_attributes (bfd * abfd)
{
int arch = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC, Tag_ARC_CPU_base);
? bfd_mach_arc_arc700 : bfd_mach_arc_arcv2;
}
-/* Set the right machine number for an ARC ELF file. Make sure this
- is initialised, or you'll have the potential of passing
- garbage---or misleading values---into the call to
- bfd_default_set_arch_mach (). */
-
+/* Set the right machine number for an ARC ELF file. */
static bool
arc_elf_object_p (bfd * abfd)
{
- unsigned int mach;
- unsigned long ATTRIBUTE_UNUSED arch = elf_elfheader (abfd)->e_flags
- & EF_ARC_MACH_MSK;
- unsigned e_machine = elf_elfheader (abfd)->e_machine;
+ /* Make sure this is initialised, or you'll have the potential of passing
+ garbage---or misleading values---into the call to
+ bfd_default_set_arch_mach (). */
+ unsigned int mach = bfd_mach_arc_arc700;
+ unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH_MSK;
+ unsigned e_machine = elf_elfheader (abfd)->e_machine;
- switch (e_machine)
+ if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2)
{
-#if (ARCH_TYPE == ARC) && (ARCH_SIZE == 32)
- case EM_ARC_COMPACT:
- case EM_ARC_COMPACT2:
switch (arch)
{
case E_ARC_MACH_ARC600:
mach = bfd_arc_get_mach_from_attributes (abfd);
break;
}
- break;
-
- case EM_ARC:
- _bfd_error_handler
- (_("error: the ARC4 architecture is no longer supported"));
- return false;
-
-#else /* New ARCv3 arches. */
- case EM_ARC_COMPACT3_64:
- mach = bfd_mach_arcv3_64;
- break;
-
- case EM_ARC_COMPACT3:
- mach = bfd_mach_arcv3_32;
- break;
-#endif
-
- default:
- _bfd_error_handler (_("error: unset or old architecture flags."));
- return false;
+ }
+ else
+ {
+ if (e_machine == EM_ARC)
+ {
+ _bfd_error_handler
+ (_("error: the ARC4 architecture is no longer supported"));
+ return false;
+ }
+ else
+ {
+ _bfd_error_handler
+ (_("warning: unset or old architecture flags; "
+ "use default machine"));
+ }
}
- return bfd_default_set_arch_mach (abfd, ARC_BFD_ARCH, mach);
+ return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
}
/* The final processing done just before writing out an ARC ELF object file.
Tag_ARC_ABI_osver);
flagword e_flags = elf_elfheader (abfd)->e_flags & ~EF_ARC_OSABI_MSK;
-#if (ARCH_TYPE == ARC) && (ARCH_SIZE == 32)
switch (bfd_get_mach (abfd))
{
case bfd_mach_arc_arcv2:
emf = EM_ARC_COMPACT;
break;
}
-#else
- switch (bfd_get_mach (abfd))
- {
- case bfd_mach_arcv3_64:
- emf = EM_ARC_COMPACT3_64;
- break;
- case bfd_mach_arcv3_32:
- emf = EM_ARC_COMPACT3;
- break;
- default:
- _bfd_error_handler (_("Unknown ARC architecture"));
- bfd_set_error (bfd_error_sorry);
- return false;
- }
-#endif
+
elf_elfheader (abfd)->e_machine = emf;
/* Record whatever is the current syscall ABI version. */
ARC_DEBUG (" Input_section:\n");
if (reloc_data.input_section != NULL)
{
- ARC_DEBUG (" section name = %s, output_offset 0x%08x, " \
- "output_section->vma = 0x%08x\n",
+ ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
reloc_data.input_section->name,
(unsigned int) reloc_data.input_section->output_offset,
(unsigned int) reloc_data.input_section->output_section->vma);
}
else
{
- ARC_DEBUG ("\tinput section is NULL\n");
+ ARC_DEBUG (" input section is NULL\n");
}
}
#else
{
insn
= ((insn & 0xffff0000) >> 16)
- | ((insn & 0xffff) << 16);
+ | ((insn & 0xffff) << 16);
}
return insn;
}
-/* This function is called for relocations that are otherwise marked
- as NOT requiring overflow checks. In here we perform non-standard
- checks of the relocation value. */
+/* This function is called for relocations that are otherwise marked as NOT
+ requiring overflow checks. In here we perform non-standard checks of
+ the relocation value. */
static inline bfd_reloc_status_type
arc_special_overflow_checks (const struct arc_relocation_data reloc_data,
#define ME(reloc) (reloc)
-#define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
+#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 \
- ((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 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 ((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 A (reloc_data.reloc_addend)
#define B (0)
#define G (reloc_data.got_offset_value)
#define GOT_BEGIN (htab->sgot->output_section->vma)
#define MES (0)
-/* P: relative offset to PCL The offset should be to the
- current location aligned to 32 bits. */
-#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 : \
- (bitsize == 34 ? 2 : 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 SECTSTART \
- (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
- + reloc_data.sym_section->output_offset)
-#define FINAL_SECTSTART \
+ /* P: relative offset to PCL The offset should be to the
+ current location aligned to 32 bits. */
+#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 ((bfd_signed_vma) ( \
+ (reloc_data.input_section->output_section->vma \
+ + reloc_data.input_section->output_offset \
+ + (reloc_data.reloc_offset))))
+#define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
+ + reloc_data.sym_section->output_offset)
+#define FINAL_SECTSTART \
(bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
#define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
#define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
#define TLS_REL (bfd_signed_vma)(tls_sec->output_section->vma)
#define TLS_TBSS (align_power (TCB_SIZE, tls_sec->alignment_power))
-#define ICARRY insn
-#define DEREFP (insn)
#define none (0)
#define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
#define PRINT_DEBUG_RELOC_INFO_AFTER
-#endif /* ARC_ENABLE_DEBUG. */
+#endif /* ARC_ENABLE_DEBUG */
-#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, \
- RELOC_FUNCTION, OVERFLOW, FORMULA) \
+#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
case R_##TYPE: \
- { \
- bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
- relocation = FORMULA ; \
- 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;
+ { \
+ bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
+ relocation = FORMULA ; \
+ 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_reloc_status_type
arc_do_relocation (bfd_byte * contents,
switch (bfd_get_reloc_size (reloc_data.howto))
{
- case 8:
- insn = arc_bfd_get_64 (abfd,
- contents + reloc_data.reloc_offset,
- reloc_data.input_section);
- break;
case 4:
insn = arc_bfd_get_32 (abfd,
contents + reloc_data.reloc_offset,
DEBUG_ARC_RELOC (reloc_data);
ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
", hex -> (0x%08x)\n",
- (int) relocation, (unsigned) relocation, (int) relocation);
+ (int) relocation, (unsigned) relocation, (int) relocation);
return flag;
}
/* Write updated instruction back to memory. */
switch (bfd_get_reloc_size (reloc_data.howto))
{
- case 8:
- arc_bfd_put_64 (abfd, insn,
- contents + reloc_data.reloc_offset,
- reloc_data.input_section);
- break;
case 4:
arc_bfd_put_32 (abfd, insn,
contents + reloc_data.reloc_offset,
#undef SECTSTART
#undef JLI
#undef _SDA_BASE_
-#undef ICARRY
#undef none
#undef ARC_RELOC_HOWTO
corresponding to the st_shndx field of each
local symbol. */
static int
-elf_arc_relocate_section (bfd *output_bfd,
- struct bfd_link_info *info,
- bfd *input_bfd,
- asection *input_section,
- bfd_byte *contents,
- Elf_Internal_Rela *relocs,
- Elf_Internal_Sym *local_syms,
- asection **local_sections)
+elf_arc_relocate_section (bfd * output_bfd,
+ struct bfd_link_info * info,
+ bfd * input_bfd,
+ asection * input_section,
+ bfd_byte * contents,
+ Elf_Internal_Rela * relocs,
+ Elf_Internal_Sym * local_syms,
+ asection ** local_sections)
{
Elf_Internal_Shdr * symtab_hdr;
struct elf_link_hash_entry ** sym_hashes;
Elf_Internal_Rela * wrel;
Elf_Internal_Rela * relend;
struct elf_link_hash_table * htab = elf_hash_table (info);
- const struct elf_backend_data *bed;
- bed = get_elf_backend_data (output_bfd);
symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
for (; rel < relend; wrel++, rel++)
{
- enum elf_arc_reloc_type r_type;
- reloc_howto_type * howto;
- unsigned long r_symndx;
- struct elf_link_hash_entry * h;
- Elf_Internal_Sym * sym;
- asection * sec;
- struct elf_link_hash_entry * h2;
- const char * msg;
- bool unresolved_reloc = false;
- bool resolved_to_zero;
+ enum elf_arc_reloc_type r_type;
+ reloc_howto_type *howto;
+ unsigned long r_symndx;
+ struct elf_link_hash_entry *h;
+ Elf_Internal_Sym *sym;
+ asection *sec;
+ struct elf_link_hash_entry *h2;
+ const char *msg;
+ bool unresolved_reloc = false;
struct arc_relocation_data reloc_data =
- {
- .reloc_offset = 0,
- .reloc_addend = 0,
- .got_offset_value = 0,
- .sym_value = 0,
- .sym_section = NULL,
- .howto = NULL,
- .input_section = NULL,
- .sdata_begin_symbol_vma = 0,
- .sdata_begin_symbol_vma_set = false,
- .got_symbol_vma = 0,
- .should_relocate = false
- };
-
- r_type = ELFNN_R_TYPE (rel->r_info);
+ {
+ .reloc_offset = 0,
+ .reloc_addend = 0,
+ .got_offset_value = 0,
+ .sym_value = 0,
+ .sym_section = NULL,
+ .howto = NULL,
+ .input_section = NULL,
+ .sdata_begin_symbol_vma = 0,
+ .sdata_begin_symbol_vma_set = false,
+ .got_symbol_vma = 0,
+ .should_relocate = false
+ };
+
+ r_type = ELF32_R_TYPE (rel->r_info);
if (r_type >= (int) R_ARC_max)
{
}
howto = arc_elf_howto (r_type);
- r_symndx = ELFNN_R_SYM (rel->r_info);
+ r_symndx = ELF32_R_SYM (rel->r_info);
/* If we are generating another .o file and the symbol in not
local, skip this relocation. */
/* For ld -r, remove relocations in debug sections against
sections defined in discarded sections. Not done for
eh_frame editing code expects to be present. */
- if (bfd_link_relocatable (info)
- && (input_section->flags & SEC_DEBUGGING))
- wrel--;
+ if (bfd_link_relocatable (info)
+ && (input_section->flags & SEC_DEBUGGING))
+ wrel--;
continue;
}
continue;
}
- resolved_to_zero = (h != NULL && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
-
if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */
{
reloc_data.sym_value = sym->st_value;
BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
if (htab->sgot != NULL)
reloc_data.got_symbol_vma = htab->sgot->output_section->vma
- + htab->sgot->output_offset;
+ + htab->sgot->output_offset;
reloc_data.should_relocate = true;
}
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
- {
- struct elf_arc_link_hash_entry *ah_old
- = (struct elf_arc_link_hash_entry *) h;
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
- struct elf_arc_link_hash_entry *ah
- = (struct elf_arc_link_hash_entry *) h;
-
- if (ah->got_ents == 0 && ah_old->got_ents != ah->got_ents)
- ah->got_ents = ah_old->got_ents;
- }
+ {
+ struct elf_arc_link_hash_entry *ah_old =
+ (struct elf_arc_link_hash_entry *) h;
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ struct elf_arc_link_hash_entry *ah =
+ (struct elf_arc_link_hash_entry *) h;
+
+ if (ah->got_ents == 0 && ah_old->got_ents != ah->got_ents)
+ ah->got_ents = ah_old->got_ents;
+ }
/* TODO: Need to validate what was the intention. */
+ /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
reloc_data.symbol_name = h->root.root.string;
/* If we have encountered a definition for this symbol. */
struct elf_arc_link_hash_entry *ah =
(struct elf_arc_link_hash_entry *) h;
/* TODO: Change it to use arc_do_relocation with
- ARC_32 reloc. Try to use ADD_RELA macro. */
+ ARC_32 reloc. Try to use ADD_RELA macro. */
bfd_vma relocation =
reloc_data.sym_value + reloc_data.reloc_addend
+ (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_offset
+ + reloc_data.sym_section->output_section->vma)
+ : 0);
BFD_ASSERT (ah->got_ents);
bfd_vma got_offset = ah->got_ents->offset;
reloc_data.sym_section = htab->splt;
reloc_data.should_relocate = true;
}
- /* See pr22269. */
- else if (!resolved_to_zero)
+ else
continue;
}
else
BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
if (htab->sgot != NULL)
reloc_data.got_symbol_vma = htab->sgot->output_section->vma
- + htab->sgot->output_offset;
+ + htab->sgot->output_offset;
}
- if (is_reloc_for_GOT (howto)
- || (is_reloc_for_TLS (howto)
- && !resolved_to_zero))
+ if ((is_reloc_for_GOT (howto)
+ || is_reloc_for_TLS (howto)))
{
reloc_data.should_relocate = true;
if (h == NULL)
{
- create_got_dynrelocs_for_single_entry
- (got_entry_for_type (list,
- arc_got_entry_type_for_reloc (howto)),
- output_bfd, info, NULL);
+ create_got_dynrelocs_for_single_entry (
+ got_entry_for_type (list,
+ arc_got_entry_type_for_reloc (howto)),
+ output_bfd, info, NULL);
}
}
-#define IS_ARC_PCREL_TYPE(TYPE) \
- ((TYPE == R_ARC_PC32) \
- || (TYPE == R_ARC_32_PCREL))
+#define IS_ARC_PCREL_TYPE(TYPE) \
+ ( (TYPE == R_ARC_PC32) \
+ || (TYPE == R_ARC_32_PCREL))
switch (r_type)
{
- case R_ARC_64:
- case R_ARC_32:
- case R_ARC_32_ME:
- case R_ARC_PC32:
- case R_ARC_32_PCREL:
- case R_ARC_HI32_ME:
- case R_ARC_LO32_ME:
- if (bfd_link_pic (info)
- && !resolved_to_zero
- && (input_section->flags & SEC_ALLOC) != 0
- && (!IS_ARC_PCREL_TYPE (r_type)
- || (h != NULL
- && h->dynindx != -1
- && (!SYMBOL_REFERENCES_LOCAL (info, h)))))
- {
- Elf_Internal_Rela outrel;
- bfd_byte *loc;
- bool skip = false;
- bool relocate = false;
- asection *sreloc = _bfd_elf_get_dynamic_reloc_section
- (input_bfd, input_section,
- /*RELA*/ true);
+ case R_ARC_32:
+ case R_ARC_32_ME:
+ case R_ARC_PC32:
+ case R_ARC_32_PCREL:
+ if (bfd_link_pic (info)
+ && (input_section->flags & SEC_ALLOC) != 0
+ && (!IS_ARC_PCREL_TYPE (r_type)
+ || (h != NULL
+ && h->dynindx != -1
+ && !h->def_regular
+ && (!info->symbolic || !h->def_regular))))
+ {
+ Elf_Internal_Rela outrel;
+ bfd_byte *loc;
+ bool skip = false;
+ bool relocate = false;
+ asection *sreloc = _bfd_elf_get_dynamic_reloc_section
+ (input_bfd, input_section,
+ /*RELA*/ true);
- BFD_ASSERT (sreloc != NULL);
+ BFD_ASSERT (sreloc != NULL);
- outrel.r_offset = _bfd_elf_section_offset (output_bfd,
- info,
- input_section,
- rel->r_offset);
+ outrel.r_offset = _bfd_elf_section_offset (output_bfd,
+ info,
+ input_section,
+ rel->r_offset);
if (outrel.r_offset == (bfd_vma) -1)
skip = true;
- outrel.r_addend = rel->r_addend;
- outrel.r_offset += (input_section->output_section->vma
- + input_section->output_offset);
+ outrel.r_addend = rel->r_addend;
+ outrel.r_offset += (input_section->output_section->vma
+ + input_section->output_offset);
- if (skip)
- {
- memset (&outrel, 0, sizeof outrel);
- relocate = false;
- }
- else if (h != NULL
- && h->dynindx != -1
- && (IS_ARC_PCREL_TYPE (r_type)
- || !(bfd_link_executable (info)
- || SYMBOLIC_BIND (info, h))
- || ! h->def_regular))
- {
- BFD_ASSERT (h != NULL);
- if ((input_section->flags & SEC_ALLOC) != 0)
+ if (skip)
+ {
+ memset (&outrel, 0, sizeof outrel);
relocate = false;
- else
+ }
+ else if (h != NULL
+ && h->dynindx != -1
+ && (IS_ARC_PCREL_TYPE (r_type)
+ || !(bfd_link_executable (info)
+ || SYMBOLIC_BIND (info, h))
+ || ! h->def_regular))
+ {
+ 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
+ {
+ /* Handle local symbols, they either do not have a
+ global hash table entry (h == NULL), or are
+ forced local due to a version script
+ (h->forced_local), or the third condition is
+ legacy, it appears to say something like, for
+ links where we are pre-binding the symbols, or
+ there's not an entry for this symbol in the
+ dynamic symbol table, and it's a regular symbol
+ not defined in a shared object, then treat the
+ symbol as local, resolve it now. */
relocate = true;
+ /* outrel.r_addend = 0; */
+ outrel.r_info = ELF32_R_INFO (0, R_ARC_RELATIVE);
+ }
- BFD_ASSERT (h->dynindx != -1);
- outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
- }
- else
- {
- /* Handle local symbols, they either do not have a
- global hash table entry (h == NULL), or are
- forced local due to a version script
- (h->forced_local), or the third condition is
- legacy, it appears to say something like, for
- links where we are pre-binding the symbols, or
- there's not an entry for this symbol in the
- dynamic symbol table, and it's a regular symbol
- not defined in a shared object, then treat the
- symbol as local, resolve it now. */
- relocate = true;
- /* outrel.r_addend = 0; */
- outrel.r_info = ELFNN_R_INFO (0, R_ARC_RELATIVE);
- }
-
- BFD_ASSERT (sreloc->contents != 0);
+ BFD_ASSERT (sreloc->contents != 0);
- loc = sreloc->contents;
- loc += sreloc->reloc_count * sizeof (ElfNN_External_Rela);
- sreloc->reloc_count += 1;
+ loc = sreloc->contents;
+ loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
+ sreloc->reloc_count += 1;
- bed->s->swap_reloca_out (output_bfd, &outrel, loc);
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
- if (!relocate)
- continue;
- }
- break;
- default:
- break;
+ if (!relocate)
+ continue;
+ }
+ break;
+ default:
+ break;
}
if (is_reloc_SDA_relative (howto)
/* Make sure we have with a dynamic linker. In case of GOT and PLT
the sym_section should point to .got or .plt respectively. */
if ((is_reloc_for_GOT (howto) || is_reloc_for_PLT (howto))
- && reloc_data.sym_section == NULL
- && !resolved_to_zero)
+ && reloc_data.sym_section == NULL)
{
_bfd_error_handler
- (_("GOT and PLT relocations cannot be fixed with a non dynamic" \
- " linker"));
+ (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
bfd_set_error (bfd_error_bad_value);
return false;
}
case bfd_reloc_overflow:
(*info->callbacks->reloc_overflow)
- (info, (h ? &h->root : NULL), reloc_data.symbol_name, howto->name,
- (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
+ (info, (h ? &h->root : NULL), reloc_data.symbol_name, howto->name, (bfd_vma) 0,
+ input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
(*info->callbacks->undefined_symbol)
- (info, reloc_data.symbol_name, input_bfd, input_section,
- rel->r_offset, true);
+ (info, reloc_data.symbol_name, input_bfd, input_section, rel->r_offset, true);
break;
case bfd_reloc_other:
/* xgettext:c-format */
- msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the" \
- " small data area");
+ msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
break;
case bfd_reloc_outofrange:
}
if (msg)
- _bfd_error_handler (msg, input_bfd, input_section,
- reloc_data.symbol_name);
+ _bfd_error_handler (msg, input_bfd, input_section, reloc_data.symbol_name);
return false;
}
unsigned long r_symndx;
struct elf_link_hash_entry *h;
- r_type = ELFNN_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rel->r_info);
if (r_type >= (int) R_ARC_max)
{
howto = arc_elf_howto (r_type);
/* Load symbol information. */
- r_symndx = ELFNN_R_SYM (rel->r_info);
+ r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol. */
h = NULL;
else /* Global one. */
switch (r_type)
{
- case R_ARC_8:
- case R_ARC_16:
case R_ARC_32:
- case R_ARC_64:
case R_ARC_32_ME:
- case R_ARC_HI32_ME:
- case R_ARC_LO32_ME:
/* During shared library creation, these relocs should not
appear in a shared library (as memory will be read only
and the dynamic linker can not resolve these. However
return false;
}
- /* In some cases we are not setting the 'non_got_ref' flag,
- even though the relocations don't require a GOT access.
- We should extend the testing in this area to ensure that
- no significant cases are being missed. */
- if (h)
- h->non_got_ref = 1;
-
- /* We don't need to handle relocs into sections not going
- into the "real" output. */
- if ((sec->flags & SEC_ALLOC) == 0)
- break;
-
- /* No need to do anything if we're not creating a shared
- object. */
- if (!bfd_link_pic (info)
- || (h != NULL
- && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
- break;
+ /* In some cases we are not setting the 'non_got_ref'
+ flag, even though the relocations don't require a GOT
+ access. We should extend the testing in this area to
+ ensure that no significant cases are being missed. */
+ if (h)
+ h->non_got_ref = 1;
+ /* FALLTHROUGH */
+ case R_ARC_PC32:
+ case R_ARC_32_PCREL:
+ if ((bfd_link_pic (info))
+ && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
+ || (h != NULL
+ && (!info->symbolic || !h->def_regular))))
+ {
+ if (sreloc == NULL)
+ {
+ if (info->dynamic
+ && ! htab->dynamic_sections_created
+ && ! _bfd_elf_link_create_dynamic_sections (abfd, info))
+ return false;
+ sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
+ 2, abfd,
+ /*rela*/
+ true);
+
+ if (sreloc == NULL)
+ return false;
+ }
+ sreloc->size += sizeof (Elf32_External_Rela);
- /* fall through */
- case R_ARC_PC32:
- case R_ARC_32_PCREL:
- if (!bfd_link_pic (info))
+ }
+ default:
break;
-
- if (((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
- || (!SYMBOL_REFERENCES_LOCAL (info, h))))
- {
- if (sreloc == NULL)
- {
- if (info->dynamic
- && ! htab->dynamic_sections_created
- && ! _bfd_elf_link_create_dynamic_sections (abfd, info))
- return false;
- sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
- 2, abfd,
- /* rela */
- true);
-
- if (sreloc == NULL)
- return false;
- }
- sreloc->size += sizeof (ElfNN_External_Rela);
- }
- default:
- break;
}
if (is_reloc_for_PLT (howto))
if (! _bfd_elf_create_got_section (dynobj, info))
return false;
- arc_fill_got_info_for_reloc
- (arc_got_entry_type_for_reloc (howto),
- get_got_entry_list_for_symbol (abfd, r_symndx, h),
- info,
- h);
+ arc_fill_got_info_for_reloc (
+ arc_got_entry_type_for_reloc (howto),
+ get_got_entry_list_for_symbol (abfd, r_symndx, h),
+ info,
+ h);
}
}
return true;
}
-static struct plt_version_t *
+#define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
+
+static const struct plt_version_t *
arc_get_plt_version (struct bfd_link_info *info)
{
int i;
(int) plt_versions[i].elem_size);
}
- if (bfd_get_mach (info->output_bfd) == bfd_mach_arcv3_64)
- {
- return &(plt_versions[ELF_ARCV3_PIC]);
- }
- else if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2
- || bfd_get_mach (info->output_bfd) == bfd_mach_arcv3_32)
+ if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2)
{
if (bfd_link_pic (info))
return &(plt_versions[ELF_ARCV2_PIC]);
else
return &(plt_versions[ELF_ARC_ABS]);
}
- BFD_ASSERT (0);
- return NULL;
}
static bfd_vma
htab->splt->size += plt_data->elem_size;
ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size);
- htab->sgotplt->size += GOT_ENTRY_SIZE;
- htab->srelplt->size += sizeof (ElfNN_External_Rela);
+ htab->sgotplt->size += 4;
+ htab->srelplt->size += sizeof (Elf32_External_Rela);
+
return ret;
}
switch (SYM_ONLY (reloc->symbol))
{
- case SGOT:
- relocation
- = htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset + symbol_got_offset;
- break;
+ case SGOT:
+ relocation
+ = htab->sgotplt->output_section->vma
+ + htab->sgotplt->output_offset + symbol_got_offset;
+ break;
}
relocation += reloc->addend;
reloc_offset -= (IS_INSN_24 (reloc->symbol)) ? 2 : 0;
relocation -= htab->splt->output_section->vma
- + htab->splt->output_offset
- + plt_offset + reloc_offset;
+ + htab->splt->output_offset
+ + plt_offset + reloc_offset;
}
/* TODO: being ME is not a property of the relocation but of the
- section of which is applying the relocation. */
+ section of which is applying the relocation. */
if (IS_MIDDLE_ENDIAN (reloc->symbol) && !bfd_big_endian (abfd))
{
relocation
= ((relocation & 0xffff0000) >> 16)
- | ((relocation & 0xffff) << 16);
+ | ((relocation & 0xffff) << 16);
}
switch (reloc->size)
{
- case 32:
- bfd_put_32 (htab->splt->output_section->owner,
- relocation,
- htab->splt->contents + plt_offset + reloc->offset);
- break;
+ case 32:
+ bfd_put_32 (htab->splt->output_section->owner,
+ relocation,
+ htab->splt->contents + plt_offset + reloc->offset);
+ break;
}
reloc = &(reloc[1]); /* Jump to next relocation. */
{
const struct plt_version_t *plt_data = arc_get_plt_version (info);
struct elf_link_hash_table *htab = elf_hash_table (info);
- const struct elf_backend_data *bed;
bfd_vma plt_index = (h->plt.offset - plt_data->entry_size)
- / plt_data->elem_size;
- bfd_vma got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
- bed = get_elf_backend_data (output_bfd);
+ / plt_data->elem_size;
+ bfd_vma got_offset = (plt_index + 3) * 4;
ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
rel.r_addend = 0;
BFD_ASSERT (h->dynindx != -1);
- rel.r_info = ELFNN_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
+ rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
loc = htab->srelplt->contents;
- loc += plt_index * sizeof (ElfNN_External_Rela); /* relA */
- bed->s->swap_reloca_out (output_bfd, &rel, loc);
+ loc += plt_index * sizeof (Elf32_External_Rela); /* relA */
+ bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
}
}
-/* Initialize the PLT with ARC specific PLT header. See arc-plt.def.
- Use middle-endian to fill in the data as it is executable code. */
-
static void
relocate_plt_for_entry (bfd *abfd,
struct bfd_link_info *info)
{
const struct plt_version_t *plt_data = arc_get_plt_version (info);
struct elf_link_hash_table *htab = elf_hash_table (info);
- bfd_vma i = 0;
- uint16_t *ptr = (uint16_t *) plt_data->entry;
- for (i = 0; i < plt_data->entry_size/2; i++)
- {
- bfd_put_16 (abfd, (bfd_vma) ptr[i], htab->splt->contents + (i*2));
- }
+ {
+ 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);
}
static bool
elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info,
- struct elf_link_hash_entry *h)
+ struct elf_link_hash_entry *h)
{
asection *s;
bfd *dynobj = (elf_hash_table (info))->dynobj;
struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
BFD_ASSERT (arc_htab->elf.srelbss != NULL);
- arc_htab->elf.srelbss->size += sizeof (ElfNN_External_Rela);
+ arc_htab->elf.srelbss->size += sizeof (Elf32_External_Rela);
h->needs_copy = 1;
}
/* Function : elf_arc_finish_dynamic_symbol
Brief : Finish up dynamic symbol handling. We set the
- contents of various dynamic sections here.
+ contents of various dynamic sections here.
Args : output_bfd :
info :
h :
struct elf_link_hash_entry *h,
Elf_Internal_Sym * sym)
{
- const struct elf_backend_data *bed;
-
- bed = get_elf_backend_data (output_bfd);
-
if (h->plt.offset != (bfd_vma) -1)
{
relocate_plt_for_symbol (output_bfd, info, h);
create respective dynamic relocs. */
/* TODO: Make function to get list and not access the list directly. */
/* TODO: Move function to relocate_section create this relocs eagerly. */
- struct elf_arc_link_hash_entry *ah = (struct elf_arc_link_hash_entry *) h;
- create_got_dynrelocs_for_got_info (&ah->got_ents, output_bfd, info, h);
+ struct elf_arc_link_hash_entry *ah =
+ (struct elf_arc_link_hash_entry *) h;
+ create_got_dynrelocs_for_got_info (&ah->got_ents,
+ output_bfd,
+ info,
+ h);
if (h->needs_copy)
{
+ h->root.u.def.section->output_offset);
bfd_byte * loc = arc_htab->elf.srelbss->contents
- + (arc_htab->elf.srelbss->reloc_count * sizeof (ElfNN_External_Rela));
+ + (arc_htab->elf.srelbss->reloc_count * sizeof (Elf32_External_Rela));
arc_htab->elf.srelbss->reloc_count++;
Elf_Internal_Rela rel;
rel.r_offset = rel_offset;
BFD_ASSERT (h->dynindx != -1);
- rel.r_info = ELFNN_R_INFO (h->dynindx, R_ARC_COPY);
+ rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY);
- bed->s->swap_reloca_out (output_bfd, &rel, loc);
+ bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
}
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
while (list != NULL)
{
create_got_dynrelocs_for_single_entry (list, tmp->output_bfd,
- tmp->info, (struct elf_link_hash_entry *) h);
+ tmp->info,
+ (struct elf_link_hash_entry *) h);
list = list->next;
}
}
struct elf_link_hash_table *htab = elf_hash_table (info);
bfd *dynobj = (elf_hash_table (info))->dynobj;
asection *sdyn = bfd_get_linker_section (dynobj, ".dynamic");
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
- /* TODO: instead of checking for sdyn, we can use elf_hash_table
- (info)->dynamic_sections_created to see if we have dynamic
- sections creared. */
if (sdyn)
{
- ElfNN_External_Dyn *dyncon, *dynconend;
+ Elf32_External_Dyn *dyncon, *dynconend;
- dyncon = (ElfNN_External_Dyn *) sdyn->contents;
- dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
+ dyncon = (Elf32_External_Dyn *) sdyn->contents;
+ dynconend
+ = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
for (; dyncon < dynconend; dyncon++)
{
Elf_Internal_Dyn internal_dyn;
struct elf_link_hash_entry *h = NULL;
asection *s = NULL;
- bed->s->swap_dyn_in (dynobj, dyncon, &internal_dyn);
+ bfd_elf32_swap_dyn_in (dynobj, dyncon, &internal_dyn);
switch (internal_dyn.d_tag)
{
GET_SYMBOL_OR_SECTION (DT_INIT, info->init_function, NULL)
- GET_SYMBOL_OR_SECTION (DT_FINI, info->fini_function, NULL)
- GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt")
- GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt")
- GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt")
- GET_SYMBOL_OR_SECTION (DT_VERSYM, NULL, ".gnu.version")
- GET_SYMBOL_OR_SECTION (DT_VERDEF, NULL, ".gnu.version_d")
- GET_SYMBOL_OR_SECTION (DT_VERNEED, NULL, ".gnu.version_r")
- default:
- break;
+ GET_SYMBOL_OR_SECTION (DT_FINI, info->fini_function, NULL)
+ GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt")
+ GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt")
+ GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt")
+ GET_SYMBOL_OR_SECTION (DT_VERSYM, NULL, ".gnu.version")
+ GET_SYMBOL_OR_SECTION (DT_VERDEF, NULL, ".gnu.version_d")
+ GET_SYMBOL_OR_SECTION (DT_VERNEED, NULL, ".gnu.version_r")
+ default:
+ break;
}
/* In case the dynamic symbols should be updated with a symbol. */
}
if (do_it)
- bed->s->swap_dyn_out (output_bfd, &internal_dyn, dyncon);
+ bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon);
}
- /* Fill in the first entry in the procedure linkage table. */
if (htab->splt->size > 0)
{
relocate_plt_for_entry (output_bfd, info);
/* TODO: Validate this. */
if (htab->srelplt->output_section != bfd_abs_section_ptr)
elf_section_data (htab->srelplt->output_section)
- ->this_hdr.sh_entsize = GOT_ENTRY_SIZE * 3;
+ ->this_hdr.sh_entsize = 12;
}
/* Fill in the first three entries in the global offset table. */
if (htab->sgot)
{
- struct elf_link_hash_entry *got;
- /* Get the hash entry of the first GOT entry. */
- got = elf_link_hash_lookup (elf_hash_table (info),
- "_GLOBAL_OFFSET_TABLE_", false, false, true);
-
- if (got != NULL
- && got->root.type != bfd_link_hash_undefined
- && got->root.u.def.section != NULL)
- {
- asection *sec = got->root.u.def.section;
- bfd_vma dyn_vma = 0;
+ struct elf_link_hash_entry *h;
+ h = elf_link_hash_lookup (elf_hash_table (info), "_GLOBAL_OFFSET_TABLE_",
+ false, false, true);
- /* Check if we participate in a dynamic linking. */
- if (sdyn)
- {
- /* Get the unrelocated address of the _DYNAMIC, which is
- the start of the start of the dynamic sction. */
- dyn_vma = sdyn->output_section->vma + sdyn->output_offset;
- }
+ if (h != NULL && h->root.type != bfd_link_hash_undefined
+ && h->root.u.def.section != NULL)
+ {
+ asection *sec = h->root.u.def.section;
- /* _GLOBAL_OFFSET_TABLE_[0] = VMA (.dynamic) */
- write_in_got (output_bfd, dyn_vma, sec->contents);
- /* _GLOBAL_OFFSET_TABLE_[1] = 0. Reserved for dynamic linker. */
- write_in_got (output_bfd, (bfd_vma) 0,
- sec->contents + (GOT_ENTRY_SIZE));
- /* _GLOBAL_OFFSET_TABLE_[2] = 0. Reserved for dynamic linker. */
- write_in_got (output_bfd, (bfd_vma) 0,
- sec->contents + (GOT_ENTRY_SIZE * 2));
+ if (sdyn == NULL)
+ bfd_put_32 (output_bfd, (bfd_vma) 0,
+ sec->contents);
+ else
+ bfd_put_32 (output_bfd,
+ sdyn->output_section->vma + sdyn->output_offset,
+ sec->contents);
+ bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 4);
+ bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 8);
}
}
bfd *dynobj;
asection *s;
bool relocs_exist = false;
- bool reltext_exist = false;
struct elf_link_hash_table *htab = elf_hash_table (info);
dynobj = htab->dynobj;
{
s = bfd_get_section_by_name (dynobj, ".interp");
BFD_ASSERT (s != NULL);
- s->size = sizeof (ELFNN_DYNAMIC_INTERPRETER);
- s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
+ s->size = sizeof (ELF_DYNAMIC_INTERPRETER);
+ s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
}
/* Add some entries to the .dynamic section. We fill in some of
else if (startswith (s->name, ".rela"))
{
if (s->size != 0 && s != htab->srelplt)
- {
- if (!reltext_exist)
- {
- const char *name = s->name + 5;
- bfd *ibfd;
- for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
- if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
- && ibfd->flags & DYNAMIC)
- {
- asection *target = bfd_get_section_by_name (ibfd, name);
- if (target != NULL
- && elf_section_data (target)->sreloc == s
- && ((target->output_section->flags
- & (SEC_READONLY | SEC_ALLOC))
- == (SEC_READONLY | SEC_ALLOC)))
- {
- reltext_exist = true;
- break;
- }
- }
- }
- relocs_exist = true;
- }
+ relocs_exist = true;
/* We use the reloc_count field as a counter if we need to
copy relocs into the output file. */
return false;
}
- if (htab->dynamic_sections_created)
- {
- /* TODO: Check if this is needed. */
- if (!bfd_link_pic (info))
- if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
- return false;
-
- if (htab->splt && (htab->splt->flags & SEC_EXCLUDE) == 0)
- if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
- || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
- return false;
-
- if (relocs_exist)
- if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
- sizeof (ElfNN_External_Rela)))
- return false;
-
- if (reltext_exist)
- if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
- return false;
- }
-
- return true;
+ return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs_exist);
}
-/* Classify dynamic relocs such that -z combreloc can reorder and
- combine them. */
+/* Classify dynamic relocs such that -z combreloc can reorder and combine
+ them. */
static enum elf_reloc_type_class
-arc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
- const asection *rel_sec ATTRIBUTE_UNUSED,
- const Elf_Internal_Rela *rela)
+elf32_arc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
- switch ((int) ELFNN_R_TYPE (rela->r_info))
+ switch ((int) ELF32_R_TYPE (rela->r_info))
{
case R_ARC_RELATIVE:
return reloc_class_relative;
return reloc_class_plt;
case R_ARC_COPY:
return reloc_class_copy;
+ /* TODO: Needed in future to support ifunc. */
+ /*
+ case R_ARC_IRELATIVE:
+ return reloc_class_ifunc;
+ */
default:
return reloc_class_normal;
}
}
-/* We use this so we can override certain functions
- (though currently we don't). */
+const struct elf_size_info arc_elf32_size_info =
+{
+ sizeof (Elf32_External_Ehdr),
+ sizeof (Elf32_External_Phdr),
+ sizeof (Elf32_External_Shdr),
+ sizeof (Elf32_External_Rel),
+ sizeof (Elf32_External_Rela),
+ sizeof (Elf32_External_Sym),
+ sizeof (Elf32_External_Dyn),
+ sizeof (Elf_External_Note),
+ 4,
+ 1,
+ 32, 2,
+ ELFCLASS32, EV_CURRENT,
+ bfd_elf32_write_out_phdrs,
+ bfd_elf32_write_shdrs_and_ehdr,
+ bfd_elf32_checksum_contents,
+ bfd_elf32_write_relocs,
+ bfd_elf32_swap_symbol_in,
+ bfd_elf32_swap_symbol_out,
+ bfd_elf32_slurp_reloc_table,
+ bfd_elf32_slurp_symbol_table,
+ bfd_elf32_swap_dyn_in,
+ bfd_elf32_swap_dyn_out,
+ bfd_elf32_swap_reloc_in,
+ bfd_elf32_swap_reloc_out,
+ bfd_elf32_swap_reloca_in,
+ bfd_elf32_swap_reloca_out
+};
-const struct elf_size_info arc_elfNN_size_info =
- {
- sizeof (ElfNN_External_Ehdr),
- sizeof (ElfNN_External_Phdr),
- sizeof (ElfNN_External_Shdr),
- sizeof (ElfNN_External_Rel),
- sizeof (ElfNN_External_Rela),
- sizeof (ElfNN_External_Sym),
- sizeof (ElfNN_External_Dyn),
- sizeof (Elf_External_Note),
- 4,
- 1,
- ARCH_SIZE,
- LOG_FILE_ALIGN,
- ELFCLASSNN, EV_CURRENT,
- bfd_elfNN_write_out_phdrs,
- bfd_elfNN_write_shdrs_and_ehdr,
- bfd_elfNN_checksum_contents,
- bfd_elfNN_write_relocs,
- bfd_elfNN_swap_symbol_in,
- bfd_elfNN_swap_symbol_out,
- bfd_elfNN_slurp_reloc_table,
- bfd_elfNN_slurp_symbol_table,
- bfd_elfNN_swap_dyn_in,
- bfd_elfNN_swap_dyn_out,
- bfd_elfNN_swap_reloc_in,
- bfd_elfNN_swap_reloc_out,
- bfd_elfNN_swap_reloca_in,
- bfd_elfNN_swap_reloca_out
- };
+#define elf_backend_size_info arc_elf32_size_info
/* GDB expects general purpose registers to be in section .reg. However Linux
kernel doesn't create this section and instead writes registers to NOTE
stable. */
static bool
-elfNN_arc_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
+elf32_arc_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
size_t size;
return false;
case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
- /* pr_cursig. */
+ /* pr_cursig */
elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
- /* pr_pid. */
+ /* pr_pid */
elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
- /* pr_regs. */
+ /* pr_regs */
offset = 72;
size = (40 * 4); /* There are 40 registers in user_regs_struct. */
break;
string or both. */
static int
-elfNN_arc_obj_attrs_arg_type (int tag)
+elf32_arc_obj_attrs_arg_type (int tag)
{
if (tag == Tag_ARC_CPU_name
- || tag == Tag_ARC_ISA_config
- || tag == Tag_ARC_ISA_apex)
+ || tag == Tag_ARC_ISA_config
+ || tag == Tag_ARC_ISA_apex)
return ATTR_TYPE_FLAG_STR_VAL;
else if (tag < (Tag_ARC_ISA_mpy_option + 1))
return ATTR_TYPE_FLAG_INT_VAL;
/* Attribute numbers >=14 can be safely ignored. */
static bool
-elfNN_arc_obj_attrs_handle_unknown (bfd *abfd, int tag)
+elf32_arc_obj_attrs_handle_unknown (bfd *abfd, int tag)
{
if ((tag & 127) < (Tag_ARC_ISA_mpy_option + 1))
{
}
}
-/* Handle an ARC specific section when reading an object file. This
- is called when bfd_section_from_shdr finds a section with an
- unknown type. */
+/* Handle an ARC specific section when reading an object file. This is
+ called when bfd_section_from_shdr finds a section with an unknown
+ type. */
static bool
-elfNN_arc_section_from_shdr (bfd *abfd,
+elf32_arc_section_from_shdr (bfd *abfd,
Elf_Internal_Shdr * hdr,
const char *name,
int shindex)
return true;
}
-/* Delete a number of bytes from a given section while relaxing. */
-
-static bool
-arc_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
- asection *sec, bfd_vma addr, int count)
-{
- Elf_Internal_Shdr *symtab_hdr;
- unsigned int sec_shndx;
- bfd_byte *contents;
- Elf_Internal_Rela *irel, *irelend;
- bfd_vma toaddr;
- Elf_Internal_Sym *isym;
- Elf_Internal_Sym *isymend;
- struct elf_link_hash_entry **sym_hashes;
- struct elf_link_hash_entry **end_hashes;
- struct elf_link_hash_entry **start_hashes;
- unsigned int symcount;
-
- sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
-
- contents = elf_section_data (sec)->this_hdr.contents;
-
- toaddr = sec->size;
-
- irel = elf_section_data (sec)->relocs;
- irelend = irel + sec->reloc_count;
-
- /* Actually delete the bytes. */
- memmove (contents + addr, contents + addr + count,
- (size_t) (toaddr - addr - count));
- sec->size -= count;
-
- /* Adjust all the relocs. */
- for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
- /* Get the new reloc address. */
- if ((irel->r_offset > addr && irel->r_offset < toaddr))
- irel->r_offset -= count;
-
- /* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- isym = (Elf_Internal_Sym *) symtab_hdr->contents;
- for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
- {
- if (isym->st_shndx == sec_shndx
- && isym->st_value > addr
- && isym->st_value <= toaddr)
- {
- /* Adjust the addend of SWITCH relocations in this section,
- which reference this local symbol. */
- isym->st_value -= count;
- }
- }
-
- /* Now adjust the global symbols defined in this section. */
- symcount = (symtab_hdr->sh_size / sizeof (ElfNN_External_Sym)
- - symtab_hdr->sh_info);
- sym_hashes = start_hashes = elf_sym_hashes (abfd);
- end_hashes = sym_hashes + symcount;
-
- for (; sym_hashes < end_hashes; sym_hashes++)
- {
- struct elf_link_hash_entry *sym_hash = *sym_hashes;
-
- /* The '--wrap SYMBOL' option is causing a pain when the object
- file, containing the definition of __wrap_SYMBOL, includes a
- direct call to SYMBOL as well. Since both __wrap_SYMBOL and
- SYMBOL reference the same symbol (which is __wrap_SYMBOL),
- but still exist as two different symbols in 'sym_hashes', we
- don't want to adjust the global symbol __wrap_SYMBOL twice.
- This check is only relevant when symbols are being
- wrapped. */
- if (link_info->wrap_hash != NULL)
- {
- struct elf_link_hash_entry **cur_sym_hashes;
-
- /* Loop only over the symbols whom been already checked. */
- for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
- cur_sym_hashes++)
- /* If the current symbol is identical to 'sym_hash', that means
- the symbol was already adjusted (or at least checked). */
- if (*cur_sym_hashes == sym_hash)
- break;
-
- /* Don't adjust the symbol again. */
- if (cur_sym_hashes < sym_hashes)
- continue;
- }
-
- if ((sym_hash->root.type == bfd_link_hash_defined
- || sym_hash->root.type == bfd_link_hash_defweak)
- && sym_hash->root.u.def.section == sec)
- {
- /* As above, adjust the value if needed. */
- if (sym_hash->root.u.def.value > addr
- && sym_hash->root.u.def.value <= toaddr)
- sym_hash->root.u.def.value -= count;
-
- /* As above, adjust the size if needed. */
- if (sym_hash->root.u.def.value <= addr
- && sym_hash->root.u.def.value + sym_hash->size > addr
- && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
- sym_hash->size -= count;
- }
- }
-
- return true;
-}
-
-/* Check Tag_ARC_PCS_config if we can relax. */
-static bool
-arc_can_relax_p (bfd *abfd)
-{
- obj_attribute *attr = elf_known_obj_attributes_proc (abfd);
-
- if (attr[Tag_ARC_PCS_config].i & 0x100)
- return true;
- return false;
-}
-
/* Relaxation hook.
These are the current relaxing opportunities available:
* R_ARC_GOTPC32 => R_ARC_PCREL.
- * R_ARC_S25W_PCREL => R_ARC_S13_PCREL.
-
- This is a two step relaxation procedure, in the first round, we
- relax all the above opportunities. In the second round, we deal
- with function align by removing unnecessary NOP_S placed by the
- assembler.
- Inspired from CRX and RISCV backends. */
+*/
static bool
arc_elf_relax_section (bfd *abfd, asection *sec,
Elf_Internal_Rela *irel, *irelend;
bfd_byte *contents = NULL;
Elf_Internal_Sym *isymbuf = NULL;
- bool do_relax = false;
/* Assume nothing changes. */
*again = false;
- /* Check if we can do size related relaxation. */
- do_relax = arc_can_relax_p (abfd);
-
/* We don't have to do anything for a relocatable link, if this
section does not have relocs, or if this is not a code
section. */
|| sec->reloc_count == 0
|| (sec->flags & SEC_RELOC) == 0
|| (sec->flags & SEC_HAS_CONTENTS) == 0
- || sec->sec_flg0
|| (sec->flags & SEC_CODE) == 0)
return true;
irelend = internal_relocs + sec->reloc_count;
for (irel = internal_relocs; irel < irelend; irel++)
{
- asection *sym_sec;
- struct elf_link_hash_entry *htop = NULL;
- bfd_vma symval;
-
- /* If this isn't something that can be relaxed, then ignore this
- reloc. */
- if (ELFNN_R_TYPE (irel->r_info) != (int) R_ARC_GOTPC32
- && ELFNN_R_TYPE (irel->r_info) != (int) R_ARC_S25W_PCREL
- && ELFNN_R_TYPE (irel->r_info) != (int) R_ARC_ALIGN)
- continue;
+ /* If this isn't something that can be relaxed, then ignore
+ this reloc. */
+ if (ELF32_R_TYPE (irel->r_info) != (int) R_ARC_GOTPC32)
+ continue;
/* Get the section contents if we haven't done so already. */
if (contents == NULL)
- {
- /* Get cached copy if it exists. */
- if (elf_section_data (sec)->this_hdr.contents != NULL)
- contents = elf_section_data (sec)->this_hdr.contents;
- /* Go get them off disk. */
- else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
- goto error_return;
- }
+ {
+ /* Get cached copy if it exists. */
+ if (elf_section_data (sec)->this_hdr.contents != NULL)
+ contents = elf_section_data (sec)->this_hdr.contents;
+ /* Go get them off disk. */
+ else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
+ goto error_return;
+ }
/* Read this BFD's local symbols if we haven't done so already. */
if (isymbuf == NULL && symtab_hdr->sh_info != 0)
- {
- isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
- if (isymbuf == NULL)
- isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
- symtab_hdr->sh_info, 0,
- NULL, NULL, NULL);
- if (isymbuf == NULL)
- goto error_return;
- }
+ {
+ isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+ if (isymbuf == NULL)
+ isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
+ symtab_hdr->sh_info, 0,
+ NULL, NULL, NULL);
+ if (isymbuf == NULL)
+ goto error_return;
+ }
- /* Get the value of the symbol referred to by the reloc. */
- if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
- {
- /* A local symbol. */
- Elf_Internal_Sym *isym;
-
- isym = isymbuf + ELFNN_R_SYM (irel->r_info);
- sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
- symval = isym->st_value;
- /* If the reloc is absolute, it will not have
- a symbol or section associated with it. */
- if (sym_sec)
- symval += sym_sec->output_section->vma
- + sym_sec->output_offset;
- }
- else
+ struct elf_link_hash_entry *htop = NULL;
+
+ if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
{
/* An external symbol. */
- unsigned int indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
+ unsigned int indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
htop = elf_sym_hashes (abfd)[indx];
-
- BFD_ASSERT (htop != NULL);
- if (htop->root.type != bfd_link_hash_defined
- && htop->root.type != bfd_link_hash_defweak)
- /* This appears to be a reference to an undefined
- symbol. Just ignore it--it will be caught by the
- regular reloc processing. */
- continue;
-
- symval = (htop->root.u.def.value
- + htop->root.u.def.section->output_section->vma
- + htop->root.u.def.section->output_offset);
- sym_sec = htop->root.u.def.section;
}
- if (ELFNN_R_TYPE (irel->r_info) == (int) R_ARC_GOTPC32
- && SYMBOL_REFERENCES_LOCAL (link_info, htop)
- && link_info->relax_pass == 0)
+ if (ELF32_R_TYPE (irel->r_info) == (int) R_ARC_GOTPC32
+ && SYMBOL_REFERENCES_LOCAL (link_info, htop))
{
unsigned int code;
symtab_hdr->contents = (unsigned char *) isymbuf;
/* Fix the relocation's type. */
- irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info), R_ARC_PC32);
+ irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_ARC_PC32);
/* ld rA,[pcl,symbol@tgot] -> add rA,pcl,symbol@pcl. */
/* 0010 0bbb aa11 0ZZX DBBB 1111 10AA AAAA.
/* The size isn't changed, don't redo. */
*again = false;
}
-
- /* Any of the next relax rules are changing the size, allow them
- is assembler was informed. */
- if (!do_relax)
- continue;
-
- if (ELFNN_R_TYPE (irel->r_info) == (int) R_ARC_S25W_PCREL
- && link_info->relax_pass == 0)
- {
- unsigned int code;
- bfd_vma value = symval + irel->r_addend;
- bfd_vma dot, gap;
-
- /* Get the address (PCL) of this instruction. */
- dot = (sec->output_section->vma
- + sec->output_offset + irel->r_offset) & ~0x03;
-
- /* Compute the distance from this insn to the branch target. */
- gap = value - dot;
-
- /* Check if the gap falls in the range that can be
- accomodated in 13bit signed range (32-bit aligned). */
- if ((int) gap < -4094 || (int) gap > 4097 || ((int) gap & 0x3) != 0)
- continue;
-
- /* Get the opcode. */
- code = bfd_get_32_me (abfd, contents + irel->r_offset);
- /* bl @symb@pcl -> bl_s @symb@pcl. */
- /* 0000 1sss ssss ss10 SSSS SSSS SSNR tttt. */
- BFD_ASSERT ((code & 0xF8030000) == 0x08020000);
-
- /* Check for delay slot bit. */
- if (code & 0x20)
- continue;
-
- /* Note that we've changed the relocs, section contents, etc. */
- elf_section_data (sec)->relocs = internal_relocs;
- elf_section_data (sec)->this_hdr.contents = contents;
- symtab_hdr->contents = (unsigned char *) isymbuf;
-
- /* Fix the relocation's type. */
- irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
- R_ARC_S13_PCREL);
-
- /* Write back bl_s instruction. */
- bfd_put_16 (abfd, 0xF800, contents + irel->r_offset);
- /* Delete two bytes of data. */
- if (!arc_relax_delete_bytes (link_info, abfd, sec,
- irel->r_offset + 2, 2))
- goto error_return;
-
- *again = true;
- }
-
- if (ELFNN_R_TYPE (irel->r_info) == (int) R_ARC_ALIGN
- && link_info->relax_pass == 1)
- {
- bfd_vma aligned_addr;
- bfd_vma nop_bytes;
- bfd_vma alignment = 4;
-
- if (irel->r_addend == 2)
- alignment = 2;
- aligned_addr = ((irel->r_offset - 1) & ~(alignment - 1)) + alignment;
- nop_bytes = aligned_addr - irel->r_offset;
-
- /* Cannot remove more than we have left. */
- BFD_ASSERT (irel->r_addend >= nop_bytes);
- /* I should be always 16bit multiple quantum. */
- BFD_ASSERT (nop_bytes == 0 || nop_bytes == 2);
-
- /* Once we aligned we cannot relax anything else. */
- sec->sec_flg0 = true;
-
- /* Note that we've changed the relocs, section contents, etc. */
- elf_section_data (sec)->relocs = internal_relocs;
- elf_section_data (sec)->this_hdr.contents = contents;
- symtab_hdr->contents = (unsigned char *) isymbuf;
-
- /* Delete the relocation's type. */
- irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
- R_ARC_NONE);
-
- /* Add an NOP_S if needed. */
- if (nop_bytes != 0)
- bfd_put_16 (abfd, 0x78E0, contents + irel->r_offset);
-
- /* Delete nop_bytes bytes of data. */
- if (!arc_relax_delete_bytes (link_info, abfd, sec,
- irel->r_offset + nop_bytes,
- irel->r_addend - nop_bytes))
- goto error_return;
-
- *again = true;
- }
}
if (isymbuf != NULL
&& symtab_hdr->contents != (unsigned char *) isymbuf)
{
if (!link_info->keep_memory)
- free (isymbuf);
+ free (isymbuf);
else
- /* Cache the symbols for elf_link_input_bfd. */
- symtab_hdr->contents = (unsigned char *) isymbuf;
+ /* Cache the symbols for elf_link_input_bfd. */
+ symtab_hdr->contents = (unsigned char *) isymbuf;
}
if (contents != NULL
&& elf_section_data (sec)->this_hdr.contents != contents)
{
if (!link_info->keep_memory)
- free (contents);
+ free (contents);
else
- /* Cache the section contents for elf_link_input_bfd. */
- elf_section_data (sec)->this_hdr.contents = contents;
+ /* Cache the section contents for elf_link_input_bfd. */
+ elf_section_data (sec)->this_hdr.contents = contents;
}
if (elf_section_data (sec)->relocs != internal_relocs)
return false;
}
-#define TARGET_LITTLE_SYM arcAA_elfNN_le_vec
-#define TARGET_LITTLE_NAME "elfNN-littlearcAA"
-#define TARGET_BIG_SYM arc_elfNN_be_vec
-#define TARGET_BIG_NAME "elfNN-bigarc"
-#define ELF_ARCH ARC_BFD_ARCH
+#define TARGET_LITTLE_SYM arc_elf32_le_vec
+#define TARGET_LITTLE_NAME "elf32-littlearc"
+#define TARGET_BIG_SYM arc_elf32_be_vec
+#define TARGET_BIG_NAME "elf32-bigarc"
+#define ELF_ARCH bfd_arch_arc
#define ELF_TARGET_ID ARC_ELF_DATA
-
-#if (ARCH_TYPE == ARC) && (ARCH_SIZE == 32)
-# define ELF_MACHINE_CODE EM_ARC_COMPACT2
-# define ELF_MACHINE_ALT1 EM_ARC_COMPACT
-#elif (ARCH_TYPE == ARC32) || (ARCH_TYPE == ARC64)
-# define ELF_MACHINE_CODE EM_ARC_COMPACT3_64
-# define ELF_MACHINE_ALT1 EM_ARC_COMPACT3
-#else
-# error "Unsupported ARC architecture"
-#endif
-
+#define ELF_MACHINE_CODE EM_ARC_COMPACT
+#define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
#define ELF_MAXPAGESIZE 0x2000
-#define bfd_elfNN_bfd_link_hash_table_create arc_elf_link_hash_table_create
-
-#define bfd_elfNN_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
-#define bfd_elfNN_bfd_reloc_type_lookup arc_elfNN_bfd_reloc_type_lookup
-#define bfd_elfNN_bfd_set_private_flags arc_elf_set_private_flags
-#define bfd_elfNN_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
-#define bfd_elfNN_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
-#define bfd_elfNN_bfd_relax_section arc_elf_relax_section
+#define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
-#define elf_backend_size_info arc_elfNN_size_info
+#define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
+#define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
+#define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
+#define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
+#define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
+#define bfd_elf32_bfd_relax_section arc_elf_relax_section
#define elf_info_to_howto_rel arc_info_to_howto_rel
#define elf_backend_object_p arc_elf_object_p
#define elf_backend_check_relocs elf_arc_check_relocs
#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
-#define elf_backend_reloc_type_class arc_reloc_type_class
+#define elf_backend_reloc_type_class elf32_arc_reloc_type_class
#define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
#define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
#define elf_backend_plt_readonly 1
#define elf_backend_rela_plts_and_copies_p 1
#define elf_backend_want_plt_sym 0
-#define elf_backend_got_header_size (GOT_ENTRY_SIZE * 3)
+#define elf_backend_got_header_size 12
#define elf_backend_dtrel_excludes_plt 1
#define elf_backend_may_use_rel_p 0
#define elf_backend_may_use_rela_p 1
#define elf_backend_default_use_rela_p 1
-#define elf_backend_grok_prstatus elfNN_arc_grok_prstatus
+#define elf_backend_grok_prstatus elf32_arc_grok_prstatus
#define elf_backend_default_execstack 0
#undef elf_backend_obj_attrs_section
#define elf_backend_obj_attrs_section ".ARC.attributes"
#undef elf_backend_obj_attrs_arg_type
-#define elf_backend_obj_attrs_arg_type elfNN_arc_obj_attrs_arg_type
+#define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
#undef elf_backend_obj_attrs_section_type
#define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
-#define elf_backend_obj_attrs_handle_unknown \
- elfNN_arc_obj_attrs_handle_unknown
+#define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
-#define elf_backend_section_from_shdr elfNN_arc_section_from_shdr
+#define elf_backend_section_from_shdr elf32_arc_section_from_shdr
-#include "elfNN-target.h"
+#include "elf32-target.h"
projects / thirdparty / binutils-gdb.git / commitdiff
