[reland][libc][NFC] Implement FPBits in terms of FloatProperties to reduce clutter (#75196)
#75318
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…to reduce clutter (llvm#75196) Also make type naming consistent by using `UIntType` instead of `intU_t`. This patch does not include the "use `FPBits` instead of `FPBits_t`, `FPB`" part. This needs more work.
|
@llvm/pr-subscribers-libc Author: Guillaume Chatelet (gchatelet) ChangesAlso make type naming consistent by using Patch is 25.00 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/75318.diff 13 Files Affected:
diff --git a/libc/src/__support/FPUtil/FPBits.h b/libc/src/__support/FPUtil/FPBits.h
index 65c53921181a73..bef166e14d72b2 100644
--- a/libc/src/__support/FPUtil/FPBits.h
+++ b/libc/src/__support/FPUtil/FPBits.h
@@ -36,71 +36,74 @@ template <typename T> struct ExponentWidth {
// floating numbers. On x86 platforms however, the 'long double' type maps to
// an x87 floating point format. This format is an IEEE 754 extension format.
// It is handled as an explicit specialization of this class.
-template <typename T> struct FPBits {
+template <typename T> struct FPBits : private FloatProperties<T> {
static_assert(cpp::is_floating_point_v<T>,
"FPBits instantiated with invalid type.");
+ using typename FloatProperties<T>::UIntType;
+ using FloatProperties<T>::BIT_WIDTH;
+ using FloatProperties<T>::EXP_MANT_MASK;
+ using FloatProperties<T>::EXPONENT_MASK;
+ using FloatProperties<T>::EXPONENT_BIAS;
+ using FloatProperties<T>::EXPONENT_WIDTH;
+ using FloatProperties<T>::MANTISSA_MASK;
+ using FloatProperties<T>::MANTISSA_WIDTH;
+ using FloatProperties<T>::QUIET_NAN_MASK;
+ using FloatProperties<T>::SIGN_MASK;
// Reinterpreting bits as an integer value and interpreting the bits of an
// integer value as a floating point value is used in tests. So, a convenient
// type is provided for such reinterpretations.
- using FloatProp = FloatProperties<T>;
- using UIntType = typename FloatProp::UIntType;
-
UIntType bits;
LIBC_INLINE constexpr void set_mantissa(UIntType mantVal) {
- mantVal &= (FloatProp::MANTISSA_MASK);
- bits &= ~(FloatProp::MANTISSA_MASK);
+ mantVal &= MANTISSA_MASK;
+ bits &= ~MANTISSA_MASK;
bits |= mantVal;
}
LIBC_INLINE constexpr UIntType get_mantissa() const {
- return bits & FloatProp::MANTISSA_MASK;
+ return bits & MANTISSA_MASK;
}
LIBC_INLINE constexpr void set_biased_exponent(UIntType expVal) {
- expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
- bits &= ~(FloatProp::EXPONENT_MASK);
+ expVal = (expVal << MANTISSA_WIDTH) & EXPONENT_MASK;
+ bits &= ~EXPONENT_MASK;
bits |= expVal;
}
LIBC_INLINE constexpr uint16_t get_biased_exponent() const {
- return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
- (FloatProp::MANTISSA_WIDTH));
+ return uint16_t((bits & EXPONENT_MASK) >> MANTISSA_WIDTH);
}
// The function return mantissa with the implicit bit set iff the current
// value is a valid normal number.
LIBC_INLINE constexpr UIntType get_explicit_mantissa() {
return ((get_biased_exponent() > 0 && !is_inf_or_nan())
- ? (FloatProp::MANTISSA_MASK + 1)
+ ? (MANTISSA_MASK + 1)
: 0) |
- (FloatProp::MANTISSA_MASK & bits);
+ (MANTISSA_MASK & bits);
}
LIBC_INLINE constexpr void set_sign(bool signVal) {
- bits |= FloatProp::SIGN_MASK;
+ bits |= SIGN_MASK;
if (!signVal)
- bits -= FloatProp::SIGN_MASK;
+ bits -= SIGN_MASK;
}
LIBC_INLINE constexpr bool get_sign() const {
- return (bits & FloatProp::SIGN_MASK) != 0;
+ return (bits & SIGN_MASK) != 0;
}
static_assert(sizeof(T) == sizeof(UIntType),
"Data type and integral representation have different sizes.");
- static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
- static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
+ static constexpr int MAX_EXPONENT = (1 << EXPONENT_WIDTH) - 1;
static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
- static constexpr UIntType MAX_SUBNORMAL =
- (UIntType(1) << MantissaWidth<T>::VALUE) - 1;
- static constexpr UIntType MIN_NORMAL =
- (UIntType(1) << MantissaWidth<T>::VALUE);
+ static constexpr UIntType MAX_SUBNORMAL = (UIntType(1) << MANTISSA_WIDTH) - 1;
+ static constexpr UIntType MIN_NORMAL = (UIntType(1) << MANTISSA_WIDTH);
static constexpr UIntType MAX_NORMAL =
- ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
+ ((UIntType(MAX_EXPONENT) - 1) << MANTISSA_WIDTH) | MAX_SUBNORMAL;
// We don't want accidental type promotions/conversions, so we require exact
// type match.
@@ -151,32 +154,29 @@ template <typename T> struct FPBits {
}
LIBC_INLINE constexpr bool is_inf() const {
- return (bits & FloatProp::EXP_MANT_MASK) == FloatProp::EXPONENT_MASK;
+ return (bits & EXP_MANT_MASK) == EXPONENT_MASK;
}
LIBC_INLINE constexpr bool is_nan() const {
- return (bits & FloatProp::EXP_MANT_MASK) > FloatProp::EXPONENT_MASK;
+ return (bits & EXP_MANT_MASK) > EXPONENT_MASK;
}
LIBC_INLINE constexpr bool is_quiet_nan() const {
- return (bits & FloatProp::EXP_MANT_MASK) ==
- (FloatProp::EXPONENT_MASK | FloatProp::QUIET_NAN_MASK);
+ return (bits & EXP_MANT_MASK) == (EXPONENT_MASK | QUIET_NAN_MASK);
}
LIBC_INLINE constexpr bool is_inf_or_nan() const {
- return (bits & FloatProp::EXPONENT_MASK) == FloatProp::EXPONENT_MASK;
+ return (bits & EXPONENT_MASK) == EXPONENT_MASK;
}
LIBC_INLINE static constexpr T zero(bool sign = false) {
- return FPBits(sign ? FloatProp::SIGN_MASK : UIntType(0)).get_val();
+ return FPBits(sign ? SIGN_MASK : UIntType(0)).get_val();
}
LIBC_INLINE static constexpr T neg_zero() { return zero(true); }
LIBC_INLINE static constexpr T inf(bool sign = false) {
- return FPBits((sign ? FloatProp::SIGN_MASK : UIntType(0)) |
- FloatProp::EXPONENT_MASK)
- .get_val();
+ return FPBits((sign ? SIGN_MASK : UIntType(0)) | EXPONENT_MASK).get_val();
}
LIBC_INLINE static constexpr T neg_inf() { return inf(true); }
@@ -204,7 +204,7 @@ template <typename T> struct FPBits {
}
LIBC_INLINE static constexpr T build_quiet_nan(UIntType v) {
- return build_nan(FloatProp::QUIET_NAN_MASK | v);
+ return build_nan(QUIET_NAN_MASK | v);
}
// The function convert integer number and unbiased exponent to proper float
@@ -220,7 +220,7 @@ template <typename T> struct FPBits {
LIBC_INLINE static constexpr FPBits<T> make_value(UIntType number, int ep) {
FPBits<T> result;
// offset: +1 for sign, but -1 for implicit first bit
- int lz = cpp::countl_zero(number) - FloatProp::EXPONENT_WIDTH;
+ int lz = cpp::countl_zero(number) - EXPONENT_WIDTH;
number <<= lz;
ep -= lz;
diff --git a/libc/src/__support/FPUtil/generic/FMod.h b/libc/src/__support/FPUtil/generic/FMod.h
index 7502660c88a133..f30586f9d7f341 100644
--- a/libc/src/__support/FPUtil/generic/FMod.h
+++ b/libc/src/__support/FPUtil/generic/FMod.h
@@ -167,11 +167,11 @@ template <typename T> struct FModFastMathWrapper {
template <typename T> class FModDivisionSimpleHelper {
private:
- using intU_t = typename FPBits<T>::UIntType;
+ using UIntType = typename FPBits<T>::UIntType;
public:
- LIBC_INLINE constexpr static intU_t
- execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
+ LIBC_INLINE constexpr static UIntType
+ execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
while (exp_diff > sides_zeroes_count) {
exp_diff -= sides_zeroes_count;
m_x <<= sides_zeroes_count;
@@ -186,23 +186,22 @@ template <typename T> class FModDivisionSimpleHelper {
template <typename T> class FModDivisionInvMultHelper {
private:
using FPB = FPBits<T>;
- using intU_t = typename FPB::UIntType;
+ using UIntType = typename FPB::UIntType;
public:
- LIBC_INLINE constexpr static intU_t
- execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
+ LIBC_INLINE constexpr static UIntType
+ execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
if (exp_diff > sides_zeroes_count) {
- intU_t inv_hy = (cpp::numeric_limits<intU_t>::max() / m_y);
+ UIntType inv_hy = (cpp::numeric_limits<UIntType>::max() / m_y);
while (exp_diff > sides_zeroes_count) {
exp_diff -= sides_zeroes_count;
- intU_t hd =
- (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - sides_zeroes_count);
+ UIntType hd = (m_x * inv_hy) >> (FPB::BIT_WIDTH - sides_zeroes_count);
m_x <<= sides_zeroes_count;
m_x -= hd * m_y;
while (LIBC_UNLIKELY(m_x > m_y))
m_x -= m_y;
}
- intU_t hd = (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - exp_diff);
+ UIntType hd = (m_x * inv_hy) >> (FPB::BIT_WIDTH - exp_diff);
m_x <<= exp_diff;
m_x -= hd * m_y;
while (LIBC_UNLIKELY(m_x > m_y))
@@ -223,7 +222,7 @@ class FMod {
private:
using FPB = FPBits<T>;
- using intU_t = typename FPB::UIntType;
+ using UIntType = typename FPB::UIntType;
LIBC_INLINE static constexpr FPB eval_internal(FPB sx, FPB sy) {
@@ -237,11 +236,11 @@ class FMod {
int e_y = sy.get_biased_exponent();
// Most common case where |y| is "very normal" and |x/y| < 2^EXPONENT_WIDTH
- if (LIBC_LIKELY(e_y > int(FPB::FloatProp::MANTISSA_WIDTH) &&
- e_x - e_y <= int(FPB::FloatProp::EXPONENT_WIDTH))) {
- intU_t m_x = sx.get_explicit_mantissa();
- intU_t m_y = sy.get_explicit_mantissa();
- intU_t d = (e_x == e_y) ? (m_x - m_y) : (m_x << (e_x - e_y)) % m_y;
+ if (LIBC_LIKELY(e_y > int(FPB::MANTISSA_WIDTH) &&
+ e_x - e_y <= int(FPB::EXPONENT_WIDTH))) {
+ UIntType m_x = sx.get_explicit_mantissa();
+ UIntType m_y = sy.get_explicit_mantissa();
+ UIntType d = (e_x == e_y) ? (m_x - m_y) : (m_x << (e_x - e_y)) % m_y;
if (d == 0)
return FPB(FPB::zero());
// iy - 1 because of "zero power" for number with power 1
@@ -255,11 +254,11 @@ class FMod {
}
// Note that hx is not subnormal by conditions above.
- intU_t m_x = sx.get_explicit_mantissa();
+ UIntType m_x = sx.get_explicit_mantissa();
e_x--;
- intU_t m_y = sy.get_explicit_mantissa();
- int lead_zeros_m_y = FPB::FloatProp::EXPONENT_WIDTH;
+ UIntType m_y = sy.get_explicit_mantissa();
+ int lead_zeros_m_y = FPB::EXPONENT_WIDTH;
if (LIBC_LIKELY(e_y > 0)) {
e_y--;
} else {
@@ -282,9 +281,8 @@ class FMod {
{
// Shift hx left until the end or n = 0
- int left_shift = exp_diff < int(FPB::FloatProp::EXPONENT_WIDTH)
- ? exp_diff
- : FPB::FloatProp::EXPONENT_WIDTH;
+ int left_shift =
+ exp_diff < int(FPB::EXPONENT_WIDTH) ? exp_diff : FPB::EXPONENT_WIDTH;
m_x <<= left_shift;
exp_diff -= left_shift;
}
diff --git a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
index f1ef928f230819..f682f171bcab63 100644
--- a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
+++ b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
@@ -26,10 +26,18 @@
namespace LIBC_NAMESPACE {
namespace fputil {
-template <> struct FPBits<long double> {
- using UIntType = UInt128;
+template <> struct FPBits<long double> : private FloatProperties<long double> {
+ using typename FloatProperties<long double>::UIntType;
+ using FloatProperties<long double>::BIT_WIDTH;
+ using FloatProperties<long double>::EXP_MANT_MASK;
+ using FloatProperties<long double>::EXPONENT_MASK;
+ using FloatProperties<long double>::EXPONENT_BIAS;
+ using FloatProperties<long double>::EXPONENT_WIDTH;
+ using FloatProperties<long double>::MANTISSA_MASK;
+ using FloatProperties<long double>::MANTISSA_WIDTH;
+ using FloatProperties<long double>::QUIET_NAN_MASK;
+ using FloatProperties<long double>::SIGN_MASK;
- static constexpr int EXPONENT_BIAS = 0x3FFF;
static constexpr int MAX_EXPONENT = 0x7FFF;
static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
// Subnormal numbers include the implicit bit in x86 long double formats.
@@ -41,59 +49,52 @@ template <> struct FPBits<long double> {
(UIntType(MAX_EXPONENT - 1) << (MantissaWidth<long double>::VALUE + 1)) |
(UIntType(1) << MantissaWidth<long double>::VALUE) | MAX_SUBNORMAL;
- using FloatProp = FloatProperties<long double>;
-
UIntType bits;
LIBC_INLINE constexpr void set_mantissa(UIntType mantVal) {
- mantVal &= (FloatProp::MANTISSA_MASK);
- bits &= ~(FloatProp::MANTISSA_MASK);
+ mantVal &= MANTISSA_MASK;
+ bits &= ~MANTISSA_MASK;
bits |= mantVal;
}
LIBC_INLINE constexpr UIntType get_mantissa() const {
- return bits & FloatProp::MANTISSA_MASK;
+ return bits & MANTISSA_MASK;
}
LIBC_INLINE constexpr UIntType get_explicit_mantissa() const {
// The x86 80 bit float represents the leading digit of the mantissa
// explicitly. This is the mask for that bit.
- constexpr UIntType EXPLICIT_BIT_MASK =
- (UIntType(1) << FloatProp::MANTISSA_WIDTH);
- return bits & (FloatProp::MANTISSA_MASK | EXPLICIT_BIT_MASK);
+ constexpr UIntType EXPLICIT_BIT_MASK = UIntType(1) << MANTISSA_WIDTH;
+ return bits & (MANTISSA_MASK | EXPLICIT_BIT_MASK);
}
LIBC_INLINE constexpr void set_biased_exponent(UIntType expVal) {
- expVal =
- (expVal << (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH)) &
- FloatProp::EXPONENT_MASK;
- bits &= ~(FloatProp::EXPONENT_MASK);
+ expVal = (expVal << (BIT_WIDTH - 1 - EXPONENT_WIDTH)) & EXPONENT_MASK;
+ bits &= ~EXPONENT_MASK;
bits |= expVal;
}
LIBC_INLINE constexpr uint16_t get_biased_exponent() const {
- return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
- (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH));
+ return uint16_t((bits & EXPONENT_MASK) >> (BIT_WIDTH - 1 - EXPONENT_WIDTH));
}
LIBC_INLINE constexpr void set_implicit_bit(bool implicitVal) {
- bits &= ~(UIntType(1) << FloatProp::MANTISSA_WIDTH);
- bits |= (UIntType(implicitVal) << FloatProp::MANTISSA_WIDTH);
+ bits &= ~(UIntType(1) << MANTISSA_WIDTH);
+ bits |= (UIntType(implicitVal) << MANTISSA_WIDTH);
}
LIBC_INLINE constexpr bool get_implicit_bit() const {
- return bool((bits & (UIntType(1) << FloatProp::MANTISSA_WIDTH)) >>
- FloatProp::MANTISSA_WIDTH);
+ return bool((bits & (UIntType(1) << MANTISSA_WIDTH)) >> MANTISSA_WIDTH);
}
LIBC_INLINE constexpr void set_sign(bool signVal) {
- bits &= ~(FloatProp::SIGN_MASK);
- UIntType sign1 = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
+ bits &= ~SIGN_MASK;
+ UIntType sign1 = UIntType(signVal) << (BIT_WIDTH - 1);
bits |= sign1;
}
LIBC_INLINE constexpr bool get_sign() const {
- return bool((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
+ return bool((bits & SIGN_MASK) >> (BIT_WIDTH - 1));
}
LIBC_INLINE constexpr FPBits() : bits(0) {}
@@ -117,7 +118,7 @@ template <> struct FPBits<long double> {
LIBC_INLINE constexpr UIntType uintval() {
// We zero the padding bits as they can contain garbage.
- return bits & FloatProp::FP_MASK;
+ return bits & FP_MASK;
}
LIBC_INLINE constexpr long double get_val() const {
@@ -196,7 +197,7 @@ template <> struct FPBits<long double> {
}
LIBC_INLINE static constexpr long double build_quiet_nan(UIntType v) {
- return build_nan(FloatProp::QUIET_NAN_MASK | v);
+ return build_nan(QUIET_NAN_MASK | v);
}
LIBC_INLINE static constexpr long double min_normal() {
diff --git a/libc/src/__support/str_to_float.h b/libc/src/__support/str_to_float.h
index 2a6f15c018f1ec..3807d3ff572162 100644
--- a/libc/src/__support/str_to_float.h
+++ b/libc/src/__support/str_to_float.h
@@ -71,7 +71,7 @@ LIBC_INLINE cpp::optional<ExpandedFloat<T>>
eisel_lemire(ExpandedFloat<T> init_num,
RoundDirection round = RoundDirection::Nearest) {
using FPBits = typename fputil::FPBits<T>;
- using FloatProp = typename FPBits::FloatProp;
+ using FloatProp = typename fputil::FloatProperties<T>;
using UIntType = typename FPBits::UIntType;
UIntType mantissa = init_num.mantissa;
@@ -184,7 +184,7 @@ LIBC_INLINE cpp::optional<ExpandedFloat<long double>>
eisel_lemire<long double>(ExpandedFloat<long double> init_num,
RoundDirection round) {
using FPBits = typename fputil::FPBits<long double>;
- using FloatProp = typename FPBits::FloatProp;
+ using FloatProp = typename fputil::FloatProperties<long double>;
using UIntType = typename FPBits::UIntType;
UIntType mantissa = init_num.mantissa;
@@ -322,7 +322,7 @@ LIBC_INLINE FloatConvertReturn<T>
simple_decimal_conversion(const char *__restrict numStart,
RoundDirection round = RoundDirection::Nearest) {
using FPBits = typename fputil::FPBits<T>;
- using FloatProp = typename FPBits::FloatProp;
+ using FloatProp = typename fputil::FloatProperties<T>;
using UIntType = typename FPBits::UIntType;
int32_t exp2 = 0;
@@ -516,7 +516,7 @@ LIBC_INLINE cpp::optional<ExpandedFloat<T>>
clinger_fast_path(ExpandedFloat<T> init_num,
RoundDirection round = RoundDirection::Nearest) {
using FPBits = typename fputil::FPBits<T>;
- using FloatProp = typename FPBits::FloatProp;
+ using FloatProp = typename fputil::FloatProperties<T>;
using UIntType = typename FPBits::UIntType;
UIntType mantissa = init_num.mantissa;
@@ -724,7 +724,7 @@ LIBC_INLINE FloatConvertReturn<T> binary_exp_to_float(ExpandedFloat<T> init_num,
bool truncated,
RoundDirection round) {
using FPBits = typename fputil::FPBits<T>;
- using FloatProp = typename FPBits::FloatProp;
+ using FloatProp = typename fputil::FloatProperties<T>;
using UIntType = typename FPBits::UIntType;
UIntType mantissa = init_num.mantissa;
diff --git a/libc/src/math/generic/acoshf.cpp b/libc/src/math/generic/acoshf.cpp
index 9438be1bee74eb..142c17795d083a 100644
--- a/libc/src/math/generic/acoshf.cpp
+++ b/libc/src/math/generic/acoshf.cpp
@@ -34,7 +34,7 @@ LLVM_LIBC_FUNCTION(float, acoshf, (float x)) {
if (LIBC_UNLIKELY(x_u >= 0x4f8ffb03)) {
// Check for exceptional values.
- uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK;
+ uint32_t x_abs = x_u & FPBits_t::EXP_MANT_MASK;
if (LIBC_UNLIKELY(x_abs >= 0x7f80'0000U)) {
// x is +inf or NaN.
return x;
diff --git a/libc/src/math/generic/asinhf.cpp b/libc/src/math/generic/asinhf.cpp
index 6bde08d42a429c..5b2f63d3fe144e 100644
--- a/libc/src/math/generic/asinhf.cpp
+++ b/libc/src/math/generic/asinhf.cpp
@@ -21,7 +21,7 @@ LLVM_LIBC_FUNCTION(float, asinhf, (float x)) {
using FPBits_t = typename fputil::FPBits<float>;
FPBits_t xbits(x);
uint32_t x_u = xbits.uintval();
- uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK;
+ uint32_t x_abs = x_u & FPBits_t::EXP_MANT_MASK;
// |x| <= 2^-3
if (LIBC_UNLIKELY(x_abs <= 0x3e80'0000U)) {
diff --git a/libc/src/math/generic/atanhf.cpp b/libc/src/math/generic/atanhf.cpp
index 839ef5b076ac35..dfec28e9a44a72 100644
--- a/libc/src/math/generic/atanhf.cpp
+++ b/libc/src/math/generic/atanhf.cpp
@@ -17,7 +17,7 @@ LLVM_LIBC_FUNCTION(float, atanhf, (float x)) {
using FPBits = typename fputil::FPBits<float>;
FPBits xbits(x);
bool sign = xbits.get_sign();
- uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK;
+ uint32_t x_abs = xbits.uintval() & FPBits::EXP_MANT_MASK;
// |x| >= 1.0
if (LIBC_UNLIKELY(x_abs >= 0x3F80'0000U)) {
diff --git a/libc/src/math/generic/erff.cpp b/libc/src/math/generic/erff.cpp
index a7b0897c3b58cb..d63fb8e31384d2 100644
--- a/libc/src/math/generic/erff.cpp
+++ b/libc/src/math/generic/erff.cpp
@@ -154,7 +154,7 @@ LLVM_LIBC_FUNCTION(float, erff, (float x)) {
double xd = static_cast<double>(x);
double xsq = xd * xd;
- const uint32_t EIGHT = 3 << FPBits::FloatProp::MANTISSA_WIDTH;
+ const uint32_t EIGHT = 3 << FPBits::MANTISSA_WIDTH;
int idx = static_cast<int>(FPBits(x_abs + EIGHT).get_val());
double x4 = xsq * xsq;
diff --git a/libc/src/math/generic/explogxf.h b/libc/src/math/generic/explogxf.h
index 77ec9cb94e0854..3dae5af068b4b0 100644
--- a/libc/src/math/generic/explogxf.h
+++ b/libc/src/math/generic/explogxf.h
@@ -280,12 +280,11 @@ LIBC_INLINE static double log2_eval(double x) {
double result = 0;
result += bs.get_exponent();
- int p1 =
- (bs.get_mantissa() >> (FPB::FloatProp::MANTISSA_WIDTH - LOG_P1_BITS)) &
- (LOG_P1_SIZE - 1);
+ int p1 = (bs.get_mantissa() >> ...
[truncated]
|
gchatelet
deleted the
reland-75196-implement_fp_bits_in_terms_of_float_properties
branch
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Also make type naming consistent by using
UIntTypeinstead ofintU_t.This patch is a reland of #75196 but does not include the "use
FPBitsinstead ofFPBits_t,FPB" part. This needs more work.