diff --git a/libcxx/include/utility b/libcxx/include/utility
--- a/libcxx/include/utility
+++ b/libcxx/include/utility
@@ -319,7 +319,8 @@
                       wchar_t, byte>::value;
 
 template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
-constexpr bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   using T1U = make_unsigned_t<_T1>;
   using T2U = make_unsigned_t<_T2>;
@@ -331,14 +332,16 @@
    return __t2 < 0 ? false : __t1 == T2U(__t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_not_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_not_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   return !cmp_equal(__t1, __t2);
 }
 
 template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
-constexpr bool cmp_less(const _T1 __t1, const _T2 __t2) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less(const _T1 __t1, const _T2 __t2) noexcept
 {
   using T1U = make_unsigned_t<_T1>;
   using T2U = make_unsigned_t<_T2>;
@@ -350,26 +353,30 @@
    return __t2 < 0 ? false : __t1 < T2U(__t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_greater(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater(const _T1 __t1, const _T2 __t2) noexcept
 {
  return cmp_less(__t2, __t1);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_less_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   return !cmp_greater(__t1, __t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_greater_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
  return !cmp_less(__t1, __t2);
 }
 
 template<__is_safe_integral_cmp _Rt, __is_safe_integral_cmp _Ty>
-constexpr bool in_range(const _Ty __t) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool in_range(const _Ty __t) noexcept
 {
   return cmp_less_equal(__t, numeric_limits<_Rt>::max()) &&
          cmp_greater_equal(__t, numeric_limits<_Rt>::min());
diff --git a/libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp b/libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp
--- a/libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp
+++ b/libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp
@@ -24,17 +24,93 @@
 
 #include "test_macros.h"
 
+struct NonEmptyT {
+  static int foo;
+  void func(int);
+};
+
+struct EmptyT {};
+
 template<class T>
 constexpr void test() {
-  std::cmp_equal(T(), T());   // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_equal(T(), int()); // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_equal(int(), T()); // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_less(T(), T());    // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::cmp_less(T(), int());  // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::cmp_less(int(), T());  // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::in_range<T>(int());    // expected-error10{{no matching function for call to 'in_range'}}
-  std::in_range<int>(T());    // expected-error10{{no matching function for call to 'in_range'}}
+  std::cmp_equal(
+      T(),
+      T()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error7{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error7{{no matching function for call to 'in_range'}}
+}
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template <class T>
+constexpr void test_char8t() {
+  std::cmp_equal(
+      T(),
+      T()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error{{no matching function for call to 'in_range'}}
+}
+#endif // _LIBCPP_NO_HAS_CHAR8_T
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+template <class T>
+constexpr void test_uchars() {
+  std::cmp_equal(
+      T(),
+      T()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error2{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error2{{no matching function for call to 'in_range'}}
 }
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 int main() {
   test<bool>();
@@ -44,13 +120,15 @@
   test<double>();
   test<long double>();
   test<std::byte>();
+  test<NonEmptyT>();
+  test<EmptyT>();
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
-  test<char8_t>();
+  test_char8t<char8_t>();
 #endif // !_LIBCPP_NO_HAS_CHAR8_T
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-  test<char16_t>();
-  test<char32_t>();
+  test_uchars<char16_t>();
+  test_uchars<char32_t>();
 #endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
 return 0;
 }
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp
@@ -0,0 +1,124 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr static bool test_cmp_equal1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_equal(T(0), T(0)));
+  assert(std::cmp_equal(T(10), T(10)));
+  assert(std::cmp_equal(tup.min, tup.min));
+  assert(std::cmp_equal(tup.max, tup.max));
+
+  assert(!std::cmp_equal(T(0), T(1)));
+  assert(!std::cmp_equal(T(1), T(0)));
+  assert(!std::cmp_equal(T(5), T(10)));
+  assert(!std::cmp_equal(T(10), T(5)));
+
+  assert(!std::cmp_equal(tup.min, tup.max));
+  assert(!std::cmp_equal(tup.max, tup.min));
+
+  assert(!std::cmp_equal(1, tup.max));
+  assert(!std::cmp_equal(tup.max, 1));
+  assert(!std::cmp_equal(1, tup.min));
+  assert(!std::cmp_equal(tup.min, 1));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_equal(T(-5), T(-5)));
+
+    assert(!std::cmp_equal(-2, tup.min));
+    assert(!std::cmp_equal(tup.min, -2));
+    assert(!std::cmp_equal(-2, tup.max));
+    assert(!std::cmp_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr static bool test_cmp_equal2() {
+  constexpr Tuple<T> ttup;
+  constexpr Tuple<U> utup;
+  assert(std::cmp_equal(T(0), U(0)));
+  assert(std::cmp_equal(T(10), U(10)));
+  assert(!std::cmp_equal(T(0), U(1)));
+  assert(!std::cmp_equal(T(1), U(0)));
+  assert(!std::cmp_equal(T(5), U(10)));
+  assert(!std::cmp_equal(T(10), U(5)));
+  assert(!std::cmp_equal(ttup.min, utup.max));
+  assert(!std::cmp_equal(utup.min, ttup.max));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_equal2<T, U>()) && (... && test_cmp_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+//   constexpr bool cmp_greater(T t, U u) noexcept;       // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_greater1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_greater(T(0), T(1)));
+  assert(!std::cmp_greater(T(1), T(2)));
+  assert(!std::cmp_greater(tup.min, tup.max));
+  assert(!std::cmp_greater(tup.min, tup.mid));
+  assert(!std::cmp_greater(tup.mid, tup.max));
+
+  assert(std::cmp_greater(T(1), T(0)));
+  assert(std::cmp_greater(T(10), T(5)));
+  assert(std::cmp_greater(tup.max, tup.min));
+  assert(std::cmp_greater(tup.mid, tup.min));
+  assert(!std::cmp_greater(tup.mid, tup.mid));
+  assert(!std::cmp_greater(tup.min, tup.min));
+  assert(!std::cmp_greater(tup.max, tup.max));
+
+  assert(std::cmp_greater(tup.max, 1));
+  assert(std::cmp_greater(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(!std::cmp_greater(T(-1), T(-1)));
+    assert(std::cmp_greater(-2, tup.min));
+    assert(!std::cmp_greater(tup.min, -2));
+    assert(!std::cmp_greater(-2, tup.max));
+    assert(std::cmp_greater(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_greater2() {
+  assert(!std::cmp_greater(T(0), U(1)));
+  assert(std::cmp_greater(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_greater1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_greater2<T, U>()) &&
+         (... && test_cmp_greater2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_greater(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+//   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_greater_equal1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_greater_equal(T(0), T(1)));
+  assert(!std::cmp_greater_equal(T(1), T(2)));
+  assert(!std::cmp_greater_equal(tup.min, tup.max));
+  assert(!std::cmp_greater_equal(tup.min, tup.mid));
+  assert(!std::cmp_greater_equal(tup.mid, tup.max));
+
+  assert(std::cmp_greater_equal(T(1), T(0)));
+  assert(std::cmp_greater_equal(T(10), T(5)));
+  assert(std::cmp_greater_equal(tup.max, tup.min));
+  assert(std::cmp_greater_equal(tup.mid, tup.min));
+  assert(std::cmp_greater_equal(tup.mid, tup.mid));
+  assert(std::cmp_greater_equal(tup.min, tup.min));
+  assert(std::cmp_greater_equal(tup.max, tup.max));
+
+  assert(std::cmp_greater_equal(tup.max, 1));
+  assert(std::cmp_greater_equal(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_greater_equal(T(-1), T(-1)));
+
+    assert(std::cmp_greater_equal(-2, tup.min));
+    assert(!std::cmp_greater_equal(tup.min, -2));
+    assert(!std::cmp_greater_equal(-2, tup.max));
+    assert(std::cmp_greater_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_greater_equal2() {
+  assert(!std::cmp_greater_equal(T(0), U(1)));
+  assert(std::cmp_greater_equal(T(1), U(0)));
+  assert(std::cmp_greater_equal(T(0), U(0)));
+  assert(std::cmp_greater_equal(T(1), U(1)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_greater_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_greater_equal2<T, U>()) &&
+         (... && test_cmp_greater_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(
+      std::cmp_greater_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_less(T t, U u) noexcept;          // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_less1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_less(T(0), T(1)));
+  assert(std::cmp_less(T(1), T(2)));
+  assert(std::cmp_less(tup.min, tup.max));
+  assert(std::cmp_less(tup.min, tup.mid));
+  assert(std::cmp_less(tup.mid, tup.max));
+
+  assert(!std::cmp_less(T(1), T(0)));
+  assert(!std::cmp_less(T(10), T(5)));
+  assert(!std::cmp_less(tup.max, tup.min));
+  assert(!std::cmp_less(tup.mid, tup.min));
+  assert(!std::cmp_less(tup.mid, tup.mid));
+  assert(!std::cmp_less(tup.min, tup.min));
+  assert(!std::cmp_less(tup.max, tup.max));
+
+  assert(!std::cmp_less(tup.max, 1));
+  assert(!std::cmp_less(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(!std::cmp_less(T(-1), T(-1)));
+
+    assert(!std::cmp_less(-2, tup.min));
+    assert(std::cmp_less(tup.min, -2));
+    assert(std::cmp_less(-2, tup.max));
+    assert(!std::cmp_less(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_less2() {
+  assert(std::cmp_less(T(0), U(1)));
+  assert(!std::cmp_less(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_less1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_less2<T, U>()) && (... && test_cmp_less2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_less(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp
@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+//   constexpr bool cmp_less_equal(T t, U u) noexcept;    // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_less_equal1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_less_equal(T(0), T(0)));
+  assert(std::cmp_less_equal(T(0), T(1)));
+  assert(std::cmp_less_equal(tup.min, tup.max));
+  assert(std::cmp_less_equal(tup.min, tup.mid));
+  assert(std::cmp_less_equal(tup.mid, tup.max));
+  assert(std::cmp_less_equal(tup.max, tup.max));
+  assert(std::cmp_less_equal(tup.mid, tup.mid));
+  assert(std::cmp_less_equal(tup.min, tup.min));
+
+  assert(!std::cmp_less_equal(T(1), T(0)));
+  assert(!std::cmp_less_equal(T(10), T(5)));
+  assert(!std::cmp_less_equal(tup.max, tup.min));
+  assert(!std::cmp_less_equal(tup.mid, tup.min));
+  assert(!std::cmp_less_equal(tup.max, 1));
+  assert(!std::cmp_less_equal(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_less_equal(T(-1), T(-1)));
+    assert(!std::cmp_less_equal(-2, tup.min));
+    assert(std::cmp_less_equal(tup.min, -2));
+    assert(std::cmp_less_equal(-2, tup.max));
+    assert(!std::cmp_less_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_less_equal2() {
+  assert(std::cmp_less_equal(T(0), U(1)));
+  assert(std::cmp_less_equal(T(0), U(0)));
+  assert(!std::cmp_less_equal(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_less_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_less_equal2<T, U>()) &&
+         (... && test_cmp_less_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+int main() {
+
+  ASSERT_NOEXCEPT(
+      std::cmp_less_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp
@@ -0,0 +1,125 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_not_equal(T t, U u) noexcept;     // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_not_equal1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_not_equal(T(0), T(0)));
+  assert(!std::cmp_not_equal(T(10), T(10)));
+  assert(!std::cmp_not_equal(tup.min, tup.min));
+  assert(!std::cmp_not_equal(tup.max, tup.max));
+
+  assert(std::cmp_not_equal(T(0), T(1)));
+  assert(std::cmp_not_equal(T(1), T(0)));
+  assert(std::cmp_not_equal(T(5), T(10)));
+  assert(std::cmp_not_equal(T(10), T(5)));
+
+  assert(std::cmp_not_equal(tup.min, tup.max));
+  assert(std::cmp_not_equal(tup.max, tup.min));
+
+  assert(std::cmp_not_equal(1, tup.max));
+  assert(std::cmp_not_equal(tup.max, 1));
+  assert(std::cmp_not_equal(1, tup.min));
+  assert(std::cmp_not_equal(tup.min, 1));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_not_equal(-2, tup.min));
+    assert(std::cmp_not_equal(tup.min, -2));
+    assert(std::cmp_not_equal(-2, tup.max));
+    assert(std::cmp_not_equal(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_not_equal2() {
+  constexpr Tuple<T> ttup;
+  constexpr Tuple<U> utup;
+  assert(!std::cmp_not_equal(T(0), U(0)));
+  assert(!std::cmp_not_equal(T(10), U(10)));
+
+  assert(std::cmp_not_equal(T(0), U(1)));
+  assert(std::cmp_not_equal(T(1), U(0)));
+  assert(std::cmp_not_equal(T(5), U(10)));
+  assert(std::cmp_not_equal(T(10), U(5)));
+  assert(std::cmp_not_equal(ttup.min, utup.max));
+  assert(std::cmp_not_equal(utup.min, ttup.max));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_not_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_not_equal2<T, U>()) &&
+         (... && test_cmp_not_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types2{}) &&
+         test2(Types1{}, Types2{}) && test2(Types2{}, Types1{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_not_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <utility>
+
+// template<class R, class T>
+//   constexpr bool in_range(T t) noexcept;               // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr static bool test_in_range() {
+  constexpr Tuple<T> tup;
+  assert(std::in_range<T>(tup.min));
+  assert(std::in_range<T>(tup.min + 1));
+  assert(std::in_range<T>(tup.max));
+  assert(std::in_range<T>(tup.max - 1));
+  assert(std::in_range<T>(tup.mid));
+  assert(std::in_range<T>(tup.mid - 1));
+  assert(std::in_range<T>(tup.mid + 1));
+  return true;
+}
+
+constexpr static bool test_in_range1() {
+  constexpr Tuple<uint8_t> utup8;
+  constexpr Tuple<int8_t> stup8;
+  assert(!std::in_range<int8_t>(utup8.max));
+  assert(std::in_range<short>(utup8.max));
+  assert(!std::in_range<uint8_t>(stup8.min));
+  assert(std::in_range<int8_t>(utup8.mid));
+  assert(!std::in_range<uint8_t>(stup8.mid));
+  assert(!std::in_range<uint8_t>(-1));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_in_range<T>()) && test_in_range1();
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  assert(test1(Types1{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::in_range<int>(std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}