Clang Project

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