Author: Guillaume Chatelet Date: 2023-12-13T09:54:13+01:00 New Revision: d5a74566ca46cbb84945b0a523ccd44adb075071
URL: https://github.com/llvm/llvm-project/commit/d5a74566ca46cbb84945b0a523ccd44adb075071 DIFF: https://github.com/llvm/llvm-project/commit/d5a74566ca46cbb84945b0a523ccd44adb075071.diff LOG: Revert "[libc][NFC] Implement `FPBits` in terms of `FloatProperties` to reduce clutter (#75196)" This reverts commit f64a0576ad4fbdf6a514ae89f90814c8f4c6e254. Added: Modified: libc/src/__support/FPUtil/FPBits.h libc/src/__support/FPUtil/Hypot.h libc/src/__support/FPUtil/generic/FMod.h libc/src/__support/FPUtil/x86_64/LongDoubleBits.h libc/src/__support/str_to_float.h libc/src/math/generic/acoshf.cpp libc/src/math/generic/asinhf.cpp libc/src/math/generic/atanhf.cpp libc/src/math/generic/erff.cpp libc/src/math/generic/explogxf.h libc/src/math/generic/inv_trigf_utils.h libc/src/math/generic/log.cpp libc/src/math/generic/log10.cpp libc/src/math/generic/log1p.cpp libc/src/math/generic/log2.cpp libc/src/math/generic/sinhf.cpp libc/src/math/generic/tanhf.cpp Removed: ################################################################################ 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 diff erent 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 +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 fputil::FloatProperties<long double>; + using FloatProp = typename FPBits::FloatProp; 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 fputil::FloatProperties<T>; + using FloatProp = typename FPBits::FloatProp; 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 fputil::FloatProperties<T>; + using FloatProp = typename FPBits::FloatProp; 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 fputil::FloatProperties<T>; + using FloatProp = typename FPBits::FloatProp; 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 f782c004312e10..9438be1bee74eb 100644 --- a/libc/src/math/generic/acoshf.cpp +++ b/libc/src/math/generic/acoshf.cpp @@ -19,8 +19,8 @@ namespace LIBC_NAMESPACE { LLVM_LIBC_FUNCTION(float, acoshf, (float x)) { - using FPBits = typename fputil::FPBits<float>; - FPBits xbits(x); + using FPBits_t = typename fputil::FPBits<float>; + FPBits_t xbits(x); uint32_t x_u = xbits.uintval(); if (LIBC_UNLIKELY(x <= 1.0f)) { @@ -29,12 +29,12 @@ LLVM_LIBC_FUNCTION(float, acoshf, (float x)) { // x < 1. fputil::set_errno_if_required(EDOM); fputil::raise_except_if_required(FE_INVALID); - return FPBits::build_quiet_nan(0); + return FPBits_t::build_quiet_nan(0); } if (LIBC_UNLIKELY(x_u >= 0x4f8ffb03)) { // Check for exceptional values. - uint32_t x_abs = x_u & FPBits::EXP_MANT_MASK; + uint32_t x_abs = x_u & FPBits_t::FloatProp::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 325c30c3c04e09..6bde08d42a429c 100644 --- a/libc/src/math/generic/asinhf.cpp +++ b/libc/src/math/generic/asinhf.cpp @@ -18,10 +18,10 @@ namespace LIBC_NAMESPACE { LLVM_LIBC_FUNCTION(float, asinhf, (float x)) { - using FPBits = typename fputil::FPBits<float>; - FPBits xbits(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::EXP_MANT_MASK; + uint32_t x_abs = x_u & FPBits_t::FloatProp::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 dfec28e9a44a72..839ef5b076ac35 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::EXP_MANT_MASK; + uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::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 d63fb8e31384d2..a7b0897c3b58cb 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::MANTISSA_WIDTH; + const uint32_t EIGHT = 3 << FPBits::FloatProp::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 055fb6c2947984..77ec9cb94e0854 100644 --- a/libc/src/math/generic/explogxf.h +++ b/libc/src/math/generic/explogxf.h @@ -274,17 +274,18 @@ template <bool is_sinh> LIBC_INLINE double exp_pm_eval(float x) { // x should be positive, normal finite value LIBC_INLINE static double log2_eval(double x) { - using FPBits = fputil::FPBits<double>; - FPBits bs(x); + using FPB = fputil::FPBits<double>; + FPB bs(x); double result = 0; result += bs.get_exponent(); - int p1 = (bs.get_mantissa() >> (FPBits::MANTISSA_WIDTH - LOG_P1_BITS)) & - (LOG_P1_SIZE - 1); + int p1 = + (bs.get_mantissa() >> (FPB::FloatProp::MANTISSA_WIDTH - LOG_P1_BITS)) & + (LOG_P1_SIZE - 1); - bs.bits &= FPBits::MANTISSA_MASK >> LOG_P1_BITS; - bs.set_biased_exponent(FPBits::EXPONENT_BIAS); + bs.bits &= FPB::FloatProp::MANTISSA_MASK >> LOG_P1_BITS; + bs.set_biased_exponent(FPB::FloatProp::EXPONENT_BIAS); double dx = (bs.get_val() - 1.0) * LOG_P1_1_OVER[p1]; // Taylor series for log(2,1+x) @@ -303,18 +304,19 @@ LIBC_INLINE static double log2_eval(double x) { LIBC_INLINE static double log_eval(double x) { // For x = 2^ex * (1 + mx) // log(x) = ex * log(2) + log(1 + mx) - using FPBits = fputil::FPBits<double>; - FPBits bs(x); + using FPB = fputil::FPBits<double>; + FPB bs(x); double ex = static_cast<double>(bs.get_exponent()); // p1 is the leading 7 bits of mx, i.e. // p1 * 2^(-7) <= m_x < (p1 + 1) * 2^(-7). - int p1 = static_cast<int>(bs.get_mantissa() >> (FPBits::MANTISSA_WIDTH - 7)); + int p1 = static_cast<int>(bs.get_mantissa() >> + (FPB::FloatProp::MANTISSA_WIDTH - 7)); // Set bs to (1 + (mx - p1*2^(-7)) - bs.bits &= FPBits::MANTISSA_MASK >> 7; - bs.set_biased_exponent(FPBits::EXPONENT_BIAS); + bs.bits &= FPB::FloatProp::MANTISSA_MASK >> 7; + bs.set_biased_exponent(FPB::FloatProp::EXPONENT_BIAS); // dx = (mx - p1*2^(-7)) / (1 + p1*2^(-7)). double dx = (bs.get_val() - 1.0) * ONE_OVER_F[p1]; diff --git a/libc/src/math/generic/inv_trigf_utils.h b/libc/src/math/generic/inv_trigf_utils.h index 5779e689383464..c88ded20b5bf24 100644 --- a/libc/src/math/generic/inv_trigf_utils.h +++ b/libc/src/math/generic/inv_trigf_utils.h @@ -37,21 +37,21 @@ extern const double ATAN_K[5]; // x should be positive, normal finite value LIBC_INLINE double atan_eval(double x) { - using FPBits = fputil::FPBits<double>; + using FPB = fputil::FPBits<double>; // Added some small value to umin and umax mantissa to avoid possible rounding // errors. - FPBits::UIntType umin = - FPBits::create_value(false, FPBits::EXPONENT_BIAS - ATAN_T_BITS - 1, - 0x100000000000UL) + FPB::UIntType umin = + FPB::create_value(false, FPB::EXPONENT_BIAS - ATAN_T_BITS - 1, + 0x100000000000UL) .uintval(); - FPBits::UIntType umax = - FPBits::create_value(false, FPBits::EXPONENT_BIAS + ATAN_T_BITS, - 0xF000000000000UL) + FPB::UIntType umax = + FPB::create_value(false, FPB::EXPONENT_BIAS + ATAN_T_BITS, + 0xF000000000000UL) .uintval(); - FPBits bs(x); + FPB bs(x); bool sign = bs.get_sign(); - auto x_abs = bs.uintval() & FPBits::EXP_MANT_MASK; + auto x_abs = bs.uintval() & FPB::FloatProp::EXP_MANT_MASK; if (x_abs <= umin) { double pe = LIBC_NAMESPACE::fputil::polyeval( @@ -67,7 +67,7 @@ LIBC_INLINE double atan_eval(double x) { return fputil::multiply_add(pe, one_over_x_m, sign ? (-M_MATH_PI_2) : (M_MATH_PI_2)); } - double pos_x = FPBits(x_abs).get_val(); + double pos_x = FPB(x_abs).get_val(); bool one_over_x = pos_x > 1.0; if (one_over_x) { pos_x = 1.0 / pos_x; diff --git a/libc/src/math/generic/log.cpp b/libc/src/math/generic/log.cpp index b278f66718c742..dfa41ad64578d3 100644 --- a/libc/src/math/generic/log.cpp +++ b/libc/src/math/generic/log.cpp @@ -730,29 +730,29 @@ double log_accurate(int e_x, int index, double m_x) { } // namespace LLVM_LIBC_FUNCTION(double, log, (double x)) { - using FPBits = typename fputil::FPBits<double>; - FPBits xbits(x); + using FPBits_t = typename fputil::FPBits<double>; + FPBits_t xbits(x); uint64_t x_u = xbits.uintval(); - int x_e = -FPBits::EXPONENT_BIAS; + int x_e = -FPBits_t::EXPONENT_BIAS; if (LIBC_UNLIKELY(x_u == 0x3FF0'0000'0000'0000ULL)) { // log(1.0) = +0.0 return 0.0; } - if (LIBC_UNLIKELY(xbits.uintval() < FPBits::MIN_NORMAL || - xbits.uintval() > FPBits::MAX_NORMAL)) { + if (LIBC_UNLIKELY(xbits.uintval() < FPBits_t::MIN_NORMAL || + xbits.uintval() > FPBits_t::MAX_NORMAL)) { if (xbits.is_zero()) { // return -Inf and raise FE_DIVBYZERO. fputil::set_errno_if_required(ERANGE); fputil::raise_except_if_required(FE_DIVBYZERO); - return static_cast<double>(FPBits::neg_inf()); + return static_cast<double>(FPBits_t::neg_inf()); } if (xbits.get_sign() && !xbits.is_nan()) { fputil::set_errno_if_required(EDOM); fputil::raise_except_if_required(FE_INVALID); - return FPBits::build_quiet_nan(0); + return FPBits_t::build_quiet_nan(0); } if (xbits.is_inf_or_nan()) { return x; @@ -786,7 +786,7 @@ LLVM_LIBC_FUNCTION(double, log, (double x)) { // Set m = 1.mantissa. uint64_t x_m = (x_u & 0x000F'FFFF'FFFF'FFFFULL) | 0x3FF0'0000'0000'0000ULL; - double m = FPBits(x_m).get_val(); + double m = FPBits_t(x_m).get_val(); double u, u_sq, err; fputil::DoubleDouble r1; @@ -796,7 +796,7 @@ LLVM_LIBC_FUNCTION(double, log, (double x)) { u = fputil::multiply_add(r, m, -1.0); // exact #else uint64_t c_m = x_m & 0x3FFF'E000'0000'0000ULL; - double c = FPBits(c_m).get_val(); + double c = FPBits_t(c_m).get_val(); u = fputil::multiply_add(r, m - c, CD[index]); // exact #endif // LIBC_TARGET_CPU_HAS_FMA diff --git a/libc/src/math/generic/log10.cpp b/libc/src/math/generic/log10.cpp index e33f0d4306950b..2a801c6e98429a 100644 --- a/libc/src/math/generic/log10.cpp +++ b/libc/src/math/generic/log10.cpp @@ -731,29 +731,29 @@ double log10_accurate(int e_x, int index, double m_x) { } // namespace LLVM_LIBC_FUNCTION(double, log10, (double x)) { - using FPBits = typename fputil::FPBits<double>; - FPBits xbits(x); + using FPBits_t = typename fputil::FPBits<double>; + FPBits_t xbits(x); uint64_t x_u = xbits.uintval(); - int x_e = -FPBits::EXPONENT_BIAS; + int x_e = -FPBits_t::EXPONENT_BIAS; if (LIBC_UNLIKELY(x_u == 0x3FF0'0000'0000'0000ULL)) { // log10(1.0) = +0.0 return 0.0; } - if (LIBC_UNLIKELY(xbits.uintval() < FPBits::MIN_NORMAL || - xbits.uintval() > FPBits::MAX_NORMAL)) { + if (LIBC_UNLIKELY(xbits.uintval() < FPBits_t::MIN_NORMAL || + xbits.uintval() > FPBits_t::MAX_NORMAL)) { if (xbits.is_zero()) { // return -Inf and raise FE_DIVBYZERO. fputil::set_errno_if_required(ERANGE); fputil::raise_except_if_required(FE_DIVBYZERO); - return static_cast<double>(FPBits::neg_inf()); + return static_cast<double>(FPBits_t::neg_inf()); } if (xbits.get_sign() && !xbits.is_nan()) { fputil::set_errno_if_required(EDOM); fputil::raise_except_if_required(FE_INVALID); - return FPBits::build_quiet_nan(0); + return FPBits_t::build_quiet_nan(0); } if (xbits.is_inf_or_nan()) { return x; @@ -787,7 +787,7 @@ LLVM_LIBC_FUNCTION(double, log10, (double x)) { // Set m = 1.mantissa. uint64_t x_m = (x_u & 0x000F'FFFF'FFFF'FFFFULL) | 0x3FF0'0000'0000'0000ULL; - double m = FPBits(x_m).get_val(); + double m = FPBits_t(x_m).get_val(); double u, u_sq, err; fputil::DoubleDouble r1; @@ -797,7 +797,7 @@ LLVM_LIBC_FUNCTION(double, log10, (double x)) { u = fputil::multiply_add(r, m, -1.0); // exact #else uint64_t c_m = x_m & 0x3FFF'E000'0000'0000ULL; - double c = FPBits(c_m).get_val(); + double c = FPBits_t(c_m).get_val(); u = fputil::multiply_add(r, m - c, CD[index]); // exact #endif // LIBC_TARGET_CPU_HAS_FMA diff --git a/libc/src/math/generic/log1p.cpp b/libc/src/math/generic/log1p.cpp index bde759bef291dd..c8b45fd57b42f8 100644 --- a/libc/src/math/generic/log1p.cpp +++ b/libc/src/math/generic/log1p.cpp @@ -871,11 +871,11 @@ LIBC_INLINE double log1p_accurate(int e_x, int index, } // namespace LLVM_LIBC_FUNCTION(double, log1p, (double x)) { - using FPBits = typename fputil::FPBits<double>; - constexpr int EXPONENT_BIAS = FPBits::EXPONENT_BIAS; - constexpr int MANTISSA_WIDTH = FPBits::MANTISSA_WIDTH; - constexpr uint64_t MANTISSA_MASK = FPBits::MANTISSA_MASK; - FPBits xbits(x); + using FPBits_t = typename fputil::FPBits<double>; + constexpr int EXPONENT_BIAS = FPBits_t::EXPONENT_BIAS; + constexpr int MANTISSA_WIDTH = FPBits_t::FloatProp::MANTISSA_WIDTH; + constexpr uint64_t MANTISSA_MASK = FPBits_t::FloatProp::MANTISSA_MASK; + FPBits_t xbits(x); uint64_t x_u = xbits.uintval(); fputil::DoubleDouble x_dd{0.0, 0.0}; @@ -886,19 +886,19 @@ LLVM_LIBC_FUNCTION(double, log1p, (double x)) { // |x| >= 1 if (LIBC_UNLIKELY(x_u >= 0x4650'0000'0000'0000ULL)) { // x >= 2^102 or x is negative, inf, or NaN - if (LIBC_UNLIKELY(x_u > FPBits::MAX_NORMAL)) { + if (LIBC_UNLIKELY(x_u > FPBits_t::MAX_NORMAL)) { // x <= -1.0 or x is Inf or NaN if (x_u == 0xbff0'0000'0000'0000ULL) { // x = -1.0 fputil::set_errno_if_required(ERANGE); fputil::raise_except_if_required(FE_DIVBYZERO); - return static_cast<double>(FPBits::neg_inf()); + return static_cast<double>(FPBits_t::neg_inf()); } if (xbits.get_sign() && !xbits.is_nan()) { // x < -1.0 fputil::set_errno_if_required(EDOM); fputil::raise_except_if_required(FE_INVALID); - return FPBits::build_quiet_nan(0); + return FPBits_t::build_quiet_nan(0); } // x is +Inf or NaN return x; @@ -928,11 +928,11 @@ LLVM_LIBC_FUNCTION(double, log1p, (double x)) { bool rdn = (tn - 0x1p-24f != tn); if (x > 0 && rdp) { - return FPBits(x_u - 1).get_val(); + return FPBits_t(x_u - 1).get_val(); } if (x < 0 && rdn) { - return FPBits(x_u + 1).get_val(); + return FPBits_t(x_u + 1).get_val(); } return x; @@ -945,7 +945,7 @@ LLVM_LIBC_FUNCTION(double, log1p, (double x)) { // |x_dd.hi| >= 2^-54 // |x_dd.lo| < ulp(x_dd.hi) - FPBits xhi_bits(x_dd.hi); + FPBits_t xhi_bits(x_dd.hi); x_u = xhi_bits.uintval(); // Range reduction: // Find k such that |x_hi - k * 2^-7| <= 2^-8. @@ -969,10 +969,10 @@ LLVM_LIBC_FUNCTION(double, log1p, (double x)) { // Scaling factior = 2^(-xh_bits.get_exponent()) uint64_t s_u = (static_cast<uint64_t>(EXPONENT_BIAS) << (MANTISSA_WIDTH + 1)) - - (x_u & FPBits::EXPONENT_MASK); + (x_u & FPBits_t::FloatProp::EXPONENT_MASK); // When the exponent of x is 2^1023, its inverse, 2^(-1023), is subnormal. const double EXPONENT_CORRECTION[2] = {0.0, 0x1.0p-1023}; - double scaling = FPBits(s_u).get_val() + EXPONENT_CORRECTION[s_u == 0]; + double scaling = FPBits_t(s_u).get_val() + EXPONENT_CORRECTION[s_u == 0]; // Normalize arguments: // 1 <= m_dd.hi < 2 // |m_dd.lo| < 2^-52. @@ -999,8 +999,8 @@ LLVM_LIBC_FUNCTION(double, log1p, (double x)) { v_hi = fputil::multiply_add(r, m_dd.hi, -1.0); // Exact. #else // c = 1 + idx * 2^-7. - double c = FPBits((static_cast<uint64_t>(idx) << (MANTISSA_WIDTH - 7)) + - uint64_t(0x3FF0'0000'0000'0000ULL)) + double c = FPBits_t((static_cast<uint64_t>(idx) << (MANTISSA_WIDTH - 7)) + + uint64_t(0x3FF0'0000'0000'0000ULL)) .get_val(); v_hi = fputil::multiply_add(r, m_dd.hi - c, RCM1[idx]); // Exact #endif // LIBC_TARGET_CPU_HAS_FMA diff --git a/libc/src/math/generic/log2.cpp b/libc/src/math/generic/log2.cpp index cb09e865b7d577..2ceddf87dfd560 100644 --- a/libc/src/math/generic/log2.cpp +++ b/libc/src/math/generic/log2.cpp @@ -852,29 +852,29 @@ double log2_accurate(int e_x, int index, double m_x) { } // namespace LLVM_LIBC_FUNCTION(double, log2, (double x)) { - using FPBits = typename fputil::FPBits<double>; - FPBits xbits(x); + using FPBits_t = typename fputil::FPBits<double>; + FPBits_t xbits(x); uint64_t x_u = xbits.uintval(); - int x_e = -FPBits::EXPONENT_BIAS; + int x_e = -FPBits_t::EXPONENT_BIAS; if (LIBC_UNLIKELY(x_u == 0x3FF0'0000'0000'0000ULL)) { // log2(1.0) = +0.0 return 0.0; } - if (LIBC_UNLIKELY(xbits.uintval() < FPBits::MIN_NORMAL || - xbits.uintval() > FPBits::MAX_NORMAL)) { + if (LIBC_UNLIKELY(xbits.uintval() < FPBits_t::MIN_NORMAL || + xbits.uintval() > FPBits_t::MAX_NORMAL)) { if (xbits.is_zero()) { // return -Inf and raise FE_DIVBYZERO. fputil::set_errno_if_required(ERANGE); fputil::raise_except_if_required(FE_DIVBYZERO); - return static_cast<double>(FPBits::neg_inf()); + return static_cast<double>(FPBits_t::neg_inf()); } if (xbits.get_sign() && !xbits.is_nan()) { fputil::set_errno_if_required(EDOM); fputil::raise_except_if_required(FE_INVALID); - return FPBits::build_quiet_nan(0); + return FPBits_t::build_quiet_nan(0); } if (xbits.is_inf_or_nan()) { return x; @@ -901,7 +901,7 @@ LLVM_LIBC_FUNCTION(double, log2, (double x)) { // Set m = 1.mantissa. uint64_t x_m = (x_u & 0x000F'FFFF'FFFF'FFFFULL) | 0x3FF0'0000'0000'0000ULL; - double m = FPBits(x_m).get_val(); + double m = FPBits_t(x_m).get_val(); double u, u_sq, err; fputil::DoubleDouble r1; @@ -911,7 +911,7 @@ LLVM_LIBC_FUNCTION(double, log2, (double x)) { u = fputil::multiply_add(r, m, -1.0); // exact #else uint64_t c_m = x_m & 0x3FFF'E000'0000'0000ULL; - double c = FPBits(c_m).get_val(); + double c = FPBits_t(c_m).get_val(); u = fputil::multiply_add(r, m - c, CD[index]); // exact #endif // LIBC_TARGET_CPU_HAS_FMA diff --git a/libc/src/math/generic/sinhf.cpp b/libc/src/math/generic/sinhf.cpp index db6794620b068c..2f48ddbc0f88d3 100644 --- a/libc/src/math/generic/sinhf.cpp +++ b/libc/src/math/generic/sinhf.cpp @@ -17,7 +17,7 @@ namespace LIBC_NAMESPACE { LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { using FPBits = typename fputil::FPBits<float>; FPBits xbits(x); - uint32_t x_abs = xbits.uintval() & FPBits::EXP_MANT_MASK; + uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK; // When |x| >= 90, or x is inf or nan if (LIBC_UNLIKELY(x_abs >= 0x42b4'0000U || x_abs <= 0x3da0'0000U)) { @@ -57,7 +57,8 @@ LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { int rounding = fputil::quick_get_round(); if (sign) { if (LIBC_UNLIKELY(rounding == FE_UPWARD || rounding == FE_TOWARDZERO)) - return FPBits(FPBits::MAX_NORMAL | FPBits::SIGN_MASK).get_val(); + return FPBits(FPBits::MAX_NORMAL | FPBits::FloatProp::SIGN_MASK) + .get_val(); } else { if (LIBC_UNLIKELY(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)) return FPBits(FPBits::MAX_NORMAL).get_val(); diff --git a/libc/src/math/generic/tanhf.cpp b/libc/src/math/generic/tanhf.cpp index a0046d3dabc62d..7d9f86cf9044b2 100644 --- a/libc/src/math/generic/tanhf.cpp +++ b/libc/src/math/generic/tanhf.cpp @@ -24,7 +24,7 @@ LLVM_LIBC_FUNCTION(float, tanhf, (float x)) { using FPBits = typename fputil::FPBits<float>; FPBits xbits(x); uint32_t x_u = xbits.uintval(); - uint32_t x_abs = x_u & FPBits::EXP_MANT_MASK; + uint32_t x_abs = x_u & FPBits::FloatProp::EXP_MANT_MASK; // When |x| >= 15, or x is inf or nan, or |x| <= 0.078125 if (LIBC_UNLIKELY((x_abs >= 0x4170'0000U) || (x_abs <= 0x3da0'0000U))) { _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
