Restructure ArithmeticPromotion to support alternate promotions

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 177 matching lines @@
   CheckedNumericState<T> state_;
 };
 
 // This is the boilerplate for the standard arithmetic operator overloads. A
 // macro isn't the prettiest solution, but it beats rewriting these five times.
 // Some details worth noting are:
 //  * We apply the standard arithmetic promotions.
 //  * We skip range checks for floating points.
 //  * We skip range checks for destination integers with sufficient range.
 // TODO(jschuh): extract these out into templates.
-#define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP)              \
+#define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP, PROMOTION)   \
   /* Binary arithmetic operator for CheckedNumerics of the same type. */      \
   template <typename L, typename R>                                           \
-  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
-      const CheckedNumeric<L>& lhs, const CheckedNumeric<R>& rhs) {           \
-    using P = typename ArithmeticPromotion<L, R>::type;                       \
+  CheckedNumeric<typename ArithmeticPromotion<PROMOTION, L, R>::type>         \
+  operator OP(const CheckedNumeric<L>& lhs, const CheckedNumeric<R>& rhs) {   \
+    using P = typename ArithmeticPromotion<PROMOTION, L, R>::type;            \
     if (!rhs.IsValid() || !lhs.IsValid())                                     \
       return CheckedNumeric<P>(0, false);                                     \
     /* Floating point always takes the fast path */                           \
     if (std::is_floating_point<L>::value || std::is_floating_point<R>::value) \
       return CheckedNumeric<P>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());       \
     P result = 0;                                                             \
     bool is_valid =                                                           \
         Checked##NAME(lhs.ValueUnsafe(), rhs.ValueUnsafe(), &result);         \
     return CheckedNumeric<P>(result, is_valid);                               \
   }                                                                           \
   /* Assignment arithmetic operator implementation from CheckedNumeric. */    \
   template <typename L>                                                       \
   template <typename R>                                                       \
   CheckedNumeric<L>& CheckedNumeric<L>::operator COMPOUND_OP(R rhs) {         \
     *this = *this OP rhs;                                                     \
     return *this;                                                             \
   }                                                                           \
   /* Binary arithmetic operator for left CheckedNumeric and right numeric. */ \
   template <typename L, typename R,                                           \
             typename std::enable_if<std::is_arithmetic<R>::value>::type* =    \
                 nullptr>                                                      \
-  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
-      const CheckedNumeric<L>& lhs, R rhs) {                                  \
+  CheckedNumeric<typename ArithmeticPromotion<PROMOTION, L, R>::type>         \
+  operator OP(const CheckedNumeric<L>& lhs, R rhs) {                          \
     return lhs OP CheckedNumeric<R>(rhs);                                     \
   }                                                                           \
   /* Binary arithmetic operator for left numeric and right CheckedNumeric. */ \
   template <typename L, typename R,                                           \
             typename std::enable_if<std::is_arithmetic<L>::value>::type* =    \
                 nullptr>                                                      \
-  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
-      L lhs, const CheckedNumeric<R>& rhs) {                                  \
+  CheckedNumeric<typename ArithmeticPromotion<PROMOTION, L, R>::type>         \
+  operator OP(L lhs, const CheckedNumeric<R>& rhs) {                          \
     return CheckedNumeric<L>(lhs) OP rhs;                                     \
   }
 
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Add, +, += )
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Sub, -, -= )
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Mul, *, *= )
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Div, /, /= )
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Mod, %, %= )
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Add, +, +=, MAX_EXPONENT_PROMOTION)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Sub, -, -=, MAX_EXPONENT_PROMOTION)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Mul, *, *=, MAX_EXPONENT_PROMOTION)

[Tom Sepez, 2016/11/15 22:31:17]

Shouldn't multiplicaton be BIG_ENOUGH_PROMOTION?

[jschuh, 2016/11/15 22:38:49]

It is, but in the intermediate representation for the CheckedMul function.

+BASE_NUMERIC_ARITHMETIC_OPERATORS(Div, /, /=, MAX_EXPONENT_PROMOTION)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Mod, %, %=, MAX_EXPONENT_PROMOTION)
 
 #undef BASE_NUMERIC_ARITHMETIC_OPERATORS
 
 }  // namespace internal
 
 using internal::CheckedNumeric;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_