87 changes: 49 additions & 38 deletions libc/test/src/__support/FPUtil/fpbits_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,117 +7,122 @@
//===----------------------------------------------------------------------===//

#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/fpbits_str.h"
#include "test/UnitTest/Test.h"

using __llvm_libc::fputil::FPBits;

TEST(LlvmLibcFPBitsTest, FloatType) {
EXPECT_STREQ(FPBits<float>::inf().str().c_str(), "(+Infinity)");
EXPECT_STREQ(FPBits<float>::neg_inf().str().c_str(), "(-Infinity)");
EXPECT_STREQ(FPBits<float>(FPBits<float>::build_nan(1)).str().c_str(),
"(NaN)");
EXPECT_STREQ(__llvm_libc::str(FPBits<float>::inf()).c_str(), "(+Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<float>::neg_inf()).c_str(),
"(-Infinity)");
EXPECT_STREQ(
__llvm_libc::str(FPBits<float>(FPBits<float>::build_nan(1))).c_str(),
"(NaN)");

FPBits<float> zero(0.0f);
EXPECT_EQ(zero.get_sign(), false);
EXPECT_EQ(zero.get_unbiased_exponent(), static_cast<uint16_t>(0));
EXPECT_EQ(zero.get_mantissa(), static_cast<uint32_t>(0));
EXPECT_EQ(zero.uintval(), static_cast<uint32_t>(0x00000000));
EXPECT_STREQ(zero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(zero).c_str(),
"0x00000000 = (S: 0, E: 0x0000, M: 0x00000000)");

FPBits<float> negzero(-0.0f);
EXPECT_EQ(negzero.get_sign(), true);
EXPECT_EQ(negzero.get_unbiased_exponent(), static_cast<uint16_t>(0));
EXPECT_EQ(negzero.get_mantissa(), static_cast<uint32_t>(0));
EXPECT_EQ(negzero.uintval(), static_cast<uint32_t>(0x80000000));
EXPECT_STREQ(negzero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negzero).c_str(),
"0x80000000 = (S: 1, E: 0x0000, M: 0x00000000)");

FPBits<float> one(1.0f);
EXPECT_EQ(one.get_sign(), false);
EXPECT_EQ(one.get_unbiased_exponent(), static_cast<uint16_t>(0x7F));
EXPECT_EQ(one.get_mantissa(), static_cast<uint32_t>(0));
EXPECT_EQ(one.uintval(), static_cast<uint32_t>(0x3F800000));
EXPECT_STREQ(one.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(one).c_str(),
"0x3F800000 = (S: 0, E: 0x007F, M: 0x00000000)");

FPBits<float> negone(-1.0f);
EXPECT_EQ(negone.get_sign(), true);
EXPECT_EQ(negone.get_unbiased_exponent(), static_cast<uint16_t>(0x7F));
EXPECT_EQ(negone.get_mantissa(), static_cast<uint32_t>(0));
EXPECT_EQ(negone.uintval(), static_cast<uint32_t>(0xBF800000));
EXPECT_STREQ(negone.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negone).c_str(),
"0xBF800000 = (S: 1, E: 0x007F, M: 0x00000000)");

FPBits<float> num(1.125f);
EXPECT_EQ(num.get_sign(), false);
EXPECT_EQ(num.get_unbiased_exponent(), static_cast<uint16_t>(0x7F));
EXPECT_EQ(num.get_mantissa(), static_cast<uint32_t>(0x00100000));
EXPECT_EQ(num.uintval(), static_cast<uint32_t>(0x3F900000));
EXPECT_STREQ(num.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(num).c_str(),
"0x3F900000 = (S: 0, E: 0x007F, M: 0x00100000)");

