[libc] Add next_toward_inf fo FPBits (#80654)

It is needed to provide correct rounding when building FPRep from
greater precision representations.

Author: gchatelet

libc/src/__support/FPUtil/CMakeLists.txt

@@ -31,6 +31,7 @@ add_header_library(
     libc.src.__support.common
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
+    libc.src.__support.libc_assert
     libc.src.__support.macros.attributes
     libc.src.__support.macros.properties.float
     libc.src.__support.math_extras

libc/src/__support/FPUtil/FPBits.h

@@ -13,6 +13,7 @@
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/common.h"
+#include "src/__support/libc_assert.h"       // LIBC_ASSERT
 #include "src/__support/macros/attributes.h" // LIBC_INLINE, LIBC_INLINE_VAR
 #include "src/__support/macros/properties/float.h" // LIBC_COMPILER_HAS_FLOAT128
 #include "src/__support/math_extras.h"             // mask_trailing_ones
@@ -266,6 +267,18 @@ template <FPType fp_type> struct FPStorage : public FPLayout<fp_type> {
     LIBC_INLINE constexpr operator Exponent() const {
       return Exponent(UP::value - EXP_BIAS);
     }
+
+    LIBC_INLINE constexpr BiasedExponent &operator++() {
+      LIBC_ASSERT(*this != BiasedExponent(Exponent::INF()));
+      ++UP::value;
+      return *this;
+    }
+
+    LIBC_INLINE constexpr BiasedExponent &operator--() {
+      LIBC_ASSERT(*this != BiasedExponent(Exponent::SUBNORMAL()));
+      --UP::value;
+      return *this;
+    }
   };
 
   // An opaque type to store a floating point significand.
@@ -370,6 +383,7 @@ struct FPRepSem : public FPStorage<fp_type> {
 protected:
   using typename UP::Exponent;
   using typename UP::Significand;
+  using UP::bits;
   using UP::encode;
   using UP::exp_bits;
   using UP::exp_sig_bits;
@@ -435,6 +449,12 @@ struct FPRepSem : public FPStorage<fp_type> {
   LIBC_INLINE constexpr bool is_normal() const {
     return is_finite() && !is_subnormal();
   }
+  LIBC_INLINE constexpr RetT next_toward_inf() const {
+    if (is_finite())
+      return RetT(bits + StorageType(1));
+    return RetT(bits);
+  }
+
   // Returns the mantissa with the implicit bit set iff the current
   // value is a valid normal number.
   LIBC_INLINE constexpr StorageType get_explicit_mantissa() const {
@@ -551,6 +571,21 @@ struct FPRepSem<FPType::X86_Binary80, RetT>
       return false;
     return get_implicit_bit();
   }
+  LIBC_INLINE constexpr RetT next_toward_inf() const {
+    if (is_finite()) {
+      if (exp_sig_bits() == max_normal().uintval()) {
+        return inf(sign());
+      } else if (exp_sig_bits() == max_subnormal().uintval()) {
+        return min_normal(sign());
+      } else if (sig_bits() == SIG_MASK) {
+        return RetT(encode(sign(), ++biased_exponent(), Significand::ZERO()));
+      } else {
+        return RetT(bits + StorageType(1));
+      }
+    }
+    return RetT(bits);
+  }
+
   LIBC_INLINE constexpr StorageType get_explicit_mantissa() const {
     return sig_bits();
   }
@@ -653,6 +688,7 @@ struct FPRepImpl : public FPRepSem<fp_type, RetT> {
   using UP::is_signaling_nan;
   using UP::is_subnormal;
   using UP::is_zero;
+  using UP::next_toward_inf;
   using UP::sign;
   LIBC_INLINE constexpr bool is_inf_or_nan() const { return !is_finite(); }
   LIBC_INLINE constexpr bool is_neg() const { return sign().is_neg(); }

libc/test/src/__support/FPUtil/fpbits_test.cpp

@@ -306,6 +306,27 @@ TYPED_TEST(LlvmLibcFPBitsTest, Properties, FPTypes) {
   }
 }
 
+#define ASSERT_SAME_REP(A, B) ASSERT_EQ(A.uintval(), B.uintval());
+
+TYPED_TEST(LlvmLibcFPBitsTest, NextTowardInf, FPTypes) {
+  struct {
+    FP before, after;
+  } TEST_CASES[] = {
+      {FP::ZERO, FP::MIN_SUBNORMAL},          //
+      {FP::MAX_SUBNORMAL, FP::MIN_NORMAL},    //
+      {FP::MAX_NORMAL, FP::INF},              //
+      {FP::INF, FP::INF},                     //
+      {FP::QUIET_NAN, FP::QUIET_NAN},         //
+      {FP::SIGNALING_NAN, FP::SIGNALING_NAN}, //
+  };
+  for (Sign sign : all_signs) {
+    for (auto tc : TEST_CASES) {
+      T val = make<T>(sign, tc.before);
+      ASSERT_SAME_REP(val.next_toward_inf(), make<T>(sign, tc.after));
+    }
+  }
+}
+
 TEST(LlvmLibcFPBitsTest, FloatType) {
   using FloatBits = FPBits<float>;
 

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

@@ -666,6 +666,7 @@ libc_support_library(
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
+        ":__support_libc_assert",
         ":__support_macros_attributes",
         ":__support_macros_properties_float",
         ":__support_math_extras",