[ConstExprPreter] Overflow-detecting methods use GCC or clang builtins

[jfb]

llvm/include/llvm/Support/MathExtras.h

863

The current minimum GCC version is 4.8, with 5.1 on the horizon. You therefore don't need the check :)

[nand]

removed redundant check

[jfb]

https://reviews.llvm.org/rL367490

llvm/include/llvm/Support/MathExtras.h

 extern const float huge_valf;
 
 
 /// Add two signed integers, computing the two's complement truncated result,
 /// returning true if overflow occured.
 template <typename T>
 typename std::enable_if<std::is_signed<T>::value, T>::type
 AddOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_add_overflow)
+  return __builtin_add_overflow(X, Y, &Result);
+#else
   // Perform the unsigned addition.
   using U = typename std::make_unsigned<T>::type;
   const U UX = static_cast<U>(X);
   const U UY = static_cast<U>(Y);
   const U UResult = UX + UY;
 
   // Convert to signed.
   Result = static_cast<T>(UResult);
 
   // Adding two positive numbers should result in a positive number.
   if (X > 0 && Y > 0)
     return Result <= 0;
   // Adding two negatives should result in a negative number.
   if (X < 0 && Y < 0)
     return Result >= 0;
   return false;
+#endif
 }
 
 /// Subtract two signed integers, computing the two's complement truncated
 /// result, returning true if an overflow ocurred.
 template <typename T>
 typename std::enable_if<std::is_signed<T>::value, T>::type
 SubOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_sub_overflow)
+  return __builtin_sub_overflow(X, Y, &Result);
+#else
   // Perform the unsigned addition.
   using U = typename std::make_unsigned<T>::type;
   const U UX = static_cast<U>(X);
   const U UY = static_cast<U>(Y);
   const U UResult = UX - UY;
 
   // Convert to signed.
   Result = static_cast<T>(UResult);
 
   // Subtracting a positive number from a negative results in a negative number.
   if (X <= 0 && Y > 0)
     return Result >= 0;
   // Subtracting a negative number from a positive results in a positive number.
   if (X >= 0 && Y < 0)
     return Result <= 0;
   return false;
+#endif
 }
 
 
 /// Multiply two signed integers, computing the two's complement truncated
 /// result, returning true if an overflow ocurred.
 template <typename T>
 typename std::enable_if<std::is_signed<T>::value, T>::type
 MulOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_mul_overflow)
+  return __builtin_mul_overflow(X, Y, &Result);
+#else
   // Perform the unsigned multiplication on absolute values.
   using U = typename std::make_unsigned<T>::type;
   const U UX = X < 0 ? (0 - static_cast<U>(X)) : static_cast<U>(X);
   const U UY = Y < 0 ? (0 - static_cast<U>(Y)) : static_cast<U>(Y);
   const U UResult = UX * UY;
 
   // Convert to signed.
   const bool IsNegative = (X < 0) ^ (Y < 0);
   Result = IsNegative ? (0 - UResult) : UResult;
 
   // If any of the args was 0, result is 0 and no overflow occurs.
   if (UX == 0 || UY == 0)
     return false;
 
   // UX and UY are in [1, 2^n], where n is the number of digits.
   // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for
   // positive) divided by an argument compares to the other.
   if (IsNegative)
     return UX > (static_cast<U>(std::numeric_limits<T>::max()) + U(1)) / UY;
   else
     return UX > (static_cast<U>(std::numeric_limits<T>::max())) / UY;
+#endif
 }
 
 } // End llvm namespace
 
 #endif