FPBits<float> negnum(-1.125f);
EXPECT_EQ(negnum.get_sign(), true);
EXPECT_EQ(negnum.get_unbiased_exponent(), static_cast<uint16_t>(0x7F));
EXPECT_EQ(negnum.get_mantissa(), static_cast<uint32_t>(0x00100000));
EXPECT_EQ(negnum.uintval(), static_cast<uint32_t>(0xBF900000));
EXPECT_STREQ(negnum.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negnum).c_str(),
"0xBF900000 = (S: 1, E: 0x007F, M: 0x00100000)");
}

TEST(LlvmLibcFPBitsTest, DoubleType) {
EXPECT_STREQ(FPBits<double>::inf().str().c_str(), "(+Infinity)");
EXPECT_STREQ(FPBits<double>::neg_inf().str().c_str(), "(-Infinity)");
EXPECT_STREQ(FPBits<double>(FPBits<double>::build_nan(1)).str().c_str(),
"(NaN)");
EXPECT_STREQ(__llvm_libc::str(FPBits<double>::inf()).c_str(), "(+Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<double>::neg_inf()).c_str(),
"(-Infinity)");
EXPECT_STREQ(
__llvm_libc::str(FPBits<double>(FPBits<double>::build_nan(1))).c_str(),
"(NaN)");

FPBits<double> zero(0.0);
EXPECT_EQ(zero.get_sign(), false);
EXPECT_EQ(zero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
EXPECT_EQ(zero.get_mantissa(), static_cast<uint64_t>(0x0000000000000000));
EXPECT_EQ(zero.uintval(), static_cast<uint64_t>(0x0000000000000000));
EXPECT_STREQ(zero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(zero).c_str(),
"0x0000000000000000 = (S: 0, E: 0x0000, M: 0x0000000000000000)");

FPBits<double> negzero(-0.0);
EXPECT_EQ(negzero.get_sign(), true);
EXPECT_EQ(negzero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
EXPECT_EQ(negzero.get_mantissa(), static_cast<uint64_t>(0x0000000000000000));
EXPECT_EQ(negzero.uintval(), static_cast<uint64_t>(0x8000000000000000));
EXPECT_STREQ(negzero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negzero).c_str(),
"0x8000000000000000 = (S: 1, E: 0x0000, M: 0x0000000000000000)");

FPBits<double> one(1.0);
EXPECT_EQ(one.get_sign(), false);
EXPECT_EQ(one.get_unbiased_exponent(), static_cast<uint16_t>(0x03FF));
EXPECT_EQ(one.get_mantissa(), static_cast<uint64_t>(0x0000000000000000));
EXPECT_EQ(one.uintval(), static_cast<uint64_t>(0x3FF0000000000000));
EXPECT_STREQ(one.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(one).c_str(),
"0x3FF0000000000000 = (S: 0, E: 0x03FF, M: 0x0000000000000000)");

FPBits<double> negone(-1.0);
EXPECT_EQ(negone.get_sign(), true);
EXPECT_EQ(negone.get_unbiased_exponent(), static_cast<uint16_t>(0x03FF));
EXPECT_EQ(negone.get_mantissa(), static_cast<uint64_t>(0x0000000000000000));
EXPECT_EQ(negone.uintval(), static_cast<uint64_t>(0xBFF0000000000000));
EXPECT_STREQ(negone.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negone).c_str(),
"0xBFF0000000000000 = (S: 1, E: 0x03FF, M: 0x0000000000000000)");

FPBits<double> num(1.125);
EXPECT_EQ(num.get_sign(), false);
EXPECT_EQ(num.get_unbiased_exponent(), static_cast<uint16_t>(0x03FF));
EXPECT_EQ(num.get_mantissa(), static_cast<uint64_t>(0x0002000000000000));
EXPECT_EQ(num.uintval(), static_cast<uint64_t>(0x3FF2000000000000));
EXPECT_STREQ(num.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(num).c_str(),
"0x3FF2000000000000 = (S: 0, E: 0x03FF, M: 0x0002000000000000)");

FPBits<double> negnum(-1.125);
EXPECT_EQ(negnum.get_sign(), true);
EXPECT_EQ(negnum.get_unbiased_exponent(), static_cast<uint16_t>(0x03FF));
EXPECT_EQ(negnum.get_mantissa(), static_cast<uint64_t>(0x0002000000000000));
EXPECT_EQ(negnum.uintval(), static_cast<uint64_t>(0xBFF2000000000000));
EXPECT_STREQ(negnum.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negnum).c_str(),
"0xBFF2000000000000 = (S: 1, E: 0x03FF, M: 0x0002000000000000)");
}

