* [PATCH 0/2] Unify and deduplicate FTM code
@ 2023-04-29 10:16 Arsen Arsenović
2023-04-29 10:16 ` [PATCH 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Arsen Arsenović @ 2023-04-29 10:16 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Arsen Arsenović
Greetings!
This patch set replaces all code that involves defining feature test
macros based on loosely put together conditionals in the standard
library with a unified helper for specifying and requiring feature test
macros, as well as updating most usage sites, many of which have been
migrated to following a pattern similar, in structure, to:
...
#define __glibcxx_want_foo
#include <bits/version.h>
...
namespace std {
...
#ifdef __cpp_lib_foo
template<typename T>
void foonicate(T&& t)
{ __builtin_foonicate_address(std::__addressof(t)); }
#endif // __cpp_lib_foo
...
} // namespace std
In the future this should aid in preventing <version> from being
dishonest about what the implementation provides, as well as reducing
the amount of finicky work it takes to update FTMs.
Note that this patchset is not perfect. The usage sites of various
feature test macros still include "wide" condition blocks that shadow
over the blocks that check for FTMs, mostly in places where features
with FTMs are the exception, rather than the norm.
That said, using a pair of scripts[1][2], I've tested that the code
emitted in bits/stdc++.h remains unchanged (save for a misdeclared
__cpp_lib_constexpr_string in !HOSTED), as well as regression-tested
--enable-languages=c,c++,lto on x86_64-pc-linux-gnu, and ran the
libstdc++ testsuite with
--target_board="unix{,-std=c++98,-std=gnu++11,-std=gnu++20,
-D_GLIBCXX_USE_CXX11_ABI=0/-D_GLIBCXX_DEBUG,-D_GLIBCXX_DEBUG,
-std=gnu++23}{-fno-freestanding,-ffreestanding}"
(without the line breaks) to find no relevant failures.
OK for trunk?
Thanks in advance, have a lovely day.
[1] https://git.sr.ht/~arsen/scripts/tree/master/item/difall.bash
[2] https://git.sr.ht/~arsen/scripts/tree/master/item/vercmp.bash
Arsen Arsenović (2):
libstdc++: Implement more maintainable <version> header
libstdc++: Replace all manual FTM definitions and use
libstdc++-v3/include/Makefile.am | 10 +-
libstdc++-v3/include/Makefile.in | 10 +-
libstdc++-v3/include/bits/algorithmfwd.h | 7 +-
libstdc++-v3/include/bits/align.h | 8 +-
libstdc++-v3/include/bits/alloc_traits.h | 11 +-
libstdc++-v3/include/bits/allocator.h | 3 +-
libstdc++-v3/include/bits/atomic_base.h | 14 +-
libstdc++-v3/include/bits/atomic_wait.h | 10 +-
libstdc++-v3/include/bits/basic_string.h | 24 +-
libstdc++-v3/include/bits/char_traits.h | 11 +-
libstdc++-v3/include/bits/chrono.h | 18 +-
libstdc++-v3/include/bits/cow_string.h | 9 +-
libstdc++-v3/include/bits/erase_if.h | 11 +-
libstdc++-v3/include/bits/forward_list.h | 6 +-
libstdc++-v3/include/bits/hashtable.h | 9 +-
libstdc++-v3/include/bits/ios_base.h | 6 +-
libstdc++-v3/include/bits/move.h | 8 +-
.../include/bits/move_only_function.h | 9 +-
libstdc++-v3/include/bits/node_handle.h | 8 +-
libstdc++-v3/include/bits/ptr_traits.h | 15 +-
libstdc++-v3/include/bits/range_access.h | 16 +-
libstdc++-v3/include/bits/ranges_algo.h | 27 +-
libstdc++-v3/include/bits/ranges_cmp.h | 14 +-
libstdc++-v3/include/bits/shared_ptr.h | 10 +-
libstdc++-v3/include/bits/shared_ptr_atomic.h | 6 +-
libstdc++-v3/include/bits/shared_ptr_base.h | 17 +-
libstdc++-v3/include/bits/specfun.h | 6 +-
libstdc++-v3/include/bits/stl_algo.h | 20 +-
libstdc++-v3/include/bits/stl_algobase.h | 13 +-
libstdc++-v3/include/bits/stl_function.h | 28 +-
libstdc++-v3/include/bits/stl_iterator.h | 21 +-
libstdc++-v3/include/bits/stl_list.h | 6 +-
libstdc++-v3/include/bits/stl_map.h | 6 +-
libstdc++-v3/include/bits/stl_pair.h | 12 +-
libstdc++-v3/include/bits/stl_queue.h | 9 +-
libstdc++-v3/include/bits/stl_stack.h | 7 +-
libstdc++-v3/include/bits/stl_tree.h | 7 +-
libstdc++-v3/include/bits/stl_uninitialized.h | 9 +-
libstdc++-v3/include/bits/stl_vector.h | 4 +-
libstdc++-v3/include/bits/unique_ptr.h | 13 +-
libstdc++-v3/include/bits/unordered_map.h | 8 +-
.../include/bits/uses_allocator_args.h | 10 +-
libstdc++-v3/include/bits/utility.h | 21 +-
libstdc++-v3/include/bits/version.def | 1591 ++++++++++++++
libstdc++-v3/include/bits/version.h | 1937 +++++++++++++++++
libstdc++-v3/include/bits/version.tpl | 209 ++
.../include/c_compatibility/stdatomic.h | 9 +-
libstdc++-v3/include/c_global/cmath | 18 +-
libstdc++-v3/include/c_global/cstddef | 9 +-
libstdc++-v3/include/std/algorithm | 10 +-
libstdc++-v3/include/std/any | 9 +-
libstdc++-v3/include/std/array | 9 +-
libstdc++-v3/include/std/atomic | 67 +-
libstdc++-v3/include/std/barrier | 11 +-
libstdc++-v3/include/std/bit | 30 +-
libstdc++-v3/include/std/bitset | 7 +-
libstdc++-v3/include/std/charconv | 11 +-
libstdc++-v3/include/std/complex | 11 +-
libstdc++-v3/include/std/concepts | 10 +-
libstdc++-v3/include/std/coroutine | 20 +-
libstdc++-v3/include/std/deque | 9 +-
libstdc++-v3/include/std/execution | 10 +-
libstdc++-v3/include/std/expected | 8 +-
libstdc++-v3/include/std/filesystem | 9 +-
libstdc++-v3/include/std/format | 19 +-
libstdc++-v3/include/std/forward_list | 10 +-
libstdc++-v3/include/std/functional | 39 +-
libstdc++-v3/include/std/iomanip | 9 +-
libstdc++-v3/include/std/iterator | 5 +-
libstdc++-v3/include/std/latch | 10 +-
libstdc++-v3/include/std/list | 10 +-
libstdc++-v3/include/std/memory | 15 +-
libstdc++-v3/include/std/memory_resource | 20 +-
libstdc++-v3/include/std/mutex | 8 +-
libstdc++-v3/include/std/numbers | 8 +-
libstdc++-v3/include/std/numeric | 35 +-
libstdc++-v3/include/std/optional | 15 +-
libstdc++-v3/include/std/ranges | 60 +-
libstdc++-v3/include/std/semaphore | 9 +-
libstdc++-v3/include/std/shared_mutex | 12 +-
libstdc++-v3/include/std/source_location | 9 +-
libstdc++-v3/include/std/span | 11 +-
libstdc++-v3/include/std/spanstream | 11 +-
libstdc++-v3/include/std/stacktrace | 10 +-
libstdc++-v3/include/std/stop_token | 5 +-
libstdc++-v3/include/std/string | 9 +-
libstdc++-v3/include/std/string_view | 23 +-
libstdc++-v3/include/std/syncstream | 17 +-
libstdc++-v3/include/std/thread | 3 +
libstdc++-v3/include/std/tuple | 25 +-
libstdc++-v3/include/std/type_traits | 141 +-
libstdc++-v3/include/std/utility | 38 +-
libstdc++-v3/include/std/variant | 13 +-
libstdc++-v3/include/std/vector | 9 +-
libstdc++-v3/include/std/version | 350 +--
libstdc++-v3/libsupc++/compare | 11 +-
libstdc++-v3/libsupc++/exception | 6 +-
libstdc++-v3/libsupc++/new | 20 +-
libstdc++-v3/libsupc++/typeinfo | 7 +-
.../array/tuple_interface/get_neg.cc | 6 +-
100 files changed, 4445 insertions(+), 1064 deletions(-)
create mode 100644 libstdc++-v3/include/bits/version.def
create mode 100644 libstdc++-v3/include/bits/version.h
create mode 100644 libstdc++-v3/include/bits/version.tpl
--
2.40.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 1/2] libstdc++: Implement more maintainable <version> header
2023-04-29 10:16 [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
@ 2023-04-29 10:16 ` Arsen Arsenović
2023-06-01 20:06 ` Jonathan Wakely
2023-04-29 10:16 ` [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović
2023-05-08 23:08 ` Ping: [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
2 siblings, 1 reply; 9+ messages in thread
From: Arsen Arsenović @ 2023-04-29 10:16 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Arsen Arsenović
This commit replaces the ad-hoc logic in <version> with an AutoGen
database that (mostly) declaratively generates a version.h bit which
combines all of the FTM logic across all headers together.
This generated header defines macros of the form __glibcxx_foo,
equivalent to their __cpp_lib_foo variants, according to rules specified
in version.def and, optionally, if __glibcxx_want_foo or
__glibcxx_want_all are defined, also defines __cpp_lib_foo forms with
the same definition.
libstdc++-v3/ChangeLog:
* include/Makefile.am (bits_freestanding): Add version.h.
(allcreated): Add version.h.
(${bits_srcdir}/version.h): New rule. Regenerates
version.h out of version.{def,tpl}.
* include/Makefile.in: Regenerate.
* include/bits/version.def: New file. Declares a list of
all feature test macros, their values and their preconditions.
* include/bits/version.tpl: New file. Turns version.def
into a sequence of #if blocks.
* include/bits/version.h: New file. Generated from
version.def.
* include/std/version: Replace with a __glibcxx_want_all define
and bits/version.h include.
---
libstdc++-v3/include/Makefile.am | 10 +-
libstdc++-v3/include/Makefile.in | 10 +-
libstdc++-v3/include/bits/version.def | 1591 ++++++++++++++++++++
libstdc++-v3/include/bits/version.h | 1937 +++++++++++++++++++++++++
libstdc++-v3/include/bits/version.tpl | 209 +++
libstdc++-v3/include/std/version | 350 +----
6 files changed, 3758 insertions(+), 349 deletions(-)
create mode 100644 libstdc++-v3/include/bits/version.def
create mode 100644 libstdc++-v3/include/bits/version.h
create mode 100644 libstdc++-v3/include/bits/version.tpl
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index a880e8ee227..a07b4c18585 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -154,6 +154,7 @@ bits_freestanding = \
${bits_srcdir}/stl_raw_storage_iter.h \
${bits_srcdir}/stl_relops.h \
${bits_srcdir}/stl_uninitialized.h \
+ ${bits_srcdir}/version.h \
${bits_srcdir}/string_view.tcc \
${bits_srcdir}/uniform_int_dist.h \
${bits_srcdir}/unique_ptr.h \
@@ -1113,7 +1114,8 @@ allcreated = \
${host_builddir}/c++config.h \
${host_builddir}/largefile-config.h \
${thread_host_headers} \
- ${pch_build}
+ ${pch_build} \
+ ${bits_srcdir}/version.h
# Here are the rules for building the headers
all-local: ${allstamped} ${allcreated}
@@ -1463,6 +1465,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
-mkdir -p ${pch3_output_builddir}
$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+# AutoGen <bits/version.h>.
+${bits_srcdir}/version.h: ${bits_srcdir}/version.def \
+ ${bits_srcdir}/version.tpl
+ cd $(@D) && \
+ autogen version.def
+
# The real deal.
install-data-local: install-headers
install-headers:
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 0ff875b280b..f5b04d3fe8a 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -509,6 +509,7 @@ bits_freestanding = \
${bits_srcdir}/stl_raw_storage_iter.h \
${bits_srcdir}/stl_relops.h \
${bits_srcdir}/stl_uninitialized.h \
+ ${bits_srcdir}/version.h \
${bits_srcdir}/string_view.tcc \
${bits_srcdir}/uniform_int_dist.h \
${bits_srcdir}/unique_ptr.h \
@@ -1441,7 +1442,8 @@ allcreated = \
${host_builddir}/c++config.h \
${host_builddir}/largefile-config.h \
${thread_host_headers} \
- ${pch_build}
+ ${pch_build} \
+ ${bits_srcdir}/version.h
# Host includes for threads
@@ -1937,6 +1939,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
-mkdir -p ${pch3_output_builddir}
$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+# AutoGen <bits/version.h>.
+${bits_srcdir}/version.h: ${bits_srcdir}/version.def \
+ ${bits_srcdir}/version.tpl
+ cd $(@D) && \
+ autogen version.def
+
# The real deal.
install-data-local: install-headers
install-headers:
diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def
new file mode 100644
index 00000000000..afdec9acfe3
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.def
@@ -0,0 +1,1591 @@
+// Feature test macro definitions -*- C++ -*-
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+AutoGen Definitions version.tpl;
+
+// The top level variable ftms is an array of feature test macros. Each entry
+// consists of a structure like following:
+
+// Schema:
+// ftms = {
+// name = FTM NAME;
+// [stdname = FTM STANDARD MACRO NAME;]
+// values = {
+// v = VALUE FOR FTM IF MATCHING;
+// [extra_cond = STRING;]
+// [cxxmin = NUMBER;]
+// [gnuxxmin = NUMBER;]
+// [gthread = yes|no;]
+// [hosted = yes|no;]
+// [cxx11abi = yes|no;]
+// }; ...
+// };
+
+// The elements in square brackets are optional. These are formulated into a
+// logical expression like:
+// ((strict && c++ >= cxxmin) || (!strict && c++ >= gnuxxmin))
+// && (gthr <=> gthread)
+// && (host <=> hosted)
+// && (cxx11 <=> cxx11abi)
+// && (extra_cond)
+// Where gthr, cxx11 and host are _GLIBCXX_HAS_GTHREADS, _GLIBCXX_USE_CXX11_ABI
+// and _GLIBCXX_HOSTED respectively. If any of these are omitted, their
+// sub-expressions are equivalent to the identity. Specially, if gnuxxmin is
+// omitted, it is taken to be the value of cxxmin, and so, only if both are
+// omitted, the clause is omitted.
+
+// stdname configures the name of the *standard* macro emitted, i.e. it
+// replaces only the __cpp_lib_ macro in the emitted definition. Defaults to
+// __cpp_lib_${name}
+
+// N.B This list needs to be in topological sort order, as later entries in
+// this list can and do use the earlier entries.
+
+ftms = {
+ name = incomplete_container_elements;
+ values = {
+ v = 201505;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = uncaught_exceptions;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ gnuxxmin = 03;
+ };
+};
+
+ftms = {
+ name = allocator_traits_is_always_equal;
+ values = {
+ v = 201411;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = is_null_pointer;
+ values = {
+ v = 201309;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = result_of_sfinae;
+ values = {
+ v = 201210;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = shared_ptr_arrays;
+ values = {
+ v = 201707;
+ cxxmin = 20;
+ hosted = yes;
+ };
+ values = {
+ v = 201611;
+ cxxmin = 11;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = is_swappable;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ };
+};
+
+ftms = {
+ name = void_t;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ };
+};
+
+ftms = {
+ name = enable_shared_from_this;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = math_spec_funcs;
+ stdname = "__STDCPP_MATH_SPEC_FUNCS__";
+ values = {
+ v = 201003;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = coroutine;
+ values = {
+ v = 201902;
+ // It is very likely that earlier versions would work, but they are
+ // untested.
+ cxxmin = 14;
+ extra_cond = "__cpp_impl_coroutine";
+ };
+};
+
+ftms = {
+ name = exchange_function;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = integer_sequence;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = integral_constant_callable;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = is_final;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = make_reverse_iterator;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = null_iterators;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ extra_cond = "!defined(_GLIBCXX_DEBUG)";
+ };
+};
+
+ftms = {
+ name = transformation_trait_aliases;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = transparent_operators;
+ values = {
+ v = 201510;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = tuple_element_t;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = tuples_by_type;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = robust_nonmodifying_seq_ops;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = to_chars;
+ values = {
+ v = 201611;
+ cxxmin = 14;
+ extra_cond = "_GLIBCXX_FLOAT_IS_IEEE_BINARY32 "
+ "&& _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 "
+ "&& __SIZE_WIDTH__ >= 32";
+ };
+};
+
+ftms = {
+ name = chrono_udls;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = complex_udls;
+ values = {
+ v = 201309;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = generic_associative_lookup;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = make_unique;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = quoted_string_io;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = shared_timed_mutex;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = string_udls;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = addressof_constexpr;
+ values = {
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2296. std::addressof should be constexpr
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = any;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = apply;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = as_const;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = atomic_is_always_lock_free;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = bool_constant;
+ values = {
+ v = 201505;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = byte;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = has_unique_object_representations;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP)";
+ };
+};
+
+ftms = {
+ name = hardware_interference_size;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ extra_cond = "defined(__GCC_DESTRUCTIVE_SIZE)";
+ };
+};
+
+ftms = {
+ name = invoke;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = is_aggregate;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE)";
+ };
+};
+
+ftms = {
+ name = is_invocable;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = launder;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER)";
+ };
+};
+
+ftms = {
+ name = logical_traits;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = make_from_tuple;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = not_fn;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = type_trait_variable_templates;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = variant;
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L";
+ };
+ values = {
+ v = 202102;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ // Used in earlier draft of SD6.
+ name = lcm;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ // Used in earlier draft of SD6.
+ name = gcd;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = gcd_lcm;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = raw_memory_algorithms;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = array_constexpr;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+ values = {
+ v = 201803;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = nonmember_container_access;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = clamp;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = sample;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = boyer_moore_searcher;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = chrono;
+ values = {
+ v = 201611;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = execution;
+ values = {
+ v = 201902; // FIXME: should be 201603L
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = filesystem;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = hypot;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = map_try_emplace;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = math_special_functions;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = memory_resource;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+ values = {
+ v = 1;
+ /* For when there's no gthread. */
+ cxxmin = 17;
+ hosted = yes;
+ gthread = no;
+ };
+};
+
+ftms = {
+ name = node_extract;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = parallel_algorithm;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = scoped_lock;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = shared_mutex;
+ values = {
+ v = 201505;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = shared_ptr_weak_type;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = string_view;
+ values = {
+ v = 201803;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = unordered_map_try_emplace;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = assume_aligned;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_flag_test;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_float;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_lock_free_type_aliases;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_ref;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_value_initialization;
+ values = {
+ v = 201911;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bind_front;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = starts_ends_with;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bit_cast;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__builtin_bit_cast)";
+ };
+};
+
+ftms = {
+ name = bitops;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bounded_array_traits;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = concepts;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts >= 201907L";
+ };
+};
+
+// Moved down here (after concepts) by topological sort.
+ftms = {
+ name = optional;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ extra_cond = "__glibcxx_concepts";
+ };
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ };
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = destroying_delete;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ extra_cond = "__cpp_impl_destroying_delete";
+ };
+};
+
+ftms = {
+ name = constexpr_string_view;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = endian;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = int_pow2;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = integer_comparison_functions;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = is_constant_evaluated;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)";
+ };
+};
+
+// Moved down here (after is_constant_evaluated) by topological sort.
+ftms = {
+ name = constexpr_char_traits;
+ values = {
+ // Unofficial macro indicating P1032R1 support in C++20
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ // Unofficial macro indicating P0426R1 support in C++17
+ v = 201611;
+ cxxmin = 17;
+ extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED";
+ };
+};
+
+ftms = {
+ name = is_layout_compatible;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__is_layout_compatible) "
+ "&& __has_builtin(__builtin_is_corresponding_member)";
+ };
+};
+
+ftms = {
+ name = is_nothrow_convertible;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = is_pointer_interconvertible;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond =
+ "__has_builtin(__is_pointer_interconvertible_base_of) "
+ "&& __has_builtin(__builtin_is_pointer_interconvertible_with_class)";
+ };
+};
+
+ftms = {
+ name = math_constants;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = make_obj_using_allocator;
+ values = {
+ // Not specified by C++20, used internally
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts";
+ };
+};
+
+ftms = {
+ name = remove_cvref;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = source_location;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__builtin_source_location)";
+ };
+};
+
+ftms = {
+ name = span;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = ssize;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = three_way_comparison;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__cpp_impl_three_way_comparison >= 201907L "
+ "&& __glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = to_address;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = to_array;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = type_identity;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = unwrap_ref;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_iterator;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = interpolate;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_utility;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = shift;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = ranges;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ extra_cond = "__glibcxx_concepts";
+ };
+ values = {
+ v = 202110;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = constexpr_numeric;
+ values = {
+ v = 201911;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_functional;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_algorithms;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_tuple;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_memory;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ extra_cond = "__cpp_constexpr_dynamic_alloc";
+ };
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_shared_ptr;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = atomic_wait;
+ // atomic_wait is available if either futexes or gthread are.
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ gthread = yes;
+ };
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ gthread = no;
+ extra_cond = "defined(_GLIBCXX_HAVE_LINUX_FUTEX)";
+ };
+};
+
+ftms = {
+ name = barrier;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ // This condition carries in the hosted&&(futex||gthread) logic from above.
+ extra_cond = "__cpp_aligned_new && __glibcxx_atomic_wait";
+ };
+};
+
+ftms = {
+ // 201907 Text Formatting, Integration of chrono, printf corner cases.
+ // 202106 std::format improvements.
+ // 202110 Fixing locale handling in chrono formatters, generator-like types.
+ // 202207 Encodings in localized formatting of chrono, basic-format-string.
+ // 202207 P2286R8 Formatting Ranges
+ // 202207 P2585R1 Improving default container formatting
+ // TODO: #define __cpp_lib_format_ranges 202207L
+ name = format;
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+// #undef __glibcxx_chrono
+// #define __glibcxx_chrono 201907L
+// FIXME: #define __glibcxx_execution 201902L
+
+ftms = {
+ name = constexpr_complex;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = constexpr_dynamic_alloc;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = constexpr_string;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = yes;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = no;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ v = 201611;
+ cxxmin = 17;
+ hosted = yes;
+ extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED";
+ };
+};
+
+ftms = {
+ name = constexpr_vector;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = erase_if;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = generic_unordered_lookup;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = jthread;
+ values = {
+ v = 201911;
+ gthread = yes;
+ hosted = yes;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = latch;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_atomic_wait";
+ };
+};
+
+ftms = {
+ name = list_remove_return_type;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = polymorphic_allocator;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = move_iterator_concept;
+ values = {
+ v = 202207;
+ // This is P2520R0, a C++23 change, but we treat it as a DR against C++20.
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = semaphore;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ extra_cond = "__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE";
+ };
+};
+
+ftms = {
+ name = smart_ptr_for_overwrite;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = syncbuf;
+ values = {
+ v = 201803;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = yes;
+ };
+};
+
+ftms = {
+ name = byteswap;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_charconv;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_typeinfo;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = expected;
+ values = {
+ v = 202211;
+ cxxmin = 23;
+ extra_cond = "__cpp_concepts >= 202002L";
+ };
+};
+
+ftms = {
+ name = invoke_r;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = is_scoped_enum;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = reference_from_temporary;
+ values = {
+ v = 202202;
+ extra_cond =
+ "__has_builtin(__reference_constructs_from_temporary) "
+ "&& __has_builtin(__reference_converts_from_temporary)";
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = to_underlying;
+ values = {
+ v = 202102;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = unreachable;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_zip;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_chunk;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_slide;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_chunk_by;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_join_with;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_repeat;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_stride;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_cartesian_product;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_as_rvalue;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_as_const;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_enumerate;
+ values = {
+ v = 202302;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_fold;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_contains;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_iota;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_find_last;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_bitset;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "__cpp_constexpr_dynamic_alloc";
+ };
+};
+
+ftms = {
+ name = stdatomic_h;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = adaptor_iterator_pair_constructor;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = ios_noreplace;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = move_only_function;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = spanstream;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "__glibcxx_span";
+ };
+};
+
+ftms = {
+ name = stacktrace;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "_GLIBCXX_HAVE_STACKTRACE";
+ };
+};
+
+ftms = {
+ name = string_contains;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = string_resize_and_overwrite;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ hosted = yes;
+ cxx11abi = yes;
+ };
+};
+
+// Standard test specifications.
+stds[97] = ">= 199711L";
+stds[03] = ">= 199711L";
+stds[11] = ">= 201103L";
+stds[14] = ">= 201402L";
+stds[17] = ">= 201703L";
+stds[20] = ">= 202002L";
+stds[23] = "> 202002L"; // TODO: update when finalized
+
+// Local Variables:
+// compile-command: "autogen version.def"
+// End:
diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h
new file mode 100644
index 00000000000..a6a6d2cec42
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.h
@@ -0,0 +1,1937 @@
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+// DO NOT EDIT THIS FILE (version.h)
+//
+// It has been AutoGen-ed
+// From the definitions version.def
+// and the template file version.tpl
+
+/** @file bits/version.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{version}
+ */
+
+// Usage guide:
+//
+// In your usual header, do something like:
+//
+// #define __glibcxx_want_ranges
+// #define __glibcxx_want_concepts
+// #include <bits/version.h>
+//
+// This will generate the FTMs you named, and let you use them in your code as
+// if it was user code. All macros are also exposed under __glibcxx_NAME even
+// if unwanted, to permit bits and other FTMs to depend on them for condtional
+// computation without exposing extra FTMs to user code.
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+// from version.def line 65
+#if !defined(__cpp_lib_incomplete_container_elements)
+# if _GLIBCXX_HOSTED
+# define __glibcxx_incomplete_container_elements 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_incomplete_container_elements)
+# define __cpp_lib_incomplete_container_elements 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_incomplete_container_elements) && defined(__glibcxx_want_incomplete_container_elements) */
+#undef __glibcxx_want_incomplete_container_elements
+
+// from version.def line 73
+#if !defined(__cpp_lib_uncaught_exceptions)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 199711L))
+# define __glibcxx_uncaught_exceptions 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_uncaught_exceptions)
+# define __cpp_lib_uncaught_exceptions 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_uncaught_exceptions) && defined(__glibcxx_want_uncaught_exceptions) */
+#undef __glibcxx_want_uncaught_exceptions
+
+// from version.def line 82
+#if !defined(__cpp_lib_allocator_traits_is_always_equal)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_allocator_traits_is_always_equal 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_allocator_traits_is_always_equal)
+# define __cpp_lib_allocator_traits_is_always_equal 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_allocator_traits_is_always_equal) && defined(__glibcxx_want_allocator_traits_is_always_equal) */
+#undef __glibcxx_want_allocator_traits_is_always_equal
+
+// from version.def line 90
+#if !defined(__cpp_lib_is_null_pointer)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_is_null_pointer 201309L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_null_pointer)
+# define __cpp_lib_is_null_pointer 201309L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_null_pointer) && defined(__glibcxx_want_is_null_pointer) */
+#undef __glibcxx_want_is_null_pointer
+
+// from version.def line 98
+#if !defined(__cpp_lib_result_of_sfinae)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_result_of_sfinae 201210L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_result_of_sfinae)
+# define __cpp_lib_result_of_sfinae 201210L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_result_of_sfinae) && defined(__glibcxx_want_result_of_sfinae) */
+#undef __glibcxx_want_result_of_sfinae
+
+// from version.def line 106
+#if !defined(__cpp_lib_shared_ptr_arrays)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_arrays 201707L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays)
+# define __cpp_lib_shared_ptr_arrays 201707L
+# endif
+# elif (__cplusplus >= 201103L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_arrays 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays)
+# define __cpp_lib_shared_ptr_arrays 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_ptr_arrays) && defined(__glibcxx_want_shared_ptr_arrays) */
+#undef __glibcxx_want_shared_ptr_arrays
+
+// from version.def line 120
+#if !defined(__cpp_lib_is_swappable)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L))
+# define __glibcxx_is_swappable 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_swappable)
+# define __cpp_lib_is_swappable 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_swappable) && defined(__glibcxx_want_is_swappable) */
+#undef __glibcxx_want_is_swappable
+
+// from version.def line 129
+#if !defined(__cpp_lib_void_t)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L))
+# define __glibcxx_void_t 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_void_t)
+# define __cpp_lib_void_t 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_void_t) && defined(__glibcxx_want_void_t) */
+#undef __glibcxx_want_void_t
+
+// from version.def line 138
+#if !defined(__cpp_lib_enable_shared_from_this)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L)) && _GLIBCXX_HOSTED
+# define __glibcxx_enable_shared_from_this 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_enable_shared_from_this)
+# define __cpp_lib_enable_shared_from_this 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_enable_shared_from_this) && defined(__glibcxx_want_enable_shared_from_this) */
+#undef __glibcxx_want_enable_shared_from_this
+
+// from version.def line 148
+#if !defined(__cpp_lib_math_spec_funcs)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_math_spec_funcs 201003L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_spec_funcs)
+# define __STDCPP_MATH_SPEC_FUNCS__ 201003L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_spec_funcs) && defined(__glibcxx_want_math_spec_funcs) */
+#undef __glibcxx_want_math_spec_funcs
+
+// from version.def line 157
+#if !defined(__cpp_lib_coroutine)
+# if (__cplusplus >= 201402L) && (__cpp_impl_coroutine)
+# define __glibcxx_coroutine 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_coroutine)
+# define __cpp_lib_coroutine 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_coroutine) && defined(__glibcxx_want_coroutine) */
+#undef __glibcxx_want_coroutine
+
+// from version.def line 168
+#if !defined(__cpp_lib_exchange_function)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_exchange_function 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_exchange_function)
+# define __cpp_lib_exchange_function 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_exchange_function) && defined(__glibcxx_want_exchange_function) */
+#undef __glibcxx_want_exchange_function
+
+// from version.def line 176
+#if !defined(__cpp_lib_integer_sequence)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_integer_sequence 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_sequence)
+# define __cpp_lib_integer_sequence 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integer_sequence) && defined(__glibcxx_want_integer_sequence) */
+#undef __glibcxx_want_integer_sequence
+
+// from version.def line 184
+#if !defined(__cpp_lib_integral_constant_callable)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_integral_constant_callable 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integral_constant_callable)
+# define __cpp_lib_integral_constant_callable 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integral_constant_callable) && defined(__glibcxx_want_integral_constant_callable) */
+#undef __glibcxx_want_integral_constant_callable
+
+// from version.def line 192
+#if !defined(__cpp_lib_is_final)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_is_final 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_final)
+# define __cpp_lib_is_final 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_final) && defined(__glibcxx_want_is_final) */
+#undef __glibcxx_want_is_final
+
+// from version.def line 200
+#if !defined(__cpp_lib_make_reverse_iterator)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_make_reverse_iterator 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_reverse_iterator)
+# define __cpp_lib_make_reverse_iterator 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_reverse_iterator) && defined(__glibcxx_want_make_reverse_iterator) */
+#undef __glibcxx_want_make_reverse_iterator
+
+// from version.def line 208
+#if !defined(__cpp_lib_null_iterators)
+# if (__cplusplus >= 201402L) && (!defined(_GLIBCXX_DEBUG))
+# define __glibcxx_null_iterators 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_null_iterators)
+# define __cpp_lib_null_iterators 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_null_iterators) && defined(__glibcxx_want_null_iterators) */
+#undef __glibcxx_want_null_iterators
+
+// from version.def line 217
+#if !defined(__cpp_lib_transformation_trait_aliases)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_transformation_trait_aliases 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transformation_trait_aliases)
+# define __cpp_lib_transformation_trait_aliases 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_transformation_trait_aliases) && defined(__glibcxx_want_transformation_trait_aliases) */
+#undef __glibcxx_want_transformation_trait_aliases
+
+// from version.def line 225
+#if !defined(__cpp_lib_transparent_operators)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_transparent_operators 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transparent_operators)
+# define __cpp_lib_transparent_operators 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_transparent_operators) && defined(__glibcxx_want_transparent_operators) */
+#undef __glibcxx_want_transparent_operators
+
+// from version.def line 233
+#if !defined(__cpp_lib_tuple_element_t)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_tuple_element_t 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuple_element_t)
+# define __cpp_lib_tuple_element_t 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_tuple_element_t) && defined(__glibcxx_want_tuple_element_t) */
+#undef __glibcxx_want_tuple_element_t
+
+// from version.def line 241
+#if !defined(__cpp_lib_tuples_by_type)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_tuples_by_type 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuples_by_type)
+# define __cpp_lib_tuples_by_type 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_tuples_by_type) && defined(__glibcxx_want_tuples_by_type) */
+#undef __glibcxx_want_tuples_by_type
+
+// from version.def line 249
+#if !defined(__cpp_lib_robust_nonmodifying_seq_ops)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_robust_nonmodifying_seq_ops 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_robust_nonmodifying_seq_ops)
+# define __cpp_lib_robust_nonmodifying_seq_ops 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_robust_nonmodifying_seq_ops) && defined(__glibcxx_want_robust_nonmodifying_seq_ops) */
+#undef __glibcxx_want_robust_nonmodifying_seq_ops
+
+// from version.def line 257
+#if !defined(__cpp_lib_to_chars)
+# if (__cplusplus >= 201402L) && (_GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 && __SIZE_WIDTH__ >= 32)
+# define __glibcxx_to_chars 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_chars)
+# define __cpp_lib_to_chars 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_chars) && defined(__glibcxx_want_to_chars) */
+#undef __glibcxx_want_to_chars
+
+// from version.def line 268
+#if !defined(__cpp_lib_chrono_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_chrono_udls 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono_udls)
+# define __cpp_lib_chrono_udls 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_chrono_udls) && defined(__glibcxx_want_chrono_udls) */
+#undef __glibcxx_want_chrono_udls
+
+// from version.def line 277
+#if !defined(__cpp_lib_complex_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_complex_udls 201309L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_complex_udls)
+# define __cpp_lib_complex_udls 201309L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_complex_udls) && defined(__glibcxx_want_complex_udls) */
+#undef __glibcxx_want_complex_udls
+
+// from version.def line 286
+#if !defined(__cpp_lib_generic_associative_lookup)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_generic_associative_lookup 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_associative_lookup)
+# define __cpp_lib_generic_associative_lookup 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_generic_associative_lookup) && defined(__glibcxx_want_generic_associative_lookup) */
+#undef __glibcxx_want_generic_associative_lookup
+
+// from version.def line 295
+#if !defined(__cpp_lib_make_unique)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_make_unique 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_unique)
+# define __cpp_lib_make_unique 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_unique) && defined(__glibcxx_want_make_unique) */
+#undef __glibcxx_want_make_unique
+
+// from version.def line 304
+#if !defined(__cpp_lib_quoted_string_io)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_quoted_string_io 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_quoted_string_io)
+# define __cpp_lib_quoted_string_io 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_quoted_string_io) && defined(__glibcxx_want_quoted_string_io) */
+#undef __glibcxx_want_quoted_string_io
+
+// from version.def line 313
+#if !defined(__cpp_lib_shared_timed_mutex)
+# if (__cplusplus >= 201402L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_timed_mutex 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_timed_mutex)
+# define __cpp_lib_shared_timed_mutex 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_timed_mutex) && defined(__glibcxx_want_shared_timed_mutex) */
+#undef __glibcxx_want_shared_timed_mutex
+
+// from version.def line 323
+#if !defined(__cpp_lib_string_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_udls 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_udls)
+# define __cpp_lib_string_udls 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_udls) && defined(__glibcxx_want_string_udls) */
+#undef __glibcxx_want_string_udls
+
+// from version.def line 332
+#if !defined(__cpp_lib_addressof_constexpr)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_addressof_constexpr 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_addressof_constexpr)
+# define __cpp_lib_addressof_constexpr 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_addressof_constexpr) && defined(__glibcxx_want_addressof_constexpr) */
+#undef __glibcxx_want_addressof_constexpr
+
+// from version.def line 342
+#if !defined(__cpp_lib_any)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_any 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_any)
+# define __cpp_lib_any 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_any) && defined(__glibcxx_want_any) */
+#undef __glibcxx_want_any
+
+// from version.def line 350
+#if !defined(__cpp_lib_apply)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_apply 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_apply)
+# define __cpp_lib_apply 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_apply) && defined(__glibcxx_want_apply) */
+#undef __glibcxx_want_apply
+
+// from version.def line 358
+#if !defined(__cpp_lib_as_const)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_as_const 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_as_const)
+# define __cpp_lib_as_const 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_as_const) && defined(__glibcxx_want_as_const) */
+#undef __glibcxx_want_as_const
+
+// from version.def line 366
+#if !defined(__cpp_lib_atomic_is_always_lock_free)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_atomic_is_always_lock_free 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_is_always_lock_free)
+# define __cpp_lib_atomic_is_always_lock_free 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_is_always_lock_free) && defined(__glibcxx_want_atomic_is_always_lock_free) */
+#undef __glibcxx_want_atomic_is_always_lock_free
+
+// from version.def line 374
+#if !defined(__cpp_lib_bool_constant)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_bool_constant 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bool_constant)
+# define __cpp_lib_bool_constant 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bool_constant) && defined(__glibcxx_want_bool_constant) */
+#undef __glibcxx_want_bool_constant
+
+// from version.def line 382
+#if !defined(__cpp_lib_byte)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_byte 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byte)
+# define __cpp_lib_byte 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_byte) && defined(__glibcxx_want_byte) */
+#undef __glibcxx_want_byte
+
+// from version.def line 390
+#if !defined(__cpp_lib_has_unique_object_representations)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP))
+# define __glibcxx_has_unique_object_representations 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_has_unique_object_representations)
+# define __cpp_lib_has_unique_object_representations 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_has_unique_object_representations) && defined(__glibcxx_want_has_unique_object_representations) */
+#undef __glibcxx_want_has_unique_object_representations
+
+// from version.def line 399
+#if !defined(__cpp_lib_hardware_interference_size)
+# if (__cplusplus >= 201703L) && (defined(__GCC_DESTRUCTIVE_SIZE))
+# define __glibcxx_hardware_interference_size 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hardware_interference_size)
+# define __cpp_lib_hardware_interference_size 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_hardware_interference_size) && defined(__glibcxx_want_hardware_interference_size) */
+#undef __glibcxx_want_hardware_interference_size
+
+// from version.def line 408
+#if !defined(__cpp_lib_invoke)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_invoke 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke)
+# define __cpp_lib_invoke 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_invoke) && defined(__glibcxx_want_invoke) */
+#undef __glibcxx_want_invoke
+
+// from version.def line 416
+#if !defined(__cpp_lib_is_aggregate)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE))
+# define __glibcxx_is_aggregate 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_aggregate)
+# define __cpp_lib_is_aggregate 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_aggregate) && defined(__glibcxx_want_is_aggregate) */
+#undef __glibcxx_want_is_aggregate
+
+// from version.def line 425
+#if !defined(__cpp_lib_is_invocable)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_is_invocable 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_invocable)
+# define __cpp_lib_is_invocable 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_invocable) && defined(__glibcxx_want_is_invocable) */
+#undef __glibcxx_want_is_invocable
+
+// from version.def line 433
+#if !defined(__cpp_lib_launder)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER))
+# define __glibcxx_launder 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_launder)
+# define __cpp_lib_launder 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_launder) && defined(__glibcxx_want_launder) */
+#undef __glibcxx_want_launder
+
+// from version.def line 442
+#if !defined(__cpp_lib_logical_traits)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_logical_traits 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_logical_traits)
+# define __cpp_lib_logical_traits 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_logical_traits) && defined(__glibcxx_want_logical_traits) */
+#undef __glibcxx_want_logical_traits
+
+// from version.def line 450
+#if !defined(__cpp_lib_make_from_tuple)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_make_from_tuple 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_from_tuple)
+# define __cpp_lib_make_from_tuple 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_from_tuple) && defined(__glibcxx_want_make_from_tuple) */
+#undef __glibcxx_want_make_from_tuple
+
+// from version.def line 458
+#if !defined(__cpp_lib_not_fn)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_not_fn 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_not_fn)
+# define __cpp_lib_not_fn 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_not_fn) && defined(__glibcxx_want_not_fn) */
+#undef __glibcxx_want_not_fn
+
+// from version.def line 466
+#if !defined(__cpp_lib_type_trait_variable_templates)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_type_trait_variable_templates 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_trait_variable_templates)
+# define __cpp_lib_type_trait_variable_templates 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_type_trait_variable_templates) && defined(__glibcxx_want_type_trait_variable_templates) */
+#undef __glibcxx_want_type_trait_variable_templates
+
+// from version.def line 474
+#if !defined(__cpp_lib_variant)
+# if (__cplusplus >= 202002L) && (__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L)
+# define __glibcxx_variant 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant)
+# define __cpp_lib_variant 202106L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_variant 202102L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant)
+# define __cpp_lib_variant 202102L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_variant) && defined(__glibcxx_want_variant) */
+#undef __glibcxx_want_variant
+
+// from version.def line 488
+#if !defined(__cpp_lib_lcm)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_lcm 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_lcm)
+# define __cpp_lib_lcm 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_lcm) && defined(__glibcxx_want_lcm) */
+#undef __glibcxx_want_lcm
+
+// from version.def line 497
+#if !defined(__cpp_lib_gcd)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_gcd 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd)
+# define __cpp_lib_gcd 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_gcd) && defined(__glibcxx_want_gcd) */
+#undef __glibcxx_want_gcd
+
+// from version.def line 505
+#if !defined(__cpp_lib_gcd_lcm)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_gcd_lcm 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd_lcm)
+# define __cpp_lib_gcd_lcm 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_gcd_lcm) && defined(__glibcxx_want_gcd_lcm) */
+#undef __glibcxx_want_gcd_lcm
+
+// from version.def line 513
+#if !defined(__cpp_lib_raw_memory_algorithms)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_raw_memory_algorithms 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_raw_memory_algorithms)
+# define __cpp_lib_raw_memory_algorithms 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_raw_memory_algorithms) && defined(__glibcxx_want_raw_memory_algorithms) */
+#undef __glibcxx_want_raw_memory_algorithms
+
+// from version.def line 521
+#if !defined(__cpp_lib_array_constexpr)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_array_constexpr 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr)
+# define __cpp_lib_array_constexpr 201811L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_array_constexpr 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr)
+# define __cpp_lib_array_constexpr 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_array_constexpr) && defined(__glibcxx_want_array_constexpr) */
+#undef __glibcxx_want_array_constexpr
+
+// from version.def line 533
+#if !defined(__cpp_lib_nonmember_container_access)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_nonmember_container_access 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_nonmember_container_access)
+# define __cpp_lib_nonmember_container_access 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_nonmember_container_access) && defined(__glibcxx_want_nonmember_container_access) */
+#undef __glibcxx_want_nonmember_container_access
+
+// from version.def line 541
+#if !defined(__cpp_lib_clamp)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_clamp 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_clamp)
+# define __cpp_lib_clamp 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_clamp) && defined(__glibcxx_want_clamp) */
+#undef __glibcxx_want_clamp
+
+// from version.def line 549
+#if !defined(__cpp_lib_sample)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_sample 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_sample)
+# define __cpp_lib_sample 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_sample) && defined(__glibcxx_want_sample) */
+#undef __glibcxx_want_sample
+
+// from version.def line 557
+#if !defined(__cpp_lib_boyer_moore_searcher)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_boyer_moore_searcher 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_boyer_moore_searcher)
+# define __cpp_lib_boyer_moore_searcher 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_boyer_moore_searcher) && defined(__glibcxx_want_boyer_moore_searcher) */
+#undef __glibcxx_want_boyer_moore_searcher
+
+// from version.def line 566
+#if !defined(__cpp_lib_chrono)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_chrono 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono)
+# define __cpp_lib_chrono 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_chrono) && defined(__glibcxx_want_chrono) */
+#undef __glibcxx_want_chrono
+
+// from version.def line 575
+#if !defined(__cpp_lib_execution)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_execution 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_execution)
+# define __cpp_lib_execution 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_execution) && defined(__glibcxx_want_execution) */
+#undef __glibcxx_want_execution
+
+// from version.def line 584
+#if !defined(__cpp_lib_filesystem)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_filesystem 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_filesystem)
+# define __cpp_lib_filesystem 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_filesystem) && defined(__glibcxx_want_filesystem) */
+#undef __glibcxx_want_filesystem
+
+// from version.def line 593
+#if !defined(__cpp_lib_hypot)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_hypot 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hypot)
+# define __cpp_lib_hypot 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_hypot) && defined(__glibcxx_want_hypot) */
+#undef __glibcxx_want_hypot
+
+// from version.def line 602
+#if !defined(__cpp_lib_map_try_emplace)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_map_try_emplace 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_map_try_emplace)
+# define __cpp_lib_map_try_emplace 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_map_try_emplace) && defined(__glibcxx_want_map_try_emplace) */
+#undef __glibcxx_want_map_try_emplace
+
+// from version.def line 611
+#if !defined(__cpp_lib_math_special_functions)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_math_special_functions 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_special_functions)
+# define __cpp_lib_math_special_functions 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_special_functions) && defined(__glibcxx_want_math_special_functions) */
+#undef __glibcxx_want_math_special_functions
+
+// from version.def line 620
+#if !defined(__cpp_lib_memory_resource)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_memory_resource 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource)
+# define __cpp_lib_memory_resource 201603L
+# endif
+# elif (__cplusplus >= 201703L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_memory_resource 1L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource)
+# define __cpp_lib_memory_resource 1L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_memory_resource) && defined(__glibcxx_want_memory_resource) */
+#undef __glibcxx_want_memory_resource
+
+// from version.def line 637
+#if !defined(__cpp_lib_node_extract)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_node_extract 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_node_extract)
+# define __cpp_lib_node_extract 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_node_extract) && defined(__glibcxx_want_node_extract) */
+#undef __glibcxx_want_node_extract
+
+// from version.def line 646
+#if !defined(__cpp_lib_parallel_algorithm)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_parallel_algorithm 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_parallel_algorithm)
+# define __cpp_lib_parallel_algorithm 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_parallel_algorithm) && defined(__glibcxx_want_parallel_algorithm) */
+#undef __glibcxx_want_parallel_algorithm
+
+// from version.def line 655
+#if !defined(__cpp_lib_scoped_lock)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_scoped_lock 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_scoped_lock)
+# define __cpp_lib_scoped_lock 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_scoped_lock) && defined(__glibcxx_want_scoped_lock) */
+#undef __glibcxx_want_scoped_lock
+
+// from version.def line 665
+#if !defined(__cpp_lib_shared_mutex)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_mutex 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_mutex)
+# define __cpp_lib_shared_mutex 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_mutex) && defined(__glibcxx_want_shared_mutex) */
+#undef __glibcxx_want_shared_mutex
+
+// from version.def line 675
+#if !defined(__cpp_lib_shared_ptr_weak_type)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_weak_type 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_weak_type)
+# define __cpp_lib_shared_ptr_weak_type 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_ptr_weak_type) && defined(__glibcxx_want_shared_ptr_weak_type) */
+#undef __glibcxx_want_shared_ptr_weak_type
+
+// from version.def line 684
+#if !defined(__cpp_lib_string_view)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_view 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_view)
+# define __cpp_lib_string_view 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_view) && defined(__glibcxx_want_string_view) */
+#undef __glibcxx_want_string_view
+
+// from version.def line 693
+#if !defined(__cpp_lib_unordered_map_try_emplace)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_unordered_map_try_emplace 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unordered_map_try_emplace)
+# define __cpp_lib_unordered_map_try_emplace 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unordered_map_try_emplace) && defined(__glibcxx_want_unordered_map_try_emplace) */
+#undef __glibcxx_want_unordered_map_try_emplace
+
+// from version.def line 702
+#if !defined(__cpp_lib_assume_aligned)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_assume_aligned 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_assume_aligned)
+# define __cpp_lib_assume_aligned 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_assume_aligned) && defined(__glibcxx_want_assume_aligned) */
+#undef __glibcxx_want_assume_aligned
+
+// from version.def line 710
+#if !defined(__cpp_lib_atomic_flag_test)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_flag_test 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_flag_test)
+# define __cpp_lib_atomic_flag_test 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_flag_test) && defined(__glibcxx_want_atomic_flag_test) */
+#undef __glibcxx_want_atomic_flag_test
+
+// from version.def line 718
+#if !defined(__cpp_lib_atomic_float)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_float 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_float)
+# define __cpp_lib_atomic_float 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_float) && defined(__glibcxx_want_atomic_float) */
+#undef __glibcxx_want_atomic_float
+
+// from version.def line 726
+#if !defined(__cpp_lib_atomic_lock_free_type_aliases)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_lock_free_type_aliases 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_lock_free_type_aliases)
+# define __cpp_lib_atomic_lock_free_type_aliases 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_lock_free_type_aliases) && defined(__glibcxx_want_atomic_lock_free_type_aliases) */
+#undef __glibcxx_want_atomic_lock_free_type_aliases
+
+// from version.def line 734
+#if !defined(__cpp_lib_atomic_ref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_ref 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_ref)
+# define __cpp_lib_atomic_ref 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_ref) && defined(__glibcxx_want_atomic_ref) */
+#undef __glibcxx_want_atomic_ref
+
+// from version.def line 742
+#if !defined(__cpp_lib_atomic_value_initialization)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_value_initialization 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_value_initialization)
+# define __cpp_lib_atomic_value_initialization 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_value_initialization) && defined(__glibcxx_want_atomic_value_initialization) */
+#undef __glibcxx_want_atomic_value_initialization
+
+// from version.def line 750
+#if !defined(__cpp_lib_bind_front)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bind_front 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_front)
+# define __cpp_lib_bind_front 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bind_front) && defined(__glibcxx_want_bind_front) */
+#undef __glibcxx_want_bind_front
+
+// from version.def line 758
+#if !defined(__cpp_lib_starts_ends_with)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_starts_ends_with 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_starts_ends_with)
+# define __cpp_lib_starts_ends_with 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_starts_ends_with) && defined(__glibcxx_want_starts_ends_with) */
+#undef __glibcxx_want_starts_ends_with
+
+// from version.def line 766
+#if !defined(__cpp_lib_bit_cast)
+# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_bit_cast))
+# define __glibcxx_bit_cast 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bit_cast)
+# define __cpp_lib_bit_cast 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bit_cast) && defined(__glibcxx_want_bit_cast) */
+#undef __glibcxx_want_bit_cast
+
+// from version.def line 775
+#if !defined(__cpp_lib_bitops)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bitops 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bitops)
+# define __cpp_lib_bitops 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bitops) && defined(__glibcxx_want_bitops) */
+#undef __glibcxx_want_bitops
+
+// from version.def line 783
+#if !defined(__cpp_lib_bounded_array_traits)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bounded_array_traits 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bounded_array_traits)
+# define __cpp_lib_bounded_array_traits 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bounded_array_traits) && defined(__glibcxx_want_bounded_array_traits) */
+#undef __glibcxx_want_bounded_array_traits
+
+// from version.def line 791
+#if !defined(__cpp_lib_concepts)
+# if (__cplusplus >= 202002L) && (__cpp_concepts >= 201907L)
+# define __glibcxx_concepts 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_concepts)
+# define __cpp_lib_concepts 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_concepts) && defined(__glibcxx_want_concepts) */
+#undef __glibcxx_want_concepts
+
+// from version.def line 801
+#if !defined(__cpp_lib_optional)
+# if (__cplusplus > 202002L) && (__glibcxx_concepts)
+# define __glibcxx_optional 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 202110L
+# endif
+# elif (__cplusplus >= 202002L)
+# define __glibcxx_optional 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 202106L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_optional 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_optional) && defined(__glibcxx_want_optional) */
+#undef __glibcxx_want_optional
+
+// from version.def line 818
+#if !defined(__cpp_lib_destroying_delete)
+# if (__cplusplus >= 202002L) && (__cpp_impl_destroying_delete)
+# define __glibcxx_destroying_delete 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_destroying_delete)
+# define __cpp_lib_destroying_delete 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_destroying_delete) && defined(__glibcxx_want_destroying_delete) */
+#undef __glibcxx_want_destroying_delete
+
+// from version.def line 827
+#if !defined(__cpp_lib_constexpr_string_view)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_string_view 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string_view)
+# define __cpp_lib_constexpr_string_view 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_string_view) && defined(__glibcxx_want_constexpr_string_view) */
+#undef __glibcxx_want_constexpr_string_view
+
+// from version.def line 835
+#if !defined(__cpp_lib_endian)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_endian 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_endian)
+# define __cpp_lib_endian 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_endian) && defined(__glibcxx_want_endian) */
+#undef __glibcxx_want_endian
+
+// from version.def line 843
+#if !defined(__cpp_lib_int_pow2)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_int_pow2 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_int_pow2)
+# define __cpp_lib_int_pow2 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_int_pow2) && defined(__glibcxx_want_int_pow2) */
+#undef __glibcxx_want_int_pow2
+
+// from version.def line 851
+#if !defined(__cpp_lib_integer_comparison_functions)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_integer_comparison_functions 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_comparison_functions)
+# define __cpp_lib_integer_comparison_functions 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integer_comparison_functions) && defined(__glibcxx_want_integer_comparison_functions) */
+#undef __glibcxx_want_integer_comparison_functions
+
+// from version.def line 859
+#if !defined(__cpp_lib_is_constant_evaluated)
+# if (__cplusplus >= 202002L) && (defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED))
+# define __glibcxx_is_constant_evaluated 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_constant_evaluated)
+# define __cpp_lib_is_constant_evaluated 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_constant_evaluated) && defined(__glibcxx_want_is_constant_evaluated) */
+#undef __glibcxx_want_is_constant_evaluated
+
+// from version.def line 869
+#if !defined(__cpp_lib_constexpr_char_traits)
+# if (__cplusplus >= 202002L) && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_char_traits 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits)
+# define __cpp_lib_constexpr_char_traits 201811L
+# endif
+# elif (__cplusplus >= 201703L) && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)
+# define __glibcxx_constexpr_char_traits 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits)
+# define __cpp_lib_constexpr_char_traits 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_char_traits) && defined(__glibcxx_want_constexpr_char_traits) */
+#undef __glibcxx_want_constexpr_char_traits
+
+// from version.def line 885
+#if !defined(__cpp_lib_is_layout_compatible)
+# if (__cplusplus >= 202002L) && (__has_builtin(__is_layout_compatible) && __has_builtin(__builtin_is_corresponding_member))
+# define __glibcxx_is_layout_compatible 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_layout_compatible)
+# define __cpp_lib_is_layout_compatible 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_layout_compatible) && defined(__glibcxx_want_is_layout_compatible) */
+#undef __glibcxx_want_is_layout_compatible
+
+// from version.def line 895
+#if !defined(__cpp_lib_is_nothrow_convertible)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_is_nothrow_convertible 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_nothrow_convertible)
+# define __cpp_lib_is_nothrow_convertible 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_nothrow_convertible) && defined(__glibcxx_want_is_nothrow_convertible) */
+#undef __glibcxx_want_is_nothrow_convertible
+
+// from version.def line 903
+#if !defined(__cpp_lib_is_pointer_interconvertible)
+# if (__cplusplus >= 202002L) && (__has_builtin(__is_pointer_interconvertible_base_of) && __has_builtin(__builtin_is_pointer_interconvertible_with_class))
+# define __glibcxx_is_pointer_interconvertible 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_pointer_interconvertible)
+# define __cpp_lib_is_pointer_interconvertible 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_pointer_interconvertible) && defined(__glibcxx_want_is_pointer_interconvertible) */
+#undef __glibcxx_want_is_pointer_interconvertible
+
+// from version.def line 914
+#if !defined(__cpp_lib_math_constants)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_math_constants 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_constants)
+# define __cpp_lib_math_constants 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_constants) && defined(__glibcxx_want_math_constants) */
+#undef __glibcxx_want_math_constants
+
+// from version.def line 922
+#if !defined(__cpp_lib_make_obj_using_allocator)
+# if (__cplusplus >= 202002L) && (__cpp_concepts)
+# define __glibcxx_make_obj_using_allocator 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_obj_using_allocator)
+# define __cpp_lib_make_obj_using_allocator 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_obj_using_allocator) && defined(__glibcxx_want_make_obj_using_allocator) */
+#undef __glibcxx_want_make_obj_using_allocator
+
+// from version.def line 932
+#if !defined(__cpp_lib_remove_cvref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_remove_cvref 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_remove_cvref)
+# define __cpp_lib_remove_cvref 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_remove_cvref) && defined(__glibcxx_want_remove_cvref) */
+#undef __glibcxx_want_remove_cvref
+
+// from version.def line 940
+#if !defined(__cpp_lib_source_location)
+# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_source_location))
+# define __glibcxx_source_location 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_source_location)
+# define __cpp_lib_source_location 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_source_location) && defined(__glibcxx_want_source_location) */
+#undef __glibcxx_want_source_location
+
+// from version.def line 949
+#if !defined(__cpp_lib_span)
+# if (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_span 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_span)
+# define __cpp_lib_span 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_span) && defined(__glibcxx_want_span) */
+#undef __glibcxx_want_span
+
+// from version.def line 958
+#if !defined(__cpp_lib_ssize)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_ssize 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ssize)
+# define __cpp_lib_ssize 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ssize) && defined(__glibcxx_want_ssize) */
+#undef __glibcxx_want_ssize
+
+// from version.def line 966
+#if !defined(__cpp_lib_three_way_comparison)
+# if (__cplusplus >= 202002L) && (__cpp_impl_three_way_comparison >= 201907L && __glibcxx_concepts)
+# define __glibcxx_three_way_comparison 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_three_way_comparison)
+# define __cpp_lib_three_way_comparison 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_three_way_comparison) && defined(__glibcxx_want_three_way_comparison) */
+#undef __glibcxx_want_three_way_comparison
+
+// from version.def line 976
+#if !defined(__cpp_lib_to_address)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_to_address 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_address)
+# define __cpp_lib_to_address 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_address) && defined(__glibcxx_want_to_address) */
+#undef __glibcxx_want_to_address
+
+// from version.def line 984
+#if !defined(__cpp_lib_to_array)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_to_array 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_array)
+# define __cpp_lib_to_array 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_array) && defined(__glibcxx_want_to_array) */
+#undef __glibcxx_want_to_array
+
+// from version.def line 992
+#if !defined(__cpp_lib_type_identity)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_type_identity 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_identity)
+# define __cpp_lib_type_identity 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_type_identity) && defined(__glibcxx_want_type_identity) */
+#undef __glibcxx_want_type_identity
+
+// from version.def line 1000
+#if !defined(__cpp_lib_unwrap_ref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_unwrap_ref 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unwrap_ref)
+# define __cpp_lib_unwrap_ref 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unwrap_ref) && defined(__glibcxx_want_unwrap_ref) */
+#undef __glibcxx_want_unwrap_ref
+
+// from version.def line 1008
+#if !defined(__cpp_lib_constexpr_iterator)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_iterator 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_iterator)
+# define __cpp_lib_constexpr_iterator 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_iterator) && defined(__glibcxx_want_constexpr_iterator) */
+#undef __glibcxx_want_constexpr_iterator
+
+// from version.def line 1016
+#if !defined(__cpp_lib_interpolate)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_interpolate 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_interpolate)
+# define __cpp_lib_interpolate 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_interpolate) && defined(__glibcxx_want_interpolate) */
+#undef __glibcxx_want_interpolate
+
+// from version.def line 1024
+#if !defined(__cpp_lib_constexpr_utility)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_utility 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_utility)
+# define __cpp_lib_constexpr_utility 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_utility) && defined(__glibcxx_want_constexpr_utility) */
+#undef __glibcxx_want_constexpr_utility
+
+// from version.def line 1032
+#if !defined(__cpp_lib_shift)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_shift 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shift)
+# define __cpp_lib_shift 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shift) && defined(__glibcxx_want_shift) */
+#undef __glibcxx_want_shift
+
+// from version.def line 1040
+#if !defined(__cpp_lib_ranges)
+# if (__cplusplus > 202002L) && (__glibcxx_concepts)
+# define __glibcxx_ranges 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges)
+# define __cpp_lib_ranges 202202L
+# endif
+# elif (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_ranges 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges)
+# define __cpp_lib_ranges 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges) && defined(__glibcxx_want_ranges) */
+#undef __glibcxx_want_ranges
+
+// from version.def line 1054
+#if !defined(__cpp_lib_constexpr_numeric)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_numeric 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_numeric)
+# define __cpp_lib_constexpr_numeric 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_numeric) && defined(__glibcxx_want_constexpr_numeric) */
+#undef __glibcxx_want_constexpr_numeric
+
+// from version.def line 1062
+#if !defined(__cpp_lib_constexpr_functional)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_functional 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_functional)
+# define __cpp_lib_constexpr_functional 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_functional) && defined(__glibcxx_want_constexpr_functional) */
+#undef __glibcxx_want_constexpr_functional
+
+// from version.def line 1070
+#if !defined(__cpp_lib_constexpr_algorithms)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_algorithms 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_algorithms)
+# define __cpp_lib_constexpr_algorithms 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_algorithms) && defined(__glibcxx_want_constexpr_algorithms) */
+#undef __glibcxx_want_constexpr_algorithms
+
+// from version.def line 1078
+#if !defined(__cpp_lib_constexpr_tuple)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_tuple 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_tuple)
+# define __cpp_lib_constexpr_tuple 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_tuple) && defined(__glibcxx_want_constexpr_tuple) */
+#undef __glibcxx_want_constexpr_tuple
+
+// from version.def line 1086
+#if !defined(__cpp_lib_constexpr_memory)
+# if (__cplusplus > 202002L) && (__cpp_constexpr_dynamic_alloc)
+# define __glibcxx_constexpr_memory 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory)
+# define __cpp_lib_constexpr_memory 202202L
+# endif
+# elif (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_memory 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory)
+# define __cpp_lib_constexpr_memory 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_memory) && defined(__glibcxx_want_constexpr_memory) */
+#undef __glibcxx_want_constexpr_memory
+
+// from version.def line 1099
+#if !defined(__cpp_lib_atomic_shared_ptr)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_atomic_shared_ptr 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_shared_ptr)
+# define __cpp_lib_atomic_shared_ptr 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_shared_ptr) && defined(__glibcxx_want_atomic_shared_ptr) */
+#undef __glibcxx_want_atomic_shared_ptr
+
+// from version.def line 1108
+#if !defined(__cpp_lib_atomic_wait)
+# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_atomic_wait 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait)
+# define __cpp_lib_atomic_wait 201907L
+# endif
+# elif (__cplusplus >= 202002L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED && (defined(_GLIBCXX_HAVE_LINUX_FUTEX))
+# define __glibcxx_atomic_wait 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait)
+# define __cpp_lib_atomic_wait 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_wait) && defined(__glibcxx_want_atomic_wait) */
+#undef __glibcxx_want_atomic_wait
+
+// from version.def line 1126
+#if !defined(__cpp_lib_barrier)
+# if (__cplusplus >= 202002L) && (__cpp_aligned_new && __glibcxx_atomic_wait)
+# define __glibcxx_barrier 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_barrier)
+# define __cpp_lib_barrier 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_barrier) && defined(__glibcxx_want_barrier) */
+#undef __glibcxx_want_barrier
+
+// from version.def line 1143
+#if !defined(__cpp_lib_format)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_format 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_format)
+# define __cpp_lib_format 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_format) && defined(__glibcxx_want_format) */
+#undef __glibcxx_want_format
+
+// from version.def line 1156
+#if !defined(__cpp_lib_constexpr_complex)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_complex 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_complex)
+# define __cpp_lib_constexpr_complex 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_complex) && defined(__glibcxx_want_constexpr_complex) */
+#undef __glibcxx_want_constexpr_complex
+
+// from version.def line 1165
+#if !defined(__cpp_lib_constexpr_dynamic_alloc)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_dynamic_alloc 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_dynamic_alloc)
+# define __cpp_lib_constexpr_dynamic_alloc 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_dynamic_alloc) && defined(__glibcxx_want_constexpr_dynamic_alloc) */
+#undef __glibcxx_want_constexpr_dynamic_alloc
+
+// from version.def line 1174
+#if !defined(__cpp_lib_constexpr_string)
+# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_string 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201907L
+# endif
+# elif (__cplusplus >= 202002L) && !_GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_string 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201811L
+# endif
+# elif (__cplusplus >= 201703L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)
+# define __glibcxx_constexpr_string 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_string) && defined(__glibcxx_want_constexpr_string) */
+#undef __glibcxx_want_constexpr_string
+
+// from version.def line 1198
+#if !defined(__cpp_lib_constexpr_vector)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_vector 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_vector)
+# define __cpp_lib_constexpr_vector 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_vector) && defined(__glibcxx_want_constexpr_vector) */
+#undef __glibcxx_want_constexpr_vector
+
+// from version.def line 1207
+#if !defined(__cpp_lib_erase_if)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_erase_if 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_erase_if)
+# define __cpp_lib_erase_if 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_erase_if) && defined(__glibcxx_want_erase_if) */
+#undef __glibcxx_want_erase_if
+
+// from version.def line 1216
+#if !defined(__cpp_lib_generic_unordered_lookup)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_generic_unordered_lookup 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_unordered_lookup)
+# define __cpp_lib_generic_unordered_lookup 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_generic_unordered_lookup) && defined(__glibcxx_want_generic_unordered_lookup) */
+#undef __glibcxx_want_generic_unordered_lookup
+
+// from version.def line 1225
+#if !defined(__cpp_lib_jthread)
+# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_jthread 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_jthread)
+# define __cpp_lib_jthread 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_jthread) && defined(__glibcxx_want_jthread) */
+#undef __glibcxx_want_jthread
+
+// from version.def line 1235
+#if !defined(__cpp_lib_latch)
+# if (__cplusplus >= 202002L) && (__glibcxx_atomic_wait)
+# define __glibcxx_latch 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_latch)
+# define __cpp_lib_latch 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_latch) && defined(__glibcxx_want_latch) */
+#undef __glibcxx_want_latch
+
+// from version.def line 1244
+#if !defined(__cpp_lib_list_remove_return_type)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_list_remove_return_type 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_list_remove_return_type)
+# define __cpp_lib_list_remove_return_type 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_list_remove_return_type) && defined(__glibcxx_want_list_remove_return_type) */
+#undef __glibcxx_want_list_remove_return_type
+
+// from version.def line 1253
+#if !defined(__cpp_lib_polymorphic_allocator)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_polymorphic_allocator 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_polymorphic_allocator)
+# define __cpp_lib_polymorphic_allocator 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_polymorphic_allocator) && defined(__glibcxx_want_polymorphic_allocator) */
+#undef __glibcxx_want_polymorphic_allocator
+
+// from version.def line 1262
+#if !defined(__cpp_lib_move_iterator_concept)
+# if (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_move_iterator_concept 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_iterator_concept)
+# define __cpp_lib_move_iterator_concept 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_move_iterator_concept) && defined(__glibcxx_want_move_iterator_concept) */
+#undef __glibcxx_want_move_iterator_concept
+
+// from version.def line 1272
+#if !defined(__cpp_lib_semaphore)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED && (__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE)
+# define __glibcxx_semaphore 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_semaphore)
+# define __cpp_lib_semaphore 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_semaphore) && defined(__glibcxx_want_semaphore) */
+#undef __glibcxx_want_semaphore
+
+// from version.def line 1282
+#if !defined(__cpp_lib_smart_ptr_for_overwrite)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_smart_ptr_for_overwrite 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_smart_ptr_for_overwrite)
+# define __cpp_lib_smart_ptr_for_overwrite 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_smart_ptr_for_overwrite) && defined(__glibcxx_want_smart_ptr_for_overwrite) */
+#undef __glibcxx_want_smart_ptr_for_overwrite
+
+// from version.def line 1291
+#if !defined(__cpp_lib_syncbuf)
+# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED
+# define __glibcxx_syncbuf 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_syncbuf)
+# define __cpp_lib_syncbuf 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_syncbuf) && defined(__glibcxx_want_syncbuf) */
+#undef __glibcxx_want_syncbuf
+
+// from version.def line 1301
+#if !defined(__cpp_lib_byteswap)
+# if (__cplusplus > 202002L)
+# define __glibcxx_byteswap 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byteswap)
+# define __cpp_lib_byteswap 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_byteswap) && defined(__glibcxx_want_byteswap) */
+#undef __glibcxx_want_byteswap
+
+// from version.def line 1309
+#if !defined(__cpp_lib_constexpr_charconv)
+# if (__cplusplus > 202002L)
+# define __glibcxx_constexpr_charconv 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_charconv)
+# define __cpp_lib_constexpr_charconv 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_charconv) && defined(__glibcxx_want_constexpr_charconv) */
+#undef __glibcxx_want_constexpr_charconv
+
+// from version.def line 1317
+#if !defined(__cpp_lib_constexpr_typeinfo)
+# if (__cplusplus > 202002L)
+# define __glibcxx_constexpr_typeinfo 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_typeinfo)
+# define __cpp_lib_constexpr_typeinfo 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_typeinfo) && defined(__glibcxx_want_constexpr_typeinfo) */
+#undef __glibcxx_want_constexpr_typeinfo
+
+// from version.def line 1325
+#if !defined(__cpp_lib_expected)
+# if (__cplusplus > 202002L) && (__cpp_concepts >= 202002L)
+# define __glibcxx_expected 202211L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_expected)
+# define __cpp_lib_expected 202211L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_expected) && defined(__glibcxx_want_expected) */
+#undef __glibcxx_want_expected
+
+// from version.def line 1334
+#if !defined(__cpp_lib_invoke_r)
+# if (__cplusplus > 202002L)
+# define __glibcxx_invoke_r 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke_r)
+# define __cpp_lib_invoke_r 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_invoke_r) && defined(__glibcxx_want_invoke_r) */
+#undef __glibcxx_want_invoke_r
+
+// from version.def line 1342
+#if !defined(__cpp_lib_is_scoped_enum)
+# if (__cplusplus > 202002L)
+# define __glibcxx_is_scoped_enum 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_scoped_enum)
+# define __cpp_lib_is_scoped_enum 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_scoped_enum) && defined(__glibcxx_want_is_scoped_enum) */
+#undef __glibcxx_want_is_scoped_enum
+
+// from version.def line 1350
+#if !defined(__cpp_lib_reference_from_temporary)
+# if (__cplusplus > 202002L) && (__has_builtin(__reference_constructs_from_temporary) && __has_builtin(__reference_converts_from_temporary))
+# define __glibcxx_reference_from_temporary 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_reference_from_temporary)
+# define __cpp_lib_reference_from_temporary 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_reference_from_temporary) && defined(__glibcxx_want_reference_from_temporary) */
+#undef __glibcxx_want_reference_from_temporary
+
+// from version.def line 1361
+#if !defined(__cpp_lib_to_underlying)
+# if (__cplusplus > 202002L)
+# define __glibcxx_to_underlying 202102L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_underlying)
+# define __cpp_lib_to_underlying 202102L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_underlying) && defined(__glibcxx_want_to_underlying) */
+#undef __glibcxx_want_to_underlying
+
+// from version.def line 1369
+#if !defined(__cpp_lib_unreachable)
+# if (__cplusplus > 202002L)
+# define __glibcxx_unreachable 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unreachable)
+# define __cpp_lib_unreachable 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unreachable) && defined(__glibcxx_want_unreachable) */
+#undef __glibcxx_want_unreachable
+
+// from version.def line 1377
+#if !defined(__cpp_lib_ranges_zip)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_zip 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_zip)
+# define __cpp_lib_ranges_zip 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_zip) && defined(__glibcxx_want_ranges_zip) */
+#undef __glibcxx_want_ranges_zip
+
+// from version.def line 1385
+#if !defined(__cpp_lib_ranges_chunk)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_chunk 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk)
+# define __cpp_lib_ranges_chunk 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_chunk) && defined(__glibcxx_want_ranges_chunk) */
+#undef __glibcxx_want_ranges_chunk
+
+// from version.def line 1393
+#if !defined(__cpp_lib_ranges_slide)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_slide 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_slide)
+# define __cpp_lib_ranges_slide 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_slide) && defined(__glibcxx_want_ranges_slide) */
+#undef __glibcxx_want_ranges_slide
+
+// from version.def line 1401
+#if !defined(__cpp_lib_ranges_chunk_by)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_chunk_by 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk_by)
+# define __cpp_lib_ranges_chunk_by 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_chunk_by) && defined(__glibcxx_want_ranges_chunk_by) */
+#undef __glibcxx_want_ranges_chunk_by
+
+// from version.def line 1409
+#if !defined(__cpp_lib_ranges_join_with)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_join_with 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_join_with)
+# define __cpp_lib_ranges_join_with 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_join_with) && defined(__glibcxx_want_ranges_join_with) */
+#undef __glibcxx_want_ranges_join_with
+
+// from version.def line 1417
+#if !defined(__cpp_lib_ranges_repeat)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_repeat 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_repeat)
+# define __cpp_lib_ranges_repeat 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_repeat) && defined(__glibcxx_want_ranges_repeat) */
+#undef __glibcxx_want_ranges_repeat
+
+// from version.def line 1425
+#if !defined(__cpp_lib_ranges_stride)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_stride 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_stride)
+# define __cpp_lib_ranges_stride 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_stride) && defined(__glibcxx_want_ranges_stride) */
+#undef __glibcxx_want_ranges_stride
+
+// from version.def line 1433
+#if !defined(__cpp_lib_ranges_cartesian_product)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_cartesian_product 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_cartesian_product)
+# define __cpp_lib_ranges_cartesian_product 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_cartesian_product) && defined(__glibcxx_want_ranges_cartesian_product) */
+#undef __glibcxx_want_ranges_cartesian_product
+
+// from version.def line 1441
+#if !defined(__cpp_lib_ranges_as_rvalue)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_as_rvalue 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_rvalue)
+# define __cpp_lib_ranges_as_rvalue 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_as_rvalue) && defined(__glibcxx_want_ranges_as_rvalue) */
+#undef __glibcxx_want_ranges_as_rvalue
+
+// from version.def line 1449
+#if !defined(__cpp_lib_ranges_as_const)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_as_const 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_const)
+# define __cpp_lib_ranges_as_const 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_as_const) && defined(__glibcxx_want_ranges_as_const) */
+#undef __glibcxx_want_ranges_as_const
+
+// from version.def line 1457
+#if !defined(__cpp_lib_ranges_enumerate)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_enumerate 202302L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_enumerate)
+# define __cpp_lib_ranges_enumerate 202302L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_enumerate) && defined(__glibcxx_want_ranges_enumerate) */
+#undef __glibcxx_want_ranges_enumerate
+
+// from version.def line 1465
+#if !defined(__cpp_lib_ranges_fold)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_fold 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_fold)
+# define __cpp_lib_ranges_fold 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_fold) && defined(__glibcxx_want_ranges_fold) */
+#undef __glibcxx_want_ranges_fold
+
+// from version.def line 1473
+#if !defined(__cpp_lib_ranges_contains)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_contains 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_contains)
+# define __cpp_lib_ranges_contains 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_contains) && defined(__glibcxx_want_ranges_contains) */
+#undef __glibcxx_want_ranges_contains
+
+// from version.def line 1481
+#if !defined(__cpp_lib_ranges_iota)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_iota 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_iota)
+# define __cpp_lib_ranges_iota 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_iota) && defined(__glibcxx_want_ranges_iota) */
+#undef __glibcxx_want_ranges_iota
+
+// from version.def line 1489
+#if !defined(__cpp_lib_ranges_find_last)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_find_last 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_find_last)
+# define __cpp_lib_ranges_find_last 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_find_last) && defined(__glibcxx_want_ranges_find_last) */
+#undef __glibcxx_want_ranges_find_last
+
+// from version.def line 1497
+#if !defined(__cpp_lib_constexpr_bitset)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__cpp_constexpr_dynamic_alloc)
+# define __glibcxx_constexpr_bitset 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_bitset)
+# define __cpp_lib_constexpr_bitset 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_bitset) && defined(__glibcxx_want_constexpr_bitset) */
+#undef __glibcxx_want_constexpr_bitset
+
+// from version.def line 1507
+#if !defined(__cpp_lib_stdatomic_h)
+# if (__cplusplus > 202002L)
+# define __glibcxx_stdatomic_h 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stdatomic_h)
+# define __cpp_lib_stdatomic_h 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_stdatomic_h) && defined(__glibcxx_want_stdatomic_h) */
+#undef __glibcxx_want_stdatomic_h
+
+// from version.def line 1515
+#if !defined(__cpp_lib_adaptor_iterator_pair_constructor)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_adaptor_iterator_pair_constructor 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_adaptor_iterator_pair_constructor)
+# define __cpp_lib_adaptor_iterator_pair_constructor 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_adaptor_iterator_pair_constructor) && defined(__glibcxx_want_adaptor_iterator_pair_constructor) */
+#undef __glibcxx_want_adaptor_iterator_pair_constructor
+
+// from version.def line 1524
+#if !defined(__cpp_lib_ios_noreplace)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_ios_noreplace 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ios_noreplace)
+# define __cpp_lib_ios_noreplace 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ios_noreplace) && defined(__glibcxx_want_ios_noreplace) */
+#undef __glibcxx_want_ios_noreplace
+
+// from version.def line 1533
+#if !defined(__cpp_lib_move_only_function)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_move_only_function 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_only_function)
+# define __cpp_lib_move_only_function 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_move_only_function) && defined(__glibcxx_want_move_only_function) */
+#undef __glibcxx_want_move_only_function
+
+// from version.def line 1542
+#if !defined(__cpp_lib_spanstream)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__glibcxx_span)
+# define __glibcxx_spanstream 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_spanstream)
+# define __cpp_lib_spanstream 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_spanstream) && defined(__glibcxx_want_spanstream) */
+#undef __glibcxx_want_spanstream
+
+// from version.def line 1552
+#if !defined(__cpp_lib_stacktrace)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_STACKTRACE)
+# define __glibcxx_stacktrace 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stacktrace)
+# define __cpp_lib_stacktrace 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_stacktrace) && defined(__glibcxx_want_stacktrace) */
+#undef __glibcxx_want_stacktrace
+
+// from version.def line 1562
+#if !defined(__cpp_lib_string_contains)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_contains 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_contains)
+# define __cpp_lib_string_contains 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_contains) && defined(__glibcxx_want_string_contains) */
+#undef __glibcxx_want_string_contains
+
+// from version.def line 1571
+#if !defined(__cpp_lib_string_resize_and_overwrite)
+# if (__cplusplus > 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED
+# define __glibcxx_string_resize_and_overwrite 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_resize_and_overwrite)
+# define __cpp_lib_string_resize_and_overwrite 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_resize_and_overwrite) && defined(__glibcxx_want_string_resize_and_overwrite) */
+#undef __glibcxx_want_string_resize_and_overwrite
+
+#undef __glibcxx_want_all
diff --git a/libstdc++-v3/include/bits/version.tpl b/libstdc++-v3/include/bits/version.tpl
new file mode 100644
index 00000000000..98f0df6f793
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.tpl
@@ -0,0 +1,209 @@
+/*{ AutoGen5 template -*- C++ -*-
+h
+(use-modules (srfi srfi-1))
+}*/
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*{ (dne "// ") }*/
+
+/** @file bits/version.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{version}
+ */
+
+// Usage guide:
+//
+// In your usual header, do something like:
+//
+// #define __glibcxx_want_ranges
+// #define __glibcxx_want_concepts
+// #include <bits/version.h>
+//
+// This will generate the FTMs you named, and let you use them in your code as
+// if it was user code. All macros are also exposed under __glibcxx_NAME even
+// if unwanted, to permit bits and other FTMs to depend on them for condtional
+// computation without exposing extra FTMs to user code.
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+/*{
+
+;; Helper for dealing with autogens redefined (error)
+(define (ferror msg . args)
+ (error (apply format (cons* #f msg args))))
+
+;; Helper function that, in the context of a single FTM value, generates the
+;; condition expression that fulfills the specification of this value. See the
+;; comment block in version.def for an explanation of the format this
+;; function parses.
+(define (generate-cond)
+ (define c++min #f)
+ (define gnu++min #f)
+ (define gthread #f)
+ (define hosted #f)
+ (define c++11-abi #f)
+ (define extra-cond (get "extra_cond"))
+
+ (define conds '())
+ (define (prepend x)
+ (if x (set! conds (cons x conds))))
+
+ (if (string-null? extra-cond)
+ (set! extra-cond #f))
+
+ (let ((cxxmin (get "cxxmin"))
+ (gnuxxmin (get "gnuxxmin"))
+ (getstdcond
+ (lambda (var)
+ (let ((ver (get var)))
+ (if (not (string-null? ver))
+ (let ((std-cond (get (format #f "stds[~a]" ver))))
+ (if (string-null? std-cond)
+ (ferror "Standard ~s invalid." ver))
+ std-cond)
+ #f)))))
+ (set! c++min (getstdcond "cxxmin"))
+ (set! gnu++min (getstdcond "gnuxxmin")))
+
+ (let ((process-tristate
+ (lambda (name)
+ (let ((val (get name)))
+ (cond
+ ((equal? val "") #f) ; Don't test
+ ((equal? val "yes") "") ; Test directly
+ ((equal? val "no") "!") ; Invert
+ (else (ferror "Bad ~a value ~a." name val)))))))
+ (set! gthread (process-tristate "gthread"))
+ (set! c++11-abi (process-tristate "cxx11abi"))
+ (set! hosted (process-tristate "hosted")))
+
+ (prepend (if extra-cond (format #f "(~a)" extra-cond) #f))
+ (prepend (if hosted (format #f "~a~a" hosted "_GLIBCXX_HOSTED") #f))
+ (prepend (if gthread (format #f "~a~a" gthread "defined(_GLIBCXX_HAS_GTHREADS)") #f))
+ (prepend (if c++11-abi (format #f "~a~a" c++11-abi "_GLIBCXX_USE_CXX11_ABI") #f))
+
+ (prepend
+ (let ((strict "defined(__STRICT_ANSI__)")
+ (c++ "__cplusplus"))
+ (cond
+ ((or (and (equal? c++min gnu++min) c++min)
+ (and (not gnu++min) c++min))
+ ;; If we have both values, and they are equal, or we only have c++min,
+ ;; we want to output a simple check.
+ (format #f "(~a ~a)" c++ c++min))
+ ((and gnu++min c++min)
+ ;; We have differing cases for strict and non-strict modes.
+ (format #f "((~a && ~a ~a) || (!~a && ~a ~a))"
+ strict c++ c++min
+ strict c++ gnu++min))
+ ((and gnu++min (not c++min))
+ (format #f "(!~a && (~a ~a))" strict c++ gnu++min))
+ (else #f))))
+ (string-join conds " && " 'strict-infix))
+
+ }*/
+/*{ FOR ftms
+ }*/// /*{ (def-file-line "name") }*/
+#if !defined(__cpp_lib_/*{name}*/)
+/*{ FOR values }*//*{ #
+
+ This macro block defines two versions of each FTM:
+
+ 1. __glibcxx_NAME, which is defined unconditionally, and
+ 2. __cpp_lib_NAME, which is defined only if marked as wanted.
+
+ This allows FTMs to depend on eachother in their definitions without messing
+ with the exported values.
+
+ This can also be used by bits that do not want to expose FTMs that they can't
+ implement.
+
+}*/# /*{(unless (first-for?) "el")}*/if /*{(generate-cond)}*/
+# define __glibcxx_/*{name}*/ /*{v}*/L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_/*{name}*/)
+# define /*{
+;; Compute the name for this FTM based on stdname/name.
+(if (exist? "stdname")
+ (get "stdname")
+ (format #f "__cpp_lib_~a" (get "name")))
+}*/ /*{v}*/L
+# endif
+/*{ ENDFOR values
+ }*/# endif
+#endif /* !defined(__cpp_lib_/*{name}*/) && defined(__glibcxx_want_/*{name}*/) */
+#undef __glibcxx_want_/*{name
+}*//*{ (unless (last-for?) "\n\n" "\n")}*/
+/*{ ENDFOR ftms }*//*{
+
+;; Helper that generates [LO, HI].
+(define (closed-int-set lo hi)
+ (iota (+ (- hi lo) 1) lo))
+
+;; Sanity checking for duplicates and for value order.
+(let ((ht (make-hash-table (count "ftms"))))
+ (for-each
+ (lambda (idx)
+ (let ((name (get (format #f "ftms[~a].name" idx))))
+ (if (string-null? name) (ferror "No name for FTM ~a" idx))
+ (let ((cur (cdr (or (hash-get-handle ht name) '(1 . 0)))))
+ (hash-set! ht name (+ cur 1)))))
+ (closed-int-set (low-lim "ftms") (high-lim "ftms")))
+ (if (hash-fold
+ (lambda (name count prior)
+ (if (= 1 count)
+ prior
+ (begin
+ (printf "FTM %s appears %d times.\n" name count)
+ #t)))
+ #f ht)
+ (error "Duplicates found.")))
+
+(define (check-value-order ftm key order)
+ (let ((valmin 999999)) ; TODO(arsen): bump before year 10000
+ (for-each
+ (lambda (vidx)
+ (let* ((sval (get (format #f "values[~a].~a" vidx key)))
+ (val (string->number sval)))
+ (unless (string-null? sval)
+ (unless val (ferror "Bad value in FTM ~a" ftm))
+ (if (order val valmin)
+ (ferror "Found inverted ~s value in FTM ~a: ~a" key ftm sval))
+ (set! valmin val))))
+ (closed-int-set (low-lim "values") (high-lim "values")))))
+
+}*//*{ FOR ftms }*//*{#
+ Check for values that are in ascending order. Because it is generally the
+ case that FTMs increase as the values of tests they probe for do, we check
+ them to prevent simple, silly errors.
+
+ We're iterating in a separate FOR block rather than in pure Guile since, for
+ some reason, high-lim and low-lim do not work with complex names that include
+ periods and indices (whereas exist? and others do).
+}*//*{
+(let ((ftm (get "name")))
+ (check-value-order (get "name") "v" >)
+ (check-value-order (get "name") "cxxmin" >)
+ (check-value-order (get "name") "gnuxxmin" >))
+}*//*{ ENDFOR ftms }*/
+#undef __glibcxx_want_all
diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 02ead8f1443..100257405f9 100644
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -35,348 +35,7 @@
# pragma GCC system_header
#endif
-#include <bits/c++config.h>
-
-// c++03
-#if _GLIBCXX_HOSTED
-# define __cpp_lib_incomplete_container_elements 201505L
-#endif
-
-#if !defined(__STRICT_ANSI__)
-// gnu++03
-# define __cpp_lib_uncaught_exceptions 201411L
-#endif
-
-#if __cplusplus >= 201103L
-// c++11
-#define __cpp_lib_allocator_traits_is_always_equal 201411L
-#define __cpp_lib_is_null_pointer 201309L
-#define __cpp_lib_result_of_sfinae 201210L
-
-#if _GLIBCXX_HOSTED
-#if __cplusplus <= 201703L // N.B. updated value in C++20
-# define __cpp_lib_shared_ptr_arrays 201611L
-#endif
-#endif
-
-#if !defined(__STRICT_ANSI__)
-// gnu++11
-# define __cpp_lib_is_swappable 201603L
-# define __cpp_lib_void_t 201411L
-# if _GLIBCXX_HOSTED
-# define __cpp_lib_enable_shared_from_this 201603L
-# endif
-#endif
-
-// For C++11 and later we support ISO/IEC 29124 Mathematical Special Functions
-#define __STDCPP_MATH_SPEC_FUNCS__ 201003L
-
-#if __cplusplus >= 201402L
-// c++14
-#if __cpp_impl_coroutine
-# define __cpp_lib_coroutine 201902L
-#endif
-#define __cpp_lib_exchange_function 201304L
-#define __cpp_lib_integer_sequence 201304L
-#define __cpp_lib_integral_constant_callable 201304L
-#define __cpp_lib_is_final 201402L
-#define __cpp_lib_make_reverse_iterator 201402L
-#ifndef _GLIBCXX_DEBUG // PR libstdc++/70303
-# define __cpp_lib_null_iterators 201304L
-#endif
-#define __cpp_lib_robust_nonmodifying_seq_ops 201304L
-#define __cpp_lib_transformation_trait_aliases 201304L
-#define __cpp_lib_transparent_operators 201510L
-#define __cpp_lib_tuple_element_t 201402L
-#define __cpp_lib_tuples_by_type 201304L
-
-#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
- && __SIZE_WIDTH__ >= 32
-# define __cpp_lib_to_chars 201611L
-#endif
-
-#if _GLIBCXX_HOSTED
-# define __cpp_lib_chrono_udls 201304L
-# define __cpp_lib_complex_udls 201309L
-# define __cpp_lib_generic_associative_lookup 201304L
-# define __cpp_lib_make_unique 201304L
-# define __cpp_lib_quoted_string_io 201304L
-# ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_shared_timed_mutex 201402L
-# endif
-# define __cpp_lib_string_udls 201304L
-#endif
-
-#if __cplusplus >= 201703L
-// c++17
-#define __cpp_lib_addressof_constexpr 201603L
-#define __cpp_lib_any 201606L
-#define __cpp_lib_apply 201603L
-#define __cpp_lib_as_const 201510L
-#define __cpp_lib_atomic_is_always_lock_free 201603L
-#define __cpp_lib_bool_constant 201505L
-#define __cpp_lib_byte 201603L
-#define __cpp_lib_clamp 201603L
-#define __cpp_lib_gcd 201606L
-#define __cpp_lib_gcd_lcm 201606L
-#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
-# define __cpp_lib_has_unique_object_representations 201606L
-#endif
-#ifdef __GCC_DESTRUCTIVE_SIZE
-# define __cpp_lib_hardware_interference_size 201703L
-#endif
-#define __cpp_lib_invoke 201411L
-#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
-# define __cpp_lib_is_aggregate 201703L
-#endif
-#define __cpp_lib_is_invocable 201703L
-#define __cpp_lib_is_swappable 201603L
-#ifdef _GLIBCXX_HAVE_BUILTIN_LAUNDER
-# define __cpp_lib_launder 201606L
-#endif
-#define __cpp_lib_lcm 201606L
-#define __cpp_lib_logical_traits 201510L
-#define __cpp_lib_make_from_tuple 201606L
-#define __cpp_lib_nonmember_container_access 201411L
-#define __cpp_lib_not_fn 201603L
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# define __cpp_lib_optional 201606L
-#endif
-#define __cpp_lib_raw_memory_algorithms 201606L
-#define __cpp_lib_sample 201603L
-#define __cpp_lib_type_trait_variable_templates 201510L
-#define __cpp_lib_uncaught_exceptions 201411L
-#if !(__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L)
-// N.B. updated value in C++20
-# define __cpp_lib_variant 202102L
-#endif
-#define __cpp_lib_void_t 201411L
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# define __cpp_lib_array_constexpr 201803L
-#endif
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-# define __cpp_lib_constexpr_char_traits 201611L
-# define __cpp_lib_constexpr_string 201611L
-# endif
-#endif
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_boyer_moore_searcher 201603L
-#define __cpp_lib_chrono 201611L
-#define __cpp_lib_enable_shared_from_this 201603L
-#define __cpp_lib_execution 201902L // FIXME: should be 201603L
-#define __cpp_lib_filesystem 201703L
-#define __cpp_lib_hypot 201603L
-#define __cpp_lib_map_try_emplace 201411L
-#define __cpp_lib_math_special_functions 201603L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_memory_resource 201603L
-#else
-# define __cpp_lib_memory_resource 1
-#endif
-#define __cpp_lib_node_extract 201606L
-#define __cpp_lib_parallel_algorithm 201603L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_scoped_lock 201703L
-# define __cpp_lib_shared_mutex 201505L
-#endif
-#define __cpp_lib_shared_ptr_weak_type 201606L
-#define __cpp_lib_string_view 201803L
-#define __cpp_lib_unordered_map_try_emplace 201411L
-#endif
-
-#if __cplusplus >= 202002L
-// c++20
-#define __cpp_lib_assume_aligned 201811L
-#define __cpp_lib_atomic_flag_test 201907L
-#define __cpp_lib_atomic_float 201711L
-#define __cpp_lib_atomic_lock_free_type_aliases 201907L
-#define __cpp_lib_atomic_ref 201806L
-#define __cpp_lib_atomic_value_initialization 201911L
-#define __cpp_lib_bind_front 201907L
-#define __cpp_lib_starts_ends_with 201711L
-#if __has_builtin(__builtin_bit_cast)
-# define __cpp_lib_bit_cast 201806L
-#endif
-#define __cpp_lib_bitops 201907L
-#define __cpp_lib_bounded_array_traits 201902L
-// __cpp_lib_char8_t is defined in <bits/c++config.h>
-#if __cpp_concepts >= 201907L
-# define __cpp_lib_concepts 202002L
-#endif
-#if __cpp_impl_destroying_delete
-# define __cpp_lib_destroying_delete 201806L
-#endif
-#define __cpp_lib_constexpr_string_view 201811L
-#define __cpp_lib_endian 201907L
-#define __cpp_lib_int_pow2 202002L
-#define __cpp_lib_integer_comparison_functions 202002L
-#ifdef _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-# define __cpp_lib_is_constant_evaluated 201811L
-#endif
-#if __has_builtin(__is_layout_compatible) \
- && __has_builtin(__builtin_is_corresponding_member)
-# define __cpp_lib_is_layout_compatible 201907L
-#endif
-#define __cpp_lib_is_nothrow_convertible 201806L
-#if __has_builtin(__is_pointer_interconvertible_base_of) \
- && __has_builtin(__builtin_is_pointer_interconvertible_with_class)
-# define __cpp_lib_is_pointer_interconvertible 201907L
-#endif
-#define __cpp_lib_math_constants 201907L
-#if __cpp_lib_concepts
-# define __cpp_lib_make_obj_using_allocator 201811L
-#endif
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_optional 202106L
-#endif
-#define __cpp_lib_remove_cvref 201711L
-#if __has_builtin(__builtin_source_location)
-# define __cpp_lib_source_location 201907L
-#endif
-#if __cpp_lib_concepts
-# define __cpp_lib_span 202002L
-#endif
-#define __cpp_lib_ssize 201902L
-#if __cpp_impl_three_way_comparison >= 201907L && __cpp_lib_concepts
-# define __cpp_lib_three_way_comparison 201907L
-#endif
-#define __cpp_lib_to_address 201711L
-#define __cpp_lib_to_array 201907L
-#define __cpp_lib_type_identity 201806L
-#define __cpp_lib_unwrap_ref 201811L
-#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L
-# define __cpp_lib_variant 202106L
-#endif
-#define __cpp_lib_constexpr_algorithms 201806L
-#define __cpp_lib_constexpr_functional 201907L
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_constexpr_memory 201811L
-#endif // C++20
-#define __cpp_lib_constexpr_numeric 201911L
-#define __cpp_lib_constexpr_tuple 201811L
-#define __cpp_lib_array_constexpr 201811L
-#ifdef __cpp_lib_is_constant_evaluated
-# define __cpp_lib_constexpr_char_traits 201811L
-#endif
-#define __cpp_lib_constexpr_iterator 201811L
-#define __cpp_lib_constexpr_utility 201811L
-#define __cpp_lib_interpolate 201902L
-#if __cpp_lib_concepts
-# define __cpp_lib_move_iterator_concept 202207L
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_ranges 202110L
-#endif
-#endif
-#define __cpp_lib_shift 201806L
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_atomic_shared_ptr 201711L
-#if defined _GLIBCXX_HAS_GTHREADS || defined _GLIBCXX_HAVE_LINUX_FUTEX
-# define __cpp_lib_atomic_wait 201907L
-# if __cpp_aligned_new
-# define __cpp_lib_barrier 201907L
-# endif
-#endif
-// #undef __cpp_lib_chrono
-// #define __cpp_lib_chrono 201907L
-// FIXME: #define __cpp_lib_execution 201902L
-#define __cpp_lib_constexpr_complex 201711L
-#define __cpp_lib_constexpr_dynamic_alloc 201907L
-#define __cpp_lib_constexpr_tuple 201811L
-#ifdef __cpp_lib_is_constant_evaluated
-# if _GLIBCXX_USE_CXX11_ABI
-# define __cpp_lib_constexpr_string 201907L
-# else
-# define __cpp_lib_constexpr_string 201811L
-# endif
-#endif
-#define __cpp_lib_constexpr_vector 201907L
-#define __cpp_lib_erase_if 202002L
-#define __cpp_lib_format 202106L
-#define __cpp_lib_generic_unordered_lookup 201811L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_jthread 201911L
-#endif
-#if __cpp_lib_atomic_wait
-# define __cpp_lib_latch 201907L
-#endif
-#define __cpp_lib_list_remove_return_type 201806L
-#define __cpp_lib_polymorphic_allocator 201902L
-#if __cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE
-# define __cpp_lib_semaphore 201907L
-#endif
-#define __cpp_lib_shared_ptr_arrays 201707L
-#define __cpp_lib_smart_ptr_for_overwrite 202002L
-# if _GLIBCXX_USE_CXX11_ABI
-// Only supported with cxx11-abi
-# define __cpp_lib_syncbuf 201803L
-# endif
-#endif
-
-#if __cplusplus > 202002L
-// c++23
-#define __cpp_lib_byteswap 202110L
-#define __cpp_lib_constexpr_charconv 202207L
-#define __cpp_lib_constexpr_typeinfo 202106L
-#if __cpp_concepts >= 202002L
-# define __cpp_lib_expected 202211L
-#endif
-#define __cpp_lib_invoke_r 202106L
-#define __cpp_lib_is_scoped_enum 202011L
-#if __cpp_lib_concepts
-# undef __cpp_lib_optional
-# define __cpp_lib_optional 202110L
-#endif
-#define __cpp_lib_reference_from_temporary 202202L
-#define __cpp_lib_to_underlying 202102L
-#define __cpp_lib_unreachable 202202L
-#define __cpp_lib_ranges 202202L
-#define __cpp_lib_ranges_zip 202110L
-#define __cpp_lib_ranges_chunk 202202L
-#define __cpp_lib_ranges_slide 202202L
-#define __cpp_lib_ranges_chunk_by 202202L
-#define __cpp_lib_ranges_join_with 202202L
-#define __cpp_lib_ranges_repeat 202207L
-#define __cpp_lib_ranges_stride 202207L
-#define __cpp_lib_ranges_cartesian_product 202207L
-#define __cpp_lib_ranges_as_rvalue 202207L
-#define __cpp_lib_ranges_as_const 202207L
-#define __cpp_lib_ranges_enumerate 202302L
-#define __cpp_lib_ranges_contains 202207L
-#define __cpp_lib_ranges_iota 202202L
-#define __cpp_lib_ranges_find_last 202207L
-#define __cpp_lib_ranges_fold 202207L
-#if __cpp_constexpr_dynamic_alloc
-# if _GLIBCXX_HOSTED
-# define __cpp_lib_constexpr_bitset 202202L
-# endif
-# undef __cpp_lib_constexpr_memory
-# define __cpp_lib_constexpr_memory 202202L
-#endif
-#define __cpp_lib_stdatomic_h 202011L
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
-#define __cpp_lib_ios_noreplace 202207L
-#define __cpp_lib_move_only_function 202110L
-#if __cpp_lib_span
-# define __cpp_lib_spanstream 202106L
-#endif
-#if _GLIBCXX_HAVE_STACKTRACE
-# define __cpp_lib_stacktrace 202011L
-#endif
-#define __cpp_lib_stdatomic_h 202011L
-#define __cpp_lib_string_contains 202011L
-#if _GLIBCXX_USE_CXX11_ABI // Only supported with cxx11-abi
-# define __cpp_lib_string_resize_and_overwrite 202110L
-#endif
-#endif
-#endif // C++23
-#endif // C++20
-#endif // C++17
-#endif // C++14
-#endif // C++11
+#define __glibcxx_want_all
+#include <bits/version.h>
#endif // _GLIBCXX_VERSION_INCLUDED
--
2.40.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use
2023-04-29 10:16 [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
2023-04-29 10:16 ` [PATCH 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović
@ 2023-04-29 10:16 ` Arsen Arsenović
2023-06-01 20:30 ` Jonathan Wakely
2023-05-08 23:08 ` Ping: [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
2 siblings, 1 reply; 9+ messages in thread
From: Arsen Arsenović @ 2023-04-29 10:16 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Arsen Arsenović
libstdc++-v3/ChangeLog:
* libsupc++/typeinfo: Switch to bits/version.h for
__cpp_lib_constexpr_typeinfo.
* libsupc++/new: Switch to bits/version.h for
__cpp_lib_{launder,hardware_interference_size,destroying_delete}.
(launder): Guard behind __cpp_lib_launder.
(hardware_destructive_interference_size)
(hardware_constructive_interference_size): Guard behind
__cpp_lib_hardware_interference_size.
* libsupc++/exception: Switch to bits/version.h for
__cpp_lib_uncaught_exceptions.
(uncaught_exceptions): Guard behind __cpp_lib_uncaught_exceptions.
* libsupc++/compare: Switch to bits/version.h for
__cpp_lib_three_way_comparison.
(three_way_comparable, three_way_comparable_with)
(compare_three_way, weak_order, strong_order, partial_order):
Guard behind __cpp_lib_three_way_comparison >= 201907L.
* include/std/vector: Switch to bits/version.h for
__cpp_lib_erase_if.
(erase, erase_if): Guard behind __cpp_lib_erase_if.
* include/std/variant: Switch to bits/version.h for
__cpp_lib_variant. Guard whole header behind that FTM.
* include/std/utility: Switch to bits/version.h for
__cpp_lib_{exchange_function,constexpr_algorithms,as_const},
__cpp_lib_{integer_comparison_functions,to_underlying}, and
__cpp_lib_unreachable.
(exchange): Guard behind __cpp_lib_exchange_function.
(cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal)
(cmp_greater_equal, in_range): Guard behind
__cpp_lib_integer_comparison_functions.
(to_underlying): Guard behind __cpp_lib_to_underlying.
(unreachable): Guard behind __cpp_lib_unreachable.
* include/std/type_traits: Switch to bits/version.h for
__cpp_lib_is_{null_pointer,final,nothrow_convertible,aggregate},
__cpp_lib_is_{constant_evaluated,invocable,layout_compatible},
__cpp_lib_is_{pointer_interconvertible,scoped_enum,swappable},
__cpp_lib_{logical_traits,reference_from_temporary,remove_cvref},
__cpp_lib_{result_of_sfinae,transformation_trait_aliases},
__cpp_lib_{type_identity,type_trait_variable_templates},
__cpp_lib_{unwrap_ref,void_t,integral_constant_callable},
__cpp_lib_{bool_constant,bounded_array_traits}, and
__cpp_lib_has_unique_object_representations.
(integral_constant::operator()): Guard behind
__cpp_lib_integral_constant_callable.
(bool_constant): Guard behind __cpp_lib_bool_constant.
(conjunction, disjunction, negation, conjunction_v, disjunction_v)
(negation_v): Guard behind __cpp_lib_logical_traits.
(is_null_pointer): Guard behind __cpp_lib_is_null_pointer.
(is_final): Guard behind __cpp_lib_is_final.
(is_nothrow_convertible, is_nothrow_convertible_v): Guard behind
__cpp_lib_is_nothrow_convertible.
(remove_const_t, remove_volatile_t, remove_cv_t)
(add_const_t, add_volatile_t, add_cv_t): Guard behind
__cpp_lib_transformation_trait_aliases.
(void_t): Guard behind __cpp_lib_void_t.
(is_swappable_with_v, is_nothrow_swappable_with_v)
(is_swappable_with, is_nothrow_swappable_with): Guard behind
__cpp_lib_is_swappable.
(is_nothrow_invocable_r, is_invocable_r, invoke_result)
(is_invocable, invoke_result_t): Guard behind
__cpp_lib_is_invocable.
(alignment_of_v, extent_v, has_virtual_destructor_v)
(is_abstract_v, is_arithmetic_v, is_array_v)
(is_assignable_v, is_base_of_v, is_class_v, is_compound_v)
(is_constructible_v, is_const_v, is_convertible_v)
(is_copy_assignable_v, is_copy_constructible_v)
(is_default_constructible_v, is_destructible_v)
(is_empty_v, is_enum_v, is_final_v, is_floating_point_v)
(is_function_v, is_fundamental_v, is_integral_v)
(is_invocable_r_v, is_invocable_v, is_literal_type_v)
(is_lvalue_reference_v, is_member_function_pointer_v)
(is_member_object_pointer_v, is_member_pointer_v)
(is_move_assignable_v, is_move_constructible_v)
(is_nothrow_assignable_v, is_nothrow_constructible_v)
(is_nothrow_copy_assignable_v, is_nothrow_copy_constructible_v)
(is_nothrow_default_constructible_v, is_nothrow_destructible_v)
(is_nothrow_invocable_r_v, is_nothrow_invocable_v)
(is_nothrow_move_assignable_v, is_nothrow_move_constructible_v)
(is_null_pointer_v, is_object_v, is_pod_v, is_pointer_v)
(is_polymorphic_v, is_reference_v, is_rvalue_reference_v)
(is_same_v, is_scalar_v, is_signed_v, is_standard_layout_v)
(is_trivially_assignable_v, is_trivially_constructible_v)
(is_trivially_copyable_v, is_trivially_copy_assignable_v)
(is_trivially_copy_constructible_v)
(is_trivially_default_constructible_v)
(is_trivially_destructible_v, is_trivially_move_assignable_v)
(is_trivially_move_constructible_v, is_trivial_v, is_union_v)
(is_unsigned_v, is_void_v, is_volatile_v, rank_v, as variadic):
Guard behind __cpp_lib_type_trait_variable_templates.
(has_unique_object_representations)
(has_unique_object_representations_v): Guard behind
__cpp_lib_has_unique_object_representation.
(is_aggregate): Guard behind __cpp_lib_is_aggregate.
(remove_cvref, remove_cvref_t): Guard behind
__cpp_lib_remove_cvref.
(type_identity, type_identity_t): Guard behind
__cpp_lib_type_identity.
(unwrap_reference, unwrap_reference_t, unwrap_ref_decay)
(unwrap_ref_decay_t): Guard behind __cpp_lib_unwrap_ref.
(is_bounded_array_v, is_unbounded_array_v, is_bounded_array)
(is_unbounded_array): Guard behind __cpp_lib_bounded_array_traits.
(is_scoped_enum, is_scoped_enum_v): Guard behind
__cpp_lib_is_scoped_enum.
(reference_constructs_from_temporary)
(reference_constructs_from_temporary_v): Guard behind
__cpp_lib_reference_from_temporary.
* include/std/tuple: Switch to bits/version.h for
__cpp_lib_{constexpr_tuple,tuple_by_type,apply_make_from_tuple}.
(get<T>): Guard behind __cpp_lib_tuple_by_type.
(apply): Guard behind __cpp_lib_apply.
(make_from_tuple): Guard behind __cpp_lib_make_from_tuple.
* include/std/syncstream: Switch to bits/version.h for
__cpp_lib_syncbuf. Guard header behind that FTM.
* include/std/string_view: Switch to bits/version.h for
__cpp_lib_{string_{view,contains},constexpr_string_view} and
__cpp_lib_starts_ends_with.
(basic_string_view::starts_with, basic_string_view::ends_with):
Guard behind __cpp_lib_starts_ends_with.
[C++23 && _GLIBCXX_HOSTED && !defined(__cpp_lib_string_contains)]:
Assert as impossible ithout a bug in C++23.
* include/std/string: Switch to bits/version.h for
__cpp_lib_erase_if.
(erase, erase_if): Guard behind __cpp_lib_erase_if.
* include/std/thread: Switch to bits/version.h for
__cpp_lib_jthread.
* include/std/stop_token: Switch to bits/version.h for
__cpp_lib_jthread.
* include/std/spanstream: Switch to bits/version.h for
__cpp_lib_spanstream. Guard header behind that FTM.
* include/std/span: Switch to bits/version.h for __cpp_lib_span.
Guard header behind that FTM.
* include/std/source_location: Switch to bits/version.h for
__cpp_lib_source_location. Guard header with that FTM.
* include/std/shared_mutex: Switch to bits/version.h for
__cpp_lib_shared{,_timed}_mutex.
(shared_mutex): Guard behind __cpp_lib_shared_mutex.
* include/std/semaphore: Switch to bits/version.h for
__cpp_lib_semaphore. Guard header behind that FTM.
* include/std/ranges: Switch to bits/version.h for
__cpp_lib_ranges_{zip,chunk{,_by},slide,join_with},
__cpp_lib_ranges_{repeat_stride,cartesian_product,as_rvalue},
and __cpp_lib_ranges_{as_const,enumerate,iota}.
(ranges::zip et al, ranges::chunk et al, ranges::slide et al)
(ranges::chunk_by et al, ranges::join_with et al)
(ranges::stride et al, ranges::cartesian_product et al)
(ranges::as_rvalue et al, ranges::as_const et al)
(ranges::enumerate et al): Guard behind appropriate FTM.
* include/std/optional: Switch to bits/version.h for
__cpp_lib_optional. Guard header behind that FTM.
* include/std/numeric: Switch to bits/version.h for
__cpp_lib_{gcd{,_lcm},lcm,constexpr_numeric,interpolate}
and __cpp_lib_parallel_algorithm.
(gcd, lcm): Guard behind __cpp_lib_gcd_lcm.
(midpoint): Guard behind __cpp_lib_interpolate.
* include/std/numbers: Switch to bits/version.h for
__cpp_lib_math_constants. Guard header behind that FTM.
* include/std/mutex: Switch to bits/version.h for
__cpp_lib_scoped_lock.
(scoped_Lock): Guard behind __cpp_lib_scoped_lock.
* include/std/memory_resource: Switch to bits/version.h for
__cpp_lib_{polymorphic_allocator,memory_resource}.
(synchronized_pool_resource): Guard behind
__cpp_lib_memory_resource >= 201603L.
(polymorphic_allocator): Guard behind
__cpp_lib_polymorphic_allocator.
* include/std/memory: Switch to bits/version.h for
__cpp_lib_{parallel_algorithm,atomic_value_initialization}.
* include/std/list: Switch to bits/version.h for
__cpp_lib_erase_if.
(erase, erase_if): Guard behind __cpp_lib_erase_if.
* include/std/latch: Switch to bits/version.h for __cpp_lib_latch.
Guard header behind that FTM.
* include/std/iterator: Switch to bits/version.h for
__cpp_lib_null_iterators.
* include/std/iomanip: Switch to bits/version.h for
__cpp_lib_quoted_string_io.
(quoted): Guard behind __cpp_lib_quoted_string_io.
* include/std/functional: Switch to bits/version.h for
__cpp_lib_{invoke{,_r},constexpr_functional,bind_front} and
__cpp_lib_{not_fn,booyer_moore_searcher}.
(invoke): Guard behind __cpp_lib_invoke.
(invoke_r): Guard behind __cpp_lib_invoke_r.
(bind_front): Guard behind __cpp_lib_bind_front.
(not_fn): Guard behind __cpp_lib_not_fn.
(boyer_moore_searcher, boyer_moore_horspool_searcher): Guard
definition behind __cpp_lib_boyer_moore_searcher.
* include/std/forward_list: Switch to bits/version.h for
__cpp_lib_erase_if.
(erase, erase_if): Guard behind __cpp_lib_erase_if.
* include/std/format: Switch to bits/version.h for
__cpp_lib_format. Guard header behind that FTM.
* include/std/filesystem: Switch to bits/version.h for
__cpp_lib_filesystem. Guard header behind that FTM.
* include/std/expected: Switch to bits/version.h for
__cpp_lib_expected. Guard header behind it.
* include/std/execution: Switch to bits/version.h for
__cpp_lib_{execution,parallel_algorithm}. Guard header behind
either.
* include/std/deque: Switch to bits/version.h for
__cpp_lib_erase_if.
(erase, erase_if): Guard behind __cpp_lib_erase_if.
* include/std/coroutine: Switch to bits/version.h for
__cpp_lib_coroutine. Guard header behind that FTM.
* include/std/concepts: Switch to bits/version.h for
__cpp_lib_concepts. Guard header behind that FTM.
* include/std/complex: Switch to bits/version.h for
__cpp_lib_{complex_udls,constexpr_complex}.
(operator""if, operator""i, operator""il): Guard behind
__cpp_lib_complex_udls.
* include/std/charconv: Swtich to bits/version.h for
__cpp_lib_{to_chars,constexpr_charconv}.
* include/std/bitset: Switch to bits/version.h for
__cpp_lib_constexpr_bitset.
* include/std/bit: Switch to bits/version.h for
__cpp_lib_{bit_cast,byteswap,bitops,int_pow2,endian}.
(bit_cast): Guard behind __cpp_lib_bit_cast.
(byteswap): Guard behind __cpp_lib_byteswap.
(rotl, rotr, countl_zero, countl_one, countr_zero, countr_one)
(popcount): Guard behind __cpp_lib_bitops.
(has_single_bit, bit_ceil, bit_floor, bit_width): Guard behind
__cpp_lib_int_pow2.
(endian): Guard behind __cpp_lib_endian.
* include/std/barrier: Switch to bits/version.h for
__cpp_lib_barrier. Guard header behind that FTM.
* include/std/atomic: Switch to bits/version.h for
__cpp_lib_atomic_{is_always_lock_free,float,ref}
and __cpp_lib_lock_free_type_aliases.
(*::is_always_lock_free): Guard behind
__cpp_lib_atomic_is_always_lock_free.
(atomic<float>): Guard behind __cpp_lib_atomic_float.
(atomic_ref): Guard behind __cpp_lib_atomic_ref.
(atomic_signed_lock_free, atomic_unsigned_lock_free): Guard behind
__cpp_lib_atomic_lock_free_type_aliases.
* include/std/array: Switch to bits/version.h for
__cpp_lib_to_array.
(to_array): Guard behind __cpp_lib_to_array.
* include/std/any: Switch to bits/version.h for __cpp_lib_any.
Guard header behind that FTM.
* include/std/algorithm: Switch to bits/version.h for
__cpp_lib_parallel_algorithm.
* include/c_global/cstddef: Switch to bits/version.h for
__cpp_lib_byte.
(byte): Guard behind __cpp_lib_byte.
* include/c_global/cmath: Switch to bits/version.h for
__cpp_lib_{hypot,interpolate}.
(hypot3): Guard behind __cpp_lib_hypot.
(lerp): Guard behind __cpp_lib_interpolate.
* include/c_compatibility/stdatomic.h: Switch to
bits/stl_version.h for __cpp_lib_atomic. Guard header behind that
FTM.
* include/bits/utility.h: Switch to bits/version.h for
__cpp_lib_{tuple_element_t,integer_sequence,ranges_zip}.
(tuple_element_t): Guard behind __cpp_lib_tuple_element_t.
(integer_sequence et al): Guard behind __cpp_lib_integer_sequence.
* include/bits/uses_allocator_args.h: Switch to bits/version.h for
__cpp_lib_make_obj_using_allocator. Guard header behind that FTM.
* include/bits/unordered_map.h: Switch to bits/version.h for
__cpp_lib_unordered_map_try_emplace.
(try_emplace): Guard behind __cpp_lib_unordered_map_try_emplace.
* include/bits/unique_ptr.h: Switch to bits/version.h for
__cpp_lib_{constexpr_memory,make_unique}.
(make_unique): Guard behind __cpp_lib_make_unique.
* include/bits/stl_vector.h: Switch to bits/version.h for
__cpp_lib_constexpr_vector.
* include/bits/stl_uninitialized.h: Switch to bits/version.h for
__cpp_lib_raw_memory_algorithms.
(uninitialized_default_construct)
(uninitialized_default_construct_n, uninitialized_move)
(uninitialized_move_n, uninitialized_value_construct)
(uninitialized_value_construct_n): Guard behind
__cpp_lib_raw_memory_algorithms.
* include/bits/stl_tree.h: Switch to bits/version.h for
__cpp_lib_generic_associative_lookup.
* include/bits/stl_stack.h: Switch to bits/version.h for
__cpp_lib_adaptor_iterator_pair_constructor.
(stack): Guard iterator-pair constructor behind
__cpp_lib_adaptor_iterator_pair_constructor.
* include/bits/stl_queue.h: Switch to bits/version.h for
__cpp_lib_adaptor_iterator_pair_constructor.
(queue): Guard iterator-pair constructor behind
__cpp_lib_adaptor_iterator_pair_constructor.
* include/bits/stl_pair.h: Switch to bits/version.h for
__cpp_lib_{concepts,tuples_by_type}.
(get): Guard type-getting overloads behind
__cpp_lib_tuples_by_type.
* include/bits/stl_map.h: Switch to bits/version.h for
__cpp_lib_map_try_emplace.
(map<>::try_emplace): Guard behind __cpp_lib_map_try_emplace.
* include/bits/stl_list.h: Switch to bits/version.h for
__cpp_lib_list_remove_return_type.
(__remove_return_type, _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG)
[C++20]: guard behind __cpp_lib_list_remove_return_type instead.
* include/bits/stl_iterator.h: Switch to bits/version.h for
__cpp_lib_{constexpr_iterator,array_constexpr} and
__cpp_lib_{make_reverse_iterator,move_iterator_concept}.
(make_reverse_iterator): Guard behind
__cpp_lib_make_reverse_iterator.
(iterator_concept et al): Guard __cpp_lib_move_iterator_concept
changes behind that FTM.
* include/bits/stl_function.h: Switch to bits/version.h for
__cpp_lib_transparent_operators.
(equal_to, not_equal_to, greater, less, greater_equal)
(less_equal, bit_and, bit_or, bit_xor, bit_not, logical_and)
(logical_or, logical_not, plus, minus, multiplies, divides)
(modulus, negate): Guard '= void' fwdecls behind
__cpp_lib_transparent_operators.
(plus<void>, minus<void>, multiplies<void>, divides<void>)
(modulus<void>, negate<void>, logical_and<void>, logical_or<void>)
(logical_not<void>, bit_and<void>, bit_or<void>, bit_xor<void>)
(equal_to<void>, not_equal_to<void>, greater<void>, less<void>)
(greater_equal<void>, less_equal<void>, bit_not<void>)
(__has_is_transparent): Guard behind
__cpp_lib_transparent_operators.
* include/bits/stl_algobase.h: Switch to bits/version.h for
__cpp_lib_robust_nonmodifying_seq_ops.
(robust equal, mismatch): Guard behind
__cpp_lib_nonmember_container_access.
* include/bits/stl_algo.h: Swtich to bits/version.h for
__cpp_lib_{clamp,sample}.
(clamp): Guard behind __cpp_lib_clamp.
(sample): Guard behind __cpp_lib_sample.
* include/bits/specfun.h: Switch to bits/version.h for
__cpp_lib_math_special_functions and __STDCPP_MATH_SPEC_FUNCS__.
* include/bits/shared_ptr_base.h: Switch to bits/version.h for
__cpp_lib_{smart_ptr_for_overwrite,shared_ptr_arrays}.
(_Sp_overwrite_tag): Guard behind
__cpp_lib_smart_ptr_for_overwrite.
(_Sp_counted_array_base, _Sp_counted_array): Guard behind
__cpp_lib_shared_ptr_arrays >= 201707L.
* include/bits/shared_ptr_atomic.h: Switch to bits/version.h for
__cpp_lib_atomic_shared_ptr.
* include/bits/shared_ptr.h: Switch to bits/version.h for
__cpp_lib_{enable_shared_from_this,shared_ptr_weak_type}.
(shared_ptr<T>::weak_type): Guard behind
__cpp_lib_shared_ptr_weak_type.
(enable_shared_from_this<T>::weak_from_this): Guard behind
__cpp_lib_enable_shared_from_this.
* include/bits/ranges_cmp.h: Switch to bits/version.h for
__cpp_lib_ranges.
* include/bits/ranges_algo.h: Switch to bits/version.h for
__cpp_lib_{shift,ranges_{contains,find_last,fold,iota}}.
(ranges::iota et al, ranges::contains et al)
(ranges::find_last et al, ranges::fold et al): Guard behind
respective FTMs.
* include/bits/range_access.h: Switch to bits/version.h for
__cpp_lib_nonmember_container_access
(size, empty, data): Guard behind
__cpp_lib_nonmember_container_access.
(ssize): Guard behind __cpp_lib_ssize.
* include/bits/ptr_traits.h: Switch to bits/version.h. for
__cpp_lib_{constexpr_memory,to_address}.
(to_address): Guard behind __cpp_lib_to_address.
* include/bits/node_handle.h: Switch to bits/version.h for
__cpp_lib_node_extract. Guard header behind that FTM.
* include/bits/move_only_function.h: Switch to bits/version.h for
__cpp_lib_move_only_function. Guard header behind that FTM.
* include/bits/move.h: Switch to bits/version.h for
__cpp_lib_addressof_constexpr.
* include/bits/ios_base.h: Switch to bits/version.h for
__cpp_lib_ios_noreplace.
(noreplace): Guard with __cpp_lib_ios_noreplace.
* include/bits/hashtable.h: Switch to bits/version.h for
__cpp_lib_generic_unordered_lookup.
(_M_equal_range_tr, _M_count_tr, _M_find_tr): Guard behind
__cpp_lib_generic_unordered_lookup.
* include/bits/forward_list.h: Switch to bits/version.h for
__cpp_lib_list_remove_return_type.
(__remove_return_type): Guard behind
__cpp_lib_list_remove_return_type.
* include/bits/erase_if.h: Switch to bits/version.h for
__cpp_lib_erase_if.
* include/bits/cow_string.h: Switch to bits/version.h for
__cpp_lib_constexpr_string.
* include/bits/chrono.h: Swtich to bits/version.h for
__cpp_lib_chrono{,_udls}.
(ceil): Guard behind __cpp_lib_chrono.
(operator""ns et al): Guard behind __cpp_lib_chrono_udls.
* include/bits/char_traits.h: Switch to bits/version.h for
__cpp_lib_constexpr_char_traits.
* include/bits/basic_string.h: Switch to bits/version.h for
__cpp_lib_{constexpr_string,string_{resize_and_overwrite,udls}}.
(resize_and_overwrite): Guard behind
__cpp_lib_string_resize_and_overwrite.
(operator""s): Guard behind __cpp_lib_string_udls.
* include/bits/atomic_wait.h: Switch to bits/version.h for
__cpp_lib_atomic_wait. Guard header behind that FTM.
* include/bits/atomic_base.h: Switch to bits/version.h for
__cpp_lib_atomic_value_initialization and
__cpp_lib_atomic_flag_test.
(atomic_flag::test): Guard behind __cpp_lib_atomic_flag_test,
rather than C++20.
* include/bits/allocator.h: Switch to bits/version.h for
__cpp_lib_incomplete_container_elements.
* include/bits/alloc_traits.h: Switch to using bits/version.h for
__cpp_lib_constexpr_dynamic_alloc and
__cpp_lib_allocator_traits_is_always_equal.
* include/bits/align.h: Switch to bits/version.h for defining
__cpp_lib_assume_aligned.
(assume_aligned): Guard with __cpp_lib_assume_aligned.
* include/bits/algorithmfwd.h: Switch to bits/version.h for
defining __cpp_lib_constexpr_algorithms.
* include/std/stacktrace: Switch to bits/version.h for
__cpp_lib_stacktrace. Guard header behind that FTM.
* testsuite/23_containers/array/tuple_interface/get_neg.cc:
Update line numbers.
---
libstdc++-v3/include/bits/algorithmfwd.h | 7 +-
libstdc++-v3/include/bits/align.h | 8 +-
libstdc++-v3/include/bits/alloc_traits.h | 11 +-
libstdc++-v3/include/bits/allocator.h | 3 +-
libstdc++-v3/include/bits/atomic_base.h | 14 +-
libstdc++-v3/include/bits/atomic_wait.h | 10 +-
libstdc++-v3/include/bits/basic_string.h | 24 ++-
libstdc++-v3/include/bits/char_traits.h | 11 +-
libstdc++-v3/include/bits/chrono.h | 18 +--
libstdc++-v3/include/bits/cow_string.h | 9 +-
libstdc++-v3/include/bits/erase_if.h | 11 +-
libstdc++-v3/include/bits/forward_list.h | 6 +-
libstdc++-v3/include/bits/hashtable.h | 9 +-
libstdc++-v3/include/bits/ios_base.h | 6 +-
libstdc++-v3/include/bits/move.h | 8 +-
.../include/bits/move_only_function.h | 9 +-
libstdc++-v3/include/bits/node_handle.h | 8 +-
libstdc++-v3/include/bits/ptr_traits.h | 15 +-
libstdc++-v3/include/bits/range_access.h | 16 +-
libstdc++-v3/include/bits/ranges_algo.h | 27 ++--
libstdc++-v3/include/bits/ranges_cmp.h | 14 +-
libstdc++-v3/include/bits/shared_ptr.h | 10 +-
libstdc++-v3/include/bits/shared_ptr_atomic.h | 6 +-
libstdc++-v3/include/bits/shared_ptr_base.h | 17 +--
libstdc++-v3/include/bits/specfun.h | 6 +-
libstdc++-v3/include/bits/stl_algo.h | 20 +--
libstdc++-v3/include/bits/stl_algobase.h | 13 +-
libstdc++-v3/include/bits/stl_function.h | 28 ++--
libstdc++-v3/include/bits/stl_iterator.h | 21 +--
libstdc++-v3/include/bits/stl_list.h | 6 +-
libstdc++-v3/include/bits/stl_map.h | 6 +-
libstdc++-v3/include/bits/stl_pair.h | 12 +-
libstdc++-v3/include/bits/stl_queue.h | 9 +-
libstdc++-v3/include/bits/stl_stack.h | 7 +-
libstdc++-v3/include/bits/stl_tree.h | 7 +-
libstdc++-v3/include/bits/stl_uninitialized.h | 9 +-
libstdc++-v3/include/bits/stl_vector.h | 4 +-
libstdc++-v3/include/bits/unique_ptr.h | 13 +-
libstdc++-v3/include/bits/unordered_map.h | 8 +-
.../include/bits/uses_allocator_args.h | 10 +-
libstdc++-v3/include/bits/utility.h | 21 ++-
.../include/c_compatibility/stdatomic.h | 9 +-
libstdc++-v3/include/c_global/cmath | 18 +--
libstdc++-v3/include/c_global/cstddef | 9 +-
libstdc++-v3/include/std/algorithm | 10 +-
libstdc++-v3/include/std/any | 9 +-
libstdc++-v3/include/std/array | 9 +-
libstdc++-v3/include/std/atomic | 67 +++++----
libstdc++-v3/include/std/barrier | 11 +-
libstdc++-v3/include/std/bit | 30 ++--
libstdc++-v3/include/std/bitset | 7 +-
libstdc++-v3/include/std/charconv | 11 +-
libstdc++-v3/include/std/complex | 11 +-
libstdc++-v3/include/std/concepts | 10 +-
libstdc++-v3/include/std/coroutine | 20 ++-
libstdc++-v3/include/std/deque | 9 +-
libstdc++-v3/include/std/execution | 10 +-
libstdc++-v3/include/std/expected | 8 +-
libstdc++-v3/include/std/filesystem | 9 +-
libstdc++-v3/include/std/format | 19 +--
libstdc++-v3/include/std/forward_list | 10 +-
libstdc++-v3/include/std/functional | 39 ++---
libstdc++-v3/include/std/iomanip | 9 +-
libstdc++-v3/include/std/iterator | 5 +-
libstdc++-v3/include/std/latch | 10 +-
libstdc++-v3/include/std/list | 10 +-
libstdc++-v3/include/std/memory | 15 +-
libstdc++-v3/include/std/memory_resource | 20 +--
libstdc++-v3/include/std/mutex | 8 +-
libstdc++-v3/include/std/numbers | 8 +-
libstdc++-v3/include/std/numeric | 35 ++---
libstdc++-v3/include/std/optional | 15 +-
libstdc++-v3/include/std/ranges | 60 ++++----
libstdc++-v3/include/std/semaphore | 9 +-
libstdc++-v3/include/std/shared_mutex | 12 +-
libstdc++-v3/include/std/source_location | 9 +-
libstdc++-v3/include/std/span | 11 +-
libstdc++-v3/include/std/spanstream | 11 +-
libstdc++-v3/include/std/stacktrace | 10 +-
libstdc++-v3/include/std/stop_token | 5 +-
libstdc++-v3/include/std/string | 9 +-
libstdc++-v3/include/std/string_view | 23 ++-
libstdc++-v3/include/std/syncstream | 17 +--
libstdc++-v3/include/std/thread | 3 +
libstdc++-v3/include/std/tuple | 25 ++--
libstdc++-v3/include/std/type_traits | 141 +++++++++---------
libstdc++-v3/include/std/utility | 38 +++--
libstdc++-v3/include/std/variant | 13 +-
libstdc++-v3/include/std/vector | 9 +-
libstdc++-v3/libsupc++/compare | 11 +-
libstdc++-v3/libsupc++/exception | 6 +-
libstdc++-v3/libsupc++/new | 20 +--
libstdc++-v3/libsupc++/typeinfo | 7 +-
.../array/tuple_interface/get_neg.cc | 6 +-
94 files changed, 687 insertions(+), 715 deletions(-)
diff --git a/libstdc++-v3/include/bits/algorithmfwd.h b/libstdc++-v3/include/bits/algorithmfwd.h
index 03e627866ad..89c956af59b 100644
--- a/libstdc++-v3/include/bits/algorithmfwd.h
+++ b/libstdc++-v3/include/bits/algorithmfwd.h
@@ -39,6 +39,9 @@
#include <initializer_list>
#endif
+#define __glibcxx_want_constexpr_algorithms
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -191,10 +194,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// adjacent_find
-#if __cplusplus > 201703L
-# define __cpp_lib_constexpr_algorithms 201806L
-#endif
-
#if __cplusplus >= 201103L
template<typename _IIter, typename _Predicate>
_GLIBCXX20_CONSTEXPR
diff --git a/libstdc++-v3/include/bits/align.h b/libstdc++-v3/include/bits/align.h
index 32d9349ee25..1bcd262bb86 100644
--- a/libstdc++-v3/include/bits/align.h
+++ b/libstdc++-v3/include/bits/align.h
@@ -32,6 +32,9 @@
#include <bits/c++config.h>
+#define __glibcxx_want_assume_aligned
+#include <bits/version.h>
+
#include <bit> // std::has_single_bit
#include <stdint.h> // uintptr_t
#include <debug/assertions.h> // _GLIBCXX_DEBUG_ASSERT
@@ -75,8 +78,7 @@ align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
}
}
-#if __cplusplus > 201703L
-#define __cpp_lib_assume_aligned 201811L
+#ifdef __cpp_lib_assume_aligned
/** @brief Inform the compiler that a pointer is aligned.
*
* @tparam _Align An alignment value (i.e. a power of two)
@@ -103,7 +105,7 @@ align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align));
}
}
-#endif // C++2a
+#endif // __cpp_lib_assume_aligned
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/bits/alloc_traits.h b/libstdc++-v3/include/bits/alloc_traits.h
index cd91d152f64..259a0b179f7 100644
--- a/libstdc++-v3/include/bits/alloc_traits.h
+++ b/libstdc++-v3/include/bits/alloc_traits.h
@@ -40,13 +40,15 @@
# endif
#endif
+#define __glibcxx_want_constexpr_dynamic_alloc
+#define __glibcxx_want_allocator_traits_is_always_equal
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cplusplus >= 201103L
-#define __cpp_lib_allocator_traits_is_always_equal 201411L
-
/// @cond undocumented
struct __allocator_traits_base
{
@@ -418,11 +420,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
#if _GLIBCXX_HOSTED
-
-#if __cplusplus > 201703L
-# define __cpp_lib_constexpr_dynamic_alloc 201907L
-#endif
-
/// Partial specialization for std::allocator.
template<typename _Tp>
struct allocator_traits<allocator<_Tp>>
diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h
index abbd753d33d..41e35f876f0 100644
--- a/libstdc++-v3/include/bits/allocator.h
+++ b/libstdc++-v3/include/bits/allocator.h
@@ -49,7 +49,8 @@
#include <type_traits>
#endif
-#define __cpp_lib_incomplete_container_elements 201505L
+#define __glibcxx_want_incomplete_container_elements
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h
index 3af61881895..c98cf058a8b 100644
--- a/libstdc++-v3/include/bits/atomic_base.h
+++ b/libstdc++-v3/include/bits/atomic_base.h
@@ -46,6 +46,10 @@
#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
#endif
+#define __glibcxx_want_atomic_value_initialization
+#define __glibcxx_want_atomic_flag_test
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -156,10 +160,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __ret;
}
-#if __cplusplus >= 202002L
-# define __cpp_lib_atomic_value_initialization 201911L
-#endif
-
/// @cond undocumented
#if __cpp_lib_atomic_value_initialization
# define _GLIBCXX20_INIT(I) = I
@@ -234,9 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __atomic_test_and_set (&_M_i, int(__m));
}
-#if __cplusplus > 201703L
-#define __cpp_lib_atomic_flag_test 201907L
-
+#ifdef __cpp_lib_atomic_flag_test
_GLIBCXX_ALWAYS_INLINE bool
test(memory_order __m = memory_order_seq_cst) const noexcept
{
@@ -252,7 +250,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__atomic_load(&_M_i, &__v, int(__m));
return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL;
}
+#endif
+#if __cplusplus > 201703L
#if __cpp_lib_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(bool __old,
diff --git a/libstdc++-v3/include/bits/atomic_wait.h b/libstdc++-v3/include/bits/atomic_wait.h
index 67c0e3bf56b..9cbfb99a7c2 100644
--- a/libstdc++-v3/include/bits/atomic_wait.h
+++ b/libstdc++-v3/include/bits/atomic_wait.h
@@ -32,8 +32,10 @@
#pragma GCC system_header
-#include <bits/c++config.h>
-#if defined _GLIBCXX_HAS_GTHREADS || defined _GLIBCXX_HAVE_LINUX_FUTEX
+#define __glibcxx_want_atomic_wait
+#include <bits/version.h>
+
+#if __cpp_lib_atomic_wait
#include <bits/functional_hash.h>
#include <bits/gthr.h>
#include <ext/numeric_traits.h>
@@ -48,8 +50,6 @@
# include <bits/std_mutex.h> // std::mutex, std::__condvar
-#define __cpp_lib_atomic_wait 201907L
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -476,5 +476,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // GTHREADS || LINUX_FUTEX
+#endif // __cpp_lib_atomic_wait
#endif // _GLIBCXX_ATOMIC_WAIT_H
diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 8247ee6bdc6..8be385b3330 100644
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -47,22 +47,20 @@
# include <string_view>
#endif
+#define __glibcxx_want_constexpr_string
+#define __glibcxx_want_string_resize_and_overwrite
+#define __glibcxx_want_string_udls
+#include <bits/version.h>
+
#if ! _GLIBCXX_USE_CXX11_ABI
# include "cow_string.h"
#else
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CXX11
-#ifdef __cpp_lib_is_constant_evaluated
-// Support P0980R1 in C++20.
-# define __cpp_lib_constexpr_string 201907L
-#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-// Support P0426R1 changes to char_traits in C++17.
-# define __cpp_lib_constexpr_string 201611L
-#endif
-
/**
* @class basic_string basic_string.h <string>
* @brief Managing sequences of characters and character-like objects.
@@ -1125,8 +1123,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
#pragma GCC diagnostic pop
#endif
-#if __cplusplus > 202002L
-#define __cpp_lib_string_resize_and_overwrite 202110L
+#ifdef __cpp_lib_string_resize_and_overwrite
/** Resize the string and call a function to fill it.
*
* @param __n The maximum size requested.
@@ -4466,10 +4463,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
#endif
-#if __cplusplus >= 201402L
-
-#define __cpp_lib_string_udls 201304L
-
+#ifdef __cpp_lib_string_udls
inline namespace literals
{
inline namespace string_literals
@@ -4514,6 +4508,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#pragma GCC diagnostic pop
} // inline namespace string_literals
} // inline namespace literals
+#endif // __cpp_lib_string_udls
#if __cplusplus >= 201703L
namespace __detail::__variant
@@ -4531,7 +4526,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
} // namespace __detail::__variant
#endif // C++17
-#endif // C++14
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h
index 68ed827f982..bfde677a395 100644
--- a/libstdc++-v3/include/bits/char_traits.h
+++ b/libstdc++-v3/include/bits/char_traits.h
@@ -61,6 +61,9 @@
# define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
#endif
+#define __glibcxx_want_constexpr_char_traits
+#include <bits/version.h>
+
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -316,14 +319,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#ifdef __cpp_lib_is_constant_evaluated
-// Unofficial macro indicating P1032R1 support in C++20
-# define __cpp_lib_constexpr_char_traits 201811L
-#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-// Unofficial macro indicating P0426R1 support in C++17
-# define __cpp_lib_constexpr_char_traits 201611L
-#endif
-
// 21.1
/**
* @brief Basis for explicit traits specializations.
diff --git a/libstdc++-v3/include/bits/chrono.h b/libstdc++-v3/include/bits/chrono.h
index fb99fe5eed7..d92afdac64f 100644
--- a/libstdc++-v3/include/bits/chrono.h
+++ b/libstdc++-v3/include/bits/chrono.h
@@ -32,6 +32,10 @@
#pragma GCC system_header
+#define __glibcxx_want_chrono
+#define __glibcxx_want_chrono_udls
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <ratio>
@@ -368,9 +372,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
#endif // C++20
-#if __cplusplus >= 201703L
-# define __cpp_lib_chrono 201611L
-
+#ifdef __cpp_lib_chrono
/** Convert a `duration` to type `ToDur` and round down.
*
* If the duration cannot be represented exactly in the result type,
@@ -464,7 +466,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Make chrono::ceil<D> also usable as chrono::__detail::ceil<D>.
namespace __detail { using chrono::ceil; }
-#else // ! C++17
+#else // ! __cpp_lib_chrono
// We want to use ceil even when compiling for earlier standards versions.
// C++11 only allows a single statement in a constexpr function, so we
@@ -486,7 +488,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d);
}
}
-#endif // C++17
+#endif // __cpp_lib_chrono
/// duration_values
template<typename _Rep>
@@ -1323,9 +1325,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
#endif // C++20
} // namespace chrono
-#if __cplusplus >= 201402L
-#define __cpp_lib_chrono_udls 201304L
-
+#ifdef __cpp_lib_chrono_udls
inline namespace literals
{
/** ISO C++ 2014 namespace for suffixes for duration literals.
@@ -1446,7 +1446,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
{
using namespace literals::chrono_literals;
} // namespace chrono
-#endif // C++14
+#endif // __cpp_lib_chrono_udls
#if __cplusplus >= 201703L
namespace filesystem
diff --git a/libstdc++-v3/include/bits/cow_string.h b/libstdc++-v3/include/bits/cow_string.h
index e5f094fd13e..bf676ed40c5 100644
--- a/libstdc++-v3/include/bits/cow_string.h
+++ b/libstdc++-v3/include/bits/cow_string.h
@@ -36,13 +36,8 @@
#include <ext/atomicity.h> // _Atomic_word, __is_single_threaded
-#ifdef __cpp_lib_is_constant_evaluated
-// Support P1032R1 in C++20 (but not P0980R1 for COW strings).
-# define __cpp_lib_constexpr_string 201811L
-#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-// Support P0426R1 changes to char_traits in C++17.
-# define __cpp_lib_constexpr_string 201611L
-#endif
+#define __glibcxx_want_constexpr_string
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/bits/erase_if.h b/libstdc++-v3/include/bits/erase_if.h
index bb1b53dd4f6..4ff81e0f98f 100644
--- a/libstdc++-v3/include/bits/erase_if.h
+++ b/libstdc++-v3/include/bits/erase_if.h
@@ -32,18 +32,16 @@
#pragma GCC system_header
-#if __cplusplus >= 201402L
-
#include <bits/c++config.h>
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
+#if __cplusplus >= 201402L
namespace std
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if __cplusplus > 201703L
-# define __cpp_lib_erase_if 202002L
-#endif
-
namespace __detail
{
template<typename _Container, typename _UnsafeContainer,
@@ -70,7 +68,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-
#endif // C++14
#endif // _GLIBCXX_ERASE_IF_H
diff --git a/libstdc++-v3/include/bits/forward_list.h b/libstdc++-v3/include/bits/forward_list.h
index 72b1ef46d14..84d79492d7e 100644
--- a/libstdc++-v3/include/bits/forward_list.h
+++ b/libstdc++-v3/include/bits/forward_list.h
@@ -41,6 +41,9 @@
#include <ext/alloc_traits.h>
#include <ext/aligned_buffer.h>
+#define __glibcxx_want_list_remove_return_type
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -1180,8 +1183,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// @}
private:
-#if __cplusplus > 201703L
-# define __cpp_lib_list_remove_return_type 201806L
+#ifdef __cpp_lib_list_remove_return_type
using __remove_return_type = size_type;
# define _GLIBCXX_FWDLIST_REMOVE_RETURN_TYPE_TAG \
__attribute__((__abi_tag__("__cxx20")))
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
index d2ff15320fc..569105600b7 100644
--- a/libstdc++-v3/include/bits/hashtable.h
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -39,6 +39,9 @@
# include <bits/node_handle.h>
#endif
+#define __glibcxx_want_generic_unordered_lookup
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -752,9 +755,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __k) const;
-#if __cplusplus >= 202002L
-#define __cpp_lib_generic_unordered_lookup 201811L
-
+#ifdef __cpp_lib_generic_unordered_lookup
template<typename _Kt,
typename = __has_is_transparent_t<_Hash, _Kt>,
typename = __has_is_transparent_t<_Equal, _Kt>>
@@ -784,7 +785,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename = __has_is_transparent_t<_Equal, _Kt>>
pair<const_iterator, const_iterator>
_M_equal_range_tr(const _Kt& __k) const;
-#endif // C++20
+#endif // __cpp_lib_generic_unordered_lookup
private:
// Bucket index computation helpers.
diff --git a/libstdc++-v3/include/bits/ios_base.h b/libstdc++-v3/include/bits/ios_base.h
index addfd054e76..c3fab14e951 100644
--- a/libstdc++-v3/include/bits/ios_base.h
+++ b/libstdc++-v3/include/bits/ios_base.h
@@ -46,6 +46,9 @@
# include <system_error>
#endif
+#define __glibcxx_want_ios_noreplace
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -473,8 +476,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
static const openmode __noreplace = _S_noreplace;
-#if __cplusplus >= 202100L
-#define __cpp_lib_ios_noreplace 202207L
+#ifdef __cpp_lib_ios_noreplace
/// Open a file in exclusive mode.
static const openmode noreplace = _S_noreplace;
#endif
diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h
index 4a8fceff96a..00997d6f1fb 100644
--- a/libstdc++-v3/include/bits/move.h
+++ b/libstdc++-v3/include/bits/move.h
@@ -37,6 +37,9 @@
# include <type_traits> // Brings in std::declval too.
#endif
+#define __glibcxx_want_addressof_constexpr
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -120,11 +123,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// declval, from type_traits.
-#if __cplusplus > 201402L
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 2296. std::addressof should be constexpr
-# define __cpp_lib_addressof_constexpr 201603L
-#endif
/**
* @brief Returns the actual address of the object or function
* referenced by r, even in the presence of an overloaded
diff --git a/libstdc++-v3/include/bits/move_only_function.h b/libstdc++-v3/include/bits/move_only_function.h
index 71d52074978..81d7d9f7c0a 100644
--- a/libstdc++-v3/include/bits/move_only_function.h
+++ b/libstdc++-v3/include/bits/move_only_function.h
@@ -32,7 +32,10 @@
#pragma GCC system_header
-#if __cplusplus > 202002L
+#define __glibcxx_want_move_only_function
+#include <bits/version.h>
+
+#ifdef __cpp_lib_move_only_function
#include <bits/invoke.h>
#include <bits/utility.h>
@@ -41,8 +44,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_move_only_function 202110L
-
template<typename... _Signature>
class move_only_function; // not defined
@@ -212,5 +213,5 @@ _GLIBCXX_END_NAMESPACE_VERSION
#define _GLIBCXX_MOF_REF &&
#include "mofunc_impl.h"
-#endif // C++23
+#endif // __cpp_lib_move_only_function
#endif // _GLIBCXX_MOVE_ONLY_FUNCTION_H
diff --git a/libstdc++-v3/include/bits/node_handle.h b/libstdc++-v3/include/bits/node_handle.h
index 8904a5ac496..25a4c8f167c 100644
--- a/libstdc++-v3/include/bits/node_handle.h
+++ b/libstdc++-v3/include/bits/node_handle.h
@@ -33,8 +33,10 @@
#pragma GCC system_header
-#if __cplusplus >= 201703L
-# define __cpp_lib_node_extract 201606L
+#define __glibcxx_want_node_extract
+#include <bits/version.h>
+
+#ifdef __cpp_lib_node_extract
#include <new>
#include <bits/alloc_traits.h>
@@ -390,5 +392,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++17
+#endif // __cpp_lib_node_extract
#endif
diff --git a/libstdc++-v3/include/bits/ptr_traits.h b/libstdc++-v3/include/bits/ptr_traits.h
index 8a919ec1090..dfaa377ac6d 100644
--- a/libstdc++-v3/include/bits/ptr_traits.h
+++ b/libstdc++-v3/include/bits/ptr_traits.h
@@ -34,12 +34,9 @@
#include <bits/move.h>
-/* Duplicate definition with unique_ptr.h. */
-#if __cplusplus > 202002L && defined(__cpp_constexpr_dynamic_alloc)
-# define __cpp_lib_constexpr_memory 202202L
-#elif __cplusplus > 201703L
-# define __cpp_lib_constexpr_memory 201811L
-#endif
+#define __glibcxx_want_constexpr_memory
+#define __glibcxx_want_to_address
+#include <bits/version.h>
#if __cplusplus > 201703L
#include <concepts>
@@ -215,7 +212,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __ptr;
}
-#if __cplusplus <= 201703L
+#ifndef __cpp_lib_to_address
template<typename _Ptr>
constexpr typename std::pointer_traits<_Ptr>::element_type*
__to_address(const _Ptr& __ptr)
@@ -237,8 +234,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return std::__to_address(__ptr.operator->());
}
-#define __cpp_lib_to_address 201711L
-
/**
* @brief Obtain address referenced by a pointer to an object
* @param __ptr A pointer to an object
@@ -261,7 +256,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr auto
to_address(const _Ptr& __ptr) noexcept
{ return std::__to_address(__ptr); }
-#endif // C++2a
+#endif // __cpp_lib_to_address
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
diff --git a/libstdc++-v3/include/bits/range_access.h b/libstdc++-v3/include/bits/range_access.h
index b7169c616f9..aeef6890a1f 100644
--- a/libstdc++-v3/include/bits/range_access.h
+++ b/libstdc++-v3/include/bits/range_access.h
@@ -32,6 +32,10 @@
#pragma GCC system_header
+#define __glibcxx_want_nonmember_container_access
+#define __glibcxx_want_ssize
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <initializer_list>
#include <type_traits> // common_type_t, make_signed_t
@@ -251,9 +255,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif // C++14
-#if __cplusplus >= 201703L
-#define __cpp_lib_nonmember_container_access 201411L
-
+#ifdef __cpp_lib_nonmember_container_access
/**
* @brief Return the size of a container.
* @param __cont Container.
@@ -345,9 +347,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr const _Tp*
data(initializer_list<_Tp> __il) noexcept
{ return __il.begin(); }
+#endif // __cpp_lib_nonmember_container_access
-#if __cplusplus > 201703L
-#define __cpp_lib_ssize 201902L
+#ifdef __cpp_lib_ssize
template<typename _Container>
[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
@@ -364,9 +366,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr ptrdiff_t
ssize(const _Tp (&)[_Num]) noexcept
{ return _Num; }
-#endif // C++20
-
-#endif // C++17
+#endif // __cpp_lib_ssize
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/bits/ranges_algo.h b/libstdc++-v3/include/bits/ranges_algo.h
index 410d3ae1dd8..5841e93d168 100644
--- a/libstdc++-v3/include/bits/ranges_algo.h
+++ b/libstdc++-v3/include/bits/ranges_algo.h
@@ -39,6 +39,13 @@
#include <bits/ranges_util.h>
#include <bits/uniform_int_dist.h> // concept uniform_random_bit_generator
+#define __glibcxx_want_ranges_contains
+#define __glibcxx_want_ranges_find_last
+#define __glibcxx_want_ranges_fold
+#define __glibcxx_want_ranges_iota
+#define __glibcxx_want_shift
+#include <bits/version.h>
+
#if __cpp_lib_concepts
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -3467,10 +3474,7 @@ namespace ranges
inline constexpr __prev_permutation_fn prev_permutation{};
-#if __cplusplus > 202002L
-
-#define __cpp_lib_ranges_contains 202207L
-
+#ifdef __cpp_lib_ranges_contains
struct __contains_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
@@ -3523,9 +3527,9 @@ namespace ranges
};
inline constexpr __contains_subrange_fn contains_subrange{};
+#endif // __cpp_lib_ranges_contains
-#define __cpp_lib_ranges_iota 202202L
-
+#ifdef __cpp_lib_ranges_iota
template<typename _Out, typename _Tp>
struct out_value_result
{
@@ -3573,9 +3577,9 @@ namespace ranges
};
inline constexpr __iota_fn iota{};
+#endif // __cpp_lib_ranges_iota
-#define __cpp_lib_ranges_find_last 202207L
-
+#ifdef __cpp_lib_ranges_find_last
struct __find_last_fn
{
template<forward_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp, typename _Proj = identity>
@@ -3701,9 +3705,9 @@ namespace ranges
};
inline constexpr __find_last_if_not_fn find_last_if_not{};
+#endif // __cpp_lib_ranges_find_last
-#define __cpp_lib_ranges_fold 202207L
-
+#ifdef __cpp_lib_ranges_fold
template<typename _Iter, typename _Tp>
struct in_value_result
{
@@ -3949,10 +3953,9 @@ namespace ranges
};
inline constexpr __fold_right_last_fn fold_right_last{};
-#endif // C++23
+#endif // __cpp_lib_ranges_fold
} // namespace ranges
-#define __cpp_lib_shift 201806L
template<typename _ForwardIterator>
constexpr _ForwardIterator
shift_left(_ForwardIterator __first, _ForwardIterator __last,
diff --git a/libstdc++-v3/include/bits/ranges_cmp.h b/libstdc++-v3/include/bits/ranges_cmp.h
index 6710d829a37..043b5ee381f 100644
--- a/libstdc++-v3/include/bits/ranges_cmp.h
+++ b/libstdc++-v3/include/bits/ranges_cmp.h
@@ -30,6 +30,9 @@
#ifndef _RANGES_CMP_H
#define _RANGES_CMP_H 1
+#define __glibcxx_want_ranges
+#include <bits/version.h>
+
#if __cplusplus > 201703L
# include <bits/move.h>
# include <concepts>
@@ -55,14 +58,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using is_transparent = __is_transparent;
};
-#ifdef __cpp_lib_concepts
-// Define this here, included by all the headers that need to define it.
-#if __cplusplus > 202002L
-#define __cpp_lib_ranges 202202L
-#else
-#define __cpp_lib_ranges 202110L
-#endif
-
+#ifdef __cpp_lib_ranges
namespace ranges
{
namespace __detail
@@ -179,7 +175,7 @@ namespace ranges
};
} // namespace ranges
-#endif // library concepts
+#endif // __cpp_lib_ranges
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++20
diff --git a/libstdc++-v3/include/bits/shared_ptr.h b/libstdc++-v3/include/bits/shared_ptr.h
index 2c24eada950..c5c24b0853e 100644
--- a/libstdc++-v3/include/bits/shared_ptr.h
+++ b/libstdc++-v3/include/bits/shared_ptr.h
@@ -52,6 +52,10 @@
#include <iosfwd> // std::basic_ostream
#include <bits/shared_ptr_base.h>
+#define __glibcxx_want_shared_ptr_weak_type
+#define __glibcxx_want_enable_shared_from_this
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -189,8 +193,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// The type pointed to by the stored pointer, remove_extent_t<_Tp>
using element_type = typename __shared_ptr<_Tp>::element_type;
-#if __cplusplus >= 201703L
-# define __cpp_lib_shared_ptr_weak_type 201606L
+#ifdef __cpp_lib_shared_ptr_weak_type
/// The corresponding weak_ptr type for this shared_ptr
/// @since C++17
using weak_type = weak_ptr<_Tp>;
@@ -938,8 +941,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
shared_from_this() const
{ return shared_ptr<const _Tp>(this->_M_weak_this); }
-#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
-#define __cpp_lib_enable_shared_from_this 201603L
+#ifdef __cpp_lib_enable_shared_from_this
/** @{
* Get a `weak_ptr` referring to the object that has `*this` as its base.
* @since C++17
diff --git a/libstdc++-v3/include/bits/shared_ptr_atomic.h b/libstdc++-v3/include/bits/shared_ptr_atomic.h
index 2295b48e732..244965a637a 100644
--- a/libstdc++-v3/include/bits/shared_ptr_atomic.h
+++ b/libstdc++-v3/include/bits/shared_ptr_atomic.h
@@ -32,6 +32,9 @@
#include <bits/atomic_base.h>
+#define __glibcxx_want_atomic_shared_ptr
+#include <bits/version.h>
+
// Annotations for the custom locking in atomic<shared_ptr<T>>.
#if defined _GLIBCXX_TSAN && __has_include(<sanitizer/tsan_interface.h>)
#include <sanitizer/tsan_interface.h>
@@ -355,8 +358,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @} group pointer_abstractions
-#if __cplusplus >= 202002L
-# define __cpp_lib_atomic_shared_ptr 201711L
+#ifdef __cpp_lib_atomic_shared_ptr
template<typename _Tp>
class atomic;
diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h
index 2c948d5b838..9194345e7c8 100644
--- a/libstdc++-v3/include/bits/shared_ptr_base.h
+++ b/libstdc++-v3/include/bits/shared_ptr_base.h
@@ -67,6 +67,10 @@
# include <bits/stl_uninitialized.h>
#endif
+#define __glibcxx_want_smart_ptr_for_overwrite
+#define __glibcxx_want_shared_ptr_arrays
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -652,8 +656,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Impl _M_impl;
};
-#if __cplusplus >= 202002L
-# define __cpp_lib_smart_ptr_for_overwrite 202002L
+#ifdef __cpp_lib_smart_ptr_for_overwrite
struct _Sp_overwrite_tag { };
// Partial specialization used for make_shared_for_overwrite<non-array>().
@@ -712,13 +715,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_get_deleter(const std::type_info&) noexcept override
{ return nullptr; }
};
-#endif // C++20
-
-#if __cplusplus <= 201703L
-# define __cpp_lib_shared_ptr_arrays 201611L
-#else
-# define __cpp_lib_shared_ptr_arrays 201707L
+#endif // __cpp_lib_smart_ptr_for_overwrite
+#if __cpp_lib_shared_ptr_arrays >= 201707L
struct _Sp_overwrite_tag;
// For make_shared<T[]>, make_shared<T[N]>, allocate_shared<T[]> etc.
@@ -880,7 +879,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_get_deleter(const std::type_info&) noexcept override
{ return nullptr; }
};
-#endif // C++20
+#endif // __cpp_lib_shared_ptr_arrays >= 201707L
// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
diff --git a/libstdc++-v3/include/bits/specfun.h b/libstdc++-v3/include/bits/specfun.h
index afb13857036..fdaaaf4576b 100644
--- a/libstdc++-v3/include/bits/specfun.h
+++ b/libstdc++-v3/include/bits/specfun.h
@@ -32,9 +32,9 @@
#include <bits/c++config.h>
-#define __STDCPP_MATH_SPEC_FUNCS__ 201003L
-
-#define __cpp_lib_math_special_functions 201603L
+#define __glibcxx_want_math_spec_funcs
+#define __glibcxx_want_math_special_functions
+#include <bits/version.h>
#if __cplusplus <= 201403L && __STDCPP_WANT_MATH_SPEC_FUNCS__ == 0
# error include <cmath> and define __STDCPP_WANT_MATH_SPEC_FUNCS__
diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
index 3d37091a9b4..5754c602086 100644
--- a/libstdc++-v3/include/bits/stl_algo.h
+++ b/libstdc++-v3/include/bits/stl_algo.h
@@ -72,6 +72,10 @@
# endif
#endif
+#define __glibcxx_want_clamp
+#define __glibcxx_want_sample
+#include <bits/version.h>
+
// See concept_check.h for the __glibcxx_*_requires macros.
namespace std _GLIBCXX_VISIBILITY(default)
@@ -3646,11 +3650,9 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
return std::__is_permutation(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred));
}
+#endif // C++14
-#if __cplusplus >= 201703L
-
-#define __cpp_lib_clamp 201603L
-
+#ifdef __cpp_lib_clamp
/**
* @brief Returns the value clamped between lo and hi.
* @ingroup sorting_algorithms
@@ -3689,8 +3691,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
__glibcxx_assert(!__comp(__hi, __lo));
return std::min(std::max(__val, __lo, __comp), __hi, __comp);
}
-#endif // C++17
-#endif // C++14
+#endif // __cpp_lib_clamp
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
/**
@@ -5905,9 +5906,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
}
return __out;
}
+#endif // C++14
-#if __cplusplus > 201402L
-#define __cpp_lib_sample 201603L
+#ifdef __cpp_lib_sample
/// Take a random sample from a population.
template<typename _PopulationIterator, typename _SampleIterator,
typename _Distance, typename _UniformRandomBitGenerator>
@@ -5935,8 +5936,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
std::forward<_UniformRandomBitGenerator>(__g));
}
-#endif // C++17
-#endif // C++14
+#endif // __cpp_lib_sample
_GLIBCXX_END_NAMESPACE_ALGO
_GLIBCXX_END_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index 4a6f8195d98..3a69d7afecb 100644
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -79,6 +79,9 @@
# include <compare>
#endif
+#define __glibcxx_want_robust_nonmodifying_seq_ops
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -1648,10 +1651,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
}
#endif // C++11
-#if __cplusplus > 201103L
-
-#define __cpp_lib_robust_nonmodifying_seq_ops 201304L
-
+#ifdef __cpp_lib_robust_nonmodifying_seq_ops
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
@@ -1713,7 +1713,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
return _GLIBCXX_STD_A::__equal4(__first1, __last1, __first2, __last2,
__binary_pred);
}
-#endif // C++14
+#endif // __cpp_lib_robust_nonmodifying_seq_ops
/**
* @brief Performs @b dictionary comparison on ranges.
@@ -1955,8 +1955,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
-#if __cplusplus > 201103L
-
+#if __cpp_lib_robust_nonmodifying_seq_ops
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
_GLIBCXX20_CONSTEXPR
diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h
index fa03f32b1b8..1c023c7f85f 100644
--- a/libstdc++-v3/include/bits/stl_function.h
+++ b/libstdc++-v3/include/bits/stl_function.h
@@ -60,6 +60,9 @@
#include <bits/move.h>
#endif
+#define __glibcxx_want_transparent_operators
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -153,7 +156,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#if __cplusplus > 201103L
+#if __cpp_lib_transparent_operators
struct __is_transparent; // undefined
template<typename _Tp = void>
@@ -241,10 +244,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
#pragma GCC diagnostic pop
-#if __cplusplus > 201103L
-
-#define __cpp_lib_transparent_operators 201510L
-
+#ifdef __cpp_lib_transparent_operators
template<>
struct plus<void>
{
@@ -345,7 +345,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*
* @{
*/
-#if __cplusplus > 201103L
+#if __cpp_lib_transparent_operators
template<typename _Tp = void>
struct equal_to;
@@ -489,7 +489,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
#pragma GCC diagnostic pop
-#if __cplusplus >= 201402L
+#ifdef __cpp_lib_transparent_operators
/// One of the @link comparison_functors comparison functors@endlink.
template<>
struct equal_to<void>
@@ -765,7 +765,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};
-#endif // C++14
+#endif // __cpp_lib_transparent_operators
/** @} */
// 20.3.4 logical operations
@@ -777,7 +777,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*
* @{
*/
-#if __cplusplus > 201103L
+#ifdef __cpp_lib_transparent_operators
template<typename _Tp = void>
struct logical_and;
@@ -822,7 +822,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
#pragma GCC diagnostic pop
-#if __cplusplus > 201103L
+#ifdef __cpp_lib_transparent_operators
/// One of the @link logical_functors Boolean operations functors@endlink.
template<>
struct logical_and<void>
@@ -867,10 +867,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef __is_transparent is_transparent;
};
-#endif
+#endif // __cpp_lib_transparent_operators
/** @} */
-#if __cplusplus > 201103L
+#ifdef __cpp_lib_transparent_operators
template<typename _Tp = void>
struct bit_and;
@@ -926,7 +926,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
#pragma GCC diagnostic pop
-#if __cplusplus > 201103L
+#ifdef __cpp_lib_transparent_operators
template <>
struct bit_and<void>
{
@@ -1416,7 +1416,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @} */
-#if __cplusplus >= 201402L
+#ifdef __cpp_lib_transparent_operators
template<typename _Func, typename _SfinaeType, typename = __void_t<>>
struct __has_is_transparent
{ };
diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h
index b22d9a4fdb3..6c8b6b4540d 100644
--- a/libstdc++-v3/include/bits/stl_iterator.h
+++ b/libstdc++-v3/include/bits/stl_iterator.h
@@ -70,12 +70,11 @@
# include <type_traits>
#endif
-#if __cplusplus > 201703L
-# define __cpp_lib_array_constexpr 201811L
-# define __cpp_lib_constexpr_iterator 201811L
-#elif __cplusplus == 201703L
-# define __cpp_lib_array_constexpr 201803L
-#endif
+#define __glibcxx_want_constexpr_iterator
+#define __glibcxx_want_array_constexpr
+#define __glibcxx_want_make_reverse_iterator
+#define __glibcxx_want_move_iterator_concept
+#include <bits/version.h>
#if __cplusplus >= 202002L
# include <compare>
@@ -642,9 +641,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
-# if __cplusplus >= 201402L
-# define __cpp_lib_make_reverse_iterator 201402L
-
+# ifdef __cpp_lib_make_reverse_iterator
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 2285. make_reverse_iterator
/// Generator function for reverse_iterator.
@@ -661,7 +658,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
reverse_iterator<_Iterator2>> = true;
# endif // C++20
-# endif // C++14
+# endif // __cpp_lib_make_reverse_iterator
template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
@@ -1487,9 +1484,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
public:
using iterator_type = _Iterator;
-#if __cplusplus > 201703L && __cpp_lib_concepts
- // This is P2520R0, a C++23 change, but we treat it as a DR against C++20.
-# define __cpp_lib_move_iterator_concept 202207L
+#ifdef __cpp_lib_move_iterator_concept
using iterator_concept = decltype(_S_iter_concept());
// iterator_category defined in __move_iter_cat
diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h
index bf1f1b37ab4..9e7208f95cf 100644
--- a/libstdc++-v3/include/bits/stl_list.h
+++ b/libstdc++-v3/include/bits/stl_list.h
@@ -65,6 +65,9 @@
#include <ext/aligned_buffer.h>
#endif
+#define __glibcxx_want_list_remove_return_type
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -1761,8 +1764,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
#endif
private:
-#if __cplusplus > 201703L
-# define __cpp_lib_list_remove_return_type 201806L
+#ifdef __cpp_lib_list_remove_return_type
typedef size_type __remove_return_type;
# define _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG \
__attribute__((__abi_tag__("__cxx20")))
diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h
index 059916d0a7f..58ba485969a 100644
--- a/libstdc++-v3/include/bits/stl_map.h
+++ b/libstdc++-v3/include/bits/stl_map.h
@@ -63,6 +63,9 @@
#include <tuple>
#endif
+#define __glibcxx_want_map_try_emplace
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -696,8 +699,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
{ merge(__source); }
#endif // C++17
-#if __cplusplus > 201402L
-#define __cpp_lib_map_try_emplace 201411L
+#ifdef __cpp_lib_map_try_emplace
/**
* @brief Attempts to build and insert a std::pair into the %map.
*
diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index 3f1624f40b4..4df1a41e6ee 100644
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -63,9 +63,12 @@
#endif
#if __cplusplus >= 202002L
# include <compare>
-# define __cpp_lib_constexpr_utility 201811L
#endif
+#define __glibcxx_want_constexpr_utility
+#define __glibcxx_want_tuples_by_type
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -1050,10 +1053,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
get(const pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__const_move_get(std::move(__in)); }
-#if __cplusplus >= 201402L
-
-#define __cpp_lib_tuples_by_type 201304L
+#ifdef __cpp_lib_tuples_by_type
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
@@ -1093,6 +1094,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr const _Tp&&
get(const pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
+#endif // __cpp_lib_tuples_by_type
+
#if __cplusplus > 202002L
template<typename _T1, typename _T2, typename _U1, typename _U2,
@@ -1111,7 +1114,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; };
#endif // C++23
-#endif // C++14
/// @}
#endif // C++11
diff --git a/libstdc++-v3/include/bits/stl_queue.h b/libstdc++-v3/include/bits/stl_queue.h
index 8a8dc95f889..ec3f8a637fa 100644
--- a/libstdc++-v3/include/bits/stl_queue.h
+++ b/libstdc++-v3/include/bits/stl_queue.h
@@ -62,6 +62,9 @@
# include <bits/uses_allocator.h>
#endif
+#define __glibcxx_want_adaptor_iterator_pair_constructor
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -194,10 +197,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
queue(queue&& __q, const _Alloc& __a)
: c(std::move(__q.c), __a) { }
+#endif
-#if __cplusplus > 202002L
-#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
-
+#ifdef __cpp_lib_adaptor_iterator_pair_constructor
template<typename _InputIterator,
typename = _RequireInputIter<_InputIterator>>
queue(_InputIterator __first, _InputIterator __last)
@@ -208,7 +210,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename = _Uses<_Alloc>>
queue(_InputIterator __first, _InputIterator __last, const _Alloc& __a)
: c(__first, __last, __a) { }
-#endif
#endif
/**
diff --git a/libstdc++-v3/include/bits/stl_stack.h b/libstdc++-v3/include/bits/stl_stack.h
index 006b18c9683..ad23c703c5d 100644
--- a/libstdc++-v3/include/bits/stl_stack.h
+++ b/libstdc++-v3/include/bits/stl_stack.h
@@ -62,6 +62,9 @@
# include <bits/uses_allocator.h>
#endif
+#define __glibcxx_want_adaptor_iterator_pair_constructor
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -170,9 +173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
stack(_Sequence&& __c)
: c(std::move(__c)) { }
-#if __cplusplus > 202002L
-#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
-
+#ifdef __cpp_lib_adaptor_iterator_pair_constructor
template<typename _InputIterator,
typename = _RequireInputIter<_InputIterator>>
stack(_InputIterator __first, _InputIterator __last)
diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h
index 3c331fbc952..c9d11a1f80f 100644
--- a/libstdc++-v3/include/bits/stl_tree.h
+++ b/libstdc++-v3/include/bits/stl_tree.h
@@ -72,14 +72,13 @@
# include <bits/node_handle.h>
#endif
+#define __glibcxx_want_generic_associative_lookup
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if __cplusplus > 201103L
-# define __cpp_lib_generic_associative_lookup 201304L
-#endif
-
// Red-black tree class, designed for use in implementing STL
// associative containers (set, multiset, map, and multimap). The
// insertion and deletion algorithms are based on those in Cormen,
diff --git a/libstdc++-v3/include/bits/stl_uninitialized.h b/libstdc++-v3/include/bits/stl_uninitialized.h
index 6752c6b5746..36071e9a22f 100644
--- a/libstdc++-v3/include/bits/stl_uninitialized.h
+++ b/libstdc++-v3/include/bits/stl_uninitialized.h
@@ -67,6 +67,9 @@
#include <bits/stl_pair.h>
#endif
+#define __glibcxx_want_raw_memory_algorithms
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -958,9 +961,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @endcond
#endif
-#if __cplusplus >= 201703L
-# define __cpp_lib_raw_memory_algorithms 201606L
-
+#ifdef __cpp_lib_raw_memory_algorithms
/**
* @brief Default-initializes objects in the range [first,last).
* @param __first A forward iterator.
@@ -1053,7 +1054,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__count, __result);
return {__res.first.base(), __res.second};
}
-#endif // C++17
+#endif // __cpp_lib_raw_memory_algorithms
#if __cplusplus >= 201103L
/// @cond undocumented
diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index acb29396d26..ccba58f0b71 100644
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -64,9 +64,11 @@
#endif
#if __cplusplus >= 202002L
# include <compare>
-#define __cpp_lib_constexpr_vector 201907L
#endif
+#define __glibcxx_want_constexpr_vector
+#include <bits/version.h>
+
#include <debug/assertions.h>
#if _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR
diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h
index f0c6d2383b4..c41ab744d5e 100644
--- a/libstdc++-v3/include/bits/unique_ptr.h
+++ b/libstdc++-v3/include/bits/unique_ptr.h
@@ -43,12 +43,9 @@
# endif
#endif
-/* Duplicate definition with ptr_traits.h. */
-#if __cplusplus > 202002L && defined(__cpp_constexpr_dynamic_alloc)
-# define __cpp_lib_constexpr_memory 202202L
-#elif __cplusplus > 201703L
-# define __cpp_lib_constexpr_memory 201811L
-#endif
+#define __glibcxx_want_constexpr_memory
+#define __glibcxx_want_make_unique
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -1029,9 +1026,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
{ };
-#if __cplusplus >= 201402L && _GLIBCXX_HOSTED
-#define __cpp_lib_make_unique 201304L
-
+#ifdef __cpp_lib_make_unique
/// @cond undocumented
namespace __detail
{
diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index 2f63bc5f1fa..6b0620d4c14 100644
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -35,6 +35,9 @@
#include <bits/functional_hash.h> // hash
#include <bits/stl_function.h> // equal_to
+#define __glibcxx_want_unordered_map_try_emplace
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -449,8 +452,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
iterator
insert(const_iterator, node_type&& __nh)
{ return _M_h._M_reinsert_node(std::move(__nh)).position; }
+#endif // C++17
-#define __cpp_lib_unordered_map_try_emplace 201411L
+#ifdef __cpp_lib_unordered_map_try_emplace
/**
* @brief Attempts to build and insert a std::pair into the
* %unordered_map.
@@ -534,7 +538,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
return _M_h.try_emplace(__hint, std::move(__k),
std::forward<_Args>(__args)...).first;
}
-#endif // C++17
+#endif // __cpp_lib_unordered_map_try_emplace
///@{
/**
diff --git a/libstdc++-v3/include/bits/uses_allocator_args.h b/libstdc++-v3/include/bits/uses_allocator_args.h
index bc038f03458..0a32e455624 100644
--- a/libstdc++-v3/include/bits/uses_allocator_args.h
+++ b/libstdc++-v3/include/bits/uses_allocator_args.h
@@ -32,8 +32,10 @@
#pragma GCC system_header
-#if __cplusplus > 201703L && __cpp_concepts
+#define __glibcxx_want_make_obj_using_allocator
+#include <bits/version.h>
+#ifdef __cpp_lib_make_obj_using_allocator
#include <new> // for placement operator new
#include <tuple> // for tuple, make_tuple, make_from_tuple
#include <bits/stl_construct.h> // construct_at
@@ -49,10 +51,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @addtogroup allocators
* @{
*/
-
-// Not specified by C++20, used internally
-#define __cpp_lib_make_obj_using_allocator 201811L
-
template<typename _Tp, typename _Alloc, typename... _Args>
constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
@@ -247,5 +245,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // __cpp_lib_make_obj_using_allocator
#endif // _USES_ALLOCATOR_ARGS
diff --git a/libstdc++-v3/include/bits/utility.h b/libstdc++-v3/include/bits/utility.h
index 4692aa0c9b0..c12732d6d36 100644
--- a/libstdc++-v3/include/bits/utility.h
+++ b/libstdc++-v3/include/bits/utility.h
@@ -35,6 +35,11 @@
#pragma GCC system_header
+#define __glibcxx_want_tuple_element_t
+#define __glibcxx_want_integer_sequence
+#define __glibcxx_want_ranges_zip
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <type_traits>
@@ -123,17 +128,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
return __n;
}
+#endif // C++14
// The standard says this macro and alias template should be in <tuple> but we
// define them here, to be available in <array>, <utility> and <ranges> too.
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3378. tuple_size_v/tuple_element_t should be available when
// tuple_size/tuple_element are
-#define __cpp_lib_tuple_element_t 201402L
-
+#ifdef __cpp_lib_tuple_element_t
template<size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
-#endif // C++14
+#endif
// Stores a tuple of indices. Used by tuple and pair, and by bind() to
// extract the elements in a tuple.
@@ -155,9 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
};
-#if __cplusplus >= 201402L
-
-#define __cpp_lib_integer_sequence 201304L
+#ifdef __cpp_lib_integer_sequence
/// Class template integer_sequence
template<typename _Tp, _Tp... _Idx>
@@ -187,6 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Alias template index_sequence_for
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+#endif // __cpp_lib_integer_sequence
#if __cplusplus >= 201703L
@@ -222,7 +226,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>;
#endif // C++17
-#endif // C++14
#if __has_builtin(__type_pack_element)
template<size_t _Np, typename... _Types>
@@ -269,10 +272,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
#endif
-#if __cplusplus > 202002L
-#define __cpp_lib_ranges_zip 202110L // for <tuple> and <utility>
-#endif
-
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/c_compatibility/stdatomic.h b/libstdc++-v3/include/c_compatibility/stdatomic.h
index b565a1c1ab1..c0475ae36f4 100644
--- a/libstdc++-v3/include/c_compatibility/stdatomic.h
+++ b/libstdc++-v3/include/c_compatibility/stdatomic.h
@@ -29,11 +29,12 @@
#ifndef _GLIBCXX_STDATOMIC_H
#define _GLIBCXX_STDATOMIC_H
-#if __cplusplus > 202002L
+#define __glibcxx_want_stdatomic_h
+#include <bits/version.h>
+
+#ifdef __cpp_lib_stdatomic_h
#include <atomic>
-#define __cpp_lib_stdatomic_h 202011L
-
#define _Atomic(_Tp) std::atomic<_Tp>
using std::memory_order;
@@ -126,5 +127,5 @@ using std::atomic_signal_fence;
#elif defined __clang__
# include_next <stdatomic.h>
-#endif // C++23
+#endif // __cpp_lib_stdatomic_h
#endif // _GLIBCXX_STDATOMIC_H
diff --git a/libstdc++-v3/include/c_global/cmath b/libstdc++-v3/include/c_global/cmath
index 568eb354c2d..9063a23311c 100644
--- a/libstdc++-v3/include/c_global/cmath
+++ b/libstdc++-v3/include/c_global/cmath
@@ -51,6 +51,10 @@
#ifndef _GLIBCXX_CMATH
#define _GLIBCXX_CMATH 1
+#define __glibcxx_want_hypot
+#define __glibcxx_want_interpolate
+#include <bits/version.h>
+
// Get rid of those macros defined in <math.h> in lieu of real functions.
#undef div
#undef acos
@@ -3559,11 +3563,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif // _GLIBCXX_USE_C99_MATH_TR1
#endif // C++11
-#if __cplusplus >= 201703L
-
+#ifdef __cpp_lib_hypot
// [c.math.hypot3], three-dimensional hypotenuse
-#define __cpp_lib_hypot 201603L
-
template<typename _Tp>
inline _Tp
__hypot3(_Tp __x, _Tp __y, _Tp __z)
@@ -3631,12 +3632,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
#endif
-#endif // C++17
+#endif // __cpp_lib_hypot
-#if __cplusplus >= 202002L
+#ifdef __cpp_lib_interpolate
// linear interpolation
-# define __cpp_lib_interpolate 201902L
-
template<typename _Fp>
constexpr _Fp
__lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
@@ -3706,8 +3705,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept
{ return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
#endif
-
-#endif // C++20
+#endif // __cpp_lib_interpolate
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/c_global/cstddef b/libstdc++-v3/include/c_global/cstddef
index 728ac796542..1699841030e 100644
--- a/libstdc++-v3/include/c_global/cstddef
+++ b/libstdc++-v3/include/c_global/cstddef
@@ -49,6 +49,9 @@
#include <bits/c++config.h>
#include <stddef.h>
+#define __glibcxx_want_byte
+#include <bits/version.h>
+
extern "C++"
{
#if __cplusplus >= 201103L
@@ -59,12 +62,10 @@ namespace std
}
#endif // C++11
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_byte
namespace std
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_byte 201603L
-
/// std::byte
enum class byte : unsigned char {};
@@ -185,7 +186,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++17
+#endif // __cpp_lib_byte
} // extern "C++"
#endif // _GLIBCXX_CSTDDEF
diff --git a/libstdc++-v3/include/std/algorithm b/libstdc++-v3/include/std/algorithm
index fc393eeacf7..365ac04fba3 100644
--- a/libstdc++-v3/include/std/algorithm
+++ b/libstdc++-v3/include/std/algorithm
@@ -63,7 +63,10 @@
# include <bits/ranges_algo.h>
#endif
-#if __cplusplus > 201402L && _GLIBCXX_HOSTED
+#define __glibcxx_want_parallel_algorithm
+#include <bits/version.h>
+
+#if __cpp_lib_parallel_algorithm
// Parallel STL algorithms
# if _PSTL_EXECUTION_POLICIES_DEFINED
// If <execution> has already been included, pull in implementations
@@ -73,10 +76,7 @@
# include <pstl/glue_algorithm_defs.h>
# define _PSTL_ALGORITHM_FORWARD_DECLARED 1
# endif
-
-// Feature test macro for parallel algorithms
-# define __cpp_lib_parallel_algorithm 201603L
-#endif // C++17 && HOSTED
+#endif
#ifdef _GLIBCXX_PARALLEL
# include <parallel/algorithm>
diff --git a/libstdc++-v3/include/std/any b/libstdc++-v3/include/std/any
index a221445df27..00c756ecf14 100644
--- a/libstdc++-v3/include/std/any
+++ b/libstdc++-v3/include/std/any
@@ -31,7 +31,10 @@
#pragma GCC system_header
-#if __cplusplus >= 201703L
+#define __glibcxx_want_any
+#include <bits/version.h>
+
+#ifdef __cpp_lib_any
#include <initializer_list>
#include <typeinfo>
@@ -67,8 +70,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
}
-#define __cpp_lib_any 201606L
-
/**
* @brief A type-safe container of any type.
*
@@ -652,5 +653,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++17
+#endif // defined(__glibcxx_any)
#endif // _GLIBCXX_ANY
diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array
index 27354d9e3fb..153888552e6 100644
--- a/libstdc++-v3/include/std/array
+++ b/libstdc++-v3/include/std/array
@@ -45,6 +45,9 @@
#include <bits/utility.h> // std::index_sequence, std::tuple_size
#include <debug/assertions.h>
+#define __glibcxx_want_to_array
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -414,9 +417,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return std::move(std::get<_Int>(__arr));
}
-#if __cplusplus > 201703L
-#define __cpp_lib_to_array 201907L
-
+#ifdef __cpp_lib_to_array
template<bool _Move = false, typename _Tp, size_t... _Idx>
constexpr array<remove_cv_t<_Tp>, sizeof...(_Idx)>
__to_array(_Tp (&__a)[sizeof...(_Idx)], index_sequence<_Idx...>)
@@ -452,7 +453,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __to_array<1>(__a, make_index_sequence<_Nm>{});
__builtin_unreachable(); // FIXME: see PR c++/91388
}
-#endif // C++20
+#endif // __cpp_lib_to_array
// Tuple interface to class template array.
diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic
index 96e87ded864..716a1efabc2 100644
--- a/libstdc++-v3/include/std/atomic
+++ b/libstdc++-v3/include/std/atomic
@@ -38,6 +38,12 @@
# include <bits/c++0x_warning.h>
#else
+#define __glibcxx_want_atomic_is_always_lock_free
+#define __glibcxx_want_atomic_float
+#define __glibcxx_want_atomic_ref
+#define __glibcxx_want_atomic_lock_free_type_aliases
+#include <bits/version.h>
+
#include <bits/atomic_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
@@ -49,10 +55,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#if __cplusplus >= 201703L
-# define __cpp_lib_atomic_is_always_lock_free 201603L
-#endif
-
template<typename _Tp>
struct atomic;
@@ -95,7 +97,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2;
#endif
@@ -557,7 +559,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
is_lock_free() const volatile noexcept
{ return _M_b.is_lock_free(); }
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free
= ATOMIC_POINTER_LOCK_FREE == 2;
#endif
@@ -720,7 +722,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
#endif
};
@@ -743,7 +745,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
#endif
};
@@ -766,7 +768,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
#endif
};
@@ -789,7 +791,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
#endif
};
@@ -812,7 +814,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
#endif
};
@@ -835,7 +837,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
#endif
};
@@ -858,7 +860,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
#endif
};
@@ -881,7 +883,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
#endif
};
@@ -904,7 +906,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
#endif
};
@@ -927,7 +929,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
#endif
};
@@ -950,7 +952,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
#endif
};
@@ -973,7 +975,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
#endif
};
@@ -997,7 +999,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus > 201402L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free
= ATOMIC_CHAR8_T_LOCK_FREE == 2;
#endif
@@ -1022,7 +1024,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free
= ATOMIC_CHAR16_T_LOCK_FREE == 2;
#endif
@@ -1046,7 +1048,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __base_type::operator __integral_type;
using __base_type::operator=;
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_atomic_is_always_lock_free
static constexpr bool is_always_lock_free
= ATOMIC_CHAR32_T_LOCK_FREE == 2;
#endif
@@ -1617,8 +1619,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__atomic_val_t<_ITp> __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
-#if __cplusplus > 201703L
-#define __cpp_lib_atomic_float 201711L
+#if __cpp_lib_atomic_float
template<>
struct atomic<float> : __atomic_float<float>
{
@@ -1748,9 +1749,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __atomic_float<__gnu_cxx::__bfloat16_t>::operator=;
};
#endif
+#endif // defined(__cpp_lib_atomic_float)
-#define __cpp_lib_atomic_ref 201806L
-
+#ifdef __cpp_lib_atomic_ref
/// Class template to provide atomic operations on a non-atomic variable.
template<typename _Tp>
struct atomic_ref : __atomic_ref<_Tp>
@@ -1765,26 +1766,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __atomic_ref<_Tp>::operator=;
};
+#endif // defined(__cpp_lib_atomic_ref)
-#define __cpp_lib_atomic_lock_free_type_aliases 201907L
-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT
+#ifdef __cpp_lib_atomic_lock_free_type_aliases
+# ifdef _GLIBCXX_HAVE_PLATFORM_WAIT
using atomic_signed_lock_free
= atomic<make_signed_t<__detail::__platform_wait_t>>;
using atomic_unsigned_lock_free
= atomic<make_unsigned_t<__detail::__platform_wait_t>>;
-#elif ATOMIC_INT_LOCK_FREE || !(ATOMIC_LONG_LOCK_FREE || ATOMIC_CHAR_LOCK_FREE)
+# elif ATOMIC_INT_LOCK_FREE || !(ATOMIC_LONG_LOCK_FREE || ATOMIC_CHAR_LOCK_FREE)
using atomic_signed_lock_free = atomic<signed int>;
using atomic_unsigned_lock_free = atomic<unsigned int>;
-#elif ATOMIC_LONG_LOCK_FREE
+# elif ATOMIC_LONG_LOCK_FREE
using atomic_signed_lock_free = atomic<signed long>;
using atomic_unsigned_lock_free = atomic<unsigned long>;
-#elif ATOMIC_CHAR_LOCK_FREE
+# elif ATOMIC_CHAR_LOCK_FREE
using atomic_signed_lock_free = atomic<signed char>;
using atomic_unsigned_lock_free = atomic<unsigned char>;
+# else
+# error "libstdc++ bug: no lock-free atomics but they were emitted in version?"
+# endif
#endif
-#endif // C++2a
-
/// @} group atomics
_GLIBCXX_END_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/std/barrier b/libstdc++-v3/include/std/barrier
index 6070ad5cd27..57968c4a9f8 100644
--- a/libstdc++-v3/include/std/barrier
+++ b/libstdc++-v3/include/std/barrier
@@ -42,16 +42,16 @@
#include <bits/requires_hosted.h> // threading primitive
-#if __cplusplus > 201703L
+#define __glibcxx_want_barrier
+#include <bits/version.h>
+
+#ifdef __cpp_lib_barrier
#include <bits/atomic_base.h>
-#if __cpp_lib_atomic_wait && __cpp_aligned_new
#include <bits/std_thread.h>
#include <bits/unique_ptr.h>
#include <array>
-#define __cpp_lib_barrier 201907L
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -261,6 +261,5 @@ It looks different from literature pseudocode for two main reasons:
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-#endif // __cpp_lib_atomic_wait && __cpp_aligned_new
-#endif // __cplusplus > 201703L
+#endif // defined(__cpp_lib_barrier)
#endif // _GLIBCXX_BARRIER
diff --git a/libstdc++-v3/include/std/bit b/libstdc++-v3/include/std/bit
index 5eb40218be9..1728f851fcc 100644
--- a/libstdc++-v3/include/std/bit
+++ b/libstdc++-v3/include/std/bit
@@ -52,6 +52,13 @@ namespace __gnu_cxx
/// @endcond
#endif
+#define __glibcxx_want_bit_cast
+#define __glibcxx_want_byteswap
+#define __glibcxx_want_bitops
+#define __glibcxx_want_int_pow2
+#define __glibcxx_want_endian
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -65,8 +72,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#if __cplusplus > 201703l && __has_builtin(__builtin_bit_cast)
-#define __cpp_lib_bit_cast 201806L
+#ifdef __cpp_lib_bit_cast
/// Create a value of type `To` from the bits of `from`.
/**
@@ -86,10 +92,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
return __builtin_bit_cast(_To, __from);
}
-#endif
+#endif // defined(__cpp_lib_bit_cast)
-#if __cplusplus > 202002L
-#define __cpp_lib_byteswap 202110L
+#ifdef __cpp_lib_byteswap
/// Reverse order of bytes in the object representation of `value`.
/**
@@ -142,7 +147,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
return __val;
}
-#endif
+#endif // defined(__cpp_lib_byteswap)
/// @cond undocumented
@@ -370,9 +375,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @endcond
-#if __cplusplus > 201703L
-
-#define __cpp_lib_bitops 201907L
+#ifdef __cpp_lib_bitops
/// @cond undocumented
template<typename _Tp, typename _Up = _Tp>
@@ -425,11 +428,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr _If_is_unsigned_integer<_Tp, int>
popcount(_Tp __x) noexcept
{ return std::__popcount(__x); }
+#endif // defined(__cpp_lib_bitops)
+#ifdef __cpp_lib_int_pow2
// [bit.pow.two], integral powers of 2
-#define __cpp_lib_int_pow2 202002L
-
/// True if `x` is a power of two, false otherwise.
template<typename _Tp>
constexpr _If_is_unsigned_integer<_Tp, bool>
@@ -455,8 +458,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr _If_is_unsigned_integer<_Tp, int>
bit_width(_Tp __x) noexcept
{ return std::__bit_width(__x); }
+#endif // defined (__cpp_lib_int_pow2)
-#define __cpp_lib_endian 201907L
+#ifdef __cpp_lib_endian
/// Byte order constants
/**
@@ -471,7 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
big = __ORDER_BIG_ENDIAN__,
native = __BYTE_ORDER__
};
-#endif // C++2a
+#endif // defined(__cpp_lib_endian)
/// @}
diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset
index acd5768d6f6..a0379ed101a 100644
--- a/libstdc++-v3/include/std/bitset
+++ b/libstdc++-v3/include/std/bitset
@@ -58,6 +58,9 @@
# include <bits/functional_hash.h>
#endif
+#define __glibcxx_want_constexpr_bitset
+#include <bits/version.h>
+
#define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * __SIZEOF_LONG__)
#define _GLIBCXX_BITSET_WORDS(__n) \
((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
@@ -69,10 +72,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
-#if __cplusplus > 202002L && _GLIBCXX_HOSTED
-# define __cpp_lib_constexpr_bitset 202202L
-#endif
-
/**
* Base class, general case. It is a class invariant that _Nw will be
* nonnegative.
diff --git a/libstdc++-v3/include/std/charconv b/libstdc++-v3/include/std/charconv
index b34d672f5bd..2c523b69a7b 100644
--- a/libstdc++-v3/include/std/charconv
+++ b/libstdc++-v3/include/std/charconv
@@ -45,14 +45,9 @@
#include <bits/error_constants.h> // for std::errc
#include <ext/numeric_traits.h>
-#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
- && __SIZE_WIDTH__ >= 32 && _GLIBCXX_HOSTED
-# define __cpp_lib_to_chars 201611L
-#endif
-
-#if __cplusplus > 202002L
-# define __cpp_lib_constexpr_charconv 202207L
-#endif
+#define __glibcxx_want_to_chars
+#define __glibcxx_want_constexpr_charconv
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex
index 0f5f14c3ddb..8d488aa0e09 100644
--- a/libstdc++-v3/include/std/complex
+++ b/libstdc++-v3/include/std/complex
@@ -47,9 +47,9 @@
// Get rid of a macro possibly defined in <complex.h>
#undef complex
-#if __cplusplus > 201703L
-# define __cpp_lib_constexpr_complex 201711L
-#endif
+#define __glibcxx_want_constexpr_complex
+#define __glibcxx_want_complex_udls
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -2586,13 +2586,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return std::complex<__type>(__x, -__type());
}
-#if __cplusplus > 201103L
+#ifdef __cpp_lib_complex_udls
inline namespace literals {
inline namespace complex_literals {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"
-#define __cpp_lib_complex_udls 201309L
constexpr std::complex<float>
operator""if(long double __num)
@@ -2622,7 +2621,7 @@ inline namespace complex_literals {
} // inline namespace complex_literals
} // inline namespace literals
-#endif // C++14
+#endif // defined(__cpp_lib_complex_udls)
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/std/concepts b/libstdc++-v3/include/std/concepts
index d77f7e5647a..6f789faf82b 100644
--- a/libstdc++-v3/include/std/concepts
+++ b/libstdc++-v3/include/std/concepts
@@ -30,10 +30,12 @@
#ifndef _GLIBCXX_CONCEPTS
#define _GLIBCXX_CONCEPTS 1
-#if __cplusplus > 201703L && __cpp_concepts >= 201907L
-
#pragma GCC system_header
+#define __glibcxx_want_concepts
+#include <bits/version.h>
+
+#ifdef __cpp_lib_concepts
/**
* @defgroup concepts Concepts
* @ingroup utilities
@@ -47,8 +49,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_concepts 202002L
-
// [concepts.lang], language-related concepts
namespace __detail
@@ -376,6 +376,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-#endif // C++2a
+#endif // defined(__cpp_lib_concepts)
#endif /* _GLIBCXX_CONCEPTS */
diff --git a/libstdc++-v3/include/std/coroutine b/libstdc++-v3/include/std/coroutine
index b0ca18949db..fc806963590 100644
--- a/libstdc++-v3/include/std/coroutine
+++ b/libstdc++-v3/include/std/coroutine
@@ -31,8 +31,14 @@
#pragma GCC system_header
-// It is very likely that earlier versions would work, but they are untested.
-#if __cplusplus >= 201402L
+#define __glibcxx_want_coroutine
+#include <bits/version.h>
+
+#if !__cpp_impl_coroutine
+# error "the <coroutine> header requires -fcoroutines"
+#endif
+
+#ifdef __cpp_lib_coroutine
#include <type_traits>
#if __cplusplus > 201703L
@@ -55,10 +61,6 @@ namespace std _GLIBCXX_VISIBILITY (default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if __cpp_impl_coroutine
-
-#define __cpp_lib_coroutine 201902L
-
inline namespace __n4861 {
// C++20 17.12.2 coroutine traits
@@ -351,13 +353,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
};
-#else
-#error "the <coroutine> header requires -fcoroutines"
-#endif
-
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++14 (we are allowing use from at least this)
+#endif // __cpp_lib_coroutine
#endif // _GLIBCXX_COROUTINE
diff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque
index e3d50d2cf8b..004b01201ad 100644
--- a/libstdc++-v3/include/std/deque
+++ b/libstdc++-v3/include/std/deque
@@ -68,6 +68,9 @@
#include <bits/range_access.h>
#include <bits/deque.tcc>
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
#ifdef _GLIBCXX_DEBUG
# include <debug/deque>
#endif
@@ -86,13 +89,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++17
-#if __cplusplus > 201703L
+#ifdef __cpp_lib_erase_if
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_erase_if 202002L
-
template<typename _Tp, typename _Alloc, typename _Predicate>
inline typename deque<_Tp, _Alloc>::size_type
erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred)
@@ -134,6 +135,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // defined(__cpp_lib_erase_if)
#endif /* _GLIBCXX_DEQUE */
diff --git a/libstdc++-v3/include/std/execution b/libstdc++-v3/include/std/execution
index 14c8bbeef4f..ba4d44fd2fb 100644
--- a/libstdc++-v3/include/std/execution
+++ b/libstdc++-v3/include/std/execution
@@ -29,7 +29,11 @@
#include <bits/requires_hosted.h> // execution policies are hosted only
-#if __cplusplus >= 201703L
+#define __glibcxx_want_parallel_algorithm
+#define __glibcxx_want_execution
+#include <bits/version.h>
+
+#if defined(__cpp_lib_parallel_algorithm) || defined(__cpp_lib_execution)
# include <bits/c++config.h>
# include <pstl/glue_execution_defs.h>
@@ -50,10 +54,6 @@
# include <pstl/glue_memory_impl.h>
# endif
-// Feature test macro for parallel algorithms
-# define __cpp_lib_parallel_algorithm 201603L
-# define __cpp_lib_execution 201902L
-
#endif // C++17
#endif /* _GLIBCXX_EXECUTION */
diff --git a/libstdc++-v3/include/std/expected b/libstdc++-v3/include/std/expected
index c6d26b0d224..ce6378bd150 100644
--- a/libstdc++-v3/include/std/expected
+++ b/libstdc++-v3/include/std/expected
@@ -31,8 +31,10 @@
#pragma GCC system_header
-#if __cplusplus > 202002L && __cpp_concepts >= 202002L
+#define __glibcxx_want_expected
+#include <bits/version.h>
+#ifdef __cpp_lib_expected
#include <initializer_list>
#include <bits/exception.h> // exception
#include <bits/invoke.h> // __invoke
@@ -50,8 +52,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#define __cpp_lib_expected 202211L
-
/// Discriminated union that holds an expected value or an error value.
/**
* @since C++23
@@ -1817,5 +1817,5 @@ namespace __expected
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++23
+#endif // defined(__cpp_lib_expected)
#endif // _GLIBCXX_EXPECTED
diff --git a/libstdc++-v3/include/std/filesystem b/libstdc++-v3/include/std/filesystem
index d46e842826d..a88d13f14e4 100644
--- a/libstdc++-v3/include/std/filesystem
+++ b/libstdc++-v3/include/std/filesystem
@@ -34,7 +34,10 @@
#include <bits/requires_hosted.h>
-#if __cplusplus >= 201703L
+#define __glibcxx_want_filesystem
+#include <bits/version.h>
+
+#ifdef __cpp_lib_filesystem
/**
* @defgroup filesystem File System
@@ -50,8 +53,6 @@
#include <bits/fs_dir.h>
#include <bits/fs_ops.h>
-#define __cpp_lib_filesystem 201703L
-
-#endif // C++17
+#endif // __cpp_lib_filesystem
#endif // _GLIBCXX_FILESYSTEM
diff --git a/libstdc++-v3/include/std/format b/libstdc++-v3/include/std/format
index 6edc3208afa..0433b3a71b8 100644
--- a/libstdc++-v3/include/std/format
+++ b/libstdc++-v3/include/std/format
@@ -33,7 +33,10 @@
#include <bits/requires_hosted.h> // for std::string
-#if __cplusplus >= 202002L
+#define __glibcxx_want_format
+#include <bits/version.h>
+
+#ifdef __cpp_lib_format
#include <array>
#include <charconv>
@@ -60,18 +63,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-// 201907 Text Formatting, Integration of chrono, printf corner cases.
-// 202106 std::format improvements.
-// 202110 Fixing locale handling in chrono formatters, generator-like types.
-// 202207 Encodings in localized formatting of chrono, basic-format-string.
-#define __cpp_lib_format 202106L
-
-#if __cplusplus > 202002L
-// 202207 P2286R8 Formatting Ranges
-// 202207 P2585R1 Improving default container formatting
-// TODO: #define __cpp_lib_format_ranges 202207L
-#endif
-
// [format.context], class template basic_format_context
template<typename _Out, typename _CharT> class basic_format_context;
@@ -3989,5 +3980,5 @@ namespace __format
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // __cpp_lib_format
#endif // _GLIBCXX_FORMAT
diff --git a/libstdc++-v3/include/std/forward_list b/libstdc++-v3/include/std/forward_list
index 1c110df971b..7c029986095 100644
--- a/libstdc++-v3/include/std/forward_list
+++ b/libstdc++-v3/include/std/forward_list
@@ -45,6 +45,9 @@
# include <debug/forward_list>
#endif
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
@@ -59,13 +62,10 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++17
-#if __cplusplus > 201703L
+#ifdef __cpp_lib_erase_if
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
-#define __cpp_lib_erase_if 202002L
-
template<typename _Tp, typename _Alloc, typename _Predicate>
inline typename forward_list<_Tp, _Alloc>::size_type
erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred)
@@ -82,7 +82,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // defined(__cpp_lib_erase_if)
#endif // C++11
diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index c7c6a5a7924..dd72051f8f6 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -48,6 +48,14 @@
#include <bits/c++config.h>
#include <bits/stl_function.h> // std::equal_to, std::unary_function etc.
+#define __glibcxx_want_invoke
+#define __glibcxx_want_constexpr_functional
+#define __glibcxx_want_invoke_r
+#define __glibcxx_want_bind_front
+#define __glibcxx_want_not_fn
+#define __glibcxx_want_boyer_moore_searcher
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <tuple>
@@ -86,13 +94,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<int _Num> struct _Placeholder { };
-#if __cplusplus >= 201103L
-
-#if __cplusplus >= 201703L
-# define __cpp_lib_invoke 201411L
-# if __cplusplus > 201703L
-# define __cpp_lib_constexpr_functional 201907L
-# endif
+#ifdef __cpp_lib_invoke
/** Invoke a callable object.
*
@@ -113,9 +115,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return std::__invoke(std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
+#endif
-#if __cplusplus > 202002L
-# define __cpp_lib_invoke_r 202106L
+#ifdef __cpp_lib_invoke_r
/** Invoke a callable object and convert the result to `_Res`.
*
@@ -133,11 +135,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return std::__invoke_r<_Res>(std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
-#endif // C++23
-#endif // C++17
+#endif // defined(__cpp_lib_invoke_r)
/// @cond undocumented
+#if __cplusplus >= 201103L
template<typename _MemFunPtr,
bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
class _Mem_fn_base
@@ -910,8 +912,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
std::forward<_BoundArgs>(__args)...);
}
-#if __cplusplus > 201703L
-#define __cpp_lib_bind_front 201907L
+#ifdef __cpp_lib_bind_front
template<typename _Fd, typename... _BoundArgs>
struct _Bind_front
@@ -1077,7 +1078,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return _Bind_front_t<_Fn, _Args...>(0, std::forward<_Fn>(__fn),
std::forward<_Args>(__args)...);
}
-#endif // C++20
+#endif // defined(__cpp_lib_bind_front)
#if __cplusplus >= 201402L
/// Generalized negator.
@@ -1147,9 +1148,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
struct __is_byte_like<byte, equal_to<void>>
: true_type { };
+#endif
// [func.not_fn] Function template not_fn
-#define __cpp_lib_not_fn 201603L
+#ifdef __cpp_lib_not_fn
/** Wrap a function object to create one that negates its result.
*
* The function template `std::not_fn` creates a "forwarding call wrapper",
@@ -1170,7 +1172,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
}
+#endif
+#if __cplusplus >= 201703L
// Searchers
template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
@@ -1203,8 +1207,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
};
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_boyer_moore_searcher 201603L
+#ifdef __cpp_lib_boyer_moore_searcher
template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
struct __boyer_moore_map_base
@@ -1448,7 +1451,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
return std::make_pair(__last, __last);
}
-#endif // HOSTED
+#endif // defined(__cpp_lib_boyer_moore_searcher)
#endif // C++17
#endif // C++14
diff --git a/libstdc++-v3/include/std/iomanip b/libstdc++-v3/include/std/iomanip
index 5c0fb09a60e..a2555a269da 100644
--- a/libstdc++-v3/include/std/iomanip
+++ b/libstdc++-v3/include/std/iomanip
@@ -41,6 +41,9 @@
#include <iosfwd>
#include <bits/ios_base.h>
+#define __glibcxx_want_quoted_string_io
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <locale>
#if __cplusplus > 201103L
@@ -448,9 +451,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __is;
}
-#if __cplusplus >= 201402L
-
-#define __cpp_lib_quoted_string_io 201304L
+#ifdef __cpp_lib_quoted_string_io
/**
* @brief Manipulator for quoted strings.
@@ -500,7 +501,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
basic_string_view<_CharT, _Traits>, _CharT>(__sv, __delim, __escape);
}
#endif // C++17
-#endif // C++14
+#endif // defined(__cpp_lib_quoted_string_io)
#endif // __cplusplus >= 201103L
diff --git a/libstdc++-v3/include/std/iterator b/libstdc++-v3/include/std/iterator
index 695e18e2c47..8c8670fbdf0 100644
--- a/libstdc++-v3/include/std/iterator
+++ b/libstdc++-v3/include/std/iterator
@@ -67,9 +67,8 @@
#endif
#include <bits/range_access.h>
-#if __cplusplus >= 201402L && ! defined _GLIBCXX_DEBUG // PR libstdc++/70303
-# define __cpp_lib_null_iterators 201304L
-#endif
+#define __glibcxx_want_null_iterators
+#include <bits/version.h>
#if __cplusplus >= 202002L
#include <bits/ranges_base.h> // ranges::distance, ranges::next, ranges::prev
diff --git a/libstdc++-v3/include/std/latch b/libstdc++-v3/include/std/latch
index a5a92fad919..357f3fe795e 100644
--- a/libstdc++-v3/include/std/latch
+++ b/libstdc++-v3/include/std/latch
@@ -33,18 +33,17 @@
#include <bits/requires_hosted.h> // concurrency
-#if __cplusplus > 201703L
+#define __glibcxx_want_latch
+#include <bits/version.h>
+#ifdef __cpp_lib_latch
#include <bits/atomic_base.h>
#include <ext/numeric_traits.h>
-#if __cpp_lib_atomic_wait
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_latch 201907L
-
class latch
{
public:
@@ -91,6 +90,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-#endif // __cpp_lib_atomic_wait
-#endif // __cplusplus > 201703L
+#endif // defined(__cpp_lib_latch)
#endif // _GLIBCXX_LATCH
diff --git a/libstdc++-v3/include/std/list b/libstdc++-v3/include/std/list
index 48861b9a340..84d284f683b 100644
--- a/libstdc++-v3/include/std/list
+++ b/libstdc++-v3/include/std/list
@@ -69,6 +69,9 @@
# include <debug/list>
#endif
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
@@ -83,13 +86,10 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++17
-#if __cplusplus > 201703L
+#ifdef __cpp_lib_erase_if
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
-#define __cpp_lib_erase_if 202002L
-
template<typename _Tp, typename _Alloc, typename _Predicate>
inline typename list<_Tp, _Alloc>::size_type
erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred)
@@ -106,6 +106,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // defined(__cpp_lib_erase_if)
#endif /* _GLIBCXX_LIST */
diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory
index 85c36d67ee1..ff271cbcf9d 100644
--- a/libstdc++-v3/include/std/memory
+++ b/libstdc++-v3/include/std/memory
@@ -91,11 +91,9 @@
# include <bits/uses_allocator_args.h>
#endif
-/* As a hack, we declare __cpp_lib_atomic_value_initialization here even though
- we don't include the bit that actually declares it, for consistency. */
-#if !defined(__cpp_lib_atomic_value_initialization) && __cplusplus >= 202002L
-# define __cpp_lib_atomic_value_initialization 201911L
-#endif
+#define __glibcxx_want_atomic_value_initialization
+#define __glibcxx_want_parallel_algorithm
+#include <bits/version.h>
#if __cplusplus >= 201103L && __cplusplus <= 202002L && _GLIBCXX_HOSTED
namespace std _GLIBCXX_VISIBILITY(default)
@@ -144,7 +142,7 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // C++11 to C++20
-#if __cplusplus >= 201703L && _GLIBCXX_HOSTED
+#ifdef __cpp_lib_parallel_algorithm
// Parallel STL algorithms
# if _PSTL_EXECUTION_POLICIES_DEFINED
// If <execution> has already been included, pull in implementations
@@ -153,9 +151,6 @@ _GLIBCXX_END_NAMESPACE_VERSION
// Otherwise just pull in forward declarations
# include <pstl/glue_memory_defs.h>
# endif
-
-// Feature test macro for parallel algorithms
-# define __cpp_lib_parallel_algorithm 201603L
-#endif // C++17
+#endif // __cpp_lib_parallel_algorithm
#endif /* _GLIBCXX_MEMORY */
diff --git a/libstdc++-v3/include/std/memory_resource b/libstdc++-v3/include/std/memory_resource
index fdfc23c95ed..64c481f74fd 100644
--- a/libstdc++-v3/include/std/memory_resource
+++ b/libstdc++-v3/include/std/memory_resource
@@ -36,6 +36,10 @@
#include <bits/requires_hosted.h> // polymorphic allocation
+#define __glibcxx_want_polymorphic_allocator
+#define __glibcxx_want_memory_resource
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
/**
@@ -68,16 +72,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace pmr
{
-#ifdef _GLIBCXX_HAS_GTHREADS
- // Header and all contents are present.
-# define __cpp_lib_memory_resource 201603L
-#else
- // The pmr::synchronized_pool_resource type is missing.
-# define __cpp_lib_memory_resource 1
-#endif
-#if __cplusplus >= 202002L
-# define __cpp_lib_polymorphic_allocator 201902L
+#ifdef __cpp_lib_polymorphic_allocator
template<typename _Tp = std::byte>
class polymorphic_allocator;
#endif
@@ -111,7 +107,7 @@ namespace pmr
// Pool resource classes
struct pool_options;
-#ifdef _GLIBCXX_HAS_GTHREADS
+#if __cpp_lib_memory_resource >= 201603L
class synchronized_pool_resource;
#endif
class unsynchronized_pool_resource;
@@ -182,7 +178,7 @@ namespace pmr
const int _M_npools;
};
-#ifdef _GLIBCXX_HAS_GTHREADS
+#if __cpp_lib_memory_resource >= 201603L
/// A thread-safe memory resource that manages pools of fixed-size blocks.
/**
* @ingroup pmr
@@ -252,7 +248,7 @@ namespace pmr
_TPools* _M_tpools = nullptr;
mutable shared_mutex _M_mx;
};
-#endif
+#endif // __cpp_lib_memory_resource >= 201603L
/// A non-thread-safe memory resource that manages pools of fixed-size blocks.
/**
diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex
index 79420388abc..b2bef926b35 100644
--- a/libstdc++-v3/include/std/mutex
+++ b/libstdc++-v3/include/std/mutex
@@ -54,6 +54,9 @@
# include <bits/std_function.h> // std::function
#endif
+#define __glibcxx_want_scoped_lock
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -726,8 +729,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
}
-#if __cplusplus >= 201703L
-#define __cpp_lib_scoped_lock 201703L
+#ifdef __cpp_lib_scoped_lock
/** @brief A scoped lock type for multiple lockable objects.
*
* A scoped_lock controls mutex ownership within a scope, releasing
@@ -791,7 +793,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private:
mutex_type& _M_device;
};
-#endif // C++17
+#endif // defined(__cpp_lib_scoped_lock)
#ifdef _GLIBCXX_HAS_GTHREADS
/// Flag type used by std::call_once
diff --git a/libstdc++-v3/include/std/numbers b/libstdc++-v3/include/std/numbers
index d7d9e81e540..8c7030c159b 100644
--- a/libstdc++-v3/include/std/numbers
+++ b/libstdc++-v3/include/std/numbers
@@ -31,7 +31,10 @@
#pragma GCC system_header
-#if __cplusplus > 201703L
+#define __glibcxx_want_math_constants
+#include <bits/version.h>
+
+#ifdef __cpp_lib_math_constants
#include <type_traits>
@@ -47,7 +50,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Namespace for mathematical constants
namespace numbers
{
-#define __cpp_lib_math_constants 201907L
/// @cond undocumented
template<typename _Tp>
@@ -230,5 +232,5 @@ __glibcxx_numbers (__float128, Q);
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // __cpp_lib_math_constants
#endif // _GLIBCXX_NUMBERS
diff --git a/libstdc++-v3/include/std/numeric b/libstdc++-v3/include/std/numeric
index 514db936623..4b5513e026b 100644
--- a/libstdc++-v3/include/std/numeric
+++ b/libstdc++-v3/include/std/numeric
@@ -79,6 +79,14 @@
# include <limits>
#endif
+#define __glibcxx_want_constexpr_numeric
+#define __glibcxx_want_gcd
+#define __glibcxx_want_gcd_lcm
+#define __glibcxx_want_interpolate
+#define __glibcxx_want_lcm
+#define __glibcxx_want_parallel_algorithm
+#include <bits/version.h>
+
/**
* @defgroup numerics Numerics
*
@@ -150,14 +158,9 @@ namespace __detail
}
}
} // namespace __detail
+#endif // C++14
-#if __cplusplus >= 201703L
-
-#define __cpp_lib_gcd_lcm 201606L
-// These were used in drafts of SD-6:
-#define __cpp_lib_gcd 201606L
-#define __cpp_lib_lcm 201606L
-
+#ifdef __cpp_lib_gcd_lcm
/// Greatest common divisor
template<typename _Mn, typename _Nn>
constexpr common_type_t<_Mn, _Nn>
@@ -198,14 +201,10 @@ namespace __detail
return __r;
}
-#endif // C++17
-#endif // C++14
-
-#if __cplusplus > 201703L
+#endif // __cpp_lib_gcd_lcm
// midpoint
-# define __cpp_lib_interpolate 201902L
-
+#ifdef __cpp_lib_interpolate 201902L
template<typename _Tp>
constexpr
enable_if_t<__and_v<is_arithmetic<_Tp>, is_same<remove_cv_t<_Tp>, _Tp>,
@@ -251,14 +250,9 @@ namespace __detail
static_assert( sizeof(_Tp) != 0, "type must be complete" );
return __a + (__b - __a) / 2;
}
-#endif // C++20
+#endif // __cpp_lib_interpolate
#if __cplusplus >= 201703L
-
-#if __cplusplus > 201703L
-#define __cpp_lib_constexpr_numeric 201911L
-#endif
-
/// @addtogroup numeric_ops
/// @{
@@ -739,9 +733,6 @@ _GLIBCXX_END_NAMESPACE_VERSION
# include <pstl/glue_numeric_defs.h>
# define _PSTL_NUMERIC_FORWARD_DECLARED 1
# endif
-
-// Feature test macro for parallel algorithms
-# define __cpp_lib_parallel_algorithm 201603L
#endif // C++17
#endif /* _GLIBCXX_NUMERIC */
diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index bcac1522701..c3ee1325529 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -32,7 +32,10 @@
#pragma GCC system_header
-#if __cplusplus >= 201703L
+#define __glibcxx_want_optional
+#include <bits/version.h>
+
+#ifdef __cpp_lib_optional
#include <type_traits>
#include <exception>
@@ -60,14 +63,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#if __cplusplus > 202002L && __cpp_lib_concepts
-# define __cpp_lib_optional 202110L
-#elif __cplusplus >= 202002L
-# define __cpp_lib_optional 202106L
-#else
-# define __cpp_lib_optional 201606L
-#endif
-
template<typename _Tp>
class optional;
@@ -1507,6 +1502,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++17
+#endif // __cpp_lib_optional
#endif // _GLIBCXX_OPTIONAL
diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index c4d4d85bf90..4704287f3bc 100644
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -34,6 +34,19 @@
#pragma GCC system_header
+#define __glibcxx_want_ranges_as_const
+#define __glibcxx_want_ranges_as_rvalue
+#define __glibcxx_want_ranges_cartesian_product
+#define __glibcxx_want_ranges_chunk
+#define __glibcxx_want_ranges_chunk_by
+#define __glibcxx_want_ranges_enumerate
+#define __glibcxx_want_ranges_join_with
+#define __glibcxx_want_ranges_repeat
+#define __glibcxx_want_ranges_slide
+#define __glibcxx_want_ranges_stride
+#define __glibcxx_want_ranges_zip
+#include <bits/version.h>
+
#include <concepts>
#if __cpp_lib_concepts
@@ -4390,10 +4403,7 @@ namespace views::__adaptor
inline constexpr auto values = elements<1>;
} // namespace views
-#if __cplusplus > 202002L
-
-#define __cpp_lib_ranges_zip 202110L
-
+#ifdef __cpp_lib_ranges_zip
namespace __detail
{
template<typename... _Rs>
@@ -5831,9 +5841,9 @@ namespace views::__adaptor
inline constexpr auto pairwise_transform = adjacent_transform<2>;
}
+#endif // defined(__cpp_lib_ranges_zip)
-#define __cpp_lib_ranges_chunk 202202L
-
+#ifdef __cpp_lib_ranges_chunk
namespace __detail
{
template<typename _Tp>
@@ -6370,9 +6380,9 @@ namespace views::__adaptor
inline constexpr _Chunk chunk;
}
+#endif // defined(__cpp_lib_ranges_chunk)
-#define __cpp_lib_ranges_slide 202202L
-
+#ifdef __cpp_lib_ranges_slide
namespace __detail
{
template<typename _Vp>
@@ -6735,9 +6745,9 @@ namespace views::__adaptor
inline constexpr _Slide slide;
}
+#endif // defined(__cpp_lib_ranges_slide)
-#define __cpp_lib_ranges_chunk_by 202202L
-
+#ifdef __cpp_lib_ranges_chunk_by
template<forward_range _Vp,
indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
requires view<_Vp> && is_object_v<_Pred>
@@ -6930,9 +6940,9 @@ namespace views::__adaptor
inline constexpr _ChunkBy chunk_by;
}
+#endif // defined(__cpp_lib_ranges_chunk_by)
-#define __cpp_lib_ranges_join_with 202202L
-
+#ifdef __cpp_lib_ranges_join_with
namespace __detail
{
template<typename _Range, typename _Pattern>
@@ -7412,9 +7422,9 @@ namespace views::__adaptor
inline constexpr _JoinWith join_with;
} // namespace views
+#endif // defined(__cpp_lib_ranges_join_with)
-#define __cpp_lib_ranges_repeat 202207L
-
+#ifdef __cpp_lib_ranges_repeat
template<copy_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
&& (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
@@ -7666,9 +7676,9 @@ namespace views::__adaptor
}
}
}
+#endif // defined(__cpp_lib_ranges_repeat)
-#define __cpp_lib_ranges_stride 202207L
-
+#ifdef __cpp_lib_ranges_stride
template<input_range _Vp>
requires view<_Vp>
class stride_view : public view_interface<stride_view<_Vp>>
@@ -8019,9 +8029,9 @@ namespace views::__adaptor
inline constexpr _Stride stride;
}
+#endif // defined(__cpp_lib_ranges_stride)
-#define __cpp_lib_ranges_cartesian_product 202207L
-
+#ifdef __cpp_lib_ranges_cartesian_product
namespace __detail
{
template<bool _Const, typename _First, typename... _Vs>
@@ -8542,9 +8552,9 @@ namespace views::__adaptor
inline constexpr _CartesianProduct cartesian_product;
}
+#endif // defined(__cpp_lib_ranges_cartesian_product)
-#define __cpp_lib_ranges_as_rvalue 202207L
-
+#ifdef __cpp_lib_ranges_as_rvalue
template<input_range _Vp>
requires view<_Vp>
class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
@@ -8634,9 +8644,9 @@ namespace views::__adaptor
inline constexpr _AsRvalue as_rvalue;
}
+#endif // defined(__cpp_lib_as_rvalue)
-#define __cpp_lib_ranges_enumerate 202302L
-
+#ifdef __cpp_lib_ranges_enumerate
namespace __detail
{
template<typename _Range>
@@ -8937,9 +8947,9 @@ namespace views::__adaptor
inline constexpr _Enumerate enumerate;
}
+#endif // defined(__cpp_lib_ranges_enumerate)
-#define __cpp_lib_ranges_as_const 202207L
-
+#ifdef __cpp_lib_ranges_as_const
template<view _Vp>
requires input_range<_Vp>
class as_const_view : public view_interface<as_const_view<_Vp>>
@@ -9043,7 +9053,7 @@ namespace views::__adaptor
inline constexpr _AsConst as_const;
}
-#endif // C++23
+#endif // defined(__cpp_lib_as_const)
} // namespace ranges
namespace views = ranges::views;
diff --git a/libstdc++-v3/include/std/semaphore b/libstdc++-v3/include/std/semaphore
index dfc272f6d35..3831c5696a0 100644
--- a/libstdc++-v3/include/std/semaphore
+++ b/libstdc++-v3/include/std/semaphore
@@ -36,13 +36,14 @@
#if __cplusplus > 201703L
#include <bits/semaphore_base.h>
-#if __cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE
+#define __glibcxx_want_semaphore 201907L
+#include <bits/version.h>
+
+#ifdef __cpp_lib_semaphore
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_semaphore 201907L
-
template<ptrdiff_t __least_max_value = __semaphore_impl::_S_max>
class counting_semaphore
{
@@ -93,5 +94,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE
-#endif // C++20
+#endif // defined(__cpp_lib_semaphore)
#endif // _GLIBCXX_SEMAPHORE
diff --git a/libstdc++-v3/include/std/shared_mutex b/libstdc++-v3/include/std/shared_mutex
index 124da614061..f553e8fef1d 100644
--- a/libstdc++-v3/include/std/shared_mutex
+++ b/libstdc++-v3/include/std/shared_mutex
@@ -41,6 +41,10 @@
#include <bits/move.h> // move, __exchange
#include <bits/std_mutex.h> // defer_lock_t
+#define __glibcxx_want_shared_mutex
+#define __glibcxx_want_shared_timed_mutex
+#include <bits/version.h>
+
#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
# include <condition_variable>
#endif
@@ -56,12 +60,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef _GLIBCXX_HAS_GTHREADS
-#if __cplusplus >= 201703L
-#define __cpp_lib_shared_mutex 201505L
+#ifdef __cpp_lib_shared_mutex
class shared_mutex;
#endif
-#define __cpp_lib_shared_timed_mutex 201402L
class shared_timed_mutex;
/// @cond undocumented
@@ -407,7 +409,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
/// @endcond
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_shared_mutex
/// The standard shared mutex type.
class shared_mutex
{
@@ -441,7 +443,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__shared_mutex_cv _M_impl;
#endif
};
-#endif // C++17
+#endif // defined(__cpp_lib_shared_mutex)
/// @cond undocumented
#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
diff --git a/libstdc++-v3/include/std/source_location b/libstdc++-v3/include/std/source_location
index 9f492826268..7409d67ca66 100644
--- a/libstdc++-v3/include/std/source_location
+++ b/libstdc++-v3/include/std/source_location
@@ -29,15 +29,16 @@
#ifndef _GLIBCXX_SRCLOC
#define _GLIBCXX_SRCLOC 1
-#if __cplusplus > 201703L && __has_builtin(__builtin_source_location)
+#define __glibcxx_want_source_location
+#include <bits/version.h>
+
+#if __cpp_lib_source_location
#include <bits/c++config.h>
namespace std
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_source_location 201907L
-
/// A class that describes a location in source code.
struct source_location
{
@@ -88,5 +89,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20 && __builtin_source_location
+#endif // defined(__cpp_lib_source_location)
#endif // _GLIBCXX_SRCLOC
diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span
index 67633899665..e9db531387b 100644
--- a/libstdc++-v3/include/std/span
+++ b/libstdc++-v3/include/std/span
@@ -36,20 +36,18 @@
#pragma GCC system_header
-#if __cplusplus > 201703L
+#define __glibcxx_want_span
+#include <bits/version.h>
+#ifdef __cpp_lib_span
#include <array>
#include <cstddef>
#include <bits/stl_iterator.h>
#include <bits/ranges_base.h>
-
-#if __cpp_lib_concepts
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_span 202002L
-
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
template<typename _Type, size_t _Extent>
@@ -476,6 +474,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // concepts
-#endif // C++20
+#endif // defined(__cpp_lib_span)
#endif // _GLIBCXX_SPAN
diff --git a/libstdc++-v3/include/std/spanstream b/libstdc++-v3/include/std/spanstream
index 483996b274f..4fe5193677b 100644
--- a/libstdc++-v3/include/std/spanstream
+++ b/libstdc++-v3/include/std/spanstream
@@ -33,20 +33,20 @@
#include <bits/requires_hosted.h> // iostreams
-#if __cplusplus > 202002L
+#define __glibcxx_want_spanstream
+#include <bits/version.h>
+
+#ifdef __cpp_lib_spanstream
#include <span>
#include <streambuf>
#include <istream>
#include <ostream>
#include <bits/ranges_base.h>
-#if __cpp_lib_span
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_spanstream 202106L
-
template<typename _CharT, typename _Traits>
class basic_spanbuf
: public basic_streambuf<_CharT, _Traits>
@@ -451,6 +451,5 @@ using wspanstream = basic_spanstream<wchar_t>;
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // __cpp_lib_span
-#endif // C++23
+#endif // defined(__cpp_lib_spanstream)
#endif // _GLIBCXX_SPANSTREAM
diff --git a/libstdc++-v3/include/std/stacktrace b/libstdc++-v3/include/std/stacktrace
index 346c7b14142..f8581cab9a4 100644
--- a/libstdc++-v3/include/std/stacktrace
+++ b/libstdc++-v3/include/std/stacktrace
@@ -30,7 +30,10 @@
#include <bits/c++config.h>
-#if __cplusplus > 202002L && _GLIBCXX_HAVE_STACKTRACE
+#define __glibcxx_want_stacktrace
+#include <bits/version.h>
+
+#ifdef __cpp_lib_stacktrace
#include <compare>
#include <new>
#include <string>
@@ -83,8 +86,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_stacktrace 202011L
-
// [stacktrace.entry], class stacktrace_entry
class stacktrace_entry
{
@@ -800,6 +801,5 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++23
-
+#endif // __cpp_lib_stacktrace
#endif /* _GLIBCXX_STACKTRACE */
diff --git a/libstdc++-v3/include/std/stop_token b/libstdc++-v3/include/std/stop_token
index c90fc786b63..3be0f5a3ac4 100644
--- a/libstdc++-v3/include/std/stop_token
+++ b/libstdc++-v3/include/std/stop_token
@@ -31,6 +31,9 @@
#include <bits/requires_hosted.h> // concurrency
+#define __glibcxx_want_jthread
+#include <bits/version.h>
+
#if __cplusplus > 201703L
#include <atomic>
@@ -38,8 +41,6 @@
#include <semaphore>
-#define __cpp_lib_jthread 201911L
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string
index dd4ece12801..bde0227ccc7 100644
--- a/libstdc++-v3/include/std/string
+++ b/libstdc++-v3/include/std/string
@@ -54,6 +54,9 @@
#include <bits/basic_string.h>
#include <bits/basic_string.tcc>
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
#if __cplusplus >= 201703L && _GLIBCXX_USE_CXX11_ABI
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
@@ -75,13 +78,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++17
-#if __cplusplus > 201703L
+#ifdef __cpp_lib_erase_if
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_erase_if 202002L
-
template<typename _CharT, typename _Traits, typename _Alloc,
typename _Predicate>
_GLIBCXX20_CONSTEXPR
@@ -112,6 +113,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // defined(__cpp_lib_erase_if)
#endif /* _GLIBCXX_STRING */
diff --git a/libstdc++-v3/include/std/string_view b/libstdc++-v3/include/std/string_view
index be9036a20a3..5680ca7d030 100644
--- a/libstdc++-v3/include/std/string_view
+++ b/libstdc++-v3/include/std/string_view
@@ -35,6 +35,12 @@
#pragma GCC system_header
+#define __glibcxx_want_string_view
+#define __glibcxx_want_constexpr_string_view
+#define __glibcxx_want_starts_ends_with
+#define __glibcxx_want_string_contains
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/char_traits.h>
@@ -57,14 +63,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if _GLIBCXX_HOSTED
-# define __cpp_lib_string_view 201803L
-#endif
-
-#if __cplusplus > 201703L
-# define __cpp_lib_constexpr_string_view 201811L
-#endif
-
// Helper for basic_string and basic_string_view members.
constexpr size_t
__sv_check(size_t __size, size_t __pos, const char* __s)
@@ -380,8 +378,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
.compare(basic_string_view(__str, __n2));
}
-#if __cplusplus > 201703L
-#define __cpp_lib_starts_ends_with 201711L
+#ifdef __cpp_lib_starts_ends_with
[[nodiscard]]
constexpr bool
starts_with(basic_string_view __x) const noexcept
@@ -416,13 +413,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr bool
ends_with(const _CharT* __x) const noexcept
{ return this->ends_with(basic_string_view(__x)); }
-#endif // C++20
+#endif // defined(__cpp_lib_starts_ends_with)
#if __cplusplus > 202002L
-#if _GLIBCXX_HOSTED
+#if _GLIBCXX_HOSTED && !defined(__cpp_lib_string_contains)
// This FTM is not freestanding as it also implies matching <string>
// support, and <string> is omitted from the freestanding subset.
-# define __cpp_lib_string_contains 202011L
+# error "libstdc++ bug: string_contents not defined when it should be"
#endif // HOSTED
[[nodiscard]]
constexpr bool
diff --git a/libstdc++-v3/include/std/syncstream b/libstdc++-v3/include/std/syncstream
index 3788b71ecdd..416a27a83ae 100644
--- a/libstdc++-v3/include/std/syncstream
+++ b/libstdc++-v3/include/std/syncstream
@@ -29,17 +29,16 @@
#ifndef _GLIBCXX_SYNCSTREAM
#define _GLIBCXX_SYNCSTREAM 1
-#if __cplusplus > 201703L
-
-#include <bits/c++config.h>
-#if _GLIBCXX_USE_CXX11_ABI
-
-#define __cpp_lib_syncbuf 201803L
-
#pragma GCC system_header
#include <bits/requires_hosted.h> // iostreams
+#include <bits/c++config.h>
+
+#define __glibcxx_want_syncbuf
+#include <bits/version.h>
+
+#ifdef __cpp_lib_syncbuf
#include <sstream>
#include <bits/alloc_traits.h>
@@ -314,6 +313,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using wosyncstream = basic_osyncstream<wchar_t>;
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // _GLIBCXX_USE_CXX11_ABI
-#endif // C++2a
+#endif // defined(__cpp_lib_syncbuf)
+
#endif /* _GLIBCXX_SYNCSTREAM */
diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread
index ee2dc36158b..2c049edcbd6 100644
--- a/libstdc++-v3/include/std/thread
+++ b/libstdc++-v3/include/std/thread
@@ -45,6 +45,9 @@
#include <bits/std_thread.h> // std::thread, get_id, yield
#include <bits/this_thread_sleep.h> // std::this_thread::sleep_for, sleep_until
+#define __glibcxx_want_jthread
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index 0e47abed573..2a9bee45105 100644
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -42,9 +42,14 @@
#if __cplusplus > 201703L
# include <compare>
# include <bits/ranges_util.h> // for std::ranges::subrange
-# define __cpp_lib_constexpr_tuple 201811L
#endif
+#define __glibcxx_want_constexpr_tuple
+#define __glibcxx_want_tuples_by_type
+#define __glibcxx_want_apply
+#define __glibcxx_want_make_from_tuple
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -1820,10 +1825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
get(const tuple<_Elements...>&) = delete;
/// @endcond
-#if __cplusplus >= 201402L
-
-#define __cpp_lib_tuples_by_type 201304L
-
+#ifdef __cpp_lib_tuples_by_type
/// Return a reference to the unique element of type _Tp of a tuple.
template <typename _Tp, typename... _Types>
constexpr _Tp&
@@ -2254,8 +2256,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
{ }
-#if __cplusplus >= 201703L
-
+#if defined(__cpp_lib_apply) || defined(__cpp_lib_make_from_tuple)
// Unpack a std::tuple into a type trait and use its value.
// For cv std::tuple<_Up> the result is _Trait<_Tp, cv _Up...>::value.
// For cv std::tuple<_Up>& the result is _Trait<_Tp, cv _Up&...>::value.
@@ -2278,9 +2279,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<template<typename...> class _Trait, typename _Tp, typename... _Up>
inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
= _Trait<_Tp, const _Up&...>::value;
+#endif
-# define __cpp_lib_apply 201603L
-
+#ifdef __cpp_lib_apply
template <typename _Fn, typename _Tuple, size_t... _Idx>
constexpr decltype(auto)
__apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
@@ -2300,9 +2301,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
std::forward<_Tuple>(__t),
_Indices{});
}
+#endif
-#define __cpp_lib_make_from_tuple 201606L
-
+#ifdef __cpp_lib_make_from_tuple
template <typename _Tp, typename _Tuple, size_t... _Idx>
constexpr _Tp
__make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
@@ -2324,7 +2325,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
make_index_sequence<__n>{});
}
-#endif // C++17
+#endif
#if __cplusplus > 202002L
template<typename... _TTypes, typename... _UTypes,
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 2bd607a8b8f..37d27af28b4 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -37,6 +37,31 @@
#include <bits/c++config.h>
+#define __glibcxx_want_bool_constant
+#define __glibcxx_want_bounded_array_traits
+#define __glibcxx_want_has_unique_object_representations
+#define __glibcxx_want_integral_constant_callable
+#define __glibcxx_want_is_aggregate
+#define __glibcxx_want_is_constant_evaluated
+#define __glibcxx_want_is_final
+#define __glibcxx_want_is_invocable
+#define __glibcxx_want_is_layout_compatible
+#define __glibcxx_want_is_nothrow_convertible
+#define __glibcxx_want_is_null_pointer
+#define __glibcxx_want_is_pointer_interconvertible
+#define __glibcxx_want_is_scoped_enum
+#define __glibcxx_want_is_swappable
+#define __glibcxx_want_logical_traits
+#define __glibcxx_want_reference_from_temporary
+#define __glibcxx_want_remove_cvref
+#define __glibcxx_want_result_of_sfinae
+#define __glibcxx_want_transformation_trait_aliases
+#define __glibcxx_want_type_identity
+#define __glibcxx_want_type_trait_variable_templates
+#define __glibcxx_want_unwrap_ref
+#define __glibcxx_want_void_t
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -65,10 +90,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const noexcept { return value; }
-#if __cplusplus > 201103L
-
-#define __cpp_lib_integral_constant_callable 201304L
+#ifdef __cpp_lib_integral_constant_callable
constexpr value_type operator()() const noexcept { return value; }
#endif
};
@@ -90,8 +113,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __bool_constant = integral_constant<bool, __v>;
/// @endcond
-#if __cplusplus >= 201703L
-# define __cpp_lib_bool_constant 201505L
+#ifdef __cpp_lib_bool_constant
/// Alias template for compile-time boolean constant types.
/// @since C++17
template<bool __v>
@@ -183,7 +205,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
/// @endcond
-#if __cplusplus >= 201703L
+#ifdef __cpp_lib_logical_traits
/// @cond undocumented
template<typename... _Bn>
@@ -211,8 +233,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} // namespace __detail
/// @endcond
-#define __cpp_lib_logical_traits 201510L
-
template<typename... _Bn>
struct conjunction
: __detail::__conjunction_impl<void, _Bn...>::type
@@ -251,7 +271,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline constexpr bool negation_v = negation<_Pp>::value;
/// @}
-#endif // C++17
+#endif // defined(__cpp_lib_logical_traits)
// Forward declarations
template<typename>
@@ -606,8 +626,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct is_function<_Tp&&>
: public false_type { };
-#define __cpp_lib_is_null_pointer 201309L
-
+#ifdef __cpp_lib_is_null_pointer
/// is_null_pointer (LWG 2247).
template<typename _Tp>
struct is_null_pointer
@@ -635,6 +654,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ } _GLIBCXX_DEPRECATED_SUGGEST("std::is_null_pointer");
+#endif // defined(__cpp_lib_is_null_pointer)
// Composite type categories.
@@ -849,8 +869,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
-#if __cplusplus >= 201402L
-#define __cpp_lib_is_final 201402L
+#ifdef __cpp_lib_is_final
/// is_final
/// @since C++14
template<typename _Tp>
@@ -1459,8 +1478,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __is_array_convertible
= is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
-#if __cplusplus >= 202002L
-#define __cpp_lib_is_nothrow_convertible 201806L
+#ifdef __cpp_lib_is_nothrow_convertible
#if __has_builtin(__is_nothrow_convertible)
/// is_nothrow_convertible_v
@@ -1514,7 +1532,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline constexpr bool is_nothrow_convertible_v
= is_nothrow_convertible<_From, _To>::value;
#endif
-#endif // C++2a
+#endif // defined(__cpp_lib_is_nothrow_convertible)
// Const-volatile modifications.
@@ -1574,10 +1592,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct add_cv
{ using type = _Tp const volatile; };
-#if __cplusplus > 201103L
-
-#define __cpp_lib_transformation_trait_aliases 201304L
-
+#ifdef __cpp_lib_transformation_trait_aliases
/// Alias template for remove_const
template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;
@@ -2396,8 +2411,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Sfinae-friendly result_of implementation:
-#define __cpp_lib_result_of_sfinae 201210L
-
/// @cond undocumented
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
@@ -2626,8 +2639,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using result_of_t = typename result_of<_Tp>::type;
#endif // C++14
-#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11
-#define __cpp_lib_void_t 201411L
+#ifdef __cpp_lib_void_t
/// A metafunction that always yields void, used for detecting valid types.
template<typename...> using void_t = void;
#endif
@@ -2784,8 +2796,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
/// @endcond
-#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
-#define __cpp_lib_is_swappable 201603L
+#ifdef __cpp_lib_is_swappable
/// Metafunctions used for detecting swappable types: p0185r1
/// is_swappable
@@ -2914,7 +2925,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
is_nothrow_swappable_with<_Tp, _Up>::value;
#endif // __cplusplus >= 201402L
-#endif// c++1z or gnu++11
+#endif // defined(__cpp_lib_is_swappable)
/// @cond undocumented
@@ -3053,9 +3064,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#pragma GCC diagnostic pop
/// @endcond
-#if __cplusplus >= 201703L
-# define __cpp_lib_is_invocable 201703L
-
+#ifdef __cpp_lib_is_invocable
/// std::invoke_result
template<typename _Functor, typename... _ArgTypes>
struct invoke_result
@@ -3134,10 +3143,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
"_Ret must be a complete class or an unbounded array");
};
-#endif // C++17
+#endif // defined(__cpp_lib_is_invocable)
-#if __cplusplus >= 201703L
-# define __cpp_lib_type_trait_variable_templates 201510L
+#if __cpp_lib_type_trait_variable_templates
/**
* @defgroup variable_templates Variable templates for type traits
* @ingroup metaprogramming
@@ -3373,9 +3381,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
inline constexpr bool is_nothrow_invocable_r_v
= is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
/// @}
+#endif // defined(__cpp_lib_type_trait_variable_templates)
-#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
-# define __cpp_lib_has_unique_object_representations 201606L
+#ifdef __cpp_lib_has_unique_object_representations
/// has_unique_object_representations
/// @since C++17
template<typename _Tp>
@@ -3388,14 +3396,15 @@ template<typename _Ret, typename _Fn, typename... _Args>
"template argument must be a complete class or an unbounded array");
};
+# if __cpp_lib_type_trait_variable_templates
/// @ingroup variable_templates
template<typename _Tp>
inline constexpr bool has_unique_object_representations_v
= has_unique_object_representations<_Tp>::value;
+# endif
#endif
-#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
-# define __cpp_lib_is_aggregate 201703L
+#ifdef __cpp_lib_is_aggregate
/// is_aggregate - true if the type is an aggregate.
/// @since C++17
template<typename _Tp>
@@ -3403,28 +3412,26 @@ template<typename _Ret, typename _Fn, typename... _Args>
: bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
{ };
+# if __cpp_lib_type_trait_variable_templates
/** is_aggregate_v - true if the type is an aggregate.
* @ingroup variable_templates
* @since C++17
*/
template<typename _Tp>
inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>);
+# endif
#endif
-#endif // C++17
-
-#if __cplusplus >= 202002L
/** * Remove references and cv-qualifiers.
* @since C++20
* @{
*/
-#define __cpp_lib_remove_cvref 201711L
-
-#if __has_builtin(__remove_cvref)
+#ifdef __cpp_lib_remove_cvref
+# if __has_builtin(__remove_cvref)
template<typename _Tp>
struct remove_cvref
{ using type = __remove_cvref(_Tp); };
-#else
+# else
template<typename _Tp>
struct remove_cvref
{ using type = typename remove_cv<_Tp>::type; };
@@ -3436,26 +3443,27 @@ template<typename _Ret, typename _Fn, typename... _Args>
template<typename _Tp>
struct remove_cvref<_Tp&&>
{ using type = typename remove_cv<_Tp>::type; };
-#endif
+# endif
template<typename _Tp>
using remove_cvref_t = typename remove_cvref<_Tp>::type;
/// @}
+#endif // defined(__cpp_lib_remove_cvref)
+#ifdef __cpp_lib_type_identity
/** * Identity metafunction.
* @since C++20
* @{
*/
-#define __cpp_lib_type_identity 201806L
template<typename _Tp>
struct type_identity { using type = _Tp; };
template<typename _Tp>
using type_identity_t = typename type_identity<_Tp>::type;
/// @}
+#endif
-#define __cpp_lib_unwrap_ref 201811L
-
+#ifdef __cpp_lib_unwrap_ref
/** Unwrap a reference_wrapper
* @since C++20
* @{
@@ -3480,9 +3488,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
template<typename _Tp>
using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
/// @}
+#endif // defined(__cpp_lib_unwrap_ref)
-#define __cpp_lib_bounded_array_traits 201902L
-
+#ifdef __cpp_lib_bounded_array_traits
/// True for a type that is an array of known bound.
/// @ingroup variable_templates
/// @since C++20
@@ -3514,8 +3522,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
struct is_unbounded_array
: public bool_constant<is_unbounded_array_v<_Tp>>
{ };
+#endif // __cpp_lib_bounded_array_traits
-#if __has_builtin(__is_layout_compatible)
+#if __has_builtin(__is_layout_compatible) && __cplusplus >= 202002L
/// @since C++20
template<typename _Tp, typename _Up>
@@ -3530,7 +3539,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
= __is_layout_compatible(_Tp, _Up);
#if __has_builtin(__builtin_is_corresponding_member)
-#define __cpp_lib_is_layout_compatible 201907L
+# ifndef __cpp_lib_is_layout_compatible
+# error "libstdc++ bug: is_corresponding_member and is_layout_compatible are provided but their FTM is not set?"
+# endif
/// @since C++20
template<typename _S1, typename _S2, typename _M1, typename _M2>
@@ -3540,7 +3551,8 @@ template<typename _Ret, typename _Fn, typename... _Args>
#endif
#endif
-#if __has_builtin(__is_pointer_interconvertible_base_of)
+#if __has_builtin(__is_pointer_interconvertible_base_of) \
+ && __cplusplus >= 202002L
/// True if `_Derived` is standard-layout and has a base class of type `_Base`
/// @since C++20
template<typename _Base, typename _Derived>
@@ -3555,7 +3567,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
= __is_pointer_interconvertible_base_of(_Base, _Derived);
#if __has_builtin(__builtin_is_pointer_interconvertible_with_class)
-#define __cpp_lib_is_pointer_interconvertible 201907L
+# ifndef __cpp_lib_is_pointer_interconvertible
+# error "libstdc++ bug: is_pointer_interconvertible available but FTM unset?"
+# endif
/// True if `__mp` points to the first member of a standard-layout type
/// @returns true if `s.*__mp` is pointer-interconvertible with `s`
@@ -3567,9 +3581,7 @@ template<typename _Ret, typename _Fn, typename... _Args>
#endif
#endif
-#if __cplusplus > 202002L
-#define __cpp_lib_is_scoped_enum 202011L
-
+#ifdef __cpp_lib_is_scoped_enum
/// True if the type is a scoped enumeration type.
/// @since C++23
@@ -3589,12 +3601,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
/// @since C++23
template<typename _Tp>
inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
+#endif
-#if __has_builtin(__reference_constructs_from_temporary) \
- && __has_builtin(__reference_converts_from_temporary)
-
-#define __cpp_lib_reference_from_temporary 202202L
-
+#ifdef __cpp_lib_reference_from_temporary
/// True if _Tp is a reference type, a _Up value can be bound to _Tp in
/// direct-initialization, and a temporary object would be bound to
/// the reference, false otherwise.
@@ -3632,12 +3641,9 @@ template<typename _Ret, typename _Fn, typename... _Args>
template<typename _Tp, typename _Up>
inline constexpr bool reference_converts_from_temporary_v
= reference_converts_from_temporary<_Tp, _Up>::value;
-#endif // __has_builtin for reference_from_temporary
-#endif // C++23
-
-#if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-#define __cpp_lib_is_constant_evaluated 201811L
+#endif // define(__cpp_lib_reference_from_temporary)
+#ifdef __cpp_lib_is_constant_evaluated
/// Returns true only when called during constant evaluation.
/// @since C++20
constexpr inline bool
@@ -3651,6 +3657,7 @@ template<typename _Ret, typename _Fn, typename... _Args>
}
#endif
+#if __cplusplus >= 202002L
/// @cond undocumented
template<typename _From, typename _To>
using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type;
diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility
index 006b19c00fc..d5ba2e6642d 100644
--- a/libstdc++-v3/include/std/utility
+++ b/libstdc++-v3/include/std/utility
@@ -68,6 +68,14 @@
#include <bits/stl_relops.h>
#include <bits/stl_pair.h>
+#define __glibcxx_want_exchange_function
+#define __glibcxx_want_constexpr_algorithms
+#define __glibcxx_want_as_const
+#define __glibcxx_want_integer_comparison_functions
+#define __glibcxx_want_to_underlying
+#define __glibcxx_want_unreachable
+#include <bits/version.h>
+
#if __cplusplus >= 201103L
#include <initializer_list>
@@ -83,13 +91,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if __cplusplus >= 201402L
-#define __cpp_lib_exchange_function 201304L
-
-#if __cplusplus > 201703L
-# define __cpp_lib_constexpr_algorithms 201806L
-#endif
-
+#ifdef __cpp_lib_exchange_function
/// Assign @p __new_val to @p __obj and return its previous value.
template <typename _Tp, typename _Up = _Tp>
_GLIBCXX20_CONSTEXPR
@@ -98,10 +100,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_assignable<_Tp&, _Up>>::value)
{ return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+#endif
-#if __cplusplus >= 201703L
-
-#define __cpp_lib_as_const 201510L
+#ifdef __cpp_lib_as_const
template<typename _Tp>
[[nodiscard]]
constexpr add_const_t<_Tp>&
@@ -110,10 +111,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
void as_const(const _Tp&&) = delete;
+#endif
-#if __cplusplus > 201703L
-#define __cpp_lib_integer_comparison_functions 202002L
-
+#ifdef __cpp_lib_integer_comparison_functions
template<typename _Tp, typename _Up>
constexpr bool
cmp_equal(_Tp __t, _Up __u) noexcept
@@ -181,17 +181,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
else
return __t <= make_unsigned_t<_Up>(__int_traits<_Up>::__max);
}
+#endif // __cpp_lib_integer_comparison_functions
-#if __cplusplus > 202002L
-#define __cpp_lib_to_underlying 202102L
+#ifdef __cpp_lib_to_underlying
/// Convert an object of enumeration type to its underlying type.
template<typename _Tp>
[[nodiscard]]
constexpr underlying_type_t<_Tp>
to_underlying(_Tp __value) noexcept
{ return static_cast<underlying_type_t<_Tp>>(__value); }
+#endif
-#define __cpp_lib_unreachable 202202L
+#ifdef __cpp_lib_unreachable
/// Informs the compiler that program control flow never reaches this point.
/**
* Evaluating a call to this function results in undefined behaviour.
@@ -216,10 +217,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__builtin_unreachable();
#endif
}
-#endif // C++23
-#endif // C++20
-#endif // C++17
-#endif // C++14
+#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant
index 5155124522f..a6b0c6ecdb8 100644
--- a/libstdc++-v3/include/std/variant
+++ b/libstdc++-v3/include/std/variant
@@ -31,8 +31,10 @@
#pragma GCC system_header
-#if __cplusplus >= 201703L
+#define __glibcxx_want_variant
+#include <bits/version.h>
+#ifdef __cpp_lib_variant
#include <initializer_list>
#include <type_traits>
#include <bits/enable_special_members.h>
@@ -47,12 +49,8 @@
# include <compare>
#endif
-#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L
-// P2231R1 constexpr needs constexpr unions and constrained destructors.
-# define __cpp_lib_variant 202106L
-#else
+#if __cpp_lib_variant < 202106L
# include <ext/aligned_buffer.h> // Use __aligned_membuf instead of union.
-# define __cpp_lib_variant 202102L
#endif
namespace std _GLIBCXX_VISIBILITY(default)
@@ -1941,6 +1939,5 @@ namespace __variant
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++17
-
+#endif // __cpp_lib_variant
#endif // _GLIBCXX_VARIANT
diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector
index 712087f1bdd..f4abbb62714 100644
--- a/libstdc++-v3/include/std/vector
+++ b/libstdc++-v3/include/std/vector
@@ -76,6 +76,9 @@
# include <debug/vector>
#endif
+#define __glibcxx_want_erase_if
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
@@ -96,13 +99,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++17
-#if __cplusplus > 201703L
+#ifdef __cpp_lib_erase_if
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#define __cpp_lib_erase_if 202002L
-
template<typename _Tp, typename _Alloc, typename _Predicate>
_GLIBCXX20_CONSTEXPR
inline typename vector<_Tp, _Alloc>::size_type
@@ -146,6 +147,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // C++20
+#endif // defined(__cpp_lib_erase_if)
#endif /* _GLIBCXX_VECTOR */
diff --git a/libstdc++-v3/libsupc++/compare b/libstdc++-v3/libsupc++/compare
index 8fa960eff47..2b0af1fc854 100644
--- a/libstdc++-v3/libsupc++/compare
+++ b/libstdc++-v3/libsupc++/compare
@@ -32,14 +32,13 @@
#pragma GCC system_header
+#define __glibcxx_want_three_way_comparison
+#include <bits/version.h>
+
#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
#include <concepts>
-#if __cpp_lib_concepts
-# define __cpp_lib_three_way_comparison 201907L
-#endif
-
namespace std _GLIBCXX_VISIBILITY(default)
{
// [cmp.categories], comparison category types
@@ -448,7 +447,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
using common_comparison_category_t
= typename common_comparison_category<_Ts...>::type;
-#if __cpp_lib_concepts
+#if __cpp_lib_three_way_comparison >= 201907L
namespace __detail
{
template<typename _Tp, typename _Cat>
@@ -1239,7 +1238,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
= decltype(__detail::__synth3way(std::declval<_Tp&>(),
std::declval<_Up&>()));
} // namespace __detail
-#endif // concepts
+#endif // __cpp_lib_three_way_comparison >= 201907L
} // namespace std
#endif // C++20
diff --git a/libstdc++-v3/libsupc++/exception b/libstdc++-v3/libsupc++/exception
index a34386e6026..be1919fcf53 100644
--- a/libstdc++-v3/libsupc++/exception
+++ b/libstdc++-v3/libsupc++/exception
@@ -35,6 +35,9 @@
#include <bits/c++config.h>
#include <bits/exception.h>
+#define __glibcxx_want_uncaught_exceptions
+#include <bits/version.h>
+
extern "C++" {
namespace std _GLIBCXX_VISIBILITY(default)
@@ -121,8 +124,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
_GLIBCXX17_DEPRECATED_SUGGEST("std::uncaught_exceptions()")
bool uncaught_exception() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
-#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++98
-#define __cpp_lib_uncaught_exceptions 201411L
+#ifdef __cpp_lib_uncaught_exceptions
/** The number of uncaught exceptions.
* @since C++17, or any non-strict mode, e.g. `-std=gnu++98`
* @see uncaught_exception()
diff --git a/libstdc++-v3/libsupc++/new b/libstdc++-v3/libsupc++/new
index 082053fc4d9..030e1446344 100644
--- a/libstdc++-v3/libsupc++/new
+++ b/libstdc++-v3/libsupc++/new
@@ -40,6 +40,11 @@
#include <bits/c++config.h>
#include <bits/exception.h>
+#define __glibcxx_want_launder
+#define __glibcxx_want_hardware_interference_size
+#define __glibcxx_want_destroying_delete
+#include <bits/version.h>
+
#pragma GCC visibility push(default)
extern "C++" {
@@ -185,8 +190,7 @@ inline void operator delete[](void*, void*) _GLIBCXX_USE_NOEXCEPT { }
#if __cplusplus >= 201703L
namespace std
{
-#ifdef _GLIBCXX_HAVE_BUILTIN_LAUNDER
-#define __cpp_lib_launder 201606L
+#ifdef __cpp_lib_launder
/// Pointer optimization barrier [ptr.launder]
template<typename _Tp>
[[nodiscard]] constexpr _Tp*
@@ -205,16 +209,16 @@ namespace std
void launder(const void*) = delete;
void launder(volatile void*) = delete;
void launder(const volatile void*) = delete;
-#endif // _GLIBCXX_HAVE_BUILTIN_LAUNDER
+#endif // __cpp_lib_launder
-#ifdef __GCC_DESTRUCTIVE_SIZE
-# define __cpp_lib_hardware_interference_size 201703L
+#ifdef __cpp_lib_hardware_interference_size
inline constexpr size_t hardware_destructive_interference_size = __GCC_DESTRUCTIVE_SIZE;
inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
-#endif // __GCC_DESTRUCTIVE_SIZE
+#endif // __cpp_lib_hardware_interference_size
}
#endif // C++17
+// Emitted despite the FTM potentially being undefined.
#if __cplusplus > 201703L
namespace std
{
@@ -227,10 +231,6 @@ namespace std
/// Tag variable of type destroying_delete_t.
inline constexpr destroying_delete_t destroying_delete{};
}
-// Only define the feature test macro if the compiler supports the feature:
-#if __cpp_impl_destroying_delete
-# define __cpp_lib_destroying_delete 201806L
-#endif
#endif // C++20
#pragma GCC visibility pop
diff --git a/libstdc++-v3/libsupc++/typeinfo b/libstdc++-v3/libsupc++/typeinfo
index 4cce6cb414b..bb4ed438dd6 100644
--- a/libstdc++-v3/libsupc++/typeinfo
+++ b/libstdc++-v3/libsupc++/typeinfo
@@ -36,12 +36,11 @@
#include <bits/hash_bytes.h>
#endif
+#define __glibcxx_want_constexpr_typeinfo
+#include <bits/version.h>
+
#pragma GCC visibility push(default)
-#if __cplusplus >= 202100L
-# define __cpp_lib_constexpr_typeinfo 202106L
-#endif
-
extern "C++" {
namespace __cxxabiv1
diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
index 7d99b331fde..889d4aa2e0b 100644
--- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
+++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
@@ -26,6 +26,6 @@ int n1 = std::get<1>(a);
int n2 = std::get<1>(std::move(a));
int n3 = std::get<1>(ca);
-// { dg-error "static assertion failed" "" { target *-*-* } 386 }
-// { dg-error "static assertion failed" "" { target *-*-* } 395 }
-// { dg-error "static assertion failed" "" { target *-*-* } 404 }
+// { dg-error "static assertion failed" "" { target *-*-* } 389 }
+// { dg-error "static assertion failed" "" { target *-*-* } 398 }
+// { dg-error "static assertion failed" "" { target *-*-* } 407 }
--
2.40.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* Ping: [PATCH 0/2] Unify and deduplicate FTM code
2023-04-29 10:16 [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
2023-04-29 10:16 ` [PATCH 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović
2023-04-29 10:16 ` [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović
@ 2023-05-08 23:08 ` Arsen Arsenović
2 siblings, 0 replies; 9+ messages in thread
From: Arsen Arsenović @ 2023-05-08 23:08 UTC (permalink / raw)
To: Arsen Arsenović; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 126 bytes --]
Ping.
This patch rebases cleanly as of right now. No new changes to review.
Have a lovely day!
--
Arsen Arsenović
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 381 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 1/2] libstdc++: Implement more maintainable <version> header
2023-04-29 10:16 ` [PATCH 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović
@ 2023-06-01 20:06 ` Jonathan Wakely
2023-08-07 17:22 ` Arsen Arsenović
0 siblings, 1 reply; 9+ messages in thread
From: Jonathan Wakely @ 2023-06-01 20:06 UTC (permalink / raw)
To: Arsen Arsenović; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 4591 bytes --]
On Sat, 29 Apr 2023 at 11:25, Arsen Arsenović via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> This commit replaces the ad-hoc logic in <version> with an AutoGen
> database that (mostly) declaratively generates a version.h bit which
> combines all of the FTM logic across all headers together.
>
> This generated header defines macros of the form __glibcxx_foo,
> equivalent to their __cpp_lib_foo variants, according to rules specified
> in version.def and, optionally, if __glibcxx_want_foo or
> __glibcxx_want_all are defined, also defines __cpp_lib_foo forms with
> the same definition.
>
> libstdc++-v3/ChangeLog:
>
> * include/Makefile.am (bits_freestanding): Add version.h.
> (allcreated): Add version.h.
> (${bits_srcdir}/version.h): New rule. Regenerates
> version.h out of version.{def,tpl}.
> * include/Makefile.in: Regenerate.
> * include/bits/version.def: New file. Declares a list of
> all feature test macros, their values and their preconditions.
> * include/bits/version.tpl: New file. Turns version.def
> into a sequence of #if blocks.
> * include/bits/version.h: New file. Generated from
> version.def.
> * include/std/version: Replace with a __glibcxx_want_all define
> and bits/version.h include.
> ---
> libstdc++-v3/include/Makefile.am | 10 +-
> libstdc++-v3/include/Makefile.in | 10 +-
> libstdc++-v3/include/bits/version.def | 1591 ++++++++++++++++++++
> libstdc++-v3/include/bits/version.h | 1937 +++++++++++++++++++++++++
> libstdc++-v3/include/bits/version.tpl | 209 +++
> libstdc++-v3/include/std/version | 350 +----
> 6 files changed, 3758 insertions(+), 349 deletions(-)
> create mode 100644 libstdc++-v3/include/bits/version.def
> create mode 100644 libstdc++-v3/include/bits/version.h
> create mode 100644 libstdc++-v3/include/bits/version.tpl
>
> diff --git a/libstdc++-v3/include/Makefile.am
> b/libstdc++-v3/include/Makefile.am
> index a880e8ee227..a07b4c18585 100644
> --- a/libstdc++-v3/include/Makefile.am
> +++ b/libstdc++-v3/include/Makefile.am
> @@ -154,6 +154,7 @@ bits_freestanding = \
> ${bits_srcdir}/stl_raw_storage_iter.h \
> ${bits_srcdir}/stl_relops.h \
> ${bits_srcdir}/stl_uninitialized.h \
> + ${bits_srcdir}/version.h \
> ${bits_srcdir}/string_view.tcc \
> ${bits_srcdir}/uniform_int_dist.h \
> ${bits_srcdir}/unique_ptr.h \
> @@ -1113,7 +1114,8 @@ allcreated = \
> ${host_builddir}/c++config.h \
> ${host_builddir}/largefile-config.h \
> ${thread_host_headers} \
> - ${pch_build}
> + ${pch_build} \
> + ${bits_srcdir}/version.h
>
> # Here are the rules for building the headers
> all-local: ${allstamped} ${allcreated}
> @@ -1463,6 +1465,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
> -mkdir -p ${pch3_output_builddir}
> $(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
>
> +# AutoGen <bits/version.h>.
> +${bits_srcdir}/version.h: ${bits_srcdir}/version.def \
> + ${bits_srcdir}/version.tpl
> + cd $(@D) && \
> + autogen version.def
>
It looks like this will regenerate the bits/version.h file if it's older
than the definitions or the autogen template, right?
Generally we don't want to touch anything in the source tree as part of a
normal build. It's OK to do that when configured with
--enable-maintainer-mode (which nobody working on libstdc++ actually uses,
because it causes problems IME) or via a dedicated target which is not
built by default (e.g. doc/Makefile.am has the doc-html-docbook-regenerate
target, which is isn't a prereq of any other targets so it's only run if
you explicitly request it).
The problem with modifying the source tree as part of a normal build is
that it might be on read-only media, and so the build will fail if this
target can't be updated. We would also want to add the version.h header to
the contrib/gcc_update script that updates the timestamps of generated
files, so that they are always newer than their prereqs.
Maybe the best option here is to assume that version.h is always up to
date, and add a custom target to regen it manually, which we can run after
editing the .def or .tpl files. What do you think?
My only other concern with this patch is that I don't speak lisp so the
Guile code in version.tpl is opaque and unmaintainable for me. That is
fixable though.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use
2023-04-29 10:16 ` [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović
@ 2023-06-01 20:30 ` Jonathan Wakely
2023-08-07 17:34 ` Arsen Arsenović
2023-08-07 17:38 ` Arsen Arsenović
0 siblings, 2 replies; 9+ messages in thread
From: Jonathan Wakely @ 2023-06-01 20:30 UTC (permalink / raw)
To: Arsen Arsenović; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 3123 bytes --]
On Sat, 29 Apr 2023 at 11:24, Arsen Arsenović via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> libstdc++-v3/ChangeLog:
>
> * libsupc++/typeinfo: Switch to bits/version.h for
> __cpp_lib_constexpr_typeinfo.
>
>
Does this change have an impact on compilation speed?
With this change we'll be re-including bits/version.h multiple times in
most compilations, and unlike other headers the preprocessor can't optimize
away the second and subsequent times its' included, because the header
isn't idempotent.
It will only affect the preprocessing phase, which is a fraction of the
time taken by template instantiation and middle end optimizations, but I'd
like to know it's not *too* expensive before committing to this approach.
> @@ -234,9 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> return __atomic_test_and_set (&_M_i, int(__m));
> }
>
> -#if __cplusplus > 201703L
> -#define __cpp_lib_atomic_flag_test 201907L
> -
> +#ifdef __cpp_lib_atomic_flag_test
> _GLIBCXX_ALWAYS_INLINE bool
> test(memory_order __m = memory_order_seq_cst) const noexcept
> {
>
This is more "structured" and maintainable than the current ad-hoc way we
deal with FTMs, but this seems like a readability/usability regression in
terms of being able to open the header and see "ah this feature is only
available for C++20 and up". Instead you can see it's available for the
specified FTM, but now you have to go and find where that's defined, and
that's not even defined in C++, it's in the version.def file. It's also
defined in bits/version.h, but that's a generated file and so is very
verbose and long.
diff --git a/libstdc++-v3/include/bits/move_only_function.h
> b/libstdc++-v3/include/bits/move_only_function.h
> index 71d52074978..81d7d9f7c0a 100644
> --- a/libstdc++-v3/include/bits/move_only_function.h
> +++ b/libstdc++-v3/include/bits/move_only_function.h
> @@ -32,7 +32,10 @@
>
> #pragma GCC system_header
>
> -#if __cplusplus > 202002L
> +#define __glibcxx_want_move_only_function
> +#include <bits/version.h>
> +
> +#ifdef __cpp_lib_move_only_function
>
Here's another case where I think the __cplusplus > 202002L is more
discoverable.
Although maybe I'm biased, because I look at that and immediately see
"C++23 and up". Maybe the average user finds that less clear. Maybe the
average user doesn't need to look at this anyway, but I know *I* do it
fairly often.
I wonder if it would help if we kept a comment there with a (possibly
imprecise) hint about the conditions under which the feature is defined. So
in this case:
// Only defined for C++23
#ifdef __cpp_lib_move_only_function
That retains the info that's currently there, and is even more readable
than the __cplusplus check.
There's a risk that those comments would get out of step with reality,
which is one of the things this patch set aims to solve. But I think in
practice that's unlikely. std::move_only_function isn't suddenly going to
become available in C++20, or stop being available in C++23 and move to
C++26.
What do you think?
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 1/2] libstdc++: Implement more maintainable <version> header
2023-06-01 20:06 ` Jonathan Wakely
@ 2023-08-07 17:22 ` Arsen Arsenović
0 siblings, 0 replies; 9+ messages in thread
From: Arsen Arsenović @ 2023-08-07 17:22 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 1855 bytes --]
Jonathan Wakely <jwakely@redhat.com> writes:
> [...snip...]
> It looks like this will regenerate the bits/version.h file if it's older
> than the definitions or the autogen template, right?
>
> Generally we don't want to touch anything in the source tree as part of a
> normal build. It's OK to do that when configured with
> --enable-maintainer-mode (which nobody working on libstdc++ actually uses,
> because it causes problems IME) or via a dedicated target which is not
> built by default (e.g. doc/Makefile.am has the doc-html-docbook-regenerate
> target, which is isn't a prereq of any other targets so it's only run if
> you explicitly request it).
>
> The problem with modifying the source tree as part of a normal build is
> that it might be on read-only media, and so the build will fail if this
> target can't be updated. We would also want to add the version.h header to
> the contrib/gcc_update script that updates the timestamps of generated
> files, so that they are always newer than their prereqs.
>
> Maybe the best option here is to assume that version.h is always up to
> date, and add a custom target to regen it manually, which we can run after
> editing the .def or .tpl files. What do you think?
Ah, I wasn't aware of this concern. I'll make it a phony target, yeah.
> My only other concern with this patch is that I don't speak lisp so the
> Guile code in version.tpl is opaque and unmaintainable for me. That is
> fixable though.
The algorithm the code implements is quite simple, it just verifies that
the three numeric fields associated with each FTM are in a non-ascending
order (which ensures that the most broad option comes last in the
#if/#elif chain). It's a sanity check that's caught a couple of
transcription errors I made during the initial conversion.
--
Arsen Arsenović
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 381 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use
2023-06-01 20:30 ` Jonathan Wakely
@ 2023-08-07 17:34 ` Arsen Arsenović
2023-08-07 17:38 ` Arsen Arsenović
1 sibling, 0 replies; 9+ messages in thread
From: Arsen Arsenović @ 2023-08-07 17:34 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 3446 bytes --]
Jonathan Wakely <jwakely@redhat.com> writes:
> On Sat, 29 Apr 2023 at 11:24, Arsen Arsenović via Libstdc++ <
> libstdc++@gcc.gnu.org> wrote:
>
>> libstdc++-v3/ChangeLog:
>>
>> * libsupc++/typeinfo: Switch to bits/version.h for
>> __cpp_lib_constexpr_typeinfo.
>>
>>
> Does this change have an impact on compilation speed?
> With this change we'll be re-including bits/version.h multiple times in
> most compilations, and unlike other headers the preprocessor can't optimize
> away the second and subsequent times its' included, because the header
> isn't idempotent.
> It will only affect the preprocessing phase, which is a fraction of the
> time taken by template instantiation and middle end optimizations, but I'd
> like to know it's not *too* expensive before committing to this approach.
>
>> @@ -234,9 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>> return __atomic_test_and_set (&_M_i, int(__m));
>> }
>>
>> -#if __cplusplus > 201703L
>> -#define __cpp_lib_atomic_flag_test 201907L
>> -
>> +#ifdef __cpp_lib_atomic_flag_test
>> _GLIBCXX_ALWAYS_INLINE bool
>> test(memory_order __m = memory_order_seq_cst) const noexcept
>> {
>>
>
> This is more "structured" and maintainable than the current ad-hoc way we
> deal with FTMs, but this seems like a readability/usability regression in
> terms of being able to open the header and see "ah this feature is only
> available for C++20 and up". Instead you can see it's available for the
> specified FTM, but now you have to go and find where that's defined, and
> that's not even defined in C++, it's in the version.def file. It's also
> defined in bits/version.h, but that's a generated file and so is very
> verbose and long.
>
>
> diff --git a/libstdc++-v3/include/bits/move_only_function.h
>> b/libstdc++-v3/include/bits/move_only_function.h
>> index 71d52074978..81d7d9f7c0a 100644
>> --- a/libstdc++-v3/include/bits/move_only_function.h
>> +++ b/libstdc++-v3/include/bits/move_only_function.h
>> @@ -32,7 +32,10 @@
>>
>> #pragma GCC system_header
>>
>> -#if __cplusplus > 202002L
>> +#define __glibcxx_want_move_only_function
>> +#include <bits/version.h>
>> +
>> +#ifdef __cpp_lib_move_only_function
>>
>
> Here's another case where I think the __cplusplus > 202002L is more
> discoverable.
>
> Although maybe I'm biased, because I look at that and immediately see
> "C++23 and up". Maybe the average user finds that less clear. Maybe the
> average user doesn't need to look at this anyway, but I know *I* do it
> fairly often.
>
> I wonder if it would help if we kept a comment there with a (possibly
> imprecise) hint about the conditions under which the feature is defined. So
> in this case:
>
> // Only defined for C++23
> #ifdef __cpp_lib_move_only_function
>
> That retains the info that's currently there, and is even more readable
> than the __cplusplus check.
>
> There's a risk that those comments would get out of step with reality,
> which is one of the things this patch set aims to solve. But I think in
> practice that's unlikely. std::move_only_function isn't suddenly going to
> become available in C++20, or stop being available in C++23 and move to
> C++26.
>
> What do you think?
I think that's reasonable. And, yes, I doubt these conditions change
much. I'll go over the conditions and insert a hint.
--
Arsen Arsenović
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 381 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use
2023-06-01 20:30 ` Jonathan Wakely
2023-08-07 17:34 ` Arsen Arsenović
@ 2023-08-07 17:38 ` Arsen Arsenović
1 sibling, 0 replies; 9+ messages in thread
From: Arsen Arsenović @ 2023-08-07 17:38 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc-patches, libstdc++
[-- Attachment #1: Type: text/plain, Size: 1820 bytes --]
Jonathan Wakely <jwakely@redhat.com> writes:
> On Sat, 29 Apr 2023 at 11:24, Arsen Arsenović via Libstdc++ <
> libstdc++@gcc.gnu.org> wrote:
>
>> libstdc++-v3/ChangeLog:
>>
>> * libsupc++/typeinfo: Switch to bits/version.h for
>> __cpp_lib_constexpr_typeinfo.
>>
>>
> Does this change have an impact on compilation speed?
> With this change we'll be re-including bits/version.h multiple times in
> most compilations, and unlike other headers the preprocessor can't optimize
> away the second and subsequent times its' included, because the header
> isn't idempotent.
> It will only affect the preprocessing phase, which is a fraction of the
> time taken by template instantiation and middle end optimizations, but I'd
> like to know it's not *too* expensive before committing to this approach.
>
Whoops, I forgot to provide these measurements.
~/gcc/build$ time for x in $(seq 1 100); do _pfx/bin/g++ -x c++ - \
-S -o /dev/null <<< '#include <bits/stdc++.h>'; done
real 3m4.104s
user 2m53.394s
sys 0m10.132s
~/gcc/pristine-bld$ time for x in $(seq 1 100); do _pfx/bin/g++ \
-x c++ - -S -o /dev/null \
<<< '#include <bits/stdc++.h>'; done
real 2m56.430s
user 2m46.898s
sys 0m8.967s
The top is a build of gcc with (a rebase of) this patchset, and the
bottom is the merge base. The configuration for both was:
../configure --enable-languages=c++ \
--disable-libsanitizers \
--prefix="$(pwd)/_pfx"
This should imply that the difference is minor compared to compilation
time.
Of course, for preprocessing, the difference is far more significant
(same testcase, but with -E): 0m17.248s vs 0m28.382s.
This seems okay to me.
--
Arsen Arsenović
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 381 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2023-08-07 17:51 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-04-29 10:16 [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
2023-04-29 10:16 ` [PATCH 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović
2023-06-01 20:06 ` Jonathan Wakely
2023-08-07 17:22 ` Arsen Arsenović
2023-04-29 10:16 ` [PATCH 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović
2023-06-01 20:30 ` Jonathan Wakely
2023-08-07 17:34 ` Arsen Arsenović
2023-08-07 17:38 ` Arsen Arsenović
2023-05-08 23:08 ` Ping: [PATCH 0/2] Unify and deduplicate FTM code Arsen Arsenović
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).