/* Renesas RL78 specific support for 32-bit ELF.
- Copyright (C) 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2011-2016 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
+static bfd_reloc_status_type rl78_special_reloc (bfd *, arelent *, asymbol *, void *,
+ asection *, bfd *, char **);
+
+/* FIXME: We could omit the SHIFT parameter, it is always zero. */
+#define RL78_OP_REL(n,sz,bit,shift,complain,pcrel) \
+ HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
+ rl78_special_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
+
/* Note that the relocations around 0x7f are internal to this file;
feel free to move them as needed to avoid conflicts with published
relocation numbers. */
static reloc_howto_type rl78_elf_howto_table [] =
{
- RL78REL (NONE, 0, 0, 0, dont, FALSE),
+ RL78REL (NONE, 3, 0, 0, dont, FALSE),
RL78REL (DIR32, 2, 32, 0, signed, FALSE),
RL78REL (DIR24S, 2, 24, 0, signed, FALSE),
RL78REL (DIR16, 1, 16, 0, dont, FALSE),
RL78REL (RH_RELAX, 0, 0, 0, dont, FALSE),
EMPTY_HOWTO (0x2e),
- EMPTY_HOWTO (0x2f),
+ RL78REL (RH_SADDR, 0, 0, 0, dont, FALSE),
EMPTY_HOWTO (0x30),
EMPTY_HOWTO (0x31),
EMPTY_HOWTO (0x32),
EMPTY_HOWTO (0x3f),
EMPTY_HOWTO (0x40),
- RL78REL (ABS32, 2, 32, 0, dont, FALSE),
- RL78REL (ABS24S, 2, 24, 0, signed, FALSE),
- RL78REL (ABS16, 1, 16, 0, dont, FALSE),
- RL78REL (ABS16U, 1, 16, 0, unsigned, FALSE),
- RL78REL (ABS16S, 1, 16, 0, signed, FALSE),
- RL78REL (ABS8, 0, 8, 0, dont, FALSE),
- RL78REL (ABS8U, 0, 8, 0, unsigned, FALSE),
- RL78REL (ABS8S, 0, 8, 0, signed, FALSE),
- RL78REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
- RL78REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
- RL78REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
- RL78REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
- RL78REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
- RL78REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
- RL78REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
- RL78REL (ABS32_REV, 2, 32, 0, dont, FALSE),
- RL78REL (ABS16_REV, 1, 16, 0, dont, FALSE),
+ RL78_OP_REL (ABS32, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (ABS24S, 2, 24, 0, signed, FALSE),
+ RL78_OP_REL (ABS16, 1, 16, 0, dont, FALSE),
+ RL78_OP_REL (ABS16U, 1, 16, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS16S, 1, 16, 0, signed, FALSE),
+ RL78_OP_REL (ABS8, 0, 8, 0, dont, FALSE),
+ RL78_OP_REL (ABS8U, 0, 8, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS8S, 0, 8, 0, signed, FALSE),
+ RL78_OP_REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
+ RL78_OP_REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
+ RL78_OP_REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
+ RL78_OP_REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
+ RL78_OP_REL (ABS32_REV, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (ABS16_REV, 1, 16, 0, dont, FALSE),
#define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
EMPTY_HOWTO (0x7e),
EMPTY_HOWTO (0x7f),
- RL78REL (SYM, 2, 32, 0, dont, FALSE),
- RL78REL (OPneg, 2, 32, 0, dont, FALSE),
- RL78REL (OPadd, 2, 32, 0, dont, FALSE),
- RL78REL (OPsub, 2, 32, 0, dont, FALSE),
- RL78REL (OPmul, 2, 32, 0, dont, FALSE),
- RL78REL (OPdiv, 2, 32, 0, dont, FALSE),
- RL78REL (OPshla, 2, 32, 0, dont, FALSE),
- RL78REL (OPshra, 2, 32, 0, dont, FALSE),
- RL78REL (OPsctsize, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (SYM, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPneg, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPadd, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPsub, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPmul, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPdiv, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPshla, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPshra, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPsctsize, 2, 32, 0, dont, FALSE),
EMPTY_HOWTO (0x89),
EMPTY_HOWTO (0x8a),
EMPTY_HOWTO (0x8b),
EMPTY_HOWTO (0x8c),
- RL78REL (OPscttop, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPscttop, 2, 32, 0, dont, FALSE),
EMPTY_HOWTO (0x8e),
EMPTY_HOWTO (0x8f),
- RL78REL (OPand, 2, 32, 0, dont, FALSE),
- RL78REL (OPor, 2, 32, 0, dont, FALSE),
- RL78REL (OPxor, 2, 32, 0, dont, FALSE),
- RL78REL (OPnot, 2, 32, 0, dont, FALSE),
- RL78REL (OPmod, 2, 32, 0, dont, FALSE),
- RL78REL (OPromtop, 2, 32, 0, dont, FALSE),
- RL78REL (OPramtop, 2, 32, 0, dont, FALSE)
+ RL78_OP_REL (OPand, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPor, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPxor, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPnot, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPmod, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPromtop, 2, 32, 0, dont, FALSE),
+ RL78_OP_REL (OPramtop, 2, 32, 0, dont, FALSE)
};
\f
/* Map BFD reloc types to RL78 ELF reloc types. */
{ BFD_RELOC_RL78_ABS16UL, R_RL78_ABS16UL },
{ BFD_RELOC_RL78_ABS16UW, R_RL78_ABS16UW },
{ BFD_RELOC_RL78_ABS16U, R_RL78_ABS16U },
+ { BFD_RELOC_RL78_SADDR, R_RL78_RH_SADDR },
{ BFD_RELOC_RL78_RELAX, R_RL78_RH_RELAX }
};
if (code == BFD_RELOC_RL78_32_OP)
return rl78_elf_howto_table + R_RL78_DIR32;
- for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
+ for (i = ARRAY_SIZE (rl78_reloc_map); i--;)
if (rl78_reloc_map [i].bfd_reloc_val == code)
return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
unsigned int r_type;
r_type = ELF32_R_TYPE (dst->r_info);
- BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
+ if (r_type >= (unsigned int) R_RL78_max)
+ {
+ _bfd_error_handler (_("%B: invalid RL78 reloc number: %d"), abfd, r_type);
+ r_type = 0;
+ }
cache_ptr->howto = rl78_elf_howto_table + r_type;
}
\f
static bfd_vma
get_symbol_value (const char * name,
- bfd_reloc_status_type * status,
struct bfd_link_info * info,
bfd * input_bfd,
asection * input_section,
int offset)
{
- bfd_vma value = 0;
struct bfd_link_hash_entry * h;
+ if (info == NULL)
+ return 0;
+
h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
if (h == NULL
|| (h->type != bfd_link_hash_defined
&& h->type != bfd_link_hash_defweak))
- * status = info->callbacks->undefined_symbol
- (info, name, input_bfd, input_section, offset, TRUE);
- else
- value = (h->u.def.value
- + h->u.def.section->output_section->vma
- + h->u.def.section->output_offset);
+ {
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, offset, TRUE);
+ return 0;
+ }
- return value;
+ return (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
}
static bfd_vma
-get_romstart (bfd_reloc_status_type * status,
- struct bfd_link_info * info,
+get_romstart (struct bfd_link_info * info,
bfd * abfd,
asection * sec,
int offset)
if (!cached)
{
- cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
+ cached_value = get_symbol_value ("_start", info, abfd, sec, offset);
cached = TRUE;
}
return cached_value;
}
static bfd_vma
-get_ramstart (bfd_reloc_status_type * status,
- struct bfd_link_info * info,
+get_ramstart (struct bfd_link_info * info,
bfd * abfd,
asection * sec,
int offset)
if (!cached)
{
- cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
+ cached_value = get_symbol_value ("__datastart", info, abfd, sec, offset);
cached = TRUE;
}
return cached_value;
if (rl78_stack_top < NUM_STACK_ENTRIES) \
rl78_stack [rl78_stack_top ++] = (val); \
else \
- r = bfd_reloc_dangerous; \
+ _bfd_error_handler (_("Internal Error: RL78 reloc stack overflow")); \
} \
while (0)
do \
{ \
if (rl78_stack_top > 0) \
- (dest) = rl78_stack [-- rl78_stack_top]; \
+ (dest) = rl78_stack [-- rl78_stack_top];\
else \
- (dest) = 0, r = bfd_reloc_dangerous; \
+ { \
+ _bfd_error_handler (_("Internal Error: RL78 reloc stack underflow")); \
+ (dest) = 0; \
+ } \
} \
while (0)
+/* Special handling for RL78 complex relocs. Returns the
+ value of the reloc, or 0 for relocs which do not generate
+ a result. SYMVAL is the value of the symbol for relocs
+ which use a symbolic argument. */
+
+static bfd_vma
+rl78_compute_complex_reloc (unsigned long r_type,
+ bfd_vma symval,
+ asection * input_section)
+{
+ int32_t tmp1, tmp2;
+ bfd_vma relocation;
+
+ switch (r_type)
+ {
+ default:
+ return 0;
+
+ case R_RL78_ABS24S_PCREL:
+ case R_RL78_ABS16S_PCREL:
+ case R_RL78_ABS8S_PCREL:
+ RL78_STACK_POP (relocation);
+ relocation -= input_section->output_section->vma + input_section->output_offset;
+ return relocation;
+
+ case R_RL78_ABS32:
+ case R_RL78_ABS32_REV:
+ case R_RL78_ABS16:
+ case R_RL78_ABS16_REV:
+ case R_RL78_ABS16S:
+ case R_RL78_ABS16U:
+ case R_RL78_ABS8:
+ case R_RL78_ABS8U:
+ case R_RL78_ABS8S:
+ RL78_STACK_POP (relocation);
+ return relocation;
+
+ case R_RL78_ABS16UL:
+ case R_RL78_ABS8UL:
+ RL78_STACK_POP (relocation);
+ return relocation >> 2;
+
+ case R_RL78_ABS16UW:
+ case R_RL78_ABS8UW:
+ RL78_STACK_POP (relocation);
+ return relocation >> 1;
+
+ /* The rest of the relocs compute values and then push them onto the stack. */
+ case R_RL78_OPramtop:
+ case R_RL78_OPromtop:
+ case R_RL78_SYM:
+ RL78_STACK_PUSH (symval);
+ return 0;
+
+ case R_RL78_OPneg:
+ RL78_STACK_POP (tmp1);
+ tmp1 = - tmp1;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPadd:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 += tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPsub:
+ /* For the expression "A - B", the assembler pushes A,
+ then B, then OPSUB. So the first op we pop is B, not A. */
+ RL78_STACK_POP (tmp2); /* B */
+ RL78_STACK_POP (tmp1); /* A */
+ tmp1 -= tmp2; /* A - B */
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPmul:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 *= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPdiv:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 /= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPshla:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 <<= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPshra:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 >>= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPsctsize:
+ RL78_STACK_PUSH (input_section->size);
+ return 0;
+
+ case R_RL78_OPscttop:
+ RL78_STACK_PUSH (input_section->output_section->vma);
+ return 0;
+
+ case R_RL78_OPand:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 &= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPor:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 |= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPxor:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 ^= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPnot:
+ RL78_STACK_POP (tmp1);
+ tmp1 = ~ tmp1;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+
+ case R_RL78_OPmod:
+ RL78_STACK_POP (tmp2);
+ RL78_STACK_POP (tmp1);
+ tmp1 %= tmp2;
+ RL78_STACK_PUSH (tmp1);
+ return 0;
+ }
+}
+
+#undef RL78_STACK_PUSH
+#undef RL78_STACK_POP
+
+#define OP(i) (contents[reloc->address + (i)])
+
+static bfd_reloc_status_type
+rl78_special_reloc (bfd * input_bfd,
+ arelent * reloc,
+ asymbol * symbol,
+ void * data,
+ asection * input_section,
+ bfd * output_bfd ATTRIBUTE_UNUSED,
+ char ** error_message ATTRIBUTE_UNUSED)
+{
+ bfd_reloc_status_type r = bfd_reloc_ok;
+ bfd_vma relocation = 0;
+ unsigned long r_type = reloc->howto->type;
+ bfd_byte * contents = data;
+
+ /* If necessary, compute the symbolic value of the relocation. */
+ switch (r_type)
+ {
+ case R_RL78_SYM:
+ relocation = (symbol->value
+ + symbol->section->output_section->vma
+ + symbol->section->output_offset
+ + reloc->addend);
+ break;
+
+ case R_RL78_OPromtop:
+ relocation = get_romstart (NULL, input_bfd, input_section,
+ reloc->address);
+ break;
+
+ case R_RL78_OPramtop:
+ relocation = get_ramstart (NULL, input_bfd, input_section,
+ reloc->address);
+ break;
+ }
+
+ /* Get the value of the relocation. */
+ relocation = rl78_compute_complex_reloc (r_type, relocation, input_section);
+
+ /* If the relocation alters the contents of the section then apply it now.
+ Note - since this function is called from
+ bfd_generic_get_relocated_section_contents via bfd_perform_relocation,
+ and not from the linker, we do not perform any range checking. The
+ clients who are calling us are only interested in some relocated section
+ contents, and not any linkage problems that might occur later. */
+ switch (r_type)
+ {
+ case R_RL78_ABS32:
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ OP (2) = relocation >> 16;
+ OP (3) = relocation >> 24;
+ break;
+
+ case R_RL78_ABS32_REV:
+ OP (3) = relocation;
+ OP (2) = relocation >> 8;
+ OP (1) = relocation >> 16;
+ OP (0) = relocation >> 24;
+ break;
+
+ case R_RL78_ABS24S_PCREL:
+ case R_RL78_ABS24S:
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ OP (2) = relocation >> 16;
+ break;
+
+ case R_RL78_ABS16_REV:
+ OP (1) = relocation;
+ OP (0) = relocation >> 8;
+ break;
+
+ case R_RL78_ABS16S_PCREL:
+ case R_RL78_ABS16:
+ case R_RL78_ABS16S:
+ case R_RL78_ABS16U:
+ case R_RL78_ABS16UL:
+ case R_RL78_ABS16UW:
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ break;
+
+ case R_RL78_ABS8S_PCREL:
+ case R_RL78_ABS8:
+ case R_RL78_ABS8U:
+ case R_RL78_ABS8UL:
+ case R_RL78_ABS8UW:
+ case R_RL78_ABS8S:
+ OP (0) = relocation;
+ break;
+
+ default:
+ break;
+ }
+
+ return r;
+}
+
+#undef OP
+#define OP(i) (contents[rel->r_offset + (i)])
+
/* Relocate an RL78 ELF section.
There is some attempt to make this function usable for many architectures,
both USE_REL and USE_RELA ['twould be nice if such a critter existed],
dynobj = elf_hash_table (info)->dynobj;
splt = NULL;
if (dynobj != NULL)
- splt = bfd_get_section_by_name (dynobj, ".plt");
+ splt = bfd_get_linker_section (dynobj, ".plt");
for (rel = relocs; rel < relend; rel ++)
{
}
else
{
- bfd_boolean warned;
+ bfd_boolean warned ATTRIBUTE_UNUSED;
+ bfd_boolean ignored ATTRIBUTE_UNUSED;
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
r_symndx, symtab_hdr, sym_hashes, h,
sec, relocation, unresolved_reloc,
- warned);
+ warned, ignored);
name = h->root.root.string;
}
- if (sec != NULL && elf_discarded_section (sec))
+ if (sec != NULL && discarded_section (sec))
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
- rel, relend, howto, contents);
+ rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
{
/* This is a relocatable link. We don't have to change
anything, unless the reloc is against a section symbol,
else
plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
- /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
- relocation, *plt_offset);*/
if (! valid_16bit_address (relocation))
{
/* If this is the first time we've processed this symbol,
r = bfd_reloc_ok;
#define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
-#define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
-#define OP(i) (contents[rel->r_offset + (i)])
/* Opcode relocs are always big endian. Data relocs are bi-endian. */
switch (r_type)
break;
case R_RL78_RH_SFR:
- printf("SFR 0x%lx\n", relocation);
RANGE (0xfff00, 0xfffff);
OP (0) = relocation & 0xff;
break;
case R_RL78_RH_SADDR:
- printf("SADDR 0x%lx\n", relocation);
RANGE (0xffe20, 0xfff1f);
OP (0) = relocation & 0xff;
- printf(" - in\n");
break;
/* Complex reloc handling: */
-
case R_RL78_ABS32:
- RL78_STACK_POP (relocation);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- OP (2) = relocation >> 16;
- OP (3) = relocation >> 24;
- break;
-
case R_RL78_ABS32_REV:
- RL78_STACK_POP (relocation);
- OP (3) = relocation;
- OP (2) = relocation >> 8;
- OP (1) = relocation >> 16;
- OP (0) = relocation >> 24;
- break;
-
case R_RL78_ABS24S_PCREL:
case R_RL78_ABS24S:
- RL78_STACK_POP (relocation);
- RANGE (-0x800000, 0x7fffff);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- OP (2) = relocation >> 16;
- break;
-
case R_RL78_ABS16:
- RL78_STACK_POP (relocation);
- RANGE (-32768, 65535);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- break;
-
case R_RL78_ABS16_REV:
- RL78_STACK_POP (relocation);
- RANGE (-32768, 65535);
- OP (1) = relocation;
- OP (0) = relocation >> 8;
- break;
-
case R_RL78_ABS16S_PCREL:
case R_RL78_ABS16S:
- RL78_STACK_POP (relocation);
- RANGE (-32768, 32767);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- break;
-
case R_RL78_ABS16U:
- RL78_STACK_POP (relocation);
- RANGE (0, 65536);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- break;
-
case R_RL78_ABS16UL:
- RL78_STACK_POP (relocation);
- relocation >>= 2;
- RANGE (0, 65536);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- break;
-
case R_RL78_ABS16UW:
- RL78_STACK_POP (relocation);
- relocation >>= 1;
- RANGE (0, 65536);
- OP (0) = relocation;
- OP (1) = relocation >> 8;
- break;
-
case R_RL78_ABS8:
- RL78_STACK_POP (relocation);
- RANGE (-128, 255);
- OP (0) = relocation;
- break;
-
case R_RL78_ABS8U:
- RL78_STACK_POP (relocation);
- RANGE (0, 255);
- OP (0) = relocation;
- break;
-
case R_RL78_ABS8UL:
- RL78_STACK_POP (relocation);
- relocation >>= 2;
- RANGE (0, 255);
- OP (0) = relocation;
- break;
-
case R_RL78_ABS8UW:
- RL78_STACK_POP (relocation);
- relocation >>= 1;
- RANGE (0, 255);
- OP (0) = relocation;
- break;
-
case R_RL78_ABS8S_PCREL:
case R_RL78_ABS8S:
- RL78_STACK_POP (relocation);
- RANGE (-128, 127);
- OP (0) = relocation;
- break;
-
- case R_RL78_SYM:
- if (r_symndx < symtab_hdr->sh_info)
- RL78_STACK_PUSH (sec->output_section->vma
- + sec->output_offset
- + sym->st_value
- + rel->r_addend);
- else
- {
- if (h != NULL
- && (h->root.type == bfd_link_hash_defined
- || h->root.type == bfd_link_hash_defweak))
- RL78_STACK_PUSH (h->root.u.def.value
- + sec->output_section->vma
- + sec->output_offset
- + rel->r_addend);
- else
- _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
- }
- break;
-
case R_RL78_OPneg:
- {
- int32_t tmp;
-
- RL78_STACK_POP (tmp);
- tmp = - tmp;
- RL78_STACK_PUSH (tmp);
- }
- break;
-
case R_RL78_OPadd:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 += tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
-
case R_RL78_OPsub:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp2 -= tmp1;
- RL78_STACK_PUSH (tmp2);
- }
- break;
-
case R_RL78_OPmul:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 *= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
-
case R_RL78_OPdiv:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 /= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
-
case R_RL78_OPshla:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 <<= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
-
case R_RL78_OPshra:
- {
- int32_t tmp1, tmp2;
+ case R_RL78_OPsctsize:
+ case R_RL78_OPscttop:
+ case R_RL78_OPand:
+ case R_RL78_OPor:
+ case R_RL78_OPxor:
+ case R_RL78_OPnot:
+ case R_RL78_OPmod:
+ relocation = rl78_compute_complex_reloc (r_type, 0, input_section);
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 >>= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
+ switch (r_type)
+ {
+ case R_RL78_ABS32:
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ OP (2) = relocation >> 16;
+ OP (3) = relocation >> 24;
+ break;
- case R_RL78_OPsctsize:
- RL78_STACK_PUSH (input_section->size);
- break;
+ case R_RL78_ABS32_REV:
+ OP (3) = relocation;
+ OP (2) = relocation >> 8;
+ OP (1) = relocation >> 16;
+ OP (0) = relocation >> 24;
+ break;
- case R_RL78_OPscttop:
- RL78_STACK_PUSH (input_section->output_section->vma);
- break;
+ case R_RL78_ABS24S_PCREL:
+ case R_RL78_ABS24S:
+ RANGE (-0x800000, 0x7fffff);
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ OP (2) = relocation >> 16;
+ break;
- case R_RL78_OPand:
- {
- int32_t tmp1, tmp2;
+ case R_RL78_ABS16:
+ RANGE (-32768, 65535);
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ break;
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 &= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
+ case R_RL78_ABS16_REV:
+ RANGE (-32768, 65535);
+ OP (1) = relocation;
+ OP (0) = relocation >> 8;
+ break;
- case R_RL78_OPor:
- {
- int32_t tmp1, tmp2;
+ case R_RL78_ABS16S_PCREL:
+ case R_RL78_ABS16S:
+ RANGE (-32768, 32767);
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ break;
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 |= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
+ case R_RL78_ABS16U:
+ case R_RL78_ABS16UL:
+ case R_RL78_ABS16UW:
+ RANGE (0, 65536);
+ OP (0) = relocation;
+ OP (1) = relocation >> 8;
+ break;
- case R_RL78_OPxor:
- {
- int32_t tmp1, tmp2;
+ case R_RL78_ABS8:
+ RANGE (-128, 255);
+ OP (0) = relocation;
+ break;
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 ^= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
- break;
+ case R_RL78_ABS8U:
+ case R_RL78_ABS8UL:
+ case R_RL78_ABS8UW:
+ RANGE (0, 255);
+ OP (0) = relocation;
+ break;
- case R_RL78_OPnot:
- {
- int32_t tmp;
+ case R_RL78_ABS8S_PCREL:
+ case R_RL78_ABS8S:
+ RANGE (-128, 127);
+ OP (0) = relocation;
+ break;
- RL78_STACK_POP (tmp);
- tmp = ~ tmp;
- RL78_STACK_PUSH (tmp);
- }
+ default:
+ break;
+ }
break;
- case R_RL78_OPmod:
- {
- int32_t tmp1, tmp2;
-
- RL78_STACK_POP (tmp2);
- RL78_STACK_POP (tmp1);
- tmp1 %= tmp2;
- RL78_STACK_PUSH (tmp1);
- }
+ case R_RL78_SYM:
+ if (r_symndx < symtab_hdr->sh_info)
+ relocation = sec->output_section->vma + sec->output_offset
+ + sym->st_value + rel->r_addend;
+ else if (h != NULL
+ && (h->root.type == bfd_link_hash_defined
+ || h->root.type == bfd_link_hash_defweak))
+ relocation = h->root.u.def.value
+ + sec->output_section->vma
+ + sec->output_offset
+ + rel->r_addend;
+ else
+ {
+ relocation = 0;
+ if (h->root.type != bfd_link_hash_undefweak)
+ _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
+ }
+ (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
break;
case R_RL78_OPromtop:
- RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
+ relocation = get_romstart (info, input_bfd, input_section, rel->r_offset);
+ (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
break;
case R_RL78_OPramtop:
- RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
+ relocation = get_ramstart (info, input_bfd, input_section, rel->r_offset);
+ (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
break;
default:
if (r_type == R_RL78_DIR24S_PCREL)
msg = _("%B(%A): error: call to undefined function '%s'");
else
- r = info->callbacks->reloc_overflow
+ (*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- r = info->callbacks->undefined_symbol
- (info, name, input_bfd, input_section, rel->r_offset,
- TRUE);
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_other:
if (msg)
_bfd_error_handler (msg, input_bfd, input_section, name);
-
- if (! r)
- return FALSE;
}
}
no_warn_mismatch = user_no_warn_mismatch;
}
+static const char *
+rl78_cpu_name (flagword flags)
+{
+ switch (flags & E_FLAG_RL78_CPU_MASK)
+ {
+ default: return "";
+ case E_FLAG_RL78_G10: return "G10";
+ case E_FLAG_RL78_G13: return "G13";
+ case E_FLAG_RL78_G14: return "G14";
+ }
+}
+
/* Merge backend specific data from an object file to the output
object file when linking. */
rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
{
flagword new_flags;
+ flagword old_flags;
bfd_boolean error = FALSE;
new_flags = elf_elfheader (ibfd)->e_flags;
+ old_flags = elf_elfheader (obfd)->e_flags;
if (!elf_flags_init (obfd))
{
elf_flags_init (obfd) = TRUE;
elf_elfheader (obfd)->e_flags = new_flags;
}
+ else if (old_flags != new_flags)
+ {
+ flagword changed_flags = old_flags ^ new_flags;
+
+ if (changed_flags & E_FLAG_RL78_CPU_MASK)
+ {
+ flagword out_cpu = old_flags & E_FLAG_RL78_CPU_MASK;
+ flagword in_cpu = new_flags & E_FLAG_RL78_CPU_MASK;
+
+ if (in_cpu == E_FLAG_RL78_ANY_CPU || in_cpu == out_cpu)
+ /* It does not matter what new_cpu may have. */;
+ else if (out_cpu == E_FLAG_RL78_ANY_CPU)
+ {
+ if (in_cpu == E_FLAG_RL78_G10)
+ {
+ /* G10 files can only be linked with other G10 files.
+ If the output is set to "any" this means that it is
+ a G14 file that does not use hardware multiply/divide,
+ but that is still incompatible with the G10 ABI. */
+ error = TRUE;
+
+ _bfd_error_handler
+ (_("RL78 ABI conflict: G10 file %s cannot be linked with %s file %s"),
+ bfd_get_filename (ibfd),
+ rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
+ }
+ else
+ {
+ old_flags &= ~ E_FLAG_RL78_CPU_MASK;
+ old_flags |= in_cpu;
+ elf_elfheader (obfd)->e_flags = old_flags;
+ }
+ }
+ else
+ {
+ error = TRUE;
+
+ _bfd_error_handler
+ (_("RL78 ABI conflict: cannot link %s file %s with %s file %s"),
+ rl78_cpu_name (in_cpu), bfd_get_filename (ibfd),
+ rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
+ }
+ }
+
+ if (changed_flags & E_FLAG_RL78_64BIT_DOUBLES)
+ {
+ _bfd_error_handler
+ (_("RL78 merge conflict: cannot link 32-bit and 64-bit objects together"));
+
+ if (old_flags & E_FLAG_RL78_64BIT_DOUBLES)
+ _bfd_error_handler (_("- %s is 64-bit, %s is not"),
+ bfd_get_filename (obfd), bfd_get_filename (ibfd));
+ else
+ _bfd_error_handler (_("- %s is 64-bit, %s is not"),
+ bfd_get_filename (ibfd), bfd_get_filename (obfd));
+ error = TRUE;
+ }
+ }
return !error;
}
flags = elf_elfheader (abfd)->e_flags;
fprintf (file, _("private flags = 0x%lx:"), (long) flags);
+ if (flags & E_FLAG_RL78_CPU_MASK)
+ fprintf (file, " [%s]", rl78_cpu_name (flags));
+
+ if (flags & E_FLAG_RL78_64BIT_DOUBLES)
+ fprintf (file, _(" [64-bit doubles]"));
+
fputc ('\n', file);
return TRUE;
}
/* Return the MACH for an e_flags value. */
static int
-elf32_rl78_machine (bfd * abfd)
+elf32_rl78_machine (bfd * abfd ATTRIBUTE_UNUSED)
{
- if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
- return bfd_mach_rl78;
-
- return 0;
+ return bfd_mach_rl78;
}
static bfd_boolean
elf32_rl78_machine (abfd));
return TRUE;
}
- \f
-#ifdef DEBUG
-void
-rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
-{
- size_t locsymcount;
- Elf_Internal_Sym * isymbuf;
- Elf_Internal_Sym * isymend;
- Elf_Internal_Sym * isym;
- Elf_Internal_Shdr * symtab_hdr;
- bfd_boolean free_internal = FALSE, free_external = FALSE;
- char * st_info_str;
- char * st_info_stb_str;
- char * st_other_str;
- char * st_shndx_str;
-
- if (! internal_syms)
- {
- internal_syms = bfd_malloc (1000);
- free_internal = 1;
- }
- if (! external_syms)
- {
- external_syms = bfd_malloc (1000);
- free_external = 1;
- }
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
- if (free_internal)
- isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
- symtab_hdr->sh_info, 0,
- internal_syms, external_syms, NULL);
- else
- isymbuf = internal_syms;
- isymend = isymbuf + locsymcount;
-
- for (isym = isymbuf ; isym < isymend ; isym++)
- {
- switch (ELF_ST_TYPE (isym->st_info))
- {
- case STT_FUNC: st_info_str = "STT_FUNC";
- case STT_SECTION: st_info_str = "STT_SECTION";
- case STT_FILE: st_info_str = "STT_FILE";
- case STT_OBJECT: st_info_str = "STT_OBJECT";
- case STT_TLS: st_info_str = "STT_TLS";
- default: st_info_str = "";
- }
- switch (ELF_ST_BIND (isym->st_info))
- {
- case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
- case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
- default: st_info_stb_str = "";
- }
- switch (ELF_ST_VISIBILITY (isym->st_other))
- {
- case STV_DEFAULT: st_other_str = "STV_DEFAULT";
- case STV_INTERNAL: st_other_str = "STV_INTERNAL";
- case STV_PROTECTED: st_other_str = "STV_PROTECTED";
- default: st_other_str = "";
- }
- switch (isym->st_shndx)
- {
- case SHN_ABS: st_shndx_str = "SHN_ABS";
- case SHN_COMMON: st_shndx_str = "SHN_COMMON";
- case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
- default: st_shndx_str = "";
- }
-
- printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
- "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
- isym,
- (unsigned long) isym->st_value,
- (unsigned long) isym->st_size,
- isym->st_name,
- bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
- isym->st_name),
- isym->st_info, st_info_str, st_info_stb_str,
- isym->st_other, st_other_str,
- isym->st_shndx, st_shndx_str);
- }
- if (free_internal)
- free (internal_syms);
- if (free_external)
- free (external_syms);
-}
-
-char *
-rl78_get_reloc (long reloc)
-{
- if (0 <= reloc && reloc < R_RL78_max)
- return rl78_elf_howto_table[reloc].name;
- return "";
-}
-#endif /* DEBUG */
-
\f
/* support PLT for 16-bit references to 24-bit functions. */
/* We support 16-bit pointers to code above 64k by generating a thunk
below 64k containing a JMP instruction to the final address. */
-
+
static bfd_boolean
rl78_elf_check_relocs
(bfd * abfd,
asection *splt;
bfd *dynobj;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
-
+
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
local_plt_offsets = elf_local_got_offsets (abfd);
struct elf_link_hash_entry *h;
unsigned long r_symndx;
bfd_vma *offset;
-
+
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+ /* PR15323, ref flags aren't set for references in the same
+ object. */
+ h->root.non_ir_ref = 1;
}
-
+
switch (ELF32_R_TYPE (rel->r_info))
{
/* This relocation describes a 16-bit pointer to a function.
elf_hash_table (info)->dynobj = dynobj = abfd;
if (splt == NULL)
{
- splt = bfd_get_section_by_name (dynobj, ".plt");
+ splt = bfd_get_linker_section (dynobj, ".plt");
if (splt == NULL)
{
flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
| SEC_IN_MEMORY | SEC_LINKER_CREATED
| SEC_READONLY | SEC_CODE);
- splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
+ splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
+ flags);
if (splt == NULL
|| ! bfd_set_section_alignment (dynobj, splt, 1))
return FALSE;
break;
}
}
-
+
return TRUE;
}
bfd *dynobj;
asection *splt;
+ if (!elf_hash_table (info)->dynamic_sections_created)
+ return TRUE;
+
/* As an extra sanity check, verify that all plt entries have been
filled in. However, relaxing might have changed the relocs so
that some plt entries don't get filled in, so we have to skip
called before relaxation. */
if (info->relax_trip > 0)
+ return TRUE;
+
+ if ((dynobj = elf_hash_table (info)->dynobj) != NULL
+ && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
{
- if ((dynobj = elf_hash_table (info)->dynobj) != NULL
- && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
+ bfd_byte *contents = splt->contents;
+ unsigned int i, size = splt->size;
+
+ for (i = 0; i < size; i += 4)
{
- bfd_byte *contents = splt->contents;
- unsigned int i, size = splt->size;
- for (i = 0; i < size; i += 4)
- {
- unsigned int x = bfd_get_32 (dynobj, contents + i);
- BFD_ASSERT (x != 0);
- }
+ unsigned int x = bfd_get_32 (dynobj, contents + i);
+ BFD_ASSERT (x != 0);
}
}
bfd *dynobj;
asection *splt;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
dynobj = elf_hash_table (info)->dynobj;
if (dynobj == NULL)
return TRUE;
- splt = bfd_get_section_by_name (dynobj, ".plt");
+ splt = bfd_get_linker_section (dynobj, ".plt");
BFD_ASSERT (splt != NULL);
splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
};
static bfd_boolean
-rl78_relax_plt_check (struct elf_link_hash_entry *h,
- PTR xdata)
+rl78_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
{
struct relax_plt_data *data = (struct relax_plt_data *) xdata;
previously had a plt entry, give it a new entry offset. */
static bfd_boolean
-rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
- PTR xdata)
+rl78_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
{
bfd_vma *entry = (bfd_vma *) xdata;
/* Assume nothing changes. */
*again = FALSE;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
/* We only relax the .plt section at the moment. */
/* Likewise for local symbols, though that's somewhat less convenient
as we have to walk the list of input bfds and swap in symbol data. */
- for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
Elf_Internal_Shdr *symtab_hdr;
elf_link_hash_traverse (elf_hash_table (info),
rl78_relax_plt_realloc, &entry);
- for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
static bfd_boolean
elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
- Elf_Internal_Rela *alignment_rel, int force_snip)
+ Elf_Internal_Rela *alignment_rel, int force_snip)
{
Elf_Internal_Shdr * symtab_hdr;
unsigned int sec_shndx;
toaddr = alignment_rel->r_offset;
irel = elf_section_data (sec)->relocs;
+ if (irel == NULL)
+ {
+ _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
+ irel = elf_section_data (sec)->relocs;
+ }
+
irelend = irel + sec->reloc_count;
/* Actually delete the bytes. */
memset (contents + toaddr - count, 0x03, count);
/* Adjust all the relocs. */
- for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
+ for (; irel && irel < irelend; irel++)
{
/* Get the new reloc address. */
if (irel->r_offset > addr
#define OFFSET_FOR_RELOC(rel, lrel, scale) \
rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
- lrel, abfd, sec, link_info, scale)
+ lrel, abfd, sec, link_info, scale)
static bfd_vma
rl78_offset_for_reloc (bfd * abfd,
- Elf_Internal_Rela * rel,
- Elf_Internal_Shdr * symtab_hdr,
- Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
- Elf_Internal_Sym * intsyms,
- Elf_Internal_Rela ** lrel,
- bfd * input_bfd,
- asection * input_section,
- struct bfd_link_info * info,
- int * scale)
+ Elf_Internal_Rela * rel,
+ Elf_Internal_Shdr * symtab_hdr,
+ Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
+ Elf_Internal_Sym * intsyms,
+ Elf_Internal_Rela ** lrel,
+ bfd * input_bfd,
+ asection * input_section,
+ struct bfd_link_info * info,
+ int * scale)
{
bfd_vma symval;
- bfd_reloc_status_type r;
*scale = 1;
gets a pointer to the last relocation used. */
while (1)
{
- int32_t tmp1, tmp2;
+ unsigned long r_type;
/* Get the value of the symbol referred to by the reloc. */
if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
if (ssec)
{
if ((ssec->flags & SEC_MERGE)
- && ssec->sec_info_type == ELF_INFO_TYPE_MERGE)
+ && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
symval = _bfd_merged_section_offset (abfd, & ssec,
elf_section_data (ssec)->sec_info,
symval);
symval += rel->r_addend;
}
- switch (ELF32_R_TYPE (rel->r_info))
+ r_type = ELF32_R_TYPE (rel->r_info);
+ switch (r_type)
{
case R_RL78_SYM:
- RL78_STACK_PUSH (symval);
+ (void) rl78_compute_complex_reloc (r_type, symval, input_section);
break;
- case R_RL78_OPneg:
- RL78_STACK_POP (tmp1);
- tmp1 = - tmp1;
- RL78_STACK_PUSH (tmp1);
+ case R_RL78_OPromtop:
+ symval = get_romstart (info, input_bfd, input_section, rel->r_offset);
+ (void) rl78_compute_complex_reloc (r_type, symval, input_section);
break;
- case R_RL78_OPadd:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 += tmp2;
- RL78_STACK_PUSH (tmp1);
+ case R_RL78_OPramtop:
+ symval = get_ramstart (info, input_bfd, input_section, rel->r_offset);
+ (void) rl78_compute_complex_reloc (r_type, symval, input_section);
break;
+ case R_RL78_OPneg:
+ case R_RL78_OPadd:
case R_RL78_OPsub:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp2 -= tmp1;
- RL78_STACK_PUSH (tmp2);
- break;
-
case R_RL78_OPmul:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 *= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPdiv:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 /= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPshla:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 <<= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPshra:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 >>= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPsctsize:
- RL78_STACK_PUSH (input_section->size);
- break;
-
case R_RL78_OPscttop:
- RL78_STACK_PUSH (input_section->output_section->vma);
- break;
-
case R_RL78_OPand:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 &= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPor:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 |= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPxor:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 ^= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPnot:
- RL78_STACK_POP (tmp1);
- tmp1 = ~ tmp1;
- RL78_STACK_PUSH (tmp1);
- break;
-
case R_RL78_OPmod:
- RL78_STACK_POP (tmp1);
- RL78_STACK_POP (tmp2);
- tmp1 %= tmp2;
- RL78_STACK_PUSH (tmp1);
- break;
-
- case R_RL78_OPromtop:
- RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
- break;
-
- case R_RL78_OPramtop:
- RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
+ (void) rl78_compute_complex_reloc (r_type, 0, input_section);
break;
case R_RL78_DIR16UL:
case R_RL78_DIR8UL:
case R_RL78_ABS16UL:
case R_RL78_ABS8UL:
- if (rl78_stack_top)
- RL78_STACK_POP (symval);
- if (lrel)
- *lrel = rel;
*scale = 4;
- return symval;
+ goto reloc_computes_value;
case R_RL78_DIR16UW:
case R_RL78_DIR8UW:
case R_RL78_ABS16UW:
case R_RL78_ABS8UW:
- if (rl78_stack_top)
- RL78_STACK_POP (symval);
- if (lrel)
- *lrel = rel;
*scale = 2;
- return symval;
+ goto reloc_computes_value;
default:
- if (rl78_stack_top)
- RL78_STACK_POP (symval);
+ reloc_computes_value:
+ symval = rl78_compute_complex_reloc (r_type, symval, input_section);
+ case R_RL78_DIR32:
+ case R_RL78_DIR24S:
+ case R_RL78_DIR16:
+ case R_RL78_DIR16U:
+ case R_RL78_DIR16S:
+ case R_RL78_DIR24S_PCREL:
+ case R_RL78_DIR16S_PCREL:
+ case R_RL78_DIR8S_PCREL:
if (lrel)
*lrel = rel;
return symval;
{ 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
{ 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
{ 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
-
+
{ -1, -1, -1, -1 }
};
Elf_Internal_Rela * srel;
Elf_Internal_Rela * irelend;
Elf_Internal_Rela * next_alignment;
- Elf_Internal_Rela * prev_alignment;
bfd_byte * contents = NULL;
bfd_byte * free_contents = NULL;
Elf_Internal_Sym * intsyms = NULL;
Elf_Internal_Sym * free_intsyms = NULL;
Elf_External_Sym_Shndx * shndx_buf = NULL;
bfd_vma pc;
- bfd_vma sec_start;
bfd_vma symval ATTRIBUTE_UNUSED = 0;
int pcrel ATTRIBUTE_UNUSED = 0;
int code ATTRIBUTE_UNUSED = 0;
/* 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 (link_info->relocatable
+ 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;
- shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
-
- sec_start = sec->output_section->vma + sec->output_offset;
+ symtab_hdr = & elf_symtab_hdr (abfd);
+ if (elf_symtab_shndx_list (abfd))
+ shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
+ else
+ shndx_hdr = NULL;
/* Get the section contents. */
if (elf_section_data (sec)->this_hdr.contents != NULL)
symtab_hdr->contents = (bfd_byte *) intsyms;
}
- if (shndx_hdr->sh_size != 0)
+ if (shndx_hdr && shndx_hdr->sh_size != 0)
{
bfd_size_type amt;
if (shndx_buf == NULL)
goto error_return;
if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
- || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
+ || bfd_bread (shndx_buf, amt, abfd) != amt)
goto error_return;
shndx_hdr->contents = (bfd_byte *) shndx_buf;
}
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
- (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+ (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
link_info->keep_memory));
if (internal_relocs == NULL)
goto error_return;
/* This will either be NULL or a pointer to the next alignment
relocation. */
next_alignment = internal_relocs;
- /* This will be the previous alignment, although at first it points
- to the first real relocation. */
- prev_alignment = internal_relocs;
/* We calculate worst case shrinkage caused by alignment directives.
No fool-proof, but better than either ignoring the problem or
displacements across an alignment boundary, just in case.
Note that this only affects relocations to the same
section. */
- prev_alignment = next_alignment;
next_alignment += 2;
while (next_alignment < irelend
&& (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
nbytes /= alignment;
nbytes *= alignment;
- elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
- erel->r_offset == sec->size);
+ elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset - nbytes, nbytes,
+ next_alignment, erel->r_offset == sec->size);
*again = TRUE;
continue;
pc = sec->output_section->vma + sec->output_offset
+ srel->r_offset;
-#define GET_RELOC \
- symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
- pcrel = symval - pc + srel->r_addend; \
+#define GET_RELOC \
+ BFD_ASSERT (nrelocs > 0); \
+ symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
+ pcrel = symval - pc + srel->r_addend; \
nrelocs --;
#define SNIPNR(offset, nbytes) \
elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
-#define SNIP(offset, nbytes, newtype) \
- SNIPNR (offset, nbytes); \
+
+#define SNIP(offset, nbytes, newtype) \
+ SNIPNR (offset, nbytes); \
srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
/* The order of these bit tests must match the order that the
61 F3 EF ad SKNH ; BR $rel8
*/
- if (irel->r_addend & RL78_RELAXA_BRA)
+ if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_BRA)
{
- GET_RELOC;
+ /* SKIP opcodes that skip non-branches will have a relax tag
+ but no corresponding symbol to relax against; we just
+ skip those. */
+ if (irel->r_addend & RL78_RELAXA_RNUM)
+ {
+ GET_RELOC;
+ }
switch (insn[0])
{
+ case 0xdc: /* BC */
+ case 0xdd: /* BZ */
+ case 0xde: /* BNC */
+ case 0xdf: /* BNZ */
+ if (insn[1] == 0x03 && insn[2] == 0xee /* BR */
+ && (srel->r_offset - irel->r_offset) > 1) /* a B<c> without its own reloc */
+ {
+ /* This is a "long" conditional as generated by gas:
+ DC 03 EE ad.dr */
+ if (pcrel < 127
+ && pcrel > -127)
+ {
+ insn[0] ^= 0x02; /* invert conditional */
+ SNIPNR (4, 1);
+ SNIP (1, 2, R_RL78_DIR8S_PCREL);
+ insn[1] = pcrel;
+ *again = TRUE;
+ }
+ }
+ break;
+
case 0xec: /* BR !!abs20 */
if (pcrel < 127
insn[0] = 0xed;
insn[1] = symval & 0xff;
insn[2] = symval >> 8;
- SNIP (2, 1, R_RL78_DIR16S);
+ SNIP (2, 1, R_RL78_DIR16U);
*again = TRUE;
}
else if (pcrel < 32767
insn[0] = 0xfd;
insn[1] = symval & 0xff;
insn[2] = symval >> 8;
- SNIP (2, 1, R_RL78_DIR16S);
+ SNIP (2, 1, R_RL78_DIR16U);
*again = TRUE;
}
else if (pcrel < 32767
/* For SKIP/BR, we change the BR opcode and delete the
SKIP. That way, we don't have to find and change the
relocation for the BR. */
+ /* Note that, for the case where we're skipping some
+ other insn, we have no "other" reloc but that's safe
+ here anyway. */
switch (insn[1])
{
+ case 0xd3: /* BNH */
+ case 0xc3: /* BH */
+ if (insn[2] == 0x03 && insn[3] == 0xee
+ && (srel->r_offset - irel->r_offset) > 2) /* a B<c> without its own reloc */
+ {
+ /* Another long branch by gas:
+ 61 D3 03 EE ad.dr */
+ if (pcrel < 127
+ && pcrel > -127)
+ {
+ insn[1] ^= 0x10; /* invert conditional */
+ SNIPNR (5, 1);
+ SNIP (2, 2, R_RL78_DIR8S_PCREL);
+ insn[2] = pcrel;
+ *again = TRUE;
+ }
+ }
+ break;
+
case 0xc8: /* SKC */
if (insn[2] == 0xef)
{
}
break;
}
-
}
- if (irel->r_addend & RL78_RELAXA_ADDR16)
+ if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_ADDR16
+ && nrelocs > 0)
{
/*----------------------------------------------------------------------*/
/* Some insns have both a 16-bit address operand and an 8-bit
GET_RELOC;
- printf("relax_addr16 detected, symval 0x%lx %02x %02x\n", symval, insn[0], insn[1]);
-
if (0xffe20 <= symval && symval <= 0xfffff)
{
{
insn[poff] = relax_addr16[idx].insn_for_sfr;
SNIP (poff+2, 1, R_RL78_RH_SFR);
- printf(" - replaced by SFR\n");
}
else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
{
insn[poff] = relax_addr16[idx].insn_for_saddr;
SNIP (poff+2, 1, R_RL78_RH_SADDR);
- printf(" - replaced by SADDR\n");
}
-
}
}
}
-
/*----------------------------------------------------------------------*/
-
}
return TRUE;
#define ELF_MACHINE_CODE EM_RL78
#define ELF_MAXPAGESIZE 0x1000
-#define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
+#define TARGET_LITTLE_SYM rl78_elf32_vec
#define TARGET_LITTLE_NAME "elf32-rl78"
#define elf_info_to_howto_rel NULL
projects / deliverable / binutils-gdb.git / blobdiff