[libc++] [P1614] Implement the first half of [cmp.alg]: strong_order, weak_order, partial_order.

[• Quuxplusone]

Summary

Re the behavior of std::strong_order for floating-point types, see
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/

There's still an open question of what it should do for long double; I'm proposing to just leave it unimplemented in hopes that someone who cares about it will provide an implementation.

This PR does not implement std::strong_order_fallback et al. That will be a second PR. (It is now D111514.)

[• Quuxplusone]

libcxx/include/__utility/priority_tag.h

21–22

It probably makes sense to rename this from _PriorityTag to __priority_tag, especially in light of the _EnableIf renaming. @ldionne, opinion?

[Mordante]

For long double would it be possible to use an __int128_t when available? (Obviously this can't be bit_cast-ed.)
I've not looked at the tests in detail, but didn't see any obvious issues.

I'm not familiar enough with the exact details of floating point values, so I haven't validated whether this is correct. Other than that the implementation seems good to me.

libcxx/include/__compare/partial_order.h

38

I like this manually formatting a lot! Would it make sense to guard this code against clang-format, just in case we want to enable it for the entire libc++ in the future?

libcxx/include/__compare/strong_order.h

96

I'm not familiar with this floating point code. But wouldn't this assert trigger on system where sizeof(int) == 8 && sizeof(float) == 4. Isn't it possible to test with int32_t and int64_t?

[• Quuxplusone]

libcxx/include/__compare/partial_order.h

38

This is our standard formatting now for "you must write it three times" functions; see D108144. (Which came out of discussion on some other review.)
We guard it against clang-format in the same way as we guard the entire rest of libc++: don't run clang-format on these files, and if someone accidentally (or just naively) does, then we hope to catch it in code review.
(We could start wrapping whole files in clang-format off comments, but: That's an O(n) solution to an O(1) problem. And, it works only because clang-format is a monoculture. If anyone ever writes a second C++ formatter, we'd have to guard against that one, too. To really ensure that nobody can mess with our aesthetics, we'd put in some sort of technological "do-not-sed" and "do-not-awk" protection... I'm having flashbacks to DeCSS here... ;))

libcxx/include/__compare/strong_order.h

96

This assert would trigger on such systems, if any such systems exist.
On the one hand, I can't think of any reason for int to be 64-bit, unless char is also 64-bit, in which case float must also be at least 64-bit. So it makes more sense to wait and see if any such systems use libc++, and then if they do, they can submit a patch to use (i.e. conditional_t against) their particular type that works.
On the other hand, I actually did use int32_t and int64_t on lines 52–58, so why do I switch back to the built-in types here? I forget. It's particularly weird that I'm testing three types when in practice they'll only have two different sizes (32 and 64). So probably I should just change this to test only int32_t and int64_t.
I dunno; anyone else want to be the tiebreaker?

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

448

@Mordante writes:

For long double would it be possible to use an __int128_t when available? (Obviously this can't be bit_cast-ed.)

Yeah, long double on x86-64 has 80 value bits and 48 padding bits, so it can't be bit-casted straight to 128-bit __int128_t. We can bit-cast it to an array of char and then inspect the bytes individually; but then we have to be really confident about how they're arranged in memory (endianness? which side does the padding wind up on?) and I haven't done that homework.
Orthogonally, on non-IEC559 (non-IEEE754) platforms like I believe PPC64, long double is actually represented in memory as a pair of IEEE754 double values with different exponents, and then to find the long double's value, you add them together. In which case I haven't even bothered to think about what the correct strong_order algorithm would look like. (It might be exactly what I've got for the non-IEEE754 codepath, and then still tiebroken by "bit_cast and memcmp." But I haven't thought about it.)
So I would prefer to leave long double unimplemented in this PR; and then either we solicit an implementation from someone who claims to know what they're doing, or else eventually I get bored and submit something (and then we wait for bugfixes from someone who knows what they're doing). :)

[Mordante]

libcxx/include/__compare/partial_order.h

38

Fair point. I recall some of these discussions and the nice link you posted about a lightning talk regarding this issue.

libcxx/include/__compare/strong_order.h

96

I prefer the int32_t and int64_t especially since you used that earlier in the code.

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

448

So I would prefer to leave long double unimplemented in this PR; and then either we solicit an implementation from someone who claims to know what they're doing, or else eventually I get bored and submit something (and then we wait for bugfixes from someone who knows what they're doing). :)

Sounds fine to me to not do long double in this PR. That sounds like the SO method, do it wrong and wait for people pointing out why it's wrong ;-)

[• Quuxplusone]

Rename _PriorityTag to __priority_tag.
In partial_order.pass.cpp, work around GCC's inability to compare NaN against non-NaN at compile time.
I bet this still needs a bunch of UNSUPPORTED: libcpp-no-concepts etc. for Apple; I'll let buildkite tell me.

[• Quuxplusone]

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

354

