summaryrefslogtreecommitdiff
path: root/libstdc++-v3/include
Commit message (Collapse)AuthorAgeFilesLines
* libstdc++: Fix up some <cmath> templates [PR109883]Jakub Jelinek2023-05-171-117/+100
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | As can be seen on the following testcase, for std::{atan2,fmod,pow,copysign,fdim,fmax,fmin,hypot,nextafter,remainder,remquo,fma} if one operand type is std::float{16,32,64,128}_t or std::bfloat16_t and another one some integral type or some other floating point type which promotes to the other operand's type, we can end up with endless recursion. This is because of a declaration ordering problem in <cmath>, where the float, double and long double overloads of those functions come before the templates which use __gnu_cxx::__promote_{2,3}, but the std::float{16,32,64,128}_t and std::bfloat16_t overloads come later in the file. If the result of those promotions is _Float{16,32,64,128} or __gnu_cxx::__bfloat16_t, say std::pow(_Float64, int) calls std::pow(_Float64, _Float64) and the latter calls itself. The following patch fixes that by moving those templates later in the file, so that the calls from those templates see also the other overloads. I think other templates in the file like e.g. isgreater etc. shouldn't be a problem, because those just use __builtin_isgreater etc. in their bodies. 2023-05-17 Jakub Jelinek <jakub@redhat.com> PR libstdc++/109883 * include/c_global/cmath (atan2, fmod, pow): Move __gnu_cxx::__promote_2 using templates after _Float{16,32,64,128} and __gnu_cxx::__bfloat16_t overloads. (copysign, fdim, fmax, fmin, hypot, nextafter, remainder, remquo): Likewise. (fma): Move __gnu_cxx::__promote_3 using template after _Float{16,32,64,128} and __gnu_cxx::__bfloat16_t overloads. * testsuite/26_numerics/headers/cmath/constexpr_std_c++23.cc: New test.
* libstdc++: Add system_header pragma to <bits/c++config.h>Jonathan Wakely2023-05-171-0/+2
| | | | | | | | | | | | | | | | | | | | | | Without this change many tests that depend on an effective-target will fail when compiled with -pedantic -std=c++98. This happens because the preprocessor check done by v3_check_preprocessor_condition uses -Werror and includes <bits/c++config.h> directly (rather than via another header like <string>). If <bits/c++config.h> is not a system header then this pedwarn is not suppressed, and the effective-target check fails: bits/c++config.h:220: error: anonymous variadic macros were introduced in C++11 [-Werror=variadic-macros] cc1plus: all warnings being treated as errors compiler exited with status 1 UNSUPPORTED: 18_support/headers/limits/synopsis.cc We could consider also changing proc v3_check_preprocessor_condition so that it includes a real header, rather than just <bits/c++config.h>, but that's not necessary for now. libstdc++-v3/ChangeLog: * include/bits/c++config: Add system_header pragma.
* libstdc++: Implement LWG 3877 for std::expected monadic opsJonathan Wakely2023-05-171-24/+24
| | | | | | | | | | | | | | | This was approved in Issaquah 2023. As well as fixing the value categories, this fixes the fact that we were incorrectly testing E instead of T in the or_else constraints. libstdc++-v3/ChangeLog: * include/std/expected (expected::and_then, expected::or_else) (expected::transform, expected::transform_error): Fix exception specifications as per LWG 3877. (expected<void, E>::and_then, expected<void, E>::transform): Likewise. * testsuite/20_util/expected/lwg3877.cc: New test.
* libstdc++: use __bool_constant instead of integral_constantKen Matsui2023-05-171-16/+16
| | | | | | | | | | | | | | In the type_traits header, both integral_constant<bool> and __bool_constant are used. This patch unifies those usages into __bool_constant. libstdc++-v3/ChangeLog: * include/std/type_traits: Use __bool_constant instead of integral_constant. Signed-off-by: Ken Matsui <kmatsui@cs.washington.edu> Reviewed-by: Jonathan Wakely <jwakely@redhat.com> Reviewed-by: Patrick Palka <ppalka@redhat.com>
* libstdc++: Stop using TR1 macros in <cctype> and <cfenv>Jonathan Wakely2023-05-163-6/+6
| | | | | | | | | | | | | | | | | | | | | | | | | As with the two commits before this, the _GLIBCXX_USE_C99_CTYPE_TR1 and _GLIBCXX_USE_C99_FENV_TR1 macros are misleading when they are also used for <cctype> and <cfenv>, not only for TR1 headers. It is also wrong, because the configure checks for TR1 use -std=c++98 and a target might define the C99 features for C++11 but not for C++98. Add separate configure checks for the <ctype.h> and <fenv.h> features using -std=c++11 for the checks. Use the new macros defined by those checks in the C++11-specific parts of <cctype>, <cfenv>, and <fenv.h>. libstdc++-v3/ChangeLog: * acinclude.m4 (GLIBCXX_USE_C99): Check for isblank in C++11 mode and define _GLIBCXX_USE_C99_CTYPE. Check for <fenv.h> functions in C++11 mode and define _GLIBCXX_USE_C99_FENV. * config.h.in: Regenerate. * configure: Regenerate. * include/c_compatibility/fenv.h: Check _GLIBCXX_USE_C99_FENV instead of _GLIBCXX_USE_C99_FENV_TR1. * include/c_global/cfenv: Likewise. * include/c_global/cctype: Check _GLIBCXX_USE_C99_CTYPE instead of _GLIBCXX_USE_C99_CTYPE_TR1.
* libstdc++: Stop using _GLIBCXX_USE_C99_STDINT_TR1 in <cstdint>Jonathan Wakely2023-05-167-15/+15
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The _GLIBCXX_USE_C99_STDINT_TR1 macro (and the comments about it in acinclude.m4 and config.h) are misleading when it is also used for <stdint>, not only <tr1/stdint>. It is also wrong, because the configure checks for TR1 use -std=c++98 and a target might define uint32_t etc. for C++11 but not for C++98. Add a separate configure check for the <stdint.h> types using -std=c++11 for the checks. Use the result of that separate check in <cstdint> and most other places that still depend on the macro (many uses of that macro have been removed already). The remaining uses of the STDINT_TR1 macro are really for TR1, or are in the src/c++11/compatibility-*.cc files, where we don't want/need to change the condition they depend on (if those symbols were only exported when <stdint.h> types were available for -std=c++98, then that's the condition we should continue to use for whether to export the compat symbols now). Make similar changes for the related _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 macros, adding new macros for non-TR1 uses. libstdc++-v3/ChangeLog: * acinclude.m4 (GLIBCXX_USE_C99): Check for <stdint.h> types in C++11 mode and define _GLIBCXX_USE_C99_STDINT. Check for <inttypes.h> features in C++11 mode and define _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T. * config.h.in: Regenerate. * configure: Regenerate. * doc/doxygen/user.cfg.in (PREDEFINED): Add new macros. * include/bits/chrono.h: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/c_compatibility/inttypes.h: Check _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T instead of _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1. * include/c_compatibility/stdatomic.h: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/c_compatibility/stdint.h: Likewise. * include/c_global/cinttypes: Check _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T instead of _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1. * include/c_global/cstdint: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/std/atomic: Likewise. * src/c++11/cow-stdexcept.cc: Likewise. * testsuite/29_atomics/headers/stdatomic.h/c_compat.cc: Likewise. * testsuite/lib/libstdc++.exp (check_v3_target_cstdint): Likewise.
* libstdc++: Stop using _GLIBCXX_USE_C99_COMPLEX_TR1 in <complex>Jonathan Wakely2023-05-161-7/+7
| | | | | | | | | | | | | | | | | | | | | | The _GLIBCXX_USE_C99_COMPLEX_TR1 macro (and the comments about it in acinclude.m4 and config.h) are misleading when it is also used for <complex>, not only <tr1/complex>. It is also wrong, because the configure checks for TR1 use -std=c++98 and a target might define cacos etc. for C++11 but not for C++98. Add a separate configure check for the inverse trigonometric functions that are covered by _GLIBCXX_USE_C99_COMPLEX_TR1, but using -std=c++11 for the checks. Use the result of that separate check in <complex>. libstdc++-v3/ChangeLog: * acinclude.m4 (GLIBCXX_USE_C99): Check for complex inverse trig functions in C++11 mode and define _GLIBCXX_USE_C99_COMPLEX_ARC. * config.h.in: Regenerate. * configure: Regenerate. * doc/doxygen/user.cfg.in (PREDEFINED): Add new macro. * include/std/complex: Check _GLIBCXX_USE_C99_COMPLEX_ARC instead of _GLIBCXX_USE_C99_COMPLEX_TR1.
* libstdc++: Remove redundant dependencies on _GLIBCXX_USE_C99_STDINT_TR1Jonathan Wakely2023-05-122-12/+2
| | | | | | | | | | | | | | | | We never need to use std::make_unsigned in std::char_traits<char16_t> and std::char_traits<char32_t> because <cstdint> guarantees to provide the types we need, since r9-2028-g8ba7f29e3dd064. Similarly, experimental::source_location can just assume uint_least32_t is defined by <cstdint>. libstdc++-v3/ChangeLog: * include/bits/char_traits.h (char_traits<char16_t>): Do not depend on _GLIBCXX_USE_C99_STDINT_TR1. (char_traits<char32_t>): Likewise. * include/experimental/source_location: Likewise.
* libstdc++: Reduce <atomic> dependency on _GLIBCXX_USE_C99_STDINT_TR1Jonathan Wakely2023-05-121-4/+1
| | | | | | | | | | | | | | | | | | | | | | Since r9-2028-g8ba7f29e3dd064 we've defined most of <cstdint> unconditionally, so we can do the same for most of the std::atomic aliases such as std::atomic_int_least32_t. The only aliases that need to depend on _GLIBCXX_USE_C99_STDINT_TR1 are the ones for the integer types that are not guaranteed to be defined, e.g. std::atomic_int32_t. libstdc++-v3/ChangeLog: * include/std/atomic (atomic_int_least8_t, atomic_uint_least8_t) (atomic_int_least16_t, atomic_uint_least16_t) (atomic_int_least32_t, atomic_uint_least32_t) (atomic_int_least64_t, atomic_uint_least64_t) (atomic_int_fast16_t, atomic_uint_fast16_t) (atomic_int_fast32_t, atomic_uint_fast32_t) (atomic_int_fast64_t, atomic_uint_fast64_t) (atomic_intmax_t, atomic_uintmax_t): Define unconditionally. * testsuite/29_atomics/headers/stdatomic.h/c_compat.cc: Adjust.
* libstdc++: Remove <random> dependency on _GLIBCXX_USE_C99_STDINT_TR1Jonathan Wakely2023-05-126-22/+4
| | | | | | | | | | | | | | | | | | | Since r9-2028-g8ba7f29e3dd064 we've defined most of <cstdint> unconditionally, including uint_least32_t. This means that all of <random> can be defined unconditionally, which means that std::shuffle and std::ranges::shuffle can be too. libstdc++-v3/ChangeLog: * include/bits/algorithmfwd.h (shuffle): Do not depend on _GLIBCXX_USE_C99_STDINT_TR1. * include/bits/ranges_algo.h (shuffle): Likewise. * include/bits/stl_algo.h (shuffle): Likewise. * include/ext/random: Likewise. * include/ext/throw_allocator.h (random_condition): Likewise. * include/std/random: Likewise. * src/c++11/cow-string-inst.cc: Likewise. * src/c++11/random.cc: Likewise.
* libstdc++: Fix chrono::hh_mm_ss::subseconds() [PR109772]Jonathan Wakely2023-05-111-10/+2
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | I borked the logic in r13-4526-g5329e1a8e1480d so that the selected partial specialization of hh_mm_ss::__subseconds might not be able to represent the correct number of subseconds. This can result in a truncated value being stored for the subseconds, e.g., 4755859375 gets truncated to 460892079 because the correct value doesn't fit in uint_least32_t. Instead of checking whether the maximum value of the incoming duration type can be represented, we would need to check whether that maximum value can be represented after being converted to the correct precision type: template<typename _Tp> static constexpr bool __fits = duration_cast<precision>(_Duration::max()).count() <= duration_values<_Tp>::max(); However, this can fail to compile, due to integer overflow in the constexpr multiplications. Instead, we could limit the check to the case where the incoming duration has the same period as the precision, where no conversion is needed and so no overflow can happen. But that seems of very limited value, as it would only benefit specializations like hh_mm_ss<duration<int, std::pico>>, which can only represent a time-of-day between -00:00:00.0215 and +00:00:00.0215 measured in picoseconds! Additionally, the hh_mm_ss::__subseconds partial specializations do not have disjoint constraints, so that some hh_mm_ss specializations result in ambiguities tying to match a __subseconds partial specialization. The most practical fix is to just stop using the __fits variable template in the constraints of the partial specializations. This fixes the truncated values by not selecting an inappropriate partial specialization, and fixes the ambiguous match by ensuring the constraints are disjoint. Fixing this changes the layout of some specializations, so is an ABI change. It only affects specializations that have a small (less than 64-bit) representation type and either a very small period (e.g. like the picosecond specialization above) or a non-power-of-ten period like ratio<1, 1024>. For example both hh_mm_ss<duration<int, std::pico>> and hh_mm_ss<duration<int, ratio<1, 1024>> are affected (increasing from 16 bytes to 24 on x86_64), but hh_mm_ss<duration<int, ratio<1, 1000>> and hh_mm_ss<duration<long, ratio<1, 1024>> are not affected. libstdc++-v3/ChangeLog: PR libstdc++/109772 * include/std/chrono (hh_mm_ss::__fits): Remove variable template. (hh_mm_ss::__subseconds): Remove __fits from constraints. * testsuite/std/time/hh_mm_ss/109772.cc: New test. * testsuite/std/time/hh_mm_ss/1.cc: Adjust expected size for hh_mm_ss<duration<int, std::pico>>.
* libstdc++: Enforce value_type consistency in strings and streamsJonathan Wakely2023-05-113-35/+30
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | P1463R1 made it ill-formed for allocator-aware containers (including std::basic_string) to use an allocator that has a different value_type from the container itself. We already enforce that for other containers (since r8-4828-g866e4d3853ccc0), but not for std::basic_string. We traditionally accepted it as an extension and rebound the allocator, so this change only adds the enforcement for C++20 and later. Similarly, P1148R0 made it ill-formed for strings and streams to use a traits type that has an incorrect char_type. We already enforce that for std::basic_string_view, so we just need to add it to std::basic_ios and std::basic_string. The assertion for the allocator's value_type caused some testsuite regressions: FAIL: 21_strings/basic_string/cons/char/deduction.cc (test for excess errors) FAIL: 21_strings/basic_string/cons/wchar_t/deduction.cc (test for excess errors) FAIL: 21_strings/basic_string/requirements/explicit_instantiation/debug.cc (test for excess errors) FAIL: 21_strings/basic_string/requirements/explicit_instantiation/int.cc (test for excess errors) The last two are testing the traditional extension that rebinds the allocator, so need to be disabled for C++20. The first two are similar to LWG 3076 where an incorrect constructor is considered for CTAD. In this case, determining that it's not viable requires instantiating std::basic_string<Iter, char_traits<Iter>, Alloc> which then fails the new assertion, because Alloc::value_type is not the same as Iter. This is only a problem because the size_type parameter of the non-viable constructor is an alias for _Alloc_traits_impl<A>::size_type which is a nested type, and so the enclosing basic_string specialization needs to be instantiated. If we remove the _Alloc_traits_impl wrapper that was added in r12-5413-g2d76292bd6719d, then the definition of size_type no longer depends on basic_string, and we don't instantiate an invalid specialization and don't fail the assertion. The work done by _Alloc_traits_impl::allocate can be done in a _S_allocate function instead, which is probably more efficient to compile anyway. libstdc++-v3/ChangeLog: * config/abi/pre/gnu.ver: Export basic_string::_S_allocate. * include/bits/basic_ios.h: Add static assertion checking traits_type::value_type. * include/bits/basic_string.h: Likewise. Do not rebind allocator, and add static assertion checking its value_type. (basic_string::_Alloc_traits_impl): Remove class template. (basic_string::_S_allocate): New static member function. (basic_string::assign): Use _S_allocate. * include/bits/basic_string.tcc (basic_string::_M_create) (basic_string::reserve, basic_string::_M_replace): Likewise. * testsuite/21_strings/basic_string/requirements/explicit_instantiation/debug.cc: Disable for C++20 and later. * testsuite/21_strings/basic_string/requirements/explicit_instantiation/int.cc: Likweise.
* libstdc++: Fix std::abs(__float128) for -NaN and -0.0 [PR109758]Jonathan Wakely2023-05-111-2/+11
| | | | | | | | | | | | | | | | | | The current implementation of this non-standard overload of std::abs incorrectly returns a negative value for negative NaNs and negative zero, because x < 0 is false in both cases. Use fabsl(long double) or fabsf128(_Float128) if those do the right thing. Otherwise, use __builtin_signbit(x) instead of x < 0 to detect negative inputs. This assumes that __builtin_signbit handles __float128 correctly, but that seems to be true for all of GCC, clang and icc. libstdc++-v3/ChangeLog: PR libstdc++/109758 * include/bits/std_abs.h (abs(__float128)): Handle negative NaN and negative zero correctly. * testsuite/26_numerics/headers/cmath/109758.cc: New test.
* libstdc++: [_Hashtable] Implement several small methods implicitly inlineFrançois Dumont2023-05-102-132/+106
| | | | | | | | | | | | | | | | | | | | | | | | | | | Make implementation of 3 simple _Hashtable methods implicitly inline. Avoid usage of const_iterator abstraction within _Hashtable implementation. Replace several usages of __node_type* with expected __node_ptr. libstdc++-v3/ChangeLog: * include/bits/hashtable_policy.h (_NodeBuilder<>::_S_build): Use __node_ptr. (_ReuseOrAllocNode<>): Use __node_ptr in place of __node_type*. (_AllocNode<>): Likewise. (_Equality<>::_M_equal): Remove const_iterator usages. Only preserved to call std::is_permutation in the non-unique key implementation. * include/bits/hashtable.h (_Hashtable<>::_M_update_begin()): Capture _M_begin() once. (_Hashtable<>::_M_bucket_begin(size_type)): Implement implicitly inline. (_Hashtable<>::_M_insert_bucket_begin): Likewise. (_Hashtable<>::_M_remove_bucket_begin): Likewise. (_Hashtable<>::_M_compute_hash_code): Use __node_ptr rather than const_iterator. (_Hashtable<>::find): Likewise. (_Hashtable<>::_M_emplace): Likewise. (_Hashtable<>::_M_insert_unique): Likewise.
* libstdc++: Set _M_string_length before calling _M_dispose() [PR109703]Kefu Chai2023-05-031-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This always sets _M_string_length in the constructor for ranges of input iterators, such as stream iterators. We copy from the source range to the local buffer, and then repeatedly reallocate a larger one if necessary. When disposing the old buffer, _M_is_local() is used to tell if the buffer is the local one or not (and so must be deallocated). In addition to comparing the buffer address with the local buffer, _M_is_local() has an optimization hint so that the compiler knows that for a string using the local buffer, there is an invariant that _M_string_length <= _S_local_capacity (added for PR109299 via r13-6915-gbf78b43873b0b7). But we failed to set _M_string_length in the constructor taking a pair of iterators, so the invariant might not hold, and __builtin_unreachable() is reached. This causes UBsan errors, and potentially misoptimization. To ensure the invariant holds, _M_string_length is initialized to zero before doing anything else, so that _M_is_local() doesn't see an uninitialized value. This issue only surfaces when constructing a string with a range of input iterator, and the uninitialized _M_string_length happens to be greater than _S_local_capacity, i.e., 15 for the std::string specialization. libstdc++-v3/ChangeLog: PR libstdc++/109703 * include/bits/basic_string.h (basic_string(Iter, Iter, Alloc)): Initialize _M_string_length. Signed-off-by: Kefu Chai <kefu.chai@scylladb.com> Co-authored-by: Jonathan Wakely <jwakely@redhat.com>
* libstdc++: Improve doxygen docs for <random>Jonathan Wakely2023-04-282-6/+132
| | | | | | | | | | | | | | | | | | Add @headerfile and @since tags. Add gamma_distribution to the correct group (poisson distributions). Add a group for the sampling distributions and add the missing definitions of their probability functions. Add uniform_int_distribution back to the uniform distributions group. libstdc++-v3/ChangeLog: * include/bits/random.h (gamma_distribution): Add to the right doxygen group. (discrete_distribution, piecewise_constant_distribution) (piecewise_linear_distribution): Create a new doxygen group and fix the incomplete doxygen comments. * include/bits/uniform_int_dist.h (uniform_int_distribution): Add to doxygen group.
* libstdc++: Minor fixes to doxygen commentsJonathan Wakely2023-04-286-11/+10
| | | | | | | | | | | libstdc++-v3/ChangeLog: * include/bits/uses_allocator.h: Add missing @file comment. * include/bits/regex.tcc: Remove stray doxygen comments. * include/experimental/memory_resource: Likewise. * include/std/bit: Tweak doxygen @cond comments. * include/std/expected: Likewise. * include/std/numbers: Likewise.
* libstdc++: Simplify preprocessor/namespace nesting in <bits/move.h>Jonathan Wakely2023-04-281-9/+2
| | | | | | | | | | There's no good reason to conditionally close and reopen namespace std within an #if block. Just include the <type_traits> header at the top instead. libstdc++-v3/ChangeLog: * include/bits/move.h: Simplify opening/closing namespace std.
* libstdc++: Another attempt to ensure g++ 13+ compiled programs enforce gcc ↵Jakub Jelinek2023-04-281-0/+2
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 13.2+ libstdc++.so.6 [PR108969] GCC used to emit an instance of an empty ios_base::Init class in every TU which included <iostream> to ensure it is std::cout etc. is initialized, but thanks to Patrick work on some targets (which have init_priority attribute support) it is now initialized only inside of libstdc++.so.6/libstdc++.a. This causes a problem if people do something that has never been supported, try to run GCC 13 compiled C++ code against GCC 12 or earlier libstdc++.so.6 - std::cout etc. are then never initialized because code including <iostream> expects the library to initialize it and the library expects code including <iostream> to do that. The following patch is second attempt to make this work cheaply as the earlier attempt of aliasing the std::cout etc. symbols with another symbol version didn't work out due to copy relocation breaking the aliases appart. The patch forces just a _ZSt21ios_base_library_initv undefined symbol into all *.o files which include <iostream> and while there is no runtime relocation against that, it seems to enforce the right version of libstdc++.so.6. /home/jakub/src/gcc/obj08i/usr/local/ is the install directory of trunk patched with this patch, /home/jakub/src/gcc/obj06/ is builddir of trunk without this patch, system g++ is GCC 12.1.1. $ cat /tmp/hw.C #include <iostream> int main () { std::cout << "Hello, world!" << std::endl; } $ cd /home/jakub/src/gcc/obj08i/usr/local/bin $ ./g++ -o /tmp/hw /tmp/hw.C $ readelf -Wa /tmp/hw 2>/dev/null | grep initv 4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _ZSt21ios_base_library_initv@GLIBCXX_3.4.32 (4) 71: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _ZSt21ios_base_library_initv@GLIBCXX_3.4.32 $ /tmp/hw /tmp/hw: /lib64/libstdc++.so.6: version `GLIBCXX_3.4.32' not found (required by /tmp/hw) $ LD_LIBRARY_PATH=/home/jakub/src/gcc/obj08i/usr/local/lib64/ /tmp/hw Hello, world! $ LD_LIBRARY_PATH=/home/jakub/src/gcc/obj06/x86_64-pc-linux-gnu/libstdc++-v3/src/.libs/ /tmp/hw /tmp/hw: /home/jakub/src/gcc/obj06/x86_64-pc-linux-gnu/libstdc++-v3/src/.libs/libstdc++.so.6: version `GLIBCXX_3.4.32' not found (required by /tmp/hw) $ g++ -o /tmp/hw /tmp/hw.C $ /tmp/hw Hello, world! $ LD_LIBRARY_PATH=/home/jakub/src/gcc/obj06/x86_64-pc-linux-gnu/libstdc++-v3/src/.libs/ /tmp/hw Hello, world! $ LD_LIBRARY_PATH=/home/jakub/src/gcc/obj08i/usr/local/lib64/ /tmp/hw Hello, world! On sparc-sun-solaris2.11 one I've actually checked a version which had defined(_GLIBCXX_SYMVER_SUN) next to defined(_GLIBCXX_SYMVER_GNU), but init_priority attribute doesn't seem to be supported there and so I couldn't actually test how this works there. Using gas and Sun ld, Rainer, does one need to use gas + gld for init_priority or something else? 2023-04-28 Jakub Jelinek <jakub@redhat.com> PR libstdc++/108969 * config/abi/pre/gnu.ver (GLIBCXX_3.4.32): Export _ZSt21ios_base_library_initv. * testsuite/util/testsuite_abi.cc (check_version): Add GLIBCXX_3.4.32 symver and make it the latestp. * src/c++98/ios_init.cc (ios_base_library_init): New alias. * acinclude.m4 (libtool_VERSION): Change to 6:32:0. * include/std/iostream: If init_priority attribute is supported and _GLIBCXX_SYMVER_GNU, force undefined _ZSt21ios_base_library_initv symbol into the object. * configure: Regenerated.
* libstdc++: Fix typos in doxygen commentsJonathan Wakely2023-04-272-4/+3
| | | | | | | libstdc++-v3/ChangeLog: * include/bits/mofunc_impl.h: Fix typo in doxygen comment. * include/std/format: Likewise.
* libstdc++: Reduce Doxygen output for PDFJonathan Wakely2023-04-275-0/+10
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Including the header source code in the doxygen-generated PDF file makes it too large, and causes pdflatex to run out of memory. If we only set SOURCE_BROWSER=YES for the HTML docs then we won't include the sources in the PDF file. There are several macros defined for std::valarray that are only used to generate repetitive code and then #undef'd. Those aren't useful in the doxygen docs, especially the ones that reuse the same name in different files. Omitting them avoids warnings about duplicate labels in the refman.tex file. libstdc++-v3/ChangeLog: * doc/doxygen/user.cfg.in (SOURCE_BROWSER): Only set to YES for HTML docs. * include/bits/gslice_array.h (_DEFINE_VALARRAY_OPERATOR): Omit from doxygen docs. * include/bits/indirect_array.h (_DEFINE_VALARRAY_OPERATOR): Likewise. * include/bits/mask_array.h (_DEFINE_VALARRAY_OPERATOR): Likewise. * include/bits/slice_array.h (_DEFINE_VALARRAY_OPERATOR): Likewise. * include/std/valarray (_DEFINE_VALARRAY_UNARY_OPERATOR) (_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT) (_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT) (_DEFINE_BINARY_OPERATOR): Likewise.
* libstdc++: Improve doxygen docs for <memory_resource>Jonathan Wakely2023-04-272-0/+75
| | | | | | | libstdc++-v3/ChangeLog: * include/bits/memory_resource.h: Improve doxygen comments. * include/std/memory_resource: Likewise.
* libstdc++: Add @headerfile and @since to doxygen comments [PR40380]Jonathan Wakely2023-04-2716-8/+87
| | | | | | | | | | | | | | | | | | | | | | libstdc++-v3/ChangeLog: PR libstdc++/40380 * include/bits/basic_string.h: Improve doxygen comments. * include/bits/cow_string.h: Likewise. * include/bits/forward_list.h: Likewise. * include/bits/fs_dir.h: Likewise. * include/bits/fs_path.h: Likewise. * include/bits/quoted_string.h: Likewise. * include/bits/stl_bvector.h: Likewise. * include/bits/stl_map.h: Likewise. * include/bits/stl_multimap.h: Likewise. * include/bits/stl_multiset.h: Likewise. * include/bits/stl_set.h: Likewise. * include/bits/stl_vector.h: Likewise. * include/bits/unordered_map.h: Likewise. * include/bits/unordered_set.h: Likewise. * include/std/filesystem: Likewise. * include/std/iomanip: Likewise.
* libstdc++: Fix __max_diff_type::operator>>= for negative valuesPatrick Palka2023-04-241-1/+2
| | | | | | | | | | | | | | | | | This patch fixes sign bit propagation when right-shifting a negative __max_diff_type value by more than one, a bug that our existing test coverage didn't expose until r14-159-g03cebd304955a6 fixed the front end's 'signed typedef-name' handling that the test relies on (which is a non-standard extension to the language grammar). libstdc++-v3/ChangeLog: * include/bits/max_size_type.h (__max_diff_type::operator>>=): Fix propagation of sign bit. * testsuite/std/ranges/iota/max_size_type.cc: Avoid using the non-standard 'signed typedef-name'. Add some compile-time tests for right-shifting a negative __max_diff_type value by more than one.
* c++: Define built-in for std::tuple_element [PR100157]Patrick Palka2023-04-191-0/+6
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This adds a new built-in to replace the recursive class template instantiations done by traits such as std::tuple_element and std::variant_alternative. The purpose is to select the Nth type from a list of types, e.g. __type_pack_element<1, char, int, float> is int. We implement it as a special kind of TRAIT_TYPE. For a pathological example tuple_element_t<1000, tuple<2000 types...>> the compilation time is reduced by more than 90% and the memory used by the compiler is reduced by 97%. In realistic examples the gains will be much smaller, but still relevant. Unlike the other built-in traits, __type_pack_element uses template-id syntax instead of call syntax and is SFINAE-enabled, matching Clang's implementation. And like the other built-in traits, it's not mangleable so we can't use it directly in function signatures. N.B. Clang seems to implement __type_pack_element as a first-class template that can e.g. be used as a template-template argument. For simplicity we implement it in a more ad-hoc way. Co-authored-by: Jonathan Wakely <jwakely@redhat.com> PR c++/100157 gcc/cp/ChangeLog: * cp-trait.def (TYPE_PACK_ELEMENT): Define. * cp-tree.h (finish_trait_type): Add complain parameter. * cxx-pretty-print.cc (pp_cxx_trait): Handle CPTK_TYPE_PACK_ELEMENT. * parser.cc (cp_parser_constant_expression): Document default arguments. (cp_parser_trait): Handle CPTK_TYPE_PACK_ELEMENT. Pass tf_warning_or_error to finish_trait_type. * pt.cc (tsubst) <case TRAIT_TYPE>: Handle non-type first argument. Pass complain to finish_trait_type. * semantics.cc (finish_type_pack_element): Define. (finish_trait_type): Add complain parameter. Handle CPTK_TYPE_PACK_ELEMENT. * tree.cc (strip_typedefs): Handle non-type first argument. Pass tf_warning_or_error to finish_trait_type. * typeck.cc (structural_comptypes) <case TRAIT_TYPE>: Use cp_tree_equal instead of same_type_p for the first argument. libstdc++-v3/ChangeLog: * include/bits/utility.h (_Nth_type): Conditionally define in terms of __type_pack_element if available. * testsuite/20_util/tuple/element_access/get_neg.cc: Prune additional errors from the new built-in. gcc/testsuite/ChangeLog: * g++.dg/ext/type_pack_element1.C: New test. * g++.dg/ext/type_pack_element2.C: New test. * g++.dg/ext/type_pack_element3.C: New test.
* libstdc++: Implement range_adaptor_closure from P2387R3 [PR108827]Patrick Palka2023-04-183-0/+15
| | | | | | | | | | | | | | | PR libstdc++/108827 libstdc++-v3/ChangeLog: * include/bits/ranges_cmp.h (__cpp_lib_ranges): Bump value for C++23. * include/std/ranges (range_adaptor_closure): Define for C++23. * include/std/version (__cpp_lib_ranges): Bump value for C++23. * testsuite/std/ranges/version_c++23.cc: Bump expected value of __cpp_lib_ranges. * testsuite/std/ranges/range_adaptor_closure.cc: New test.
* libstdc++: Adding missing feature-test macros for C++23 ranges algosPatrick Palka2023-04-182-2/+12
| | | | | | | | | | | | | | | | | | | This patch also renames __cpp_lib_fold to __cpp_lib_ranges_fold as per the current draft standard. libstdc++-v3/ChangeLog: * include/bits/ranges_algo.h (__cpp_lib_ranges_contains): Define for C++23. (__cpp_lib_ranges_iota): Likewise. (__cpp_lib_ranges_find_last): Likewise. (__cpp_lib_fold): Rename to ... (__cpp_lib_ranges_fold): ... this. * include/std/version: As above. * testsuite/25_algorithms/fold_left/1.cc: Adjust after renaming __cpp_lib_fold. * testsuite/std/ranges/version_c++23.cc: Verify values of the above feature-test macros.
* libstdc++: Fix typo in views::as_const's operator() [PR109525]Patrick Palka2023-04-181-1/+1
| | | | | | | | | | | | PR libstdc++/109525 libstdc++-v3/ChangeLog: * include/std/ranges (views::_AsConst::operator()): Add missing const to constant_range test. * testsuite/std/ranges/adaptors/as_const/1.cc (test02): Improve formatting. Adjust expected type of v2. (test03): New test.
* libstdc++: Implement P2278R4 "cbegin should always return a constant iterator"Patrick Palka2023-04-146-3/+614
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This also implements the approved follow-up LWG issues 3765, 3766, 3769, 3770, 3811, 3850, 3853, 3862 and 3872. libstdc++-v3/ChangeLog: * include/bits/ranges_base.h (const_iterator_t): Define for C++23. (const_sentinel_t): Likewise. (range_const_reference_t): Likewise. (constant_range): Likewise. (__cust_access::__possibly_const_range): Likewise, replacing ... (__cust_access::__as_const): ... this. (__cust_access::_CBegin::operator()): Redefine for C++23 as per P2278R4. (__cust_access::_CEnd::operator()): Likewise. (__cust_access::_CRBegin::operator()): Likewise. (__cust_access::_CREnd::operator()): Likewise. (__cust_access::_CData::operator()): Likewise. * include/bits/ranges_util.h (ranges::__detail::__different_from): Make it an alias of std::__detail::__different_from. (view_interface::cbegin): Define for C++23. (view_interface::cend): Likewise. * include/bits/stl_iterator.h (__detail::__different_from): Define. (iter_const_reference_t): Define for C++23. (__detail::__constant_iterator): Likewise. (__detail::__is_const_iterator): Likewise. (__detail::__not_a_const_iterator): Likewise. (__detail::__iter_const_rvalue_reference_t): Likewise. (__detail::__basic_const_iter_cat):: Likewise. (const_iterator): Likewise. (__detail::__const_sentinel): Likewise. (const_sentinel): Likewise. (basic_const_iterator): Likewise. (common_type<basic_const_iterator<_Tp>, _Up>): Likewise. (common_type<_Up, basic_const_iterator<_Tp>>): Likewise. (common_type<basic_const_iterator<_Tp>, basic_const_iterator<Up>>): Likewise. (make_const_iterator): Define for C++23. (make_const_sentinel): Likewise. * include/std/ranges (__cpp_lib_ranges_as_const): Likewise. (as_const_view): Likewise. (enable_borrowed_range<as_const_view>): Likewise. (views::__detail::__is_ref_view): Likewise. (views::__detail::__can_is_const_view): Likewise. (views::_AsConst, views::as_const): Likewise. * include/std/span (span::const_iterator): Likewise. (span::const_reverse_iterator): Likewise. (span::cbegin): Likewise. (span::cend): Likewise. (span::crbegin): Likewise. (span::crend): Likewise. * include/std/version (__cpp_lib_ranges_as_const): Likewise. * testsuite/std/ranges/adaptors/join.cc (test06): Adjust to behave independently of C++20 vs C++23. * testsuite/std/ranges/version_c++23.cc: Verify value of __cpp_lib_ranges_as_const macro. * testsuite/24_iterators/const_iterator/1.cc: New test. * testsuite/std/ranges/adaptors/as_const/1.cc: New test.
* libstdc++: Move down definitions of ranges::cbegin/cend/cetcPatrick Palka2023-04-141-83/+91
| | | | | | | | | | | | | | | | This moves down the definitions of the range const-access CPOs to after the definition of input_range in preparation for implementing P2278R4 which redefines these CPOs in a way that indirectly uses input_range. libstdc++-v3/ChangeLog: * include/bits/ranges_base.h (__cust_access::__as_const) (__cust_access::_CBegin, __cust::cbegin) (__cust_access::_CEnd, __cust::cend) (__cust_access::_CRBegin, __cust::crbegin) (__cust_access::_CREnd, __cust::crend) (__cust_access::_CData, __cust::cdata): Move down definitions to shortly after the definition of input_range.
* libstdc++: Implement ranges::fold_* from P2322R6Patrick Palka2023-04-142-0/+252
| | | | | | | | | | | | | | | | | | | | | | | libstdc++-v3/ChangeLog: * include/bits/ranges_algo.h: Include <optional> for C++23. (__cpp_lib_fold): Define for C++23. (in_value_result): Likewise. (__detail::__flipped): Likewise. (__detail::__indirectly_binary_left_foldable_impl): Likewise. (__detail::__indirectly_binary_left_foldable): Likewise. (___detail:__indirectly_binary_right_foldable): Likewise. (fold_left_with_iter_result): Likewise. (__fold_left_with_iter_fn, fold_left_with_iter): Likewise. (__fold_left_fn, fold_left): Likewise. (__fold_left_first_with_iter_fn, fold_left_first_with_iter): Likewise. (__fold_left_first_fn, fold_left_first): Likewise. (__fold_right_fn, fold_right): Likewise. (__fold_right_last_fn, fold_right_last): Likewise. * include/std/version (__cpp_lib_fold): Likewise. * testsuite/25_algorithms/fold_left/1.cc: New test. * testsuite/25_algorithms/fold_right/1.cc: New test.
* libstdc++: Improve diagnostics for invalid std::format callsJonathan Wakely2023-04-141-5/+9
| | | | | | | | | | | | | | | | | | | Add a static_assert and a comment so that calling std::format for unformattable argument types will now show: /home/jwakely/gcc/13/include/c++/13.0.1/format:3563:22: error: static assertion failed: std::formatter must be specialized for each format arg 3563 | static_assert((is_default_constructible_v<formatter<_Args, _CharT>> && ...), | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ and: 140 | formatter() = delete; // No std::formatter specialization for this type. libstdc++-v3/ChangeLog: * include/std/format (formatter): Add comment to deleted default constructor of primary template. (_Checking_scanner): Add static_assert.
* libstdc++: Implement ranges::enumerate_view from P2164R9Patrick Palka2023-04-122-0/+304
| | | | | | | | | | | | | | | | | libstdc++-v3/ChangeLog: * include/std/ranges (__cpp_lib_ranges_enumerate): Define for C++23. (__detail::__range_with_movable_reference): Likewise. (enumerate_view): Likewise. (enumerate_view::_Iterator): Likewise. (enumerate_view::_Sentinel): Likewise. (views::__detail::__can_enumerate_view): Likewise. (views::_Enumerate, views::enumerate): Likewise. * include/std/version (__cpp_lib_ranges_enumerate): Likewise. * testsuite/std/ranges/version_c++23.cc: Verify value of __cpp_lib_ranges_enumerate. * testsuite/std/ranges/adaptors/enumerate/1.cc: New test.
* libstdc++: Implement LWG 3904 change to lazy_split_view's iteratorPatrick Palka2023-04-121-1/+2
| | | | | | | | | | | libstdc++-v3/ChangeLog: * include/std/ranges (lazy_split_view::_OuterIter::_OuterIter): Propagate _M_trailing_empty in the const-converting constructor as per LWG 3904. * testsuite/std/ranges/adaptors/adjacent/1.cc (test04): Correct assertion. * testsuite/std/ranges/adaptors/lazy_split.cc (test12): New test.
* libstdc++: Fix chunk_by_view when value_type& and reference differ [PR108291]Patrick Palka2023-04-121-4/+4
| | | | | | | | | | | | PR libstdc++/108291 libstdc++-v3/ChangeLog: * include/std/ranges (chunk_by_view::_M_find_next): Generalize parameter types of the lambda wrapper passed to adjacent_find. (chunk_by_view::_M_find_prev): Likewise. * testsuite/std/ranges/adaptors/chunk_by/1.cc (test04, test05): New tests.
* libstdc++: Initialize all members of basic_endpoint union [PR109482]Jonathan Wakely2023-04-121-4/+18
| | | | | | | | | | | | | | | | | | | | | | | | On Solaris the in_addr struct contains a union and value-initializing it does not make the s_addr member active. This means we can't access that member later during constant evaluation. Make the constructors explicitly set every member that we might want to read later in constexpr member functions. This means even the default constructor can only be constexpr for C++20, because we can't change the active member of a union in older standards. libstdc++-v3/ChangeLog: PR libstdc++/109482 * include/experimental/internet (basic_endpoint::basic_endpoint()): Ensure that the required union members are active. Only define as constexpr for C++20 and later. (basic_endpoint::basic_endpoint(const protocol_type&, port_type)): Likewise. * testsuite/experimental/net/internet/endpoint/cons.cc: Only check constexpr default constructor for C++20 and later. * testsuite/experimental/net/internet/endpoint/extensible.cc: Likewise.
* libstdc++: Fix some freestanding test failuresArsen Arsenović2023-04-051-1/+0
| | | | | | | | | | | | | | | | | | | At some point, <charconv> was added to the non-hosted bit of the C++17 block, which induced failures in many tests. In addition, some tests also lacked a dg-require-effective-target hosted tag. libstdc++-v3/ChangeLog: * include/precompiled/stdc++.h (C++17): Don't double-include <charconv>, once with wrong conditions. * testsuite/18_support/96817.cc: Require hosted. * testsuite/18_support/bad_exception/59392.cc: Ditto. * testsuite/20_util/scoped_allocator/108952.cc: Ditto. * testsuite/20_util/uses_allocator/lwg3527.cc: Ditto. * testsuite/29_atomics/atomic/operators/pointer_partial_void.cc: Ditto.
* libstdc++: Downgrade DEBUG to ASSERTIONS when !HOSTEDArsen Arsenović2023-04-051-0/+7
| | | | | | | | | | | | | | Supporting the debug mode in freestanding is a non-trivial job, so instead, as a best-effort, enable assertions, which are light and easy. libstdc++-v3/ChangeLog: * include/bits/c++config: When __STDC_HOSTED__ is zero, disable _GLIBCXX_DEBUG and, if it was set, enable _GLIBCXX_ASSERTIONS. * testsuite/lib/libstdc++.exp (check_v3_target_debug_mode): Include <bits/c++config.h> when determining whether debug is set, in order to inherit the logic from above
* libstdc++: Add a test for <version> FTM redefinitionsArsen Arsenović2023-04-051-1/+4
| | | | | | | | | | | | This test detects redefinitions by compiling stdc++.h and <version>, by disabling the system_header pragma on the latter, to allow warnings in it. Thanks Patrick Palka for the suggestion. libstdc++-v3/ChangeLog: * testsuite/17_intro/versionconflict.cc: New test. * include/std/version: Allow disabling the system_header pragma via _GLIBCXX_TESTING_SYSHDR.
* libstdc++: Harmonize <version> and other headersArsen Arsenović2023-04-054-48/+65
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Due to recent, large changes in libstdc++, the feature test macros declared in <version> got out of sync with the other headers that possibly declare them. libstdc++-v3/ChangeLog: * include/bits/unique_ptr.h (__cpp_lib_constexpr_memory): Synchronize the definition block with... * include/bits/ptr_traits.h (__cpp_lib_constexpr_memory): ... this one here. Also define the 202202L value, rather than leaving it up to purely unique_ptr.h, so that the value is synchronized across all headers. (__gnu_debug::_Safe_iterator_base): Move into new conditional block. * include/std/memory (__cpp_lib_atomic_value_initialization): Define on freestanding under the same conditions as in atomic_base.h. * include/std/version (__cpp_lib_robust_nonmodifying_seq_ops): Also define on freestanding. (__cpp_lib_to_chars): Ditto. (__cpp_lib_gcd): Ditto. (__cpp_lib_gcd_lcm): Ditto. (__cpp_lib_raw_memory_algorithms): Ditto. (__cpp_lib_array_constexpr): Ditto. (__cpp_lib_nonmember_container_access): Ditto. (__cpp_lib_clamp): Ditto. (__cpp_lib_constexpr_char_traits): Ditto. (__cpp_lib_constexpr_string): Ditto. (__cpp_lib_sample): Ditto. (__cpp_lib_lcm): Ditto. (__cpp_lib_constexpr_iterator): Ditto. (__cpp_lib_constexpr_char_traits): Ditto. (__cpp_lib_interpolate): Ditto. (__cpp_lib_constexpr_utility): Ditto. (__cpp_lib_shift): Ditto. (__cpp_lib_ranges): Ditto. (__cpp_lib_move_iterator_concept): Ditto. (__cpp_lib_constexpr_numeric): Ditto. (__cpp_lib_constexpr_functional): Ditto. (__cpp_lib_constexpr_algorithms): Ditto. (__cpp_lib_constexpr_tuple): Ditto. (__cpp_lib_constexpr_memory): Ditto.
* libstdc++: Define std::sub_match::swap member function (LWG 3204)Jonathan Wakely2023-04-051-0/+10
| | | | | | | | | This was approved at the C++ meeting in February. libstdc++-v3/ChangeLog: * include/bits/regex.h (sub_match::swap): New function. * testsuite/28_regex/sub_match/lwg3204.cc: New test.
* libstdc++: Teach optimizer that empty COW strings are empty [PR107087]Jonathan Wakely2023-03-311-2/+9
| | | | | | | | | | | | | | | | | | | | | | | | | | The compiler doesn't know about the invariant that the _S_empty_rep() object is immutable and so _M_length and _M_refcount are always zero. This means that we get warnings about writing possibly-non-zero length strings into buffers that can't hold them. If we teach the compiler that the empty rep is always zero length, it knows it can be copied into any buffer. For Stage 1 we might want to also consider adding this to capacity(): if (_S_empty_rep()._M_capacity != 0) __builtin_unreachable(); And this to _Rep::_M_is_leaked() and _Rep::_M_is_shared(): if (_S_empty_rep()._M_refcount != 0) __builtin_unreachable(); libstdc++-v3/ChangeLog: PR tree-optimization/107087 * include/bits/cow_string.h (basic_string::size()): Add optimizer hint that _S_empty_rep()._M_length is always zero. (basic_string::length()): Call size().
* libstdc++: Avoid -Wmaybe-uninitialized warning in std::stop_source [PR109339]Jonathan Wakely2023-03-311-0/+1
| | | | | | | | | | | | | We pass a const-reference to *this before it's constructed, and GCC assumes that all const-references are accessed. Add the access attribute to say it's not accessed. libstdc++-v3/ChangeLog: PR libstdc++/109339 * include/std/stop_token (_Stop_state_ptr(const stop_source&)): Add attribute access with access-mode 'none'. * testsuite/30_threads/stop_token/stop_source/109339.cc: New test.
* libstdc++: Revert addition of boolean flag to net::ip::basic_endpointJonathan Wakely2023-03-311-18/+14
| | | | | | | | | | | | | | | | | As pointed out in P2641R1, we can use GCC's __builtin_constant_p to emulate the proposed std::is_active_member. This allows us to detect which of the union members is active during constant evaluation, so we don't need the extra bool data member. We still can't support constexpr until C++20 though, as we need to change the active member during constant evaluation. libstdc++-v3/ChangeLog: * include/experimental/internet (ip::basic_endpoint::_M_if_v6): Revert change from member function to data member. Fix for constant evaluation by detecting which union member is active. (ip::basic_endpoint::resize): Revert changes to update _M_is_v6 flag.
* libstdc++: Fix constexpr functions in <experimental/internet>Jonathan Wakely2023-03-301-28/+75
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Change ip::basic_endpoint to work in constant expressions, but only for C++20 and later (due to the use of a union, which cannot change active member in constexpr evaluation until C++20). During constant evaluation we cannot inspect the common initial sequence of basic_endpoint's union members to check whether sin_family == AF_INET or AF_INET6. This means we need to store an additional boolean member that remembers whether we have a v4 or v6 address. The address type can change behind our backs if a user copies an address to the data() pointer and then calls resize(n), so we need to inspect the sa_family_t member in the union after a resize and update the boolean. POSIX only guarantees that the sa_family_t member of each protocol-specific address structure is at the same offset and of the same type, not that there is a common initial sequence. The check in resize is done using memcmp, so that we avoid accessing an inactive member of the union if the sockaddr_in and sockaddr_in6 structures do not have a common initial sequence that includes the sa_family_t member. libstdc++-v3/ChangeLog: * include/experimental/internet (ip::make_address): Implement missing overload. (ip::address_v4::broadcast()): Avoid undefined shift. (ip::basic_endpoint): Fix member functions for constexpr. (ip::basic_endpoint::_M_is_v6): Replace member function with data member, adjust member functions using it. (ip::basic_endpoint::resize): Update _M_is_v6 based on sockaddr content. * testsuite/experimental/net/internet/address/v4/cons.cc: Fix constexpr checks to work in C++14. * testsuite/experimental/net/internet/address/v4/creation.cc: Likewise. * testsuite/experimental/net/internet/endpoint/cons.cc: Likewise. * testsuite/experimental/net/internet/network/v4/cons.cc: Likewise. * testsuite/experimental/net/internet/network/v4/members.cc: Likewise. * testsuite/experimental/net/internet/endpoint/extensible.cc: New test.
* libstdc++: Apply small fix from LWG 3843 to std::expectedJonathan Wakely2023-03-301-1/+2
| | | | | | | | | | | | | | | LWG 3843 adds some type requirements to std::expected::value to ensure that it can correctly copy the error value if it needs to throw an exception. We don't need to do anything to enforce that, because it will already be ill-formed if the type can't be copied. The issue also makes a small drive-by fix to ensure that a const E& is copied from the non-const value()& overload, which this change implements. libstdc++-v3/ChangeLog: * include/std/expected (expected::value() &): Use const lvalue for unex member passed to bad_expected_access constructor, as per LWG 3843.
* libstdc++: Use std::remove_cv_t in std::optional::transform [PR109340]Jonathan Wakely2023-03-302-20/+24
| | | | | | | | | | | | | | | | | | | | We need to strip cv-qualifiers from the result of the callable passed to std::optional::transform. For std::expected::transform and std::expected::transform_error I noticed we were stripping cv-qualifiers but were also incorrectly stripping references. libstdc++-v3/ChangeLog: PR libstdc++/109340 * include/std/expected (expected::transform): Use std::remove_cv_t instead of std::remove_cvref_t. (expected::transform_error): Likewise. (expected<cv void, E>::transform): Likewise. (expected<cv void, E>::transform_error): Likewise. * include/std/optional (transform): Use std::remove_cv_t. * testsuite/20_util/optional/monadic/pr109340.cc: New test.
* libstdc++: Enforce requirements on template argument of std::optionalJonathan Wakely2023-03-301-1/+1
| | | | | | | | | | | | | | | | | The standard does not allow std::optional<T&>, std::optional<T[1]>, std::optional<T()> etc. and although we do give errors, they come from down inside the internals of std::optional. We could improve the static assertions at the top of the class so that users get a more precise diagnostic: optional:721:21: error: static assertion failed 721 | static_assert(is_object_v<_Tp> && !is_array_v<_Tp>); libstdc++-v3/ChangeLog: * include/std/optional (optional): Adjust static assertion to reject arrays and functions as well as references. * testsuite/20_util/optional/requirements_neg.cc: New test.
* libstdc++: Do not use facets cached in ios for ATL128 build [PR103387]Jonathan Wakely2023-03-282-0/+20
| | | | | | | | | | | | | | | | | | | | For the powerpc64le build with two different long double representations, we cannot use the ios_base::_M_num_put and ios_base::_M_num_get pointers, because they might have been initialized in a translation unit using the other long double type. With the changes to add __try_use_facet to GCC 13 the cache isn't really needed now, we can just access the right facet in the locale directly, without needing RTTI checks. libstdc++-v3/ChangeLog: PR libstdc++/103387 * include/bits/istream.tcc (istream::_M_extract(ValueT&)): Use std::use_facet instead of cached _M_num_get facet. (istream::operator>>(short&)): Likewise. (istream::operator>>(int&)): Likewise. * include/bits/ostream.tcc (ostream::_M_insert(ValueT)): Use std::use_facet instead of cached _M_num_put facet.
* libstdc++: More fixes for null pointers used with std::char_traitsJonathan Wakely2023-03-281-4/+8
| | | | | | | | | | | | | | | | | The std::char_traits member functions require that [p,p+n) is a valid range, which is true for p==nullptr iff n==0. But we must not call memcpy, memset etc, in that case, as they require non-null pointers even when n==0. This std::char_traits<char> and std::char_traits<wchar_t> explicit specializations are already correct, but the primary template has some bugs. libstdc++-v3/ChangeLog: * include/bits/char_traits.h (char_traits::copy): Return without using memcpy if n==0. (char_traits::assign): Likewise for memset.
View Lorry Controller Status