[libc] move to combined integer converter

[michaelrj]

Summary

The functions converting integers into decimal, hexadecimal, and octal,
are all very similar. This patch moves to a combined converter to save
code size.

[michaelrj]

rebase to move integer to string tests out of this patch.

[sivachandra]

LGTM modulo the changes suggested on D131301.

[michaelrj]

rebase

[sivachandra]

libc/src/stdio/printf_core/int_converter.h

62–76

A way to avoid this ugliness would be to move this over to an inline function like this:

cpp:optional<cpp::StringView> int_to_str(char conv_name) {
  if (to_lower(conv_name) == 'x') {
    return IntegerToString<uintmax_t, 16>::convert(
        num, bufref, is_lower(to_conv.conv_name));
  } else if (conv_name == 'o') {
    return IntegerToString<uintmax_t, 8>::convert(num, bufref, true);
  } else {
    return IntegerToString<uintmax_t, 10>::convert(num, bufref, true);
  }
}

And then use it as:

auto str = int_to_string(to_conv.conv_name);
if (!str)
  return INT_CONVERSION_ERROR;

Also, feel free to add operator-> to cpp:optional so that you can call str->size() and str->data().

[michaelrj]

move optional handling to separate inline function

[sivachandra]

libc/src/stdio/printf_core/int_converter.h

61

Nit: just do if (!str)

[michaelrj]

address comment

libc/src/stdio/printf_core/CMakeLists.txt

SRCS
     converter.cpp
   HDRS
     converter.h
     converter_atlas.h
     converter_utils.h
     string_converter.h
     char_converter.h
     int_converter.h
-    hex_converter.h
     ptr_converter.h
-    oct_converter.h
     write_int_converter.h
     float_inf_nan_converter.h
     float_hex_converter.h
   DEPENDS
     .writer
     .core_structs
     libc.src.__support.integer_to_string
     libc.src.__support.CPP.limits
