// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify=both,expected -Wno-unused-value %s
// RUN: %clang_cc1 -verify=both,ref -Wno-unused-value %s
constexpr _Complex double z1 = {1.0, 2.0};
static_assert(__real(z1) == 1.0, "");
static_assert(__imag(z1) == 2.0, "");
static_assert(&__imag z1 == &__real z1 + 1, "");
static_assert((*(&__imag z1)) == __imag z1, "");
static_assert((*(&__real z1)) == __real z1, "");
static_assert(((1.25 + 0.5j) * (0.25 - 0.75j)) == (0.6875 - 0.8125j), "");
static_assert(((1.25 + 0.5j) * 0.25) == (0.3125 + 0.125j), "");
static_assert((1.25 * (0.25 - 0.75j)) == (0.3125 - 0.9375j), "");
constexpr _Complex float InfC = {1.0, __builtin_inf()};
constexpr _Complex float InfInf = __builtin_inf() + InfC;
static_assert(__real__(InfInf) == __builtin_inf());
static_assert(__imag__(InfInf) == __builtin_inf());
static_assert(__builtin_isnan(__real__(InfInf * InfInf)));
static_assert(__builtin_isinf_sign(__imag__(InfInf * InfInf)) == 1);
static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * 1.0)) == 1);
static_assert(__builtin_isinf_sign(__imag__((1.0 + InfC) * 1.0)) == 1);
static_assert(__builtin_isinf_sign(__real__(1.0 * (__builtin_inf() + 1.0j))) == 1);
static_assert(__builtin_isinf_sign(__imag__(1.0 * (1.0 + InfC))) == 1);
static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * (1.0 + 1.0j))) == 1);
static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) * (__builtin_inf() + 1.0j))) == 1);
static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * (__builtin_inf() + 1.0j))) == 1);
static_assert(__builtin_isinf_sign(__real__((1.0 + InfC) * (1.0 + 1.0j))) == -1);
static_assert(__builtin_isinf_sign(__imag__((1.0 + InfC) * (1.0 + 1.0j))) == 1);
static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) * (1.0 + InfC))) == -1);
static_assert(__builtin_isinf_sign(__imag__((1.0 + 1.0j) * (1.0 + InfC))) == 1);
static_assert(__builtin_isinf_sign(__real__((1.0 + InfC) * (1.0 + InfC))) == -1);
static_assert(__builtin_isinf_sign(__real__(InfInf * InfInf)) == 0);
constexpr _Complex int IIMA = {1,2};
constexpr _Complex int IIMB = {10,20};
constexpr _Complex int IIMC = IIMA * IIMB;
static_assert(__real(IIMC) == -30, "");
static_assert(__imag(IIMC) == 40, "");
static_assert(1.0j / 0.0 == 1); // both-error {{static assertion}} \
// both-note {{division by zero}}
static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) / (0.0 + 0.0j))) == 1);
static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) / 0.0)) == 1); // both-error {{static assertion}} \
// both-note {{division by zero}}
static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) / (0.0 + 0.0j))) == 1);
static_assert(__builtin_isinf_sign(__imag__((1.0 + InfC) / (0.0 + 0.0j))) == 1);
static_assert(__builtin_isinf_sign(__imag__((InfInf) / (0.0 + 0.0j))) == 1);
constexpr _Complex int IIDA = {10,20};
constexpr _Complex int IIDB = {1,2};
constexpr _Complex int IIDC = IIDA / IIDB;
static_assert(__real(IIDC) == 10, "");
static_assert(__imag(IIDC) == 0, "");
constexpr _Complex int Comma1 = {1, 2};
constexpr _Complex int Comma2 = (0, Comma1);
static_assert(Comma1 == Comma1, "");
constexpr double setter() {
_Complex float d = {1.0, 2.0};
__imag(d) = 4.0;
return __imag(d);
}
static_assert(setter() == 4, "");
constexpr _Complex double getter() {
return {1.0, 3.0};
}
constexpr _Complex double D = getter();
static_assert(__real(D) == 1.0, "");
static_assert(__imag(D) == 3.0, "");
constexpr _Complex int I1 = {1, 2};
static_assert(__real(I1) == 1, "");
static_assert(__imag(I1) == 2, "");
constexpr _Complex double D1 = {};
static_assert(__real(D1) == 0, "");
static_assert(__imag(D1) == 0, "");
constexpr _Complex int I2 = {};
static_assert(__real(I2) == 0, "");
static_assert(__imag(I2) == 0, "");
static_assert(__real(4.0) == 4.0, "");
static_assert(__real(12u) == 12u, "");
static_assert(__imag(4.0) == 0.0, "");
static_assert(__imag(13) == 0, "");
constexpr _Complex long L1 = D;
static_assert(__real(L1) == 1.0, "");
static_assert(__imag(L1) == 3.0, "");
constexpr _Complex short I4 = L1;
static_assert(__real(I4) == 1, "");
static_assert(__imag(I4) == 3, "");
constexpr _Complex float D3 = D;
static_assert(__real(D3) == 1.0, "");
static_assert(__imag(D3) == 3.0, "");
constexpr _Complex int a = 2i;
static_assert(__real(a) == 0, "");
static_assert(__imag(a) == 2, "");
constexpr _Complex double b = 4.0i;
static_assert(__real(b) == 0, "");
static_assert(__imag(b) == 4, "");
constexpr int ignored() {
I2;
(int)I2;
(float)I2;
D1;
(int)D1;
(double)D1;
(_Complex float)I2;
(bool)D1;
(bool)I2;
return 0;
}
static_assert(ignored() == 0, "");
static_assert((int)I1 == 1, "");
static_assert((float)D == 1.0f, "");
static_assert(__real((_Complex unsigned)5) == 5);
static_assert(__imag((_Complex unsigned)5) == 0);
/// Standalone complex expressions.
static_assert(__real((_Complex float){1.0, 3.0}) == 1.0, "");
constexpr _Complex double D2 = {12};
static_assert(__real(D2) == 12, "");
static_assert(__imag(D2) == 0, "");
constexpr _Complex int I3 = {15};
static_assert(__real(I3) == 15, "");
static_assert(__imag(I3) == 0, "");
constexpr _Complex _BitInt(8) A = {4};
static_assert(__real(A) == 4, "");
static_assert(__imag(A) == 0, "");
constexpr _Complex double Doubles[4] = {{1.0, 2.0}};
static_assert(__real(Doubles[0]) == 1.0, "");
static_assert(__imag(Doubles[0]) == 2.0, "");
static_assert(__real(Doubles[1]) == 0.0, "");
static_assert(__imag(Doubles[1]) == 0.0, "");
static_assert(__real(Doubles[2]) == 0.0, "");
static_assert(__imag(Doubles[2]) == 0.0, "");
static_assert(__real(Doubles[3]) == 0.0, "");
static_assert(__imag(Doubles[3]) == 0.0, "");
static_assert(~(0.5 + 1.5j) == (0.5 + -1.5j), "");
static_assert(__extension__ __imag(A) == 0, "");
static_assert(__imag(__extension__ A) == 0, "");
void func(void) {
__complex__ int arr;
_Complex int result;
int ii = 0;
int bb = 0;
/// The following line will call into the constant interpreter.
result = arr * ii;
}
constexpr _Complex float getComplexFloat() {
return {1,2};
}
static_assert(__real(getComplexFloat()) == 1, "");
static_assert(__imag(getComplexFloat()) == 2, "");
constexpr auto GH55390 = 1 / 65536j; // both-note {{division by zero}} \
// both-error {{constexpr variable 'GH55390' must be initialized by a constant expression}}
namespace CastToBool {
constexpr _Complex int F = {0, 1};
static_assert(F, "");
constexpr _Complex int F2 = {1, 0};
static_assert(F2, "");
constexpr _Complex int F3 = {0, 0};
static_assert(!F3, "");
constexpr _Complex unsigned char F4 = {0, 1};
static_assert(F4, "");
constexpr _Complex unsigned char F5 = {1, 0};
static_assert(F5, "");
constexpr _Complex unsigned char F6 = {0, 0};
static_assert(!F6, "");
constexpr _Complex float F7 = {0, 1};
static_assert(F7, "");
constexpr _Complex float F8 = {1, 0};
static_assert(F8, "");
constexpr _Complex double F9 = {0, 0};
static_assert(!F9, "");
}
namespace BinOps {
namespace Add {
constexpr _Complex float A = { 13.0, 2.0 };
constexpr _Complex float B = { 2.0, 1.0 };
constexpr _Complex float C = A + B;
static_assert(__real(C) == 15.0, "");
static_assert(__imag(C) == 3.0, "");
constexpr _Complex float D = B + A;
static_assert(__real(D) == 15.0, "");
static_assert(__imag(D) == 3.0, "");
constexpr _Complex unsigned int I1 = { 5, 10 };
constexpr _Complex unsigned int I2 = { 40, 2 };
constexpr _Complex unsigned int I3 = I1 + I2;
static_assert(__real(I3) == 45, "");
static_assert(__imag(I3) == 12, "");
static_assert(__real(A + 2.0) == 15, "");
static_assert(__imag(A + 2.0) == 2, "");
static_assert(__real(2.0 + A) == 15, "");
static_assert(__imag(2.0 + A) == 2, "");
static_assert(__real(D + 1) == 16, "");
static_assert(__real(D + 1.0) == 16, "");
constexpr _Complex double D2 = D + 3.0;
static_assert(__real(D2) == 18.0, "");
static_assert(__imag(D2) == 3.0, "");
constexpr _Complex double D3 = 3.0 + D;
static_assert(__real(D3) == 18.0, "");
static_assert(__imag(D3) == 3.0, "");
}
namespace Sub {
constexpr _Complex float A = { 13.0, 2.0 };
constexpr _Complex float B = { 2.0, 1.0 };
constexpr _Complex float C = A - B;
static_assert(__real(C) == 11.0, "");
static_assert(__imag(C) == 1.0, "");
static_assert(__real(A - 2.0) == 11, "");
static_assert(__real(2.0 - A) == -11, "");
constexpr _Complex float D = B - A;
static_assert(__real(D) == -11.0, "");
static_assert(__imag(D) == -1.0, "");
constexpr _Complex unsigned int I1 = { 5, 10 };
constexpr _Complex unsigned int I2 = { 40, 2 };
constexpr _Complex unsigned int I3 = I1 - I2;
static_assert(__real(I3) == -35, "");
static_assert(__imag(I3) == 8, "");
using Bobble = _Complex float;
constexpr _Complex float A_ = { 13.0, 2.0 };
constexpr Bobble B_ = { 2.0, 1.0 };
constexpr _Complex float D_ = A_ - B_;
static_assert(__real(D_) == 11.0, "");
static_assert(__imag(D_) == 1.0, "");
static_assert(__real(D - 1) == -12, "");
static_assert(__real(D - 1.0) == -12, "");
constexpr _Complex double D2 = D - 3.0;
static_assert(__real(D2) == -14.0, "");
static_assert(__imag(D2) == -1.0, "");
constexpr _Complex double D3 = 3.0 - D;
static_assert(__real(D3) == 14.0, "");
static_assert(__imag(D3) == 1.0, "");
}
}
namespace ZeroInit {
typedef _Complex float fcomplex;
typedef _Complex unsigned icomplex;
constexpr fcomplex test7 = fcomplex();
static_assert(__real(test7) == 0.0f, "");
static_assert(__imag(test7) == 0.0f, "");
constexpr icomplex test8 = icomplex();
static_assert(__real(test8) == 0, "");
static_assert(__imag(test8) == 0, "");
constexpr int ignored = (fcomplex(), 0);
}
namespace DeclRefCopy {
constexpr _Complex int ComplexInt = 42 + 24i;
constexpr _Complex int B = ComplexInt;
constexpr _Complex int ArrayOfComplexInt[4] = {ComplexInt, ComplexInt, ComplexInt, ComplexInt};
static_assert(__real(ArrayOfComplexInt[0]) == 42, "");
static_assert(__imag(ArrayOfComplexInt[0]) == 24, "");
static_assert(__real(ArrayOfComplexInt[3]) == 42, "");
static_assert(__imag(ArrayOfComplexInt[3]) == 24, "");
constexpr int localComplexArray() {
_Complex int A = 42 + 24i;
_Complex int ArrayOfComplexInt[4] = {A, A, A, A};
return __real(ArrayOfComplexInt[0]) + __imag(ArrayOfComplexInt[3]);
}
static_assert(localComplexArray() == (24 + 42), "");
}
namespace Builtin {
constexpr _Complex float A = __builtin_complex(10.0f, 20.0f);
static_assert(__real(A) == 10, "");
static_assert(__imag(A) == 20, "");
constexpr _Complex double B = __builtin_complex(10.0, 20.0);
static_assert(__real(B) == 10, "");
static_assert(__imag(B) == 20, "");
constexpr _Complex float C = __builtin_complex(10.0f, 20.0); // both-error {{arguments are of different types}}
}
namespace Cmp {
static_assert((0.0 + 0.0j) == (0.0 + 0.0j));
static_assert((0.0 + 0.0j) != (0.0 + 0.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((0.0 + 0.0j) == 0.0);
static_assert(0.0 == (0.0 + 0.0j));
static_assert(0.0 == 0.0j);
static_assert((0.0 + 1.0j) != 0.0);
static_assert(1.0 != (0.0 + 0.0j));
static_assert(0.0 != 1.0j);
// Walk around the complex plane stepping between angular differences and
// equality.
static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((1.0 + 0.0j) == (1.0 + 0.0j));
static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((1.0 + 1.0j) == (1.0 + 1.0j));
static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((0.0 + 1.0j) == (0.0 + 1.0j));
static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((-1.0 + 1.0j) == (-1.0 + 1.0j));
static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((-1.0 + 0.0j) == (-1.0 + 0.0j));
static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((-1.0 - 1.0j) == (-1.0 - 1.0j));
static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((0.0 - 1.0j) == (0.0 - 1.0j));
static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // both-error {{static assertion}} \
// both-note {{evaluates to}}
static_assert((1.0 - 1.0j) == (1.0 - 1.0j));
/// Make sure these are rejected before reaching the constexpr interpreter.
static_assert((0.0 + 0.0j) & (0.0 + 0.0j)); // both-error {{invalid operands to binary expression}}
static_assert((0.0 + 0.0j) | (0.0 + 0.0j)); // both-error {{invalid operands to binary expression}}
static_assert((0.0 + 0.0j) < (0.0 + 0.0j)); // both-error {{invalid operands to binary expression}}
static_assert((0.0 + 0.0j) > (0.0 + 0.0j)); // both-error {{invalid operands to binary expression}}
static_assert((0.0 + 0.0j) ^ (0.0 + 0.0j)); // both-error {{invalid operands to binary expression}}
}
/// From test/SemaCXX/constant-expression-cxx11.cpp
///
/// Some of the diagnostics we emit are different than the one of the
/// current interpreter.
///
/// FIXME: For the '&test3 + 1' test, we are _not_ creating an explicit pointer variable
/// anywhere and so the &test3+1 is the same as __imag(test3) for us.
namespace ComplexConstexpr {
constexpr _Complex float test1 = {};
constexpr _Complex float test2 = {1};
constexpr _Complex double test3 = {1,2};
constexpr _Complex int test4 = {4};
constexpr _Complex int test5 = 4;
constexpr _Complex int test6 = {5,6};
typedef _Complex float fcomplex;
constexpr fcomplex test7 = fcomplex();
constexpr const double &t2r = __real test3;
constexpr const double &t2i = __imag test3;
static_assert(&t2r + 1 == &t2i, "");
static_assert(t2r == 1.0, "");
static_assert(t2i == 2.0, "");
constexpr const double *t2p = &t2r;
static_assert(t2p[-1] == 0.0, ""); // both-error {{constant expr}} \
// both-note {{cannot refer to element -1 of array of 2 elements}}
static_assert(t2p[0] == 1.0, "");
static_assert(t2p[1] == 2.0, "");
static_assert(t2p[2] == 0.0, ""); // both-error {{constant expr}} \
// both-note {{one-past-the-end pointer}}
static_assert(t2p[3] == 0.0, ""); // both-error {{constant expr}} \
// both-note {{cannot refer to element 3 of array of 2 elements}}
constexpr _Complex float *p = 0;
constexpr float pr = __real *p; // both-error {{constant expr}} \
// ref-note {{cannot access real component of null}} \
// expected-note {{read of dereferenced null pointer}}
constexpr float pi = __imag *p; // both-error {{constant expr}} \
// ref-note {{cannot access imaginary component of null}} \
// expected-note {{cannot perform pointer arithmetic on null pointer}}
constexpr const _Complex double *q = &test3 + 1;
constexpr double qr = __real *q; // ref-error {{constant expr}} \
// ref-note {{cannot access real component of pointer past the end}}
constexpr double qi = __imag *q; // both-error {{constant expr}} \
// ref-note {{cannot access imaginary component of pointer past the end}} \
// expected-note {{read of dereferenced one-past-the-end pointer}}
static_assert(__real test6 == 5, "");
static_assert(__imag test6 == 6, "");
static_assert(&__imag test6 == &__real test6 + 1, "");
}
Codebase Browser
llvm