[libc-commits] [libc] [libc][NFC] Remove `FloatProperties` (PR #76508)
via libc-commits
libc-commits at lists.llvm.org
Thu Dec 28 07:09:17 PST 2023
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libc
Author: Guillaume Chatelet (gchatelet)
<details>
<summary>Changes</summary>
Access is now done through `FPBits` exclusively.
This patch also renames a few internal structs and uses `T` instead of `FP` as a template parameter.
---
Patch is 33.32 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/76508.diff
26 Files Affected:
- (modified) libc/fuzzing/stdlib/strtofloat_fuzz.cpp (+3-4)
- (modified) libc/src/__support/FPUtil/FPBits.h (+24-26)
- (modified) libc/src/__support/FPUtil/ManipulationFunctions.h (+3-3)
- (modified) libc/src/__support/FPUtil/dyadic_float.h (+17-20)
- (modified) libc/src/__support/FPUtil/generic/FMA.h (+1-1)
- (modified) libc/src/__support/FPUtil/x86_64/LongDoubleBits.h (+2-3)
- (modified) libc/src/__support/float_to_string.h (+1-1)
- (modified) libc/src/__support/str_to_float.h (+7-7)
- (modified) libc/src/math/generic/exp.cpp (+1-1)
- (modified) libc/src/math/generic/exp10.cpp (+1-1)
- (modified) libc/src/math/generic/exp2.cpp (+1-1)
- (modified) libc/src/math/generic/exp2f_impl.h (+1-1)
- (modified) libc/src/math/generic/explogxf.h (+4-4)
- (modified) libc/src/math/generic/expm1.cpp (+1-1)
- (modified) libc/src/math/generic/powf.cpp (+5-5)
- (modified) libc/src/math/generic/range_reduction.h (+1-1)
- (modified) libc/src/math/generic/tanhf.cpp (+1-1)
- (modified) libc/src/stdio/printf_core/float_dec_converter.h (+4-5)
- (modified) libc/test/src/__support/str_to_fp_test.h (+1-1)
- (modified) libc/test/src/math/FrexpTest.h (+1-2)
- (modified) libc/test/src/math/LogbTest.h (+1-2)
- (modified) libc/test/src/math/SqrtTest.h (+1-2)
- (modified) libc/test/src/math/smoke/FrexpTest.h (+1-2)
- (modified) libc/test/src/math/smoke/LogbTest.h (+1-2)
- (modified) libc/test/src/math/smoke/SqrtTest.h (+1-2)
- (modified) libc/utils/MPFRWrapper/MPFRUtils.cpp (+1-1)
``````````diff
diff --git a/libc/fuzzing/stdlib/strtofloat_fuzz.cpp b/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
index 0e0d82fd3e8af9..affef6fcf549e0 100644
--- a/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
+++ b/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
@@ -22,18 +22,17 @@
#include "utils/MPFRWrapper/mpfr_inc.h"
-using LIBC_NAMESPACE::fputil::FloatProperties;
+using LIBC_NAMESPACE::fputil::FPBits;
// This function calculates the effective precision for a given float type and
// exponent. Subnormals have a lower effective precision since they don't
// necessarily use all of the bits of the mantissa.
template <typename F> inline constexpr int effective_precision(int exponent) {
- const int full_precision = FloatProperties<F>::MANTISSA_PRECISION;
+ const int full_precision = FPBits<F>::MANTISSA_PRECISION;
// This is intended to be 0 when the exponent is the lowest normal and
// increase as the exponent's magnitude increases.
- const int bits_below_normal =
- (-exponent) - (FloatProperties<F>::EXP_BIAS - 1);
+ const int bits_below_normal = (-exponent) - (FPBits<F>::EXP_BIAS - 1);
// The precision should be the normal, full precision, minus the bits lost
// by this being a subnormal, minus one for the implicit leading one.
diff --git a/libc/src/__support/FPUtil/FPBits.h b/libc/src/__support/FPUtil/FPBits.h
index d06625ed13852d..01a2ff2bc9dd67 100644
--- a/libc/src/__support/FPUtil/FPBits.h
+++ b/libc/src/__support/FPUtil/FPBits.h
@@ -39,9 +39,9 @@ enum class FPEncoding {
X86_ExtendedPrecision,
};
-template <FPType> struct FPBaseProperties {};
+template <FPType> struct FPBaseAttr {};
-template <> struct FPBaseProperties<FPType::IEEE754_Binary16> {
+template <> struct FPBaseAttr<FPType::IEEE754_Binary16> {
using StorageType = uint16_t;
LIBC_INLINE_VAR static constexpr int TOTAL_LEN = 16;
LIBC_INLINE_VAR static constexpr int SIG_LEN = 10;
@@ -49,7 +49,7 @@ template <> struct FPBaseProperties<FPType::IEEE754_Binary16> {
LIBC_INLINE_VAR static constexpr auto ENCODING = FPEncoding::IEEE754;
};
-template <> struct FPBaseProperties<FPType::IEEE754_Binary32> {
+template <> struct FPBaseAttr<FPType::IEEE754_Binary32> {
using StorageType = uint32_t;
LIBC_INLINE_VAR static constexpr int TOTAL_LEN = 32;
LIBC_INLINE_VAR static constexpr int SIG_LEN = 23;
@@ -57,7 +57,7 @@ template <> struct FPBaseProperties<FPType::IEEE754_Binary32> {
LIBC_INLINE_VAR static constexpr auto ENCODING = FPEncoding::IEEE754;
};
-template <> struct FPBaseProperties<FPType::IEEE754_Binary64> {
+template <> struct FPBaseAttr<FPType::IEEE754_Binary64> {
using StorageType = uint64_t;
LIBC_INLINE_VAR static constexpr int TOTAL_LEN = 64;
LIBC_INLINE_VAR static constexpr int SIG_LEN = 52;
@@ -65,7 +65,7 @@ template <> struct FPBaseProperties<FPType::IEEE754_Binary64> {
LIBC_INLINE_VAR static constexpr auto ENCODING = FPEncoding::IEEE754;
};
-template <> struct FPBaseProperties<FPType::IEEE754_Binary128> {
+template <> struct FPBaseAttr<FPType::IEEE754_Binary128> {
using StorageType = UInt128;
LIBC_INLINE_VAR static constexpr int TOTAL_LEN = 128;
LIBC_INLINE_VAR static constexpr int SIG_LEN = 112;
@@ -73,7 +73,7 @@ template <> struct FPBaseProperties<FPType::IEEE754_Binary128> {
LIBC_INLINE_VAR static constexpr auto ENCODING = FPEncoding::IEEE754;
};
-template <> struct FPBaseProperties<FPType::X86_Binary80> {
+template <> struct FPBaseAttr<FPType::X86_Binary80> {
using StorageType = UInt128;
LIBC_INLINE_VAR static constexpr int TOTAL_LEN = 80;
LIBC_INLINE_VAR static constexpr int SIG_LEN = 64;
@@ -85,9 +85,9 @@ template <> struct FPBaseProperties<FPType::X86_Binary80> {
} // namespace internal
template <FPType fp_type>
-struct FPProperties : public internal::FPBaseProperties<fp_type> {
+struct FPBaseMasksAndShifts : public internal::FPBaseAttr<fp_type> {
private:
- using UP = internal::FPBaseProperties<fp_type>;
+ using UP = internal::FPBaseAttr<fp_type>;
public:
// The number of bits to represent sign. For documentation purpose, always 1.
@@ -174,12 +174,12 @@ struct FPProperties : public internal::FPBaseProperties<fp_type> {
};
//-----------------------------------------------------------------------------
-template <typename FP> LIBC_INLINE static constexpr FPType get_fp_type() {
- if constexpr (cpp::is_same_v<FP, float> && __FLT_MANT_DIG__ == 24)
+template <typename T> LIBC_INLINE static constexpr FPType get_fp_type() {
+ if constexpr (cpp::is_same_v<T, float> && __FLT_MANT_DIG__ == 24)
return FPType::IEEE754_Binary32;
- else if constexpr (cpp::is_same_v<FP, double> && __DBL_MANT_DIG__ == 53)
+ else if constexpr (cpp::is_same_v<T, double> && __DBL_MANT_DIG__ == 53)
return FPType::IEEE754_Binary64;
- else if constexpr (cpp::is_same_v<FP, long double>) {
+ else if constexpr (cpp::is_same_v<T, long double>) {
if constexpr (__LDBL_MANT_DIG__ == 53)
return FPType::IEEE754_Binary64;
else if constexpr (__LDBL_MANT_DIG__ == 64)
@@ -188,30 +188,27 @@ template <typename FP> LIBC_INLINE static constexpr FPType get_fp_type() {
return FPType::IEEE754_Binary128;
}
#if defined(LIBC_COMPILER_HAS_C23_FLOAT16)
- else if constexpr (cpp::is_same_v<FP, _Float16>)
+ else if constexpr (cpp::is_same_v<T, _Float16>)
return FPType::IEEE754_Binary16;
#endif
#if defined(LIBC_COMPILER_HAS_C23_FLOAT128)
- else if constexpr (cpp::is_same_v<FP, _Float128>)
+ else if constexpr (cpp::is_same_v<T, _Float128>)
return FPType::IEEE754_Binary128;
#endif
#if defined(LIBC_COMPILER_HAS_FLOAT128_EXTENSION)
- else if constexpr (cpp::is_same_v<FP, __float128>)
+ else if constexpr (cpp::is_same_v<T, __float128>)
return FPType::IEEE754_Binary128;
#endif
else
- static_assert(cpp::always_false<FP>, "Unsupported type");
+ static_assert(cpp::always_false<T>, "Unsupported type");
}
-template <typename FP>
-struct FloatProperties : public FPProperties<get_fp_type<FP>()> {};
-
namespace internal {
// This is a temporary class to unify common methods and properties between
// FPBits and FPBits<long double>.
-template <FPType fp_type> struct FPBitsCommon : private FPProperties<fp_type> {
- using UP = FPProperties<fp_type>;
+template <FPType fp_type> struct FPRep : private FPBaseMasksAndShifts<fp_type> {
+ using UP = FPBaseMasksAndShifts<fp_type>;
using typename UP::StorageType;
using UP::TOTAL_LEN;
@@ -227,15 +224,17 @@ template <FPType fp_type> struct FPBitsCommon : private FPProperties<fp_type> {
using UP::FP_MASK;
using UP::FRACTION_LEN;
using UP::FRACTION_MASK;
+ using UP::MANTISSA_PRECISION;
using UP::SIGN_MASK;
+ using UP::STORAGE_LEN;
// 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.
StorageType bits;
- LIBC_INLINE constexpr FPBitsCommon() : bits(0) {}
- LIBC_INLINE explicit constexpr FPBitsCommon(StorageType bits) : bits(bits) {}
+ LIBC_INLINE constexpr FPRep() : bits(0) {}
+ LIBC_INLINE explicit constexpr FPRep(StorageType bits) : bits(bits) {}
LIBC_INLINE constexpr void set_mantissa(StorageType mantVal) {
mantVal &= FRACTION_MASK;
@@ -305,11 +304,10 @@ template <FPType fp_type> struct FPBitsCommon : private FPProperties<fp_type> {
// 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 : public internal::FPBitsCommon<get_fp_type<T>()> {
+template <typename T> struct FPBits : public internal::FPRep<get_fp_type<T>()> {
static_assert(cpp::is_floating_point_v<T>,
"FPBits instantiated with invalid type.");
- using UP = internal::FPBitsCommon<get_fp_type<T>()>;
+ using UP = internal::FPRep<get_fp_type<T>()>;
using StorageType = typename UP::StorageType;
using UP::bits;
diff --git a/libc/src/__support/FPUtil/ManipulationFunctions.h b/libc/src/__support/FPUtil/ManipulationFunctions.h
index a2064594e63a5c..42433b9b8442db 100644
--- a/libc/src/__support/FPUtil/ManipulationFunctions.h
+++ b/libc/src/__support/FPUtil/ManipulationFunctions.h
@@ -174,13 +174,13 @@ LIBC_INLINE T nextafter(T from, U to) {
} else {
int_val = FPBits<T>::MIN_SUBNORMAL;
if (to_bits.get_sign())
- int_val |= FloatProperties<T>::SIGN_MASK;
+ int_val |= FPBits<T>::SIGN_MASK;
}
- StorageType exponent_bits = int_val & FloatProperties<T>::EXP_MASK;
+ StorageType exponent_bits = int_val & FPBits<T>::EXP_MASK;
if (exponent_bits == StorageType(0))
raise_except_if_required(FE_UNDERFLOW | FE_INEXACT);
- else if (exponent_bits == FloatProperties<T>::EXP_MASK)
+ else if (exponent_bits == FPBits<T>::EXP_MASK)
raise_except_if_required(FE_OVERFLOW | FE_INEXACT);
return cpp::bit_cast<T>(int_val);
diff --git a/libc/src/__support/FPUtil/dyadic_float.h b/libc/src/__support/FPUtil/dyadic_float.h
index 561345fd87cfd7..ccd3c69bf3db2a 100644
--- a/libc/src/__support/FPUtil/dyadic_float.h
+++ b/libc/src/__support/FPUtil/dyadic_float.h
@@ -41,10 +41,10 @@ template <size_t Bits> struct DyadicFloat {
template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
DyadicFloat(T x) {
- static_assert(FloatProperties<T>::FRACTION_LEN < Bits);
+ static_assert(FPBits<T>::FRACTION_LEN < Bits);
FPBits<T> x_bits(x);
sign = x_bits.get_sign();
- exponent = x_bits.get_exponent() - FloatProperties<T>::FRACTION_LEN;
+ exponent = x_bits.get_exponent() - FPBits<T>::FRACTION_LEN;
mantissa = MantissaType(x_bits.get_explicit_mantissa());
normalize();
}
@@ -83,21 +83,20 @@ template <size_t Bits> struct DyadicFloat {
// Output is rounded correctly with respect to the current rounding mode.
// TODO(lntue): Add support for underflow.
// TODO(lntue): Test or add specialization for x86 long double.
- template <typename T, typename = cpp::enable_if_t<
- cpp::is_floating_point_v<T> &&
- (FloatProperties<T>::FRACTION_LEN < Bits),
- void>>
+ template <typename T,
+ typename = cpp::enable_if_t<cpp::is_floating_point_v<T> &&
+ (FPBits<T>::FRACTION_LEN < Bits),
+ void>>
explicit operator T() const {
// TODO(lntue): Do we need to treat signed zeros properly?
if (mantissa.is_zero())
return 0.0;
// Assume that it is normalized, and output is also normal.
- constexpr uint32_t PRECISION = FloatProperties<T>::MANTISSA_PRECISION;
+ constexpr uint32_t PRECISION = FPBits<T>::MANTISSA_PRECISION;
using output_bits_t = typename FPBits<T>::StorageType;
- int exp_hi =
- exponent + static_cast<int>((Bits - 1) + FloatProperties<T>::EXP_BIAS);
+ int exp_hi = exponent + static_cast<int>((Bits - 1) + FPBits<T>::EXP_BIAS);
bool denorm = false;
uint32_t shift = Bits - PRECISION;
@@ -106,7 +105,7 @@ template <size_t Bits> struct DyadicFloat {
denorm = true;
shift = (Bits - PRECISION) + static_cast<uint32_t>(1 - exp_hi);
- exp_hi = FloatProperties<T>::EXP_BIAS;
+ exp_hi = FPBits<T>::EXP_BIAS;
}
int exp_lo = exp_hi - static_cast<int>(PRECISION) - 1;
@@ -115,7 +114,7 @@ template <size_t Bits> struct DyadicFloat {
T d_hi = FPBits<T>::create_value(sign, exp_hi,
static_cast<output_bits_t>(m_hi) &
- FloatProperties<T>::FRACTION_MASK)
+ FPBits<T>::FRACTION_MASK)
.get_val();
const MantissaType round_mask = MantissaType(1) << (shift - 1);
@@ -129,15 +128,13 @@ template <size_t Bits> struct DyadicFloat {
if (LIBC_UNLIKELY(exp_lo <= 0)) {
// d_lo is denormal, but the output is normal.
int scale_up_exponent = 2 * PRECISION;
- T scale_up_factor = FPBits<T>::create_value(sign,
- FloatProperties<T>::EXP_BIAS +
- scale_up_exponent,
- output_bits_t(0))
- .get_val();
+ T scale_up_factor =
+ FPBits<T>::create_value(sign, FPBits<T>::EXP_BIAS + scale_up_exponent,
+ output_bits_t(0))
+ .get_val();
T scale_down_factor =
- FPBits<T>::create_value(
- sign, FloatProperties<T>::EXP_BIAS - scale_up_exponent,
- output_bits_t(0))
+ FPBits<T>::create_value(sign, FPBits<T>::EXP_BIAS - scale_up_exponent,
+ output_bits_t(0))
.get_val();
d_lo = FPBits<T>::create_value(sign, exp_lo + scale_up_exponent,
@@ -156,7 +153,7 @@ template <size_t Bits> struct DyadicFloat {
if (LIBC_UNLIKELY(denorm)) {
// Output is denormal, simply clear the exponent field.
output_bits_t clear_exp = output_bits_t(exp_hi)
- << FloatProperties<T>::FRACTION_LEN;
+ << FPBits<T>::FRACTION_LEN;
output_bits_t r_bits = FPBits<T>(r).uintval() - clear_exp;
return FPBits<T>(r_bits).get_val();
}
diff --git a/libc/src/__support/FPUtil/generic/FMA.h b/libc/src/__support/FPUtil/generic/FMA.h
index 4ba9e1d2be39e0..c587bf6ee85637 100644
--- a/libc/src/__support/FPUtil/generic/FMA.h
+++ b/libc/src/__support/FPUtil/generic/FMA.h
@@ -94,7 +94,7 @@ LIBC_INLINE bool shift_mantissa(int shift_length, UInt128 &mant) {
template <> LIBC_INLINE double fma<double>(double x, double y, double z) {
using FPBits = fputil::FPBits<double>;
- using FloatProp = fputil::FloatProperties<double>;
+ using FloatProp = fputil::FPBits<double>;
if (LIBC_UNLIKELY(x == 0 || y == 0 || z == 0)) {
return x * y + z;
diff --git a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
index 1011e61f03fd6b..4dc5d25e269820 100644
--- a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
+++ b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
@@ -27,9 +27,8 @@ namespace LIBC_NAMESPACE {
namespace fputil {
template <>
-struct FPBits<long double>
- : public internal::FPBitsCommon<FPType::X86_Binary80> {
- using UP = internal::FPBitsCommon<FPType::X86_Binary80>;
+struct FPBits<long double> : public internal::FPRep<FPType::X86_Binary80> {
+ using UP = internal::FPRep<FPType::X86_Binary80>;
using StorageType = typename UP::StorageType;
using UP::bits;
diff --git a/libc/src/__support/float_to_string.h b/libc/src/__support/float_to_string.h
index 923633e3d207f5..67eaa4b445a080 100644
--- a/libc/src/__support/float_to_string.h
+++ b/libc/src/__support/float_to_string.h
@@ -105,7 +105,7 @@ namespace LIBC_NAMESPACE {
using BlockInt = uint32_t;
constexpr uint32_t BLOCK_SIZE = 9;
-using FloatProp = fputil::FloatProperties<long double>;
+using FloatProp = fputil::FPBits<long double>;
// Larger numbers prefer a slightly larger constant than is used for the smaller
// numbers.
diff --git a/libc/src/__support/str_to_float.h b/libc/src/__support/str_to_float.h
index 36b512d6972a93..a4eafbac83650c 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 fputil::FPBits<T>;
using StorageType = typename FPBits::StorageType;
StorageType 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 fputil::FPBits<long double>;
using StorageType = typename FPBits::StorageType;
StorageType mantissa = init_num.mantissa;
@@ -321,7 +321,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 fputil::FPBits<T>;
using StorageType = typename FPBits::StorageType;
int32_t exp2 = 0;
@@ -515,7 +515,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 fputil::FPBits<T>;
using StorageType = typename FPBits::StorageType;
StorageType mantissa = init_num.mantissa;
@@ -605,7 +605,7 @@ clinger_fast_path(ExpandedFloat<T> init_num,
// log10(2^(exponent bias)).
// The generic approximation uses the fact that log10(2^x) ~= x/3
template <typename T> constexpr int32_t get_upper_bound() {
- return fputil::FloatProperties<T>::EXP_BIAS / 3;
+ return fputil::FPBits<T>::EXP_BIAS / 3;
}
template <> constexpr int32_t get_upper_bound<float>() { return 39; }
@@ -621,7 +621,7 @@ template <> constexpr int32_t get_upper_bound<double>() { return 309; }
// other out, and subnormal numbers allow for the result to be at the very low
// end of the final mantissa.
template <typename T> constexpr int32_t get_lower_bound() {
- using FloatProp = typename fputil::FloatProperties<T>;
+ using FloatProp = typename fputil::FPBits<T>;
return -(
(FloatProp::EXP_BIAS +
static_cast<int32_t>(FloatProp::FRACTION_LEN + FloatProp::STORAGE_LEN)) /
@@ -723,7 +723,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 fputil::FPBits<T>;
using StorageType = typename FPBits::StorageType;
StorageType mantissa = init_num.mantissa;
diff --git a/libc/src/math/generic/exp.cpp b/libc/src/math/generic/exp.cpp
index 5428a04430887f..c83441be28f2be 100644
--- a/libc/src/math/generic/exp.cpp
+++ b/libc/src/math/generic/exp.cpp
@@ -220,7 +220,7 @@ double set_exceptional(double x) {
LLVM_LIBC_FUNCTION(double, exp, (double x)) {
using FPBits = typename fputil::FPBits<double>;
- using FloatProp = typename fputil::FloatProperties<double>;
+ using FloatProp = typename fputil::FPBits<double>;
FPBits xbits(x);
uint64_t x_u = xbits.uintval();
diff --git a/libc/src/math/generic/exp10.cpp b/libc/src/math/generic/exp10.cpp
index aa66d4f17a3a02..cf7f3673b90872 100644
--- a/libc/src/math/generic/exp10.cpp
+++ b/libc/src/math/generic/exp10.cpp
@@ -270,7 +270,7 @@ double set_exceptional(double x) {
LLVM_LIBC_FUNCTION(double, exp10, (double x)) {
using FPBits = typename fputil::FPBits<double>;
- using FloatProp = typename fputil::FloatProperties<double>;
+ using FloatProp = typename fputil::FPBits<double>;
FPBits xbits(x);
uint64_t x_u = xbits.uintval();
diff --git a/libc/src/math/generic/exp2.cpp b/libc/src/math/generic/exp2.cpp
index 3e9f9c6855c436..cc0cc3337f558e 100644
--- a/libc/src/math/generic/exp2.cpp
+++ b/libc/src/math/generic/exp2.cpp
@@ -245,7 +245,7 @@ double set_exceptional(double x) {
LLVM_LIBC_FUNCTION(double, exp2, (double x)) {
using FPBits = typename fputil::FPBits<double>;
- using FloatProp = typename fputil::FloatProperties<double>;
+ using FloatProp = typename fputil::FPBits<double>;
FPBits xbits(x);
uint64_t x_u = xbits.uintval();
diff --git a/libc/src/math/generic/exp2f_impl.h b/libc/src/math/generic/exp2f_impl.h
index 1d86e4d08770ca..e6fd65264c721e 100644
--- a/libc/src/math/generic/exp2f_impl.h
+++ b/libc/src/math/generic/exp2f_impl.h
@@ -137...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/76508
More information about the libc-commits
mailing list