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