1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++98 %s 3 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++11 %s 4 5 typedef char char16 __attribute__ ((__vector_size__ (16))); 6 typedef long long longlong16 __attribute__ ((__vector_size__ (16))); 7 typedef char char16_e __attribute__ ((__ext_vector_type__ (16))); 8 typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2))); 9 10 // Test overloading and function calls with vector types. 11 void f0(char16); 12 f0_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)13 void f0_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 14 f0(c16); 15 f0(ll16); 16 f0(c16e); 17 f0(ll16e); 18 } 19 20 int &f1(char16); // expected-note 2{{candidate function}} 21 float &f1(longlong16); // expected-note 2{{candidate function}} 22 f1_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)23 void f1_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 24 int &ir1 = f1(c16); 25 float &fr1 = f1(ll16); 26 f1(c16e); // expected-error{{call to 'f1' is ambiguous}} 27 f1(ll16e); // expected-error{{call to 'f1' is ambiguous}} 28 } 29 30 void f2(char16_e); // expected-note{{no known conversion from 'longlong16_e' (vector of 2 'long long' values) to 'char16_e' (vector of 16 'char' values) for 1st argument}} \ 31 // expected-note{{candidate function not viable: no known conversion from 'convertible_to<longlong16_e>' to 'char16_e' (vector of 16 'char' values) for 1st argument}} 32 f2_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)33 void f2_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { 34 f2(c16); 35 f2(ll16); 36 f2(c16e); 37 f2(ll16e); // expected-error{{no matching function}} 38 f2('a'); 39 f2(17); 40 } 41 42 // Test the conditional operator with vector types. conditional(bool Cond,char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)43 void conditional(bool Cond, char16 c16, longlong16 ll16, char16_e c16e, 44 longlong16_e ll16e) { 45 // Conditional operators with the same type. 46 __typeof__(Cond? c16 : c16) *c16p1 = &c16; 47 __typeof__(Cond? ll16 : ll16) *ll16p1 = &ll16; 48 __typeof__(Cond? c16e : c16e) *c16ep1 = &c16e; 49 __typeof__(Cond? ll16e : ll16e) *ll16ep1 = &ll16e; 50 51 // Conditional operators with similar types. 52 __typeof__(Cond? c16 : c16e) *c16ep2 = &c16e; 53 __typeof__(Cond? c16e : c16) *c16ep3 = &c16e; 54 __typeof__(Cond? ll16 : ll16e) *ll16ep2 = &ll16e; 55 __typeof__(Cond? ll16e : ll16) *ll16ep3 = &ll16e; 56 57 // Conditional operators with compatible types under -flax-vector-conversions (default) 58 (void)(Cond? c16 : ll16); 59 (void)(Cond? ll16e : c16e); 60 (void)(Cond? ll16e : c16); 61 } 62 63 // Test C++ cast'ing of vector types. casts(longlong16 ll16,longlong16_e ll16e)64 void casts(longlong16 ll16, longlong16_e ll16e) { 65 // C-style casts. 66 (void)(char16)ll16; 67 (void)(char16_e)ll16; 68 (void)(longlong16)ll16; 69 (void)(longlong16_e)ll16; 70 (void)(char16)ll16e; 71 (void)(char16_e)ll16e; 72 (void)(longlong16)ll16e; 73 (void)(longlong16_e)ll16e; 74 75 // Function-style casts. 76 (void)char16(ll16); 77 (void)char16_e(ll16); 78 (void)longlong16(ll16); 79 (void)longlong16_e(ll16); 80 (void)char16(ll16e); 81 (void)char16_e(ll16e); 82 (void)longlong16(ll16e); 83 (void)longlong16_e(ll16e); 84 85 // static_cast 86 (void)static_cast<char16>(ll16); 87 (void)static_cast<char16_e>(ll16); 88 (void)static_cast<longlong16>(ll16); 89 (void)static_cast<longlong16_e>(ll16); 90 (void)static_cast<char16>(ll16e); 91 (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}} 92 (void)static_cast<longlong16>(ll16e); 93 (void)static_cast<longlong16_e>(ll16e); 94 95 // reinterpret_cast 96 (void)reinterpret_cast<char16>(ll16); 97 (void)reinterpret_cast<char16_e>(ll16); 98 (void)reinterpret_cast<longlong16>(ll16); 99 (void)reinterpret_cast<longlong16_e>(ll16); 100 (void)reinterpret_cast<char16>(ll16e); 101 (void)reinterpret_cast<char16_e>(ll16e); 102 (void)reinterpret_cast<longlong16>(ll16e); 103 (void)reinterpret_cast<longlong16_e>(ll16e); 104 } 105 106 template<typename T> 107 struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable}} 108 #if __cplusplus >= 201103L // C++11 or later 109 // expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}} 110 #endif 111 operator T() const; 112 }; 113 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)114 void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16, 115 char16_e c16e, longlong16_e ll16e, 116 convertible_to<char16> to_c16, 117 convertible_to<longlong16> to_ll16, 118 convertible_to<char16_e> to_c16e, 119 convertible_to<longlong16_e> to_ll16e, 120 convertible_to<char16&> rto_c16, 121 convertible_to<char16_e&> rto_c16e) { 122 f0(to_c16); 123 f0(to_ll16); 124 f0(to_c16e); 125 f0(to_ll16e); 126 f2(to_c16); 127 f2(to_ll16); 128 f2(to_c16e); 129 f2(to_ll16e); // expected-error{{no matching function}} 130 131 (void)(c16 == c16e); 132 (void)(c16 == to_c16); 133 (void)+to_c16; 134 (void)-to_c16; 135 (void)~to_c16; 136 (void)(to_c16 == to_c16e); 137 (void)(to_c16 != to_c16e); 138 (void)(to_c16 < to_c16e); 139 (void)(to_c16 <= to_c16e); 140 (void)(to_c16 > to_c16e); 141 (void)(to_c16 >= to_c16e); 142 (void)(to_c16 + to_c16); 143 (void)(to_c16 - to_c16); 144 (void)(to_c16 * to_c16); 145 (void)(to_c16 / to_c16); 146 (void)(rto_c16 = to_c16); // expected-error{{no viable overloaded '='}} 147 (void)(rto_c16 += to_c16); 148 (void)(rto_c16 -= to_c16); 149 (void)(rto_c16 *= to_c16); 150 (void)(rto_c16 /= to_c16); 151 152 (void)+to_c16e; 153 (void)-to_c16e; 154 (void)~to_c16e; 155 (void)(to_c16e == to_c16e); 156 (void)(to_c16e != to_c16e); 157 (void)(to_c16e < to_c16e); 158 (void)(to_c16e <= to_c16e); 159 (void)(to_c16e > to_c16e); 160 (void)(to_c16e >= to_c16e); 161 (void)(to_c16e + to_c16); 162 (void)(to_c16e - to_c16); 163 (void)(to_c16e * to_c16); 164 (void)(to_c16e / to_c16); 165 (void)(rto_c16e = to_c16); // expected-error{{no viable overloaded '='}} 166 (void)(rto_c16e += to_c16); 167 (void)(rto_c16e -= to_c16); 168 (void)(rto_c16e *= to_c16); 169 (void)(rto_c16e /= to_c16); 170 171 (void)+to_c16; 172 (void)-to_c16; 173 (void)~to_c16; 174 (void)(to_c16 == to_c16e); 175 (void)(to_c16 != to_c16e); 176 (void)(to_c16 < to_c16e); 177 (void)(to_c16 <= to_c16e); 178 (void)(to_c16 > to_c16e); 179 (void)(to_c16 >= to_c16e); 180 (void)(to_c16 + to_c16e); 181 (void)(to_c16 - to_c16e); 182 (void)(to_c16 * to_c16e); 183 (void)(to_c16 / to_c16e); 184 (void)(rto_c16 = c16e); // expected-error{{no viable overloaded '='}} 185 (void)(rto_c16 += to_c16e); 186 (void)(rto_c16 -= to_c16e); 187 (void)(rto_c16 *= to_c16e); 188 (void)(rto_c16 /= to_c16e); 189 190 (void)(Cond? to_c16 : to_c16e); 191 (void)(Cond? to_ll16e : to_ll16); 192 193 // These 2 are convertable with -flax-vector-conversions (default) 194 (void)(Cond? to_c16 : to_ll16); 195 (void)(Cond? to_c16e : to_ll16e); 196 } 197 198 typedef float fltx2 __attribute__((__vector_size__(8))); 199 typedef float fltx4 __attribute__((__vector_size__(16))); 200 typedef double dblx2 __attribute__((__vector_size__(16))); 201 typedef double dblx4 __attribute__((__vector_size__(32))); 202 203 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}} 204 void accept_fltx4(fltx4); 205 void accept_dblx2(dblx2); 206 void accept_dblx4(dblx4); 207 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}} 208 test(fltx2 fltx2_val,fltx4 fltx4_val,dblx2 dblx2_val,dblx4 dblx4_val)209 void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) { 210 // Exact matches 211 accept_fltx2(fltx2_val); 212 accept_fltx4(fltx4_val); 213 accept_dblx2(dblx2_val); 214 accept_dblx4(dblx4_val); 215 216 // Same-size conversions 217 // FIXME: G++ rejects these conversions, we accept them. Revisit this! 218 accept_fltx4(dblx2_val); 219 accept_dblx2(fltx4_val); 220 221 // Conversion to bool. 222 accept_bool(fltx2_val); // expected-error{{no matching function for call to 'accept_bool'}} 223 224 // Scalar-to-vector conversions. 225 accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}} 226 } 227 228 typedef int intx4 __attribute__((__vector_size__(16))); 229 typedef int inte4 __attribute__((__ext_vector_type__(4))); 230 typedef int flte4 __attribute__((__ext_vector_type__(4))); 231 test_mixed_vector_types(fltx4 f,intx4 n,flte4 g,flte4 m)232 void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, flte4 m) { 233 (void)(f == g); 234 (void)(g != f); 235 (void)(f <= g); 236 (void)(g >= f); 237 (void)(f < g); 238 (void)(g > f); 239 240 (void)(+g); 241 (void)(-g); 242 243 (void)(f + g); 244 (void)(f - g); 245 (void)(f * g); 246 (void)(f / g); 247 (void)(f = g); 248 (void)(f += g); 249 (void)(f -= g); 250 (void)(f *= g); 251 (void)(f /= g); 252 253 254 (void)(n == m); 255 (void)(m != n); 256 (void)(n <= m); 257 (void)(m >= n); 258 (void)(n < m); 259 (void)(m > n); 260 261 (void)(+m); 262 (void)(-m); 263 (void)(~m); 264 265 (void)(n + m); 266 (void)(n - m); 267 (void)(n * m); 268 (void)(n / m); 269 (void)(n % m); 270 (void)(n = m); 271 (void)(n += m); 272 (void)(n -= m); 273 (void)(n *= m); 274 (void)(n /= m); 275 } 276 test_pseudo_dtor_tmpl(T * ptr)277 template<typename T> void test_pseudo_dtor_tmpl(T *ptr) { 278 ptr->~T(); 279 (*ptr).~T(); 280 } 281 test_pseudo_dtor(fltx4 * f)282 void test_pseudo_dtor(fltx4 *f) { 283 f->~fltx4(); 284 (*f).~fltx4(); 285 test_pseudo_dtor_tmpl(f); 286 } 287 288 // PR16204 289 typedef __attribute__((ext_vector_type(4))) int vi4; 290 const int &reference_to_vec_element = vi4(1).x; 291 292 // PR12649 293 typedef bool bad __attribute__((__vector_size__(16))); // expected-error {{invalid vector element type 'bool'}} 294