[libc] Add a convenience class and function for integer to string conversion.

[sivachandra]

Summary

Printf's integer converter has been modified to use the new converter. In
future, it will be used to implement other parts of the libc.

[sivachandra]

Fix copy-pasted comments.

[michaelrj]

overall LGTM, with a few comments

libc/src/__support/integer_to_string.h

34–35

for integer division you can just add (divisor - 1) to the initial number to get ceil, so in this case it would be ((sizeof(T) * 5) + 1) / 2)

libc/test/src/__support/integer_to_string_test.cpp

21

would it be better to implement an equality checker for string views?

[sivachandra]

Address comments.

libc/test/src/__support/integer_to_string_test.cpp

21

Yes, I think we should. I will do it in a separate patch.

[michaelrj]

LGTM

libc/src/__support/CMakeLists.txt

add_header_library(
   DEPENDS
     .ctype_utils
     libc.include.errno
     libc.src.errno.errno
     libc.src.__support.CPP.limits
 )
 
 add_header_library(
+  integer_to_string
+  HDRS
+    integer_to_string.h
+  DEPENDS
+    libc.src.__support.CPP.string_view
+    libc.src.__support.CPP.type_traits
+)
+
+add_header_library(
   high_precision_decimal
   HDRS
     high_precision_decimal.h
   DEPENDS
     .str_to_integer
 )
 
 add_header_library(

libc/src/__support/CPP/TypeTraits.h

static constexpr bool Value =
       IsSameV<unsigned long, TypeNoCV> || IsSameV<long long, TypeNoCV> ||
       IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV> ||
       // We need to include UInt<128> and __uint128_t when available because
       // we want to unittest UInt<128>. If we include only UInt128, then on
       // platform where it resolves to __uint128_t, we cannot unittest
       // UInt<128>.
       IsSameV<__llvm_libc::cpp::UInt<128>, TypeNoCV>
 #ifdef __SIZEOF_INT128__
-      || IsSameV<__uint128_t, TypeNoCV>
+      || IsSameV<__int128_t, TypeNoCV> || IsSameV<__uint128_t, TypeNoCV>
 #endif
       ;
 };
 
 template <typename Type> struct IsEnum {
   static constexpr bool Value = __is_enum(Type);
 };
 
static constexpr bool Value = IsSame<float, TypeNoCV>::Value ||
                                 IsSame<long double, TypeNoCV>::Value;
 };
 
 template <typename Type> struct IsArithmetic {
   static constexpr bool Value =
       IsIntegral<Type>::Value || IsFloatingPointType<Type>::Value;
 };
 
+template <typename Type> struct IsSigned {
+  static constexpr bool Value =
+      IsArithmetic<Type>::Value && (Type(-1) < Type(0));
+  constexpr operator bool() const { return Value; }
+  constexpr bool operator()() const { return Value; }
+};
+
+template <typename Type> struct MakeUnsigned;
+template <> struct MakeUnsigned<char> {
+  using Type = unsigned char;
+};
+template <> struct MakeUnsigned<signed char> {
+  using Type = unsigned char;
+};
+template <> struct MakeUnsigned<short> {
+  using Type = unsigned short;
+};
+template <> struct MakeUnsigned<int> {
+  using Type = unsigned int;
+};
+template <> struct MakeUnsigned<long> {
+  using Type = unsigned long;
+};
+template <> struct MakeUnsigned<long long> {
+  using Type = unsigned long long;
+};
+template <> struct MakeUnsigned<unsigned char> {
+  using Type = unsigned char;
+};
+template <> struct MakeUnsigned<unsigned short> {
+  using Type = unsigned short;
+};
+template <> struct MakeUnsigned<unsigned int> {
+  using Type = unsigned int;
+};
+template <> struct MakeUnsigned<unsigned long> {
+  using Type = unsigned long;
+};
+template <> struct MakeUnsigned<unsigned long long> {
+  using Type = unsigned long long;
+};
+#ifdef __SIZEOF_INT128__
+template <> struct MakeUnsigned<__int128_t> {
+  using Type = __uint128_t;
+};
+template <> struct MakeUnsigned<__uint128_t> {
+  using Type = __uint128_t;
+};
+#endif
+
+template <typename T> using MakeUnsignedType = typename MakeUnsigned<T>::Type;
+
 // Compile time type selection.
 template <bool _, class TrueT, class FalseT> struct Conditional {
   using type = TrueT;
 };
 template <class TrueT, class FalseT> struct Conditional<false, TrueT, FalseT> {
   using type = FalseT;
 };
 template <bool Cond, typename TrueT, typename FalseT>
 using ConditionalType = typename Conditional<Cond, TrueT, FalseT>::type;
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/integer_to_string.h

