[libc++] Implements constexpr <charconv>.

[Mordante]

Summary

Implements:

• P2291R3 Add Constexpr Modifiers to Functions to_chars and from_chars for Integral Types in <charconv> Header

[philnik]

libcxx/include/__charconv/tables.h

26

What is the difference between the versions? Why can't the arrays be constexpr before C++17?

libcxx/include/__config

852–856 ↗

(On Diff #450499)

I've named this _LIBCPP_CONSTEXPR_CXX23 in D131218 because I find it a lot more intuitive. I'll open a discussion on Discord whether we want this change or not.

libcxx/include/charconv

33–34

I think we don't add the constexpr if it's "constexpr since C++ab".

711–720

What does this do here?

742

Is there a reason this isn't in C++11 or 14?

libcxx/test/support/charconv_test_helpers.h

99

Maybe make this a runtime-only test or implement it a constexpr memcmp for portability?

[Mordante]

Fixes CI.

[Mordante]

More CI fixes.

[Mordante]

Attempts to fix the CI.

[Mordante]

CI fixes.

[Mordante]

Attempts to fix GCC CI.

[Mordante]

Fixes GCC CI.

[Mordante]

Thanks for the review!

libcxx/include/__charconv/tables.h

26

No inline constexpr before C++17. I want to look at this later but prefer to move that out of this change.

libcxx/include/__config

852–856 ↗

(On Diff #450499)

Yeah it seems we manage to get 3 reviews that basically add this macro at the same time.
I keep it for now until we finished the discussion which direction to go.

libcxx/include/charconv

33–34

We do, git grep 'constexpr.*constexpr' include shows a lot of hits, some for C++14.

711–720

The "script" to generate the table below.

742

yes not inline constexpr and log2f itself isn't constexpr so it can't be used in C++23.

libcxx/test/libcxx/clang_tidy.sh.cpp

11 ↗

(On Diff #450837)

@philnik does running this in GCC have any benefit for this test?
I see there are work-arounds for unsupported diagnostics and now I have an unsupported compiler option -fconstexpr-ops-limit. I even wonder should this be limited to the clang compiler?

[philnik]

libcxx/include/__charconv/tables.h

26

Isn't this in the class to achieve the same effect? Clang seems to be happy with that in C++11: https://godbolt.org/z/c6nz39xbv

libcxx/include/__config

852–856 ↗

(On Diff #450499)

Sounds good to me. Although there seems to be no opposition to the change.

libcxx/include/charconv

711–720

Oh OK. Could you maybe add a comment like // __from_chars_log2f_lut generator script?

libcxx/test/libcxx/clang_tidy.sh.cpp

11 ↗

(On Diff #450837)

It also works for people who primarily use GCC, but I guess that's about zero people. So it's probably fine to disable it entirely for GCC. Could you also remove the compatibility stuff in that case?

[Mordante]

libcxx/include/__config

852–856 ↗

(On Diff #450499)

True, but I expect one of the other two patches to land before this one, so then I can remove this hunk, rebase, and fix the other places. There are some changes here that shouldn't be hiding in this review; but I really want to get a CI run before making these changes.

libcxx/test/libcxx/clang_tidy.sh.cpp

11 ↗

(On Diff #450837)

Yes I intend to do that, however I want to move these changes to their own review.

[h-vetinari]

libcxx/include/__config

852–856 ↗

(On Diff #450499)

To me, _LIBCPP_CONSTEXPR_AFTER_CXX20 sounds like it is inclusive "after", i.e. also C++20.

Perhaps "FROM" is less ambiguous w.r.t to >= vs. > than "AFTER"? I think the most intuitive option might be: _LIBCPP_CONSTEXPR_FROM_CXX23

[Mordante]

libcxx/include/__config

852–856 ↗

(On Diff #450499)

To me after sounds exclusive. I'm not sure when _LIBCPP_CONSTEXPR_AFTER_CXX11 was added, but I strongly expect that was in the era where C++0x had just slipped to C++11 and it was uncertain the then new 3 year schedule would be a real thing. So I understand the naming from a historical point of view. I prefer without the FROM since that's what we already do in our lit tests. We already settled on that in our Discord channel.

[Mordante]

libcxx/include/__charconv/tables.h

26

Changed to inline constexpr instead.

[Mordante]

Reworked the patch to work on main and addressed review comments.

[Mordante]

Fixes CI.

[Mordante]

Attempts to fix CI.

[Mordante]

Attempts to fix CI.

[Mordante]

Fix CI.

[Mordante]

Fix the CI.

[Mordante]

Removes pre C++17 support.

[ldionne]

libcxx/include/charconv

741–742

Do we ever validate that __base <= 36? If not, we should add an assertion, but probably at a higher level. And here we should just add a comment like // __base is always between 2 and 36 inclusive.

libcxx/test/support/charconv_test_helpers.h

99

I think we could use std::equal here?

104–105

Can we get rid of this while we're at it?

140

This does weaken the test inside constexpr because this is now a roundtrip test (and we already have a test for that), but I guess it's better than nothing.

[Mordante]

Thanks for the reviews!

libcxx/include/charconv

797

The base range validation is done here.

[Mordante]

Rebased and addresses review comments.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_associative_heterogeneous_erasure``   *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_back``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_byteswap``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_bitset``                    ``202207L``
     ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_charconv``                  ``202207L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_cmath``                     *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_memory``                    ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_typeinfo``                  *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_forward_like``                        ``202207L``
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 
 Implemented Papers
 ------------------
 - P2499R0 - ``string_view`` range constructor should be ``explicit``
 - P2417R2 - A more constexpr bitset
 - P2445R1 - ``std::forward_like``
 - P2273R3 - Making ``std::unique_ptr`` constexpr
 - P0591R4 - Utility functions to implement uses-allocator construction
+- P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
+  ``from_chars`` for Integral Types in ``<charconv>`` Header
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","",""
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
 "`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","",""
 "`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","",""
 "`P2165R4 <https://wg21.link/P2165R4>`__","LWG","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","July 2022","",""
 "`P2278R4 <https://wg21.link/P2278R4>`__","LWG","``cbegin`` should always return a constant iterator","July 2022","",""
 "`P2286R8 <https://wg21.link/P2286R8>`__","LWG","Formatting Ranges","July 2022","",""
-"`P2291R3 <https://wg21.link/P2291R3>`__","LWG","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","July 2022","|In Progress|",""
+"`P2291R3 <https://wg21.link/P2291R3>`__","LWG","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","July 2022","|Complete|","16.0"
 "`P2302R4 <https://wg21.link/P2302R4>`__","LWG","``std::ranges::contains``","July 2022","",""
 "`P2322R6 <https://wg21.link/P2322R6>`__","LWG","``ranges::fold``","July 2022","",""
 "`P2374R4 <https://wg21.link/P2374R4>`__","LWG","``views::cartesian_product``","July 2022","",""
 "`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","",""
 "`P2408R5 <https://wg21.link/P2408R5>`__","LWG","Ranges iterators as inputs to non-Ranges algorithms","July 2022","",""
 "`P2417R2 <https://wg21.link/P2417R2>`__","LWG","A more ``constexpr`` ``bitset``","July 2022","|Complete|","16.0"
 "`P2419R2 <https://wg21.link/P2419R2>`__","LWG","Clarify handling of encodings in localized formatting of chrono types","July 2022","",""
 "`P2438R2 <https://wg21.link/P2438R2>`__","LWG","``std::string::substr() &&``","July 2022","",""

libcxx/include/__charconv/tables.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 namespace __itoa {
 
-/// Contains the charconv helper tables.
-///
-/// In C++17 these could be inline constexpr variable, but libc++ supports
-/// charconv for integrals in C++11 mode.
-template <class = void>
-struct __table {
-  static const char __base_2_lut[64];
-  static const char __base_8_lut[128];
-  static const char __base_16_lut[512];
-
-  static const uint32_t __pow10_32[10];
-  static const uint64_t __pow10_64[20];
-#  ifndef _LIBCPP_HAS_NO_INT128
-  // TODO FMT Reduce the number of entries in this table.
-  static const __uint128_t __pow10_128[40];
-  static const int __pow10_128_offset = 0;
-#  endif
-  static const char __digits_base_10[200];
-};
-
-template <class _Tp>
-const char __table<_Tp>::__base_2_lut[64] = {
+inline constexpr char __base_2_lut[64] = {
     '0', '0', '0', '0', '0', '0', '0', '1', '0', '0', '1', '0', '0', '0', '1', '1', '0', '1', '0', '0', '0', '1',
     '0', '1', '0', '1', '1', '0', '0', '1', '1', '1', '1', '0', '0', '0', '1', '0', '0', '1', '1', '0', '1', '0',
     '1', '0', '1', '1', '1', '1', '0', '0', '1', '1', '0', '1', '1', '1', '1', '0', '1', '1', '1', '1'};
 
-template <class _Tp>
-const char __table<_Tp>::__base_8_lut[128] = {
+inline constexpr char __base_8_lut[128] = {
     '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '1', '0', '1', '1', '1', '2',
     '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5',
     '2', '6', '2', '7', '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '4', '0',
     '4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '5', '0', '5', '1', '5', '2', '5', '3',
     '5', '4', '5', '5', '5', '6', '5', '7', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6',
     '6', '7', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7'};
 
-template <class _Tp>
-const char __table<_Tp>::__base_16_lut[512] = {
+inline constexpr char __base_16_lut[512] = {
     '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '0', 'a', '0',
     'b', '0', 'c', '0', 'd', '0', 'e', '0', 'f', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6',
     '1', '7', '1', '8', '1', '9', '1', 'a', '1', 'b', '1', 'c', '1', 'd', '1', 'e', '1', 'f', '2', '0', '2', '1', '2',
     '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', '2', 'a', '2', 'b', '2', 'c', '2', 'd',
     '2', 'e', '2', 'f', '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3',
     '9', '3', 'a', '3', 'b', '3', 'c', '3', 'd', '3', 'e', '3', 'f', '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
     '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '4', 'a', '4', 'b', '4', 'c', '4', 'd', '4', 'e', '4', 'f', '5',
     '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', '5', 'a', '5', 'b',
     '5', 'c', '5', 'd', '5', 'e', '5', 'f', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6',
     '7', '6', '8', '6', '9', '6', 'a', '6', 'b', '6', 'c', '6', 'd', '6', 'e', '6', 'f', '7', '0', '7', '1', '7', '2',
     '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '7', 'a', '7', 'b', '7', 'c', '7', 'd', '7',
     'e', '7', 'f', '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
     '8', 'a', '8', 'b', '8', 'c', '8', 'd', '8', 'e', '8', 'f', '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9',
     '5', '9', '6', '9', '7', '9', '8', '9', '9', '9', 'a', '9', 'b', '9', 'c', '9', 'd', '9', 'e', '9', 'f', 'a', '0',
     'a', '1', 'a', '2', 'a', '3', 'a', '4', 'a', '5', 'a', '6', 'a', '7', 'a', '8', 'a', '9', 'a', 'a', 'a', 'b', 'a',
     'c', 'a', 'd', 'a', 'e', 'a', 'f', 'b', '0', 'b', '1', 'b', '2', 'b', '3', 'b', '4', 'b', '5', 'b', '6', 'b', '7',
     'b', '8', 'b', '9', 'b', 'a', 'b', 'b', 'b', 'c', 'b', 'd', 'b', 'e', 'b', 'f', 'c', '0', 'c', '1', 'c', '2', 'c',
     '3', 'c', '4', 'c', '5', 'c', '6', 'c', '7', 'c', '8', 'c', '9', 'c', 'a', 'c', 'b', 'c', 'c', 'c', 'd', 'c', 'e',
     'c', 'f', 'd', '0', 'd', '1', 'd', '2', 'd', '3', 'd', '4', 'd', '5', 'd', '6', 'd', '7', 'd', '8', 'd', '9', 'd',
     'a', 'd', 'b', 'd', 'c', 'd', 'd', 'd', 'e', 'd', 'f', 'e', '0', 'e', '1', 'e', '2', 'e', '3', 'e', '4', 'e', '5',
     'e', '6', 'e', '7', 'e', '8', 'e', '9', 'e', 'a', 'e', 'b', 'e', 'c', 'e', 'd', 'e', 'e', 'e', 'f', 'f', '0', 'f',
     '1', 'f', '2', 'f', '3', 'f', '4', 'f', '5', 'f', '6', 'f', '7', 'f', '8', 'f', '9', 'f', 'a', 'f', 'b', 'f', 'c',
     'f', 'd', 'f', 'e', 'f', 'f'};
 
-template <class _Tp>
-const uint32_t __table<_Tp>::__pow10_32[10] = {
+inline constexpr uint32_t __pow10_32[10] = {
     UINT32_C(0),      UINT32_C(10),      UINT32_C(100),      UINT32_C(1000),      UINT32_C(10000),
     UINT32_C(100000), UINT32_C(1000000), UINT32_C(10000000), UINT32_C(100000000), UINT32_C(1000000000)};
 
-template <class _Tp>
-const uint64_t __table<_Tp>::__pow10_64[20] = {UINT64_C(0),
+inline constexpr uint64_t __pow10_64[20] = {UINT64_C(0),
                                                UINT64_C(10),
                                                UINT64_C(100),
                                                UINT64_C(1000),
                                                UINT64_C(10000),
                                                UINT64_C(100000),
                                                UINT64_C(1000000),
                                                UINT64_C(10000000),
                                                UINT64_C(100000000),
                                                UINT64_C(1000000000),
                                                UINT64_C(10000000000),
                                                UINT64_C(100000000000),
                                                UINT64_C(1000000000000),
                                                UINT64_C(10000000000000),
                                                UINT64_C(100000000000000),
                                                UINT64_C(1000000000000000),
                                                UINT64_C(10000000000000000),
                                                UINT64_C(100000000000000000),
                                                UINT64_C(1000000000000000000),
                                                UINT64_C(10000000000000000000)};
 
 #  ifndef _LIBCPP_HAS_NO_INT128
-template <class _Tp>
-const __uint128_t __table<_Tp>::__pow10_128[40] = {
+inline constexpr int __pow10_128_offset = 0;
+inline constexpr __uint128_t __pow10_128[40] = {
     UINT64_C(0),
     UINT64_C(10),
     UINT64_C(100),
     UINT64_C(1000),
     UINT64_C(10000),
     UINT64_C(100000),
     UINT64_C(1000000),
     UINT64_C(10000000),
inline constexpr __uint128_t __pow10_128[40] = {
     __uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(1000000000000000),
     __uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(10000000000000000),
     __uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(100000000000000000),
     __uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(1000000000000000000),
     __uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(10000000000000000000),
     (__uint128_t(UINT64_C(10000000000000000000)) * UINT64_C(10000000000000000000)) * 10};
 #  endif
 
-template <class _Tp>
-const char __table<_Tp>::__digits_base_10[200] = {
+inline constexpr char __digits_base_10[200] = {
     // clang-format off
     '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',

libcxx/include/__charconv/to_chars_base_10.h

 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 namespace __itoa {
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append1(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append1(char* __first, uint32_t __value) noexcept {
   *__first = '0' + static_cast<char>(__value);
   return __first + 1;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append2(char* __first, uint32_t __value) noexcept {
-  return std::copy_n(&__table<>::__digits_base_10[__value * 2], 2, __first);
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append2(char* __first, uint32_t __value) noexcept {
+  return std::copy_n(&__digits_base_10[__value * 2], 2, __first);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append3(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append3(char* __first, uint32_t __value) noexcept {
   return __itoa::__append2(__itoa::__append1(__first, __value / 100), __value % 100);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append4(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append4(char* __first, uint32_t __value) noexcept {
   return __itoa::__append2(__itoa::__append2(__first, __value / 100), __value % 100);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append5(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append5(char* __first, uint32_t __value) noexcept {
   return __itoa::__append4(__itoa::__append1(__first, __value / 10000), __value % 10000);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append6(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append6(char* __first, uint32_t __value) noexcept {
   return __itoa::__append4(__itoa::__append2(__first, __value / 10000), __value % 10000);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append7(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append7(char* __first, uint32_t __value) noexcept {
   return __itoa::__append6(__itoa::__append1(__first, __value / 1000000), __value % 1000000);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append8(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append8(char* __first, uint32_t __value) noexcept {
   return __itoa::__append6(__itoa::__append2(__first, __value / 1000000), __value % 1000000);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __append9(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append9(char* __first, uint32_t __value) noexcept {
   return __itoa::__append8(__itoa::__append1(__first, __value / 100000000), __value % 100000000);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI char* __append10(char* __first, _Tp __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI char* __append10(char* __first, _Tp __value) noexcept {
   return __itoa::__append8(__itoa::__append2(__first, static_cast<uint32_t>(__value / 100000000)),
                            static_cast<uint32_t>(__value % 100000000));
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __base_10_u32(char* __first, uint32_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __base_10_u32(char* __first, uint32_t __value) noexcept {
   if (__value < 1000000) {
     if (__value < 10000) {
       if (__value < 100) {
         // 0 <= __value < 100
         if (__value < 10)
           return __itoa::__append1(__first, __value);
         return __itoa::__append2(__first, __value);
       }
_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __base_10_u32(char* __first, uint32_t __value) noexcept {
   }
 
   // 100'000'000 <= __value < max
   if (__value < 1000000000)
     return __itoa::__append9(__first, __value);
   return __itoa::__append10(__first, __value);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __base_10_u64(char* __buffer, uint64_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __base_10_u64(char* __buffer, uint64_t __value) noexcept {
   if (__value <= UINT32_MAX)
     return __itoa::__base_10_u32(__buffer, static_cast<uint32_t>(__value));
 
   // Numbers in the range UINT32_MAX <= val < 10'000'000'000 always contain 10
   // digits and are outputted after this if statement.
   if (__value >= 10000000000) {
     // This function properly deterimines the first non-zero leading digit.
     __buffer = __itoa::__base_10_u32(__buffer, static_cast<uint32_t>(__value / 10000000000));
     __value %= 10000000000;
   }
   return __itoa::__append10(__buffer, __value);
 }
 
 #  ifndef _LIBCPP_HAS_NO_INT128
 /// \returns 10^\a exp
 ///
 /// \pre \a exp [19, 39]
 ///
 /// \note The lookup table contains a partial set of exponents limiting the
 /// range that can be used. However the range is sufficient for
 /// \ref __base_10_u128.
-_LIBCPP_HIDE_FROM_ABI inline __uint128_t __pow_10(int __exp) noexcept {
-  _LIBCPP_ASSERT(__exp >= __table<>::__pow10_128_offset, "Index out of bounds");
-  return __table<>::__pow10_128[__exp - __table<>::__pow10_128_offset];
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline __uint128_t __pow_10(int __exp) noexcept {
+  _LIBCPP_ASSERT(__exp >= __pow10_128_offset, "Index out of bounds");
+  return __pow10_128[__exp - __pow10_128_offset];
 }
 
-_LIBCPP_HIDE_FROM_ABI inline char* __base_10_u128(char* __buffer, __uint128_t __value) noexcept {
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __base_10_u128(char* __buffer, __uint128_t __value) noexcept {
   _LIBCPP_ASSERT(
       __value > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fail when this isn't true.");
 
   // Unlike the 64 to 32 bit case the 128 bit case the "upper half" can't be
   // stored in the "lower half". Instead we first need to handle the top most
   // digits separately.
   //
   // Maximum unsigned values

libcxx/include/charconv

namespace std {
 
   // 23.20.2, primitive numerical output conversion
   struct to_chars_result {
     char* ptr;
     errc ec;
     friend bool operator==(const to_chars_result&, const to_chars_result&) = default; // since C++20
   };
 
-  to_chars_result to_chars(char* first, char* last, see below value,
-                           int base = 10);
+  constexpr to_chars_result to_chars(char* first, char* last, see below value,
+                                     int base = 10);                                  // constexpr since C++23
   to_chars_result to_chars(char* first, char* last, bool value,
                            int base = 10) = delete;
 
   to_chars_result to_chars(char* first, char* last, float value);
   to_chars_result to_chars(char* first, char* last, double value);
   to_chars_result to_chars(char* first, char* last, long double value);
 
   to_chars_result to_chars(char* first, char* last, float value,
namespace std {
 
   // 23.20.3, primitive numerical input conversion
   struct from_chars_result {
     const char* ptr;
     errc ec;
     friend bool operator==(const from_chars_result&, const from_chars_result&) = default; // since C++20
   };
 
-  from_chars_result from_chars(const char* first, const char* last,
-                               see below& value, int base = 10);
+  constexpr from_chars_result from_chars(const char* first, const char* last,
+                               see below& value, int base = 10);                         // constexpr since C++23
 
   from_chars_result from_chars(const char* first, const char* last,
                                float& value,
                                chars_format fmt = chars_format::general);
   from_chars_result from_chars(const char* first, const char* last,
                                double& value,
                                chars_format fmt = chars_format::general);
   from_chars_result from_chars(const char* first, const char* last,
                                long double& value,
                                chars_format fmt = chars_format::general);
 
 } // namespace std
 
 */
 
+#include <__algorithm/copy_n.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__bits>
 #include <__charconv/chars_format.h>
 #include <__charconv/from_chars_result.h>
 #include <__charconv/tables.h>
 #include <__charconv/to_chars_base_10.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
 #include <__debug>
 #include <__errc>
+#include <__memory/addressof.h>
 #include <__type_traits/make_32_64_or_128_bit.h>
 #include <__utility/unreachable.h>
 #include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <type_traits>
struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) <= sizeof(uint32_t)>>
     /// The width estimation using a log10 algorithm.
     ///
     /// The algorithm is based on
     /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
     /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that
     /// function requires its input to have at least one bit set the value of
     /// zero is set to one. This means the first element of the lookup table is
     /// zero.
-    static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
+    static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
     {
         auto __t = (32 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12;
-        return __t - (__v < __table<>::__pow10_32[__t]) + 1;
+        return __t - (__v < __itoa::__pow10_32[__t]) + 1;
     }
 
-    static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v)
+    static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v)
     {
         return __itoa::__base_10_u32(__p, __v);
     }
 
-    static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_32)& __pow() { return __table<>::__pow10_32; }
+    static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI decltype(__pow10_32)& __pow() { return __itoa::__pow10_32; }
 };
 
 template <typename _Tp>
 struct _LIBCPP_HIDDEN
     __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(uint64_t)>> {
   using type = uint64_t;
 
   /// The width estimation using a log10 algorithm.
   ///
   /// The algorithm is based on
   /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
   /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that
   /// function requires its input to have at least one bit set the value of
   /// zero is set to one. This means the first element of the lookup table is
   /// zero.
-  static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) {
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) {
     auto __t = (64 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12;
-    return __t - (__v < __table<>::__pow10_64[__t]) + 1;
+    return __t - (__v < __itoa::__pow10_64[__t]) + 1;
   }
 
-  static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u64(__p, __v); }
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u64(__p, __v); }
 
-  static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_64)& __pow() { return __table<>::__pow10_64; }
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI decltype(__pow10_64)& __pow() { return __itoa::__pow10_64; }
 };
 
 
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <typename _Tp>
 struct _LIBCPP_HIDDEN
     __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__uint128_t)> > {
   using type = __uint128_t;
 
   /// The width estimation using a log10 algorithm.
   ///
   /// The algorithm is based on
   /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
   /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that
   /// function requires its input to have at least one bit set the value of
   /// zero is set to one. This means the first element of the lookup table is
   /// zero.
-  static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) {
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) {
     _LIBCPP_ASSERT(__v > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fail when this isn't true.");
     // There's always a bit set in the upper 64-bits.
     auto __t = (128 - std::__libcpp_clz(static_cast<uint64_t>(__v >> 64))) * 1233 >> 12;
-    _LIBCPP_ASSERT(__t >= __table<>::__pow10_128_offset, "Index out of bounds");
+    _LIBCPP_ASSERT(__t >= __itoa::__pow10_128_offset, "Index out of bounds");
     // __t is adjusted since the lookup table misses the lower entries.
-    return __t - (__v < __table<>::__pow10_128[__t - __table<>::__pow10_128_offset]) + 1;
+    return __t - (__v < __itoa::__pow10_128[__t - __itoa::__pow10_128_offset]) + 1;
   }
 
-  static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u128(__p, __v); }
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u128(__p, __v); }
 
   // TODO FMT This pow function should get an index.
   // By moving this to its own header it can be reused by the pow function in to_chars_base_10.
-  static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_128)& __pow() { return __table<>::__pow10_128; }
+  static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI decltype(__pow10_128)& __pow() { return __itoa::__pow10_128; }
 };
 #endif
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI bool
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r)
 {
     auto __c = __a * __b;
     __r = __c;
     return __c > numeric_limits<unsigned char>::max();
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI bool
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r)
 {
     auto __c = __a * __b;
     __r = __c;
     return __c > numeric_limits<unsigned short>::max();
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI bool
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(_Tp __a, _Tp __b, _Tp& __r)
 {
     static_assert(is_unsigned<_Tp>::value, "");
     return __builtin_mul_overflow(__a, __b, &__r);
 }
 
 template <typename _Tp, typename _Up>
 inline _LIBCPP_HIDE_FROM_ABI bool
-__mul_overflowed(_Tp __a, _Up __b, _Tp& __r)
+_LIBCPP_CONSTEXPR_SINCE_CXX23 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r)
 {
     return __mul_overflowed(__a, static_cast<_Tp>(__b), __r);
 }
 
 template <typename _Tp>
 struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp>
 {
     static constexpr int digits = numeric_limits<_Tp>::digits10 + 1;
     using __traits_base<_Tp>::__pow;
     using typename __traits_base<_Tp>::type;
 
     // precondition: at least one non-zero character available
-    static _LIBCPP_HIDE_FROM_ABI char const*
+    static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI char const*
     __read(char const* __p, char const* __ep, type& __a, type& __b)
     {
         type __cprod[digits];
         int __j = digits - 1;
         int __i = digits;
         do
         {
             if (!('0' <= *__p && *__p <= '9'))
                 break;
             __cprod[--__i] = *__p++ - '0';
         } while (__p != __ep && __i != 0);
 
         __a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1,
                               __cprod[__i]);
         if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))
             --__p;
         return __p;
     }
 
     template <typename _It1, typename _It2, class _Up>
-    static _LIBCPP_HIDE_FROM_ABI _Up
+    static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _Up
     __inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init)
     {
         for (; __first1 < __last1; ++__first1, ++__first2)
             __init = __init + *__first1 * *__first2;
         return __init;
     }
 };
 
 }  // namespace __itoa
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Tp
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _Tp
 __complement(_Tp __x)
 {
     static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
     return _Tp(~__x + 1);
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
 {
     auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_itoa(__first, __last, __x, false_type());
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
 {
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
     if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
         return {__tx::__convert(__first, __value), errc(0)};
     else
         return {__last, errc::value_too_large};
 }
 
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_itoa(char* __first, char* __last, __uint128_t __value, false_type)
 {
     // When the value fits in 64-bits use the 64-bit code path. This reduces
     // the number of expensive calculations on 128-bit values.
     //
     // NOTE the 128-bit code path requires this optimization.
     if(__value <= numeric_limits<uint64_t>::max())
         return __to_chars_itoa(__first, __last, static_cast<uint64_t>(__value), false_type());
 
     using __tx = __itoa::__traits<__uint128_t>;
     auto __diff = __last - __first;
 
     if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
         return {__tx::__convert(__first, __value), errc(0)};
     else
         return {__last, errc::value_too_large};
 }
 #endif
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     true_type)
 {
     auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
struct _LIBCPP_HIDDEN __integral<2> {
   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
     // If value == 0 still need one digit. If the value != this has no
     // effect since the code scans for the most significant bit set. (Note
     // that __libcpp_clz doesn't work for 0.)
     return numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1);
   }
 
   template <typename _Tp>
-  _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
     ptrdiff_t __cap = __last - __first;
     int __n = __width(__value);
     if (__n > __cap)
       return {__last, errc::value_too_large};
 
     __last = __first + __n;
     char* __p = __last;
     const unsigned __divisor = 16;
     while (__value > __divisor) {
       unsigned __c = __value % __divisor;
       __value /= __divisor;
       __p -= 4;
-      std::memcpy(__p, &__table<>::__base_2_lut[4 * __c], 4);
+      std::copy_n(&__base_2_lut[4 * __c], 4, __p);
     }
     do {
       unsigned __c = __value % 2;
       __value /= 2;
       *--__p = "01"[__c];
     } while (__value != 0);
     return {__last, errc(0)};
   }
 };
 
 template <>
 struct _LIBCPP_HIDDEN __integral<8> {
   template <typename _Tp>
   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
     // If value == 0 still need one digit. If the value != this has no
     // effect since the code scans for the most significat bit set. (Note
     // that __libcpp_clz doesn't work for 0.)
     return ((numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1)) + 2) / 3;
   }
 
   template <typename _Tp>
-  _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
     ptrdiff_t __cap = __last - __first;
     int __n = __width(__value);
     if (__n > __cap)
       return {__last, errc::value_too_large};
 
     __last = __first + __n;
     char* __p = __last;
     unsigned __divisor = 64;
     while (__value > __divisor) {
       unsigned __c = __value % __divisor;
       __value /= __divisor;
       __p -= 2;
-      std::memcpy(__p, &__table<>::__base_8_lut[2 * __c], 2);
+      std::copy_n(&__base_8_lut[2 * __c], 2, __p);
     }
     do {
       unsigned __c = __value % 8;
       __value /= 8;
       *--__p = "01234567"[__c];
     } while (__value != 0);
     return {__last, errc(0)};
   }
 
 };
 
 template <>
 struct _LIBCPP_HIDDEN __integral<16> {
   template <typename _Tp>
   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
     // If value == 0 still need one digit. If the value != this has no
     // effect since the code scans for the most significat bit set. (Note
     // that __libcpp_clz doesn't work for 0.)
     return (numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1) + 3) / 4;
   }
 
   template <typename _Tp>
-  _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
     ptrdiff_t __cap = __last - __first;
     int __n = __width(__value);
     if (__n > __cap)
       return {__last, errc::value_too_large};
 
     __last = __first + __n;
     char* __p = __last;
     unsigned __divisor = 256;
     while (__value > __divisor) {
       unsigned __c = __value % __divisor;
       __value /= __divisor;
       __p -= 2;
-      std::memcpy(__p, &__table<>::__base_16_lut[2 * __c], 2);
+      std::copy_n(&__base_16_lut[2 * __c], 2, __p);
     }
     if (__first != __last)
       do {
         unsigned __c = __value % 16;
         __value /= 16;
         *--__p = "0123456789abcdef"[__c];
       } while (__value != 0);
     return {__last, errc(0)};
   }
 };
 
 } // namespace __itoa
 
 template <unsigned _Base, typename _Tp,
           typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI int
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int
 __to_chars_integral_width(_Tp __value) {
   return __itoa::__integral<_Base>::__width(__value);
 }
 
 template <unsigned _Base, typename _Tp,
           typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI int
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int
 __to_chars_integral_width(_Tp __value) {
   return std::__to_chars_integral_width<_Base>(static_cast<unsigned>(__value));
 }
 
 template <unsigned _Base, typename _Tp,
           typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI to_chars_result
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value) {
   return __itoa::__integral<_Base>::__to_chars(__first, __last, __value);
 }
 
 template <unsigned _Base, typename _Tp,
           typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI to_chars_result
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value) {
   return std::__to_chars_integral<_Base>(__first, __last, static_cast<unsigned>(__value));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI int
+_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int
 __to_chars_integral_width(_Tp __value, unsigned __base) {
   _LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value.");
 
   unsigned __base_2 = __base * __base;
   unsigned __base_3 = __base_2 * __base;
   unsigned __base_4 = __base_2 * __base_2;
 
   int __r = 0;
while (true) {
     __value /= __base_4;
     __r += 4;
   }
 
   __libcpp_unreachable();
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     false_type)
 {
   if (__base == 10) [[likely]]
     return __to_chars_itoa(__first, __last, __value, false_type());
 
   switch (__base) {
   case 2:
do {
     unsigned __c = __value % __base;
     __value /= __base;
     *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
   } while (__value != 0);
   return {__last, errc(0)};
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, _Tp __value)
 {
   using _Type = __make_32_64_or_128_bit_t<_Tp>;
   static_assert(!is_same<_Type, void>::value, "unsupported integral type used in to_chars");
   return std::__to_chars_itoa(__first, __last, static_cast<_Type>(__value), is_signed<_Tp>());
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, _Tp __value, int __base)
 {
   _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
 
   using _Type = __make_32_64_or_128_bit_t<_Tp>;
   return std::__to_chars_integral(__first, __last, static_cast<_Type>(__value), __base, is_signed<_Tp>());
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
 {
     using __tl = numeric_limits<_Tp>;
     decltype(__to_unsigned_like(__value)) __x;
 
     bool __neg = (__first != __last && *__first == '-');
     auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
     switch (__r.ec)
     {
     case errc::invalid_argument:
         return {__first, __r.ec};
     case errc::result_out_of_range:
         return __r;
     default:
         break;
     }
 
     if (__neg)
     {
         if (__x <= __complement(__to_unsigned_like(__tl::min())))
         {
             __x = __complement(__x);
-            std::memcpy(&__value, &__x, sizeof(__x));
+            std::copy_n(std::addressof(__x), 1, std::addressof(__value));
             return __r;
         }
     }
     else
     {
         if (__x <= __to_unsigned_like(__tl::max()))
         {
             __value = __x;
             return __r;
         }
     }
 
     return {__r.ptr, errc::result_out_of_range};
 }
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI bool
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
 __in_pattern(_Tp __c)
 {
     return '0' <= __c && __c <= '9';
 }
 
 struct _LIBCPP_HIDDEN __in_pattern_result
 {
     bool __ok;
     int __val;
 
-    explicit _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; }
+    explicit _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; }
 };
 
 template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI __in_pattern_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI __in_pattern_result
 __in_pattern(_Tp __c, int __base)
 {
     if (__base <= 10)
         return {'0' <= __c && __c < '0' + __base, __c - '0'};
     else if (__in_pattern(__c))
         return {true, __c - '0'};
     else if ('a' <= __c && __c < 'a' + __base - 10)
         return {true, __c - 'a' + 10};
     else
         return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                          _Ts... __args)
 {
     auto __find_non_zero = [](_It __firstit, _It __lastit) {
         for (; __firstit != __lastit; ++__firstit)
             if (*__firstit != '0')
                 break;
         return __firstit;
if (__r.ec == errc::result_out_of_range)
                 break;
         }
     }
 
     return __r;
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
     return __subject_seq_combinator(
         __first, __last, __value,
         [](const char* __f, const char* __l,
return __subject_seq_combinator(
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
+
+/*
+// Code used to generate __from_chars_log2f_lut.
+#include <cmath>
+#include <iostream>
+#include <format>
+
+int main() {
+  for (int i = 2; i <= 36; ++i)
+    std::cout << std::format("{},\n", log2f(i));
+}
+*/
+/// log2f table for bases [2, 36].
+inline constexpr float __from_chars_log2f_lut[35] = {
+    1,         1.5849625, 2,         2.321928, 2.5849626, 2.807355, 3,        3.169925,  3.321928,
+    3.4594316, 3.5849626, 3.7004397, 3.807355, 3.9068906, 4,        4.087463, 4.169925,  4.2479277,
+    4.321928,  4.3923173, 4.4594316, 4.523562, 4.5849624, 4.643856, 4.70044,  4.7548876, 4.807355,
+    4.857981,  4.9068904, 4.9541965, 5,        5.044394,  5.087463, 5.129283, 5.169925};
+
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
         [](const char* __p, const char* __lastp, _Tp& __val,
            int __b) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
-            auto __digits = __tl::digits / log2f(float(__b));
+            // __base is always between 2 and 36 inclusive.
+            auto __digits = __tl::digits / __from_chars_log2f_lut[__b - 2];
             _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
 
             for (int __i = 1; __p != __lastp; ++__i, ++__p)
             {
                 if (auto __c = __in_pattern(*__p, __b))
                 {
                     if (__i < __digits - 1)
                         __x = __x * __b + __c.__val;
return __subject_seq_combinator(
                 }
             }
             return {__p, errc::result_out_of_range};
         },
         __base);
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value,
                              __from_chars_integral<__t>, __base);
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value)
 {
     return __from_chars_atoi(__first, __last, __value);
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
-inline _LIBCPP_HIDE_FROM_ABI from_chars_result
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
     return __from_chars_integral(__first, __last, __value, __base);
 }
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, float __value);
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, double __value);

libcxx/include/version

__cpp_lib_char8_t                                       201907L <atomic> <filesystem> <istream>
                                                                 <string> <string_view>
 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      202002L <concepts>
 __cpp_lib_constexpr_algorithms                          201806L <algorithm>
 __cpp_lib_constexpr_bitset                              202207L <bitset>
+__cpp_lib_constexpr_charconv                            202207L <charconv>
 __cpp_lib_constexpr_cmath                               202202L <cmath> <cstdlib>
 __cpp_lib_constexpr_complex                             201711L <complex>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
 __cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_iterator                            201811L <iterator>
 __cpp_lib_constexpr_memory                              202202L <memory>
                                                         201811L // C++20
 __cpp_lib_constexpr_numeric                             201911L <numeric>

 
 #if _LIBCPP_STD_VER > 20
 # define __cpp_lib_adaptor_iterator_pair_constructor    202106L
 # define __cpp_lib_allocate_at_least                    202106L
 // # define __cpp_lib_associative_heterogeneous_erasure    202110L
 // # define __cpp_lib_bind_back                            202202L
 # define __cpp_lib_byteswap                             202110L
 # define __cpp_lib_constexpr_bitset                     202207L
+# define __cpp_lib_constexpr_charconv                   202207L
 // # define __cpp_lib_constexpr_cmath                      202202L
 # undef  __cpp_lib_constexpr_memory
 # define __cpp_lib_constexpr_memory                     202202L
 // # define __cpp_lib_constexpr_typeinfo                   202106L
 # define __cpp_lib_forward_like                         202207L
 // # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_move_only_function                   202110L

libcxx/src/include/ryu/digit_table.h

 _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.
 //
 // In order to minimize the diff in the Ryu code between MSVC STL and libc++
 // the code uses the name __DIGIT_TABLE. In order to avoid code duplication it
 // reuses the table already available in libc++.
-inline constexpr auto& __DIGIT_TABLE = __itoa::__table<>::__digits_base_10;
+inline constexpr auto& __DIGIT_TABLE = __itoa::__digits_base_10;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H

libcxx/test/std/language.support/support.limits/support.limits.general/charconv.version.compile.pass.cpp

 // and should not be edited manually.
 //
 // clang-format off
 
 // <charconv>
 
 // Test the feature test macros defined by <charconv>
 
-/*  Constant              Value
-    __cpp_lib_to_chars    201611L [C++17]
+/*  Constant                        Value
+    __cpp_lib_constexpr_charconv    202207L [C++2b]
+    __cpp_lib_to_chars              201611L [C++17]
 */
 
 #include <charconv>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 14
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 17
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should be defined in c++17"
 #   endif
 #   if __cpp_lib_to_chars != 201611L
 #     error "__cpp_lib_to_chars should have the value 201611L in c++17"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #elif TEST_STD_VER == 20
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should be defined in c++20"
 #   endif
 #   if __cpp_lib_to_chars != 201611L
 #     error "__cpp_lib_to_chars should have the value 201611L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
+# ifndef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_charconv != 202207L
+#   error "__cpp_lib_constexpr_charconv should have the value 202207L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should be defined in c++2b"
 #   endif
 #   if __cpp_lib_to_chars != 201611L
 #     error "__cpp_lib_to_chars should have the value 201611L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_char8_t                              201907L [C++20]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             202002L [C++20]
     __cpp_lib_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_bitset                     202207L [C++2b]
+    __cpp_lib_constexpr_charconv                   202207L [C++2b]
     __cpp_lib_constexpr_cmath                      202202L [C++2b]
     __cpp_lib_constexpr_complex                    201711L [C++20]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++20]
     __cpp_lib_constexpr_functional                 201907L [C++20]
     __cpp_lib_constexpr_iterator                   201811L [C++20]
     __cpp_lib_constexpr_memory                     201811L [C++20]
                                                    202202L [C++2b]
     __cpp_lib_constexpr_numeric                    201911L [C++20]

 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_constexpr_cmath
 #   error "__cpp_lib_constexpr_cmath should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_constexpr_complex
 #   error "__cpp_lib_constexpr_complex should not be defined before c++20"
 # endif
 

 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_constexpr_cmath
 #   error "__cpp_lib_constexpr_cmath should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_constexpr_complex
 #   error "__cpp_lib_constexpr_complex should not be defined before c++20"
 # endif
 

 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_constexpr_cmath
 #   error "__cpp_lib_constexpr_cmath should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_constexpr_complex
 #   error "__cpp_lib_constexpr_complex should not be defined before c++20"
 # endif
 

 # if __cpp_lib_constexpr_algorithms != 201806L
 #   error "__cpp_lib_constexpr_algorithms should have the value 201806L in c++20"
 # endif
 
 # ifdef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_constexpr_cmath
 #   error "__cpp_lib_constexpr_cmath should not be defined before c++2b"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_complex
 #     error "__cpp_lib_constexpr_complex should be defined in c++20"
 #   endif

 
 # ifndef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_bitset != 202207L
 #   error "__cpp_lib_constexpr_bitset should have the value 202207L in c++2b"
 # endif
 
+# ifndef __cpp_lib_constexpr_charconv
+#   error "__cpp_lib_constexpr_charconv should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_charconv != 202207L
+#   error "__cpp_lib_constexpr_charconv should have the value 202207L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_cmath
 #     error "__cpp_lib_constexpr_cmath should be defined in c++2b"
 #   endif
 #   if __cpp_lib_constexpr_cmath != 202202L
 #     error "__cpp_lib_constexpr_cmath should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
-// from_chars_result from_chars(const char* first, const char* last,
-//                              Integral& value, int base = 10)
+// constexpr from_chars_result from_chars(const char* first, const char* last,
+//                                        Integral& value, int base = 10)
 
 #include <charconv>
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 template <typename T>
 struct test_basics
 {
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         std::from_chars_result r;
         T x;
 
         {
             char s[] = "001x";
 
             // the expected form of the subject sequence is a sequence of
TEST_CONSTEXPR_CXX23 void operator()()
             assert(r.ptr == s + 5);
         }
     }
 };
 
 template <typename T>
 struct test_signed
 {
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         std::from_chars_result r;
         T x = 42;
 
         {
             // If the pattern allows for an optional sign,
             // but the string has no digit characters following the sign,
             char s[] = "- 9+12";
TEST_CONSTEXPR_CXX23 void operator()()
             // the member ptr of the return value is first and
             assert(r.ptr == s);
             // the member ec is equal to errc::invalid_argument.
             assert(r.ec == std::errc::invalid_argument);
         }
     }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX23 bool test()
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 20
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.roundtrip.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=12712420
+
 // <charconv>
 
-// from_chars_result from_chars(const char* first, const char* last,
-//                              Integral& value, int base = 10)
+// constexpr from_chars_result from_chars(const char* first, const char* last,
+//                                        Integral& value, int base = 10)
 
 #include <charconv>
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 template <typename T>
 struct test_basics : roundtrip_test_base<T>
 {
     using roundtrip_test_base<T>::test;
 
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         test(0);
         test(42);
         test(32768);
         test(0, 10);
         test(42, 10);
         test(32768, 10);
         test(0xf, 16);
struct test_basics : roundtrip_test_base<T>
     }
 };
 
 template <typename T>
 struct test_signed : roundtrip_test_base<T>
 {
     using roundtrip_test_base<T>::test;
 
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         test(-1);
         test(-12);
         test(-1, 10);
         test(-12, 10);
         test(-21734634, 10);
         test(-2647, 2);
         test(-0xcc1, 16);
 
         for (int b = 2; b < 37; ++b)
         {
             using xl = std::numeric_limits<T>;
 
             test(0, b);
             test(xl::lowest(), b);
             test((xl::max)(), b);
         }
     }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX23 bool test()
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 20
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=12712420
-// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=12712420
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=50000000
 
 // <charconv>
 
-// to_chars_result to_chars(char* first, char* last, Integral value,
-//                          int base = 10)
+// constexpr to_chars_result to_chars(char* first, char* last, Integral value,
+//                                    int base = 10)
 
 #include <charconv>
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 #ifndef TEST_HAS_NO_INT128
-__uint128_t make_u128(__uint128_t a, uint64_t b) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b) {
   a *= 1000000000000000000UL;
   a *= 10;
   return a + b;
 }
 
-__uint128_t make_u128(__uint128_t a, uint64_t b, uint64_t c) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b, uint64_t c) {
   a *= 10000000000000ULL;
   a += b;
   a *= 10000000000000ULL;
   return a + c;
 }
 
-__int128_t make_i128(__int128_t a, int64_t b) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, int64_t b) {
   if (a < 0)
     return -make_u128(-a, b);
   return make_u128(a, b);
 }
 
-__int128_t make_i128(__int128_t a, __int128_t b, int64_t c) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, __int128_t b, int64_t c) {
   if (a < 0)
     return -make_u128(-a, b, c);
   return make_u128(a, b, c);
 }
 #endif
 
 template <typename T>
 struct test_basics : to_chars_test_base<T>
 {
     using to_chars_test_base<T>::test;
     using to_chars_test_base<T>::test_value;
 
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         test(0, "0");
         test(42, "42");
         test(32768, "32768");
         test(0, "0", 10);
         test(42, "42", 10);
         test(32768, "32768", 10);
         test(0xf, "f", 16);

 };
 
 template <typename T>
 struct test_signed : to_chars_test_base<T>
 {
     using to_chars_test_base<T>::test;
     using to_chars_test_base<T>::test_value;
 
-    void operator()()
+    TEST_CONSTEXPR_CXX23 void operator()()
     {
         test(-1, "-1");
         test(-12, "-12");
         test(-1, "-1", 10);
         test(-12, "-12", 10);
         test(-21734634, "-21734634", 10);
         test(-2647, "-101001010111", 2);
         test(-0xcc1, "-cc1", 16);
#endif
 
             test_value(0, b);
             test_value(xl::lowest(), b);
             test_value((xl::max)(), b);
         }
     }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX23 bool test()
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
 
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER > 20
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/support/charconv_test_helpers.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_CHARCONV_TEST_HELPERS_H
 #define SUPPORT_CHARCONV_TEST_HELPERS_H
 
+#include <algorithm>
 #include <charconv>
 #include <cassert>
 #include <limits>
 #include <numeric>
 #include <string.h>
 #include <stdlib.h>
 
 #include "test_macros.h"

 {
   return _fits_in<X>(v, is_non_narrowing<X>(v), std::is_signed<T>(), std::is_signed<X>());
 }
 
 template <typename X>
 struct to_chars_test_base
 {
     template <typename T, size_t N, typename... Ts>
-    void test(T v, char const (&expect)[N], Ts... args)
+    TEST_CONSTEXPR_CXX23 void test(T v, char const (&expect)[N], Ts... args)
     {
-        using std::to_chars;
         std::to_chars_result r;
 
         constexpr size_t len = N - 1;
         static_assert(len > 0, "expected output won't be empty");
 
         if (!fits_in<X>(v))
             return;
 
-        r = to_chars(buf, buf + len - 1, X(v), args...);
+        r = std::to_chars(buf, buf + len - 1, X(v), args...);
         assert(r.ptr == buf + len - 1);
         assert(r.ec == std::errc::value_too_large);
 
-        r = to_chars(buf, buf + sizeof(buf), X(v), args...);
+        r = std::to_chars(buf, buf + sizeof(buf), X(v), args...);
         assert(r.ptr == buf + len);
         assert(r.ec == std::errc{});
-        assert(memcmp(buf, expect, len) == 0);
+        assert(std::equal(buf, buf + len, expect));
     }
 
     template <typename... Ts>
-    void test_value(X v, Ts... args)
+    TEST_CONSTEXPR_CXX23 void test_value(X v, Ts... args)
     {
-        using std::to_chars;
         std::to_chars_result r;
 
         // Poison the buffer for testing whether a successful std::to_chars
-        // doesn't modify data beyond r.ptr.
-        std::iota(buf, buf + sizeof(buf), char(1));
-        r = to_chars(buf, buf + sizeof(buf), v, args...);
+        // doesn't modify data beyond r.ptr. Use unsigned values to avoid
+        // overflowing char when it's signed.
+        std::iota(buf, buf + sizeof(buf), static_cast<unsigned char>(1));
+        r = std::to_chars(buf, buf + sizeof(buf), v, args...);
         assert(r.ec == std::errc{});
         for (size_t i = r.ptr - buf; i < sizeof(buf); ++i)
-            assert(buf[i] == static_cast<char>(i + 1));
+            assert(static_cast<unsigned char>(buf[i]) == i + 1);
         *r.ptr = '\0';
 
 #ifndef TEST_HAS_NO_INT128
         if (sizeof(X) == sizeof(__int128_t)) {
             auto a = fromchars128_impl(buf, r.ptr, args...);
             assert(v == a);
         } else
 #endif
         {
             auto a = fromchars_impl(buf, r.ptr, args...);
             assert(v == a);
         }
 
         auto ep = r.ptr - 1;
-        r = to_chars(buf, ep, v, args...);
+        r = std::to_chars(buf, ep, v, args...);
         assert(r.ptr == ep);
         assert(r.ec == std::errc::value_too_large);
     }
 
 private:
-    static long long fromchars_impl(char const* p, char const* ep, int base, true_type)
+    static TEST_CONSTEXPR_CXX23 long long fromchars_impl(char const* p, char const* ep, int base, true_type)
     {
         char* last;
-        auto r = strtoll(p, &last, base);
+        long long r;
+        if (TEST_IS_CONSTANT_EVALUATED)
+          last = const_cast<char*>(std::from_chars(p, ep, r, base).ptr);
+        else
+          r = strtoll(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 
-    static unsigned long long fromchars_impl(char const* p, char const* ep, int base, false_type)
+    static TEST_CONSTEXPR_CXX23 unsigned long long fromchars_impl(char const* p, char const* ep, int base, false_type)
     {
         char* last;
-        auto r = strtoull(p, &last, base);
+        unsigned long long r;
+        if (TEST_IS_CONSTANT_EVALUATED)
+          last = const_cast<char*>(std::from_chars(p, ep, r, base).ptr);
+        else
+          r = strtoull(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 #ifndef TEST_HAS_NO_INT128
-    static __int128_t fromchars128_impl(char const* p, char const* ep, int base, true_type)
+    static TEST_CONSTEXPR_CXX23 __int128_t fromchars128_impl(char const* p, char const* ep, int base, true_type)
     {
+        if (!TEST_IS_CONSTANT_EVALUATED) {
             char* last;
             __int128_t r = strtoll(p, &last, base);
             if(errno != ERANGE) {
                 assert(last == ep);
                 return r;
             }
+        }
 
         // When the value doesn't fit in a long long use from_chars. This is
         // not ideal since it does a round-trip test instead if using an
         // external source.
+        __int128_t r;
         std::from_chars_result s = std::from_chars(p, ep, r, base);
         assert(s.ec == std::errc{});
         assert(s.ptr == ep);
 
         return r;
     }
 
-    static __uint128_t fromchars128_impl(char const* p, char const* ep, int base, false_type)
+    static TEST_CONSTEXPR_CXX23 __uint128_t fromchars128_impl(char const* p, char const* ep, int base, false_type)
     {
+        if (!TEST_IS_CONSTANT_EVALUATED) {
             char* last;
             __uint128_t r = strtoull(p, &last, base);
             if(errno != ERANGE) {
                 assert(last == ep);
                 return r;
             }
+        }
 
+        __uint128_t r;
         std::from_chars_result s = std::from_chars(p, ep, r, base);
         assert(s.ec == std::errc{});
         assert(s.ptr == ep);
 
         return r;
     }
 
-    static auto fromchars128_impl(char const* p, char const* ep, int base = 10)
+    static TEST_CONSTEXPR_CXX23 auto fromchars128_impl(char const* p, char const* ep, int base = 10)
     -> decltype(fromchars128_impl(p, ep, base, std::is_signed<X>()))
     {
         return fromchars128_impl(p, ep, base, std::is_signed<X>());
     }
 
 #endif
 
-    static auto fromchars_impl(char const* p, char const* ep, int base = 10)
+    static TEST_CONSTEXPR_CXX23 auto fromchars_impl(char const* p, char const* ep, int base = 10)
     -> decltype(fromchars_impl(p, ep, base, std::is_signed<X>()))
     {
         return fromchars_impl(p, ep, base, std::is_signed<X>());
     }
 
     char buf[150];
 };
 
 template <typename X>
 struct roundtrip_test_base
 {
     template <typename T, typename... Ts>
-    void test(T v, Ts... args)
+    TEST_CONSTEXPR_CXX23 void test(T v, Ts... args)
     {
-        using std::from_chars;
-        using std::to_chars;
         std::from_chars_result r2;
         std::to_chars_result r;
         X x = 0xc;
 
         if (fits_in<X>(v))
         {
-            r = to_chars(buf, buf + sizeof(buf), v, args...);
+            r = std::to_chars(buf, buf + sizeof(buf), v, args...);
             assert(r.ec == std::errc{});
 
-            r2 = from_chars(buf, r.ptr, x, args...);
+            r2 = std::from_chars(buf, r.ptr, x, args...);
             assert(r2.ptr == r.ptr);
             assert(x == X(v));
         }
         else
         {
-            r = to_chars(buf, buf + sizeof(buf), v, args...);
+            r = std::to_chars(buf, buf + sizeof(buf), v, args...);
             assert(r.ec == std::errc{});
 
-            r2 = from_chars(buf, r.ptr, x, args...);
+            r2 = std::from_chars(buf, r.ptr, x, args...);
 
             TEST_DIAGNOSTIC_PUSH
             TEST_MSVC_DIAGNOSTIC_IGNORED(4127) // conditional expression is constant
 
             if (std::is_signed<T>::value && v < 0 && std::is_unsigned<X>::value)
             {
                 assert(x == 0xc);
                 assert(r2.ptr == buf);

 #ifndef TEST_HAS_NO_INT128
     ,
     __uint128_t
 #endif
     >();
 auto integrals = concat(all_signed, all_unsigned);
 
 template <template <typename> class Fn, typename... Ts>
-void
+TEST_CONSTEXPR_CXX23 void
 run(type_list<Ts...>)
 {
     int ls[sizeof...(Ts)] = {(Fn<Ts>{}(), 0)...};
     (void)ls;
 }
 
 #endif // SUPPORT_CHARCONV_TEST_HELPERS_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_constexpr_algorithms",
     "values": { "c++20": 201806 },
     "headers": ["algorithm"],
   }, {
     "name": "__cpp_lib_constexpr_bitset",
     "values": { "c++2b": 202207 },
     "headers": ["bitset"],
   }, {
+    "name": "__cpp_lib_constexpr_charconv",
+    "values": { "c++2b": 202207 },
+    "headers": ["charconv"],
+  }, {
     "name": "__cpp_lib_constexpr_cmath",
     "values": { "c++2b": 202202 },
     "headers": ["cmath", "cstdlib"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_complex",
     "values": { "c++20": 201711 },
     "headers": ["complex"],