[libc++] Reduces std::to_chars instantiations.

[Mordante]

Summary

Instead of instantiating all functions called by std::to_chars for the
integral types only instantiate them for 32 and 64 bit integral types.
This results in a smaller binary when using different types.

In an example using the types: signed char, short, int, long, long long,
unsigned char, unsigned short, unsigned int, unsigned long, and
unsigned long long this saved 2792 bytes of code size. For libc++.so.1
is saves 688 bytes of code size (64-bit Linux).

This was discovered while investigating a solution for #52709.

[Mordante]

libcxx/include/type_traits

1025

Note I'm not fond of this name, so I'm open to suggestions for a better name.

[philnik]

Is there a reason to not just instantiate it for that largest integral type? Or size_t and the largest integral type to avoid using multiple registers for smaller types?

libcxx/include/charconv

492

502

Why _Uglify it? You can just use type. Otherwise I would use _Type to make it clear that it's a type.

504

libcxx/include/type_traits

1024–1045

Could you put this into it's own header?

1025

Maybe __extend_to_32_64_or_128_bit_t? It's also not exactly perfect, but I think it describes it a bit better.

[Mordante]

In D128215#3596983, @philnik wrote:

Is there a reason to not just instantiate it for that largest integral type? Or size_t and the largest integral type to avoid using multiple registers for smaller types?

Yes we still support 32-bit platforms, using a 64-bit value there would give a performance penalty, especially on platforms with a small number or registers. Another reason why I prefer 32-bits is that I'm quite sure that division of a 32-bit value by a constant is more efficient than the division of a 64-bit value. (The compiler will transform it in a multiplication and a shift which IIRC always fits in a 64-bit register, when using a 32-bit value.) This is what we're doing for base 10.

libcxx/include/type_traits

1024–1045

Yes I think that makes sense, but I first want to settle on a good name.

[philnik]

Yes we still support 32-bit platforms, using a 64-bit value there would give a performance penalty, especially on platforms with a small number or registers.

Isn't size_t 32 bits wide on 32-bit platforms?

Another reason why I prefer 32-bits is that I'm quite sure that division of a 32-bit value by a constant is more efficient than the division of a 64-bit value. (The compiler will transform it in a multiplication and a shift which IIRC always fits in a 64-bit register, when using a 32-bit value.) This is what we're doing for base 10.

Could you do a benchmark to check if using a 32-bit wide instantiation yields better performance even on 64-bit platforms?

[ldionne]

libcxx/include/charconv

491

I think you need parentheses here.

502

While it's true that type is technically not a name that users can macro-ize (otherwise the world would break), it's still good to uglify our internal names for consistency. I don't care strongly about __type or _Type, but I do have a small preference for _Type. What I care strongly about is that we do uglify the name.

The only places were we use type should be where the Standard mandates that we have such a user-facing name in our API (in the type traits). I know in practice we sometimes use it for internal-only things because it's convenient, though.

libcxx/include/type_traits

1024

I would suggest this instead (the reformatting would make it easier to read IMO):

template <bool _Cond, class _If, class _Else>
using __conditional_t = typename conditional<_Cond, _If, _Else>::type;

template <class _Tp>
using __make_32_64_or_128_bit_t = __copy_unsigned_t<_Tp,
  __conditional_t<sizeof(_Tp) <= sizeof(int32_t),   int32_t,
  __conditional_t<sizeof(_Tp) <= sizeof(int64_t),   int64_t,
  __conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t,
  /* else */                                         void
  >>>
>;

Here, __copy_unsigned_t would be basically

template <class _Tp, class _Up>
using __copy_unsigned_t = typename conditional<is_unsigned<_Tp>::value, make_unsigned_t<_Up>, _Up>;

1025

Just throwing another suggestion out there, but perhaps something like __widen_up_to_128_t would be reasonable?

[Mordante]

libcxx/include/charconv

491

For simplicity I just split it into two asserts, that makes removing 128-bit one easier.

libcxx/include/type_traits

1024–1045

After the rewrite to the suggestion above that's no longer an option; it uses make_unsigned. Do you have patches in progress to move that? If not I can make a followup patch to move make_unsigned and this new helper.

[Mordante]

Rebased and adresses review comments.

[philnik]

libcxx/include/type_traits

1024–1045

I don't have a patch for that currently. You can just leave the new trait here and I'll move it once I get around to granularizing <type_traits> further.

