1 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++98 %s 3 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++11 %s 4 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++20 %s 5 // RUN: %clang_cc1 -flax-vector-conversions=integer -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT 6 // RUN: %clang_cc1 -flax-vector-conversions=none -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT -DNO_LAX_INT 7 8 typedef char char16 __attribute__ ((__vector_size__ (16))); 9 typedef long long longlong16 __attribute__ ((__vector_size__ (16))); 10 typedef char char16_e __attribute__ ((__ext_vector_type__ (16))); 11 typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2))); 12 13 // Test overloading and function calls with vector types. 14 void f0(char16); // expected-note 0+{{candidate}} 15 16 void f0_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 17 f0(c16); 18 f0(ll16); 19 #ifdef NO_LAX_INT 20 // expected-error@-2 {{no matching function}} 21 #endif 22 f0(c16e); 23 f0(ll16e); 24 #ifdef NO_LAX_INT 25 // expected-error@-2 {{no matching function}} 26 #endif 27 } 28 29 int &f1(char16); 30 float &f1(longlong16); 31 32 void f1_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 33 int &ir1 = f1(c16); 34 float &fr1 = f1(ll16); 35 int &ir2 = f1(c16e); 36 float &fr2 = f1(ll16e); 37 } 38 39 void f2(char16_e); // expected-note 0+{{candidate}} 40 41 void f2_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 42 f2(c16); 43 f2(ll16); 44 #ifdef NO_LAX_INT 45 // expected-error@-2 {{no matching function}} 46 #endif 47 f2(c16e); 48 f2(ll16e); // expected-error{{no matching function}} 49 f2('a'); 50 f2(17); 51 } 52 53 // Test the conditional operator with vector types. 54 void conditional(bool Cond, char16 c16, longlong16 ll16, char16_e c16e, 55 longlong16_e ll16e) { 56 // Conditional operators with the same type. 57 __typeof__(Cond? c16 : c16) *c16p1 = &c16; 58 __typeof__(Cond? ll16 : ll16) *ll16p1 = &ll16; 59 __typeof__(Cond? c16e : c16e) *c16ep1 = &c16e; 60 __typeof__(Cond? ll16e : ll16e) *ll16ep1 = &ll16e; 61 62 // Conditional operators with similar types. 63 __typeof__(Cond? c16 : c16e) *c16ep2 = &c16e; 64 __typeof__(Cond? c16e : c16) *c16ep3 = &c16e; 65 __typeof__(Cond? ll16 : ll16e) *ll16ep2 = &ll16e; 66 __typeof__(Cond? ll16e : ll16) *ll16ep3 = &ll16e; 67 68 // Conditional operators with compatible types under -flax-vector-conversions (default) 69 (void)(Cond? c16 : ll16); 70 (void)(Cond? ll16e : c16e); 71 (void)(Cond? ll16e : c16); 72 #ifdef NO_LAX_INT 73 // expected-error@-4 {{cannot convert}} 74 // expected-error@-4 {{cannot convert}} 75 // expected-error@-4 {{cannot convert}} 76 #endif 77 } 78 79 // Test C++ cast'ing of vector types. 80 void casts(longlong16 ll16, longlong16_e ll16e) { 81 // C-style casts. 82 (void)(char16)ll16; 83 (void)(char16_e)ll16; 84 (void)(longlong16)ll16; 85 (void)(longlong16_e)ll16; 86 (void)(char16)ll16e; 87 (void)(char16_e)ll16e; 88 (void)(longlong16)ll16e; 89 (void)(longlong16_e)ll16e; 90 91 // Function-style casts. 92 (void)char16(ll16); 93 (void)char16_e(ll16); 94 (void)longlong16(ll16); 95 (void)longlong16_e(ll16); 96 (void)char16(ll16e); 97 (void)char16_e(ll16e); 98 (void)longlong16(ll16e); 99 (void)longlong16_e(ll16e); 100 101 // static_cast 102 (void)static_cast<char16>(ll16); 103 (void)static_cast<char16_e>(ll16); 104 #ifdef NO_LAX_INT 105 // expected-error@-3 {{not allowed}} 106 // expected-error@-3 {{not allowed}} 107 #endif 108 (void)static_cast<longlong16>(ll16); 109 (void)static_cast<longlong16_e>(ll16); 110 (void)static_cast<char16>(ll16e); 111 #ifdef NO_LAX_INT 112 // expected-error@-2 {{not allowed}} 113 #endif 114 (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}} 115 (void)static_cast<longlong16>(ll16e); 116 (void)static_cast<longlong16_e>(ll16e); 117 118 // reinterpret_cast 119 (void)reinterpret_cast<char16>(ll16); 120 (void)reinterpret_cast<char16_e>(ll16); 121 (void)reinterpret_cast<longlong16>(ll16); 122 (void)reinterpret_cast<longlong16_e>(ll16); 123 (void)reinterpret_cast<char16>(ll16e); 124 (void)reinterpret_cast<char16_e>(ll16e); 125 (void)reinterpret_cast<longlong16>(ll16e); 126 (void)reinterpret_cast<longlong16_e>(ll16e); 127 } 128 129 template<typename T> 130 struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable}} 131 #if __cplusplus >= 201103L // C++11 or later 132 // expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}} 133 #endif 134 operator T() const; 135 }; 136 137 void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16, 138 char16_e c16e, longlong16_e ll16e, 139 convertible_to<char16> to_c16, 140 convertible_to<longlong16> to_ll16, 141 convertible_to<char16_e> to_c16e, 142 convertible_to<longlong16_e> to_ll16e, 143 convertible_to<char16&> rto_c16, 144 convertible_to<char16_e&> rto_c16e) { 145 f0(to_c16); 146 f0(to_ll16); 147 #ifdef NO_LAX_INT 148 // expected-error@-2 {{no matching function}} 149 #endif 150 f0(to_c16e); 151 f0(to_ll16e); 152 #ifdef NO_LAX_INT 153 // expected-error@-2 {{no matching function}} 154 #endif 155 f2(to_c16); 156 f2(to_ll16); 157 #ifdef NO_LAX_INT 158 // expected-error@-2 {{no matching function}} 159 #endif 160 f2(to_c16e); 161 f2(to_ll16e); // expected-error{{no matching function}} 162 163 (void)(c16 == c16e); 164 (void)(c16 == to_c16); 165 (void)+to_c16; 166 (void)-to_c16; 167 (void)~to_c16; 168 (void)(to_c16 == to_c16e); 169 (void)(to_c16 != to_c16e); 170 (void)(to_c16 < to_c16e); 171 (void)(to_c16 <= to_c16e); 172 (void)(to_c16 > to_c16e); 173 (void)(to_c16 >= to_c16e); 174 (void)(to_c16 + to_c16); 175 (void)(to_c16 - to_c16); 176 (void)(to_c16 * to_c16); 177 (void)(to_c16 / to_c16); 178 (void)(rto_c16 = to_c16); // expected-error{{no viable overloaded '='}} 179 (void)(rto_c16 += to_c16); 180 (void)(rto_c16 -= to_c16); 181 (void)(rto_c16 *= to_c16); 182 (void)(rto_c16 /= to_c16); 183 184 (void)+to_c16e; 185 (void)-to_c16e; 186 (void)~to_c16e; 187 (void)(to_c16e == to_c16e); 188 (void)(to_c16e != to_c16e); 189 (void)(to_c16e < to_c16e); 190 (void)(to_c16e <= to_c16e); 191 (void)(to_c16e > to_c16e); 192 (void)(to_c16e >= to_c16e); 193 (void)(to_c16e + to_c16); 194 (void)(to_c16e - to_c16); 195 (void)(to_c16e * to_c16); 196 (void)(to_c16e / to_c16); 197 (void)(rto_c16e = to_c16); // expected-error{{no viable overloaded '='}} 198 (void)(rto_c16e += to_c16); 199 (void)(rto_c16e -= to_c16); 200 (void)(rto_c16e *= to_c16); 201 (void)(rto_c16e /= to_c16); 202 203 (void)+to_c16; 204 (void)-to_c16; 205 (void)~to_c16; 206 (void)(to_c16 == to_c16e); 207 (void)(to_c16 != to_c16e); 208 (void)(to_c16 < to_c16e); 209 (void)(to_c16 <= to_c16e); 210 (void)(to_c16 > to_c16e); 211 (void)(to_c16 >= to_c16e); 212 (void)(to_c16 + to_c16e); 213 (void)(to_c16 - to_c16e); 214 (void)(to_c16 * to_c16e); 215 (void)(to_c16 / to_c16e); 216 (void)(rto_c16 = c16e); // expected-error{{no viable overloaded '='}} 217 (void)(rto_c16 += to_c16e); 218 (void)(rto_c16 -= to_c16e); 219 (void)(rto_c16 *= to_c16e); 220 (void)(rto_c16 /= to_c16e); 221 222 (void)(Cond? to_c16 : to_c16e); 223 (void)(Cond? to_ll16e : to_ll16); 224 225 // These 2 are convertible with -flax-vector-conversions (default) 226 (void)(Cond? to_c16 : to_ll16); 227 (void)(Cond? to_c16e : to_ll16e); 228 #ifdef NO_LAX_INT 229 // expected-error@-3 {{cannot convert}} 230 // expected-error@-3 {{cannot convert}} 231 #endif 232 } 233 234 typedef float fltx2 __attribute__((__vector_size__(8))); 235 typedef float fltx4 __attribute__((__vector_size__(16))); 236 typedef double dblx2 __attribute__((__vector_size__(16))); 237 typedef double dblx4 __attribute__((__vector_size__(32))); 238 239 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}} 240 void accept_fltx4(fltx4); 241 void accept_dblx2(dblx2); 242 #ifdef NO_LAX_FLOAT 243 // expected-note@-3 {{no known conversion}} 244 // expected-note@-3 {{no known conversion}} 245 #endif 246 void accept_dblx4(dblx4); 247 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}} 248 249 void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) { 250 // Exact matches 251 accept_fltx2(fltx2_val); 252 accept_fltx4(fltx4_val); 253 accept_dblx2(dblx2_val); 254 accept_dblx4(dblx4_val); 255 256 // Same-size conversions 257 accept_fltx4(dblx2_val); 258 accept_dblx2(fltx4_val); 259 #ifdef NO_LAX_FLOAT 260 // expected-error@-3 {{no matching function}} 261 // expected-error@-3 {{no matching function}} 262 #endif 263 264 // Conversion to bool. 265 accept_bool(fltx2_val); // expected-error{{no matching function for call to 'accept_bool'}} 266 267 // Scalar-to-vector conversions. 268 accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}} 269 } 270 271 typedef int intx4 __attribute__((__vector_size__(16))); 272 typedef int inte4 __attribute__((__ext_vector_type__(4))); 273 typedef float flte4 __attribute__((__ext_vector_type__(4))); 274 275 void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, inte4 m) { 276 (void)(f == g); 277 (void)(g != f); 278 (void)(f <= g); 279 (void)(g >= f); 280 (void)(f < g); 281 (void)(g > f); 282 283 (void)(+g); 284 (void)(-g); 285 286 (void)(f + g); 287 (void)(f - g); 288 (void)(f * g); 289 (void)(f / g); 290 (void)(f = g); 291 (void)(f += g); 292 (void)(f -= g); 293 (void)(f *= g); 294 (void)(f /= g); 295 296 297 (void)(n == m); 298 (void)(m != n); 299 (void)(n <= m); 300 (void)(m >= n); 301 (void)(n < m); 302 (void)(m > n); 303 304 (void)(+m); 305 (void)(-m); 306 (void)(~m); 307 308 (void)(n + m); 309 (void)(n - m); 310 (void)(n * m); 311 (void)(n / m); 312 (void)(n % m); 313 (void)(n = m); 314 (void)(n += m); 315 (void)(n -= m); 316 (void)(n *= m); 317 (void)(n /= m); 318 } 319 320 template<typename T> void test_pseudo_dtor_tmpl(T *ptr) { 321 ptr->~T(); 322 (*ptr).~T(); 323 } 324 325 void test_pseudo_dtor(fltx4 *f) { 326 f->~fltx4(); 327 (*f).~fltx4(); 328 test_pseudo_dtor_tmpl(f); 329 } 330 331 // PR16204 332 typedef __attribute__((ext_vector_type(4))) int vi4; 333 const int &reference_to_vec_element = vi4(1).x; 334 335 // PR12649 336 typedef bool bad __attribute__((__vector_size__(16))); // expected-error {{invalid vector element type 'bool'}} 337 338 namespace Templates { 339 template <typename Elt, unsigned long long Size> 340 struct TemplateVectorType { 341 typedef Elt __attribute__((__vector_size__(Size))) type; // #1 342 }; 343 344 template <int N, typename T> 345 struct PR15730 { 346 typedef T __attribute__((vector_size(N * sizeof(T)))) type; 347 typedef T __attribute__((vector_size(0x1000000000))) type2; // #2 348 typedef T __attribute__((vector_size(3))) type3; // #3 349 }; 350 351 void Init() { 352 const TemplateVectorType<float, 32>::type Works = {}; 353 const TemplateVectorType<int, 32>::type Works2 = {}; 354 // expected-error@#1 {{invalid vector element type 'bool'}} 355 // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}} 356 const TemplateVectorType<bool, 32>::type NoBool = {}; 357 // expected-error@#1 {{invalid vector element type 'int __attribute__((ext_vector_type(4)))' (vector of 4 'int' values)}} 358 // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int __attribute__((ext_vector_type(4))), 32>' requested here}} 359 const TemplateVectorType<vi4, 32>::type NoComplex = {}; 360 // expected-error@#1 {{vector size not an integral multiple of component size}} 361 // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 33>' requested here}} 362 const TemplateVectorType<int, 33>::type BadSize = {}; 363 const TemplateVectorType<int, 3200>::type Large = {}; 364 // expected-error@#1 {{vector size too large}} 365 // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 68719476736>' requested here}} 366 const TemplateVectorType<int, 0x1000000000>::type TooLarge = {}; 367 // expected-error@#1 {{zero vector size}} 368 // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 0>' requested here}} 369 const TemplateVectorType<int, 0>::type Zero = {}; 370 371 // expected-error@#2 {{vector size too large}} 372 // expected-error@#3 {{vector size not an integral multiple of component size}} 373 // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, int>' requested here}} 374 const PR15730<8, int>::type PR15730_1 = {}; 375 // expected-error@#2 {{vector size too large}} 376 // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, char>' requested here}} 377 const PR15730<8, char>::type2 PR15730_2 = {}; 378 } 379 380 } // namespace Templates 381 382 typedef int inte2 __attribute__((__ext_vector_type__(2))); 383 384 void test_vector_literal(inte4 res) { 385 inte2 a = (inte2)(1, 2); //expected-warning{{left operand of comma operator has no effect}} 386 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}} 387 } 388 389 typedef __attribute__((__ext_vector_type__(4))) float vector_float4; 390 typedef __attribute__((__ext_vector_type__(4))) int vector_int4; 391 392 namespace swizzle_template_confusion { 393 template<typename T> struct xyzw {}; 394 vector_int4 foo123(vector_float4 &A, vector_float4 &B) { 395 return A.xyzw < B.x && B.y > A.y; // OK, not a template-id 396 } 397 } 398 399 namespace swizzle_typo_correction { 400 template<typename T> struct xyzv {}; 401 vector_int4 foo123(vector_float4 &A, vector_float4 &B) { 402 return A.xyzw < B.x && B.y > A.y; // OK, not a typo for 'xyzv' 403 } 404 } 405 406 namespace PR45299 { 407 typedef float float4 __attribute__((vector_size(16))); 408 409 // In this example, 'k' is value dependent. PR45299 reported that this asserted 410 // because of that, since the truncation check attempted to constant evaluate k, 411 // which it could not do because it is dependent. 412 template <typename T> 413 struct NormalMember { 414 float4 f(float4 x) { 415 return k * x; 416 } 417 float k; 418 }; 419 420 #if __cplusplus >= 201103L 421 // This should not diagnose, since the constant evaluator (during instantiation) 422 // can tell that this isn't a truncation. 423 template <typename T> 424 struct ConstantValueNoDiag { 425 float4 f(float4 x) { 426 return k * x; 427 } 428 static constexpr double k = 1; 429 }; 430 template <typename T, int N> 431 struct ConstantValueNoDiagDependentValue { 432 float4 f(float4 x) { 433 return k * x; 434 } 435 static constexpr double k = N; 436 }; 437 438 // The following two both diagnose because they cause a truncation. Test both 439 // the dependent type and non-dependent type versions. 440 template <typename T> 441 struct DiagTrunc { 442 float4 f(float4 x) { 443 // expected-error@+1{{as implicit conversion would cause truncation}} 444 return k * x; 445 } 446 static constexpr double k = 1340282346638528859811704183484516925443.000000; 447 }; 448 template <typename T, int N> 449 struct DiagTruncDependentValue { 450 float4 f(float4 x) { 451 // expected-error@+1{{as implicit conversion would cause truncation}} 452 return k * x; 453 } 454 static constexpr double k = N + 1340282346638528859811704183484516925443.000000; 455 }; 456 template <typename T> 457 struct DiagTruncDependentType { 458 float4 f(float4 x) { 459 // expected-error@+1{{as implicit conversion would cause truncation}} 460 return k * x; 461 } 462 static constexpr T k = 1340282346638528859811704183484516925443.000000; 463 }; 464 465 template <typename T> 466 struct PR45298 { 467 T k1 = T(0); 468 }; 469 470 // Ensure this no longer asserts. 471 template <typename T> 472 struct PR45298Consumer { 473 float4 f(float4 x) { 474 return (float)s.k1 * x; 475 } 476 477 PR45298<T> s; 478 }; 479 #endif // __cplusplus >= 201103L 480 481 void use() { 482 float4 theFloat4; 483 NormalMember<double>().f(theFloat4); 484 #if __cplusplus >= 201103L 485 ConstantValueNoDiag<double>().f(theFloat4); 486 ConstantValueNoDiagDependentValue<double, 1>().f(theFloat4); 487 DiagTrunc<double>().f(theFloat4); 488 // expected-note@+1{{in instantiation of member function}} 489 DiagTruncDependentValue<double, 0>().f(theFloat4); 490 // expected-note@+1{{in instantiation of member function}} 491 DiagTruncDependentType<double>().f(theFloat4); 492 PR45298Consumer<double>().f(theFloat4); 493 #endif // __cplusplus >= 201103L 494 } 495 } 496 497 namespace rdar60092165 { 498 template <class T> void f() { 499 typedef T first_type __attribute__((vector_size(sizeof(T) * 4))); 500 typedef T second_type __attribute__((vector_size(sizeof(T) * 4))); 501 502 second_type st; 503 } 504 } 505 506 namespace PR45780 { 507 enum E { Value = 15 }; 508 void use(char16 c) { 509 E e; 510 c &Value; // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}} 511 c == Value; // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}} 512 e | c; // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}} 513 e != c; // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}} 514 } 515 516 } // namespace PR45780 517 518 namespace PR48540 { 519 // The below used to cause an OOM error, or an assert, make sure it is still 520 // valid. 521 int (__attribute__((vector_size(16))) a); 522 523 template <typename T, int I> 524 struct S { 525 T (__attribute__((vector_size(16))) a); 526 int (__attribute__((vector_size(I))) b); 527 T (__attribute__((vector_size(I))) c); 528 }; 529 530 void use() { 531 S<int, 16> s; 532 } 533 } // namespace PR48540 534 535 #if __cplusplus >= 202002L // C++20 or later 536 // Don't crash due to missing integer ranks. 537 char8_t v1 __attribute__((vector_size(16))); 538 char16_t v2 __attribute__((vector_size(16))); 539 char32_t v3 __attribute__((vector_size(16))); 540 wchar_t v4 __attribute__((vector_size(16))); 541 void triggerIntegerRankCheck() { 542 auto b1 = (v1 >= 0x12); 543 auto b2 = (v2 >= 0x12); 544 auto b3 = (v3 >= 0x12); 545 auto b4 = (v4 >= 0x12); 546 } 547 #endif 548 549 namespace all_operators { 550 typedef unsigned int v2u __attribute__((ext_vector_type(2))); 551 typedef float v2f __attribute__((ext_vector_type(2))); 552 553 void test_int_vector_scalar(unsigned int ua, v2u v2ua) { 554 // Operators with one integer vector and one integer scalar operand. The scalar will splat. 555 (void)(v2ua + ua); 556 (void)(ua + v2ua); 557 (void)(v2ua - ua); 558 (void)(ua - v2ua); 559 (void)(v2ua * ua); 560 (void)(ua * v2ua); 561 (void)(v2ua / ua); 562 (void)(ua / v2ua); 563 (void)(v2ua % ua); 564 (void)(ua % v2ua); 565 566 (void)(v2ua == ua); 567 (void)(ua == v2ua); 568 (void)(v2ua != ua); 569 (void)(ua != v2ua); 570 (void)(v2ua <= ua); 571 (void)(ua <= v2ua); 572 (void)(v2ua >= ua); 573 (void)(ua >= v2ua); 574 (void)(v2ua < ua); 575 (void)(ua < v2ua); 576 (void)(v2ua > ua); 577 (void)(ua > v2ua); 578 (void)(v2ua && ua); 579 (void)(ua && v2ua); 580 (void)(v2ua || ua); 581 (void)(ua || v2ua); 582 583 (void)(v2ua & ua); 584 (void)(ua & v2ua); 585 (void)(v2ua | ua); 586 (void)(ua | v2ua); 587 (void)(v2ua ^ ua); 588 (void)(ua ^ v2ua); 589 (void)(v2ua << ua); 590 (void)(ua << v2ua); 591 (void)(v2ua >> ua); 592 (void)(ua >> v2ua); 593 594 v2ua += ua; 595 v2ua -= ua; 596 v2ua *= ua; 597 v2ua /= ua; 598 v2ua %= ua; 599 v2ua &= ua; 600 v2ua |= ua; 601 v2ua ^= ua; 602 v2ua >>= ua; 603 v2ua <<= ua; 604 605 ua += v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 606 ua -= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 607 ua *= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 608 ua /= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 609 ua %= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 610 ua &= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 611 ua |= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 612 ua ^= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 613 ua >>= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 614 ua <<= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}} 615 } 616 617 void test_float_vector_scalar(float fa, unsigned int ua, v2f v2fa) { 618 // Operators with one float vector and one float scalar operand. The scalar will splat. 619 (void)(v2fa + fa); 620 (void)(fa + v2fa); 621 (void)(v2fa - fa); 622 (void)(fa - v2fa); 623 (void)(v2fa * fa); 624 (void)(fa * v2fa); 625 (void)(v2fa / fa); 626 (void)(fa / v2fa); 627 (void)(v2fa % fa); // expected-error{{invalid operands to binary expression}} 628 (void)(fa % v2fa); // expected-error{{invalid operands to binary expression}} 629 630 (void)(v2fa == fa); 631 (void)(fa == v2fa); 632 (void)(v2fa != fa); 633 (void)(fa != v2fa); 634 (void)(v2fa <= fa); 635 (void)(fa <= v2fa); 636 (void)(v2fa >= fa); 637 (void)(fa >= v2fa); 638 (void)(v2fa < fa); 639 (void)(fa < v2fa); 640 (void)(v2fa > fa); 641 (void)(fa > v2fa); 642 (void)(v2fa && fa); 643 (void)(fa && v2fa); 644 (void)(v2fa || fa); 645 (void)(fa || v2fa); 646 647 (void)(v2fa & fa); // expected-error{{invalid operands to binary expression}} 648 (void)(fa & v2fa); // expected-error{{invalid operands to binary expression}} 649 (void)(v2fa | fa); // expected-error{{invalid operands to binary expression}} 650 (void)(fa | v2fa); // expected-error{{invalid operands to binary expression}} 651 (void)(v2fa ^ fa); // expected-error{{invalid operands to binary expression}} 652 (void)(fa ^ v2fa); // expected-error{{invalid operands to binary expression}} 653 (void)(v2fa << fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 654 (void)(v2fa << ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 655 (void)(fa << v2fa); // expected-error{{used type 'float' where integer is required}} 656 (void)(ua << v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 657 (void)(v2fa >> fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 658 (void)(v2fa >> ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 659 (void)(fa >> v2fa); // expected-error{{used type 'float' where integer is required}} 660 (void)(ua >> v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 661 662 v2fa += fa; 663 v2fa -= fa; 664 v2fa *= fa; 665 v2fa /= fa; 666 v2fa %= fa; // expected-error{{invalid operands to binary expression}} 667 v2fa &= fa; // expected-error{{invalid operands to binary expression}} 668 v2fa |= fa; // expected-error{{invalid operands to binary expression}} 669 v2fa ^= fa; // expected-error{{invalid operands to binary expression}} 670 v2fa >>= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 671 v2fa <<= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}} 672 673 fa += v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} 674 fa -= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} 675 fa *= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} 676 fa /= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}} 677 fa %= v2fa; // expected-error{{invalid operands to binary expression}} 678 fa &= v2fa; // expected-error{{invalid operands to binary expression}} 679 fa |= v2fa; // expected-error{{invalid operands to binary expression}} 680 fa ^= v2fa; // expected-error{{invalid operands to binary expression}} 681 fa >>= v2fa; // expected-error{{used type 'float' where integer is required}} 682 fa <<= v2fa; // expected-error{{used type 'float' where integer is required}} 683 } 684 685 enum Enum { ENUM }; 686 687 void test_enum_vector_scalar(Enum ea, v2u v2ua) { 688 // Operators with one integer vector and one enum scalar operand. 689 // The scalar will have an implicit conversion to an integral type and then splat. 690 // FIXME: These should behave the same as in C, they should be accepted via 691 // the enum converting to an integer then splatting to the vector width. 692 // https://github.com/llvm/llvm-project/issues/62869 693 (void)(v2ua + ea); // expected-error{{cannot convert between vector values of different size}} 694 (void)(ea + v2ua); // expected-error{{cannot convert between vector values of different size}} 695 (void)(v2ua - ea); // expected-error{{cannot convert between vector values of different size}} 696 (void)(ea - v2ua); // expected-error{{cannot convert between vector values of different size}} 697 (void)(v2ua * ea); // expected-error{{cannot convert between vector values of different size}} 698 (void)(ea * v2ua); // expected-error{{cannot convert between vector values of different size}} 699 (void)(v2ua / ea); // expected-error{{cannot convert between vector values of different size}} 700 (void)(ea / v2ua); // expected-error{{cannot convert between vector values of different size}} 701 (void)(v2ua % ea); // expected-error{{cannot convert between vector values of different size}} 702 (void)(ea % v2ua); // expected-error{{cannot convert between vector values of different size}} 703 704 (void)(v2ua == ea); // expected-error{{cannot convert between vector values of different size}} 705 (void)(ea == v2ua); // expected-error{{cannot convert between vector values of different size}} 706 (void)(v2ua != ea); // expected-error{{cannot convert between vector values of different size}} 707 (void)(ea != v2ua); // expected-error{{cannot convert between vector values of different size}} 708 (void)(v2ua <= ea); // expected-error{{cannot convert between vector values of different size}} 709 (void)(ea <= v2ua); // expected-error{{cannot convert between vector values of different size}} 710 (void)(v2ua >= ea); // expected-error{{cannot convert between vector values of different size}} 711 (void)(ea >= v2ua); // expected-error{{cannot convert between vector values of different size}} 712 (void)(v2ua < ea); // expected-error{{cannot convert between vector values of different size}} 713 (void)(ea < v2ua); // expected-error{{cannot convert between vector values of different size}} 714 (void)(v2ua > ea); // expected-error{{cannot convert between vector values of different size}} 715 (void)(ea > v2ua); // expected-error{{cannot convert between vector values of different size}} 716 (void)(v2ua && ea); // expected-error{{cannot convert between vector values of different size}} 717 // expected-error@-1{{invalid operands to binary expression}} 718 (void)(ea && v2ua); // expected-error{{cannot convert between vector values of different size}} 719 // expected-error@-1{{invalid operands to binary expression}} 720 (void)(v2ua || ea); // expected-error{{cannot convert between vector values of different size}} 721 // expected-error@-1{{invalid operands to binary expression}} 722 (void)(ea || v2ua); // expected-error{{cannot convert between vector values of different size}} 723 // expected-error@-1{{invalid operands to binary expression}} 724 725 (void)(v2ua & ea); // expected-error{{cannot convert between vector values of different size}} 726 (void)(ea & v2ua); // expected-error{{cannot convert between vector values of different size}} 727 (void)(v2ua | ea); // expected-error{{cannot convert between vector values of different size}} 728 (void)(ea | v2ua); // expected-error{{cannot convert between vector values of different size}} 729 (void)(v2ua ^ ea); // expected-error{{cannot convert between vector values of different size}} 730 (void)(ea ^ v2ua); // expected-error{{cannot convert between vector values of different size}} 731 // FIXME: Vector/scalar shifts cause an assertion failure 732 // https://github.com/llvm/llvm-project/issues/62870 733 // (void)(v2ua << ea); 734 // (void)(ea << v2ua); 735 // (void)(v2ua >> ea); 736 // (void)(ea >> v2ua); 737 738 v2ua += ea; // expected-error{{cannot convert between vector values of different size}} 739 v2ua -= ea; // expected-error{{cannot convert between vector values of different size}} 740 v2ua *= ea; // expected-error{{cannot convert between vector values of different size}} 741 v2ua /= ea; // expected-error{{cannot convert between vector values of different size}} 742 v2ua %= ea; // expected-error{{cannot convert between vector values of different size}} 743 v2ua &= ea; // expected-error{{cannot convert between vector values of different size}} 744 v2ua |= ea; // expected-error{{cannot convert between vector values of different size}} 745 v2ua ^= ea; // expected-error{{cannot convert between vector values of different size}} 746 // FIXME: Vector/scalar shifts cause an assertion failure 747 // https://github.com/llvm/llvm-project/issues/62870 748 // v2ua >>= ea; 749 // v2ua <<= ea; 750 751 ea += v2ua; // expected-error{{cannot convert between vector values of different size}} 752 ea -= v2ua; // expected-error{{cannot convert between vector values of different size}} 753 ea *= v2ua; // expected-error{{cannot convert between vector values of different size}} 754 ea /= v2ua; // expected-error{{cannot convert between vector values of different size}} 755 ea %= v2ua; // expected-error{{cannot convert between vector values of different size}} 756 ea &= v2ua; // expected-error{{cannot convert between vector values of different size}} 757 ea |= v2ua; // expected-error{{cannot convert between vector values of different size}} 758 ea ^= v2ua; // expected-error{{cannot convert between vector values of different size}} 759 // FIXME: Vector/scalar shifts cause an assertion failure 760 // https://github.com/llvm/llvm-project/issues/62870 761 // ea >>= v2ua; // not-expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}} 762 // ea <<= v2ua; // not-expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}} 763 } 764 765 #if __cplusplus >= 201103L // C++11 or later 766 enum class EnumClass { ENUM }; 767 768 void test_scoped_enum_vector(EnumClass ea, v2u v2ua) { 769 // Scoped enumerations are only compatible with exactly matching types. They shouldn't integral promote. 770 (void)(v2ua + ea); // expected-error{{cannot convert between vector and non-scalar values}} 771 (void)(ea + v2ua); // expected-error{{cannot convert between vector and non-scalar values}} 772 } 773 #endif 774 } 775 776 namespace GH105486 { 777 __attribute__((__vector_size__(sizeof(double)))) double a; 778 double b = a - (long)(*0); // expected-error {{indirection requires pointer operand ('int' invalid)}} \ 779 // expected-error {{cannot initialize a variable of type 'double' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(double)))) double' (vector of 1 'double' value)}} 780 781 __attribute__((__vector_size__(sizeof(long)))) long c; 782 long d = c - (long)(*0); // expected-error {{indirection requires pointer operand ('int' invalid)}} \ 783 // expected-error {{cannot initialize a variable of type 'long' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(long)))) long' (vector of 1 'long' value)}} 784 785 const long long e = *0; // expected-error {{indirection requires pointer operand ('int' invalid)}} 786 double f = a - e; // expected-error {{cannot initialize a variable of type 'double' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(double)))) double' (vector of 1 'double' value)}} 787 int h = c - e; // expected-error {{cannot initialize a variable of type 'int' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(long)))) long' (vector of 1 'long' value)}} 788 } 789