[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

2

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

3

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

14

What do you need this include for?

17

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

20

What does _builtin_constant_p do?

31

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

3

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

14

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.

20

__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

3

yes

14

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/std/numerics/c.math/constexpr.cmath.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <cmath>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+#include "hexfloat.h"
+
+void test_p0533r9() {
+  bool ImplementedP0533R9 = true;
+
+#if TEST_STD_VER >= 23
+#  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
+#else
+#  define ASSERT_CONSTEXPR_CXX23(Expr)
+#  define ASSERT_NOT_CONSTEXPR_CXX23(Expr)
+  ImplementedP0533R9 = false;
+#endif
+
+  int DummyInt;
+  float DummyFloat;
+  double DummyDouble;
+  long double DummyLongDouble;
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1) == 1);       // int abs(int j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1L) == 1L);     // long int abs(long int j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1LL) == 1LL);   // long long int abs(long long int j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0f) == 1.0f); // float abs(float j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0) == 1.0);   // double abs(double j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::abs(-1.0L) == 1.0L); // long double abs(long double j)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::labs(-1L) == 1L);    // long int labs(long int j)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llabs(-1LL) == 1LL); // long long int llabs(long long int j)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13, 5).rem == 3);       // div_t div(int numer, int denom)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13L, 5L).rem == 3L);    // ldiv_t div(long int numer, long int denom)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::div(13LL, 5LL).rem == 3LL); // lldiv_t div(long long int numer, long long int denom)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldiv(13L, 5L).rem == 3L);   // ldiv_t ldiv(long int numer, long int denom)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::lldiv(13LL, 5LL).rem == 3LL); // lldiv_t lldiv(long long int numer, long long int denom)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0f, &DummyInt) == 0.0f);  // float frexp(float value, int* exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0, &DummyInt) == 0.0);    // double frexp(double value, int* exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexp(0.0L, &DummyInt) == 0.0L);  // long double frexp(long double value, int* exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpf(0.0f, &DummyInt) == 0.0f); // float frexpf(float value, int* exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::frexpl(0.0L, &DummyInt) == 0.0L); // long double frexpl(long double value, int* exp)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0f) == 0);  // int ilogb(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0) == 0);   // int ilogb(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogb(1.0L) == 0);  // int ilogb(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogbf(1.0f) == 0); // int ilogbf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ilogbl(1.0L) == 0); // int ilogbl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0f, 1) == 2.0f);  // float ldexp(float x, int exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0, 1) == 2.0);    // double ldexp(double x, int exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexp(1.0L, 1) == 2.0L);  // long double ldexp(long double x, int exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexpf(1.0f, 1) == 2.0f); // float ldexpf(float x, int exp)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ldexpl(1.0L, 1) == 2.0L); // long double ldexpl(long double x, int exp)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0f) == 0.0f);  // float logb(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0) == 0.0);    // double logb(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logb(1.0L) == 0.0L);  // long double logb(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logbf(1.0f) == 0.0f); // float logbf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::logbl(1.0L) == 0.0L); // long double ilogbl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0f, &DummyFloat) == 0.0f); // float modf(float value, float* iptr)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modf(1.0, &DummyDouble) == 0.0);  // double modf(double value, double* iptr)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::modf(1.0L, &DummyLongDouble) == 0.0L); // long double modf(long double value, long double* iptr)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::modff(1.0f, &DummyFloat) == 0.0f); // float modff(float value, float* iptr)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::modfl(1.0L, &DummyLongDouble) == 0.0L); // long double modfl(long double value, long double* iptr)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0f, 1) == 2.0f);  // float scalbn(float x, int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0, 1) == 2.0);    // double scalbn(double x, int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbn(1.0L, 1) == 2.0L);  // long double scalbn(long double x, int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbnf(1.0f, 1) == 2.0f); // float scalbnf(float x, int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbnl(1.0L, 1) == 2.0L); // long double scalbnl(long double x, int n)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0f, 1L) == 2);     // float scalbln(float x, long int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0, 1L) == 2.0);    // double scalbln(double x, long int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalbln(1.0L, 1L) == 2.0L);  // long double scalbln(long double x, long int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalblnf(1.0f, 1L) == 2.0f); // float scalblnf(float x, long int n)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::scalblnl(1.0L, 1L) == 2.0L); // long double scalblnl(long double x, long int n)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0f) == 1.0f);  // float fabs(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0) == 1.0);    // double fabs(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabs(-1.0L) == 1.0L);  // long double fabs(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabsf(-1.0f) == 1.0f); // float fabsf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fabsl(-1.0L) == 1.0L); // long double fabsl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0f) == 0.0f);  // float ceil(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0) == 0.0);    // double ceil(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceil(0.0L) == 0.0L);  // long double ceil(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceilf(0.0f) == 0.0f); // float ceilf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::ceill(0.0L) == 0.0L); // long double ceill(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0f) == 1.0f);  // float floor(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0) == 1.0);    // double floor(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floor(1.0L) == 1.0L);  // long double floor(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floorf(1.0f) == 1.0f); // float floorf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::floorl(1.0L) == 1.0L); // long double floorl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0f) == 1.0f);  // float round(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0) == 1.0);    // double round(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::round(1.0L) == 1.0L);  // long double round(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::roundf(1.0f) == 1.0f); // float roundf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::roundl(1.0L) == 1.0L); // long double roundl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0f) == 1L);  // long int round(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0) == 1L);   // long int round(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lround(1.0L) == 1L);  // long int round(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lroundf(1.0f) == 1L); // long int roundf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::lroundl(1.0L) == 1L); // long int roundl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0f) == 1LL);  // long long int round(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0) == 1LL);   // long long int round(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llround(1.0L) == 1LL);  // long long int round(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llroundf(1.0f) == 1LL); // long long int roundf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::llroundl(1.0L) == 1LL); // long long int roundl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0f) == 1.0f);  // float trunc(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0) == 1.0);    // double trunc(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::trunc(1.0L) == 1.0L);  // long double trunc(long double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::truncf(1.0f) == 1.0f); // float truncf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::truncl(1.0L) == 1.0L); // long double truncl(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5f, 1.0f) == 0.5f);  // float fmod(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5, 1.0) == 0.5);     // double fmod(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmod(1.5L, 1.0L) == 0.5L);  // long double fmod(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmodf(1.5f, 1.0f) == 0.5f); // float fmodf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmodl(1.5L, 1.0L) == 0.5L); // long double fmodl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5f, 1.0f) == 0.5f); // float remainder(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5, 1.0) == 0.5);    // double remainder(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainder(0.5L, 1.0L) == 0.5L); // long double remainder(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remainderf(0.5f, 1.0f) == 0.5f); // float remainderf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::remainderl(0.5L, 1.0L) == 0.5L); // long double remainderl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5f, 1.0f, &DummyInt) == 0.5f); // float remquo(float x, float y, int* quo)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquo(0.5, 1.0, &DummyInt) == 0.5);    // double remquo(double x, double y, int* quo)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::remquo(0.5L, 1.0L, &DummyInt) == 0.5L); // long double remquo(long double x, long double y, int* quo)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::remquof(0.5f, 1.0f, &DummyInt) == 0.5f); // float remquof(float x, float y, int* quo)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::remquol(0.5L, 1.0L, &DummyInt) == 0.5L); // long double remquol(long double x, long double y, int* quo)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0f, 1.0f) == 1.0f);  // float copysign(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0, 1.0) == 1.0);     // double copysign(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysign(1.0L, 1.0L) == 1.0L);  // long double copysign(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysignf(1.0f, 1.0f) == 1.0f); // float copysignf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::copysignl(1.0L, 1.0L) == 1.0L); // long double copysignl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nextafter(0.0f, 1.0f) == hexfloat<float>(0x1, 0, -149)); // float nextafter(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nextafter(0.0, 1.0) == hexfloat<double>(0x1, 0, -1074)); // double nextafter(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nextafter(0.0L, 1.0L) ==
+      hexfloat<long double>(0x1, 0, -16445)); // long double nextafter(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nextafterf(0.0f, 1.0f) == hexfloat<float>(0x1, 0, -149)); // float nextafterf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nextafterl(0.0L, 1.0L) ==
+      hexfloat<long double>(0x1, 0, -16445)); // long double nextafterl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nexttoward(0.0f, 1.0L) == hexfloat<float>(0x1, 0, -149)); // float nexttoward(float x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nexttoward(0.0, 1.0L) == hexfloat<double>(0x1, 0, -1074)); // double nexttoward(double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nexttoward(0.0L, 1.0L) ==
+      hexfloat<long double>(0x1, 0, -16445)); // long double nexttoward(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nexttowardf(0.0f, 1.0L) == hexfloat<float>(0x1, 0, -149)); // float nexttowardf(float x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::nexttowardl(0.0L, 1.0L) ==
+      hexfloat<long double>(0x1, 0, -16445)); // long double nexttowardl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0f, 0.0f) == 1.0f);  // float fdim(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0, 0.0) == 1.0);     // double fdim(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdim(1.0L, 0.0L) == 1.0L);  // long double fdim(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdimf(1.0f, 0.0f) == 1.0f); // float fdimf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fdiml(1.0L, 0.0L) == 1.0L); // long double fdiml(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0f, 0.0f) == 1.0f);  // float fmax(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0, 0.0) == 1.0);     // double fmax(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmax(1.0L, 0.0L) == 1.0L);  // long double fmax(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaxf(1.0f, 0.0f) == 1.0f); // float fmaxf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaxl(1.0L, 0.0L) == 1.0L); // long double fmaxl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0f, 0.0f) == 0.0f);  // float fmin(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0, 0.0) == 0.0);     // double fmin(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmin(1.0L, 0.0L) == 0.0L);  // long double fmin(long double x, long double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fminf(1.0f, 0.0f) == 0.0f); // float fminf(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fminl(1.0L, 0.0L) == 0.0L); // long double fminl(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0f, 1.0f, 1.0f) == 2.0f); // float fma(float x, float y, float z)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fma(1.0, 1.0, 1.0) == 2.0);     // double fma(double x, double y, double z)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::fma(1.0L, 1.0L, 1.0L) == 2.0L); // long double fma(long double x, long double y, long double z)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fmaf(1.0f, 1.0f, 1.0f) == 2.0f); // float fmaf(float x, float y, float z)
+  ASSERT_NOT_CONSTEXPR_CXX23(
+      std::fmal(1.0L, 1.0L, 1.0L) == 2.0L); // long double fmal(long double x, long double y, long double z)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0f) == FP_NORMAL); // int fpclassify(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0) == FP_NORMAL);  // int fpclassify(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::fpclassify(-1.0L) == FP_NORMAL); // int fpclassify(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0f) == 1); // int isfinite(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0) == 1);  // int isfinite(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isfinite(-1.0L) == 1); // int isfinite(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0f) == 0); // int isinf(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0) == 0);  // int isinf(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isinf(-1.0L) == 0); // int isinf(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0f) == 0); // int isnan(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0) == 0);  // int isnan(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnan(-1.0L) == 0); // int isnan(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0f) == 1); // int isnormal(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0) == 1);  // int isnormal(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isnormal(-1.0L) == 1); // int isnormal(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0f) == 1); // int signbit(float x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0) == 1);  // int signbit(double x)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::signbit(-1.0L) == 1); // int signbit(long double x)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0f, 0.0f) == 0); // int isgreater(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0, 0.0) == 0);   // int isgreater(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreater(-1.0L, 0.0L) == 0); // int isgreater(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0f, 0.0f) == 0); // int isgreaterequal(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0, 0.0) == 0);   // int isgreaterequal(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isgreaterequal(-1.0L, 0.0L) == 0); // int isgreaterequal(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0f, 0.0f) == 1); // int isless(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0, 0.0) == 1);   // int isless(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isless(-1.0L, 0.0L) == 1); // int isless(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0f, 0.0f) == 1); // int islessequal(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0, 0.0) == 1);   // int islessequal(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessequal(-1.0L, 0.0L) == 1); // int islessequal(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0f, 0.0f) == 1); // int islessgreater(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0, 0.0) == 1);   // int islessgreater(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::islessgreater(-1.0L, 0.0L) == 1); // int islessgreater(long double x, long double y)
+
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0f, 0.0f) == 0); // int isunordered(float x, float y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0, 0.0) == 0);   // int isunordered(double x, double y)
+  ASSERT_NOT_CONSTEXPR_CXX23(std::isunordered(-1.0L, 0.0L) == 0); // int isunordered(long double x, long double y)
+
+  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`.
+)");
+}
+
+int main(int, char**) {
+  test_p0533r9();
+  return 0;
+}