[Mordante]

tab -> space

[Mordante]

Fixes C++03.

[Mordante]

In D128215#3597096, @philnik wrote:

Yes we still support 32-bit platforms, using a 64-bit value there would give a performance penalty, especially on platforms with a small number or registers.

Isn't size_t 32 bits wide on 32-bit platforms?

Another reason why I prefer 32-bits is that I'm quite sure that division of a 32-bit value by a constant is more efficient than the division of a 64-bit value. (The compiler will transform it in a multiplication and a shift which IIRC always fits in a 64-bit register, when using a 32-bit value.) This is what we're doing for base 10.

Could you do a benchmark to check if using a 32-bit wide instantiation yields better performance even on 64-bit platforms?

Actually I was wrong, for base 10 64-bit it's about as efficient. I test whether a 64-bit value fits in a 32-bit value and directly dispatch to a 32-bit value. So I guess that's why there's no penalty. But for the other bases there's a penalty. Several bases that were 25 ns before now are 30 ns. I haven't measured on 32-bit systems, but there I expect the penalty to be worse. So I will keep the 32 and 64 bit paths separated.

[Mordante]

Final polishing, when the CI passes I'll land this version.

[Mordante]

libcxx/include/type_traits

1025

Based on the suggestions I keep the original name, but thanks for them!

libcxx/include/__type_traits/conditional.h

template <bool _Bp, class _If, class _Then>
     struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
 template <class _If, class _Then>
     struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
 #endif
 
+// Helper so we can use "conditional_t" in all language versions.
+template <bool _Bp, class _If, class _Then> using __conditional_t = typename conditional<_Bp, _If, _Then>::type;
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H

libcxx/include/charconv

__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
   } 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
 to_chars(char* __first, char* __last, _Tp __value)
 {
-    return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());
+  using _Type = __make_32_64_or_128_bit_t<_Tp>;
+  static_assert(!is_same<_Type, void>::value, "unsupported integral type used in to_chars");
+  static_assert(sizeof(_Tp) <= sizeof(int64_t), "128-bit integral support isn't available yet 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
 to_chars(char* __first, char* __last, _Tp __value, int __base)
 {
-    _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
-    return __to_chars_integral(__first, __last, __value, __base,
-                               is_signed<_Tp>());
+
+  using _Type = __make_32_64_or_128_bit_t<_Tp>;
+  static_assert(sizeof(_Tp) <= sizeof(int64_t), "128-bit integral support isn't available yet in to_chars");
+  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
 __sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
 {
     using __tl = numeric_limits<_Tp>;
     decltype(__to_unsigned_like(__value)) __x;

libcxx/include/type_traits

 #include <__type_traits/remove_pointer.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/remove_volatile.h>
 #include <__type_traits/type_identity.h>
 #include <__type_traits/underlying_type.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <cstddef>
+#include <cstdint>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr
 typename make_unsigned<_Tp>::type __to_unsigned_like(_Tp __x) noexcept {
     return static_cast<typename make_unsigned<_Tp>::type>(__x);
 }
 #endif
 
+template <class _Tp, class _Up>
+using __copy_unsigned_t = __conditional_t<is_unsigned<_Tp>::value, typename make_unsigned<_Up>::type, _Up>;
+
+/// Helper to promote an integral to smallest 32, 64, or 128 bit representation.
+///
+/// The restriction is the same as the integral version of to_char.
+template <class _Tp>
+#if _LIBCPP_STD_VER > 17
+  requires (is_signed_v<_Tp> || is_unsigned_v<_Tp> || is_same_v<_Tp, char>)
+#endif
+using __make_32_64_or_128_bit_t =
+  __copy_unsigned_t<_Tp,
+    __conditional_t<sizeof(_Tp) <= sizeof(int32_t),    int32_t,
+    __conditional_t<sizeof(_Tp) <= sizeof(int64_t),    int64_t,
+#ifndef _LIBCPP_HAS_NO_INT128
+    __conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t,
+    /* else */                                         void>
+#else
+    /* else */                                         void
+#endif
+    > >
+  >;
+
 #if _LIBCPP_STD_VER > 17
 // Let COND_RES(X, Y) be:
 template <class _Tp, class _Up>
 using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>());
 
 template <class _Tp, class _Up, class = void>
 struct __common_type3 {};