[libc++] [C++20] [P0415] Constexpr for std::complex.

[philnik]

Summary

This patch adds constexpr to <complex> header: operators, member operators, and member functions (real, imag, norm, conj).

https://eel.is/c++draft/complex.numbers
https://wg21.link/p0415

[ldionne]

Nice! Are you looking for a review now, or it's just a WIP patch? Ideally you'd fix the TODOs you already noted before we take a look, unless you have specific questions/concerns.

[ldionne]

(Requesting changes so it shows up properly in my review queue)

[curdeius]

@ldionne, I'd appreciate if you (or somebody else) could tell me what you think about the way I test the constexpr. I wanted to avoid duplication but on a second thought, I think that run-time tests can actually go through compile-time (constexpr) branch and so leave the non-constexpr branch untested.
Another thing in which I'd need guidance is how to test the primary implementation (not specializations for float, double, long double). Is there another floating-point type I can use in tests? Maybe some sort of short float?
Oh, and should integral types be tested with complex<T>?

[ldionne]

In D79555#2025500, @curdeius wrote:

@ldionne, I'd appreciate if you (or somebody else) could tell me what you think about the way I test the constexpr. I wanted to avoid duplication but on a second thought, I think that run-time tests can actually go through compile-time (constexpr) branch and so leave the non-constexpr branch untested.

I think it's fine -- avoiding duplication is pretty important IMO. I don't think the compiler will try to evaluate this using the constexpr evaluator if it's not marked as constexpr. If we wanted to be really really sure, we could also make sure the values we use in the test are thought to be potentially-runtime by calling a function defined in a different TU. That would be somewhat more complicated, but imagine the following setup:

// in support.cpp
template <typename T>
T identity(T t) { return t; }

template int identity(int);
template float identity(float);
// etc...

Then, let's say you have a test that is potentially constexpr like this:

template <class T>
TEST_CONSTEXPR_CXX20 bool test(T zero) {
    T lhs(1.5 + zero);
    std::complex<T> rhs(3.5 + zero, 4.5);
    std::complex<T>   x(5.0 + zero, 4.5);
    test(lhs, rhs, x);
}

You could now call it once at runtime and once at compile-time:

int main(int argc, char** argv) {
    test<float>(identity<float>(0)); // runtime test
    static_assert(test<float>(0)); // compile-time test
}

Since identity is defined in a different TU, the compiler would really have to generate code for the runtime tests. There's a few different ways to do this, another way I can think of is to piggy back on argc or just a (volatile?) global variable. But the idea is the same. If there's interest, we can look into setting this up more widely for amphibious (constexpr/not constexpr) tests.

Another thing in which I'd need guidance is how to test the primary implementation (not specializations for float, double, long double). Is there another floating-point type I can use in tests? Maybe some sort of short float?

I'm seeing this on cppreference:

The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are LiteralTypes for representing and manipulating complex numbers. The effect of instantiating the template complex for any other type is unspecified.

I don't think we test other specializations in our other complex tests, do we? If not, I'd say it's OK to not test it... Maybe I'm not being imaginative enough?

Oh, and should integral types be tested with complex<T>?

Like I said above, I don't think so. Please LMK if you disagree.

What *does* need to be tested however is the interaction between std::complex<T> and U where T in {float, double, long double} and U is an integral type. But you seem to be testing this correct (e.g. in conj.pass.cpp).

libcxx/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp

29

Nit: this spacing seems to have changed?

[curdeius]

Fix edge cases. Fix operator* and operator/.
Use "shortcuts" to avoid NaN in constexpr evaluation (disallowed).

One remaining problem.
2 tests:

• complex_divides_complex.pass.cpp
• complex_times_complex.pass.cpp

do not pass on clang unless additional parameter --param=compile_flags='-fconstexpr-steps=4000000' is given.
That's because they test all the edge cases and each pair thereof and clang has too low a limit for the maximum number of constexpr execution steps.
I thought about splitting these tests somehow but given their (combinatoric) nature, it's pretty awkward.

I don't know how I should pass this compile flag only for these tests and only for clang (I know of ADDITIONAL_COMPILE_FLAGS but I cannot exclude gcc with that).

TODO:

• Test (at least locally) a different floating-point type (e.g. float128) to catch missing constexpr markers in the default implementation (non-specialization).

[curdeius]

Fix diff.

[curdeius]

• Revert unrelated changes in cases.h.

[curdeius]

• Add missing constexpr on generic implementation.
• Add missing static asserts in tests.

[curdeius]

• Bump version in status.

[curdeius]

• Fix pre-C++20 modes. Ugly duplication :/.

[curdeius]

• Clean up.

[curdeius]

I've tested the non-specialization with __float128 and fixed missing constexpr there. The tests mainly pass apart from those testing operators * and / that use copysign which is ambiguous (already in non-constexpr context so I didn't pursue it any further). It's implementation-specific anyway.

[ldionne]

Can you please ping once you think this is ready to review? For now, I'll "request changes" so it shows up correctly in the review queue.

[curdeius]

• Hack to add a compile flag only to clang.
• Rebase

[curdeius]

• Fix apple-clang.
• Add header guards.

[curdeius]

@ldionne, it's ready for review (at least the first glance).

[ldionne]

Can you rebase onto main so that CI runs again? You'll also need to fix a few details like the cxx2a_status page which has changed.

libcxx/include/complex

776

I think we really need to unfork these implementations and use the same one in all standard modes. It looks like the only difference is pretty much that you're calling the _constexpr variations when is_constant_evaluated() in the C++20 version. Would it be possible to always call e.g. __libcpp_scalbn, and then have that function check for is_constant_evaluated() and use a constexpr-friendly implementation in that case?

[curdeius]

• Use __libcpp_is_constant_evaluated in *_constexpr helper functions.
• Update status page and feature test macros.
• Rebase.

[curdeius]

• Fix pre-C++14 builds.

[curdeius]

libcxx/include/complex

585–614

I guess I need to do the same #if dance as below, so as not to change the current runtime behaviour.

600

Oops. Should be __builtin_copysign (without l).

676

Oops. Will remove in next update.

776

Done. The solution is IMO still a bit ugly (with those #ifdefs), but it's much better than before.
Thanks for the suggestion.

[curdeius]

• Small fixes.

[curdeius]

• Revert whitespace changes.

[curdeius]

Ping.

• Rebase.
• Revert whitespace changes.

[• Quuxplusone]

libcxx/include/complex

236–237

I think numeric_limits gives you the best chance of making things work generically with non-base-2 types (not that such things exist).
I've been starting to comment #include lines with the stuff we need them for; although I admit in this case it's pretty obvious what <limits> is always needed for ;)

600

The l is still there.

611

Here _LIBCPP_CONSTEXPR_AFTER_CXX17 can be just constexpr, because this code is enabled only when _LIBCPP_STD_VER > 17.

717

Above you used _Tp(0) for zero. I think _Tp(0) is clearer than _Tp{}, and you should use _Tp(0) down here too.

723

IIUC these two operator* implementations are identical except that the C++20 one has an extra block under __libcpp_is_constant_evaluated, and then also replaces copysign with __copysign_constexpr even outside that block.
Would it be possible to combine the operator* implementations through judicious use of #if (for the first diff) and #define _LIBCPP_COMPLEX_COPYSIGN __copysign_constexpr (for the second diff)?

