[libc][math] Move str method from FPBits class to testing utils.

[lntue]

Summary

str method of FPBits class is only used for pretty printing its objects
in tests. It brings cpp::string dependency to FPBits class, which is not ideal
for embedded use case. We move str method to a free function in test utils and
remove this dependency of FPBits class.

[sivachandra]

LGTM but a comment about putting the new function in a different place.

libc/test/UnitTest/StringUtils.h

22

I am planning to get rid of this also as it is duplicated functionality without tests. Also, adding code here but test in test/src/__support breaks our structuring. Can you move the new str function to say src/__support/FPUtil/fpbits_str.h ?

[lntue]

Move str function to a separate header in src/__support/FPUtil folder.

[phosek]

Tested with my local changes and it's working, thank you!

libc/src/__support/FPUtil/CMakeLists.txt

 add_header_library(
   fp_bits
   HDRS
     FPBits.h
   DEPENDS
     .platform_defs
     .float_properties
     libc.src.__support.builtin_wrappers
-    libc.src.__support.integer_to_string
     libc.src.__support.CPP.bit
-    libc.src.__support.CPP.string
     libc.src.__support.CPP.type_traits
     libc.src.__support.common
 )
 
 add_header_library(
   nearest_integer_operations
   HDRS
     NearestIntegerOperations.h

libc/src/__support/FPUtil/FPBits.h

 //===-- Abstract class for bit manipulation of float numbers. ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/bit.h"
-#include "src/__support/CPP/string.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
-#include "src/__support/integer_to_string.h"
 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct MantissaWidth {
template <typename T> struct FPBits {
   LIBC_INLINE static FPBits<T> create_value(bool sign, UIntType unbiased_exp,
                                             UIntType mantissa) {
     FPBits<T> result;
     result.set_sign(sign);
     result.set_unbiased_exponent(unbiased_exp);
     result.set_mantissa(mantissa);
     return result;
   }
-
-  // Converts the bits to a string in the following format:
-  //    "0x<NNN...N> = S: N, E: 0xNNNN, M:0xNNN...N"
-  // 1. N is a hexadecimal digit.
-  // 2. The hexadecimal number on the LHS is the raw numerical representation
-  //    of the bits.
-  // 3. The exponent is always 16 bits wide irrespective of the type of the
-  //    floating encoding.
-  LIBC_INLINE cpp::string str() const {
-    if (is_nan())
-      return "(NaN)";
-    if (is_inf())
-      return get_sign() ? "(-Infinity)" : "(+Infinity)";
-
-    auto zerofill = [](char *arr, size_t n) {
-      for (size_t i = 0; i < n; ++i)
-        arr[i] = '0';
-    };
-
-    cpp::string s("0x");
-    char bitsbuf[IntegerToString::hex_bufsize<UIntType>()];
-    zerofill(bitsbuf, sizeof(bitsbuf));
-    IntegerToString::hex(bits, bitsbuf, false);
-    s += cpp::string(bitsbuf, sizeof(bitsbuf));
-
-    s += " = (";
-    s += cpp::string("S: ") + (get_sign() ? "1" : "0");
-
-    char expbuf[IntegerToString::hex_bufsize<uint16_t>()];
-    zerofill(expbuf, sizeof(expbuf));
-    IntegerToString::hex(get_unbiased_exponent(), expbuf, false);
-    s += cpp::string(", E: 0x") + cpp::string(expbuf, sizeof(expbuf));
-
-    char mantbuf[IntegerToString::hex_bufsize<UIntType>()] = {'0'};
-    zerofill(mantbuf, sizeof(mantbuf));
-    IntegerToString::hex(get_mantissa(), mantbuf, false);
-    s += cpp::string(", M: 0x") + cpp::string(mantbuf, sizeof(mantbuf));
-
-    s += ")";
-    return s;
-  }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/LongDoubleBits.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 //===-- Bit representation of x86 long double numbers -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 
 #include "src/__support/CPP/bit.h"
-#include "src/__support/CPP/string.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/common.h"
-#include "src/__support/integer_to_string.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #if !defined(LIBC_TARGET_ARCH_IS_X86)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/FPBits.h"
 
template <> struct FPBits<long double> {
   LIBC_INLINE static FPBits<long double>
   create_value(bool sign, UIntType unbiased_exp, UIntType mantissa) {
     FPBits<long double> result;
     result.set_sign(sign);
     result.set_unbiased_exponent(unbiased_exp);
     result.set_mantissa(mantissa);
     return result;
   }
-
-  // Converts the bits to a string in the following format:
-  //    "0x<NNN...N> = S: N, E: 0xNNNN, I: N, M:0xNNN...N"
-  // 1. N is a hexadecimal digit.
-  // 2. "I" denotes the implicit bit.
-  // 3. The hexadecimal number on the LHS is the raw numerical representation
-  //    of the bits.
-  // 4. The exponent is always 16 bits wide irrespective of the type of the
-  //    floating encoding.
-  LIBC_INLINE cpp::string str() const {
-    if (is_nan())
-      return "(NaN)";
-    if (is_inf())
-      return get_sign() ? "(-Infinity)" : "(+Infinity)";
-
-    auto zerofill = [](char *arr, size_t n) {
-      for (size_t i = 0; i < n; ++i)
-        arr[i] = '0';
-    };
-
-    cpp::string s("0x");
-    char bitsbuf[IntegerToString::hex_bufsize<UIntType>()] = {'0'};
-    zerofill(bitsbuf, sizeof(bitsbuf));
-    IntegerToString::hex(bits, bitsbuf, false);
-    s += cpp::string(bitsbuf, sizeof(bitsbuf));
-
-    s += " = (";
-    s += cpp::string("S: ") + (get_sign() ? "1" : "0");
-
-    char expbuf[IntegerToString::hex_bufsize<uint16_t>()] = {'0'};
-    zerofill(expbuf, sizeof(expbuf));
-    IntegerToString::hex(get_unbiased_exponent(), expbuf, false);
-    s += cpp::string(", E: 0x") + cpp::string(expbuf, sizeof(expbuf));
-
-    s += cpp::string(", I: ") + (get_implicit_bit() ? "1" : "0");
-
-    char mantbuf[IntegerToString::hex_bufsize<UIntType>()] = {'0'};
-    zerofill(mantbuf, sizeof(mantbuf));
-    IntegerToString::hex(get_mantissa(), mantbuf, false);
-    s += cpp::string(", M: 0x") + cpp::string(mantbuf, sizeof(mantbuf));
-
-    s += ")";
-    return s;
-  }
 };
 
 static_assert(
     sizeof(FPBits<long double>) == sizeof(long double),
     "Internal long double representation does not match the machine format.");
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H

libc/test/UnitTest/CMakeLists.txt

 
 add_header_library(
   string_utils
   HDRS
     StringUtils.h
   DEPENDS
     libc.src.__support.CPP.string
     libc.src.__support.CPP.type_traits
+    libc.src.__support.FPUtil.fp_bits
+    libc.src.__support.integer_to_string
 )
 
 add_unittest_framework_library(
   LibcFPTestHelpers
   SRCS
     RoundingModeUtils.cpp
   HDRS
     FPMatcher.h
     RoundingModeUtils.h
   DEPENDS
     LibcTest
     libc.test.UnitTest.string_utils
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.fenv_impl
-    libc.test.UnitTest.string_utils
 )
 
 add_unittest_framework_library(
   LibcFPExceptionHelpers
   SRCS
     FPExceptMatcher.cpp
   HDRS
     FPExceptMatcher.h

libc/test/UnitTest/ErrnoSetterMatcher.h

 //===-- ErrnoSetterMatcher.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_TEST_ERRNOSETTERMATCHER_H
 #define LLVM_LIBC_TEST_ERRNOSETTERMATCHER_H
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/StringUtil/error_to_string.h"
 #include "src/__support/macros/properties/architectures.h"
 #include "src/errno/libc_errno.h"
+#include "test/UnitTest/StringUtils.h"
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 namespace internal {
 
 template <typename T> class ErrnoSetterMatcher : public Matcher<T> {
public:
   ErrnoSetterMatcher(T ExpectedReturn, int ExpectedErrno)
       : ExpectedReturn(ExpectedReturn), ExpectedErrno(ExpectedErrno) {}
 
   void explainError() override {
     if (ActualReturn != ExpectedReturn) {
       if constexpr (cpp::is_floating_point_v<T>) {
         __llvm_libc::testing::tlog
             << "Expected return value to be: "
-            << __llvm_libc::fputil::FPBits<T>(ExpectedReturn).str() << '\n';
+            << str(__llvm_libc::fputil::FPBits<T>(ExpectedReturn)) << '\n';
         __llvm_libc::testing::tlog
             << "                    But got: "
-            << __llvm_libc::fputil::FPBits<T>(ActualReturn).str() << '\n';
+            << str(__llvm_libc::fputil::FPBits<T>(ActualReturn)) << '\n';
       } else {
         __llvm_libc::testing::tlog << "Expected return value to be "
                                    << ExpectedReturn << " but got "
                                    << ActualReturn << ".\n";
       }
     }
 
     if constexpr (!ignore_errno()) {

libc/test/UnitTest/FPMatcher.h

 
 namespace __llvm_libc {
 namespace testing {
 
 template <typename T, TestCond Condition> class FPMatcher : public Matcher<T> {
   static_assert(cpp::is_floating_point_v<T>,
                 "FPMatcher can only be used with floating point values.");
   static_assert(Condition == TestCond::EQ || Condition == TestCond::NE,
-                "Unsupported FPMathcer test condition.");
+                "Unsupported FPMatcher test condition.");
 
   T expected;
   T actual;
 
 public:
   FPMatcher(T expectedValue) : expected(expectedValue) {}
 
   bool match(T actualValue) {
     actual = actualValue;
     fputil::FPBits<T> actualBits(actual), expectedBits(expected);
     if (Condition == TestCond::EQ)
       return (actualBits.is_nan() && expectedBits.is_nan()) ||
              (actualBits.uintval() == expectedBits.uintval());
 
     // If condition == TestCond::NE.
     if (actualBits.is_nan())
       return !expectedBits.is_nan();
     return expectedBits.is_nan() ||
            (actualBits.uintval() != expectedBits.uintval());
   }
 
   void explainError() override {
     tlog << "Expected floating point value: "
-         << fputil::FPBits<T>(expected).str() << '\n';
-    tlog << "Actual floating point value: " << fputil::FPBits<T>(actual).str()
+         << str(fputil::FPBits<T>(expected)) << '\n';
+    tlog << "Actual floating point value: " << str(fputil::FPBits<T>(actual))
          << '\n';
   }
 };
 
 template <TestCond C, typename T> FPMatcher<T, C> getMatcher(T expectedValue) {
   return FPMatcher<T, C>(expectedValue);
 }
 

libc/test/UnitTest/StringUtils.h

 //===-- String utils for matchers -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 #define LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 
 #include "src/__support/CPP/string.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/integer_to_string.h"
 
 namespace __llvm_libc {
 
 // Return the first N hex digits of an integer as a string in upper case.
 template <typename T>
 cpp::enable_if_t<cpp::is_integral_v<T>, cpp::string>
 int_to_hex(T value, size_t length = sizeof(T) * 2) {
   cpp::string s(length, '0');
 
   constexpr char HEXADECIMALS[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                                      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
   for (size_t i = 0; i < length; i += 2, value >>= 8) {
     unsigned char mod = static_cast<unsigned char>(value) & 0xFF;
     s[length - i] = HEXADECIMALS[mod & 0x0F];
     s[length - (i + 1)] = HEXADECIMALS[mod & 0x0F];
   }
 
   return "0x" + s;
 }
 
+// Converts the bits to a string in the following format:
+//    "0x<NNN...N> = S: N, E: 0xNNNN, M:0xNNN...N"
+// 1. N is a hexadecimal digit.
+// 2. The hexadecimal number on the LHS is the raw numerical representation
+//    of the bits.
+// 3. The exponent is always 16 bits wide irrespective of the type of the
+//    floating encoding.
+template <typename T> LIBC_INLINE cpp::string str(fputil::FPBits<T> x) {
+  using UIntType = typename fputil::FPBits<T>::UIntType;
+
+  if (x.is_nan())
+    return "(NaN)";
+  if (x.is_inf())
+    return x.get_sign() ? "(-Infinity)" : "(+Infinity)";
+
+  auto zerofill = [](char *arr, size_t n) {
+    for (size_t i = 0; i < n; ++i)
+      arr[i] = '0';
+  };
+
+  cpp::string s("0x");
+  char bitsbuf[IntegerToString::hex_bufsize<UIntType>()];
+  zerofill(bitsbuf, sizeof(bitsbuf));
+  IntegerToString::hex(x.bits, bitsbuf, false);
+  s += cpp::string(bitsbuf, sizeof(bitsbuf));
+
+  s += " = (";
+  s += cpp::string("S: ") + (x.get_sign() ? "1" : "0");
+
+  char expbuf[IntegerToString::hex_bufsize<uint16_t>()];
+  zerofill(expbuf, sizeof(expbuf));
+  IntegerToString::hex(x.get_unbiased_exponent(), expbuf, false);
+  s += cpp::string(", E: 0x") + cpp::string(expbuf, sizeof(expbuf));
+
+  if constexpr (cpp::is_same_v<T, long double> &&
+                fputil::FloatProperties<long double>::MANTISSA_WIDTH == 63) {
+    s += cpp::string(", I: ") + (x.get_implicit_bit() ? "1" : "0");
+  }
+
+  char mantbuf[IntegerToString::hex_bufsize<UIntType>()] = {'0'};
+  zerofill(mantbuf, sizeof(mantbuf));
+  IntegerToString::hex(x.get_mantissa(), mantbuf, false);
+  s += cpp::string(", M: 0x") + cpp::string(mantbuf, sizeof(mantbuf));
+
+  s += ")";
+  return s;
+}
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H

libc/test/src/__support/FPUtil/fpbits_test.cpp

 //===-- Unittests for the DyadicFloat class -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/FPUtil/FPBits.h"
+#include "test/UnitTest/StringUtils.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(),
 
   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(),
 
   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)");
 }
 
 #ifdef LIBC_TARGET_ARCH_IS_X86
 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);
   EXPECT_EQ(zero.get_sign(), false);
   EXPECT_EQ(zero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
   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(),
+      __llvm_libc::str(zero).c_str(),
       "0x00000000000000000000000000000000 = "
       "(S: 0, E: 0x0000, I: 0, M: 0x00000000000000000000000000000000)");
 
   FPBits<long double> negzero(-0.0l);
   EXPECT_EQ(negzero.get_sign(), true);
   EXPECT_EQ(negzero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
   EXPECT_EQ(negzero.get_mantissa(), static_cast<UInt128>(0x0000000000000000)
                                         << 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)");
 
   FPBits<long double> one(1.0l);
   EXPECT_EQ(one.get_sign(), false);
   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>(0x3FFF8) << 60);
   EXPECT_STREQ(
-      one.str().c_str(),
+      __llvm_libc::str(one).c_str(),
       "0x0000000000003FFF8000000000000000 = "
       "(S: 0, E: 0x3FFF, I: 1, M: 0x00000000000000000000000000000000)");
 
   FPBits<long double> negone(-1.0l);
   EXPECT_EQ(negone.get_sign(), true);
   EXPECT_EQ(negone.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
   EXPECT_EQ(negone.get_mantissa(), static_cast<UInt128>(0x0000000000000000)
                                        << 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)");
 
   FPBits<long double> num(1.125l);
   EXPECT_EQ(num.get_sign(), false);
   EXPECT_EQ(num.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
   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)");
 
   FPBits<long double> negnum(-1.125l);
   EXPECT_EQ(negnum.get_sign(), true);
   EXPECT_EQ(negnum.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
   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)");
 }
 #else
 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);
   EXPECT_EQ(zero.get_sign(), false);
   EXPECT_EQ(zero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
   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)");
 
   FPBits<long double> negzero(-0.0l);
   EXPECT_EQ(negzero.get_sign(), true);
   EXPECT_EQ(negzero.get_unbiased_exponent(), static_cast<uint16_t>(0x0000));
   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)");
 
   FPBits<long double> one(1.0l);
   EXPECT_EQ(one.get_sign(), false);
   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)");
 
   FPBits<long double> negone(-1.0l);
   EXPECT_EQ(negone.get_sign(), true);
   EXPECT_EQ(negone.get_unbiased_exponent(), static_cast<uint16_t>(0x3FFF));
   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)");
 
   FPBits<long double> num(1.125l);
   EXPECT_EQ(num.get_sign(), false);
   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)");
 
   FPBits<long double> negnum(-1.125l);
   EXPECT_EQ(negnum.get_sign(), true);
   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
 }
 #endif

libc/utils/MPFRWrapper/MPFRUtils.cpp

void explain_unary_operation_single_output_error(Operation op, T input,
                                                  RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrInput(input, precision);
   MPFRNumber mpfr_result;
   mpfr_result = unary_operation(op, input, precision, rounding);
   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';
 }
 
 template void explain_unary_operation_single_output_error<float>(Operation op,
                                                                  float, float,
                                                                  double,
void explain_unary_operation_two_outputs_error(
   MPFRNumber mpfrMatchValue(libc_result.f);
   tlog
       << "Libc floating point result is not within tolerance value of the MPFR "
       << "result.\n\n";
 
   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: "
        << mpfr_result.ulp_as_mpfr_number(libc_result.f).str() << '\n';
 }
 
 template void explain_unary_operation_two_outputs_error<float>(
     Operation, float, const BinaryOutput<float> &, double, RoundingMode);
MPFRNumber mpfr_result = binary_operation_two_outputs(
       op, input.x, input.y, mpfrIntResult, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result.f);
 
   tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
        << "MPFR integral result: " << mpfrIntResult << '\n'
        << "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';
 }
 
 template void explain_binary_operation_two_outputs_error<float>(
     Operation, const BinaryInput<float> &, const BinaryOutput<float> &, double,
     RoundingMode);
 template void explain_binary_operation_two_outputs_error<double>(
void explain_binary_operation_one_output_error(Operation op,
   MPFRNumber mpfrY(input.y, precision);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   MPFRNumber mpfr_result =
       binary_operation_one_output(op, input.x, input.y, precision, rounding);
   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';
 }
 
 template void explain_binary_operation_one_output_error<float>(
     Operation, const BinaryInput<float> &, float, double, RoundingMode);
 template void explain_binary_operation_one_output_error<double>(
     Operation, const BinaryInput<double> &, double, double, RoundingMode);
void explain_ternary_operation_one_output_error(Operation op,
   FPBits<T> ybits(input.y);
   FPBits<T> zbits(input.z);
   MPFRNumber mpfr_result = ternary_operation_one_output(
       op, input.x, input.y, input.z, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
 
   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';
 }
 
 template void explain_ternary_operation_one_output_error<float>(
     Operation, const TernaryInput<float> &, float, double, RoundingMode);
 template void explain_ternary_operation_one_output_error<double>(
     Operation, const TernaryInput<double> &, double, double, RoundingMode);

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

 libc_support_library(
     name = "__support_fputil_fp_bits",
     hdrs = ["src/__support/FPUtil/FPBits.h"],
     textual_hdrs = ["src/__support/FPUtil/x86_64/LongDoubleBits.h"],
     deps = [
         ":__support_builtin_wrappers",
         ":__support_common",
         ":__support_cpp_bit",
-        ":__support_cpp_string",
         ":__support_cpp_type_traits",
         ":__support_fputil_float_properties",
         ":__support_fputil_platform_defs",
-        ":__support_integer_to_string",
         ":__support_uint128",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_hypot",
     hdrs = ["src/__support/FPUtil/Hypot.h"],

utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel

hdrs = [
         "ErrnoSetterMatcher.h",
         "ExecuteFunction.h",
         "LibcTest.h",
         "PlatformDefs.h",
         "Test.h",
     ],
     deps = [
         ":test_logger",
+        ":string_utils",
         "//libc:__support_c_string",
         "//libc:__support_cpp_bit",
         "//libc:__support_cpp_bitset",
         "//libc:__support_cpp_span",
         "//libc:__support_cpp_string",
         "//libc:__support_cpp_string_view",
         "//libc:__support_cpp_type_traits",
         "//libc:__support_fputil_fp_bits",

 cc_library(
     name = "string_utils",
     hdrs = [
         "StringUtils.h",
     ],
     deps = [
         "//libc:__support_cpp_string",
         "//libc:__support_cpp_type_traits",
+        "//libc:__support_fputil_fp_bits",
+        "//libc:__support_integer_to_string",
     ],
 )