Performance optimizations for base/numerics absolute value and multiply

base/numerics/safe_conversions_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_CONVERSIONS_IMPL_H_
 #define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 
 #include <stdint.h>
 
 #include <limits>
@@ skipping 12 matching lines @@
 };
 
 // The number of bits (including the sign) in an integer. Eliminates sizeof
 // hacks.
 template <typename NumericType>
 struct IntegerBitsPlusSign {
   static const int value = std::numeric_limits<NumericType>::digits +
                            std::is_signed<NumericType>::value;
 };
 
+// Helper templates for integer manipulations.
+
+template <typename Integer>
+struct PositionOfSignBit {
+  static const size_t value = IntegerBitsPlusSign<Integer>::value - 1;
+};
+
+template <typename T>
+constexpr bool HasSignBit(T x) {
+  // Cast to unsigned since right shift on signed is undefined.
+  return !!(static_cast<typename std::make_unsigned<T>::type>(x) >>
+            PositionOfSignBit<T>::value);
+}
+
+// This wrapper undoes the standard integer promotions.

[scottmg, 2016/12/09 22:48:24]

I don't see this getting used?

[jschuh, 2016/12/09 22:58:05]

It is in safe_math_impl.h. I just moved it because it felt weird to leave it
hanging out alone there.

+template <typename T>
+constexpr T BinaryComplement(T x) {
+  return static_cast<T>(~x);
+}
+
+// This performs a safe, non-branching absolute value via unsigned overflow.
+template <typename T,
+          typename std::enable_if<!std::is_signed<T>::value>::type* = nullptr>

[scottmg, 2016/12/09 23:27:02]

std::is_integral<T>::value &&

in the enable_if for consistency with where it's used.

[jschuh, 2016/12/09 23:31:28]

I had that originally, but there are no unsigned non-integral types. Also, this
is an internal function called from only one place, so the specialization here
was just a sanity check rather than a requirement.

+constexpr T SafeUnsignedAbsImpl(T value, T sign_mask) {
+  return (value + sign_mask) ^ sign_mask;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value &&
+                                  std::is_signed<T>::value>::type* = nullptr>
+constexpr typename std::make_unsigned<T>::type SafeUnsignedAbs(T value) {
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  return SafeUnsignedAbsImpl(
+      static_cast<UnsignedT>(value),
+      // The sign mask is all ones for negative and zero otherwise.
+      static_cast<UnsignedT>(-static_cast<T>(HasSignBit(value))));
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value &&
+                                  !std::is_signed<T>::value>::type* = nullptr>
+constexpr T SafeUnsignedAbs(T value) {
+  // T is unsigned, so |value| must already be positive.
+  return static_cast<T>(value);
+}
+
 enum IntegerRepresentation {
   INTEGER_REPRESENTATION_UNSIGNED,
   INTEGER_REPRESENTATION_SIGNED
 };
 
 // A range for a given nunmeric Src type is contained for a given numeric Dst
 // type if both numeric_limits<Src>::max() <= numeric_limits<Dst>::max() and
 // numeric_limits<Src>::lowest() >= numeric_limits<Dst>::lowest() are true.
 // We implement this as template specializations rather than simple static
 // comparisons to ensure type correctness in our comparisons.
@@ skipping 238 matching lines @@
 static_assert(IntegerBitsPlusSign<intmax_t>::value == 64,
               "Max integer size not supported for this toolchain.");
 
 template <typename Integer, bool IsSigned = std::is_signed<Integer>::value>
 struct TwiceWiderInteger {
   using type =
       typename IntegerForDigitsAndSign<IntegerBitsPlusSign<Integer>::value * 2,
                                        IsSigned>::type;
 };
 
-template <typename Integer>
-struct PositionOfSignBit {
-  static const size_t value = IntegerBitsPlusSign<Integer>::value - 1;
-};
-
 enum ArithmeticPromotionCategory {
   LEFT_PROMOTION,  // Use the type of the left-hand argument.
   RIGHT_PROMOTION  // Use the type of the right-hand argument.
 };
 
 // Determines the type that can represent the largest positive value.
 template <typename Lhs,
           typename Rhs,
           ArithmeticPromotionCategory Promotion =
               (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value)
@@ skipping 301 matching lines @@
                    static_cast<BigType>(static_cast<L>(lhs)),
                    static_cast<BigType>(static_cast<R>(rhs)))
              // Let the template functions figure it out for mixed types.
              : C<L, R>::Test(lhs, rhs);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_