I don't know what changed, but I'm seeing some new failures: FAIL: 23_containers/vector/capacity/114945.cc -std=gnu++11 (test for excess errors) FAIL: 23_containers/vector/capacity/114945.cc -std=gnu++14 (test for excess errors) FAIL: 23_containers/vector/capacity/114945.cc -std=gnu++17 (test for excess errors) FAIL: 28_regex/basic_regex/85098.cc -std=gnu++11 (test for excess errors) FAIL: 28_regex/basic_regex/85098.cc -std=gnu++14 (test for excess errors) FAIL: 28_regex/basic_regex/85098.cc -std=gnu++17 (test for excess errors) FAIL: 28_regex/simple_c++11.cc (test for excess errors) libstdc++-v3/ChangeLog: * include/bits/regex_automaton.tcc [_GLIBCXX_DEBUG]: Include <ostream> so that _State_base::_M_print etc. can use it.
This improves the code generation slightly for std::string because of aliasing. In many cases the length will be read again and the store of the null character will cause the length to be re-read due to aliasing requirements of the char type. So swapping around the stores will allow the length not to have to be reloaded from memory and will allow for more optimizations. Bootstrapped and tested on x86_64-linux-gnu. libstdc++-v3/ChangeLog: * include/bits/basic_string.h (basic_string::M_set_length): Swap around the order of traits_type::assign and _M_length so that _M_length is at the end. Signed-off-by: Andrew Pinski <andrew.pinski@oss.qualcomm.com>
To reduce instantiation count, function_ref(nontype<&S::x>, r) previously reused the invoker from function_ref(nontype<&S::x>, &r). This assumed r was always a reference to S or a derived class. However, this constructor is also valid for lvalues (but not rvalues) of reference_wrapper specializations. This patch fixes this by limiting above optimization only to situations, when argument is not specialization of reference_wrapper. This is achieved bu comparing __inv_unwrap<_Td>::type with _Td. We use __inv_unwrap because unwrap_reference_t does not handle cv-qualified types. PR libstdc++/121858 libstdc++-v3/ChangeLog: * include/bits/funcref_impl.h (function_ref::function_ref(nontype<__fn>, _Up&&)): Handle. reference_wrapper. * testsuite/20_util/function_ref/call.cc: Call and update test05(). Add new test06() for reference_wrapper. Reviewed-by: Jonathan Wakely <jwakely@redhat.com> Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>
libstdc++-v3/ChangeLog: * include/bits/atomic_base.h: Tweak grammar of static assert messages for unsupported atomic wait on volatile.
Previously, _Utf_view accepted any input_range, including reference-to-array types like char(&)[2], and stored it as the _M_base member. In such cases, _Utf_view was not assignable, failing the requirements of view concept. This patch addresses the issue by adding the ranges::view constraint to the second template parameter of _Utf_view, and for clarity renaming it from _Range to _View. The constructor is also adjusted to accept its argument by value (views must be O(1) move-constructible). This prevents implicitly generated CTAD from deducing a reference type. This makes _Utf_view consistent with both other standard views and the wording from P2728R8: Unicode in the Library, Part 1: UTF Transcoding [1]. The explicit CTAD from viewable_range is not defined for _Utf_view because it depends on views::all_t, views::ref_view, and views::owning_view, which are declared in <ranges>. Consequently, users must explicitly cast the argument to a view or specify it as a template parameter. [1] https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2728r8.html libstdc++-v3/ChangeLog: * include/bits/unicode.h (_Utf_view): Rename the template parameter from _Range to _View and constrain it with ranges::view. (_Utf_view::_Utf_view): Accept by value instead of rvalue reference. * include/std/format (__format::__write_padded): Replace _Utf_view over const char32_t(&)[1] with span<const char32_t, 1>. * testsuite/ext/unicode/view.cc: Add checks if specialization of _Utf_view satisfy view. Wrap arrays into std::span before constructing _Utf_view. Reviewed-by: Jonathan Wakely <jwakely@redhat.com> Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>
The std::is_assignable check should test for assignment to an lvalue, not an rvalue. libstdc++-v3/ChangeLog: PR libstdc++/122661 * include/bits/forward_list.h (forward_list::assign(I, I)): Fix value category in is_assignable check. * testsuite/23_containers/forward_list/modifiers/122661.cc: New test.
Since the implementation namespaces __detail and __exception_ptr aren't exported from std, ADL can't find these functions there. Adding friend declarations makes it work. libstdc++-v3/ChangeLog: * include/bits/quoted_string.h: Add ADL friends. * libsupc++/exception_ptr.h: Add ADL friend.
In r15-3499 I added attributes to _Ios_Openmode to avoid -Wswitch false positives; let's do the same for the other enums in ios_base. It also seems to me that with these attributes, the tests don't need to include the end/max/min cases. libstdc++-v3/ChangeLog: * include/bits/ios_base.h: Add attribs to _Ios_Fmtflags, _Ios_Iostate, _ios_seekdir. * testsuite/27_io/ios_base/types/fmtflags/case_label.cc: Remove unneeded cases. * testsuite/27_io/ios_base/types/iostate/case_label.cc: Likewise. * testsuite/27_io/ios_base/types/openmode/case_label.cc: Likewise. * testsuite/27_io/ios_base/types/seekdir/case_label.cc: Likewise.
The following patch attempts to implement the library side of the C++23 P2674R1 paper. As mentioned in the paper, since CWG2605 the trait isn't really implementable purely on the library side. The compiler side has been committed earlier, so this just uses the new builtin trait on the library side. 2025-10-30 Jakub Jelinek <jakub@redhat.com> * include/bits/version.def (is_implicit_lifetime): New. * include/bits/version.h: Regenerate. * include/std/type_traits (std::is_implicit_lifetime, std::is_implicit_lifetime_v): New trait. * src/c++23/std.cc.in (std::is_implicit_lifetime, std::is_implicit_lifetime_v): Export. * testsuite/20_util/is_implicit_lifetime/version.cc: New test. * testsuite/20_util/is_implicit_lifetime/value.cc: New test.
In r16-4709-gc55c1de3a9adb2 I meant to use the result of the static_cast<char> for the rest of the function following it, but I accidentally used the original variable __ch. This causes -Wunused-variable warnings for the __c initialized from the cast. This fixes the rest of the function to use __c instead of __ch. libstdc++-v3/ChangeLog: * include/bits/regex.tcc (regex_traits::value): Use __c instead of __ch.