diff --git a/libcxx/docs/Status/SpaceshipProjects.csv b/libcxx/docs/Status/SpaceshipProjects.csv
--- a/libcxx/docs/Status/SpaceshipProjects.csv
+++ b/libcxx/docs/Status/SpaceshipProjects.csv
@@ -38,7 +38,7 @@
 | `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| array,[expos.only.func],Unassigned,|Not Started|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| deque,[expos.only.func],Unassigned,|Not Started|
 | `[forward.list.syn] <https://wg21.link/forward.list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| forward_list,[expos.only.func],Unassigned,|Not Started|
-| `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| list,[expos.only.func],Unassigned,|Not Started|
+| `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `list <https://reviews.llvm.org/DXXXXXX>`_,[expos.only.func],Adrian Vogelsgesang,|Complete|
 | `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| vector,[expos.only.func],Unassigned,|Not Started|
 | `[associative.map.syn] <https://wg21.link/associative.map.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| map
 | multimap",[expos.only.func],Unassigned,|Not Started|
diff --git a/libcxx/include/list b/libcxx/include/list
--- a/libcxx/include/list
+++ b/libcxx/include/list
@@ -155,15 +155,18 @@
 template <class T, class Alloc>
     bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y);
 template <class T, class Alloc>
-    bool operator< (const list<T,Alloc>& x, const list<T,Alloc>& y);
+    bool operator< (const list<T,Alloc>& x, const list<T,Alloc>& y);     // removed in C++20
 template <class T, class Alloc>
-    bool operator!=(const list<T,Alloc>& x, const list<T,Alloc>& y);
+    bool operator!=(const list<T,Alloc>& x, const list<T,Alloc>& y);     // removed in C++20
 template <class T, class Alloc>
-    bool operator> (const list<T,Alloc>& x, const list<T,Alloc>& y);
+    bool operator> (const list<T,Alloc>& x, const list<T,Alloc>& y);     // removed in C++20
 template <class T, class Alloc>
-    bool operator>=(const list<T,Alloc>& x, const list<T,Alloc>& y);
+    bool operator>=(const list<T,Alloc>& x, const list<T,Alloc>& y);     // removed in C++20
 template <class T, class Alloc>
-    bool operator<=(const list<T,Alloc>& x, const list<T,Alloc>& y);
+    bool operator<=(const list<T,Alloc>& x, const list<T,Alloc>& y);     // removed in C++20
+template<class T, class Allocator>
+  synth-three-way-result<T> operator<=>(const list<T, Allocator>& x,
+                                        const list<T, Allocator>& y);    // since C++20
 
 template <class T, class Alloc>
     void swap(list<T,Alloc>& x, list<T,Alloc>& y)
@@ -171,10 +174,10 @@
 
 template <class T, class Allocator, class U>
     typename list<T, Allocator>::size_type
-    erase(list<T, Allocator>& c, const U& value);       // C++20
+    erase(list<T, Allocator>& c, const U& value);       // since C++20
 template <class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
-    erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
+    erase_if(list<T, Allocator>& c, Predicate pred);    // since C++20
 
 }  // std
 
@@ -183,6 +186,7 @@
 #include <__algorithm/comp.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
@@ -2289,6 +2293,8 @@
     return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
@@ -2329,6 +2335,18 @@
     return !(__y < __x);
 }
 
