clang/test/SemaCXX/vector.cpp

   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=integer -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT
   5 // RUN: %clang_cc1 -flax-vector-conversions=none -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT -DNO_LAX_INT
   6
   7 typedef char char16 __attribute__ ((__vector_size__ (16)));
   8 typedef long long longlong16 __attribute__ ((__vector_size__ (16)));
   9 typedef char char16_e __attribute__ ((__ext_vector_type__ (16)));
  10 typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2)));
  11
  12 // Test overloading and function calls with vector types.
  13 void f0(char16); // expected-note 0+{{candidate}}
  14
  15 void f0_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) {
  16   f0(c16);
  17   f0(ll16);
  18 #ifdef NO_LAX_INT
  19   // expected-error@-2 {{no matching function}}
  20 #endif
  21   f0(c16e);
  22   f0(ll16e);
  23 #ifdef NO_LAX_INT
  24   // expected-error@-2 {{no matching function}}
  25 #endif
  26 }
  27
  28 int &f1(char16);
  29 float &f1(longlong16);
  30
  31 void f1_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) {
  32   int &ir1 = f1(c16);
  33   float &fr1 = f1(ll16);
  34   int &ir2 = f1(c16e);
  35   float &fr2 = f1(ll16e);
  36 }
  37
  38 void f2(char16_e); // expected-note 0+{{candidate}}
  39
  40 void f2_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) {
  41   f2(c16);
  42   f2(ll16);
  43 #ifdef NO_LAX_INT
  44   // expected-error@-2 {{no matching function}}
  45 #endif
  46   f2(c16e);
  47   f2(ll16e); // expected-error{{no matching function}}
  48   f2('a');
  49   f2(17);
  50 }
  51
  52 // Test the conditional operator with vector types.
  53 void conditional(bool Cond, char16 c16, longlong16 ll16, char16_e c16e,
  54                  longlong16_e ll16e) {
  55   // Conditional operators with the same type.
  56   __typeof__(Cond? c16 : c16) *c16p1 = &c16;
  57   __typeof__(Cond? ll16 : ll16) *ll16p1 = &ll16;
  58   __typeof__(Cond? c16e : c16e) *c16ep1 = &c16e;
  59   __typeof__(Cond? ll16e : ll16e) *ll16ep1 = &ll16e;
  60
  61   // Conditional operators with similar types.
  62   __typeof__(Cond? c16 : c16e) *c16ep2 = &c16e;
  63   __typeof__(Cond? c16e : c16) *c16ep3 = &c16e;
  64   __typeof__(Cond? ll16 : ll16e) *ll16ep2 = &ll16e;
  65   __typeof__(Cond? ll16e : ll16) *ll16ep3 = &ll16e;
  66
  67   // Conditional operators with compatible types under -flax-vector-conversions (default)
  68   (void)(Cond? c16 : ll16);
  69   (void)(Cond? ll16e : c16e);
  70   (void)(Cond? ll16e : c16);
  71 #ifdef NO_LAX_INT
  72   // expected-error@-4 {{cannot convert}}
  73   // expected-error@-4 {{cannot convert}}
  74   // expected-error@-4 {{cannot convert}}
  75 #endif
  76 }
  77
  78 // Test C++ cast'ing of vector types.
  79 void casts(longlong16 ll16, longlong16_e ll16e) {
  80   // C-style casts.
  81   (void)(char16)ll16;
  82   (void)(char16_e)ll16;
  83   (void)(longlong16)ll16;
  84   (void)(longlong16_e)ll16;
  85   (void)(char16)ll16e;
  86   (void)(char16_e)ll16e;
  87   (void)(longlong16)ll16e;
  88   (void)(longlong16_e)ll16e;
  89
  90   // Function-style casts.
  91   (void)char16(ll16);
  92   (void)char16_e(ll16);
  93   (void)longlong16(ll16);
  94   (void)longlong16_e(ll16);
  95   (void)char16(ll16e);
  96   (void)char16_e(ll16e);
  97   (void)longlong16(ll16e);
  98   (void)longlong16_e(ll16e);
  99
 100   // static_cast
 101   (void)static_cast<char16>(ll16);
 102   (void)static_cast<char16_e>(ll16);
 103 #ifdef NO_LAX_INT
 104   // expected-error@-3 {{not allowed}}
 105   // expected-error@-3 {{not allowed}}
 106 #endif
 107   (void)static_cast<longlong16>(ll16);
 108   (void)static_cast<longlong16_e>(ll16);
 109   (void)static_cast<char16>(ll16e);
 110 #ifdef NO_LAX_INT
 111   // expected-error@-2 {{not allowed}}
 112 #endif
 113   (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}}
 114   (void)static_cast<longlong16>(ll16e);
 115   (void)static_cast<longlong16_e>(ll16e);
 116
 117   // reinterpret_cast
 118   (void)reinterpret_cast<char16>(ll16);
 119   (void)reinterpret_cast<char16_e>(ll16);
 120   (void)reinterpret_cast<longlong16>(ll16);
 121   (void)reinterpret_cast<longlong16_e>(ll16);
 122   (void)reinterpret_cast<char16>(ll16e);
 123   (void)reinterpret_cast<char16_e>(ll16e);
 124   (void)reinterpret_cast<longlong16>(ll16e);
 125   (void)reinterpret_cast<longlong16_e>(ll16e);
 126 }
 127
 128 template<typename T>
 129 struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable}}
 130 #if __cplusplus >= 201103L // C++11 or later
 131 // expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
 132 #endif
 133   operator T() const;
 134 };
 135
 136 void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16,
 137                                char16_e c16e, longlong16_e ll16e,
 138                                convertible_to<char16> to_c16,
 139                                convertible_to<longlong16> to_ll16,
 140                                convertible_to<char16_e> to_c16e,
 141                                convertible_to<longlong16_e> to_ll16e,
 142                                convertible_to<char16&> rto_c16,
 143                                convertible_to<char16_e&> rto_c16e) {
 144   f0(to_c16);
 145   f0(to_ll16);
 146 #ifdef NO_LAX_INT
 147   // expected-error@-2 {{no matching function}}
 148 #endif
 149   f0(to_c16e);
 150   f0(to_ll16e);
 151 #ifdef NO_LAX_INT
 152   // expected-error@-2 {{no matching function}}
 153 #endif
 154   f2(to_c16);
 155   f2(to_ll16);
 156 #ifdef NO_LAX_INT
 157   // expected-error@-2 {{no matching function}}
 158 #endif
 159   f2(to_c16e);
 160   f2(to_ll16e); // expected-error{{no matching function}}
 161
 162   (void)(c16 == c16e);
 163   (void)(c16 == to_c16);
 164   (void)+to_c16;
 165   (void)-to_c16;
 166   (void)~to_c16;
 167   (void)(to_c16 == to_c16e);
 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_c16);
 174   (void)(to_c16 - to_c16);
 175   (void)(to_c16 * to_c16);
 176   (void)(to_c16 / to_c16);
 177   (void)(rto_c16 = to_c16); // expected-error{{no viable overloaded '='}}
 178   (void)(rto_c16 += to_c16);
 179   (void)(rto_c16 -= to_c16);
 180   (void)(rto_c16 *= to_c16);
 181   (void)(rto_c16 /= to_c16);
 182
 183   (void)+to_c16e;
 184   (void)-to_c16e;
 185   (void)~to_c16e;
 186   (void)(to_c16e == 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_c16);
 193   (void)(to_c16e - to_c16);
 194   (void)(to_c16e * to_c16);
 195   (void)(to_c16e / to_c16);
 196   (void)(rto_c16e = to_c16); // expected-error{{no viable overloaded '='}}
 197   (void)(rto_c16e += to_c16);
 198   (void)(rto_c16e -= to_c16);
 199   (void)(rto_c16e *= to_c16);
 200   (void)(rto_c16e /= to_c16);
 201
 202   (void)+to_c16;
 203   (void)-to_c16;
 204   (void)~to_c16;
 205   (void)(to_c16 == to_c16e);
 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)(rto_c16 = c16e); // expected-error{{no viable overloaded '='}}
 216   (void)(rto_c16 += to_c16e);
 217   (void)(rto_c16 -= to_c16e);
 218   (void)(rto_c16 *= to_c16e);
 219   (void)(rto_c16 /= to_c16e);
 220
 221   (void)(Cond? to_c16 : to_c16e);
 222   (void)(Cond? to_ll16e : to_ll16);
 223
 224   // These 2 are convertible with -flax-vector-conversions (default)
 225   (void)(Cond? to_c16 : to_ll16);
 226   (void)(Cond? to_c16e : to_ll16e);
 227 #ifdef NO_LAX_INT
 228   // expected-error@-3 {{cannot convert}}
 229   // expected-error@-3 {{cannot convert}}
 230 #endif
 231 }
 232
 233 typedef float fltx2 __attribute__((__vector_size__(8)));
 234 typedef float fltx4 __attribute__((__vector_size__(16)));
 235 typedef double dblx2 __attribute__((__vector_size__(16)));
 236 typedef double dblx4 __attribute__((__vector_size__(32)));
 237
 238 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}}
 239 void accept_fltx4(fltx4);
 240 void accept_dblx2(dblx2);
 241 #ifdef NO_LAX_FLOAT
 242 // expected-note@-3 {{no known conversion}}
 243 // expected-note@-3 {{no known conversion}}
 244 #endif
 245 void accept_dblx4(dblx4);
 246 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}}
 247
 248 void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) {
 249   // Exact matches
 250   accept_fltx2(fltx2_val);
 251   accept_fltx4(fltx4_val);
 252   accept_dblx2(dblx2_val);
 253   accept_dblx4(dblx4_val);
 254
 255   // Same-size conversions
 256   accept_fltx4(dblx2_val);
 257   accept_dblx2(fltx4_val);
 258 #ifdef NO_LAX_FLOAT
 259   // expected-error@-3 {{no matching function}}
 260   // expected-error@-3 {{no matching function}}
 261 #endif
 262
 263   // Conversion to bool.
 264   accept_bool(fltx2_val); // expected-error{{no matching function for call to 'accept_bool'}}
 265
 266   // Scalar-to-vector conversions.
 267   accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}}
 268 }
 269
 270 typedef int intx4 __attribute__((__vector_size__(16)));
 271 typedef int inte4 __attribute__((__ext_vector_type__(4)));
 272 typedef float flte4 __attribute__((__ext_vector_type__(4)));
 273
 274 void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, inte4 m) {
 275   (void)(f == g);
 276   (void)(g != f);
 277   (void)(f <= g);
 278   (void)(g >= f);
 279   (void)(f < g);
 280   (void)(g > f);
 281
 282   (void)(+g);
 283   (void)(-g);
 284
 285   (void)(f + g);
 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
 295
 296   (void)(n == m);
 297   (void)(m != n);
 298   (void)(n <= m);
 299   (void)(m >= n);
 300   (void)(n < m);
 301   (void)(m > n);
 302
 303   (void)(+m);
 304   (void)(-m);
 305   (void)(~m);
 306
 307   (void)(n + m);
 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 }
 318
 319 template<typename T> void test_pseudo_dtor_tmpl(T *ptr) {
 320   ptr->~T();
 321   (*ptr).~T();
 322 }
 323
 324 void test_pseudo_dtor(fltx4 *f) {
 325   f->~fltx4();
 326   (*f).~fltx4();
 327   test_pseudo_dtor_tmpl(f);
 328 }
 329
 330 // PR16204
 331 typedef __attribute__((ext_vector_type(4))) int vi4;
 332 const int &reference_to_vec_element = vi4(1).x;
 333
 334 // PR12649
 335 typedef bool bad __attribute__((__vector_size__(16)));  // expected-error {{invalid vector element type 'bool'}}
 336
 337 namespace Templates {
 338 template <typename Elt, unsigned long long Size>
 339 struct TemplateVectorType {
 340   typedef Elt __attribute__((__vector_size__(Size))) type; // #1
 341 };
 342
 343 template <int N, typename T>
 344 struct PR15730 {
 345   typedef T __attribute__((vector_size(N * sizeof(T)))) type;
 346   typedef T __attribute__((vector_size(0x1000000000))) type2; // #2
 347   typedef T __attribute__((vector_size(3))) type3; // #3
 348 };
 349
 350 void Init() {
 351   const TemplateVectorType<float, 32>::type Works = {};
 352   const TemplateVectorType<int, 32>::type Works2 = {};
 353   // expected-error@#1 {{invalid vector element type 'bool'}}
 354   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}}
 355   const TemplateVectorType<bool, 32>::type NoBool = {};
 356   // expected-error@#1 {{invalid vector element type 'int __attribute__((ext_vector_type(4)))' (vector of 4 'int' values)}}
 357   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int __attribute__((ext_vector_type(4))), 32>' requested here}}
 358   const TemplateVectorType<vi4, 32>::type NoComplex = {};
 359   // expected-error@#1 {{vector size not an integral multiple of component size}}
 360   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 33>' requested here}}
 361   const TemplateVectorType<int, 33>::type BadSize = {};
 362   const TemplateVectorType<int, 3200>::type Large = {};
 363   // expected-error@#1 {{vector size too large}}
 364   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 68719476736>' requested here}}
 365   const TemplateVectorType<int, 0x1000000000>::type TooLarge = {};
 366   // expected-error@#1 {{zero vector size}}
 367   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 0>' requested here}}
 368   const TemplateVectorType<int, 0>::type Zero = {};
 369
 370   // expected-error@#2 {{vector size too large}}
 371   // expected-error@#3 {{vector size not an integral multiple of component size}}
 372   // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, int>' requested here}}
 373   const PR15730<8, int>::type PR15730_1 = {};
 374   // expected-error@#2 {{vector size too large}}
 375   // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, char>' requested here}}
 376   const PR15730<8, char>::type2 PR15730_2 = {};
 377 }
 378
 379 } // namespace Templates
 380
 381 typedef int inte2 __attribute__((__ext_vector_type__(2)));
 382
 383 void test_vector_literal(inte4 res) {
 384   inte2 a = (inte2)(1, 2); //expected-warning{{left operand of comma operator has no effect}}
 385   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}}
 386 }
 387
 388 typedef __attribute__((__ext_vector_type__(4))) float vector_float4;
 389 typedef __attribute__((__ext_vector_type__(4))) int vector_int4;
 390
 391 namespace swizzle_template_confusion {
 392   template<typename T> struct xyzw {};
 393   vector_int4 foo123(vector_float4 &A, vector_float4 &B) {
 394     return A.xyzw < B.x && B.y > A.y; // OK, not a template-id
 395   }
 396 }
 397
 398 namespace swizzle_typo_correction {
 399   template<typename T> struct xyzv {};
 400   vector_int4 foo123(vector_float4 &A, vector_float4 &B) {
 401     return A.xyzw < B.x && B.y > A.y; // OK, not a typo for 'xyzv'
 402   }
 403 }
 404
 405 namespace PR45299 {
 406 typedef float float4 __attribute__((vector_size(16)));
 407
 408 // In this example, 'k' is value dependent. PR45299 reported that this asserted
 409 // because of that, since the truncation check attempted to constant evaluate k,
 410 // which it could not do because it is dependent.
 411 template <typename T>
 412 struct NormalMember {
 413   float4 f(float4 x) {
 414     return k * x;
 415   }
 416   float k;
 417 };
 418
 419 #if __cplusplus >= 201103L
 420 // This should not diagnose, since the constant evaluator (during instantiation)
 421 // can tell that this isn't a truncation.
 422 template <typename T>
 423 struct ConstantValueNoDiag {
 424   float4 f(float4 x) {
 425     return k * x;
 426   }
 427   static constexpr double k = 1;
 428 };
 429 template <typename T, int N>
 430 struct ConstantValueNoDiagDependentValue {
 431   float4 f(float4 x) {
 432     return k * x;
 433   }
 434   static constexpr double k = N;
 435 };
 436
 437 // The following two both diagnose because they cause a truncation.  Test both
 438 // the dependent type and non-dependent type versions.
 439 template <typename T>
 440 struct DiagTrunc {
 441   float4 f(float4 x) {
 442     // expected-error@+1{{as implicit conversion would cause truncation}}
 443     return k * x;
 444   }
 445   static constexpr double k = 1340282346638528859811704183484516925443.000000;
 446 };
 447 template <typename T, int N>
 448 struct DiagTruncDependentValue {
 449   float4 f(float4 x) {
 450     // expected-error@+1{{as implicit conversion would cause truncation}}
 451     return k * x;
 452   }
 453   static constexpr double k = N + 1340282346638528859811704183484516925443.000000;
 454 };
 455 template <typename T>
 456 struct DiagTruncDependentType {
 457   float4 f(float4 x) {
 458     // expected-error@+1{{as implicit conversion would cause truncation}}
 459     return k * x;
 460   }
 461   static constexpr T k = 1340282346638528859811704183484516925443.000000;
 462 };
 463
 464 template <typename T>
 465 struct PR45298 {
 466     T k1 = T(0);
 467 };
 468
 469 // Ensure this no longer asserts.
 470 template <typename T>
 471 struct PR45298Consumer {
 472   float4 f(float4 x) {
 473     return (float)s.k1 * x;
 474   }
 475
 476   PR45298<T> s;
 477 };
 478 #endif // __cplusplus >= 201103L
 479
 480 void use() {
 481   float4 theFloat4;
 482   NormalMember<double>().f(theFloat4);
 483 #if __cplusplus >= 201103L
 484   ConstantValueNoDiag<double>().f(theFloat4);
 485   ConstantValueNoDiagDependentValue<double, 1>().f(theFloat4);
 486   DiagTrunc<double>().f(theFloat4);
 487   // expected-note@+1{{in instantiation of member function}}
 488   DiagTruncDependentValue<double, 0>().f(theFloat4);
 489   // expected-note@+1{{in instantiation of member function}}
 490   DiagTruncDependentType<double>().f(theFloat4);
 491   PR45298Consumer<double>().f(theFloat4);
 492 #endif // __cplusplus >= 201103L
 493 }
 494 }
 495
 496 namespace rdar60092165 {
 497 template <class T> void f() {
 498   typedef T first_type __attribute__((vector_size(sizeof(T) * 4)));
 499   typedef T second_type __attribute__((vector_size(sizeof(T) * 4)));
 500
 501   second_type st;
 502 }
 503 }
 504
 505 namespace PR45780 {
 506 enum E { Value = 15 };
 507 void use(char16 c) {
 508   E e;
 509   c &Value;   // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}}
 510   c == Value; // expected-error{{cannot convert between scalar type 'PR45780::E' and vector type 'char16'}}
 511   e | c;      // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}}
 512   e != c;     // expected-error{{cannot convert between scalar type 'E' and vector type 'char16'}}
 513 }
 514
 515 } // namespace PR45780
 516
 517 namespace PR48540 {
 518 // The below used to cause an OOM error, or an assert, make sure it is still
 519 //  valid.
 520 int (__attribute__((vector_size(16))) a);
 521
 522 template <typename T, int I>
 523 struct S {
 524   T (__attribute__((vector_size(16))) a);
 525   int (__attribute__((vector_size(I))) b);
 526   T (__attribute__((vector_size(I))) c);
 527 };
 528
 529 void use() {
 530   S<int, 16> s;
 531 }
 532 } // namespace PR48540