Overhaul relocation framework to support overflow checking.

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.

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.