}
}
+// For x32, we need to handle PC-relative relocations using full 64-bit
+// arithmetic, so that we can detect relocation overflows properly.
+// This class overrides the pcrela32_check methods from the defaults in
+// Relocate_functions in reloc.h.
+
+template<int size>
+class X86_64_relocate_functions : public Relocate_functions<size, false>
+{
+ public:
+ typedef Relocate_functions<size, false> Base;
+
+ // Do a simple PC relative relocation with the addend in the
+ // relocation.
+ static inline typename Base::Reloc_status
+ pcrela32_check(unsigned char* view,
+ typename elfcpp::Elf_types<64>::Elf_Addr value,
+ typename elfcpp::Elf_types<64>::Elf_Swxword addend,
+ typename elfcpp::Elf_types<64>::Elf_Addr address)
+ {
+ typedef typename elfcpp::Swap<32, false>::Valtype Valtype;
+ Valtype* wv = reinterpret_cast<Valtype*>(view);
+ value = value + addend - address;
+ elfcpp::Swap<32, false>::writeval(wv, value);
+ return (Bits<32>::has_overflow(value)
+ ? Base::RELOC_OVERFLOW : Base::RELOC_OK);
+ }
+
+ // Do a simple PC relative relocation with a Symbol_value with the
+ // addend in the relocation.
+ static inline typename Base::Reloc_status
+ pcrela32_check(unsigned char* view,
+ const Sized_relobj_file<size, false>* object,
+ const Symbol_value<size>* psymval,
+ typename elfcpp::Elf_types<64>::Elf_Swxword addend,
+ typename elfcpp::Elf_types<64>::Elf_Addr address)
+ {
+ typedef typename elfcpp::Swap<32, false>::Valtype Valtype;
+ Valtype* wv = reinterpret_cast<Valtype*>(view);
+ typename elfcpp::Elf_types<64>::Elf_Addr value;
+ if (addend >= 0)
+ value = psymval->value(object, addend);
+ else
+ {
+ // For negative addends, get the symbol value without
+ // the addend, then add the addend using 64-bit arithmetic.
+ value = psymval->value(object, 0);
+ value += addend;
+ }
+ value -= address;
+ elfcpp::Swap<32, false>::writeval(wv, value);
+ return (Bits<32>::has_overflow(value)
+ ? Base::RELOC_OVERFLOW : Base::RELOC_OK);
+ }
+};
+
// Perform a relocation.
template<int size>
typename elfcpp::Elf_types<size>::Elf_Addr address,
section_size_type view_size)
{
+ typedef X86_64_relocate_functions<size> Reloc_funcs;
const elfcpp::Rela<size, false> rela(preloc);
unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info());
break;
}
+ typename Reloc_funcs::Reloc_status rstatus = Reloc_funcs::RELOC_OK;
+
switch (r_type)
{
case elfcpp::R_X86_64_NONE:
break;
case elfcpp::R_X86_64_64:
- Relocate_functions<size, false>::rela64(view, object, psymval, addend);
+ Reloc_funcs::rela64(view, object, psymval, addend);
break;
case elfcpp::R_X86_64_PC64:
- Relocate_functions<size, false>::pcrela64(view, object, psymval, addend,
+ Reloc_funcs::pcrela64(view, object, psymval, addend,
address);
break;
case elfcpp::R_X86_64_32:
- // FIXME: we need to verify that value + addend fits into 32 bits:
- // uint64_t x = value + addend;
- // x == static_cast<uint64_t>(static_cast<uint32_t>(x))
- // Likewise for other <=32-bit relocations (but see R_X86_64_32S).
- Relocate_functions<size, false>::rela32(view, object, psymval, addend);
+ rstatus = Reloc_funcs::rela32_check(view, object, psymval, addend,
+ Reloc_funcs::CHECK_UNSIGNED);
break;
case elfcpp::R_X86_64_32S:
- // FIXME: we need to verify that value + addend fits into 32 bits:
- // int64_t x = value + addend; // note this quantity is signed!
- // x == static_cast<int64_t>(static_cast<int32_t>(x))
- Relocate_functions<size, false>::rela32(view, object, psymval, addend);
+ rstatus = Reloc_funcs::rela32_check(view, object, psymval, addend,
+ Reloc_funcs::CHECK_SIGNED);
break;
case elfcpp::R_X86_64_PC32:
case elfcpp::R_X86_64_PC32_BND:
- Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
- address);
+ rstatus = Reloc_funcs::pcrela32_check(view, object, psymval, addend,
+ address);
break;
case elfcpp::R_X86_64_16:
- Relocate_functions<size, false>::rela16(view, object, psymval, addend);
+ Reloc_funcs::rela16(view, object, psymval, addend);
break;
case elfcpp::R_X86_64_PC16:
- Relocate_functions<size, false>::pcrela16(view, object, psymval, addend,
- address);
+ Reloc_funcs::pcrela16(view, object, psymval, addend, address);
break;
case elfcpp::R_X86_64_8:
- Relocate_functions<size, false>::rela8(view, object, psymval, addend);
+ Reloc_funcs::rela8(view, object, psymval, addend);
break;
case elfcpp::R_X86_64_PC8:
- Relocate_functions<size, false>::pcrela8(view, object, psymval, addend,
- address);
+ Reloc_funcs::pcrela8(view, object, psymval, addend, address);
break;
case elfcpp::R_X86_64_PLT32:
// Note: while this code looks the same as for R_X86_64_PC32, it
// behaves differently because psymval was set to point to
// the PLT entry, rather than the symbol, in Scan::global().
- Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
- address);
+ rstatus = Reloc_funcs::pcrela32_check(view, object, psymval, addend,
+ address);
break;
case elfcpp::R_X86_64_PLTOFF64:
typename elfcpp::Elf_types<size>::Elf_Addr got_address;
// This is the address of GLOBAL_OFFSET_TABLE.
got_address = target->got_plt_section()->address();
- Relocate_functions<size, false>::rela64(view, object, psymval,
- addend - got_address);
+ Reloc_funcs::rela64(view, object, psymval, addend - got_address);
}
break;
case elfcpp::R_X86_64_GOT32:
gold_assert(have_got_offset);
- Relocate_functions<size, false>::rela32(view, got_offset, addend);
+ Reloc_funcs::rela32(view, got_offset, addend);
break;
case elfcpp::R_X86_64_GOTPC32:
gold_assert(gsym);
typename elfcpp::Elf_types<size>::Elf_Addr value;
value = target->got_plt_section()->address();
- Relocate_functions<size, false>::pcrela32(view, value, addend, address);
+ Reloc_funcs::pcrela32_check(view, value, addend, address);
}
break;
// R_X86_64_GOTPLT64 is obsolete and treated the the same as
// GOT64.
gold_assert(have_got_offset);
- Relocate_functions<size, false>::rela64(view, got_offset, addend);
+ Reloc_funcs::rela64(view, got_offset, addend);
break;
case elfcpp::R_X86_64_GOTPC64:
gold_assert(gsym);
typename elfcpp::Elf_types<size>::Elf_Addr value;
value = target->got_plt_section()->address();
- Relocate_functions<size, false>::pcrela64(view, value, addend, address);
+ Reloc_funcs::pcrela64(view, value, addend, address);
}
break;
typename elfcpp::Elf_types<size>::Elf_Addr value;
value = (psymval->value(object, 0)
- target->got_plt_section()->address());
- Relocate_functions<size, false>::rela64(view, value, addend);
+ Reloc_funcs::rela64(view, value, addend);
}
break;
&& Target_x86_64<size>::can_convert_mov_to_lea(gsym))))
{
view[-2] = 0x8d;
- Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
- address);
+ Reloc_funcs::pcrela32(view, object, psymval, addend, address);
}
else
{
}
typename elfcpp::Elf_types<size>::Elf_Addr value;
value = target->got_plt_section()->address() + got_offset;
- Relocate_functions<size, false>::pcrela32(view, value, addend, address);
+ Reloc_funcs::pcrela32_check(view, value, addend, address);
}
}
break;
gold_assert(have_got_offset);
typename elfcpp::Elf_types<size>::Elf_Addr value;
value = target->got_plt_section()->address() + got_offset;
- Relocate_functions<size, false>::pcrela64(view, value, addend, address);
+ Reloc_funcs::pcrela64(view, value, addend, address);
}
break;
break;
}
+ if (rstatus == Reloc_funcs::RELOC_OVERFLOW)
+ {
+ if (gsym == NULL)
+ {
+ unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
+ gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
+ _("relocation overflow: "
+ "reference to local symbol %u in %s"),
+ r_sym, object->name().c_str());
+ }
+ else if (gsym->is_defined() && gsym->source() == Symbol::FROM_OBJECT)
+ {
+ gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
+ _("relocation overflow: "
+ "reference to '%s' defined in %s"),
+ gsym->name(),
+ gsym->object()->name().c_str());
+ }
+ else
+ {
+ gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
+ _("relocation overflow: reference to '%s'"),
+ gsym->name());
+ }
+ }
+
return true;
}
projects / deliverable / binutils-gdb.git / blobdiff