+    libc.src.__support.CPP.string_view
     libc.src.__support.FPUtil.fputil
 )
 
 
 add_object_library(
   printf_main
   SRCS
     printf_main.cpp

libc/src/stdio/printf_core/converter.cpp

case '%':
     return writer->write("%", 1);
   case 'c':
     return convert_char(writer, to_conv);
   case 's':
     return convert_string(writer, to_conv);
   case 'd':
   case 'i':
   case 'u':
-    return convert_int(writer, to_conv);
   case 'o':
-    return convert_oct(writer, to_conv);
   case 'x':
   case 'X':
-    return convert_hex(writer, to_conv);
+    return convert_int(writer, to_conv);
 #ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
   // case 'f':
   // case 'F':
   // return convert_float_decimal(writer, to_conv);
   // case 'e':
   // case 'E':
   // return convert_float_dec_exp(writer, to_conv);
   case 'a':

libc/src/stdio/printf_core/converter_atlas.h

 #include "src/stdio/printf_core/string_converter.h"
 
 // defines convert_char
 #include "src/stdio/printf_core/char_converter.h"
 
 // defines convert_int
 #include "src/stdio/printf_core/int_converter.h"
 
-// defines convert_oct
-#include "src/stdio/printf_core/oct_converter.h"
-// defines convert_hex
-#include "src/stdio/printf_core/hex_converter.h"
-
 #ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
 // defines convert_float_decimal
 // defines convert_float_dec_exp
 // defines convert_float_hex_exp
 #include "src/stdio/printf_core/float_hex_converter.h"
 // defines convert_float_mixed
 #endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
 #include "src/stdio/printf_core/write_int_converter.h"
 #endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
 
 // defines convert_pointer
 #include "src/stdio/printf_core/ptr_converter.h"
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_ATLAS_H

libc/src/stdio/printf_core/core_structs.h

 
 // This is the value to be returned by conversions when no error has occurred.
 constexpr int WRITE_OK = 0;
 // These are the printf return values for when an error has occurred. They are
 // all negative, and should be distinct.
 constexpr int FILE_WRITE_ERROR = -1;
 constexpr int FILE_STATUS_ERROR = -2;
 constexpr int NULLPTR_WRITE_ERROR = -3;
+constexpr int INT_CONVERSION_ERROR = -4;
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CORE_STRUCTS_H

libc/src/stdio/printf_core/hex_converter.h

-//===-- Hexadecimal 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_HEX_CONVERTER_H
-#define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_HEX_CONVERTER_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 convert_hex(Writer *writer, const FormatSection &to_conv) {
-  // This approximates the number of digits it takes to represent a hexadecimal
-  // value of a certain number of bits. Each hex digit represents 4 bits, so the
-  // exact value is the number of bytes multiplied by 2.
-  static constexpr size_t BUFF_LEN = sizeof(uintmax_t) * 2;
-  uintmax_t num = to_conv.conv_val_raw;
-  char buffer[BUFF_LEN];
-
-  // All of the characters will be defined relative to variable a, which will be
-  // the appropriate case based on the name of the conversion.
-  char a;
-  if (to_conv.conv_name == 'x')
-    a = 'a';
-  else
-    a = 'A';
-
-  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 /= 16)
-    buffer[buff_cur - 1] =
-        ((num % 16) > 9) ? ((num % 16) - 10 + a) : ((num % 16) + '0');
-
-  size_t digits_written = BUFF_LEN - buff_cur;
-
-  // these are signed to prevent underflow due to negative values. The eventual
-  // values will always be non-negative.
-  int zeroes;
-  int spaces;
-
-  // prefix is "0x"
-  int prefix_len;
-  char prefix[2];
-  if ((to_conv.flags & FormatFlags::ALTERNATE_FORM) ==
-      FormatFlags::ALTERNATE_FORM) {
-    prefix_len = 2;
-    prefix[0] = '0';
-    prefix[1] = a + ('x' - 'a');
-  } else {
-    prefix_len = 0;
-    prefix[0] = 0;
-  }
-
-  // negative precision indicates that it was not specified.
-  if (to_conv.precision < 0) {
-    if ((to_conv.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 - (2 if prefix). For example: ("%#04x", 15) -> "0x0f"
-      zeroes = to_conv.min_width - digits_written - prefix_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: ("%3x", 0) -> "  0"
-      zeroes = 1;
-      spaces = to_conv.min_width - zeroes - prefix_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 - prefix_len;
-    }
-  } else {
-    // if precision was specified, possibly write zeroes, and possibly write
-    // spaces. Example: ("%5.4x", 0x10000) -> "10000"
-    // If the check for if zeroes is negative was not there, spaces would be
-    // incorrectly evaluated as 1.
-    zeroes = to_conv.precision - digits_written; // a negative value means 0
-    if (zeroes < 0)
-      zeroes = 0;
-    spaces = to_conv.min_width - zeroes - digits_written - prefix_len;
-  }
-  if (spaces < 0)
-    spaces = 0;
-
-  if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
-      FormatFlags::LEFT_JUSTIFIED) {
-    // if left justified it goes prefix zeroes digits spaces
-    if (prefix[0] != 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(prefix, 2));
-    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));
-    if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
-  } else {
-    // else it goes spaces prefix zeroes digits
-    if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
-    if (prefix[0] != 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(prefix, 2));
-    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));
-  }
-  return WRITE_OK;
-}
-
-} // namespace printf_core
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_HEX_CONVERTER_H

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/CPP/ArrayRef.h"
+#include "src/__support/CPP/StringView.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 {
 
+// These functions only work on characters that are already known to be in the
+// alphabet. Their behavior is undefined otherwise.
+constexpr char inline to_lower(char a) { return a | 32; }
+constexpr bool inline is_lower(char a) { return (a & 32) > 0; }
+
 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;
 
   uintmax_t num = to_conv.conv_val_raw;
   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 {
+  const char a = is_lower(to_conv.conv_name) ? 'a' : 'A';
+
+  // If the conversion is signed, then handle negative values.
+  if (to_conv.conv_name == 'd' || to_conv.conv_name == 'i') {
     // 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;
     }
+  } else {
+    // 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));
   }
 
   num = apply_length_modifier(num, to_conv.length_modifier);
 
