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