libsupc++: Implement comparison algorithms for C++20
diff mbox series

Message ID 20191113162611.GA22189@redhat.com
State New
Headers show
Series
  • libsupc++: Implement comparison algorithms for C++20
Related show

Commit Message

Jonathan Wakely Nov. 13, 2019, 4:26 p.m. UTC
This is incomplete because std::strong_order doesn't support
floating-point types.

The partial_order and weak_order tests use VERIFY instead of
static_assert because of PR 92431.

	* libsupc++/compare (strong_order, weak_order, partial_order)
	(compare_strong_order_fallback, compare_weak_order_fallback)
	(compare_partial_order_fallback): Define customization point objects
	for C++20.
	* testsuite/18_support/comparisons/algorithms/partial_order.cc: New
	test.
	* testsuite/18_support/comparisons/algorithms/strong_order.cc: New
	test.
	* testsuite/18_support/comparisons/algorithms/weak_order.cc: New test.

Tested powerpc64le-linux, committed to trunk.
commit e4dc0c07ed229d6efca300b42753fcd365db0085
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Nov 7 21:58:46 2019 +0000

    libsupc++: Implement comparison algorithms for C++20
    
    This is incomplete because std::strong_order doesn't support
    floating-point types.
    
    The partial_order and weak_order tests use VERIFY instead of
    static_assert because of PR 92431.
    
            * libsupc++/compare (strong_order, weak_order, partial_order)
            (compare_strong_order_fallback, compare_weak_order_fallback)
            (compare_partial_order_fallback): Define customization point objects
            for C++20.
            * testsuite/18_support/comparisons/algorithms/partial_order.cc: New
            test.
            * testsuite/18_support/comparisons/algorithms/strong_order.cc: New
            test.
            * testsuite/18_support/comparisons/algorithms/weak_order.cc: New test.

Comments

Daniel Krügler Nov. 13, 2019, 5:52 p.m. UTC | #1
Am Mi., 13. Nov. 2019 um 17:26 Uhr schrieb Jonathan Wakely <jwakely@redhat.com>:
>
> This is incomplete because std::strong_order doesn't support
> floating-point types.

I'm wondering whether the local __cat lambda expression at the
beginning of __fp_weak_ordering is part of the incomplete code or just
spurious?

- Daniel
Jonathan Wakely Nov. 13, 2019, 9:45 p.m. UTC | #2
On 13/11/19 18:52 +0100, Daniel Krügler wrote:
>Am Mi., 13. Nov. 2019 um 17:26 Uhr schrieb Jonathan Wakely <jwakely@redhat.com>:
>>
>> This is incomplete because std::strong_order doesn't support
>> floating-point types.
>
>I'm wondering whether the local __cat lambda expression at the
>beginning of __fp_weak_ordering is part of the incomplete code or just
>spurious?

Oops, it's spurious. That was part of a previous implementation, but
is no longer used. I'll remove that.

__fp_weak_order is complete, it's the strong_order implementation for
floating-point types that's missing. I'll be posting that in reply to
https://gcc.gnu.org/ml/libstdc++/2019-11/msg00011.html in a few
minutes.

However, I think __fp_weak_order will fail for __float128 because
comparisons involving 128-bit NaNs are not valid in constant
expressions. I'll add some tests with __float128 and investigate that.

Patch
diff mbox series

diff --git a/libstdc++-v3/libsupc++/compare b/libstdc++-v3/libsupc++/compare
index 94728e29de8..289145dea56 100644
--- a/libstdc++-v3/libsupc++/compare
+++ b/libstdc++-v3/libsupc++/compare
@@ -576,20 +576,346 @@  namespace std
     using is_transparent = void;
   };
 