(Also, my ADL senses are on high alert through this entire function, but I guess we expect _Tp always to be a primitive type, so ADL doesn't matter here.)

776

Whatever you did to "unfork" the implementations seems maybe to have been lost between February and late-March. I still see two largely identical implementations of operator/ here (like the two operator*s above).

libcxx/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp

35

These three helper functions can stay returning void; only the test on line 55 needs to return bool.
(I do wish the helpers weren't named the same name as the top-level test.)
This comment applies to many of these test files.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333519)

The existing tests that use ADDITIONAL_COMPILE_FLAGS do it like this:

// REQUIRES: -faligned-allocation
// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation

Could we do something similar here?

I also question the "hpp"-ness of complex_divide_complex.pass.hpp. It certainly shouldn't have a header guard against multiple inclusion; but I don't think its filename should involve either "hpp" (it's not a header) nor ".pass." (the filename isn't intended for parsing by the test runner).
Of course those naming issues all disappear if you are able to do REQUIRES: -fconstexpr-steps=4500000 here.

And of course that issue will disappear if you can figure out how to squeeze some extra "cycles" out of the constexpr algorithm and/or test case. See below.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.hpp

35–36 ↗

(On Diff #333519)

Incidentally, this is a very silly series of (pre-existing) helper functions. I think you could take this suggested edit and then delete lines 24-30.

This comment applies to many of these tests.

49 ↗

(On Diff #333519)

I wonder whether the repeated calculation of classify is driving up your constexpr "cycle count"; maybe it could make sense to put at the top of this function

int classification[N];
for (unsigned i=0; i < N; ++i)
  classification[i] = classify(testcases[i]);

You're still doing O(N^2) divisions, though, which is probably the more salient problem, and harder to work around. :P

libcxx/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp

32

This entire test could be

assert(+std::complex<T>(1.5, -2.5) == std::complex<T>(1.5, -2.5));
assert(+std::complex<T>(-1.5, 2.5) == std::complex<T>(-1.5, 2.5));
return true;

and ta-da, we've more than doubled our test coverage. :P

[curdeius]

There's something fishy with my rebase.

[curdeius]

Fix rebase. Apply some review comments.

• Revert whitespace changes.
• Use numeric_limits.
• Use _Tp(0).

[curdeius]

• Simplify tests (mainly helper functions).

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333519)

Using REQUIRES as you suggest would disable the tests for gcc... And I'm not sure we want this.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.hpp

49 ↗

(On Diff #333519)

Yeah, computing the result of classify once does drive the count down... it's almost ok for the multiplication (1.7M and the default clang's limit is 1M).
But it's still at 3.5M for the division.

I'm all ears if anyone has an idea how to remove this ugly .hpp hack (which only purpose is to pass -fconstexpr-steps=N to clang, and to clang only).
What I'd like is to do something like ADDITIONAL_COMPILE_FLAGS: (apple-clang || clang) -fconstexpr-steps=N or whatever else that does this.
I've tried different lit magic, but to no avail.

[• Quuxplusone]

Looks like your new rebase succeeded in preserving the "unforked" implementations of operator* and operator/. They LGTM code-wise now.
No comment on the math part. It seems like complex_times_complex.pass.cpp does a pretty thorough job of testing its behavior, though, so I trust it.

libcxx/include/complex

708

My impression is that you don't need these dangling elses (lines 739, 750, 777) for any C++ reason (like, the else on line 739 is not saving you from having to resolve and instantiate fmax on line 741). Do they improve codegen? If not, I say eliminate them — splitting unbraced control-flow structures across #if/#endif in this way is not-good. (Consider what happens if you replace line 741 with two lines of code, for example.)

[curdeius]

• Get rid of dangling "else"s.

libcxx/include/complex

708

Good catch. Eliminated.

[curdeius]

libcxx/include/complex

723

Concerning ADL, it's unspecified by the standard what happens if _Tp is other than float, double, long double. Even less if it's a non-primitive type :).

[curdeius]

Friendly ping.

[danilaml]

ping?

[ldionne]

Sorry for sitting on this for so long. Let's push this through now.

libcxx/include/complex

585

We already jump through some hoops in <math.h> to provide copysign. Would it make sense to try and unify those in some way? Maybe create a __copysign function that is constexpr whenever it can be, and then call that from copysign. Here, we'd call __copysign directly, which has the right constexpr-ness. WDYT? I'm trying to avoid proliferating helper functions that might be useful elsewhere in just this header, since it means we'll reinvent the wheel in the future eventually.

Also, I don't understand why we're guarding the use of the builtin on _LIBCPP_STD_VER and not __has_builtin.

Same comment applies to other general functions below like fabs & friends. I think it may be a good idea to tackle those as a separate patch, then this patch would be a lot simpler.

594

I think we can remove the #if _LIBCPP_STD_VER > 17 check here. In C++ <= 17, __libcpp_is_constant_evaluated() will just return false, so this if will never be entered (but it still needs to parse).

Also, I believe a comment saying something like "catch all corner cases that would otherwise cause invalid operations if evaluated in a constant expression" wouldn't hurt. This applies here and everywhere else where the same pattern appears.

libcxx/test/std/numerics/complex.number/cases.h

214

We can't use builtins like that in the tests unless we know all supported compilers do support that builtin. Is it the case?

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

I'm quite worried by the need to add this. It means that if we somehow went crazy in the implementation and used a huge number of steps to implement the functionality, we wouldn't catch it with the tests. I'd like to suggest something like this to remove the need to pass -fconstexpr-steps:

// Helper to avoid blowing the number of steps in constexpr
template <typename F>
TEST_CONSTEXPR void chunk(std::size_t N, F f) {
  for (std::size_t i = (N/5) * 0; i != (N/5) * 1; ++i) f(i);
  for (std::size_t i = (N/5) * 1; i != (N/5) * 2; ++i) f(i);
  for (std::size_t i = (N/5) * 2; i != (N/5) * 3; ++i) f(i);
  for (std::size_t i = (N/5) * 3; i != (N/5) * 4; ++i) f(i);
  for (std::size_t i = (N/5) * 4; i != N;         ++i) f(i);
}

This is just an idea, and it's untested code, but basically I think we could add a generic helper to help us chunk large ranges into several for loops instead of one giant loop. Then we'd use it something like

TEST_CONSTEXPR_CXX20
bool test_edges() {
  const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
  int classification[N];
  for (unsigned i=0; i < N; ++i)
    classification[i] = classify(testcases[i]);

  chunk(N, [](int i) {
    for (int j = 0; j != N; ++j) {
      std::complex<double> r = testcases[i] / testcases[j];
      switch (classification[i]) {
        ...
      };
    }
  });
}

[curdeius]

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

I'm not sure I understand what you propose.
The fact that we go over the max. constexpr steps, is because of static_assert(test_edges());.
Which is a single constexpr expression to compute.
And so, even splitting up testcases to 20 pieces still hits the limit on clang (obviously with the default constexpr-steps limit).
It has as well a disadvantage of reducing the test coverage.

On the other hand, I agree that all this file splitting is a burden.
Would it be doable to have sth like // ADDITIONAL_COMPILE_FLAGS_IF_SUPPORTED: -fconstexpr-steps=3500000?

[ldionne]

libcxx/docs/Cxx2aStatusPaperStatus.csv

8 ↗

(On Diff #333776)

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

Hmmmmm, yeah, I guess my suggestion was quite silly in retrospect. I didn't realize the constexpr step limit was on the overall constexpr evaluation, but that's the only thing that makes sense now that I think of it. Let's take this discussion to D106798.

[philnik]

Commandeering to finish this, since it's been laying around for over a year and it seems like it's almost finished.

libcxx/include/complex

585

We already jump through some hoops in <math.h> to provide copysign. Would it make sense to try and unify those in some way? Maybe create a __copysign function that is constexpr whenever it can be, and then call that from copysign. Here, we'd call __copysign directly, which has the right constexpr-ness. WDYT? I'm trying to avoid proliferating helper functions that might be useful elsewhere in just this header, since it means we'll reinvent the wheel in the future eventually.

Also, I don't understand why we're guarding the use of the builtin on _LIBCPP_STD_VER and not __has_builtin.

Same comment applies to other general functions below like fabs & friends. I think it may be a good idea to tackle those as a separate patch, then this patch would be a lot simpler.

[philnik]

• Rebase
• Address comments

libcxx/include/complex

585

I think with the refactoring of math.h this comment doesn't apply anymore.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

Doesn't apply anymore, since we have mechanisms for increasing constexpr execution limits now.

[philnik]

Remove old status paper

[ldionne]

LGTM w/ green CI and assuming the answer to my question is "yes" (i.e. you didn't slip a change to the non-constexpr code path).

libcxx/include/complex

755–768

Can you confirm that this is the old implementation, we only changed calls to foo to __constexpr_foo?

[philnik]

Try to fix CI

libcxx/include/complex

755–768

Yes.

[philnik]

Next try

[philnik]

Try to fix CI

[philnik]

Try to work around windows bugs

[philnik]

Replace INFINITY with numeric_limits<_Tp>::infinity()

[philnik]

Replace INFINITY and NAN in more places

[jdoerfert]

FWIW, this broke the CUDA buildbots: https://lab.llvm.org/buildbot/#/builders/1/builds/41521

Tag: @tra

[philnik]

In D79555#4038864, @jdoerfert wrote:

FWIW, this broke the CUDA buildbots: https://lab.llvm.org/buildbot/#/builders/1/builds/41521

Tag: @tra

That looks to me like a problem with the cuda wrappers, given that we don't support cuda and we don't have any __host__ or __device__ tags.

[ldionne]

Thanks for the heads up @jdoerfert.

It looks like Clang-cuda is re-defining <complex> in clang/lib/Headers/cuda_wrappers/complex. I'm not sure how that works but that is likely the issue. I'd wait to hear back from the Clang-cuda folks what they think the exact issue is before considering a revert, since it really seems to me like libc++ isn't doing anything wrong.

[tra]

In D79555#4040527, @ldionne wrote:

Thanks for the heads up @jdoerfert.

It looks like Clang-cuda is re-defining <complex> in clang/lib/Headers/cuda_wrappers/complex. I'm not sure how that works but that is likely the issue. I'd wait to hear back from the Clang-cuda folks what they think the exact issue is before considering a revert, since it really seems to me like libc++ isn't doing anything wrong.

I'm aware of the broken bots, just didn't get a chance to deal with them yet.

It's not a libc++ problem, so I don't think we need to revert.

CUDA headers need to grow additional magic to make new libc++ code work on the GPU side. It's unfortunate that we need to play catch up here, but short of introducing CUDA support to libc++ itself, there's not much else we can do.

I'm a bit puzzled why things didn't work, though, as normally CUDA compilation should've treated constexpr functions as __host__ __device__, and should've allowed __constexpr_fmax() etc... It's possible that we may have triggered yet another new corner case.

[tra]

Something like https://reviews.llvm.org/D141555 should unbreak CUDA. It can probably get reduced a bit, as we may not have sufficiently functional builtins on the GPU, so it's still a WIP.

I can't say that I like copy/pasting libc++ code into clang headers. I think it would be great if we could directly add necessary attributes to specific functions when libc++ headers are compiled as CUDA.

libcxx/include/cmath

740

Nit: this should be // !__has_constexpr_builtin(__builtin_logb)

781

Nit: // !has_constexpr_builtin(builtin_scalbln)

[philnik]

In D79555#4045429, @tra wrote:

CUDA headers need to grow additional magic to make new libc++ code work on the GPU side. It's unfortunate that we need to play catch up here, but short of introducing CUDA support to libc++ itself, there's not much else we can do.

If you're interested in doing that you can post an RFC and tell us what would be required for that.

Closing this, since it doesn't seem to be a libc++ problem.

libcxx/include/cmath

781

Thanks! Fixed in 5d9ef6ec3f13e9ca865b25c3e068f2846ff71fa1.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_bounded_array_traits``                ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            ``202002L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_algorithms``                ``201806L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_complex``                   *unimplemented*
+    ``__cpp_lib_constexpr_complex``                   ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_functional``                ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_iterator``                  ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_memory``                    ``201811L``

libcxx/docs/ReleaseNotes.rst

 - P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
   ``from_chars`` for Integral Types in ``<charconv>`` Header
 - P0220R1 - Adopt Library Fundamentals V1 TS Components for C++17
 - P0482R6 - char8_t: A type for UTF-8 characters and strings
 - P2438R2 - ``std::string::substr() &&``
 - P0600R1 - ``nodiscard`` in the library
 - P0339R6 - ``polymorphic_allocator<>`` as a vocabulary type
 - P1169R4 - ``static operator()``
+- P0415R1 - ``constexpr`` for ``std::complex``
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

libcxx/docs/Status/Cxx20Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version","Labels"
 "`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
 "`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","|Complete|","15.0"
 "","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
 "`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
-"`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|In Progress|","7.0"
+"`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|Complete|","16.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
 "`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
 "`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"
 "`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|Complete|","16.0"
 "`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","|Complete|","12.0"
 "`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"
 "`P0718R2 <https://wg21.link/P0718R2>`__","LWG","Atomic shared_ptr","Albuquerque","",""
 "`P0767R1 <https://wg21.link/P0767R1>`__","CWG","Deprecate POD","Albuquerque","|Complete|","7.0"

libcxx/include/__config

 #  ifndef __has_feature
 #    define __has_feature(__x) 0
 #  endif
 
 #  ifndef __has_cpp_attribute
 #    define __has_cpp_attribute(__x) 0
 #  endif
 
+#  ifndef __has_constexpr_builtin
+#    define __has_constexpr_builtin(x) 0
+#  endif
+
 // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 // the compiler and '1' otherwise.
 #  ifndef __is_identifier
 #    define __is_identifier(__x) 1
 #  endif
 
 #  ifndef __has_declspec_attribute
 #    define __has_declspec_attribute(__x) 0

libcxx/include/cmath

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_floating_point.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
 #include <version>
 
 #include <math.h>
 
 #ifndef _LIBCPP_MATH_H

 #endif
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 __constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT
 {
-    return std::isfinite(__lcpp_x);
+    return __builtin_isfinite(__lcpp_x);
+}
+
+_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI float __constexpr_copysign(float __x, float __y) _NOEXCEPT {
+    return __builtin_copysignf(__x, __y);
+}
+
+_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI double __constexpr_copysign(double __x, double __y) _NOEXCEPT {
+    return __builtin_copysign(__x, __y);
+}
+
+_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI long double
+__constexpr_copysign(long double __x, long double __y) _NOEXCEPT {
+    return __builtin_copysignl(__x, __y);
+}
+
+template <class _A1, class _A2>
+_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI
+    typename std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value,
+                                std::__promote<_A1, _A2> >::type
+    __constexpr_copysign(_A1 __x, _A2 __y) _NOEXCEPT {
+    typedef typename std::__promote<_A1, _A2>::type __result_type;
+    static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), "");
+    return __builtin_copysign((__result_type)__x, (__result_type)__y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float __constexpr_fabs(float __x) _NOEXCEPT {
+    return __builtin_fabsf(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double __constexpr_fabs(double __x) _NOEXCEPT {
+    return __builtin_fabs(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double __constexpr_fabs(long double __x) _NOEXCEPT {
+    return __builtin_fabsl(__x);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double __constexpr_fabs(_Tp __x) _NOEXCEPT {
+    return __builtin_fabs(static_cast<double>(__x));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 float __constexpr_fmax(float __x, float __y) _NOEXCEPT {
+#if !__has_constexpr_builtin(__builtin_fmaxf)
+  if (__libcpp_is_constant_evaluated()) {
+    if (std::__constexpr_isnan(__x))
+      return __y;
+    if (std::__constexpr_isnan(__y))
+      return __x;
+    return __x < __y ? __y : __x;
+  }
+#endif
+  return __builtin_fmaxf(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 double __constexpr_fmax(double __x, double __y) _NOEXCEPT {
+#if !__has_constexpr_builtin(__builtin_fmax)
+  if (__libcpp_is_constant_evaluated()) {
+    if (std::__constexpr_isnan(__x))
+      return __y;
+    if (std::__constexpr_isnan(__y))
+      return __x;
+    return __x < __y ? __y : __x;
+  }
+#endif
+  return __builtin_fmax(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 long double
+__constexpr_fmax(long double __x, long double __y) _NOEXCEPT {
+#if !__has_constexpr_builtin(__builtin_fmaxl)
+  if (__libcpp_is_constant_evaluated()) {
+    if (std::__constexpr_isnan(__x))
+      return __y;
+    if (std::__constexpr_isnan(__y))
+      return __x;
+    return __x < __y ? __y : __x;
+  }
+#endif
+  return __builtin_fmaxl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __promote<_Tp, _Up>::type
+__constexpr_fmax(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::__constexpr_fmax(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+template <class _Tp>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __constexpr_logb(_Tp __x) {
+#if !__has_constexpr_builtin(__builtin_logb)
+  if (__libcpp_is_constant_evaluated()) {
+    if (__x == _Tp(0)) {
+      // raise FE_DIVBYZERO
+      return -numeric_limits<_Tp>::infinity();
+    }
+
+    if (std::__constexpr_isinf(__x))
+      return numeric_limits<_Tp>::infinity();
+
+    if (std::__constexpr_isnan(__x))
+      return numeric_limits<_Tp>::quiet_NaN();
+
+    __x = std::__constexpr_fabs(__x);
+    unsigned long long __exp = 0;
+    while (__x >= numeric_limits<_Tp>::radix) {
+      __x /= numeric_limits<_Tp>::radix;
+      __exp += 1;
+    }
+    return _Tp(__exp);
+  }
+#endif // _LIBCPP_STD_VER > 17
+  return __builtin_logb(__x);
+}
+
+template <class _Tp>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp __constexpr_scalbn(_Tp __x, int __exp) {
+#if !__has_constexpr_builtin(__builtin_scalbln)
+  if (__libcpp_is_constant_evaluated()) {
+    if (__x == _Tp(0))
+      return __x;
+
+    if (std::__constexpr_isinf(__x))
+      return __x;
+
+    if (__exp == _Tp(0))
+      return __x;
+
+    if (std::__constexpr_isnan(__x))
+      return numeric_limits<_Tp>::quiet_NaN();
+
+    _Tp __mult(1);
+    if (__exp > 0) {
+      __mult = numeric_limits<_Tp>::radix;
+      --__exp;
+    } else {
+      ++__exp;
+      __exp = -__exp;
+      __mult /= numeric_limits<_Tp>::radix;
+    }
+
+    while (__exp > 0) {
+      if (!(__exp & 1)) {
+        __mult *= __mult;
+        __exp >>= 1;
+      } else {
+        __x *= __mult;
+        --__exp;
+      }
+    }
+    return __x;
+  }
+#endif // _LIBCPP_STD_VER > 17
+  return __builtin_scalbn(__x, __exp);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <typename _Fp>
 _LIBCPP_HIDE_FROM_ABI constexpr
 _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
     if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
         return __t * __b + (1 - __t) * __a;

libcxx/include/complex

public:
 
     complex(const T& re = T(), const T& im = T()); // constexpr in C++14
     complex(const complex&);  // constexpr in C++14
     template<class X> complex(const complex<X>&);  // constexpr in C++14
 
     T real() const; // constexpr in C++14
     T imag() const; // constexpr in C++14
 
-    void real(T);
-    void imag(T);
+    void real(T); // constexpr in C++20
+    void imag(T); // constexpr in C++20
 
-    complex<T>& operator= (const T&);
-    complex<T>& operator+=(const T&);
-    complex<T>& operator-=(const T&);
-    complex<T>& operator*=(const T&);
-    complex<T>& operator/=(const T&);
-
-    complex& operator=(const complex&);
-    template<class X> complex<T>& operator= (const complex<X>&);
-    template<class X> complex<T>& operator+=(const complex<X>&);
-    template<class X> complex<T>& operator-=(const complex<X>&);
-    template<class X> complex<T>& operator*=(const complex<X>&);
-    template<class X> complex<T>& operator/=(const complex<X>&);
+    complex<T>& operator= (const T&); // constexpr in C++20
+    complex<T>& operator+=(const T&); // constexpr in C++20
+    complex<T>& operator-=(const T&); // constexpr in C++20
+    complex<T>& operator*=(const T&); // constexpr in C++20
+    complex<T>& operator/=(const T&); // constexpr in C++20
+
+    complex& operator=(const complex&); // constexpr in C++20
+    template<class X> complex<T>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<float>
 {
 public:
     typedef float value_type;
 
     constexpr complex(float re = 0.0f, float im = 0.0f);
     explicit constexpr complex(const complex<double>&);
     explicit constexpr complex(const complex<long double>&);
 
     constexpr float real() const;
-    void real(float);
+    void real(float); // constexpr in C++20
     constexpr float imag() const;
-    void imag(float);
+    void imag(float); // constexpr in C++20
 
-    complex<float>& operator= (float);
-    complex<float>& operator+=(float);
-    complex<float>& operator-=(float);
-    complex<float>& operator*=(float);
-    complex<float>& operator/=(float);
-
-    complex<float>& operator=(const complex<float>&);
-    template<class X> complex<float>& operator= (const complex<X>&);
-    template<class X> complex<float>& operator+=(const complex<X>&);
-    template<class X> complex<float>& operator-=(const complex<X>&);
-    template<class X> complex<float>& operator*=(const complex<X>&);
-    template<class X> complex<float>& operator/=(const complex<X>&);
+    complex<float>& operator= (float); // constexpr in C++20
+    complex<float>& operator+=(float); // constexpr in C++20
+    complex<float>& operator-=(float); // constexpr in C++20
+    complex<float>& operator*=(float); // constexpr in C++20
+    complex<float>& operator/=(float); // constexpr in C++20
+
+    complex<float>& operator=(const complex<float>&); // constexpr in C++20
+    template<class X> complex<float>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<double>
 {
 public:
     typedef double value_type;
 
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
     explicit constexpr complex(const complex<long double>&);
 
     constexpr double real() const;
-    void real(double);
+    void real(double); // constexpr in C++20
     constexpr double imag() const;
-    void imag(double);
+    void imag(double); // constexpr in C++20
 
-    complex<double>& operator= (double);
-    complex<double>& operator+=(double);
-    complex<double>& operator-=(double);
-    complex<double>& operator*=(double);
-    complex<double>& operator/=(double);
-    complex<double>& operator=(const complex<double>&);
-
-    template<class X> complex<double>& operator= (const complex<X>&);
-    template<class X> complex<double>& operator+=(const complex<X>&);
-    template<class X> complex<double>& operator-=(const complex<X>&);
-    template<class X> complex<double>& operator*=(const complex<X>&);
-    template<class X> complex<double>& operator/=(const complex<X>&);
+    complex<double>& operator= (double); // constexpr in C++20
+    complex<double>& operator+=(double); // constexpr in C++20
+    complex<double>& operator-=(double); // constexpr in C++20
+    complex<double>& operator*=(double); // constexpr in C++20
+    complex<double>& operator/=(double); // constexpr in C++20
+    complex<double>& operator=(const complex<double>&); // constexpr in C++20
+
+    template<class X> complex<double>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<long double>
 {
 public:
     typedef long double value_type;
 
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
 
     constexpr long double real() const;
-    void real(long double);
+    void real(long double); // constexpr in C++20
     constexpr long double imag() const;
-    void imag(long double);
+    void imag(long double); // constexpr in C++20
 
-    complex<long double>& operator=(const complex<long double>&);
-    complex<long double>& operator= (long double);
-    complex<long double>& operator+=(long double);
-    complex<long double>& operator-=(long double);
-    complex<long double>& operator*=(long double);
-    complex<long double>& operator/=(long double);
-
-    template<class X> complex<long double>& operator= (const complex<X>&);
-    template<class X> complex<long double>& operator+=(const complex<X>&);
-    template<class X> complex<long double>& operator-=(const complex<X>&);
-    template<class X> complex<long double>& operator*=(const complex<X>&);
-    template<class X> complex<long double>& operator/=(const complex<X>&);
+    complex<long double>& operator=(const complex<long double>&); // constexpr in C++20
+    complex<long double>& operator= (long double); // constexpr in C++20
+    complex<long double>& operator+=(long double); // constexpr in C++20
+    complex<long double>& operator-=(long double); // constexpr in C++20
+    complex<long double>& operator*=(long double); // constexpr in C++20
+    complex<long double>& operator/=(long double); // constexpr in C++20
+
+    template<class X> complex<long double>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 // 26.3.6 operators:
-template<class T> complex<T> operator+(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator+(const complex<T>&, const T&);
-template<class T> complex<T> operator+(const T&, const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&, const T&);
-template<class T> complex<T> operator-(const T&, const complex<T>&);
-template<class T> complex<T> operator*(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator*(const complex<T>&, const T&);
-template<class T> complex<T> operator*(const T&, const complex<T>&);
-template<class T> complex<T> operator/(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator/(const complex<T>&, const T&);
-template<class T> complex<T> operator/(const T&, const complex<T>&);
-template<class T> complex<T> operator+(const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&);
+template<class T> complex<T> operator+(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator+(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator+(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator-(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator*(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator*(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator*(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator/(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator/(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator/(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator+(const complex<T>&);                    // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&);                    // constexpr in C++20
 template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
 template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
 template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14
 
 template<class T, class charT, class traits>

 template<class T> T abs(const complex<T>&);
 
 template<class T>              T arg(const complex<T>&);
                      long double arg(long double);
                           double arg(double);
 template<Integral T>      double arg(T);
                           float  arg(float);
 
-template<class T>              T norm(const complex<T>&);
-                     long double norm(long double);
-                          double norm(double);
-template<Integral T>      double norm(T);
-                          float  norm(float);
-
-template<class T>      complex<T>           conj(const complex<T>&);
-                       complex<long double> conj(long double);
-                       complex<double>      conj(double);
-template<Integral T>   complex<double>      conj(T);
-                       complex<float>       conj(float);
+template<class T>              T norm(const complex<T>&); // constexpr in C++20
+                     long double norm(long double);       // constexpr in C++20
+                          double norm(double);            // constexpr in C++20
+template<Integral T>      double norm(T);                 // constexpr in C++20
+                          float  norm(float);             // constexpr in C++20
+
+template<class T>      complex<T>           conj(const complex<T>&); // constexpr in C++20
+                       complex<long double> conj(long double);       // constexpr in C++20
+                       complex<double>      conj(double);            // constexpr in C++20
+template<Integral T>   complex<double>      conj(T);                 // constexpr in C++20
+                       complex<float>       conj(float);             // constexpr in C++20
 
 template<class T>    complex<T>           proj(const complex<T>&);
                      complex<long double> proj(long double);
                      complex<double>      proj(double);
 template<Integral T> complex<double>      proj(T);
                      complex<float>       proj(float);
 
 template<class T> complex<T> polar(const T&, const T& = T());

 template<class T> complex<T> tanh (const complex<T>&);
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath>
 #include <iosfwd>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
 
-template<class _Tp> _LIBCPP_HIDE_FROM_ABI complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
-template<class _Tp> _LIBCPP_HIDE_FROM_ABI complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
+template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS complex
 {
 public:
     typedef _Tp value_type;
 private:
     value_type __re_;
     value_type __im_;
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     complex(const value_type& __re = value_type(), const value_type& __im = value_type())
         : __re_(__re), __im_(__im) {}
     template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     complex(const complex<_Xp>& __c)
         : __re_(__c.real()), __im_(__c.imag()) {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const value_type& __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
 template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
public:
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (float __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(float __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(float __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<>
 class _LIBCPP_TEMPLATE_VIS complex<double>
 {
     double __re_;
     double __im_;
 public:
     typedef double value_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
         : __re_(__re), __im_(__im) {}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (double __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(double __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(double __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<>
 class _LIBCPP_TEMPLATE_VIS complex<long double>
 {
     long double __re_;
     long double __im_;
 public:
     typedef long double value_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
         : __re_(__re), __im_(__im) {}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (long double __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(long double __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(long double __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 inline
 _LIBCPP_CONSTEXPR

 inline
 _LIBCPP_CONSTEXPR
 complex<long double>::complex(const complex<double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
 // 26.3.6 operators:
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t += __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator+(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t += __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator+(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__y);
     __t += __x;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t -= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator-(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t -= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator-(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(-__y);
     __t += __x;
     return __t;
 }
 
 template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
 {
     _Tp __a = __z.real();
     _Tp __b = __z.imag();
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
+
+    // Avoid floating point operations that are invalid during constant evaluation
+    if (__libcpp_is_constant_evaluated()) {
+        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
+        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
+        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
+        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
+        bool __z_nan = !__z_inf && (
+            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
+            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
+            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
+        );
+        bool __w_nan = !__w_inf && (
+            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
+            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
+            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
+        );
+        if (__z_nan || __w_nan) {
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
+        }
+        if (__z_inf || __w_inf) {
+            if (__z_zero || __w_zero) {
+                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
+            }
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
+        }
+        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
+        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
+        if (__z_nonzero_nan || __w_nonzero_nan) {
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
+        }
+    }
+
     _Tp __ac = __a * __c;
     _Tp __bd = __b * __d;
     _Tp __ad = __a * __d;
     _Tp __bc = __b * __c;
     _Tp __x = __ac - __bd;
     _Tp __y = __ad + __bc;
     if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
     {
         bool __recalc = false;
         if (std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b))
         {
-            __a = std::copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = std::copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
+            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
             if (std::__constexpr_isnan(__c))
-                __c = std::copysign(_Tp(0), __c);
+                __c = std::__constexpr_copysign(_Tp(0), __c);
             if (std::__constexpr_isnan(__d))
-                __d = std::copysign(_Tp(0), __d);
+                __d = std::__constexpr_copysign(_Tp(0), __d);
             __recalc = true;
         }
         if (std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d))
         {
-            __c = std::copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = std::copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
+            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
             if (std::__constexpr_isnan(__a))
-                __a = std::copysign(_Tp(0), __a);
+                __a = std::__constexpr_copysign(_Tp(0), __a);
             if (std::__constexpr_isnan(__b))
-                __b = std::copysign(_Tp(0), __b);
+                __b = std::__constexpr_copysign(_Tp(0), __b);
             __recalc = true;
         }
         if (!__recalc && (std::__constexpr_isinf(__ac) || std::__constexpr_isinf(__bd) ||
                           std::__constexpr_isinf(__ad) || std::__constexpr_isinf(__bc)))
         {
             if (std::__constexpr_isnan(__a))
-                __a = std::copysign(_Tp(0), __a);
+                __a = std::__constexpr_copysign(_Tp(0), __a);
             if (std::__constexpr_isnan(__b))
-                __b = std::copysign(_Tp(0), __b);
+                __b = std::__constexpr_copysign(_Tp(0), __b);
             if (std::__constexpr_isnan(__c))
-                __c = std::copysign(_Tp(0), __c);
+                __c = std::__constexpr_copysign(_Tp(0), __c);
             if (std::__constexpr_isnan(__d))
-                __d = std::copysign(_Tp(0), __d);
+                __d = std::__constexpr_copysign(_Tp(0), __d);
             __recalc = true;
         }
         if (__recalc)
         {
             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
         }
     }
     return complex<_Tp>(__x, __y);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator*(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t *= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator*(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__y);
     __t *= __x;
     return __t;
 }
 
 template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
 {
     int __ilogbw = 0;
     _Tp __a = __z.real();
     _Tp __b = __z.imag();
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
-    _Tp __logbw = std::logb(std::fmax(std::fabs(__c), std::fabs(__d)));
+    _Tp __logbw = std::__constexpr_logb(std::__constexpr_fmax(std::__constexpr_fabs(__c), std::__constexpr_fabs(__d)));
     if (std::__constexpr_isfinite(__logbw))
     {
         __ilogbw = static_cast<int>(__logbw);
-        __c = std::scalbn(__c, -__ilogbw);
-        __d = std::scalbn(__d, -__ilogbw);
+        __c = std::__constexpr_scalbn(__c, -__ilogbw);
+        __d = std::__constexpr_scalbn(__d, -__ilogbw);
+    }
+
+    // Avoid floating point operations that are invalid during constant evaluation
+    if (__libcpp_is_constant_evaluated()) {
+        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
+        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
+        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
+        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
+        bool __z_nan = !__z_inf && (
+            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
+            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
+            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
+        );
+        bool __w_nan = !__w_inf && (
+            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
+            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
+            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
+        );
+        if ((__z_nan || __w_nan) || (__z_inf && __w_inf)) {
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
+        }
+        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
+        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
+        if (__z_nonzero_nan || __w_nonzero_nan) {
+            if (__w_zero) {
+                return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
+            }
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
+        }
+        if (__w_inf) {
+            return complex<_Tp>(_Tp(0), _Tp(0));
+        }
+        if (__z_inf) {
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
+        }
+        if (__w_zero) {
+            if (__z_zero) {
+                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
             }
+            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
+        }
+    }
+
     _Tp __denom = __c * __c + __d * __d;
-    _Tp __x = std::scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
-    _Tp __y = std::scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+    _Tp __x = std::__constexpr_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+    _Tp __y = std::__constexpr_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
     if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
     {
         if ((__denom == _Tp(0)) && (!std::__constexpr_isnan(__a) || !std::__constexpr_isnan(__b)))
         {
-            __x = std::copysign(_Tp(INFINITY), __c) * __a;
-            __y = std::copysign(_Tp(INFINITY), __c) * __b;
-        }
-        else if ((std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b)) && std::__constexpr_isfinite(__c) && std::__constexpr_isfinite(__d))
-        {
-            __a = std::copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = std::copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
+            __x = std::__constexpr_copysign(_Tp(INFINITY), __c) * __a;
+            __y = std::__constexpr_copysign(_Tp(INFINITY), __c) * __b;
+        } else if ((std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b)) && std::__constexpr_isfinite(__c) &&
+                   std::__constexpr_isfinite(__d)) {
+            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
-        }
-        else if (std::__constexpr_isinf(__logbw) && __logbw > _Tp(0) && std::__constexpr_isfinite(__a) && std::__constexpr_isfinite(__b))
-        {
-            __c = std::copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = std::copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
+        } else if (std::__constexpr_isinf(__logbw) && __logbw > _Tp(0) && std::__constexpr_isfinite(__a) &&
+                   std::__constexpr_isfinite(__b)) {
+            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
             __x = _Tp(0) * (__a * __c + __b * __d);
             __y = _Tp(0) * (__b * __c - __a * __d);
         }
     }
     return complex<_Tp>(__x, __y);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator/(const complex<_Tp>& __x, const _Tp& __y)
 {
     return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator/(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t /= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator+(const complex<_Tp>& __x)
 {
     return __x;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 operator-(const complex<_Tp>& __x)
 {
     return complex<_Tp>(-__x.real(), -__x.imag());
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14

 arg(_Tp __re)
 {
     return std::atan2f(0.F, __re);
 }
 
 // norm
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 _Tp
 norm(const complex<_Tp>& __c)
 {
     if (std::__constexpr_isinf(__c.real()))
         return std::abs(__c.real());
     if (std::__constexpr_isinf(__c.imag()))
         return std::abs(__c.imag());
     return __c.real() * __c.real() + __c.imag() * __c.imag();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 norm(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
     return static_cast<_ValueType>(__re) * __re;
 }
 
 // conj
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 complex<_Tp>
 conj(const complex<_Tp>& __c)
 {
     return complex<_Tp>(__c.real(), -__c.imag());
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 conj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
     return _ComplexType(__re);
 }
 
 

libcxx/include/math.h

 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cbrt(_A1 __x) _NOEXCEPT {return __builtin_cbrt((double)__x);}
 
 // copysign
 
-_LIBCPP_CONSTEXPR
-inline _LIBCPP_HIDE_FROM_ABI float __libcpp_copysign(float __x, float __y) _NOEXCEPT {
-  return __builtin_copysignf(__x, __y);
-}
-
-_LIBCPP_CONSTEXPR
-inline _LIBCPP_HIDE_FROM_ABI double __libcpp_copysign(double __x, double __y) _NOEXCEPT {
-  return __builtin_copysign(__x, __y);
-}
-
-_LIBCPP_CONSTEXPR
-inline _LIBCPP_HIDE_FROM_ABI long double __libcpp_copysign(long double __x, long double __y) _NOEXCEPT {
-  return __builtin_copysignl(__x, __y);
-}
-
-template <class _A1, class _A2>
-_LIBCPP_CONSTEXPR
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-__libcpp_copysign(_A1 __x, _A2 __y) _NOEXCEPT {
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return __builtin_copysign((__result_type)__x, (__result_type)__y);
-}
-
 inline _LIBCPP_HIDE_FROM_ABI float copysign(float __x, float __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return ::__builtin_copysignf(__x, __y);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return ::__builtin_copysignl(__x, __y);
 }
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     std::__promote<_A1, _A2>
 >::type
     copysign(_A1 __x, _A2 __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return ::__builtin_copysign(__x, __y);
 }
 
 // erf
 
 inline _LIBCPP_HIDE_FROM_ABI float       erf(float __x) _NOEXCEPT       {return __builtin_erff(__x);}
 
 template <class = int>
 _LIBCPP_HIDE_FROM_ABI double erf(double __x) _NOEXCEPT {

libcxx/include/version

 # define __cpp_lib_bit_cast                             201806L
 // # define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #   define __cpp_lib_char8_t                            201907L
 # endif
 # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L
-// # define __cpp_lib_constexpr_complex                    201711L
+# define __cpp_lib_constexpr_complex                    201711L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 # define __cpp_lib_constexpr_functional                 201907L
 # define __cpp_lib_constexpr_iterator                   201811L
 # define __cpp_lib_constexpr_memory                     201811L
 # define __cpp_lib_constexpr_numeric                    201911L
 # define __cpp_lib_constexpr_string                     201907L
 # define __cpp_lib_constexpr_string_view                201811L
 # define __cpp_lib_constexpr_tuple                      201811L

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

 
 # ifndef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should be defined in c++20"
 # endif
 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_complex != 201711L
-#     error "__cpp_lib_constexpr_complex should have the value 201711L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++20"
+# endif
 
 #elif TEST_STD_VER > 20
 
 # ifndef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should be defined in c++2b"
 # endif
 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_complex != 201711L
-#     error "__cpp_lib_constexpr_complex should have the value 201711L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++2b"
+# endif
 
 #endif // TEST_STD_VER > 20
 

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

 # ifdef __cpp_lib_constexpr_charconv
 #   error "__cpp_lib_constexpr_charconv should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_constexpr_cmath
 #   error "__cpp_lib_constexpr_cmath should not be defined before c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_complex != 201711L
-#     error "__cpp_lib_constexpr_complex should have the value 201711L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++20"
+# endif
 
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++20"
 # endif
 

 #     error "__cpp_lib_constexpr_cmath should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_constexpr_cmath
 #     error "__cpp_lib_constexpr_cmath should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_complex != 201711L
-#     error "__cpp_lib_constexpr_complex should have the value 201711L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_complex
-#     error "__cpp_lib_constexpr_complex should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++2b"
+# endif
 
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2b"
 # endif
 

libcxx/test/std/numerics/complex.number/cases.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // test cases
 
 #ifndef CASES_H
 #define CASES_H
 
-#include <complex>
 #include <cassert>
+#include <complex>
+#include <type_traits>
 
-const std::complex<double> testcases[] =
+#include "test_macros.h"
+
+TEST_CONSTEXPR_CXX20 const std::complex<double> testcases[] =
 {
     std::complex<double>( 1.e-6,  1.e-6),
     std::complex<double>(-1.e-6,  1.e-6),
     std::complex<double>(-1.e-6, -1.e-6),
     std::complex<double>( 1.e-6, -1.e-6),
 
     std::complex<double>( 1.e+6,  1.e-6),
     std::complex<double>(-1.e+6,  1.e-6),
TEST_CONSTEXPR_CXX20 const std::complex<double> testcases[] =
     std::complex<double>( 1.e-6, -0),
     std::complex<double>( 1.e+6, -0),
     std::complex<double>(-1.e+6, -0),
     std::complex<double>(-1.e-6,  0),
     std::complex<double>( 1.e-6,  0),
     std::complex<double>( 1.e+6,  0),
     std::complex<double>(-1.e+6,  0),
 
-    std::complex<double>(NAN, NAN),
-    std::complex<double>(-INFINITY, NAN),
-    std::complex<double>(-2, NAN),
-    std::complex<double>(-1, NAN),
-    std::complex<double>(-0.5, NAN),
-    std::complex<double>(-0., NAN),
-    std::complex<double>(+0., NAN),
-    std::complex<double>(0.5, NAN),
-    std::complex<double>(1, NAN),
-    std::complex<double>(2, NAN),
-    std::complex<double>(INFINITY, NAN),
-
-    std::complex<double>(NAN, -INFINITY),
-    std::complex<double>(-INFINITY, -INFINITY),
-    std::complex<double>(-2, -INFINITY),
-    std::complex<double>(-1, -INFINITY),
-    std::complex<double>(-0.5, -INFINITY),
-    std::complex<double>(-0., -INFINITY),
-    std::complex<double>(+0., -INFINITY),
-    std::complex<double>(0.5, -INFINITY),
-    std::complex<double>(1, -INFINITY),
-    std::complex<double>(2, -INFINITY),
-    std::complex<double>(INFINITY, -INFINITY),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(-2, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(-1, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(-0.5, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(-0., std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(+0., std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(0.5, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(1, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(2, std::numeric_limits<double>::quiet_NaN()),
+    std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
+
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
+    std::complex<double>(-2, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(-1, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(-0.5, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(-0., -std::numeric_limits<double>::infinity()),
+    std::complex<double>(+0., -std::numeric_limits<double>::infinity()),
+    std::complex<double>(0.5, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(1, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(2, -std::numeric_limits<double>::infinity()),
+    std::complex<double>(std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
 
-    std::complex<double>(NAN, -2),
-    std::complex<double>(-INFINITY, -2),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -2),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), -2),
     std::complex<double>(-2, -2),
     std::complex<double>(-1, -2),
     std::complex<double>(-0.5, -2),
     std::complex<double>(-0., -2),
     std::complex<double>(+0., -2),
     std::complex<double>(0.5, -2),
     std::complex<double>(1, -2),
     std::complex<double>(2, -2),
-    std::complex<double>(INFINITY, -2),
+    std::complex<double>(std::numeric_limits<double>::infinity(), -2),
 
-    std::complex<double>(NAN, -1),
-    std::complex<double>(-INFINITY, -1),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -1),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), -1),
     std::complex<double>(-2, -1),
     std::complex<double>(-1, -1),
     std::complex<double>(-0.5, -1),
     std::complex<double>(-0., -1),
     std::complex<double>(+0., -1),
     std::complex<double>(0.5, -1),
     std::complex<double>(1, -1),
     std::complex<double>(2, -1),
-    std::complex<double>(INFINITY, -1),
+    std::complex<double>(std::numeric_limits<double>::infinity(), -1),
 
-    std::complex<double>(NAN, -0.5),
-    std::complex<double>(-INFINITY, -0.5),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.5),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), -0.5),
     std::complex<double>(-2, -0.5),
     std::complex<double>(-1, -0.5),
     std::complex<double>(-0.5, -0.5),
     std::complex<double>(-0., -0.5),
     std::complex<double>(+0., -0.5),
     std::complex<double>(0.5, -0.5),
     std::complex<double>(1, -0.5),
     std::complex<double>(2, -0.5),
-    std::complex<double>(INFINITY, -0.5),
+    std::complex<double>(std::numeric_limits<double>::infinity(), -0.5),
 
-    std::complex<double>(NAN, -0.),
-    std::complex<double>(-INFINITY, -0.),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), -0.),
     std::complex<double>(-2, -0.),
     std::complex<double>(-1, -0.),
     std::complex<double>(-0.5, -0.),
     std::complex<double>(-0., -0.),
     std::complex<double>(+0., -0.),
     std::complex<double>(0.5, -0.),
     std::complex<double>(1, -0.),
     std::complex<double>(2, -0.),
-    std::complex<double>(INFINITY, -0.),
+    std::complex<double>(std::numeric_limits<double>::infinity(), -0.),
 
-    std::complex<double>(NAN, +0.),
-    std::complex<double>(-INFINITY, +0.),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), +0.),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), +0.),
     std::complex<double>(-2, +0.),
     std::complex<double>(-1, +0.),
     std::complex<double>(-0.5, +0.),
     std::complex<double>(-0., +0.),
     std::complex<double>(+0., +0.),
     std::complex<double>(0.5, +0.),
     std::complex<double>(1, +0.),
     std::complex<double>(2, +0.),
-    std::complex<double>(INFINITY, +0.),
+    std::complex<double>(std::numeric_limits<double>::infinity(), +0.),
 
-    std::complex<double>(NAN, 0.5),
-    std::complex<double>(-INFINITY, 0.5),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 0.5),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), 0.5),
     std::complex<double>(-2, 0.5),
     std::complex<double>(-1, 0.5),
     std::complex<double>(-0.5, 0.5),
     std::complex<double>(-0., 0.5),
     std::complex<double>(+0., 0.5),
     std::complex<double>(0.5, 0.5),
     std::complex<double>(1, 0.5),
     std::complex<double>(2, 0.5),
-    std::complex<double>(INFINITY, 0.5),
+    std::complex<double>(std::numeric_limits<double>::infinity(), 0.5),
 
-    std::complex<double>(NAN, 1),
-    std::complex<double>(-INFINITY, 1),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 1),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), 1),
     std::complex<double>(-2, 1),
     std::complex<double>(-1, 1),
     std::complex<double>(-0.5, 1),
     std::complex<double>(-0., 1),
     std::complex<double>(+0., 1),
     std::complex<double>(0.5, 1),
     std::complex<double>(1, 1),
     std::complex<double>(2, 1),
-    std::complex<double>(INFINITY, 1),
+    std::complex<double>(std::numeric_limits<double>::infinity(), 1),
 
-    std::complex<double>(NAN, 2),
-    std::complex<double>(-INFINITY, 2),
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 2),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), 2),
     std::complex<double>(-2, 2),
     std::complex<double>(-1, 2),
     std::complex<double>(-0.5, 2),
     std::complex<double>(-0., 2),
     std::complex<double>(+0., 2),
     std::complex<double>(0.5, 2),
     std::complex<double>(1, 2),
     std::complex<double>(2, 2),
-    std::complex<double>(INFINITY, 2),
+    std::complex<double>(std::numeric_limits<double>::infinity(), 2),
 
-    std::complex<double>(NAN, INFINITY),
-    std::complex<double>(-INFINITY, INFINITY),
-    std::complex<double>(-2, INFINITY),
-    std::complex<double>(-1, INFINITY),
-    std::complex<double>(-0.5, INFINITY),
-    std::complex<double>(-0., INFINITY),
-    std::complex<double>(+0., INFINITY),
-    std::complex<double>(0.5, INFINITY),
-    std::complex<double>(1, INFINITY),
-    std::complex<double>(2, INFINITY),
-    std::complex<double>(INFINITY, INFINITY)
+    std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::infinity()),
+    std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()),
+    std::complex<double>(-2, std::numeric_limits<double>::infinity()),
+    std::complex<double>(-1, std::numeric_limits<double>::infinity()),
+    std::complex<double>(-0.5, std::numeric_limits<double>::infinity()),
+    std::complex<double>(-0., std::numeric_limits<double>::infinity()),
+    std::complex<double>(+0., std::numeric_limits<double>::infinity()),
+    std::complex<double>(0.5, std::numeric_limits<double>::infinity()),
+    std::complex<double>(1, std::numeric_limits<double>::infinity()),
+    std::complex<double>(2, std::numeric_limits<double>::infinity()),
+    std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity())
 };
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
+template <class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
+TEST_CONSTEXPR_CXX20 bool test_isinf(T v) {
+    return v == std::numeric_limits<T>::infinity() || v == -std::numeric_limits<T>::infinity();
+}
+
+template <class T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
+TEST_CONSTEXPR_CXX20 bool test_isnan(T v) {
+    return v != v;
+}
+
 template <class T>
+TEST_CONSTEXPR_CXX20
 int
 classify(const std::complex<T>& x)
 {
     if (x == std::complex<T>())
         return zero;
-    if (std::isinf(x.real()) || std::isinf(x.imag()))
+    if (test_isinf(x.real()) || test_isinf(x.imag()))
         return inf;
-    if (std::isnan(x.real()) && std::isnan(x.imag()))
+    if (test_isnan(x.real()) && test_isnan(x.imag()))
         return NaN;
-    if (std::isnan(x.real()))
+    if (test_isnan(x.real()))
     {
         if (x.imag() == T(0))
             return NaN;
         return non_zero_nan;
     }
-    if (std::isnan(x.imag()))
+    if (test_isnan(x.imag()))
     {
         if (x.real() == T(0))
             return NaN;
         return non_zero_nan;
     }
     return non_zero;
 }
 

libcxx/test/std/numerics/complex.number/cmplx.over/conj.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// template<class T>      complex<T>           conj(const complex<T>&);
-//                        complex<long double> conj(long double);
-//                        complex<double>      conj(double);
-// template<Integral T>   complex<double>      conj(T);
-//                        complex<float>       conj(float);
+// template<class T>      complex<T>           conj(const complex<T>&); // constexpr in C++20
+//                        complex<long double> conj(long double);       // constexpr in C++20
+//                        complex<double>      conj(double);            // constexpr in C++20
+// template<Integral T>   complex<double>      conj(T);                 // constexpr in C++20
+//                        complex<float>       conj(float);             // constexpr in C++20
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::conj(x)), std::complex<double> >::value), "");
     assert(std::conj(x) == conj(std::complex<double>(x, 0)));
 }
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
     assert(std::conj(x) == conj(std::complex<T>(x, 0)));
 }
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test(T x, typename std::enable_if<!std::is_integral<T>::value &&
                                   !std::is_floating_point<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
     assert(std::conj(x) == conj(std::complex<T>(x, 0)));
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     test<T>(0);
     test<T>(1);
     test<T>(10);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test<int>();
     test<unsigned>();
     test<long long>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test<int>());
+    static_assert(test<unsigned>());
+    static_assert(test<long long>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/cmplx.over/norm.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<Arithmetic T>
 //   T
-//   norm(T x);
+//   norm(T x); // constexpr in C++20
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::norm(x)), double>::value), "");
     assert(std::norm(x) == norm(std::complex<double>(static_cast<double>(x), 0)));
 }
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
 {
     static_assert((std::is_same<decltype(std::norm(x)), T>::value), "");
     assert(std::norm(x) == norm(std::complex<T>(x, 0)));
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     test<T>(0);
     test<T>(1);
     test<T>(10);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test<int>();
     test<unsigned>();
     test<long long>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test<int>());
+    static_assert(test<unsigned>());
+    static_assert(test<long long>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/assignment_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator=(const complex&);
-// template<class X> complex& operator= (const complex<X>&);
+// template<class X> complex& operator= (const complex<X>&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T, class X>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);
     assert(c.imag() == 0);
     std::complex<T> c2(1.5, 2.5);
     c = c2;
     assert(c.real() == 1.5);
     assert(c.imag() == 2.5);
     std::complex<X> c3(3.5, -4.5);
     c = c3;
     assert(c.real() == 3.5);
     assert(c.imag() == -4.5);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float, float>();
     test<float, double>();
     test<float, long double>();
 
     test<double, float>();
     test<double, double>();
     test<double, long double>();
 
     test<long double, float>();
     test<long double, double>();
     test<long double, long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float, float>());
+    static_assert(test<float, double>());
+    static_assert(test<float, long double>());
+
+    static_assert(test<double, float>());
+    static_assert(test<double, double>());
+    static_assert(test<double, long double>());
+
+    static_assert(test<long double, float>());
+    static_assert(test<long double, double>());
+    static_assert(test<long double, long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator= (const T&);
+// complex& operator= (const T&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c = 1.5;
     assert(c.real() == 1.5);
     assert(c.imag() == 0);
     c = -1.5;
     assert(c.real() == -1.5);
     assert(c.imag() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator/=(const complex& rhs);
+// complex& operator/=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c(-4, 7.5);
     const std::complex<T> c2(1.5, 2.5);
     assert(c.real() == -4);
     assert(c.imag() == 7.5);
     c /= c2;
     assert(c.real() == 1.5);
     assert(c.imag() == 2.5);
     c /= c2;
     assert(c.real() == 1);
     assert(c.imag() == 0);
 
     std::complex<T> c3;
 
     c3 = c;
     std::complex<int> ic (1,1);
     c3 /= ic;
-    assert(c3.real() ==  0.5);
+    assert(c3.real() == 0.5);
     assert(c3.imag() == -0.5);
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 /= fc;
-    assert(c3.real() ==  0.5);
+    assert(c3.real() == 0.5);
     assert(c3.imag() == -0.5);
-
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator/=(const T& rhs);
+// complex& operator/=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c(1);
     assert(c.real() == 1);
     assert(c.imag() == 0);
     c /= 0.5;
     assert(c.real() == 2);
     assert(c.imag() == 0);
     c /= 0.5;
     assert(c.real() == 4);
     assert(c.imag() == 0);
     c /= -0.5;
     assert(c.real() == -8);
     assert(c.imag() == 0);
     c.imag(2);
     c /= 0.5;
     assert(c.real() == -16);
     assert(c.imag() == 4);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator-=(const complex& rhs);
+// complex& operator-=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     const std::complex<T> c2(1.5, 2.5);
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c -= c2;
     assert(c.real() == -1.5);
test()
     assert(c3.real() == -4);
     assert(c3.imag() == -6);
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 -= fc;
     assert(c3.real() == -4);
     assert(c3.imag() == -6);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator-=(const T& rhs);
+// complex& operator-=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c -= 1.5;
     assert(c.real() == -1.5);
     assert(c.imag() == 0);
     c -= 1.5;
     assert(c.real() == -3);
     assert(c.imag() == 0);
     c -= -1.5;
     assert(c.real() == -1.5);
     assert(c.imag() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator+=(const complex& rhs);
+// complex& operator+=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     const std::complex<T> c2(1.5, 2.5);
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c += c2;
     assert(c.real() == 1.5);
test()
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 += fc;
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator+=(const T& rhs);
+// complex& operator+=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c += 1.5;
     assert(c.real() == 1.5);
     assert(c.imag() == 0);
     c += 1.5;
     assert(c.real() == 3);
     assert(c.imag() == 0);
     c += -1.5;
     assert(c.real() == 1.5);
     assert(c.imag() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator*=(const complex& rhs);
+// complex& operator*=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c(1);
     const std::complex<T> c2(1.5, 2.5);
     assert(c.real() == 1);
     assert(c.imag() == 0);
     c *= c2;
     assert(c.real() == 1.5);
     assert(c.imag() == 2.5);
     c *= c2;
     assert(c.real() == -4);
     assert(c.imag() == 7.5);
 
     std::complex<T> c3;
 
     c3 = c;
     std::complex<int> ic (1,1);
     c3 *= ic;
     assert(c3.real() == -11.5);
-    assert(c3.imag() ==   3.5);
+    assert(c3.imag() == 3.5);
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 *= fc;
     assert(c3.real() == -11.5);
-    assert(c3.imag() ==   3.5);
+    assert(c3.imag() == 3.5);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator*=(const T& rhs);
+// complex& operator*=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c(1);
     assert(c.real() == 1);
     assert(c.imag() == 0);
     c *= 1.5;
     assert(c.real() == 1.5);
     assert(c.imag() == 0);
     c *= 1.5;
     assert(c.real() == 2.25);
     assert(c.imag() == 0);
     c *= -1.5;
     assert(c.real() == -3.375);
     assert(c.imag() == 0);
     c.imag(2);
     c *= 1.5;
     assert(c.real() == -5.0625);
     assert(c.imag() == 3);
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.members/real_imag.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// void real(T val);
-// void imag(T val);
+// void real(T val); // constexpr in C++20
+// void imag(T val); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     constexpr std::complex<T> c1;
     static_assert(c1.real() == 0, "");
     static_assert(c1.imag() == 0, "");
     constexpr std::complex<T> c2(3);
     static_assert(c2.real() == 3, "");
     static_assert(c2.imag() == 0, "");
     constexpr std::complex<T> c3(3, 4);
     static_assert(c3.real() == 3, "");
     static_assert(c3.imag() == 4, "");
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);
     assert(c.imag() == 0);
     c.real(3.5);
     assert(c.real() == 3.5);
     assert(c.imag() == 0);
     c.imag(4.5);
     assert(c.real() == 3.5);
     assert(c.imag() == 4.5);
     c.real(-4.5);
     assert(c.real() == -4.5);
     assert(c.imag() == 4.5);
     c.imag(-5.5);
     assert(c.real() == -4.5);
     assert(c.imag() == -5.5);
 
-    test_constexpr<T> ();
+    test_constexpr<T>();
+    return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
     test<float>();
     test<double>();
     test<long double>();
-    test_constexpr<int> ();
+    test_constexpr<int>();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const complex<T>& lhs, const complex<T>& rhs);
+//   operator/(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
+
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=5000000
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> lhs(-4.0, 7.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(1.5, 2.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(-4.0, 7.5);
+    const std::complex<T> rhs(1.5, 2.5);
+    assert(lhs / rhs == std::complex<T>(1.5, 2.5));
+    return true;
 }
 
-void test_edges()
+TEST_CONSTEXPR_CXX20
+bool
+test_edges()
 {
-    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
-    for (unsigned i = 0; i < N; ++i)
-    {
-        for (unsigned j = 0; j < N; ++j)
-        {
-            std::complex<double> r = testcases[i] / testcases[j];
-            switch (classify(testcases[i]))
-            {
-            case zero:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == zero);
-                    break;
-                case inf:
-                    assert(classify(r) == zero);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case non_zero:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == non_zero);
-                    break;
-                case inf:
-                    assert(classify(r) == zero);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case inf:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == inf);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case NaN:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case non_zero_nan:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            }
-        }
-    }
+  int classification[N];
+  for (unsigned i=0; i < N; ++i)
+    classification[i] = classify(testcases[i]);
+
+  for (unsigned i = 0; i < N; ++i) {
+    for (unsigned j = 0; j < N; ++j) {
+      switch (classification[i]) {
+        switch (classification[j]) {
+        switch (classification[j]) {
+        switch (classification[j]) {
+        switch (classification[j]) {
+        switch (classification[j]) {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test_edges());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const complex<T>& lhs, const T& rhs);
+//   operator/(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> lhs(-4.0, 7.5);
-    T rhs(2);
-    std::complex<T>   x(-2, 3.75);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(-4.0, 7.5);
+    const T rhs(2);
+    assert(lhs / rhs == std::complex<T>(-2, 3.75));
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp

 //   operator==(const complex<T>& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test_constexpr()
-{
-#if TEST_STD_VER > 11
-    {
-    constexpr std::complex<T> lhs(1.5,  2.5);
-    constexpr std::complex<T> rhs(1.5, -2.5);
-    static_assert( !(lhs == rhs), "");
-    }
-    {
-    constexpr std::complex<T> lhs(1.5, 2.5);
-    constexpr std::complex<T> rhs(1.5, 2.5);
-    static_assert(lhs == rhs, "");
-    }
-#endif
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
     assert( !(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
     assert(lhs == rhs);
     }
-    test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//    test_constexpr<int> ();
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp

 //   operator==(const complex<T>& lhs, const T& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5, 2.5);
     constexpr T rhs(-2.5);
     static_assert(!(lhs == rhs), "");
#if TEST_STD_VER > 11
     constexpr std::complex<T> lhs(1.5, 0);
     constexpr T rhs(1.5);
     static_assert( (lhs == rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(-2.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
     assert( (lhs == rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_minus_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs, const complex<T>& rhs);
+//   operator-(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    std::complex<T> lhs(1.5, 2.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(-2.0, -2.0);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const std::complex<T> rhs(3.5, 4.5);
+    assert(lhs - rhs == std::complex<T>(-2.0, -2.0));
     }
     {
-    std::complex<T> lhs(1.5, -2.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(5.0, -7.0);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, -2.5);
+    const std::complex<T> rhs(-3.5, 4.5);
+    assert(lhs - rhs == std::complex<T>(5.0, -7.0));
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs, const T& rhs);
+//   operator-(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    std::complex<T> lhs(1.5, 2.5);
-    T rhs(3.5);
-    std::complex<T>   x(-2.0, 2.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const T rhs(3.5);
+    assert(lhs - rhs == std::complex<T>(-2.0, 2.5));
     }
     {
-    std::complex<T> lhs(1.5, -2.5);
-    T rhs(-3.5);
-    std::complex<T>   x(5.0, -2.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, -2.5);
+    const T rhs(-3.5);
+    assert(lhs - rhs == std::complex<T>(5.0, -2.5));
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp

 //   operator!=(const complex<T>& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5,  2.5);
     constexpr std::complex<T> rhs(1.5, -2.5);
     static_assert(lhs != rhs, "");
     }
     {
     constexpr std::complex<T> lhs(1.5, 2.5);
     constexpr std::complex<T> rhs(1.5, 2.5);
     static_assert(!(lhs != rhs), "" );
     }
 #endif
 }
 
-
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    std::complex<T> lhs(1.5,  2.5);
-    std::complex<T> rhs(1.5, -2.5);
+    const std::complex<T> lhs(1.5,  2.5);
+    const std::complex<T> rhs(1.5, -2.5);
     assert(lhs != rhs);
     }
     {
-    std::complex<T> lhs(1.5, 2.5);
-    std::complex<T> rhs(1.5, 2.5);
+    const std::complex<T> lhs(1.5, 2.5);
+    const std::complex<T> rhs(1.5, 2.5);
     assert(!(lhs != rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//   test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp

 //   operator!=(const complex<T>& lhs, const T& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5,  2.5);
     constexpr T rhs(-2.5);
     static_assert(lhs != rhs, "");
#if TEST_STD_VER > 11
     constexpr std::complex<T> lhs(1.5, 0);
     constexpr T rhs(1.5);
     static_assert( !(lhs != rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5,  0);
     T rhs(-2.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
     assert( !(lhs != rhs));
     }
 
     test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_plus_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>& lhs, const complex<T>& rhs);
+//   operator+(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    std::complex<T> lhs(1.5, 2.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(5.0, 7.0);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const std::complex<T> rhs(3.5, 4.5);
+    assert(lhs + rhs == std::complex<T>(5.0, 7.0));
     }
     {
-    std::complex<T> lhs(1.5, -2.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(-2.0, 2.0);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, -2.5);
+    const std::complex<T> rhs(-3.5, 4.5);
+    assert(lhs + rhs == std::complex<T>(-2.0, 2.0));
     }
+
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>& lhs, const T& rhs);
+//   operator+(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    std::complex<T> lhs(1.5, 2.5);
-    T rhs(3.5);
-    std::complex<T>   x(5.0, 2.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const T rhs(3.5);
+    assert(lhs + rhs == std::complex<T>(5.0, 2.5));
     }
     {
-    std::complex<T> lhs(1.5, -2.5);
-    T rhs(-3.5);
-    std::complex<T>   x(-2.0, -2.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, -2.5);
+    const T rhs(-3.5);
+    assert(lhs + rhs == std::complex<T>(-2.0, -2.5));
     }
+
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const complex<T>& lhs, const complex<T>& rhs);
+//   operator*(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
+
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=5000000
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> lhs(1.5, 2.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(-4.0, 7.5);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const std::complex<T> rhs(1.5, 2.5);
+    assert(lhs * rhs == std::complex<T>(-4.0, 7.5));
+    return true;
 }
 
 // test edges
 
-void test_edges()
+TEST_CONSTEXPR_CXX20 bool test_edges()
 {
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+    int classification[N];
+    for (unsigned i=0; i < N; ++i)
+        classification[i] = classify(testcases[i]);
+
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
             std::complex<double> r = testcases[i] * testcases[j];
-            switch (classify(testcases[i]))
+            switch (classification[i])
             {
             case zero:
-                switch (classify(testcases[j]))
+                switch (classification[j])
                 {
                 case zero:
-                    assert(classify(r) == zero);
-                    break;
                 case non_zero:
                     assert(classify(r) == zero);
                     break;
                 case inf:
-                    assert(classify(r) == NaN);
-                    break;
                 case NaN:
-                    assert(classify(r) == NaN);
-                    break;
                 case non_zero_nan:
                     assert(classify(r) == NaN);
                     break;
                 }
                 break;
             case non_zero:
-                switch (classify(testcases[j]))
+                switch (classification[j])
                 {
                 case zero:
                     assert(classify(r) == zero);
                     break;
                 case non_zero:
                     assert(classify(r) == non_zero);
                     break;
                 case inf:
                     assert(classify(r) == inf);
                     break;
                 case NaN:
-                    assert(classify(r) == NaN);
-                    break;
                 case non_zero_nan:
                     assert(classify(r) == NaN);
                     break;
                 }
                 break;
             case inf:
-                switch (classify(testcases[j]))
+                switch (classification[j])
                 {
                 case zero:
+                case NaN:
                     assert(classify(r) == NaN);
                     break;
                 case non_zero:
-                    assert(classify(r) == inf);
-                    break;
                 case inf:
-                    assert(classify(r) == inf);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
                 case non_zero_nan:
                     assert(classify(r) == inf);
                     break;
                 }
                 break;
             case NaN:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case non_zero_nan:
-                switch (classify(testcases[j]))
+                switch (classification[j])
                 {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
                 case inf:
                     assert(classify(r) == inf);
                     break;
+                case zero:
+                case non_zero:
                 case NaN:
-                    assert(classify(r) == NaN);
-                    break;
                 case non_zero_nan:
                     assert(classify(r) == NaN);
                     break;
                 }
                 break;
             }
         }
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test_edges());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_times_scalar.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const complex<T>& lhs, const T& rhs);
+//   operator*(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> lhs(1.5, 2.5);
-    T rhs(1.5);
-    std::complex<T>   x(2.25, 3.75);
-    test(lhs, rhs, x);
+    const std::complex<T> lhs(1.5, 2.5);
+    const T rhs(1.5);
+    assert(lhs * rhs == std::complex<T>(2.25, 3.75));
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const T& lhs, const complex<T>& rhs);
+//   operator/(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    T lhs(-8.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(-1.5, 2.5);
-    test(lhs, rhs, x);
+    const T lhs(-8.5);
+    const std::complex<T> rhs(1.5, 2.5);
+    assert(lhs / rhs == std::complex<T>(-1.5, 2.5));
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp

 //   operator==(const T& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr T lhs(-2.5);
     constexpr std::complex<T> rhs(1.5,  2.5);
     static_assert(!(lhs == rhs), "");
#if TEST_STD_VER > 11
     constexpr T lhs(1.5);
     constexpr std::complex<T> rhs(1.5, 0);
     static_assert(lhs == rhs, "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
     assert(!(lhs == rhs));
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
     assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
     assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
     assert(lhs == rhs);
     }
 
     test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int>();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const T& lhs, const complex<T>& rhs);
+//   operator-(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    T lhs(1.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(-2.0, -4.5);
-    test(lhs, rhs, x);
+    const T lhs(1.5);
+    const std::complex<T> rhs(3.5, 4.5);
+    assert(lhs - rhs == std::complex<T>(-2.0, -4.5));
     }
     {
-    T lhs(1.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(5.0, -4.5);
-    test(lhs, rhs, x);
+    const T lhs(1.5);
+    const std::complex<T> rhs(-3.5, 4.5);
+    assert(lhs - rhs == std::complex<T>(5.0, -4.5));
     }
+    return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp

 //   operator!=(const T& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR_CXX20
 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr T lhs(-2.5);
     constexpr std::complex<T> rhs(1.5,  2.5);
     static_assert (lhs != rhs, "");
#if TEST_STD_VER > 11
     constexpr T lhs(1.5);
     constexpr std::complex<T> rhs(1.5, 0);
     static_assert (!(lhs != rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
     assert (lhs != rhs);
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
     assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
     assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
     assert (!(lhs != rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int>();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const T& lhs, const complex<T>& rhs);
+//   operator+(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
     {
-    T lhs(1.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(5.0, 4.5);
-    test(lhs, rhs, x);
+    const T lhs(1.5);
+    const std::complex<T> rhs(3.5, 4.5);
+    assert(lhs + rhs == std::complex<T>(5.0, 4.5));
     }
     {
-    T lhs(1.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(-2.0, 4.5);
-    test(lhs, rhs, x);
+    const T lhs(1.5);
+    const std::complex<T> rhs(-3.5, 4.5);
+    assert(lhs + rhs == std::complex<T>(-2.0, 4.5));
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_times_complex.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const T& lhs, const complex<T>& rhs);
+//   operator*(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    T lhs(1.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(2.25, 3.75);
-    test(lhs, rhs, x);
+    const T lhs(1.5);
+    const std::complex<T> rhs(1.5, 2.5);
+    assert(lhs * rhs == std::complex<T>(2.25, 3.75));
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/unary_minus.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs);
+//   operator-(const complex<T>& lhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> z(1.5, 2.5);
-    assert(z.real() == 1.5);
-    assert(z.imag() == 2.5);
-    std::complex<T> c = -z;
-    assert(c.real() == -1.5);
-    assert(c.imag() == -2.5);
+    assert(-std::complex<T>(1.5, -2.5) == std::complex<T>(-1.5, 2.5));
+    assert(-std::complex<T>(-1.5, 2.5) == std::complex<T>(1.5, -2.5));
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/unary_plus.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
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>&);
+//   operator+(const complex<T>&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20
+bool
 test()
 {
-    std::complex<T> z(1.5, 2.5);
-    assert(z.real() == 1.5);
-    assert(z.imag() == 2.5);
-    std::complex<T> c = +z;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
+  assert(+std::complex<T>(1.5, -2.5) == std::complex<T>(1.5, -2.5));
+  assert(+std::complex<T>(-1.5, 2.5) == std::complex<T>(-1.5, 2.5));
+  return true;
 }
 
 int main(int, char**)
 {
-    test<float>();
-    test<double>();
-    test<long double>();
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_constexpr_cmath",
     "values": { "c++2b": 202202 },
     "headers": ["cmath", "cstdlib"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_complex",
     "values": { "c++20": 201711 },
     "headers": ["complex"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_dynamic_alloc",
     "values": { "c++20": 201907 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_constexpr_functional",
     "values": { "c++20": 201907 },
     "headers": ["functional"],