[wip][libc] Overload integer_to_string methods for fixed size buffers

[JonChesterfield]

Summary

Existing integer_to_string methods return an optional<view>.
In the common case for a perfectly sized buffer, we can return a view.

WIP because I haven't built it for non-amdgpu yet and the wider than T
test is appending a spurious zero at present so some test cases fail.

The wider-than-T hex case has a comment for an invariant, planning to
make that a compile time fault as part of this.

Posting in WIP state as a sanity check that exact overloads are acceptable
The char (&buffer) [N] is for fixed size buffer of unknown contents, it
might be possible to detect a constexpr size string view. Ideas welcome.

[JonChesterfield]

libc/src/__support/integer_to_string.h

174

this change ^ really should be a no-op, but seems to be changing the result on amdgpu. That might be a compiler bug.

libc/test/UnitTest/LibcTest.cpp

53

this ^ looks like the same bug from D155899, but might actually be fine. Placing __attribute__((warn_unused_result)) on the conversions shows a couple of places. It's possible the wider-than-8 hex case is intended to return values via the passed buffer, not the returned string view. I need to take a closer look.

[gchatelet]

libc/src/__support/libc_assert.h

35

[nit] cpp::string_view let's be explicit

libc/test/UnitTest/LibcTest.cpp

52

Not directly related to this patch but I think we should offer prefixing as part of the API. This would simplify client code.

libc/test/src/__support/integer_to_string_test.cpp

22

The required size changes if we pass in an array or a span, this is confusing.

