Use the __last_system_error() function and the system_category to
convert the Windows error to a generic one.

libstdc++-v3/ChangeLog:

	PR libstdc++/122726
	* src/filesystem/ops-common.h [_GLIBCXX_FILESYSTEM_IS_WINDOWS]
	(rename): Use __last_system_error to set errno accurately.
	* testsuite/27_io/filesystem/operations/rename.cc: Test
	error_code matches errc::no_such_file_or_directory.

Add preprocessor checks to std.cc.in for features which are not
supported with the old string ABI.

The COW std::string doesn't properly support C++11 allocators, so the
aliases such as std::pmr::string, std::pmr::u8string etc. are not
defined for the old string ABI.

The std::syncbuf type uses std::string and is not defined for the old
string ABI.

libstdc++-v3/ChangeLog:

	* src/c++23/std.cc.in [!__cpp_lib_syncbuf]: Disable exports for
	<syncstream> contents when not defined.
	[!_GLIBCXX_USE_CXX11_ABI]: Disable exports for pmr aliases in
	<string> when not defined.

For most configurations bits/std_mutex.h would already be included by
<syncstream>, but not if configured with _GLIBCXX_USE_CXX11_ABI=0 as the
default, because syncbuf is disabled in that case.

libstdc++-v3/ChangeLog:

	PR libstdc++/122698
	* src/c++20/syncbuf.cc (__syncbuf_get_mutex): Include <mutex>.
	Fix indentation of function body.

libstdc++-v3/ChangeLog:

	* src/c++20/atomic.cc (__wait_impl): Fix outdated comment.
	(__wait_until_impl): Simplify return statements.

Messing with macros before possibly importing the stdc++.h header unit is
bad form; better to mess with (other) macros afterward.

libstdc++-v3/ChangeLog:

	* src/c++23/std.cc.in: Move TBB macro shenanigans after
	bits/stdc++.h.

These exports didn't get uncommented when the functionality was implemented.

libstdc++-v3/ChangeLog:

	* src/c++23/std.cc.in: Uncomment usings for vprint_*_buffered.

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.

When exporting declarations in a namespace with using declarations, the
name must be fully qualified. Recently introduced std::full_extent{,_t},
std:strided_slice, and std::submdspan_mapping_result broke module std
and module std.compat.

libstdc++-v3/ChangeLog:

	* src/c++23/std.cc.in (std::strided_slice, std::full_extent_t)
	(std::full_extent, std::submdspan_mapping_result): Add std
	qualification.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

This implements the library parts of P1494 as amended by P3641.  For GCC the
compiler itself treats stdio operations as equivalent to the observable
checkpoint and thus it does not appear to be necessary to add calls to those
functions (it will not alter the outcome).

This adds the facility for C++26, although there is no reason, in principle,
that it would not work back to C++11 at least.

	PR c++/119060

libstdc++-v3/ChangeLog:

	* include/bits/version.def: Add observable_checkpoint at present
	allowed from C++26.
	* include/bits/version.h: Regenerate.
	* include/std/utility: Add std::observable_checkpoint().
	* src/c++23/std.cc.in: Add obervable_checkpoint () to utility.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>

When converting from a coarse duration with a very large value, the
existing code scales that up to chrono::seconds which overflows the
chrono::seconds::rep type. For example, sleep_for(chrono::hours::max())
tries to calculate LLONG_MAX * 3600, which overflows to -3600 and so the
sleep returns immediately.

The solution in this commit is inspired by this_thread::sleep_for in
libc++ which compares the duration argument to
chrono::duration<long double>(nanoseconds::max()) and limits the
duration to nanoseconds::max(). Because we split the duration into
seconds and nanoseconds, we can use seconds::max() as our upper limit.

We might need to limit further if seconds::max() doesn't fit in the
type used for sleeping, which is one of std::time_t, unsigned int, or
chrono::milliseconds.

To fix this everywhere that uses timeouts, new functions are introduced
for converting from a chrono::duration or chrono::time_point to a
timespec (or __gthread_time_t which is just a timespec on Linux). These
functions provide one central place where we can avoid overflow and also
handle negative timeouts (as these produce errors when passed to OS
functions that do not accept absolute times before the epoch). All
negative durations are converted to zero, and negative time_points are
converted to the epoch.

The new __to_timeout_gthread_time_t function in <bits/std_mutex.h>
requires adding <bits/chrono.h> to that header, but that only affects
<syncstream>. All other consumers of <bits/std_mutex.h> were already
including <bits/chrono.h> for timeouts (e.g. <shared_mutex> and
<condition_variable>).

libstdc++-v3/ChangeLog:

	PR libstdc++/113327
	PR libstdc++/116586
	PR libstdc++/119258
	PR libstdc++/58931
	* include/bits/chrono.h (__to_timeout_timespec): New overloaded
	function templates for converting chrono types to timespec.
	* include/bits/std_mutex.h (__to_timeout_gthread_time_t): New
	function template for converting time_point to __gthread_time_t.
	* include/bits/this_thread_sleep.h (sleep_for): Use
	__to_timeout_timespec.
	(__sleep_for): Remove namespace-scope declaration.
	* include/std/condition_variable: Likewise.
	* include/std/mutex: Likewise.
	* include/std/shared_mutex: Likewise.
	* src/c++11/thread.cc (limit): New helper function.
	(__sleep_for): Use limit to prevent overflow when converting
	chrono::seconds to time_t, unsigned, or chrono::milliseconds.
	* src/c++20/atomic.cc: Use __to_timeout_timespec and
	__to_timeout_gthread_time_t for timeouts.
	* testsuite/30_threads/this_thread/113327.cc: New test.

Reviewed-by: Mike Crowe <mac@mcrowe.com>
Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>