This is an archive of the discontinued LLVM Phabricator instance.

Differential D80379

[libc++] Mark __u64toa and __u32toa as noexcept
ClosedPublic

Authored by ldionne on May 21 2020, 7:32 AM.

Details

Reviewers
mclow.lists
Group Reviewers
Restricted Project
Commits
rG485b9083fe69: [libc++] Mark __u64toa and __u32toa as noexcept
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

Diff Detail

Event Timeline

ldionne created this revision.May 21 2020, 7:32 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 21 2020, 7:32 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libcxx-commits, dexonsmith, jkorous. · View Herald Transcript
ldionne added a reviewer: mclow.lists.May 21 2020, 7:32 AM
mclow.lists requested changes to this revision.May 21 2020, 7:50 AM

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.

This revision now requires changes to proceed.May 21 2020, 7:50 AM
ldionne updated this revision to Diff 265516.May 21 2020, 9:08 AM

Mark all functions in charconv.cpp as noexcept

ldionne added a comment.May 21 2020, 9:08 AM
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.

Harbormaster failed remote builds in B57527: Diff 265505!May 21 2020, 9:09 AM
Harbormaster failed remote builds in B57532: Diff 265516!May 21 2020, 10:15 AM
mclow.lists accepted this revision.May 21 2020, 4:15 PM

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

This revision is now accepted and ready to land.May 21 2020, 4:15 PM
Closed by commit rG485b9083fe69: [libc++] Mark __u64toa and __u32toa as noexcept (authored by ldionne). · Explain WhyMay 22 2020, 1:25 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
libcxx/
include/
4 lines
src/
18 lines

Diff 265797

libcxx/include/charconv

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __itoa { namespace __itoa {
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_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); _LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
enum class _LIBCPP_ENUM_VIS chars_format enum class _LIBCPP_ENUM_VIS chars_format
{ {
scientific = 0x1, scientific = 0x1,
fixed = 0x2, fixed = 0x2,
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

libcxx/src/charconv.cpp

Show All 26 Linesstatic constexpr char cDigitsLut[200] = {
'7', '6', '8', '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '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', '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', '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', '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9',
'7', '9', '8', '9', '9'}; '7', '9', '8', '9', '9'};
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append1(char* buffer, T i) append1(char* buffer, T i) noexcept
{ {
*buffer = '0' + static_cast<char>(i); *buffer = '0' + static_cast<char>(i);
return buffer + 1; return buffer + 1;
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append2(char* buffer, T i) append2(char* buffer, T i) noexcept
{ {
memcpy(buffer, &cDigitsLut[(i)*2], 2); memcpy(buffer, &cDigitsLut[(i)*2], 2);
return buffer + 2; return buffer + 2;
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append3(char* buffer, T i) append3(char* buffer, T i) noexcept
{ {
return append2(append1(buffer, (i) / 100), (i) % 100); return append2(append1(buffer, (i) / 100), (i) % 100);
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append4(char* buffer, T i) append4(char* buffer, T i) noexcept
{ {
return append2(append2(buffer, (i) / 100), (i) % 100); return append2(append2(buffer, (i) / 100), (i) % 100);
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append2_no_zeros(char* buffer, T v) append2_no_zeros(char* buffer, T v) noexcept
{ {
if (v < 10) if (v < 10)
return append1(buffer, v); return append1(buffer, v);
else else
return append2(buffer, v); return append2(buffer, v);
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append4_no_zeros(char* buffer, T v) append4_no_zeros(char* buffer, T v) noexcept
{ {
if (v < 100) if (v < 100)
return append2_no_zeros(buffer, v); return append2_no_zeros(buffer, v);
else if (v < 1000) else if (v < 1000)
return append3(buffer, v); return append3(buffer, v);
else else
return append4(buffer, v); return append4(buffer, v);
} }
template <typename T> template <typename T>
inline _LIBCPP_INLINE_VISIBILITY char* inline _LIBCPP_INLINE_VISIBILITY char*
append8_no_zeros(char* buffer, T v) append8_no_zeros(char* buffer, T v) noexcept
{ {
if (v < 10000) if (v < 10000)
{ {
buffer = append4_no_zeros(buffer, v); buffer = append4_no_zeros(buffer, v);
} }
else else
{ {
buffer = append4_no_zeros(buffer, v / 10000); buffer = append4_no_zeros(buffer, v / 10000);
buffer = append4(buffer, v % 10000); buffer = append4(buffer, v % 10000);
} }
return buffer; return buffer;
} }
char* char*
__u32toa(uint32_t value, char* buffer) __u32toa(uint32_t value, char* buffer) _NOEXCEPT
{ {
if (value < 100000000) if (value < 100000000)
{ {
buffer = append8_no_zeros(buffer, value); buffer = append8_no_zeros(buffer, value);
} }
else else
{ {
// value = aabbbbcccc in decimal // value = aabbbbcccc in decimal
const uint32_t a = value / 100000000; // 1 to 42 const uint32_t a = value / 100000000; // 1 to 42
value %= 100000000; value %= 100000000;
buffer = append2_no_zeros(buffer, a); buffer = append2_no_zeros(buffer, a);
buffer = append4(buffer, value / 10000); buffer = append4(buffer, value / 10000);
buffer = append4(buffer, value % 10000); buffer = append4(buffer, value % 10000);
} }
return buffer; return buffer;
} }
char* char*
__u64toa(uint64_t value, char* buffer) __u64toa(uint64_t value, char* buffer) _NOEXCEPT
{ {
if (value < 100000000) if (value < 100000000)
{ {
uint32_t v = static_cast<uint32_t>(value); uint32_t v = static_cast<uint32_t>(value);
buffer = append8_no_zeros(buffer, v); buffer = append8_no_zeros(buffer, v);
} }
else if (value < 10000000000000000) else if (value < 10000000000000000)
{ {
Show All 29 Lines