/* Xtensa-specific support for 32-bit ELF.
- Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ Copyright (C) 2003-2019 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
}
else if (opcode == get_const16_opcode ())
{
- /* ALT used for high 16 bits. */
- newval = relocation >> 16;
+ /* ALT used for high 16 bits.
+ Ignore 32-bit overflow. */
+ newval = (relocation >> 16) & 0xffff;
opnd = 1;
}
else
if (!xtensa_default_isa)
xtensa_default_isa = xtensa_isa_init (0, 0);
- BFD_ASSERT (is_xtensa_elf (input_bfd));
+ if (!is_xtensa_elf (input_bfd))
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return FALSE;
+ }
htab = elf_xtensa_hash_table (info);
if (htab == NULL)
{
struct elf_xtensa_link_hash_table *htab;
bfd *dynobj;
- asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
+ asection *sdyn, *srelplt, *srelgot, *sgot, *sxtlit, *sgotloc;
Elf32_External_Dyn *dyncon, *dynconend;
int num_xtlit_entries = 0;
}
srelplt = htab->elf.srelplt;
+ srelgot = htab->elf.srelgot;
if (srelplt && srelplt->size != 0)
{
- asection *sgotplt, *srelgot, *spltlittbl;
+ asection *sgotplt, *spltlittbl;
int chunk, plt_chunks, plt_entries;
Elf_Internal_Rela irela;
bfd_byte *loc;
unsigned rtld_reloc;
- srelgot = htab->elf.srelgot;
spltlittbl = htab->spltlittbl;
BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
spltlittbl->contents + (chunk * 8) + 4);
}
- /* All the dynamic relocations have been emitted at this point.
- Make sure the relocation sections are the correct size. */
- if (srelgot->size != (sizeof (Elf32_External_Rela)
- * srelgot->reloc_count)
- || srelplt->size != (sizeof (Elf32_External_Rela)
- * srelplt->reloc_count))
- abort ();
-
/* The .xt.lit.plt section has just been modified. This must
happen before the code below which combines adjacent literal
table entries, and the .xt.lit.plt contents have to be forced to
spltlittbl->flags &= ~SEC_HAS_CONTENTS;
}
+ /* All the dynamic relocations have been emitted at this point.
+ Make sure the relocation sections are the correct size. */
+ if ((srelgot && srelgot->size != (sizeof (Elf32_External_Rela)
+ * srelgot->reloc_count))
+ || (srelplt && srelplt->size != (sizeof (Elf32_External_Rela)
+ * srelplt->reloc_count)))
+ abort ();
+
/* Combine adjacent literal table entries. */
BFD_ASSERT (! bfd_link_relocatable (info));
sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
bfd_boolean *is_reachable_p)
{
asection *target_sec;
+ asection *s;
+ bfd_vma first_vma;
+ bfd_vma last_vma;
+ unsigned int first_align;
+ unsigned int adjust;
bfd_vma target_offset;
r_reloc r_rel;
xtensa_opcode opcode, direct_call_opcode;
+ target_sec->output_offset + target_offset);
}
+ /* Adjust addresses with alignments for the worst case to see if call insn
+ can fit. Don't relax l32r + callx to call if the target can be out of
+ range due to alignment.
+ Caller and target addresses are highest and lowest address.
+ Search all sections between caller and target, looking for max alignment.
+ The adjustment is max alignment bytes. If the alignment at the lowest
+ address is less than the adjustment, apply the adjustment to highest
+ address. */
+
+ /* Start from lowest address.
+ Lowest address aligmnet is from input section.
+ Initial alignment (adjust) is from input section. */
+ if (dest_address > self_address)
+ {
+ s = sec->output_section;
+ last_vma = dest_address;
+ first_align = sec->alignment_power;
+ adjust = target_sec->alignment_power;
+ }
+ else
+ {
+ s = target_sec->output_section;
+ last_vma = self_address;
+ first_align = target_sec->alignment_power;
+ adjust = sec->alignment_power;
+ }
+
+ first_vma = s->vma;
+
+ /* Find the largest alignment in output section list. */
+ for (; s && s->vma >= first_vma && s->vma <= last_vma ; s = s->next)
+ {
+ if (s->alignment_power > adjust)
+ adjust = s->alignment_power;
+ }
+
+ if (adjust > first_align)
+ {
+ /* Alignment may enlarge the range, adjust highest address. */
+ adjust = 1 << adjust;
+ if (dest_address > self_address)
+ {
+ dest_address += adjust;
+ }
+ else
+ {
+ self_address += adjust;
+ }
+ }
+
*is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
self_address, dest_address);