[libc++] Lets to_chars use header implementation.

[Mordante]

Summary

This removes the duplicated code from the dylib. Instead the dylib will
call the new functions in the header. Since this code is unneeded it's
removed from the unstable ABI.

Depends on D125704

[ldionne]

libcxx/include/__config

119–120

libcxx/src/ryu/d2s.cpp

529

To consider: If this increases our diff with "upstream" Ryu, it might be better to either #define __DIGIT_TABLE __itoa::__digits_base_10, or static constexpr auto& __DIGIT_TABLE = __itoa::__digits_base_10;.

[Mordante]

libcxx/src/ryu/d2s.cpp

529

As mentioned in the live review, since the code is in the dylib we can use inline constexpr instead of static constexpr

[Mordante]

Rebased and addresses review comments.

libcxx/include/__config

 // about ABI compatibility.
 #  define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT
 // Remove basic_string common base
 #  define _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
 // Remove vector base class
 #  define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
 // According to the Standard, `bitset::operator[] const` returns bool
 #  define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
+// Remove std::to_chars base 10 implementation from the dylib.
+// The implementation moved the header.
+#  define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
 #elif _LIBCPP_ABI_VERSION == 1
 #  if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 // Enable compiling copies of now inline methods into the dylib to support
 // applications compiled against older libraries. This is unnecessary with
 // COFF dllexport semantics, since dllexport forces a non-inline definition
 // of inline functions to be emitted anyway. Our own non-inline copy would
 // conflict with the dllexport-emitted copy, so we disable it.
 #    define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   include/config_elast.h
   include/refstring.h
   include/ryu/common.h
   include/ryu/d2fixed.h
   include/ryu/d2fixed_full_table.h
   include/ryu/d2s.h
   include/ryu/d2s_full_table.h
   include/ryu/d2s_intrinsics.h
-  include/ryu/digit_table.h
   include/ryu/f2s.h
   include/ryu/ryu.h
   include/to_chars_floating_point.h
   legacy_pointer_safety.cpp
   memory.cpp
   mutex.cpp
   mutex_destructor.cpp
   new.cpp

libcxx/src/charconv.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <charconv>
 #include <string.h>
 
-#include "include/ryu/digit_table.h"
 #include "include/to_chars_floating_point.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace __itoa
-{
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append1(char* buffer, T i) noexcept
-{
-    *buffer = '0' + static_cast<char>(i);
-    return buffer + 1;
-}
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append2(char* buffer, T i) noexcept
-{
-    memcpy(buffer, &__DIGIT_TABLE[(i)*2], 2);
-    return buffer + 2;
-}
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append3(char* buffer, T i) noexcept
-{
-    return append2(append1(buffer, (i) / 100), (i) % 100);
-}
+#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
 
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append4(char* buffer, T i) noexcept
-{
-    return append2(append2(buffer, (i) / 100), (i) % 100);
-}
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append2_no_zeros(char* buffer, T v) noexcept
-{
-    if (v < 10)
-        return append1(buffer, v);
-    else
-        return append2(buffer, v);
-}
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append4_no_zeros(char* buffer, T v) noexcept
-{
-    if (v < 100)
-        return append2_no_zeros(buffer, v);
-    else if (v < 1000)
-        return append3(buffer, v);
-    else
-        return append4(buffer, v);
-}
-
-template <typename T>
-inline _LIBCPP_INLINE_VISIBILITY char*
-append8_no_zeros(char* buffer, T v) noexcept
-{
-    if (v < 10000)
-    {
-        buffer = append4_no_zeros(buffer, v);
-    }
-    else
-    {
-        buffer = append4_no_zeros(buffer, v / 10000);
-        buffer = append4(buffer, v % 10000);
-    }
-    return buffer;
-}
+namespace __itoa
 
 _LIBCPP_FUNC_VIS char*
 __u32toa(uint32_t value, char* buffer) noexcept
 {
-    if (value < 100000000)
-    {
-        buffer = append8_no_zeros(buffer, value);
-    }
-    else
-    {
-        // value = aabbbbcccc in decimal
-        const uint32_t a = value / 100000000;  // 1 to 42
-        value %= 100000000;
-
-        buffer = append2_no_zeros(buffer, a);
-        buffer = append4(buffer, value / 10000);
-        buffer = append4(buffer, value % 10000);
-    }
-
-    return buffer;
+  return __base_10_u32(value, buffer);
 }
 
 _LIBCPP_FUNC_VIS char*
 __u64toa(uint64_t value, char* buffer) noexcept
 {
-    if (value < 100000000)
-    {
-        uint32_t v = static_cast<uint32_t>(value);
-        buffer = append8_no_zeros(buffer, v);
-    }
-    else if (value < 10000000000000000)
-    {
-        const uint32_t v0 = static_cast<uint32_t>(value / 100000000);
-        const uint32_t v1 = static_cast<uint32_t>(value % 100000000);
-
-        buffer = append8_no_zeros(buffer, v0);
-        buffer = append4(buffer, v1 / 10000);
-        buffer = append4(buffer, v1 % 10000);
-    }
-    else
-    {
-        const uint32_t a =
-            static_cast<uint32_t>(value / 10000000000000000);  // 1 to 1844
-        value %= 10000000000000000;
-
-        buffer = append4_no_zeros(buffer, a);
-
-        const uint32_t v0 = static_cast<uint32_t>(value / 100000000);
-        const uint32_t v1 = static_cast<uint32_t>(value % 100000000);
-        buffer = append4(buffer, v0 / 10000);
-        buffer = append4(buffer, v0 % 10000);
-        buffer = append4(buffer, v1 / 10000);
-        buffer = append4(buffer, v1 % 10000);
-    }
-
-    return buffer;
+  return __base_10_u64(value, buffer);
 }
 
 }  // namespace __itoa
 
