From e24b430f1ea60205162fd9b327ac6a4dfc57f37c Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Fri, 14 Oct 2022 14:25:48 +0100 Subject: libstdc++: Fix uses_allocator_construction args for cv pair (LWG 3677) The _Std_pair concept uses in handles const qualified pairs, but not volatile qualified. That's because it just uses __is_pair which is specialized for const pairs. This removes the partial specialization __is_pair>, so that __is_pair is now only true for cv-unqualified pairs. Then _Std_pair needs to explicitly use remove_cv_t for the argument to __is_pair. The other use of __is_pair is in map::insert(Pair&&) which doesn't want to handle volatile so should just use remove_const_t. libstdc++-v3/ChangeLog: * include/bits/stl_map.h (map::insert(Pair&&)): Use remove_const_t on argument to __is_pair. * include/bits/stl_pair.h (__is_pair>): Remove partial specialization. * include/bits/uses_allocator_args.h (_Std_pair): Use remove_cv_t as per LWG 3677. * testsuite/20_util/uses_allocator/lwg3677.cc: New test. --- libstdc++-v3/include/bits/stl_map.h | 2 +- libstdc++-v3/include/bits/stl_pair.h | 3 -- libstdc++-v3/include/bits/uses_allocator_args.h | 2 +- .../testsuite/20_util/uses_allocator/lwg3677.cc | 52 ++++++++++++++++++++++ 4 files changed, 54 insertions(+), 5 deletions(-) create mode 100644 libstdc++-v3/testsuite/20_util/uses_allocator/lwg3677.cc (limited to 'libstdc++-v3') diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h index 9c2b074..83c579a 100644 --- a/libstdc++-v3/include/bits/stl_map.h +++ b/libstdc++-v3/include/bits/stl_map.h @@ -847,7 +847,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER { #if __cplusplus >= 201703L using _P2 = remove_reference_t<_Pair>; - if constexpr (__is_pair<_P2>) + if constexpr (__is_pair>) if constexpr (is_same_v>) if constexpr (__usable_key) { diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h index d0f07b0..1951670 100644 --- a/libstdc++-v3/include/bits/stl_pair.h +++ b/libstdc++-v3/include/bits/stl_pair.h @@ -889,9 +889,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline constexpr bool __is_pair> = true; - - template - inline constexpr bool __is_pair> = true; #endif /// @cond undocumented diff --git a/libstdc++-v3/include/bits/uses_allocator_args.h b/libstdc++-v3/include/bits/uses_allocator_args.h index ef5c4ff..77e4860 100644 --- a/libstdc++-v3/include/bits/uses_allocator_args.h +++ b/libstdc++-v3/include/bits/uses_allocator_args.h @@ -44,7 +44,7 @@ namespace std _GLIBCXX_VISIBILITY(default) _GLIBCXX_BEGIN_NAMESPACE_VERSION template - concept _Std_pair = __is_pair<_Tp>; + concept _Std_pair = __is_pair>; /** @addtogroup allocators * @{ diff --git a/libstdc++-v3/testsuite/20_util/uses_allocator/lwg3677.cc b/libstdc++-v3/testsuite/20_util/uses_allocator/lwg3677.cc new file mode 100644 index 0000000..649b98d --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/uses_allocator/lwg3677.cc @@ -0,0 +1,52 @@ +// { dg-options "-std=gnu++23" } +// { dg-do run { target c++20 } } + +#include +#include + +struct UsesAlloc +{ + using allocator_type = std::allocator; + + bool passed_alloc; + + UsesAlloc(int) : passed_alloc(false) { } + + UsesAlloc(int, std::allocator) : passed_alloc(true) { } +}; + +using Pair = std::pair; + +void +test_const() +{ + std::allocator a; + int i = 0; + auto p = std::make_obj_using_allocator(a, i, i); + VERIFY( p.first.passed_alloc ); +} + +void +test_volatile() +{ + std::allocator a; + int i = 0; + auto p = std::make_obj_using_allocator(a, i, i); + VERIFY( p.first.passed_alloc ); +} + +void +test_const_volatile() +{ + std::allocator a; + int i = 0; + auto p = std::make_obj_using_allocator(a, i, i); + VERIFY( p.first.passed_alloc ); +} + +int main() +{ + test_const(); + test_volatile(); + test_const_volatile(); +} -- cgit v1.1 From 378a0f1840e6944d05ed1e374e514abe9564e91a Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Sat, 15 Oct 2022 21:20:47 +0100 Subject: libstdc++: Implement constexpr std::to_chars for C++23 (P2291R3) Some of the helper functions use static constexpr local variables, which is not permitted in a core constant expression. Removing the 'static' seems to have negligible performance effect for __to_chars and __to_chars_16. For __from_chars_alnum_to_val removing the 'static' causes a significant performance impact for base 36 conversions. Use a consteval lambda instead. libstdc++-v3/ChangeLog: * include/bits/charconv.h (__to_chars_10_impl): Add constexpr for C++23. Remove 'static' from array. * include/std/charconv (__cpp_lib_constexpr_charconv): Define. (__to_chars, __to_chars_16): Remove 'static' from array, add constexpr. (__to_chars_10, __to_chars_8, __to_chars_2, __to_chars_i) (to_chars, __raise_and_add, __from_chars_pow2_base) (__from_chars_alnum, from_chars): Add constexpr. (__from_chars_alnum_to_val): Avoid local static during constant evaluation. Add constexpr. * include/std/version (__cpp_lib_constexpr_charconv): Define. * testsuite/20_util/from_chars/constexpr.cc: New test. * testsuite/20_util/to_chars/constexpr.cc: New test. * testsuite/20_util/to_chars/version.cc: New test. --- libstdc++-v3/include/bits/charconv.h | 4 +- libstdc++-v3/include/std/charconv | 41 +++-- libstdc++-v3/include/std/version | 1 + .../testsuite/20_util/from_chars/constexpr.cc | 57 +++++++ .../testsuite/20_util/to_chars/constexpr.cc | 172 +++++++++++++++++++++ libstdc++-v3/testsuite/20_util/to_chars/version.cc | 16 ++ 6 files changed, 275 insertions(+), 16 deletions(-) create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/constexpr.cc create mode 100644 libstdc++-v3/testsuite/20_util/to_chars/constexpr.cc create mode 100644 libstdc++-v3/testsuite/20_util/to_chars/version.cc (limited to 'libstdc++-v3') diff --git a/libstdc++-v3/include/bits/charconv.h b/libstdc++-v3/include/bits/charconv.h index 4cae10a..d04aab7 100644 --- a/libstdc++-v3/include/bits/charconv.h +++ b/libstdc++-v3/include/bits/charconv.h @@ -68,13 +68,13 @@ namespace __detail // The caller is required to provide a buffer of exactly the right size // (which can be determined by the __to_chars_len function). template - void + _GLIBCXX23_CONSTEXPR void __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); - static constexpr char __digits[201] = + constexpr char __digits[201] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" diff --git a/libstdc++-v3/include/std/charconv b/libstdc++-v3/include/std/charconv index 64d0584..4b6cc83 100644 --- a/libstdc++-v3/include/std/charconv +++ b/libstdc++-v3/include/std/charconv @@ -50,6 +50,10 @@ # define __cpp_lib_to_chars 201611L #endif +#if __cplusplus > 202002L +# define __cpp_lib_constexpr_charconv 202202L +#endif + namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION @@ -119,7 +123,7 @@ namespace __detail // Generic implementation for arbitrary bases. template - to_chars_result + constexpr to_chars_result __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); @@ -138,7 +142,7 @@ namespace __detail unsigned __pos = __len - 1; - static constexpr char __digits[] = { + constexpr char __digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', @@ -160,7 +164,7 @@ namespace __detail } template - __integer_to_chars_result_type<_Tp> + constexpr __integer_to_chars_result_type<_Tp> __to_chars_16(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); @@ -177,7 +181,7 @@ namespace __detail return __res; } - static constexpr char __digits[] = { + constexpr char __digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; @@ -207,7 +211,7 @@ namespace __detail } template - inline __integer_to_chars_result_type<_Tp> + constexpr __integer_to_chars_result_type<_Tp> __to_chars_10(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); @@ -231,7 +235,7 @@ namespace __detail } template - __integer_to_chars_result_type<_Tp> + constexpr __integer_to_chars_result_type<_Tp> __to_chars_8(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); @@ -285,7 +289,7 @@ namespace __detail } template - __integer_to_chars_result_type<_Tp> + constexpr __integer_to_chars_result_type<_Tp> __to_chars_2(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); @@ -322,7 +326,7 @@ namespace __detail } // namespace __detail template - __detail::__integer_to_chars_result_type<_Tp> + constexpr __detail::__integer_to_chars_result_type<_Tp> __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10) { __glibcxx_assert(2 <= __base && __base <= 36); @@ -361,7 +365,7 @@ namespace __detail } #define _GLIBCXX_TO_CHARS(T) \ - inline to_chars_result \ + _GLIBCXX23_CONSTEXPR inline to_chars_result \ to_chars(char* __first, char* __last, T __value, int __base = 10) \ { return std::__to_chars_i(__first, __last, __value, __base); } _GLIBCXX_TO_CHARS(char) @@ -400,7 +404,7 @@ _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3) namespace __detail { template - bool + constexpr bool __raise_and_add(_Tp& __val, int __base, unsigned char __c) { if (__builtin_mul_overflow(__val, __base, &__val) @@ -429,18 +433,27 @@ namespace __detail return __table; } +#if __cpp_lib_constexpr_charconv + template + inline constexpr auto __table = __from_chars_alnum_to_val_table(); +#endif + // If _DecOnly is true: if the character is a decimal digit, then // return its corresponding base-10 value, otherwise return a value >= 127. // If _DecOnly is false: if the character is an alphanumeric digit, then // return its corresponding base-36 value, otherwise return a value >= 127. template - unsigned char + _GLIBCXX23_CONSTEXPR unsigned char __from_chars_alnum_to_val(unsigned char __c) { if _GLIBCXX17_CONSTEXPR (_DecOnly) return static_cast(__c - '0'); else { +#if __cpp_lib_constexpr_charconv + if (std::__is_constant_evaluated()) + return __table<_DecOnly>.__data[__c]; +#endif // This initializer is deliberately made dependent in order to work // around modules bug PR105322. static constexpr auto __table = (_DecOnly, __from_chars_alnum_to_val_table()); @@ -451,7 +464,7 @@ namespace __detail /// std::from_chars implementation for integers in a power-of-two base. /// If _DecOnly is true, then we may assume __base is at most 8. template - bool + _GLIBCXX23_CONSTEXPR bool __from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val, int __base) { @@ -508,7 +521,7 @@ namespace __detail /// std::from_chars implementation for integers in any base. /// If _DecOnly is true, then we may assume __base is at most 10. template - bool + constexpr bool __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, int __base) { @@ -548,7 +561,7 @@ namespace __detail /// std::from_chars for integral types. template - __detail::__integer_from_chars_result_type<_Tp> + _GLIBCXX23_CONSTEXPR __detail::__integer_from_chars_result_type<_Tp> from_chars(const char* __first, const char* __last, _Tp& __value, int __base = 10) { diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index 397a4aa..bec9e7a 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -302,6 +302,7 @@ #if __cplusplus > 202002L // c++23 #define __cpp_lib_byteswap 202110L +#define __cpp_lib_constexpr_charconv 202202L #define __cpp_lib_constexpr_typeinfo 202106L #if __cpp_concepts >= 202002L # define __cpp_lib_expected 202202L diff --git a/libstdc++-v3/testsuite/20_util/from_chars/constexpr.cc b/libstdc++-v3/testsuite/20_util/from_chars/constexpr.cc new file mode 100644 index 0000000..6e14694 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/from_chars/constexpr.cc @@ -0,0 +1,57 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include +#include + +constexpr bool +test() +{ + const char str[] = "-01234afz###"; + const char* end = str + sizeof(str); + + std::from_chars_result res; + int ival = 99; + unsigned uval = 99; + + res = std::from_chars(str, str+1, ival, 10); + VERIFY( res.ptr == str ); + VERIFY( res.ec == std::errc::invalid_argument ); + VERIFY( ival == 99 ); + res = std::from_chars(str, str+4, ival, 10); + VERIFY( res.ptr == str+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( ival == -12 ); + res = std::from_chars(str, end, ival, 10); + VERIFY( res.ptr == str+6 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( ival == -1234 ); + + res = std::from_chars(str, end, uval, 10); + VERIFY( res.ptr == str ); + VERIFY( res.ec == std::errc::invalid_argument ); + VERIFY( uval == 99 ); + res = std::from_chars(str+1, end, uval, 10); + VERIFY( res.ptr == str+6 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( uval == 1234 ); + + res = std::from_chars(str, end, ival, 3); + VERIFY( res.ptr == str+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( ival == -5 ); + + res = std::from_chars(str, end, ival, 16); + VERIFY( res.ptr == str+8 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( ival == -1193135 ); + + res = std::from_chars(str+1, end, uval, 36); + VERIFY( res.ptr == str+1+8 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( uval == 2302953695 ); + + return true; +} + +static_assert( test() ); diff --git a/libstdc++-v3/testsuite/20_util/to_chars/constexpr.cc b/libstdc++-v3/testsuite/20_util/to_chars/constexpr.cc new file mode 100644 index 0000000..30c5916 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/to_chars/constexpr.cc @@ -0,0 +1,172 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include + +#ifndef __cpp_lib_constexpr_charconv +# error "Feature-test macro for constexpr charconv missing in " +#elif __cpp_lib_constexpr_charconv != 202202L +# error "Feature-test macro for constexpr charconv has wrong value in " +#endif + +#include + +constexpr bool +test_base10() +{ + std::to_chars_result res; + char buf[10] = "XXXXXXXXX"; + res = std::to_chars(buf, buf+3, 1234); + VERIFY( res.ptr == buf+3 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+4, -1234); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+4, 1234); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '1' ); + VERIFY( buf[1] == '2' ); + VERIFY( buf[2] == '3' ); + VERIFY( buf[3] == '4' ); + VERIFY( buf[4] == 'X' ); + res = std::to_chars(buf, buf+10, -567, 10); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '-' ); + VERIFY( buf[1] == '5' ); + VERIFY( buf[2] == '6' ); + VERIFY( buf[3] == '7' ); + VERIFY( buf[4] == 'X' ); + return true; +} + +static_assert( test_base10() ); + +constexpr bool +test_base16() +{ + std::to_chars_result res; + char buf[10] = "XXXXXXXXX"; + res = std::to_chars(buf, buf+3, 0x1234, 16); + VERIFY( res.ptr == buf+3 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+4, -0x1234, 16); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+4, 0x1234, 16); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '1' ); + VERIFY( buf[1] == '2' ); + VERIFY( buf[2] == '3' ); + VERIFY( buf[3] == '4' ); + VERIFY( buf[4] == 'X' ); + res = std::to_chars(buf, buf+10, -0x567, 16); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '-' ); + VERIFY( buf[1] == '5' ); + VERIFY( buf[2] == '6' ); + VERIFY( buf[3] == '7' ); + VERIFY( buf[5] == 'X' ); + return true; +} + +static_assert( test_base16() ); + +constexpr bool +test_base8() +{ + std::to_chars_result res; + char buf[10] = "XXXXXXXXX"; + res = std::to_chars(buf, buf+2, 01234, 8); + VERIFY( res.ptr == buf+2 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+3, -01234, 8); + VERIFY( res.ptr == buf+3 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+4, 01234, 8); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '1' ); + VERIFY( buf[1] == '2' ); + VERIFY( buf[2] == '3' ); + VERIFY( buf[3] == '4' ); + VERIFY( buf[4] == 'X' ); + res = std::to_chars(buf, buf+10, -0567, 8); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '-' ); + VERIFY( buf[1] == '5' ); + VERIFY( buf[2] == '6' ); + VERIFY( buf[3] == '7' ); + VERIFY( buf[4] == 'X' ); + return true; +} + +static_assert( test_base8() ); + +constexpr bool +test_base2() +{ + std::to_chars_result res; + char buf[10] = "XXXXXXXXX"; + res = std::to_chars(buf, buf+4, 0b10001, 2); + VERIFY( res.ptr == buf+4 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+5, -0b10001, 2); + VERIFY( res.ptr == buf+5 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+5, 0b10001, 2); + VERIFY( res.ptr == buf+5 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '1' ); + VERIFY( buf[1] == '0' ); + VERIFY( buf[2] == '0' ); + VERIFY( buf[3] == '0' ); + VERIFY( buf[4] == '1' ); + VERIFY( buf[5] == 'X' ); + res = std::to_chars(buf, buf+10, -0b11011, 2); + VERIFY( res.ptr == buf+6 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '-' ); + VERIFY( buf[1] == '1' ); + VERIFY( buf[2] == '1' ); + VERIFY( buf[3] == '0' ); + VERIFY( buf[4] == '1' ); + VERIFY( buf[5] == '1' ); + VERIFY( buf[6] == 'X' ); + return true; +} + +static_assert( test_base2() ); + +constexpr bool +test_base36() +{ + std::to_chars_result res; + char buf[10] = "XXXXXXXXX"; + res = std::to_chars(buf, buf+1, 1234, 36); + VERIFY( res.ptr == buf+1 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+2, -1234, 36); + VERIFY( res.ptr == buf+2 ); + VERIFY( res.ec == std::errc::value_too_large ); + res = std::to_chars(buf, buf+3, 1234, 36); + VERIFY( res.ptr == buf+2 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == 'y' ); + VERIFY( buf[1] == 'a' ); + VERIFY( buf[3] == 'X' ); + res = std::to_chars(buf, buf+10, -567, 36); + VERIFY( res.ptr == buf+3 ); + VERIFY( res.ec == std::errc{} ); + VERIFY( buf[0] == '-' ); + VERIFY( buf[1] == 'f' ); + VERIFY( buf[2] == 'r' ); + VERIFY( buf[4] == 'X' ); + return true; +} + +static_assert( test_base36() ); diff --git a/libstdc++-v3/testsuite/20_util/to_chars/version.cc b/libstdc++-v3/testsuite/20_util/to_chars/version.cc new file mode 100644 index 0000000..af06e1b --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/to_chars/version.cc @@ -0,0 +1,16 @@ +// { dg-options "-std=gnu++23" } +// { dg-do preprocess { target c++23 } } + +#include + +#ifndef __cpp_lib_to_chars +# error "Feature-test macro for to_chars missing in " +#elif __cpp_lib_to_chars != 201611L +# error "Feature-test macro for to_chars has wrong value in " +#endif + +#ifndef __cpp_lib_constexpr_charconv +# error "Feature-test macro for constexpr charconv missing in " +#elif __cpp_lib_constexpr_charconv != 202202L +# error "Feature-test macro for constexpr charconv has wrong value in " +#endif -- cgit v1.1 From 030a08c857204909641b0fdc47ba3066f48de404 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Sat, 15 Oct 2022 21:15:51 +0100 Subject: libstdc++: Fix -Wunused-function warning in src/c++11/debug.cc The only remaining use of print_raw is conditionally compiled, so when libstdc++ i built without debug backtrace support, there's an unused warning function for it. Move it inside the conditional block. libstdc++-v3/ChangeLog: * src/c++11/debug.cc (print_raw): Move inside #if block. --- libstdc++-v3/src/c++11/debug.cc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'libstdc++-v3') diff --git a/libstdc++-v3/src/c++11/debug.cc b/libstdc++-v3/src/c++11/debug.cc index f2b25fb..9eda380 100644 --- a/libstdc++-v3/src/c++11/debug.cc +++ b/libstdc++-v3/src/c++11/debug.cc @@ -610,14 +610,6 @@ namespace { print_word(ctx, word, Length - 1); } void - print_raw(PrintContext& ctx, const char* str, ptrdiff_t nbc) - { - if (nbc == -1) - nbc = INT_MAX; - ctx._M_column += fprintf(stderr, "%.*s", (int)nbc, str); - } - - void print_word(PrintContext& ctx, const char* word, ptrdiff_t nbc = -1) { size_t length = nbc >= 0 ? nbc : __builtin_strlen(word); @@ -1092,6 +1084,14 @@ namespace { print_string(ctx, str, nbc, nullptr, 0); } #if _GLIBCXX_HAVE_STACKTRACE + void + print_raw(PrintContext& ctx, const char* str, ptrdiff_t nbc) + { + if (nbc == -1) + nbc = INT_MAX; + ctx._M_column += fprintf(stderr, "%.*s", (int)nbc, str); + } + int print_backtrace(void* data, __UINTPTR_TYPE__ pc, const char* filename, int lineno, const char* function) -- cgit v1.1 From 8f605de98de65262c0d3e81064b5bc708fed8f5c Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Sun, 16 Oct 2022 00:16:25 +0000 Subject: Daily bump. --- libstdc++-v3/ChangeLog | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) (limited to 'libstdc++-v3') diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 8166bc9..9ff3e3f 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,34 @@ +2022-10-15 Jonathan Wakely + + * src/c++11/debug.cc (print_raw): Move inside #if block. + +2022-10-15 Jonathan Wakely + + * include/bits/charconv.h (__to_chars_10_impl): Add constexpr + for C++23. Remove 'static' from array. + * include/std/charconv (__cpp_lib_constexpr_charconv): Define. + (__to_chars, __to_chars_16): Remove 'static' from array, add + constexpr. + (__to_chars_10, __to_chars_8, __to_chars_2, __to_chars_i) + (to_chars, __raise_and_add, __from_chars_pow2_base) + (__from_chars_alnum, from_chars): Add constexpr. + (__from_chars_alnum_to_val): Avoid local static during constant + evaluation. Add constexpr. + * include/std/version (__cpp_lib_constexpr_charconv): Define. + * testsuite/20_util/from_chars/constexpr.cc: New test. + * testsuite/20_util/to_chars/constexpr.cc: New test. + * testsuite/20_util/to_chars/version.cc: New test. + +2022-10-15 Jonathan Wakely + + * include/bits/stl_map.h (map::insert(Pair&&)): Use + remove_const_t on argument to __is_pair. + * include/bits/stl_pair.h (__is_pair>): Remove + partial specialization. + * include/bits/uses_allocator_args.h (_Std_pair): Use + remove_cv_t as per LWG 3677. + * testsuite/20_util/uses_allocator/lwg3677.cc: New test. + 2022-10-14 Jonathan Wakely * libsupc++/eh_alloc.cc [USE_POOL]: New macro. -- cgit v1.1