Expand All @@ -126,10 +131,13 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
if constexpr (sizeof(long double) == sizeof(double))
return; // The tests for the "double" type cover for this case.

EXPECT_STREQ(FPBits<long double>::inf().str().c_str(), "(+Infinity)");
EXPECT_STREQ(FPBits<long double>::neg_inf().str().c_str(), "(-Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<long double>::inf()).c_str(),
"(+Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<long double>::neg_inf()).c_str(),
"(-Infinity)");
EXPECT_STREQ(
FPBits<long double>(FPBits<long double>::build_nan(1)).str().c_str(),
__llvm_libc::str(FPBits<long double>(FPBits<long double>::build_nan(1)))
.c_str(),
"(NaN)");

FPBits<long double> zero(0.0l);
Expand All @@ -139,7 +147,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
<< 64);
EXPECT_EQ(zero.uintval(), static_cast<UInt128>(0x0000000000000000) << 64);
EXPECT_STREQ(
zero.str().c_str(),
__llvm_libc::str(zero).c_str(),
"0x00000000000000000000000000000000 = "
"(S: 0, E: 0x0000, I: 0, M: 0x00000000000000000000000000000000)");

Expand All @@ -150,7 +158,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
<< 64);
EXPECT_EQ(negzero.uintval(), static_cast<UInt128>(0x1) << 79);
EXPECT_STREQ(
negzero.str().c_str(),
__llvm_libc::str(negzero).c_str(),
"0x00000000000080000000000000000000 = "
"(S: 1, E: 0x0000, I: 0, M: 0x00000000000000000000000000000000)");

Expand All @@ -160,7 +168,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
EXPECT_EQ(one.get_mantissa(), static_cast<UInt128>(0x0000000000000000) << 64);
EXPECT_EQ(one.uintval(), static_cast<UInt128>(0x3FFF8) << 60);
EXPECT_STREQ(
one.str().c_str(),
__llvm_libc::str(one).c_str(),
"0x0000000000003FFF8000000000000000 = "
"(S: 0, E: 0x3FFF, I: 1, M: 0x00000000000000000000000000000000)");

Expand All @@ -171,7 +179,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
<< 64);
EXPECT_EQ(negone.uintval(), static_cast<UInt128>(0xBFFF8) << 60);
EXPECT_STREQ(
negone.str().c_str(),
__llvm_libc::str(negone).c_str(),
"0x000000000000BFFF8000000000000000 = "
"(S: 1, E: 0x3FFF, I: 1, M: 0x00000000000000000000000000000000)");

Expand All @@ -181,7 +189,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
EXPECT_EQ(num.get_mantissa(), static_cast<UInt128>(0x1) << 60);
EXPECT_EQ(num.uintval(), static_cast<UInt128>(0x3FFF9) << 60);
EXPECT_STREQ(
num.str().c_str(),
__llvm_libc::str(num).c_str(),
"0x0000000000003FFF9000000000000000 = "
"(S: 0, E: 0x3FFF, I: 1, M: 0x00000000000000001000000000000000)");