-  auto const int_to_str = integer_to_string(num);
-  size_t digits_written = int_to_str.str().size();
+  static constexpr size_t BUFSIZE = IntegerToString<uintmax_t, 8>::BUFSIZE;
+  char buff[BUFSIZE];
+  cpp::MutableArrayRef<char> bufref(buff, BUFSIZE);
+  cpp::StringView str;
+
+  {
+    cpp::optional<cpp::StringView> opt_str;
+    if (to_lower(to_conv.conv_name) == 'x') {
+      opt_str = IntegerToString<uintmax_t, 16>::convert(
+          num, bufref, is_lower(to_conv.conv_name));
+    } else if (to_conv.conv_name == 'o') {
+      opt_str = IntegerToString<uintmax_t, 8>::convert(num, bufref, true);
+    } else {
+      opt_str = IntegerToString<uintmax_t, 10>::convert(num, bufref, true);
+    }
+    if (!opt_str.has_value()) {
+      return INT_CONVERSION_ERROR;
+    }
+    str = opt_str.value();
+  }
+  size_t digits_written = 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)
     sign_char = ' ';
 
-  int sign_char_len = (sign_char == 0 ? 0 : 1);
-
   // These are signed to prevent underflow due to negative values. The eventual
   // values will always be non-negative.
   int zeroes;
   int spaces;
 
+  // prefix is "0x" for hexadecimal, or the sign character for signed
+  // conversions. Since hexadecimal is unsigned these will never conflict.
+  int prefix_len;
+  char prefix[2];
+  if ((to_lower(to_conv.conv_name) == 'x') &&
+      ((flags & FormatFlags::ALTERNATE_FORM) != 0)) {
+    prefix_len = 2;
+    prefix[0] = '0';
+    prefix[1] = a + ('x' - 'a');
+  } else {
+    prefix_len = (sign_char == 0 ? 0 : 1);
+    prefix[0] = sign_char;
+  }
+
   // Negative precision indicates that it was not specified.
   if (to_conv.precision < 0) {
     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;
+      zeroes = to_conv.min_width - digits_written - prefix_len;
       spaces = 0;
     } 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;
+      spaces = to_conv.min_width - digits_written - prefix_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;
+    spaces = to_conv.min_width - zeroes - digits_written - prefix_len;
+  }
+
+  if ((to_conv.conv_name == 'o') &&
+      ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0) && zeroes < 1) {
+    zeroes = 1;
+    --spaces;
   }
