* [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header @ 2023-08-13 19:35 Arsen Arsenović 2023-08-13 19:35 ` [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović ` (2 more replies) 0 siblings, 3 replies; 11+ messages in thread From: Arsen Arsenović @ 2023-08-13 19:35 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. --- This patchset is a rebase of https://inbox.sourceware.org/libstdc++/20230429101640.1697750-1-arsen@aarsen.me/ ... passing the same two checks (difall / vercmp) I wrote for the first pass. Testsuite runs are still pending. Changes in this revision: - Replace the ${bits_srcdir}/version.h rule with a update-version phony, - Add the new __cpp_lib_chrono value, - Add __cpp_lib_{ranges_{contains,find_last,fold,iota}}, - Add comments to various replaced conditions which summarize their condition, - Correct a few minor errors spotted in review OK for trunk (if those testsuite runs end up clean)? libstdc++-v3/include/Makefile.am | 10 +- libstdc++-v3/include/Makefile.in | 10 +- libstdc++-v3/include/bits/version.def | 1597 ++++++++++++++++++++ libstdc++-v3/include/bits/version.h | 1942 +++++++++++++++++++++++++ libstdc++-v3/include/bits/version.tpl | 210 +++ libstdc++-v3/include/std/version | 350 +---- 6 files changed, 3770 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..9c71c75393a 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>. +.PHONY: update-version +update-version: + cd ${bits_srcdir} && \ + 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..e63715e17e7 --- /dev/null +++ b/libstdc++-v3/include/bits/version.def @@ -0,0 +1,1597 @@ +// 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 = 201907; + cxxmin = 20; + hosted = yes; + }; + 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; + extra_cond = "__cpp_generic_lambdas >= 201707L"; + }; +}; + +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..5c5e7ff3264 --- /dev/null +++ b/libstdc++-v3/include/bits/version.h @@ -0,0 +1,1942 @@ +// 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 >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_chrono 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono) +# define __cpp_lib_chrono 201907L +# endif +# elif (__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 580 +#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 589 +#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 598 +#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 607 +#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 616 +#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 625 +#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 642 +#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 651 +#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 660 +#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 670 +#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 680 +#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 689 +#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 698 +#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 707 +#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 715 +#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 723 +#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 731 +#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 739 +#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 747 +#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 755 +#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 763 +#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 771 +#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 780 +#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 788 +#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 796 +#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 806 +#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 823 +#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 832 +#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 840 +#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 848 +#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 856 +#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 864 +#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 874 +#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 890 +#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 900 +#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 908 +#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 919 +#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 927 +#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 937 +#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 945 +#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 954 +#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 963 +#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 971 +#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 981 +#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 989 +#if !defined(__cpp_lib_to_array) +# if (__cplusplus >= 202002L) && (__cpp_generic_lambdas >= 201707L) +# 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 998 +#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 1006 +#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 1014 +#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 1022 +#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 1030 +#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 1038 +#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 1046 +#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 1060 +#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 1068 +#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 1076 +#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 1084 +#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 1092 +#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 1105 +#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 1114 +#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 1132 +#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 1149 +#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 1162 +#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 1171 +#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 1180 +#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 1204 +#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 1213 +#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 1222 +#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 1231 +#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 1241 +#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 1250 +#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 1259 +#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 1268 +#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 1278 +#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 1288 +#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 1297 +#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 1307 +#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 1315 +#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 1323 +#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 1331 +#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 1340 +#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 1348 +#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 1356 +#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 1367 +#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 1375 +#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 1383 +#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 1391 +#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 1399 +#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 1407 +#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 1415 +#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 1423 +#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 1431 +#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 1439 +#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 1447 +#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 1455 +#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 1463 +#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 1471 +#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 1479 +#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 1487 +#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 1495 +#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 1503 +#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 1513 +#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 1521 +#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 1530 +#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 1539 +#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 1548 +#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 1558 +#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 1568 +#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 1577 +#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..0b15eed35c3 --- /dev/null +++ b/libstdc++-v3/include/bits/version.tpl @@ -0,0 +1,210 @@ +/*{ 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 gnu++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 5264c8bff34..4963e4058f6 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -30,353 +30,9 @@ #ifndef _GLIBCXX_VERSION_INCLUDED #define _GLIBCXX_VERSION_INCLUDED -// To facilitate testsuite/17_intro/versionconflict.cc -#ifndef _GLIBCXX_TESTING_SYSHDR -# pragma GCC system_header -#endif +#pragma GCC system_header -#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.41.0 ^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use 2023-08-13 19:35 [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović @ 2023-08-13 19:35 ` Arsen Arsenović 2023-08-16 11:15 ` Jonathan Wakely 2023-08-14 15:18 ` [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović 2023-08-16 11:15 ` Jonathan Wakely 2 siblings, 1 reply; 11+ messages in thread From: Arsen Arsenović @ 2023-08-13 19:35 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/chrono: Drop __cpp_lib_chrono definition. * 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. * 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}}. * 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 | 16 +- 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 | 23 ++- 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 | 23 ++- 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 | 14 +- 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 | 10 +- libstdc++-v3/include/std/atomic | 69 +++++---- 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/chrono | 5 - 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 | 11 +- 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 | 62 ++++---- 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 | 15 +- libstdc++-v3/include/std/vector | 9 +- libstdc++-v3/libsupc++/compare | 12 +- libstdc++-v3/libsupc++/exception | 6 +- libstdc++-v3/libsupc++/new | 20 +-- libstdc++-v3/libsupc++/typeinfo | 7 +- .../array/tuple_interface/get_neg.cc | 6 +- 95 files changed, 703 insertions(+), 724 deletions(-) diff --git a/libstdc++-v3/include/bits/algorithmfwd.h b/libstdc++-v3/include/bits/algorithmfwd.h index 130943d2340..bc757c340a4 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..4152639622e 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 // C++ >= 20 /** @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 bc936ec15dd..453278e5348 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..4ce04a02dd0 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 // C++ >= 20 _GLIBCXX_ALWAYS_INLINE bool test(memory_order __m = memory_order_seq_cst) const noexcept { @@ -252,8 +250,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __atomic_load(&_M_i, &__v, int(__m)); return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL; } +#endif -#if __cpp_lib_atomic_wait +#if __cpp_lib_atomic_wait // C++ >= 20 && (linux_futex || gthread) _GLIBCXX_ALWAYS_INLINE void wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept @@ -279,7 +278,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload #endif // __cpp_lib_atomic_wait -#endif // C++20 _GLIBCXX_ALWAYS_INLINE void clear(memory_order __m = memory_order_seq_cst) noexcept 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 170a43664c9..c68e6171aba 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. @@ -1118,8 +1116,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 // C++ >= 23 /** Resize the string and call a function to fill it. * * @param __n The maximum size requested. @@ -4491,10 +4488,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { }; #endif -#if __cplusplus >= 201402L - -#define __cpp_lib_string_udls 201304L - +#ifdef __cpp_lib_string_udls // C++ >= 14 inline namespace literals { inline namespace string_literals @@ -4539,6 +4533,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 @@ -4556,7 +4551,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 0928137854b..e9b4e84af99 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 b2713d57ef1..50aca84f142 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> @@ -370,9 +374,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { }; #endif // C++20 -#if __cplusplus >= 201703L -# define __cpp_lib_chrono 201611L - +#ifdef __cpp_lib_chrono // C++ >= 17 && HOSTED /** Convert a `duration` to type `ToDur` and round down. * * If the duration cannot be represented exactly in the result type, @@ -466,7 +468,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 @@ -488,7 +490,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> @@ -1312,9 +1314,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 // C++ >= 14 && HOSTED inline namespace literals { /** ISO C++ 2014 namespace for suffixes for duration literals. @@ -1435,7 +1435,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..c56e430b068 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 // C++20 && HOSTED 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 954a1c7a58d..4c12dc895b2 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 @@ -756,9 +759,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 // C++ >= 20 && HOSTED template<typename _Kt, typename = __has_is_transparent_t<_Hash, _Kt>, typename = __has_is_transparent_t<_Equal, _Kt>> @@ -788,7 +789,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..3253eaaa233 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 // C++ >= 23 && HOSTED /// 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..0aa5980324a 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 // C++ >= 23 && HOSTED #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..16471355c19 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 // C++ >= 17 && HOSTED #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..9e2f4f3f216 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 // C++ < 20 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..9751b8e88d5 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 // C++ >= 17 /** * @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 // C++ >= 20 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 da66ff8045d..a06794c02c9 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) { @@ -3465,10 +3472,7 @@ namespace ranges inline constexpr __prev_permutation_fn prev_permutation{}; -#if __cplusplus > 202002L - -#define __cpp_lib_ranges_contains 202207L - +#if __cpp_lib_ranges_contains >= 202207L // C++ >= 23 struct __contains_fn { template<input_iterator _Iter, sentinel_for<_Iter> _Sent, @@ -3522,7 +3526,9 @@ namespace ranges inline constexpr __contains_subrange_fn contains_subrange{}; -#define __cpp_lib_ranges_iota 202202L +#endif // __cpp_lib_ranges_contains + +#if __cpp_lib_ranges_iota >= 202202L // C++ >= 23 template<typename _Out, typename _Tp> struct out_value_result @@ -3572,7 +3578,9 @@ namespace ranges inline constexpr __iota_fn iota{}; -#define __cpp_lib_ranges_find_last 202207L +#endif // __cpp_lib_ranges_iota + +#if __cpp_lib_ranges_find_last >= 202207L // C++ >= 23 struct __find_last_fn { @@ -3700,7 +3708,9 @@ namespace ranges inline constexpr __find_last_if_not_fn find_last_if_not{}; -#define __cpp_lib_ranges_fold 202207L +#endif // __cpp_lib_ranges_find_last + +#if __cpp_lib_ranges_fold >= 202207L // C++ >= 23 template<typename _Iter, typename _Tp> struct in_value_result @@ -3947,10 +3957,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..96fa79667e6 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 // C++ >= 20 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..9b5ee571c3e 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 // C++ >= 17 && HOSTED /// 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 // C++ >= 17 && HOSTED /** @{ * 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 b56b8153a89..ae2d1b7a094 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 // C++ >= 20 && HOSTED template<typename _Tp> struct atomic; diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index 2c948d5b838..33282e596b2 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 // C++ >= 20 && HOSTED 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 // C++ >= 20 && HOSTED 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 @@ -899,7 +898,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp> struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; -#if __cpp_lib_shared_ptr_arrays >= 201707L +#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED template<typename _Alloc> struct __not_alloc_shared_tag<_Sp_counted_array_base<_Alloc>> { }; #endif @@ -975,7 +974,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __p = __pi->_M_ptr(); } -#if __cpp_lib_shared_ptr_arrays >= 201707L +#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED template<typename _Tp, typename _Alloc, typename _Init> __shared_count(_Tp*& __p, const _Sp_counted_array_base<_Alloc>& __a, _Init __init) @@ -1717,7 +1716,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend __shared_ptr<_Tp1, _Lp1> __allocate_shared(const _Alloc& __a, _Args&&... __args); -#if __cpp_lib_shared_ptr_arrays >= 201707L +#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED // This constructor is non-standard, it is used by allocate_shared<T[]>. template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*> __shared_ptr(const _Sp_counted_array_base<_Alloc>& __a, 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 3abf0f69d46..637d53d6b95 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) @@ -3598,11 +3602,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 // C++ >= 17 /** * @brief Returns the value clamped between lo and hi. * @ingroup sorting_algorithms @@ -3641,8 +3643,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 /** * @brief Generate two uniformly distributed integers using a @@ -5812,9 +5813,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO } return __out; } +#endif // C++14 -#if __cplusplus > 201402L -#define __cpp_lib_sample 201603L +#ifdef __cpp_lib_sample // C++ >= 17 /// Take a random sample from a population. template<typename _PopulationIterator, typename _SampleIterator, typename _Distance, typename _UniformRandomBitGenerator> @@ -5842,8 +5843,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 2037d6c0443..2f5a4bd4fd4 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 @@ -1645,10 +1648,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 // C++ >= 14 /** * @brief Tests a range for element-wise equality. * @ingroup non_mutating_algorithms @@ -1710,7 +1710,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. @@ -1952,8 +1952,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); } -#if __cplusplus > 201103L - +#if __cpp_lib_robust_nonmodifying_seq_ops // C++ >= 14 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..608d4e96fb2 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 // C++ >= 14 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 // C++ >= 14 template<> struct plus<void> { @@ -345,7 +345,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * * @{ */ -#if __cplusplus > 201103L +#if __cpp_lib_transparent_operators // C++ >= 14 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 // C++ >= 14 /// 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 // C++ >= 14 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 // C++ >= 14 /// 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 // C++ >= 14 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 // C++ >= 14 template <> struct bit_and<void> { @@ -1416,7 +1416,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** @} */ -#if __cplusplus >= 201402L +#ifdef __cpp_lib_transparent_operators // C++ >= 14 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 b13f4f8ddbf..b75f87e056d 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 // C++ >= 14 // _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 @@ -1461,7 +1458,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Iter2> friend class move_iterator; -#if __cpp_lib_concepts +#if __cpp_lib_concepts // C++20 && concepts // _GLIBCXX_RESOLVE_LIB_DEFECTS // 3435. three_way_comparable_with<reverse_iterator<int*>, [...]> template<typename _Iter2> @@ -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 // C++ >= 20 && lib_concepts 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..82256b7f1c5 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 // C++ >= 20 && HOSTED 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..02cce9b37d8 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 // C++ >= 17 && HOSTED /** * @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..197a90987e6 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 // C++ >= 14 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..1d22578eb1e 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 // C++ >= 23 && HOSTED 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..2d09098ca86 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 // C++ >= 23 && HOSTED 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 f870f3dfa53..1cf887b028e 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 474a9a11297..5174cfbcbe2 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 @@ -963,9 +966,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// @endcond #endif -#if __cplusplus >= 201703L -# define __cpp_lib_raw_memory_algorithms 201606L - +#ifdef __cpp_lib_raw_memory_algorithms // C++ >= 17 /** * @brief Default-initializes objects in the range [first,last). * @param __first A forward iterator. @@ -1058,7 +1059,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 70ced3d101f..1a353397e07 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..d92fe79e2f2 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -1,3 +1,4 @@ + // unique_ptr implementation -*- C++ -*- // Copyright (C) 2008-2023 Free Software Foundation, Inc. @@ -43,12 +44,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 +1027,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 // C++ >= 14 && HOSTED /// @cond undocumented namespace __detail { diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h index 2f63bc5f1fa..4c9a6bae2fd 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 // C++ >= 17 && HOSTED /** * @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..a4eae74d5e9 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 // C++ >= 20 && concepts #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..bed94525642 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 // C++ >= 14 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 // C++ >= 14 /// 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 0b633262d08..52daa16c9b1 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 // C++ >= 23 #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 caa95e340c8..6461c92ebfe 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 @@ -3544,11 +3548,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // _GLIBCXX_USE_C99_MATH_FUNCS #endif // C++11 -#if __cplusplus >= 201703L - +#ifdef __cpp_lib_hypot // C++ >= 17 && HOSTED // [c.math.hypot3], three-dimensional hypotenuse -#define __cpp_lib_hypot 201603L - template<typename _Tp> inline _Tp __hypot3(_Tp __x, _Tp __y, _Tp __z) @@ -3616,12 +3617,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 // C++ >= 20 // linear interpolation -# define __cpp_lib_interpolate 201902L - template<typename _Fp> constexpr _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept @@ -3691,8 +3690,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..3cdd551d3ae 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 // C++ >= 17 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..c6ebb86e6a9 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 // C++ >= 17 && HOSTED // 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..b2afdc0a1cb 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 // C++ >= 17 #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 ad36cdad6d2..0e32d7b52d0 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 @@ -297,7 +300,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } -#if __cpp_lib_three_way_comparison && __cpp_lib_concepts +#if __cpp_lib_three_way_comparison // C++ >= 20 && lib_concepts template<typename _Tp, size_t _Nm> [[nodiscard]] constexpr __detail::__synth3way_t<_Tp> @@ -414,8 +417,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return std::move(std::get<_Int>(__arr)); } -#if __cplusplus >= 202002L && __cpp_generic_lambdas >= 201707L -#define __cpp_lib_to_array 201907L +#ifdef __cpp_lib_to_array // C++ >= 20 && __cpp_generic_lambdas >= 201707L template<typename _Tp, size_t _Nm> [[nodiscard]] constexpr array<remove_cv_t<_Tp>, _Nm> @@ -473,7 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION else __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 111df2a978b..d259239c683 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 // C++ >= 17 static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2; #endif @@ -268,7 +270,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION reinterpret_cast<void *>(-_S_alignment)); } -#if __cplusplus >= 201703L +#ifdef __cpp_lib_atomic_is_always_lock_free // C++ >= 17 static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_M_i), 0); #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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 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 // C++ >= 17 static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2; #endif @@ -1614,8 +1616,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> { @@ -1745,9 +1746,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> @@ -1762,26 +1763,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..f25f47823a2 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 // C++ >= 20 && __cpp_aligned_new && lib_atomic_wait #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..ff66ee51bf4 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 // C++ >= 20 /// 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 // C++ >= 23 /// 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 // C++ >= 20 /// @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 // C++ >= 20 // [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 // C++ >= 20 /// 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 cf2b1161014..01711d38576 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/chrono b/libstdc++-v3/include/std/chrono index 6fdc0c86a27..10e868e5a03 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -50,11 +50,6 @@ # include <bits/unique_ptr.h> #endif -#if __cplusplus >= 202002L -# undef __cpp_lib_chrono -# define __cpp_lib_chrono 201907L -#endif - namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex index a4abe9aa96a..b9e54199eaf 100644 --- a/libstdc++-v3/include/std/complex +++ b/libstdc++-v3/include/std/complex @@ -52,9 +52,9 @@ #pragma clang diagnostic ignored "-Wc99-extensions" #endif -#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) { @@ -2604,13 +2604,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return std::complex<__type>(__x, -__type()); } -#if __cplusplus > 201103L +#ifdef __cpp_lib_complex_udls // C++ >= 14 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) @@ -2640,7 +2639,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..7ca3e94635d 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 // C++ >= 20 && 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..14d0ea28b91 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 // C++ >= 14 && impl_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..259f2633453 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 // C++ >= 20 && 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..4349e2b9dd5 100644 --- a/libstdc++-v3/include/std/execution +++ b/libstdc++-v3/include/std/execution @@ -29,7 +29,12 @@ #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> + +// C++ >= 17 && HOSTED +#if defined(__cpp_lib_parallel_algorithm) || defined(__cpp_lib_execution) # include <bits/c++config.h> # include <pstl/glue_execution_defs.h> @@ -50,10 +55,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 a63557448f7..d9a1298f625 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 // C++ >= 23 && __cpp_concepts >= 202002L #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 @@ -1815,5 +1815,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..69b5a9cae28 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 // C++ >= 17 && HOSTED /** * @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 f4520ff3f74..1e0926ee660 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 // C++ >= 20 && HOSTED #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; @@ -4039,5 +4030,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..61c2c38d712 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 // C++ >= 20 && HOSTED 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 4a4b8b2b2e6..07cf884f3dd 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 // C++ >= 17 /** 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 // C++ >= 23 /** 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 // C++ >= 20 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 // C++ >= 17 /** 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 // C++ >= 17 && HOSTED 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 eb82fc584b6..58c3951c372 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 @@ -450,9 +453,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __is; } -#if __cplusplus >= 201402L - -#define __cpp_lib_quoted_string_io 201304L +#ifdef __cpp_lib_quoted_string_io // C++ >= 14 && HOSTED /** * @brief Manipulator for quoted strings. @@ -502,7 +503,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..e6847e3417e 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 // C++ >= 20 && atomic_wait #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..1f94c5a22ed 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 // C++ >= 20 && HOSTED 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..3cce72cc036 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 // C++ >= 17 && HOSTED // 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..229c6a8b140 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 // C++ >= 20 && HOSTED 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 // C++ >= 17 && hosted && gthread 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 // C++ >= 17 && hosted && gthread /// 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 2b0059fcfe8..430e9425fe1 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -56,6 +56,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 @@ -728,8 +731,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } } -#if __cplusplus >= 201703L -#define __cpp_lib_scoped_lock 201703L +#ifdef __cpp_lib_scoped_lock // C++ >= 17 && hosted && gthread /** @brief A scoped lock type for multiple lockable objects. * * A scoped_lock controls mutex ownership within a scope, releasing @@ -793,7 +795,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..ee717cccf5a 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 // C++ >= 20 #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..8c8d200021f 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 // C++ >= 17 /// 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 // C++ >= 20 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 85e814c3fb8..4f75eb96f97 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 // C++ >= 17 #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..64981cc873c 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -51,6 +51,21 @@ #include <bits/ranges_util.h> #include <bits/refwrap.h> +#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_iota +#define __glibcxx_want_ranges_iota +#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> + /** * @defgroup ranges Ranges * @@ -4390,10 +4405,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 // C++ >= 23 namespace __detail { template<typename... _Rs> @@ -5831,9 +5843,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 // C++ >= 23 namespace __detail { template<typename _Tp> @@ -6370,9 +6382,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 // C++ >= 23 namespace __detail { template<typename _Vp> @@ -6735,9 +6747,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 // C++ >= 23 template<forward_range _Vp, indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred> requires view<_Vp> && is_object_v<_Pred> @@ -6930,9 +6942,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 // C++ >= 23 namespace __detail { template<typename _Range, typename _Pattern> @@ -7412,9 +7424,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 // C++ >= 32 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 +7678,9 @@ namespace views::__adaptor } } } +#endif // defined(__cpp_lib_ranges_repeat) -#define __cpp_lib_ranges_stride 202207L - +#ifdef __cpp_lib_ranges_stride // C++ >= 23 template<input_range _Vp> requires view<_Vp> class stride_view : public view_interface<stride_view<_Vp>> @@ -8019,9 +8031,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 // C++ >= 23 namespace __detail { template<bool _Const, typename _First, typename... _Vs> @@ -8542,9 +8554,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 // C++ >= 23 template<input_range _Vp> requires view<_Vp> class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>> @@ -8634,9 +8646,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 // C++ >= 23 namespace __detail { template<typename _Range> @@ -8937,9 +8949,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 // C++ >= 23 template<view _Vp> requires input_range<_Vp> class as_const_view : public view_interface<as_const_view<_Vp>> @@ -9043,7 +9055,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..7340ab663ad 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 +#include <bits/version.h> + +#ifdef __cpp_lib_semaphore // C++ >= 20 && hosted && (atomic_wait || posix_sem) 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..cf69062a00c 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 // C++ >= 17 && hosted && gthread 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..873ee60383c 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 // C++ >= 20 && builtin_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..4ab5b54d252 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 // C++ >= 20 && concepts #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..e259318fbfa 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 // C++ >= 23 && hosted && lib_span #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..07949e70861 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 // C++ >= 23 && hosted && HAVE_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..06da5b2d44c 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 // C++ >= 20 && HOSTED 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..abe36ec91b6 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 // C++ >= 20 [[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..799cee21892 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 // C++ >= 20 && HOSTED && CXX11ABI #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 c9ea2a892b4..797d8c03112 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 // C++ >= 14 /// 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) // C++ >= 17 // 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 // C++ >= 17 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 // C++ >= 17 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 7dc5791a7c5..a1fe70aafc0 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 using value_type = _Tp; using type = integral_constant<_Tp, __v>; constexpr operator value_type() const noexcept { return value; } -#if __cplusplus > 201103L - -#define __cpp_lib_integral_constant_callable 201304L +#ifdef __cpp_lib_integral_constant_callable // C++ >= 14 constexpr value_type operator()() const noexcept { return value; } #endif }; @@ -90,8 +113,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// The type used as a compile-time boolean with false value. using false_type = __bool_constant<false>; -#if __cplusplus >= 201703L -# define __cpp_lib_bool_constant 201505L +#ifdef __cpp_lib_bool_constant // C++ >= 17 /// 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 // C++ >= 17 /// @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 // C++ >= 11 /// 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 __bool_constant<__is_polymorphic(_Tp)> { }; -#if __cplusplus >= 201402L -#define __cpp_lib_is_final 201402L +#ifdef __cpp_lib_is_final // C++ >= 14 /// 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 // C++ >= 20 #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 // C++ >= 14 /// 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 // C++ >= 17 || GNU++ >= 11 /// 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 // C++ >= 17 || GNU++ >= 11 /// 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 // C++ >= 17 /// 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 // C++ >= 17 /** * @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 // C++ >= 17 && HAS_UNIQ_OBJ_REP /// 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 // C++ >= 17 /// @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 // C++ >= 17 && builtin_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 // C++ >= 17 /** 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 // C++ >= 20 +# 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 // C++ >= 20 /** * 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 // C++ >= 20 /** 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 // C++ >= 20 /// 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 // C++ >= 23 /// 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 // C++ >= 23 && ref_{converts,constructs}_from_temp /// 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 // C++ >= 20 && HAVE_IS_CONST_EVAL /// 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..f30e802a88d 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 // C++ >= 14 /// 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 // C++ >= 17 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 // C++ >= 20 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 // C++ >= 23 /// 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 // C++ >= 23 /// 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..7cb7c3b1d4d 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 // C++ >= 17 #include <initializer_list> #include <type_traits> #include <bits/enable_special_members.h> @@ -47,14 +49,12 @@ # include <compare> #endif -#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L -// P2231R1 constexpr needs constexpr unions and constrained destructors. -# define __cpp_lib_variant 202106L -#else +// C++ < 20 || __cpp_concepts < 202002L || __cpp_constexpr < 201811L +#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) { _GLIBCXX_BEGIN_NAMESPACE_VERSION @@ -1941,6 +1941,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..bd2b4b02cb1 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 // C++ >= 20 && HOSTED 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..b133fdbcf1e 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,8 @@ 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 + // C++ >= 20 && impl_3way_comparison >= 201907 && lib_concepts namespace __detail { template<typename _Tp, typename _Cat> @@ -1239,7 +1239,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 00a6347ebe5..9f5adae13f6 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 // C++ >= 17 || GNU++ >= 03 /** 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..e937e5bbe0e 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 // C++ >= 17 && HAVE_BUILTIN_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 // C++ >= 17 && defined(gcc_dest_sz) 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.41.0 ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use 2023-08-13 19:35 ` [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović @ 2023-08-16 11:15 ` Jonathan Wakely 2023-08-16 12:47 ` Arsen Arsenović 0 siblings, 1 reply; 11+ messages in thread From: Jonathan Wakely @ 2023-08-16 11:15 UTC (permalink / raw) To: Arsen Arsenović; +Cc: gcc-patches, libstdc++ On Sun, 13 Aug 2023 at 21:16, Arsen Arsenović via Libstdc++ <libstdc++@gcc.gnu.org> wrote: > > 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/chrono: Drop __cpp_lib_chrono definition. > * 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. > * 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}}. > * 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. Thanks for adding the comments like "// C++ < 20". I think in <any> the comment on the #endif can be just __cpp_lib_any rather than defined(__cpp_lib_any). Similarly for __cpp_lib_atomic_float in <atomic>. Oh, and __cpp_lib_atomic_ref. And in <barrier>, and several others. I think I'd like those to be consistent, and usually we just name the macro in the #endif comment, sometimes abbreviated for clarity, without the explicit defined(...). For this error in <atomic> please add <> around "version" and remove the question mark: +# error "libstdc++ bug: no lock-free atomics but they were emitted in version?" Similarly, please remove the question marks from the two #errors in <type_traits>: +# error "libstdc++ bug: is_corresponding_member and is_layout_compatible are provided but their FTM is not set?" +# error "libstdc++ bug: is_pointer_interconvertible available but FTM unset?" In <string_view> you have: +# error "libstdc++ bug: string_contents not defined when it should be" That should be contains, not contents. OK for trunk with the #error changes. The #endif cleanup can be fixed in a follow-up. It seems like there's some inconsistency (probably some preexisting) about whether you use: #if __cpp_lib_xxx or #ifdef __cpp_lib_xxx That can be tidied up later. Currently we define many of the macros in the "bits" headers, e.g. in bits/stl_iterator.h +#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> We should consider only defining those in <iterator> itself. So that when other parts of the lib include bits/stl_iterator.h they don't define the macros. That would mean that __cpp_lib_make_reverse_iterator is not defined by <vector> and <string>, for example. Even though they do actually provide the features, the macro would only be defined by <version> and <iterator>. This might encourage users to include the right headers, instead of relying on transitive includes. If we do that, our own internal checks for features would all need to use: #if __glibcxx_make_reverse_iterator because they wouldn't have the __cpp_lib_xxx macro, because they only include the internal bits header not <iterator>. That's for another day though. ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use 2023-08-16 11:15 ` Jonathan Wakely @ 2023-08-16 12:47 ` Arsen Arsenović 0 siblings, 0 replies; 11+ messages in thread From: Arsen Arsenović @ 2023-08-16 12:47 UTC (permalink / raw) To: Jonathan Wakely; +Cc: gcc-patches, libstdc++ [-- Attachment #1: Type: text/plain, Size: 2711 bytes --] Jonathan Wakely <jwakely@redhat.com> writes: > [..snip..] > Thanks for adding the comments like "// C++ < 20". > > I think in <any> the comment on the #endif can be just __cpp_lib_any > rather than defined(__cpp_lib_any). Similarly for > __cpp_lib_atomic_float in <atomic>. Oh, and __cpp_lib_atomic_ref. And > in <barrier>, and several others. I think I'd like those to be > consistent, and usually we just name the macro in the #endif comment, > sometimes abbreviated for clarity, without the explicit defined(...). ACK. Fixed all of those. > For this error in <atomic> please add <> around "version" and remove > the question mark: > +# error "libstdc++ bug: no lock-free atomics but they were emitted in version?" > > Similarly, please remove the question marks from the two #errors in > <type_traits>: > +# error "libstdc++ bug: is_corresponding_member and > is_layout_compatible are provided but their FTM is not set?" > +# error "libstdc++ bug: is_pointer_interconvertible available but FTM unset?" > > In <string_view> you have: > +# error "libstdc++ bug: string_contents not defined when it should be" > That should be contains, not contents. > > OK for trunk with the #error changes. The #endif cleanup can be > fixed in a follow-up. > > It seems like there's some inconsistency (probably some preexisting) > about whether you use: > #if __cpp_lib_xxx > or > #ifdef __cpp_lib_xxx > That can be tidied up later. > > Currently we define many of the macros in the "bits" headers, e.g. in > bits/stl_iterator.h > > +#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> > > We should consider only defining those in <iterator> itself. So that > when other parts of the lib include bits/stl_iterator.h they don't > define the macros. That would mean that > __cpp_lib_make_reverse_iterator is not defined by <vector> and > <string>, for example. Even though they do actually provide the > features, the macro would only be defined by <version> and <iterator>. > This might encourage users to include the right headers, instead of > relying on transitive includes. > If we do that, our own internal checks for features would all need to use: > #if __glibcxx_make_reverse_iterator > because they wouldn't have the __cpp_lib_xxx macro, because they only > include the internal bits header not <iterator>. > > That's for another day though. Yes, that sounds quite reasonable. I like the idea that headers should export narrower FTMs. Pushed. Thanks :-) -- Arsen Arsenović [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 381 bytes --] ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-13 19:35 [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović 2023-08-13 19:35 ` [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović @ 2023-08-14 15:18 ` Arsen Arsenović 2023-08-16 11:15 ` Jonathan Wakely 2 siblings, 0 replies; 11+ messages in thread From: Arsen Arsenović @ 2023-08-14 15:18 UTC (permalink / raw) To: Arsen Arsenović; +Cc: gcc-patches, libstdc++ [-- Attachment #1: Type: text/plain, Size: 2017 bytes --] Arsen Arsenović <arsen@aarsen.me> writes: > 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. > --- > This patchset is a rebase of > https://inbox.sourceware.org/libstdc++/20230429101640.1697750-1-arsen@aarsen.me/ > > ... passing the same two checks (difall / vercmp) I wrote for the first > pass. Testsuite runs are still pending. > > Changes in this revision: > - Replace the ${bits_srcdir}/version.h rule with a update-version phony, > - Add the new __cpp_lib_chrono value, > - Add __cpp_lib_{ranges_{contains,find_last,fold,iota}}, > - Add comments to various replaced conditions which summarize their > condition, > - Correct a few minor errors spotted in review > > OK for trunk (if those testsuite runs end up clean)? Same tests as the first time around passed on x86_64-pc-linux-gnu (that is, regression testing + a large libstdc++ harness). -- Arsen Arsenović [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 381 bytes --] ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-13 19:35 [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović 2023-08-13 19:35 ` [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović 2023-08-14 15:18 ` [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović @ 2023-08-16 11:15 ` Jonathan Wakely 2 siblings, 0 replies; 11+ messages in thread From: Jonathan Wakely @ 2023-08-16 11:15 UTC (permalink / raw) To: Arsen Arsenović; +Cc: gcc-patches, libstdc++ On Sun, 13 Aug 2023 at 21:15, 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. I still don't love this change, due to the added overhead in preprocessing time. I also don't understand the Guile code in the autogen template, but that's OK too. But defining them all in one place, in a consistent form, is definitely an improvement, so that the macros in <version> are always consistent with other headers. And not having the definitions scattered around various headers is probably much easier for most maintainers to follow. I think it's a net improvement, so OK for trunk. Thanks for working on this. I wonder why we only define __cpp_lib_null_iterators for >= C++14. It was a C++14 change, but in practice it Just Works even in C++98 mode. We don't have any code pre-C++14 that makes it *not* work (except debug mode). We should revisit that. ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header @ 2023-08-16 21:38 David Edelsohn 2023-08-16 21:56 ` Jonathan Wakely 0 siblings, 1 reply; 11+ messages in thread From: David Edelsohn @ 2023-08-16 21:38 UTC (permalink / raw) To: Arsen Arsenović, Jonathan Wakely; +Cc: GCC Patches [-- Attachment #1: Type: text/plain, Size: 350 bytes --] Hi, Arsen This patch broke bootstrap because it has introduced a new GCC build requirement for autogen that is not a previous requirement to build GCC. Previously the repository has included post-processed files. +# AutoGen <bits/version.h>. +.PHONY: update-version +update-version: + cd ${bits_srcdir} && \ + autogen version.def + Thanks, David ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-16 21:38 David Edelsohn @ 2023-08-16 21:56 ` Jonathan Wakely 2023-08-16 22:20 ` Jonathan Wakely 0 siblings, 1 reply; 11+ messages in thread From: Jonathan Wakely @ 2023-08-16 21:56 UTC (permalink / raw) To: David Edelsohn; +Cc: Arsen Arsenović, GCC Patches On Wed, 16 Aug 2023 at 22:39, David Edelsohn <dje.gcc@gmail.com> wrote: > > Hi, Arsen > > This patch broke bootstrap because it has introduced a new GCC build requirement for autogen that is not a previous requirement to build GCC. Previously the repository has included post-processed files. The repo does include the generated bits/version.h file. autogen should only be needed if you modify version.dep > > +# AutoGen <bits/version.h>. > +.PHONY: update-version > +update-version: > + cd ${bits_srcdir} && \ > + autogen version.def > + > > > Thanks, David > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-16 21:56 ` Jonathan Wakely @ 2023-08-16 22:20 ` Jonathan Wakely 2023-08-16 22:36 ` David Edelsohn 0 siblings, 1 reply; 11+ messages in thread From: Jonathan Wakely @ 2023-08-16 22:20 UTC (permalink / raw) To: David Edelsohn; +Cc: Arsen Arsenović, GCC Patches On Wed, 16 Aug 2023 at 22:56, Jonathan Wakely <jwakely@redhat.com> wrote: > > On Wed, 16 Aug 2023 at 22:39, David Edelsohn <dje.gcc@gmail.com> wrote: > > > > Hi, Arsen > > > > This patch broke bootstrap because it has introduced a new GCC build requirement for autogen that is not a previous requirement to build GCC. Previously the repository has included post-processed files. > > The repo does include the generated bits/version.h file. autogen > should only be needed if you modify version.dep And I've just checked again with an x86_64-pc-linux-gnu bootstrap on a box without autogen, and it worked. > > > > > +# AutoGen <bits/version.h>. > > +.PHONY: update-version > > +update-version: > > + cd ${bits_srcdir} && \ > > + autogen version.def > > + > > > > > > Thanks, David > > > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-16 22:20 ` Jonathan Wakely @ 2023-08-16 22:36 ` David Edelsohn 2023-08-16 22:38 ` Andrew Pinski 0 siblings, 1 reply; 11+ messages in thread From: David Edelsohn @ 2023-08-16 22:36 UTC (permalink / raw) To: Jonathan Wakely; +Cc: Arsen Arsenović, GCC Patches [-- Attachment #1: Type: text/plain, Size: 1116 bytes --] Was the dependency added to the dependencies in contrib/gcc_update? Otherwise the timestamp can get out of sync in a Git checkout. Thanks, David On Wed, Aug 16, 2023 at 6:20 PM Jonathan Wakely <jwakely@redhat.com> wrote: > On Wed, 16 Aug 2023 at 22:56, Jonathan Wakely <jwakely@redhat.com> wrote: > > > > On Wed, 16 Aug 2023 at 22:39, David Edelsohn <dje.gcc@gmail.com> wrote: > > > > > > Hi, Arsen > > > > > > This patch broke bootstrap because it has introduced a new GCC build > requirement for autogen that is not a previous requirement to build GCC. > Previously the repository has included post-processed files. > > > > The repo does include the generated bits/version.h file. autogen > > should only be needed if you modify version.dep > > And I've just checked again with an x86_64-pc-linux-gnu bootstrap on a > box without autogen, and it worked. > > > > > > > > > +# AutoGen <bits/version.h>. > > > +.PHONY: update-version > > > +update-version: > > > + cd ${bits_srcdir} && \ > > > + autogen version.def > > > + > > > > > > > > > Thanks, David > > > > > > > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header 2023-08-16 22:36 ` David Edelsohn @ 2023-08-16 22:38 ` Andrew Pinski 0 siblings, 0 replies; 11+ messages in thread From: Andrew Pinski @ 2023-08-16 22:38 UTC (permalink / raw) To: David Edelsohn; +Cc: Jonathan Wakely, Arsen Arsenović, GCC Patches On Wed, Aug 16, 2023 at 3:36 PM David Edelsohn via Gcc-patches <gcc-patches@gcc.gnu.org> wrote: > > Was the dependency added to the dependencies in contrib/gcc_update? > Otherwise the timestamp can get out of sync in a Git checkout. I checked in https://gcc.gnu.org/pipermail/gcc-patches/2023-August/627667.html which just added it to gcc_update. Thanks, Andrew > > Thanks, David > > > On Wed, Aug 16, 2023 at 6:20 PM Jonathan Wakely <jwakely@redhat.com> wrote: > > > On Wed, 16 Aug 2023 at 22:56, Jonathan Wakely <jwakely@redhat.com> wrote: > > > > > > On Wed, 16 Aug 2023 at 22:39, David Edelsohn <dje.gcc@gmail.com> wrote: > > > > > > > > Hi, Arsen > > > > > > > > This patch broke bootstrap because it has introduced a new GCC build > > requirement for autogen that is not a previous requirement to build GCC. > > Previously the repository has included post-processed files. > > > > > > The repo does include the generated bits/version.h file. autogen > > > should only be needed if you modify version.dep > > > > And I've just checked again with an x86_64-pc-linux-gnu bootstrap on a > > box without autogen, and it worked. > > > > > > > > > > > > > +# AutoGen <bits/version.h>. > > > > +.PHONY: update-version > > > > +update-version: > > > > + cd ${bits_srcdir} && \ > > > > + autogen version.def > > > > + > > > > > > > > > > > > Thanks, David > > > > > > > > > > > > ^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2023-08-16 22:38 UTC | newest] Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2023-08-13 19:35 [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović 2023-08-13 19:35 ` [PATCH v2 2/2] libstdc++: Replace all manual FTM definitions and use Arsen Arsenović 2023-08-16 11:15 ` Jonathan Wakely 2023-08-16 12:47 ` Arsen Arsenović 2023-08-14 15:18 ` [PATCH v2 1/2] libstdc++: Implement more maintainable <version> header Arsen Arsenović 2023-08-16 11:15 ` Jonathan Wakely 2023-08-16 21:38 David Edelsohn 2023-08-16 21:56 ` Jonathan Wakely 2023-08-16 22:20 ` Jonathan Wakely 2023-08-16 22:36 ` David Edelsohn 2023-08-16 22:38 ` Andrew Pinski
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).