[WIP] [libc++] [P1614] Various unimplemented parts of <compare>. [WIP]

[• Quuxplusone]

Summary

I have this locally as five commits, and plan to upload several PRs when it's actually ready to land.

Duplicates/supersedes the following similar PRs by others:

• D80899 compare_three_way, blocked by lack of three_way_comparable

But does not supersede this one:

• D80902 lexicographical_compare_three_way, blocked by lack of compare_three_way

[• Quuxplusone]

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

• [libc++][modularisation] Split up <concepts> into granular headers.
• [libc++] [p1614] Implement std::compare_three_way_result.
• [libc++] [p1614] Implement std::three_way_comparable.
• [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

[• Quuxplusone]

Rebase (expecting CI to pass this time)

[cjdb]

In D107036#2914445, @Quuxplusone wrote:

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

• [libc++][modularisation] Split up <concepts> into granular headers.
• [libc++] [p1614] Implement std::compare_three_way_result.
• [libc++] [p1614] Implement std::three_way_comparable.
• [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

I'd appreciate it if you could make these dependent PRs to make it easier to review.

libcxx/include/__concepts/__boolean_testable.h

1 ↗

(On Diff #363160)

Please rename this file to boolean_testable.h. We decided a while back to not prefix detail headers with underscores.

libcxx/include/concepts

155–159 ↗

(On Diff #363160)

If you're going to split up <concepts>, please entirely split it up. Having some content in <concepts> and other stuff in __concepts is going to be difficult to track.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

1 ↗

(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

1 ↗

(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

[cjdb]

In addition to my feedback above, please drop the <concepts> changes from this patch (no longer necessary), as well as the changes in common with D80899 and D80902 (I'll return to these once three_way_comparable lands).

Please also ensure that what's left properly credits the original patch authors in the commit, preferably by making them the person that's named in git blame.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

I would hope that we can order them by union view of the data in memory if such a thing is allowed (or memcpy, if that's better) once we know that the sign and signaling bits are the same, because the specifics of the payload ordering are unspecified by totalOrder. Any way that we can look at the raw data in memory without UB should be sufficient.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

Ah I see, there are literally no standard implementation for the isSignaling predicate for iec559 types in C++. However, it does look like ISO C has an issignaling macro as part of the Floating-point extensions part 1, which I gather was accepted into the C23 standard in 2019 (ISO/IEC TS 60559-1, of interest section 7.12.3.7). Complete implementation of C++ strong_order for iec559 floating point types might be considered to be blocked on the implementation of this part of the standard as that seems like the best place to get it.

Implementing this just for strong_order is messy, very complex, and generally inadvisable. (Even for binary floating point values, ignoring the existence of decimal floating point types, some platforms -- notably PA-RISC -- use the opposite interpretation for the signaling bit in IEC559 floating point types, even though it's in the same location.) Unless we can strongly declare that we don't support any platforms other than say ARM and x86 this seems like a no-go, and it just seems better to take the platform support directly from the llvm C standard implementation.

[• Quuxplusone]

libcxx/include/__compare/cmp_alg.h

67

@mumbleskates: I doubt I understand your two comments. In case it's not already obvious: the IEEE 754 "total order" predicate is well-defined and we must implement std::strong_order consistently with it, on IEEE 754 platforms, because the Standard says so. (On other platforms, C++ doesn't care so much, because those platforms are dumb. :)) std::strong_order(x,y) is the way that C++20 exposes the "total order" predicate to end-users; there is no isolable floating-point-total-order library function for us to delegate to (because WG21 doesn't do software engineering).

Is there an isolable "llvm C standard implementation" we could be exploiting here — some kind of __builtin_totalorder we could use when it's available? That would be really cool.
I do think that this will eventually need to use either constexpr-friendly __builtin_memcpy, or else std::bit_cast; I just haven't gotten around to revisiting it.

A bit of googling turned up this solution which maybe just needs to be tweaked a tiny bit: https://stackoverflow.com/a/20154751/1424877

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

That general solution in the stackoverflow link works, but may only be correct for x86/ARM binary representation floating point types. (I don't know enough about the decimal types to know if they would also sort this way, but they are unsupported by by x86/ARM silicon.)

What it boils down to is that the *only* predicate we are missing, for any given iec559 type, is isSignaling: detecting whether a NaN is signaling or not. If we have that we can use it to complete the implementation here. Such a predicate does exist in standard C, but I believe it is not yet implemented in llvm's libc.

I know exactly how to do this on x86 and ARM with bit twiddling for pretty much any floating point type in the standard, but there are platforms with iec559 implementations where the signaling bit has the opposite meaning, and I think there might exist platforms where it is in a different place. Because signaling/non-signaling NaN implementation details are a property of the platform this immediately becomes a question of platform support; it's probably best to centralize this implementation knowledge as much as possible, but I don't know much about our approach to that in the llvm project.

[• Quuxplusone]

Rebased on main, to show what's left to do.
Tried a new bit-twiddling version of IEC559 totalOrder. Unfortunately I still don't know how to test it or how to make it constexpr. Fortunately, C++20 requires that it not be constexpr, AFAICT? See https://eel.is/c++draft/cmp#alg-1 which doesn't mention constexpr either positively or negatively.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

50

Fun cursed fact here, intel 80bit long doubles are also iec559. At least on my skylakex system they have sizeof() 16, have 6 bytes of padding at the end, and otherwise work mostly the same (sign bit at the top, 15 bits of exponent, 63 bits of mantissa in a 64 bit field wherein the MSB is always 1 except when it's sub-normal, and the next highest bit is used for 0=signaling/1=quiet NaN, as the highest bit of the real mantissa). Not completely sure what to do about that!

[jloser]

libcxx/include/__compare/cmp_alg.h

46

Should we use std::same_as and std::floating_point concepts instead? Same applies to other uses ofG type traits that are concepts now as well.

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp

26

Any reason to prefer this over just return true;? Similarly for the fallback overload (except return false; in that case).

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

60

We can drop the empty string second argument if you care.

[• Quuxplusone]

Rebase on std::bit_cast (D75960), and use std::bit_cast in the implementation of std::strong_order.
Rebase on D103478 (which has been merged now).

[• Quuxplusone]

Fix std::strong_order for floats, thanks to
https://stackoverflow.com/questions/59348310/how-to-implement-the-totalorder-predicate-for-floating-point-values
https://stackoverflow.com/questions/69068075/what-is-the-purpose-of-if-x-and-y-represent-the-same-floating-point-datum-i
https://quuxplusone.github.io/blog/2021/09/05/float-format/

Add std::weak_order and std::partial_order; they lack testing.

Drive-by fix some minor stuff.

Still unimplemented: std::strong_order_fallback and so on.

[• Quuxplusone]

Rebase; incorporate D109331 and further bugfixes to D75960.

[• Quuxplusone]

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

2

This one test file is the only part of D107036 that hasn't been superseded by D110738 + D111514.
@ldionne or whoever, do you think we care about this test file? Should I open a new PR for it (or repurpose this one)? or should I just close D107036 completely?

[ldionne]

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

2

I think this test is useful, and I would encourage splitting it into another PR to clear things up a bit. And then we can close this one as it has been superseded.

[• Quuxplusone]

The last piece of this (the test) has been superseded by D115588.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_atomic_value_initialization``         ``201911L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_wait``                         ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_barrier``                             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_bit_cast``                            *unimplemented*
+    ``__cpp_lib_bit_cast``                            ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bitops``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bounded_array_traits``                ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            ``202002L``

libcxx/docs/Status/Cxx20Papers.csv

 "`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|",""
 "`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","",""
 "`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
 "`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\  Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
 "","","","","",""
 "`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
 "`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0"
 "`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|",""
-"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","",""
+"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","|Complete|","14.0"
 "`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","",""
 "`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","*Removed in Cologne*","n/a"
 "`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0"
 "`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_",""
 "`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0"
 "`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0"
 "`P0758R1 <https://wg21.link/P0758R1>`__","LWG","Implicit conversion traits and utility functions","Rapperswil","|Complete|",""
 "`P0759R1 <https://wg21.link/P0759R1>`__","LWG","fpos Requirements","Rapperswil","|Complete|","11.0"

 "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0"
 "`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","",""
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","",""
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
-"`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
+"`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
 

libcxx/docs/UsingLibcxx.rst

 * ``remove_if``
 * ``remove``
 * ``search_n``
 * ``search``
 * ``unique``
 * ``upper_bound``
 * ``lock_guard``'s constructors
 * ``as_const``
+* ``bit_cast``
 * ``forward``
 * ``move``
 * ``move_if_noexcept``
 * ``identity::operator()``
 * ``to_integer``
 * ``to_underlying``

libcxx/include/CMakeLists.txt

set(files
   __algorithm/swap_ranges.h
   __algorithm/transform.h
   __algorithm/unique_copy.h
   __algorithm/unique.h
   __algorithm/unwrap_iter.h
   __algorithm/upper_bound.h
   __availability
   __bit_reference
+  __bit/bit_cast.h
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __charconv/chars_format.h
   __charconv/from_chars_result.h
   __charconv/to_chars_result.h
+  __compare/cmp_alg.h
   __compare/common_comparison_category.h
+  __compare/compare_three_way.h
   __compare/compare_three_way_result.h
   __compare/ordering.h
   __compare/three_way_comparable.h
   __concepts/arithmetic.h
   __concepts/assignable.h
   __concepts/boolean_testable.h
   __concepts/class_or_enum.h
   __concepts/common_reference_with.h
set(files
   __utility/declval.h
   __utility/exchange.h
   __utility/forward.h
   __utility/in_place.h
   __utility/integer_sequence.h
   __utility/move.h
   __utility/pair.h
   __utility/piecewise_construct.h
+  __utility/priority_tag.h
   __utility/rel_ops.h
   __utility/swap.h
   __utility/to_underlying.h
   __variant/monostate.h
   algorithm
   any
   array
   atomic

libcxx/include/__bit/bit_cast.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___BIT_BIT_CAST_H
+#define _LIBCPP___BIT_BIT_CAST_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template<class _ToType, class _FromType, class = _EnableIf<
+  sizeof(_ToType) == sizeof(_FromType) &&
+  is_trivially_copyable_v<_ToType> &&
+  is_trivially_copyable_v<_FromType>
+>>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT
+constexpr _ToType bit_cast(_FromType const& __from) noexcept {
+    return __builtin_bit_cast(_ToType, __from);
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___BIT_BIT_CAST_H

libcxx/include/__compare/cmp_alg.h

+// -*- C++ -*-
+//===-------------------------- compare -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___COMPARE_CMP_ALG
+#define _LIBCPP___COMPARE_CMP_ALG
+
+#include <__bit/bit_cast.h>
+#include <__compare/compare_three_way.h>
+#include <__compare/ordering.h>
+#include <__config>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+// [cmp.alg]
+namespace __strong_order {
+    struct __fn {
+        template<class _Ep, class _Fp>
+            requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
+        _LIBCPP_HIDE_FROM_ABI static constexpr auto
+        __go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>)
+            noexcept(noexcept( strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+        }
+
+        template<class _Ep, class _Fp, class _Dp = decay_t<_Ep>>
+            requires is_same_v<_Dp, decay_t<_Fp>> && is_floating_point_v<_Dp>
+        _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering
+        __go(_Ep&& __e, _Fp&& __f, _PriorityTag<1>) noexcept
+        {
+            struct _Intermediate { unsigned char __rest_[16]; };
+            struct _Parts { signed char __hi_; unsigned char __rest_[15]; auto operator<=>(const _Parts&) const = default; };
+            if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
+                int32_t __rx = _VSTD::bit_cast<int32_t>(__e);
+                int32_t __ry = _VSTD::bit_cast<int32_t>(__f);
+                __rx = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
+                __ry = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
+                return (__rx <=> __ry);
+            } else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
+                int64_t __rx = _VSTD::bit_cast<int64_t>(__e);
+                int64_t __ry = _VSTD::bit_cast<int64_t>(__f);
+                __rx = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
+                __ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
+                return (__rx <=> __ry);
+            } else if (__e < __f) {
+                return strong_ordering::less;
+            } else if (__e > __f) {
+                return strong_ordering::greater;
+            } else if (__e == __f) {
+                if (__e == 0) {
+                    return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
+                } else if (_VSTD::isinf(__e)) {
+                    return strong_ordering::equal;
+                } else {
+                    int __eexp, __fexp;
+                    (void)_VSTD::frexp(__e, &__eexp);
+                    (void)_VSTD::frexp(__f, &__fexp);
+                    return (__e < 0) ? (__eexp <=> __fexp) : (__fexp <=> __eexp);
+                }
+            } else {
+                // They're unordered, so one of them must be a NAN.
+                // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
+                bool __e_is_nan = _VSTD::isnan(__e);
+                bool __f_is_nan = _VSTD::isnan(__f);
+                bool __e_is_negative = _VSTD::signbit(__e);
+                bool __f_is_negative = _VSTD::signbit(__f);
+                using _IntType = std::conditional_t<
+                    sizeof(__e) == sizeof(int), int, std::conditional_t<
+                    sizeof(__e) == sizeof(long), long, std::conditional_t<
+                    sizeof(__e) == sizeof(long long), long long, void>>
+                >;
+                static_assert(!std::is_same_v<_IntType, void>, "std::strong_order is unimplemented for this floating-point type");
+                if (__e_is_nan && __f_is_nan) {
+                    // Order by sign bit, then by "payload bits" (we'll just use bit_cast).
+                    if (__e_is_negative != __f_is_negative) {
+                        return (__f_is_negative <=> __e_is_negative);
+                    } else {
+                        return _VSTD::bit_cast<_IntType>(__e) <=> _VSTD::bit_cast<_IntType>(__f);
+                    }
+                } else if (__e_is_nan) {
+                    return __e_is_negative ? strong_ordering::greater : strong_ordering::less;
+                } else {
+                    return __f_is_negative ? strong_ordering::less : strong_ordering::greater;
+                }
+            }
+        }
+
+        template<class _Ep, class _Fp>
+            requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
+        _LIBCPP_HIDE_FROM_ABI static constexpr auto
+        __go(_Ep&& __e, _Fp&& __f, _PriorityTag<0>)
+            noexcept(noexcept( strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+        }
+
+        template<class _Ep, class _Fp>
+        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ep&& __e, _Fp&& __f) const
+            noexcept(noexcept( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) ))
+            -> decltype(       __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) )
+        {
+            return             __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>());
+        }
+    };
+} // namespace __strong_order
+
+inline namespace __cpo {
+    inline constexpr auto strong_order = __strong_order::__fn{};
+} // namespace __cpo
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_CMP_ALG

libcxx/include/__compare/compare_three_way.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
+#define _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
+
+#include <__config>
+#include <__compare/three_way_comparable.h>
+#include <__utility/forward.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+struct _LIBCPP_TEMPLATE_VIS compare_three_way
+{
+    template<class _T1, class _T2>
+        requires three_way_comparable_with<_T1, _T2>
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
+        { return          _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
+
+    using is_transparent = void;
+};
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H

libcxx/include/__utility/priority_tag.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_PRIORITY_TAG_H
+#define _LIBCPP___UTILITY_PRIORITY_TAG_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<size_t _Ip> struct _PriorityTag : _PriorityTag<_Ip - 1> {};
+template<> struct _PriorityTag<0> {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_PRIORITY_TAG_H

libcxx/include/bit

 // -*- C++ -*-
 //===------------------------------ bit ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_BIT
 #define _LIBCPP_BIT
 
 /*
     bit synopsis
 
 namespace std {
+    // [bit.cast], bit_cast
+    template<class To, class From>
+      constexpr To bit_cast(const From& from) noexcept; // C++20
 
   // [bit.pow.two], integral powers of 2
   template <class T>
     constexpr bool has_single_bit(T x) noexcept; // C++20
   template <class T>
     constexpr T bit_ceil(T x);                   // C++20
   template <class T>
     constexpr T bit_floor(T x) noexcept;         // C++20
enum class endian {
     big = see below,           // C++20
     native = see below         // C++20
 };
 
 } // namespace std
 
 */
 
-#include <__config>
+#include <__bit/bit_cast.h>
 #include <__bits> // __libcpp_clz
+#include <__config>
 #include <__debug>
 #include <limits>
 #include <type_traits>
 #include <version>
 
 #if defined(__IBMCPP__)
 #include "__support/ibm/support.h"
 #endif

libcxx/include/compare

template<class T, class U, class Cat = partial_ordering>
     concept three_way_comparable_with = see below;
 
   // [cmp.result], result of three-way comparison
   template<class T, class U = T> struct compare_three_way_result;
 
   template<class T, class U = T>
     using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;
 
+  // [comparisons.three.way], class compare_three_way
+  struct compare_three_way;
+
   // [cmp.alg], comparison algorithms
   template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
   template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
   template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
 
   // [cmp.partialord], Class partial_ordering
   class partial_ordering {
   public:
public:
     friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
     friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
     friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
 }
 */
 
+#include <__compare/cmp_alg.h>
 #include <__compare/common_comparison_category.h>
+#include <__compare/compare_three_way.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/ordering.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
 
-#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
-#pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
-
-// [cmp.alg], comparison algorithms
-// TODO: unimplemented
-template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
-
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
-
-_LIBCPP_END_NAMESPACE_STD
-
 #endif // _LIBCPP_COMPARE

libcxx/include/functional

struct greater_equal {
     bool operator()(const T& x, const T& y) const;
 };
 
 template <class T> // <class T=void> in C++14
 struct less_equal {
     bool operator()(const T& x, const T& y) const;
 };
 
+// [comparisons.three.way], class compare_three_way
+struct compare_three_way;
+
 template <class T> // <class T=void> in C++14
 struct logical_and {
     bool operator()(const T& x, const T& y) const;
 };
 
 template <class T> // <class T=void> in C++14
 struct logical_or {
     bool operator()(const T& x, const T& y) const;

 
 POLICY:  For non-variadic implementations, the number of arguments is limited
          to 3.  It is hoped that the need for non-variadic implementations
          will be minimal.
 
 */
 
 #include <__algorithm/search.h>
+#include <__compare/compare_three_way.h>
 #include <__config>
 #include <__debug>
 #include <__functional/binary_function.h> // TODO: deprecate
 #include <__functional/binary_negate.h>
 #include <__functional/bind_back.h>
 #include <__functional/bind_front.h>
 #include <__functional/bind.h>
 #include <__functional/binder1st.h>

libcxx/include/module.modulemap

module std [system] {
   module barrier {
     requires cplusplus14
     header "barrier"
     export *
   }
   module bit {
     header "bit"
     export *
+
+    module __bit {
+      module bit_cast { private header "__bit/bit_cast.h" }
+    }
   }
   module bitset {
     header "bitset"
     export string
     export iosfwd
     export *
   }
   // No submodule for cassert. It fundamentally needs repeated, textual inclusion.
module codecvt {
     header "codecvt"
     export *
   }
   module compare {
     header "compare"
     export *
 
     module __compare {
+      module cmp_alg                    { private header "__compare/cmp_alg.h"                    }
       module common_comparison_category { private header "__compare/common_comparison_category.h" }
+      module compare_three_way          { private header "__compare/compare_three_way.h"          }
       module compare_three_way_result   { private header "__compare/compare_three_way_result.h"   }
       module ordering                   { private header "__compare/ordering.h"                   }
       module three_way_comparable       { private header "__compare/three_way_comparable.h"       }
     }
   }
   module complex {
     header "complex"
     export *
module __utility {
       module declval             { private header "__utility/declval.h"             }
       module exchange            { private header "__utility/exchange.h"            }
       module forward             { private header "__utility/forward.h"             }
       module in_place            { private header "__utility/in_place.h"            }
       module integer_sequence    { private header "__utility/integer_sequence.h"    }
       module move                { private header "__utility/move.h"                }
       module pair                { private header "__utility/pair.h"                }
       module piecewise_construct { private header "__utility/piecewise_construct.h" }
+      module priority_tag        { private header "__utility/priority_tag.h"        }
       module rel_ops             { private header "__utility/rel_ops.h"             }
       module swap                { private header "__utility/swap.h"                }
       module to_underlying       { private header "__utility/to_underlying.h"       }
     }
   }
   module valarray {
     header "valarray"
     export initializer_list

libcxx/include/utility

 #include <__utility/declval.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
+#include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
 #include <compare>
 #include <initializer_list>
 #include <version>
 
 #endif // _LIBCPP_UTILITY

libcxx/include/version

 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L
-// # define __cpp_lib_bit_cast                             201806L
+# define __cpp_lib_bit_cast                             201806L
 // # define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L
 // # define __cpp_lib_constexpr_complex                    201711L

libcxx/test/libcxx/diagnostics/detail.headers/bit/bit_cast.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__bit/bit_cast.h'}}
+#include <__bit/bit_cast.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/cmp_alg.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__compare/cmp_alg.h'}}
+#include <__compare/cmp_alg.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/compare_three_way.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__compare/compare_three_way.h'}}
+#include <__compare/compare_three_way.h>

libcxx/test/libcxx/diagnostics/detail.headers/utility/priority_tag.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__utility/priority_tag.h'}}
+#include <__utility/priority_tag.h>

libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

 // This test intentionally leaks memory, so it is unsupported under ASAN.
 // UNSUPPORTED: asan
 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.fail.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 #include <algorithm>
+#include <bit> // bit_cast
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>
 #include <memory>
 #include <utility> // to_underlying
 
 #include "test_macros.h"
 

 
 void test_nontemplate_cast_wrappers()
 {
 #if TEST_STD_VER >= 17
   std::byte b{42};
   std::to_integer<int>(b);
 #endif
 
-#if TEST_STD_VER >= 20
-  // std::bit_cast<unsigned int>(42);
+#if TEST_STD_VER > 17
+  std::bit_cast<unsigned int>(42);
 #endif
 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   std::to_underlying(e);
 #endif
 }
 

libcxx/test/libcxx/diagnostics/nodiscard_extensions.verify.cpp

 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.pass.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD
 
 #include <algorithm>
+#include <bit> // bit_cast
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>
 #include <memory>
 #include <utility> // to_underlying
 
 #include "test_macros.h"
 

 void test_nontemplate_cast_wrappers()
 {
 #if TEST_STD_VER >= 17
   std::byte b{42};
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::to_integer<int>(b);
 #endif
 
-#if TEST_STD_VER >= 20
-  // std::bit_cast<unsigned int>(42);
+#if TEST_STD_VER > 17
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  std::bit_cast<unsigned int>(42);
 #endif
 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::to_underlying(e);
 #endif
 }

libcxx/test/std/language.support/cmp/cmp.alg/strong_order.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class strong_ordering
+
+#include <compare>
+
+#include <cassert>
+#include <cmath>
+#include <iterator> // std::size
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+template<class T, class U>
+constexpr auto has_strong_order(T&& t, U&& u)
+    -> decltype(std::strong_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
+{
+    return true;
+}
+
+constexpr bool has_strong_order(...) {
+    return false;
+}
+
+namespace N11 {
+    struct A {};
+    struct B {};
+    std::strong_ordering strong_order(const A&, const A&) { return std::strong_ordering::less; }
+    std::strong_ordering strong_order(const A&, const B&);
+}
+
+void test_1_1()
+{
+    // If the decayed types of E and F differ, strong_order(E, F) is ill-formed.
+
+    static_assert( has_strong_order(1, 2));
+    static_assert(!has_strong_order(1, (short)2));
+    static_assert(!has_strong_order(1, 2.0));
+    static_assert(!has_strong_order(1.0f, 2.0));
+
+    static_assert( has_strong_order((int*)nullptr, (int*)nullptr));
+    static_assert(!has_strong_order((int*)nullptr, (const int*)nullptr));
+    static_assert(!has_strong_order((const int*)nullptr, (int*)nullptr));
+    static_assert( has_strong_order((const int*)nullptr, (const int*)nullptr));
+
+    N11::A a;
+    N11::B b;
+    static_assert( has_strong_order(a, a));
+    static_assert(!has_strong_order(a, b));
+}
+
+namespace N12 {
+    struct A {};
+    std::strong_ordering strong_order(A&, A&&) { return std::strong_ordering::less; }
+    std::strong_ordering strong_order(A&&, A&&) { return std::strong_ordering::equal; }
+    std::strong_ordering strong_order(const A&, const A&);
+
+    struct B {
+        friend std::weak_ordering strong_order(B&, B&);
+    };
+
+    struct Order {
+        explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
+    };
+    struct C {
+        bool touched = false;
+        friend Order strong_order(C& lhs, C&) { lhs.touched = true; return Order(); }
+    };
+}
+
+void test_1_2()
+{
+    // Otherwise, strong_ordering(strong_order(E, F))
+    // if it is a well-formed expression with overload resolution performed
+    // in a context that does not include a declaration of std::strong_order.
+
+    // Test that strong_order does not const-qualify the forwarded arguments.
+    N12::A a;
+    assert(std::strong_order(a, std::move(a)) == std::strong_ordering::less);
+    assert(std::strong_order(std::move(a), std::move(a)) == std::strong_ordering::equal);
+
+    // The type of strong_order(e,f) must be explicitly convertible to strong_order.
+    N12::B b;
+    static_assert(!has_strong_order(b, b));
+
+    N12::C c1, c2;
+    ASSERT_SAME_TYPE(decltype(std::strong_order(c1, c2)), std::strong_ordering);
+    assert(std::strong_order(c1, c2) == std::strong_ordering::less);
+    assert(c1.touched);
+    assert(!c2.touched);
+}
+
+template<class F>
+constexpr bool test_1_3()
+{
+    // Otherwise, if the decayed type T of E is a floating-point type,
+    // yields a value of type strong_ordering that is consistent with
+    // the ordering observed by T's comparison operators,
+    // and if numeric_limits<T>::is_iec559 is true, is additionally consistent with
+    // the totalOrder operation as specified in ISO/IEC/IEEE 60559.
+
+    static_assert(std::numeric_limits<F>::is_iec559);
+
+    ASSERT_SAME_TYPE(decltype(std::strong_order(F(0), F(0))), std::strong_ordering);
+
+    F v[] = {
+        -std::numeric_limits<F>::infinity(),
+        std::numeric_limits<F>::lowest(),  // largest (finite) negative number
+        F(-1.0), F(-0.1),
+        -std::numeric_limits<F>::min(),    // smallest (normal) negative number
+        F(-0.0),                           // negative zero
+        F(0.0),
+        std::numeric_limits<F>::min(),     // smallest (normal) positive number
+        F(0.1), F(1.0), F(2.0), F(3.14),
+        std::numeric_limits<F>::max(),     // largest (finite) positive number
+        std::numeric_limits<F>::infinity(),
+    };
+
+    static_assert(std::size(v) == 14);
+
+    // Sanity-check that array 'v' is indeed in the right order.
+    for (int i=0; i < 14; ++i) {
+        for (int j=0; j < 14; ++j) {
+            auto naturalOrder = (v[i] <=> v[j]);
+            if (v[i] == 0 && v[j] == 0) {
+                assert(naturalOrder == std::partial_ordering::equivalent);
+            } else {
+                assert(naturalOrder == std::partial_ordering::unordered || naturalOrder == (i <=> j));
+            }
+        }
+    }
+
+    assert(std::strong_order(v[0], v[0]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[0], v[1]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[2]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[3]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[4]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[5]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[0], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[1], v[1]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[1], v[2]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[3]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[4]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[5]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[1], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[2], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[2], v[2]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[2], v[3]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[4]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[5]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[2], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[3], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[3], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[3], v[3]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[3], v[4]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[5]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[3], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[4], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[4], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[4], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[4], v[4]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[4], v[5]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[4], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[5], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[5], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[5], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[5], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[5], v[5]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[5], v[6]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[5], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[6], v[6]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[6], v[7]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[6], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[7], v[7]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[7], v[8]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[7], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[8], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[8], v[8]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[8], v[9]) == std::strong_ordering::less);
+    assert(std::strong_order(v[8], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[8], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[8], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[8], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[9], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[8]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[9], v[9]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[9], v[10]) == std::strong_ordering::less);
+    assert(std::strong_order(v[9], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[9], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[9], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[10], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[8]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[9]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[10], v[10]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[10], v[11]) == std::strong_ordering::less);
+    assert(std::strong_order(v[10], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[10], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[11], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[8]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[9]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[10]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[11], v[11]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[11], v[12]) == std::strong_ordering::less);
+    assert(std::strong_order(v[11], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[12], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[8]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[9]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[10]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[11]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[12], v[12]) == std::strong_ordering::equal);
+    assert(std::strong_order(v[12], v[13]) == std::strong_ordering::less);
+    assert(std::strong_order(v[13], v[0]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[1]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[2]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[3]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[4]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[5]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[6]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[7]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[8]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[9]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[10]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[11]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[12]) == std::strong_ordering::greater);
+    assert(std::strong_order(v[13], v[13]) == std::strong_ordering::equal);
+
+
+    // There's no way to produce a specifically positive or negative NAN
+    // at compile-time, so the NAN-related tests must be runtime-only.
+
+    if (!std::is_constant_evaluated()) {
+        F nq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
+        F ns = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
+        F ps = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
+        F pq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
+
+        assert(std::strong_order(nq, nq) == std::strong_ordering::equal);
+        assert(std::strong_order(nq, ns) == std::strong_ordering::less);
+        for (int i=0; i < 14; ++i) {
+            assert(std::strong_order(nq, v[i]) == std::strong_ordering::less);
+        }
+        assert(std::strong_order(nq, ps) == std::strong_ordering::less);
+        assert(std::strong_order(nq, pq) == std::strong_ordering::less);
+
+        assert(std::strong_order(ns, nq) == std::strong_ordering::greater);
+        assert(std::strong_order(ns, ns) == std::strong_ordering::equal);
+        for (int i=0; i < 14; ++i) {
+            assert(std::strong_order(ns, v[i]) == std::strong_ordering::less);
+        }
+        assert(std::strong_order(ns, ps) == std::strong_ordering::less);
+        assert(std::strong_order(ns, pq) == std::strong_ordering::less);
+
+        assert(std::strong_order(ps, nq) == std::strong_ordering::greater);
+        assert(std::strong_order(ps, ns) == std::strong_ordering::greater);
+        for (int i=0; i < 14; ++i) {
+            assert(std::strong_order(ps, v[i]) == std::strong_ordering::greater);
+        }
+        assert(std::strong_order(ps, ps) == std::strong_ordering::equal);
+        assert(std::strong_order(ps, pq) == std::strong_ordering::less);
+
+        assert(std::strong_order(pq, nq) == std::strong_ordering::greater);
+        assert(std::strong_order(pq, ns) == std::strong_ordering::greater);
+        for (int i=0; i < 14; ++i) {
+            assert(std::strong_order(pq, v[i]) == std::strong_ordering::greater);
+        }
+        assert(std::strong_order(pq, ps) == std::strong_ordering::greater);
+        assert(std::strong_order(pq, pq) == std::strong_ordering::equal);
+    }
+
+    return true;
+}
+
+namespace N14 {
+    // Compare to N12::A.
+    struct A {};
+    bool operator==(const A&, const A&);
+    constexpr std::strong_ordering operator<=>(A&, A&&) { return std::strong_ordering::less; }
+    constexpr std::strong_ordering operator<=>(A&&, A&&) { return std::strong_ordering::equal; }
+    std::strong_ordering operator<=>(const A&, const A&);
+    static_assert(std::three_way_comparable<A>);
+
+    struct B {
+        std::strong_ordering operator<=>(const B&) const;  // lacks operator==
+    };
+    static_assert(!std::three_way_comparable<B>);
+
+    struct C {
+        mutable bool touched = false;
+        bool operator==(const C&) const;
+        constexpr std::strong_ordering operator<=>(const C& rhs) const {
+            rhs.touched = true;
+            return std::strong_ordering::equal;
+        }
+    };
+    static_assert(std::three_way_comparable<C>);
+}
+
+constexpr bool test_1_4()
+{
+    // Otherwise, strong_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
+
+    // Test neither strong_order nor compare_three_way const-qualify the forwarded arguments.
+    N14::A a;
+    assert(std::strong_order(a, std::move(a)) == std::strong_ordering::less);
+    assert(std::strong_order(std::move(a), std::move(a)) == std::strong_ordering::equal);
+
+    N14::B b;
+    static_assert(!has_strong_order(b, b));
+
+    N14::C c1, c2;
+    assert(std::strong_order(c1, c2) == std::strong_ordering::equal);
+    assert(!c1.touched);
+    assert(c2.touched);
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test_1_1();
+    test_1_2();
+    test_1_3<float>();
+    test_1_3<double>();
+    // test_1_3<long double>();
+    test_1_4();
+
+    static_assert(test_1_3<float>());
+    static_assert(test_1_3<double>());
+    // static_assert(test_1_3<long double>());
+    static_assert(test_1_4());
+
+    return 0;
+}

libcxx/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp

 # endif
 
 # ifdef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++20"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++20"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++20"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++20"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++20"
 #   endif

 #   error "__cpp_lib_int_pow2 should be defined in c++20"
 # endif
 # if __cpp_lib_int_pow2 != 202002L
 #   error "__cpp_lib_int_pow2 should have the value 202002L in c++20"
 # endif
 
 #elif TEST_STD_VER > 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++2b"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++2b"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++2b"
 #   endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 
 # ifndef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should be defined in c++20"
 # endif
 # if __cpp_lib_bind_front != 201907L
 #   error "__cpp_lib_bind_front should have the value 201907L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++20"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++20"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++20"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++20"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++20"

 
 # ifndef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should be defined in c++2b"
 # endif
 # if __cpp_lib_bind_front != 201907L
 #   error "__cpp_lib_bind_front should have the value 201907L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++2b"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++2b"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++2b"

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// [customization.point.object]
+// [range.adaptor.object] "A range adaptor object is a customization point object..."
+
+#include <compare>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+template<class CPO, class... Args>
+constexpr bool test(CPO& o, Args&&...)
+{
+    auto p = o;
+    using T = decltype(p);
+
+    // The type of a customization point object, ignoring cv-qualifiers, shall model semiregular.
+    static_assert(std::semiregular<T>);
+
+    // All instances of a specific customization point object type shall be equal.
+    // (However, they need not support operator==, so there's nothing to test here.)
+
+    // The type T of a customization point object, ignoring cv-qualifiers, shall model...
+    static_assert(std::invocable<T&, Args...>);
+    static_assert(std::invocable<const T&, Args...>);
+    static_assert(std::invocable<T, Args...>);
+    static_assert(std::invocable<const T, Args...>);
+
+    return true;
+}
+
+int main(int, char**)
+{
+    int a[10];
+//    int arrays[10][10];
+//    std::pair<int, int> pairs[10];
+
+    // [iterator.cust]
+    static_assert(test(std::ranges::iter_move, a+0));
+    static_assert(test(std::ranges::iter_swap, a+0, a+1));
+
+    // [cmp.alg]
+    static_assert(test(std::strong_order, 1, 2));
+//    static_assert(test(std::weak_order, 1, 2));
+//    static_assert(test(std::partial_order, 1, 2));
+//    static_assert(test(std::compare_strong_order_fallback, 1, 2));
+//    static_assert(test(std::compare_weak_order_fallback, 1, 2));
+//    static_assert(test(std::compare_partial_order_fallback, 1, 2));
+
+    // [range.access]
+    static_assert(test(std::ranges::begin, a));
+    static_assert(test(std::ranges::end, a));
+    static_assert(test(std::ranges::cbegin, a));
+    static_assert(test(std::ranges::cend, a));
+//    static_assert(test(std::ranges::rbegin, a));
+//    static_assert(test(std::ranges::rend, a));
+//    static_assert(test(std::ranges::crbegin, a));
+//    static_assert(test(std::ranges::crend, a));
+    static_assert(test(std::ranges::size, a));
+    static_assert(test(std::ranges::ssize, a));
+    static_assert(test(std::ranges::empty, a));
+    static_assert(test(std::ranges::data, a));
+//    static_assert(test(std::ranges::cdata, a));
+
+    // [range.factories]
+    // views::empty<T> is not a CPO
+//    static_assert(test(std::views::single, 4));
+//    static_assert(test(std::views::iota, 1));
+//    static_assert(test(std::views::iota, 1, 10));
+    // ranges::istream_view<T> is not a CPO
+
+    // [range.adaptors]
+    static_assert(test(std::views::all, a));
+//    static_assert(test(std::views::filter, a, [](int x){ return x < 10; }));
+//    static_assert(test(std::views::transform, a, [](int x){ return x + 1; }));
+//    static_assert(test(std::views::take, a, 10));
+//    static_assert(test(std::views::take_while, a, [](int x){ return x < 10; }));
+//    static_assert(test(std::views::drop, a, 10));
+//    static_assert(test(std::views::drop_while, a, [](int x){ return x < 10; }));
+//    static_assert(test(std::views::join, arrays));
+//    static_assert(test(std::views::lazy_split, a, 4));
+//    static_assert(test(std::views::split, a, 4));
+//    static_assert(test(std::views::counted, a, 10));
+//    static_assert(test(std::views::common, a));
+//    static_assert(test(std::views::reverse, a));
+//    static_assert(test(std::views::elements<0>, pairs));
+
+    return 0;
+}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <bit>
+//
+// template<class To, class From>
+//   constexpr To bit_cast(const From& from) noexcept; // C++20
+
+// This test makes sure that std::bit_cast fails when any of the following
+// constraints are violated:
+//
+//      (1.1) sizeof(To) == sizeof(From) is true;
+//      (1.2) is_trivially_copyable_v<To> is true;
+//      (1.3) is_trivially_copyable_v<From> is true.
+
+#include <bit>
+#include <concepts>
+
+template<class To, class From>
+concept bit_cast_is_valid = requires(From from) {
+    { std::bit_cast<To>(from) } -> std::same_as<To>;
+};
+
+// Types are not the same size
+namespace ns1 {
+    struct To { char a; };
+    struct From { char a; char b; };
+    static_assert(!bit_cast_is_valid<To, From>);
+
+    static_assert(!bit_cast_is_valid<char[2], From>);  // makes bit_cast's return type invalid
+    static_assert(!bit_cast_is_valid<int(), From>);  // duh, but might as well check
+    static_assert(bit_cast_is_valid<From, From>);  // OK, right?
+    static_assert(!bit_cast_is_valid<From&, From>);  // Not OK???
+}
+
+// To is not trivially copyable
+namespace ns2 {
+    struct To { char a; To(const To&); };
+    struct From { char a; };
+    static_assert(!bit_cast_is_valid<To, From>);
+}
+
+// From is not trivially copyable
+namespace ns3 {
+    struct To { char a; };
+    struct From { char a; From(const From&); };
+    static_assert(!bit_cast_is_valid<To, From>);
+}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <bit>
+//
+// template<class To, class From>
+//   constexpr To bit_cast(const From& from) noexcept; // C++20
+
+#include <array>
+#include <bit>
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+template <typename T>
+void test_roundtrip_through_buffer(T from) {
+    struct Buffer { char buffer[sizeof(T)]; };
+    Buffer middle = std::bit_cast<Buffer>(from);
+    T to = std::bit_cast<T>(middle);
+    Buffer middle2 = std::bit_cast<Buffer>(to);
+
+    assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&from, &to, sizeof(T)) == 0);
+    assert(std::memcmp(&middle, &middle2, sizeof(Buffer)) == 0);
+}
+
+template <typename T>
+void test_roundtrip_through_nested_T(T from) {
+    struct Nested { T x; };
+    Nested middle = std::bit_cast<Nested>(from);
+    T to = std::bit_cast<T>(middle);
+    Nested middle2 = std::bit_cast<Nested>(to);
+
+    assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&from, &to, sizeof(T)) == 0);
+    assert(std::memcmp(&middle, &middle2, sizeof(Nested)) == 0);
+}
+
+template <typename Intermediate, typename T>
+void test_roundtrip_through(T from) {
+    Intermediate middle = std::bit_cast<Intermediate>(from);
+    T to = std::bit_cast<T>(middle);
+    Intermediate middle2 = std::bit_cast<Intermediate>(to);
+
+    assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+    assert(std::memcmp(&from, &to, sizeof(T)) == 0);
+    assert(std::memcmp(&middle, &middle2, sizeof(Intermediate)) == 0);
+}
+
+template <typename T>
+constexpr std::array<T, 10> generate_signed_integral_values() {
+    return {std::numeric_limits<T>::min(),
+            std::numeric_limits<T>::min() + 1,
+            static_cast<T>(-2), static_cast<T>(-1),
+            static_cast<T>(0), static_cast<T>(1),
+            static_cast<T>(2), static_cast<T>(3),
+            std::numeric_limits<T>::max() - 1,
+            std::numeric_limits<T>::max()};
+}
+
+template <typename T>
+constexpr std::array<T, 6> generate_unsigned_integral_values() {
+    return {static_cast<T>(0), static_cast<T>(1),
+            static_cast<T>(2), static_cast<T>(3),
+            std::numeric_limits<T>::max() - 1,
+            std::numeric_limits<T>::max()};
+}
+
+bool tests() {
+    for (bool b : {false, true}) {
+        test_roundtrip_through_nested_T(b);
+        test_roundtrip_through_buffer(b);
+        test_roundtrip_through<char>(b);
+    }
+
+    for (char c : {'\0', 'a', 'b', 'c', 'd'}) {
+        test_roundtrip_through_nested_T(c);
+        test_roundtrip_through_buffer(c);
+        test_roundtrip_through<bool>(c);
+    }
+
+    // Fundamental signed integer types
+    for (signed char i : generate_signed_integral_values<signed char>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (short i : generate_signed_integral_values<short>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (int i : generate_signed_integral_values<int>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (long i : generate_signed_integral_values<long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (long long i : generate_signed_integral_values<long long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fundamental unsigned integer types
+    for (unsigned char i : generate_unsigned_integral_values<unsigned char>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned short i : generate_unsigned_integral_values<unsigned short>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned int i : generate_unsigned_integral_values<unsigned int>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (unsigned long i : generate_unsigned_integral_values<unsigned long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned long long i : generate_unsigned_integral_values<unsigned long long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fixed width signed integer types
+    for (std::int32_t i : generate_signed_integral_values<std::int32_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+        test_roundtrip_through<std::uint32_t>(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (std::int64_t i : generate_signed_integral_values<std::int64_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+        test_roundtrip_through<std::uint64_t>(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fixed width unsigned integer types
+    for (std::uint32_t i : generate_unsigned_integral_values<std::uint32_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+        test_roundtrip_through<std::int32_t>(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (std::uint64_t i : generate_unsigned_integral_values<std::uint64_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+        test_roundtrip_through<std::int64_t>(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Floating point types
+    for (float i : {0.0f, 1.0f, -1.0f, 10.0f, -10.0f, 1e10f, 1e-10f, 1e20f, 1e-20f, 2.71828f, 3.14159f,
+                    std::nanf(""),
+                    __builtin_nanf("0x55550001"), // NaN with a payload
+                    std::numeric_limits<float>::signaling_NaN(),
+                    std::numeric_limits<float>::quiet_NaN()}) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+    }
+
+    for (double i : {0.0, 1.0, -1.0, 10.0, -10.0, 1e10, 1e-10, 1e100, 1e-100,
+                     2.718281828459045,
+                     3.141592653589793238462643383279502884197169399375105820974944,
+                     std::nan(""),
+                     std::numeric_limits<double>::signaling_NaN(),
+                     std::numeric_limits<double>::quiet_NaN()}) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+    }
+
+    for (long double i : {0.0l, 1.0l, -1.0l, 10.0l, -10.0l, 1e10l, 1e-10l, 1e100l, 1e-100l,
+                          2.718281828459045l,
+                          3.141592653589793238462643383279502884197169399375105820974944l,
+                          std::nanl(""),
+                          std::numeric_limits<long double>::signaling_NaN(),
+                          std::numeric_limits<long double>::quiet_NaN()}) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    return true;
+}
+
+// TODO: There doesn't seem to be a way to perform non-trivial correctness
+//       tests inside constexpr.
+constexpr bool basic_constexpr_test() {
+    struct Nested { char buffer[sizeof(int)]; };
+    int from = 3;
+    Nested middle = std::bit_cast<Nested>(from);
+    int to = std::bit_cast<int>(middle);
+    assert(from == to);
+    return true;
+}
+
+int main(int, char**) {
+    tests();
+    static_assert(basic_constexpr_test());
+    return 0;
+}

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <compare>
+// <functional>
+
+// compare_three_way
+
+#include <compare>
+#include <cassert>
+#include <type_traits>
+
+#include "pointer_comparison_test_helper.h"
+
+template<class T, class U>
+constexpr auto test_sfinae(T t, U u)
+    -> decltype(std::compare_three_way()(t, u), std::true_type{})
+    { return std::true_type{}; }
+
+constexpr auto test_sfinae(...)
+    { return std::false_type{}; }
+
+struct NotThreeWayComparable {
+    std::strong_ordering operator<=>(const NotThreeWayComparable&) const;
+};
+ASSERT_SAME_TYPE(std::compare_three_way_result_t<NotThreeWayComparable>, std::strong_ordering);
+static_assert(!std::three_way_comparable<NotThreeWayComparable>);  // it lacks operator==
+
+constexpr bool test()
+{
+    ASSERT_SAME_TYPE(decltype(std::compare_three_way()(1, 1)), std::strong_ordering);
+    assert(std::compare_three_way()(1, 1) == std::strong_ordering::equal);
+    assert(std::compare_three_way()(1, 2) == std::strong_ordering::less);
+    assert(std::compare_three_way()(2, 1) == std::strong_ordering::greater);
+
+    ASSERT_SAME_TYPE(decltype(std::compare_three_way()(1.0, 1.0)), std::partial_ordering);
+    assert(std::compare_three_way()(1.0, 1.0) == std::partial_ordering::equivalent);
+    assert(std::compare_three_way()(1.0, 2.0) == std::partial_ordering::less);
+    assert(std::compare_three_way()(2.0, 1.0) == std::partial_ordering::greater);
+
+    // Try heterogeneous comparison.
+    ASSERT_SAME_TYPE(decltype(std::compare_three_way()(42.0, 42)), std::partial_ordering);
+    assert(std::compare_three_way()(42.0, 42) == std::partial_ordering::equivalent);
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+
+    do_pointer_comparison_test(std::compare_three_way());
+
+    static_assert(test_sfinae(1, 2));
+    static_assert(!test_sfinae(1, nullptr));
+    static_assert(!test_sfinae(NotThreeWayComparable(), NotThreeWayComparable()));
+
+    return 0;
+}

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

int main(int, char**)
     static_assert (  is_transparent<std::greater<void>>::value, "" );
     static_assert (  is_transparent<std::greater<>>::value, "" );
 
     static_assert ( !is_transparent<std::greater_equal<int>>::value, "" );
     static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" );
     static_assert (  is_transparent<std::greater_equal<void>>::value, "" );
     static_assert (  is_transparent<std::greater_equal<>>::value, "" );
 
+#if TEST_STD_VER > 17
+    static_assert(   is_transparent<std::compare_three_way>::value, "" );
+#endif
+
     return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++20": 201907 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_bit_cast",
     "values": { "c++20": 201806 },
     "headers": ["bit"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_bitops",
     "values": { "c++20": 201907 },
     "headers": ["bit"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_bool_constant",
     "values": { "c++17": 201505 },