Expand All @@ -191,7 +199,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
EXPECT_EQ(negnum.get_mantissa(), static_cast<UInt128>(0x1) << 60);
EXPECT_EQ(negnum.uintval(), static_cast<UInt128>(0xBFFF9) << 60);
EXPECT_STREQ(
negnum.str().c_str(),
__llvm_libc::str(negnum).c_str(),
"0x000000000000BFFF9000000000000000 = "
"(S: 1, E: 0x3FFF, I: 1, M: 0x00000000000000001000000000000000)");
}
Expand All @@ -200,10 +208,13 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
#if defined(LONG_DOUBLE_IS_DOUBLE)
return; // The tests for the "double" type cover for this case.
#else
EXPECT_STREQ(FPBits<long double>::inf().str().c_str(), "(+Infinity)");
EXPECT_STREQ(FPBits<long double>::neg_inf().str().c_str(), "(-Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<long double>::inf()).c_str(),
"(+Infinity)");
EXPECT_STREQ(__llvm_libc::str(FPBits<long double>::neg_inf()).c_str(),
"(-Infinity)");
EXPECT_STREQ(
FPBits<long double>(FPBits<long double>::build_nan(1)).str().c_str(),
__llvm_libc::str(FPBits<long double>(FPBits<long double>::build_nan(1)))
.c_str(),
"(NaN)");

FPBits<long double> zero(0.0l);
Expand All @@ -212,7 +223,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(zero.get_mantissa(), static_cast<UInt128>(0x0000000000000000)
<< 64);
EXPECT_EQ(zero.uintval(), static_cast<UInt128>(0x0000000000000000) << 64);
EXPECT_STREQ(zero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(zero).c_str(),
"0x00000000000000000000000000000000 = "
"(S: 0, E: 0x0000, M: 0x00000000000000000000000000000000)");

Expand All @@ -222,7 +233,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(negzero.get_mantissa(), static_cast<UInt128>(0x0000000000000000)
<< 64);
EXPECT_EQ(negzero.uintval(), static_cast<UInt128>(0x1) << 127);
EXPECT_STREQ(negzero.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negzero).c_str(),
"0x80000000000000000000000000000000 = "
"(S: 1, E: 0x0000, M: 0x00000000000000000000000000000000)");

Expand All @@ -231,7 +242,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(one.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
EXPECT_EQ(one.get_mantissa(), static_cast<UInt128>(0x0000000000000000) << 64);
EXPECT_EQ(one.uintval(), static_cast<UInt128>(0x3FFF) << 112);
EXPECT_STREQ(one.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(one).c_str(),
"0x3FFF0000000000000000000000000000 = "
"(S: 0, E: 0x3FFF, M: 0x00000000000000000000000000000000)");

Expand All @@ -241,7 +252,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(negone.get_mantissa(), static_cast<UInt128>(0x0000000000000000)
<< 64);
EXPECT_EQ(negone.uintval(), static_cast<UInt128>(0xBFFF) << 112);
EXPECT_STREQ(negone.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negone).c_str(),
"0xBFFF0000000000000000000000000000 = "
"(S: 1, E: 0x3FFF, M: 0x00000000000000000000000000000000)");

