| // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify %s |
| // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++98 %s |
| // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++11 %s |
| // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++20 %s |
| // RUN: %clang_cc1 -flax-vector-conversions=integer -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT |
| // RUN: %clang_cc1 -flax-vector-conversions=none -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT -DNO_LAX_INT |
| |
| typedef char char16 __attribute__ ((__vector_size__ (16))); |
| typedef long long longlong16 __attribute__ ((__vector_size__ (16))); |
| typedef char char16_e __attribute__ ((__ext_vector_type__ (16))); |
| typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2))); |
| |
| // Test overloading and function calls with vector types. |
| void f0(char16); // expected-note 0+{{candidate}} |
| |
| void f0_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { |
| f0(c16); |
| f0(ll16); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| f0(c16e); |
| f0(ll16e); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| } |
| |
| int &f1(char16); |
| float &f1(longlong16); |
| |
| void f1_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { |
| int &ir1 = f1(c16); |
| float &fr1 = f1(ll16); |
| int &ir2 = f1(c16e); |
| float &fr2 = f1(ll16e); |
| } |
| |
| void f2(char16_e); // expected-note 0+{{candidate}} |
| |
| void f2_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { |
| f2(c16); |
| f2(ll16); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| f2(c16e); |
| f2(ll16e); // expected-error{{no matching function}} |
| f2('a'); |
| f2(17); |
| } |
| |
| // Test the conditional operator with vector types. |
| void conditional(bool Cond, char16 c16, longlong16 ll16, char16_e c16e, |
| longlong16_e ll16e) { |
| // Conditional operators with the same type. |
| __typeof__(Cond? c16 : c16) *c16p1 = &c16; |
| __typeof__(Cond? ll16 : ll16) *ll16p1 = &ll16; |
| __typeof__(Cond? c16e : c16e) *c16ep1 = &c16e; |
| __typeof__(Cond? ll16e : ll16e) *ll16ep1 = &ll16e; |
| |
| // Conditional operators with similar types. |
| __typeof__(Cond? c16 : c16e) *c16ep2 = &c16e; |
| __typeof__(Cond? c16e : c16) *c16ep3 = &c16e; |
| __typeof__(Cond? ll16 : ll16e) *ll16ep2 = &ll16e; |
| __typeof__(Cond? ll16e : ll16) *ll16ep3 = &ll16e; |
| |
| // Conditional operators with compatible types under -flax-vector-conversions (default) |
| (void)(Cond? c16 : ll16); |
| (void)(Cond? ll16e : c16e); |
| (void)(Cond? ll16e : c16); |
| #ifdef NO_LAX_INT |
| // expected-error@-4 {{cannot convert}} |
| // expected-error@-4 {{cannot convert}} |
| // expected-error@-4 {{cannot convert}} |
| #endif |
| } |
| |
| // Test C++ cast'ing of vector types. |
| void casts(longlong16 ll16, longlong16_e ll16e) { |
| // C-style casts. |
| (void)(char16)ll16; |
| (void)(char16_e)ll16; |
| (void)(longlong16)ll16; |
| (void)(longlong16_e)ll16; |
| (void)(char16)ll16e; |
| (void)(char16_e)ll16e; |
| (void)(longlong16)ll16e; |
| (void)(longlong16_e)ll16e; |
| |
| // Function-style casts. |
| (void)char16(ll16); |
| (void)char16_e(ll16); |
| (void)longlong16(ll16); |
| (void)longlong16_e(ll16); |
| (void)char16(ll16e); |
| (void)char16_e(ll16e); |
| (void)longlong16(ll16e); |
| (void)longlong16_e(ll16e); |
| |
| // static_cast |
| (void)static_cast<char16>(ll16); |
| (void)static_cast<char16_e>(ll16); |
| #ifdef NO_LAX_INT |
| // expected-error@-3 {{not allowed}} |
| // expected-error@-3 {{not allowed}} |
| #endif |
| (void)static_cast<longlong16>(ll16); |
| (void)static_cast<longlong16_e>(ll16); |
| (void)static_cast<char16>(ll16e); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{not allowed}} |
| #endif |
| (void)static_cast<char16_e>(ll16e); // expected-error{{static_cast from 'longlong16_e' (vector of 2 'long long' values) to 'char16_e' (vector of 16 'char' values) is not allowed}} |
| (void)static_cast<longlong16>(ll16e); |
| (void)static_cast<longlong16_e>(ll16e); |
| |
| // reinterpret_cast |
| (void)reinterpret_cast<char16>(ll16); |
| (void)reinterpret_cast<char16_e>(ll16); |
| (void)reinterpret_cast<longlong16>(ll16); |
| (void)reinterpret_cast<longlong16_e>(ll16); |
| (void)reinterpret_cast<char16>(ll16e); |
| (void)reinterpret_cast<char16_e>(ll16e); |
| (void)reinterpret_cast<longlong16>(ll16e); |
| (void)reinterpret_cast<longlong16_e>(ll16e); |
| } |
| |
| template<typename T> |
| struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable}} |
| #if __cplusplus >= 201103L // C++11 or later |
| // expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}} |
| #endif |
| operator T() const; |
| }; |
| |
| void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16, |
| char16_e c16e, longlong16_e ll16e, |
| convertible_to<char16> to_c16, |
| convertible_to<longlong16> to_ll16, |
| convertible_to<char16_e> to_c16e, |
| convertible_to<longlong16_e> to_ll16e, |
| convertible_to<char16&> rto_c16, |
| convertible_to<char16_e&> rto_c16e) { |
| f0(to_c16); |
| f0(to_ll16); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| f0(to_c16e); |
| f0(to_ll16e); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| f2(to_c16); |
| f2(to_ll16); |
| #ifdef NO_LAX_INT |
| // expected-error@-2 {{no matching function}} |
| #endif |
| f2(to_c16e); |
| f2(to_ll16e); // expected-error{{no matching function}} |
| |
| (void)(c16 == c16e); |
| (void)(c16 == to_c16); |
| (void)+to_c16; |
| (void)-to_c16; |
| (void)~to_c16; |
| (void)(to_c16 == to_c16e); |
| (void)(to_c16 != to_c16e); |
| (void)(to_c16 < to_c16e); |
| (void)(to_c16 <= to_c16e); |
| (void)(to_c16 > to_c16e); |
| (void)(to_c16 >= to_c16e); |
| (void)(to_c16 + to_c16); |
| (void)(to_c16 - to_c16); |
| (void)(to_c16 * to_c16); |
| (void)(to_c16 / to_c16); |
| (void)(rto_c16 = to_c16); // expected-error{{no viable overloaded '='}} |
| (void)(rto_c16 += to_c16); |
| (void)(rto_c16 -= to_c16); |
| (void)(rto_c16 *= to_c16); |
| (void)(rto_c16 /= to_c16); |
| |
| (void)+to_c16e; |
| (void)-to_c16e; |
| (void)~to_c16e; |
| (void)(to_c16e == to_c16e); |
| (void)(to_c16e != to_c16e); |
| (void)(to_c16e < to_c16e); |
| (void)(to_c16e <= to_c16e); |
| (void)(to_c16e > to_c16e); |
| (void)(to_c16e >= to_c16e); |
| (void)(to_c16e + to_c16); |
| (void)(to_c16e - to_c16); |
| (void)(to_c16e * to_c16); |
| (void)(to_c16e / to_c16); |
| (void)(rto_c16e = to_c16); // expected-error{{no viable overloaded '='}} |
| (void)(rto_c16e += to_c16); |
| (void)(rto_c16e -= to_c16); |
| (void)(rto_c16e *= to_c16); |
| (void)(rto_c16e /= to_c16); |
| |
| (void)+to_c16; |
| (void)-to_c16; |
| (void)~to_c16; |
| (void)(to_c16 == to_c16e); |
| (void)(to_c16 != to_c16e); |
| (void)(to_c16 < to_c16e); |
| (void)(to_c16 <= to_c16e); |
| (void)(to_c16 > to_c16e); |
| (void)(to_c16 >= to_c16e); |
| (void)(to_c16 + to_c16e); |
| (void)(to_c16 - to_c16e); |
| (void)(to_c16 * to_c16e); |
| (void)(to_c16 / to_c16e); |
| (void)(rto_c16 = c16e); // expected-error{{no viable overloaded '='}} |
| (void)(rto_c16 += to_c16e); |
| (void)(rto_c16 -= to_c16e); |
| (void)(rto_c16 *= to_c16e); |
| (void)(rto_c16 /= to_c16e); |
| |
| (void)(Cond? to_c16 : to_c16e); |
| (void)(Cond? to_ll16e : to_ll16); |
| |
| // These 2 are convertible with -flax-vector-conversions (default) |
| (void)(Cond? to_c16 : to_ll16); |
| (void)(Cond? to_c16e : to_ll16e); |
| #ifdef NO_LAX_INT |
| // expected-error@-3 {{cannot convert}} |
| // expected-error@-3 {{cannot convert}} |
| #endif |
| } |
| |
| typedef float fltx2 __attribute__((__vector_size__(8))); |
| typedef float fltx4 __attribute__((__vector_size__(16))); |
| typedef double dblx2 __attribute__((__vector_size__(16))); |
| typedef double dblx4 __attribute__((__vector_size__(32))); |
| |
| void accept_fltx2(fltx2); // expected-note{{candidate function not viable: no known conversion from 'double' to 'fltx2' (vector of 2 'float' values) for 1st argument}} |
| void accept_fltx4(fltx4); |
| void accept_dblx2(dblx2); |
| #ifdef NO_LAX_FLOAT |
| // expected-note@-3 {{no known conversion}} |
| // expected-note@-3 {{no known conversion}} |
| #endif |
| void accept_dblx4(dblx4); |
| void accept_bool(bool); // expected-note{{candidate function not viable: no known conversion from 'fltx2' (vector of 2 'float' values) to 'bool' for 1st argument}} |
| |
| void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) { |
| // Exact matches |
| accept_fltx2(fltx2_val); |
| accept_fltx4(fltx4_val); |
| accept_dblx2(dblx2_val); |
| accept_dblx4(dblx4_val); |
| |
| // Same-size conversions |
| accept_fltx4(dblx2_val); |
| accept_dblx2(fltx4_val); |
| #ifdef NO_LAX_FLOAT |
| // expected-error@-3 {{no matching function}} |
| // expected-error@-3 {{no matching function}} |
| #endif |
| |
| // Conversion to bool. |
| accept_bool(fltx2_val); // expected-error{{no matching function for call to 'accept_bool'}} |
| |
| // Scalar-to-vector conversions. |
| accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}} |
| } |
| |
| typedef int intx4 __attribute__((__vector_size__(16))); |
| typedef int inte4 __attribute__((__ext_vector_type__(4))); |
| typedef float flte4 __attribute__((__ext_vector_type__(4))); |
| |
| void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, inte4 m) { |
| (void)(f == g); |
| (void)(g != f); |
| (void)(f <= g); |
| (void)(g >= f); |
| (void)(f < g); |
| (void)(g > f); |
| |
| (void)(+g); |
| (void)(-g); |
| |
| (void)(f + g); |
| (void)(f - g); |
| (void)(f * g); |
| (void)(f / g); |
| (void)(f = g); |
| (void)(f += g); |
| (void)(f -= g); |
| (void)(f *= g); |
| (void)(f /= g); |
| |
| |
| (void)(n == m); |
| (void)(m != n); |
| (void)(n <= m); |
| (void)(m >= n); |
| (void)(n < m); |
| (void)(m > n); |
| |
| (void)(+m); |
| (void)(-m); |
| (void)(~m); |
| |
| (void)(n + m); |
| (void)(n - m); |
| (void)(n * m); |
| (void)(n / m); |
| (void)(n % m); |
| (void)(n = m); |
| (void)(n += m); |
| (void)(n -= m); |
| (void)(n *= m); |
| (void)(n /= m); |
| } |
| |
| template<typename T> void test_pseudo_dtor_tmpl(T *ptr) { |
| ptr->~T(); |
| (*ptr).~T(); |
| } |
| |
| void test_pseudo_dtor(fltx4 *f) { |
| f->~fltx4(); |
| (*f).~fltx4(); |
| test_pseudo_dtor_tmpl(f); |
| } |
| |
| // PR16204 |
| typedef __attribute__((ext_vector_type(4))) int vi4; |
| const int &reference_to_vec_element = vi4(1).x; |
| |
| // PR12649 |
| typedef bool bad __attribute__((__vector_size__(16))); // expected-error {{invalid vector element type 'bool'}} |
| |
| namespace Templates { |
| template <typename Elt, unsigned long long Size> |
| struct TemplateVectorType { |
| typedef Elt __attribute__((__vector_size__(Size))) type; // #1 |
| }; |
| |
| template <int N, typename T> |
| struct PR15730 { |
| typedef T __attribute__((vector_size(N * sizeof(T)))) type; |
| typedef T __attribute__((vector_size(0x1000000000))) type2; // #2 |
| typedef T __attribute__((vector_size(3))) type3; // #3 |
| }; |
| |
| void Init() { |
| const TemplateVectorType<float, 32>::type Works = {}; |
| const TemplateVectorType<int, 32>::type Works2 = {}; |
| // expected-error@#1 {{invalid vector element type 'bool'}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}} |
| const TemplateVectorType<bool, 32>::type NoBool = {}; |
| // expected-error@#1 {{invalid vector element type 'int __attribute__((ext_vector_type(4)))' (vector of 4 'int' values)}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int __attribute__((ext_vector_type(4))), 32>' requested here}} |
| const TemplateVectorType<vi4, 32>::type NoComplex = {}; |
| // expected-error@#1 {{vector size not an integral multiple of component size}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 33>' requested here}} |
| const TemplateVectorType<int, 33>::type BadSize = {}; |
| const TemplateVectorType<int, 3200>::type Large = {}; |
| // expected-error@#1 {{vector size too large}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 68719476736>' requested here}} |
| const TemplateVectorType<int, 0x1000000000>::type TooLarge = {}; |
| // expected-error@#1 {{zero vector size}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 0>' requested here}} |
| const TemplateVectorType<int, 0>::type Zero = {}; |
| |
| // expected-error@#2 {{vector size too large}} |
| // expected-error@#3 {{vector size not an integral multiple of component size}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, int>' requested here}} |
| const PR15730<8, int>::type PR15730_1 = {}; |
| // expected-error@#2 {{vector size too large}} |
| // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, char>' requested here}} |
| const PR15730<8, char>::type2 PR15730_2 = {}; |
| } |
| |
| } // namespace Templates |
| |
| typedef int inte2 __attribute__((__ext_vector_type__(2))); |
| |
| void test_vector_literal(inte4 res) { |
| inte2 a = (inte2)(1, 2); //expected-warning{{left operand of comma operator has no effect}} |
| inte4 b = (inte4)(a, a); //expected-error{{C-style cast from vector 'inte2' (vector of 2 'int' values) to vector 'inte4' (vector of 4 'int' values) of different size}} //expected-warning{{left operand of comma operator has no effect}} |
| } |
| |
| typedef __attribute__((__ext_vector_type__(4))) float vector_float4; |
| typedef __attribute__((__ext_vector_type__(4))) int vector_int4; |
| |
| namespace swizzle_template_confusion { |
| template<typename T> struct xyzw {}; |
| vector_int4 foo123(vector_float4 &A, vector_float4 &B) { |
| return A.xyzw < B.x && B.y > A.y; // OK, not a template-id |
| } |
| } |
| |
| namespace swizzle_typo_correction { |
| template<typename T> struct xyzv {}; |
| vector_int4 foo123(vector_float4 &A, vector_float4 &B) { |
| return A.xyzw < B.x && B.y > A.y; // OK, not a typo for 'xyzv' |
| } |
| } |
| |
| namespace PR45299 { |
| typedef float float4 __attribute__((vector_size(16))); |
| |
| // In this example, 'k' is value dependent. PR45299 reported that this asserted |
| // because of that, since the truncation check attempted to constant evaluate k, |
| // which it could not do because it is dependent. |
| template <typename T> |
| struct NormalMember { |
| float4 f(float4 x) { |
| return k * x; |
| } |
| float k; |
| }; |
| |
| #if __cplusplus >= 201103L |
| // This should not diagnose, since the constant evaluator (during instantiation) |
| // can tell that this isn't a truncation. |
| template <typename T> |
| struct ConstantValueNoDiag { |
| float4 f(float4 x) { |
| return k * x; |
| } |
| static constexpr double k = 1; |
| }; |
| template <typename T, int N> |
| struct ConstantValueNoDiagDependentValue { |
| float4 f(float4 x) { |
| return k * x; |
| } |
| static constexpr double k = N; |
| }; |
| |
| // The following two both diagnose because they cause a truncation. Test both |
| // the dependent type and non-dependent type versions. |
| template <typename T> |
| struct DiagTrunc { |
| float4 f(float4 x) { |
| // expected-error@+1{{as implicit conversion would cause truncation}} |
| return k * x; |
| } |
| static constexpr double k = 1340282346638528859811704183484516925443.000000; |
| }; |
| template <typename T, int N> |
| struct DiagTruncDependentValue { |
| float4 f(float4 x) { |
| // expected-error@+1{{as implicit conversion would cause truncation}} |
| return k * x; |
| } |
| static constexpr double k = N + 1340282346638528859811704183484516925443.000000; |
| }; |
| template <typename T> |
| struct DiagTruncDependentType { |
| float4 f(float4 x) { |
| // expected-error@+1{{as implicit conversion would cause truncation}} |
| return k * x; |
| } |
| static constexpr T k = 1340282346638528859811704183484516925443.000000; |
| }; |
| |
| template <typename T> |
| struct PR45298 { |
| T k1 = T(0); |
| }; |
| |
| // Ensure this no longer asserts. |
| template <typename T> |
| struct PR45298Consumer { |
| float4 f(float4 x) { |
| return (float)s.k1 * x; |
| } |
| |
| PR45298<T> s; |
| }; |
| #endif // __cplusplus >= 201103L |
| |
| void use() { |
| float4 theFloat4; |
| NormalMember<double>().f(theFloat4); |
| #if __cplusplus >= 201103L |
| ConstantValueNoDiag<double>().f(theFloat4); |
| ConstantValueNoDiagDependentValue<double, 1>().f(theFloat4); |
| DiagTrunc<double>().f(theFloat4); |
| // expected-note@+1{{in instantiation of member function}} |
| DiagTruncDependentValue<double, 0>().f(theFloat4); |
| // expected-note@+1{{in instantiation of member function}} |
| DiagTruncDependentType<double>().f(theFloat4); |
| PR45298Consumer<double>().f(theFloat4); |
| #endif // __cplusplus >= 201103L |
| } |
| } |
| |
| namespace rdar60092165 { |
| template <class T> void f() { |
| typedef T first_type __attribute__((vector_size(sizeof(T) * 4))); |
| typedef T second_type __attribute__((vector_size(sizeof(T) * 4))); |
| |
| second_type st; |
| } |
| } |
| |
| namespace PR45780 { |
| enum E { Value = 15 }; |
| void use(char16 c) { |
| E e; |
| c &Value; // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}} |
| c == Value; // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}} |
| e | c; // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}} |
| e != c; // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}} |
| } |
| |
| } // namespace PR45780 |
| |
| namespace PR48540 { |
| // The below used to cause an OOM error, or an assert, make sure it is still |
| // valid. |
| int (__attribute__((vector_size(16))) a); |
| |
| template <typename T, int I> |
| struct S { |
| T (__attribute__((vector_size(16))) a); |
| int (__attribute__((vector_size(I))) b); |
| T (__attribute__((vector_size(I))) c); |
| }; |
| |
| void use() { |
| S<int, 16> s; |
| } |
| } // namespace PR48540 |
| |
| #if __cplusplus >= 202002L // C++20 or later |
| // Don't crash due to missing integer ranks. |
| char8_t v1 __attribute__((vector_size(16))); |
| char16_t v2 __attribute__((vector_size(16))); |
| char32_t v3 __attribute__((vector_size(16))); |
| wchar_t v4 __attribute__((vector_size(16))); |
| void triggerIntegerRankCheck() { |
| auto b1 = (v1 >= 0x12); |
| auto b2 = (v2 >= 0x12); |
| auto b3 = (v3 >= 0x12); |
| auto b4 = (v4 >= 0x12); |
| } |
| #endif |
| |
| namespace all_operators { |
| typedef unsigned int v2u __attribute__((ext_vector_type(2))); |
| typedef float v2f __attribute__((ext_vector_type(2))); |
| |
| void test_int_vector_scalar(unsigned int ua, v2u v2ua) { |
| // Operators with one integer vector and one integer scalar operand. The scalar will splat. |
| (void)(v2ua + ua); |
| (void)(ua + v2ua); |
| (void)(v2ua - ua); |
| (void)(ua - v2ua); |
| (void)(v2ua * ua); |
| (void)(ua * v2ua); |
| (void)(v2ua / ua); |
| (void)(ua / v2ua); |
| (void)(v2ua % ua); |
| (void)(ua % v2ua); |
| |
| (void)(v2ua == ua); |
| (void)(ua == v2ua); |
| (void)(v2ua != ua); |
| (void)(ua != v2ua); |
| (void)(v2ua <= ua); |
| (void)(ua <= v2ua); |
| (void)(v2ua >= ua); |
| (void)(ua >= v2ua); |
| (void)(v2ua < ua); |
| (void)(ua < v2ua); |
| (void)(v2ua > ua); |
| (void)(ua > v2ua); |
| (void)(v2ua && ua); |
| (void)(ua && v2ua); |
| (void)(v2ua || ua); |
| (void)(ua || v2ua); |
| |
| (void)(v2ua & ua); |
| (void)(ua & v2ua); |
| (void)(v2ua | ua); |
| (void)(ua | v2ua); |
| (void)(v2ua ^ ua); |
| (void)(ua ^ v2ua); |
| (void)(v2ua << ua); |
| (void)(ua << v2ua); |
| (void)(v2ua >> ua); |
| (void)(ua >> v2ua); |
| |
| v2ua += ua; |
| v2ua -= ua; |
| v2ua *= ua; |
| v2ua /= ua; |
| v2ua %= ua; |
| v2ua &= ua; |
| v2ua |= ua; |
| v2ua ^= ua; |
| v2ua >>= ua; |
| v2ua <<= ua; |
| |
| ua += v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua -= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua *= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua /= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua %= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua &= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua |= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua ^= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua >>= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| ua <<= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} |
| } |
| |
| void test_float_vector_scalar(float fa, unsigned int ua, v2f v2fa) { |
| // Operators with one float vector and one float scalar operand. The scalar will splat. |
| (void)(v2fa + fa); |
| (void)(fa + v2fa); |
| (void)(v2fa - fa); |
| (void)(fa - v2fa); |
| (void)(v2fa * fa); |
| (void)(fa * v2fa); |
| (void)(v2fa / fa); |
| (void)(fa / v2fa); |
| (void)(v2fa % fa); // expected-error{{invalid operands to binary expression}} |
| (void)(fa % v2fa); // expected-error{{invalid operands to binary expression}} |
| |
| (void)(v2fa == fa); |
| (void)(fa == v2fa); |
| (void)(v2fa != fa); |
| (void)(fa != v2fa); |
| (void)(v2fa <= fa); |
| (void)(fa <= v2fa); |
| (void)(v2fa >= fa); |
| (void)(fa >= v2fa); |
| (void)(v2fa < fa); |
| (void)(fa < v2fa); |
| (void)(v2fa > fa); |
| (void)(fa > v2fa); |
| (void)(v2fa && fa); |
| (void)(fa && v2fa); |
| (void)(v2fa || fa); |
| (void)(fa || v2fa); |
| |
| (void)(v2fa & fa); // expected-error{{invalid operands to binary expression}} |
| (void)(fa & v2fa); // expected-error{{invalid operands to binary expression}} |
| (void)(v2fa | fa); // expected-error{{invalid operands to binary expression}} |
| (void)(fa | v2fa); // expected-error{{invalid operands to binary expression}} |
| (void)(v2fa ^ fa); // expected-error{{invalid operands to binary expression}} |
| (void)(fa ^ v2fa); // expected-error{{invalid operands to binary expression}} |
| (void)(v2fa << fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| (void)(v2fa << ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| (void)(fa << v2fa); // expected-error{{used type 'float' where integer is required}} |
| (void)(ua << v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| (void)(v2fa >> fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| (void)(v2fa >> ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| (void)(fa >> v2fa); // expected-error{{used type 'float' where integer is required}} |
| (void)(ua >> v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| |
| v2fa += fa; |
| v2fa -= fa; |
| v2fa *= fa; |
| v2fa /= fa; |
| v2fa %= fa; // expected-error{{invalid operands to binary expression}} |
| v2fa &= fa; // expected-error{{invalid operands to binary expression}} |
| v2fa |= fa; // expected-error{{invalid operands to binary expression}} |
| v2fa ^= fa; // expected-error{{invalid operands to binary expression}} |
| v2fa >>= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| v2fa <<= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} |
| |
| fa += v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} |
| fa -= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} |
| fa *= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} |
| fa /= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} |
| fa %= v2fa; // expected-error{{invalid operands to binary expression}} |
| fa &= v2fa; // expected-error{{invalid operands to binary expression}} |
| fa |= v2fa; // expected-error{{invalid operands to binary expression}} |
| fa ^= v2fa; // expected-error{{invalid operands to binary expression}} |
| fa >>= v2fa; // expected-error{{used type 'float' where integer is required}} |
| fa <<= v2fa; // expected-error{{used type 'float' where integer is required}} |
| } |
| |
| enum Enum { ENUM }; |
| |
| void test_enum_vector_scalar(Enum ea, v2u v2ua) { |
| // Operators with one integer vector and one enum scalar operand. |
| // The scalar will have an implicit conversion to an integral type and then splat. |
| // FIXME: These should behave the same as in C, they should be accepted via |
| // the enum converting to an integer then splatting to the vector width. |
| // https://github.com/llvm/llvm-project/issues/62869 |
| (void)(v2ua + ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea + v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua - ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea - v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua * ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea * v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua / ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea / v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua % ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea % v2ua); // expected-error{{cannot convert between vector values of different size}} |
| |
| (void)(v2ua == ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea == v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua != ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea != v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua <= ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea <= v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua >= ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea >= v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua < ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea < v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua > ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea > v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua && ea); // expected-error{{cannot convert between vector values of different size}} |
| // expected-error@-1{{invalid operands to binary expression}} |
| (void)(ea && v2ua); // expected-error{{cannot convert between vector values of different size}} |
| // expected-error@-1{{invalid operands to binary expression}} |
| (void)(v2ua || ea); // expected-error{{cannot convert between vector values of different size}} |
| // expected-error@-1{{invalid operands to binary expression}} |
| (void)(ea || v2ua); // expected-error{{cannot convert between vector values of different size}} |
| // expected-error@-1{{invalid operands to binary expression}} |
| |
| (void)(v2ua & ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea & v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua | ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea | v2ua); // expected-error{{cannot convert between vector values of different size}} |
| (void)(v2ua ^ ea); // expected-error{{cannot convert between vector values of different size}} |
| (void)(ea ^ v2ua); // expected-error{{cannot convert between vector values of different size}} |
| // FIXME: Vector/scalar shifts cause an assertion failure |
| // https://github.com/llvm/llvm-project/issues/62870 |
| // (void)(v2ua << ea); |
| // (void)(ea << v2ua); |
| // (void)(v2ua >> ea); |
| // (void)(ea >> v2ua); |
| |
| v2ua += ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua -= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua *= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua /= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua %= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua &= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua |= ea; // expected-error{{cannot convert between vector values of different size}} |
| v2ua ^= ea; // expected-error{{cannot convert between vector values of different size}} |
| // FIXME: Vector/scalar shifts cause an assertion failure |
| // https://github.com/llvm/llvm-project/issues/62870 |
| // v2ua >>= ea; |
| // v2ua <<= ea; |
| |
| ea += v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea -= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea *= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea /= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea %= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea &= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea |= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| ea ^= v2ua; // expected-error{{cannot convert between vector values of different size}} |
| // FIXME: Vector/scalar shifts cause an assertion failure |
| // https://github.com/llvm/llvm-project/issues/62870 |
| // ea >>= v2ua; // not-expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}} |
| // ea <<= v2ua; // not-expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}} |
| } |
| |
| #if __cplusplus >= 201103L // C++11 or later |
| enum class EnumClass { ENUM }; |
| |
| void test_scoped_enum_vector(EnumClass ea, v2u v2ua) { |
| // Scoped enumerations are only compatible with exactly matching types. They shouldn't integral promote. |
| (void)(v2ua + ea); // expected-error{{cannot convert between vector and non-scalar values}} |
| (void)(ea + v2ua); // expected-error{{cannot convert between vector and non-scalar values}} |
| } |
| #endif |
| } |