[libc++] Add test for checking progress on P0533R9

[Izaron]

Summary

This test checks progress on P0533R9 (https://wg21.link/p0533r9).
Whenever a desired function becomes constexpr, the programmer won't forget
to switch ASSERT_NOT_CONSTEXPR_CXX23 to ASSERT_CONSTEXPR_CXX23 and
eventually to change the paper's implementation status. The test also works
as a reference list of unimplemented functions.

[Izaron]

This is a part of our work on implementing p0533r9:
https://discourse.llvm.org/t/how-do-we-plan-to-make-constexpr-cmath-and-cstdlib/65930

This patch introduces a test that serve as:

1. A reference list of functions that need to be declared constexpr to make p0533r9 implemented.
2. A progress checker, so that whenever a new function is declared constexpr, the programmer won't forget to switch the corresponding ASSERT_NOT_CONSTEXPR_CXX23s to ASSERT_CONSTEXPR_CXX23s and eventually confidently mark the paper as implemented.

With this test (and previous commits) we will have a nice automated workflow for working on this paper:

1. The programmer makes a new constexpr builtin, for example patch for __builtin_fmax.
2. The programmer has to mark the builtin with the E attribute in Builtins.def, for example __builtins_def (otherwise the evaluator returns early).
3. Since the builtin __builtin_fmax is marked as constant evaluated (in Builtins.def), the __has_constexpr_builtin(__builtin_fmax) starts returning true.
4. Since __has_constexpr_builtin(__builtin_fmax) == true, the corresponding libcxx function std::fmax becomes constexpr, because our fellow @philnik is now refactoring cmath to using builtins unconditionally, and the functions will be conditionally constexpr, so it will soon look like this:

inline _LIBCPP_CONSTEXPR_CXX23_IF_CONSTEXPR_BUILTIN(__builtin_fmax) _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT { return __builtin_fmax(__x, __y); }

5. The new test (that I added in this patch request) starts to fails, so the programmer has to switch ASSERT_NOT_CONSTEXPR_CXX23 to ASSERT_CONSTEXPR_CXX23
6. GoTo 1, if there are any other non-constexpr function.
7. There are no non-constexpr functions anymore, so the new test (that I added in this patch request) congratulates you! The paper is implemented.

I hope this workflow is clear 😅 This is not an overengineering - only a clear adherence to the paper so that we clearly understand the current status.

[Izaron]

Get rid of C++ earlier that C++2b.
Get rid of GNU compiler.

[Izaron]

Get rid of hexfloat, because hexfloat<long double> not working on test machines.

[philnik]

Thanks for working on this! Looks good in general, but I've got a few suggestions.

libcxx/test/std/numerics/c.math/constexpr.cmath.pass.cpp

1 ↗

(On Diff #469942)

I think this test should be in libcxx/test/libcxx, since we don't actually test the standard, but our current implementation status.

2 ↗

(On Diff #469942)

Could you also add a test for GCC and the global namespace versions of the functions?

13 ↗

(On Diff #469942)

What do you need this include for?

16 ↗

(On Diff #469942)

You can mark the test as // REQUIRES: clang and // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 instead.

19 ↗

(On Diff #469942)

What does _builtin_constant_p do?

30 ↗

(On Diff #469942)

I'm not sure these comments add a lot of value, since it's pretty clear what is tested by looking at the call.

[Izaron]

libcxx/test/std/numerics/c.math/constexpr.cmath.pass.cpp

2 ↗

(On Diff #469942)

What are "global namespace versions of the functions"? Functions outside the std:: namespace?

13 ↗

(On Diff #469942)

I couldn't use TEST_STD_VER without this include. But now this is irrelevant since I don't need this macro with // REQUIRES and // UNSUPPORTED. I don't include this anymore.

19 ↗

(On Diff #469942)

__builtin_constant_p(Expr) is a GNU builtin (has been ported to Clang) that determines whether the Expr expression is known to be constant in compile time - https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

This is somewhat similar with __has_constexpr_builtin:

static_assert(__builtin_constant_p(__builtin_fmax(12.34, 45.67) == 45.67));
static_assert(__has_constexpr_builtin(__builtin_fmax));

I think __has_constexpr_builtin is better for "conditionally constexpr" math functions in the headers, and __builtin_constant_p is better for tests checking that expression is constant evaluable.

ASSERT_CONSTEXPR_CXX23 ensures that the Expr is constant evaluable, ASSERT_NOT_CONSTEXPR_CXX23 ensures that isn't.

[Izaron]

Move to constexpr-cxx2b.pass.cpp, fixed issues. Thanks to @philnik!

[Izaron]

Could you also add a test for GCC and the global namespace versions of the functions?

Does "test for GCC" mean testing how GCC would compile libc++?

I think we could make it by copy-pasting the file with changing // REQUIRES: clang to // REQUIRES: gcc.

But we need to think how we could declare functions constexpr giving that GCC doesn't support __has_constexpr_builtin? Since GCC supposedly supports a ton of constexpr builtins now, we could check __has_constexpr_builtin for Clang and the compiler's version for GCC. Would that work?

#ifdef __clang__
#  if __has_constexpr_builtin(__builtin_fmax)
     constexpr
#  endif
#elifdef __GNU__
#  if __GNU_VERSION__ >= 1234
     constexpr
#  endif
#endif
double fmax(double a, double b) { return __builtin_fmax(a, b); }

[philnik]

In D136538#3880021, @Izaron wrote:

Could you also add a test for GCC and the global namespace versions of the functions?

Does "test for GCC" mean testing how GCC would compile libc++?

I think we could make it by copy-pasting the file with changing // REQUIRES: clang to // REQUIRES: gcc.

Yes, that's what I had in mind.

But we need to think how we could declare functions constexpr giving that GCC doesn't support __has_constexpr_builtin? Since GCC supposedly supports a ton of constexpr builtins now, we could check __has_constexpr_builtin for Clang and the compiler's version for GCC. Would that work?

#ifdef __clang__
#  if __has_constexpr_builtin(__builtin_fmax)
     constexpr
#  endif
#elifdef __GNU__
#  if __GNU_VERSION__ >= 1234
     constexpr
#  endif
#endif
double fmax(double a, double b) { return __builtin_fmax(a, b); }

We only support GCC 12, so we could simplify this to

__config

#ifndef __has_constexpr_builtin
#  define __has_constexpr_builtin(...) 0
#endif

math.h

#if __has_constexpr_builtin(__builtin_fmax) || defined(_LIBCPP_COMPILER_GCC)
constexpr
#endif
double fmax(double a, double b) { return __builtin_fmax(a, b); }

but yes, that's the general idea.

libcxx/test/std/numerics/c.math/constexpr.cmath.pass.cpp

2 ↗

(On Diff #469942)

yes

13 ↗

(On Diff #469942)

I missed that, thanks.

[Izaron]

Add test for GCC. Thanks to @philnik!

[philnik]

LGTM with CI passing.

[Izaron]

Fix GCC tests - some of its functions are already constexpr

[ldionne]

Thanks for the contribution. However, this looks a bit unusual to me. @philnik I think this should really be under libcxx/test/std since we are testing standard conformance. We would comment out tests for functions that we don't implement constexpr for yet, and uncomment them as we go. This is what we've done a bunch in e.g. ranges.

[philnik]

In D136538#3899436, @ldionne wrote:

Thanks for the contribution. However, this looks a bit unusual to me. @philnik I think this should really be under libcxx/test/std since we are testing standard conformance. We would comment out tests for functions that we don't implement constexpr for yet, and uncomment them as we go. This is what we've done a bunch in e.g. ranges.

I'd consider this test to be a bit different. Here we essentially check what the compiler has implemented. We don't have to do anything special in the implementation, we just have to add constexpr to the functions. My plan was to add tests as we mark the functions constexpr, since our current cmath tests are really lacking. It currently also differs massively between the compilers what we can actually make constexpr, which isn't normally the case AFAIK.

libcxx/test/libcxx/numerics/c.math/constexpr-cxx2b-clang.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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that Clang supports constexpr <cmath> and <cstdlib> functions
+// mentioned in the P0533R9 paper that is part of C++2b
+// (https://wg21.link/p0533r9)
+//
+// Every function called in this test should become constexpr. Whenever some
+// of the desired function become constexpr, the programmer switches
+// `ASSERT_NOT_CONSTEXPR_CXX23` to `ASSERT_CONSTEXPR_CXX23` and eventually the
+// paper is implemented in Clang.
+// The test also works as a reference list of unimplemented functions.
+//
+// REQUIRES: clang
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cmath>
+#include <cstdlib>
+#include <cassert>
+
+int main(int, char**) {
+  bool ImplementedP0533R9 = true;
+
+#define ASSERT_CONSTEXPR_CXX23(Expr) static_assert(__builtin_constant_p(Expr) && (Expr))
+#define ASSERT_NOT_CONSTEXPR_CXX23(Expr)                                                                               \
+  static_assert(!__builtin_constant_p(Expr));                                                                          \
+  assert(Expr);                                                                                                        \
+  ImplementedP0533R9 = false
+
+  int DummyInt;
+  float DummyFloat;
+  double DummyDouble;
+  long double DummyLongDouble;
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1L) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1LL) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::labs(-1L) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llabs(-1LL) == 1LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13, 5).rem == 3);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13L, 5L).rem == 3L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13LL, 5LL).rem == 3LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldiv(13L, 5L).rem == 3L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lldiv(13LL, 5LL).rem == 3LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0f, &DummyInt) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0, &DummyInt) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0L, &DummyInt) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpf(0.0f, &DummyInt) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpl(0.0L, &DummyInt) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0L) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogbf(1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogbl(1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0f, 1) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0, 1) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0L, 1) == 2.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexpf(1.0f, 1) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexpl(1.0L, 1) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0L) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logbf(1.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logbl(1.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0f, &DummyFloat) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0, &DummyDouble) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0L, &DummyLongDouble) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modff(1.0f, &DummyFloat) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modfl(1.0L, &DummyLongDouble) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0f, 1) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0, 1) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0L, 1) == 2.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbnf(1.0f, 1) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbnl(1.0L, 1) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0f, 1L) == 2);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0, 1L) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0L, 1L) == 2.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalblnf(1.0f, 1L) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalblnl(1.0L, 1L) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabsf(-1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabsl(-1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0L) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceilf(0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceill(0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floorf(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floorl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::roundf(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::roundl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0f) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0L) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lroundf(1.0f) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lroundl(1.0L) == 1L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0f) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0L) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llroundf(1.0f) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llroundl(1.0L) == 1LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::truncf(1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::truncl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5f, 1.0f) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5, 1.0) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5L, 1.0L) == 0.5L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmodf(1.5f, 1.0f) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmodl(1.5L, 1.0L) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5f, 1.0f) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5, 1.0) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5L, 1.0L) == 0.5L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainderf(0.5f, 1.0f) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainderl(0.5L, 1.0L) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5f, 1.0f, &DummyInt) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5, 1.0, &DummyInt) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5L, 1.0L, &DummyInt) == 0.5L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquof(0.5f, 1.0f, &DummyInt) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquol(0.5L, 1.0L, &DummyInt) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0f, 1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0, 1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0L, 1.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysignf(1.0f, 1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysignl(1.0L, 1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafter(0.0f, 0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafter(0.0, 0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafter(0.0L, 0.0L) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafterf(0.0f, 0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafterl(0.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttoward(0.0f, 0.0L) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttoward(0.0, 0.0L) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttoward(0.0L, 0.0L) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttowardf(0.0f, 0.0L) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttowardl(0.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0f, 0.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0, 0.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0L, 0.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdimf(1.0f, 0.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdiml(1.0L, 0.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0f, 0.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0, 0.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0L, 0.0L) == 1.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaxf(1.0f, 0.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaxl(1.0L, 0.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0f, 0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0, 0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0L, 0.0L) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fminf(1.0f, 0.0f) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fminl(1.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0f, 1.0f, 1.0f) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0, 1.0, 1.0) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0L, 1.0L, 1.0L) == 2.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaf(1.0f, 1.0f, 1.0f) == 2.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmal(1.0L, 1.0L, 1.0L) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0f) == FP_NORMAL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0) == FP_NORMAL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0L) == FP_NORMAL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0L, 0.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0L, 0.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0L, 0.0L) == 0);
+
+  assert(!ImplementedP0533R9 && R"(
+Congratulations! You just have implemented P0533R9 (https://wg21.link/p0533r9).
+Please go to `clang/www/cxx_status.html` and change the paper's implementation
+status. Also please delete this assert and refactor `ASSERT_CONSTEXPR_CXX23`
+and `ASSERT_NOT_CONSTEXPR_CXX23`.
+)");
+
+  return 0;
+}

libcxx/test/libcxx/numerics/c.math/constexpr-cxx2b-gcc.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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that GCC supports constexpr <cmath> and <cstdlib> functions
+// mentioned in the P0533R9 paper that is part of C++2b
+// (https://wg21.link/p0533r9)
+//
+// Every function called in this test should become constexpr. Whenever some
+// of the desired function become constexpr, the programmer switches
+// `ASSERT_NOT_CONSTEXPR_CXX23` to `ASSERT_CONSTEXPR_CXX23` and eventually the
+// paper is implemented in Clang.
+// The test also works as a reference list of unimplemented functions.
+//
+// REQUIRES: gcc
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cmath>
+#include <cstdlib>
+#include <cassert>
+
+int main(int, char**) {
+  bool ImplementedP0533R9 = true;
+
+#define ASSERT_CONSTEXPR_CXX23(Expr) static_assert(__builtin_constant_p(Expr) && (Expr))
+#define ASSERT_NOT_CONSTEXPR_CXX23(Expr)                                                                               \
+  static_assert(!__builtin_constant_p(Expr));                                                                          \
+  assert(Expr);                                                                                                        \
+  ImplementedP0533R9 = false
+
+  int DummyInt;
+  float DummyFloat;
+  double DummyDouble;
+  long double DummyLongDouble;
+
+  ASSERT_CONSTEXPR_CXX23(std::abs(-1) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1L) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1LL) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0f) == 1.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0L) == 1.0L);
+
+  ASSERT_CONSTEXPR_CXX23(std::labs(-1L) == 1L);
+  ASSERT_CONSTEXPR_CXX23(std::llabs(-1LL) == 1LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13, 5).rem == 3);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13L, 5L).rem == 3L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13LL, 5LL).rem == 3LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldiv(13L, 5L).rem == 3L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lldiv(13LL, 5LL).rem == 3LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0f, &DummyInt) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0, &DummyInt) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0L, &DummyInt) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpf(0.0f, &DummyInt) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpl(0.0L, &DummyInt) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0f) == 0);
+  ASSERT_CONSTEXPR_CXX23(std::ilogb(1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0L) == 0);
+  ASSERT_CONSTEXPR_CXX23(std::ilogbf(1.0f) == 0);
+  ASSERT_CONSTEXPR_CXX23(std::ilogbl(1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0f, 1) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::ldexp(1.0, 1) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0L, 1) == 2.0L);
+  ASSERT_CONSTEXPR_CXX23(std::ldexpf(1.0f, 1) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::ldexpl(1.0L, 1) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::logb(1.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0L) == 0.0L);
+  ASSERT_CONSTEXPR_CXX23(std::logbf(1.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::logbl(1.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0f, &DummyFloat) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0, &DummyDouble) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0L, &DummyLongDouble) == 0.0L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modff(1.0f, &DummyFloat) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modfl(1.0L, &DummyLongDouble) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0f, 1) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::scalbn(1.0, 1) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0L, 1) == 2.0L);
+  ASSERT_CONSTEXPR_CXX23(std::scalbnf(1.0f, 1) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::scalbnl(1.0L, 1) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0f, 1L) == 2);
+  ASSERT_CONSTEXPR_CXX23(std::scalbln(1.0, 1L) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0L, 1L) == 2.0L);
+  ASSERT_CONSTEXPR_CXX23(std::scalblnf(1.0f, 1L) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::scalblnl(1.0L, 1L) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fabs(-1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::fabsf(-1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fabsl(-1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::ceil(0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0L) == 0.0L);
+  ASSERT_CONSTEXPR_CXX23(std::ceilf(0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::ceill(0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::floor(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::floorf(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::floorl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::round(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::roundf(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::roundl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0f) == 1L);
+  ASSERT_CONSTEXPR_CXX23(std::lround(1.0) == 1L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0L) == 1L);
+  ASSERT_CONSTEXPR_CXX23(std::lroundf(1.0f) == 1L);
+  ASSERT_CONSTEXPR_CXX23(std::lroundl(1.0L) == 1L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0f) == 1LL);
+  ASSERT_CONSTEXPR_CXX23(std::llround(1.0) == 1LL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0L) == 1LL);
+  ASSERT_CONSTEXPR_CXX23(std::llroundf(1.0f) == 1LL);
+  ASSERT_CONSTEXPR_CXX23(std::llroundl(1.0L) == 1LL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::trunc(1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::truncf(1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::truncl(1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5f, 1.0f) == 0.5f);
+  ASSERT_CONSTEXPR_CXX23(std::fmod(1.5, 1.0) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5L, 1.0L) == 0.5L);
+  ASSERT_CONSTEXPR_CXX23(std::fmodf(1.5f, 1.0f) == 0.5f);
+  ASSERT_CONSTEXPR_CXX23(std::fmodl(1.5L, 1.0L) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5f, 1.0f) == 0.5f);
+  ASSERT_CONSTEXPR_CXX23(std::remainder(0.5, 1.0) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5L, 1.0L) == 0.5L);
+  ASSERT_CONSTEXPR_CXX23(std::remainderf(0.5f, 1.0f) == 0.5f);
+  ASSERT_CONSTEXPR_CXX23(std::remainderl(0.5L, 1.0L) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5f, 1.0f, &DummyInt) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5, 1.0, &DummyInt) == 0.5);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5L, 1.0L, &DummyInt) == 0.5L);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquof(0.5f, 1.0f, &DummyInt) == 0.5f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquol(0.5L, 1.0L, &DummyInt) == 0.5L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0f, 1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::copysign(1.0, 1.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0L, 1.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::copysignf(1.0f, 1.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::copysignl(1.0L, 1.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafter(0.0f, 0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::nextafter(0.0, 0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nextafter(0.0L, 0.0L) == 0.0L);
+  ASSERT_CONSTEXPR_CXX23(std::nextafterf(0.0f, 0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::nextafterl(0.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttoward(0.0f, 0.0L) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::nexttoward(0.0, 0.0L) == 0.0f);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::nexttoward(0.0L, 0.0L) == 0.0L);
+  ASSERT_CONSTEXPR_CXX23(std::nexttowardf(0.0f, 0.0L) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::nexttowardl(0.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0f, 0.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fdim(1.0, 0.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0L, 0.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::fdimf(1.0f, 0.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fdiml(1.0L, 0.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0f, 0.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fmax(1.0, 0.0) == 1.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0L, 0.0L) == 1.0L);
+  ASSERT_CONSTEXPR_CXX23(std::fmaxf(1.0f, 0.0f) == 1.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fmaxl(1.0L, 0.0L) == 1.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0f, 0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fmin(1.0, 0.0) == 0.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0L, 0.0L) == 0.0L);
+  ASSERT_CONSTEXPR_CXX23(std::fminf(1.0f, 0.0f) == 0.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fminl(1.0L, 0.0L) == 0.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0f, 1.0f, 1.0f) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fma(1.0, 1.0, 1.0) == 2.0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0L, 1.0L, 1.0L) == 2.0L);
+  ASSERT_CONSTEXPR_CXX23(std::fmaf(1.0f, 1.0f, 1.0f) == 2.0f);
+  ASSERT_CONSTEXPR_CXX23(std::fmal(1.0L, 1.0L, 1.0L) == 2.0L);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0f) == FP_NORMAL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0) == FP_NORMAL);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0L) == FP_NORMAL);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0L, 0.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0L, 0.0L) == 0);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0f, 0.0f) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0, 0.0) == 1);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0L, 0.0L) == 1);
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0f, 0.0f) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0, 0.0) == 0);
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0L, 0.0L) == 0);
+
+  assert(!ImplementedP0533R9 && R"(
+Congratulations! You just have implemented P0533R9 (https://wg21.link/p0533r9).
+Please go to `clang/www/cxx_status.html` and change the paper's implementation
+status. Also please delete this assert and refactor `ASSERT_CONSTEXPR_CXX23`
+and `ASSERT_NOT_CONSTEXPR_CXX23`.
+)");
+
+  return 0;
+}