1 // REQUIRES: powerpc-registered-target
2 // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
3 // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-LE
4 // RUN: not %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64-unknown-unknown -emit-llvm %s -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PPC
5 // Added -target-feature +vsx above to avoid errors about "vector double" and to
6 // generate the correct errors for functions that are only overloaded with VSX
7 // (vec_cmpge, vec_cmple). Without this option, there is only one overload so
8 // it is selected.
9
dummy()10 void dummy() { }
11 signed int si;
12 signed long long sll;
13 unsigned long long ull;
14 signed __int128 sx;
15 unsigned __int128 ux;
16 double d;
17 vector signed char vsc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 };
18 vector unsigned char vuc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 };
19 vector bool char vbc = { 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1 };
20
21 vector signed short vss = { 0, 1, 2, 3, 4, 5, 6, 7 };
22 vector unsigned short vus = { 0, 1, 2, 3, 4, 5, 6, 7 };
23 vector bool short vbs = { 1, 1, 0, 0, 0, 0, 1, 1 };
24
25 vector signed int vsi = { -1, 2, -3, 4 };
26 vector unsigned int vui = { 1, 2, 3, 4 };
27 vector bool int vbi = {0, -1, -1, 0};
28
29 vector signed long long vsll = { 1, 2 };
30 vector unsigned long long vull = { 1, 2 };
31 vector bool long long vbll = { 1, 0 };
32
33 vector signed __int128 vsx = { 1 };
34 vector unsigned __int128 vux = { 1 };
35
36 vector float vfa = { 1.e-4f, -132.23f, -22.1, 32.00f };
37 vector double vda = { 1.e-11, -132.23e10 };
38
39 int res_i;
40 double res_d;
41 signed long long res_sll;
42 unsigned long long res_ull;
43
44 vector signed char res_vsc;
45 vector unsigned char res_vuc;
46 vector bool char res_vbc;
47
48 vector signed short res_vss;
49 vector unsigned short res_vus;
50 vector bool short res_vbs;
51
52 vector signed int res_vsi;
53 vector unsigned int res_vui;
54 vector bool int res_vbi;
55
56 vector signed long long res_vsll;
57 vector unsigned long long res_vull;
58 vector bool long long res_vbll;
59
60 vector signed __int128 res_vsx;
61 vector unsigned __int128 res_vux;
62
63 vector float res_vf;
64 vector double res_vd;
65
66 // CHECK-LABEL: define void @test1
test1()67 void test1() {
68
69 /* vec_abs */
70 res_vsll = vec_abs(vsll);
71 // CHECK: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64>
72 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64>
73 // CHECK-PPC: error: call to 'vec_abs' is ambiguous
74
75 res_vd = vec_abs(vda);
76 // CHECK: store <2 x i64> <i64 9223372036854775807, i64 9223372036854775807>, <2 x i64>*
77 // CHECK: and <2 x i64>
78 // CHECK-LE: store <2 x i64> <i64 9223372036854775807, i64 9223372036854775807>, <2 x i64>*
79 // CHECK-LE: and <2 x i64>
80 // CHECK-PPC: error: call to 'vec_abs' is ambiguous
81
82 /* vec_add */
83 res_vsll = vec_add(vsll, vsll);
84 // CHECK: add <2 x i64>
85 // CHECK-LE: add <2 x i64>
86 // CHECK-PPC: error: call to 'vec_add' is ambiguous
87
88 res_vull = vec_add(vull, vull);
89 // CHECK: add <2 x i64>
90 // CHECK-LE: add <2 x i64>
91 // CHECK-PPC: error: call to 'vec_add' is ambiguous
92
93 /* vec_addc */
94 res_vsi = vec_addc(vsi, vsi);
95 // CHECK: @llvm.ppc.altivec.vaddcuw
96 // CHECK-LE: @llvm.ppc.altivec.vaddcuw
97
98 res_vui = vec_addc(vui, vui);
99 // CHECK: @llvm.ppc.altivec.vaddcuw
100 // CHECK-LE: @llvm.ppc.altivec.vaddcuw
101
102 res_vsx = vec_addc(vsx, vsx);
103 // CHECK: @llvm.ppc.altivec.vaddcuq
104 // CHECK-LE: @llvm.ppc.altivec.vaddcuq
105
106 res_vux = vec_addc(vux, vux);
107 // CHECK: @llvm.ppc.altivec.vaddcuq
108 // CHECK-LE: @llvm.ppc.altivec.vaddcuq
109
110 /* vec_adde */
111 res_vsx = vec_adde(vsx, vsx, vsx);
112 // CHECK: @llvm.ppc.altivec.vaddeuqm
113 // CHECK-LE: @llvm.ppc.altivec.vaddeuqm
114
115 res_vux = vec_adde(vux, vux, vux);
116 // CHECK: @llvm.ppc.altivec.vaddeuqm
117 // CHECK-LE: @llvm.ppc.altivec.vaddeuqm
118
119 /* vec_addec */
120 res_vsx = vec_addec(vsx, vsx, vsx);
121 // CHECK: @llvm.ppc.altivec.vaddecuq
122 // CHECK-LE: @llvm.ppc.altivec.vaddecuq
123
124 /* vec_mergee */
125 res_vbi = vec_mergee(vbi, vbi);
126 // CHECK: @llvm.ppc.altivec.vperm
127 // CHECK-LE: @llvm.ppc.altivec.vperm
128
129 res_vsi = vec_mergee(vsi, vsi);
130 // CHECK: @llvm.ppc.altivec.vperm
131 // CHECK-LE: @llvm.ppc.altivec.vperm
132
133 res_vui = vec_mergee(vui, vui);
134 // CHECK: @llvm.ppc.altivec.vperm
135 // CHECK-LE: @llvm.ppc.altivec.vperm
136 // CHECK-PPC: warning: implicit declaration of function 'vec_mergee'
137
138 /* vec_mergeo */
139 res_vbi = vec_mergeo(vbi, vbi);
140 // CHECK: @llvm.ppc.altivec.vperm
141 // CHECK-LE: @llvm.ppc.altivec.vperm
142
143 res_vsi = vec_mergeo(vsi, vsi);
144 // CHECK: @llvm.ppc.altivec.vperm
145 // CHECK-LE: @llvm.ppc.altivec.vperm
146
147 res_vui = vec_mergeo(vui, vui);
148 // CHECK: @llvm.ppc.altivec.vperm
149 // CHECK-LE: @llvm.ppc.altivec.vperm
150 // CHECK-PPC: warning: implicit declaration of function 'vec_mergeo'
151
152 /* vec_cmpeq */
153 res_vbll = vec_cmpeq(vsll, vsll);
154 // CHECK: @llvm.ppc.altivec.vcmpequd
155 // CHECK-LE: @llvm.ppc.altivec.vcmpequd
156 // CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous
157
158 res_vbll = vec_cmpeq(vull, vull);
159 // CHECK: @llvm.ppc.altivec.vcmpequd
160 // CHECK-LE: @llvm.ppc.altivec.vcmpequd
161 // CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous
162
163 /* vec_cmpge */
164 res_vbll = vec_cmpge(vsll, vsll);
165 // CHECK: @llvm.ppc.altivec.vcmpgtsd
166 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd
167 // CHECK-PPC: error: call to 'vec_cmpge' is ambiguous
168
169 res_vbll = vec_cmpge(vull, vull);
170 // CHECK: @llvm.ppc.altivec.vcmpgtud
171 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud
172 // CHECK-PPC: error: call to 'vec_cmpge' is ambiguous
173
174 /* vec_cmple */
175 res_vbll = vec_cmple(vsll, vsll);
176 // CHECK: @llvm.ppc.altivec.vcmpgtsd
177 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd
178 // CHECK-PPC: error: call to 'vec_cmple' is ambiguous
179
180 res_vbll = vec_cmple(vull, vull);
181 // CHECK: @llvm.ppc.altivec.vcmpgtud
182 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud
183 // CHECK-PPC: error: call to 'vec_cmple' is ambiguous
184
185 /* vec_cmpgt */
186 res_vbll = vec_cmpgt(vsll, vsll);
187 // CHECK: @llvm.ppc.altivec.vcmpgtsd
188 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd
189 // CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous
190
191 res_vbll = vec_cmpgt(vull, vull);
192 // CHECK: @llvm.ppc.altivec.vcmpgtud
193 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud
194 // CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous
195
196 /* vec_cmplt */
197 res_vbll = vec_cmplt(vsll, vsll);
198 // CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}})
199 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}})
200 // CHECK-PPC: error: call to 'vec_cmplt' is ambiguous
201
202 res_vbll = vec_cmplt(vull, vull);
203 // CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}})
204 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}})
205 // CHECK-PPC: error: call to 'vec_cmplt' is ambiguous
206
207 /* vec_double */
208 res_vd = vec_double(vsll);
209 // CHECK: sitofp i64 {{.+}} to double
210 // CHECK-BE: sitofp i64 {{.+}} to double
211
212 res_vd = vec_double(vull);
213 // CHECK: uitofp i64 {{.+}} to double
214 // CHECK-BE: uitofp i64 {{.+}} to double
215
216 /* vec_eqv */
217 res_vsc = vec_eqv(vsc, vsc);
218 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
219 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
220 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
221 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8>
222 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
223 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
224 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
225 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8>
226 // CHECK-PPC: error: assigning to
227
228 res_vsc = vec_eqv(vbc, vbc);
229 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
230 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
231 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
232 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8>
233 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
234 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
235 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
236 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8>
237 // CHECK-PPC: error: assigning to
238
239 res_vuc = vec_eqv(vuc, vuc);
240 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
241 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
242 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
243 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8>
244 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
245 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32>
246 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
247 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8>
248 // CHECK-PPC: error: assigning to
249
250 res_vss = vec_eqv(vss, vss);
251 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
252 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
253 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
254 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16>
255 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
256 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
257 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
258 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16>
259 // CHECK-PPC: error: assigning to
260
261 res_vss = vec_eqv(vbs, vbs);
262 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
263 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
264 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
265 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16>
266 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
267 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
268 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
269 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16>
270 // CHECK-PPC: error: assigning to
271
272 res_vus = vec_eqv(vus, vus);
273 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
274 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
275 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
276 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16>
277 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
278 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32>
279 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
280 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16>
281 // CHECK-PPC: error: assigning to
282
283 res_vsi = vec_eqv(vsi, vsi);
284 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
285 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
286 // CHECK-PPC: error: assigning to
287
288 res_vsi = vec_eqv(vbi, vbi);
289 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
290 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
291 // CHECK-PPC: error: assigning to
292
293 res_vui = vec_eqv(vui, vui);
294 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
295 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}})
296 // CHECK-PPC: error: assigning to
297
298 res_vsll = vec_eqv(vsll, vsll);
299 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
300 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
301 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
302 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64>
303 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
304 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
305 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
306 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64>
307 // CHECK-PPC: error: assigning to
308
309 res_vsll = vec_eqv(vbll, vbll);
310 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
311 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
312 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
313 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64>
314 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
315 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
316 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
317 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64>
318 // CHECK-PPC: error: assigning to
319
320 res_vull = vec_eqv(vull, vull);
321 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
322 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
323 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
324 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64>
325 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
326 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32>
327 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
328 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64>
329 // CHECK-PPC: error: assigning to
330
331 res_vf = vec_eqv(vfa, vfa);
332 // CHECK: [[T1:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32>
333 // CHECK: [[T2:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32>
334 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
335 // CHECK: bitcast <4 x i32> [[T3]] to <4 x float>
336 // CHECK-LE: [[T1:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32>
337 // CHECK-LE: [[T2:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32>
338 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
339 // CHECK-LE: bitcast <4 x i32> [[T3]] to <4 x float>
340 // CHECK-PPC: error: assigning to
341
342 res_vd = vec_eqv(vda, vda);
343 // CHECK: [[T1:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32>
344 // CHECK: [[T2:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32>
345 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
346 // CHECK: bitcast <4 x i32> [[T3]] to <2 x double>
347 // CHECK-LE: [[T1:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32>
348 // CHECK-LE: [[T2:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32>
349 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]])
350 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x double>
351 // CHECK-PPC: error: assigning to
352
353 /* vec_extract */
354 res_sll = vec_extract(vsll, si);
355 // CHECK: extractelement <2 x i64>
356 // CHECK-LE: extractelement <2 x i64>
357
358 res_ull = vec_extract(vull, si);
359 // CHECK: extractelement <2 x i64>
360 // CHECK-LE: extractelement <2 x i64>
361
362 res_ull = vec_extract(vbll, si);
363 // CHECK: extractelement <2 x i64>
364 // CHECK-LE: extractelement <2 x i64>
365
366 res_d = vec_extract(vda, si);
367 // CHECK: extractelement <2 x double>
368 // CHECK-LE: extractelement <2 x double>
369
370 /* vec_insert */
371 res_vsll = vec_insert(sll, vsll, si);
372 // CHECK: insertelement <2 x i64>
373 // CHECK-LE: insertelement <2 x i64>
374
375 res_vbll = vec_insert(ull, vbll, si);
376 // CHECK: insertelement <2 x i64>
377 // CHECK-LE: insertelement <2 x i64>
378
379 res_vull = vec_insert(ull, vull, si);
380 // CHECK: insertelement <2 x i64>
381 // CHECK-LE: insertelement <2 x i64>
382
383 res_vd = vec_insert(d, vda, si);
384 // CHECK: insertelement <2 x double>
385 // CHECK-LE: insertelement <2 x double>
386
387 /* vec_cntlz */
388 res_vsc = vec_cntlz(vsc);
389 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
390 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
391 // CHECK-PPC: warning: implicit declaration of function 'vec_cntlz' is invalid in C99
392
393 res_vuc = vec_cntlz(vuc);
394 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
395 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
396
397 res_vss = vec_cntlz(vss);
398 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)
399 // CHECK-LE: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)
400
401 res_vus = vec_cntlz(vus);
402 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)
403 // CHECK-LE: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)
404
405 res_vsi = vec_cntlz(vsi);
406 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false)
407 // CHECK-LE: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false)
408
409 res_vui = vec_cntlz(vui);
410 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false)
411 // CHECK-LE: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false)
412
413 res_vsll = vec_cntlz(vsll);
414 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false)
415 // CHECK-LE: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false)
416
417 res_vull = vec_cntlz(vull);
418 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false)
419 // CHECK-LE: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false)
420
421 /* ----------------------- predicates --------------------------- */
422 /* vec_all_eq */
423 res_i = vec_all_eq(vsll, vsll);
424 // CHECK: @llvm.ppc.altivec.vcmpequd.p
425 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
426 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
427
428 res_i = vec_all_eq(vsll, vbll);
429 // CHECK: @llvm.ppc.altivec.vcmpequd.p
430 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
431 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
432
433 res_i = vec_all_eq(vull, vull);
434 // CHECK: @llvm.ppc.altivec.vcmpequd.p
435 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
436 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
437
438 res_i = vec_all_eq(vull, vbll);
439 // CHECK: @llvm.ppc.altivec.vcmpequd.p
440 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
441 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
442
443 res_i = vec_all_eq(vbll, vsll);
444 // CHECK: @llvm.ppc.altivec.vcmpequd.p
445 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
446 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
447
448 res_i = vec_all_eq(vbll, vull);
449 // CHECK: @llvm.ppc.altivec.vcmpequd.p
450 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
451 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
452
453 res_i = vec_all_eq(vbll, vbll);
454 // CHECK: @llvm.ppc.altivec.vcmpequd.p
455 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
456 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
457
458 res_i = vec_all_eq(vda, vda);
459 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
460 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
461
462 /* vec_all_ne */
463 res_i = vec_all_ne(vsll, vsll);
464 // CHECK: @llvm.ppc.altivec.vcmpequd.p
465 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
466 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
467
468 res_i = vec_all_ne(vsll, vbll);
469 // CHECK: @llvm.ppc.altivec.vcmpequd.p
470 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
471 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
472
473 res_i = vec_all_ne(vull, vull);
474 // CHECK: @llvm.ppc.altivec.vcmpequd.p
475 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
476 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
477
478 res_i = vec_all_ne(vull, vbll);
479 // CHECK: @llvm.ppc.altivec.vcmpequd.p
480 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
481 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
482
483 res_i = vec_all_ne(vbll, vsll);
484 // CHECK: @llvm.ppc.altivec.vcmpequd.p
485 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
486 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
487
488 res_i = vec_all_ne(vbll, vull);
489 // CHECK: @llvm.ppc.altivec.vcmpequd.p
490 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
491 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
492
493 res_i = vec_all_ne(vbll, vbll);
494 // CHECK: @llvm.ppc.altivec.vcmpequd.p
495 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
496 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
497
498 dummy();
499 // CHECK: @dummy
500
501 res_i = vec_all_ne(vda, vda);
502 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
503 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
504
505 dummy();
506 // CHECK: @dummy
507
508 res_i = vec_all_nge(vda, vda);
509 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p
510 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p
511
512 res_i = vec_all_ngt(vda, vda);
513 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p
514 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p
515
516 /* vec_any_eq */
517 res_i = vec_any_eq(vsll, vsll);
518 // CHECK: @llvm.ppc.altivec.vcmpequd.p
519 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
520 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
521
522 res_i = vec_any_eq(vsll, vbll);
523 // CHECK: @llvm.ppc.altivec.vcmpequd.p
524 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
525 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
526
527 res_i = vec_any_eq(vull, vull);
528 // CHECK: @llvm.ppc.altivec.vcmpequd.p
529 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
530 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
531
532 res_i = vec_any_eq(vull, vbll);
533 // CHECK: @llvm.ppc.altivec.vcmpequd.p
534 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
535 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
536
537 res_i = vec_any_eq(vbll, vsll);
538 // CHECK: @llvm.ppc.altivec.vcmpequd.p
539 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
540 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
541
542 res_i = vec_any_eq(vbll, vull);
543 // CHECK: @llvm.ppc.altivec.vcmpequd.p
544 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
545 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
546
547 res_i = vec_any_eq(vbll, vbll);
548 // CHECK: @llvm.ppc.altivec.vcmpequd.p
549 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
550 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
551
552 res_i = vec_any_eq(vda, vda);
553 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
554 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
555
556 /* vec_any_ne */
557 res_i = vec_any_ne(vsll, vsll);
558 // CHECK: @llvm.ppc.altivec.vcmpequd.p
559 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
560 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
561
562 res_i = vec_any_ne(vsll, vbll);
563 // CHECK: @llvm.ppc.altivec.vcmpequd.p
564 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
565 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
566
567 res_i = vec_any_ne(vull, vull);
568 // CHECK: @llvm.ppc.altivec.vcmpequd.p
569 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
570 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
571
572 res_i = vec_any_ne(vull, vbll);
573 // CHECK: @llvm.ppc.altivec.vcmpequd.p
574 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
575 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
576
577 res_i = vec_any_ne(vbll, vsll);
578 // CHECK: @llvm.ppc.altivec.vcmpequd.p
579 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
580 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
581
582 res_i = vec_any_ne(vbll, vull);
583 // CHECK: @llvm.ppc.altivec.vcmpequd.p
584 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
585 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
586
587 res_i = vec_any_ne(vbll, vbll);
588 // CHECK: @llvm.ppc.altivec.vcmpequd.p
589 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
590 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
591
592 res_i = vec_any_ne(vda, vda);
593 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
594 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
595
596 /* vec_all_ge */
597 res_i = vec_all_ge(vsll, vsll);
598 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
599 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
600 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
601
602 res_i = vec_all_ge(vsll, vbll);
603 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
604 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
605 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
606
607 res_i = vec_all_ge(vull, vull);
608 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
609 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
610 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
611
612 res_i = vec_all_ge(vull, vbll);
613 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
614 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
615 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
616
617 res_i = vec_all_ge(vbll, vsll);
618 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
619 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
620 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
621
622 res_i = vec_all_ge(vbll, vull);
623 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
624 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
625 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
626
627 res_i = vec_all_ge(vbll, vbll);
628 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
629 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
630 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
631
632 res_i = vec_all_ge(vda, vda);
633 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p
634 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p
635
636 /* vec_all_gt */
637 res_i = vec_all_gt(vsll, vsll);
638 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
639 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
640 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
641
642 res_i = vec_all_gt(vsll, vbll);
643 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
644 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
645 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
646
647 res_i = vec_all_gt(vull, vull);
648 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
649 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
650 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
651
652 res_i = vec_all_gt(vull, vbll);
653 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
654 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
655 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
656
657 res_i = vec_all_gt(vbll, vsll);
658 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
659 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
660 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
661
662 res_i = vec_all_gt(vbll, vull);
663 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
664 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
665 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
666
667 res_i = vec_all_gt(vbll, vbll);
668 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
669 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
670 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
671
672 res_i = vec_all_gt(vda, vda);
673 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p
674 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p
675
676 /* vec_all_le */
677 res_i = vec_all_le(vsll, vsll);
678 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
679 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
680 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
681
682 res_i = vec_all_le(vsll, vbll);
683 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
684 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
685 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
686
687 res_i = vec_all_le(vull, vull);
688 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
689 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
690 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
691
692 res_i = vec_all_le(vull, vbll);
693 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
694 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
695 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
696
697 res_i = vec_all_le(vbll, vsll);
698 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
699 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
700 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
701
702 res_i = vec_all_le(vbll, vull);
703 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
704 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
705 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
706
707 res_i = vec_all_le(vbll, vbll);
708 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
709 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
710 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
711
712 res_i = vec_all_le(vda, vda);
713 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p
714 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p
715
716 /* vec_all_lt */
717 res_i = vec_all_lt(vsll, vsll);
718 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
719 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
720 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
721
722 res_i = vec_all_lt(vsll, vbll);
723 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
724 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
725 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
726
727 res_i = vec_all_lt(vull, vull);
728 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
729 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
730 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
731
732 res_i = vec_all_lt(vull, vbll);
733 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
734 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
735 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
736
737 res_i = vec_all_lt(vbll, vsll);
738 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
739 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
740 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
741
742 res_i = vec_all_lt(vbll, vull);
743 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
744 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
745 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
746
747 res_i = vec_all_lt(vbll, vbll);
748 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
749 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
750 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
751
752 res_i = vec_all_lt(vda, vda);
753 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p
754 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p
755
756 res_i = vec_all_nan(vda);
757 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
758 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
759
760 /* vec_any_ge */
761 res_i = vec_any_ge(vsll, vsll);
762 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
763 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
764 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
765
766 res_i = vec_any_ge(vsll, vbll);
767 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
768 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
769 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
770
771 res_i = vec_any_ge(vull, vull);
772 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
773 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
774 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
775
776 res_i = vec_any_ge(vull, vbll);
777 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
778 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
779 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
780
781 res_i = vec_any_ge(vbll, vsll);
782 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
783 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
784 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
785
786 res_i = vec_any_ge(vbll, vull);
787 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
788 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
789 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
790
791 res_i = vec_any_ge(vbll, vbll);
792 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
793 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
794 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
795
796 res_i = vec_any_ge(vda, vda);
797 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p
798 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p
799
800 /* vec_any_gt */
801 res_i = vec_any_gt(vsll, vsll);
802 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
803 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
804 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
805
806 res_i = vec_any_gt(vsll, vbll);
807 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
808 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
809 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
810
811 res_i = vec_any_gt(vull, vull);
812 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
813 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
814 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
815
816 res_i = vec_any_gt(vull, vbll);
817 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
818 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
819 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
820
821 res_i = vec_any_gt(vbll, vsll);
822 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
823 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
824 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
825
826 res_i = vec_any_gt(vbll, vull);
827 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
828 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
829 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
830
831 res_i = vec_any_gt(vbll, vbll);
832 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
833 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
834 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
835
836 res_i = vec_any_gt(vda, vda);
837 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p
838 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p
839
840 /* vec_any_le */
841 res_i = vec_any_le(vsll, vsll);
842 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
843 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
844 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
845
846 res_i = vec_any_le(vsll, vbll);
847 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
848 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
849 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
850
851 res_i = vec_any_le(vull, vull);
852 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
853 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
854 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
855
856 res_i = vec_any_le(vull, vbll);
857 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
858 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
859 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
860
861 res_i = vec_any_le(vbll, vsll);
862 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
863 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
864 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
865
866 res_i = vec_any_le(vbll, vull);
867 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
868 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
869 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
870
871 res_i = vec_any_le(vbll, vbll);
872 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
873 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
874 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
875
876 res_i = vec_any_le(vda, vda);
877 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p
878 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p
879
880 /* vec_any_lt */
881 res_i = vec_any_lt(vsll, vsll);
882 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
883 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
884 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
885
886 res_i = vec_any_lt(vsll, vbll);
887 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
888 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
889 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
890
891 res_i = vec_any_lt(vull, vull);
892 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
893 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
894 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
895
896 res_i = vec_any_lt(vull, vbll);
897 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
898 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
899 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
900
901 res_i = vec_any_lt(vbll, vsll);
902 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
903 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
904 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
905
906 res_i = vec_any_lt(vbll, vull);
907 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
908 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
909 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
910
911 res_i = vec_any_lt(vbll, vbll);
912 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
913 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
914 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
915
916 res_i = vec_any_lt(vda, vda);
917 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p
918 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p
919
920 /* vec_max */
921 res_vsll = vec_max(vsll, vsll);
922 // CHECK: @llvm.ppc.altivec.vmaxsd
923 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
924 // CHECK-PPC: error: call to 'vec_max' is ambiguous
925
926 res_vsll = vec_max(vbll, vsll);
927 // CHECK: @llvm.ppc.altivec.vmaxsd
928 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
929 // CHECK-PPC: error: call to 'vec_max' is ambiguous
930
931 res_vsll = vec_max(vsll, vbll);
932 // CHECK: @llvm.ppc.altivec.vmaxsd
933 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
934 // CHECK-PPC: error: call to 'vec_max' is ambiguous
935
936 res_vull = vec_max(vull, vull);
937 // CHECK: @llvm.ppc.altivec.vmaxud
938 // CHECK-LE: @llvm.ppc.altivec.vmaxud
939 // CHECK-PPC: error: call to 'vec_max' is ambiguous
940
941 res_vull = vec_max(vbll, vull);
942 // CHECK: @llvm.ppc.altivec.vmaxud
943 // CHECK-LE: @llvm.ppc.altivec.vmaxud
944 // CHECK-PPC: error: call to 'vec_max' is ambiguous
945
946 res_vull = vec_max(vull, vbll);
947 // CHECK: @llvm.ppc.altivec.vmaxud
948 // CHECK-LE: @llvm.ppc.altivec.vmaxud
949 // CHECK-PPC: error: call to 'vec_max' is ambiguous
950
951 /* vec_mergeh */
952 res_vbll = vec_mergeh(vbll, vbll);
953 // CHECK: @llvm.ppc.altivec.vperm
954 // CHECK-LE: @llvm.ppc.altivec.vperm
955
956 res_vbll = vec_mergel(vbll, vbll);
957 // CHECK: @llvm.ppc.altivec.vperm
958 // CHECK-LE: @llvm.ppc.altivec.vperm
959
960 /* vec_min */
961 res_vsll = vec_min(vsll, vsll);
962 // CHECK: @llvm.ppc.altivec.vminsd
963 // CHECK-LE: @llvm.ppc.altivec.vminsd
964 // CHECK-PPC: error: call to 'vec_min' is ambiguous
965
966 res_vsll = vec_min(vbll, vsll);
967 // CHECK: @llvm.ppc.altivec.vminsd
968 // CHECK-LE: @llvm.ppc.altivec.vminsd
969 // CHECK-PPC: error: call to 'vec_min' is ambiguous
970
971 res_vsll = vec_min(vsll, vbll);
972 // CHECK: @llvm.ppc.altivec.vminsd
973 // CHECK-LE: @llvm.ppc.altivec.vminsd
974 // CHECK-PPC: error: call to 'vec_min' is ambiguous
975
976 res_vull = vec_min(vull, vull);
977 // CHECK: @llvm.ppc.altivec.vminud
978 // CHECK-LE: @llvm.ppc.altivec.vminud
979 // CHECK-PPC: error: call to 'vec_min' is ambiguous
980
981 res_vull = vec_min(vbll, vull);
982 // CHECK: @llvm.ppc.altivec.vminud
983 // CHECK-LE: @llvm.ppc.altivec.vminud
984 // CHECK-PPC: error: call to 'vec_min' is ambiguous
985
986 res_vull = vec_min(vull, vbll);
987 // CHECK: @llvm.ppc.altivec.vminud
988 // CHECK-LE: @llvm.ppc.altivec.vminud
989 // CHECK-PPC: error: call to 'vec_min' is ambiguous
990
991 /* vec_mule */
992 res_vsll = vec_mule(vsi, vsi);
993 // CHECK: @llvm.ppc.altivec.vmulesw
994 // CHECK-LE: @llvm.ppc.altivec.vmulosw
995 // CHECK-PPC: error: call to 'vec_mule' is ambiguous
996
997 res_vull = vec_mule(vui , vui);
998 // CHECK: @llvm.ppc.altivec.vmuleuw
999 // CHECK-LE: @llvm.ppc.altivec.vmulouw
1000 // CHECK-PPC: error: call to 'vec_mule' is ambiguous
1001
1002 /* vec_mulo */
1003 res_vsll = vec_mulo(vsi, vsi);
1004 // CHECK: @llvm.ppc.altivec.vmulosw
1005 // CHECK-LE: @llvm.ppc.altivec.vmulesw
1006 // CHECK-PPC: error: call to 'vec_mulo' is ambiguous
1007
1008 res_vull = vec_mulo(vui, vui);
1009 // CHECK: @llvm.ppc.altivec.vmulouw
1010 // CHECK-LE: @llvm.ppc.altivec.vmuleuw
1011 // CHECK-PPC: error: call to 'vec_mulo' is ambiguous
1012
1013 /* vec_packs */
1014 res_vsi = vec_packs(vsll, vsll);
1015 // CHECK: @llvm.ppc.altivec.vpksdss
1016 // CHECK-LE: @llvm.ppc.altivec.vpksdss
1017 // CHECK-PPC: error: call to 'vec_packs' is ambiguous
1018
1019 res_vui = vec_packs(vull, vull);
1020 // CHECK: @llvm.ppc.altivec.vpkudus
1021 // CHECK-LE: @llvm.ppc.altivec.vpkudus
1022 // CHECK-PPC: error: call to 'vec_packs' is ambiguous
1023
1024 /* vec_packsu */
1025 res_vui = vec_packsu(vsll, vsll);
1026 // CHECK: @llvm.ppc.altivec.vpksdus
1027 // CHECK-LE: @llvm.ppc.altivec.vpksdus
1028 // CHECK-PPC: error: call to 'vec_packsu' is ambiguous
1029
1030 res_vui = vec_packsu(vull, vull);
1031 // CHECK: @llvm.ppc.altivec.vpkudus
1032 // CHECK-LE: @llvm.ppc.altivec.vpkudus
1033 // CHECK-PPC: error: call to 'vec_packsu' is ambiguous
1034
1035 /* vec_rl */
1036 res_vsll = vec_rl(vsll, vull);
1037 // CHECK: @llvm.ppc.altivec.vrld
1038 // CHECK-LE: @llvm.ppc.altivec.vrld
1039 // CHECK-PPC: error: call to 'vec_rl' is ambiguous
1040
1041 res_vull = vec_rl(vull, vull);
1042 // CHECK: @llvm.ppc.altivec.vrld
1043 // CHECK-LE: @llvm.ppc.altivec.vrld
1044 // CHECK-PPC: error: call to 'vec_rl' is ambiguous
1045
1046 /* vec_sl */
1047 res_vsll = vec_sl(vsll, vull);
1048 // CHECK: shl <2 x i64>
1049 // CHECK-LE: shl <2 x i64>
1050 // CHECK-PPC: error: call to 'vec_sl' is ambiguous
1051
1052 res_vull = vec_sl(vull, vull);
1053 // CHECK: shl <2 x i64>
1054 // CHECK-LE: shl <2 x i64>
1055 // CHECK-PPC: error: call to 'vec_sl' is ambiguous
1056
1057 /* vec_sr */
1058 res_vsll = vec_sr(vsll, vull);
1059 // CHECK: lshr <2 x i64>
1060 // CHECK-LE: lshr <2 x i64>
1061 // CHECK-PPC: error: call to 'vec_sr' is ambiguous
1062
1063 res_vull = vec_sr(vull, vull);
1064 // CHECK: lshr <2 x i64>
1065 // CHECK-LE: lshr <2 x i64>
1066 // CHECK-PPC: error: call to 'vec_sr' is ambiguous
1067
1068 /* vec_sra */
1069 res_vsll = vec_sra(vsll, vull);
1070 // CHECK: ashr <2 x i64>
1071 // CHECK-LE: ashr <2 x i64>
1072 // CHECK-PPC: error: call to 'vec_sra' is ambiguous
1073
1074 res_vull = vec_sra(vull, vull);
1075 // CHECK: ashr <2 x i64>
1076 // CHECK-LE: ashr <2 x i64>
1077 // CHECK-PPC: error: call to 'vec_sra' is ambiguous
1078
1079 /* vec_splats */
1080 res_vsll = vec_splats(sll);
1081 // CHECK: insertelement <2 x i64>
1082 // CHECK-LE: insertelement <2 x i64>
1083
1084 res_vull = vec_splats(ull);
1085 // CHECK: insertelement <2 x i64>
1086 // CHECK-LE: insertelement <2 x i64>
1087
1088 res_vsx = vec_splats(sx);
1089 // CHECK: insertelement <1 x i128>
1090 // CHECK-LE: insertelement <1 x i128>
1091
1092 res_vux = vec_splats(ux);
1093 // CHECK: insertelement <1 x i128>
1094 // CHECK-LE: insertelement <1 x i128>
1095
1096 res_vd = vec_splats(d);
1097 // CHECK: insertelement <2 x double>
1098 // CHECK-LE: insertelement <2 x double>
1099
1100
1101 /* vec_unpackh */
1102 res_vsll = vec_unpackh(vsi);
1103 // CHECK: llvm.ppc.altivec.vupkhsw
1104 // CHECK-LE: llvm.ppc.altivec.vupklsw
1105 // CHECK-PPC: error: call to 'vec_unpackh' is ambiguous
1106
1107 res_vbll = vec_unpackh(vbi);
1108 // CHECK: llvm.ppc.altivec.vupkhsw
1109 // CHECK-LE: llvm.ppc.altivec.vupklsw
1110 // CHECK-PPC: error: call to 'vec_unpackh' is ambiguous
1111
1112 /* vec_unpackl */
1113 res_vsll = vec_unpackl(vsi);
1114 // CHECK: llvm.ppc.altivec.vupklsw
1115 // CHECK-LE: llvm.ppc.altivec.vupkhsw
1116 // CHECK-PPC: error: call to 'vec_unpackl' is ambiguous
1117
1118 res_vbll = vec_unpackl(vbi);
1119 // CHECK: llvm.ppc.altivec.vupklsw
1120 // CHECK-LE: llvm.ppc.altivec.vupkhsw
1121 // CHECK-PPC: error: call to 'vec_unpackl' is ambiguous
1122
1123 /* vec_vpksdss */
1124 res_vsi = vec_vpksdss(vsll, vsll);
1125 // CHECK: llvm.ppc.altivec.vpksdss
1126 // CHECK-LE: llvm.ppc.altivec.vpksdss
1127 // CHECK-PPC: warning: implicit declaration of function 'vec_vpksdss'
1128
1129 /* vec_vpksdus */
1130 res_vui = vec_vpksdus(vsll, vsll);
1131 // CHECK: llvm.ppc.altivec.vpksdus
1132 // CHECK-LE: llvm.ppc.altivec.vpksdus
1133 // CHECK-PPC: warning: implicit declaration of function 'vec_vpksdus'
1134
1135 /* vec_vpkudum */
1136 res_vsi = vec_vpkudum(vsll, vsll);
1137 // CHECK: vperm
1138 // CHECK-LE: vperm
1139 // CHECK-PPC: warning: implicit declaration of function 'vec_vpkudum'
1140
1141 res_vui = vec_vpkudum(vull, vull);
1142 // CHECK: vperm
1143 // CHECK-LE: vperm
1144
1145 res_vui = vec_vpkudus(vull, vull);
1146 // CHECK: llvm.ppc.altivec.vpkudus
1147 // CHECK-LE: llvm.ppc.altivec.vpkudus
1148 // CHECK-PPC: warning: implicit declaration of function 'vec_vpkudus'
1149
1150 /* vec_vupkhsw */
1151 res_vsll = vec_vupkhsw(vsi);
1152 // CHECK: llvm.ppc.altivec.vupkhsw
1153 // CHECK-LE: llvm.ppc.altivec.vupklsw
1154 // CHECK-PPC: warning: implicit declaration of function 'vec_vupkhsw'
1155
1156 res_vbll = vec_vupkhsw(vbi);
1157 // CHECK: llvm.ppc.altivec.vupkhsw
1158 // CHECK-LE: llvm.ppc.altivec.vupklsw
1159
1160 /* vec_vupklsw */
1161 res_vsll = vec_vupklsw(vsi);
1162 // CHECK: llvm.ppc.altivec.vupklsw
1163 // CHECK-LE: llvm.ppc.altivec.vupkhsw
1164 // CHECK-PPC: warning: implicit declaration of function 'vec_vupklsw'
1165
1166 res_vbll = vec_vupklsw(vbi);
1167 // CHECK: llvm.ppc.altivec.vupklsw
1168 // CHECK-LE: llvm.ppc.altivec.vupkhsw
1169
1170 /* vec_max */
1171 res_vsll = vec_max(vsll, vsll);
1172 // CHECK: @llvm.ppc.altivec.vmaxsd
1173 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
1174
1175 res_vsll = vec_max(vbll, vsll);
1176 // CHECK: @llvm.ppc.altivec.vmaxsd
1177 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
1178
1179 res_vsll = vec_max(vsll, vbll);
1180 // CHECK: @llvm.ppc.altivec.vmaxsd
1181 // CHECK-LE: @llvm.ppc.altivec.vmaxsd
1182
1183 res_vull = vec_max(vull, vull);
1184 // CHECK: @llvm.ppc.altivec.vmaxud
1185 // CHECK-LE: @llvm.ppc.altivec.vmaxud
1186
1187 res_vull = vec_max(vbll, vull);
1188 // CHECK: @llvm.ppc.altivec.vmaxud
1189 // CHECK-LE: @llvm.ppc.altivec.vmaxud
1190
1191 /* vec_min */
1192 res_vsll = vec_min(vsll, vsll);
1193 // CHECK: @llvm.ppc.altivec.vminsd
1194 // CHECK-LE: @llvm.ppc.altivec.vminsd
1195
1196 res_vsll = vec_min(vbll, vsll);
1197 // CHECK: @llvm.ppc.altivec.vminsd
1198 // CHECK-LE: @llvm.ppc.altivec.vminsd
1199
1200 res_vsll = vec_min(vsll, vbll);
1201 // CHECK: @llvm.ppc.altivec.vminsd
1202 // CHECK-LE: @llvm.ppc.altivec.vminsd
1203
1204 res_vull = vec_min(vull, vull);
1205 // CHECK: @llvm.ppc.altivec.vminud
1206 // CHECK-LE: @llvm.ppc.altivec.vminud
1207
1208 res_vull = vec_min(vbll, vull);
1209 // CHECK: @llvm.ppc.altivec.vminud
1210 // CHECK-LE: @llvm.ppc.altivec.vminud
1211
1212 /* vec_nand */
1213 res_vsc = vec_nand(vsc, vsc);
1214 // CHECK: [[T1:%.+]] = and <16 x i8>
1215 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1216 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
1217 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1218 // CHECK-PPC: warning: implicit declaration of function 'vec_nand' is invalid in C99
1219
1220 res_vsc = vec_nand(vbc, vbc);
1221 // CHECK: [[T1:%.+]] = and <16 x i8>
1222 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1223 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
1224 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1225
1226 res_vuc = vec_nand(vuc, vuc);
1227 // CHECK: [[T1:%.+]] = and <16 x i8>
1228 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1229 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
1230 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1231
1232 res_vss = vec_nand(vss, vss);
1233 // CHECK: [[T1:%.+]] = and <8 x i16>
1234 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1235 // CHECK-LE: [[T1:%.+]] = and <8 x i16>
1236 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1237
1238 res_vss = vec_nand(vbs, vbs);
1239 // CHECK: [[T1:%.+]] = and <8 x i16>
1240 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1241 // CHECK-LE: [[T1:%.+]] = and <8 x i16>
1242 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1243
1244 res_vus = vec_nand(vus, vus);
1245 // CHECK: [[T1:%.+]] = and <8 x i16>
1246 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1247 // CHECK-LE: [[T1:%.+]] = and <8 x i16>
1248 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1249
1250 res_vsi = vec_nand(vsi, vsi);
1251 // CHECK: [[T1:%.+]] = and <4 x i32>
1252 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1253 // CHECK-LE: [[T1:%.+]] = and <4 x i32>
1254 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1255
1256 res_vsi = vec_nand(vbi, vbi);
1257 // CHECK: [[T1:%.+]] = and <4 x i32>
1258 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1259 // CHECK-LE: [[T1:%.+]] = and <4 x i32>
1260 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1261
1262 res_vui = vec_nand(vui, vui);
1263 // CHECK: [[T1:%.+]] = and <4 x i32>
1264 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1265 // CHECK-LE: [[T1:%.+]] = and <4 x i32>
1266 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
1267
1268 res_vsll = vec_nand(vsll, vsll);
1269 // CHECK: [[T1:%.+]] = and <2 x i64>
1270 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1271 // CHECK-LE: [[T1:%.+]] = and <2 x i64>
1272 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1273
1274 res_vsll = vec_nand(vbll, vbll);
1275 // CHECK: [[T1:%.+]] = and <2 x i64>
1276 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1277 // CHECK-LE: [[T1:%.+]] = and <2 x i64>
1278 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1279
1280 res_vull = vec_nand(vull, vull);
1281 // CHECK: [[T1:%.+]] = and <2 x i64>
1282 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1283 // CHECK-LE: [[T1:%.+]] = and <2 x i64>
1284 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1>
1285
1286 /* vec_orc */
1287 res_vsc = vec_orc(vsc, vsc);
1288 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1289 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1290 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1291 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1292 // CHECK-PPC: warning: implicit declaration of function 'vec_orc' is invalid in C99
1293
1294 res_vsc = vec_orc(vsc, vbc);
1295 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1296 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1297 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1298 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1299
1300 res_vsc = vec_orc(vbc, vsc);
1301 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1302 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1303 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1304 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1305
1306 res_vuc = vec_orc(vuc, vuc);
1307 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1308 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1309 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1310 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1311
1312 res_vuc = vec_orc(vuc, vbc);
1313 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1314 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1315 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1316 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1317
1318 res_vuc = vec_orc(vbc, vuc);
1319 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1320 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1321 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1322 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1323
1324 res_vbc = vec_orc(vbc, vbc);
1325 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1326 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
1327 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
1328 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
1329
1330 res_vss = vec_orc(vss, vss);
1331 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1332 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1333 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1334 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1335
1336 res_vss = vec_orc(vss, vbs);
1337 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1338 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1339 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1340 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1341
1342 res_vss = vec_orc(vbs, vss);
1343 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1344 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1345 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1346 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1347
1348 res_vus = vec_orc(vus, vus);
1349 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1350 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1351 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1352 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1353
1354 res_vus = vec_orc(vus, vbs);
1355 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1356 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1357 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1358 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1359
1360 res_vus = vec_orc(vbs, vus);
1361 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1362 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1363 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1364 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1365
1366 res_vbs = vec_orc(vbs, vbs);
1367 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1368 // CHECK: or <8 x i16> {{%.+}}, [[T1]]
1369 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
1370 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]]
1371
1372 res_vsi = vec_orc(vsi, vsi);
1373 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1374 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1375 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1376 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1377
1378 res_vsi = vec_orc(vsi, vbi);
1379 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1380 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1381 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1382 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1383
1384 res_vsi = vec_orc(vbi, vsi);
1385 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1386 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1387 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1388 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1389
1390 res_vui = vec_orc(vui, vui);
1391 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1392 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1393 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1394 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1395
1396 res_vui = vec_orc(vui, vbi);
1397 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1398 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1399 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1400 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1401
1402 res_vui = vec_orc(vbi, vui);
1403 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1404 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1405 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1406 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1407
1408 res_vbi = vec_orc(vbi, vbi);
1409 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1410 // CHECK: or <4 x i32> {{%.+}}, [[T1]]
1411 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1>
1412 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]]
1413
1414 res_vsll = vec_orc(vsll, vsll);
1415 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1416 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1417 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1418 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1419
1420 res_vsll = vec_orc(vsll, vbll);
1421 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1422 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1423 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1424 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1425
1426 res_vsll = vec_orc(vbll, vsll);
1427 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1428 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1429 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1430 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1431
1432 res_vull = vec_orc(vull, vull);
1433 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1434 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1435 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1436 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1437
1438 res_vull = vec_orc(vull, vbll);
1439 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1440 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1441 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1442 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1443
1444 res_vull = vec_orc(vbll, vull);
1445 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1446 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1447 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1448 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1449
1450 res_vbll = vec_orc(vbll, vbll);
1451 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1452 // CHECK: or <2 x i64> {{%.+}}, [[T1]]
1453 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1>
1454 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]]
1455
1456 /* vec_sub */
1457 res_vsll = vec_sub(vsll, vsll);
1458 // CHECK: sub <2 x i64>
1459 // CHECK-LE: sub <2 x i64>
1460
1461 res_vull = vec_sub(vull, vull);
1462 // CHECK: sub <2 x i64>
1463 // CHECK-LE: sub <2 x i64>
1464
1465 res_vd = vec_sub(vda, vda);
1466 // CHECK: fsub <2 x double>
1467 // CHECK-LE: fsub <2 x double>
1468
1469 res_vsx = vec_sub(vsx, vsx);
1470 // CHECK: sub <1 x i128>
1471 // CHECK-LE: sub <1 x i128>
1472
1473 res_vux = vec_sub(vux, vux);
1474 // CHECK: sub <1 x i128>
1475 // CHECK-LE: sub <1 x i128>
1476
1477 /* vec_vbpermq */
1478 res_vsll = vec_vbpermq(vsc, vsc);
1479 // CHECK: llvm.ppc.altivec.vbpermq
1480 // CHECK-LE: llvm.ppc.altivec.vbpermq
1481
1482 res_vull = vec_vbpermq(vuc, vuc);
1483 // CHECK: llvm.ppc.altivec.vbpermq
1484 // CHECK-LE: llvm.ppc.altivec.vbpermq
1485 // CHECK-PPC: warning: implicit declaration of function 'vec_vbpermq'
1486
1487 /* vec_vgbbd */
1488 res_vsc = vec_vgbbd(vsc);
1489 // CHECK: llvm.ppc.altivec.vgbbd
1490 // CHECK-LE: llvm.ppc.altivec.vgbbd
1491
1492 res_vuc = vec_vgbbd(vuc);
1493 // CHECK: llvm.ppc.altivec.vgbbd
1494 // CHECK-LE: llvm.ppc.altivec.vgbbd
1495 // CHECK-PPC: warning: implicit declaration of function 'vec_vgbbd'
1496
1497 res_vuc = vec_gb(vuc);
1498 // CHECK: llvm.ppc.altivec.vgbbd
1499 // CHECK-LE: llvm.ppc.altivec.vgbbd
1500 // CHECK-PPC: warning: implicit declaration of function 'vec_gb'
1501
1502 res_vull = vec_bperm(vux, vux);
1503 // CHECK: llvm.ppc.altivec.vbpermq
1504 // CHECK-LE: llvm.ppc.altivec.vbpermq
1505 // CHECK-PPC: warning: implicit declaration of function 'vec_bperm'
1506 }
1507