[libc++] Mark __u64toa and __u32toa as noexcept

[ldionne]

Summary

The two functions don't throw, and the generated code is better when
we explicitly tell the compiler that the functions are noexcept. This
isn't an ABI break because the signatures of the functions stay the
same with or without noexcept.

https://llvm.org/PR46016

[mclow.lists]

This is not sufficient; it just "moves the pain" from the callers code into the dylib. All the functions in charconv.cpp need to be marked as noexcept.

[ldionne]

Mark all functions in charconv.cpp as noexcept

[ldionne]

In D80379#2049116, @mclow.lists wrote:

This is not sufficient; it just "moves the pain" from the callers code into the dylib. All the functions in charconv.cpp need to be marked as noexcept.

Excellent point.

[mclow.lists]

LGTM. Feel free to ignore the clang-format whining.

libcxx/include/charconv

 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __itoa {
-_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer);
-_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer);
+_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 enum class _LIBCPP_ENUM_VIS chars_format
 {
     scientific = 0x1,
     fixed = 0x2,

libcxx/src/charconv.cpp

static constexpr char cDigitsLut[200] = {
     '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'};
 
 template <typename T>
 inline _LIBCPP_INLINE_VISIBILITY char*
-append1(char* buffer, T i)
+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)
+append2(char* buffer, T i) noexcept
 {
     memcpy(buffer, &cDigitsLut[(i)*2], 2);
     return buffer + 2;
 }
 
 template <typename T>
 inline _LIBCPP_INLINE_VISIBILITY char*
-append3(char* buffer, T i)
+append3(char* buffer, T i) noexcept
 {
     return append2(append1(buffer, (i) / 100), (i) % 100);
 }
 
 template <typename T>
 inline _LIBCPP_INLINE_VISIBILITY char*
-append4(char* buffer, T i)
+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)
+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)
+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)
+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;
 }
 
 char*
-__u32toa(uint32_t value, char* buffer)
+__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;
 }
 
 char*
-__u64toa(uint64_t value, char* buffer)
+__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)
     {