Overhaul relocation framework to support overflow checking. Overflow checking is best done while applying the relocations, rather than after the fact, to avoid double-computation of the relocation. In the style of the aarch64 and powerpc targets, this patch moves the overflow checking into the common relocation functions in reloc.h, and adds missing has_unsigned_overflow functions to the Bits class. This is a framework change only; its purpose is to enable subsequent patches that will update the x86_64 and potentially other targets to make use of the new _check routines. 2016-02-06 Cary Coutant gold/ PR gold/18695 * reloc.h (Relocate_functions::Address): New typedef. (Relocate_functions::Addendtype): New typedef. (Relocate_functions::Overflow_check): New enum type. (Relocate_functions::Reloc_status): New enum type. (Relocate_functions::check_overflow): New function template. (Relocate_functions::rel): Add check parameter; check for overflow. (Relocate_functions::rel_unaligned): Likewise. (Relocate_functions::rela): Likewise. (Relocate_functions::pcrel): Likewise. (Relocate_functions::pcrel_unaligned): Likewise. (Relocate_functions::pcrela): Likewise. (Relocate_functions::rel8): Adjust parameter types. (Relocate_functions::rela8): Likewise. (Relocate_functions::pcrel8): Likewise. (Relocate_functions::pcrela8): Likewise. (Relocate_functions::rel16): Likewise. (Relocate_functions::rela168): Likewise. (Relocate_functions::pcrel16): Likewise. (Relocate_functions::pcrela16): Likewise. (Relocate_functions::rel32): Likewise. (Relocate_functions::rel32_unaligned): Likewise. (Relocate_functions::rela32): Likewise. (Relocate_functions::pcrel32): Likewise. (Relocate_functions::pcrel32_unaligned): Likewise. (Relocate_functions::pcrela32): Likewise. (Relocate_functions::rel8_check): New function. (Relocate_functions::rela8_check): New function. (Relocate_functions::pcrel8_check): New function. (Relocate_functions::pcrela8_check): New function. (Relocate_functions::rel16_check): New function. (Relocate_functions::rela168_check): New function. (Relocate_functions::pcrel16_check): New function. (Relocate_functions::pcrela16_check): New function. (Relocate_functions::rel32_check): New function. (Relocate_functions::rel32_unaligned_check): New function. (Relocate_functions::rela32_check): New function. (Relocate_functions::pcrel32_check): New function. (Relocate_functions::pcrel32_unaligned_check): New function. (Relocate_functions::pcrela32_check): New function. (Bits::has_unsigned_overflow32): New function. (Bits::has_unsigned_overflow): New function. * testsuite/Makefile.am (overflow_unittest): New test. * testsuite/Makefile.in: Regenerate. * testsuite/overflow_unittest.cc: New source file. diff --git a/gold/reloc.h b/gold/reloc.h index 5a72f27..4f1e753 100644 --- a/gold/reloc.h +++ b/gold/reloc.h @@ -321,406 +321,652 @@ class Relocatable_relocs Output_data* posd_; }; +template +class Bits; + // Standard relocation routines which are used on many targets. Here // SIZE and BIG_ENDIAN refer to the target, not the relocation type. template class Relocate_functions { -private: + public: + typedef typename elfcpp::Elf_types::Elf_Addr Address; + typedef typename elfcpp::Elf_types::Elf_Swxword Addendtype; + + enum Overflow_check + { + CHECK_NONE, + CHECK_SIGNED, + CHECK_UNSIGNED, + CHECK_SIGNED_OR_UNSIGNED + }; + + enum Reloc_status + { + RELOC_OK, + RELOC_OVERFLOW + }; + + private: + // Check for overflow. + template + static inline Reloc_status + check_overflow(Address value, Overflow_check check) + { + switch (check) + { + case CHECK_SIGNED: + if (size == 32) + return (Bits::has_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_UNSIGNED: + if (size == 32) + return (Bits::has_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_unsigned_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_SIGNED_OR_UNSIGNED: + if (size == 32) + return (Bits::has_signed_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits::has_signed_unsigned_overflow64(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_NONE: + default: + return RELOC_OK; + } + } + // Do a simple relocation with the addend in the section contents. // VALSIZE is the size of the value. template - static inline void - rel(unsigned char* view, - typename elfcpp::Swap::Valtype value) + static inline Reloc_status + rel(unsigned char* view, Address value, Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - elfcpp::Swap::writeval(wv, x + value); + Valtype addend = elfcpp::Swap::readval(wv); + value += addend; + elfcpp::Swap:: + writeval(wv, static_cast(value)); + return check_overflow(value, check); } // Like the above but for relocs at unaligned addresses. template - static inline void - rel_unaligned(unsigned char* view, - typename elfcpp::Swap::Valtype value) + static inline Reloc_status + rel_unaligned(unsigned char* view, Address value, Overflow_check check) { typedef typename elfcpp::Swap_unaligned::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned::readval(view); - elfcpp::Swap_unaligned::writeval(view, x + value); + Valtype addend = elfcpp::Swap_unaligned::readval(view); + value += addend; + elfcpp::Swap_unaligned:: + writeval(view, static_cast(value)); + return check_overflow(value, check); } // Do a simple relocation using a Symbol_value with the addend in // the section contents. VALSIZE is the size of the value to // relocate. template - static inline void + static inline Reloc_status rel(unsigned char* view, const Sized_relobj_file* object, - const Symbol_value* psymval) + const Symbol_value* psymval, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap::writeval(wv, x); + Valtype addend = elfcpp::Swap::readval(wv); + Address value = psymval->value(object, addend); + elfcpp::Swap:: + writeval(wv, static_cast(value)); + return check_overflow(value, check); } // Like the above but for relocs at unaligned addresses. template - static inline void + static inline Reloc_status rel_unaligned(unsigned char* view, const Sized_relobj_file* object, - const Symbol_value* psymval) + const Symbol_value* psymval, + Overflow_check check) { typedef typename elfcpp::Swap_unaligned::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned::readval(view); - x = psymval->value(object, x); - elfcpp::Swap_unaligned::writeval(view, x); + Valtype addend = elfcpp::Swap_unaligned::readval(view); + Address value = psymval->value(object, addend); + elfcpp::Swap_unaligned::writeval(view, value); + return check_overflow(value, check); } // Do a simple relocation with the addend in the relocation. // VALSIZE is the size of the value. template - static inline void - rela(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Swap::Valtype addend) + static inline Reloc_status + rela(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - elfcpp::Swap::writeval(wv, value + addend); + value += addend; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple relocation using a symbol value with the addend in // the relocation. VALSIZE is the size of the value. template - static inline void + static inline Reloc_status rela(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Swap::Valtype addend) + Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap::writeval(wv, x); + Address value = psymval->value(object, addend); + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with the addend in the section // contents. VALSIZE is the size of the value. template - static inline void - pcrel(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Elf_types::Elf_Addr address) + static inline Reloc_status + pcrel(unsigned char* view, Address value, Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - elfcpp::Swap::writeval(wv, x + value - address); + Valtype addend = elfcpp::Swap::readval(wv); + value = value + addend - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Like the above but for relocs at unaligned addresses. template - static inline void - pcrel_unaligned(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Elf_types::Elf_Addr address) + static inline Reloc_status + pcrel_unaligned(unsigned char* view, Address value, Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned::readval(view); - elfcpp::Swap_unaligned::writeval(view, - x + value - address); + Valtype addend = elfcpp::Swap_unaligned::readval(view); + value = value + addend - address; + elfcpp::Swap_unaligned::writeval(view, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with a Symbol_value with the // addend in the section contents. VALSIZE is the size of the // value. template - static inline void + static inline Reloc_status pcrel(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) + Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = elfcpp::Swap::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap::writeval(wv, x - address); + Valtype addend = elfcpp::Swap::readval(wv); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with the addend in the // relocation. VALSIZE is the size of the value. template - static inline void - pcrela(unsigned char* view, - typename elfcpp::Swap::Valtype value, - typename elfcpp::Swap::Valtype addend, - typename elfcpp::Elf_types::Elf_Addr address) + static inline Reloc_status + pcrela(unsigned char* view, Address value, Addendtype addend, Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - elfcpp::Swap::writeval(wv, value + addend - address); + value = value + addend - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } // Do a simple PC relative relocation with a Symbol_value with the // addend in the relocation. VALSIZE is the size of the value. template - static inline void + static inline Reloc_status pcrela(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Swap::Valtype addend, - typename elfcpp::Elf_types::Elf_Addr address) + Addendtype addend, + Address address, + Overflow_check check) { typedef typename elfcpp::Swap::Valtype Valtype; Valtype* wv = reinterpret_cast(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap::writeval(wv, x - address); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap::writeval(wv, value); + return check_overflow(value, check); } typedef Relocate_functions This; -public: + public: // Do a simple 8-bit REL relocation with the addend in the section // contents. static inline void - rel8(unsigned char* view, unsigned char value) - { This::template rel<8>(view, value); } + rel8(unsigned char* view, Address value) + { This::template rel<8>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel8_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<8>(view, value, check); } static inline void rel8(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval) - { This::template rel<8>(view, object, psymval); } + { This::template rel<8>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<8>(view, object, psymval, check); } // Do an 8-bit RELA relocation with the addend in the relocation. static inline void - rela8(unsigned char* view, unsigned char value, unsigned char addend) - { This::template rela<8>(view, value, addend); } + rela8(unsigned char* view, Address value, Addendtype addend) + { This::template rela<8>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela8_check(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<8>(view, value, addend, check); } static inline void rela8(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - unsigned char addend) - { This::template rela<8>(view, object, psymval, addend); } + Addendtype addend) + { This::template rela<8>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<8>(view, object, psymval, addend, check); } // Do a simple 8-bit PC relative relocation with the addend in the // section contents. static inline void - pcrel8(unsigned char* view, unsigned char value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<8>(view, value, address); } + pcrel8(unsigned char* view, unsigned char value, Address address) + { This::template pcrel<8>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel8_check(unsigned char* view, unsigned char value, Address address, + Overflow_check check) + { return This::template pcrel<8>(view, value, address, check); } static inline void pcrel8(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<8>(view, object, psymval, address); } + Address address) + { This::template pcrel<8>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<8>(view, object, psymval, address, check); } // Do a simple 8-bit PC relative RELA relocation with the addend in // the reloc. static inline void - pcrela8(unsigned char* view, unsigned char value, unsigned char addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<8>(view, value, addend, address); } + pcrela8(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<8>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela8_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<8>(view, value, addend, address, check); } static inline void pcrela8(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - unsigned char addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<8>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<8>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela8_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<8>(view, object, psymval, addend, address, + check); } // Do a simple 16-bit REL relocation with the addend in the section // contents. static inline void - rel16(unsigned char* view, elfcpp::Elf_Half value) - { This::template rel<16>(view, value); } + rel16(unsigned char* view, Address value) + { This::template rel<16>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel16_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<16>(view, value, check); } static inline void rel16(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval) - { This::template rel<16>(view, object, psymval); } + { This::template rel<16>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<16>(view, object, psymval, check); } // Do an 16-bit RELA relocation with the addend in the relocation. static inline void - rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend) - { This::template rela<16>(view, value, addend); } + rela16(unsigned char* view, Address value, Addendtype addend) + { This::template rela<16>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela16_check(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<16>(view, value, addend, check); } static inline void rela16(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Half addend) - { This::template rela<16>(view, object, psymval, addend); } + Addendtype addend) + { This::template rela<16>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<16>(view, object, psymval, addend, check); } // Do a simple 16-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel16(unsigned char* view, elfcpp::Elf_Half value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<16>(view, value, address); } + pcrel16(unsigned char* view, Address value, Address address) + { This::template pcrel<16>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel16_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel<16>(view, value, address, check); } static inline void pcrel16(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<16>(view, object, psymval, address); } + Address address) + { This::template pcrel<16>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<16>(view, object, psymval, address, check); } // Do a simple 16-bit PC relative RELA relocation with the addend in // the reloc. static inline void - pcrela16(unsigned char* view, elfcpp::Elf_Half value, - elfcpp::Elf_Half addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<16>(view, value, addend, address); } + pcrela16(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<16>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela16_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<16>(view, value, addend, address, check); } static inline void pcrela16(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Half addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<16>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<16>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela16_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<16>(view, object, psymval, addend, address, + check); } // Do a simple 32-bit REL relocation with the addend in the section // contents. static inline void - rel32(unsigned char* view, elfcpp::Elf_Word value) - { This::template rel<32>(view, value); } + rel32(unsigned char* view, Address value) + { This::template rel<32>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel32_check(unsigned char* view, Address value, Overflow_check check) + { return This::template rel<32>(view, value, check); } // Like above but for relocs at unaligned addresses. static inline void - rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value) - { This::template rel_unaligned<32>(view, value); } + rel32_unaligned(unsigned char* view, Address value) + { This::template rel_unaligned<32>(view, value, CHECK_NONE); } + + static inline Reloc_status + rel32_unaligned_check(unsigned char* view, Address value, + Overflow_check check) + { return This::template rel_unaligned<32>(view, value, check); } static inline void rel32(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval) - { This::template rel<32>(view, object, psymval); } + { This::template rel<32>(view, object, psymval, CHECK_NONE); } + + static inline Reloc_status + rel32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel<32>(view, object, psymval, check); } // Like above but for relocs at unaligned addresses. static inline void rel32_unaligned(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval) - { This::template rel_unaligned<32>(view, object, psymval); } + { This::template rel_unaligned<32>(view, object, psymval, CHECK_NONE); } - // Do an 32-bit RELA relocation with the addend in the relocation. + static inline Reloc_status + rel32_unaligned_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Overflow_check check) + { return This::template rel_unaligned<32>(view, object, psymval, check); } + + // Do a 32-bit RELA relocation with the addend in the relocation. static inline void - rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend) - { This::template rela<32>(view, value, addend); } + rela32(unsigned char* view, Address value, Addendtype addend) + { This::template rela<32>(view, value, addend, CHECK_NONE); } + + static inline Reloc_status + rela32(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) + { return This::template rela<32>(view, value, addend, check); } static inline void rela32(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Word addend) - { This::template rela<32>(view, object, psymval, addend); } + Addendtype addend) + { This::template rela<32>(view, object, psymval, addend, CHECK_NONE); } + + static inline Reloc_status + rela32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Overflow_check check) + { return This::template rela<32>(view, object, psymval, addend, check); } // Do a simple 32-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel32(unsigned char* view, elfcpp::Elf_Word value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<32>(view, value, address); } + pcrel32(unsigned char* view, Address value, Address address) + { This::template pcrel<32>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel<32>(view, value, address, check); } // Unaligned version of the above. static inline void - pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel_unaligned<32>(view, value, address); } + pcrel32_unaligned(unsigned char* view, Address value, Address address) + { This::template pcrel_unaligned<32>(view, value, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_unaligned_check(unsigned char* view, Address value, Address address, + Overflow_check check) + { return This::template pcrel_unaligned<32>(view, value, address, check); } static inline void pcrel32(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<32>(view, object, psymval, address); } + Address address) + { This::template pcrel<32>(view, object, psymval, address, CHECK_NONE); } + + static inline Reloc_status + pcrel32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Address address, + Overflow_check check) + { return This::template pcrel<32>(view, object, psymval, address, check); } // Do a simple 32-bit PC relative RELA relocation with the addend in // the relocation. static inline void - pcrela32(unsigned char* view, elfcpp::Elf_Word value, - elfcpp::Elf_Word addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<32>(view, value, addend, address); } + pcrela32(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<32>(view, value, addend, address, CHECK_NONE); } + + static inline Reloc_status + pcrela32_check(unsigned char* view, Address value, Addendtype addend, + Address address, Overflow_check check) + { return This::template pcrela<32>(view, value, addend, address, check); } static inline void pcrela32(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Word addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<32>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<32>(view, object, psymval, addend, address, + CHECK_NONE); } + + static inline Reloc_status + pcrela32_check(unsigned char* view, + const Sized_relobj_file* object, + const Symbol_value* psymval, + Addendtype addend, + Address address, + Overflow_check check) + { return This::template pcrela<32>(view, object, psymval, addend, address, + check); } // Do a simple 64-bit REL relocation with the addend in the section // contents. static inline void - rel64(unsigned char* view, elfcpp::Elf_Xword value) - { This::template rel<64>(view, value); } + rel64(unsigned char* view, Address value) + { This::template rel<64>(view, value, CHECK_NONE); } static inline void rel64(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval) - { This::template rel<64>(view, object, psymval); } + { This::template rel<64>(view, object, psymval, CHECK_NONE); } // Do a 64-bit RELA relocation with the addend in the relocation. static inline void - rela64(unsigned char* view, elfcpp::Elf_Xword value, - elfcpp::Elf_Xword addend) - { This::template rela<64>(view, value, addend); } + rela64(unsigned char* view, Address value, Addendtype addend) + { This::template rela<64>(view, value, addend, CHECK_NONE); } static inline void rela64(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Xword addend) - { This::template rela<64>(view, object, psymval, addend); } + Addendtype addend) + { This::template rela<64>(view, object, psymval, addend, CHECK_NONE); } // Do a simple 64-bit PC relative REL relocation with the addend in // the section contents. static inline void - pcrel64(unsigned char* view, elfcpp::Elf_Xword value, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<64>(view, value, address); } + pcrel64(unsigned char* view, Address value, Address address) + { This::template pcrel<64>(view, value, address, CHECK_NONE); } static inline void pcrel64(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrel<64>(view, object, psymval, address); } + Address address) + { This::template pcrel<64>(view, object, psymval, address, CHECK_NONE); } // Do a simple 64-bit PC relative RELA relocation with the addend in // the relocation. static inline void - pcrela64(unsigned char* view, elfcpp::Elf_Xword value, - elfcpp::Elf_Xword addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<64>(view, value, addend, address); } + pcrela64(unsigned char* view, Address value, Addendtype addend, + Address address) + { This::template pcrela<64>(view, value, addend, address, CHECK_NONE); } static inline void pcrela64(unsigned char* view, const Sized_relobj_file* object, const Symbol_value* psymval, - elfcpp::Elf_Xword addend, - typename elfcpp::Elf_types::Elf_Addr address) - { This::template pcrela<64>(view, object, psymval, addend, address); } + Addendtype addend, + Address address) + { This::template pcrela<64>(view, object, psymval, addend, address, + CHECK_NONE); } }; // Integer manipulation functions used by various targets when @@ -761,6 +1007,18 @@ class Bits return as_signed > max || as_signed < min; } + // Return true if VAL (stored in a uint32_t) has overflowed an unsigned + // value with BITS bits. + static inline bool + has_unsigned_overflow32(uint32_t val) + { + gold_assert(bits > 0 && bits <= 32); + if (bits == 32) + return false; + int32_t max = static_cast((1U << bits) - 1); + return val > max; + } + // Return true if VAL (stored in a uint32_t) has overflowed both a // signed and an unsigned value. E.g., // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL < @@ -815,6 +1073,18 @@ class Bits return as_signed > max || as_signed < min; } + // Return true if VAL (stored in a uint64_t) has overflowed an unsigned + // value with BITS bits. + static inline bool + has_unsigned_overflow(uint64_t val) + { + gold_assert(bits > 0 && bits <= 64); + if (bits == 64) + return false; + int64_t max = static_cast((static_cast(1) << bits) - 1); + return val > max; + } + // Return true if VAL (stored in a uint64_t) has overflowed both a // signed and an unsigned value. E.g., // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL < diff --git a/gold/testsuite/Makefile.am b/gold/testsuite/Makefile.am index c8e5f9f..96d2b19 100644 --- a/gold/testsuite/Makefile.am +++ b/gold/testsuite/Makefile.am @@ -138,6 +138,11 @@ binary_unittest_SOURCES = binary_unittest.cc check_PROGRAMS += leb128_unittest leb128_unittest_SOURCES = leb128_unittest.cc +check_PROGRAMS += overflow_unittest +overflow_unittest_SOURCES = overflow_unittest.cc +overflow_unittest.o: overflow_unittest.cc + $(CXXCOMPILE) -O3 -c -o $@ $< + endif NATIVE_OR_CROSS_LINKER # --------------------------------------------------------------------- diff --git a/gold/testsuite/overflow_unittest.cc b/gold/testsuite/overflow_unittest.cc new file mode 100644 index 0000000..e33e012 --- /dev/null +++ b/gold/testsuite/overflow_unittest.cc @@ -0,0 +1,139 @@ +// overflow_unittest.cc -- test functions that check for overflow. + +// Copyright (C) 2016 Free Software Foundation, Inc. +// Written by Cary Coutant . + +// This file is part of gold. + +// 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 "gold.h" +#include "reloc.h" + +#include + +#include "test.h" + +namespace gold_testsuite +{ + +using namespace gold; + +bool +Overflow_test(Test_report*) +{ + CHECK(! Bits<16>::has_unsigned_overflow(0ULL)); + CHECK(! Bits<16>::has_unsigned_overflow(1ULL)); + CHECK(! Bits<16>::has_unsigned_overflow(0x7fffULL)); + CHECK(! Bits<16>::has_unsigned_overflow(0x8000ULL)); + CHECK(! Bits<16>::has_unsigned_overflow(0x8001ULL)); + CHECK(! Bits<16>::has_unsigned_overflow(0xffffULL)); + CHECK(Bits<16>::has_unsigned_overflow(0x10000ULL)); + CHECK(Bits<16>::has_unsigned_overflow(0x10001ULL)); + CHECK(Bits<16>::has_unsigned_overflow(~0ULL)); + CHECK(Bits<16>::has_unsigned_overflow(~0x7fffULL + 1)); + CHECK(Bits<16>::has_unsigned_overflow(~0x8000ULL + 1)); + CHECK(Bits<16>::has_unsigned_overflow(~0x8001ULL + 1)); + CHECK(Bits<16>::has_unsigned_overflow(~0xffffULL + 1)); + CHECK(Bits<16>::has_unsigned_overflow(~0x10000ULL + 1)); + CHECK(Bits<16>::has_unsigned_overflow(~0x10001ULL + 1)); + + CHECK(! Bits<16>::has_overflow(0ULL)); + CHECK(! Bits<16>::has_overflow(1ULL)); + CHECK(! Bits<16>::has_overflow(0x7fffULL)); + CHECK(Bits<16>::has_overflow(0x8000ULL)); + CHECK(Bits<16>::has_overflow(0x8001ULL)); + CHECK(Bits<16>::has_overflow(0xffffULL)); + CHECK(Bits<16>::has_overflow(0x10000ULL)); + CHECK(Bits<16>::has_overflow(0x10001ULL)); + CHECK(! Bits<16>::has_overflow(~0ULL)); + CHECK(! Bits<16>::has_overflow(~0x7fffULL + 1)); + CHECK(! Bits<16>::has_overflow(~0x8000ULL + 1)); + CHECK(Bits<16>::has_overflow(~0x8001ULL + 1)); + CHECK(Bits<16>::has_overflow(~0xffffULL + 1)); + CHECK(Bits<16>::has_overflow(~0x10000ULL + 1)); + CHECK(Bits<16>::has_overflow(~0x10001ULL + 1)); + + CHECK(! Bits<16>::has_signed_unsigned_overflow64(0ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(1ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(0x7fffULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(0x8000ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(0x8001ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(0xffffULL)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(0x10000ULL)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(0x10001ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(~0ULL)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(~0x7fffULL + 1)); + CHECK(! Bits<16>::has_signed_unsigned_overflow64(~0x8000ULL + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(~0x8001ULL + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(~0xffffULL + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(~0x10000ULL + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow64(~0x10001ULL + 1)); + + CHECK(! Bits<16>::has_unsigned_overflow32(0U)); + CHECK(! Bits<16>::has_unsigned_overflow32(1U)); + CHECK(! Bits<16>::has_unsigned_overflow32(0x7fffU)); + CHECK(! Bits<16>::has_unsigned_overflow32(0x8000U)); + CHECK(! Bits<16>::has_unsigned_overflow32(0x8001U)); + CHECK(! Bits<16>::has_unsigned_overflow32(0xffffU)); + CHECK(Bits<16>::has_unsigned_overflow32(0x10000U)); + CHECK(Bits<16>::has_unsigned_overflow32(0x10001U)); + CHECK(Bits<16>::has_unsigned_overflow32(~0U)); + CHECK(Bits<16>::has_unsigned_overflow32(~0x7fffU + 1)); + CHECK(Bits<16>::has_unsigned_overflow32(~0x8000U + 1)); + CHECK(Bits<16>::has_unsigned_overflow32(~0x8001U + 1)); + CHECK(Bits<16>::has_unsigned_overflow32(~0xffffU + 1)); + CHECK(Bits<16>::has_unsigned_overflow32(~0x10000U + 1)); + CHECK(Bits<16>::has_unsigned_overflow32(~0x10001U + 1)); + + CHECK(! Bits<16>::has_overflow32(0U)); + CHECK(! Bits<16>::has_overflow32(1U)); + CHECK(! Bits<16>::has_overflow32(0x7fffU)); + CHECK(Bits<16>::has_overflow32(0x8000U)); + CHECK(Bits<16>::has_overflow32(0x8001U)); + CHECK(Bits<16>::has_overflow32(0xffffU)); + CHECK(Bits<16>::has_overflow32(0x10000U)); + CHECK(Bits<16>::has_overflow32(0x10001U)); + CHECK(! Bits<16>::has_overflow32(~0U)); + CHECK(! Bits<16>::has_overflow32(~0x7fffU + 1)); + CHECK(! Bits<16>::has_overflow32(~0x8000U + 1)); + CHECK(Bits<16>::has_overflow32(~0x8001U + 1)); + CHECK(Bits<16>::has_overflow32(~0xffffU + 1)); + CHECK(Bits<16>::has_overflow32(~0x10000U + 1)); + CHECK(Bits<16>::has_overflow32(~0x10001U + 1)); + + CHECK(! Bits<16>::has_signed_unsigned_overflow32(0U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(1U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(0x7fffU)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(0x8000U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(0x8001U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(0xffffU)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(0x10000U)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(0x10001U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(~0U)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(~0x7fffU + 1)); + CHECK(! Bits<16>::has_signed_unsigned_overflow32(~0x8000U + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(~0x8001U + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(~0xffffU + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(~0x10000U + 1)); + CHECK(Bits<16>::has_signed_unsigned_overflow32(~0x10001U + 1)); + + return true; +} + +Register_test overflow_register("Overflow", Overflow_test); + +} // End namespace gold_testsuite.