1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s
2 typedef char char16 __attribute__ ((__vector_size__ (16)));
3 typedef long long longlong16 __attribute__ ((__vector_size__ (16)));
4 typedef char char16_e __attribute__ ((__ext_vector_type__ (16)));
5 typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2)));
6
7 // Test overloading and function calls with vector types.
8 void f0(char16);
9
f0_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)10 void 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
17 int &f1(char16); // expected-note 2{{candidate function}}
18 float &f1(longlong16); // expected-note 2{{candidate function}}
19
f1_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)20 void 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
27 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}} \
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
f2_test(char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)30 void 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.
conditional(bool Cond,char16 c16,longlong16 ll16,char16_e c16e,longlong16_e ll16e)40 void 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.
casts(longlong16 ll16,longlong16_e ll16e)61 void 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
103 template<typename T>
104 struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator)}}
105 operator T() const;
106 };
107
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)108 void 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
192 typedef float fltx2 __attribute__((__vector_size__(8)));
193 typedef float fltx4 __attribute__((__vector_size__(16)));
194 typedef double dblx2 __attribute__((__vector_size__(16)));
195 typedef double dblx4 __attribute__((__vector_size__(32)));
196
197 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}}
198 void accept_fltx4(fltx4);
199 void accept_dblx2(dblx2);
200 void accept_dblx4(dblx4);
201 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}}
202
test(fltx2 fltx2_val,fltx4 fltx4_val,dblx2 dblx2_val,dblx4 dblx4_val)203 void 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
222 typedef int intx4 __attribute__((__vector_size__(16)));
223 typedef int inte4 __attribute__((__ext_vector_type__(4)));
224 typedef int flte4 __attribute__((__ext_vector_type__(4)));
225
test_mixed_vector_types(fltx4 f,intx4 n,flte4 g,flte4 m)226 void 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
test_pseudo_dtor_tmpl(T * ptr)271 template<typename T> void test_pseudo_dtor_tmpl(T *ptr) {
272 ptr->~T();
273 (*ptr).~T();
274 }
275
test_pseudo_dtor(fltx4 * f)276 void test_pseudo_dtor(fltx4 *f) {
277 f->~fltx4();
278 (*f).~fltx4();
279 test_pseudo_dtor_tmpl(f);
280 }
281
282 // PR16204
283 typedef __attribute__((ext_vector_type(4))) int vi4;
284 const int &reference_to_vec_element = vi4(1).x;
285
286 // PR12649
287 typedef bool bad __attribute__((__vector_size__(16))); // expected-error {{invalid vector element type 'bool'}}
288