+//===-- Utilities to convert integral values to string ----------*- 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_INTEGER_TO_STRING_H
+#define LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
+
+#include "src/__support/CPP/StringView.h"
+#include "src/__support/CPP/TypeTraits.h"
+
+namespace __llvm_libc {
+
+template <typename T> class IntegerToString {
+  static_assert(cpp::IsIntegral<T>::Value,
+                "IntegerToString can only be used with integral types.");
+
+  using UnsignedType = cpp::MakeUnsignedType<T>;
+
+  // We size the string buffer using an approximation algorithm:
+  //
+  //   size = ceil(sizeof(T) * 5 / 2)
+  //
+  // If sizeof(T) is 1, then size is 3 (actually 3)
+  // If sizeof(T) is 2, then size is 5 (actually need 5)
+  // If sizeof(T) is 4, then size is 10 (actually need 10)
+  // If sizeof(T) is 8, then size is 20 (actually need 20)
+  // If sizeof(T) is 16, then size is 40 (actually need 39)
+  //
+  // NOTE: The ceil operation is actually implemented as
+  //     floor(((sizeof(T) * 5) + 1)/2)
+  // where floor operation is just integer division.
+  //
+  // This estimation grows slightly faster than the actual value, but the
+  // overhead is small enough to tolerate. In the actual formula below, we
+  // add an additional byte to accommodate the '-' sign in case of signed
+  // integers.
+  static constexpr size_t BUFSIZE =
+      (sizeof(T) * 5 + 1) / 2 + (cpp::IsSigned<T>() ? 1 : 0);
+  char strbuf[BUFSIZE] = {'\0'};
+  size_t len = 0;
+
+  constexpr void convert(UnsignedType val) {
+    size_t buffptr = BUFSIZE;
+    if (val == 0) {
+      strbuf[buffptr - 1] = '0';
+      --buffptr;
+    } else {
+      for (; val > 0; --buffptr, val /= 10)
+        strbuf[buffptr - 1] = (val % 10) + '0';
+    }
+    len = BUFSIZE - buffptr;
+  }
+
+public:
+  constexpr explicit IntegerToString(T val) {
+    convert(val < 0 ? UnsignedType(-val) : UnsignedType(val));
+    if (val < 0) {
+      // This branch will be taken only for negative signed values.
+      ++len;
+      strbuf[BUFSIZE - len] = '-';
+    }
+  }
+
+  cpp::StringView str() const {
+    return cpp::StringView(strbuf + BUFSIZE - len, len);
+  }
+
+  operator cpp::StringView() const { return str(); }
+};
+
+template <typename T> IntegerToString<T> integer_to_string(T val) {
+  return IntegerToString<T>(val);
+}
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H

libc/src/stdio/printf_core/CMakeLists.txt

HDRS
     hex_converter.h
     ptr_converter.h
     oct_converter.h
     write_int_converter.h
     float_hex_converter.h
   DEPENDS
     .writer
     .core_structs
+    libc.src.__support.integer_to_string
     libc.src.__support.CPP.limits
     libc.src.__support.FPUtil.fputil
 )
 
 
 add_object_library(
   printf_main
   SRCS

libc/src/stdio/printf_core/int_converter.h

 //===-- Integer Converter for printf ----------------------------*- 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_STDIO_PRINTF_CORE_INT_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H
 
+#include "src/__support/integer_to_string.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int inline convert_int(Writer *writer, const FormatSection &to_conv) {
   static constexpr size_t BITS_IN_BYTE = 8;
   static constexpr size_t BITS_IN_NUM = sizeof(uintmax_t) * BITS_IN_BYTE;
 
-  // This approximates the number of digits it takes to represent an integer of
-  // a certain number of bits. The calculation is floor((bits * 5) / 16)
-  // 32 -> 10 (actually needs 10)
-  // 64 -> 20 (actually needs 20)
-  // 128 -> 40 (actually needs 39)
-  // This estimation grows slightly faster than the actual value, but is close
-  // enough.
-
-  static constexpr size_t BUFF_LEN =
-      ((sizeof(uintmax_t) * BITS_IN_BYTE * 5) / 16);
   uintmax_t num = to_conv.conv_val_raw;
-  char buffer[BUFF_LEN];
   bool is_negative = false;
   FormatFlags flags = to_conv.flags;
 
   if (to_conv.conv_name == 'u') {
     // These flags are only for signed conversions, so this removes them if the
     // conversion is unsigned.
     flags = FormatFlags(flags &
                         ~(FormatFlags::FORCE_SIGN | FormatFlags::SPACE_PREFIX));
   } else {
     // Check if the number is negative by checking the high bit. This works even
     // for smaller numbers because they're sign extended by default.
     if ((num & (uintmax_t(1) << (BITS_IN_NUM - 1))) > 0) {
       is_negative = true;
       num = -num;
     }
   }
 
   num = apply_length_modifier(num, to_conv.length_modifier);
 
-  // buff_cur can never reach 0, since the buffer is sized to always be able to
-  // contain the whole integer. This means that bounds checking it should be
-  // unnecessary.
-  size_t buff_cur = BUFF_LEN;
-  for (; num > 0 /* && buff_cur > 0 */; --buff_cur, num /= 10)
-    buffer[buff_cur - 1] = (num % 10) + '0';
-
-  size_t digits_written = BUFF_LEN - buff_cur;
+  auto const int_to_str = integer_to_string(num);
+  size_t digits_written = int_to_str.str().size();
 
   char sign_char = 0;
 
   if (is_negative)
     sign_char = '-';
   else if ((flags & FormatFlags::FORCE_SIGN) == FormatFlags::FORCE_SIGN)
     sign_char = '+'; // FORCE_SIGN has precedence over SPACE_PREFIX
   else if ((flags & FormatFlags::SPACE_PREFIX) == FormatFlags::SPACE_PREFIX)
if ((flags & (FormatFlags::LEADING_ZEROES | FormatFlags::LEFT_JUSTIFIED)) ==
         FormatFlags::LEADING_ZEROES) {
       // If this conv has flag 0 but not - and no specified precision, it's
       // padded with 0's instead of spaces identically to if precision =
       // min_width - (1 if sign_char). For example: ("%+04d", 1) -> "+001"
       zeroes = to_conv.min_width - digits_written - sign_char_len;
       if (zeroes < 0)
         zeroes = 0;
       spaces = 0;
-    } else if (digits_written < 1) {
-      // If no precision is specified, precision defaults to 1. This means that
-      // if the integer passed to the conversion is 0, a 0 will be printed.
-      // Example: ("%3d", 0) -> "  0"
-      zeroes = 1;
-      spaces = to_conv.min_width - zeroes - sign_char_len;
     } else {
       // If there are enough digits to pass over the precision, just write the
       // number, padded by spaces.
       zeroes = 0;
       spaces = to_conv.min_width - digits_written - sign_char_len;
     }
   } else {
     // If precision was specified, possibly write zeroes, and possibly write
     // spaces. Example: ("%5.4d", 10000) -> "10000"
     // If the check for if zeroes is negative was not there, spaces would be
     // incorrectly evaluated as 1.
+    //
+    // The standard treats the case when num and precision are both zeroes as
+    // special - it requires that no characters are produced. So, we adjust for
+    // that special case first.
+    if (num == 0 && to_conv.precision == 0)
+      digits_written = 0;
     zeroes = to_conv.precision - digits_written; // a negative value means 0
     if (zeroes < 0)
       zeroes = 0;
     spaces = to_conv.min_width - zeroes - digits_written - sign_char_len;
   }
   if (spaces < 0)
     spaces = 0;
 
   if ((flags & FormatFlags::LEFT_JUSTIFIED) == FormatFlags::LEFT_JUSTIFIED) {
     // If left justified it goes sign zeroes digits spaces
     if (sign_char != 0)
       RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, digits_written));
