#include "opcode/arc.h"
#include "arc-plt.h"
-#define PR_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
-
/* #define ARC_ENABLE_DEBUG 1 */
-#ifndef ARC_ENABLE_DEBUG
-#define ARC_DEBUG(...)
-#else
-static char *
+#ifdef ARC_ENABLE_DEBUG
+static const char *
name_for_global_symbol (struct elf_link_hash_entry *h)
{
static char *local_str = "(local)";
if (h == NULL)
return local_str;
- else
- return h->root.root.string;
+ return h->root.root.string;
}
-#define ARC_DEBUG(args...) fprintf (stderr, ##args)
+#define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
+#else
+#define ARC_DEBUG(...)
#endif
#undef ARC_RELOC_HOWTO
#define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
- [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, "R_" #TYPE, FALSE, 0, 0, FALSE),
+ [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
+ complain_overflow_##OVERFLOW, arc_elf_reloc, \
+ "R_" #TYPE, FALSE, 0, 0, FALSE),
static struct reloc_howto_struct elf_arc_howto_table[] =
{
unsigned char elf_reloc_val;
};
+/* ARC ELF linker hash entry. */
+struct elf_arc_link_hash_entry
+{
+ struct elf_link_hash_entry root;
+
+ /* Track dynamic relocs copied for this symbol. */
+ struct elf_dyn_relocs *dyn_relocs;
+};
+
+/* ARC ELF linker hash table. */
+struct elf_arc_link_hash_table
+{
+ struct elf_link_hash_table elf;
+
+ /* Short-cuts to get to dynamic linker sections. */
+ asection *srelbss;
+};
+
+static struct bfd_hash_entry *
+elf_arc_link_hash_newfunc (struct bfd_hash_entry *entry,
+ struct bfd_hash_table *table,
+ const char *string)
+{
+ /* Allocate the structure if it has not already been allocated by a
+ subclass. */
+ if (entry == NULL)
+ {
+ entry = (struct bfd_hash_entry *)
+ bfd_hash_allocate (table,
+ sizeof (struct elf_arc_link_hash_entry));
+ if (entry == NULL)
+ return entry;
+ }
+
+ /* Call the allocation method of the superclass. */
+ entry = _bfd_elf_link_hash_newfunc (entry, table, string);
+ if (entry != NULL)
+ {
+ struct elf_arc_link_hash_entry *eh;
+
+ eh = (struct elf_arc_link_hash_entry *) entry;
+ eh->dyn_relocs = NULL;
+ }
+
+ return entry;
+}
+
+/* Destroy an ARC ELF linker hash table. */
+static void
+elf_arc_link_hash_table_free (bfd *obfd)
+{
+ _bfd_elf_link_hash_table_free (obfd);
+}
+
+/* Create an ARC ELF linker hash table. */
+
+static struct bfd_link_hash_table *
+arc_elf_link_hash_table_create (bfd *abfd)
+{
+ struct elf_arc_link_hash_table *ret;
+
+ ret = (struct elf_arc_link_hash_table *) bfd_zmalloc (sizeof (*ret));
+ if (ret == NULL)
+ return NULL;
+
+ if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
+ elf_arc_link_hash_newfunc,
+ sizeof (struct elf_arc_link_hash_entry),
+ ARC_ELF_DATA))
+ {
+ free (ret);
+ return NULL;
+ }
+
+ ret->srelbss = NULL;
+
+ ret->elf.init_got_refcount.refcount = 0;
+ ret->elf.init_got_refcount.glist = NULL;
+ ret->elf.init_got_offset.offset = 0;
+ ret->elf.init_got_offset.glist = NULL;
+
+ ret->elf.root.hash_table_free = elf_arc_link_hash_table_free;
+
+ return &ret->elf.root;
+}
+
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
{ BFD_RELOC_##TYPE, R_##TYPE },
static const struct arc_reloc_map arc_reloc_map[] =
object file when linking. */
static bfd_boolean
-arc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+arc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
unsigned short mach_ibfd;
static unsigned short mach_obfd = EM_NONE;
flagword out_flags;
asection *sec;
/* Check if we have the same endianess. */
- if (! _bfd_generic_verify_endian_match (ibfd, obfd))
- {
- _bfd_error_handler (_("ERROR: Endian Match failed. Attempting to link "
- "%B with binary %s of opposite endian-ness"),
- ibfd, bfd_get_filename (obfd));
- return FALSE;
- }
+ if (! _bfd_generic_verify_endian_match (ibfd, info))
+ return FALSE;
/* Collect ELF flags. */
in_flags = elf_elfheader (ibfd)->e_flags & EF_ARC_MACH_MSK;
else if (in_flags != out_flags)
{
/* Warn if different flags. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: uses different e_flags (0x%lx) fields than "
"previous modules (0x%lx)"),
bfd_get_filename (ibfd), (long)in_flags, (long)out_flags);
{
if (e_machine == EM_ARC)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Error: The ARC4 architecture is no longer supported.\n"));
return FALSE;
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: unset or old architecture flags. \n"
" Use default machine.\n"));
}
return;
}
-#define BFD_DEBUG_PIC(...)
-
+#ifdef ARC_ENABLE_DEBUG
+#define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
static void
debug_arc_reloc (struct arc_relocation_data reloc_data)
{
- PR_DEBUG ("Reloc type=%s, should_relocate = %s\n",
- reloc_data.howto->name,
- reloc_data.should_relocate ? "true" : "false");
- PR_DEBUG (" offset = 0x%x, addend = 0x%x\n",
- (unsigned int) reloc_data.reloc_offset,
- (unsigned int) reloc_data.reloc_addend);
- PR_DEBUG (" Symbol:\n");
- PR_DEBUG (" value = 0x%08x\n",
- (unsigned int) reloc_data.sym_value);
+ ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
+ reloc_data.howto->name,
+ reloc_data.should_relocate ? "true" : "false");
+ ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
+ (unsigned int) reloc_data.reloc_offset,
+ (unsigned int) reloc_data.reloc_addend);
+ ARC_DEBUG (" Symbol:\n");
+ ARC_DEBUG (" value = 0x%08x\n",
+ (unsigned int) reloc_data.sym_value);
if (reloc_data.sym_section != NULL)
{
- PR_DEBUG (" Symbol Section:\n");
- PR_DEBUG (
- " section name = %s, output_offset 0x%08x",
- reloc_data.sym_section->name,
- (unsigned int) reloc_data.sym_section->output_offset);
+ ARC_DEBUG (" Symbol Section:\n");
+ ARC_DEBUG (" section name = %s, output_offset 0x%08x",
+ reloc_data.sym_section->name,
+ (unsigned int) reloc_data.sym_section->output_offset);
if (reloc_data.sym_section->output_section != NULL)
- {
- PR_DEBUG (
- ", output_section->vma = 0x%08x",
+ ARC_DEBUG (", output_section->vma = 0x%08x",
((unsigned int) reloc_data.sym_section->output_section->vma));
- }
- PR_DEBUG ( "\n");
- PR_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename);
+ ARC_DEBUG ("\n");
+ if (reloc_data.sym_section->owner && reloc_data.sym_section->owner->filename)
+ ARC_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename);
}
else
{
- PR_DEBUG ( " symbol section is NULL\n");
+ ARC_DEBUG (" symbol section is NULL\n");
}
- PR_DEBUG ( " Input_section:\n");
+ ARC_DEBUG (" Input_section:\n");
if (reloc_data.input_section != NULL)
{
- PR_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);
- PR_DEBUG ( " changed_address = 0x%08x\n",
- (unsigned int) (reloc_data.input_section->output_section->vma
- + reloc_data.input_section->output_offset
- + reloc_data.reloc_offset));
- PR_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename);
+ 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);
+ ARC_DEBUG (" changed_address = 0x%08x\n",
+ (unsigned int) (reloc_data.input_section->output_section->vma
+ + reloc_data.input_section->output_offset
+ + reloc_data.reloc_offset));
+ ARC_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename);
}
else
{
- PR_DEBUG ( " input section is NULL\n");
+ ARC_DEBUG (" input section is NULL\n");
}
}
+#else
+#define DEBUG_ARC_RELOC(A)
+#endif /* ARC_ENABLE_DEBUG */
static bfd_vma
middle_endian_convert (bfd_vma insn, bfd_boolean do_it)
if (((relocation >> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE)
{
if (reloc_data.reloc_addend == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
"16 MSB should be 0x%04x (value is 0x%lx)"),
reloc_data.input_section->owner,
NPS_CMEM_HIGH_VALUE,
(relocation));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
"16 MSB should be 0x%04x (value is 0x%lx)"),
reloc_data.input_section->owner,
#define none (0)
-#define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
- {\
- asection *sym_section = reloc_data.sym_section; \
- asection *input_section = reloc_data.input_section; \
- 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); \
- if (sym_section->output_section != NULL) \
- { \
- ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
- sym_section->output_section->vma + sym_section->output_offset); \
- } \
- else \
- { \
- ARC_DEBUG ("symbol_section->vma = NULL\n"); \
- } \
- if (input_section->output_section != NULL) \
- { \
- ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
- input_section->output_section->vma + input_section->output_offset); \
- } \
- else \
- { \
- ARC_DEBUG ("symbol_section->vma = NULL\n"); \
- } \
- ARC_DEBUG ("PCL = 0x%x\n", P); \
- ARC_DEBUG ("P = 0x%x\n", P); \
- ARC_DEBUG ("G = 0x%x\n", G); \
- ARC_DEBUG ("SDA_OFFSET = 0x%x\n", _SDA_BASE_); \
+#ifdef ARC_ENABLE_DEBUG
+#define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
+ do \
+ { \
+ asection *sym_section = reloc_data.sym_section; \
+ asection *input_section = reloc_data.input_section; \
+ ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
+ ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
+ ARC_DEBUG ("S = %#lx\n", S); \
+ ARC_DEBUG ("A = %#lx\n", A); \
+ ARC_DEBUG ("L = %lx\n", L); \
+ if (sym_section->output_section != NULL) \
+ ARC_DEBUG ("symbol_section->vma = %#lx\n", \
+ sym_section->output_section->vma \
+ + sym_section->output_offset); \
+ else \
+ ARC_DEBUG ("symbol_section->vma = NULL\n"); \
+ if (input_section->output_section != NULL) \
+ ARC_DEBUG ("symbol_section->vma = %#lx\n", \
+ input_section->output_section->vma \
+ + input_section->output_offset); \
+ else \
+ ARC_DEBUG ("symbol_section->vma = NULL\n"); \
+ ARC_DEBUG ("PCL = %#lx\n", P); \
+ ARC_DEBUG ("P = %#lx\n", P); \
+ ARC_DEBUG ("G = %#lx\n", G); \
+ ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
- ARC_DEBUG ("GOT_OFFSET = 0x%x\n", GOT); \
- ARC_DEBUG ("relocation = 0x%08x\n", relocation); \
- ARC_DEBUG ("before = 0x%08x\n", (unsigned int) insn); \
- ARC_DEBUG ("data = 0x%08x (%u) (%d)\n", (unsigned int) relocation, (unsigned int) relocation, (int) relocation); \
- }
+ ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
+ ARC_DEBUG ("relocation = %#08lx\n", relocation); \
+ ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
+ ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
+ (unsigned) relocation, (int) relocation); \
+ } \
+ while (0)
+
+#define PRINT_DEBUG_RELOC_INFO_AFTER \
+ do \
+ { \
+ ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
+ } \
+ while (0)
-#define PRINT_DEBUG_RELOC_INFO_AFTER \
- { \
- ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
- }
+#else
+
+#define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
+#define PRINT_DEBUG_RELOC_INFO_AFTER
+
+#endif /* ARC_ENABLE_DEBUG */
#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 \
- } \
+ 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;
static bfd_reloc_status_type
else
flag = arc_special_overflow_checks (reloc_data, relocation, info);
-#undef DEBUG_ARC_RELOC
-#define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
if (flag != bfd_reloc_ok)
{
- PR_DEBUG ( "Relocation overflows !!!!\n");
-
+ ARC_DEBUG ("Relocation overflows !\n");
DEBUG_ARC_RELOC (reloc_data);
+ ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
+ ", hex -> (0x%08x)\n",
+ (int) relocation, (unsigned) relocation, (int) relocation);
- PR_DEBUG (
- "Relocation value = signed -> %d, unsigned -> %u"
- ", hex -> (0x%08x)\n",
- (int) relocation,
- (unsigned int) relocation,
- (unsigned int) relocation);
return flag;
}
-#undef DEBUG_ARC_RELOC
-#define DEBUG_ARC_RELOC(A)
/* Write updated instruction back to memory. */
switch (reloc_data.howto->size)
corresponding to the st_shndx field of each
local symbol. */
static bfd_boolean
-elf_arc_relocate_section (bfd * output_bfd,
+elf_arc_relocate_section (bfd * output_bfd,
struct bfd_link_info * info,
- bfd * input_bfd,
- asection * input_section,
- bfd_byte * contents,
+ bfd * input_bfd,
+ asection * input_section,
+ bfd_byte * contents,
Elf_Internal_Rela * relocs,
Elf_Internal_Sym * local_syms,
- asection ** local_sections)
+ asection ** local_sections)
{
- Elf_Internal_Shdr * symtab_hdr;
- struct elf_link_hash_entry ** sym_hashes;
- Elf_Internal_Rela * rel;
- Elf_Internal_Rela * wrel;
- Elf_Internal_Rela * relend;
- struct elf_link_hash_table *htab = elf_hash_table (info);
+ Elf_Internal_Shdr * symtab_hdr;
+ struct elf_link_hash_entry ** sym_hashes;
+ Elf_Internal_Rela * rel;
+ Elf_Internal_Rela * wrel;
+ Elf_Internal_Rela * relend;
+ struct elf_link_hash_table * htab = elf_hash_table (info);
symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
sym_hashes = elf_sym_hashes (input_bfd);
{
enum elf_arc_reloc_type r_type;
reloc_howto_type * howto;
- unsigned long r_symndx;
+ unsigned long r_symndx;
struct elf_link_hash_entry * h;
Elf_Internal_Sym * sym;
asection * sec;
- struct elf_link_hash_entry *h2;
+ struct elf_link_hash_entry * h2;
+ const char * msg;
struct arc_relocation_data reloc_data =
{
{
sec = local_sections[r_symndx];
- /* for RELA relocs.Just adjust the addend
+ /* For RELA relocs. Just adjust the addend
value in the relocation entry. */
rel->r_addend += sec->output_offset + sym->st_value;
- BFD_DEBUG_PIC (
- PR_DEBUG ("local symbols reloc "
- "(section=%d %s) seen in %s\n",
- r_symndx,
- local_sections[r_symndx]->name,
- __PRETTY_FUNCTION__)
- );
+ ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
+ (int) r_symndx, local_sections[r_symndx]->name,
+ __PRETTY_FUNCTION__);
}
}
}
}
else /* Global symbol. */
{
+ /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
+ (defined in elf-bfd.h) here. */
+
/* Get the symbol's entry in the symtab. */
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
reloc_data.should_relocate = TRUE;
}
- else if (!bfd_link_pic (info))
+ else if (!bfd_link_pic (info) || bfd_link_executable (info))
(*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd, input_section,
rel->r_offset, TRUE);
if ((is_reloc_for_GOT (howto)
|| is_reloc_for_TLS (howto)))
{
+ reloc_data.should_relocate = TRUE;
+
struct got_entry **list
= get_got_entry_list_for_symbol (output_bfd, r_symndx, h);
output_bfd, info, NULL);
}
}
+
switch (r_type)
{
case R_ARC_32:
case R_ARC_32_ME:
case R_ARC_PC32:
case R_ARC_32_PCREL:
- if ((bfd_link_pic (info))// || bfd_link_pie (info))
+ if ((bfd_link_pic (info))
&& ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
|| (h != NULL
&& h->dynindx != -1
+ input_section->output_offset);
#define IS_ARC_PCREL_TYPE(TYPE) \
- ( (TYPE == R_ARC_PC32) \
+ ( (TYPE == R_ARC_PC32) \
|| (TYPE == R_ARC_32_PCREL))
+
if (skip)
{
memset (&outrel, 0, sizeof outrel);
if (is_reloc_SDA_relative (howto)
&& (reloc_data.sdata_begin_symbol_vma_set == FALSE))
{
- (*_bfd_error_handler)
- ("Error: Linker symbol __SDATA_BEGIN__ not found");
+ _bfd_error_handler
+ ("Error: Linker symbol __SDATA_BEGIN__ not found");
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((is_reloc_for_GOT (howto) || is_reloc_for_PLT (howto))
&& reloc_data.sym_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
- if (arc_do_relocation (contents, reloc_data, info) != bfd_reloc_ok)
- return FALSE;
+ msg = NULL;
+ switch (arc_do_relocation (contents, reloc_data, info))
+ {
+ case bfd_reloc_ok:
+ continue; /* The reloc processing loop. */
+
+ 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);
+ break;
+
+ case bfd_reloc_undefined:
+ (*info->callbacks->undefined_symbol)
+ (info, reloc_data.symbol_name, input_bfd, input_section, rel->r_offset, TRUE);
+ break;
+
+ case bfd_reloc_other:
+ msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
+ break;
+
+ case bfd_reloc_outofrange:
+ msg = _("%B(%A): internal error: out of range error");
+ break;
+
+ case bfd_reloc_notsupported:
+ msg = _("%B(%A): internal error: unsupported relocation error");
+ break;
+
+ case bfd_reloc_dangerous:
+ msg = _("%B(%A): internal error: dangerous relocation");
+ break;
+
+ default:
+ msg = _("%B(%A): internal error: unknown error");
+ break;
+ }
+
+ if (msg)
+ _bfd_error_handler (msg, input_bfd, input_section, reloc_data.symbol_name);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+#define elf_arc_hash_table(p) \
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
+
+/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
+ .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
+ hash table. */
+
+static bfd_boolean
+arc_elf_create_dynamic_sections (bfd *dynobj,
+ struct bfd_link_info *info)
+{
+ struct elf_arc_link_hash_table *htab;
+
+ if (!_bfd_elf_create_dynamic_sections (dynobj, info))
+ return FALSE;
+
+ htab = elf_arc_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
+ if (bfd_link_executable (info))
+ {
+ /* Always allow copy relocs for building executables. */
+ asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
+ if (s == NULL)
+ {
+ const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
+ s = bfd_make_section_anyway_with_flags (dynobj,
+ ".rela.bss",
+ (bed->dynamic_sec_flags
+ | SEC_READONLY));
+ if (s == NULL
+ || ! bfd_set_section_alignment (dynobj, s,
+ bed->s->log_file_align))
+ return FALSE;
+ }
+ htab->srelbss = s;
}
return TRUE;
else
/* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
name = "UNKNOWN";
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("\
%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd,
/* FALLTHROUGH */
case R_ARC_PC32:
case R_ARC_32_PCREL:
- if ((bfd_link_pic (info))// || bfd_link_pie (info))
+ if ((bfd_link_pic (info))
&& ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
|| (h != NULL
- && h->dynindx != -1
&& (!info->symbolic || !h->def_regular))))
{
if (sreloc == NULL)
for (i = 0; i < 1; i++)
{
ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i,
- plt_versions[i].entry_size,
- plt_versions[i].elem_size);
+ (int) plt_versions[i].entry_size,
+ (int) plt_versions[i].elem_size);
}
if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2)
ret = htab->splt->size;
htab->splt->size += plt_data->elem_size;
- ARC_DEBUG ("PLT_SIZE = %d\n", htab->splt->size);
+ ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size);
htab->sgotplt->size += 4;
htab->srelplt->size += sizeof (Elf32_External_Rela);
/ plt_data->elem_size;
bfd_vma got_offset = (plt_index + 3) * 4;
- ARC_DEBUG ("arc_info: PLT_OFFSET = 0x%x, PLT_ENTRY_VMA = 0x%x, \
-GOT_ENTRY_OFFSET = 0x%x, GOT_ENTRY_VMA = 0x%x, for symbol %s\n",
- h->plt.offset,
- htab->splt->output_section->vma
- + htab->splt->output_offset
- + h->plt.offset,
- got_offset,
- htab->sgotplt->output_section->vma
- + htab->sgotplt->output_offset
- + got_offset,
+ ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
+GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
+ (long) h->plt.offset,
+ (long) (htab->splt->output_section->vma
+ + htab->splt->output_offset
+ + h->plt.offset),
+ (long) got_offset,
+ (long) (htab->sgotplt->output_section->vma
+ + htab->sgotplt->output_offset
+ + got_offset),
h->root.root.string);
-
{
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];
.rela.bss section we are going to use. */
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
{
- asection *srel;
+ struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
- srel = bfd_get_section_by_name (dynobj, ".rela.bss");
- BFD_ASSERT (srel != NULL);
- srel->size += sizeof (Elf32_External_Rela);
+ BFD_ASSERT (arc_htab->srelbss != NULL);
+ arc_htab->srelbss->size += sizeof (Elf32_External_Rela);
h->needs_copy = 1;
}
+ /* TODO: Move this also to arc_hash_table. */
s = bfd_get_section_by_name (dynobj, ".dynbss");
BFD_ASSERT (s != NULL);
if (h->needs_copy)
{
+ struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
+
+ if (h->dynindx == -1
+ || (h->root.type != bfd_link_hash_defined
+ && h->root.type != bfd_link_hash_defweak)
+ || arc_htab->srelbss == NULL)
+ abort ();
+
bfd_vma rel_offset = (h->root.u.def.value
+ h->root.u.def.section->output_section->vma
+ h->root.u.def.section->output_offset);
- asection *srelbss
- = bfd_get_section_by_name (h->root.u.def.section->owner,
- ".rela.bss");
-
- bfd_byte * loc = srelbss->contents
- + (srelbss->reloc_count * sizeof (Elf32_External_Rela));
- srelbss->reloc_count++;
+ bfd_byte * loc = arc_htab->srelbss->contents
+ + (arc_htab->srelbss->reloc_count * sizeof (Elf32_External_Rela));
+ arc_htab->srelbss->reloc_count++;
Elf_Internal_Rela rel;
rel.r_addend = 0;
switch (internal_dyn.d_tag)
{
- GET_SYMBOL_OR_SECTION (DT_INIT, "_init", NULL)
- GET_SYMBOL_OR_SECTION (DT_FINI, "_fini", NULL)
+ 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")
section. Checking if the .init section is present. We also
create DT_INIT and DT_FINI entries if the init_str has been
changed by the user. */
- ADD_DYNAMIC_SYMBOL ("init", DT_INIT);
- ADD_DYNAMIC_SYMBOL ("fini", DT_FINI);
+ ADD_DYNAMIC_SYMBOL (info->init_function, DT_INIT);
+ ADD_DYNAMIC_SYMBOL (info->fini_function, DT_FINI);
}
else
{
#define elf_backend_size_info arc_elf32_size_info
-static struct bfd_link_hash_table *
-arc_elf_link_hash_table_create (bfd *abfd)
-{
- struct elf_link_hash_table *htab;
-
- htab = bfd_zmalloc (sizeof (*htab));
- if (htab == NULL)
- return NULL;
-
- if (!_bfd_elf_link_hash_table_init (htab, abfd,
- _bfd_elf_link_hash_newfunc,
- sizeof (struct elf_link_hash_entry),
- GENERIC_ELF_DATA))
- {
- free (htab);
- return NULL;
- }
-
- htab->init_got_refcount.refcount = 0;
- htab->init_got_refcount.glist = NULL;
- htab->init_got_offset.offset = 0;
- htab->init_got_offset.glist = NULL;
- return (struct bfd_link_hash_table *) htab;
-}
-
/* Hook called by the linker routine which adds symbols from an object
file. */
return TRUE;
}
+/* GDB expects general purpose registers to be in section .reg. However Linux
+ kernel doesn't create this section and instead writes registers to NOTE
+ section. It is up to the binutils to create a pseudo-section .reg from the
+ contents of NOTE. Also BFD will read pid and signal number from NOTE. This
+ function relies on offsets inside elf_prstatus structure in Linux to be
+ stable. */
+
+static bfd_boolean
+elf32_arc_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
+{
+ int offset;
+ size_t size;
+
+ switch (note->descsz)
+ {
+ default:
+ return FALSE;
+
+ case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
+ /* pr_cursig */
+ elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
+ /* pr_pid */
+ elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
+ /* pr_regs */
+ offset = 72;
+ size = (40 * 4); /* There are 40 registers in user_regs_struct. */
+ break;
+ }
+ /* Make a ".reg/999" section. */
+ return _bfd_elfcore_make_pseudosection (abfd, ".reg", size,
+ note->descpos + offset);
+}
+
#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
#define ELF_MACHINE_CODE EM_ARC_COMPACT
#define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
#define ELF_MAXPAGESIZE 0x2000
#define elf_backend_relocate_section elf_arc_relocate_section
#define elf_backend_check_relocs elf_arc_check_relocs
-#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
+#define elf_backend_create_dynamic_sections arc_elf_create_dynamic_sections
#define elf_backend_reloc_type_class elf32_arc_reloc_type_class
#define elf_backend_may_use_rela_p 1
#define elf_backend_default_use_rela_p 1
+#define elf_backend_grok_prstatus elf32_arc_grok_prstatus
+
#define elf_backend_default_execstack 0
#include "elf32-target.h"