This fails for float on the 32-bit x86 buildkite:
https://reviews.llvm.org/harbormaster/unit/view/1389305/
(And maybe other cases would fail after this one, but buildkite won't tell us.)
Anyone got any leads on why this might be? When I try it on Godbolt, it seems OK: https://godbolt.org/z/7eEcnWev7

[• Quuxplusone]

Skip signaling-NaN tests on x86-32 (x87 floating point).

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

354

Now I can reproduce it: https://godbolt.org/z/f17a5GzM9
The problem is that when -m32, the bit-pattern of numeric_limits<float>::signaling_NaN() depends on optimization level. At -O1 the bit-pattern is 0x7fa00000. At -O0 it is 0x7fe00000, which is actually not a signaling NaN at all!
This seems to be a problem with __builtin_nansf("") on -m32: https://godbolt.org/z/cTjqxeG1T
And googling that turns up: https://stackoverflow.com/questions/22816095/signalling-nan-was-corrupted-when-returning-from-x86-function-flds-fstps-of-x87

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57484#c12

This issue is unfortunately unfixable. x87 and x86-32 ABI are just not designed to handle all details of IEEE 754 standard.

So it looks like the appropriate workaround here is just to ifdef out the offending NaN tests on x86-32 targets.

[• Quuxplusone]

strong_order depends on compare_three_way depends on three_way_comparable_with depends on Concepts, so UNSUPPORTED: libcpp-no-concepts and guard the header too.

[mumbleskates]

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

448

I could gin up some asserts for confirming the standard layout of an intel long double. Not 100% sure how to do that constexpr but I think it's doable.

long double on my ARM device(s) is a true iec559 quad precision type, and should be implementable in the same way as the others by bit_casting to __int128_t in this layout.

I find that layout for PPC long double hilarious, but thankfully the standard specifies that strong_order is not required at all for non-iec559 numeric types, so we can simply leave it out and don't have to worry about ever implementing those types unless it is added to the standard draft as a mandate in the future.

All this to say I'm happy to help pushing on this todo for our supported platforms, and I agree that we probably shouldn't get it in with this diff.

[mumbleskates]

libcxx/include/__compare/strong_order.h

96

Would it also be sensible for us to static_assert that quiet_NaN() and signaling_NaN() are ordered correctly by strong_order, or even perhaps SFINAE via a wrapper function that participates only when the behavior is as expected?

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

349–352

Now that we have bit_cast, is it not possible for us to flip the sign by round tripping it it through an integer and xor'ing it with the bits for -0.0 at compile time? (I am pretty sure that -0.0 has, in all iec559 encodings binary and decimal, only the sign bit set and all others zeroed out, which can also be checked via has_single_bit).

[• Quuxplusone]

libcxx/include/__compare/strong_order.h

96

Would it also be sensible for us to static_assert that quiet_NaN() and signaling_NaN() are ordered correctly by strong_order

Isn't that covered in the tests below? (I'll comment on the exact line.)

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

349–352

It appears that we can! https://godbolt.org/z/z163Ges6G
However, this requires a bit of metaprogramming to determine an integral type with the same width as F, and that's a bit more complicated than I really want to put into this test file. It would basically be repeating the conditional_t chain from lines 91–94 of strong_order.h.

auto copysign = [](F f, int sign) {
    using I = std::conditional_t<sizeof(F) == sizeof(int32_t), int32_t,
        std::conditional_t<sizeof(F) == sizeof(int64_t), int64_t, void>>;
    I mask = std::bit_cast<I>(F(-0.0));
    if (sign < 0) {
        return std::bit_cast<F>(std::bit_cast<I>(to) | mask);
    } else {
        return std::bit_cast<F>(std::bit_cast<I>(to) & ~mask);
    }
};

387

@mumbleskates: This is the exact line that compares quiet_NaN() against signaling_NaN() (and see line 395 too).
Notice that we're testing "positive quiet NaN" (which might not be literally quiet_NaN()) against "positive signaling NaN" (which might not be literally signaling_NaN()), and lines 361 and 370 are testing "negative quiet" against "negative signaling"; we never literally test the numeric_limits values directly. The Standard doesn't mandate (AFAIK) whether numeric_limits<F>::quiet_NaN() should have a positive or negative sign bit.

[mumbleskates]

libcxx/include/__compare/strong_order.h

96

I was thinking about in the library itself, such that the assertion runs at compile time for the user rather than only in our test suite's platform coverage. If that isn't part of our mandate of rigor and our CI tests are adequate for deploying the code everywhere then I suppose that would answer my question.

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

349–352

Okay, that's pretty cool! and could be helpful, depending on your thoughts on my other comments here.

387

Yeah, this all makes sense. I was mostly thinking in terms of getting this to also run statically, or check at our strong_ordering header's compile time whether these basic assumptions about the natural ordering of float payloads hold. Again not sure whether that's within our mandate, but recall that the iec559 standard recommends, but does not require, that the signaling bit be set to 1 for quiet and 0 for signaling; it may be reversed.

So yes, this also depends on how paranoid we are being. The only arch I have read about doing this for sure is PA-RISC, whose most recently released CPU came out in 2005, and any support for that platform is "out-of-tree" for LLVM.

[• Quuxplusone]

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

387

I think that adding static_assert to our actual libcxx/include/ headers would be a bad idea. Our libcxx/test/ tests will certainly catch such an issue, on any supported platform; and I would hope that anyone trying to use libc++ on a non-supported platform would at least think to run the tests first, just out of curiosity.

