Minor base/numerics cleanup

base/numerics/safe_math_impl.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_NUMERICS_SAFE_MATH_IMPL_H_
 #define BASE_NUMERICS_SAFE_MATH_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 39 matching lines @@
 #else
 #define USE_OVERFLOW_BUILTINS (0)
 #endif
 
 template <typename T,
           typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
 bool CheckedAddImpl(T x, T y, T* result) {
   // Since the value of x+y is undefined if we have a signed type, we compute
   // it using the unsigned type of the same size.
   using UnsignedDst = typename std::make_unsigned<T>::type;
+  using SignedDst = typename std::make_signed<T>::type;
   UnsignedDst ux = static_cast<UnsignedDst>(x);
   UnsignedDst uy = static_cast<UnsignedDst>(y);
   UnsignedDst uresult = static_cast<UnsignedDst>(ux + uy);
   *result = static_cast<T>(uresult);
   // Addition is valid if the sign of (x + y) is equal to either that of x or
   // that of y.
   return (std::is_signed<T>::value)
-             ? HasSignBit(BinaryComplement(
-                   static_cast<UnsignedDst>((uresult ^ ux) & (uresult ^ uy))))
-             : (BinaryComplement(x) >=
-                y);  // Unsigned is either valid or underflow.
+             ? static_cast<SignedDst>((uresult ^ ux) & (uresult ^ uy)) >= 0
+             : uresult >= uy;  // Unsigned is either valid or underflow.
 }
 
 template <typename T, typename U, class Enable = void>
 struct CheckedAddOp {};
 
 template <typename T, typename U>
 struct CheckedAddOp<T,
                     U,
                     typename std::enable_if<std::is_integral<T>::value &&
                                             std::is_integral<U>::value>::type> {
@@ skipping 21 matching lines @@
 #endif
   }
 };
 
 template <typename T,
           typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
 bool CheckedSubImpl(T x, T y, T* result) {
   // Since the value of x+y is undefined if we have a signed type, we compute
   // it using the unsigned type of the same size.
   using UnsignedDst = typename std::make_unsigned<T>::type;
+  using SignedDst = typename std::make_signed<T>::type;
   UnsignedDst ux = static_cast<UnsignedDst>(x);
   UnsignedDst uy = static_cast<UnsignedDst>(y);
   UnsignedDst uresult = static_cast<UnsignedDst>(ux - uy);
   *result = static_cast<T>(uresult);
   // Subtraction is valid if either x and y have same sign, or (x-y) and x have
   // the same sign.
   return (std::is_signed<T>::value)
-             ? HasSignBit(BinaryComplement(
-                   static_cast<UnsignedDst>((uresult ^ ux) & (ux ^ uy))))
-             : (x >= y);
+             ? static_cast<SignedDst>((uresult ^ ux) & (ux ^ uy)) >= 0
+             : x >= y;
 }
 
 template <typename T, typename U, class Enable = void>
 struct CheckedSubOp {};
 
 template <typename T, typename U>
 struct CheckedSubOp<T,
                     U,
                     typename std::enable_if<std::is_integral<T>::value &&
                                             std::is_integral<U>::value>::type> {
@@ skipping 41 matching lines @@
 
 template <typename T,
           typename std::enable_if<
               std::is_integral<T>::value && std::is_signed<T>::value &&
               ((IntegerBitsPlusSign<T>::value * 2) >
                IntegerBitsPlusSign<intmax_t>::value)>::type* = nullptr>
 bool CheckedMulImpl(T x, T y, T* result) {
   // Since the value of x*y is potentially undefined if we have a signed type,
   // we compute it using the unsigned type of the same size.
   using UnsignedDst = typename std::make_unsigned<T>::type;
-  const T is_negative = HasSignBit(x) ^ HasSignBit(y);
   const UnsignedDst ux = SafeUnsignedAbs(x);
   const UnsignedDst uy = SafeUnsignedAbs(y);
   UnsignedDst uresult = static_cast<UnsignedDst>(ux * uy);
   // This is a non-branching conditional negation.
+  const T is_negative = (x ^ y) < 0;
   *result = static_cast<T>((uresult ^ -is_negative) + is_negative);
   // This uses the unsigned overflow check on the absolute value, with a +1
   // bound for a negative result.
   return (uy == 0 ||
           ux <= (static_cast<UnsignedDst>(std::numeric_limits<T>::max()) +
                  is_negative) /
                     uy);
 }
 
 template <typename T,
@@ skipping 490 matching lines @@
   using math = M<typename UnderlyingType<L>::type,
                  typename UnderlyingType<R>::type,
                  void>;
   using type = typename math::result_type;
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_IMPL_H_