+  namespace __cmp_cust
+  {
+    template<floating_point _Tp>
+      constexpr weak_ordering
+      __fp_weak_ordering(_Tp __e, _Tp __f)
+      {
+	// Returns an integer with the same sign as the argument, and magnitude
+	// indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5
+	auto __cat = [](_Tp __fp) -> int {
+	  const int __sign = __builtin_signbit(__fp) ? -1 : 1;
+	  if (__builtin_isnormal(__fp))
+	    return (__fp == 0 ? 1 : 3) * __sign;
+	  if (__builtin_isnan(__fp))
+	    return 5 * __sign;
+	  if (int __inf = __builtin_isinf_sign(__fp))
+	    return 4 * __inf;
+	  return 2 * __sign;
+	};
+
+	auto __po = __e <=> __f;
+	if (is_lt(__po))
+	  return weak_ordering::less;
+	else if (is_gt(__po))
+	  return weak_ordering::greater;
+	else if (__po == partial_ordering::equivalent)
+	  return weak_ordering::equivalent;
+	else  // unordered, at least one argument is NaN
+	  {
+	    // return -1 for negative nan, +1 for positive nan, 0 otherwise.
+	    auto __isnan_sign = [](_Tp __fp) -> int {
+	      return __builtin_isnan(__fp)
+		? __builtin_signbit(__fp) ? -1 : 1
+		: 0;
+	    };
+	    auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
+	    if (is_eq(__ord))
+	      return weak_ordering::equivalent;
+	    else if (is_lt(__ord))
+	      return weak_ordering::less;
+	    else
+	      return weak_ordering::greater;
+	  }
+      }
+
+    template<typename _Tp, typename _Up>
+      concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
+	{
+	  strong_ordering(strong_order(static_cast<_Tp&&>(__t),
+				       static_cast<_Up&&>(__u)));
+	};
+
+    template<typename _Tp, typename _Up>
+      concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
+	{
+	  weak_ordering(weak_order(static_cast<_Tp&&>(__t),
+				   static_cast<_Up&&>(__u)));
+	};
+
+    template<typename _Tp, typename _Up>
+      concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
+	{
+	  partial_ordering(partial_order(static_cast<_Tp&&>(__t),
+					 static_cast<_Up&&>(__u)));
+	};
+
+    template<typename _Ord, typename _Tp, typename _Up>
+      concept __op_cmp = requires(_Tp&& __t, _Up&& __u)
+	{
+	  _Ord(static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u));
+	};
+
+    template<typename _Tp, typename _Up>
+      concept __strongly_ordered
+	= __adl_strong<_Tp, _Up>
+	  // FIXME: || floating_point<remove_reference_t<_Tp>>
+	  || __op_cmp<strong_ordering, _Tp, _Up>;
+
+    class _Strong_order
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (floating_point<decay_t<_Tp>>)
+	    return true;
+	  else if constexpr (__adl_strong<_Tp, _Up>)
+	    return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
+							 std::declval<_Up>())));
+	  else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
+	    return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
+	}
+
+      friend class _Weak_order;
+      friend class _Strong_fallback;
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __strongly_ordered<_Tp, _Up>
+	constexpr strong_ordering
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  /* FIXME:
+	  if constexpr (floating_point<decay_t<_Tp>>)
+	    return __cmp_cust::__fp_strong_order(__e, __f);
+	  else */ if constexpr (__adl_strong<_Tp, _Up>)
+	    return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
+						static_cast<_Up&&>(__f)));
+	  else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
+	}
+    };
+
+    template<typename _Tp, typename _Up>
+      concept __weakly_ordered
+	= floating_point<remove_reference_t<_Tp>>
+	  || __adl_weak<_Tp, _Up>
+	  || __op_cmp<weak_ordering, _Tp, _Up>
+	  || __strongly_ordered<_Tp, _Up>;
+
+    class _Weak_order
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (floating_point<decay_t<_Tp>>)
+	    return true;
+	  else if constexpr (__adl_weak<_Tp, _Up>)
+	    return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
+						     std::declval<_Up>())));
+	  else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
+	    return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
+	  else if constexpr (__strongly_ordered<_Tp, _Up>)
+	    return _Strong_order::_S_noexcept<_Tp, _Up>();
+	}
+
+      friend class _Partial_order;
+      friend class _Weak_fallback;
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __weakly_ordered<_Tp, _Up>
+	constexpr weak_ordering
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  if constexpr (floating_point<decay_t<_Tp>>)
+	    return __cmp_cust::__fp_weak_ordering(__e, __f);
+	  else if constexpr (__adl_weak<_Tp, _Up>)
+	    return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
+					    static_cast<_Up&&>(__f)));
+	  else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
+	  else if constexpr (__strongly_ordered<_Tp, _Up>)
+	    return _Strong_order{}(static_cast<_Tp&&>(__e),
+				   static_cast<_Up&&>(__f));
+	}
+    };
+
+    template<typename _Tp, typename _Up>
+      concept __partially_ordered
+	= __adl_partial<_Tp, _Up>
+	|| __op_cmp<partial_ordering, _Tp, _Up>
+	|| __weakly_ordered<_Tp, _Up>;
+
+    class _Partial_order
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (__adl_partial<_Tp, _Up>)
+	    return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
+							 std::declval<_Up>())));
+	  else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
+	    return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
+	  else if constexpr (__weakly_ordered<_Tp, _Up>)
+	    return _Weak_order::_S_noexcept<_Tp, _Up>();
+	}
+
+      friend class _Partial_fallback;
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __partially_ordered<_Tp, _Up>
+	constexpr partial_ordering
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  if constexpr (__adl_partial<_Tp, _Up>)
+	    return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
+						  static_cast<_Up&&>(__f)));
+	  else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
+	  else if constexpr (__weakly_ordered<_Tp, _Up>)
+	    return _Weak_order{}(static_cast<_Tp&&>(__e),
+				 static_cast<_Up&&>(__f));
+	}
+    };
+
+    template<typename _Tp, typename _Up>
+      concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
+	{
+	  { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
+	    -> convertible_to<bool>;
+	  { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
+	    -> convertible_to<bool>;
+	};
+
+    class _Strong_fallback
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (__strongly_ordered<_Tp, _Up>)
+	    return _Strong_order::_S_noexcept<_Tp, _Up>();
+	  else
+	    return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+	      && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+	}
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
+	constexpr decltype(auto)
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  if constexpr (__strongly_ordered<_Tp, _Up>)
+	    return _Strong_order{}(static_cast<_Tp&&>(__e),
+				   static_cast<_Up&&>(__f));
+	  else if constexpr (__op_eq_lt<_Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+	      ? strong_ordering::equal
+	      : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+	      ? strong_ordering::less
+	      : strong_ordering::greater;
+	}
+    };
+
+    class _Weak_fallback
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (__weakly_ordered<_Tp, _Up>)
+	    return _Weak_order::_S_noexcept<_Tp, _Up>();
+	  else
+	    return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+	      && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+	}
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
+	constexpr decltype(auto)
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  if constexpr (__weakly_ordered<_Tp, _Up>)
+	    return _Weak_order{}(static_cast<_Tp&&>(__e),
+				 static_cast<_Up&&>(__f));
+	  else if constexpr (__op_eq_lt<_Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+	      ? weak_ordering::equivalent
+	      : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+	      ? weak_ordering::less
+	      : weak_ordering::greater;
+	}
+    };
+
+    class _Partial_fallback
+    {
+      template<typename _Tp, typename _Up>
+	static constexpr bool
+	_S_noexcept()
+	{
+	  if constexpr (__partially_ordered<_Tp, _Up>)
+	    return _Partial_order::_S_noexcept<_Tp, _Up>();
+	  else
+	    return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+	      && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+	}
+
+    public:
+      template<typename _Tp, typename _Up>
+	requires __partially_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
+	constexpr decltype(auto)
+	operator()(_Tp&& __e, _Up&& __f) const
+	noexcept(_S_noexcept<_Tp, _Up>())
+	{
+	  static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
+
+	  if constexpr (__partially_ordered<_Tp, _Up>)
+	    return _Partial_order{}(static_cast<_Tp&&>(__e),
+				    static_cast<_Up&&>(__f));
+	  else if constexpr (__op_eq_lt<_Tp, _Up>)
+	    return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+	      ? partial_ordering::equivalent
+	      : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+	      ? partial_ordering::less
+	      : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
+	      ? partial_ordering::greater
+	      : partial_ordering::unordered;
+	}
+    };
+  } // namespace __cmp_cust
+
   // [cmp.alg], comparison algorithms
   inline namespace __cmp_alg
   {
-    // TODO
-#if 0
-    inline constexpr unspecified strong_order = unspecified;
-    inline constexpr unspecified weak_order = unspecified;
-    inline constexpr unspecified partial_order = unspecified;
-    inline constexpr unspecified compare_strong_order_fallback = unspecified;
-    inline constexpr unspecified compare_weak_order_fallback = unspecified;
-    inline constexpr unspecified compare_partial_order_fallback = unspecified;
-#endif
+    inline constexpr __cmp_cust::_Strong_order strong_order{};
+
+    inline constexpr __cmp_cust::_Weak_order weak_order{};
+
+    inline constexpr __cmp_cust::_Partial_order partial_order{};
+
+    inline constexpr __cmp_cust::_Strong_fallback
+    compare_strong_order_fallback{};
+
+    inline constexpr __cmp_cust::_Weak_fallback
+    compare_weak_order_fallback{};
+
+    inline constexpr __cmp_cust::_Partial_fallback
+    compare_partial_order_fallback{};
   }