I did notice on Godbolt that apparently MSVC-on-Windows uses 0x7fc00000 for quiet-NaN (as usual) but 0x7fc00001 for signaling-NaN (which is not a signaling NaN on the platforms I'm familiar with).
https://godbolt.org/z/oh6ch1dGa

[mumbleskates]

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

387

Okay that makes sense. If there are really that many buggy underlying implementations of quiet_NaN and signaling_NaN we're an order of magnitude more likely to see those just be outright wrong in this way than we are to find platforms with different-looking NaNs then it isn't really very helpful for us to guard against it this way. Sounds good

[ldionne]

libcxx/include/__compare/partial_order.h

35

That speaks a bit more than go (even though I'm pretty sure I'm guilty of this name at some point too, I have a faint memory).

38

As a side note, usually we do this:

noexcept(noexcept(EXPRESSION))
-> decltype(      EXPRESSION)
{ return          EXPRESSION; }

67

Do you want to ADL-protect those?

libcxx/include/__compare/strong_order.h

41

Throughout: I've found it a bit surprising that the parameters are called e and f. I would've found a and b easier to follow and closer to what everyone does. Any reason?

59

So for long double, we're supposed to implement it using the ISO/IEC/IEEE 60559 algorithm but currently we fall back to the common operator< & friends. Are those equivalent, but the ISO/IEC/IEEE 60559 is simply more efficient? If that's the case, I think it's reasonable not to implement it immediately. However, if the current implementation isn't correct on long double, then we either can't ship it or we should error out explicitly if someone uses long double.

libcxx/include/__compare/weak_order.h

47

What am I missing here? We're never checking for is_iec559?

libcxx/include/__utility/priority_tag.h

21–22

Yeah, I agree.

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

112

General comment for all the floating point comparisons in this patch: is there an existing set of inputs with known comparison outputs we could use and feed as test data? IOW, if we had a list of floating points and how they compare to each other, we could use that to validate our implementation -- as long as we satisfy that almost exhaustive set of inputs, we'd know our algorithm is most likely implemented correctly.

[• Quuxplusone]

@ldionne ping — some responses to your comments; no planned changes yet.

libcxx/include/__compare/partial_order.h

35

FWIW, I wanted to stay away from "overloading" names that already have a different meaning in the STL. What we're doing here is very much not apply'ing anything (in the std::apply sense); we just need a name that is both a reasonable substitute for operator(), and reasonably Ctrl+F'able (so I also didn't want __f). I also have a faint memory of __go somewhere in libc++, but git grep says it's not there now.

Still, I think it would be nice for us to standardize on __go, for "overload sets like this that take __priority_tag"!

67

You mean __go? No, it's a member, so it needn't (and can't) be qualified.

libcxx/include/__compare/strong_order.h

41

The Standard calls them E and F, so I just went with that.
https://eel.is/c++draft/cmp.alg#1
I suspect the original etymology is just "Expression". :)
I'm not super strongly attached, but if we were to change them, I think I'd want _Tp __t, _Up __u over either _Tp __a, _Up __b (inconsistent) or _Ap __a, _Bp __b (unfamiliar).

59

"Are those equivalent[?]" — No; non-IEC559 types can't guarantee to order sNAN before qNAN, because we don't know anything about the bit layout of the type. However, what actually happens in this case is that we go to codegen the long else if ladder, and we get down to the bit_cast on line 101, and it blows up at compile-time because we're trying to bit_cast to void (line 93).
So, if sizeof(long double) == sizeof(double), then I think we do the right thing; and if sizeof(long double) > sizeof(double) (as on common platforms), regardless of whether it's IEC559 or not, then we already error out at compile time rather than do the wrong thing.

If you like, I could add a more explicit assertion, like

} else if constexpr (!(sizeof(_Dp) == sizeof(int32_t) || sizeof(_Dp) == sizeof(int64_t))) {
    static_assert(sizeof(_Dp) == 0, "Only 32-bit and 64-bit floating-point types are supported right now");

libcxx/include/__compare/weak_order.h

47

The weak_order algorithm doesn't benefit from knowing it's IEC559.
https://eel.is/c++draft/cmp.alg#2
We can't just compare the bits int-wise, the way we can for strong_order, because we need to arrange it so that std::weak_order(qNAN, sNAN) == std::weak_ordering::equivalent even when their bits are different. That motivates lines 55–66. And then the rest of the algorithm ends up being exactly the same no matter whether the type is IEC559 or not (because it's just the ordinary meaning of <=>, including the ordinary meaning of equivalence for positive+negative zeroes).

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

112

