[libc++] [C++20] [P0586] Implement safe integral comparisons

[kamleshbhalui]

Summary

• https://wg21.link/P0586

[curdeius]

The implementation looks okay at the first glance but you need to rework the tests.

• Test noexcept using ASSERT_NOEXCEPT
• Add tests in non-constexpr context. Look at other recently added commits and add a test function with asserts that gets called twice, once normally (runtime) and once in static_assert.
• Split tests for each added function. Please follow the naming of test files according to the standard paragraphs.
• Add more tests with all standard integer types and extended integer types.
• Test various values and their combinations: 0 limits::min/max +-1, min/2, max/2 and so on. Test interesting combinations of different types

[curdeius]

FWIW, you can take a look at the stub I've started writing at https://github.com/mkurdej/llvm-project/commit/0b7eccea2fbab13e897502c6d44ff958a0d550a9.
You might have a look at tests and other stuff like extended integer types.
It's just a WIP and far from ready though, so use with caution.

libcxx/include/utility

312

You need to guard the use of char(8|16|32)_t.

[kamleshbhalui]

addressed @curdeius comments.
added tests, few test snippets taken from the link given by @curdeius.

[kamleshbhalui]

used _LIBCPP_NO_HAS_CHAR8_T and _LIBCPP_HAS_NO_UNICODE_CHARS macro to guard char8_t, and char16_t, char32_t.

note:
I think _LIBCPP_NO_HAS_CHAR8_T should be _LIBCPP_HAS_NO_CHAR8_T since _LIBCPP_NO_HAS_CHAR8_T is used at several places I used it here as well, I can clean it up in
different patch if everyone agrees.

[Mordante]

In D94511#2562349, @kamleshbhalui wrote:

I think _LIBCPP_NO_HAS_CHAR8_T should be _LIBCPP_HAS_NO_CHAR8_T since _LIBCPP_NO_HAS_CHAR8_T is used at several places I used it here as well, I can clean it up in
different patch if everyone agrees.

Nice catch! @ldionne Do we want to change the macro or is it considered a part of our API?

I'll had a short look and some remarks, will look in more detail later.

libcxx/include/utility

319

Is byte considered an integral in libc++?

321

Is there a reason no to use template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>. That can than also be used without the extra requires for cmp_not_equal.

323

Libc++ should only use __ugly_names, can you rename all t1 and similar cases to __t1?

libcxx/test/std/utilities/utility/intcmp/intcmp.pass.cpp

12 ↗