+#endif // _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+
 // The original version of floating-point to_chars was written by Microsoft and
 // contributed with the following license.
 
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 // This implementation is dedicated to the memory of Mary and Thavatchai.
 

libcxx/src/include/ryu/digit_table.h

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// Copyright 2018 Ulf Adams
-// Copyright (c) Microsoft Corporation. All rights reserved.
-
-// Boost Software License - Version 1.0 - August 17th, 2003
-
-// Permission is hereby granted, free of charge, to any person or organization
-// obtaining a copy of the software and accompanying documentation covered by
-// this license (the "Software") to use, reproduce, display, distribute,
-// execute, and transmit the Software, and to prepare derivative works of the
-// Software, and to permit third-parties to whom the Software is furnished to
-// do so, all subject to the following:
-
-// The copyright notices in the Software and this entire statement, including
-// the above license grant, this restriction and the following disclaimer,
-// must be included in all copies of the Software, in whole or in part, and
-// all derivative works of the Software, unless such copies or derivative
-// works are solely in the form of machine-executable object code generated by
-// a source language processor.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-#ifndef _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
-#define _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
-
-// Avoid formatting to keep the changes with the original code minimal.
-// clang-format off
-
-#include <__config>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// A table of all two-digit numbers. This is used to speed up decimal digit
-// generation by copying pairs of digits into the final output.
-inline constexpr char __DIGIT_TABLE[200] = {
-  '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
-  '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
-  '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
-  '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
-  '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
-  '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
-  '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
-  '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
-  '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
-  '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-// clang-format on
-
-#endif // _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H

libcxx/src/ryu/d2fixed.cpp

 #include <cstring>
 #include <system_error>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2fixed_full_table.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_intrinsics.h"
-#include "include/ryu/digit_table.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline constexpr int __POW10_ADDITIONAL_BITS = 120;
 
 #ifdef _LIBCPP_INTRINSIC128
 // Returns the low 64 bits of the high 128 bits of the 256-bit product of a and b.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint64_t __umul256_hi128_lo64(

 #ifdef __clang__ // TRANSITION, LLVM-38217
     const uint32_t __c = __digits - 10000 * (__digits / 10000);
 #else
     const uint32_t __c = __digits % 10000;
 #endif
     __digits /= 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
-    _VSTD::memcpy(__result + __olength - __i - 2, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + __olength - __i - 4, __DIGIT_TABLE + __c1, 2);
+    _VSTD::memcpy(__result + __olength - __i - 2, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + __olength - __i - 4, __itoa::__digits_base_10 + __c1, 2);
     __i += 4;
   }
   if (__digits >= 100) {
     const uint32_t __c = (__digits % 100) << 1;
     __digits /= 100;
-    _VSTD::memcpy(__result + __olength - __i - 2, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __olength - __i - 2, __itoa::__digits_base_10 + __c, 2);
     __i += 2;
   }
   if (__digits >= 10) {
     const uint32_t __c = __digits << 1;
-    _VSTD::memcpy(__result + __olength - __i - 2, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __olength - __i - 2, __itoa::__digits_base_10 + __c, 2);
   } else {
     __result[0] = static_cast<char>('0' + __digits);
   }
 }
 
 _LIBCPP_HIDE_FROM_ABI inline void __append_d_digits(const uint32_t __olength, uint32_t __digits, char* const __result) {
   uint32_t __i = 0;
   while (__digits >= 10000) {
 #ifdef __clang__ // TRANSITION, LLVM-38217
     const uint32_t __c = __digits - 10000 * (__digits / 10000);
 #else
     const uint32_t __c = __digits % 10000;
 #endif
     __digits /= 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
-    _VSTD::memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + __olength + 1 - __i - 4, __DIGIT_TABLE + __c1, 2);
+    _VSTD::memcpy(__result + __olength + 1 - __i - 2, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + __olength + 1 - __i - 4, __itoa::__digits_base_10 + __c1, 2);
     __i += 4;
   }
   if (__digits >= 100) {
     const uint32_t __c = (__digits % 100) << 1;
     __digits /= 100;
-    _VSTD::memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __olength + 1 - __i - 2, __itoa::__digits_base_10 + __c, 2);
     __i += 2;
   }
   if (__digits >= 10) {
     const uint32_t __c = __digits << 1;
-    __result[2] = __DIGIT_TABLE[__c + 1];
+    __result[2] = __itoa::__digits_base_10[__c + 1];
     __result[1] = '.';
-    __result[0] = __DIGIT_TABLE[__c];
+    __result[0] = __itoa::__digits_base_10[__c];
   } else {
     __result[1] = '.';
     __result[0] = static_cast<char>('0' + __digits);
   }
 }
 
 _LIBCPP_HIDE_FROM_ABI inline void __append_c_digits(const uint32_t __count, uint32_t __digits, char* const __result) {
   uint32_t __i = 0;
   for (; __i < __count - 1; __i += 2) {
     const uint32_t __c = (__digits % 100) << 1;
     __digits /= 100;
-    _VSTD::memcpy(__result + __count - __i - 2, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __count - __i - 2, __itoa::__digits_base_10 + __c, 2);
   }
   if (__i < __count) {
     const char __c = static_cast<char>('0' + (__digits % 10));
     __result[__count - __i - 1] = __c;
   }
 }
 
 void __append_nine_digits(uint32_t __digits, char* const __result) {
   if (__digits == 0) {
     _VSTD::memset(__result, '0', 9);
     return;
   }
 
   for (uint32_t __i = 0; __i < 5; __i += 4) {
 #ifdef __clang__ // TRANSITION, LLVM-38217
     const uint32_t __c = __digits - 10000 * (__digits / 10000);
 #else
     const uint32_t __c = __digits % 10000;
 #endif
     __digits /= 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
-    _VSTD::memcpy(__result + 7 - __i, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + 5 - __i, __DIGIT_TABLE + __c1, 2);
+    _VSTD::memcpy(__result + 7 - __i, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + 5 - __i, __itoa::__digits_base_10 + __c1, 2);
   }
   __result[0] = static_cast<char>('0' + __digits);
 }
 
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __indexForExponent(const uint32_t __e) {
   return (__e + 15) / 16;
 }
 
