Make Checked* functions better align with GCC/Clang intrinsics

base/numerics/safe_math.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_H_
 #define BASE_NUMERICS_SAFE_MATH_H_
 
 #include <stddef.h>
 
 #include <limits>
@@ skipping 101 matching lines @@
   T ValueUnsafe() const { return state_.value(); }
 
   // Prototypes for the supported arithmetic operator overloads.
   template <typename Src> CheckedNumeric& operator+=(Src rhs);
   template <typename Src> CheckedNumeric& operator-=(Src rhs);
   template <typename Src> CheckedNumeric& operator*=(Src rhs);
   template <typename Src> CheckedNumeric& operator/=(Src rhs);
   template <typename Src> CheckedNumeric& operator%=(Src rhs);
 
   CheckedNumeric operator-() const {
-    bool is_valid;
-    T value = CheckedNeg(state_.value(), &is_valid);
     // Negation is always valid for floating point.
-    if (std::numeric_limits<T>::is_iec559)
-      return CheckedNumeric<T>(value);
-
-    is_valid &= state_.is_valid();
+    T value = 0;
+    bool is_valid = (std::numeric_limits<T>::is_iec559 || IsValid()) &&
+                    CheckedNeg(state_.value(), &value);
     return CheckedNumeric<T>(value, is_valid);
   }
 
   CheckedNumeric Abs() const {
-    bool is_valid;
-    T value = CheckedAbs(state_.value(), &is_valid);
     // Absolute value is always valid for floating point.
-    if (std::numeric_limits<T>::is_iec559)
-      return CheckedNumeric<T>(value);
-
-    is_valid &= state_.is_valid();
+    T value = 0;
+    bool is_valid = (std::numeric_limits<T>::is_iec559 || IsValid()) &&
+                    CheckedAbs(state_.value(), &value);
     return CheckedNumeric<T>(value, is_valid);
   }
 
   // This function is available only for integral types. It returns an unsigned
   // integer of the same width as the source type, containing the absolute value
   // of the source, and properly handling signed min.
   CheckedNumeric<typename UnsignedOrFloatForSize<T>::type> UnsignedAbs() const {
     return CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>(
-        CheckedUnsignedAbs(state_.value()), state_.is_valid());
+        SafeUnsignedAbs(state_.value()), state_.is_valid());
   }
 
   CheckedNumeric& operator++() {
     *this += 1;
     return *this;
   }
 
   CheckedNumeric operator++(int) {
     CheckedNumeric value = *this;
     *this += 1;
@@ skipping 54 matching lines @@
 // TODO(jschuh): extract these out into templates.
 #define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP)               \
   /* Binary arithmetic operator for CheckedNumerics of the same type. */       \
   template <typename T>                                                        \
   CheckedNumeric<typename ArithmeticPromotion<T>::type> operator OP(           \
       const CheckedNumeric<T>& lhs, const CheckedNumeric<T>& rhs) {            \
     typedef typename ArithmeticPromotion<T>::type Promotion;                   \
     /* Floating point always takes the fast path */                            \
     if (std::numeric_limits<T>::is_iec559)                                     \
       return CheckedNumeric<T>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());        \
+    if (!rhs.IsValid() || !lhs.IsValid())                                      \
+      return CheckedNumeric<Promotion>(0, false);                              \
     if (IsIntegerArithmeticSafe<Promotion, T, T>::value)                       \
-      return CheckedNumeric<Promotion>(lhs.ValueUnsafe() OP rhs.ValueUnsafe(), \
-                                       rhs.IsValid() && lhs.IsValid());        \
-    bool is_valid = true;                                                      \
-    T result = static_cast<T>(                                                 \
+      return CheckedNumeric<Promotion>(lhs.ValueUnsafe()                       \
+                                       OP rhs.ValueUnsafe());                  \
+    Promotion result = 0;                                                      \
+    bool is_valid =                                                            \
         Checked##NAME(static_cast<Promotion>(lhs.ValueUnsafe()),               \
-                      static_cast<Promotion>(rhs.ValueUnsafe()), &is_valid));  \
-    return CheckedNumeric<Promotion>(                                          \
-        result, is_valid && lhs.IsValid() && rhs.IsValid());                   \
+                      static_cast<Promotion>(rhs.ValueUnsafe()), &result);     \
+    return CheckedNumeric<Promotion>(result, is_valid);                        \
   }                                                                            \
   /* Assignment arithmetic operator implementation from CheckedNumeric. */     \
   template <typename T>                                                        \
   template <typename Src>                                                      \
   CheckedNumeric<T>& CheckedNumeric<T>::operator COMPOUND_OP(Src rhs) {        \
     *this = CheckedNumeric<T>::cast(*this)                                     \
         OP CheckedNumeric<typename UnderlyingType<Src>::type>::cast(rhs);      \
     return *this;                                                              \
   }                                                                            \
   /* Binary arithmetic operator for CheckedNumeric of different type. */       \
   template <typename T, typename Src>                                          \
   CheckedNumeric<typename ArithmeticPromotion<T, Src>::type> operator OP(      \
       const CheckedNumeric<Src>& lhs, const CheckedNumeric<T>& rhs) {          \
     typedef typename ArithmeticPromotion<T, Src>::type Promotion;              \
+    if (!rhs.IsValid() || !lhs.IsValid())                                      \
+      return CheckedNumeric<Promotion>(0, false);                              \
     if (IsIntegerArithmeticSafe<Promotion, T, Src>::value)                     \
-      return CheckedNumeric<Promotion>(lhs.ValueUnsafe() OP rhs.ValueUnsafe(), \
-                                       rhs.IsValid() && lhs.IsValid());        \
+      return CheckedNumeric<Promotion>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());\
     return CheckedNumeric<Promotion>::cast(lhs)                                \
         OP CheckedNumeric<Promotion>::cast(rhs);                               \
   }                                                                            \
   /* Binary arithmetic operator for left CheckedNumeric and right numeric. */  \
   template <typename T, typename Src,                                          \
             typename std::enable_if<std::is_arithmetic<Src>::value>::type* =   \
                 nullptr>                                                       \
   CheckedNumeric<typename ArithmeticPromotion<T, Src>::type> operator OP(      \
       const CheckedNumeric<T>& lhs, Src rhs) {                                 \
     typedef typename ArithmeticPromotion<T, Src>::type Promotion;              \
@@ skipping 25 matching lines @@
 
 #undef BASE_NUMERIC_ARITHMETIC_OPERATORS
 
 }  // namespace internal
 
 using internal::CheckedNumeric;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_