(On Diff #323623)

Can you add the synopsis for the functions tested?
Can you also add test with ASSERT_NOEXCEPT to validate the functions are noexcept?

22 ↗

(On Diff #323623)

The tests are user-land code, so please don't use _UglyNames

[kamleshbhalui]

libcxx/include/utility

319

no. and the test for this is already in intcmp.fail.cpp.

[kamleshbhalui]

addressed @Mordante comments.

[Mordante]

Can you use arc to upload the next diff. This will trigger our CI and we can see whether your patch passes all build nodes.

Also can you address @curdeius request: "Split tests for each added function. Please follow the naming of test files according to the standard paragraphs."

libcxx/include/utility

319

Yes but since it's not an integral it doesn't need to be removed from the set of integrals. I was just concerned libc++ would accept std::byte as an integral.

322

Please also mark the functions with _LIBCPP_INLINE_VISIBILITY e.g:

template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept

334

I think it would be nice to also use __is_safe_integral_cmp to properly constrain these functions.

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

48 ↗

(On Diff #323649)

The tests at lines 29-36 all expect to get 10 failures. So if _LIBCPP_NO_HAS_CHAR8_T isn't defined there will be 9 and the test will fail.

libcxx/test/std/utilities/utility/intcmp/intcmp.pass.cpp

58 ↗

(On Diff #323649)

There are only tests where std::in_range returns true. I miss test where it fails and test where the template arguments R and T aren't the same.

351 ↗

(On Diff #323649)

Can you also test that test1 and test2 pass. Normally we tend to have one constexpr bool test function and call use test(); static_assert(test()); in main. For example `libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp'.

358 ↗

(On Diff #323649)

I like these tests!
Maybe add some additional tests where the bitwidth in the first and second tuple differ.

[kamleshbhalui]

Updated the tests

[curdeius]

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

115 ↗

(On Diff #333763)

Please test some non-primitive non-enum type.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

103

Please test signed char and unsigned char. This applies to other tests too.

[kamleshbhalui]

Addressed @curdeius comments.

[• Quuxplusone]

libcxx/include/utility

294–381

My ADL sense is tingling. This turns out to be OK because __t1 and __t2 are guaranteed to be integral types with no associated namespaces; but I think it would still be a peace-of-mind improvement to write return !_VSTD::cmp_equal(__t1, __t2) (or rather return !_VSTD::cmp_equal(__t, __u)).

323

While you're in the area, please remove all the redundant consts from these function headers: bool cmp_equal(const _T1 __t1...) is too easily mistaken for (a typo for) bool cmp_equal(const _T1& __t1...).
So, just write

bool cmp_equal(_T1 __t1, _T2 __t2) noexcept

Also, if you feel like it, I think it would be more consistent with existing libc++ style to use the parameter names (_Tp __t, _Up __u) throughout.

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

27–30 ↗

(On Diff #335823)

This is a confusing name, because NonEmptyT is in fact an empty type. Did you mean to give it some non-static data members?

Anyway, the point of this test file seems to be to test that various interesting cases are not overload-resolved. So, I recommend testing only the interesting cases. struct EmptyT {} already covers the "test a class type" case. If you're looking for more cases to test that are interesting, I suggest

• a class type with an implicit conversion to int
• an enum type
• nullptr_t
• __int128_t

To be clear, I don't think you should add any of these (except maybe the enum). But they'd all be much more interesting from the QA perspective than yet another empty class type.

36–38 ↗

(On Diff #335823)

Please revert your whitespace changes here. There's nothing wrong with the code on the left, and it's much easier to read.

If you'd like to shorten the message, e.g.

std::cmp_equal(T(), T()); // expected-error7{{no matching function}}

that'd be fine IMHO. (But unnecessary. There's nothing wrong with the code on the left.)

[kamleshbhalui]

Incorporated @Quuxplusone suggestions.

[curdeius]

libcxx/include/utility

332

This doesn't make sense._Tp is unsigned here. You should have swapped t and u.
Cf. the example implementation https://raw.githubusercontent.com/fekir/safeintegral/master/safeintegral/safeintegralop_cmp.hpp.
But first, you need to add a regression test for this.

[curdeius]

I'd like to see some "manual" tests like:

• max(uint64_t) vs. min(int64_t) (both represented as 0xFF'FF'FF'FF unless I'm mistaken)

And other cases for the different non-trivial conditions of cmp_equal/cmp_less.
Please correct me if they're already present.

libcxx/include/utility

325

Please _Uglify the names.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

53

Please be exhaustive and test less_equal, greater_equal, not_equal too.

[• Quuxplusone]

libcxx/include/utility

325–326

Thanks for renaming T1 to _Tp and T2 to _Up; however, that implies you also need to rename T2U into e.g. _UnsignedUp. Or just get rid of the name; it seems like you use it only once? E.g.

if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
   return __t == __u;
else if constexpr (is_signed_v<_Tp>)
   return (__t >= 0) && (__u == make_unsigned_t<_Tp>(__t));
else
   return (__u >= 0) && (__t == make_unsigned_t<_Up>(__u));

I'm actually puzzled how this isn't equivalent to simply

if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
   return __t == __u;
else
   return (__t >= 0) && (__u >= 0) && (__t == __u);

but I don't object to the longer form, especially since it's currently given on cppreference.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

97–113

It appears that Types1 and Types2 are just the exact same list in a different order.
So I think what you want to do here is use just one list, but do all O(n^2) comparisons:

std::tuple<
#ifndef _LIBCPP_HAS_NO_INT128
    __int128_t, __uint128_t,
#endif
    unsigned long long, long long, unsigned long, long,
    unsigned int, int, unsigned short, short,
    unsigned char, signed char
> types;
test1(types);
test2(types, types);

preceded by

template <class... Ts>
constexpr void test1(const std::tuple<Ts...>&) {
  assert((test_cmp_equal1<Ts>() && ...));
}
template <class T, class... Us>
constexpr void test2_impl(const std::tuple<Us...>& utuple) {
    assert((test_cmp_equal2<T, Us>() && ...));
}
template <class... Ts, class UTuple>
constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
    (test2_impl<Ts>(utuple) , ...);
}

You don't need to test uint32_t etc. because those are just library typedefs for the primitive types that you're already testing (e.g. unsigned int or unsigned long).

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp

57–64

I think it'd probably make sense to rewrite this as unconditional — lose the if:

assert(std::cmp_greater_equal(T(-1), T(-1)));
assert(std::cmp_greater_equal(-2, tup.min) == std::is_signed_v<T>);
assert(std::cmp_greater_equal(tup.min, -2) == std::is_unsigned_v<T>);
assert(!std::cmp_greater_equal(-2, tup.max));
assert(std::cmp_greater_equal(tup.max, -2));

114–115

Spurious newline here.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

56–57

This style was... not what I wanted. :P I can fix the style post-commit, if need be.

[Mordante]

libcxx/include/utility

296

We recently added a macro to simplify this test. #if defined(__cpp_concepts) && __cpp_concepts >= 201811L -> #if !defined(_LIBCPP_HAS_NO_CONCEPTS), or better combine it with the #if the line above.

300

Can you also switch these to _Tp and _Up?

305

For consistency with the rest of our code-base please use _Tp, _Up, and _Args.

319

Please remove the byte.

326

I also like to remove the lines with using .... The code @Quuxplusone is easier to understand. Please also adjust cmp_less in the same fashion.

360

Minor nit, but it seems this is indented by 1 space. Please format the patch as described at https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

[kamleshbhalui]

incorporated comments from @Quuxplusone, @Mordante and @curdeius

[kamleshbhalui]

fixed a typo.

[• Quuxplusone]

libcxx/include/utility

311

A type which is already known to be "integral" cannot also be cvref-qualified.
Please replace lines 296–318 with simply

template<class _Tp, class... _Up>
struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};

template<class _Tp>
concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
                      !_IsSameAsAny<_Tp, bool, char,
#ifndef _LIBCPP_NO_HAS_CHAR8_T
                      char8_t,
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
                      char16_t, char32_t,
#endif
                      wchar_t>::value;

(Btw I've tested this against your tests and it passes them, so if anyone finds a bug in what I wrote, then you'll need more tests.)

349

You've got 1-space indents on lines 344, 346, 348. Please make them 2-space.
Ditto lines 325, 327, 329.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

58–65

These tests also pass when !is_signed_v<T>, so you can remove line 58. (See also my unaddressed comment about the cmp_greater_equal test.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

103

std::declval<int>() is a verbose way to write 0. Please write std::cmp_greater(0, 0) or std::cmp_greater(42, 42), your choice. (Ditto throughout. And then you can remove some clang-format-introduced linebreaks, too.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

86

Bogus blank line on line 81.

[kamleshbhalui]

incorporated @Quuxplusone comments

[• Quuxplusone]

LGTM modulo these few last style notes.
I'd also appreciate better indentation in intcmp.fail.cpp — don't line-break in the middle of a qualified identifier! — but I know that'll be tedious to fix, and I still volunteer to go fix it later, if need be.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

102–103

Nit: Please break this line in a sensible way. (Ditto throughout.) I suggest breaking before unsigned short.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

79

Sorry, I may have told you to do this initially, but am now revising it after seeing it in print. The functions test_cmp_greater1 and test_cmp_greater2 don't need to return bool because they already assert their own stuff. They should return void, and you should use (test_cmp_greater1<Ts>() , ...); instead of assert((test_cmp_greater1<Ts>() && ...));
(Style note: Prefer (xs , ...) in fold-expressions, not (xs, ...), to (subtly/obscurely) emphasize that it's the comma operator being folded and not somehow an ordinary comma-separated list of xs.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

65–66

As above: test_in_range and test_in_range1 should just return void, and this should be a fold-expression over operator,.

[kamleshbhalui]

formatted the tests as per @Quuxplusone comments

[kamleshbhalui]

formatted intcmp.fail.cpp

[• Quuxplusone]

This continues to LGTM.
Can we get a second approver (@curdeius @Mordante @ldionne?), then let's land this, and then I'll update and land D100736 after that.

[Mordante]

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

Other than that is seems good now. I still like to see a fresh CI run, to make sure generate_feature_test_macro_components.py is updated properly.

libcxx/utils/generate_feature_test_macro_components.py

312–313

This should be "defined(__cpp_concepts) && __cpp_concepts >= 201907L", the guard below is correct.
(I'm sure wrote that before, but I can't find it anymore :-()

Make sure to run the script after updating.

[• Quuxplusone]

@Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

@Mordante: That's intentional; we write (x , ...) when we're folding over operator,. If clang-format can't tell the difference, that's a bug in clang-format.
(All: Please do not blindly clang-format; that just introduces whitespace errors that someone else will have to fix manually down the road.)

[kamleshbhalui]

In D94511#2698813, @Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

It's the case for fold expression, and it is done deliberately after @Quuxplusone suggestions.

Other than that is seems good now. I still like to see a fresh CI run, to make sure generate_feature_test_macro_components.py is updated properly.

ok, will update this.

[kamleshbhalui]

updated generate_feature_test_macro_components.py.

[curdeius]

LGTM.

[Mordante]

In D94511#2698917, @Quuxplusone wrote:

@Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

@Mordante: That's intentional; we write (x , ...) when we're folding over operator,. If clang-format can't tell the difference, that's a bug in clang-format.
(All: Please do not blindly clang-format; that just introduces whitespace errors that someone else will have to fix manually down the road.)

I was mainly concerned since a previous iteration had indention errors. I still prefer to leave the formatting to clang-format and be happy with it. But I know you have a different opinion. But since you asked for this formatting change I'm not objecting. So LGTM, even if it already landed.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P1878 <https://wg21.link/P1878>`__","LWG","Constraining Readable Types","Belfast","* *",""
 "`P1892 <https://wg21.link/P1892>`__","LWG","Extended locale-specific presentation specifiers for std::format","Belfast","* *",""
 "`P1902 <https://wg21.link/P1902>`__","LWG","Missing feature-test macros 2018-2019","Belfast","* *",""
 "`P1959 <https://wg21.link/P1959>`__","LWG","Remove std::weak_equality and std::strong_equality","Belfast","* *",""
 "`P1960 <https://wg21.link/P1960>`__","LWG","NB Comment Changes Reviewed by SG1","Belfast","* *",""
 "`P1961 <https://wg21.link/P1961>`__","LWG","Harmonizing the definitions of total order for pointers","Belfast","* *",""
 "`P1965 <https://wg21.link/P1965>`__","LWG","Blanket Wording for Specifying ""Hidden Friends""","Belfast","* *",""
 "","","","","",""
-"`P0586 <https://wg21.link/P0586>`__","LWG","Safe integral comparisons","Prague","* *",""
+"`P0586 <https://wg21.link/P0586>`__","LWG","Safe integral comparisons","Prague","|Complete|","13.0"
 "`P0593 <https://wg21.link/P0593>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *",""
 "`P1115 <https://wg21.link/P1115>`__","LWG","Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if","Prague","|Complete|","11.0"
 "`P1243 <https://wg21.link/P1243>`__","LWG","Rangify New Algorithms","Prague","* *",""
 "`P1460 <https://wg21.link/P1460>`__","LWG","Mandating the Standard Library: Clause 20 - Utilities library","Prague","* *",""
 "`P1739 <https://wg21.link/P1739>`__","LWG","Avoid template bloat for safe_ranges in combination with ""subrange-y"" view adaptors","Prague","* *",""
 "`P1831 <https://wg21.link/P1831>`__","LWG","Deprecating volatile: library","Prague","* *",""
 "`P1868 <https://wg21.link/P1868>`__","LWG","width: clarifying units of width and precision in std::format","Prague","* *",""
 "`P1908 <https://wg21.link/P1908>`__","CWG","Reserving Attribute Namespaces for Future Use","Prague","* *",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_execution``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_format``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_generic_unordered_lookup``            ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_int_pow2``                            ``202002L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_integer_comparison_functions``        *unimplemented*
+    ``__cpp_lib_integer_comparison_functions``        ``202002L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_interpolate``                         ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_constant_evaluated``               ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_layout_compatible``                *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_nothrow_convertible``              ``201806L``

libcxx/include/utility

template <class T>
     >::type
     move_if_noexcept(T& x) noexcept; // constexpr in C++14
 
 template <class T> constexpr add_const_t<T>& as_const(T& t) noexcept;      // C++17
 template <class T>                      void as_const(const T&&) = delete; // C++17
 
 template <class T> typename add_rvalue_reference<T>::type declval() noexcept;
 
+template<class T, class U> constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
+template<class T, class U> constexpr bool cmp_not_equal(T t, U u) noexcept;     // C++20
+template<class T, class U> constexpr bool cmp_less(T t, U u) noexcept;          // C++20
+template<class T, class U> constexpr bool cmp_greater(T t, U u) noexcept;       // C++20
+template<class T, class U> constexpr bool cmp_less_equal(T t, U u) noexcept;    // C++20
+template<class T, class U> constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+template<class R, class T> constexpr bool in_range(T t) noexcept;               // C++20
+
 template <class T1, class T2>
 struct pair
 {
     typedef T1 first_type;
     typedef T2 second_type;
 
     T1 first;
     T2 second;

 
 #include <__config>
 #include <__tuple>
 #include <type_traits>
 #include <initializer_list>
 #include <cstddef>
 #include <cstring>
 #include <cstdint>
+#include <limits>
 #include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace rel_ops
 {
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool

 {
     return _VSTD::move(__x);
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
 template <class _Tp>                        void as_const(const _Tp&&) = delete;
 #endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+template<class...>
+struct __is_any_of;
+
+template<class _Tp, class _Up>
+struct __is_any_of<_Tp, _Up> {
+constexpr bool static value = is_same_v<_Tp, _Up>;
+};
+
+template<class _Tp, class _Up, class... _Args>
+struct __is_any_of<_Tp, _Up, _Args...> {
+constexpr bool static value = is_same_v<_Tp, _Up> || __is_any_of<_Tp, _Args...>::value;
+};
+
+template<class _Tp>
+concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
+                      !__is_any_of<remove_cvref_t<_Tp>, bool, char,
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+                      char8_t,
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+                      char16_t, char32_t,
+#endif
+                      wchar_t>::value;
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_equal(_Tp __t, _Up __u) noexcept
+{
+  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+   return __t == __u;
+  else if constexpr (is_signed_v<_Tp>)
+   return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
+  else
+   return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_not_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_VSTD::cmp_equal(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less(_Tp __t, _Up __u) noexcept
+{
+  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+   return __t < __u;
+  else if constexpr (is_signed_v<_Tp>)
+   return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
+  else
+   return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater(_Tp __t, _Up __u) noexcept
+{
+  return _VSTD::cmp_less(__u, __t);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_VSTD::cmp_greater(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_VSTD::cmp_less(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool in_range(_Up __u) noexcept
+{
+  return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
+         _VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
+}
+#endif
+
 struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };
 #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
 extern _LIBCPP_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
 #else
 /* _LIBCPP_INLINE_VAR */ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 #endif
 
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
 template <class, class>

 _LIBCPP_INLINE_VISIBILITY constexpr underlying_type_t<_Tp>
 to_underlying(_Tp __val) noexcept {
   return _VSTD::__to_underlying(__val);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif  // _LIBCPP_UTILITY

libcxx/include/version

 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 # undef  __cpp_lib_execution
 // # define __cpp_lib_execution                            201902L
 // # define __cpp_lib_format                               201907L
 # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_int_pow2                             202002L
-// # define __cpp_lib_integer_comparison_functions         202002L
+# if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#   define __cpp_lib_integer_comparison_functions       202002L
+# endif
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 #   define __cpp_lib_is_constant_evaluated              201811L
 # endif
 // # define __cpp_lib_is_layout_compatible                 201907L
 # define __cpp_lib_is_nothrow_convertible               201806L
 // # define __cpp_lib_is_pointer_interconvertible          201907L
 # if !defined(_LIBCPP_HAS_NO_THREADS)

libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp

 
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++20"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   ifndef __cpp_lib_integer_comparison_functions
 #     error "__cpp_lib_integer_comparison_functions should be defined in c++20"
 #   endif
 #   if __cpp_lib_integer_comparison_functions != 202002L
 #     error "__cpp_lib_integer_comparison_functions should have the value 202002L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_integer_comparison_functions
-#     error "__cpp_lib_integer_comparison_functions should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_integer_comparison_functions should not be defined when defined(__cpp_concepts) && __cpp_concepts >= 201811L is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++20"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++20"

 
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++2b"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   ifndef __cpp_lib_integer_comparison_functions
 #     error "__cpp_lib_integer_comparison_functions should be defined in c++2b"
 #   endif
 #   if __cpp_lib_integer_comparison_functions != 202002L
 #     error "__cpp_lib_integer_comparison_functions should have the value 202002L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_integer_comparison_functions
-#     error "__cpp_lib_integer_comparison_functions should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_integer_comparison_functions should not be defined when defined(__cpp_concepts) && __cpp_concepts >= 201811L is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++2b"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++2b"

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 
 # ifndef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should be defined in c++20"
 # endif
 # if __cpp_lib_int_pow2 != 202002L
 #   error "__cpp_lib_int_pow2 should have the value 202002L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   ifndef __cpp_lib_integer_comparison_functions
 #     error "__cpp_lib_integer_comparison_functions should be defined in c++20"
 #   endif
 #   if __cpp_lib_integer_comparison_functions != 202002L
 #     error "__cpp_lib_integer_comparison_functions should have the value 202002L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_integer_comparison_functions
-#     error "__cpp_lib_integer_comparison_functions should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_integer_comparison_functions should not be defined when defined(__cpp_concepts) && __cpp_concepts >= 201811L is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++20"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++20"

 
 # ifndef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should be defined in c++2b"
 # endif
 # if __cpp_lib_int_pow2 != 202002L
 #   error "__cpp_lib_int_pow2 should have the value 202002L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   ifndef __cpp_lib_integer_comparison_functions
 #     error "__cpp_lib_integer_comparison_functions should be defined in c++2b"
 #   endif
 #   if __cpp_lib_integer_comparison_functions != 202002L
 #     error "__cpp_lib_integer_comparison_functions should have the value 202002L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_integer_comparison_functions
-#     error "__cpp_lib_integer_comparison_functions should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_integer_comparison_functions should not be defined when defined(__cpp_concepts) && __cpp_concepts >= 201811L is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++2b"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++2b"

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_equal1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_equal2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_greater1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_greater2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_greater(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_greater_equal1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_greater_equal2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(
+      std::cmp_greater_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_less1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_less2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_less(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_less_equal1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_less_equal2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(
+      std::cmp_less_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_cmp_not_equal1<Ts>() && ...));
+}
+
+template <class T, class... Us>
+constexpr void test2_impl(const std::tuple<Us...>&) {
+  assert((test_cmp_not_equal2<T, Us>() && ...));
+}
+
+template <class... Ts, class UTuple>
+constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
+  (test2_impl<Ts>(utuple), ...);
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  test2(types, types);
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_not_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// template<class T, class U>
+//   constexpr bool cmp_not_equal(T t, U u) noexcept; // C++20
+
+// template<class T, class U>
+//   constexpr bool cmp_less(T t, U u) noexcept; // C++20
+
+// template<class T, class U>
+//   constexpr bool cmp_less_equal(T t, U u) noexcept; // C++20
+
+// template<class T, class U>
+//   constexpr bool cmp_greater(T t, U u) noexcept; // C++20
+
+// template<class T, class U>
+//   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+
+// template<class R, class T>
+//   constexpr bool in_range(T t) noexcept;      // C++20
+
+#include <utility>
+
+#include "test_macros.h"
+
+struct NonEmptyT {
+  int val;
+  NonEmptyT() : val(0) {}
+  NonEmptyT(int val) : val(val) {}
+  operator int&() { return val; }
+  operator int() const { return val; }
+};
+
+enum ColorT { red, green, blue };
+
+struct EmptyT {};
+
+template <class T>
+constexpr void test() {
+  std:: // expected-error11{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(int(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(int(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_less'}}
+      cmp_less(int(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(int(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(int(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), T());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), int());
+  std:: // expected-error11{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(int(), T());
+  std:: // expected-error11{{no matching function for call to 'in_range'}}
+      in_range<T>(int());
+  std:: // expected-error11{{no matching function for call to 'in_range'}}
+      in_range<int>(T());
+}
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template <class T>
+constexpr void test_char8t() {
+  std:: // expected-error1{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(int(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(int(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_less'}}
+      cmp_less(int(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(int(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(int(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), T());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), int());
+  std:: // expected-error1{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(int(), T());
+  std:: // expected-error1{{no matching function for call to 'in_range'}}
+      in_range<T>(int());
+  std:: // expected-error1{{no matching function for call to 'in_range'}}
+      in_range<int>(T());
+}
+#endif // _LIBCPP_NO_HAS_CHAR8_T
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+template <class T>
+constexpr void test_uchars() {
+  std:: // expected-error2{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_equal'}}
+      cmp_equal(int(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_not_equal'}}
+      cmp_not_equal(int(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_less'}}
+      cmp_less(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_less'}}
+      cmp_less(int(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_less_equal'}}
+      cmp_less_equal(int(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater'}}
+      cmp_greater(int(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), T());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(T(), int());
+  std:: // expected-error2{{no matching function for call to 'cmp_greater_equal'}}
+      cmp_greater_equal(int(), T());
+  std:: // expected-error2{{no matching function for call to 'in_range'}}
+      in_range<T>(int());
+  std:: // expected-error2{{no matching function for call to 'in_range'}}
+      in_range<int>(T());
+}
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+int main() {
+  test<bool>();
+  test<char>();
+  test<wchar_t>();
+  test<float>();
+  test<double>();
+  test<long double>();
+  test<std::byte>();
+  test<NonEmptyT>();
+  test<ColorT>();
+  test<nullptr_t>();
+  test<EmptyT>();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test_char8t<char8_t>();
+#endif // !_LIBCPP_NO_HAS_CHAR8_T
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test_uchars<char16_t>();
+  test_uchars<char32_t>();
+#endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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 <class... Ts>
+constexpr void test1(const std::tuple<Ts...>&) {
+  assert((test_in_range<Ts>() && ...));
+  assert(test_in_range1());
+}
+
+constexpr bool test() {
+  std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, unsigned long, long, unsigned int, int,
+      unsigned short, short, unsigned char, signed char>
+      types;
+  test1(types);
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::in_range<int>(std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_int_pow2",
     "values": { "c++20": 202002 },
     "headers": ["bit"],
   }, {
     "name": "__cpp_lib_integer_comparison_functions",
     "values": { "c++20": 202002 },
     "headers": ["utility"],
-    "unimplemented": True,
+    "depends": "defined(__cpp_concepts) && __cpp_concepts >= 201811L",
+    "internal_depends": "!defined(_LIBCPP_HAS_NO_CONCEPTS)",
   }, {
     "name": "__cpp_lib_integer_sequence",
     "values": { "c++14": 201304 },
     "headers": ["utility"],
   }, {
     "name": "__cpp_lib_integral_constant_callable",
     "values": { "c++14": 201304 },
     "headers": ["type_traits"],