// 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 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), ""); 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}} \ // both-note {{dereferencing a null pointer}} constexpr float pi = __imag *p; // both-error {{constant expr}} \ // both-note {{dereferencing a 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, ""); }