diff options
| -rw-r--r-- | gold/ChangeLog | 48 | ||||
| -rw-r--r-- | gold/reloc.h | 556 | ||||
| -rw-r--r-- | gold/testsuite/Makefile.am | 5 | ||||
| -rw-r--r-- | gold/testsuite/Makefile.in | 34 | ||||
| -rw-r--r-- | gold/testsuite/overflow_unittest.cc | 139 |
5 files changed, 632 insertions, 150 deletions
diff --git a/gold/ChangeLog b/gold/ChangeLog index ae50474..ecb5057 100644 --- a/gold/ChangeLog +++ b/gold/ChangeLog @@ -1,3 +1,51 @@ +2016-02-06 Cary Coutant <ccoutant@gmail.com> + + 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. + 2016-02-04 Alan Modra <amodra@gmail.com> * powerpc.cc (relocate): Adjust last patch for big-endian. 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<int valsize> +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<int size, bool big_endian> class Relocate_functions { -private: + public: + typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; + typedef typename elfcpp::Elf_types<size>::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<int valsize> + static inline Reloc_status + check_overflow(Address value, Overflow_check check) + { + switch (check) + { + case CHECK_SIGNED: + if (size == 32) + return (Bits<valsize>::has_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits<valsize>::has_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_UNSIGNED: + if (size == 32) + return (Bits<valsize>::has_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits<valsize>::has_unsigned_overflow(value) + ? RELOC_OVERFLOW + : RELOC_OK); + case CHECK_SIGNED_OR_UNSIGNED: + if (size == 32) + return (Bits<valsize>::has_signed_unsigned_overflow32(value) + ? RELOC_OVERFLOW + : RELOC_OK); + else + return (Bits<valsize>::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<int valsize> - static inline void - rel(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value) + static inline Reloc_status + rel(unsigned char* view, Address value, Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value); + Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv); + value += addend; + elfcpp::Swap<valsize, big_endian>:: + writeval(wv, static_cast<Valtype>(value)); + return check_overflow<valsize>(value, check); } // Like the above but for relocs at unaligned addresses. template<int valsize> - static inline void - rel_unaligned(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value) + static inline Reloc_status + rel_unaligned(unsigned char* view, Address value, Overflow_check check) { typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); - elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value); + Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); + value += addend; + elfcpp::Swap_unaligned<valsize, big_endian>:: + writeval(view, static_cast<Valtype>(value)); + return check_overflow<valsize>(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<int valsize> - static inline void + static inline Reloc_status rel(unsigned char* view, const Sized_relobj_file<size, big_endian>* object, - const Symbol_value<size>* psymval) + const Symbol_value<size>* psymval, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x); + Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv); + Address value = psymval->value(object, addend); + elfcpp::Swap<valsize, big_endian>:: + writeval(wv, static_cast<Valtype>(value)); + return check_overflow<valsize>(value, check); } // Like the above but for relocs at unaligned addresses. template<int valsize> - static inline void + static inline Reloc_status rel_unaligned(unsigned char* view, const Sized_relobj_file<size, big_endian>* object, - const Symbol_value<size>* psymval) + const Symbol_value<size>* psymval, + Overflow_check check) { typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); - x = psymval->value(object, x); - elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x); + Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); + Address value = psymval->value(object, addend); + elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value); + return check_overflow<valsize>(value, check); } // Do a simple relocation with the addend in the relocation. // VALSIZE is the size of the value. template<int valsize> - static inline void - rela(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value, - typename elfcpp::Swap<valsize, big_endian>::Valtype addend) + static inline Reloc_status + rela(unsigned char* view, Address value, Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend); + value += addend; + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(value, check); } // Do a simple relocation using a symbol value with the addend in // the relocation. VALSIZE is the size of the value. template<int valsize> - static inline void + static inline Reloc_status rela(unsigned char* view, const Sized_relobj_file<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Swap<valsize, big_endian>::Valtype addend) + Addendtype addend, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x); + Address value = psymval->value(object, addend); + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(value, check); } // Do a simple PC relative relocation with the addend in the section // contents. VALSIZE is the size of the value. template<int valsize> - static inline void - pcrel(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value, - typename elfcpp::Elf_types<size>::Elf_Addr address) + static inline Reloc_status + pcrel(unsigned char* view, Address value, Address address, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address); + Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv); + value = value + addend - address; + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(value, check); } // Like the above but for relocs at unaligned addresses. template<int valsize> - static inline void - pcrel_unaligned(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value, - typename elfcpp::Elf_types<size>::Elf_Addr address) + static inline Reloc_status + pcrel_unaligned(unsigned char* view, Address value, Address address, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; - Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); - elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, - x + value - address); + Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view); + value = value + addend - address; + elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value); + return check_overflow<valsize>(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<int valsize> - static inline void + static inline Reloc_status pcrel(unsigned char* view, const Sized_relobj_file<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Elf_types<size>::Elf_Addr address) + Address address, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv); - x = psymval->value(object, x); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address); + Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(value, check); } // Do a simple PC relative relocation with the addend in the // relocation. VALSIZE is the size of the value. template<int valsize> - static inline void - pcrela(unsigned char* view, - typename elfcpp::Swap<valsize, big_endian>::Valtype value, - typename elfcpp::Swap<valsize, big_endian>::Valtype addend, - typename elfcpp::Elf_types<size>::Elf_Addr address) + static inline Reloc_status + pcrela(unsigned char* view, Address value, Addendtype addend, Address address, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address); + value = value + addend - address; + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(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<int valsize> - static inline void + static inline Reloc_status pcrela(unsigned char* view, const Sized_relobj_file<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Swap<valsize, big_endian>::Valtype addend, - typename elfcpp::Elf_types<size>::Elf_Addr address) + Addendtype addend, + Address address, + Overflow_check check) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); - Valtype x = psymval->value(object, addend); - elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address); + Address value = psymval->value(object, addend) - address; + elfcpp::Swap<valsize, big_endian>::writeval(wv, value); + return check_overflow<valsize>(value, check); } typedef Relocate_functions<size, big_endian> 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - unsigned char addend, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - elfcpp::Elf_Half addend, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - elfcpp::Elf_Word addend, - typename elfcpp::Elf_types<size>::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<size, big_endian>* object, + const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size, big_endian>* object, const Symbol_value<size>* 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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - typename elfcpp::Elf_types<size>::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<size>::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<size, big_endian>* object, const Symbol_value<size>* psymval, - elfcpp::Elf_Xword addend, - typename elfcpp::Elf_types<size>::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<int32_t>((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<int64_t>((static_cast<uint64_t>(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/Makefile.in b/gold/testsuite/Makefile.in index 31c9951..c771a42 100644 --- a/gold/testsuite/Makefile.in +++ b/gold/testsuite/Makefile.in @@ -54,7 +54,8 @@ check_PROGRAMS = $(am__EXEEXT_1) $(am__EXEEXT_2) $(am__EXEEXT_3) \ $(am__EXEEXT_34) $(am__EXEEXT_35) $(am__EXEEXT_36) \ $(am__EXEEXT_37) @NATIVE_OR_CROSS_LINKER_TRUE@am__append_1 = object_unittest \ -@NATIVE_OR_CROSS_LINKER_TRUE@ binary_unittest leb128_unittest +@NATIVE_OR_CROSS_LINKER_TRUE@ binary_unittest leb128_unittest \ +@NATIVE_OR_CROSS_LINKER_TRUE@ overflow_unittest @GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_2 = incremental_test.sh \ @GCC_TRUE@@NATIVE_LINKER_TRUE@ gc_comdat_test.sh gc_tls_test.sh \ @GCC_TRUE@@NATIVE_LINKER_TRUE@ gc_orphan_section_test.sh \ @@ -849,7 +850,8 @@ am_libgoldtest_a_OBJECTS = test.$(OBJEXT) testmain.$(OBJEXT) \ libgoldtest_a_OBJECTS = $(am_libgoldtest_a_OBJECTS) @NATIVE_OR_CROSS_LINKER_TRUE@am__EXEEXT_1 = object_unittest$(EXEEXT) \ @NATIVE_OR_CROSS_LINKER_TRUE@ binary_unittest$(EXEEXT) \ -@NATIVE_OR_CROSS_LINKER_TRUE@ leb128_unittest$(EXEEXT) +@NATIVE_OR_CROSS_LINKER_TRUE@ leb128_unittest$(EXEEXT) \ +@NATIVE_OR_CROSS_LINKER_TRUE@ overflow_unittest$(EXEEXT) @GCC_TRUE@@NATIVE_LINKER_TRUE@am__EXEEXT_2 = icf_virtual_function_folding_test$(EXEEXT) \ @GCC_TRUE@@NATIVE_LINKER_TRUE@ large_symbol_alignment$(EXEEXT) \ @GCC_TRUE@@NATIVE_LINKER_TRUE@ basic_test$(EXEEXT) \ @@ -1584,6 +1586,14 @@ object_unittest_DEPENDENCIES = libgoldtest.a ../libgold.a \ ../../libiberty/libiberty.a $(am__DEPENDENCIES_1) \ $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \ $(am__DEPENDENCIES_1) +@NATIVE_OR_CROSS_LINKER_TRUE@am_overflow_unittest_OBJECTS = \ +@NATIVE_OR_CROSS_LINKER_TRUE@ overflow_unittest.$(OBJEXT) +overflow_unittest_OBJECTS = $(am_overflow_unittest_OBJECTS) +overflow_unittest_LDADD = $(LDADD) +overflow_unittest_DEPENDENCIES = libgoldtest.a ../libgold.a \ + ../../libiberty/libiberty.a $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) permission_test_SOURCES = permission_test.c permission_test_OBJECTS = permission_test.$(OBJEXT) permission_test_LDADD = $(LDADD) @@ -2126,11 +2136,12 @@ SOURCES = $(libgoldtest_a_SOURCES) basic_pic_test.c basic_pie_test.c \ $(large_symbol_alignment_SOURCES) $(leb128_unittest_SOURCES) \ local_labels_test.c many_sections_r_test.c \ $(many_sections_test_SOURCES) $(object_unittest_SOURCES) \ - permission_test.c $(pie_copyrelocs_test_SOURCES) \ - plugin_test_1.c plugin_test_10.c plugin_test_11.c \ - plugin_test_2.c plugin_test_3.c plugin_test_4.c \ - plugin_test_5.c plugin_test_6.c plugin_test_7.c \ - plugin_test_8.c plugin_test_tls.c $(protected_1_SOURCES) \ + $(overflow_unittest_SOURCES) permission_test.c \ + $(pie_copyrelocs_test_SOURCES) plugin_test_1.c \ + plugin_test_10.c plugin_test_11.c plugin_test_2.c \ + plugin_test_3.c plugin_test_4.c plugin_test_5.c \ + plugin_test_6.c plugin_test_7.c plugin_test_8.c \ + plugin_test_tls.c $(protected_1_SOURCES) \ $(protected_2_SOURCES) $(relro_now_test_SOURCES) \ $(relro_script_test_SOURCES) $(relro_strip_test_SOURCES) \ $(relro_test_SOURCES) $(script_test_1_SOURCES) \ @@ -2496,6 +2507,7 @@ LDADD = libgoldtest.a ../libgold.a ../../libiberty/libiberty.a $(LIBINTL) \ @NATIVE_OR_CROSS_LINKER_TRUE@object_unittest_SOURCES = object_unittest.cc @NATIVE_OR_CROSS_LINKER_TRUE@binary_unittest_SOURCES = binary_unittest.cc @NATIVE_OR_CROSS_LINKER_TRUE@leb128_unittest_SOURCES = leb128_unittest.cc +@NATIVE_OR_CROSS_LINKER_TRUE@overflow_unittest_SOURCES = overflow_unittest.cc @GCC_TRUE@@NATIVE_LINKER_TRUE@large_symbol_alignment_SOURCES = large_symbol_alignment.cc @GCC_TRUE@@NATIVE_LINKER_TRUE@large_symbol_alignment_DEPENDENCIES = gcctestdir/ld @GCC_TRUE@@NATIVE_LINKER_TRUE@large_symbol_alignment_LDFLAGS = -Bgcctestdir/ @@ -3533,6 +3545,9 @@ many_sections_test$(EXEEXT): $(many_sections_test_OBJECTS) $(many_sections_test_ object_unittest$(EXEEXT): $(object_unittest_OBJECTS) $(object_unittest_DEPENDENCIES) @rm -f object_unittest$(EXEEXT) $(CXXLINK) $(object_unittest_OBJECTS) $(object_unittest_LDADD) $(LIBS) +overflow_unittest$(EXEEXT): $(overflow_unittest_OBJECTS) $(overflow_unittest_DEPENDENCIES) + @rm -f overflow_unittest$(EXEEXT) + $(CXXLINK) $(overflow_unittest_OBJECTS) $(overflow_unittest_LDADD) $(LIBS) @GCC_FALSE@permission_test$(EXEEXT): $(permission_test_OBJECTS) $(permission_test_DEPENDENCIES) @GCC_FALSE@ @rm -f permission_test$(EXEEXT) @GCC_FALSE@ $(LINK) $(permission_test_OBJECTS) $(permission_test_LDADD) $(LIBS) @@ -3969,6 +3984,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/many_sections_r_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/many_sections_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/object_unittest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/overflow_unittest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/permission_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pie_copyrelocs_test-pie_copyrelocs_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/plugin_test_1.Po@am__quote@ @@ -4550,6 +4566,8 @@ binary_unittest.log: binary_unittest$(EXEEXT) @p='binary_unittest$(EXEEXT)'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post) leb128_unittest.log: leb128_unittest$(EXEEXT) @p='leb128_unittest$(EXEEXT)'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post) +overflow_unittest.log: overflow_unittest$(EXEEXT) + @p='overflow_unittest$(EXEEXT)'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post) icf_virtual_function_folding_test.log: icf_virtual_function_folding_test$(EXEEXT) @p='icf_virtual_function_folding_test$(EXEEXT)'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post) large_symbol_alignment.log: large_symbol_alignment$(EXEEXT) @@ -5027,6 +5045,8 @@ uninstall-am: @GCC_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ test -d gcctestdir || mkdir -p gcctestdir @GCC_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ rm -f gcctestdir/as @GCC_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ (cd gcctestdir && $(LN_S) $(abs_top_builddir)/../gas/as-new as) +@NATIVE_OR_CROSS_LINKER_TRUE@overflow_unittest.o: overflow_unittest.cc +@NATIVE_OR_CROSS_LINKER_TRUE@ $(CXXCOMPILE) -O3 -c -o $@ $< # --------------------------------------------------------------------- # These tests test the output of gold (end-to-end tests). In 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 <ccoutant@google.com>. + +// 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 <sys/types.h> + +#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. |