if (_Last - _First < _Exponent_part_length) {
     return { _Last, errc::value_too_large };
   }
 
   *_First++ = 'e';
   *_First++ = _Sign_character;
 
   if (__exp >= 100) {
     const int32_t __c = __exp % 10;
-    _VSTD::memcpy(_First, __DIGIT_TABLE + 2 * (__exp / 10), 2);
+    _VSTD::memcpy(_First, __itoa::__digits_base_10 + 2 * (__exp / 10), 2);
     _First[2] = static_cast<char>('0' + __c);
     _First += 3;
   } else {
-    _VSTD::memcpy(_First, __DIGIT_TABLE + 2 * __exp, 2);
+    _VSTD::memcpy(_First, __itoa::__digits_base_10 + 2 * __exp, 2);
     _First += 2;
   }
 
   return { _First, errc{} };
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 // clang-format on

libcxx/src/ryu/d2s.cpp

 #include <__config>
 #include <charconv>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_full_table.h"
 #include "include/ryu/d2s_intrinsics.h"
-#include "include/ryu/digit_table.h"
 #include "include/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // We need a 64x128-bit multiplication and a subsequent 128-bit shift.
 // Multiplication:
 //   The 64-bit factor is variable and passed in, the 128-bit factor comes
 //   from a lookup table. We know that the 64-bit factor only has 55