Expand All @@ -250,7 +261,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(num.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
EXPECT_EQ(num.get_mantissa(), static_cast<UInt128>(0x2) << 108);
EXPECT_EQ(num.uintval(), static_cast<UInt128>(0x3FFF2) << 108);
EXPECT_STREQ(num.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(num).c_str(),
"0x3FFF2000000000000000000000000000 = "
"(S: 0, E: 0x3FFF, M: 0x00002000000000000000000000000000)");

Expand All @@ -259,7 +270,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
EXPECT_EQ(negnum.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
EXPECT_EQ(negnum.get_mantissa(), static_cast<UInt128>(0x2) << 108);
EXPECT_EQ(negnum.uintval(), static_cast<UInt128>(0xBFFF2) << 108);
EXPECT_STREQ(negnum.str().c_str(),
EXPECT_STREQ(__llvm_libc::str(negnum).c_str(),
"0xBFFF2000000000000000000000000000 = "
"(S: 1, E: 0x3FFF, M: 0x00002000000000000000000000000000)");
#endif
Expand Down
1 change: 1 addition & 0 deletions libc/utils/MPFRWrapper/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@ if(LIBC_TESTS_CAN_USE_MPFR)
libc.src.__support.CPP.string_view
libc.src.__support.CPP.type_traits
libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.fpbits_str
libc.src.__support.FPUtil.platform_defs
LibcTest.unit
)
Expand Down
33 changes: 17 additions & 16 deletions libc/utils/MPFRWrapper/MPFRUtils.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@
#include "src/__support/CPP/string_view.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/PlatformDefs.h"
#include "src/__support/FPUtil/fpbits_str.h"
#include "test/UnitTest/FPMatcher.h"

#include <cmath>
Expand Down Expand Up @@ -694,11 +695,11 @@ void explain_unary_operation_single_output_error(Operation op, T input,
MPFRNumber mpfrMatchValue(matchValue);
tlog << "Match value not within tolerance value of MPFR result:\n"
<< " Input decimal: " << mpfrInput.str() << '\n';
tlog << " Input bits: " << FPBits<T>(input).str() << '\n';
tlog << " Input bits: " << str(FPBits<T>(input)) << '\n';
tlog << '\n' << " Match decimal: " << mpfrMatchValue.str() << '\n';
tlog << " Match bits: " << FPBits<T>(matchValue).str() << '\n';
tlog << " Match bits: " << str(FPBits<T>(matchValue)) << '\n';
tlog << '\n' << " MPFR result: " << mpfr_result.str() << '\n';
tlog << " MPFR rounded: " << FPBits<T>(mpfr_result.as<T>()).str() << '\n';
tlog << " MPFR rounded: " << str(FPBits<T>(mpfr_result.as<T>())) << '\n';
tlog << '\n';
tlog << " ULP error: "
<< mpfr_result.ulp_as_mpfr_number(matchValue).str() << '\n';
Expand Down Expand Up @@ -738,12 +739,12 @@ void explain_unary_operation_two_outputs_error(
tlog << " Input decimal: " << mpfrInput.str() << "\n\n";

tlog << "Libc floating point value: " << mpfrMatchValue.str() << '\n';
tlog << " Libc floating point bits: " << FPBits<T>(libc_result.f).str()
tlog << " Libc floating point bits: " << str(FPBits<T>(libc_result.f))
<< '\n';
tlog << "\n\n";

tlog << " MPFR result: " << mpfr_result.str() << '\n';
tlog << " MPFR rounded: " << FPBits<T>(mpfr_result.as<T>()).str()
tlog << " MPFR rounded: " << str(FPBits<T>(mpfr_result.as<T>()))
<< '\n';
tlog << '\n'
<< " ULP error: "
Expand Down Expand Up @@ -776,10 +777,10 @@ void explain_binary_operation_two_outputs_error(
<< "Libc integral result: " << libc_result.i << '\n'
<< "Libc floating point result: " << mpfrMatchValue.str() << '\n'
<< " MPFR result: " << mpfr_result.str() << '\n';
tlog << "Libc floating point result bits: " << FPBits<T>(libc_result.f).str()
tlog << "Libc floating point result bits: " << str(FPBits<T>(libc_result.f))
<< '\n';
tlog << " MPFR rounded bits: "
<< FPBits<T>(mpfr_result.as<T>()).str() << '\n';
<< str(FPBits<T>(mpfr_result.as<T>())) << '\n';
tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result.f).str()
<< '\n';
}
Expand Down Expand Up @@ -810,15 +811,15 @@ void explain_binary_operation_one_output_error(Operation op,
MPFRNumber mpfrMatchValue(libc_result);

tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
tlog << "First input bits: " << FPBits<T>(input.x).str() << '\n';
tlog << "Second input bits: " << FPBits<T>(input.y).str() << '\n';
tlog << "First input bits: " << str(FPBits<T>(input.x)) << '\n';
tlog << "Second input bits: " << str(FPBits<T>(input.y)) << '\n';

tlog << "Libc result: " << mpfrMatchValue.str() << '\n'
<< "MPFR result: " << mpfr_result.str() << '\n';
tlog << "Libc floating point result bits: " << FPBits<T>(libc_result).str()
tlog << "Libc floating point result bits: " << str(FPBits<T>(libc_result))
<< '\n';
tlog << " MPFR rounded bits: "
<< FPBits<T>(mpfr_result.as<T>()).str() << '\n';
<< str(FPBits<T>(mpfr_result.as<T>())) << '\n';
tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result).str()
<< '\n';
}
Expand Down Expand Up @@ -850,16 +851,16 @@ void explain_ternary_operation_one_output_error(Operation op,

tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
<< " z: " << mpfrZ.str() << '\n';
tlog << " First input bits: " << FPBits<T>(input.x).str() << '\n';
tlog << "Second input bits: " << FPBits<T>(input.y).str() << '\n';
tlog << " Third input bits: " << FPBits<T>(input.z).str() << '\n';
tlog << " First input bits: " << str(FPBits<T>(input.x)) << '\n';
tlog << "Second input bits: " << str(FPBits<T>(input.y)) << '\n';
tlog << " Third input bits: " << str(FPBits<T>(input.z)) << '\n';

tlog << "Libc result: " << mpfrMatchValue.str() << '\n'
<< "MPFR result: " << mpfr_result.str() << '\n';
tlog << "Libc floating point result bits: " << FPBits<T>(libc_result).str()
tlog << "Libc floating point result bits: " << str(FPBits<T>(libc_result))
<< '\n';
tlog << " MPFR rounded bits: "
<< FPBits<T>(mpfr_result.as<T>()).str() << '\n';
<< str(FPBits<T>(mpfr_result.as<T>())) << '\n';
tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result).str()
<< '\n';
}
Expand Down
14 changes: 14 additions & 0 deletions utils/bazel/llvm-project-overlay/libc/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -569,9 +569,23 @@ libc_support_library(
":__support_builtin_wrappers",
":__support_common",
":__support_cpp_bit",
":__support_cpp_type_traits",
":__support_fputil_float_properties",
":__support_fputil_platform_defs",
":__support_uint128",
":libc_root",
],
)

