Revert "[libc][NFC] Implement FPBits in terms of FloatProperties to reduce clutter"
#75304
Conversation
This file contains 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
gchatelet
deleted the
revert-75196-implement_fp_bits_in_terms_of_float_properties
branch
|
@llvm/pr-subscribers-libc Author: Guillaume Chatelet (gchatelet) ChangesReverts llvm/llvm-project#75196 GCC complains about change of meaning for I'll reland with a different name. Patch is 40.11 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/75304.diff 17 Files Affected:
diff --git a/libc/src/__support/FPUtil/FPBits.h b/libc/src/__support/FPUtil/FPBits.h
index bef166e14d72b2..65c53921181a73 100644
--- a/libc/src/__support/FPUtil/FPBits.h
+++ b/libc/src/__support/FPUtil/FPBits.h
@@ -36,74 +36,71 @@ 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 : private FloatProperties<T> {
+template <typename T> struct FPBits {
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 &= MANTISSA_MASK;
- bits &= ~MANTISSA_MASK;
+ mantVal &= (FloatProp::MANTISSA_MASK);
+ bits &= ~(FloatProp::MANTISSA_MASK);
bits |= mantVal;
}
LIBC_INLINE constexpr UIntType get_mantissa() const {
- return bits & MANTISSA_MASK;
+ return bits & FloatProp::MANTISSA_MASK;
}
LIBC_INLINE constexpr void set_biased_exponent(UIntType expVal) {
- expVal = (expVal << MANTISSA_WIDTH) & EXPONENT_MASK;
- bits &= ~EXPONENT_MASK;
+ expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
+ bits &= ~(FloatProp::EXPONENT_MASK);
bits |= expVal;
}
LIBC_INLINE constexpr uint16_t get_biased_exponent() const {
- return uint16_t((bits & EXPONENT_MASK) >> MANTISSA_WIDTH);
+ return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
+ (FloatProp::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())
- ? (MANTISSA_MASK + 1)
+ ? (FloatProp::MANTISSA_MASK + 1)
: 0) |
- (MANTISSA_MASK & bits);
+ (FloatProp::MANTISSA_MASK & bits);
}
LIBC_INLINE constexpr void set_sign(bool signVal) {
- bits |= SIGN_MASK;
+ bits |= FloatProp::SIGN_MASK;
if (!signVal)
- bits -= SIGN_MASK;
+ bits -= FloatProp::SIGN_MASK;
}
LIBC_INLINE constexpr bool get_sign() const {
- return (bits & SIGN_MASK) != 0;
+ return (bits & FloatProp::SIGN_MASK) != 0;
}
static_assert(sizeof(T) == sizeof(UIntType),
"Data type and integral representation have different sizes.");
- static constexpr int MAX_EXPONENT = (1 << EXPONENT_WIDTH) - 1;
+ static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
+ static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
- static constexpr UIntType MAX_SUBNORMAL = (UIntType(1) << MANTISSA_WIDTH) - 1;
- static constexpr UIntType MIN_NORMAL = (UIntType(1) << MANTISSA_WIDTH);
+ 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_NORMAL =
- ((UIntType(MAX_EXPONENT) - 1) << MANTISSA_WIDTH) | MAX_SUBNORMAL;
+ ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
// We don't want accidental type promotions/conversions, so we require exact
// type match.
@@ -154,29 +151,32 @@ template <typename T> struct FPBits : private FloatProperties<T> {
}
LIBC_INLINE constexpr bool is_inf() const {
- return (bits & EXP_MANT_MASK) == EXPONENT_MASK;
+ return (bits & FloatProp::EXP_MANT_MASK) == FloatProp::EXPONENT_MASK;
}
LIBC_INLINE constexpr bool is_nan() const {
- return (bits & EXP_MANT_MASK) > EXPONENT_MASK;
+ return (bits & FloatProp::EXP_MANT_MASK) > FloatProp::EXPONENT_MASK;
}
LIBC_INLINE constexpr bool is_quiet_nan() const {
- return (bits & EXP_MANT_MASK) == (EXPONENT_MASK | QUIET_NAN_MASK);
+ return (bits & FloatProp::EXP_MANT_MASK) ==
+ (FloatProp::EXPONENT_MASK | FloatProp::QUIET_NAN_MASK);
}
LIBC_INLINE constexpr bool is_inf_or_nan() const {
- return (bits & EXPONENT_MASK) == EXPONENT_MASK;
+ return (bits & FloatProp::EXPONENT_MASK) == FloatProp::EXPONENT_MASK;
}
LIBC_INLINE static constexpr T zero(bool sign = false) {
- return FPBits(sign ? SIGN_MASK : UIntType(0)).get_val();
+ return FPBits(sign ? FloatProp::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 ? SIGN_MASK : UIntType(0)) | EXPONENT_MASK).get_val();
+ return FPBits((sign ? FloatProp::SIGN_MASK : UIntType(0)) |
+ FloatProp::EXPONENT_MASK)
+ .get_val();
}
LIBC_INLINE static constexpr T neg_inf() { return inf(true); }
@@ -204,7 +204,7 @@ template <typename T> struct FPBits : private FloatProperties<T> {
}
LIBC_INLINE static constexpr T build_quiet_nan(UIntType v) {
- return build_nan(QUIET_NAN_MASK | v);
+ return build_nan(FloatProp::QUIET_NAN_MASK | v);
}
// The function convert integer number and unbiased exponent to proper float
@@ -220,7 +220,7 @@ template <typename T> struct FPBits : private FloatProperties<T> {
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) - EXPONENT_WIDTH;
+ int lz = cpp::countl_zero(number) - FloatProp::EXPONENT_WIDTH;
number <<= lz;
ep -= lz;
diff --git a/libc/src/__support/FPUtil/Hypot.h b/libc/src/__support/FPUtil/Hypot.h
index ecf992c0d964c0..42d9e1b3f8cec5 100644
--- a/libc/src/__support/FPUtil/Hypot.h
+++ b/libc/src/__support/FPUtil/Hypot.h
@@ -104,14 +104,14 @@ template <> struct DoubleLength<uint64_t> {
//
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
LIBC_INLINE T hypot(T x, T y) {
- using FPBits = FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPBits_t = FPBits<T>;
+ using UIntType = typename FPBits<T>::UIntType;
using DUIntType = typename DoubleLength<UIntType>::Type;
- FPBits x_bits(x), y_bits(y);
+ FPBits_t x_bits(x), y_bits(y);
if (x_bits.is_inf() || y_bits.is_inf()) {
- return T(FPBits::inf());
+ return T(FPBits_t::inf());
}
if (x_bits.is_nan()) {
return x;
@@ -193,11 +193,11 @@ LIBC_INLINE T hypot(T x, T y) {
sticky_bits = sticky_bits || ((sum & 0x3U) != 0);
sum >>= 2;
++out_exp;
- if (out_exp >= FPBits::MAX_EXPONENT) {
+ if (out_exp >= FPBits_t::MAX_EXPONENT) {
if (int round_mode = quick_get_round();
round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
- return T(FPBits::inf());
- return T(FPBits(FPBits::MAX_NORMAL));
+ return T(FPBits_t::inf());
+ return T(FPBits_t(FPBits_t::MAX_NORMAL));
}
} else {
// For denormal result, we simply move the leading bit of the result to
@@ -251,10 +251,10 @@ LIBC_INLINE T hypot(T x, T y) {
if (y_new >= (ONE >> 1)) {
y_new -= ONE >> 1;
++out_exp;
- if (out_exp >= FPBits::MAX_EXPONENT) {
+ if (out_exp >= FPBits_t::MAX_EXPONENT) {
if (round_mode == FE_TONEAREST || round_mode == FE_UPWARD)
- return T(FPBits::inf());
- return T(FPBits(FPBits::MAX_NORMAL));
+ return T(FPBits_t::inf());
+ return T(FPBits_t(FPBits_t::MAX_NORMAL));
}
}
diff --git a/libc/src/__support/FPUtil/generic/FMod.h b/libc/src/__support/FPUtil/generic/FMod.h
index 5cf982150956e4..7502660c88a133 100644
--- a/libc/src/__support/FPUtil/generic/FMod.h
+++ b/libc/src/__support/FPUtil/generic/FMod.h
@@ -123,9 +123,9 @@ template <typename T> struct FModExceptionalInputHandler {
"FModCStandardWrapper instantiated with invalid type.");
LIBC_INLINE static bool pre_check(T x, T y, T &out) {
- using FPBits = fputil::FPBits<T>;
- const T quiet_nan = FPBits::build_quiet_nan(0);
- FPBits sx(x), sy(y);
+ using FPB = fputil::FPBits<T>;
+ const T quiet_nan = FPB::build_quiet_nan(0);
+ FPB sx(x), sy(y);
if (LIBC_LIKELY(!sy.is_zero() && !sy.is_inf_or_nan() &&
!sx.is_inf_or_nan())) {
return false;
@@ -167,11 +167,11 @@ template <typename T> struct FModFastMathWrapper {
template <typename T> class FModDivisionSimpleHelper {
private:
- using UIntType = typename FPBits<T>::UIntType;
+ using intU_t = typename FPBits<T>::UIntType;
public:
- LIBC_INLINE constexpr static UIntType
- execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
+ LIBC_INLINE constexpr static intU_t
+ execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
while (exp_diff > sides_zeroes_count) {
exp_diff -= sides_zeroes_count;
m_x <<= sides_zeroes_count;
@@ -185,24 +185,24 @@ template <typename T> class FModDivisionSimpleHelper {
template <typename T> class FModDivisionInvMultHelper {
private:
- using FPBits = FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = FPBits<T>;
+ using intU_t = typename FPB::UIntType;
public:
- LIBC_INLINE constexpr static UIntType
- execute(int exp_diff, int sides_zeroes_count, UIntType m_x, UIntType m_y) {
+ LIBC_INLINE constexpr static intU_t
+ execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
if (exp_diff > sides_zeroes_count) {
- UIntType inv_hy = (cpp::numeric_limits<UIntType>::max() / m_y);
+ intU_t inv_hy = (cpp::numeric_limits<intU_t>::max() / m_y);
while (exp_diff > sides_zeroes_count) {
exp_diff -= sides_zeroes_count;
- UIntType hd =
- (m_x * inv_hy) >> (FPBits::BIT_WIDTH - sides_zeroes_count);
+ intU_t hd =
+ (m_x * inv_hy) >> (FPB::FloatProp::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;
}
- UIntType hd = (m_x * inv_hy) >> (FPBits::BIT_WIDTH - exp_diff);
+ intU_t hd = (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - exp_diff);
m_x <<= exp_diff;
m_x -= hd * m_y;
while (LIBC_UNLIKELY(m_x > m_y))
@@ -222,44 +222,44 @@ class FMod {
"FMod instantiated with invalid type.");
private:
- using FPBits = FPBits<T>;
- using UIntType = typename FPBits::UIntType;
+ using FPB = FPBits<T>;
+ using intU_t = typename FPB::UIntType;
- LIBC_INLINE static constexpr FPBits eval_internal(FPBits sx, FPBits sy) {
+ LIBC_INLINE static constexpr FPB eval_internal(FPB sx, FPB sy) {
if (LIBC_LIKELY(sx.uintval() <= sy.uintval())) {
if (sx.uintval() < sy.uintval())
- return sx; // |x|<|y| return x
- return FPBits(FPBits::zero()); // |x|=|y| return 0.0
+ return sx; // |x|<|y| return x
+ return FPB(FPB::zero()); // |x|=|y| return 0.0
}
int e_x = sx.get_biased_exponent();
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(FPBits::MANTISSA_WIDTH) &&
- e_x - e_y <= int(FPBits::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 (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 (d == 0)
- return FPBits(FPBits::zero());
+ return FPB(FPB::zero());
// iy - 1 because of "zero power" for number with power 1
- return FPBits::make_value(d, e_y - 1);
+ return FPB::make_value(d, e_y - 1);
}
/* Both subnormal special case. */
if (LIBC_UNLIKELY(e_x == 0 && e_y == 0)) {
- FPBits d;
+ FPB d;
d.set_mantissa(sx.uintval() % sy.uintval());
return d;
}
// Note that hx is not subnormal by conditions above.
- UIntType m_x = sx.get_explicit_mantissa();
+ intU_t m_x = sx.get_explicit_mantissa();
e_x--;
- UIntType m_y = sy.get_explicit_mantissa();
- int lead_zeros_m_y = FPBits::EXPONENT_WIDTH;
+ intU_t m_y = sy.get_explicit_mantissa();
+ int lead_zeros_m_y = FPB::FloatProp::EXPONENT_WIDTH;
if (LIBC_LIKELY(e_y > 0)) {
e_y--;
} else {
@@ -282,34 +282,34 @@ class FMod {
{
// Shift hx left until the end or n = 0
- int left_shift = exp_diff < int(FPBits::EXPONENT_WIDTH)
+ int left_shift = exp_diff < int(FPB::FloatProp::EXPONENT_WIDTH)
? exp_diff
- : FPBits::EXPONENT_WIDTH;
+ : FPB::FloatProp::EXPONENT_WIDTH;
m_x <<= left_shift;
exp_diff -= left_shift;
}
m_x %= m_y;
if (LIBC_UNLIKELY(m_x == 0))
- return FPBits(FPBits::zero());
+ return FPB(FPB::zero());
if (exp_diff == 0)
- return FPBits::make_value(m_x, e_y);
+ return FPB::make_value(m_x, e_y);
/* hx next can't be 0, because hx < hy, hy % 2 == 1 hx * 2^i % hy != 0 */
m_x = DivisionHelper::execute(exp_diff, sides_zeroes_count, m_x, m_y);
- return FPBits::make_value(m_x, e_y);
+ return FPB::make_value(m_x, e_y);
}
public:
LIBC_INLINE static T eval(T x, T y) {
if (T out; Wrapper::pre_check(x, y, out))
return out;
- FPBits sx(x), sy(y);
+ FPB sx(x), sy(y);
bool sign = sx.get_sign();
sx.set_sign(false);
sy.set_sign(false);
- FPBits result = eval_internal(sx, sy);
+ FPB result = eval_internal(sx, sy);
result.set_sign(sign);
return result.get_val();
}
diff --git a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
index a7070291389496..f1ef928f230819 100644
--- a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
+++ b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
@@ -26,19 +26,10 @@
namespace LIBC_NAMESPACE {
namespace fputil {
-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;
+template <> struct FPBits<long double> {
+ using UIntType = UInt128;
+
+ 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.
@@ -50,52 +41,59 @@ template <> struct FPBits<long double> : private FloatProperties<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 &= MANTISSA_MASK;
- bits &= ~MANTISSA_MASK;
+ mantVal &= (FloatProp::MANTISSA_MASK);
+ bits &= ~(FloatProp::MANTISSA_MASK);
bits |= mantVal;
}
LIBC_INLINE constexpr UIntType get_mantissa() const {
- return bits & MANTISSA_MASK;
+ return bits & FloatProp::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) << MANTISSA_WIDTH;
- return bits & (MANTISSA_MASK | EXPLICIT_BIT_MASK);
+ constexpr UIntType EXPLICIT_BIT_MASK =
+ (UIntType(1) << FloatProp::MANTISSA_WIDTH);
+ return bits & (FloatProp::MANTISSA_MASK | EXPLICIT_BIT_MASK);
}
LIBC_INLINE constexpr void set_biased_exponent(UIntType expVal) {
- expVal = (expVal << (BIT_WIDTH - 1 - EXPONENT_WIDTH)) & EXPONENT_MASK;
- bits &= ~EXPONENT_MASK;
+ expVal =
+ (expVal << (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH)) &
+ FloatProp::EXPONENT_MASK;
+ bits &= ~(FloatProp::EXPONENT_MASK);
bits |= expVal;
}
LIBC_INLINE constexpr uint16_t get_biased_exponent() const {
- return uint16_t((bits & EXPONENT_MASK) >> (BIT_WIDTH - 1 - EXPONENT_WIDTH));
+ return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
+ (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH));
}
LIBC_INLINE constexpr void set_implicit_bit(bool implicitVal) {
- bits &= ~(UIntType(1) << MANTISSA_WIDTH);
- bits |= (UIntType(implicitVal) << MANTISSA_WIDTH);
+ bits &= ~(UIntType(1) << FloatProp::MANTISSA_WIDTH);
+ bits |= (UIntType(implicitVal) << FloatProp::MANTISSA_WIDTH);
}
LIBC_INLINE constexpr bool get_implicit_bit() const {
- return bool((bits & (UIntType(1) << MANTISSA_WIDTH)) >> MANTISSA_WIDTH);
+ return bool((bits & (UIntType(1) << FloatProp::MANTISSA_WIDTH)) >>
+ FloatProp::MANTISSA_WIDTH);
}
LIBC_INLINE constexpr void set_sign(bool signVal) {
- bits &= ~SIGN_MASK;
- UIntType sign1 = UIntType(signVal) << (BIT_WIDTH - 1);
+ bits &= ~(FloatProp::SIGN_MASK);
+ UIntType sign1 = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
bits |= sign1;
}
LIBC_INLINE constexpr bool get_sign() const {
- return bool((bits & SIGN_MASK) >> (BIT_WIDTH - 1));
+ return bool((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
}
LIBC_INLINE constexpr FPBits() : bits(0) {}
@@ -119,7 +117,7 @@ template <> struct FPBits<long double> : private FloatProperties<long double> {
LIBC_INLINE constexpr UIntType uintval() {
// We zero the padding bits as they can contain garbage.
- return bits & FP_MASK;
+ return bits & FloatProp::FP_MASK;
}
LIBC_INLINE constexpr long double get_val() const {
@@ -198,7 +196,7 @@ template <> struct FPBits<long double> : private FloatProperties<long double> {
}
LIBC_INLINE static constexpr long double build_quiet_nan(UIntType v) {
- return build_nan(QUIET_NAN_MASK | v);
+ return build_nan(FloatProp::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 3807d3ff572162..2a6f15c018f1ec 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 fputil::FloatProperties<T>;
+ using FloatProp = typename FPBits::FloatProp;
using UIntType = typename FPBits::UIntType;
UIntType mantissa = init_num.mantissa;
@@ -184,7 ...
[truncated]
|
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.
Reverts #75196
GCC complains about change of meaning for
FPBitsI'll reland with a different name.