[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

308

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

315

Is byte considered an integral in libc++?

317

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.

319

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

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

22

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

[kamleshbhalui]

libcxx/include/utility

315

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

315

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.

318

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

330

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

49

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

59

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.

352

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'.

359

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

Please test some non-primitive non-enum type.

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

102 ↗

(On Diff #333763)

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

[kamleshbhalui]

Addressed @curdeius comments.

[• Quuxplusone]

libcxx/include/utility

290–377

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)).

319

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

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

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

328

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

321

Please _Uglify the names.

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

52 ↗

(On Diff #335859)

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

[• Quuxplusone]

libcxx/include/utility

321–322

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

96–112 ↗

(On Diff #335859)

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

56–63 ↗

(On Diff #335859)

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));

113–114 ↗

(On Diff #335859)

Spurious newline here.

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

55–56 ↗

(On Diff #335859)

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

[Mordante]

libcxx/include/utility

292

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.

296

Can you also switch these to _Tp and _Up?

301

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

315

Please remove the byte.

322

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.

356

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

307

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.)

345

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 ↗

(On Diff #338376)

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

102 ↗

(On Diff #333763)

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 ↗

(On Diff #338376)

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

101–102 ↗

(On Diff #338401)

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

78 ↗

(On Diff #338401)

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

64–65 ↗

(On Diff #338401)

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

318–319

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
+#if defined(__cpp_concepts) && __cpp_concepts >= 201811L
+template<class...>
+struct __is_any_of;
+
+template<class _Ty1, class _Ty2>
+struct __is_any_of<_Ty1, _Ty2> {
+constexpr bool static value = is_same_v<_Ty1, _Ty2>;
+};
+
+template<class _Ty, class _Ty1, class..._Tyn>
+struct __is_any_of<_Ty, _Ty1, _Tyn...> {
+constexpr bool static value = is_same_v<_Ty, _Ty1> || __is_any_of<_Ty, _Tyn...>::value;
+};
+
+template<class _Ty>
+concept __is_safe_integral_cmp = is_integral_v<_Ty> &&
+                      !__is_any_of<remove_cvref_t<_Ty>, bool, char,
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+                      char8_t,
+#endif // !_LIBCPP_NO_HAS_CHAR8_T
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+                      char16_t, char32_t,
+#endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
+                      wchar_t, byte>::value;
+
+template<class _T1, class _T2>
+requires(__is_safe_integral_cmp<_T1> && __is_safe_integral_cmp<_T2>)
+constexpr bool cmp_equal(const _T1 t1, const _T2 t2) noexcept
+{
+  using T1U = make_unsigned_t<_T1>;
+  using T2U = make_unsigned_t<_T2>;
+  if constexpr (is_signed_v<_T1> == is_signed_v<_T2>)
+   return t1 == t2;
+  else if constexpr (is_signed_v<_T1>)
+   return t1 < 0 ? false : T1U(t1) == t2;
+  else
+   return t2 < 0 ? false : t1 == T2U(t2);
+}
+
+template<class _T1, class _T2>
+constexpr bool cmp_not_equal(const _T1 t1, const _T2 t2) noexcept
+{
+  return !cmp_equal(t1, t2);
+}
+
+template<class _T1, class _T2>
+requires(__is_safe_integral_cmp<_T1> && __is_safe_integral_cmp<_T2>)
+constexpr bool cmp_less(const _T1 t1, const _T2 t2) noexcept
+{
+  using T1U = make_unsigned_t<_T1>;
+  using T2U = make_unsigned_t<_T2>;
+  if constexpr (is_signed_v<_T1> == is_signed_v<_T2>)
+   return t1 < t2;
+  else if constexpr (is_signed_v<_T1>)
+   return t1 < 0 ? true : T1U(t1) < t2;
+  else
+   return t2 < 0 ? false : t1 < T2U(t2);
+}
+
+template<class _T1, class _T2>
+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
+{
+  return !cmp_greater(t1, t2);
+}
+
+template<class _T1, class _T2>
+constexpr bool cmp_greater_equal(const _T1 t1, const _T2 t2) noexcept
+{
+ return !cmp_less(t1, t2);
+}
+
+template<class _Rt, class _Ty>
+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());
+}
+#endif
+#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>

 template <class _Type, class ...>
 using __enable_hash_helper _LIBCPP_NODEBUG_TYPE = _Type;
 #endif
 
 #endif // !_LIBCPP_CXX03_LANG
 
 _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(__cpp_concepts) && __cpp_concepts >= 201811LL
+#   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/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_less(T t, U u) noexcept; // C++20
+
+#include <utility>
+
+#include "test_macros.h"
+
+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'}}
+}
+
+int main() {
+  test<bool>();
+  test<char>();
+  test<wchar_t>();
+  test<float>();
+  test<double>();
+  test<long double>();
+  test<std::byte>();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<char8_t>();
+#endif // !_LIBCPP_NO_HAS_CHAR8_T
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<char16_t>();
+  test<char32_t>();
+#endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
+return 0;
+}

libcxx/test/std/utilities/utility/intcmp/intcmp.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>
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<typename _Ty>
+struct Tuple {
+ _Ty min;
+ _Ty max;
+ _Ty mid;
+constexpr Tuple() {
+ min = std::numeric_limits<_Ty>::min();
+ max = std::numeric_limits<_Ty>::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;
+  }
+
+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 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 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 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(1), U(0)));
+  return true;
+}
+
+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 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()
+{
+ return (... && test_in_range<T>()) &&
+        (... && test_cmp_equal1<T>()) &&
+        (... && test_cmp_not_equal1<T>()) &&
+        (... && test_cmp_less1<T>()) &&
+        (... && test_cmp_less_equal1<T>()) &&
+        (... && test_cmp_greater1<T>()) &&
+        (... && 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_equal2<T, U>()) &&
+        (... && test_cmp_equal2<U, T>()) &&
+        (... && test_cmp_not_equal2<T, U>()) &&
+        (... && test_cmp_not_equal2<U, T>()) &&
+        (... && test_cmp_less2<T, U>()) &&
+        (... && test_cmp_less2<U, T>()) &&
+        (... && test_cmp_less_equal2<T, U>()) &&
+        (... && test_cmp_less_equal2<U, T>()) &&
+        (... && test_cmp_greater2<T, U>()) &&
+        (... && test_cmp_greater2<U, T>()) &&
+        (... && test_cmp_greater_equal2<T, U>());
+        (... && test_cmp_greater_equal2<U, T>());
+}
+
+int main() {
+
+  static_assert(test1<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
+                >());
+  static_assert(test2(std::tuple<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
+                             >{},
+                             std::tuple<uint8_t, int8_t, unsigned short, short,
+                             uint16_t, int16_t, unsigned int, int, uint32_t,
+                             int32_t, unsigned long, long, uint64_t, int64_t,
+                             unsigned long long, long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                             ,__uint128_t, __int128_t
+#endif
+                             >{}));
+  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(__cpp_concepts) && __cpp_concepts >= 201811LL",
   }, {
     "name": "__cpp_lib_integer_sequence",
     "values": { "c++14": 201304 },
     "headers": ["utility"],
   }, {
     "name": "__cpp_lib_integral_constant_callable",
     "values": { "c++14": 201304 },
     "headers": ["type_traits"],