1 // REQUIRES: systemz-registered-target
2 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
3 // RUN: -O2 -fzvector -flax-vector-conversions=none \
4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
5 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
6 // RUN: -O2 -fzvector -flax-vector-conversions=none \
7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
8 
9 #include <vecintrin.h>
10 
11 volatile vector signed char vsc;
12 volatile vector signed short vss;
13 volatile vector signed int vsi;
14 volatile vector signed long long vsl;
15 volatile vector unsigned char vuc;
16 volatile vector unsigned short vus;
17 volatile vector unsigned int vui;
18 volatile vector unsigned long long vul;
19 volatile vector bool char vbc;
20 volatile vector bool short vbs;
21 volatile vector bool int vbi;
22 volatile vector bool long long vbl;
23 volatile vector float vf;
24 volatile vector double vd;
25 
26 volatile signed char sc;
27 volatile signed short ss;
28 volatile signed int si;
29 volatile signed long long sl;
30 volatile unsigned char uc;
31 volatile unsigned short us;
32 volatile unsigned int ui;
33 volatile unsigned long long ul;
34 volatile float f;
35 volatile double d;
36 
37 const void * volatile cptr;
38 const signed char * volatile cptrsc;
39 const signed short * volatile cptrss;
40 const signed int * volatile cptrsi;
41 const signed long long * volatile cptrsl;
42 const unsigned char * volatile cptruc;
43 const unsigned short * volatile cptrus;
44 const unsigned int * volatile cptrui;
45 const unsigned long long * volatile cptrul;
46 const float * volatile cptrf;
47 const double * volatile cptrd;
48 
49 void * volatile ptr;
50 signed char * volatile ptrsc;
51 signed short * volatile ptrss;
52 signed int * volatile ptrsi;
53 signed long long * volatile ptrsl;
54 unsigned char * volatile ptruc;
55 unsigned short * volatile ptrus;
56 unsigned int * volatile ptrui;
57 unsigned long long * volatile ptrul;
58 float * volatile ptrf;
59 double * volatile ptrd;
60 
61 volatile unsigned int len;
62 volatile int idx;
63 int cc;
64 
65 void test_core(void) {
66   // CHECK-ASM-LABEL: test_core
67   vector float vf2;
68   vector double vd2;
69 
70   f = vec_extract(vf, 0);
71   // CHECK: extractelement <4 x float> %{{.*}}, i32 0
72   // CHECK-ASM: vstef
73   f = vec_extract(vf, idx);
74   // CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
75   // CHECK-ASM: vlgvf
76   d = vec_extract(vd, 0);
77   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
78   // CHECK-ASM: vsteg
79   d = vec_extract(vd, idx);
80   // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
81   // CHECK-ASM: vlgvg
82 
83   vf2 = vf;
84   vf = vec_insert(f, vf2, 0);
85   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0
86   // CHECK-ASM: vlef
87   vf = vec_insert(0.0f, vf, 1);
88   // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i32 1
89   // CHECK-ASM: vleif %{{.*}}, 0, 1
90   vf = vec_insert(f, vf, idx);
91   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
92   // CHECK-ASM: vlvgf
93   vd2 = vd;
94   vd = vec_insert(d, vd2, 0);
95   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
96   // CHECK-ASM: vleg
97   vd = vec_insert(0.0, vd, 1);
98   // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i32 1
99   // CHECK-ASM: vleig %{{.*}}, 0, 1
100   vd = vec_insert(d, vd, idx);
101   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
102   // CHECK-ASM: vlvgg
103 
104   vf = vec_promote(f, idx);
105   // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 %{{.*}}
106   // CHECK-ASM: vlvgf
107   vd = vec_promote(d, idx);
108   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
109   // CHECK-ASM: vlvgg
110 
111   vf = vec_insert_and_zero(cptrf);
112   // CHECK: insertelement <4 x float> <float 0.000000e+00, float poison, float 0.000000e+00, float 0.000000e+00>, float %{{.*}}, i32 1
113   // CHECK-ASM: vllezf
114   vd = vec_insert_and_zero(cptrd);
115   // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i32 0
116   // CHECK-ASM: vllezg
117 
118   vf = vec_perm(vf, vf, vuc);
119   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
120   // CHECK-ASM: vperm
121   vd = vec_perm(vd, vd, vuc);
122   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
123   // CHECK-ASM: vperm
124 
125   vul = vec_bperm_u128(vuc, vuc);
126   // CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
127   // CHECK-ASM: vbperm
128 
129   vf = vec_revb(vf);
130   // CHECK-ASM: vperm
131   vd = vec_revb(vd);
132   // CHECK-ASM: vperm
133 
134   vf = vec_reve(vf);
135   // CHECK-ASM: vperm
136   vd = vec_reve(vd);
137   // CHECK-ASM: {{vperm|vpdi}}
138 
139   vf = vec_sel(vf, vf, vui);
140   // CHECK-ASM: vsel
141   vf = vec_sel(vf, vf, vbi);
142   // CHECK-ASM: vsel
143   vd = vec_sel(vd, vd, vul);
144   // CHECK-ASM: vsel
145   vd = vec_sel(vd, vd, vbl);
146   // CHECK-ASM: vsel
147 
148   vf = vec_gather_element(vf, vui, cptrf, 0);
149   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
150   vf = vec_gather_element(vf, vui, cptrf, 1);
151   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
152   vf = vec_gather_element(vf, vui, cptrf, 2);
153   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
154   vf = vec_gather_element(vf, vui, cptrf, 3);
155   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
156   vd = vec_gather_element(vd, vul, cptrd, 0);
157   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
158   vd = vec_gather_element(vd, vul, cptrd, 1);
159   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
160 
161   vec_scatter_element(vf, vui, ptrf, 0);
162   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
163   vec_scatter_element(vf, vui, ptrf, 1);
164   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
165   vec_scatter_element(vf, vui, ptrf, 2);
166   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
167   vec_scatter_element(vf, vui, ptrf, 3);
168   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
169   vec_scatter_element(vd, vul, ptrd, 0);
170   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
171   vec_scatter_element(vd, vul, ptrd, 1);
172   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
173 
174   vf = vec_xl(idx, cptrf);
175   // CHECK-ASM: vl
176   vd = vec_xl(idx, cptrd);
177   // CHECK-ASM: vl
178 
179   vec_xst(vf, idx, ptrf);
180   // CHECK-ASM: vst
181   vec_xst(vd, idx, ptrd);
182   // CHECK-ASM: vst
183 
184   vd = vec_load_bndry(cptrd, 64);
185   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
186   // CHECK-ASM: vlbb
187   vf = vec_load_bndry(cptrf, 64);
188   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0)
189   // CHECK-ASM: vlbb
190   vf = vec_load_bndry(cptrf, 128);
191   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1)
192   // CHECK-ASM: vlbb
193   vf = vec_load_bndry(cptrf, 256);
194   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2)
195   // CHECK-ASM: vlbb
196   vf = vec_load_bndry(cptrf, 512);
197   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3)
198   // CHECK-ASM: vlbb
199   vf = vec_load_bndry(cptrf, 1024);
200   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4)
201   // CHECK-ASM: vlbb
202   vf = vec_load_bndry(cptrf, 2048);
203   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5)
204   // CHECK-ASM: vlbb
205   vf = vec_load_bndry(cptrf, 4096);
206   // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6)
207   // CHECK-ASM: vlbb
208 
209   vf = vec_load_len(cptrf, idx);
210   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
211   // CHECK-ASM: vll
212   vd = vec_load_len(cptrd, idx);
213   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}})
214   // CHECK-ASM: vll
215 
216   vec_store_len(vf, ptrf, idx);
217   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
218   // CHECK-ASM: vstl
219   vec_store_len(vd, ptrd, idx);
220   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
221   // CHECK-ASM: vstl
222 
223   vuc = vec_load_len_r(cptruc, 0);
224   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, i8* %{{.*}})
225   // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0
226   vuc = vec_load_len_r(cptruc, idx);
227   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, i8* %{{.*}})
228   // CHECK-ASM: vlrlr
229 
230   vec_store_len_r(vuc, ptruc, 0);
231   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, i8* %{{.*}})
232   // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0
233   vec_store_len_r(vuc, ptruc, idx);
234   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}})
235   // CHECK-ASM: vstrlr
236 
237   vf = vec_splat(vf, 0);
238   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
239   // CHECK-ASM: vrepf
240   vf = vec_splat(vf, 1);
241   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
242   // CHECK-ASM: vrepf
243   vd = vec_splat(vd, 0);
244   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
245   // CHECK-ASM: vrepg
246   vd = vec_splat(vd, 1);
247   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
248   // CHECK-ASM: vrepg
249 
250   vf = vec_splats(f);
251   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
252   // CHECK-ASM: vlrepf
253   vd = vec_splats(d);
254   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
255   // CHECK-ASM: vlrepg
256 
257   vf = vec_mergeh(vf, vf);
258   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
259   // CHECK-ASM: vmrhf
260   vd = vec_mergeh(vd, vd);
261   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
262   // CHECK-ASM: vmrhg
263 
264   vf = vec_mergel(vf, vf);
265   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
266   // CHECK-ASM: vmrlf
267   vd = vec_mergel(vd, vd);
268   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
269   // CHECK-ASM: vmrlg
270 }
271 
272 void test_compare(void) {
273   // CHECK-ASM-LABEL: test_compare
274 
275   vbi = vec_cmpeq(vf, vf);
276   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
277   // CHECK-ASM: vfcesb
278   vbl = vec_cmpeq(vd, vd);
279   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
280   // CHECK-ASM: vfcedb
281 
282   vbi = vec_cmpge(vf, vf);
283   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
284   // CHECK-ASM: vfchesb
285   vbl = vec_cmpge(vd, vd);
286   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
287   // CHECK-ASM: vfchedb
288 
289   vbi = vec_cmpgt(vf, vf);
290   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
291   // CHECK-ASM: vfchsb
292   vbl = vec_cmpgt(vd, vd);
293   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
294   // CHECK-ASM: vfchdb
295 
296   vbi = vec_cmple(vf, vf);
297   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
298   // CHECK-ASM: vfchesb
299   vbl = vec_cmple(vd, vd);
300   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
301   // CHECK-ASM: vfchedb
302 
303   vbi = vec_cmplt(vf, vf);
304   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
305   // CHECK-ASM: vfchsb
306   vbl = vec_cmplt(vd, vd);
307   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
308   // CHECK-ASM: vfchdb
309 
310   idx = vec_all_eq(vf, vf);
311   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
312   // CHECK-ASM: vfcesbs
313   idx = vec_all_eq(vd, vd);
314   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
315   // CHECK-ASM: vfcedbs
316 
317   idx = vec_all_ne(vf, vf);
318   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
319   // CHECK-ASM: vfcesbs
320   idx = vec_all_ne(vd, vd);
321   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
322   // CHECK-ASM: vfcedbs
323 
324   idx = vec_all_ge(vf, vf);
325   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
326   // CHECK-ASM: vfchesbs
327   idx = vec_all_ge(vd, vd);
328   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
329   // CHECK-ASM: vfchedbs
330 
331   idx = vec_all_gt(vf, vf);
332   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
333   // CHECK-ASM: vfchsbs
334   idx = vec_all_gt(vd, vd);
335   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
336   // CHECK-ASM: vfchdbs
337 
338   idx = vec_all_le(vf, vf);
339   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
340   // CHECK-ASM: vfchesbs
341   idx = vec_all_le(vd, vd);
342   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
343   // CHECK-ASM: vfchedbs
344 
345   idx = vec_all_lt(vf, vf);
346   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
347   // CHECK-ASM: vfchsbs
348   idx = vec_all_lt(vd, vd);
349   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
350   // CHECK-ASM: vfchdbs
351 
352   idx = vec_all_nge(vf, vf);
353   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
354   // CHECK-ASM: vfchesbs
355   idx = vec_all_nge(vd, vd);
356   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
357   // CHECK-ASM: vfchedbs
358 
359   idx = vec_all_ngt(vf, vf);
360   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
361   // CHECK-ASM: vfchsbs
362   idx = vec_all_ngt(vd, vd);
363   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
364   // CHECK-ASM: vfchdbs
365 
366   idx = vec_all_nle(vf, vf);
367   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
368   // CHECK-ASM: vfchesbs
369   idx = vec_all_nle(vd, vd);
370   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
371   // CHECK-ASM: vfchedbs
372 
373   idx = vec_all_nlt(vf, vf);
374   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
375   // CHECK-ASM: vfchsbs
376   idx = vec_all_nlt(vd, vd);
377   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
378   // CHECK-ASM: vfchdbs
379 
380   idx = vec_all_nan(vf);
381   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
382   // CHECK-ASM: vftcisb
383   idx = vec_all_nan(vd);
384   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
385   // CHECK-ASM: vftcidb
386 
387   idx = vec_all_numeric(vf);
388   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
389   // CHECK-ASM: vftcisb
390   idx = vec_all_numeric(vd);
391   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
392   // CHECK-ASM: vftcidb
393 
394   idx = vec_any_eq(vf, vf);
395   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
396   // CHECK-ASM: vfcesbs
397   idx = vec_any_eq(vd, vd);
398   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
399   // CHECK-ASM: vfcedbs
400 
401   idx = vec_any_ne(vf, vf);
402   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
403   // CHECK-ASM: vfcesbs
404   idx = vec_any_ne(vd, vd);
405   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
406   // CHECK-ASM: vfcedbs
407 
408   idx = vec_any_ge(vf, vf);
409   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
410   // CHECK-ASM: vfchesbs
411   idx = vec_any_ge(vd, vd);
412   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
413   // CHECK-ASM: vfchedbs
414 
415   idx = vec_any_gt(vf, vf);
416   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
417   // CHECK-ASM: vfchsbs
418   idx = vec_any_gt(vd, vd);
419   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
420   // CHECK-ASM: vfchdbs
421 
422   idx = vec_any_le(vf, vf);
423   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
424   // CHECK-ASM: vfchesbs
425   idx = vec_any_le(vd, vd);
426   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
427   // CHECK-ASM: vfchedbs
428 
429   idx = vec_any_lt(vf, vf);
430   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
431   // CHECK-ASM: vfchsbs
432   idx = vec_any_lt(vd, vd);
433   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
434   // CHECK-ASM: vfchdbs
435 
436   idx = vec_any_nge(vf, vf);
437   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
438   // CHECK-ASM: vfchesbs
439   idx = vec_any_nge(vd, vd);
440   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
441   // CHECK-ASM: vfchedbs
442 
443   idx = vec_any_ngt(vf, vf);
444   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
445   // CHECK-ASM: vfchsbs
446   idx = vec_any_ngt(vd, vd);
447   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
448   // CHECK-ASM: vfchdbs
449 
450   idx = vec_any_nle(vf, vf);
451   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
452   // CHECK-ASM: vfchesbs
453   idx = vec_any_nle(vd, vd);
454   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
455   // CHECK-ASM: vfchedbs
456 
457   idx = vec_any_nlt(vf, vf);
458   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
459   // CHECK-ASM: vfchsbs
460   idx = vec_any_nlt(vd, vd);
461   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
462   // CHECK-ASM: vfchdbs
463 
464   idx = vec_any_nan(vf);
465   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
466   // CHECK-ASM: vftcisb
467   idx = vec_any_nan(vd);
468   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
469   // CHECK-ASM: vftcidb
470 
471   idx = vec_any_numeric(vf);
472   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
473   // CHECK-ASM: vftcisb
474   idx = vec_any_numeric(vd);
475   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
476   // CHECK-ASM: vftcidb
477 }
478 
479 void test_integer(void) {
480   // CHECK-ASM-LABEL: test_integer
481 
482   vf = vec_andc(vf, vf);
483   // CHECK-ASM: vnc
484   vd = vec_andc(vd, vd);
485   // CHECK-ASM: vnc
486 
487   vf = vec_nor(vf, vf);
488   // CHECK-ASM: vno
489   vd = vec_nor(vd, vd);
490   // CHECK-ASM: vno
491 
492   vsc = vec_nand(vsc, vsc);
493   // CHECK-ASM: vnn
494   vuc = vec_nand(vuc, vuc);
495   // CHECK-ASM: vnn
496   vbc = vec_nand(vbc, vbc);
497   // CHECK-ASM: vnn
498   vss = vec_nand(vss, vss);
499   // CHECK-ASM: vnn
500   vus = vec_nand(vus, vus);
501   // CHECK-ASM: vnn
502   vbs = vec_nand(vbs, vbs);
503   // CHECK-ASM: vnn
504   vsi = vec_nand(vsi, vsi);
505   // CHECK-ASM: vnn
506   vui = vec_nand(vui, vui);
507   // CHECK-ASM: vnn
508   vbi = vec_nand(vbi, vbi);
509   // CHECK-ASM: vnn
510   vsl = vec_nand(vsl, vsl);
511   // CHECK-ASM: vnn
512   vul = vec_nand(vul, vul);
513   // CHECK-ASM: vnn
514   vbl = vec_nand(vbl, vbl);
515   // CHECK-ASM: vnn
516   vf = vec_nand(vf, vf);
517   // CHECK-ASM: vnn
518   vd = vec_nand(vd, vd);
519   // CHECK-ASM: vnn
520 
521   vsc = vec_orc(vsc, vsc);
522   // CHECK-ASM: voc
523   vuc = vec_orc(vuc, vuc);
524   // CHECK-ASM: voc
525   vbc = vec_orc(vbc, vbc);
526   // CHECK-ASM: voc
527   vss = vec_orc(vss, vss);
528   // CHECK-ASM: voc
529   vus = vec_orc(vus, vus);
530   // CHECK-ASM: voc
531   vbs = vec_orc(vbs, vbs);
532   // CHECK-ASM: voc
533   vsi = vec_orc(vsi, vsi);
534   // CHECK-ASM: voc
535   vui = vec_orc(vui, vui);
536   // CHECK-ASM: voc
537   vbi = vec_orc(vbi, vbi);
538   // CHECK-ASM: voc
539   vsl = vec_orc(vsl, vsl);
540   // CHECK-ASM: voc
541   vul = vec_orc(vul, vul);
542   // CHECK-ASM: voc
543   vbl = vec_orc(vbl, vbl);
544   // CHECK-ASM: voc
545   vf = vec_orc(vf, vf);
546   // CHECK-ASM: voc
547   vd = vec_orc(vd, vd);
548   // CHECK-ASM: voc
549 
550   vsc = vec_eqv(vsc, vsc);
551   // CHECK-ASM: vnx
552   vuc = vec_eqv(vuc, vuc);
553   // CHECK-ASM: vnx
554   vbc = vec_eqv(vbc, vbc);
555   // CHECK-ASM: vnx
556   vss = vec_eqv(vss, vss);
557   // CHECK-ASM: vnx
558   vus = vec_eqv(vus, vus);
559   // CHECK-ASM: vnx
560   vbs = vec_eqv(vbs, vbs);
561   // CHECK-ASM: vnx
562   vsi = vec_eqv(vsi, vsi);
563   // CHECK-ASM: vnx
564   vui = vec_eqv(vui, vui);
565   // CHECK-ASM: vnx
566   vbi = vec_eqv(vbi, vbi);
567   // CHECK-ASM: vnx
568   vsl = vec_eqv(vsl, vsl);
569   // CHECK-ASM: vnx
570   vul = vec_eqv(vul, vul);
571   // CHECK-ASM: vnx
572   vbl = vec_eqv(vbl, vbl);
573   // CHECK-ASM: vnx
574   vf = vec_eqv(vf, vf);
575   // CHECK-ASM: vnx
576   vd = vec_eqv(vd, vd);
577   // CHECK-ASM: vnx
578 
579   vuc = vec_popcnt(vsc);
580   // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
581   // CHECK-ASM: vpopctb
582   vuc = vec_popcnt(vuc);
583   // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
584   // CHECK-ASM: vpopctb
585   vus = vec_popcnt(vss);
586   // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
587   // CHECK-ASM: vpopcth
588   vus = vec_popcnt(vus);
589   // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
590   // CHECK-ASM: vpopcth
591   vui = vec_popcnt(vsi);
592   // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
593   // CHECK-ASM: vpopctf
594   vui = vec_popcnt(vui);
595   // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
596   // CHECK-ASM: vpopctf
597   vul = vec_popcnt(vsl);
598   // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
599   // CHECK-ASM: vpopctg
600   vul = vec_popcnt(vul);
601   // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
602   // CHECK-ASM: vpopctg
603 
604   vf = vec_slb(vf, vsi);
605   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
606   // CHECK-ASM: vslb
607   vf = vec_slb(vf, vui);
608   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
609   // CHECK-ASM: vslb
610   vd = vec_slb(vd, vsl);
611   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
612   // CHECK-ASM: vslb
613   vd = vec_slb(vd, vul);
614   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
615   // CHECK-ASM: vslb
616 
617   vf = vec_sld(vf, vf, 0);
618   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
619   // CHECK-ASM: vsldb
620   vf = vec_sld(vf, vf, 15);
621   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
622   // CHECK-ASM: vsldb
623   vd = vec_sld(vd, vd, 0);
624   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
625   // CHECK-ASM: vsldb
626   vd = vec_sld(vd, vd, 15);
627   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
628   // CHECK-ASM: vsldb
629 
630   vf = vec_srab(vf, vsi);
631   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
632   // CHECK-ASM: vsrab
633   vf = vec_srab(vf, vui);
634   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
635   // CHECK-ASM: vsrab
636   vd = vec_srab(vd, vsl);
637   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
638   // CHECK-ASM: vsrab
639   vd = vec_srab(vd, vul);
640   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
641   // CHECK-ASM: vsrab
642 
643   vf = vec_srb(vf, vsi);
644   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
645   // CHECK-ASM: vsrlb
646   vf = vec_srb(vf, vui);
647   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
648   // CHECK-ASM: vsrlb
649   vd = vec_srb(vd, vsl);
650   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
651   // CHECK-ASM: vsrlb
652   vd = vec_srb(vd, vul);
653   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
654   // CHECK-ASM: vsrlb
655 
656   idx = vec_test_mask(vf, vui);
657   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
658   // CHECK-ASM: vtm
659   idx = vec_test_mask(vd, vul);
660   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
661   // CHECK-ASM: vtm
662 
663   vuc = vec_msum_u128(vul, vul, vuc, 0);
664   // CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
665   // CHECK-ASM: vmslg
666   vuc = vec_msum_u128(vul, vul, vuc, 4);
667   // CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
668   // CHECK-ASM: vmslg
669   vuc = vec_msum_u128(vul, vul, vuc, 8);
670   // CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
671   // CHECK-ASM: vmslg
672   vuc = vec_msum_u128(vul, vul, vuc, 12);
673   // CHECK: call <16 x i8> @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
674   // CHECK-ASM: vmslg
675 }
676 
677 void test_float(void) {
678   // CHECK-ASM-LABEL: test_float
679 
680   vf = vec_abs(vf);
681   // CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
682   // CHECK-ASM: vflpsb
683   vd = vec_abs(vd);
684   // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
685   // CHECK-ASM: vflpdb
686 
687   vf = vec_nabs(vf);
688   // CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
689   // CHECK-NEXT: fneg <4 x float> [[ABS]]
690   // CHECK-ASM: vflnsb
691   vd = vec_nabs(vd);
692   // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
693   // CHECK-NEXT: fneg <2 x double> [[ABS]]
694   // CHECK-ASM: vflndb
695 
696   vf = vec_max(vf, vf);
697   // CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
698   // CHECK-ASM: vfmaxsb
699   vd = vec_max(vd, vd);
700   // CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
701   // CHECK-ASM: vfmaxdb
702 
703   vf = vec_min(vf, vf);
704   // CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
705   // CHECK-ASM: vfminsb
706   vd = vec_min(vd, vd);
707   // CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
708   // CHECK-ASM: vfmindb
709 
710   vf = vec_madd(vf, vf, vf);
711   // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
712   // CHECK-ASM: vfmasb
713   vd = vec_madd(vd, vd, vd);
714   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
715   // CHECK-ASM: vfmadb
716 
717   vf = vec_msub(vf, vf, vf);
718   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
719   // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
720   // CHECK-ASM: vfmssb
721   vd = vec_msub(vd, vd, vd);
722   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
723   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
724   // CHECK-ASM: vfmsdb
725 
726   vf = vec_nmadd(vf, vf, vf);
727   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
728   // CHECK: fneg <4 x float> [[RES]]
729   // CHECK-ASM: vfnmasb
730   vd = vec_nmadd(vd, vd, vd);
731   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
732   // CHECK: fneg <2 x double> [[RES]]
733   // CHECK-ASM: vfnmadb
734 
735   vf = vec_nmsub(vf, vf, vf);
736   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
737   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
738   // CHECK: fneg <4 x float> [[RES]]
739   // CHECK-ASM: vfnmssb
740   vd = vec_nmsub(vd, vd, vd);
741   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
742   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
743   // CHECK: fneg <2 x double> [[RES]]
744   // CHECK-ASM: vfnmsdb
745 
746   vf = vec_sqrt(vf);
747   // CHECK: call <4 x float> @llvm.sqrt.v4f32(<4 x float> %{{.*}})
748   // CHECK-ASM: vfsqsb
749   vd = vec_sqrt(vd);
750   // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
751   // CHECK-ASM: vfsqdb
752 
753   vd = vec_doublee(vf);
754   // CHECK: fpext <2 x float> %{{.*}} to <2 x double>
755   // CHECK-ASM: vldeb
756   vf = vec_floate(vd);
757   // CHECK: fptrunc <2 x double> %{{.*}} to <2 x float>
758   // CHECK-ASM: vledb
759 
760   vd = vec_double(vsl);
761   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
762   // CHECK-ASM: vcdgb
763   vd = vec_double(vul);
764   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
765   // CHECK-ASM: vcdlgb
766 
767   vsl = vec_signed(vd);
768   // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
769   // CHECK-ASM: vcgdb
770   vul = vec_unsigned(vd);
771   // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
772   // CHECK-ASM: vclgdb
773 
774   vf = vec_roundp(vf);
775   // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
776   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
777   vf = vec_ceil(vf);
778   // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
779   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
780   vd = vec_roundp(vd);
781   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
782   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
783   vd = vec_ceil(vd);
784   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
785   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
786 
787   vf = vec_roundm(vf);
788   // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
789   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
790   vf = vec_floor(vf);
791   // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
792   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
793   vd = vec_roundm(vd);
794   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
795   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
796   vd = vec_floor(vd);
797   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
798   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
799 
800   vf = vec_roundz(vf);
801   // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
802   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
803   vf = vec_trunc(vf);
804   // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
805   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
806   vd = vec_roundz(vd);
807   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
808   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
809   vd = vec_trunc(vd);
810   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
811   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
812 
813   vf = vec_roundc(vf);
814   // CHECK: call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %{{.*}})
815   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
816   vd = vec_roundc(vd);
817   // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
818   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
819 
820   vf = vec_rint(vf);
821   // CHECK: call <4 x float> @llvm.rint.v4f32(<4 x float> %{{.*}})
822   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
823   vd = vec_rint(vd);
824   // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
825   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
826 
827   vf = vec_round(vf);
828   // CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
829   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
830   vd = vec_round(vd);
831   // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
832   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
833 
834   vbi = vec_fp_test_data_class(vf, 0, &cc);
835   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
836   // CHECK-ASM: vftcisb
837   vbi = vec_fp_test_data_class(vf, 4095, &cc);
838   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
839   // CHECK-ASM: vftcisb
840   vbl = vec_fp_test_data_class(vd, 0, &cc);
841   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
842   // CHECK-ASM: vftcidb
843   vbl = vec_fp_test_data_class(vd, 4095, &cc);
844   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
845   // CHECK-ASM: vftcidb
846 }
847