-  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 left justified it goes prefix zeroes digits spaces
+    if (prefix_len != 0)
+      RET_IF_RESULT_NEGATIVE(writer->write(prefix, prefix_len));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(
-          writer->write(int_to_str.str().data(), digits_written));
+      RET_IF_RESULT_NEGATIVE(writer->write(str.data(), digits_written));
     if (spaces > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
   } else {
-    // Else it goes spaces sign zeroes digits
+    // Else it goes spaces prefix 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 (prefix_len != 0)
+      RET_IF_RESULT_NEGATIVE(writer->write(prefix, prefix_len));
     if (zeroes > 0)
       RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
     if (digits_written > 0)
-      RET_IF_RESULT_NEGATIVE(
-          writer->write(int_to_str.str().data(), digits_written));
+      RET_IF_RESULT_NEGATIVE(writer->write(str.data(), digits_written));
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H

libc/src/stdio/printf_core/oct_converter.h

-//===-- Octal 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_OCT_CONVERTER_H
-#define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_OCT_CONVERTER_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_oct(Writer *writer, const FormatSection &to_conv) {
-  // This is the number of digits it takes to represent a octal value of a
-  // certain number of bits. Each oct digit represents 3 bits, so the value is
-  // ceil(number of bits / 3).
-  constexpr size_t BUFF_LEN = ((sizeof(uintmax_t) * 8) + 2) / 3;
-  uintmax_t num = to_conv.conv_val_raw;
-  char buffer[BUFF_LEN];
-
-  num = apply_length_modifier(num, to_conv.length_modifier);
-
-  // Since the buffer is size to sized to be able fit the entire number, buf_cur
-  // can never reach 0. So, we do not need bounds checking on buf_cur.
-  size_t buff_cur = BUFF_LEN;
-  for (; num > 0 /* && buff_cur > 0 */; --buff_cur, num /= 8)
-    buffer[buff_cur - 1] = (num % 8) + '0';
-
-  size_t num_digits = BUFF_LEN - buff_cur;
-
-  // These are signed to prevent underflow due to negative values. Negative
-  // values are treated the same as 0.
-  int zeroes;
-  int spaces;
-
-  // Negative precision indicates that it was not specified.
-  if (to_conv.precision < 0) {
-    if ((to_conv.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. For example: ("%04o", 15) -> "0017"
-      zeroes = to_conv.min_width - num_digits;
-      spaces = 0;
-    } else if (num_digits < 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: ("%3o", 0) -> "  0"
-      zeroes = 1;
-      spaces = to_conv.min_width - zeroes;
-    } 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 - num_digits;
-    }
-  } else {
-    // If precision was specified, possibly write zeroes, and possibly write
-    // spaces. Example: ("%5.4o", 010000) -> "10000"
-    // If the check for if zeroes is negative was not there, spaces would be
-    // incorrectly evaluated as 1.
-    zeroes = to_conv.precision - num_digits; // a negative value means 0
-    if (zeroes < 0)
-      zeroes = 0;
-    spaces = to_conv.min_width - zeroes - num_digits;
-  }
-
-  // The alternate form prefix is "0", so it's handled by increasing the number
-  // of zeroes if necessary.
-  if (((to_conv.flags & FormatFlags::ALTERNATE_FORM) ==
-       FormatFlags::ALTERNATE_FORM) &&
-      zeroes < 1) {
-    zeroes = 1;
-    --spaces;
-  }
-
-  if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
-      FormatFlags::LEFT_JUSTIFIED) {
-    // If left justified the pattern is zeroes digits spaces
-    if (zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
-    if (num_digits > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, num_digits));
-    if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
-  } else {
-    // Else the pattern is spaces zeroes digits
-    if (spaces > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars(' ', spaces));
-    if (zeroes > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write_chars('0', zeroes));
-    if (num_digits > 0)
-      RET_IF_RESULT_NEGATIVE(writer->write(buffer + buff_cur, num_digits));
-  }
-  return WRITE_OK;
-}
-
-} // namespace printf_core
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_OCT_CONVERTER_H

libc/src/stdio/printf_core/ptr_converter.h

 //===-- Pointer 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_PTR_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_CONVERTER_H
 
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
-#include "src/stdio/printf_core/hex_converter.h"
+#include "src/stdio/printf_core/int_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int inline convert_pointer(Writer *writer, const FormatSection &to_conv) {
   if (to_conv.conv_val_ptr == (void *)(nullptr)) {
     const char ZERO_STR[] = "(nullptr)";
     // subtract 1 from sizeof to remove the null byte at the end.
     RET_IF_RESULT_NEGATIVE(writer->write(ZERO_STR, sizeof(ZERO_STR) - 1));
   } else {
     FormatSection hex_conv;
     hex_conv.has_conv = true;
     hex_conv.conv_name = 'x';
     hex_conv.flags = FormatFlags::ALTERNATE_FORM;
     hex_conv.conv_val_raw = reinterpret_cast<uintptr_t>(to_conv.conv_val_ptr);
-    return convert_hex(writer, hex_conv);
+    return convert_int(writer, hex_conv);
   }
   return WRITE_OK;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_CONVERTER_H