mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-27 12:03:41 +08:00
0f55320bc4
* elf-m10300.c (elf32_mn10300_hash_table): Test is_elf_hash_table before accessing elf_hash_table_id. * elf32-arc.c (elf_arc_hash_table): Likewise. * elf32-arm.c (elf32_arm_hash_table): Likewise. * elf32-avr.c (avr_link_hash_table): Likewise. * elf32-bfin.c (bfinfdpic_hash_table): Likewise. * elf32-cris.c (elf_cris_hash_table): Likewise. * elf32-csky.c (csky_elf_hash_table): Likewise. * elf32-frv.c (frvfdpic_hash_table): Likewise. * elf32-hppa.c (hppa_link_hash_table): Likewise. * elf32-lm32.c (lm32_elf_hash_table): Likewise. * elf32-m32r.c (m32r_elf_hash_table): Likewise. * elf32-m68hc1x.h (m68hc11_elf_hash_table): Likewise. * elf32-m68k.c (elf_m68k_hash_table): Likewise. * elf32-metag.c (metag_link_hash_table): Likewise. * elf32-microblaze.c (elf32_mb_hash_table): Likewise. * elf32-nds32.h (nds32_elf_hash_table): Likewise. * elf32-or1k.c (or1k_elf_hash_table): Likewise. * elf32-s390.c (elf_s390_hash_table): Likewise. * elf32-sh.c (sh_elf_hash_table): Likewise. * elf32-spu.c (spu_hash_table): Likewise. * elf32-tilepro.c (tilepro_elf_hash_table): Likewise. * elf32-xtensa.c (elf_xtensa_hash_table): Likewise. * elf64-alpha.c (alpha_elf_hash_table): Likewise. * elf64-hppa.c (hppa_link_hash_table): Likewise. * elf64-ia64-vms.c (elf64_ia64_hash_table): Likewise. * elf64-s390.c (elf_s390_hash_table): Likewise. * elfnn-ia64.c (elfNN_ia64_hash_table): Likewise. * elfnn-riscv.c (riscv_elf_hash_table): Likewise. * elfxx-mips.c (mips_elf_hash_table): Likewise. * elfxx-sparc.h (_bfd_sparc_elf_hash_table): Likewise. * elfxx-tilegx.c (tilegx_elf_hash_table): Likewise.
3160 lines
88 KiB
C
3160 lines
88 KiB
C
/* ARC-specific support for 32-bit ELF
|
|
Copyright (C) 1994-2020 Free Software Foundation, Inc.
|
|
Contributed by Cupertino Miranda (cmiranda@synopsys.com).
|
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
#include "sysdep.h"
|
|
#include "bfd.h"
|
|
#include "libbfd.h"
|
|
#include "elf-bfd.h"
|
|
#include "elf/arc.h"
|
|
#include "libiberty.h"
|
|
#include "opcode/arc-func.h"
|
|
#include "opcode/arc.h"
|
|
#include "arc-plt.h"
|
|
|
|
#define FEATURE_LIST_NAME bfd_feature_list
|
|
#define CONFLICT_LIST bfd_conflict_list
|
|
#include "opcode/arc-attrs.h"
|
|
|
|
/* #define ARC_ENABLE_DEBUG 1 */
|
|
#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;
|
|
return h->root.root.string;
|
|
}
|
|
#define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
|
|
#else
|
|
#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; \
|
|
\
|
|
if (_htab->dynamic_sections_created == TRUE) \
|
|
{ \
|
|
BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
|
|
_loc = _htab->srel##SECTION->contents \
|
|
+ ((_htab->srel##SECTION->reloc_count) \
|
|
* 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 = ELF32_R_INFO (SYM_IDX, TYPE); \
|
|
bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
|
|
} \
|
|
}
|
|
|
|
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
|
|
case VALUE: \
|
|
return "R_" #TYPE; \
|
|
break;
|
|
|
|
static ATTRIBUTE_UNUSED const char *
|
|
reloc_type_to_name (unsigned int type)
|
|
{
|
|
switch (type)
|
|
{
|
|
#include "elf/arc-reloc.def"
|
|
|
|
default:
|
|
return "UNKNOWN";
|
|
break;
|
|
}
|
|
}
|
|
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
/* Try to minimize the amount of space occupied by relocation tables
|
|
on the ROM (not that the ROM won't be swamped by other ELF overhead). */
|
|
|
|
#define USE_REL 1
|
|
|
|
/* Similar with bfd_get_32 but taking into account the
|
|
middle-endianess of the ARC CPUs. Only to be used in code
|
|
sections. */
|
|
|
|
static bfd_vma
|
|
bfd_get_32_me (bfd * abfd,const unsigned char * data)
|
|
{
|
|
bfd_vma value = 0;
|
|
|
|
if (bfd_big_endian (abfd))
|
|
value = bfd_get_32 (abfd, data);
|
|
else
|
|
{
|
|
value = ((bfd_get_8 (abfd, data) & 255) << 16);
|
|
value |= ((bfd_get_8 (abfd, data + 1) & 255) << 24);
|
|
value |= (bfd_get_8 (abfd, data + 2) & 255);
|
|
value |= ((bfd_get_8 (abfd, data + 3) & 255) << 8);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
static void
|
|
bfd_put_32_me (bfd *abfd, bfd_vma value,unsigned char *data)
|
|
{
|
|
bfd_put_16 (abfd, (value & 0xffff0000) >> 16, data);
|
|
bfd_put_16 (abfd, value & 0xffff, data + 2);
|
|
}
|
|
|
|
static ATTRIBUTE_UNUSED bfd_boolean
|
|
is_reloc_PC_relative (reloc_howto_type *howto)
|
|
{
|
|
return (strstr (howto->name, "PC") != NULL) ? TRUE : FALSE;
|
|
}
|
|
|
|
static bfd_boolean
|
|
is_reloc_SDA_relative (reloc_howto_type *howto)
|
|
{
|
|
return (strstr (howto->name, "SDA") != NULL) ? TRUE : FALSE;
|
|
}
|
|
|
|
static bfd_boolean
|
|
is_reloc_for_GOT (reloc_howto_type * howto)
|
|
{
|
|
if (strstr (howto->name, "TLS") != NULL)
|
|
return FALSE;
|
|
return (strstr (howto->name, "GOT") != NULL) ? TRUE : FALSE;
|
|
}
|
|
|
|
static bfd_boolean
|
|
is_reloc_for_PLT (reloc_howto_type * howto)
|
|
{
|
|
return (strstr (howto->name, "PLT") != NULL) ? TRUE : FALSE;
|
|
}
|
|
|
|
static bfd_boolean
|
|
is_reloc_for_TLS (reloc_howto_type *howto)
|
|
{
|
|
return (strstr (howto->name, "TLS") != NULL) ? TRUE : FALSE;
|
|
}
|
|
|
|
struct arc_relocation_data
|
|
{
|
|
bfd_signed_vma reloc_offset;
|
|
bfd_signed_vma reloc_addend;
|
|
bfd_signed_vma got_offset_value;
|
|
|
|
bfd_signed_vma sym_value;
|
|
asection * sym_section;
|
|
|
|
reloc_howto_type *howto;
|
|
|
|
asection * input_section;
|
|
|
|
bfd_signed_vma sdata_begin_symbol_vma;
|
|
bfd_boolean sdata_begin_symbol_vma_set;
|
|
bfd_signed_vma got_symbol_vma;
|
|
|
|
bfd_boolean should_relocate;
|
|
|
|
const char * symbol_name;
|
|
};
|
|
|
|
/* ARC ELF linker hash entry. */
|
|
struct elf_arc_link_hash_entry
|
|
{
|
|
struct elf_link_hash_entry root;
|
|
|
|
struct got_entry *got_ents;
|
|
};
|
|
|
|
|
|
/* Should be included at this location due to static declarations
|
|
defined before this point. */
|
|
#include "arc-got.h"
|
|
|
|
#define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
|
|
#define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
|
|
#define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
|
|
#define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
|
|
#define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
|
|
#define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
|
|
|
|
|
|
static bfd_reloc_status_type
|
|
arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
|
|
arelent *reloc_entry,
|
|
asymbol *symbol_in,
|
|
void *data ATTRIBUTE_UNUSED,
|
|
asection *input_section,
|
|
bfd *output_bfd,
|
|
char ** error_message ATTRIBUTE_UNUSED)
|
|
{
|
|
if (output_bfd != NULL)
|
|
{
|
|
reloc_entry->address += input_section->output_offset;
|
|
|
|
/* In case of relocateable link and if the reloc is against a
|
|
section symbol, the addend needs to be adjusted according to
|
|
where the section symbol winds up in the output section. */
|
|
if ((symbol_in->flags & BSF_SECTION_SYM) && symbol_in->section)
|
|
reloc_entry->addend += symbol_in->section->output_offset;
|
|
|
|
return bfd_reloc_ok;
|
|
}
|
|
|
|
return bfd_reloc_continue;
|
|
}
|
|
|
|
|
|
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
|
|
TYPE = VALUE,
|
|
|
|
enum howto_list
|
|
{
|
|
#include "elf/arc-reloc.def"
|
|
HOWTO_LIST_LAST
|
|
};
|
|
|
|
#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),
|
|
|
|
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.
|
|
HOWTO (R_ARC_NONE, // Type.
|
|
0, // Rightshift.
|
|
2, // Size (0 = byte, 1 = short, 2 = long).
|
|
32, // Bitsize.
|
|
FALSE, // PC_relative.
|
|
0, // Bitpos.
|
|
complain_overflow_bitfield, // Complain_on_overflow.
|
|
bfd_elf_generic_reloc, // Special_function.
|
|
"R_ARC_NONE", // Name.
|
|
TRUE, // Partial_inplace.
|
|
0, // Src_mask.
|
|
0, // Dst_mask.
|
|
FALSE), // PCrel_offset.
|
|
*/
|
|
};
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
static void
|
|
arc_elf_howto_init (void)
|
|
{
|
|
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
|
|
elf_arc_howto_table[TYPE].pc_relative = \
|
|
(strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
|
|
elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
|
|
/* Only 32 bit data relocations should be marked as ME. */ \
|
|
if (strstr (#FORMULA, " ME ") != NULL) \
|
|
{ \
|
|
BFD_ASSERT (SIZE == 2); \
|
|
}
|
|
|
|
#include "elf/arc-reloc.def"
|
|
|
|
}
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
|
|
#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)
|
|
{
|
|
if (elf_arc_howto_table[R_ARC_32].dst_mask == 0)
|
|
arc_elf_howto_init ();
|
|
return &elf_arc_howto_table[r_type];
|
|
}
|
|
|
|
/* Map BFD reloc types to ARC ELF reloc types. */
|
|
|
|
struct arc_reloc_map
|
|
{
|
|
bfd_reloc_code_real_type bfd_reloc_val;
|
|
unsigned char elf_reloc_val;
|
|
};
|
|
|
|
/* ARC ELF linker hash table. */
|
|
struct elf_arc_link_hash_table
|
|
{
|
|
struct elf_link_hash_table elf;
|
|
};
|
|
|
|
static struct bfd_hash_entry *
|
|
elf_arc_link_hash_newfunc (struct bfd_hash_entry *entry,
|
|
struct bfd_hash_table *table,
|
|
const char *string)
|
|
{
|
|
struct elf_arc_link_hash_entry * ret =
|
|
(struct elf_arc_link_hash_entry *) entry;
|
|
|
|
/* Allocate the structure if it has not already been allocated by a
|
|
subclass. */
|
|
if (ret == NULL)
|
|
ret = (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;
|
|
|
|
/* Call the allocation method of the superclass. */
|
|
ret = ((struct elf_arc_link_hash_entry *)
|
|
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
|
|
table, string));
|
|
if (ret != NULL)
|
|
{
|
|
ret->got_ents = NULL;
|
|
}
|
|
|
|
return (struct bfd_hash_entry *) ret;
|
|
}
|
|
|
|
/* 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->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[] =
|
|
{
|
|
#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},
|
|
};
|
|
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
typedef ATTRIBUTE_UNUSED bfd_vma (*replace_func) (unsigned, int ATTRIBUTE_UNUSED);
|
|
|
|
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
|
|
case TYPE: \
|
|
func = (void *) RELOC_FUNCTION; \
|
|
break;
|
|
|
|
static replace_func
|
|
get_replace_function (bfd *abfd, unsigned int r_type)
|
|
{
|
|
void *func = NULL;
|
|
|
|
switch (r_type)
|
|
{
|
|
#include "elf/arc-reloc.def"
|
|
}
|
|
|
|
if (func == replace_bits24 && bfd_big_endian (abfd))
|
|
func = replace_bits24_be;
|
|
|
|
return (replace_func) func;
|
|
}
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
static reloc_howto_type *
|
|
arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
|
|
bfd_reloc_code_real_type code)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = ARRAY_SIZE (arc_reloc_map); i--;)
|
|
{
|
|
if (arc_reloc_map[i].bfd_reloc_val == code)
|
|
return arc_elf_howto (arc_reloc_map[i].elf_reloc_val);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Function to set the ELF flag bits. */
|
|
static bfd_boolean
|
|
arc_elf_set_private_flags (bfd *abfd, flagword flags)
|
|
{
|
|
elf_elfheader (abfd)->e_flags = flags;
|
|
elf_flags_init (abfd) = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
/* Print private flags. */
|
|
static bfd_boolean
|
|
arc_elf_print_private_bfd_data (bfd *abfd, void * ptr)
|
|
{
|
|
FILE *file = (FILE *) ptr;
|
|
flagword flags;
|
|
|
|
BFD_ASSERT (abfd != NULL && ptr != NULL);
|
|
|
|
/* Print normal ELF private data. */
|
|
_bfd_elf_print_private_bfd_data (abfd, ptr);
|
|
|
|
flags = elf_elfheader (abfd)->e_flags;
|
|
fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
|
|
|
|
switch (flags & EF_ARC_MACH_MSK)
|
|
{
|
|
case EF_ARC_CPU_ARCV2HS : fprintf (file, " -mcpu=ARCv2HS"); break;
|
|
case EF_ARC_CPU_ARCV2EM : fprintf (file, " -mcpu=ARCv2EM"); break;
|
|
case E_ARC_MACH_ARC600 : fprintf (file, " -mcpu=ARC600"); break;
|
|
case E_ARC_MACH_ARC601 : fprintf (file, " -mcpu=ARC601"); break;
|
|
case E_ARC_MACH_ARC700 : fprintf (file, " -mcpu=ARC700"); break;
|
|
default:
|
|
fprintf (file, "-mcpu=unknown");
|
|
break;
|
|
}
|
|
|
|
switch (flags & EF_ARC_OSABI_MSK)
|
|
{
|
|
case E_ARC_OSABI_ORIG : fprintf (file, " (ABI:legacy)"); break;
|
|
case E_ARC_OSABI_V2 : fprintf (file, " (ABI:v2)"); break;
|
|
case E_ARC_OSABI_V3 : fprintf (file, " (ABI:v3)"); break;
|
|
case E_ARC_OSABI_V4 : fprintf (file, " (ABI:v4)"); break;
|
|
default:
|
|
fprintf (file, " (ABI:unknown)");
|
|
break;
|
|
}
|
|
|
|
fputc ('\n', file);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Copy backend specific data from one object module to another. */
|
|
|
|
static bfd_boolean
|
|
arc_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
|
|
{
|
|
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
|
return TRUE;
|
|
|
|
BFD_ASSERT (!elf_flags_init (obfd)
|
|
|| elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
|
|
|
|
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
|
|
elf_flags_init (obfd) = TRUE;
|
|
|
|
/* Copy object attributes. */
|
|
_bfd_elf_copy_obj_attributes (ibfd, obfd);
|
|
|
|
return _bfd_elf_copy_private_bfd_data (ibfd, obfd);
|
|
}
|
|
|
|
static reloc_howto_type *
|
|
bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED,
|
|
const char *r_name)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE (elf_arc_howto_table); i++)
|
|
if (elf_arc_howto_table[i].name != NULL
|
|
&& strcasecmp (elf_arc_howto_table[i].name, r_name) == 0)
|
|
return arc_elf_howto (i);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Set the howto pointer for an ARC ELF reloc. */
|
|
|
|
static bfd_boolean
|
|
arc_info_to_howto_rel (bfd * abfd,
|
|
arelent * cache_ptr,
|
|
Elf_Internal_Rela * dst)
|
|
{
|
|
unsigned int r_type;
|
|
|
|
r_type = ELF32_R_TYPE (dst->r_info);
|
|
if (r_type >= (unsigned int) R_ARC_max)
|
|
{
|
|
/* xgettext:c-format */
|
|
_bfd_error_handler (_("%pB: unsupported relocation type %#x"),
|
|
abfd, r_type);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
|
|
cache_ptr->howto = arc_elf_howto (r_type);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Extract CPU features from an NTBS. */
|
|
|
|
static unsigned
|
|
arc_extract_features (const char *p)
|
|
{
|
|
unsigned i, r = 0;
|
|
|
|
if (!p)
|
|
return 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE (bfd_feature_list); i++)
|
|
{
|
|
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 |= bfd_feature_list[i].feature;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/* Concatenate two strings. s1 can be NULL but not
|
|
s2. */
|
|
|
|
static char *
|
|
arc_stralloc (char * s1, const char * s2)
|
|
{
|
|
char *p;
|
|
|
|
/* Only s1 can be null. */
|
|
BFD_ASSERT (s2);
|
|
|
|
p = s1 ? concat (s1, ",", s2, NULL) : (char *)s2;
|
|
|
|
return p;
|
|
}
|
|
|
|
/* Merge ARC object attributes from IBFD into OBFD. Raise an error if
|
|
there are conflicting attributes. */
|
|
|
|
static bfd_boolean
|
|
arc_elf_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
|
|
{
|
|
bfd *obfd = info->output_bfd;
|
|
obj_attribute *in_attr;
|
|
obj_attribute *out_attr;
|
|
int i;
|
|
bfd_boolean result = TRUE;
|
|
const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
|
|
char *tagname = NULL;
|
|
|
|
/* Skip the linker stubs file. This preserves previous behavior
|
|
of accepting unknown attributes in the first input file - but
|
|
is that a bug? */
|
|
if (ibfd->flags & BFD_LINKER_CREATED)
|
|
return TRUE;
|
|
|
|
/* Skip any input that hasn't attribute section.
|
|
This enables to link object files without attribute section with
|
|
any others. */
|
|
if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
|
|
return TRUE;
|
|
|
|
if (!elf_known_obj_attributes_proc (obfd)[0].i)
|
|
{
|
|
/* This is the first object. Copy the attributes. */
|
|
_bfd_elf_copy_obj_attributes (ibfd, obfd);
|
|
|
|
out_attr = elf_known_obj_attributes_proc (obfd);
|
|
|
|
/* Use the Tag_null value to indicate the attributes have been
|
|
initialized. */
|
|
out_attr[0].i = 1;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
in_attr = elf_known_obj_attributes_proc (ibfd);
|
|
out_attr = elf_known_obj_attributes_proc (obfd);
|
|
|
|
for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
|
|
{
|
|
/* Merge this attribute with existing attributes. */
|
|
switch (i)
|
|
{
|
|
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 != 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 < 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],
|
|
tagval[out_attr[i].i]);
|
|
}
|
|
break;
|
|
|
|
case Tag_ARC_CPU_base:
|
|
if (out_attr[i].i == 0)
|
|
out_attr[i].i = in_attr[i].i;
|
|
else if (in_attr[i].i != 0 && out_attr[i].i != in_attr[i].i
|
|
&& ((out_attr[i].i + in_attr[i].i) < 6))
|
|
{
|
|
const char *tagval[] = { "Absent", "ARC6xx", "ARC7xx",
|
|
"ARCEM", "ARCHS" };
|
|
BFD_ASSERT (in_attr[i].i < 5);
|
|
BFD_ASSERT (out_attr[i].i < 5);
|
|
/* We cannot mix code for different CPUs. */
|
|
_bfd_error_handler
|
|
(_("error: %pB: unable to merge CPU base attributes "
|
|
"%s with %s"),
|
|
obfd,
|
|
tagval[in_attr[i].i],
|
|
tagval[out_attr[i].i]);
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/* The CPUs may be different, check if we can still mix
|
|
the objects against the output choosen CPU. */
|
|
unsigned in_feature = 0;
|
|
unsigned out_feature = 0;
|
|
char *p1 = in_attr[Tag_ARC_ISA_config].s;
|
|
char *p2 = out_attr[Tag_ARC_ISA_config].s;
|
|
unsigned j;
|
|
unsigned cpu_out;
|
|
unsigned opcode_map[] = {0, ARC_OPCODE_ARC600, ARC_OPCODE_ARC700,
|
|
ARC_OPCODE_ARCv2EM, ARC_OPCODE_ARCv2HS};
|
|
|
|
BFD_ASSERT (in_attr[i].i < (sizeof (opcode_map)
|
|
/ sizeof (unsigned)));
|
|
BFD_ASSERT (out_attr[i].i < (sizeof (opcode_map)
|
|
/ sizeof (unsigned)));
|
|
cpu_out = opcode_map[out_attr[i].i];
|
|
|
|
in_feature = arc_extract_features (p1);
|
|
out_feature = arc_extract_features (p2);
|
|
|
|
/* First, check if a feature is compatible with the
|
|
output object chosen CPU. */
|
|
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, 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 (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 (bfd_feature_list); k++)
|
|
{
|
|
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 "
|
|
"%s with %s"),
|
|
obfd, p1, p2);
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
/* Everithing is alright. */
|
|
out_feature |= in_feature;
|
|
p1 = NULL;
|
|
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);
|
|
}
|
|
/* Fall through. */
|
|
case Tag_ARC_CPU_variation:
|
|
case Tag_ARC_ISA_mpy_option:
|
|
case Tag_ARC_ABI_osver:
|
|
/* Use the largest value specified. */
|
|
if (in_attr[i].i > out_attr[i].i)
|
|
out_attr[i].i = in_attr[i].i;
|
|
break;
|
|
|
|
/* The CPU name is given by the vendor, just choose an
|
|
existing one if missing or different. There are no fail
|
|
criteria if they different or both missing. */
|
|
case Tag_ARC_CPU_name:
|
|
if (!out_attr[i].s && in_attr[i].s)
|
|
out_attr[i].s = _bfd_elf_attr_strdup (obfd, in_attr[i].s);
|
|
break;
|
|
|
|
case Tag_ARC_ABI_rf16:
|
|
if (out_attr[i].i == 0)
|
|
out_attr[i].i = in_attr[i].i;
|
|
else if (out_attr[i].i != in_attr[i].i)
|
|
{
|
|
/* We cannot mix code with rf16 and without. */
|
|
_bfd_error_handler
|
|
(_("error: %pB: cannot mix rf16 with full register set %pB"),
|
|
obfd, ibfd);
|
|
result = FALSE;
|
|
}
|
|
break;
|
|
|
|
case Tag_ARC_ABI_pic:
|
|
tagname = "PIC";
|
|
/* fall through */
|
|
case Tag_ARC_ABI_sda:
|
|
if (!tagname)
|
|
tagname = "SDA";
|
|
/* fall through */
|
|
case Tag_ARC_ABI_tls:
|
|
{
|
|
const char *tagval[] = { "Absent", "MWDT", "GNU" };
|
|
|
|
if (!tagname)
|
|
tagname = "TLS";
|
|
|
|
BFD_ASSERT (in_attr[i].i < 3);
|
|
BFD_ASSERT (out_attr[i].i < 3);
|
|
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)
|
|
{
|
|
_bfd_error_handler
|
|
(_("error: %pB: conflicting attributes %s: %s with %s"),
|
|
obfd, tagname,
|
|
tagval[in_attr[i].i],
|
|
tagval[out_attr[i].i]);
|
|
result = FALSE;
|
|
}
|
|
tagname = NULL;
|
|
break;
|
|
}
|
|
|
|
case Tag_ARC_ABI_double_size:
|
|
tagname = "Double size";
|
|
/* fall through */
|
|
case Tag_ARC_ABI_enumsize:
|
|
if (!tagname)
|
|
tagname = "Enum size";
|
|
/* fall through */
|
|
case Tag_ARC_ABI_exceptions:
|
|
if (!tagname)
|
|
tagname = "ABI exceptions";
|
|
|
|
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)
|
|
{
|
|
_bfd_error_handler
|
|
(_("error: %pB: conflicting attributes %s"),
|
|
obfd, tagname);
|
|
result = FALSE;
|
|
}
|
|
break;
|
|
|
|
case Tag_ARC_ISA_apex:
|
|
break; /* Do nothing for APEX attributes. */
|
|
|
|
case Tag_ARC_ISA_config:
|
|
/* It is handled in Tag_ARC_CPU_base. */
|
|
break;
|
|
|
|
case Tag_ARC_ATR_version:
|
|
if (out_attr[i].i == 0)
|
|
out_attr[i].i = in_attr[i].i;
|
|
break;
|
|
|
|
default:
|
|
result
|
|
= result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
|
|
}
|
|
|
|
/* If out_attr was copied from in_attr then it won't have a type yet. */
|
|
if (in_attr[i].type && !out_attr[i].type)
|
|
out_attr[i].type = in_attr[i].type;
|
|
}
|
|
|
|
/* Merge Tag_compatibility attributes and any common GNU ones. */
|
|
if (!_bfd_elf_merge_object_attributes (ibfd, info))
|
|
return FALSE;
|
|
|
|
/* Check for any attributes not known on ARC. */
|
|
result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Merge backend specific data from an object file to the output
|
|
object file when linking. */
|
|
|
|
static bfd_boolean
|
|
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;
|
|
flagword in_flags;
|
|
asection *sec;
|
|
|
|
/* Check if we have the same endianess. */
|
|
if (! _bfd_generic_verify_endian_match (ibfd, info))
|
|
return FALSE;
|
|
|
|
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
|
return TRUE;
|
|
|
|
/* Collect ELF flags. */
|
|
in_flags = elf_elfheader (ibfd)->e_flags & EF_ARC_MACH_MSK;
|
|
out_flags = elf_elfheader (obfd)->e_flags & EF_ARC_MACH_MSK;
|
|
|
|
if (!elf_flags_init (obfd)) /* First call, no flags set. */
|
|
{
|
|
elf_flags_init (obfd) = TRUE;
|
|
out_flags = in_flags;
|
|
}
|
|
|
|
if (!arc_elf_merge_attributes (ibfd, info))
|
|
return FALSE;
|
|
|
|
/* Check to see if the input BFD actually contains any sections. Do
|
|
not short-circuit dynamic objects; their section list may be
|
|
emptied by elf_link_add_object_symbols. */
|
|
if (!(ibfd->flags & DYNAMIC))
|
|
{
|
|
bfd_boolean null_input_bfd = TRUE;
|
|
bfd_boolean only_data_sections = TRUE;
|
|
|
|
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
|
|
{
|
|
if ((bfd_section_flags (sec)
|
|
& (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
|
|
== (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
|
|
only_data_sections = FALSE;
|
|
|
|
null_input_bfd = FALSE;
|
|
}
|
|
|
|
if (null_input_bfd || only_data_sections)
|
|
return TRUE;
|
|
}
|
|
|
|
/* Complain about various flag/architecture mismatches. */
|
|
mach_ibfd = elf_elfheader (ibfd)->e_machine;
|
|
if (mach_obfd == EM_NONE)
|
|
{
|
|
mach_obfd = mach_ibfd;
|
|
}
|
|
else
|
|
{
|
|
if (mach_ibfd != mach_obfd)
|
|
{
|
|
/* xgettext:c-format */
|
|
_bfd_error_handler (_("error: attempting to link %pB "
|
|
"with a binary %pB of different architecture"),
|
|
ibfd, obfd);
|
|
return FALSE;
|
|
}
|
|
else if ((in_flags != out_flags)
|
|
/* If we have object attributes, then we already
|
|
checked the objects compatibility, skip it. */
|
|
&& !bfd_elf_get_obj_attr_int (ibfd, OBJ_ATTR_PROC,
|
|
Tag_ARC_CPU_base))
|
|
{
|
|
if (in_flags && out_flags)
|
|
{
|
|
/* Warn if different flags. */
|
|
_bfd_error_handler
|
|
/* xgettext:c-format */
|
|
(_("%pB: uses different e_flags (%#x) fields than "
|
|
"previous modules (%#x)"),
|
|
ibfd, in_flags, out_flags);
|
|
return FALSE;
|
|
}
|
|
/* MWDT doesnt set the eflags hence make sure we choose the
|
|
eflags set by gcc. */
|
|
in_flags = in_flags > out_flags ? in_flags : out_flags;
|
|
}
|
|
else
|
|
{
|
|
/* Everything is correct; don't change the output flags. */
|
|
in_flags = out_flags;
|
|
}
|
|
}
|
|
|
|
/* Update the flags. */
|
|
elf_elfheader (obfd)->e_flags = in_flags;
|
|
|
|
if (bfd_get_mach (obfd) < 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 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);
|
|
unsigned e_machine = elf_elfheader (abfd)->e_machine;
|
|
|
|
switch (arch)
|
|
{
|
|
case TAG_CPU_ARC6xx:
|
|
return bfd_mach_arc_arc600;
|
|
case TAG_CPU_ARC7xx:
|
|
return bfd_mach_arc_arc700;
|
|
case TAG_CPU_ARCEM:
|
|
case TAG_CPU_ARCHS:
|
|
return bfd_mach_arc_arcv2;
|
|
default:
|
|
break;
|
|
}
|
|
return (e_machine == EM_ARC_COMPACT)
|
|
? bfd_mach_arc_arc700 : bfd_mach_arc_arcv2;
|
|
}
|
|
|
|
/* Set the right machine number for an ARC ELF file. */
|
|
static bfd_boolean
|
|
arc_elf_object_p (bfd * abfd)
|
|
{
|
|
/* 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;
|
|
|
|
if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2)
|
|
{
|
|
switch (arch)
|
|
{
|
|
case E_ARC_MACH_ARC600:
|
|
mach = bfd_mach_arc_arc600;
|
|
break;
|
|
case E_ARC_MACH_ARC601:
|
|
mach = bfd_mach_arc_arc601;
|
|
break;
|
|
case E_ARC_MACH_ARC700:
|
|
mach = bfd_mach_arc_arc700;
|
|
break;
|
|
case EF_ARC_CPU_ARCV2HS:
|
|
case EF_ARC_CPU_ARCV2EM:
|
|
mach = bfd_mach_arc_arcv2;
|
|
break;
|
|
default:
|
|
mach = bfd_arc_get_mach_from_attributes (abfd);
|
|
break;
|
|
}
|
|
}
|
|
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, bfd_arch_arc, mach);
|
|
}
|
|
|
|
/* The final processing done just before writing out an ARC ELF object file.
|
|
This gets the ARC architecture right based on the machine number. */
|
|
|
|
static bfd_boolean
|
|
arc_elf_final_write_processing (bfd *abfd)
|
|
{
|
|
unsigned long emf;
|
|
int osver = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC,
|
|
Tag_ARC_ABI_osver);
|
|
flagword e_flags = elf_elfheader (abfd)->e_flags & ~EF_ARC_OSABI_MSK;
|
|
|
|
switch (bfd_get_mach (abfd))
|
|
{
|
|
case bfd_mach_arc_arcv2:
|
|
emf = EM_ARC_COMPACT2;
|
|
break;
|
|
default:
|
|
emf = EM_ARC_COMPACT;
|
|
break;
|
|
}
|
|
|
|
elf_elfheader (abfd)->e_machine = emf;
|
|
|
|
/* Record whatever is the current syscall ABI version. */
|
|
if (osver)
|
|
e_flags |= ((osver & 0x0f) << 8);
|
|
else
|
|
e_flags |= E_ARC_OSABI_V3;
|
|
|
|
elf_elfheader (abfd)->e_flags |= e_flags;
|
|
return _bfd_elf_final_write_processing (abfd);
|
|
}
|
|
|
|
#ifdef ARC_ENABLE_DEBUG
|
|
#define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
|
|
|
|
static void
|
|
debug_arc_reloc (struct arc_relocation_data reloc_data)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
ARC_DEBUG (", output_section->vma = 0x%08x",
|
|
((unsigned int) reloc_data.sym_section->output_section->vma));
|
|
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
|
|
{
|
|
ARC_DEBUG (" symbol section is NULL\n");
|
|
}
|
|
|
|
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",
|
|
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
|
|
{
|
|
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 (do_it)
|
|
{
|
|
insn
|
|
= ((insn & 0xffff0000) >> 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. */
|
|
|
|
static inline bfd_reloc_status_type
|
|
arc_special_overflow_checks (const struct arc_relocation_data reloc_data,
|
|
bfd_signed_vma relocation,
|
|
struct bfd_link_info *info ATTRIBUTE_UNUSED)
|
|
{
|
|
switch (reloc_data.howto->type)
|
|
{
|
|
case R_ARC_NPS_CMEM16:
|
|
if (((relocation >> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE)
|
|
{
|
|
if (reloc_data.reloc_addend == 0)
|
|
_bfd_error_handler
|
|
/* xgettext:c-format */
|
|
(_("%pB(%pA+%#" PRIx64 "): CMEM relocation to `%s' is invalid, "
|
|
"16 MSB should be %#x (value is %#" PRIx64 ")"),
|
|
reloc_data.input_section->owner,
|
|
reloc_data.input_section,
|
|
(uint64_t) reloc_data.reloc_offset,
|
|
reloc_data.symbol_name,
|
|
NPS_CMEM_HIGH_VALUE,
|
|
(uint64_t) relocation);
|
|
else
|
|
_bfd_error_handler
|
|
/* xgettext:c-format */
|
|
(_("%pB(%pA+%#" PRIx64 "): CMEM relocation to `%s+%#" PRIx64
|
|
"' is invalid, 16 MSB should be %#x (value is %#" PRIx64 ")"),
|
|
reloc_data.input_section->owner,
|
|
reloc_data.input_section,
|
|
(uint64_t) reloc_data.reloc_offset,
|
|
reloc_data.symbol_name,
|
|
(uint64_t) reloc_data.reloc_addend,
|
|
NPS_CMEM_HIGH_VALUE,
|
|
(uint64_t) relocation);
|
|
return bfd_reloc_overflow;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return bfd_reloc_ok;
|
|
}
|
|
|
|
#define ME(reloc) (reloc)
|
|
|
|
#define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
|
|
&& (!bfd_big_endian (BFD)))
|
|
|
|
#define S ((bfd_signed_vma) (reloc_data.sym_value \
|
|
+ (reloc_data.sym_section->output_section != NULL ? \
|
|
(reloc_data.sym_section->output_offset \
|
|
+ reloc_data.sym_section->output_section->vma) : 0)))
|
|
#define L ((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 (reloc_data.got_symbol_vma)
|
|
#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 : 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) \
|
|
((elf_hash_table (info))->tls_sec->output_section->vma)
|
|
#define TLS_TBSS (align_power(TCB_SIZE, \
|
|
reloc_data.sym_section->alignment_power))
|
|
|
|
#define none (0)
|
|
|
|
#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 ("input_section->vma = %#lx\n", \
|
|
input_section->output_section->vma \
|
|
+ input_section->output_offset); \
|
|
else \
|
|
ARC_DEBUG ("input_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 = %#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)
|
|
|
|
#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; \
|
|
} \
|
|
break;
|
|
|
|
static bfd_reloc_status_type
|
|
arc_do_relocation (bfd_byte * contents,
|
|
struct arc_relocation_data reloc_data,
|
|
struct bfd_link_info *info)
|
|
{
|
|
bfd_signed_vma relocation = 0;
|
|
bfd_vma insn;
|
|
bfd_vma orig_insn ATTRIBUTE_UNUSED;
|
|
bfd * abfd = reloc_data.input_section->owner;
|
|
struct elf_link_hash_table *htab ATTRIBUTE_UNUSED = elf_hash_table (info);
|
|
bfd_reloc_status_type flag;
|
|
|
|
if (!reloc_data.should_relocate)
|
|
return bfd_reloc_ok;
|
|
|
|
switch (reloc_data.howto->size)
|
|
{
|
|
case 2:
|
|
insn = arc_bfd_get_32 (abfd,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
case 1:
|
|
insn = arc_bfd_get_16 (abfd,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
case 0:
|
|
insn = arc_bfd_get_8 (abfd,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
default:
|
|
insn = 0;
|
|
BFD_ASSERT (0);
|
|
break;
|
|
}
|
|
|
|
orig_insn = insn;
|
|
|
|
switch (reloc_data.howto->type)
|
|
{
|
|
#include "elf/arc-reloc.def"
|
|
|
|
default:
|
|
BFD_ASSERT (0);
|
|
break;
|
|
}
|
|
|
|
/* Check for relocation overflow. */
|
|
if (reloc_data.howto->complain_on_overflow != complain_overflow_dont)
|
|
flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow,
|
|
reloc_data.howto->bitsize,
|
|
reloc_data.howto->rightshift,
|
|
bfd_arch_bits_per_address (abfd),
|
|
relocation);
|
|
else
|
|
flag = arc_special_overflow_checks (reloc_data, relocation, info);
|
|
|
|
if (flag != bfd_reloc_ok)
|
|
{
|
|
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);
|
|
|
|
return flag;
|
|
}
|
|
|
|
/* Write updated instruction back to memory. */
|
|
switch (reloc_data.howto->size)
|
|
{
|
|
case 2:
|
|
arc_bfd_put_32 (abfd, insn,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
case 1:
|
|
arc_bfd_put_16 (abfd, insn,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
case 0:
|
|
arc_bfd_put_8 (abfd, insn,
|
|
contents + reloc_data.reloc_offset,
|
|
reloc_data.input_section);
|
|
break;
|
|
default:
|
|
ARC_DEBUG ("size = %d\n", reloc_data.howto->size);
|
|
BFD_ASSERT (0);
|
|
break;
|
|
}
|
|
|
|
return bfd_reloc_ok;
|
|
}
|
|
#undef S
|
|
#undef A
|
|
#undef B
|
|
#undef G
|
|
#undef GOT
|
|
#undef L
|
|
#undef MES
|
|
#undef P
|
|
#undef SECTSTAR
|
|
#undef SECTSTART
|
|
#undef JLI
|
|
#undef _SDA_BASE_
|
|
#undef none
|
|
|
|
#undef ARC_RELOC_HOWTO
|
|
|
|
|
|
/* Relocate an arc ELF section.
|
|
Function : elf_arc_relocate_section
|
|
Brief : Relocate an arc section, by handling all the relocations
|
|
appearing in that section.
|
|
Args : output_bfd : The bfd being written to.
|
|
info : Link information.
|
|
input_bfd : The input bfd.
|
|
input_section : The section being relocated.
|
|
contents : contents of the section being relocated.
|
|
relocs : List of relocations in the section.
|
|
local_syms : is a pointer to the swapped in local symbols.
|
|
local_section : is an array giving the section in the input file
|
|
corresponding to the st_shndx field of each
|
|
local symbol. */
|
|
static bfd_boolean
|
|
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 * 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);
|
|
|
|
rel = wrel = relocs;
|
|
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;
|
|
bfd_boolean 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 = ELF32_R_TYPE (rel->r_info);
|
|
|
|
if (r_type >= (int) R_ARC_max)
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
howto = arc_elf_howto (r_type);
|
|
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
|
|
|
/* If we are generating another .o file and the symbol in not
|
|
local, skip this relocation. */
|
|
if (bfd_link_relocatable (info))
|
|
{
|
|
/* This is a relocateable link. We don't have to change
|
|
anything, unless the reloc is against a section symbol,
|
|
in which case we have to adjust according to where the
|
|
section symbol winds up in the output section. */
|
|
|
|
/* Checks if this is a local symbol and thus the reloc
|
|
might (will??) be against a section symbol. */
|
|
if (r_symndx < symtab_hdr->sh_info)
|
|
{
|
|
sym = local_syms + r_symndx;
|
|
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
|
|
{
|
|
sec = local_sections[r_symndx];
|
|
|
|
/* For RELA relocs. Just adjust the addend
|
|
value in the relocation entry. */
|
|
rel->r_addend += sec->output_offset + sym->st_value;
|
|
|
|
ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
|
|
(int) r_symndx, local_sections[r_symndx]->name,
|
|
__PRETTY_FUNCTION__);
|
|
}
|
|
}
|
|
}
|
|
|
|
h2 = elf_link_hash_lookup (elf_hash_table (info), "__SDATA_BEGIN__",
|
|
FALSE, FALSE, TRUE);
|
|
|
|
if (!reloc_data.sdata_begin_symbol_vma_set
|
|
&& h2 != NULL && h2->root.type != bfd_link_hash_undefined
|
|
&& h2->root.u.def.section->output_section != NULL)
|
|
/* TODO: Verify this condition. */
|
|
{
|
|
reloc_data.sdata_begin_symbol_vma =
|
|
(h2->root.u.def.value
|
|
+ h2->root.u.def.section->output_section->vma);
|
|
reloc_data.sdata_begin_symbol_vma_set = TRUE;
|
|
}
|
|
|
|
reloc_data.input_section = input_section;
|
|
reloc_data.howto = howto;
|
|
reloc_data.reloc_offset = rel->r_offset;
|
|
reloc_data.reloc_addend = rel->r_addend;
|
|
|
|
/* This is a final link. */
|
|
h = NULL;
|
|
sym = NULL;
|
|
sec = NULL;
|
|
|
|
if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */
|
|
{
|
|
sym = local_syms + r_symndx;
|
|
sec = local_sections[r_symndx];
|
|
}
|
|
else
|
|
{
|
|
bfd_boolean warned, ignored;
|
|
bfd_vma relocation ATTRIBUTE_UNUSED;
|
|
|
|
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
|
|
r_symndx, symtab_hdr, sym_hashes,
|
|
h, sec, relocation,
|
|
unresolved_reloc, warned, ignored);
|
|
|
|
/* TODO: This code is repeated from below. We should
|
|
clean it and remove duplications.
|
|
Sec is used check for discarded sections.
|
|
Need to redesign code below. */
|
|
|
|
/* Get the symbol's entry in the symtab. */
|
|
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
|
|
|
|
while (h->root.type == bfd_link_hash_indirect
|
|
|| h->root.type == bfd_link_hash_warning)
|
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
|
|
|
/* If we have encountered a definition for this symbol. */
|
|
if (h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak)
|
|
{
|
|
reloc_data.sym_value = h->root.u.def.value;
|
|
sec = h->root.u.def.section;
|
|
}
|
|
}
|
|
|
|
/* Clean relocs for symbols in discarded sections. */
|
|
if (sec != NULL && discarded_section (sec))
|
|
{
|
|
_bfd_clear_contents (howto, input_bfd, input_section,
|
|
contents, rel->r_offset);
|
|
rel->r_info = 0;
|
|
rel->r_addend = 0;
|
|
|
|
/* 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--;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (bfd_link_relocatable (info))
|
|
{
|
|
if (wrel != rel)
|
|
*wrel = *rel;
|
|
continue;
|
|
}
|
|
|
|
if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */
|
|
{
|
|
reloc_data.sym_value = sym->st_value;
|
|
reloc_data.sym_section = sec;
|
|
reloc_data.symbol_name =
|
|
bfd_elf_string_from_elf_section (input_bfd,
|
|
symtab_hdr->sh_link,
|
|
sym->st_name);
|
|
|
|
/* Mergeable section handling. */
|
|
if ((sec->flags & SEC_MERGE)
|
|
&& ELF_ST_TYPE (sym->st_info) == STT_SECTION)
|
|
{
|
|
asection *msec;
|
|
msec = sec;
|
|
rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym,
|
|
&msec, rel->r_addend);
|
|
rel->r_addend -= (sec->output_section->vma
|
|
+ sec->output_offset
|
|
+ sym->st_value);
|
|
rel->r_addend += msec->output_section->vma + msec->output_offset;
|
|
|
|
reloc_data.reloc_addend = rel->r_addend;
|
|
}
|
|
|
|
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;
|
|
|
|
reloc_data.should_relocate = TRUE;
|
|
}
|
|
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];
|
|
|
|
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;
|
|
}
|
|
|
|
/* 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. */
|
|
if (h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak)
|
|
{
|
|
reloc_data.sym_value = h->root.u.def.value;
|
|
reloc_data.sym_section = h->root.u.def.section;
|
|
|
|
reloc_data.should_relocate = TRUE;
|
|
|
|
if (is_reloc_for_GOT (howto) && !bfd_link_pic (info))
|
|
{
|
|
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. */
|
|
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);
|
|
|
|
BFD_ASSERT (ah->got_ents);
|
|
bfd_vma got_offset = ah->got_ents->offset;
|
|
bfd_put_32 (output_bfd, relocation,
|
|
htab->sgot->contents + got_offset);
|
|
}
|
|
if (is_reloc_for_PLT (howto) && h->plt.offset != (bfd_vma) -1)
|
|
{
|
|
/* TODO: This is repeated up here. */
|
|
reloc_data.sym_value = h->plt.offset;
|
|
reloc_data.sym_section = htab->splt;
|
|
}
|
|
}
|
|
else if (h->root.type == bfd_link_hash_undefweak)
|
|
{
|
|
/* Is weak symbol and has no definition. */
|
|
if (is_reloc_for_GOT (howto))
|
|
{
|
|
reloc_data.sym_value = h->root.u.def.value;
|
|
reloc_data.sym_section = htab->sgot;
|
|
reloc_data.should_relocate = TRUE;
|
|
}
|
|
else if (is_reloc_for_PLT (howto)
|
|
&& h->plt.offset != (bfd_vma) -1)
|
|
{
|
|
/* TODO: This is repeated up here. */
|
|
reloc_data.sym_value = h->plt.offset;
|
|
reloc_data.sym_section = htab->splt;
|
|
reloc_data.should_relocate = TRUE;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (is_reloc_for_GOT (howto))
|
|
{
|
|
reloc_data.sym_value = h->root.u.def.value;
|
|
reloc_data.sym_section = htab->sgot;
|
|
|
|
reloc_data.should_relocate = TRUE;
|
|
}
|
|
else if (is_reloc_for_PLT (howto))
|
|
{
|
|
/* Fail if it is linking for PIE and the symbol is
|
|
undefined. */
|
|
if (bfd_link_executable (info))
|
|
(*info->callbacks->undefined_symbol)
|
|
(info, h->root.root.string, input_bfd, input_section,
|
|
rel->r_offset, TRUE);
|
|
reloc_data.sym_value = h->plt.offset;
|
|
reloc_data.sym_section = htab->splt;
|
|
|
|
reloc_data.should_relocate = TRUE;
|
|
}
|
|
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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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 (input_bfd, r_symndx, h);
|
|
|
|
reloc_data.got_offset_value
|
|
= relocate_fix_got_relocs_for_got_info (list,
|
|
tls_type_for_reloc (howto),
|
|
info,
|
|
output_bfd,
|
|
r_symndx,
|
|
local_syms,
|
|
local_sections,
|
|
h,
|
|
&reloc_data);
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
#define IS_ARC_PCREL_TYPE(TYPE) \
|
|
( (TYPE == R_ARC_PC32) \
|
|
|| (TYPE == R_ARC_32_PCREL))
|
|
|
|
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)
|
|
&& (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;
|
|
bfd_boolean skip = FALSE;
|
|
bfd_boolean relocate = FALSE;
|
|
asection *sreloc = _bfd_elf_get_dynamic_reloc_section
|
|
(input_bfd, input_section,
|
|
/*RELA*/ TRUE);
|
|
|
|
BFD_ASSERT (sreloc != NULL);
|
|
|
|
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);
|
|
|
|
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)
|
|
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 (sreloc->contents != 0);
|
|
|
|
loc = sreloc->contents;
|
|
loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
|
|
sreloc->reloc_count += 1;
|
|
|
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
|
|
|
|
if (!relocate)
|
|
continue;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (is_reloc_SDA_relative (howto)
|
|
&& !reloc_data.sdata_begin_symbol_vma_set)
|
|
{
|
|
_bfd_error_handler
|
|
("error: linker symbol __SDATA_BEGIN__ not found");
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
|
|
DEBUG_ARC_RELOC (reloc_data);
|
|
|
|
/* 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)
|
|
{
|
|
_bfd_error_handler
|
|
(_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
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:
|
|
/* xgettext:c-format */
|
|
msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
|
|
break;
|
|
|
|
case bfd_reloc_outofrange:
|
|
/* xgettext:c-format */
|
|
msg = _("%pB(%pA): internal error: out of range error");
|
|
break;
|
|
|
|
case bfd_reloc_notsupported:
|
|
/* xgettext:c-format */
|
|
msg = _("%pB(%pA): internal error: unsupported relocation error");
|
|
break;
|
|
|
|
case bfd_reloc_dangerous:
|
|
/* xgettext:c-format */
|
|
msg = _("%pB(%pA): internal error: dangerous relocation");
|
|
break;
|
|
|
|
default:
|
|
/* xgettext:c-format */
|
|
msg = _("%pB(%pA): 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) \
|
|
((is_elf_hash_table ((p)->hash) \
|
|
&& elf_hash_table_id (elf_hash_table (p)) == ARC_ELF_DATA) \
|
|
? (struct elf_arc_link_hash_table *) (p)->hash : NULL)
|
|
|
|
static bfd_boolean
|
|
elf_arc_check_relocs (bfd * abfd,
|
|
struct bfd_link_info * info,
|
|
asection * sec,
|
|
const Elf_Internal_Rela * relocs)
|
|
{
|
|
Elf_Internal_Shdr * symtab_hdr;
|
|
struct elf_link_hash_entry ** sym_hashes;
|
|
const Elf_Internal_Rela * rel;
|
|
const Elf_Internal_Rela * rel_end;
|
|
bfd * dynobj;
|
|
asection * sreloc = NULL;
|
|
struct elf_link_hash_table * htab = elf_hash_table (info);
|
|
|
|
if (bfd_link_relocatable (info))
|
|
return TRUE;
|
|
|
|
if (htab->dynobj == NULL)
|
|
htab->dynobj = abfd;
|
|
|
|
dynobj = (elf_hash_table (info))->dynobj;
|
|
symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);
|
|
sym_hashes = elf_sym_hashes (abfd);
|
|
|
|
rel_end = relocs + sec->reloc_count;
|
|
for (rel = relocs; rel < rel_end; rel++)
|
|
{
|
|
enum elf_arc_reloc_type r_type;
|
|
reloc_howto_type *howto;
|
|
unsigned long r_symndx;
|
|
struct elf_link_hash_entry *h;
|
|
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
|
|
|
if (r_type >= (int) R_ARC_max)
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
howto = arc_elf_howto (r_type);
|
|
|
|
/* Load symbol information. */
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
|
if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol. */
|
|
h = NULL;
|
|
else /* Global one. */
|
|
{
|
|
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
|
|
while (h->root.type == bfd_link_hash_indirect
|
|
|| h->root.type == bfd_link_hash_warning)
|
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
|
}
|
|
|
|
|
|
switch (r_type)
|
|
{
|
|
case R_ARC_32:
|
|
case R_ARC_32_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
|
|
the error should not occur for e.g. debugging or
|
|
non-readonly sections. */
|
|
if (h != NULL
|
|
&& (bfd_link_dll (info) && !bfd_link_pie (info))
|
|
&& (sec->flags & SEC_ALLOC) != 0
|
|
&& (sec->flags & SEC_READONLY) != 0
|
|
&& ((sec->flags & SEC_CODE) != 0
|
|
|| (sec->flags & SEC_DEBUGGING) != 0))
|
|
{
|
|
const char *name;
|
|
if (h)
|
|
name = h->root.root.string;
|
|
else
|
|
name = "UNKNOWN";
|
|
_bfd_error_handler
|
|
/* xgettext:c-format */
|
|
(_("%pB: relocation %s against `%s' can not be used"
|
|
" when making a shared object; recompile with -fPIC"),
|
|
abfd,
|
|
arc_elf_howto (r_type)->name,
|
|
name);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
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;
|
|
/* 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);
|
|
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (is_reloc_for_PLT (howto))
|
|
{
|
|
if (h == NULL)
|
|
continue;
|
|
else
|
|
if (h->forced_local == 0)
|
|
h->needs_plt = 1;
|
|
}
|
|
|
|
/* Add info to the symbol got_entry_list. */
|
|
if (is_reloc_for_GOT (howto)
|
|
|| is_reloc_for_TLS (howto))
|
|
{
|
|
if (bfd_link_dll (info) && !bfd_link_pie (info)
|
|
&& (r_type == R_ARC_TLS_LE_32 || r_type == R_ARC_TLS_LE_S9))
|
|
{
|
|
const char *name;
|
|
if (h)
|
|
name = h->root.root.string;
|
|
else
|
|
/* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
|
|
name = "UNKNOWN";
|
|
_bfd_error_handler
|
|
/* xgettext:c-format */
|
|
(_("%pB: relocation %s against `%s' can not be used"
|
|
" when making a shared object; recompile with -fPIC"),
|
|
abfd,
|
|
arc_elf_howto (r_type)->name,
|
|
name);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
|
|
|
|
static struct plt_version_t *
|
|
arc_get_plt_version (struct bfd_link_info *info)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 1; i++)
|
|
{
|
|
ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i,
|
|
(int) plt_versions[i].entry_size,
|
|
(int) plt_versions[i].elem_size);
|
|
}
|
|
|
|
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_ARCV2_ABS]);
|
|
}
|
|
else
|
|
{
|
|
if (bfd_link_pic (info))
|
|
return &(plt_versions[ELF_ARC_PIC]);
|
|
else
|
|
return &(plt_versions[ELF_ARC_ABS]);
|
|
}
|
|
}
|
|
|
|
static bfd_vma
|
|
add_symbol_to_plt (struct bfd_link_info *info)
|
|
{
|
|
struct elf_link_hash_table *htab = elf_hash_table (info);
|
|
bfd_vma ret;
|
|
|
|
struct plt_version_t *plt_data = arc_get_plt_version (info);
|
|
|
|
/* If this is the first .plt entry, make room for the special first
|
|
entry. */
|
|
if (htab->splt->size == 0)
|
|
htab->splt->size += plt_data->entry_size;
|
|
|
|
ret = htab->splt->size;
|
|
|
|
htab->splt->size += plt_data->elem_size;
|
|
ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size);
|
|
|
|
htab->sgotplt->size += 4;
|
|
htab->srelplt->size += sizeof (Elf32_External_Rela);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
|
|
plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
|
|
|
|
static void
|
|
plt_do_relocs_for_symbol (bfd *abfd,
|
|
struct elf_link_hash_table *htab,
|
|
const struct plt_reloc *reloc,
|
|
bfd_vma plt_offset,
|
|
bfd_vma symbol_got_offset)
|
|
{
|
|
while (SYM_ONLY (reloc->symbol) != LAST_RELOC)
|
|
{
|
|
bfd_vma relocation = 0;
|
|
|
|
switch (SYM_ONLY (reloc->symbol))
|
|
{
|
|
case SGOT:
|
|
relocation
|
|
= htab->sgotplt->output_section->vma
|
|
+ htab->sgotplt->output_offset + symbol_got_offset;
|
|
break;
|
|
}
|
|
relocation += reloc->addend;
|
|
|
|
if (IS_RELATIVE (reloc->symbol))
|
|
{
|
|
bfd_vma reloc_offset = reloc->offset;
|
|
reloc_offset -= (IS_INSN_32 (reloc->symbol)) ? 4 : 0;
|
|
reloc_offset -= (IS_INSN_24 (reloc->symbol)) ? 2 : 0;
|
|
|
|
relocation -= htab->splt->output_section->vma
|
|
+ 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. */
|
|
if (IS_MIDDLE_ENDIAN (reloc->symbol) && !bfd_big_endian (abfd))
|
|
{
|
|
relocation
|
|
= ((relocation & 0xffff0000) >> 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;
|
|
}
|
|
|
|
reloc = &(reloc[1]); /* Jump to next relocation. */
|
|
}
|
|
}
|
|
|
|
static void
|
|
relocate_plt_for_symbol (bfd *output_bfd,
|
|
struct bfd_link_info *info,
|
|
struct elf_link_hash_entry *h)
|
|
{
|
|
struct plt_version_t *plt_data = arc_get_plt_version (info);
|
|
struct elf_link_hash_table *htab = elf_hash_table (info);
|
|
|
|
bfd_vma plt_index = (h->plt.offset - plt_data->entry_size)
|
|
/ 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",
|
|
(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];
|
|
bfd_put_16 (output_bfd,
|
|
(bfd_vma) data,
|
|
htab->splt->contents + h->plt.offset + (i*2));
|
|
}
|
|
}
|
|
|
|
plt_do_relocs_for_symbol (output_bfd, htab,
|
|
plt_data->elem_relocs,
|
|
h->plt.offset,
|
|
got_offset);
|
|
|
|
/* Fill in the entry in the global offset table. */
|
|
bfd_put_32 (output_bfd,
|
|
(bfd_vma) (htab->splt->output_section->vma
|
|
+ htab->splt->output_offset),
|
|
htab->sgotplt->contents + got_offset);
|
|
|
|
/* TODO: Fill in the entry in the .rela.plt section. */
|
|
{
|
|
Elf_Internal_Rela rel;
|
|
bfd_byte *loc;
|
|
|
|
rel.r_offset = (htab->sgotplt->output_section->vma
|
|
+ htab->sgotplt->output_offset
|
|
+ got_offset);
|
|
rel.r_addend = 0;
|
|
|
|
BFD_ASSERT (h->dynindx != -1);
|
|
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
|
|
|
|
loc = htab->srelplt->contents;
|
|
loc += plt_index * sizeof (Elf32_External_Rela); /* relA */
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
|
|
}
|
|
}
|
|
|
|
static void
|
|
relocate_plt_for_entry (bfd *abfd,
|
|
struct bfd_link_info *info)
|
|
{
|
|
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++)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/* Desc : Adjust a symbol defined by a dynamic object and referenced
|
|
by a regular object. The current definition is in some section of
|
|
the dynamic object, but we're not including those sections. We
|
|
have to change the definition to something the rest of the link can
|
|
understand. */
|
|
|
|
static bfd_boolean
|
|
elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info,
|
|
struct elf_link_hash_entry *h)
|
|
{
|
|
asection *s;
|
|
bfd *dynobj = (elf_hash_table (info))->dynobj;
|
|
struct elf_link_hash_table *htab = elf_hash_table (info);
|
|
|
|
if (h->type == STT_FUNC
|
|
|| h->type == STT_GNU_IFUNC
|
|
|| h->needs_plt == 1)
|
|
{
|
|
if (!bfd_link_pic (info) && !h->def_dynamic && !h->ref_dynamic)
|
|
{
|
|
/* This case can occur if we saw a PLT32 reloc in an input
|
|
file, but the symbol was never referred to by a dynamic
|
|
object. In such a case, we don't actually need to build
|
|
a procedure linkage table, and we can just do a PC32
|
|
reloc instead. */
|
|
BFD_ASSERT (h->needs_plt);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Make sure this symbol is output as a dynamic symbol. */
|
|
if (h->dynindx == -1 && !h->forced_local
|
|
&& !bfd_elf_link_record_dynamic_symbol (info, h))
|
|
return FALSE;
|
|
|
|
if (bfd_link_pic (info)
|
|
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
|
|
{
|
|
bfd_vma loc = add_symbol_to_plt (info);
|
|
|
|
if (bfd_link_executable (info) && !h->def_regular)
|
|
{
|
|
h->root.u.def.section = htab->splt;
|
|
h->root.u.def.value = loc;
|
|
}
|
|
h->plt.offset = loc;
|
|
}
|
|
else
|
|
{
|
|
h->plt.offset = (bfd_vma) -1;
|
|
h->needs_plt = 0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* If this is a weak symbol, and there is a real definition, the
|
|
processor independent code will have arranged for us to see the
|
|
real definition first, and we can just use the same value. */
|
|
if (h->is_weakalias)
|
|
{
|
|
struct elf_link_hash_entry *def = weakdef (h);
|
|
BFD_ASSERT (def->root.type == bfd_link_hash_defined);
|
|
h->root.u.def.section = def->root.u.def.section;
|
|
h->root.u.def.value = def->root.u.def.value;
|
|
return TRUE;
|
|
}
|
|
|
|
/* This is a reference to a symbol defined by a dynamic object which
|
|
is not a function. */
|
|
|
|
/* If we are creating a shared library, we must presume that the
|
|
only references to the symbol are via the global offset table.
|
|
For such cases we need not do anything here; the relocations will
|
|
be handled correctly by relocate_section. */
|
|
if (!bfd_link_executable (info))
|
|
return TRUE;
|
|
|
|
/* If there are no non-GOT references, we do not need a copy
|
|
relocation. */
|
|
if (!h->non_got_ref)
|
|
return TRUE;
|
|
|
|
/* If -z nocopyreloc was given, we won't generate them either. */
|
|
if (info->nocopyreloc)
|
|
{
|
|
h->non_got_ref = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
/* We must allocate the symbol in our .dynbss section, which will
|
|
become part of the .bss section of the executable. There will be
|
|
an entry for this symbol in the .dynsym section. The dynamic
|
|
object will contain position independent code, so all references
|
|
from the dynamic object to this symbol will go through the global
|
|
offset table. The dynamic linker will use the .dynsym entry to
|
|
determine the address it must put in the global offset table, so
|
|
both the dynamic object and the regular object will refer to the
|
|
same memory location for the variable. */
|
|
|
|
if (htab == NULL)
|
|
return FALSE;
|
|
|
|
/* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
|
|
copy the initial value out of the dynamic object and into the
|
|
runtime process image. We need to remember the offset into the
|
|
.rela.bss section we are going to use. */
|
|
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
|
|
{
|
|
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 (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);
|
|
|
|
return _bfd_elf_adjust_dynamic_copy (info, h, s);
|
|
}
|
|
|
|
/* Function : elf_arc_finish_dynamic_symbol
|
|
Brief : Finish up dynamic symbol handling. We set the
|
|
contents of various dynamic sections here.
|
|
Args : output_bfd :
|
|
info :
|
|
h :
|
|
sym :
|
|
Returns : True/False as the return status. */
|
|
|
|
static bfd_boolean
|
|
elf_arc_finish_dynamic_symbol (bfd * output_bfd,
|
|
struct bfd_link_info *info,
|
|
struct elf_link_hash_entry *h,
|
|
Elf_Internal_Sym * sym)
|
|
{
|
|
if (h->plt.offset != (bfd_vma) -1)
|
|
{
|
|
relocate_plt_for_symbol (output_bfd, info, h);
|
|
|
|
if (!h->def_regular)
|
|
{
|
|
/* Mark the symbol as undefined, rather than as defined in
|
|
the .plt section. Leave the value alone. */
|
|
sym->st_shndx = SHN_UNDEF;
|
|
}
|
|
}
|
|
|
|
|
|
/* This function traverses list of GOT entries and
|
|
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);
|
|
|
|
if (h->needs_copy)
|
|
{
|
|
struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
|
|
|
|
if (arc_htab == NULL)
|
|
return FALSE;
|
|
|
|
if (h->dynindx == -1
|
|
|| (h->root.type != bfd_link_hash_defined
|
|
&& h->root.type != bfd_link_hash_defweak)
|
|
|| arc_htab->elf.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);
|
|
|
|
bfd_byte * loc = arc_htab->elf.srelbss->contents
|
|
+ (arc_htab->elf.srelbss->reloc_count * sizeof (Elf32_External_Rela));
|
|
arc_htab->elf.srelbss->reloc_count++;
|
|
|
|
Elf_Internal_Rela rel;
|
|
rel.r_addend = 0;
|
|
rel.r_offset = rel_offset;
|
|
|
|
BFD_ASSERT (h->dynindx != -1);
|
|
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY);
|
|
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
|
|
}
|
|
|
|
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
|
|
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
|
|
|| strcmp (h->root.root.string, "__DYNAMIC") == 0
|
|
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
|
|
sym->st_shndx = SHN_ABS;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
|
|
case TAG: \
|
|
if (SYMBOL != NULL) \
|
|
h = elf_link_hash_lookup (elf_hash_table (info), \
|
|
SYMBOL, FALSE, FALSE, TRUE); \
|
|
else if (SECTION != NULL) \
|
|
s = bfd_get_linker_section (dynobj, SECTION); \
|
|
break;
|
|
|
|
|
|
struct obfd_info_group {
|
|
bfd *output_bfd;
|
|
struct bfd_link_info *info;
|
|
};
|
|
|
|
static bfd_boolean
|
|
arc_create_forced_local_got_entries_for_tls (struct bfd_hash_entry *bh,
|
|
void *data)
|
|
{
|
|
struct elf_arc_link_hash_entry * h =
|
|
(struct elf_arc_link_hash_entry *) bh;
|
|
struct obfd_info_group *tmp = (struct obfd_info_group *) data;
|
|
|
|
if (h->got_ents != NULL)
|
|
{
|
|
BFD_ASSERT (h);
|
|
|
|
struct got_entry *list = h->got_ents;
|
|
|
|
while (list != NULL)
|
|
{
|
|
create_got_dynrelocs_for_single_entry (list, tmp->output_bfd,
|
|
tmp->info,
|
|
(struct elf_link_hash_entry *) h);
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* Function : elf_arc_finish_dynamic_sections
|
|
Brief : Finish up the dynamic sections handling.
|
|
Args : output_bfd :
|
|
info :
|
|
h :
|
|
sym :
|
|
Returns : True/False as the return status. */
|
|
|
|
static bfd_boolean
|
|
elf_arc_finish_dynamic_sections (bfd * output_bfd,
|
|
struct bfd_link_info *info)
|
|
{
|
|
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");
|
|
|
|
if (sdyn)
|
|
{
|
|
Elf32_External_Dyn *dyncon, *dynconend;
|
|
|
|
dyncon = (Elf32_External_Dyn *) sdyn->contents;
|
|
dynconend
|
|
= (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
|
|
for (; dyncon < dynconend; dyncon++)
|
|
{
|
|
Elf_Internal_Dyn internal_dyn;
|
|
bfd_boolean do_it = FALSE;
|
|
|
|
struct elf_link_hash_entry *h = NULL;
|
|
asection *s = NULL;
|
|
|
|
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;
|
|
}
|
|
|
|
/* In case the dynamic symbols should be updated with a symbol. */
|
|
if (h != NULL
|
|
&& (h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak))
|
|
{
|
|
asection *asec_ptr;
|
|
|
|
internal_dyn.d_un.d_val = h->root.u.def.value;
|
|
asec_ptr = h->root.u.def.section;
|
|
if (asec_ptr->output_section != NULL)
|
|
{
|
|
internal_dyn.d_un.d_val +=
|
|
(asec_ptr->output_section->vma
|
|
+ asec_ptr->output_offset);
|
|
}
|
|
else
|
|
{
|
|
/* The symbol is imported from another shared
|
|
library and does not apply to this one. */
|
|
internal_dyn.d_un.d_val = 0;
|
|
}
|
|
do_it = TRUE;
|
|
}
|
|
else if (s != NULL) /* With a section information. */
|
|
{
|
|
switch (internal_dyn.d_tag)
|
|
{
|
|
case DT_PLTGOT:
|
|
case DT_JMPREL:
|
|
case DT_VERSYM:
|
|
case DT_VERDEF:
|
|
case DT_VERNEED:
|
|
internal_dyn.d_un.d_ptr = (s->output_section->vma
|
|
+ s->output_offset);
|
|
do_it = TRUE;
|
|
break;
|
|
|
|
case DT_PLTRELSZ:
|
|
internal_dyn.d_un.d_val = s->size;
|
|
do_it = TRUE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (do_it)
|
|
bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon);
|
|
}
|
|
|
|
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 = 12;
|
|
}
|
|
|
|
/* Fill in the first three entries in the global offset table. */
|
|
if (htab->sgot)
|
|
{
|
|
struct elf_link_hash_entry *h;
|
|
h = elf_link_hash_lookup (elf_hash_table (info), "_GLOBAL_OFFSET_TABLE_",
|
|
FALSE, FALSE, TRUE);
|
|
|
|
if (h != NULL && h->root.type != bfd_link_hash_undefined
|
|
&& h->root.u.def.section != NULL)
|
|
{
|
|
asection *sec = h->root.u.def.section;
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
struct obfd_info_group group;
|
|
group.output_bfd = output_bfd;
|
|
group.info = info;
|
|
bfd_hash_traverse (&info->hash->table,
|
|
arc_create_forced_local_got_entries_for_tls, &group);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
|
|
h = elf_link_hash_lookup (elf_hash_table (info), \
|
|
NAME, FALSE, FALSE, FALSE); \
|
|
if ((h != NULL && (h->ref_regular || h->def_regular))) \
|
|
if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
|
|
return FALSE;
|
|
|
|
/* Set the sizes of the dynamic sections. */
|
|
static bfd_boolean
|
|
elf_arc_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
|
|
struct bfd_link_info *info)
|
|
{
|
|
bfd *dynobj;
|
|
asection *s;
|
|
bfd_boolean relocs_exist = FALSE;
|
|
struct elf_link_hash_table *htab = elf_hash_table (info);
|
|
|
|
dynobj = htab->dynobj;
|
|
BFD_ASSERT (dynobj != NULL);
|
|
|
|
if (htab->dynamic_sections_created)
|
|
{
|
|
struct elf_link_hash_entry *h;
|
|
|
|
/* Set the contents of the .interp section to the
|
|
interpreter. */
|
|
if (bfd_link_executable (info) && !info->nointerp)
|
|
{
|
|
s = bfd_get_section_by_name (dynobj, ".interp");
|
|
BFD_ASSERT (s != NULL);
|
|
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
|
|
the values later, in elf_bfd_final_link, but we must add the
|
|
entries now so that we know the final size of the .dynamic
|
|
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 (info->init_function, DT_INIT);
|
|
ADD_DYNAMIC_SYMBOL (info->fini_function, DT_FINI);
|
|
}
|
|
else
|
|
{
|
|
/* We may have created entries in the .rela.got section.
|
|
However, if we are not creating the dynamic sections, we will
|
|
not actually use these entries. Reset the size of .rela.got,
|
|
which will cause it to get stripped from the output file
|
|
below. */
|
|
if (htab->srelgot != NULL)
|
|
htab->srelgot->size = 0;
|
|
}
|
|
|
|
for (s = dynobj->sections; s != NULL; s = s->next)
|
|
{
|
|
if ((s->flags & SEC_LINKER_CREATED) == 0)
|
|
continue;
|
|
|
|
if (s == htab->splt
|
|
|| s == htab->sgot
|
|
|| s == htab->sgotplt
|
|
|| s == htab->sdynbss)
|
|
{
|
|
/* Strip this section if we don't need it. */
|
|
}
|
|
else if (strncmp (s->name, ".rela", 5) == 0)
|
|
{
|
|
if (s->size != 0 && s != htab->srelplt)
|
|
relocs_exist = TRUE;
|
|
|
|
/* We use the reloc_count field as a counter if we need to
|
|
copy relocs into the output file. */
|
|
s->reloc_count = 0;
|
|
}
|
|
else
|
|
{
|
|
/* It's not one of our sections, so don't allocate space. */
|
|
continue;
|
|
}
|
|
|
|
if (s->size == 0)
|
|
{
|
|
s->flags |= SEC_EXCLUDE;
|
|
continue;
|
|
}
|
|
|
|
if ((s->flags & SEC_HAS_CONTENTS) == 0)
|
|
continue;
|
|
|
|
/* Allocate memory for the section contents. */
|
|
s->contents = bfd_zalloc (dynobj, s->size);
|
|
if (s->contents == NULL)
|
|
return FALSE;
|
|
}
|
|
|
|
return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs_exist);
|
|
}
|
|
|
|
|
|
/* Classify dynamic relocs such that -z combreloc can reorder and combine
|
|
them. */
|
|
static enum elf_reloc_type_class
|
|
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) ELF32_R_TYPE (rela->r_info))
|
|
{
|
|
case R_ARC_RELATIVE:
|
|
return reloc_class_relative;
|
|
case R_ARC_JMP_SLOT:
|
|
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;
|
|
}
|
|
}
|
|
|
|
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
|
|
};
|
|
|
|
#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
|
|
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);
|
|
}
|
|
|
|
/* Determine whether an object attribute tag takes an integer, a
|
|
string or both. */
|
|
|
|
static int
|
|
elf32_arc_obj_attrs_arg_type (int tag)
|
|
{
|
|
if (tag == Tag_ARC_CPU_name
|
|
|| 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;
|
|
else
|
|
return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
|
|
}
|
|
|
|
/* Attribute numbers >=14 can be safely ignored. */
|
|
|
|
static bfd_boolean
|
|
elf32_arc_obj_attrs_handle_unknown (bfd *abfd, int tag)
|
|
{
|
|
if ((tag & 127) < (Tag_ARC_ISA_mpy_option + 1))
|
|
{
|
|
_bfd_error_handler
|
|
(_("%pB: unknown mandatory ARC object attribute %d"),
|
|
abfd, tag);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
_bfd_error_handler
|
|
(_("warning: %pB: unknown ARC object attribute %d"),
|
|
abfd, tag);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
/* 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 bfd_boolean
|
|
elf32_arc_section_from_shdr (bfd *abfd,
|
|
Elf_Internal_Shdr * hdr,
|
|
const char *name,
|
|
int shindex)
|
|
{
|
|
switch (hdr->sh_type)
|
|
{
|
|
case 0x0c: /* MWDT specific section, don't complain about it. */
|
|
case SHT_ARC_ATTRIBUTES:
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Relaxation hook.
|
|
|
|
These are the current relaxing opportunities available:
|
|
|
|
* R_ARC_GOTPC32 => R_ARC_PCREL.
|
|
|
|
*/
|
|
|
|
static bfd_boolean
|
|
arc_elf_relax_section (bfd *abfd, asection *sec,
|
|
struct bfd_link_info *link_info, bfd_boolean *again)
|
|
{
|
|
Elf_Internal_Shdr *symtab_hdr;
|
|
Elf_Internal_Rela *internal_relocs;
|
|
Elf_Internal_Rela *irel, *irelend;
|
|
bfd_byte *contents = NULL;
|
|
Elf_Internal_Sym *isymbuf = NULL;
|
|
|
|
/* Assume nothing changes. */
|
|
*again = FALSE;
|
|
|
|
/* 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. */
|
|
if (bfd_link_relocatable (link_info)
|
|
|| (sec->flags & SEC_RELOC) == 0
|
|
|| sec->reloc_count == 0
|
|
|| (sec->flags & SEC_CODE) == 0)
|
|
return TRUE;
|
|
|
|
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
|
|
|
|
/* Get a copy of the native relocations. */
|
|
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
|
|
link_info->keep_memory);
|
|
if (internal_relocs == NULL)
|
|
goto error_return;
|
|
|
|
/* Walk through them looking for relaxing opportunities. */
|
|
irelend = internal_relocs + sec->reloc_count;
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
|
{
|
|
/* 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;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
struct elf_link_hash_entry *htop = NULL;
|
|
|
|
if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
|
|
{
|
|
/* An external symbol. */
|
|
unsigned int indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
|
|
htop = elf_sym_hashes (abfd)[indx];
|
|
}
|
|
|
|
if (ELF32_R_TYPE (irel->r_info) == (int) R_ARC_GOTPC32
|
|
&& SYMBOL_REFERENCES_LOCAL (link_info, htop))
|
|
{
|
|
unsigned int code;
|
|
|
|
/* Get the opcode. */
|
|
code = bfd_get_32_me (abfd, contents + irel->r_offset - 4);
|
|
|
|
/* 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 = 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.
|
|
111 00 000 0111 xx xxxx*/
|
|
code &= ~0x27307F80;
|
|
BFD_ASSERT (code <= 62UL);
|
|
code |= 0x27007F80;
|
|
|
|
/* Write back the new instruction. */
|
|
bfd_put_32_me (abfd, code, contents + irel->r_offset - 4);
|
|
|
|
/* The size isn't changed, don't redo. */
|
|
*again = FALSE;
|
|
}
|
|
}
|
|
|
|
if (isymbuf != NULL
|
|
&& symtab_hdr->contents != (unsigned char *) isymbuf)
|
|
{
|
|
if (!link_info->keep_memory)
|
|
free (isymbuf);
|
|
else
|
|
/* 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);
|
|
else
|
|
/* 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)
|
|
free (internal_relocs);
|
|
|
|
return TRUE;
|
|
|
|
error_return:
|
|
if (symtab_hdr->contents != (unsigned char *) isymbuf)
|
|
free (isymbuf);
|
|
if (elf_section_data (sec)->this_hdr.contents != contents)
|
|
free (contents);
|
|
if (elf_section_data (sec)->relocs != internal_relocs)
|
|
free (internal_relocs);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#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 bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
|
|
|
|
#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_final_write_processing arc_elf_final_write_processing
|
|
|
|
#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_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_finish_dynamic_sections elf_arc_finish_dynamic_sections
|
|
#define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
|
|
|
|
#define elf_backend_can_gc_sections 1
|
|
#define elf_backend_want_got_plt 1
|
|
#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 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 elf32_arc_grok_prstatus
|
|
|
|
#define elf_backend_default_execstack 0
|
|
|
|
#undef elf_backend_obj_attrs_vendor
|
|
#define elf_backend_obj_attrs_vendor "ARC"
|
|
#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 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 elf32_arc_obj_attrs_handle_unknown
|
|
|
|
#define elf_backend_section_from_shdr elf32_arc_section_from_shdr
|
|
|
|
#include "elf32-target.h"
|