Convert CheckedNumeric unary operators to constexpr

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 454 matching lines @@
                             std::is_arithmetic<U>::value>::type> {
   using result_type = typename LowestValuePromotion<T, U>::type;
   template <typename V = result_type>
   static bool Do(T x, U y, V* result) {
     *result = IsLess<T, U>::Test(x, y) ? static_cast<result_type>(x)
                                        : static_cast<result_type>(y);
     return true;
   }
 };
 
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  std::is_signed<T>::value>::type* = nullptr>
-bool CheckedNeg(T value, T* result) {
-  // The negation of signed min is min, so catch that one.
-  if (value != std::numeric_limits<T>::lowest()) {
-    *result = static_cast<T>(-value);
-    return true;
-  }
-  return false;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  !std::is_signed<T>::value>::type* = nullptr>
-bool CheckedNeg(T value, T* result) {
-  if (!value) {
-    *result = static_cast<T>(0);
-    return true;
-  }
-  return false;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  !std::is_signed<T>::value>::type* = nullptr>
-bool CheckedInv(T value, T* result) {
-  *result = ~value;
-  return true;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  std::is_signed<T>::value>::type* = nullptr>
-bool CheckedAbs(T value, T* result) {
-  *result = static_cast<T>(SafeUnsignedAbs(value));
-  return *result != std::numeric_limits<T>::lowest();
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  !std::is_signed<T>::value>::type* = nullptr>
-bool CheckedAbs(T value, T* result) {
-  // T is unsigned, so |value| must already be positive.
-  *result = value;
-  return true;
-}
-
 // This is just boilerplate that wraps the standard floating point arithmetic.
 // A macro isn't the nicest solution, but it beats rewriting these repeatedly.
 #define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                                    \
   template <typename T, typename U>                                            \
   struct Checked##NAME##Op<                                                    \
       T, U, typename std::enable_if<std::is_floating_point<T>::value ||        \
                                     std::is_floating_point<U>::value>::type> { \
     using result_type = typename MaxExponentPromotion<T, U>::type;             \
     template <typename V>                                                      \
     static bool Do(T x, U y, V* result) {                                      \
       using Promotion = typename MaxExponentPromotion<T, U>::type;             \
       Promotion presult = x OP y;                                              \
       *result = static_cast<V>(presult);                                       \
       return IsValueInRangeForNumericType<V>(presult);                         \
     }                                                                          \
   };
 
 BASE_FLOAT_ARITHMETIC_OPS(Add, +)
 BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
 BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
 BASE_FLOAT_ARITHMETIC_OPS(Div, /)
 
 #undef BASE_FLOAT_ARITHMETIC_OPS
 
-template <
-    typename T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-bool CheckedNeg(T value, T* result) {
-  *result = static_cast<T>(-value);
-  return true;
+// Wrap the unary operations to allow SFINAE when instantiating integrals versus
+// floating points. These don't perform any overflow checking. Rather, they
+// exhibit well-defined overflow semantics and rely on the caller to detect
+// if an overflow occured.
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr T NegateWrapper(T value) {
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  // This will compile to a NEG on Intel, and is normal negation on ARM.
+  return static_cast<T>(UnsignedT(0) - static_cast<UnsignedT>(value));
 }
 
 template <
     typename T,
     typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-bool CheckedAbs(T value, T* result) {
-  *result = static_cast<T>(std::abs(value));
-  return true;
+constexpr T NegateWrapper(T value) {
+  return -value;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr typename std::make_unsigned<T>::type InvertWrapper(T value) {
+  return ~value;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr T AbsWrapper(T value) {
+  return static_cast<T>(SafeUnsignedAbs(value));
+}
+
+template <
+    typename T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+constexpr T AbsWrapper(T value) {
+  return value < 0 ? -value : value;
 }
 
 // Floats carry around their validity state with them, but integers do not. So,
 // we wrap the underlying value in a specialization in order to hide that detail
 // and expose an interface via accessors.
 enum NumericRepresentation {
   NUMERIC_INTEGER,
   NUMERIC_FLOATING,
   NUMERIC_UNKNOWN
 };
@@ skipping 116 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_