Merge branch 'gh47926-safe-arith' into exp-csv-fuzz-safe-arith

Author: pitrou

cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc

@@ -241,7 +241,10 @@ class TestUnaryArithmetic : public TestBaseUnaryArithmetic<T, ArithmeticOptions>
  protected:
   using Base = TestBaseUnaryArithmetic<T, ArithmeticOptions>;
   using Base::options_;
-  void SetOverflowCheck(bool value) { options_.check_overflow = value; }
+  void SetOverflowCheck(bool value) {
+    ARROW_SCOPED_TRACE("check_overflow = ", value);
+    options_.check_overflow = value;
+  }
 };
 
 template <typename T>
@@ -421,7 +424,10 @@ class TestBinaryArithmetic : public TestBaseArithmetic<T> {
     AssertArraysApproxEqual(*expected, *actual, /*verbose=*/true, equal_options_);
   }
 
-  void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
+  void SetOverflowCheck(bool value) {
+    ARROW_SCOPED_TRACE("check_overflow = ", value);
+    options_.check_overflow = value;
+  }
 
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);

cpp/src/arrow/util/int_util_overflow.h

@@ -40,16 +40,15 @@ namespace internal {
     return !check_##_op_name##_##_type##_##_type(u, v, out);                        \
   }
 
-#define SAFE_INT_OPS_WITH_OVERFLOW(_func_name, _psnip_op)            \
-  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _psnip_op, int32_t, int32)   \
-  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _psnip_op, int64_t, int64)   \
-  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _psnip_op, uint32_t, uint32) \
-  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _psnip_op, uint64_t, uint64)
+#define SAFE_INT_OPS_WITH_OVERFLOW(_func_name, _op_name)            \
+  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _op_name, int32_t, int32)   \
+  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _op_name, int64_t, int64)   \
+  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _op_name, uint32_t, uint32) \
+  SAFE_INT_OP_WITH_OVERFLOW(_func_name, _op_name, uint64_t, uint64)
 
 SAFE_INT_OPS_WITH_OVERFLOW(SafeIntAddWithOverflow, add)
 SAFE_INT_OPS_WITH_OVERFLOW(SafeIntSubtractWithOverflow, sub)
 SAFE_INT_OPS_WITH_OVERFLOW(SafeIntMultiplyWithOverflow, mul)
-SAFE_INT_OPS_WITH_OVERFLOW(SafeIntDivideWithOverflow, div)
 
 #undef SAFE_INT_OP_WITH_OVERFLOW
 #undef SAFE_INT_OPS_WITH_OVERFLOW
@@ -77,8 +76,8 @@ template <typename Int>
   return __builtin_add_overflow(u, v, out);
 #else
   if constexpr (sizeof(Int) < 4) {
-    auto r =
-        static_cast<upscaled_int32_t<Int> >(u) + static_cast<upscaled_int32_t<Int> >(v);
+    using UpscaledInt = upscaled_int32_t<Int>;
+    auto r = static_cast<UpscaledInt>(u) + static_cast<UpscaledInt>(v);
     *out = static_cast<Int>(r);
     return r != *out;
   } else {
@@ -93,8 +92,8 @@ template <typename Int>
   return __builtin_sub_overflow(u, v, out);
 #else
   if constexpr (sizeof(Int) < 4) {
-    auto r =
-        static_cast<upscaled_int32_t<Int> >(u) - static_cast<upscaled_int32_t<Int> >(v);
+    using UpscaledInt = upscaled_int32_t<Int>;
+    auto r = static_cast<UpscaledInt>(u) - static_cast<UpscaledInt>(v);
     *out = static_cast<Int>(r);
     return r != *out;
   } else {
@@ -109,8 +108,8 @@ template <typename Int>
   return __builtin_mul_overflow(u, v, out);
 #else
   if constexpr (sizeof(Int) < 4) {
-    auto r =
-        static_cast<upscaled_int32_t<Int> >(u) * static_cast<upscaled_int32_t<Int> >(v);
+    using UpscaledInt = upscaled_int32_t<Int>;
+    auto r = static_cast<UpscaledInt>(u) * static_cast<UpscaledInt>(v);
     *out = static_cast<Int>(r);
     return r != *out;
   } else {
@@ -122,17 +121,18 @@ template <typename Int>
 template <typename Int>
 [[nodiscard]] bool DivideWithOverflowGeneric(Int u, Int v, Int* out) {
   if (v == 0) {
+    *out = Int{};
     return true;
   }
-  if constexpr (sizeof(Int) < 4) {
-    using UpscaledInt = upscaled_int32_t<Int>;
-    UpscaledInt r;
-    bool error = SafeIntDivideWithOverflow(UpscaledInt{u}, UpscaledInt{v}, &r);
-    *out = static_cast<Int>(r);
-    return error || r != *out;
-  } else {
-    return SafeIntDivideWithOverflow(u, v, out);
+  if constexpr (std::is_signed_v<Int>) {
+    constexpr auto kMin = std::numeric_limits<Int>::min();
+    if (u == kMin && v == -1) {
+      *out = kMin;
+      return true;
+    }
   }
+  *out = u / v;
+  return false;
 }
 
 // Define non-generic versions of the above so as to benefit from automatic
@@ -141,7 +141,7 @@ template <typename Int>
 
 #define NON_GENERIC_OP_WITH_OVERFLOW(_func_name, _c_type)                    \
   [[nodiscard]] inline bool _func_name(_c_type u, _c_type v, _c_type* out) { \
-    return _func_name##Generic(u, v, out);                                   \
+    return ARROW_PREDICT_FALSE(_func_name##Generic(u, v, out));              \
   }
 
 #define NON_GENERIC_OPS_WITH_OVERFLOW(_func_name)    \