libc_support_library(
name = "__support_fputil_fpbits_str",
hdrs = ["src/__support/FPUtil/fpbits_str.h"],
deps = [
":__support_common",
":__support_cpp_string",
":__support_cpp_type_traits",
":__support_fputil_float_properties",
":__support_fputil_fp_bits",
":__support_fputil_platform_defs",
":__support_integer_to_string",
":__support_uint128",
Expand Down
2 changes: 2 additions & 0 deletions utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,7 @@ cc_library(
"//libc:__support_cpp_string_view",
"//libc:__support_cpp_type_traits",
"//libc:__support_fputil_fp_bits",
"//libc:__support_fputil_fpbits_str",
"//libc:__support_macros_properties_architectures",
"//libc:__support_stringutil",
"//libc:__support_uint128",
Expand Down Expand Up @@ -74,6 +75,7 @@ cc_library(
"//libc:__support_cpp_type_traits",
"//libc:__support_fputil_fenv_impl",
"//libc:__support_fputil_fp_bits",
"//libc:__support_fputil_fpbits_str",
"//libc:libc_root",
],
)
Expand Down
1 change: 1 addition & 0 deletions utils/bazel/llvm-project-overlay/libc/utils/MPFRWrapper/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,7 @@ cc_library(
"//libc:__support_cpp_string_view",
"//libc:__support_cpp_type_traits",
"//libc:__support_fputil_fp_bits",
"//libc:__support_fputil_fpbits_str",
"//libc:__support_fputil_platform_defs",
"//libc:libc_root",
"//libc/test/UnitTest:LibcUnitTest",
Expand Down