-#endif
+#endif // concepts
 } // namespace std
 
 #pragma GCC visibility pop
diff --git a/libstdc++-v3/testsuite/18_support/comparisons/algorithms/partial_order.cc b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/partial_order.cc
new file mode 100644
index 00000000000..ec85996e16d
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/partial_order.cc
@@ -0,0 +1,118 @@ 
+// Copyright (C) 2019 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <compare>
+#include <limits>
+#include <testsuite_hooks.h>
+
+using std::partial_order;
+using std::partial_ordering;
+
+void
+test01()
+{
+  int one = 1, two = 2;
+
+  VERIFY( partial_order(one, two) == partial_ordering::less );
+  VERIFY( partial_order(one, one) == partial_ordering::equivalent );
+  VERIFY( partial_order(two, one) == partial_ordering::greater );
+  static_assert( noexcept(partial_order(1, 1)) );
+}
+
+constexpr partial_ordering different_cv_quals(int i, const int j)
+{
+  return partial_order(i, j);
+}
+
+void
+test02()
+{
+  int fortytwo = 42, nines = 999, lots = 1000;
+  VERIFY( different_cv_quals(fortytwo, nines) == partial_ordering::less );
+  VERIFY( different_cv_quals(-nines, -nines) == partial_ordering::equivalent );
+  VERIFY( different_cv_quals(-nines, -lots) == partial_ordering::greater );
+}
+
+void
+test03()
+{
+  double zero = 0.0;
+  VERIFY( partial_order(zero, zero) == partial_ordering::equivalent );
+  VERIFY( partial_order(-zero, -zero) == partial_ordering::equivalent );
+  VERIFY( partial_order(-zero, zero) == partial_ordering::equivalent );
+  VERIFY( partial_order(zero, -zero) == partial_ordering::equivalent );
+  static_assert( noexcept(partial_order(zero, 1.0)) );
+  static_assert( partial_order(0.0, 1.0) == std::partial_ordering::less );
+
+  double min = std::numeric_limits<double>::lowest();
+  double max = std::numeric_limits<double>::max();
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  double inf = std::numeric_limits<double>::infinity();
+  double denorm = std::numeric_limits<double>::denorm_min();
+  double smallest = std::numeric_limits<double>::min();
+  double epsilon = std::numeric_limits<double>::epsilon();
+  VERIFY( partial_order(denorm, smallest) == partial_ordering::less );
+  VERIFY( partial_order(denorm, 0.0) == partial_ordering::greater );
+  VERIFY( partial_order(0.0, nan) == partial_ordering::unordered );
+  VERIFY( partial_order(nan, nan) == partial_ordering::unordered );
+  VERIFY( partial_order(nan, 0.0) == partial_ordering::unordered );
+  VERIFY( partial_order(-nan, 0.0) == partial_ordering::unordered );
+  VERIFY( partial_order(-nan, min) == partial_ordering::unordered );
+  VERIFY( partial_order(-inf, min) == partial_ordering::less );
+  VERIFY( partial_order(-nan, -inf) == partial_ordering::unordered );
+  VERIFY( partial_order(-inf, -nan) == partial_ordering::unordered );
+  VERIFY( partial_order(max, inf) == partial_ordering::less );
+  VERIFY( partial_order(inf, max) == partial_ordering::greater );
+  VERIFY( partial_order(inf, nan) == partial_ordering::unordered );
+  VERIFY( partial_order(1.0, 1.0+epsilon) == partial_ordering::less );
+}
+
+namespace N
+{
+  struct X { int i; };
+
+  constexpr partial_ordering operator<=>(X l, X r)
+  {
+    if (l.i < 0 && r.i < 0)
+      return partial_ordering::equivalent;
+    return r.i <=> l.i;
+  }
+}
+
+void
+test04()
+{
+  using N::X;
+  X one{1};
+  X negone{-1};
+
+  VERIFY( partial_order(one, X{1}) == partial_ordering::equivalent );
+  VERIFY( partial_order(negone, X{-2}) == partial_ordering::equivalent );
+  VERIFY( partial_order(one, X{2}) == partial_ordering::greater );
+  static_assert( !noexcept(partial_order(X{1}, X{2})) );
+}
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+}
diff --git a/libstdc++-v3/testsuite/18_support/comparisons/algorithms/strong_order.cc b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/strong_order.cc
new file mode 100644
index 00000000000..2c813494ce7
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/strong_order.cc
@@ -0,0 +1,56 @@ 
+// Copyright (C) 2019 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <compare>
+#include <limits>
+
+using std::strong_order;
+using std::strong_ordering;
+
+static_assert( strong_order(1, 2) == strong_ordering::less );
+static_assert( strong_order(1, 1) == strong_ordering::equal );
+static_assert( strong_order(2, 1) == strong_ordering::greater );
+static_assert( noexcept(strong_order(1, 1)) );
+
+constexpr strong_ordering different_cv_quals(int i, const int j)
+{
+  return strong_order(i, j);
+}
+static_assert( different_cv_quals(42, 999) == strong_ordering::less );
+static_assert( different_cv_quals(-999, -999) == strong_ordering::equal );
+static_assert( different_cv_quals(-99, -111) == strong_ordering::greater );
+
+namespace N
+{
+  struct X { int i; };
+
+  constexpr strong_ordering operator<=>(X l, X r)
+  {
+    if (l.i < 0 && r.i < 0)
+      return strong_ordering::equivalent;
+    return r.i <=> l.i;
+  }
+}
+using N::X;
+
+static_assert( strong_order(X{1}, X{1}) == strong_ordering::equal );
+static_assert( strong_order(X{-1}, X{-2}) == strong_ordering::equivalent );
+static_assert( strong_order(X{1}, X{2}) == strong_ordering::greater );
+static_assert( !noexcept(strong_order(X{1}, X{2})) );
diff --git a/libstdc++-v3/testsuite/18_support/comparisons/algorithms/weak_order.cc b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/weak_order.cc
new file mode 100644
index 00000000000..03a162b86d5
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/weak_order.cc
@@ -0,0 +1,119 @@ 
+// Copyright (C) 2019 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <compare>
+#include <limits>
+#include <testsuite_hooks.h>
+
+using std::weak_order;
+using std::weak_ordering;
+
+void
+test01()
+{
+  int one = 1, two = 2;
+
+  VERIFY( weak_order(one, two) == weak_ordering::less );
+  VERIFY( weak_order(one, one) == weak_ordering::equivalent );
+  VERIFY( weak_order(two, one) == weak_ordering::greater );
+  static_assert( noexcept(weak_order(1, 1)) );
+}
+
+constexpr weak_ordering different_cv_quals(int i, const int j)
+{
+  return weak_order(i, j);
+}
+
+void
+test02()
+{
+  int fortytwo = 42, nines = 999, lots = 1000;
+
+  VERIFY( different_cv_quals(fortytwo, nines) == weak_ordering::less );
+  VERIFY( different_cv_quals(-nines, -nines) == weak_ordering::equivalent );
+  VERIFY( different_cv_quals(-nines, -lots) == weak_ordering::greater );
+}
+
+void
+test03()
+{
+  double zero = 0.0;
+  VERIFY( weak_order(zero, zero) == weak_ordering::equivalent );
+  VERIFY( weak_order(-zero, -zero) == weak_ordering::equivalent );
+  VERIFY( weak_order(-zero, zero) == weak_ordering::equivalent );
+  VERIFY( weak_order(zero, -zero) == weak_ordering::equivalent );
+
+  double min = std::numeric_limits<double>::lowest();
+  double max = std::numeric_limits<double>::max();
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  double inf = std::numeric_limits<double>::infinity();
+  double denorm = std::numeric_limits<double>::denorm_min();
+  double smallest = std::numeric_limits<double>::min();
+  double epsilon = std::numeric_limits<double>::epsilon();
+  VERIFY( weak_order(denorm, smallest) == weak_ordering::less );
+  VERIFY( weak_order(denorm, 0.0) == weak_ordering::greater );
+  VERIFY( weak_order(0.0, nan) == weak_ordering::less );
+  VERIFY( weak_order(nan, nan) == weak_ordering::equivalent );
+  VERIFY( weak_order(nan, -nan) == weak_ordering::greater );
+  VERIFY( weak_order(-nan, nan) == weak_ordering::less );
+  VERIFY( weak_order(nan, 0.0) == weak_ordering::greater );
+  VERIFY( weak_order(-nan, 0.0) == weak_ordering::less );
+  VERIFY( weak_order(-nan, min) == weak_ordering::less );
+  VERIFY( weak_order(-inf, min) == weak_ordering::less );
+  VERIFY( weak_order(-nan, -inf) == weak_ordering::less );
+  VERIFY( weak_order(-inf, -nan) == weak_ordering::greater );
+  VERIFY( weak_order(max, inf) == weak_ordering::less );
+  VERIFY( weak_order(inf, max) == weak_ordering::greater );
+  VERIFY( weak_order(inf, nan) == weak_ordering::less );
+  VERIFY( weak_order(1.0, 1.0+epsilon) == weak_ordering::less );
+}
+
+namespace N
+{
+  struct X { int i; };
+
+  constexpr weak_ordering operator<=>(X l, X r)
+  {
+    if (l.i < 0 && r.i < 0)
+      return weak_ordering::equivalent;
+    return r.i <=> l.i;
+  }
+}
+
+void
+test04()
+{
+  using N::X;
+  X one{1};
+  X negone{-1};
+
+  VERIFY( weak_order(one, X{1}) == weak_ordering::equivalent );
+  VERIFY( weak_order(negone, X{-2}) == weak_ordering::equivalent );
+  VERIFY( weak_order(one, X{2}) == weak_ordering::greater );
+  static_assert( !noexcept(weak_order(X{1}, X{2})) );
+}
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+}