diff --git a/libcxx/docs/ReleaseNotes.rst b/libcxx/docs/ReleaseNotes.rst
--- a/libcxx/docs/ReleaseNotes.rst
+++ b/libcxx/docs/ReleaseNotes.rst
@@ -41,6 +41,8 @@
 Improvements and New Features
 -----------------------------
 
+* Implemented ``operator<=>`` for ``std::shared_ptr``
+
 Deprecations and Removals
 -------------------------
 
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
@@ -26,7 +26,7 @@
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| monostate
 | variant",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| unique_ptr,[comparisons.three.way],Unassigned,|Not Started|
-| `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| shared_ptr,[comparisons.three.way],Unassigned,|Not Started|
+| `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| shared_ptr,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| type_index,None,Unassigned,|Not Started|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
diff --git a/libcxx/include/__memory/shared_ptr.h b/libcxx/include/__memory/shared_ptr.h
--- a/libcxx/include/__memory/shared_ptr.h
+++ b/libcxx/include/__memory/shared_ptr.h
@@ -1184,6 +1184,8 @@
     return __x.get() == __y.get();
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
@@ -1230,6 +1232,17 @@
     return !(__x < __y);
 }
 
+#endif // _LIBCPP_STD_VER <= 17
+
+#if _LIBCPP_STD_VER > 17
+template<class _Tp, class _Up>
+strong_ordering
+operator<=>(shared_ptr<_Tp> const& __a, shared_ptr<_Up> const& __b) _NOEXCEPT
+{
+    return compare_three_way()(__a.get(), __b.get());
+}
+#endif
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
@@ -1238,6 +1251,8 @@
     return !__x;
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
@@ -1326,6 +1341,17 @@
     return !(nullptr < __x);
 }
 
+#endif // _LIBCPP_STD_VER <= 17
+
+#if _LIBCPP_STD_VER > 17
+template<class _Tp>
+strong_ordering
+operator<=>(shared_ptr<_Tp> const& __a, nullptr_t) _NOEXCEPT
+{
+    return compare_three_way()(__a.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
+}
+#endif
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
diff --git a/libcxx/include/memory b/libcxx/include/memory
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -617,40 +617,44 @@
 template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
-    bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
 template<class T, class U>
-    bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;                // removed in C++20
 template<class T, class U>
-    bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;                // removed in C++20
 template<class T, class U>
-    bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
 template<class T, class U>
-    bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
+template<class T, class U>
+    strong_ordering operator<=>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;   // C++20
 
 template <class T>
     bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
-    bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
 template <class T>
-    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
 template <class T>
-    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;                // removed in C++20
 template <class T>
-bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;                // removed in C++20
 template <class T>
-    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
 template <class T>
-    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;                // removed in C++20
 template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;                // removed in C++20
 template <class T>
-    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
+template<class T>
+    strong_ordering operator<=>(shared_ptr<T> const& a, nullptr_t) noexcept;   // C++20
 
 // shared_ptr specialized algorithms:
 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
@@ -34,6 +34,8 @@
 //     bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
 // template <class T>
 //     bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
+// template<class T>
+//     strong_ordering operator<=>(shared_ptr<T> const& a, nullptr_t) noexcept;   // C++20
 
 #include <memory>
 #include <cassert>
@@ -55,6 +57,10 @@
     assert(!(nullptr > p1));
     assert( (p1 >= nullptr));
     assert(!(nullptr >= p1));
+#if TEST_STD_VER > 17
+    assert((nullptr <=> p1) == std::strong_ordering::less);
+    assert((p1 <=> nullptr) == std::strong_ordering::greater);
+#endif
 
     const std::shared_ptr<int> p2;
     assert( (p2 == nullptr));
@@ -67,6 +73,9 @@
     assert(!(nullptr > p2));
     assert( (p2 >= nullptr));
     assert( (nullptr >= p2));
+#if TEST_STD_VER > 17
+    assert((nullptr <=> p2) == std::strong_ordering::equivalent);
+#endif
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/order.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/order.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/order.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class U>
+//     strong_ordering operator<=>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+void do_nothing(int*) {}
+
+int main(int, char**) {
+#if TEST_STD_VER > 17
+  int* ptr1(new int);
+  int* ptr2(new int);
+  const std::shared_ptr<int> p1(ptr1);
+  const std::shared_ptr<int> p2(ptr2);
+  const std::shared_ptr<int> p3(ptr2, do_nothing);
+  assert((p1 <=> p2) != std::strong_ordering::equal);
+  assert((p1 <=> p2) == (ptr1 <=> ptr2));
+  assert((p2 <=> p3) == std::strong_ordering::equal);
+#endif
+
+  return 0;
+}