Clang Project

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