+      RET_IF_RESULT_NEGATIVE(
+          writer->write(int_to_str.str().data(), digits_written));
     if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
   } else {
     // Else it goes spaces sign zeroes digits
     if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
     if (sign_char != 0)
       RET_IF_RESULT_NEGATIVE(writer->write(&sign_char, 1));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, digits_written));
+      RET_IF_RESULT_NEGATIVE(
+          writer->write(int_to_str.str().data(), digits_written));
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H

libc/test/src/__support/CMakeLists.txt

add_libc_unittest(
   SRCS
     str_to_float_test.cpp
   DEPENDS
     libc.src.__support.str_to_float
     libc.src.__support.CPP.uint128
 )
 
 add_libc_unittest(
+  integer_to_string_test
+  SUITE
+    libc_support_unittests
+  SRCS
+    integer_to_string_test.cpp
+  DEPENDS
+    libc.src.__support.integer_to_string
+    libc.src.__support.CPP.string_view
+)
+
+add_libc_unittest(
   arg_list_test
   SUITE
     libc_support_unittests
   SRCS
     arg_list_test.cpp
   DEPENDS
     libc.src.__support.arg_list
 )

libc/test/src/__support/integer_to_string_test.cpp

+//===-- Unittests for integer_to_string -----------------------------------===//
+//
+// 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/CPP/StringView.h"
+#include "src/__support/integer_to_string.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include "limits.h"
+
+using __llvm_libc::integer_to_string;
+using __llvm_libc::cpp::StringView;
+
+TEST(LlvmLibcIntegerToStringTest, UINT8) {
+  EXPECT_TRUE(integer_to_string(uint8_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(uint8_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(uint8_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(uint8_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(uint8_t(UINT8_MAX)).str().equals(StringView("255")));
+  EXPECT_TRUE(integer_to_string(uint8_t(-1)).str().equals(StringView("255")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, INT8) {
+  EXPECT_TRUE(integer_to_string(int8_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(int8_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(int8_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(int8_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(integer_to_string(int8_t(-12)).str().equals(StringView("-12")));
+  EXPECT_TRUE(integer_to_string(int8_t(-123)).str().equals(StringView("-123")));
+  EXPECT_TRUE(
+      integer_to_string(int8_t(INT8_MAX)).str().equals(StringView("127")));
+  EXPECT_TRUE(
+      integer_to_string(int8_t(INT8_MIN)).str().equals(StringView("-128")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, UINT16) {
+  EXPECT_TRUE(integer_to_string(uint16_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(uint16_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(uint16_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(uint16_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(uint16_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(uint16_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(integer_to_string(uint16_t(UINT16_MAX))
+                  .str()
+                  .equals(StringView("65535")));
+  EXPECT_TRUE(
+      integer_to_string(uint16_t(-1)).str().equals(StringView("65535")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, INT16) {
+  EXPECT_TRUE(integer_to_string(int16_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(int16_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(int16_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(int16_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(integer_to_string(int16_t(-1)).str().equals(StringView("-1")));
+  EXPECT_TRUE(integer_to_string(int16_t(-12)).str().equals(StringView("-12")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(-123)).str().equals(StringView("-123")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(-1234)).str().equals(StringView("-1234")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(-12345)).str().equals(StringView("-12345")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(INT16_MAX)).str().equals(StringView("32767")));
+  EXPECT_TRUE(
+      integer_to_string(int16_t(INT16_MIN)).str().equals(StringView("-32768")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, UINT32) {
+  EXPECT_TRUE(integer_to_string(uint32_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(uint32_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(uint32_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(uint32_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(uint32_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(uint32_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(
+      integer_to_string(uint32_t(123456)).str().equals(StringView("123456")));
+  EXPECT_TRUE(
+      integer_to_string(uint32_t(1234567)).str().equals(StringView("1234567")));
+  EXPECT_TRUE(integer_to_string(uint32_t(12345678))
+                  .str()
+                  .equals(StringView("12345678")));
+  EXPECT_TRUE(integer_to_string(uint32_t(123456789))
+                  .str()
+                  .equals(StringView("123456789")));
+  EXPECT_TRUE(integer_to_string(uint32_t(1234567890))
+                  .str()
+                  .equals(StringView("1234567890")));
+  EXPECT_TRUE(integer_to_string(uint32_t(UINT32_MAX))
+                  .str()
+                  .equals(StringView("4294967295")));
+  EXPECT_TRUE(
+      integer_to_string(uint32_t(-1)).str().equals(StringView("4294967295")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, INT32) {
+  EXPECT_TRUE(integer_to_string(int32_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(int32_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(int32_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(int32_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(123456)).str().equals(StringView("123456")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(1234567)).str().equals(StringView("1234567")));
+  EXPECT_TRUE(integer_to_string(int32_t(12345678))
+                  .str()
+                  .equals(StringView("12345678")));
+  EXPECT_TRUE(integer_to_string(int32_t(123456789))
+                  .str()
+                  .equals(StringView("123456789")));
+  EXPECT_TRUE(integer_to_string(int32_t(1234567890))
+                  .str()
+                  .equals(StringView("1234567890")));
+  EXPECT_TRUE(integer_to_string(int32_t(-1)).str().equals(StringView("-1")));
+  EXPECT_TRUE(integer_to_string(int32_t(-12)).str().equals(StringView("-12")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(-123)).str().equals(StringView("-123")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(-1234)).str().equals(StringView("-1234")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(-12345)).str().equals(StringView("-12345")));
+  EXPECT_TRUE(
+      integer_to_string(int32_t(-123456)).str().equals(StringView("-123456")));
+  EXPECT_TRUE(integer_to_string(int32_t(-1234567))
+                  .str()
+                  .equals(StringView("-1234567")));
+  EXPECT_TRUE(integer_to_string(int32_t(-12345678))
+                  .str()
+                  .equals(StringView("-12345678")));
+  EXPECT_TRUE(integer_to_string(int32_t(-123456789))
+                  .str()
+                  .equals(StringView("-123456789")));
+  EXPECT_TRUE(integer_to_string(int32_t(-1234567890))
+                  .str()
+                  .equals(StringView("-1234567890")));
+  EXPECT_TRUE(integer_to_string(int32_t(INT32_MAX))
+                  .str()
+                  .equals(StringView("2147483647")));
+  EXPECT_TRUE(integer_to_string(int32_t(INT32_MIN))
+                  .str()
+                  .equals(StringView("-2147483648")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, UINT64) {
+  EXPECT_TRUE(integer_to_string(uint64_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(uint64_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(uint64_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(uint64_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(uint64_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(uint64_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(
+      integer_to_string(uint64_t(123456)).str().equals(StringView("123456")));
+  EXPECT_TRUE(
+      integer_to_string(uint64_t(1234567)).str().equals(StringView("1234567")));
+  EXPECT_TRUE(integer_to_string(uint64_t(12345678))
+                  .str()
+                  .equals(StringView("12345678")));
+  EXPECT_TRUE(integer_to_string(uint64_t(123456789))
+                  .str()
+                  .equals(StringView("123456789")));
+  EXPECT_TRUE(integer_to_string(uint64_t(1234567890))
+                  .str()
+                  .equals(StringView("1234567890")));
+  EXPECT_TRUE(integer_to_string(uint64_t(1234567890123456789))
+                  .str()
+                  .equals(StringView("1234567890123456789")));
+  EXPECT_TRUE(integer_to_string(uint64_t(UINT64_MAX))
+                  .str()
+                  .equals(StringView("18446744073709551615")));
+  EXPECT_TRUE(integer_to_string(uint64_t(-1))
+                  .str()
+                  .equals(StringView("18446744073709551615")));
+}
+
+TEST(LlvmLibcIntegerToStringTest, INT64) {
+  EXPECT_TRUE(integer_to_string(int64_t(0)).str().equals(StringView("0")));
+  EXPECT_TRUE(integer_to_string(int64_t(1)).str().equals(StringView("1")));
+  EXPECT_TRUE(integer_to_string(int64_t(12)).str().equals(StringView("12")));
+  EXPECT_TRUE(integer_to_string(int64_t(123)).str().equals(StringView("123")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(1234)).str().equals(StringView("1234")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(12345)).str().equals(StringView("12345")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(123456)).str().equals(StringView("123456")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(1234567)).str().equals(StringView("1234567")));
+  EXPECT_TRUE(integer_to_string(int64_t(12345678))
+                  .str()
+                  .equals(StringView("12345678")));
+  EXPECT_TRUE(integer_to_string(int64_t(123456789))
+                  .str()
+                  .equals(StringView("123456789")));
+  EXPECT_TRUE(integer_to_string(int64_t(1234567890))
+                  .str()
+                  .equals(StringView("1234567890")));
+  EXPECT_TRUE(integer_to_string(int64_t(1234567890123456789))
+                  .str()
+                  .equals(StringView("1234567890123456789")));
+  EXPECT_TRUE(integer_to_string(int64_t(-1)).str().equals(StringView("-1")));
+  EXPECT_TRUE(integer_to_string(int64_t(-12)).str().equals(StringView("-12")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(-123)).str().equals(StringView("-123")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(-1234)).str().equals(StringView("-1234")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(-12345)).str().equals(StringView("-12345")));
+  EXPECT_TRUE(
+      integer_to_string(int64_t(-123456)).str().equals(StringView("-123456")));
+  EXPECT_TRUE(integer_to_string(int64_t(-1234567))
+                  .str()
+                  .equals(StringView("-1234567")));
+  EXPECT_TRUE(integer_to_string(int64_t(-12345678))
+                  .str()
+                  .equals(StringView("-12345678")));
+  EXPECT_TRUE(integer_to_string(int64_t(-123456789))
+                  .str()
+                  .equals(StringView("-123456789")));
+  EXPECT_TRUE(integer_to_string(int64_t(-1234567890))
+                  .str()
+                  .equals(StringView("-1234567890")));
+  EXPECT_TRUE(integer_to_string(int64_t(-1234567890123456789))
+                  .str()
+                  .equals(StringView("-1234567890123456789")));
+  EXPECT_TRUE(integer_to_string(int64_t(INT64_MAX))
+                  .str()
+                  .equals(StringView("9223372036854775807")));
+  EXPECT_TRUE(integer_to_string(int64_t(INT64_MIN))
+                  .str()
+                  .equals(StringView("-9223372036854775808")));
+}