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