1 // REQUIRES: systemz-registered-target
2 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
3 // RUN: -O -fzvector -flax-vector-conversions=none \
4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
5 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
6 // RUN: -O -fzvector -flax-vector-conversions=none \
7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
8
9 #include <vecintrin.h>
10
11 volatile vector signed char vsc;
12 volatile vector signed short vss;
13 volatile vector signed int vsi;
14 volatile vector signed long long vsl;
15 volatile vector unsigned char vuc;
16 volatile vector unsigned short vus;
17 volatile vector unsigned int vui;
18 volatile vector unsigned long long vul;
19 volatile vector bool char vbc;
20 volatile vector bool short vbs;
21 volatile vector bool int vbi;
22 volatile vector bool long long vbl;
23 volatile vector double vd;
24
25 volatile signed char sc;
26 volatile signed short ss;
27 volatile signed int si;
28 volatile signed long long sl;
29 volatile unsigned char uc;
30 volatile unsigned short us;
31 volatile unsigned int ui;
32 volatile unsigned long long ul;
33 volatile double d;
34
35 const void * volatile cptr;
36 const signed char * volatile cptrsc;
37 const signed short * volatile cptrss;
38 const signed int * volatile cptrsi;
39 const signed long long * volatile cptrsl;
40 const unsigned char * volatile cptruc;
41 const unsigned short * volatile cptrus;
42 const unsigned int * volatile cptrui;
43 const unsigned long long * volatile cptrul;
44 const float * volatile cptrf;
45 const double * volatile cptrd;
46
47 void * volatile ptr;
48 signed char * volatile ptrsc;
49 signed short * volatile ptrss;
50 signed int * volatile ptrsi;
51 signed long long * volatile ptrsl;
52 unsigned char * volatile ptruc;
53 unsigned short * volatile ptrus;
54 unsigned int * volatile ptrui;
55 unsigned long long * volatile ptrul;
56 float * volatile ptrf;
57 double * volatile ptrd;
58
59 volatile unsigned int len;
60 volatile int idx;
61 int cc;
62
test_core(void)63 void test_core(void) {
64 // CHECK-ASM-LABEL: test_core
65
66 len = __lcbb(cptr, 64);
67 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 0)
68 // CHECK-ASM: lcbb
69 len = __lcbb(cptr, 128);
70 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 1)
71 // CHECK-ASM: lcbb
72 len = __lcbb(cptr, 256);
73 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 2)
74 // CHECK-ASM: lcbb
75 len = __lcbb(cptr, 512);
76 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 3)
77 // CHECK-ASM: lcbb
78 len = __lcbb(cptr, 1024);
79 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 4)
80 // CHECK-ASM: lcbb
81 len = __lcbb(cptr, 2048);
82 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 5)
83 // CHECK-ASM: lcbb
84 len = __lcbb(cptr, 4096);
85 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 6)
86 // CHECK-ASM: lcbb
87
88 sc = vec_extract(vsc, idx);
89 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
90 // CHECK-ASM: vlgvb
91 uc = vec_extract(vuc, idx);
92 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
93 // CHECK-ASM: vlgvb
94 uc = vec_extract(vbc, idx);
95 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
96 // CHECK-ASM: vlgvb
97 ss = vec_extract(vss, idx);
98 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
99 // CHECK-ASM: vlgvh
100 us = vec_extract(vus, idx);
101 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
102 // CHECK-ASM: vlgvh
103 us = vec_extract(vbs, idx);
104 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
105 // CHECK-ASM: vlgvh
106 si = vec_extract(vsi, idx);
107 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
108 // CHECK-ASM: vlgvf
109 ui = vec_extract(vui, idx);
110 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
111 // CHECK-ASM: vlgvf
112 ui = vec_extract(vbi, idx);
113 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
114 // CHECK-ASM: vlgvf
115 sl = vec_extract(vsl, idx);
116 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
117 // CHECK-ASM: vlgvg
118 ul = vec_extract(vul, idx);
119 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
120 // CHECK-ASM: vlgvg
121 ul = vec_extract(vbl, idx);
122 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
123 // CHECK-ASM: vlgvg
124 d = vec_extract(vd, idx);
125 // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
126 // CHECK-ASM: vlgvg
127
128 vsc = vec_insert(sc, vsc, idx);
129 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
130 // CHECK-ASM: vlvgb
131 vuc = vec_insert(uc, vuc, idx);
132 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
133 // CHECK-ASM: vlvgb
134 vuc = vec_insert(uc, vbc, idx);
135 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
136 // CHECK-ASM: vlvgb
137 vss = vec_insert(ss, vss, idx);
138 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
139 // CHECK-ASM: vlvgh
140 vus = vec_insert(us, vus, idx);
141 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
142 // CHECK-ASM: vlvgh
143 vus = vec_insert(us, vbs, idx);
144 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
145 // CHECK-ASM: vlvgh
146 vsi = vec_insert(si, vsi, idx);
147 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
148 // CHECK-ASM: vlvgf
149 vui = vec_insert(ui, vui, idx);
150 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
151 // CHECK-ASM: vlvgf
152 vui = vec_insert(ui, vbi, idx);
153 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
154 // CHECK-ASM: vlvgf
155 vsl = vec_insert(sl, vsl, idx);
156 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
157 // CHECK-ASM: vlvgg
158 vul = vec_insert(ul, vul, idx);
159 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
160 // CHECK-ASM: vlvgg
161 vul = vec_insert(ul, vbl, idx);
162 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
163 // CHECK-ASM: vlvgg
164 vd = vec_insert(d, vd, idx);
165 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
166 // CHECK-ASM: vlvgg
167
168 vsc = vec_promote(sc, idx);
169 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}}
170 // CHECK-ASM: vlvgb
171 vuc = vec_promote(uc, idx);
172 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}}
173 // CHECK-ASM: vlvgb
174 vss = vec_promote(ss, idx);
175 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}}
176 // CHECK-ASM: vlvgh
177 vus = vec_promote(us, idx);
178 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}}
179 // CHECK-ASM: vlvgh
180 vsi = vec_promote(si, idx);
181 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}}
182 // CHECK-ASM: vlvgf
183 vui = vec_promote(ui, idx);
184 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}}
185 // CHECK-ASM: vlvgf
186 vsl = vec_promote(sl, idx);
187 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}}
188 // CHECK-ASM: vlvgg
189 vul = vec_promote(ul, idx);
190 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}}
191 // CHECK-ASM: vlvgg
192 vd = vec_promote(d, idx);
193 // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
194 // CHECK-ASM: vlvgg
195
196 vsc = vec_insert_and_zero(cptrsc);
197 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7
198 // CHECK-ASM: vllezb
199 vuc = vec_insert_and_zero(cptruc);
200 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7
201 // CHECK-ASM: vllezb
202 vss = vec_insert_and_zero(cptrss);
203 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3
204 // CHECK-ASM: vllezh
205 vus = vec_insert_and_zero(cptrus);
206 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3
207 // CHECK-ASM: vllezh
208 vsi = vec_insert_and_zero(cptrsi);
209 // CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1
210 // CHECK-ASM: vllezf
211 vui = vec_insert_and_zero(cptrui);
212 // CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1
213 // CHECK-ASM: vllezf
214 vsl = vec_insert_and_zero(cptrsl);
215 // CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0
216 // CHECK-ASM: vllezg
217 vul = vec_insert_and_zero(cptrul);
218 // CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0
219 // CHECK-ASM: vllezg
220 vd = vec_insert_and_zero(cptrd);
221 // CHECK: insertelement <2 x double> <double undef, double 0.000000e+00>, double %{{.*}}, i32 0
222 // CHECK-ASM: vllezg
223
224 vsc = vec_perm(vsc, vsc, vuc);
225 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
226 // CHECK-ASM: vperm
227 vuc = vec_perm(vuc, vuc, vuc);
228 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
229 // CHECK-ASM: vperm
230 vbc = vec_perm(vbc, vbc, vuc);
231 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
232 // CHECK-ASM: vperm
233 vss = vec_perm(vss, vss, vuc);
234 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
235 // CHECK-ASM: vperm
236 vus = vec_perm(vus, vus, vuc);
237 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
238 // CHECK-ASM: vperm
239 vbs = vec_perm(vbs, vbs, vuc);
240 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
241 // CHECK-ASM: vperm
242 vsi = vec_perm(vsi, vsi, vuc);
243 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
244 // CHECK-ASM: vperm
245 vui = vec_perm(vui, vui, vuc);
246 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
247 // CHECK-ASM: vperm
248 vbi = vec_perm(vbi, vbi, vuc);
249 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
250 // CHECK-ASM: vperm
251 vsl = vec_perm(vsl, vsl, vuc);
252 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
253 // CHECK-ASM: vperm
254 vul = vec_perm(vul, vul, vuc);
255 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
256 // CHECK-ASM: vperm
257 vbl = vec_perm(vbl, vbl, vuc);
258 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
259 // CHECK-ASM: vperm
260 vd = vec_perm(vd, vd, vuc);
261 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
262 // CHECK-ASM: vperm
263
264 vsl = vec_permi(vsl, vsl, 0);
265 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
266 // CHECK-ASM: vpdi
267 vsl = vec_permi(vsl, vsl, 1);
268 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
269 // CHECK-ASM: vpdi
270 vsl = vec_permi(vsl, vsl, 2);
271 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
272 // CHECK-ASM: vpdi
273 vsl = vec_permi(vsl, vsl, 3);
274 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
275 // CHECK-ASM: vpdi
276 vul = vec_permi(vul, vul, 0);
277 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
278 // CHECK-ASM: vpdi
279 vul = vec_permi(vul, vul, 1);
280 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
281 // CHECK-ASM: vpdi
282 vul = vec_permi(vul, vul, 2);
283 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
284 // CHECK-ASM: vpdi
285 vul = vec_permi(vul, vul, 3);
286 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
287 // CHECK-ASM: vpdi
288 vbl = vec_permi(vbl, vbl, 0);
289 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
290 // CHECK-ASM: vpdi
291 vbl = vec_permi(vbl, vbl, 1);
292 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
293 // CHECK-ASM: vpdi
294 vbl = vec_permi(vbl, vbl, 2);
295 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
296 // CHECK-ASM: vpdi
297 vbl = vec_permi(vbl, vbl, 3);
298 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
299 // CHECK-ASM: vpdi
300 vd = vec_permi(vd, vd, 0);
301 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
302 // CHECK-ASM: vpdi
303 vd = vec_permi(vd, vd, 1);
304 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
305 // CHECK-ASM: vpdi
306 vd = vec_permi(vd, vd, 2);
307 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
308 // CHECK-ASM: vpdi
309 vd = vec_permi(vd, vd, 3);
310 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
311 // CHECK-ASM: vpdi
312
313 vss = vec_revb(vss);
314 // CHECK-ASM: vperm
315 vus = vec_revb(vus);
316 // CHECK-ASM: vperm
317 vsi = vec_revb(vsi);
318 // CHECK-ASM: vperm
319 vui = vec_revb(vui);
320 // CHECK-ASM: vperm
321 vsl = vec_revb(vsl);
322 // CHECK-ASM: vperm
323 vul = vec_revb(vul);
324 // CHECK-ASM: vperm
325 vd = vec_revb(vd);
326 // CHECK-ASM: vperm
327
328 vsc = vec_reve(vsc);
329 // CHECK-ASM: vperm
330 vuc = vec_reve(vuc);
331 // CHECK-ASM: vperm
332 vbc = vec_reve(vbc);
333 // CHECK-ASM: vperm
334 vss = vec_reve(vss);
335 // CHECK-ASM: vperm
336 vus = vec_reve(vus);
337 // CHECK-ASM: vperm
338 vbs = vec_reve(vbs);
339 // CHECK-ASM: vperm
340 vsi = vec_reve(vsi);
341 // CHECK-ASM: vperm
342 vui = vec_reve(vui);
343 // CHECK-ASM: vperm
344 vbi = vec_reve(vbi);
345 // CHECK-ASM: vperm
346 vsl = vec_reve(vsl);
347 // CHECK-ASM: {{vperm|vpdi}}
348 vul = vec_reve(vul);
349 // CHECK-ASM: {{vperm|vpdi}}
350 vbl = vec_reve(vbl);
351 // CHECK-ASM: {{vperm|vpdi}}
352 vd = vec_reve(vd);
353 // CHECK-ASM: {{vperm|vpdi}}
354
355 vsc = vec_sel(vsc, vsc, vuc);
356 // CHECK-ASM: vsel
357 vsc = vec_sel(vsc, vsc, vbc);
358 // CHECK-ASM: vsel
359 vuc = vec_sel(vuc, vuc, vuc);
360 // CHECK-ASM: vsel
361 vuc = vec_sel(vuc, vuc, vbc);
362 // CHECK-ASM: vsel
363 vbc = vec_sel(vbc, vbc, vuc);
364 // CHECK-ASM: vsel
365 vbc = vec_sel(vbc, vbc, vbc);
366 // CHECK-ASM: vsel
367 vss = vec_sel(vss, vss, vus);
368 // CHECK-ASM: vsel
369 vss = vec_sel(vss, vss, vbs);
370 // CHECK-ASM: vsel
371 vus = vec_sel(vus, vus, vus);
372 // CHECK-ASM: vsel
373 vus = vec_sel(vus, vus, vbs);
374 // CHECK-ASM: vsel
375 vbs = vec_sel(vbs, vbs, vus);
376 // CHECK-ASM: vsel
377 vbs = vec_sel(vbs, vbs, vbs);
378 // CHECK-ASM: vsel
379 vsi = vec_sel(vsi, vsi, vui);
380 // CHECK-ASM: vsel
381 vsi = vec_sel(vsi, vsi, vbi);
382 // CHECK-ASM: vsel
383 vui = vec_sel(vui, vui, vui);
384 // CHECK-ASM: vsel
385 vui = vec_sel(vui, vui, vbi);
386 // CHECK-ASM: vsel
387 vbi = vec_sel(vbi, vbi, vui);
388 // CHECK-ASM: vsel
389 vbi = vec_sel(vbi, vbi, vbi);
390 // CHECK-ASM: vsel
391 vsl = vec_sel(vsl, vsl, vul);
392 // CHECK-ASM: vsel
393 vsl = vec_sel(vsl, vsl, vbl);
394 // CHECK-ASM: vsel
395 vul = vec_sel(vul, vul, vul);
396 // CHECK-ASM: vsel
397 vul = vec_sel(vul, vul, vbl);
398 // CHECK-ASM: vsel
399 vbl = vec_sel(vbl, vbl, vul);
400 // CHECK-ASM: vsel
401 vbl = vec_sel(vbl, vbl, vbl);
402 // CHECK-ASM: vsel
403 vd = vec_sel(vd, vd, vul);
404 // CHECK-ASM: vsel
405 vd = vec_sel(vd, vd, vbl);
406 // CHECK-ASM: vsel
407
408 vsi = vec_gather_element(vsi, vui, cptrsi, 0);
409 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
410 vsi = vec_gather_element(vsi, vui, cptrsi, 1);
411 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
412 vsi = vec_gather_element(vsi, vui, cptrsi, 2);
413 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
414 vsi = vec_gather_element(vsi, vui, cptrsi, 3);
415 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
416 vui = vec_gather_element(vui, vui, cptrui, 0);
417 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
418 vui = vec_gather_element(vui, vui, cptrui, 1);
419 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
420 vui = vec_gather_element(vui, vui, cptrui, 2);
421 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
422 vui = vec_gather_element(vui, vui, cptrui, 3);
423 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
424 vbi = vec_gather_element(vbi, vui, cptrui, 0);
425 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
426 vbi = vec_gather_element(vbi, vui, cptrui, 1);
427 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
428 vbi = vec_gather_element(vbi, vui, cptrui, 2);
429 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
430 vbi = vec_gather_element(vbi, vui, cptrui, 3);
431 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
432 vsl = vec_gather_element(vsl, vul, cptrsl, 0);
433 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
434 vsl = vec_gather_element(vsl, vul, cptrsl, 1);
435 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
436 vul = vec_gather_element(vul, vul, cptrul, 0);
437 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
438 vul = vec_gather_element(vul, vul, cptrul, 1);
439 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
440 vbl = vec_gather_element(vbl, vul, cptrul, 0);
441 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
442 vbl = vec_gather_element(vbl, vul, cptrul, 1);
443 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
444 vd = vec_gather_element(vd, vul, cptrd, 0);
445 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
446 vd = vec_gather_element(vd, vul, cptrd, 1);
447 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
448
449 vec_scatter_element(vsi, vui, ptrsi, 0);
450 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
451 vec_scatter_element(vsi, vui, ptrsi, 1);
452 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
453 vec_scatter_element(vsi, vui, ptrsi, 2);
454 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
455 vec_scatter_element(vsi, vui, ptrsi, 3);
456 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
457 vec_scatter_element(vui, vui, ptrui, 0);
458 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
459 vec_scatter_element(vui, vui, ptrui, 1);
460 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
461 vec_scatter_element(vui, vui, ptrui, 2);
462 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
463 vec_scatter_element(vui, vui, ptrui, 3);
464 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
465 vec_scatter_element(vbi, vui, ptrui, 0);
466 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
467 vec_scatter_element(vbi, vui, ptrui, 1);
468 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
469 vec_scatter_element(vbi, vui, ptrui, 2);
470 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
471 vec_scatter_element(vbi, vui, ptrui, 3);
472 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
473 vec_scatter_element(vsl, vul, ptrsl, 0);
474 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
475 vec_scatter_element(vsl, vul, ptrsl, 1);
476 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
477 vec_scatter_element(vul, vul, ptrul, 0);
478 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
479 vec_scatter_element(vul, vul, ptrul, 1);
480 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
481 vec_scatter_element(vbl, vul, ptrul, 0);
482 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
483 vec_scatter_element(vbl, vul, ptrul, 1);
484 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
485 vec_scatter_element(vd, vul, ptrd, 0);
486 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
487 vec_scatter_element(vd, vul, ptrd, 1);
488 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
489
490 vsc = vec_xl(idx, cptrsc);
491 // CHECK-ASM: vl
492 vuc = vec_xl(idx, cptruc);
493 // CHECK-ASM: vl
494 vss = vec_xl(idx, cptrss);
495 // CHECK-ASM: vl
496 vus = vec_xl(idx, cptrus);
497 // CHECK-ASM: vl
498 vsi = vec_xl(idx, cptrsi);
499 // CHECK-ASM: vl
500 vui = vec_xl(idx, cptrui);
501 // CHECK-ASM: vl
502 vsl = vec_xl(idx, cptrsl);
503 // CHECK-ASM: vl
504 vul = vec_xl(idx, cptrul);
505 // CHECK-ASM: vl
506 vd = vec_xl(idx, cptrd);
507 // CHECK-ASM: vl
508
509 vsc = vec_xld2(idx, cptrsc);
510 // CHECK-ASM: vl
511 vuc = vec_xld2(idx, cptruc);
512 // CHECK-ASM: vl
513 vss = vec_xld2(idx, cptrss);
514 // CHECK-ASM: vl
515 vus = vec_xld2(idx, cptrus);
516 // CHECK-ASM: vl
517 vsi = vec_xld2(idx, cptrsi);
518 // CHECK-ASM: vl
519 vui = vec_xld2(idx, cptrui);
520 // CHECK-ASM: vl
521 vsl = vec_xld2(idx, cptrsl);
522 // CHECK-ASM: vl
523 vul = vec_xld2(idx, cptrul);
524 // CHECK-ASM: vl
525 vd = vec_xld2(idx, cptrd);
526 // CHECK-ASM: vl
527
528 vsc = vec_xlw4(idx, cptrsc);
529 // CHECK-ASM: vl
530 vuc = vec_xlw4(idx, cptruc);
531 // CHECK-ASM: vl
532 vss = vec_xlw4(idx, cptrss);
533 // CHECK-ASM: vl
534 vus = vec_xlw4(idx, cptrus);
535 // CHECK-ASM: vl
536 vsi = vec_xlw4(idx, cptrsi);
537 // CHECK-ASM: vl
538 vui = vec_xlw4(idx, cptrui);
539 // CHECK-ASM: vl
540
541 vec_xst(vsc, idx, ptrsc);
542 // CHECK-ASM: vst
543 vec_xst(vuc, idx, ptruc);
544 // CHECK-ASM: vst
545 vec_xst(vss, idx, ptrss);
546 // CHECK-ASM: vst
547 vec_xst(vus, idx, ptrus);
548 // CHECK-ASM: vst
549 vec_xst(vsi, idx, ptrsi);
550 // CHECK-ASM: vst
551 vec_xst(vui, idx, ptrui);
552 // CHECK-ASM: vst
553 vec_xst(vsl, idx, ptrsl);
554 // CHECK-ASM: vst
555 vec_xst(vul, idx, ptrul);
556 // CHECK-ASM: vst
557 vec_xst(vd, idx, ptrd);
558 // CHECK-ASM: vst
559
560 vec_xstd2(vsc, idx, ptrsc);
561 // CHECK-ASM: vst
562 vec_xstd2(vuc, idx, ptruc);
563 // CHECK-ASM: vst
564 vec_xstd2(vss, idx, ptrss);
565 // CHECK-ASM: vst
566 vec_xstd2(vus, idx, ptrus);
567 // CHECK-ASM: vst
568 vec_xstd2(vsi, idx, ptrsi);
569 // CHECK-ASM: vst
570 vec_xstd2(vui, idx, ptrui);
571 // CHECK-ASM: vst
572 vec_xstd2(vsl, idx, ptrsl);
573 // CHECK-ASM: vst
574 vec_xstd2(vul, idx, ptrul);
575 // CHECK-ASM: vst
576 vec_xstd2(vd, idx, ptrd);
577 // CHECK-ASM: vst
578
579 vec_xstw4(vsc, idx, ptrsc);
580 // CHECK-ASM: vst
581 vec_xstw4(vuc, idx, ptruc);
582 // CHECK-ASM: vst
583 vec_xstw4(vss, idx, ptrss);
584 // CHECK-ASM: vst
585 vec_xstw4(vus, idx, ptrus);
586 // CHECK-ASM: vst
587 vec_xstw4(vsi, idx, ptrsi);
588 // CHECK-ASM: vst
589 vec_xstw4(vui, idx, ptrui);
590 // CHECK-ASM: vst
591
592 vsc = vec_load_bndry(cptrsc, 64);
593 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
594 // CHECK-ASM: vlbb
595 vuc = vec_load_bndry(cptruc, 64);
596 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
597 // CHECK-ASM: vlbb
598 vss = vec_load_bndry(cptrss, 64);
599 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
600 // CHECK-ASM: vlbb
601 vus = vec_load_bndry(cptrus, 64);
602 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
603 // CHECK-ASM: vlbb
604 vsi = vec_load_bndry(cptrsi, 64);
605 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
606 // CHECK-ASM: vlbb
607 vui = vec_load_bndry(cptrui, 64);
608 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
609 // CHECK-ASM: vlbb
610 vsl = vec_load_bndry(cptrsl, 64);
611 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
612 // CHECK-ASM: vlbb
613 vul = vec_load_bndry(cptrul, 64);
614 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
615 // CHECK-ASM: vlbb
616 vd = vec_load_bndry(cptrd, 64);
617 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
618 // CHECK-ASM: vlbb
619 vsc = vec_load_bndry(cptrsc, 128);
620 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1)
621 // CHECK-ASM: vlbb
622 vsc = vec_load_bndry(cptrsc, 256);
623 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2)
624 // CHECK-ASM: vlbb
625 vsc = vec_load_bndry(cptrsc, 512);
626 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3)
627 // CHECK-ASM: vlbb
628 vsc = vec_load_bndry(cptrsc, 1024);
629 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4)
630 // CHECK-ASM: vlbb
631 vsc = vec_load_bndry(cptrsc, 2048);
632 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5)
633 // CHECK-ASM: vlbb
634 vsc = vec_load_bndry(cptrsc, 4096);
635 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6)
636 // CHECK-ASM: vlbb
637
638 vsc = vec_load_len(cptrsc, idx);
639 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
640 // CHECK-ASM: vll
641 vuc = vec_load_len(cptruc, idx);
642 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
643 // CHECK-ASM: vll
644 vss = vec_load_len(cptrss, idx);
645 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
646 // CHECK-ASM: vll
647 vus = vec_load_len(cptrus, idx);
648 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
649 // CHECK-ASM: vll
650 vsi = vec_load_len(cptrsi, idx);
651 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
652 // CHECK-ASM: vll
653 vui = vec_load_len(cptrui, idx);
654 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
655 // CHECK-ASM: vll
656 vsl = vec_load_len(cptrsl, idx);
657 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
658 // CHECK-ASM: vll
659 vul = vec_load_len(cptrul, idx);
660 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
661 // CHECK-ASM: vll
662 vd = vec_load_len(cptrd, idx);
663 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
664 // CHECK-ASM: vll
665
666 vec_store_len(vsc, ptrsc, idx);
667 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
668 // CHECK-ASM: vstl
669 vec_store_len(vuc, ptruc, idx);
670 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
671 // CHECK-ASM: vstl
672 vec_store_len(vss, ptrss, idx);
673 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
674 // CHECK-ASM: vstl
675 vec_store_len(vus, ptrus, idx);
676 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
677 // CHECK-ASM: vstl
678 vec_store_len(vsi, ptrsi, idx);
679 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
680 // CHECK-ASM: vstl
681 vec_store_len(vui, ptrui, idx);
682 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
683 // CHECK-ASM: vstl
684 vec_store_len(vsl, ptrsl, idx);
685 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
686 // CHECK-ASM: vstl
687 vec_store_len(vul, ptrul, idx);
688 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
689 // CHECK-ASM: vstl
690 vec_store_len(vd, ptrd, idx);
691 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
692 // CHECK-ASM: vstl
693
694 vsl = vec_load_pair(sl + 1, sl - 1);
695 // CHECK-ASM: vlvgp
696 vul = vec_load_pair(ul + 1, ul - 1);
697 // CHECK-ASM: vlvgp
698
699 vuc = vec_genmask(0);
700 // CHECK: <16 x i8> zeroinitializer
701 vuc = vec_genmask(0x8000);
702 // CHECK: <16 x i8> <i8 -1, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>
703 vuc = vec_genmask(0xffff);
704 // CHECK: <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>
705
706 vuc = vec_genmasks_8(0, 7);
707 // CHECK: <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>
708 vuc = vec_genmasks_8(1, 4);
709 // CHECK: <16 x i8> <i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120>
710 vuc = vec_genmasks_8(6, 2);
711 // CHECK: <16 x i8> <i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29>
712 vus = vec_genmasks_16(0, 15);
713 // CHECK: <8 x i16> <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
714 vus = vec_genmasks_16(2, 11);
715 // CHECK: <8 x i16> <i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368>
716 vus = vec_genmasks_16(9, 2);
717 // CHECK: <8 x i16> <i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065>
718 vui = vec_genmasks_32(0, 31);
719 // CHECK: <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>
720 vui = vec_genmasks_32(7, 20);
721 // CHECK: <4 x i32> <i32 33552384, i32 33552384, i32 33552384, i32 33552384>
722 vui = vec_genmasks_32(25, 4);
723 // CHECK: <4 x i32> <i32 -134217601, i32 -134217601, i32 -134217601, i32 -134217601>
724 vul = vec_genmasks_64(0, 63);
725 // CHECK: <2 x i64> <i64 -1, i64 -1>
726 vul = vec_genmasks_64(3, 40);
727 // CHECK: <2 x i64> <i64 2305843009205305344, i64 2305843009205305344>
728 vul = vec_genmasks_64(30, 11);
729 // CHECK: <2 x i64> <i64 -4503582447501313, i64 -4503582447501313>
730
731 vsc = vec_splat(vsc, 0);
732 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
733 // CHECK-ASM: vrepb
734 vsc = vec_splat(vsc, 15);
735 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
736 // CHECK-ASM: vrepb
737 vuc = vec_splat(vuc, 0);
738 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
739 // CHECK-ASM: vrepb
740 vuc = vec_splat(vuc, 15);
741 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
742 // CHECK-ASM: vrepb
743 vbc = vec_splat(vbc, 0);
744 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
745 // CHECK-ASM: vrepb
746 vbc = vec_splat(vbc, 15);
747 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
748 // CHECK-ASM: vrepb
749 vss = vec_splat(vss, 0);
750 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
751 // CHECK-ASM: vreph
752 vss = vec_splat(vss, 7);
753 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
754 // CHECK-ASM: vreph
755 vus = vec_splat(vus, 0);
756 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
757 // CHECK-ASM: vreph
758 vus = vec_splat(vus, 7);
759 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
760 // CHECK-ASM: vreph
761 vbs = vec_splat(vbs, 0);
762 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
763 // CHECK-ASM: vreph
764 vbs = vec_splat(vbs, 7);
765 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
766 // CHECK-ASM: vreph
767 vsi = vec_splat(vsi, 0);
768 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
769 // CHECK-ASM: vrepf
770 vsi = vec_splat(vsi, 3);
771 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
772 // CHECK-ASM: vrepf
773 vui = vec_splat(vui, 0);
774 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
775 // CHECK-ASM: vrepf
776 vui = vec_splat(vui, 3);
777 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
778 // CHECK-ASM: vrepf
779 vbi = vec_splat(vbi, 0);
780 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
781 // CHECK-ASM: vrepf
782 vbi = vec_splat(vbi, 3);
783 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
784 // CHECK-ASM: vrepf
785 vsl = vec_splat(vsl, 0);
786 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
787 // CHECK-ASM: vrepg
788 vsl = vec_splat(vsl, 1);
789 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
790 // CHECK-ASM: vrepg
791 vul = vec_splat(vul, 0);
792 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
793 // CHECK-ASM: vrepg
794 vul = vec_splat(vul, 1);
795 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
796 // CHECK-ASM: vrepg
797 vbl = vec_splat(vbl, 0);
798 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
799 // CHECK-ASM: vrepg
800 vbl = vec_splat(vbl, 1);
801 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
802 // CHECK-ASM: vrepg
803 vd = vec_splat(vd, 0);
804 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
805 // CHECK-ASM: vrepg
806 vd = vec_splat(vd, 1);
807 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
808 // CHECK-ASM: vrepg
809
810 vsc = vec_splat_s8(-128);
811 // CHECK: <16 x i8> <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
812 vsc = vec_splat_s8(127);
813 // CHECK: <16 x i8> <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
814 vuc = vec_splat_u8(1);
815 // CHECK: <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>
816 vuc = vec_splat_u8(254);
817 // CHECK: <16 x i8> <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2>
818 vss = vec_splat_s16(-32768);
819 // CHECK: <8 x i16> <i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768>
820 vss = vec_splat_s16(32767);
821 // CHECK: <8 x i16> <i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767>
822 vus = vec_splat_u16(1);
823 // CHECK: <8 x i16> <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
824 vus = vec_splat_u16(65534);
825 // CHECK: <8 x i16> <i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2>
826 vsi = vec_splat_s32(-32768);
827 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
828 vsi = vec_splat_s32(32767);
829 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
830 vui = vec_splat_u32(-32768);
831 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
832 vui = vec_splat_u32(32767);
833 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
834 vsl = vec_splat_s64(-32768);
835 // CHECK: <2 x i64> <i64 -32768, i64 -32768>
836 vsl = vec_splat_s64(32767);
837 // CHECK: <2 x i64> <i64 32767, i64 32767>
838 vul = vec_splat_u64(-32768);
839 // CHECK: <2 x i64> <i64 -32768, i64 -32768>
840 vul = vec_splat_u64(32767);
841 // CHECK: <2 x i64> <i64 32767, i64 32767>
842
843 vsc = vec_splats(sc);
844 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
845 // CHECK-ASM: vlrepb
846 vuc = vec_splats(uc);
847 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer
848 // CHECK-ASM: vlrepb
849 vss = vec_splats(ss);
850 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
851 // CHECK-ASM: vlreph
852 vus = vec_splats(us);
853 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer
854 // CHECK-ASM: vlreph
855 vsi = vec_splats(si);
856 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
857 // CHECK-ASM: vlrepf
858 vui = vec_splats(ui);
859 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
860 // CHECK-ASM: vlrepf
861 vsl = vec_splats(sl);
862 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
863 // CHECK-ASM: vlrepg
864 vul = vec_splats(ul);
865 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer
866 // CHECK-ASM: vlrepg
867 vd = vec_splats(d);
868 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer
869 // CHECK-ASM: vlrepg
870
871 vsl = vec_extend_s64(vsc);
872 // CHECK-ASM: vsegb
873 vsl = vec_extend_s64(vss);
874 // CHECK-ASM: vsegh
875 vsl = vec_extend_s64(vsi);
876 // CHECK-ASM: vsegf
877
878 vsc = vec_mergeh(vsc, vsc);
879 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
880 // CHECK-ASM: vmrhb
881 vuc = vec_mergeh(vuc, vuc);
882 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
883 // CHECK-ASM: vmrhb
884 vbc = vec_mergeh(vbc, vbc);
885 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
886 // CHECK-ASM: vmrhb
887 vss = vec_mergeh(vss, vss);
888 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
889 // CHECK-ASM: vmrhh
890 vus = vec_mergeh(vus, vus);
891 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
892 // CHECK-ASM: vmrhh
893 vbs = vec_mergeh(vbs, vbs);
894 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
895 // CHECK-ASM: vmrhh
896 vsi = vec_mergeh(vsi, vsi);
897 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
898 // CHECK-ASM: vmrhf
899 vui = vec_mergeh(vui, vui);
900 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
901 // CHECK-ASM: vmrhf
902 vbi = vec_mergeh(vbi, vbi);
903 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
904 // CHECK-ASM: vmrhf
905 vsl = vec_mergeh(vsl, vsl);
906 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
907 // CHECK-ASM: vmrhg
908 vul = vec_mergeh(vul, vul);
909 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
910 // CHECK-ASM: vmrhg
911 vbl = vec_mergeh(vbl, vbl);
912 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
913 // CHECK-ASM: vmrhg
914 vd = vec_mergeh(vd, vd);
915 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
916 // CHECK-ASM: vmrhg
917
918 vsc = vec_mergel(vsc, vsc);
919 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
920 // CHECK-ASM: vmrlb
921 vuc = vec_mergel(vuc, vuc);
922 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
923 // CHECK-ASM: vmrlb
924 vbc = vec_mergel(vbc, vbc);
925 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
926 // CHECK-ASM: vmrlb
927 vss = vec_mergel(vss, vss);
928 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
929 // CHECK-ASM: vmrlh
930 vus = vec_mergel(vus, vus);
931 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
932 // CHECK-ASM: vmrlh
933 vbs = vec_mergel(vbs, vbs);
934 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
935 // CHECK-ASM: vmrlh
936 vsi = vec_mergel(vsi, vsi);
937 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
938 // CHECK-ASM: vmrlf
939 vui = vec_mergel(vui, vui);
940 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
941 // CHECK-ASM: vmrlf
942 vbi = vec_mergel(vbi, vbi);
943 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
944 // CHECK-ASM: vmrlf
945 vsl = vec_mergel(vsl, vsl);
946 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
947 // CHECK-ASM: vmrlg
948 vul = vec_mergel(vul, vul);
949 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
950 // CHECK-ASM: vmrlg
951 vbl = vec_mergel(vbl, vbl);
952 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
953 // CHECK-ASM: vmrlg
954 vd = vec_mergel(vd, vd);
955 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
956 // CHECK-ASM: vmrlg
957
958 vsc = vec_pack(vss, vss);
959 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
960 // CHECK-ASM: vpkh
961 vuc = vec_pack(vus, vus);
962 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
963 // CHECK-ASM: vpkh
964 vbc = vec_pack(vbs, vbs);
965 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
966 // CHECK-ASM: vpkh
967 vss = vec_pack(vsi, vsi);
968 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
969 // CHECK-ASM: vpkf
970 vus = vec_pack(vui, vui);
971 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
972 // CHECK-ASM: vpkf
973 vbs = vec_pack(vbi, vbi);
974 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
975 // CHECK-ASM: vpkf
976 vsi = vec_pack(vsl, vsl);
977 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
978 // CHECK-ASM: vpkg
979 vui = vec_pack(vul, vul);
980 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
981 // CHECK-ASM: vpkg
982 vbi = vec_pack(vbl, vbl);
983 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
984 // CHECK-ASM: vpkg
985
986 vsc = vec_packs(vss, vss);
987 // CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
988 // CHECK-ASM: vpksh
989 vuc = vec_packs(vus, vus);
990 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
991 // CHECK-ASM: vpklsh
992 vss = vec_packs(vsi, vsi);
993 // CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
994 // CHECK-ASM: vpksf
995 vus = vec_packs(vui, vui);
996 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
997 // CHECK-ASM: vpklsf
998 vsi = vec_packs(vsl, vsl);
999 // CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1000 // CHECK-ASM: vpksg
1001 vui = vec_packs(vul, vul);
1002 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1003 // CHECK-ASM: vpklsg
1004
1005 vsc = vec_packs_cc(vss, vss, &cc);
1006 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpkshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1007 // CHECK-ASM: vpkshs
1008 vuc = vec_packs_cc(vus, vus, &cc);
1009 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1010 // CHECK-ASM: vpklshs
1011 vss = vec_packs_cc(vsi, vsi, &cc);
1012 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpksfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1013 // CHECK-ASM: vpksfs
1014 vus = vec_packs_cc(vui, vui, &cc);
1015 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1016 // CHECK-ASM: vpklsfs
1017 vsi = vec_packs_cc(vsl, vsl, &cc);
1018 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpksgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1019 // CHECK-ASM: vpksgs
1020 vui = vec_packs_cc(vul, vul, &cc);
1021 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1022 // CHECK-ASM: vpklsgs
1023
1024 vuc = vec_packsu(vss, vss);
1025 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1026 // CHECK-ASM: vpklsh
1027 vuc = vec_packsu(vus, vus);
1028 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1029 // CHECK-ASM: vpklsh
1030 vus = vec_packsu(vsi, vsi);
1031 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1032 // CHECK-ASM: vpklsf
1033 vus = vec_packsu(vui, vui);
1034 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1035 // CHECK-ASM: vpklsf
1036 vui = vec_packsu(vsl, vsl);
1037 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1038 // CHECK-ASM: vpklsg
1039 vui = vec_packsu(vul, vul);
1040 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1041 // CHECK-ASM: vpklsg
1042
1043 vuc = vec_packsu_cc(vus, vus, &cc);
1044 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1045 // CHECK-ASM: vpklshs
1046 vus = vec_packsu_cc(vui, vui, &cc);
1047 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1048 // CHECK-ASM: vpklsfs
1049 vui = vec_packsu_cc(vul, vul, &cc);
1050 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1051 // CHECK-ASM: vpklsgs
1052
1053 vss = vec_unpackh(vsc);
1054 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
1055 // CHECK-ASM: vuphb
1056 vus = vec_unpackh(vuc);
1057 // CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}})
1058 // CHECK-ASM: vuplhb
1059 vbs = vec_unpackh(vbc);
1060 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
1061 // CHECK-ASM: vuphb
1062 vsi = vec_unpackh(vss);
1063 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
1064 // CHECK-ASM: vuphh
1065 vui = vec_unpackh(vus);
1066 // CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}})
1067 // CHECK-ASM: vuplhh
1068 vbi = vec_unpackh(vbs);
1069 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
1070 // CHECK-ASM: vuphh
1071 vsl = vec_unpackh(vsi);
1072 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
1073 // CHECK-ASM: vuphf
1074 vul = vec_unpackh(vui);
1075 // CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}})
1076 // CHECK-ASM: vuplhf
1077 vbl = vec_unpackh(vbi);
1078 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
1079 // CHECK-ASM: vuphf
1080
1081 vss = vec_unpackl(vsc);
1082 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
1083 // CHECK-ASM: vuplb
1084 vus = vec_unpackl(vuc);
1085 // CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}})
1086 // CHECK-ASM: vupllb
1087 vbs = vec_unpackl(vbc);
1088 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
1089 // CHECK-ASM: vuplb
1090 vsi = vec_unpackl(vss);
1091 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
1092 // CHECK-ASM: vuplhw
1093 vui = vec_unpackl(vus);
1094 // CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}})
1095 // CHECK-ASM: vupllh
1096 vbi = vec_unpackl(vbs);
1097 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
1098 // CHECK-ASM: vuplhw
1099 vsl = vec_unpackl(vsi);
1100 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
1101 // CHECK-ASM: vuplf
1102 vul = vec_unpackl(vui);
1103 // CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}})
1104 // CHECK-ASM: vupllf
1105 vbl = vec_unpackl(vbi);
1106 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
1107 // CHECK-ASM: vuplf
1108 }
1109
test_compare(void)1110 void test_compare(void) {
1111 // CHECK-ASM-LABEL: test_compare
1112
1113 vbc = vec_cmpeq(vsc, vsc);
1114 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1115 // CHECK-ASM: vceqb
1116 vbc = vec_cmpeq(vuc, vuc);
1117 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1118 // CHECK-ASM: vceqb
1119 vbc = vec_cmpeq(vbc, vbc);
1120 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1121 // CHECK-ASM: vceqb
1122 vbs = vec_cmpeq(vss, vss);
1123 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1124 // CHECK-ASM: vceqh
1125 vbs = vec_cmpeq(vus, vus);
1126 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1127 // CHECK-ASM: vceqh
1128 vbs = vec_cmpeq(vbs, vbs);
1129 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1130 // CHECK-ASM: vceqh
1131 vbi = vec_cmpeq(vsi, vsi);
1132 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1133 // CHECK-ASM: vceqf
1134 vbi = vec_cmpeq(vui, vui);
1135 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1136 // CHECK-ASM: vceqf
1137 vbi = vec_cmpeq(vbi, vbi);
1138 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1139 // CHECK-ASM: vceqf
1140 vbl = vec_cmpeq(vsl, vsl);
1141 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1142 // CHECK-ASM: vceqg
1143 vbl = vec_cmpeq(vul, vul);
1144 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1145 // CHECK-ASM: vceqg
1146 vbl = vec_cmpeq(vbl, vbl);
1147 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1148 // CHECK-ASM: vceqg
1149 vbl = vec_cmpeq(vd, vd);
1150 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
1151 // CHECK-ASM: vfcedb
1152
1153 vbc = vec_cmpge(vsc, vsc);
1154 // CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}}
1155 // CHECK-ASM: vchb
1156 vbc = vec_cmpge(vuc, vuc);
1157 // CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}}
1158 // CHECK-ASM: vchlb
1159 vbs = vec_cmpge(vss, vss);
1160 // CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}}
1161 // CHECK-ASM: vchh
1162 vbs = vec_cmpge(vus, vus);
1163 // CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}}
1164 // CHECK-ASM: vchlh
1165 vbi = vec_cmpge(vsi, vsi);
1166 // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
1167 // CHECK-ASM: vchf
1168 vbi = vec_cmpge(vui, vui);
1169 // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
1170 // CHECK-ASM: vchlf
1171 vbl = vec_cmpge(vsl, vsl);
1172 // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
1173 // CHECK-ASM: vchg
1174 vbl = vec_cmpge(vul, vul);
1175 // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
1176 // CHECK-ASM: vchlg
1177 vbl = vec_cmpge(vd, vd);
1178 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
1179 // CHECK-ASM: vfchedb
1180
1181 vbc = vec_cmpgt(vsc, vsc);
1182 // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}}
1183 // CHECK-ASM: vchb
1184 vbc = vec_cmpgt(vuc, vuc);
1185 // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}}
1186 // CHECK-ASM: vchlb
1187 vbs = vec_cmpgt(vss, vss);
1188 // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}}
1189 // CHECK-ASM: vchh
1190 vbs = vec_cmpgt(vus, vus);
1191 // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}}
1192 // CHECK-ASM: vchlh
1193 vbi = vec_cmpgt(vsi, vsi);
1194 // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}}
1195 // CHECK-ASM: vchf
1196 vbi = vec_cmpgt(vui, vui);
1197 // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
1198 // CHECK-ASM: vchlf
1199 vbl = vec_cmpgt(vsl, vsl);
1200 // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}}
1201 // CHECK-ASM: vchg
1202 vbl = vec_cmpgt(vul, vul);
1203 // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
1204 // CHECK-ASM: vchlg
1205 vbl = vec_cmpgt(vd, vd);
1206 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
1207 // CHECK-ASM: vfchdb
1208
1209 vbc = vec_cmple(vsc, vsc);
1210 // CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}}
1211 // CHECK-ASM: vchb
1212 vbc = vec_cmple(vuc, vuc);
1213 // CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}}
1214 // CHECK-ASM: vchlb
1215 vbs = vec_cmple(vss, vss);
1216 // CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}}
1217 // CHECK-ASM: vchh
1218 vbs = vec_cmple(vus, vus);
1219 // CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}}
1220 // CHECK-ASM: vchlh
1221 vbi = vec_cmple(vsi, vsi);
1222 // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
1223 // CHECK-ASM: vchf
1224 vbi = vec_cmple(vui, vui);
1225 // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
1226 // CHECK-ASM: vchlf
1227 vbl = vec_cmple(vsl, vsl);
1228 // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
1229 // CHECK-ASM: vchg
1230 vbl = vec_cmple(vul, vul);
1231 // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
1232 // CHECK-ASM: vchlg
1233 vbl = vec_cmple(vd, vd);
1234 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
1235 // CHECK-ASM: vfchedb
1236
1237 vbc = vec_cmplt(vsc, vsc);
1238 // CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}}
1239 // CHECK-ASM: vchb
1240 vbc = vec_cmplt(vuc, vuc);
1241 // CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}}
1242 // CHECK-ASM: vchlb
1243 vbs = vec_cmplt(vss, vss);
1244 // CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}}
1245 // CHECK-ASM: vchh
1246 vbs = vec_cmplt(vus, vus);
1247 // CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}}
1248 // CHECK-ASM: vchlh
1249 vbi = vec_cmplt(vsi, vsi);
1250 // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
1251 // CHECK-ASM: vchf
1252 vbi = vec_cmplt(vui, vui);
1253 // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
1254 // CHECK-ASM: vchlf
1255 vbl = vec_cmplt(vsl, vsl);
1256 // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
1257 // CHECK-ASM: vchg
1258 vbl = vec_cmplt(vul, vul);
1259 // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
1260 // CHECK-ASM: vchlg
1261 vbl = vec_cmplt(vd, vd);
1262 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
1263 // CHECK-ASM: vfchdb
1264
1265 idx = vec_all_eq(vsc, vsc);
1266 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1267 // CHECK-ASM: vceqbs
1268 idx = vec_all_eq(vsc, vbc);
1269 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1270 // CHECK-ASM: vceqbs
1271 idx = vec_all_eq(vbc, vsc);
1272 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1273 // CHECK-ASM: vceqbs
1274 idx = vec_all_eq(vuc, vuc);
1275 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1276 // CHECK-ASM: vceqbs
1277 idx = vec_all_eq(vuc, vbc);
1278 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1279 // CHECK-ASM: vceqbs
1280 idx = vec_all_eq(vbc, vuc);
1281 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1282 // CHECK-ASM: vceqbs
1283 idx = vec_all_eq(vbc, vbc);
1284 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1285 // CHECK-ASM: vceqbs
1286 idx = vec_all_eq(vss, vss);
1287 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1288 // CHECK-ASM: vceqhs
1289 idx = vec_all_eq(vss, vbs);
1290 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1291 // CHECK-ASM: vceqhs
1292 idx = vec_all_eq(vbs, vss);
1293 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1294 // CHECK-ASM: vceqhs
1295 idx = vec_all_eq(vus, vus);
1296 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1297 // CHECK-ASM: vceqhs
1298 idx = vec_all_eq(vus, vbs);
1299 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1300 // CHECK-ASM: vceqhs
1301 idx = vec_all_eq(vbs, vus);
1302 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1303 // CHECK-ASM: vceqhs
1304 idx = vec_all_eq(vbs, vbs);
1305 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1306 // CHECK-ASM: vceqhs
1307 idx = vec_all_eq(vsi, vsi);
1308 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1309 // CHECK-ASM: vceqfs
1310 idx = vec_all_eq(vsi, vbi);
1311 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1312 // CHECK-ASM: vceqfs
1313 idx = vec_all_eq(vbi, vsi);
1314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1315 // CHECK-ASM: vceqfs
1316 idx = vec_all_eq(vui, vui);
1317 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1318 // CHECK-ASM: vceqfs
1319 idx = vec_all_eq(vui, vbi);
1320 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1321 // CHECK-ASM: vceqfs
1322 idx = vec_all_eq(vbi, vui);
1323 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1324 // CHECK-ASM: vceqfs
1325 idx = vec_all_eq(vbi, vbi);
1326 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1327 // CHECK-ASM: vceqfs
1328 idx = vec_all_eq(vsl, vsl);
1329 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1330 // CHECK-ASM: vceqgs
1331 idx = vec_all_eq(vsl, vbl);
1332 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1333 // CHECK-ASM: vceqgs
1334 idx = vec_all_eq(vbl, vsl);
1335 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1336 // CHECK-ASM: vceqgs
1337 idx = vec_all_eq(vul, vul);
1338 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1339 // CHECK-ASM: vceqgs
1340 idx = vec_all_eq(vul, vbl);
1341 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1342 // CHECK-ASM: vceqgs
1343 idx = vec_all_eq(vbl, vul);
1344 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1345 // CHECK-ASM: vceqgs
1346 idx = vec_all_eq(vbl, vbl);
1347 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1348 // CHECK-ASM: vceqgs
1349 idx = vec_all_eq(vd, vd);
1350 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1351 // CHECK-ASM: vfcedbs
1352
1353 idx = vec_all_ne(vsc, vsc);
1354 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1355 // CHECK-ASM: vceqbs
1356 idx = vec_all_ne(vsc, vbc);
1357 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1358 // CHECK-ASM: vceqbs
1359 idx = vec_all_ne(vbc, vsc);
1360 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1361 // CHECK-ASM: vceqbs
1362 idx = vec_all_ne(vuc, vuc);
1363 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1364 // CHECK-ASM: vceqbs
1365 idx = vec_all_ne(vuc, vbc);
1366 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1367 // CHECK-ASM: vceqbs
1368 idx = vec_all_ne(vbc, vuc);
1369 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1370 // CHECK-ASM: vceqbs
1371 idx = vec_all_ne(vbc, vbc);
1372 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1373 // CHECK-ASM: vceqbs
1374 idx = vec_all_ne(vss, vss);
1375 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1376 // CHECK-ASM: vceqhs
1377 idx = vec_all_ne(vss, vbs);
1378 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1379 // CHECK-ASM: vceqhs
1380 idx = vec_all_ne(vbs, vss);
1381 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1382 // CHECK-ASM: vceqhs
1383 idx = vec_all_ne(vus, vus);
1384 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1385 // CHECK-ASM: vceqhs
1386 idx = vec_all_ne(vus, vbs);
1387 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1388 // CHECK-ASM: vceqhs
1389 idx = vec_all_ne(vbs, vus);
1390 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1391 // CHECK-ASM: vceqhs
1392 idx = vec_all_ne(vbs, vbs);
1393 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1394 // CHECK-ASM: vceqhs
1395 idx = vec_all_ne(vsi, vsi);
1396 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1397 // CHECK-ASM: vceqfs
1398 idx = vec_all_ne(vsi, vbi);
1399 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1400 // CHECK-ASM: vceqfs
1401 idx = vec_all_ne(vbi, vsi);
1402 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1403 // CHECK-ASM: vceqfs
1404 idx = vec_all_ne(vui, vui);
1405 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1406 // CHECK-ASM: vceqfs
1407 idx = vec_all_ne(vui, vbi);
1408 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1409 // CHECK-ASM: vceqfs
1410 idx = vec_all_ne(vbi, vui);
1411 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1412 // CHECK-ASM: vceqfs
1413 idx = vec_all_ne(vbi, vbi);
1414 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1415 // CHECK-ASM: vceqfs
1416 idx = vec_all_ne(vsl, vsl);
1417 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1418 // CHECK-ASM: vceqgs
1419 idx = vec_all_ne(vsl, vbl);
1420 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1421 // CHECK-ASM: vceqgs
1422 idx = vec_all_ne(vbl, vsl);
1423 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1424 // CHECK-ASM: vceqgs
1425 idx = vec_all_ne(vul, vul);
1426 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1427 // CHECK-ASM: vceqgs
1428 idx = vec_all_ne(vul, vbl);
1429 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1430 // CHECK-ASM: vceqgs
1431 idx = vec_all_ne(vbl, vul);
1432 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1433 // CHECK-ASM: vceqgs
1434 idx = vec_all_ne(vbl, vbl);
1435 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1436 // CHECK-ASM: vceqgs
1437 idx = vec_all_ne(vd, vd);
1438 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1439 // CHECK-ASM: vfcedbs
1440
1441 idx = vec_all_ge(vsc, vsc);
1442 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1443 // CHECK-ASM: vchbs
1444 idx = vec_all_ge(vsc, vbc);
1445 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1446 // CHECK-ASM: vchbs
1447 idx = vec_all_ge(vbc, vsc);
1448 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1449 // CHECK-ASM: vchbs
1450 idx = vec_all_ge(vuc, vuc);
1451 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1452 // CHECK-ASM: vchlbs
1453 idx = vec_all_ge(vuc, vbc);
1454 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1455 // CHECK-ASM: vchlbs
1456 idx = vec_all_ge(vbc, vuc);
1457 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1458 // CHECK-ASM: vchlbs
1459 idx = vec_all_ge(vbc, vbc);
1460 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1461 // CHECK-ASM: vchlbs
1462 idx = vec_all_ge(vss, vss);
1463 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1464 // CHECK-ASM: vchhs
1465 idx = vec_all_ge(vss, vbs);
1466 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1467 // CHECK-ASM: vchhs
1468 idx = vec_all_ge(vbs, vss);
1469 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1470 // CHECK-ASM: vchhs
1471 idx = vec_all_ge(vus, vus);
1472 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1473 // CHECK-ASM: vchlhs
1474 idx = vec_all_ge(vus, vbs);
1475 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1476 // CHECK-ASM: vchlhs
1477 idx = vec_all_ge(vbs, vus);
1478 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1479 // CHECK-ASM: vchlhs
1480 idx = vec_all_ge(vbs, vbs);
1481 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1482 // CHECK-ASM: vchlhs
1483 idx = vec_all_ge(vsi, vsi);
1484 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1485 // CHECK-ASM: vchfs
1486 idx = vec_all_ge(vsi, vbi);
1487 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1488 // CHECK-ASM: vchfs
1489 idx = vec_all_ge(vbi, vsi);
1490 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1491 // CHECK-ASM: vchfs
1492 idx = vec_all_ge(vui, vui);
1493 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1494 // CHECK-ASM: vchlfs
1495 idx = vec_all_ge(vui, vbi);
1496 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1497 // CHECK-ASM: vchlfs
1498 idx = vec_all_ge(vbi, vui);
1499 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1500 // CHECK-ASM: vchlfs
1501 idx = vec_all_ge(vbi, vbi);
1502 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1503 // CHECK-ASM: vchlfs
1504 idx = vec_all_ge(vsl, vsl);
1505 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1506 // CHECK-ASM: vchgs
1507 idx = vec_all_ge(vsl, vbl);
1508 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1509 // CHECK-ASM: vchgs
1510 idx = vec_all_ge(vbl, vsl);
1511 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1512 // CHECK-ASM: vchgs
1513 idx = vec_all_ge(vul, vul);
1514 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1515 // CHECK-ASM: vchlgs
1516 idx = vec_all_ge(vul, vbl);
1517 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1518 // CHECK-ASM: vchlgs
1519 idx = vec_all_ge(vbl, vul);
1520 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1521 // CHECK-ASM: vchlgs
1522 idx = vec_all_ge(vbl, vbl);
1523 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1524 // CHECK-ASM: vchlgs
1525 idx = vec_all_ge(vd, vd);
1526 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1527 // CHECK-ASM: vfchedbs
1528
1529 idx = vec_all_gt(vsc, vsc);
1530 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1531 // CHECK-ASM: vchbs
1532 idx = vec_all_gt(vsc, vbc);
1533 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1534 // CHECK-ASM: vchbs
1535 idx = vec_all_gt(vbc, vsc);
1536 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1537 // CHECK-ASM: vchbs
1538 idx = vec_all_gt(vuc, vuc);
1539 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1540 // CHECK-ASM: vchlbs
1541 idx = vec_all_gt(vuc, vbc);
1542 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1543 // CHECK-ASM: vchlbs
1544 idx = vec_all_gt(vbc, vuc);
1545 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1546 // CHECK-ASM: vchlbs
1547 idx = vec_all_gt(vbc, vbc);
1548 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1549 // CHECK-ASM: vchlbs
1550 idx = vec_all_gt(vss, vss);
1551 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1552 // CHECK-ASM: vchhs
1553 idx = vec_all_gt(vss, vbs);
1554 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1555 // CHECK-ASM: vchhs
1556 idx = vec_all_gt(vbs, vss);
1557 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1558 // CHECK-ASM: vchhs
1559 idx = vec_all_gt(vus, vus);
1560 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1561 // CHECK-ASM: vchlhs
1562 idx = vec_all_gt(vus, vbs);
1563 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1564 // CHECK-ASM: vchlhs
1565 idx = vec_all_gt(vbs, vus);
1566 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1567 // CHECK-ASM: vchlhs
1568 idx = vec_all_gt(vbs, vbs);
1569 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1570 // CHECK-ASM: vchlhs
1571 idx = vec_all_gt(vsi, vsi);
1572 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1573 // CHECK-ASM: vchfs
1574 idx = vec_all_gt(vsi, vbi);
1575 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1576 // CHECK-ASM: vchfs
1577 idx = vec_all_gt(vbi, vsi);
1578 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1579 // CHECK-ASM: vchfs
1580 idx = vec_all_gt(vui, vui);
1581 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1582 // CHECK-ASM: vchlfs
1583 idx = vec_all_gt(vui, vbi);
1584 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1585 // CHECK-ASM: vchlfs
1586 idx = vec_all_gt(vbi, vui);
1587 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1588 // CHECK-ASM: vchlfs
1589 idx = vec_all_gt(vbi, vbi);
1590 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1591 // CHECK-ASM: vchlfs
1592 idx = vec_all_gt(vsl, vsl);
1593 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1594 // CHECK-ASM: vchgs
1595 idx = vec_all_gt(vsl, vbl);
1596 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1597 // CHECK-ASM: vchgs
1598 idx = vec_all_gt(vbl, vsl);
1599 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1600 // CHECK-ASM: vchgs
1601 idx = vec_all_gt(vul, vul);
1602 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1603 // CHECK-ASM: vchlgs
1604 idx = vec_all_gt(vul, vbl);
1605 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1606 // CHECK-ASM: vchlgs
1607 idx = vec_all_gt(vbl, vul);
1608 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1609 // CHECK-ASM: vchlgs
1610 idx = vec_all_gt(vbl, vbl);
1611 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1612 // CHECK-ASM: vchlgs
1613 idx = vec_all_gt(vd, vd);
1614 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1615 // CHECK-ASM: vfchdbs
1616
1617 idx = vec_all_le(vsc, vsc);
1618 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1619 // CHECK-ASM: vchbs
1620 idx = vec_all_le(vsc, vbc);
1621 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1622 // CHECK-ASM: vchbs
1623 idx = vec_all_le(vbc, vsc);
1624 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1625 // CHECK-ASM: vchbs
1626 idx = vec_all_le(vuc, vuc);
1627 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1628 // CHECK-ASM: vchlbs
1629 idx = vec_all_le(vuc, vbc);
1630 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1631 // CHECK-ASM: vchlbs
1632 idx = vec_all_le(vbc, vuc);
1633 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1634 // CHECK-ASM: vchlbs
1635 idx = vec_all_le(vbc, vbc);
1636 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1637 // CHECK-ASM: vchlbs
1638 idx = vec_all_le(vss, vss);
1639 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1640 // CHECK-ASM: vchhs
1641 idx = vec_all_le(vss, vbs);
1642 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1643 // CHECK-ASM: vchhs
1644 idx = vec_all_le(vbs, vss);
1645 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1646 // CHECK-ASM: vchhs
1647 idx = vec_all_le(vus, vus);
1648 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1649 // CHECK-ASM: vchlhs
1650 idx = vec_all_le(vus, vbs);
1651 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1652 // CHECK-ASM: vchlhs
1653 idx = vec_all_le(vbs, vus);
1654 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1655 // CHECK-ASM: vchlhs
1656 idx = vec_all_le(vbs, vbs);
1657 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1658 // CHECK-ASM: vchlhs
1659 idx = vec_all_le(vsi, vsi);
1660 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1661 // CHECK-ASM: vchfs
1662 idx = vec_all_le(vsi, vbi);
1663 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1664 // CHECK-ASM: vchfs
1665 idx = vec_all_le(vbi, vsi);
1666 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1667 // CHECK-ASM: vchfs
1668 idx = vec_all_le(vui, vui);
1669 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1670 // CHECK-ASM: vchlfs
1671 idx = vec_all_le(vui, vbi);
1672 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1673 // CHECK-ASM: vchlfs
1674 idx = vec_all_le(vbi, vui);
1675 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1676 // CHECK-ASM: vchlfs
1677 idx = vec_all_le(vbi, vbi);
1678 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1679 // CHECK-ASM: vchlfs
1680 idx = vec_all_le(vsl, vsl);
1681 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1682 // CHECK-ASM: vchgs
1683 idx = vec_all_le(vsl, vbl);
1684 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1685 // CHECK-ASM: vchgs
1686 idx = vec_all_le(vbl, vsl);
1687 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1688 // CHECK-ASM: vchgs
1689 idx = vec_all_le(vul, vul);
1690 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1691 // CHECK-ASM: vchlgs
1692 idx = vec_all_le(vul, vbl);
1693 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1694 // CHECK-ASM: vchlgs
1695 idx = vec_all_le(vbl, vul);
1696 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1697 // CHECK-ASM: vchlgs
1698 idx = vec_all_le(vbl, vbl);
1699 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1700 // CHECK-ASM: vchlgs
1701 idx = vec_all_le(vd, vd);
1702 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1703 // CHECK-ASM: vfchedbs
1704
1705 idx = vec_all_lt(vsc, vsc);
1706 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1707 // CHECK-ASM: vchbs
1708 idx = vec_all_lt(vsc, vbc);
1709 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1710 // CHECK-ASM: vchbs
1711 idx = vec_all_lt(vbc, vsc);
1712 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1713 // CHECK-ASM: vchbs
1714 idx = vec_all_lt(vuc, vuc);
1715 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1716 // CHECK-ASM: vchlbs
1717 idx = vec_all_lt(vuc, vbc);
1718 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1719 // CHECK-ASM: vchlbs
1720 idx = vec_all_lt(vbc, vuc);
1721 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1722 // CHECK-ASM: vchlbs
1723 idx = vec_all_lt(vbc, vbc);
1724 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1725 // CHECK-ASM: vchlbs
1726 idx = vec_all_lt(vss, vss);
1727 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1728 // CHECK-ASM: vchhs
1729 idx = vec_all_lt(vss, vbs);
1730 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1731 // CHECK-ASM: vchhs
1732 idx = vec_all_lt(vbs, vss);
1733 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1734 // CHECK-ASM: vchhs
1735 idx = vec_all_lt(vus, vus);
1736 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1737 // CHECK-ASM: vchlhs
1738 idx = vec_all_lt(vus, vbs);
1739 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1740 // CHECK-ASM: vchlhs
1741 idx = vec_all_lt(vbs, vus);
1742 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1743 // CHECK-ASM: vchlhs
1744 idx = vec_all_lt(vbs, vbs);
1745 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1746 // CHECK-ASM: vchlhs
1747 idx = vec_all_lt(vsi, vsi);
1748 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1749 // CHECK-ASM: vchfs
1750 idx = vec_all_lt(vsi, vbi);
1751 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1752 // CHECK-ASM: vchfs
1753 idx = vec_all_lt(vbi, vsi);
1754 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1755 // CHECK-ASM: vchfs
1756 idx = vec_all_lt(vui, vui);
1757 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1758 // CHECK-ASM: vchlfs
1759 idx = vec_all_lt(vui, vbi);
1760 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1761 // CHECK-ASM: vchlfs
1762 idx = vec_all_lt(vbi, vui);
1763 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1764 // CHECK-ASM: vchlfs
1765 idx = vec_all_lt(vbi, vbi);
1766 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1767 // CHECK-ASM: vchlfs
1768 idx = vec_all_lt(vsl, vsl);
1769 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1770 // CHECK-ASM: vchgs
1771 idx = vec_all_lt(vsl, vbl);
1772 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1773 // CHECK-ASM: vchgs
1774 idx = vec_all_lt(vbl, vsl);
1775 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1776 // CHECK-ASM: vchgs
1777 idx = vec_all_lt(vul, vul);
1778 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1779 // CHECK-ASM: vchlgs
1780 idx = vec_all_lt(vul, vbl);
1781 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1782 // CHECK-ASM: vchlgs
1783 idx = vec_all_lt(vbl, vul);
1784 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1785 // CHECK-ASM: vchlgs
1786 idx = vec_all_lt(vbl, vbl);
1787 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1788 // CHECK-ASM: vchlgs
1789 idx = vec_all_lt(vd, vd);
1790 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1791 // CHECK-ASM: vfchdbs
1792
1793 idx = vec_all_nge(vd, vd);
1794 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1795 // CHECK-ASM: vfchedbs
1796 idx = vec_all_ngt(vd, vd);
1797 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1798 // CHECK-ASM: vfchdbs
1799 idx = vec_all_nle(vd, vd);
1800 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1801 // CHECK-ASM: vfchedbs
1802 idx = vec_all_nlt(vd, vd);
1803 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1804 // CHECK-ASM: vfchdbs
1805
1806 idx = vec_all_nan(vd);
1807 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
1808 // CHECK-ASM: vftcidb
1809 idx = vec_all_numeric(vd);
1810 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
1811 // CHECK-ASM: vftcidb
1812
1813 idx = vec_any_eq(vsc, vsc);
1814 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1815 // CHECK-ASM: vceqbs
1816 idx = vec_any_eq(vsc, vbc);
1817 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1818 // CHECK-ASM: vceqbs
1819 idx = vec_any_eq(vbc, vsc);
1820 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1821 // CHECK-ASM: vceqbs
1822 idx = vec_any_eq(vuc, vuc);
1823 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1824 // CHECK-ASM: vceqbs
1825 idx = vec_any_eq(vuc, vbc);
1826 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1827 // CHECK-ASM: vceqbs
1828 idx = vec_any_eq(vbc, vuc);
1829 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1830 // CHECK-ASM: vceqbs
1831 idx = vec_any_eq(vbc, vbc);
1832 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1833 // CHECK-ASM: vceqbs
1834 idx = vec_any_eq(vss, vss);
1835 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1836 // CHECK-ASM: vceqhs
1837 idx = vec_any_eq(vss, vbs);
1838 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1839 // CHECK-ASM: vceqhs
1840 idx = vec_any_eq(vbs, vss);
1841 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1842 // CHECK-ASM: vceqhs
1843 idx = vec_any_eq(vus, vus);
1844 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1845 // CHECK-ASM: vceqhs
1846 idx = vec_any_eq(vus, vbs);
1847 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1848 // CHECK-ASM: vceqhs
1849 idx = vec_any_eq(vbs, vus);
1850 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1851 // CHECK-ASM: vceqhs
1852 idx = vec_any_eq(vbs, vbs);
1853 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1854 // CHECK-ASM: vceqhs
1855 idx = vec_any_eq(vsi, vsi);
1856 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1857 // CHECK-ASM: vceqfs
1858 idx = vec_any_eq(vsi, vbi);
1859 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1860 // CHECK-ASM: vceqfs
1861 idx = vec_any_eq(vbi, vsi);
1862 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1863 // CHECK-ASM: vceqfs
1864 idx = vec_any_eq(vui, vui);
1865 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1866 // CHECK-ASM: vceqfs
1867 idx = vec_any_eq(vui, vbi);
1868 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1869 // CHECK-ASM: vceqfs
1870 idx = vec_any_eq(vbi, vui);
1871 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1872 // CHECK-ASM: vceqfs
1873 idx = vec_any_eq(vbi, vbi);
1874 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1875 // CHECK-ASM: vceqfs
1876 idx = vec_any_eq(vsl, vsl);
1877 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1878 // CHECK-ASM: vceqgs
1879 idx = vec_any_eq(vsl, vbl);
1880 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1881 // CHECK-ASM: vceqgs
1882 idx = vec_any_eq(vbl, vsl);
1883 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1884 // CHECK-ASM: vceqgs
1885 idx = vec_any_eq(vul, vul);
1886 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1887 // CHECK-ASM: vceqgs
1888 idx = vec_any_eq(vul, vbl);
1889 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1890 // CHECK-ASM: vceqgs
1891 idx = vec_any_eq(vbl, vul);
1892 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1893 // CHECK-ASM: vceqgs
1894 idx = vec_any_eq(vbl, vbl);
1895 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1896 // CHECK-ASM: vceqgs
1897 idx = vec_any_eq(vd, vd);
1898 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1899 // CHECK-ASM: vfcedbs
1900
1901 idx = vec_any_ne(vsc, vsc);
1902 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1903 // CHECK-ASM: vceqbs
1904 idx = vec_any_ne(vsc, vbc);
1905 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1906 // CHECK-ASM: vceqbs
1907 idx = vec_any_ne(vbc, vsc);
1908 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1909 // CHECK-ASM: vceqbs
1910 idx = vec_any_ne(vuc, vuc);
1911 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1912 // CHECK-ASM: vceqbs
1913 idx = vec_any_ne(vuc, vbc);
1914 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1915 // CHECK-ASM: vceqbs
1916 idx = vec_any_ne(vbc, vuc);
1917 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1918 // CHECK-ASM: vceqbs
1919 idx = vec_any_ne(vbc, vbc);
1920 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1921 // CHECK-ASM: vceqbs
1922 idx = vec_any_ne(vss, vss);
1923 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1924 // CHECK-ASM: vceqhs
1925 idx = vec_any_ne(vss, vbs);
1926 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1927 // CHECK-ASM: vceqhs
1928 idx = vec_any_ne(vbs, vss);
1929 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1930 // CHECK-ASM: vceqhs
1931 idx = vec_any_ne(vus, vus);
1932 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1933 // CHECK-ASM: vceqhs
1934 idx = vec_any_ne(vus, vbs);
1935 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1936 // CHECK-ASM: vceqhs
1937 idx = vec_any_ne(vbs, vus);
1938 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1939 // CHECK-ASM: vceqhs
1940 idx = vec_any_ne(vbs, vbs);
1941 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1942 // CHECK-ASM: vceqhs
1943 idx = vec_any_ne(vsi, vsi);
1944 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1945 // CHECK-ASM: vceqfs
1946 idx = vec_any_ne(vsi, vbi);
1947 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1948 // CHECK-ASM: vceqfs
1949 idx = vec_any_ne(vbi, vsi);
1950 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1951 // CHECK-ASM: vceqfs
1952 idx = vec_any_ne(vui, vui);
1953 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1954 // CHECK-ASM: vceqfs
1955 idx = vec_any_ne(vui, vbi);
1956 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1957 // CHECK-ASM: vceqfs
1958 idx = vec_any_ne(vbi, vui);
1959 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1960 // CHECK-ASM: vceqfs
1961 idx = vec_any_ne(vbi, vbi);
1962 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1963 // CHECK-ASM: vceqfs
1964 idx = vec_any_ne(vsl, vsl);
1965 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1966 // CHECK-ASM: vceqgs
1967 idx = vec_any_ne(vsl, vbl);
1968 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1969 // CHECK-ASM: vceqgs
1970 idx = vec_any_ne(vbl, vsl);
1971 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1972 // CHECK-ASM: vceqgs
1973 idx = vec_any_ne(vul, vul);
1974 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1975 // CHECK-ASM: vceqgs
1976 idx = vec_any_ne(vul, vbl);
1977 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1978 // CHECK-ASM: vceqgs
1979 idx = vec_any_ne(vbl, vul);
1980 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1981 // CHECK-ASM: vceqgs
1982 idx = vec_any_ne(vbl, vbl);
1983 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1984 // CHECK-ASM: vceqgs
1985 idx = vec_any_ne(vd, vd);
1986 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1987 // CHECK-ASM: vfcedbs
1988
1989 idx = vec_any_ge(vsc, vsc);
1990 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1991 // CHECK-ASM: vchbs
1992 idx = vec_any_ge(vsc, vbc);
1993 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1994 // CHECK-ASM: vchbs
1995 idx = vec_any_ge(vbc, vsc);
1996 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1997 // CHECK-ASM: vchbs
1998 idx = vec_any_ge(vuc, vuc);
1999 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2000 // CHECK-ASM: vchlbs
2001 idx = vec_any_ge(vuc, vbc);
2002 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2003 // CHECK-ASM: vchlbs
2004 idx = vec_any_ge(vbc, vuc);
2005 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2006 // CHECK-ASM: vchlbs
2007 idx = vec_any_ge(vbc, vbc);
2008 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2009 // CHECK-ASM: vchlbs
2010 idx = vec_any_ge(vss, vss);
2011 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2012 // CHECK-ASM: vchhs
2013 idx = vec_any_ge(vss, vbs);
2014 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2015 // CHECK-ASM: vchhs
2016 idx = vec_any_ge(vbs, vss);
2017 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2018 // CHECK-ASM: vchhs
2019 idx = vec_any_ge(vus, vus);
2020 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2021 // CHECK-ASM: vchlhs
2022 idx = vec_any_ge(vus, vbs);
2023 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2024 // CHECK-ASM: vchlhs
2025 idx = vec_any_ge(vbs, vus);
2026 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2027 // CHECK-ASM: vchlhs
2028 idx = vec_any_ge(vbs, vbs);
2029 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2030 // CHECK-ASM: vchlhs
2031 idx = vec_any_ge(vsi, vsi);
2032 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2033 // CHECK-ASM: vchfs
2034 idx = vec_any_ge(vsi, vbi);
2035 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2036 // CHECK-ASM: vchfs
2037 idx = vec_any_ge(vbi, vsi);
2038 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2039 // CHECK-ASM: vchfs
2040 idx = vec_any_ge(vui, vui);
2041 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2042 // CHECK-ASM: vchlfs
2043 idx = vec_any_ge(vui, vbi);
2044 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2045 // CHECK-ASM: vchlfs
2046 idx = vec_any_ge(vbi, vui);
2047 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2048 // CHECK-ASM: vchlfs
2049 idx = vec_any_ge(vbi, vbi);
2050 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2051 // CHECK-ASM: vchlfs
2052 idx = vec_any_ge(vsl, vsl);
2053 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2054 // CHECK-ASM: vchgs
2055 idx = vec_any_ge(vsl, vbl);
2056 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2057 // CHECK-ASM: vchgs
2058 idx = vec_any_ge(vbl, vsl);
2059 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2060 // CHECK-ASM: vchgs
2061 idx = vec_any_ge(vul, vul);
2062 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2063 // CHECK-ASM: vchlgs
2064 idx = vec_any_ge(vul, vbl);
2065 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2066 // CHECK-ASM: vchlgs
2067 idx = vec_any_ge(vbl, vul);
2068 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2069 // CHECK-ASM: vchlgs
2070 idx = vec_any_ge(vbl, vbl);
2071 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2072 // CHECK-ASM: vchlgs
2073 idx = vec_any_ge(vd, vd);
2074 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2075 // CHECK-ASM: vfchedbs
2076
2077 idx = vec_any_gt(vsc, vsc);
2078 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2079 // CHECK-ASM: vchbs
2080 idx = vec_any_gt(vsc, vbc);
2081 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2082 // CHECK-ASM: vchbs
2083 idx = vec_any_gt(vbc, vsc);
2084 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2085 // CHECK-ASM: vchbs
2086 idx = vec_any_gt(vuc, vuc);
2087 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2088 // CHECK-ASM: vchlbs
2089 idx = vec_any_gt(vuc, vbc);
2090 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2091 // CHECK-ASM: vchlbs
2092 idx = vec_any_gt(vbc, vuc);
2093 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2094 // CHECK-ASM: vchlbs
2095 idx = vec_any_gt(vbc, vbc);
2096 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2097 // CHECK-ASM: vchlbs
2098 idx = vec_any_gt(vss, vss);
2099 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2100 // CHECK-ASM: vchhs
2101 idx = vec_any_gt(vss, vbs);
2102 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2103 // CHECK-ASM: vchhs
2104 idx = vec_any_gt(vbs, vss);
2105 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2106 // CHECK-ASM: vchhs
2107 idx = vec_any_gt(vus, vus);
2108 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2109 // CHECK-ASM: vchlhs
2110 idx = vec_any_gt(vus, vbs);
2111 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2112 // CHECK-ASM: vchlhs
2113 idx = vec_any_gt(vbs, vus);
2114 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2115 // CHECK-ASM: vchlhs
2116 idx = vec_any_gt(vbs, vbs);
2117 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2118 // CHECK-ASM: vchlhs
2119 idx = vec_any_gt(vsi, vsi);
2120 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2121 // CHECK-ASM: vchfs
2122 idx = vec_any_gt(vsi, vbi);
2123 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2124 // CHECK-ASM: vchfs
2125 idx = vec_any_gt(vbi, vsi);
2126 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2127 // CHECK-ASM: vchfs
2128 idx = vec_any_gt(vui, vui);
2129 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2130 // CHECK-ASM: vchlfs
2131 idx = vec_any_gt(vui, vbi);
2132 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2133 // CHECK-ASM: vchlfs
2134 idx = vec_any_gt(vbi, vui);
2135 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2136 // CHECK-ASM: vchlfs
2137 idx = vec_any_gt(vbi, vbi);
2138 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2139 // CHECK-ASM: vchlfs
2140 idx = vec_any_gt(vsl, vsl);
2141 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2142 // CHECK-ASM: vchgs
2143 idx = vec_any_gt(vsl, vbl);
2144 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2145 // CHECK-ASM: vchgs
2146 idx = vec_any_gt(vbl, vsl);
2147 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2148 // CHECK-ASM: vchgs
2149 idx = vec_any_gt(vul, vul);
2150 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2151 // CHECK-ASM: vchlgs
2152 idx = vec_any_gt(vul, vbl);
2153 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2154 // CHECK-ASM: vchlgs
2155 idx = vec_any_gt(vbl, vul);
2156 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2157 // CHECK-ASM: vchlgs
2158 idx = vec_any_gt(vbl, vbl);
2159 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2160 // CHECK-ASM: vchlgs
2161 idx = vec_any_gt(vd, vd);
2162 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2163 // CHECK-ASM: vfchdbs
2164
2165 idx = vec_any_le(vsc, vsc);
2166 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2167 // CHECK-ASM: vchbs
2168 idx = vec_any_le(vsc, vbc);
2169 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2170 // CHECK-ASM: vchbs
2171 idx = vec_any_le(vbc, vsc);
2172 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2173 // CHECK-ASM: vchbs
2174 idx = vec_any_le(vuc, vuc);
2175 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2176 // CHECK-ASM: vchlbs
2177 idx = vec_any_le(vuc, vbc);
2178 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2179 // CHECK-ASM: vchlbs
2180 idx = vec_any_le(vbc, vuc);
2181 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2182 // CHECK-ASM: vchlbs
2183 idx = vec_any_le(vbc, vbc);
2184 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2185 // CHECK-ASM: vchlbs
2186 idx = vec_any_le(vss, vss);
2187 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2188 // CHECK-ASM: vchhs
2189 idx = vec_any_le(vss, vbs);
2190 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2191 // CHECK-ASM: vchhs
2192 idx = vec_any_le(vbs, vss);
2193 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2194 // CHECK-ASM: vchhs
2195 idx = vec_any_le(vus, vus);
2196 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2197 // CHECK-ASM: vchlhs
2198 idx = vec_any_le(vus, vbs);
2199 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2200 // CHECK-ASM: vchlhs
2201 idx = vec_any_le(vbs, vus);
2202 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2203 // CHECK-ASM: vchlhs
2204 idx = vec_any_le(vbs, vbs);
2205 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2206 // CHECK-ASM: vchlhs
2207 idx = vec_any_le(vsi, vsi);
2208 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2209 // CHECK-ASM: vchfs
2210 idx = vec_any_le(vsi, vbi);
2211 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2212 // CHECK-ASM: vchfs
2213 idx = vec_any_le(vbi, vsi);
2214 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2215 // CHECK-ASM: vchfs
2216 idx = vec_any_le(vui, vui);
2217 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2218 // CHECK-ASM: vchlfs
2219 idx = vec_any_le(vui, vbi);
2220 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2221 // CHECK-ASM: vchlfs
2222 idx = vec_any_le(vbi, vui);
2223 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2224 // CHECK-ASM: vchlfs
2225 idx = vec_any_le(vbi, vbi);
2226 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2227 // CHECK-ASM: vchlfs
2228 idx = vec_any_le(vsl, vsl);
2229 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2230 // CHECK-ASM: vchgs
2231 idx = vec_any_le(vsl, vbl);
2232 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2233 // CHECK-ASM: vchgs
2234 idx = vec_any_le(vbl, vsl);
2235 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2236 // CHECK-ASM: vchgs
2237 idx = vec_any_le(vul, vul);
2238 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2239 // CHECK-ASM: vchlgs
2240 idx = vec_any_le(vul, vbl);
2241 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2242 // CHECK-ASM: vchlgs
2243 idx = vec_any_le(vbl, vul);
2244 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2245 // CHECK-ASM: vchlgs
2246 idx = vec_any_le(vbl, vbl);
2247 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2248 // CHECK-ASM: vchlgs
2249 idx = vec_any_le(vd, vd);
2250 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2251 // CHECK-ASM: vfchedbs
2252
2253 idx = vec_any_lt(vsc, vsc);
2254 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2255 // CHECK-ASM: vchbs
2256 idx = vec_any_lt(vsc, vbc);
2257 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2258 // CHECK-ASM: vchbs
2259 idx = vec_any_lt(vbc, vsc);
2260 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2261 // CHECK-ASM: vchbs
2262 idx = vec_any_lt(vuc, vuc);
2263 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2264 // CHECK-ASM: vchlbs
2265 idx = vec_any_lt(vuc, vbc);
2266 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2267 // CHECK-ASM: vchlbs
2268 idx = vec_any_lt(vbc, vuc);
2269 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2270 // CHECK-ASM: vchlbs
2271 idx = vec_any_lt(vbc, vbc);
2272 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2273 // CHECK-ASM: vchlbs
2274 idx = vec_any_lt(vss, vss);
2275 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2276 // CHECK-ASM: vchhs
2277 idx = vec_any_lt(vss, vbs);
2278 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2279 // CHECK-ASM: vchhs
2280 idx = vec_any_lt(vbs, vss);
2281 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2282 // CHECK-ASM: vchhs
2283 idx = vec_any_lt(vus, vus);
2284 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2285 // CHECK-ASM: vchlhs
2286 idx = vec_any_lt(vus, vbs);
2287 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2288 // CHECK-ASM: vchlhs
2289 idx = vec_any_lt(vbs, vus);
2290 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2291 // CHECK-ASM: vchlhs
2292 idx = vec_any_lt(vbs, vbs);
2293 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2294 // CHECK-ASM: vchlhs
2295 idx = vec_any_lt(vsi, vsi);
2296 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2297 // CHECK-ASM: vchfs
2298 idx = vec_any_lt(vsi, vbi);
2299 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2300 // CHECK-ASM: vchfs
2301 idx = vec_any_lt(vbi, vsi);
2302 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2303 // CHECK-ASM: vchfs
2304 idx = vec_any_lt(vui, vui);
2305 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2306 // CHECK-ASM: vchlfs
2307 idx = vec_any_lt(vui, vbi);
2308 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2309 // CHECK-ASM: vchlfs
2310 idx = vec_any_lt(vbi, vui);
2311 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2312 // CHECK-ASM: vchlfs
2313 idx = vec_any_lt(vbi, vbi);
2314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2315 // CHECK-ASM: vchlfs
2316 idx = vec_any_lt(vsl, vsl);
2317 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2318 // CHECK-ASM: vchgs
2319 idx = vec_any_lt(vsl, vbl);
2320 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2321 // CHECK-ASM: vchgs
2322 idx = vec_any_lt(vbl, vsl);
2323 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2324 // CHECK-ASM: vchgs
2325 idx = vec_any_lt(vul, vul);
2326 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2327 // CHECK-ASM: vchlgs
2328 idx = vec_any_lt(vul, vbl);
2329 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2330 // CHECK-ASM: vchlgs
2331 idx = vec_any_lt(vbl, vul);
2332 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2333 // CHECK-ASM: vchlgs
2334 idx = vec_any_lt(vbl, vbl);
2335 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2336 // CHECK-ASM: vchlgs
2337 idx = vec_any_lt(vd, vd);
2338 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2339 // CHECK-ASM: vfchdbs
2340
2341 idx = vec_any_nge(vd, vd);
2342 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2343 // CHECK-ASM: vfchedbs
2344 idx = vec_any_ngt(vd, vd);
2345 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2346 // CHECK-ASM: vfchdbs
2347 idx = vec_any_nle(vd, vd);
2348 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2349 // CHECK-ASM: vfchedbs
2350 idx = vec_any_nlt(vd, vd);
2351 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2352 // CHECK-ASM: vfchdbs
2353
2354 idx = vec_any_nan(vd);
2355 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
2356 // CHECK-ASM: vftcidb
2357 idx = vec_any_numeric(vd);
2358 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
2359 // CHECK-ASM: vftcidb
2360 }
2361
test_integer(void)2362 void test_integer(void) {
2363 // CHECK-ASM-LABEL: test_integer
2364
2365 vsc = vec_andc(vsc, vsc);
2366 // CHECK-ASM: vnc
2367 vsc = vec_andc(vsc, vbc);
2368 // CHECK-ASM: vnc
2369 vsc = vec_andc(vbc, vsc);
2370 // CHECK-ASM: vnc
2371 vuc = vec_andc(vuc, vuc);
2372 // CHECK-ASM: vnc
2373 vuc = vec_andc(vuc, vbc);
2374 // CHECK-ASM: vnc
2375 vuc = vec_andc(vbc, vuc);
2376 // CHECK-ASM: vnc
2377 vbc = vec_andc(vbc, vbc);
2378 // CHECK-ASM: vnc
2379 vss = vec_andc(vss, vss);
2380 // CHECK-ASM: vnc
2381 vss = vec_andc(vss, vbs);
2382 // CHECK-ASM: vnc
2383 vss = vec_andc(vbs, vss);
2384 // CHECK-ASM: vnc
2385 vus = vec_andc(vus, vus);
2386 // CHECK-ASM: vnc
2387 vus = vec_andc(vus, vbs);
2388 // CHECK-ASM: vnc
2389 vus = vec_andc(vbs, vus);
2390 // CHECK-ASM: vnc
2391 vbs = vec_andc(vbs, vbs);
2392 // CHECK-ASM: vnc
2393 vsi = vec_andc(vsi, vsi);
2394 // CHECK-ASM: vnc
2395 vsi = vec_andc(vsi, vbi);
2396 // CHECK-ASM: vnc
2397 vsi = vec_andc(vbi, vsi);
2398 // CHECK-ASM: vnc
2399 vui = vec_andc(vui, vui);
2400 // CHECK-ASM: vnc
2401 vui = vec_andc(vui, vbi);
2402 // CHECK-ASM: vnc
2403 vui = vec_andc(vbi, vui);
2404 // CHECK-ASM: vnc
2405 vbi = vec_andc(vbi, vbi);
2406 // CHECK-ASM: vnc
2407 vsl = vec_andc(vsl, vsl);
2408 // CHECK-ASM: vnc
2409 vsl = vec_andc(vsl, vbl);
2410 // CHECK-ASM: vnc
2411 vsl = vec_andc(vbl, vsl);
2412 // CHECK-ASM: vnc
2413 vul = vec_andc(vul, vul);
2414 // CHECK-ASM: vnc
2415 vul = vec_andc(vul, vbl);
2416 // CHECK-ASM: vnc
2417 vul = vec_andc(vbl, vul);
2418 // CHECK-ASM: vnc
2419 vbl = vec_andc(vbl, vbl);
2420 // CHECK-ASM: vnc
2421 vd = vec_andc(vd, vd);
2422 // CHECK-ASM: vnc
2423 vd = vec_andc(vd, vbl);
2424 // CHECK-ASM: vnc
2425 vd = vec_andc(vbl, vd);
2426 // CHECK-ASM: vnc
2427
2428 vsc = vec_nor(vsc, vsc);
2429 // CHECK-ASM: vno
2430 vsc = vec_nor(vsc, vbc);
2431 // CHECK-ASM: vno
2432 vsc = vec_nor(vbc, vsc);
2433 // CHECK-ASM: vno
2434 vuc = vec_nor(vuc, vuc);
2435 // CHECK-ASM: vno
2436 vuc = vec_nor(vuc, vbc);
2437 // CHECK-ASM: vno
2438 vuc = vec_nor(vbc, vuc);
2439 // CHECK-ASM: vno
2440 vbc = vec_nor(vbc, vbc);
2441 // CHECK-ASM: vno
2442 vss = vec_nor(vss, vss);
2443 // CHECK-ASM: vno
2444 vss = vec_nor(vss, vbs);
2445 // CHECK-ASM: vno
2446 vss = vec_nor(vbs, vss);
2447 // CHECK-ASM: vno
2448 vus = vec_nor(vus, vus);
2449 // CHECK-ASM: vno
2450 vus = vec_nor(vus, vbs);
2451 // CHECK-ASM: vno
2452 vus = vec_nor(vbs, vus);
2453 // CHECK-ASM: vno
2454 vbs = vec_nor(vbs, vbs);
2455 // CHECK-ASM: vno
2456 vsi = vec_nor(vsi, vsi);
2457 // CHECK-ASM: vno
2458 vsi = vec_nor(vsi, vbi);
2459 // CHECK-ASM: vno
2460 vsi = vec_nor(vbi, vsi);
2461 // CHECK-ASM: vno
2462 vui = vec_nor(vui, vui);
2463 // CHECK-ASM: vno
2464 vui = vec_nor(vui, vbi);
2465 // CHECK-ASM: vno
2466 vui = vec_nor(vbi, vui);
2467 // CHECK-ASM: vno
2468 vbi = vec_nor(vbi, vbi);
2469 // CHECK-ASM: vno
2470 vsl = vec_nor(vsl, vsl);
2471 // CHECK-ASM: vno
2472 vsl = vec_nor(vsl, vbl);
2473 // CHECK-ASM: vno
2474 vsl = vec_nor(vbl, vsl);
2475 // CHECK-ASM: vno
2476 vul = vec_nor(vul, vul);
2477 // CHECK-ASM: vno
2478 vul = vec_nor(vul, vbl);
2479 // CHECK-ASM: vno
2480 vul = vec_nor(vbl, vul);
2481 // CHECK-ASM: vno
2482 vbl = vec_nor(vbl, vbl);
2483 // CHECK-ASM: vno
2484 vd = vec_nor(vd, vd);
2485 // CHECK-ASM: vno
2486 vd = vec_nor(vd, vbl);
2487 // CHECK-ASM: vno
2488 vd = vec_nor(vbl, vd);
2489 // CHECK-ASM: vno
2490
2491 vuc = vec_cntlz(vsc);
2492 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
2493 // CHECK-ASM: vclzb
2494 vuc = vec_cntlz(vuc);
2495 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
2496 // CHECK-ASM: vclzb
2497 vus = vec_cntlz(vss);
2498 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
2499 // CHECK-ASM: vclzh
2500 vus = vec_cntlz(vus);
2501 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
2502 // CHECK-ASM: vclzh
2503 vui = vec_cntlz(vsi);
2504 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
2505 // CHECK-ASM: vclzf
2506 vui = vec_cntlz(vui);
2507 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
2508 // CHECK-ASM: vclzf
2509 vul = vec_cntlz(vsl);
2510 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
2511 // CHECK-ASM: vclzg
2512 vul = vec_cntlz(vul);
2513 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
2514 // CHECK-ASM: vclzg
2515
2516 vuc = vec_cnttz(vsc);
2517 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
2518 // CHECK-ASM: vctzb
2519 vuc = vec_cnttz(vuc);
2520 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
2521 // CHECK-ASM: vctzb
2522 vus = vec_cnttz(vss);
2523 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
2524 // CHECK-ASM: vctzh
2525 vus = vec_cnttz(vus);
2526 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
2527 // CHECK-ASM: vctzh
2528 vui = vec_cnttz(vsi);
2529 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
2530 // CHECK-ASM: vctzf
2531 vui = vec_cnttz(vui);
2532 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
2533 // CHECK-ASM: vctzf
2534 vul = vec_cnttz(vsl);
2535 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
2536 // CHECK-ASM: vctzg
2537 vul = vec_cnttz(vul);
2538 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
2539 // CHECK-ASM: vctzg
2540
2541 vuc = vec_popcnt(vsc);
2542 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
2543 // CHECK-ASM: vpopct
2544 vuc = vec_popcnt(vuc);
2545 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
2546 // CHECK-ASM: vpopct
2547 vus = vec_popcnt(vss);
2548 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
2549 // (emulated)
2550 vus = vec_popcnt(vus);
2551 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
2552 // (emulated)
2553 vui = vec_popcnt(vsi);
2554 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
2555 // (emulated)
2556 vui = vec_popcnt(vui);
2557 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
2558 // (emulated)
2559 vul = vec_popcnt(vsl);
2560 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
2561 // (emulated)
2562 vul = vec_popcnt(vul);
2563 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
2564 // (emulated)
2565
2566 vsc = vec_rl(vsc, vuc);
2567 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2568 // CHECK-ASM: verllvb
2569 vuc = vec_rl(vuc, vuc);
2570 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2571 // CHECK-ASM: verllvb
2572 vss = vec_rl(vss, vus);
2573 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2574 // CHECK-ASM: verllvh
2575 vus = vec_rl(vus, vus);
2576 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2577 // CHECK-ASM: verllvh
2578 vsi = vec_rl(vsi, vui);
2579 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2580 // CHECK-ASM: verllvf
2581 vui = vec_rl(vui, vui);
2582 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2583 // CHECK-ASM: verllvf
2584 vsl = vec_rl(vsl, vul);
2585 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2586 // CHECK-ASM: verllvg
2587 vul = vec_rl(vul, vul);
2588 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2589 // CHECK-ASM: verllvg
2590
2591 vsc = vec_rli(vsc, ul);
2592 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
2593 // CHECK-ASM: verllb
2594 vuc = vec_rli(vuc, ul);
2595 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
2596 // CHECK-ASM: verllb
2597 vss = vec_rli(vss, ul);
2598 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
2599 // CHECK-ASM: verllh
2600 vus = vec_rli(vus, ul);
2601 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
2602 // CHECK-ASM: verllh
2603 vsi = vec_rli(vsi, ul);
2604 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
2605 // CHECK-ASM: verllf
2606 vui = vec_rli(vui, ul);
2607 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
2608 // CHECK-ASM: verllf
2609 vsl = vec_rli(vsl, ul);
2610 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
2611 // CHECK-ASM: verllg
2612 vul = vec_rli(vul, ul);
2613 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
2614 // CHECK-ASM: verllg
2615
2616 vsc = vec_rl_mask(vsc, vuc, 0);
2617 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2618 // CHECK-ASM: verimb
2619 vsc = vec_rl_mask(vsc, vuc, 255);
2620 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
2621 // CHECK-ASM: verimb
2622 vuc = vec_rl_mask(vuc, vuc, 0);
2623 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2624 // CHECK-ASM: verimb
2625 vuc = vec_rl_mask(vuc, vuc, 255);
2626 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
2627 // CHECK-ASM: verimb
2628 vss = vec_rl_mask(vss, vus, 0);
2629 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
2630 // CHECK-ASM: verimh
2631 vss = vec_rl_mask(vss, vus, 255);
2632 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
2633 // CHECK-ASM: verimh
2634 vus = vec_rl_mask(vus, vus, 0);
2635 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
2636 // CHECK-ASM: verimh
2637 vus = vec_rl_mask(vus, vus, 255);
2638 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
2639 // CHECK-ASM: verimh
2640 vsi = vec_rl_mask(vsi, vui, 0);
2641 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
2642 // CHECK-ASM: verimf
2643 vsi = vec_rl_mask(vsi, vui, 255);
2644 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
2645 // CHECK-ASM: verimf
2646 vui = vec_rl_mask(vui, vui, 0);
2647 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
2648 // CHECK-ASM: verimf
2649 vui = vec_rl_mask(vui, vui, 255);
2650 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
2651 // CHECK-ASM: verimf
2652 vsl = vec_rl_mask(vsl, vul, 0);
2653 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
2654 // CHECK-ASM: verimg
2655 vsl = vec_rl_mask(vsl, vul, 255);
2656 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
2657 // CHECK-ASM: verimg
2658 vul = vec_rl_mask(vul, vul, 0);
2659 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
2660 // CHECK-ASM: verimg
2661 vul = vec_rl_mask(vul, vul, 255);
2662 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
2663 // CHECK-ASM: verimg
2664
2665 vsc = vec_sll(vsc, vuc);
2666 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2667 // CHECK-ASM: vsl
2668 vsc = vec_sll(vsc, vus);
2669 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2670 // CHECK-ASM: vsl
2671 vsc = vec_sll(vsc, vui);
2672 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2673 // CHECK-ASM: vsl
2674 vuc = vec_sll(vuc, vuc);
2675 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2676 // CHECK-ASM: vsl
2677 vuc = vec_sll(vuc, vus);
2678 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2679 // CHECK-ASM: vsl
2680 vuc = vec_sll(vuc, vui);
2681 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2682 // CHECK-ASM: vsl
2683 vbc = vec_sll(vbc, vuc);
2684 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2685 // CHECK-ASM: vsl
2686 vbc = vec_sll(vbc, vus);
2687 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2688 // CHECK-ASM: vsl
2689 vbc = vec_sll(vbc, vui);
2690 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2691 // CHECK-ASM: vsl
2692 vss = vec_sll(vss, vuc);
2693 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2694 // CHECK-ASM: vsl
2695 vss = vec_sll(vss, vus);
2696 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2697 // CHECK-ASM: vsl
2698 vss = vec_sll(vss, vui);
2699 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2700 // CHECK-ASM: vsl
2701 vus = vec_sll(vus, vuc);
2702 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2703 // CHECK-ASM: vsl
2704 vus = vec_sll(vus, vus);
2705 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2706 // CHECK-ASM: vsl
2707 vus = vec_sll(vus, vui);
2708 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2709 // CHECK-ASM: vsl
2710 vbs = vec_sll(vbs, vuc);
2711 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2712 // CHECK-ASM: vsl
2713 vbs = vec_sll(vbs, vus);
2714 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2715 // CHECK-ASM: vsl
2716 vbs = vec_sll(vbs, vui);
2717 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2718 // CHECK-ASM: vsl
2719 vsi = vec_sll(vsi, vuc);
2720 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2721 // CHECK-ASM: vsl
2722 vsi = vec_sll(vsi, vus);
2723 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2724 // CHECK-ASM: vsl
2725 vsi = vec_sll(vsi, vui);
2726 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2727 // CHECK-ASM: vsl
2728 vui = vec_sll(vui, vuc);
2729 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2730 // CHECK-ASM: vsl
2731 vui = vec_sll(vui, vus);
2732 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2733 // CHECK-ASM: vsl
2734 vui = vec_sll(vui, vui);
2735 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2736 // CHECK-ASM: vsl
2737 vbi = vec_sll(vbi, vuc);
2738 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2739 // CHECK-ASM: vsl
2740 vbi = vec_sll(vbi, vus);
2741 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2742 // CHECK-ASM: vsl
2743 vbi = vec_sll(vbi, vui);
2744 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2745 // CHECK-ASM: vsl
2746 vsl = vec_sll(vsl, vuc);
2747 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2748 // CHECK-ASM: vsl
2749 vsl = vec_sll(vsl, vus);
2750 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2751 // CHECK-ASM: vsl
2752 vsl = vec_sll(vsl, vui);
2753 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2754 // CHECK-ASM: vsl
2755 vul = vec_sll(vul, vuc);
2756 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2757 // CHECK-ASM: vsl
2758 vul = vec_sll(vul, vus);
2759 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2760 // CHECK-ASM: vsl
2761 vul = vec_sll(vul, vui);
2762 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2763 // CHECK-ASM: vsl
2764 vbl = vec_sll(vbl, vuc);
2765 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2766 // CHECK-ASM: vsl
2767 vbl = vec_sll(vbl, vus);
2768 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2769 // CHECK-ASM: vsl
2770 vbl = vec_sll(vbl, vui);
2771 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2772 // CHECK-ASM: vsl
2773
2774 vsc = vec_slb(vsc, vsc);
2775 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2776 // CHECK-ASM: vslb
2777 vsc = vec_slb(vsc, vuc);
2778 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2779 // CHECK-ASM: vslb
2780 vuc = vec_slb(vuc, vsc);
2781 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2782 // CHECK-ASM: vslb
2783 vuc = vec_slb(vuc, vuc);
2784 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2785 // CHECK-ASM: vslb
2786 vss = vec_slb(vss, vss);
2787 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2788 // CHECK-ASM: vslb
2789 vss = vec_slb(vss, vus);
2790 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2791 // CHECK-ASM: vslb
2792 vus = vec_slb(vus, vss);
2793 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2794 // CHECK-ASM: vslb
2795 vus = vec_slb(vus, vus);
2796 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2797 // CHECK-ASM: vslb
2798 vsi = vec_slb(vsi, vsi);
2799 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2800 // CHECK-ASM: vslb
2801 vsi = vec_slb(vsi, vui);
2802 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2803 // CHECK-ASM: vslb
2804 vui = vec_slb(vui, vsi);
2805 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2806 // CHECK-ASM: vslb
2807 vui = vec_slb(vui, vui);
2808 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2809 // CHECK-ASM: vslb
2810 vsl = vec_slb(vsl, vsl);
2811 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2812 // CHECK-ASM: vslb
2813 vsl = vec_slb(vsl, vul);
2814 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2815 // CHECK-ASM: vslb
2816 vul = vec_slb(vul, vsl);
2817 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2818 // CHECK-ASM: vslb
2819 vul = vec_slb(vul, vul);
2820 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2821 // CHECK-ASM: vslb
2822 vd = vec_slb(vd, vsl);
2823 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2824 // CHECK-ASM: vslb
2825 vd = vec_slb(vd, vul);
2826 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2827 // CHECK-ASM: vslb
2828
2829 vsc = vec_sld(vsc, vsc, 0);
2830 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2831 // CHECK-ASM: vsldb
2832 vsc = vec_sld(vsc, vsc, 15);
2833 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2834 // CHECK-ASM: vsldb
2835 vuc = vec_sld(vuc, vuc, 0);
2836 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2837 // CHECK-ASM: vsldb
2838 vuc = vec_sld(vuc, vuc, 15);
2839 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2840 // CHECK-ASM: vsldb
2841 vbc = vec_sld(vbc, vbc, 0);
2842 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2843 // CHECK-ASM: vsldb
2844 vbc = vec_sld(vbc, vbc, 15);
2845 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2846 // CHECK-ASM: vsldb
2847 vss = vec_sld(vss, vss, 0);
2848 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2849 // CHECK-ASM: vsldb
2850 vss = vec_sld(vss, vss, 15);
2851 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2852 // CHECK-ASM: vsldb
2853 vus = vec_sld(vus, vus, 0);
2854 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2855 // CHECK-ASM: vsldb
2856 vus = vec_sld(vus, vus, 15);
2857 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2858 // CHECK-ASM: vsldb
2859 vbs = vec_sld(vbs, vbs, 0);
2860 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2861 // CHECK-ASM: vsldb
2862 vbs = vec_sld(vbs, vbs, 15);
2863 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2864 // CHECK-ASM: vsldb
2865 vsi = vec_sld(vsi, vsi, 0);
2866 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2867 // CHECK-ASM: vsldb
2868 vsi = vec_sld(vsi, vsi, 15);
2869 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2870 // CHECK-ASM: vsldb
2871 vui = vec_sld(vui, vui, 0);
2872 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2873 // CHECK-ASM: vsldb
2874 vui = vec_sld(vui, vui, 15);
2875 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2876 // CHECK-ASM: vsldb
2877 vbi = vec_sld(vbi, vbi, 0);
2878 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2879 // CHECK-ASM: vsldb
2880 vbi = vec_sld(vbi, vbi, 15);
2881 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2882 // CHECK-ASM: vsldb
2883 vsl = vec_sld(vsl, vsl, 0);
2884 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2885 // CHECK-ASM: vsldb
2886 vsl = vec_sld(vsl, vsl, 15);
2887 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2888 // CHECK-ASM: vsldb
2889 vul = vec_sld(vul, vul, 0);
2890 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2891 // CHECK-ASM: vsldb
2892 vul = vec_sld(vul, vul, 15);
2893 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2894 // CHECK-ASM: vsldb
2895 vbl = vec_sld(vbl, vbl, 0);
2896 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2897 // CHECK-ASM: vsldb
2898 vbl = vec_sld(vbl, vbl, 15);
2899 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2900 // CHECK-ASM: vsldb
2901 vd = vec_sld(vd, vd, 0);
2902 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2903 // CHECK-ASM: vsldb
2904 vd = vec_sld(vd, vd, 15);
2905 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2906 // CHECK-ASM: vsldb
2907
2908 vsc = vec_sldw(vsc, vsc, 0);
2909 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2910 // CHECK-ASM: vsldb
2911 vsc = vec_sldw(vsc, vsc, 3);
2912 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2913 // CHECK-ASM: vsldb
2914 vuc = vec_sldw(vuc, vuc, 0);
2915 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2916 // CHECK-ASM: vsldb
2917 vuc = vec_sldw(vuc, vuc, 3);
2918 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2919 // CHECK-ASM: vsldb
2920 vss = vec_sldw(vss, vss, 0);
2921 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2922 // CHECK-ASM: vsldb
2923 vss = vec_sldw(vss, vss, 3);
2924 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2925 // CHECK-ASM: vsldb
2926 vus = vec_sldw(vus, vus, 0);
2927 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2928 // CHECK-ASM: vsldb
2929 vus = vec_sldw(vus, vus, 3);
2930 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2931 // CHECK-ASM: vsldb
2932 vsi = vec_sldw(vsi, vsi, 0);
2933 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2934 // CHECK-ASM: vsldb
2935 vsi = vec_sldw(vsi, vsi, 3);
2936 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2937 // CHECK-ASM: vsldb
2938 vui = vec_sldw(vui, vui, 0);
2939 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2940 // CHECK-ASM: vsldb
2941 vui = vec_sldw(vui, vui, 3);
2942 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2943 // CHECK-ASM: vsldb
2944 vsl = vec_sldw(vsl, vsl, 0);
2945 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2946 // CHECK-ASM: vsldb
2947 vsl = vec_sldw(vsl, vsl, 3);
2948 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2949 // CHECK-ASM: vsldb
2950 vul = vec_sldw(vul, vul, 0);
2951 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2952 // CHECK-ASM: vsldb
2953 vul = vec_sldw(vul, vul, 3);
2954 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2955 // CHECK-ASM: vsldb
2956 vd = vec_sldw(vd, vd, 0);
2957 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2958 // CHECK-ASM: vsldb
2959 vd = vec_sldw(vd, vd, 3);
2960 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2961 // CHECK-ASM: vsldb
2962
2963 vsc = vec_sral(vsc, vuc);
2964 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2965 // CHECK-ASM: vsra
2966 vsc = vec_sral(vsc, vus);
2967 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2968 // CHECK-ASM: vsra
2969 vsc = vec_sral(vsc, vui);
2970 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2971 // CHECK-ASM: vsra
2972 vuc = vec_sral(vuc, vuc);
2973 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2974 // CHECK-ASM: vsra
2975 vuc = vec_sral(vuc, vus);
2976 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2977 // CHECK-ASM: vsra
2978 vuc = vec_sral(vuc, vui);
2979 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2980 // CHECK-ASM: vsra
2981 vbc = vec_sral(vbc, vuc);
2982 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2983 // CHECK-ASM: vsra
2984 vbc = vec_sral(vbc, vus);
2985 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2986 // CHECK-ASM: vsra
2987 vbc = vec_sral(vbc, vui);
2988 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2989 // CHECK-ASM: vsra
2990 vss = vec_sral(vss, vuc);
2991 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2992 // CHECK-ASM: vsra
2993 vss = vec_sral(vss, vus);
2994 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2995 // CHECK-ASM: vsra
2996 vss = vec_sral(vss, vui);
2997 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2998 // CHECK-ASM: vsra
2999 vus = vec_sral(vus, vuc);
3000 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3001 // CHECK-ASM: vsra
3002 vus = vec_sral(vus, vus);
3003 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3004 // CHECK-ASM: vsra
3005 vus = vec_sral(vus, vui);
3006 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3007 // CHECK-ASM: vsra
3008 vbs = vec_sral(vbs, vuc);
3009 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3010 // CHECK-ASM: vsra
3011 vbs = vec_sral(vbs, vus);
3012 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3013 // CHECK-ASM: vsra
3014 vbs = vec_sral(vbs, vui);
3015 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3016 // CHECK-ASM: vsra
3017 vsi = vec_sral(vsi, vuc);
3018 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3019 // CHECK-ASM: vsra
3020 vsi = vec_sral(vsi, vus);
3021 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3022 // CHECK-ASM: vsra
3023 vsi = vec_sral(vsi, vui);
3024 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3025 // CHECK-ASM: vsra
3026 vui = vec_sral(vui, vuc);
3027 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3028 // CHECK-ASM: vsra
3029 vui = vec_sral(vui, vus);
3030 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3031 // CHECK-ASM: vsra
3032 vui = vec_sral(vui, vui);
3033 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3034 // CHECK-ASM: vsra
3035 vbi = vec_sral(vbi, vuc);
3036 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3037 // CHECK-ASM: vsra
3038 vbi = vec_sral(vbi, vus);
3039 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3040 // CHECK-ASM: vsra
3041 vbi = vec_sral(vbi, vui);
3042 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3043 // CHECK-ASM: vsra
3044 vsl = vec_sral(vsl, vuc);
3045 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3046 // CHECK-ASM: vsra
3047 vsl = vec_sral(vsl, vus);
3048 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3049 // CHECK-ASM: vsra
3050 vsl = vec_sral(vsl, vui);
3051 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3052 // CHECK-ASM: vsra
3053 vul = vec_sral(vul, vuc);
3054 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3055 // CHECK-ASM: vsra
3056 vul = vec_sral(vul, vus);
3057 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3058 // CHECK-ASM: vsra
3059 vul = vec_sral(vul, vui);
3060 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3061 // CHECK-ASM: vsra
3062 vbl = vec_sral(vbl, vuc);
3063 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3064 // CHECK-ASM: vsra
3065 vbl = vec_sral(vbl, vus);
3066 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3067 // CHECK-ASM: vsra
3068 vbl = vec_sral(vbl, vui);
3069 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3070 // CHECK-ASM: vsra
3071
3072 vsc = vec_srab(vsc, vsc);
3073 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3074 // CHECK-ASM: vsrab
3075 vsc = vec_srab(vsc, vuc);
3076 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3077 // CHECK-ASM: vsrab
3078 vuc = vec_srab(vuc, vsc);
3079 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3080 // CHECK-ASM: vsrab
3081 vuc = vec_srab(vuc, vuc);
3082 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3083 // CHECK-ASM: vsrab
3084 vss = vec_srab(vss, vss);
3085 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3086 // CHECK-ASM: vsrab
3087 vss = vec_srab(vss, vus);
3088 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3089 // CHECK-ASM: vsrab
3090 vus = vec_srab(vus, vss);
3091 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3092 // CHECK-ASM: vsrab
3093 vus = vec_srab(vus, vus);
3094 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3095 // CHECK-ASM: vsrab
3096 vsi = vec_srab(vsi, vsi);
3097 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3098 // CHECK-ASM: vsrab
3099 vsi = vec_srab(vsi, vui);
3100 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3101 // CHECK-ASM: vsrab
3102 vui = vec_srab(vui, vsi);
3103 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3104 // CHECK-ASM: vsrab
3105 vui = vec_srab(vui, vui);
3106 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3107 // CHECK-ASM: vsrab
3108 vsl = vec_srab(vsl, vsl);
3109 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3110 // CHECK-ASM: vsrab
3111 vsl = vec_srab(vsl, vul);
3112 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3113 // CHECK-ASM: vsrab
3114 vul = vec_srab(vul, vsl);
3115 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3116 // CHECK-ASM: vsrab
3117 vul = vec_srab(vul, vul);
3118 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3119 // CHECK-ASM: vsrab
3120 vd = vec_srab(vd, vsl);
3121 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3122 // CHECK-ASM: vsrab
3123 vd = vec_srab(vd, vul);
3124 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3125 // CHECK-ASM: vsrab
3126
3127 vsc = vec_srl(vsc, vuc);
3128 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3129 // CHECK-ASM: vsrl
3130 vsc = vec_srl(vsc, vus);
3131 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3132 // CHECK-ASM: vsrl
3133 vsc = vec_srl(vsc, vui);
3134 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3135 // CHECK-ASM: vsrl
3136 vuc = vec_srl(vuc, vuc);
3137 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3138 // CHECK-ASM: vsrl
3139 vuc = vec_srl(vuc, vus);
3140 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3141 // CHECK-ASM: vsrl
3142 vuc = vec_srl(vuc, vui);
3143 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3144 // CHECK-ASM: vsrl
3145 vbc = vec_srl(vbc, vuc);
3146 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3147 // CHECK-ASM: vsrl
3148 vbc = vec_srl(vbc, vus);
3149 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3150 // CHECK-ASM: vsrl
3151 vbc = vec_srl(vbc, vui);
3152 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3153 // CHECK-ASM: vsrl
3154 vss = vec_srl(vss, vuc);
3155 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3156 // CHECK-ASM: vsrl
3157 vss = vec_srl(vss, vus);
3158 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3159 // CHECK-ASM: vsrl
3160 vss = vec_srl(vss, vui);
3161 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3162 // CHECK-ASM: vsrl
3163 vus = vec_srl(vus, vuc);
3164 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3165 // CHECK-ASM: vsrl
3166 vus = vec_srl(vus, vus);
3167 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3168 // CHECK-ASM: vsrl
3169 vus = vec_srl(vus, vui);
3170 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3171 // CHECK-ASM: vsrl
3172 vbs = vec_srl(vbs, vuc);
3173 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3174 // CHECK-ASM: vsrl
3175 vbs = vec_srl(vbs, vus);
3176 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3177 // CHECK-ASM: vsrl
3178 vbs = vec_srl(vbs, vui);
3179 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3180 // CHECK-ASM: vsrl
3181 vsi = vec_srl(vsi, vuc);
3182 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3183 // CHECK-ASM: vsrl
3184 vsi = vec_srl(vsi, vus);
3185 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3186 // CHECK-ASM: vsrl
3187 vsi = vec_srl(vsi, vui);
3188 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3189 // CHECK-ASM: vsrl
3190 vui = vec_srl(vui, vuc);
3191 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3192 // CHECK-ASM: vsrl
3193 vui = vec_srl(vui, vus);
3194 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3195 // CHECK-ASM: vsrl
3196 vui = vec_srl(vui, vui);
3197 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3198 // CHECK-ASM: vsrl
3199 vbi = vec_srl(vbi, vuc);
3200 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3201 // CHECK-ASM: vsrl
3202 vbi = vec_srl(vbi, vus);
3203 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3204 // CHECK-ASM: vsrl
3205 vbi = vec_srl(vbi, vui);
3206 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3207 // CHECK-ASM: vsrl
3208 vsl = vec_srl(vsl, vuc);
3209 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3210 // CHECK-ASM: vsrl
3211 vsl = vec_srl(vsl, vus);
3212 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3213 // CHECK-ASM: vsrl
3214 vsl = vec_srl(vsl, vui);
3215 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3216 // CHECK-ASM: vsrl
3217 vul = vec_srl(vul, vuc);
3218 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3219 // CHECK-ASM: vsrl
3220 vul = vec_srl(vul, vus);
3221 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3222 // CHECK-ASM: vsrl
3223 vul = vec_srl(vul, vui);
3224 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3225 // CHECK-ASM: vsrl
3226 vbl = vec_srl(vbl, vuc);
3227 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3228 // CHECK-ASM: vsrl
3229 vbl = vec_srl(vbl, vus);
3230 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3231 // CHECK-ASM: vsrl
3232 vbl = vec_srl(vbl, vui);
3233 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3234 // CHECK-ASM: vsrl
3235
3236 vsc = vec_srb(vsc, vsc);
3237 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3238 // CHECK-ASM: vsrlb
3239 vsc = vec_srb(vsc, vuc);
3240 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3241 // CHECK-ASM: vsrlb
3242 vuc = vec_srb(vuc, vsc);
3243 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3244 // CHECK-ASM: vsrlb
3245 vuc = vec_srb(vuc, vuc);
3246 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3247 // CHECK-ASM: vsrlb
3248 vss = vec_srb(vss, vss);
3249 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3250 // CHECK-ASM: vsrlb
3251 vss = vec_srb(vss, vus);
3252 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3253 // CHECK-ASM: vsrlb
3254 vus = vec_srb(vus, vss);
3255 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3256 // CHECK-ASM: vsrlb
3257 vus = vec_srb(vus, vus);
3258 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3259 // CHECK-ASM: vsrlb
3260 vsi = vec_srb(vsi, vsi);
3261 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3262 // CHECK-ASM: vsrlb
3263 vsi = vec_srb(vsi, vui);
3264 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3265 // CHECK-ASM: vsrlb
3266 vui = vec_srb(vui, vsi);
3267 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3268 // CHECK-ASM: vsrlb
3269 vui = vec_srb(vui, vui);
3270 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3271 // CHECK-ASM: vsrlb
3272 vsl = vec_srb(vsl, vsl);
3273 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3274 // CHECK-ASM: vsrlb
3275 vsl = vec_srb(vsl, vul);
3276 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3277 // CHECK-ASM: vsrlb
3278 vul = vec_srb(vul, vsl);
3279 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3280 // CHECK-ASM: vsrlb
3281 vul = vec_srb(vul, vul);
3282 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3283 // CHECK-ASM: vsrlb
3284 vd = vec_srb(vd, vsl);
3285 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3286 // CHECK-ASM: vsrlb
3287 vd = vec_srb(vd, vul);
3288 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3289 // CHECK-ASM: vsrlb
3290
3291 vsc = vec_abs(vsc);
3292 // CHECK-ASM: vlpb
3293 vss = vec_abs(vss);
3294 // CHECK-ASM: vlph
3295 vsi = vec_abs(vsi);
3296 // CHECK-ASM: vlpf
3297 vsl = vec_abs(vsl);
3298 // CHECK-ASM: vlpg
3299
3300 vsc = vec_max(vsc, vsc);
3301 // CHECK-ASM: vmxb
3302 vsc = vec_max(vsc, vbc);
3303 // CHECK-ASM: vmxb
3304 vsc = vec_max(vbc, vsc);
3305 // CHECK-ASM: vmxb
3306 vuc = vec_max(vuc, vuc);
3307 // CHECK-ASM: vmxlb
3308 vuc = vec_max(vuc, vbc);
3309 // CHECK-ASM: vmxlb
3310 vuc = vec_max(vbc, vuc);
3311 // CHECK-ASM: vmxlb
3312 vss = vec_max(vss, vss);
3313 // CHECK-ASM: vmxh
3314 vss = vec_max(vss, vbs);
3315 // CHECK-ASM: vmxh
3316 vss = vec_max(vbs, vss);
3317 // CHECK-ASM: vmxh
3318 vus = vec_max(vus, vus);
3319 // CHECK-ASM: vmxlh
3320 vus = vec_max(vus, vbs);
3321 // CHECK-ASM: vmxlh
3322 vus = vec_max(vbs, vus);
3323 // CHECK-ASM: vmxlh
3324 vsi = vec_max(vsi, vsi);
3325 // CHECK-ASM: vmxf
3326 vsi = vec_max(vsi, vbi);
3327 // CHECK-ASM: vmxf
3328 vsi = vec_max(vbi, vsi);
3329 // CHECK-ASM: vmxf
3330 vui = vec_max(vui, vui);
3331 // CHECK-ASM: vmxlf
3332 vui = vec_max(vui, vbi);
3333 // CHECK-ASM: vmxlf
3334 vui = vec_max(vbi, vui);
3335 // CHECK-ASM: vmxlf
3336 vsl = vec_max(vsl, vsl);
3337 // CHECK-ASM: vmxg
3338 vsl = vec_max(vsl, vbl);
3339 // CHECK-ASM: vmxg
3340 vsl = vec_max(vbl, vsl);
3341 // CHECK-ASM: vmxg
3342 vul = vec_max(vul, vul);
3343 // CHECK-ASM: vmxlg
3344 vul = vec_max(vul, vbl);
3345 // CHECK-ASM: vmxlg
3346 vul = vec_max(vbl, vul);
3347 // CHECK-ASM: vmxlg
3348 vd = vec_max(vd, vd);
3349 // (emulated)
3350
3351 vsc = vec_min(vsc, vsc);
3352 // CHECK-ASM: vmnb
3353 vsc = vec_min(vsc, vbc);
3354 // CHECK-ASM: vmnb
3355 vsc = vec_min(vbc, vsc);
3356 // CHECK-ASM: vmnb
3357 vuc = vec_min(vuc, vuc);
3358 // CHECK-ASM: vmnlb
3359 vuc = vec_min(vuc, vbc);
3360 // CHECK-ASM: vmnlb
3361 vuc = vec_min(vbc, vuc);
3362 // CHECK-ASM: vmnlb
3363 vss = vec_min(vss, vss);
3364 // CHECK-ASM: vmnh
3365 vss = vec_min(vss, vbs);
3366 // CHECK-ASM: vmnh
3367 vss = vec_min(vbs, vss);
3368 // CHECK-ASM: vmnh
3369 vus = vec_min(vus, vus);
3370 // CHECK-ASM: vmnlh
3371 vus = vec_min(vus, vbs);
3372 // CHECK-ASM: vmnlh
3373 vus = vec_min(vbs, vus);
3374 // CHECK-ASM: vmnlh
3375 vsi = vec_min(vsi, vsi);
3376 // CHECK-ASM: vmnf
3377 vsi = vec_min(vsi, vbi);
3378 // CHECK-ASM: vmnf
3379 vsi = vec_min(vbi, vsi);
3380 // CHECK-ASM: vmnf
3381 vui = vec_min(vui, vui);
3382 // CHECK-ASM: vmnlf
3383 vui = vec_min(vui, vbi);
3384 // CHECK-ASM: vmnlf
3385 vui = vec_min(vbi, vui);
3386 // CHECK-ASM: vmnlf
3387 vsl = vec_min(vsl, vsl);
3388 // CHECK-ASM: vmng
3389 vsl = vec_min(vsl, vbl);
3390 // CHECK-ASM: vmng
3391 vsl = vec_min(vbl, vsl);
3392 // CHECK-ASM: vmng
3393 vul = vec_min(vul, vul);
3394 // CHECK-ASM: vmnlg
3395 vul = vec_min(vul, vbl);
3396 // CHECK-ASM: vmnlg
3397 vul = vec_min(vbl, vul);
3398 // CHECK-ASM: vmnlg
3399 vd = vec_min(vd, vd);
3400 // (emulated)
3401
3402 vuc = vec_addc(vuc, vuc);
3403 // CHECK: call <16 x i8> @llvm.s390.vaccb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3404 // CHECK-ASM: vaccb
3405 vus = vec_addc(vus, vus);
3406 // CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3407 // CHECK-ASM: vacch
3408 vui = vec_addc(vui, vui);
3409 // CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3410 // CHECK-ASM: vaccf
3411 vul = vec_addc(vul, vul);
3412 // CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3413 // CHECK-ASM: vaccg
3414
3415 vuc = vec_add_u128(vuc, vuc);
3416 // CHECK: call <16 x i8> @llvm.s390.vaq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3417 // CHECK-ASM: vaq
3418 vuc = vec_addc_u128(vuc, vuc);
3419 // CHECK: call <16 x i8> @llvm.s390.vaccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3420 // CHECK-ASM: vaccq
3421 vuc = vec_adde_u128(vuc, vuc, vuc);
3422 // CHECK: call <16 x i8> @llvm.s390.vacq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3423 // CHECK-ASM: vacq
3424 vuc = vec_addec_u128(vuc, vuc, vuc);
3425 // CHECK: call <16 x i8> @llvm.s390.vacccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3426 // CHECK-ASM: vacccq
3427
3428 vsc = vec_avg(vsc, vsc);
3429 // CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3430 // CHECK-ASM: vavgb
3431 vuc = vec_avg(vuc, vuc);
3432 // CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3433 // CHECK-ASM: vavglb
3434 vss = vec_avg(vss, vss);
3435 // CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3436 // CHECK-ASM: vavgh
3437 vus = vec_avg(vus, vus);
3438 // CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3439 // CHECK-ASM: vavglh
3440 vsi = vec_avg(vsi, vsi);
3441 // CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3442 // CHECK-ASM: vavgf
3443 vui = vec_avg(vui, vui);
3444 // CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3445 // CHECK-ASM: vavglf
3446 vsl = vec_avg(vsl, vsl);
3447 // CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3448 // CHECK-ASM: vavgg
3449 vul = vec_avg(vul, vul);
3450 // CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3451 // CHECK-ASM: vavglg
3452
3453 vui = vec_checksum(vui, vui);
3454 // CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3455 // CHECK-ASM: vcksm
3456
3457 vus = vec_gfmsum(vuc, vuc);
3458 // CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3459 // CHECK-ASM: vgfmb
3460 vui = vec_gfmsum(vus, vus);
3461 // CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3462 // CHECK-ASM: vgfmh
3463 vul = vec_gfmsum(vui, vui);
3464 // CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3465 // CHECK-ASM: vgfmf
3466 vuc = vec_gfmsum_128(vul, vul);
3467 // CHECK: call <16 x i8> @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3468 // CHECK-ASM: vgfmg
3469
3470 vus = vec_gfmsum_accum(vuc, vuc, vus);
3471 // CHECK: call <8 x i16> @llvm.s390.vgfmab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3472 // CHECK-ASM: vgfmab
3473 vui = vec_gfmsum_accum(vus, vus, vui);
3474 // CHECK: call <4 x i32> @llvm.s390.vgfmah(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3475 // CHECK-ASM: vgfmah
3476 vul = vec_gfmsum_accum(vui, vui, vul);
3477 // CHECK: call <2 x i64> @llvm.s390.vgfmaf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3478 // CHECK-ASM: vgfmaf
3479 vuc = vec_gfmsum_accum_128(vul, vul, vuc);
3480 // CHECK: call <16 x i8> @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}})
3481 // CHECK-ASM: vgfmag
3482
3483 vsc = vec_mladd(vsc, vsc, vsc);
3484 // CHECK-ASM: vmalb
3485 vsc = vec_mladd(vuc, vsc, vsc);
3486 // CHECK-ASM: vmalb
3487 vsc = vec_mladd(vsc, vuc, vuc);
3488 // CHECK-ASM: vmalb
3489 vuc = vec_mladd(vuc, vuc, vuc);
3490 // CHECK-ASM: vmalb
3491 vss = vec_mladd(vss, vss, vss);
3492 // CHECK-ASM: vmalhw
3493 vss = vec_mladd(vus, vss, vss);
3494 // CHECK-ASM: vmalhw
3495 vss = vec_mladd(vss, vus, vus);
3496 // CHECK-ASM: vmalhw
3497 vus = vec_mladd(vus, vus, vus);
3498 // CHECK-ASM: vmalhw
3499 vsi = vec_mladd(vsi, vsi, vsi);
3500 // CHECK-ASM: vmalf
3501 vsi = vec_mladd(vui, vsi, vsi);
3502 // CHECK-ASM: vmalf
3503 vsi = vec_mladd(vsi, vui, vui);
3504 // CHECK-ASM: vmalf
3505 vui = vec_mladd(vui, vui, vui);
3506 // CHECK-ASM: vmalf
3507
3508 vsc = vec_mhadd(vsc, vsc, vsc);
3509 // CHECK: call <16 x i8> @llvm.s390.vmahb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3510 // CHECK-ASM: vmahb
3511 vuc = vec_mhadd(vuc, vuc, vuc);
3512 // CHECK: call <16 x i8> @llvm.s390.vmalhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3513 // CHECK-ASM: vmalhb
3514 vss = vec_mhadd(vss, vss, vss);
3515 // CHECK: call <8 x i16> @llvm.s390.vmahh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3516 // CHECK-ASM: vmahh
3517 vus = vec_mhadd(vus, vus, vus);
3518 // CHECK: call <8 x i16> @llvm.s390.vmalhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3519 // CHECK-ASM: vmalhh
3520 vsi = vec_mhadd(vsi, vsi, vsi);
3521 // CHECK: call <4 x i32> @llvm.s390.vmahf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3522 // CHECK-ASM: vmahf
3523 vui = vec_mhadd(vui, vui, vui);
3524 // CHECK: call <4 x i32> @llvm.s390.vmalhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3525 // CHECK-ASM: vmalhf
3526
3527 vss = vec_meadd(vsc, vsc, vss);
3528 // CHECK: call <8 x i16> @llvm.s390.vmaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3529 // CHECK-ASM: vmaeb
3530 vus = vec_meadd(vuc, vuc, vus);
3531 // CHECK: call <8 x i16> @llvm.s390.vmaleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3532 // CHECK-ASM: vmaleb
3533 vsi = vec_meadd(vss, vss, vsi);
3534 // CHECK: call <4 x i32> @llvm.s390.vmaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3535 // CHECK-ASM: vmaeh
3536 vui = vec_meadd(vus, vus, vui);
3537 // CHECK: call <4 x i32> @llvm.s390.vmaleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3538 // CHECK-ASM: vmaleh
3539 vsl = vec_meadd(vsi, vsi, vsl);
3540 // CHECK: call <2 x i64> @llvm.s390.vmaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3541 // CHECK-ASM: vmaef
3542 vul = vec_meadd(vui, vui, vul);
3543 // CHECK: call <2 x i64> @llvm.s390.vmalef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3544 // CHECK-ASM: vmalef
3545
3546 vss = vec_moadd(vsc, vsc, vss);
3547 // CHECK: call <8 x i16> @llvm.s390.vmaob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3548 // CHECK-ASM: vmaob
3549 vus = vec_moadd(vuc, vuc, vus);
3550 // CHECK: call <8 x i16> @llvm.s390.vmalob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3551 // CHECK-ASM: vmalob
3552 vsi = vec_moadd(vss, vss, vsi);
3553 // CHECK: call <4 x i32> @llvm.s390.vmaoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3554 // CHECK-ASM: vmaoh
3555 vui = vec_moadd(vus, vus, vui);
3556 // CHECK: call <4 x i32> @llvm.s390.vmaloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3557 // CHECK-ASM: vmaloh
3558 vsl = vec_moadd(vsi, vsi, vsl);
3559 // CHECK: call <2 x i64> @llvm.s390.vmaof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3560 // CHECK-ASM: vmaof
3561 vul = vec_moadd(vui, vui, vul);
3562 // CHECK: call <2 x i64> @llvm.s390.vmalof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3563 // CHECK-ASM: vmalof
3564
3565 vsc = vec_mulh(vsc, vsc);
3566 // CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3567 // CHECK-ASM: vmhb
3568 vuc = vec_mulh(vuc, vuc);
3569 // CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3570 // CHECK-ASM: vmlhb
3571 vss = vec_mulh(vss, vss);
3572 // CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3573 // CHECK-ASM: vmhh
3574 vus = vec_mulh(vus, vus);
3575 // CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3576 // CHECK-ASM: vmlhh
3577 vsi = vec_mulh(vsi, vsi);
3578 // CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3579 // CHECK-ASM: vmhf
3580 vui = vec_mulh(vui, vui);
3581 // CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3582 // CHECK-ASM: vmlhf
3583
3584 vss = vec_mule(vsc, vsc);
3585 // CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3586 // CHECK-ASM: vmeb
3587 vus = vec_mule(vuc, vuc);
3588 // CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3589 // CHECK-ASM: vmleb
3590 vsi = vec_mule(vss, vss);
3591 // CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3592 // CHECK-ASM: vmeh
3593 vui = vec_mule(vus, vus);
3594 // CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3595 // CHECK-ASM: vmleh
3596 vsl = vec_mule(vsi, vsi);
3597 // CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3598 // CHECK-ASM: vmef
3599 vul = vec_mule(vui, vui);
3600 // CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3601 // CHECK-ASM: vmlef
3602
3603 vss = vec_mulo(vsc, vsc);
3604 // CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3605 // CHECK-ASM: vmob
3606 vus = vec_mulo(vuc, vuc);
3607 // CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3608 // CHECK-ASM: vmlob
3609 vsi = vec_mulo(vss, vss);
3610 // CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3611 // CHECK-ASM: vmoh
3612 vui = vec_mulo(vus, vus);
3613 // CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3614 // CHECK-ASM: vmloh
3615 vsl = vec_mulo(vsi, vsi);
3616 // CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3617 // CHECK-ASM: vmof
3618 vul = vec_mulo(vui, vui);
3619 // CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3620 // CHECK-ASM: vmlof
3621
3622 vuc = vec_subc(vuc, vuc);
3623 // CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3624 // CHECK-ASM: vscbib
3625 vus = vec_subc(vus, vus);
3626 // CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3627 // CHECK-ASM: vscbih
3628 vui = vec_subc(vui, vui);
3629 // CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3630 // CHECK-ASM: vscbif
3631 vul = vec_subc(vul, vul);
3632 // CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3633 // CHECK-ASM: vscbig
3634
3635 vuc = vec_sub_u128(vuc, vuc);
3636 // CHECK: call <16 x i8> @llvm.s390.vsq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3637 // CHECK-ASM: vsq
3638 vuc = vec_subc_u128(vuc, vuc);
3639 // CHECK: call <16 x i8> @llvm.s390.vscbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3640 // CHECK-ASM: vscbiq
3641 vuc = vec_sube_u128(vuc, vuc, vuc);
3642 // CHECK: call <16 x i8> @llvm.s390.vsbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3643 // CHECK-ASM: vsbiq
3644 vuc = vec_subec_u128(vuc, vuc, vuc);
3645 // CHECK: call <16 x i8> @llvm.s390.vsbcbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3646 // CHECK-ASM: vsbcbiq
3647
3648 vui = vec_sum4(vuc, vuc);
3649 // CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3650 // CHECK-ASM: vsumb
3651 vui = vec_sum4(vus, vus);
3652 // CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3653 // CHECK-ASM: vsumh
3654 vul = vec_sum2(vus, vus);
3655 // CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3656 // CHECK-ASM: vsumgh
3657 vul = vec_sum2(vui, vui);
3658 // CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3659 // CHECK-ASM: vsumgf
3660 vuc = vec_sum_u128(vui, vui);
3661 // CHECK: call <16 x i8> @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3662 // CHECK-ASM: vsumqf
3663 vuc = vec_sum_u128(vul, vul);
3664 // CHECK: call <16 x i8> @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3665 // CHECK-ASM: vsumqg
3666
3667 idx = vec_test_mask(vsc, vuc);
3668 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3669 // CHECK-ASM: vtm
3670 idx = vec_test_mask(vuc, vuc);
3671 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3672 // CHECK-ASM: vtm
3673 idx = vec_test_mask(vss, vus);
3674 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3675 // CHECK-ASM: vtm
3676 idx = vec_test_mask(vus, vus);
3677 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3678 // CHECK-ASM: vtm
3679 idx = vec_test_mask(vsi, vui);
3680 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3681 // CHECK-ASM: vtm
3682 idx = vec_test_mask(vui, vui);
3683 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3684 // CHECK-ASM: vtm
3685 idx = vec_test_mask(vsl, vul);
3686 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3687 // CHECK-ASM: vtm
3688 idx = vec_test_mask(vul, vul);
3689 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3690 // CHECK-ASM: vtm
3691 idx = vec_test_mask(vd, vul);
3692 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3693 // CHECK-ASM: vtm
3694 }
3695
test_string(void)3696 void test_string(void) {
3697 // CHECK-ASM-LABEL: test_string
3698
3699 vsc = vec_cp_until_zero(vsc);
3700 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3701 // CHECK-ASM: vistrb
3702 vuc = vec_cp_until_zero(vuc);
3703 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3704 // CHECK-ASM: vistrb
3705 vbc = vec_cp_until_zero(vbc);
3706 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3707 // CHECK-ASM: vistrb
3708 vss = vec_cp_until_zero(vss);
3709 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3710 // CHECK-ASM: vistrh
3711 vus = vec_cp_until_zero(vus);
3712 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3713 // CHECK-ASM: vistrh
3714 vbs = vec_cp_until_zero(vbs);
3715 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3716 // CHECK-ASM: vistrh
3717 vsi = vec_cp_until_zero(vsi);
3718 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3719 // CHECK-ASM: vistrf
3720 vui = vec_cp_until_zero(vui);
3721 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3722 // CHECK-ASM: vistrf
3723 vbi = vec_cp_until_zero(vbi);
3724 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3725 // CHECK-ASM: vistrf
3726
3727 vsc = vec_cp_until_zero_cc(vsc, &cc);
3728 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3729 // CHECK-ASM: vistrbs
3730 vuc = vec_cp_until_zero_cc(vuc, &cc);
3731 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3732 // CHECK-ASM: vistrbs
3733 vbc = vec_cp_until_zero_cc(vbc, &cc);
3734 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3735 // CHECK-ASM: vistrbs
3736 vss = vec_cp_until_zero_cc(vss, &cc);
3737 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3738 // CHECK-ASM: vistrhs
3739 vus = vec_cp_until_zero_cc(vus, &cc);
3740 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3741 // CHECK-ASM: vistrhs
3742 vbs = vec_cp_until_zero_cc(vbs, &cc);
3743 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3744 // CHECK-ASM: vistrhs
3745 vsi = vec_cp_until_zero_cc(vsi, &cc);
3746 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3747 // CHECK-ASM: vistrfs
3748 vui = vec_cp_until_zero_cc(vui, &cc);
3749 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3750 // CHECK-ASM: vistrfs
3751 vbi = vec_cp_until_zero_cc(vbi, &cc);
3752 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3753 // CHECK-ASM: vistrfs
3754
3755 vsc = vec_cmpeq_idx(vsc, vsc);
3756 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3757 // CHECK-ASM: vfeeb
3758 vuc = vec_cmpeq_idx(vuc, vuc);
3759 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3760 // CHECK-ASM: vfeeb
3761 vuc = vec_cmpeq_idx(vbc, vbc);
3762 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3763 // CHECK-ASM: vfeeb
3764 vss = vec_cmpeq_idx(vss, vss);
3765 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3766 // CHECK-ASM: vfeeh
3767 vus = vec_cmpeq_idx(vus, vus);
3768 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3769 // CHECK-ASM: vfeeh
3770 vus = vec_cmpeq_idx(vbs, vbs);
3771 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3772 // CHECK-ASM: vfeeh
3773 vsi = vec_cmpeq_idx(vsi, vsi);
3774 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3775 // CHECK-ASM: vfeef
3776 vui = vec_cmpeq_idx(vui, vui);
3777 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3778 // CHECK-ASM: vfeef
3779 vui = vec_cmpeq_idx(vbi, vbi);
3780 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3781 // CHECK-ASM: vfeef
3782
3783 vsc = vec_cmpeq_idx_cc(vsc, vsc, &cc);
3784 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3785 // CHECK-ASM: vfeebs
3786 vuc = vec_cmpeq_idx_cc(vuc, vuc, &cc);
3787 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3788 // CHECK-ASM: vfeebs
3789 vuc = vec_cmpeq_idx_cc(vbc, vbc, &cc);
3790 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3791 // CHECK-ASM: vfeebs
3792 vss = vec_cmpeq_idx_cc(vss, vss, &cc);
3793 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3794 // CHECK-ASM: vfeehs
3795 vus = vec_cmpeq_idx_cc(vus, vus, &cc);
3796 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3797 // CHECK-ASM: vfeehs
3798 vus = vec_cmpeq_idx_cc(vbs, vbs, &cc);
3799 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3800 // CHECK-ASM: vfeehs
3801 vsi = vec_cmpeq_idx_cc(vsi, vsi, &cc);
3802 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3803 // CHECK-ASM: vfeefs
3804 vui = vec_cmpeq_idx_cc(vui, vui, &cc);
3805 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3806 // CHECK-ASM: vfeefs
3807 vui = vec_cmpeq_idx_cc(vbi, vbi, &cc);
3808 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3809 // CHECK-ASM: vfeefs
3810
3811 vsc = vec_cmpeq_or_0_idx(vsc, vsc);
3812 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3813 // CHECK-ASM: vfeezb
3814 vuc = vec_cmpeq_or_0_idx(vuc, vuc);
3815 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3816 // CHECK-ASM: vfeezb
3817 vuc = vec_cmpeq_or_0_idx(vbc, vbc);
3818 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3819 // CHECK-ASM: vfeezb
3820 vss = vec_cmpeq_or_0_idx(vss, vss);
3821 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3822 // CHECK-ASM: vfeezh
3823 vus = vec_cmpeq_or_0_idx(vus, vus);
3824 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3825 // CHECK-ASM: vfeezh
3826 vus = vec_cmpeq_or_0_idx(vbs, vbs);
3827 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3828 // CHECK-ASM: vfeezh
3829 vsi = vec_cmpeq_or_0_idx(vsi, vsi);
3830 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3831 // CHECK-ASM: vfeezf
3832 vui = vec_cmpeq_or_0_idx(vui, vui);
3833 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3834 // CHECK-ASM: vfeezf
3835 vui = vec_cmpeq_or_0_idx(vbi, vbi);
3836 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3837 // CHECK-ASM: vfeezf
3838
3839 vsc = vec_cmpeq_or_0_idx_cc(vsc, vsc, &cc);
3840 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3841 // CHECK-ASM: vfeezbs
3842 vuc = vec_cmpeq_or_0_idx_cc(vuc, vuc, &cc);
3843 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3844 // CHECK-ASM: vfeezbs
3845 vuc = vec_cmpeq_or_0_idx_cc(vbc, vbc, &cc);
3846 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3847 // CHECK-ASM: vfeezbs
3848 vss = vec_cmpeq_or_0_idx_cc(vss, vss, &cc);
3849 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3850 // CHECK-ASM: vfeezhs
3851 vus = vec_cmpeq_or_0_idx_cc(vus, vus, &cc);
3852 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3853 // CHECK-ASM: vfeezhs
3854 vus = vec_cmpeq_or_0_idx_cc(vbs, vbs, &cc);
3855 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3856 // CHECK-ASM: vfeezhs
3857 vsi = vec_cmpeq_or_0_idx_cc(vsi, vsi, &cc);
3858 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3859 // CHECK-ASM: vfeezfs
3860 vui = vec_cmpeq_or_0_idx_cc(vui, vui, &cc);
3861 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3862 // CHECK-ASM: vfeezfs
3863 vui = vec_cmpeq_or_0_idx_cc(vbi, vbi, &cc);
3864 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3865 // CHECK-ASM: vfeezfs
3866
3867 vsc = vec_cmpne_idx(vsc, vsc);
3868 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3869 // CHECK-ASM: vfeneb
3870 vuc = vec_cmpne_idx(vuc, vuc);
3871 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3872 // CHECK-ASM: vfeneb
3873 vuc = vec_cmpne_idx(vbc, vbc);
3874 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3875 // CHECK-ASM: vfeneb
3876 vss = vec_cmpne_idx(vss, vss);
3877 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3878 // CHECK-ASM: vfeneh
3879 vus = vec_cmpne_idx(vus, vus);
3880 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3881 // CHECK-ASM: vfeneh
3882 vus = vec_cmpne_idx(vbs, vbs);
3883 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3884 // CHECK-ASM: vfeneh
3885 vsi = vec_cmpne_idx(vsi, vsi);
3886 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3887 // CHECK-ASM: vfenef
3888 vui = vec_cmpne_idx(vui, vui);
3889 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3890 // CHECK-ASM: vfenef
3891 vui = vec_cmpne_idx(vbi, vbi);
3892 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3893 // CHECK-ASM: vfenef
3894
3895 vsc = vec_cmpne_idx_cc(vsc, vsc, &cc);
3896 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3897 // CHECK-ASM: vfenebs
3898 vuc = vec_cmpne_idx_cc(vuc, vuc, &cc);
3899 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3900 // CHECK-ASM: vfenebs
3901 vuc = vec_cmpne_idx_cc(vbc, vbc, &cc);
3902 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3903 // CHECK-ASM: vfenebs
3904 vss = vec_cmpne_idx_cc(vss, vss, &cc);
3905 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3906 // CHECK-ASM: vfenehs
3907 vus = vec_cmpne_idx_cc(vus, vus, &cc);
3908 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3909 // CHECK-ASM: vfenehs
3910 vus = vec_cmpne_idx_cc(vbs, vbs, &cc);
3911 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3912 // CHECK-ASM: vfenehs
3913 vsi = vec_cmpne_idx_cc(vsi, vsi, &cc);
3914 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3915 // CHECK-ASM: vfenefs
3916 vui = vec_cmpne_idx_cc(vui, vui, &cc);
3917 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3918 // CHECK-ASM: vfenefs
3919 vui = vec_cmpne_idx_cc(vbi, vbi, &cc);
3920 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3921 // CHECK-ASM: vfenefs
3922
3923 vsc = vec_cmpne_or_0_idx(vsc, vsc);
3924 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3925 // CHECK-ASM: vfenezb
3926 vuc = vec_cmpne_or_0_idx(vuc, vuc);
3927 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3928 // CHECK-ASM: vfenezb
3929 vuc = vec_cmpne_or_0_idx(vbc, vbc);
3930 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3931 // CHECK-ASM: vfenezb
3932 vss = vec_cmpne_or_0_idx(vss, vss);
3933 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3934 // CHECK-ASM: vfenezh
3935 vus = vec_cmpne_or_0_idx(vus, vus);
3936 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3937 // CHECK-ASM: vfenezh
3938 vus = vec_cmpne_or_0_idx(vbs, vbs);
3939 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3940 // CHECK-ASM: vfenezh
3941 vsi = vec_cmpne_or_0_idx(vsi, vsi);
3942 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3943 // CHECK-ASM: vfenezf
3944 vui = vec_cmpne_or_0_idx(vui, vui);
3945 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3946 // CHECK-ASM: vfenezf
3947 vui = vec_cmpne_or_0_idx(vbi, vbi);
3948 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3949 // CHECK-ASM: vfenezf
3950
3951 vsc = vec_cmpne_or_0_idx_cc(vsc, vsc, &cc);
3952 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3953 // CHECK-ASM: vfenezbs
3954 vuc = vec_cmpne_or_0_idx_cc(vuc, vuc, &cc);
3955 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3956 // CHECK-ASM: vfenezbs
3957 vuc = vec_cmpne_or_0_idx_cc(vbc, vbc, &cc);
3958 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3959 // CHECK-ASM: vfenezbs
3960 vss = vec_cmpne_or_0_idx_cc(vss, vss, &cc);
3961 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3962 // CHECK-ASM: vfenezhs
3963 vus = vec_cmpne_or_0_idx_cc(vus, vus, &cc);
3964 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3965 // CHECK-ASM: vfenezhs
3966 vus = vec_cmpne_or_0_idx_cc(vbs, vbs, &cc);
3967 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3968 // CHECK-ASM: vfenezhs
3969 vsi = vec_cmpne_or_0_idx_cc(vsi, vsi, &cc);
3970 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3971 // CHECK-ASM: vfenezfs
3972 vui = vec_cmpne_or_0_idx_cc(vui, vui, &cc);
3973 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3974 // CHECK-ASM: vfenezfs
3975 vui = vec_cmpne_or_0_idx_cc(vbi, vbi, &cc);
3976 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3977 // CHECK-ASM: vfenezfs
3978
3979 vbc = vec_cmprg(vuc, vuc, vuc);
3980 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
3981 // CHECK-ASM: vstrcb
3982 vbs = vec_cmprg(vus, vus, vus);
3983 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
3984 // CHECK-ASM: vstrch
3985 vbi = vec_cmprg(vui, vui, vui);
3986 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
3987 // CHECK-ASM: vstrcf
3988
3989 vbc = vec_cmprg_cc(vuc, vuc, vuc, &cc);
3990 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
3991 // CHECK-ASM: vstrcbs
3992 vbs = vec_cmprg_cc(vus, vus, vus, &cc);
3993 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
3994 // CHECK-ASM: vstrchs
3995 vbi = vec_cmprg_cc(vui, vui, vui, &cc);
3996 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
3997 // CHECK-ASM: vstrcfs
3998
3999 vuc = vec_cmprg_idx(vuc, vuc, vuc);
4000 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4001 // CHECK-ASM: vstrcb
4002 vus = vec_cmprg_idx(vus, vus, vus);
4003 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4004 // CHECK-ASM: vstrch
4005 vui = vec_cmprg_idx(vui, vui, vui);
4006 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4007 // CHECK-ASM: vstrcf
4008
4009 vuc = vec_cmprg_idx_cc(vuc, vuc, vuc, &cc);
4010 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4011 // CHECK-ASM: vstrcbs
4012 vus = vec_cmprg_idx_cc(vus, vus, vus, &cc);
4013 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4014 // CHECK-ASM: vstrchs
4015 vui = vec_cmprg_idx_cc(vui, vui, vui, &cc);
4016 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4017 // CHECK-ASM: vstrcfs
4018
4019 vuc = vec_cmprg_or_0_idx(vuc, vuc, vuc);
4020 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4021 // CHECK-ASM: vstrczb
4022 vus = vec_cmprg_or_0_idx(vus, vus, vus);
4023 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4024 // CHECK-ASM: vstrczh
4025 vui = vec_cmprg_or_0_idx(vui, vui, vui);
4026 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4027 // CHECK-ASM: vstrczf
4028
4029 vuc = vec_cmprg_or_0_idx_cc(vuc, vuc, vuc, &cc);
4030 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4031 // CHECK-ASM: vstrczbs
4032 vus = vec_cmprg_or_0_idx_cc(vus, vus, vus, &cc);
4033 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4034 // CHECK-ASM: vstrczhs
4035 vui = vec_cmprg_or_0_idx_cc(vui, vui, vui, &cc);
4036 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4037 // CHECK-ASM: vstrczfs
4038
4039 vbc = vec_cmpnrg(vuc, vuc, vuc);
4040 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4041 // CHECK-ASM: vstrcb
4042 vbs = vec_cmpnrg(vus, vus, vus);
4043 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4044 // CHECK-ASM: vstrch
4045 vbi = vec_cmpnrg(vui, vui, vui);
4046 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4047 // CHECK-ASM: vstrcf
4048
4049 vbc = vec_cmpnrg_cc(vuc, vuc, vuc, &cc);
4050 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4051 // CHECK-ASM: vstrcbs
4052 vbs = vec_cmpnrg_cc(vus, vus, vus, &cc);
4053 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4054 // CHECK-ASM: vstrchs
4055 vbi = vec_cmpnrg_cc(vui, vui, vui, &cc);
4056 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4057 // CHECK-ASM: vstrcfs
4058
4059 vuc = vec_cmpnrg_idx(vuc, vuc, vuc);
4060 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4061 // CHECK-ASM: vstrcb
4062 vus = vec_cmpnrg_idx(vus, vus, vus);
4063 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4064 // CHECK-ASM: vstrch
4065 vui = vec_cmpnrg_idx(vui, vui, vui);
4066 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4067 // CHECK-ASM: vstrcf
4068
4069 vuc = vec_cmpnrg_idx_cc(vuc, vuc, vuc, &cc);
4070 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4071 // CHECK-ASM: vstrcbs
4072 vus = vec_cmpnrg_idx_cc(vus, vus, vus, &cc);
4073 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4074 // CHECK-ASM: vstrchs
4075 vui = vec_cmpnrg_idx_cc(vui, vui, vui, &cc);
4076 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4077 // CHECK-ASM: vstrcfs
4078
4079 vuc = vec_cmpnrg_or_0_idx(vuc, vuc, vuc);
4080 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4081 // CHECK-ASM: vstrczb
4082 vus = vec_cmpnrg_or_0_idx(vus, vus, vus);
4083 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4084 // CHECK-ASM: vstrczh
4085 vui = vec_cmpnrg_or_0_idx(vui, vui, vui);
4086 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4087 // CHECK-ASM: vstrczf
4088
4089 vuc = vec_cmpnrg_or_0_idx_cc(vuc, vuc, vuc, &cc);
4090 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4091 // CHECK-ASM: vstrczbs
4092 vus = vec_cmpnrg_or_0_idx_cc(vus, vus, vus, &cc);
4093 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4094 // CHECK-ASM: vstrczhs
4095 vui = vec_cmpnrg_or_0_idx_cc(vui, vui, vui, &cc);
4096 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4097 // CHECK-ASM: vstrczfs
4098
4099 vbc = vec_find_any_eq(vsc, vsc);
4100 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4101 // CHECK-ASM: vfaeb
4102 vbc = vec_find_any_eq(vuc, vuc);
4103 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4104 // CHECK-ASM: vfaeb
4105 vbc = vec_find_any_eq(vbc, vbc);
4106 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4107 // CHECK-ASM: vfaeb
4108 vbs = vec_find_any_eq(vss, vss);
4109 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4110 // CHECK-ASM: vfaeh
4111 vbs = vec_find_any_eq(vus, vus);
4112 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4113 // CHECK-ASM: vfaeh
4114 vbs = vec_find_any_eq(vbs, vbs);
4115 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4116 // CHECK-ASM: vfaeh
4117 vbi = vec_find_any_eq(vsi, vsi);
4118 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4119 // CHECK-ASM: vfaef
4120 vbi = vec_find_any_eq(vui, vui);
4121 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4122 // CHECK-ASM: vfaef
4123 vbi = vec_find_any_eq(vbi, vbi);
4124 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4125 // CHECK-ASM: vfaef
4126
4127 vbc = vec_find_any_eq_cc(vsc, vsc, &cc);
4128 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4129 // CHECK-ASM: vfaebs
4130 vbc = vec_find_any_eq_cc(vuc, vuc, &cc);
4131 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4132 // CHECK-ASM: vfaebs
4133 vbc = vec_find_any_eq_cc(vbc, vbc, &cc);
4134 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4135 // CHECK-ASM: vfaebs
4136 vbs = vec_find_any_eq_cc(vss, vss, &cc);
4137 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4138 // CHECK-ASM: vfaehs
4139 vbs = vec_find_any_eq_cc(vus, vus, &cc);
4140 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4141 // CHECK-ASM: vfaehs
4142 vbs = vec_find_any_eq_cc(vbs, vbs, &cc);
4143 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4144 // CHECK-ASM: vfaehs
4145 vbi = vec_find_any_eq_cc(vsi, vsi, &cc);
4146 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4147 // CHECK-ASM: vfaefs
4148 vbi = vec_find_any_eq_cc(vui, vui, &cc);
4149 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4150 // CHECK-ASM: vfaefs
4151 vbi = vec_find_any_eq_cc(vbi, vbi, &cc);
4152 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4153 // CHECK-ASM: vfaefs
4154
4155 vsc = vec_find_any_eq_idx(vsc, vsc);
4156 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4157 // CHECK-ASM: vfaeb
4158 vuc = vec_find_any_eq_idx(vuc, vuc);
4159 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4160 // CHECK-ASM: vfaeb
4161 vuc = vec_find_any_eq_idx(vbc, vbc);
4162 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4163 // CHECK-ASM: vfaeb
4164 vss = vec_find_any_eq_idx(vss, vss);
4165 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4166 // CHECK-ASM: vfaeh
4167 vus = vec_find_any_eq_idx(vus, vus);
4168 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4169 // CHECK-ASM: vfaeh
4170 vus = vec_find_any_eq_idx(vbs, vbs);
4171 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4172 // CHECK-ASM: vfaeh
4173 vsi = vec_find_any_eq_idx(vsi, vsi);
4174 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4175 // CHECK-ASM: vfaef
4176 vui = vec_find_any_eq_idx(vui, vui);
4177 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4178 // CHECK-ASM: vfaef
4179 vui = vec_find_any_eq_idx(vbi, vbi);
4180 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4181 // CHECK-ASM: vfaef
4182
4183 vsc = vec_find_any_eq_idx_cc(vsc, vsc, &cc);
4184 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4185 // CHECK-ASM: vfaebs
4186 vuc = vec_find_any_eq_idx_cc(vuc, vuc, &cc);
4187 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4188 // CHECK-ASM: vfaebs
4189 vuc = vec_find_any_eq_idx_cc(vbc, vbc, &cc);
4190 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4191 // CHECK-ASM: vfaebs
4192 vss = vec_find_any_eq_idx_cc(vss, vss, &cc);
4193 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4194 // CHECK-ASM: vfaehs
4195 vus = vec_find_any_eq_idx_cc(vus, vus, &cc);
4196 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4197 // CHECK-ASM: vfaehs
4198 vus = vec_find_any_eq_idx_cc(vbs, vbs, &cc);
4199 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4200 // CHECK-ASM: vfaehs
4201 vsi = vec_find_any_eq_idx_cc(vsi, vsi, &cc);
4202 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4203 // CHECK-ASM: vfaefs
4204 vui = vec_find_any_eq_idx_cc(vui, vui, &cc);
4205 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4206 // CHECK-ASM: vfaefs
4207 vui = vec_find_any_eq_idx_cc(vbi, vbi, &cc);
4208 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4209 // CHECK-ASM: vfaefs
4210
4211 vsc = vec_find_any_eq_or_0_idx(vsc, vsc);
4212 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4213 // CHECK-ASM: vfaezb
4214 vuc = vec_find_any_eq_or_0_idx(vuc, vuc);
4215 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4216 // CHECK-ASM: vfaezb
4217 vuc = vec_find_any_eq_or_0_idx(vbc, vbc);
4218 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4219 // CHECK-ASM: vfaezb
4220 vss = vec_find_any_eq_or_0_idx(vss, vss);
4221 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4222 // CHECK-ASM: vfaezh
4223 vus = vec_find_any_eq_or_0_idx(vus, vus);
4224 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4225 // CHECK-ASM: vfaezh
4226 vus = vec_find_any_eq_or_0_idx(vbs, vbs);
4227 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4228 // CHECK-ASM: vfaezh
4229 vsi = vec_find_any_eq_or_0_idx(vsi, vsi);
4230 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4231 // CHECK-ASM: vfaezf
4232 vui = vec_find_any_eq_or_0_idx(vui, vui);
4233 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4234 // CHECK-ASM: vfaezf
4235 vui = vec_find_any_eq_or_0_idx(vbi, vbi);
4236 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4237 // CHECK-ASM: vfaezf
4238
4239 vsc = vec_find_any_eq_or_0_idx_cc(vsc, vsc, &cc);
4240 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4241 // CHECK-ASM: vfaezbs
4242 vuc = vec_find_any_eq_or_0_idx_cc(vuc, vuc, &cc);
4243 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4244 // CHECK-ASM: vfaezbs
4245 vuc = vec_find_any_eq_or_0_idx_cc(vbc, vbc, &cc);
4246 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4247 // CHECK-ASM: vfaezbs
4248 vss = vec_find_any_eq_or_0_idx_cc(vss, vss, &cc);
4249 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4250 // CHECK-ASM: vfaezhs
4251 vus = vec_find_any_eq_or_0_idx_cc(vus, vus, &cc);
4252 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4253 // CHECK-ASM: vfaezhs
4254 vus = vec_find_any_eq_or_0_idx_cc(vbs, vbs, &cc);
4255 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4256 // CHECK-ASM: vfaezhs
4257 vsi = vec_find_any_eq_or_0_idx_cc(vsi, vsi, &cc);
4258 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4259 // CHECK-ASM: vfaezfs
4260 vui = vec_find_any_eq_or_0_idx_cc(vui, vui, &cc);
4261 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4262 // CHECK-ASM: vfaezfs
4263 vui = vec_find_any_eq_or_0_idx_cc(vbi, vbi, &cc);
4264 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4265 // CHECK-ASM: vfaezfs
4266
4267 vbc = vec_find_any_ne(vsc, vsc);
4268 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4269 // CHECK-ASM: vfaeb
4270 vbc = vec_find_any_ne(vuc, vuc);
4271 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4272 // CHECK-ASM: vfaeb
4273 vbc = vec_find_any_ne(vbc, vbc);
4274 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4275 // CHECK-ASM: vfaeb
4276 vbs = vec_find_any_ne(vss, vss);
4277 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4278 // CHECK-ASM: vfaeh
4279 vbs = vec_find_any_ne(vus, vus);
4280 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4281 // CHECK-ASM: vfaeh
4282 vbs = vec_find_any_ne(vbs, vbs);
4283 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4284 // CHECK-ASM: vfaeh
4285 vbi = vec_find_any_ne(vsi, vsi);
4286 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4287 // CHECK-ASM: vfaef
4288 vbi = vec_find_any_ne(vui, vui);
4289 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4290 // CHECK-ASM: vfaef
4291 vbi = vec_find_any_ne(vbi, vbi);
4292 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4293 // CHECK-ASM: vfaef
4294
4295 vbc = vec_find_any_ne_cc(vsc, vsc, &cc);
4296 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4297 // CHECK-ASM: vfaebs
4298 vbc = vec_find_any_ne_cc(vuc, vuc, &cc);
4299 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4300 // CHECK-ASM: vfaebs
4301 vbc = vec_find_any_ne_cc(vbc, vbc, &cc);
4302 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4303 // CHECK-ASM: vfaebs
4304 vbs = vec_find_any_ne_cc(vss, vss, &cc);
4305 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4306 // CHECK-ASM: vfaehs
4307 vbs = vec_find_any_ne_cc(vus, vus, &cc);
4308 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4309 // CHECK-ASM: vfaehs
4310 vbs = vec_find_any_ne_cc(vbs, vbs, &cc);
4311 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4312 // CHECK-ASM: vfaehs
4313 vbi = vec_find_any_ne_cc(vsi, vsi, &cc);
4314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4315 // CHECK-ASM: vfaefs
4316 vbi = vec_find_any_ne_cc(vui, vui, &cc);
4317 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4318 // CHECK-ASM: vfaefs
4319 vbi = vec_find_any_ne_cc(vbi, vbi, &cc);
4320 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4321 // CHECK-ASM: vfaefs
4322
4323 vsc = vec_find_any_ne_idx(vsc, vsc);
4324 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4325 // CHECK-ASM: vfaeb
4326 vuc = vec_find_any_ne_idx(vuc, vuc);
4327 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4328 // CHECK-ASM: vfaeb
4329 vuc = vec_find_any_ne_idx(vbc, vbc);
4330 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4331 // CHECK-ASM: vfaeb
4332 vss = vec_find_any_ne_idx(vss, vss);
4333 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4334 // CHECK-ASM: vfaeh
4335 vus = vec_find_any_ne_idx(vus, vus);
4336 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4337 // CHECK-ASM: vfaeh
4338 vus = vec_find_any_ne_idx(vbs, vbs);
4339 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4340 // CHECK-ASM: vfaeh
4341 vsi = vec_find_any_ne_idx(vsi, vsi);
4342 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4343 // CHECK-ASM: vfaef
4344 vui = vec_find_any_ne_idx(vui, vui);
4345 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4346 // CHECK-ASM: vfaef
4347 vui = vec_find_any_ne_idx(vbi, vbi);
4348 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4349 // CHECK-ASM: vfaef
4350
4351 vsc = vec_find_any_ne_idx_cc(vsc, vsc, &cc);
4352 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4353 // CHECK-ASM: vfaebs
4354 vuc = vec_find_any_ne_idx_cc(vuc, vuc, &cc);
4355 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4356 // CHECK-ASM: vfaebs
4357 vuc = vec_find_any_ne_idx_cc(vbc, vbc, &cc);
4358 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4359 // CHECK-ASM: vfaebs
4360 vss = vec_find_any_ne_idx_cc(vss, vss, &cc);
4361 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4362 // CHECK-ASM: vfaehs
4363 vus = vec_find_any_ne_idx_cc(vus, vus, &cc);
4364 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4365 // CHECK-ASM: vfaehs
4366 vus = vec_find_any_ne_idx_cc(vbs, vbs, &cc);
4367 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4368 // CHECK-ASM: vfaehs
4369 vsi = vec_find_any_ne_idx_cc(vsi, vsi, &cc);
4370 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4371 // CHECK-ASM: vfaefs
4372 vui = vec_find_any_ne_idx_cc(vui, vui, &cc);
4373 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4374 // CHECK-ASM: vfaefs
4375 vui = vec_find_any_ne_idx_cc(vbi, vbi, &cc);
4376 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4377 // CHECK-ASM: vfaefs
4378
4379 vsc = vec_find_any_ne_or_0_idx(vsc, vsc);
4380 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4381 // CHECK-ASM: vfaezb
4382 vuc = vec_find_any_ne_or_0_idx(vuc, vuc);
4383 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4384 // CHECK-ASM: vfaezb
4385 vuc = vec_find_any_ne_or_0_idx(vbc, vbc);
4386 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4387 // CHECK-ASM: vfaezb
4388 vss = vec_find_any_ne_or_0_idx(vss, vss);
4389 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4390 // CHECK-ASM: vfaezh
4391 vus = vec_find_any_ne_or_0_idx(vus, vus);
4392 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4393 // CHECK-ASM: vfaezh
4394 vus = vec_find_any_ne_or_0_idx(vbs, vbs);
4395 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4396 // CHECK-ASM: vfaezh
4397 vsi = vec_find_any_ne_or_0_idx(vsi, vsi);
4398 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4399 // CHECK-ASM: vfaezf
4400 vui = vec_find_any_ne_or_0_idx(vui, vui);
4401 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4402 // CHECK-ASM: vfaezf
4403 vui = vec_find_any_ne_or_0_idx(vbi, vbi);
4404 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4405 // CHECK-ASM: vfaezf
4406
4407 vsc = vec_find_any_ne_or_0_idx_cc(vsc, vsc, &cc);
4408 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4409 // CHECK-ASM: vfaezbs
4410 vuc = vec_find_any_ne_or_0_idx_cc(vuc, vuc, &cc);
4411 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4412 // CHECK-ASM: vfaezbs
4413 vuc = vec_find_any_ne_or_0_idx_cc(vbc, vbc, &cc);
4414 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4415 // CHECK-ASM: vfaezbs
4416 vss = vec_find_any_ne_or_0_idx_cc(vss, vss, &cc);
4417 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4418 // CHECK-ASM: vfaezhs
4419 vus = vec_find_any_ne_or_0_idx_cc(vus, vus, &cc);
4420 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4421 // CHECK-ASM: vfaezhs
4422 vus = vec_find_any_ne_or_0_idx_cc(vbs, vbs, &cc);
4423 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4424 // CHECK-ASM: vfaezhs
4425 vsi = vec_find_any_ne_or_0_idx_cc(vsi, vsi, &cc);
4426 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4427 // CHECK-ASM: vfaezfs
4428 vui = vec_find_any_ne_or_0_idx_cc(vui, vui, &cc);
4429 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4430 // CHECK-ASM: vfaezfs
4431 vui = vec_find_any_ne_or_0_idx_cc(vbi, vbi, &cc);
4432 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4433 // CHECK-ASM: vfaezfs
4434 }
4435
test_float(void)4436 void test_float(void) {
4437 // CHECK-ASM-LABEL: test_float
4438
4439 vd = vec_abs(vd);
4440 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
4441 // CHECK-ASM: vflpdb
4442
4443 vd = vec_nabs(vd);
4444 // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
4445 // CHECK-NEXT: fneg <2 x double> [[ABS]]
4446 // CHECK-ASM: vflndb
4447
4448 vd = vec_madd(vd, vd, vd);
4449 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
4450 // CHECK-ASM: vfmadb
4451 vd = vec_msub(vd, vd, vd);
4452 // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
4453 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
4454 // CHECK-ASM: vfmsdb
4455 vd = vec_sqrt(vd);
4456 // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
4457 // CHECK-ASM: vfsqdb
4458
4459 vd = vec_ld2f(cptrf);
4460 // CHECK: [[VAL:%[^ ]+]] = load <2 x float>, <2 x float>* %{{.*}}
4461 // CHECK: fpext <2 x float> [[VAL]] to <2 x double>
4462 // (emulated)
4463 vec_st2f(vd, ptrf);
4464 // CHECK: [[VAL:%[^ ]+]] = fptrunc <2 x double> %{{.*}} to <2 x float>
4465 // CHECK: store <2 x float> [[VAL]], <2 x float>* %{{.*}}
4466 // (emulated)
4467
4468 vd = vec_ctd(vsl, 0);
4469 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
4470 // (emulated)
4471 vd = vec_ctd(vul, 0);
4472 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
4473 // (emulated)
4474 vd = vec_ctd(vsl, 1);
4475 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
4476 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
4477 // (emulated)
4478 vd = vec_ctd(vul, 1);
4479 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
4480 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
4481 // (emulated)
4482 vd = vec_ctd(vsl, 31);
4483 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
4484 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
4485 // (emulated)
4486 vd = vec_ctd(vul, 31);
4487 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
4488 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
4489 // (emulated)
4490
4491 vsl = vec_ctsl(vd, 0);
4492 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
4493 // (emulated)
4494 vul = vec_ctul(vd, 0);
4495 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
4496 // (emulated)
4497 vsl = vec_ctsl(vd, 1);
4498 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
4499 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
4500 // (emulated)
4501 vul = vec_ctul(vd, 1);
4502 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
4503 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
4504 // (emulated)
4505 vsl = vec_ctsl(vd, 31);
4506 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
4507 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
4508 // (emulated)
4509 vul = vec_ctul(vd, 31);
4510 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
4511 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
4512 // (emulated)
4513
4514 vd = vec_double(vsl);
4515 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
4516 // CHECK-ASM: vcdgb
4517 vd = vec_double(vul);
4518 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
4519 // CHECK-ASM: vcdlgb
4520
4521 vsl = vec_signed(vd);
4522 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
4523 // CHECK-ASM: vcgdb
4524 vul = vec_unsigned(vd);
4525 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
4526 // CHECK-ASM: vclgdb
4527
4528 vd = vec_roundp(vd);
4529 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
4530 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
4531 vd = vec_ceil(vd);
4532 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
4533 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
4534 vd = vec_roundm(vd);
4535 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
4536 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
4537 vd = vec_floor(vd);
4538 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
4539 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
4540 vd = vec_roundz(vd);
4541 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
4542 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
4543 vd = vec_trunc(vd);
4544 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
4545 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
4546 vd = vec_roundc(vd);
4547 // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
4548 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
4549 vd = vec_rint(vd);
4550 // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
4551 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
4552 vd = vec_round(vd);
4553 // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
4554 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
4555
4556 vbl = vec_fp_test_data_class(vd, 0, &cc);
4557 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
4558 // CHECK-ASM: vftcidb
4559 vbl = vec_fp_test_data_class(vd, 4095, &cc);
4560 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
4561 // CHECK-ASM: vftcidb
4562 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_P, &cc);
4563 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2048)
4564 // CHECK-ASM: vftcidb
4565 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_N, &cc);
4566 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1024)
4567 // CHECK-ASM: vftcidb
4568 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO, &cc);
4569 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3072)
4570 // CHECK-ASM: vftcidb
4571 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_P, &cc);
4572 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 512)
4573 // CHECK-ASM: vftcidb
4574 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_N, &cc);
4575 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 256)
4576 // CHECK-ASM: vftcidb
4577 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL, &cc);
4578 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 768)
4579 // CHECK-ASM: vftcidb
4580 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_P, &cc);
4581 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 128)
4582 // CHECK-ASM: vftcidb
4583 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_N, &cc);
4584 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 64)
4585 // CHECK-ASM: vftcidb
4586 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL, &cc);
4587 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 192)
4588 // CHECK-ASM: vftcidb
4589 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_P, &cc);
4590 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 32)
4591 // CHECK-ASM: vftcidb
4592 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_N, &cc);
4593 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 16)
4594 // CHECK-ASM: vftcidb
4595 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY, &cc);
4596 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 48)
4597 // CHECK-ASM: vftcidb
4598 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_P, &cc);
4599 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 8)
4600 // CHECK-ASM: vftcidb
4601 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_N, &cc);
4602 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4)
4603 // CHECK-ASM: vftcidb
4604 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN, &cc);
4605 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 12)
4606 // CHECK-ASM: vftcidb
4607 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_P, &cc);
4608 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2)
4609 // CHECK-ASM: vftcidb
4610 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_N, &cc);
4611 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1)
4612 // CHECK-ASM: vftcidb
4613 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN, &cc);
4614 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3)
4615 // CHECK-ASM: vftcidb
4616 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NAN, &cc);
4617 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
4618 // CHECK-ASM: vftcidb
4619 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NOT_NORMAL, &cc);
4620 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3327)
4621 // CHECK-ASM: vftcidb
4622 }
4623