libc/src/__support/CPP/string.h

 }
 LIBC_INLINE string operator+(const char *lhs, const string &rhs) {
   return string(lhs) + rhs;
 }
 
 namespace internal {
 template <typename T> string to_dec_string(T value) {
   char dec_buf[IntegerToString::dec_bufsize<T>()];
-  auto maybe_string_view = IntegerToString::dec(value, dec_buf);
-  const auto &string_view = *maybe_string_view;
+  cpp::string_view string_view = IntegerToString::dec(value, dec_buf);
   return string(string_view.data(), string_view.size());
 }
 } // namespace internal
 
 LIBC_INLINE string to_string(int value) {
   return internal::to_dec_string<int>(value);
 }
 LIBC_INLINE string to_string(long value) {

libc/src/__support/CPP/stringstream.h

StringStream &operator<<(string_view str) {
     return *this;
   }
 
   // Write the |val| as string.
   template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
   StringStream &operator<<(T val) {
     char buffer[IntegerToString::dec_bufsize<T>()];
     auto int_to_str = IntegerToString::dec(val, buffer);
-    if (int_to_str)
-      return operator<<(*int_to_str);
-    return *this;
+    return operator<<(int_to_str);
   }
 
   template <typename T, enable_if_t<is_floating_point_v<T>, int> = 0>
   StringStream &operator<<(T) {
     // If this specialization gets activated, then the static_assert will
     // trigger a compile error about missing floating point number support.
     static_assert(!is_floating_point_v<T>,
                   "Writing floating point numbers is not yet supported");

libc/src/__support/integer_to_string.h

public:
   hex(T val, cpp::span<char> buffer, bool lowercase = true) {
     return convert<16>(val, buffer, lowercase);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T> &&
                                              (sizeof(T) > sizeof(uintmax_t)) &&
                                              sizeof(T) % sizeof(uintmax_t) == 0,
                                          int> = 0>
-  LIBC_INLINE static cpp::optional<cpp::string_view>
-  hex(T val, cpp::span<char> buffer, bool lowercase = true) {
+  LIBC_INLINE static cpp::string_view hex(T val, cpp::span<char> buffer,
+                                          bool lowercase = true) {
     // We will assume the buffer is exactly sized, which will be the case if
     // it was sized using the bufsize method.
     constexpr size_t BLOCKS = sizeof(T) / sizeof(uintmax_t);
     constexpr size_t UINTMAX_BUFSIZE = bufsize<16, uintmax_t>();
     // We will zero out the buffer. This specialization is not used to
     // implement a public function so zeroing out byte-by-byte does not
     // have any affect on runtime or user expectations.
     for (size_t i = 0; i < buffer.size(); ++i)
       buffer[i] = '0';
oct(T val, cpp::span<char> buffer) {
     return convert<8>(val, buffer);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
   LIBC_INLINE static cpp::optional<cpp::string_view>
   bin(T val, cpp::span<char> buffer) {
     return convert<2>(val, buffer);
   }
+
+  // Overloads for exactly sized char arrays. If the buffer is statically known
+  // then convert can return a string_view instead of an optional<string_view>
+  // Uses a char reference as that represents known size and unknown data
+  template <uint8_t BASE, typename T,
+            cpp::enable_if_t<2 <= BASE && BASE <= 36 && cpp::is_integral_v<T>,
+                             int> = 0>
+  LIBC_INLINE static cpp::string_view
+  convert(T val, char (&buffer)[bufsize<BASE, T>()], bool lowercase = true) {
+    cpp::span<char> span(buffer, buffer + sizeof(buffer));
+    if (cpp::is_signed_v<T>)
+      return convert_intmax(intmax_t(val), span, lowercase, BASE);
+    else
+      return convert_uintmax(uintmax_t(val), span, lowercase, BASE);
+  }
+
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  LIBC_INLINE static cpp::string_view dec(T val,
+                                          char (&buffer)[bufsize<10, T>()]) {
+    return convert<10>(val, buffer);
+  }
+
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  LIBC_INLINE static cpp::string_view hex(T val,
+                                          char (&buffer)[bufsize<16, T>()]) {
+    return convert<16>(val, buffer);
+  }
+
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  LIBC_INLINE static cpp::string_view oct(T val,
+                                          char (&buffer)[bufsize<8, T>()]) {
+    return convert<8>(val, buffer);
+  }
+
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  LIBC_INLINE static cpp::string_view bin(T val,
+                                          char (&buffer)[bufsize<2, T>()]) {
+    return convert<2>(val, buffer);
+  }
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H

libc/src/__support/libc_assert.h

 
 namespace __llvm_libc {
 
 LIBC_INLINE void report_assertion_failure(const char *assertion,
                                           const char *filename, unsigned line,
                                           const char *funcname) {
   char line_str[IntegerToString::dec_bufsize<unsigned>()];
   // dec returns an optional, will always be valid for this size buffer
   auto line_number = IntegerToString::dec(line, line_str);
   __llvm_libc::write_to_stderr(filename);
   __llvm_libc::write_to_stderr(":");
-  __llvm_libc::write_to_stderr(*line_number);
+  __llvm_libc::write_to_stderr(line_number);
   __llvm_libc::write_to_stderr(": Assertion failed: '");
   __llvm_libc::write_to_stderr(assertion);
   __llvm_libc::write_to_stderr("' in function: '");
   __llvm_libc::write_to_stderr(funcname);
   __llvm_libc::write_to_stderr("'\n");
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/float_dec_converter.h

if (mantissa != 0) {
     return convert_float_decimal_typed<T>(writer, new_conv, float_bits);
   }
 
   size_t block_width = 0;
   {
     // TODO: Find a better way to calculate the number of digits in the
     // initial block and exponent.
     char buf[IntegerToString::dec_bufsize<intmax_t>()];
-    auto int_to_str = *IntegerToString::dec(digits, buf);
+    cpp::string_view int_to_str = IntegerToString::dec(digits, buf);
     block_width = int_to_str.size();
   }
 
   size_t digits_checked = 0;
   // TODO: look into unifying trailing_zeroes and trailing_nines. The number can
   // end in a nine or a zero, but not both.
   size_t trailing_zeroes = 0;
   size_t trailing_nines = 0;

libc/test/UnitTest/LibcTest.cpp

 // When the value is UInt128, __uint128_t or wider, show its hexadecimal
 // digits.
 template <typename T>
 cpp::enable_if_t<cpp::is_integral_v<T> && (sizeof(T) > sizeof(uint64_t)),
                  cpp::string>
 describeValue(T Value) {
   static_assert(sizeof(T) % 8 == 0, "Unsupported size of UInt");
   char buf[IntegerToString::hex_bufsize<T>()];
-  IntegerToString::hex(Value, buf, false);
-  return "0x" + cpp::string(buf, sizeof(buf));
+  cpp::string_view view = IntegerToString::hex(Value, buf, false);
+  return "0x" + cpp::string(view.data(), view.size());
 }
 
 // When the value is of a standard integral type, just display it as normal.
 template <typename ValType>
 cpp::enable_if_t<cpp::is_integral_v<ValType> &&
                      sizeof(ValType) <= sizeof(uint64_t),
                  cpp::string>
 describeValue(ValType Value) {
   return cpp::to_string(Value);

libc/test/UnitTest/TestLogger.cpp

template <> TestLogger &TestLogger::operator<<(void *addr) {
   return *this << "0x" << cpp::to_string(reinterpret_cast<uintptr_t>(addr));
 }
 
 template <typename T> TestLogger &TestLogger::operator<<(T t) {
   if constexpr (cpp::is_integral_v<T> && cpp::is_unsigned_v<T> &&
                 sizeof(T) > sizeof(uint64_t)) {
     static_assert(sizeof(T) % 8 == 0, "Unsupported size of UInt");
     char buf[IntegerToString::hex_bufsize<T>()];
-    IntegerToString::hex(t, buf, false);
-    return *this << "0x" << cpp::string_view(buf, sizeof(buf));
+    cpp::string_view view = IntegerToString::hex(t, buf, false);
+    return *this << "0x" << view;
   } else {
     return *this << cpp::to_string(t);
   }
 }
 
 // is_integral specializations
 // char is already specialized to handle character
 template TestLogger &TestLogger::operator<< <short>(short);

libc/test/src/__support/integer_to_string_test.cpp

 #include "test/UnitTest/Test.h"
 
 #include "limits.h"
 
 using __llvm_libc::IntegerToString;
 using __llvm_libc::cpp::string_view;
 
 TEST(LlvmLibcIntegerToStringTest, UINT8) {
-  char buf[IntegerToString::dec_bufsize<uint8_t>()];
+  char buf[IntegerToString::dec_bufsize<uint8_t>() + 1];
   EXPECT_EQ(*IntegerToString::dec(uint8_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(uint8_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(uint8_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(uint8_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(uint8_t(UINT8_MAX), buf), string_view("255"));
   EXPECT_EQ(*IntegerToString::dec(uint8_t(-1), buf), string_view("255"));
 }
 
+TEST(LlvmLibcIntegerToStringExactTest, UINT8) {
+  char buf[IntegerToString::dec_bufsize<uint8_t>()];
+  EXPECT_EQ(IntegerToString::dec(uint8_t(0), buf), string_view("0"));
+  EXPECT_EQ(IntegerToString::dec(uint8_t(1), buf), string_view("1"));
+  EXPECT_EQ(IntegerToString::dec(uint8_t(12), buf), string_view("12"));
+  EXPECT_EQ(IntegerToString::dec(uint8_t(123), buf), string_view("123"));
+  EXPECT_EQ(IntegerToString::dec(uint8_t(UINT8_MAX), buf), string_view("255"));
+  EXPECT_EQ(IntegerToString::dec(uint8_t(-1), buf), string_view("255"));
+}
+
 TEST(LlvmLibcIntegerToStringTest, INT8) {
-  char buf[IntegerToString::dec_bufsize<int8_t>()];
+  char buf[IntegerToString::dec_bufsize<int8_t>() + 1];
   EXPECT_EQ(*IntegerToString::dec(int8_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(-12), buf), string_view("-12"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(-123), buf), string_view("-123"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(INT8_MAX), buf), string_view("127"));
   EXPECT_EQ(*IntegerToString::dec(int8_t(INT8_MIN), buf), string_view("-128"));
 }
 
+TEST(LlvmLibcIntegerToStringExactTest, INT8) {
+  char buf[IntegerToString::dec_bufsize<int8_t>()];
+  EXPECT_EQ(IntegerToString::dec(int8_t(0), buf), string_view("0"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(1), buf), string_view("1"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(12), buf), string_view("12"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(123), buf), string_view("123"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(-12), buf), string_view("-12"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(-123), buf), string_view("-123"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(INT8_MAX), buf), string_view("127"));
+  EXPECT_EQ(IntegerToString::dec(int8_t(INT8_MIN), buf), string_view("-128"));
+}
+
 TEST(LlvmLibcIntegerToStringTest, UINT16) {
-  char buf[IntegerToString::dec_bufsize<uint16_t>()];
+  char buf[IntegerToString::dec_bufsize<uint16_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(uint16_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(UINT16_MAX), buf),
             string_view("65535"));
   EXPECT_EQ(*IntegerToString::dec(uint16_t(-1), buf), string_view("65535"));
 }
 
+TEST(LlvmLibcIntegerToStringExactTest, UINT16) {
+  char buf[IntegerToString::dec_bufsize<uint16_t>()];
+  EXPECT_EQ(IntegerToString::dec(uint16_t(0), buf), string_view("0"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(1), buf), string_view("1"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(12), buf), string_view("12"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(123), buf), string_view("123"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(1234), buf), string_view("1234"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(12345), buf), string_view("12345"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(UINT16_MAX), buf),
+            string_view("65535"));
+  EXPECT_EQ(IntegerToString::dec(uint16_t(-1), buf), string_view("65535"));
+}
+
 TEST(LlvmLibcIntegerToStringTest, INT16) {
-  char buf[IntegerToString::dec_bufsize<int16_t>()];
+  char buf[IntegerToString::dec_bufsize<int16_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(int16_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(-1), buf), string_view("-1"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(-12), buf), string_view("-12"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(-123), buf), string_view("-123"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(-1234), buf), string_view("-1234"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(-12345), buf), string_view("-12345"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(INT16_MAX), buf),
             string_view("32767"));
   EXPECT_EQ(*IntegerToString::dec(int16_t(INT16_MIN), buf),
             string_view("-32768"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT32) {
-  char buf[IntegerToString::dec_bufsize<uint32_t>()];
+  char buf[IntegerToString::dec_bufsize<uint32_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(uint32_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(123456), buf), string_view("123456"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(1234567), buf),
             string_view("1234567"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(12345678), buf),
             string_view("12345678"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(123456789), buf),
             string_view("123456789"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(1234567890), buf),
             string_view("1234567890"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(UINT32_MAX), buf),
             string_view("4294967295"));
   EXPECT_EQ(*IntegerToString::dec(uint32_t(-1), buf), string_view("4294967295"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT32) {
-  char buf[IntegerToString::dec_bufsize<int32_t>()];
+  char buf[IntegerToString::dec_bufsize<int32_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(int32_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(123456), buf), string_view("123456"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(1234567), buf),
EXPECT_EQ(*IntegerToString::dec(int32_t(-1234567890), buf),
             string_view("-1234567890"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(INT32_MAX), buf),
             string_view("2147483647"));
   EXPECT_EQ(*IntegerToString::dec(int32_t(INT32_MIN), buf),
             string_view("-2147483648"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64) {
-  char buf[IntegerToString::dec_bufsize<uint64_t>()];
+  char buf[IntegerToString::dec_bufsize<uint64_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(uint64_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(123456), buf), string_view("123456"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567), buf),
             string_view("1234567"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(12345678), buf),
             string_view("12345678"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(123456789), buf),
             string_view("123456789"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567890), buf),
             string_view("1234567890"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567890123456789), buf),
             string_view("1234567890123456789"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(UINT64_MAX), buf),
             string_view("18446744073709551615"));
   EXPECT_EQ(*IntegerToString::dec(uint64_t(-1), buf),
             string_view("18446744073709551615"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT64) {
-  char buf[IntegerToString::dec_bufsize<int64_t>()];
+  char buf[IntegerToString::dec_bufsize<int64_t>()+1];
   EXPECT_EQ(*IntegerToString::dec(int64_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(1), buf), string_view("1"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(12), buf), string_view("12"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(123), buf), string_view("123"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(1234), buf), string_view("1234"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(12345), buf), string_view("12345"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(123456), buf), string_view("123456"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(1234567), buf),
EXPECT_EQ(*IntegerToString::dec(int64_t(-1234567890123456789), buf),
             string_view("-1234567890123456789"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(INT64_MAX), buf),
             string_view("9223372036854775807"));
   EXPECT_EQ(*IntegerToString::dec(int64_t(INT64_MIN), buf),
             string_view("-9223372036854775808"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_8) {
-  char buf[IntegerToString::oct_bufsize<uint64_t>()];
+  char buf[IntegerToString::oct_bufsize<uint64_t>()+1];
   EXPECT_EQ((*IntegerToString::oct(uint64_t(0), buf)), string_view("0"));
   EXPECT_EQ((*IntegerToString::oct(uint64_t(012345), buf)),
             string_view("12345"));
   EXPECT_EQ((*IntegerToString::oct(uint64_t(0123456701234567012345), buf)),
             string_view("123456701234567012345"));
   EXPECT_EQ((*IntegerToString::oct(uint64_t(01777777777777777777777), buf)),
             string_view("1777777777777777777777"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_16) {
-  char buf[IntegerToString::hex_bufsize<uint64_t>()];
+  char buf[IntegerToString::hex_bufsize<uint64_t>()+1];
   EXPECT_EQ(*IntegerToString::hex(uint64_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::hex(uint64_t(0x12345), buf), string_view("12345"));
   EXPECT_EQ((*IntegerToString::hex(uint64_t(0x123456789abcdef), buf)),
             string_view("123456789abcdef"));
   EXPECT_EQ(*IntegerToString::hex(uint64_t(0x123456789abcdef), buf, false),
             string_view("123456789ABCDEF"));
   EXPECT_EQ(*IntegerToString::hex(uint64_t(0xffffffffffffffff), buf),
             string_view("ffffffffffffffff"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_2) {
-  char buf[IntegerToString::bin_bufsize<uint64_t>()];
+  char buf[IntegerToString::bin_bufsize<uint64_t>()+1];
   EXPECT_EQ(*IntegerToString::bin(uint64_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::bin(uint64_t(0xf0c), buf),
             string_view("111100001100"));
   EXPECT_EQ(*IntegerToString::bin(uint64_t(0x123abc), buf),
             string_view("100100011101010111100"));
   EXPECT_EQ(
       *IntegerToString::bin(uint64_t(0xffffffffffffffff), buf),
       string_view(
           "1111111111111111111111111111111111111111111111111111111111111111"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_36) {
-  char buf[IntegerToString::bufsize<36, uint64_t>()];
+  char buf[IntegerToString::bufsize<36, uint64_t>()+1];
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(0), buf), string_view("0"));
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(12345), buf),
             string_view("9ix"));
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(1047601316295595), buf),
             string_view("abcdefghij"));
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(2092218013456445), buf),
             string_view("klmnopqrst"));
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(1867590395), buf, false),
             string_view("UVWXYZ"));
   EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(0xffffffffffffffff), buf),
             string_view("3w5e11264sgsf"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT128_Base_16) {
-  char buf[IntegerToString::hex_bufsize<UInt128>()];
-  EXPECT_EQ(*IntegerToString::hex(static_cast<UInt128>(0), buf),
+  char buf[IntegerToString::hex_bufsize<UInt128>()+1];
+  EXPECT_EQ(IntegerToString::hex(static_cast<UInt128>(0), buf),
             string_view("00000000000000000000000000000000"));
-  EXPECT_EQ(*IntegerToString::hex(static_cast<UInt128>(0x12345), buf),
+  EXPECT_EQ(IntegerToString::hex(static_cast<UInt128>(0x12345), buf),
             string_view("00000000000000000000000000012345"));
-  EXPECT_EQ((*IntegerToString::hex(static_cast<UInt128>(0x1234) << 112, buf)),
+  EXPECT_EQ((IntegerToString::hex(static_cast<UInt128>(0x1234) << 112, buf)),
             string_view("12340000000000000000000000000000"));
-  EXPECT_EQ((*IntegerToString::hex(static_cast<UInt128>(0x1234) << 48, buf)),
+  EXPECT_EQ((IntegerToString::hex(static_cast<UInt128>(0x1234) << 48, buf)),
             string_view("00000000000000001234000000000000"));
-  EXPECT_EQ((*IntegerToString::hex(static_cast<UInt128>(0x1234) << 52, buf)),
+  EXPECT_EQ((IntegerToString::hex(static_cast<UInt128>(0x1234) << 52, buf)),
             string_view("00000000000000012340000000000000"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT256_Base_16) {
   using UInt256 = __llvm_libc::cpp::UInt<256>;
-  char buf[IntegerToString::hex_bufsize<UInt256>()];
+  char buf[IntegerToString::hex_bufsize<UInt256>()+1];
   EXPECT_EQ(
-      *IntegerToString::hex(static_cast<UInt256>(0), buf),
+      IntegerToString::hex(static_cast<UInt256>(0), buf),
       string_view(
           "0000000000000000000000000000000000000000000000000000000000000000"));
   EXPECT_EQ(
-      *IntegerToString::hex(static_cast<UInt256>(0x12345), buf),
+      IntegerToString::hex(static_cast<UInt256>(0x12345), buf),
       string_view(
           "0000000000000000000000000000000000000000000000000000000000012345"));
   EXPECT_EQ(
-      (*IntegerToString::hex(static_cast<UInt256>(0x1234) << 112, buf)),
+      (IntegerToString::hex(static_cast<UInt256>(0x1234) << 112, buf)),
       string_view(
           "0000000000000000000000000000000012340000000000000000000000000000"));
   EXPECT_EQ(
-      (*IntegerToString::hex(static_cast<UInt256>(0x1234) << 116, buf)),
+      (IntegerToString::hex(static_cast<UInt256>(0x1234) << 116, buf)),
       string_view(
           "0000000000000000000000000000000123400000000000000000000000000000"));
   EXPECT_EQ(
-      (*IntegerToString::hex(static_cast<UInt256>(0x1234) << 240, buf)),
+      (IntegerToString::hex(static_cast<UInt256>(0x1234) << 240, buf)),
       string_view(
           "1234000000000000000000000000000000000000000000000000000000000000"));
 }