+#else // _LIBCPP_STD_VER <= 17
+
+template<class _Tp, class _Allocator>
+__synth_three_way_result<_Tp>
+operator<=>(const list<_Tp, _Allocator>& __x, const list<_Tp, _Allocator>& __y)
+{
+    return lexicographical_compare_three_way(
+        __x.begin(), __x.end(), __y.begin(), __y.end(), __synth_three_way);
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
 template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void
diff --git a/libcxx/test/std/containers/sequences/list/compare.pass.cpp b/libcxx/test/std/containers/sequences/list/compare.pass.cpp
--- a/libcxx/test/std/containers/sequences/list/compare.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/compare.pass.cpp
@@ -32,86 +32,94 @@
 // bool operator>=( const std::list<T,Alloc>& lhs,
 //                  const std::list<T,Alloc>& rhs );
 
+// template <class T, class Allocator> constexpr
+//   synth-three-way-result<T>
+//     operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
+
 #include <list>
 #include <cassert>
 
 #include "test_comparisons.h"
 
-int main(int, char**) {
-    {
-        const std::list<int> l1, l2;
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        const std::list<int> l1(1, 1), l2(1, 1);
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        int items[3] = {1, 2, 3};
-        const std::list<int> l1(items, items + 3);
-        const std::list<int> l2(items, items + 3);
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        const std::list<int> l1(1, 1), l2;
-        assert(testComparisons(l1, l2, false, false));
-    }
-    {
-        const std::list<int> l1(1, 1), l2(1, 2);
-        assert(testComparisons(l1, l2, false, true));
-    }
-    {
-        int items1[2] = {1, 2};
-        int items2[2] = {1, 3};
-        const std::list<int> l1(items1, items1 + 2);
-        const std::list<int> l2(items2, items2 + 2);
-        assert(testComparisons(l1, l2, false, true));
-    }
-    {
-        int items1[2] = {2, 2};
-        int items2[2] = {1, 3};
-        const std::list<int> l1(items1, items1 + 2);
-        const std::list<int> l2(items2, items2 + 2);
-        assert(testComparisons(l1, l2, false, false));
-    }
-    {
-        const std::list<LessAndEqComp> l1, l2;
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
-        const std::list<LessAndEqComp> l2(1, LessAndEqComp(1));
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        LessAndEqComp items[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
-        const std::list<LessAndEqComp> l1(items, items + 3);
-        const std::list<LessAndEqComp> l2(items, items + 3);
-        assert(testComparisons(l1, l2, true, false));
-    }
-    {
-        const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
-        const std::list<LessAndEqComp> l2;
-        assert(testComparisons(l1, l2, false, false));
-    }
-    {
-        const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
-        const std::list<LessAndEqComp> l2(1, LessAndEqComp(2));
-        assert(testComparisons(l1, l2, false, true));
-    }
-    {
-        LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
-        LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
-        const std::list<LessAndEqComp> l1(items1, items1 + 2);
-        const std::list<LessAndEqComp> l2(items2, items2 + 2);
-        assert(testComparisons(l1, l2, false, true));
-    }
-    {
-        LessAndEqComp items1[2] = {LessAndEqComp(2), LessAndEqComp(2)};
-        LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
-        const std::list<LessAndEqComp> l1(items1, items1 + 2);
-        const std::list<LessAndEqComp> l2(items2, items2 + 2);
-        assert(testComparisons(l1, l2, false, false));
-    }
-    return 0;
+template <typename ElemT, typename Order>
+void test_with_type() {
+  AssertComparisonsReturnBool<std::vector<ElemT> >();
+#if TEST_STD_VER >= 20
+  AssertOrderReturn<Order, std::vector<ElemT>>();
+#endif
+  {
+    const std::list<ElemT> l1, l2;
+    assert(testComparisons(l1, l2, true, false));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::equal));
+#endif
+  }
+  {
+    const std::list<ElemT> l1(1, 1), l2(1, 1);
+    assert(testComparisons(l1, l2, true, false));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::equal));
+#endif
+  }
+  {
+    ElemT items[3] = {1, 2, 3};
+    const std::list<ElemT> l1(items, items + 3);
+    const std::list<ElemT> l2(items, items + 3);
+    assert(testComparisons(l1, l2, true, false));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::equal));
+#endif
+  }
+  {
+    const std::list<ElemT> l1(1, 1), l2;
+    assert(testComparisons(l1, l2, false, false));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::greater));
+#endif
+  }
+  {
+    const std::list<ElemT> l1(1, 1), l2(1, 2);
+    assert(testComparisons(l1, l2, false, true));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::less));
+#endif
+  }
+  {
+    ElemT items1[2] = {1, 2};
+    ElemT items2[2] = {1, 3};
+    const std::list<ElemT> l1(items1, items1 + 2);
+    const std::list<ElemT> l2(items2, items2 + 2);
+    assert(testComparisons(l1, l2, false, true));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::less));
+#endif
+  }
+  {
+    ElemT items1[2] = {2, 2};
+    ElemT items2[2] = {1, 3};
+    const std::list<ElemT> l1(items1, items1 + 2);
+    const std::list<ElemT> l2(items2, items2 + 2);
+    assert(testComparisons(l1, l2, false, false));
+#if TEST_STD_VER >= 20
+    assert(testOrder(l1, l2, Order::greater));
+#endif
+  }
+}
+
+int main(int, char**) {
+#if TEST_STD_VER >= 20
+  using strong_ordering_since_cxx20 = std::strong_ordering;
+  using weak_ordering_since_cxx20   = std::weak_ordering;
+#else
+  typedef void strong_ordering_since_cxx20;
+  typedef void weak_ordering_since_cxx20;
+#endif
+  test_with_type<int, strong_ordering_since_cxx20>();
+  test_with_type<LessAndEqComp, weak_ordering_since_cxx20>();
+#if TEST_STD_VER >= 20
+  test_with_type<WeakComp, std::weak_ordering>();
+  test_with_type<PartialComp, std::partial_ordering>();
+#endif
+
+  return 0;
 }