if ((_Output >> 32) != 0) {
       const uint32_t __c = __output2 % 10000;
       __output2 /= 10000;
       const uint32_t __d = __output2 % 10000;
       const uint32_t __c0 = (__c % 100) << 1;
       const uint32_t __c1 = (__c / 100) << 1;
       const uint32_t __d0 = (__d % 100) << 1;
       const uint32_t __d1 = (__d / 100) << 1;
 
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c0, 2);
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c1, 2);
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __d0, 2);
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __d1, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c0, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c1, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __d0, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __d1, 2);
     }
     uint32_t __output2 = static_cast<uint32_t>(_Output);
     while (__output2 >= 10000) {
 #ifdef __clang__ // TRANSITION, LLVM-38217
       const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
 #else
       const uint32_t __c = __output2 % 10000;
 #endif
       __output2 /= 10000;
       const uint32_t __c0 = (__c % 100) << 1;
       const uint32_t __c1 = (__c / 100) << 1;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c0, 2);
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c1, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c0, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c1, 2);
     }
     if (__output2 >= 100) {
       const uint32_t __c = (__output2 % 100) << 1;
       __output2 /= 100;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c, 2);
     }
     if (__output2 >= 10) {
       const uint32_t __c = __output2 << 1;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c, 2);
     } else {
       *--_Mid = static_cast<char>('0' + __output2);
     }
 
     if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
       // Performance note: it might be more efficient to do this immediately after setting _Mid.
       _VSTD::memset(_First + __olength, '0', static_cast<size_t>(_Ryu_exponent));
     } else if (_Ryu_exponent == 0) { // case "1729"
if ((_Output >> 32) != 0) {
 
     const uint32_t __c = __output2 % 10000;
     __output2 /= 10000;
     const uint32_t __d = __output2 % 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
     const uint32_t __d0 = (__d % 100) << 1;
     const uint32_t __d1 = (__d / 100) << 1;
-    _VSTD::memcpy(__result + __olength - __i - 1, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + __olength - __i - 3, __DIGIT_TABLE + __c1, 2);
-    _VSTD::memcpy(__result + __olength - __i - 5, __DIGIT_TABLE + __d0, 2);
-    _VSTD::memcpy(__result + __olength - __i - 7, __DIGIT_TABLE + __d1, 2);
+    _VSTD::memcpy(__result + __olength - __i - 1, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + __olength - __i - 3, __itoa::__digits_base_10 + __c1, 2);
+    _VSTD::memcpy(__result + __olength - __i - 5, __itoa::__digits_base_10 + __d0, 2);
+    _VSTD::memcpy(__result + __olength - __i - 7, __itoa::__digits_base_10 + __d1, 2);
     __i += 8;
   }
   uint32_t __output2 = static_cast<uint32_t>(_Output);
   while (__output2 >= 10000) {
 #ifdef __clang__ // TRANSITION, LLVM-38217
     const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
 #else
     const uint32_t __c = __output2 % 10000;
 #endif
     __output2 /= 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
-    _VSTD::memcpy(__result + __olength - __i - 1, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + __olength - __i - 3, __DIGIT_TABLE + __c1, 2);
+    _VSTD::memcpy(__result + __olength - __i - 1, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + __olength - __i - 3, __itoa::__digits_base_10 + __c1, 2);
     __i += 4;
   }
   if (__output2 >= 100) {
     const uint32_t __c = (__output2 % 100) << 1;
     __output2 /= 100;
-    _VSTD::memcpy(__result + __olength - __i - 1, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __olength - __i - 1, __itoa::__digits_base_10 + __c, 2);
     __i += 2;
   }
   if (__output2 >= 10) {
     const uint32_t __c = __output2 << 1;
     // We can't use memcpy here: the decimal dot goes between these two digits.
-    __result[2] = __DIGIT_TABLE[__c + 1];
-    __result[0] = __DIGIT_TABLE[__c];
+    __result[2] = __itoa::__digits_base_10[__c + 1];
+    __result[0] = __itoa::__digits_base_10[__c];
   } else {
     __result[0] = static_cast<char>('0' + __output2);
   }
 
   // Print decimal point if needed.
   uint32_t __index;
   if (__olength > 1) {
     __result[1] = '.';
     __index = __olength + 1;
   } else {
     __index = 1;
   }
 
   // Print the exponent.
   __result[__index++] = 'e';
   if (_Scientific_exponent < 0) {
     __result[__index++] = '-';
     _Scientific_exponent = -_Scientific_exponent;
   } else {
     __result[__index++] = '+';
   }
 
   if (_Scientific_exponent >= 100) {
     const int32_t __c = _Scientific_exponent % 10;
-    _VSTD::memcpy(__result + __index, __DIGIT_TABLE + 2 * (_Scientific_exponent / 10), 2);
+    _VSTD::memcpy(__result + __index, __itoa::__digits_base_10 + 2 * (_Scientific_exponent / 10), 2);
     __result[__index + 2] = static_cast<char>('0' + __c);
     __index += 3;
   } else {
-    _VSTD::memcpy(__result + __index, __DIGIT_TABLE + 2 * _Scientific_exponent, 2);
+    _VSTD::memcpy(__result + __index, __itoa::__digits_base_10 + 2 * _Scientific_exponent, 2);
     __index += 2;
   }
 
   return { _First + _Total_scientific_length, errc{} };
 }
 
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline bool __d2d_small_int(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent,
   __floating_decimal_64* const __v) {

libcxx/src/ryu/f2s.cpp

 
 #include <__assert>
 #include <__config>
 #include <charconv>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s_intrinsics.h"
-#include "include/ryu/digit_table.h"
 #include "include/ryu/f2s.h"
 #include "include/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline constexpr int __FLOAT_MANTISSA_BITS = 23;
 inline constexpr int __FLOAT_EXPONENT_BITS = 8;
 inline constexpr int __FLOAT_BIAS = 127;

 #ifdef __clang__ // TRANSITION, LLVM-38217
       const uint32_t __c = _Output - 10000 * (_Output / 10000);
 #else
       const uint32_t __c = _Output % 10000;
 #endif
       _Output /= 10000;
       const uint32_t __c0 = (__c % 100) << 1;
       const uint32_t __c1 = (__c / 100) << 1;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c0, 2);
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c1, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c0, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c1, 2);
     }
     if (_Output >= 100) {
       const uint32_t __c = (_Output % 100) << 1;
       _Output /= 100;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c, 2);
     }
     if (_Output >= 10) {
       const uint32_t __c = _Output << 1;
-      _VSTD::memcpy(_Mid -= 2, __DIGIT_TABLE + __c, 2);
+      _VSTD::memcpy(_Mid -= 2, __itoa::__digits_base_10 + __c, 2);
     } else {
       *--_Mid = static_cast<char>('0' + _Output);
     }
 
     if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
       // Performance note: it might be more efficient to do this immediately after setting _Mid.
       _VSTD::memset(_First + __olength, '0', static_cast<size_t>(_Ryu_exponent));
     } else if (_Ryu_exponent == 0) { // case "1729"

 #ifdef __clang__ // TRANSITION, LLVM-38217
     const uint32_t __c = _Output - 10000 * (_Output / 10000);
 #else
     const uint32_t __c = _Output % 10000;
 #endif
     _Output /= 10000;
     const uint32_t __c0 = (__c % 100) << 1;
     const uint32_t __c1 = (__c / 100) << 1;
-    _VSTD::memcpy(__result + __olength - __i - 1, __DIGIT_TABLE + __c0, 2);
-    _VSTD::memcpy(__result + __olength - __i - 3, __DIGIT_TABLE + __c1, 2);
+    _VSTD::memcpy(__result + __olength - __i - 1, __itoa::__digits_base_10 + __c0, 2);
+    _VSTD::memcpy(__result + __olength - __i - 3, __itoa::__digits_base_10 + __c1, 2);
     __i += 4;
   }
   if (_Output >= 100) {
     const uint32_t __c = (_Output % 100) << 1;
     _Output /= 100;
-    _VSTD::memcpy(__result + __olength - __i - 1, __DIGIT_TABLE + __c, 2);
+    _VSTD::memcpy(__result + __olength - __i - 1, __itoa::__digits_base_10 + __c, 2);
     __i += 2;
   }
   if (_Output >= 10) {
     const uint32_t __c = _Output << 1;
     // We can't use memcpy here: the decimal dot goes between these two digits.
-    __result[2] = __DIGIT_TABLE[__c + 1];
-    __result[0] = __DIGIT_TABLE[__c];
+    __result[2] = __itoa::__digits_base_10[__c + 1];
+    __result[0] = __itoa::__digits_base_10[__c];
   } else {
     __result[0] = static_cast<char>('0' + _Output);
   }
 
   // Print decimal point if needed.
   uint32_t __index;
   if (__olength > 1) {
     __result[1] = '.';
     __index = __olength + 1;
   } else {
     __index = 1;
   }
 
   // Print the exponent.
   __result[__index++] = 'e';
   if (_Scientific_exponent < 0) {
     __result[__index++] = '-';
     _Scientific_exponent = -_Scientific_exponent;
   } else {
     __result[__index++] = '+';
   }
 
-  _VSTD::memcpy(__result + __index, __DIGIT_TABLE + 2 * _Scientific_exponent, 2);
+  _VSTD::memcpy(__result + __index, __itoa::__digits_base_10 + 2 * _Scientific_exponent, 2);
   __index += 2;
 
   return { _First + _Total_scientific_length, errc{} };
 }
 
 [[nodiscard]] to_chars_result __f2s_buffered_n(char* const _First, char* const _Last, const float __f,
   const chars_format _Fmt) {