[libc] add a few tests to handles edge cases with FRACT_{MIN/MAX}

Signed-off-by: Shreeyash Pandey <[email protected]>

Author: bojle

libc/src/__support/fixed_point/fx_bits.h

@@ -243,14 +243,10 @@ template <typename XType> LIBC_INLINE constexpr XType divi(int n, int d) {
   if (LIBC_UNLIKELY(n == 0)) {
     return FXRep<XType>::ZERO();
   }
-  bool d_is_signed = false;
-  if (d < 0) {
-    d = (d * -1);
-    d_is_signed = true;
-  }
+  bool result_is_negative = (n < 0) ^ (d < 0);
 
-  unsigned int nv = static_cast<unsigned int>(n);
-  unsigned int dv = static_cast<unsigned int>(d);
+  unsigned int nv = static_cast<unsigned int>(n < 0 ? -n : n);
+  unsigned int dv = static_cast<unsigned int>(d < 0 ? -d : d);
   unsigned int clz = cpp::countl_zero<unsigned int>(dv) - 1;
   unsigned long int scaled_val = dv << clz;
   /* Scale denominator to be in the range of [0.5,1] */
@@ -281,11 +277,25 @@ template <typename XType> LIBC_INLINE constexpr XType divi(int n, int d) {
   val = nrstep(d_scaled_val, val);
   /* E4 = 2.155e−20 */
   val = nrstep(d_scaled_val, val);
+
   long accum res = n_scaled_val * val;
-  if (d_is_signed) {
-    res *= static_cast<XType>(-1);
+
+  if (result_is_negative) {
+    res *= static_cast<long accum>(-1);
+  }
+
+  // Check for overflow before returning
+  long accum max_val = static_cast<long accum>(FXRep<XType>::MAX());
+  long accum min_val = static_cast<long accum>(FXRep<XType>::MIN());
+
+  /* Per clause 7.18a.6.1, saturate values on overflow */
+  if (res > max_val) {
+    return FXRep<XType>::MAX();
+  } else if (res < min_val) {
+    return FXRep<XType>::MIN();
+  } else {
+    return static_cast<XType>(res);
   }
-  return static_cast<XType>(res);
 }
 
 } // namespace fixed_point

libc/test/src/stdfix/DivITest.h

@@ -11,6 +11,8 @@
 #include "src/__support/fixed_point/fx_rep.h"
 #include "test/UnitTest/Test.h"
 
+#include <stdio.h>
+
 template <typename XType> XType get_epsilon() = delete;
 template <> fract get_epsilon() { return FRACT_EPSILON; }
 template <> unsigned fract get_epsilon() { return UFRACT_EPSILON; }
@@ -44,22 +46,27 @@ class DivITest : public LIBC_NAMESPACE::testing::Test {
   }
 
   void testSpecial(DivIFunc func) {
-    EXPECT_EQ(func(0,10), 0.r);
-    EXPECT_EQ(func(0,-10), 0.r);
-    EXPECT_EQ(func(-32768,32768), FRACT_MIN);
-    EXPECT_EQ(func(32767,32768), FRACT_MAX);  
-    EXPECT_EQ(func(INT_MAX,INT_MAX), 1.0r);
-    EXPECT_EQ(func(INT_MAX-1,INT_MAX), 0.99999999r);
-    EXPECT_EQ(func(INT_MIN,INT_MAX), FRACT_MIN);
-    /* Expecting 0 here as fract is not precise enough to 
+    XType epsilon = get_epsilon<XType>();
+    EXPECT_EQ(func(0, 10), 0.r);
+    EXPECT_EQ(func(0, -10), 0.r);
+    EXPECT_EQ(func(-(1 << FRACT_FBIT), 1 << FRACT_FBIT), FRACT_MIN);
+    EXPECT_EQ(func((1 << FRACT_FBIT) - 1, 1 << FRACT_FBIT), FRACT_MAX);
+    /* From Section 7.18a.6.1, functions returning a fixed-point value, the
+     * return value is saturated on overflow. */
+    EXPECT_EQ(func(INT_MAX, INT_MAX), FRACT_MAX);
+    EXPECT_LT(func(INT_MAX - 1, INT_MAX) - 0.99999999r, epsilon);
+    EXPECT_EQ(func(INT_MIN, INT_MAX), FRACT_MIN);
+    /* Expecting 0 here as fract is not precise enough to
      * handle 1/INT_MAX
      */
-    EXPECT_EQ(func(1, INT_MAX), 0.r);
+    EXPECT_LT(func(1, INT_MAX) - 0.r, epsilon);
+    /* This results in 1.1739, which should be saturated to FRACT_MAX */
+    EXPECT_EQ(func(27, 23), FRACT_MAX);
   }
 };
 
 #define LIST_DIVI_TESTS(Name, XType, func)                                     \
   using LlvmLibc##Name##diviTest = DivITest<XType>;                            \
   TEST_F(LlvmLibc##Name##diviTest, Basic) { testBasic(&func); }                \
-  TEST_F(LlvmLibc##Name##diviTest, Special) { testSpecial(&func); }                \
+  TEST_F(LlvmLibc##Name##diviTest, Special) { testSpecial(&func); }            \
   static_assert(true, "Require semicolon.")