I don't know of an existing "test vector" for floating-point; but I claim that my lines 123–134 are pretty good if I do say so myself. ;) I'm covering INF, the whole range of normals, and positive and negative zero. The one hole, I guess, is that I'm not doing anything with subnormals (numbers whose magnitude is less than numeric_limits<F>::min()). I don't know how to generate such numbers, except through bit_cast. (But that is my own ignorance; there probably is a way I just don't know.)

[• Quuxplusone]

Mark https://wg21.link/LWG3324 as "Complete".

[ldionne]

libcxx/include/__compare/partial_order.h

35

Alright, I still prefer __apply but won't bikeshed here since it's mostly about personal preference. Let's agree on not having any standardized name for this for now :-).

38

Ping on this - please format consistently with the other places where we do this. It helps for grepping.

67

Reviewed my ADL 101 and you're right.

Note that you can, however, qualify it. Like this->__go or __fn::__go. No action needed.

libcxx/include/__compare/strong_order.h

41

Non-binding, but I'd like to use __t and __u if we can agree on that. We don't use __e very often, and we are pretty consistent about using __f to denote some sort of callable, which I find misleading here.

59

I'd be happy with the assertion.

[• Quuxplusone]

Address review comments. Rename E/F to T/U. Add a .verify.cpp test for the error message on std::strong_order(ld, ld).

Also, drive-by mark some spaceship issues as "Completed." (This will be committed as a separate git commit.)

[• Quuxplusone]

libcxx/include/__compare/partial_order.h

38

The difference was just the extra spaces I put around noexcept(noexcept( E )) and decltype( E ), right? Is this the way you want it now?

libcxx/include/__compare/strong_order.h

41

Done. (But it's easy to revert if anyone objects.)

59

Added a "temporary, TODO FIXME" .verify.cpp test to verify the current behavior.

[• Quuxplusone]

libcxx/test/std/language.support/cmp/cmp.alg/strong_order_long_double.verify.cpp

16–18 ↗

(On Diff #385660)

This test fails on arm7 (32-bit?) and Win32, where long double is 64 bits just like double.
It also fails on arm8 (64-bit?) for some reason I can't reproduce on Godbolt.
It also fails on AIX.
@ldionne: Any idea what XFAIL lines I should add here? Or shall I just eliminate this test again?

[ldionne]

LGTM with requested changes and CI passing. I think you had updates to the Status pages you wanted to do separately from this commit -- please don't forget to land those (I don't mind them being landed in the same commit FWIW).

libcxx/docs/Status/Cxx20Issues.csv

253 ↗

(On Diff #385660)

Do you mean 14.0 or 13.0 here?

libcxx/docs/Status/SpaceshipPapers.csv

5 ↗

(On Diff #385660)

Same question, 14.0 or 13.0?

libcxx/include/__compare/partial_order.h

27

_LIBCPP_HAS_NO_SPACESHIP_OPERATOR can be removed now.

38

Sorry, should have made it clearer, but the difference is the positioning of braces. This seems like a nitpick, but I've mass-modified these expressions in the past and having consistent formatting really helps.

libcxx/test/std/language.support/cmp/cmp.alg/strong_order_long_double.verify.cpp

16–18 ↗

(On Diff #385660)

What I did to figure this out is go to the various CI jobs that were failing and look for the following line in the Lit output: add Lit feature target=x86_64-pc-windows-msvc' as a result of parameter 'target_triple=x86_64-pc-windows-msvc' (and similarly for all failing platforms). I think what you want is:

// The following platforms have sizeof(long double) == sizeof(double), so this test doesn't apply to them.
// UNSUPPORTED: target={{arm64|armv8|armv7|powerpc|powerpc64}}-{{.+}}
// UNSUPPORTED: target=x86_64-pc-windows-{{.+}}

24–28 ↗

(On Diff #385660)

[• Quuxplusone]

Address @ldionne's review comments. Let's see if CI likes this now.

[• Quuxplusone]

libcxx/docs/Status/Cxx20Issues.csv

253 ↗

(On Diff #385660)

I believe I mean 13. This was D99309.

libcxx/include/__compare/partial_order.h

38

Aha. I didn't notice the braces. Fixed now, AFAICT.

[• Quuxplusone]

Stop static_assert'ing is_iec559 — it turns out that that's false for long double on AIX, but I bet the test still passes either way, so let's just verify that with buildkite.

libcxx/include/CMakeLists.txt

set(files
   __bsd_locale_fallbacks.h
   __charconv/chars_format.h
   __charconv/from_chars_result.h
   __charconv/to_chars_result.h
   __compare/common_comparison_category.h
   __compare/compare_three_way.h
   __compare/compare_three_way_result.h
   __compare/ordering.h
+  __compare/partial_order.h
+  __compare/strong_order.h
   __compare/synth_three_way.h
   __compare/three_way_comparable.h
+  __compare/weak_order.h
   __concepts/arithmetic.h
   __concepts/assignable.h
   __concepts/boolean_testable.h
   __concepts/class_or_enum.h
   __concepts/common_reference_with.h
   __concepts/common_with.h
   __concepts/constructible.h
   __concepts/convertible_to.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/__compare/partial_order.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___COMPARE_PARTIAL_ORDER
+#define _LIBCPP___COMPARE_PARTIAL_ORDER
+
+#include <__compare/compare_three_way.h>
+#include <__compare/ordering.h>
+#include <__compare/weak_order.h>
+#include <__config>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
+#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 __partial_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( partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+        }
+
+        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<1>)
+            noexcept(noexcept( partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+        }
+
+        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( partial_ordering(_VSTD::weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       partial_ordering(_VSTD::weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             partial_ordering(_VSTD::weak_order(_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 __partial_order
+
+inline namespace __cpo {
+    inline constexpr auto partial_order = __partial_order::__fn{};
+} // namespace __cpo
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_PARTIAL_ORDER

libcxx/include/__compare/strong_order.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___COMPARE_STRONG_ORDER
+#define _LIBCPP___COMPARE_STRONG_ORDER
+
+#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 <limits>
+#include <type_traits>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_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
+        {
+            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 constexpr (numeric_limits<_Dp>::radix == 2) {
+                    return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
+                } else {
+                    // This is bullet 3 of the IEEE754 algorithm, relevant
+                    // only for decimal floating-point;
+                    // see https://stackoverflow.com/questions/69068075/
+                    if (__e == 0 || _VSTD::isinf(__e)) {
+                        return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
+                    } 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::less : strong_ordering::greater;
+                } else {
+                    return __f_is_negative ? strong_ordering::greater : strong_ordering::less;
+                }
+            }
+        }
+
+        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
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___COMPARE_STRONG_ORDER

libcxx/include/__compare/weak_order.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___COMPARE_WEAK_ORDER
+#define _LIBCPP___COMPARE_WEAK_ORDER
+
+#include <__compare/compare_three_way.h>
+#include <__compare/ordering.h>
+#include <__compare/strong_order.h>
+#include <__config>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
+#include <cmath>
+#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 __weak_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<3>)
+            noexcept(noexcept( weak_ordering(weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       weak_ordering(weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             weak_ordering(weak_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 weak_ordering
+        __go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>) noexcept
+        {
+            std::partial_ordering __po = (__e <=> __f);
+            if (__po == std::partial_ordering::less) {
+                return std::weak_ordering::less;
+            } else if (__po == std::partial_ordering::equivalent) {
+                return std::weak_ordering::equivalent;
+            } else if (__po == std::partial_ordering::greater) {
+                return std::weak_ordering::greater;
+            } else {
+                // Otherwise, at least one of them is a NaN.
+                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);
+                if (__e_is_nan && __f_is_nan) {
+                    return (__f_is_negative <=> __e_is_negative);
+                } else if (__e_is_nan) {
+                    return __e_is_negative ? weak_ordering::less : weak_ordering::greater;
+                } else {
+                    return __f_is_negative ? weak_ordering::greater : weak_ordering::less;
+                }
+            }
+        }
+
+        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<1>)
+            noexcept(noexcept( weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+        }
+
+        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( weak_ordering(_VSTD::strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
+            -> decltype(       weak_ordering(_VSTD::strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
+        {
+            return             weak_ordering(_VSTD::strong_order(_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<3>()) ))
+            -> decltype(       __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<3>()) )
+        {
+            return             __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<3>());
+        }
+    };
+} // namespace __weak_order
+
+inline namespace __cpo {
+    inline constexpr auto weak_order = __weak_order::__fn{};
+} // namespace __cpo
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_WEAK_ORDER

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/compare

namespace std {
   };
 }
 */
 
 #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/partial_order.h>
+#include <__compare/strong_order.h>
 #include <__compare/three_way_comparable.h>
+#include <__compare/weak_order.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/module.modulemap

module compare {
     header "compare"
     export *
 
     module __compare {
       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 partial_order              { private header "__compare/partial_order.h"              }
+      module strong_order               { private header "__compare/strong_order.h"               }
       module synth_three_way            { private header "__compare/synth_three_way.h"            }
       module three_way_comparable       { private header "__compare/three_way_comparable.h"       }
+      module weak_order                 { private header "__compare/weak_order.h"                 }
     }
   }
   module complex {
     header "complex"
     export *
   }
   module concepts {
     header "concepts"
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/test/libcxx/diagnostics/detail.headers/compare/partial_order.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/partial_order.h'}}
+#include <__compare/partial_order.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/strong_order.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/strong_order.h'}}
+#include <__compare/strong_order.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/weak_order.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/weak_order.h'}}
+#include <__compare/weak_order.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/std/language.support/cmp/cmp.alg/partial_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>
+
+// template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
+
+#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_partial_order(T&& t, U&& u)
+    -> decltype(std::partial_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
+{
+    return true;
+}
+
+constexpr bool has_partial_order(...) {
+    return false;
+}
+
+namespace N11 {
+    struct A {};
+    struct B {};
+    std::strong_ordering partial_order(const A&, const A&) { return std::strong_ordering::less; }
+    std::strong_ordering partial_order(const A&, const B&);
+}
+
+void test_1_1()
+{
+    // If the decayed types of E and F differ, weak_order(E, F) is ill-formed.
+
+    static_assert( has_partial_order(1, 2));
+    static_assert(!has_partial_order(1, (short)2));
+    static_assert(!has_partial_order(1, 2.0));
+    static_assert(!has_partial_order(1.0f, 2.0));
+
+    static_assert( has_partial_order((int*)nullptr, (int*)nullptr));
+    static_assert(!has_partial_order((int*)nullptr, (const int*)nullptr));
+    static_assert(!has_partial_order((const int*)nullptr, (int*)nullptr));
+    static_assert( has_partial_order((const int*)nullptr, (const int*)nullptr));
+
+    N11::A a;
+    N11::B b;
+    static_assert( has_partial_order(a, a));
+    static_assert(!has_partial_order(a, b));
+}
+
+namespace N12 {
+    struct A {};
+    std::strong_ordering partial_order(A&, A&&) { return std::strong_ordering::less; }
+    std::weak_ordering partial_order(A&&, A&&) { return std::weak_ordering::equivalent; }
+    std::strong_ordering partial_order(const A&, const A&);
+
+    struct B {
+        friend int partial_order(B, B);
+    };
+
+    struct PartialOrder {
+        explicit operator std::partial_ordering() const { return std::partial_ordering::less; }
+    };
+    struct C {
+        bool touched = false;
+        friend PartialOrder partial_order(C& lhs, C&) { lhs.touched = true; return PartialOrder(); }
+    };
+}
+
+void test_1_2()
+{
+    // Otherwise, partial_ordering(partial_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::partial_order.
+
+    // Test that partial_order does not const-qualify the forwarded arguments.
+    N12::A a;
+    assert(std::partial_order(a, std::move(a)) == std::partial_ordering::less);
+    assert(std::partial_order(std::move(a), std::move(a)) == std::partial_ordering::equivalent);
+
+    // The type of partial_order(e,f) must be explicitly convertible to partial_ordering.
+    N12::B b;
+    static_assert(!has_partial_order(b, b));
+
+    N12::C c1, c2;
+    ASSERT_SAME_TYPE(decltype(std::partial_order(c1, c2)), std::partial_ordering);
+    assert(std::partial_order(c1, c2) == std::partial_ordering::less);
+    assert(c1.touched);
+    assert(!c2.touched);
+}
+
+namespace N13 {
+    // Compare to N12::A.
+    struct A {};
+    bool operator==(const A&, const A&);
+    constexpr std::partial_ordering operator<=>(A&, A&&) { return std::partial_ordering::less; }
+    constexpr std::partial_ordering operator<=>(A&&, A&&) { return std::partial_ordering::equivalent; }
+    std::partial_ordering operator<=>(const A&, const A&);
+    static_assert(std::three_way_comparable<A>);
+
+    struct B {
+        std::partial_ordering operator<=>(const B&) const;  // lacks operator==
+    };
+    static_assert(!std::three_way_comparable<B>);
+
+    struct C {
+        bool *touched;
+        bool operator==(const C&) const;
+        constexpr std::partial_ordering operator<=>(const C& rhs) const {
+            *rhs.touched = true;
+            return std::partial_ordering::equivalent;
+        }
+    };
+    static_assert(std::three_way_comparable<C>);
+}
+
+constexpr bool test_1_3()
+{
+    // Otherwise, partial_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
+
+    // Test neither partial_order nor compare_three_way const-qualify the forwarded arguments.
+    N13::A a;
+    assert(std::partial_order(a, std::move(a)) == std::partial_ordering::less);
+    assert(std::partial_order(std::move(a), std::move(a)) == std::partial_ordering::equivalent);
+
+    N13::B b;
+    static_assert(!has_partial_order(b, b));
+
+    // Test that the arguments are passed to <=> in the correct order.
+    bool c1_touched = false;
+    bool c2_touched = false;
+    N13::C c1 = {&c1_touched};
+    N13::C c2 = {&c2_touched};
+    assert(std::partial_order(c1, c2) == std::partial_ordering::equivalent);
+    assert(!c1_touched);
+    assert(c2_touched);
+
+    // For partial_order, this bullet point takes care of floating-point types;
+    // they receive their natural partial order.
+    {
+        using F = float;
+        F nan = std::numeric_limits<F>::quiet_NaN();
+        assert(std::partial_order(F(1), F(2)) == std::partial_ordering::less);
+        assert(std::partial_order(F(0), -F(0)) == std::partial_ordering::equivalent);
+        assert(std::partial_order(nan, F(1)) == std::partial_ordering::unordered);
+        assert(std::partial_order(nan, nan) == std::partial_ordering::unordered);
+    }
+    {
+        using F = double;
+        F nan = std::numeric_limits<F>::quiet_NaN();
+        assert(std::partial_order(F(1), F(2)) == std::partial_ordering::less);
+        assert(std::partial_order(F(0), -F(0)) == std::partial_ordering::equivalent);
+        assert(std::partial_order(nan, F(1)) == std::partial_ordering::unordered);
+        assert(std::partial_order(nan, nan) == std::partial_ordering::unordered);
+    }
+    {
+        using F = long double;
+        F nan = std::numeric_limits<F>::quiet_NaN();
+        assert(std::partial_order(F(1), F(2)) == std::partial_ordering::less);
+        assert(std::partial_order(F(0), -F(0)) == std::partial_ordering::equivalent);
+        assert(std::partial_order(nan, F(1)) == std::partial_ordering::unordered);
+        assert(std::partial_order(nan, nan) == std::partial_ordering::unordered);
+    }
+
+    return true;
+}
+
+namespace N14 {
+    struct A {};
+    constexpr std::strong_ordering weak_order(A&, A&&) { return std::strong_ordering::less; }
+    constexpr std::strong_ordering weak_order(A&&, A&&) { return std::strong_ordering::equal; }
+    std::strong_ordering weak_order(const A&, const A&);
+
+    struct B {
+        friend std::partial_ordering weak_order(B, B);
+    };
+
+    struct StrongOrder {
+        operator std::strong_ordering() const { return std::strong_ordering::less; }
+    };
+    struct C {
+        friend StrongOrder weak_order(C& lhs, C&);
+    };
+
+    struct WeakOrder {
+        constexpr explicit operator std::weak_ordering() const { return std::weak_ordering::less; }
+        operator std::partial_ordering() const = delete;
+    };
+    struct D {
+        bool touched = false;
+        friend constexpr WeakOrder weak_order(D& lhs, D&) { lhs.touched = true; return WeakOrder(); }
+    };
+}
+
+constexpr bool test_1_4()
+{
+    // Otherwise, partial_ordering(weak_order(E, F)) [that is, std::weak_order]
+    // if it is a well-formed expression.
+
+    // Test that partial_order and weak_order do not const-qualify the forwarded arguments.
+    N14::A a;
+    assert(std::partial_order(a, std::move(a)) == std::partial_ordering::less);
+    assert(std::partial_order(std::move(a), std::move(a)) == std::partial_ordering::equivalent);
+
+    // The type of ADL weak_order(e,f) must be explicitly convertible to weak_ordering
+    // (not just to partial_ordering), or else std::weak_order(e,f) won't exist.
+    N14::B b;
+    static_assert(!has_partial_order(b, b));
+
+    // The type of ADL weak_order(e,f) must be explicitly convertible to weak_ordering
+    // (not just to strong_ordering), or else std::weak_order(e,f) won't exist.
+    N14::C c;
+    static_assert(!has_partial_order(c, c));
+
+    N14::D d1, d2;
+    ASSERT_SAME_TYPE(decltype(std::partial_order(d1, d2)), std::partial_ordering);
+    assert(std::partial_order(d1, d2) == std::partial_ordering::less);
+    assert(d1.touched);
+    assert(!d2.touched);
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test_1_1();
+    test_1_2();
+    test_1_3();
+    test_1_4();
+
+    static_assert(test_1_3());
+    static_assert(test_1_4());
+
+    return 0;
+}

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>
+
+// template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
+
+#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 StrongOrder {
+        explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
+    };
+    struct C {
+        bool touched = false;
+        friend StrongOrder strong_order(C& lhs, C&) { lhs.touched = true; return StrongOrder(); }
+    };
+}
+
+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_ordering.
+    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 {
+        bool *touched;
+        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));
+
+    // Test that the arguments are passed to <=> in the correct order.
+    bool c1_touched = false;
+    bool c2_touched = false;
+    N14::C c1 = {&c1_touched};
+    N14::C c2 = {&c2_touched};
+    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>();  // UNIMPLEMENTED
+    test_1_4();
+
+    static_assert(test_1_3<float>());
+    static_assert(test_1_3<double>());
+    // static_assert(test_1_3<long double>());  // UNIMPLEMENTED
+    static_assert(test_1_4());
+
+    return 0;
+}

libcxx/test/std/language.support/cmp/cmp.alg/weak_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>
+
+// template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
+
+#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_weak_order(T&& t, U&& u)
+    -> decltype(std::weak_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
+{
+    return true;
+}
+
+constexpr bool has_weak_order(...) {
+    return false;
+}
+
+namespace N11 {
+    struct A {};
+    struct B {};
+    std::strong_ordering weak_order(const A&, const A&) { return std::strong_ordering::less; }
+    std::strong_ordering weak_order(const A&, const B&);
+}
+
+void test_1_1()
+{
+    // If the decayed types of E and F differ, weak_order(E, F) is ill-formed.
+
+    static_assert( has_weak_order(1, 2));
+    static_assert(!has_weak_order(1, (short)2));
+    static_assert(!has_weak_order(1, 2.0));
+    static_assert(!has_weak_order(1.0f, 2.0));
+
+    static_assert( has_weak_order((int*)nullptr, (int*)nullptr));
+    static_assert(!has_weak_order((int*)nullptr, (const int*)nullptr));
+    static_assert(!has_weak_order((const int*)nullptr, (int*)nullptr));
+    static_assert( has_weak_order((const int*)nullptr, (const int*)nullptr));
+
+    N11::A a;
+    N11::B b;
+    static_assert( has_weak_order(a, a));
+    static_assert(!has_weak_order(a, b));
+}
+
+namespace N12 {
+    struct A {};
+    std::strong_ordering weak_order(A&, A&&) { return std::strong_ordering::less; }
+    std::strong_ordering weak_order(A&&, A&&) { return std::strong_ordering::equal; }
+    std::strong_ordering weak_order(const A&, const A&);
+
+    struct B {
+        friend std::partial_ordering weak_order(B&, B&);
+    };
+
+    struct WeakOrder {
+        explicit operator std::weak_ordering() const { return std::weak_ordering::less; }
+    };
+    struct C {
+        bool touched = false;
+        friend WeakOrder weak_order(C& lhs, C&) { lhs.touched = true; return WeakOrder(); }
+    };
+}
+
+void test_1_2()
+{
+    // Otherwise, weak_ordering(weak_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::weak_order.
+
+    // Test that weak_order does not const-qualify the forwarded arguments.
+    N12::A a;
+    assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
+    assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
+
+    // The type of weak_order(e,f) must be explicitly convertible to weak_ordering.
+    N12::B b;
+    static_assert(!has_weak_order(b, b));
+
+    N12::C c1, c2;
+    ASSERT_SAME_TYPE(decltype(std::weak_order(c1, c2)), std::weak_ordering);
+    assert(std::weak_order(c1, c2) == std::weak_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 weak_ordering that is consistent with
+    // the ordering observed by T's comparison operators and strong_order,
+    // and if numeric_limits<T>::is_iec559 is true, is additionally consistent with
+    // the following equivalence classes...
+
+    static_assert(std::numeric_limits<F>::is_iec559);
+
+    ASSERT_SAME_TYPE(decltype(std::weak_order(F(0), F(0))), std::weak_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::weak_order(v[0], v[0]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[0], v[1]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[2]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[3]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[4]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[5]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[6]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[0], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[1], v[1]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[1], v[2]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[3]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[4]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[5]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[6]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[1], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[2], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[2], v[2]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[2], v[3]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[4]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[5]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[6]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[2], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[3], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[3], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[3], v[3]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[3], v[4]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[5]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[6]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[3], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[4], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[4], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[4], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[4], v[4]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[4], v[5]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[6]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[4], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[5], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[5], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[5], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[5], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[5], v[5]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[5], v[6]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[5], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[5], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[6], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[6], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[6], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[6], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[6], v[5]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[6], v[6]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[6], v[7]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[6], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[7], v[7]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[7], v[8]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[7], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[8], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[8], v[8]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[8], v[9]) == std::weak_ordering::less);
+    assert(std::weak_order(v[8], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[8], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[8], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[8], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[9], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[8]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[9], v[9]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[9], v[10]) == std::weak_ordering::less);
+    assert(std::weak_order(v[9], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[9], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[9], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[10], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[8]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[9]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[10], v[10]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[10], v[11]) == std::weak_ordering::less);
+    assert(std::weak_order(v[10], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[10], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[11], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[8]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[9]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[10]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[11], v[11]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[11], v[12]) == std::weak_ordering::less);
+    assert(std::weak_order(v[11], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[12], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[8]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[9]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[10]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[11]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[12], v[12]) == std::weak_ordering::equivalent);
+    assert(std::weak_order(v[12], v[13]) == std::weak_ordering::less);
+    assert(std::weak_order(v[13], v[0]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[1]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[2]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[3]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[4]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[5]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[6]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[7]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[8]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[9]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[10]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[11]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[12]) == std::weak_ordering::greater);
+    assert(std::weak_order(v[13], v[13]) == std::weak_ordering::equivalent);
+
+
+    // 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::weak_order(nq, nq) == std::weak_ordering::equivalent);
+        assert(std::weak_order(nq, ns) == std::weak_ordering::equivalent);
+        for (int i=0; i < 14; ++i) {
+            assert(std::weak_order(nq, v[i]) == std::weak_ordering::less);
+        }
+        assert(std::weak_order(nq, ps) == std::weak_ordering::less);
+        assert(std::weak_order(nq, pq) == std::weak_ordering::less);
+
+        assert(std::weak_order(ns, nq) == std::weak_ordering::equivalent);
+        assert(std::weak_order(ns, ns) == std::weak_ordering::equivalent);
+        for (int i=0; i < 14; ++i) {
+            assert(std::weak_order(ns, v[i]) == std::weak_ordering::less);
+        }
+        assert(std::weak_order(ns, ps) == std::weak_ordering::less);
+        assert(std::weak_order(ns, pq) == std::weak_ordering::less);
+
+        assert(std::weak_order(ps, nq) == std::weak_ordering::greater);
+        assert(std::weak_order(ps, ns) == std::weak_ordering::greater);
+        for (int i=0; i < 14; ++i) {
+            assert(std::weak_order(ps, v[i]) == std::weak_ordering::greater);
+        }
+        assert(std::weak_order(ps, ps) == std::weak_ordering::equivalent);
+        assert(std::weak_order(ps, pq) == std::weak_ordering::equivalent);
+
+        assert(std::weak_order(pq, nq) == std::weak_ordering::greater);
+        assert(std::weak_order(pq, ns) == std::weak_ordering::greater);
+        for (int i=0; i < 14; ++i) {
+            assert(std::weak_order(pq, v[i]) == std::weak_ordering::greater);
+        }
+        assert(std::weak_order(pq, ps) == std::weak_ordering::equivalent);
+        assert(std::weak_order(pq, pq) == std::weak_ordering::equivalent);
+    }
+
+    return true;
+}
+
+namespace N14 {
+    // Compare to N12::A.
+    struct A {};
+    bool operator==(const A&, const A&);
+    constexpr std::weak_ordering operator<=>(A&, A&&) { return std::weak_ordering::less; }
+    constexpr std::weak_ordering operator<=>(A&&, A&&) { return std::weak_ordering::equivalent; }
+    std::weak_ordering operator<=>(const A&, const A&);
+    static_assert(std::three_way_comparable<A>);
+
+    struct B {
+        std::weak_ordering operator<=>(const B&) const;  // lacks operator==
+    };
+    static_assert(!std::three_way_comparable<B>);
+
+    struct C {
+        bool *touched;
+        bool operator==(const C&) const;
+        constexpr std::weak_ordering operator<=>(const C& rhs) const {
+            *rhs.touched = true;
+            return std::weak_ordering::equivalent;
+        }
+    };
+    static_assert(std::three_way_comparable<C>);
+}
+
+constexpr bool test_1_4()
+{
+    // Otherwise, weak_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
+
+    // Test neither weak_order nor compare_three_way const-qualify the forwarded arguments.
+    N14::A a;
+    assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
+    assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
+
+    N14::B b;
+    static_assert(!has_weak_order(b, b));
+
+    // Test that the arguments are passed to <=> in the correct order.
+    bool c1_touched = false;
+    bool c2_touched = false;
+    N14::C c1 = {&c1_touched};
+    N14::C c2 = {&c2_touched};
+    assert(std::weak_order(c1, c2) == std::weak_ordering::equivalent);
+    assert(!c1_touched);
+    assert(c2_touched);
+
+    return true;
+}
+
+namespace N15 {
+    struct A {};
+    constexpr std::strong_ordering strong_order(A&, A&&) { return std::strong_ordering::less; }
+    constexpr 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 WeakOrder {
+        operator std::weak_ordering() const { return std::weak_ordering::less; }
+    };
+    struct C {
+        friend WeakOrder strong_order(C& lhs, C&);
+    };
+
+    struct StrongOrder {
+        constexpr explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
+        operator std::weak_ordering() const = delete;
+    };
+    struct D {
+        bool touched = false;
+        friend constexpr StrongOrder strong_order(D& lhs, D&) { lhs.touched = true; return StrongOrder(); }
+    };
+}
+
+constexpr bool test_1_5()
+{
+    // Otherwise, weak_ordering(strong_order(E, F)) [that is, std::strong_order]
+    // if it is a well-formed expression.
+
+    // Test that weak_order and strong_order do not const-qualify the forwarded arguments.
+    N15::A a;
+    assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
+    assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
+
+    // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
+    // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
+    N15::B b;
+    static_assert(!has_weak_order(b, b));
+
+    // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
+    // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
+    N15::C c;
+    static_assert(!has_weak_order(c, c));
+
+    N15::D d1, d2;
+    ASSERT_SAME_TYPE(decltype(std::weak_order(d1, d2)), std::weak_ordering);
+    assert(std::weak_order(d1, d2) == std::weak_ordering::less);
+    assert(d1.touched);
+    assert(!d2.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();
+    test_1_5();
+
+    static_assert(test_1_3<float>());
+    static_assert(test_1_3<double>());
+    static_assert(test_1_3<long double>());
+    static_assert(test_1_4());
+    static_assert(test_1_5());
+
+    return 0;
+}