diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -73,6 +73,13 @@
 template<class S, class I>
   concept sentinel_for = see below;                        // since C++20
 
+// [iterator.concept.sizedsentinel], concept sized_sentinel_for
+template<class S, class I>
+  inline constexpr bool disable_sized_sentinel_for = false;
+
+template<class S, class I>
+  concept sized_sentinel_for = see below;
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
@@ -2587,6 +2594,18 @@
   input_or_output_iterator<_Ip> &&
   __weakly_equality_comparable_with<_Sp, _Ip>;
 
+template<class, class>
+inline constexpr bool disable_sized_sentinel_for = false;
+
+template<class _Sentinel, class _Iter>
+concept sized_sentinel_for =
+  sentinel_for<_Sentinel, _Iter> &&
+  !disable_sized_sentinel_for<remove_cv_t<_Sentinel>, remove_cv_t<_Iter>> &&
+  requires(const _Iter& __i, const _Sentinel& __s) {
+    { __s - __i } -> same_as<iter_difference_t<_Iter>>;
+    { __i - __s } -> same_as<iter_difference_t<_Iter>>;
+  };
+
 #undef _LIBCPP_NOEXCEPT_RETURN
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.sentinel/sized_sentinel_for.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.sentinel/sized_sentinel_for.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.sentinel/sized_sentinel_for.compile.pass.cpp
@@ -0,0 +1,192 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// [iterator.concept.sizedsentinel], concept sized_sentinel_for
+//
+// template<class S, class I>
+//   inline constexpr bool disable_sized_sentinel_for = false;
+//
+// template<class S, class I>
+//   concept sized_sentinel_for = see below;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+struct nth_element_sentinel {
+  friend constexpr bool operator==(nth_element_sentinel,
+                                   std::input_or_output_iterator auto);
+  friend constexpr long operator-(nth_element_sentinel,
+                                  std::input_or_output_iterator auto);
+  friend constexpr long operator-(std::input_or_output_iterator auto,
+                                  nth_element_sentinel);
+};
+static_assert(std::sized_sentinel_for<nth_element_sentinel, int*>);
+
+struct no_default_ctor {
+  no_default_ctor() = delete;
+  bool operator==(std::input_or_output_iterator auto) const;
+};
+static_assert(
+    !std::sized_sentinel_for<no_default_ctor, std::vector<int>::iterator>);
+
+struct not_copyable {
+  not_copyable(not_copyable const&) = delete;
+  bool operator==(std::input_or_output_iterator auto) const;
+};
+static_assert(
+    !std::sized_sentinel_for<not_copyable, std::vector<int>::iterator>);
+
+namespace std {
+
+template <>
+inline constexpr bool
+    disable_sized_sentinel_for<nth_element_sentinel, double*> = true;
+
+}
+
+static_assert(std::sized_sentinel_for<nth_element_sentinel, float*>);
+static_assert(!std::sized_sentinel_for<nth_element_sentinel, double*>);
+
+struct only_one_sub_op {
+  friend constexpr bool operator==(only_one_sub_op,
+                                   std::input_or_output_iterator auto);
+  friend constexpr long operator-(only_one_sub_op,
+                                  std::input_or_output_iterator auto);
+};
+static_assert(!std::sized_sentinel_for<only_one_sub_op, int*>);
+
+struct wrong_return_type {
+  friend constexpr bool operator==(wrong_return_type,
+                                   std::input_or_output_iterator auto);
+  friend constexpr long operator-(wrong_return_type,
+                                  std::input_or_output_iterator auto);
+  friend constexpr void operator-(std::input_or_output_iterator auto,
+                                  wrong_return_type);
+};
+static_assert(!std::sized_sentinel_for<wrong_return_type, int*>);
+
+namespace standard_types {
+static_assert(std::sized_sentinel_for<int*, int*>);
+
+template <class T>
+constexpr bool check_sized_sentinel_for() {
+  using iterator = typename T::iterator;
+  using const_iterator = typename T::const_iterator;
+
+  static_assert(std::sized_sentinel_for<iterator, iterator>);
+  static_assert(std::sized_sentinel_for<iterator, const_iterator>);
+  static_assert(std::sized_sentinel_for<const_iterator, iterator>);
+  static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
+
+  return true;
+}
+
+template <class T>
+constexpr bool check_not_sized_sentinel_for() {
+  using iterator = typename T::iterator;
+  using const_iterator = typename T::const_iterator;
+
+  static_assert(!std::sized_sentinel_for<iterator, iterator>);
+  static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
+  static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
+  static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
+
+  return true;
+}
+
+template <class T>
+constexpr bool check_sized_sentinel_for_with_reverse_iterators() {
+  check_sized_sentinel_for<T>();
+
+  using iterator = typename T::iterator;
+  using const_iterator = typename T::const_iterator;
+  using reverse_iterator = typename T::reverse_iterator;
+  using const_reverse_iterator = typename T::const_reverse_iterator;
+
+  static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
+  static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
+  static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
+  static_assert(
+      !std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
+
+  static_assert(!std::sized_sentinel_for<reverse_iterator, iterator>);
+  static_assert(!std::sized_sentinel_for<reverse_iterator, const_iterator>);
+  static_assert(std::sized_sentinel_for<reverse_iterator, reverse_iterator>);
+  static_assert(
+      std::sized_sentinel_for<reverse_iterator, const_reverse_iterator>);
+
+  static_assert(!std::sized_sentinel_for<const_reverse_iterator, iterator>);
+  static_assert(
+      !std::sized_sentinel_for<const_reverse_iterator, const_iterator>);
+  static_assert(
+      std::sized_sentinel_for<const_reverse_iterator, reverse_iterator>);
+  static_assert(
+      std::sized_sentinel_for<const_reverse_iterator, const_reverse_iterator>);
+
+  return true;
+}
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(!std::sized_sentinel_for<std::filesystem::directory_iterator,
+                                       std::filesystem::directory_iterator>);
+static_assert(
+    !std::sized_sentinel_for<std::filesystem::recursive_directory_iterator,
+                             std::filesystem::recursive_directory_iterator>);
+#endif
+
+static_assert(
+    std::sized_sentinel_for<std::move_iterator<std::vector<int>::iterator>,
+                            std::move_iterator<std::vector<int>::iterator> >);
+
+static_assert(
+    check_sized_sentinel_for_with_reverse_iterators<std::array<int, 10> >());
+static_assert(
+    check_sized_sentinel_for_with_reverse_iterators<std::deque<int> >());
+static_assert(check_not_sized_sentinel_for<std::forward_list<int> >());
+static_assert(check_not_sized_sentinel_for<std::list<int> >());
+static_assert(
+    check_sized_sentinel_for_with_reverse_iterators<std::vector<int> >());
+
+static_assert(check_not_sized_sentinel_for<std::map<int, int> >());
+static_assert(check_not_sized_sentinel_for<std::multimap<int, int> >());
+static_assert(check_not_sized_sentinel_for<std::set<int> >());
+static_assert(check_not_sized_sentinel_for<std::multiset<int> >());
+
+static_assert(check_sized_sentinel_for_with_reverse_iterators<std::string>());
+static_assert(
+    check_sized_sentinel_for_with_reverse_iterators<std::string_view>());
+
+static_assert(check_not_sized_sentinel_for<std::unordered_map<int, int> >());
+static_assert(
+    check_not_sized_sentinel_for<std::unordered_multimap<int, int> >());
+static_assert(check_not_sized_sentinel_for<std::unordered_set<int> >());
+static_assert(check_not_sized_sentinel_for<std::unordered_multiset<int> >());
+
+} // namespace standard_types