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: -ffp-exception-behavior=strict \
5 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
6 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
7 // RUN: -O2 -fzvector -flax-vector-conversions=none \
8 // RUN: -ffp-exception-behavior=strict \
9 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
10 
11 #include <vecintrin.h>
12 
13 volatile vector signed long long vsl;
14 volatile vector unsigned int vui;
15 volatile vector unsigned long long vul;
16 volatile vector bool int vbi;
17 volatile vector bool long long vbl;
18 volatile vector float vf;
19 volatile vector double vd;
20 
21 volatile float f;
22 volatile double d;
23 
24 const float * volatile cptrf;
25 const double * volatile cptrd;
26 
27 float * volatile ptrf;
28 double * volatile ptrd;
29 
30 volatile int idx;
31 int cc;
32 
33 void test_core(void) {
34   // CHECK-ASM-LABEL: test_core
35   vector float vf2;
36   vector double vd2;
37 
38   f = vec_extract(vf, 0);
39   // CHECK: extractelement <4 x float> %{{.*}}, i32 0
40   // CHECK-ASM: vstef
41   f = vec_extract(vf, idx);
42   // CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
43   // CHECK-ASM: vlgvf
44   d = vec_extract(vd, 0);
45   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
46   // CHECK-ASM: vsteg
47   d = vec_extract(vd, idx);
48   // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
49   // CHECK-ASM: vlgvg
50 
51   vf2 = vf;
52   vf = vec_insert(f, vf2, 0);
53   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0
54   // CHECK-ASM: vlef
55   vf = vec_insert(0.0f, vf, 1);
56   // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i32 1
57   // CHECK-ASM: vleif %{{.*}}, 0, 1
58   vf = vec_insert(f, vf, idx);
59   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
60   // CHECK-ASM: vlvgf
61   vd2 = vd;
62   vd = vec_insert(d, vd2, 0);
63   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
64   // CHECK-ASM: vleg
65   vd = vec_insert(0.0, vd, 1);
66   // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i32 1
67   // CHECK-ASM: vleig %{{.*}}, 0, 1
68   vd = vec_insert(d, vd, idx);
69   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
70   // CHECK-ASM: vlvgg
71 
72   vf = vec_promote(f, idx);
73   // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 %{{.*}}
74   // CHECK-ASM: vlvgf
75   vd = vec_promote(d, idx);
76   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}}
77   // CHECK-ASM: vlvgg
78 
79   vf = vec_insert_and_zero(cptrf);
80   // CHECK: insertelement <4 x float> <float 0.000000e+00, float poison, float 0.000000e+00, float 0.000000e+00>, float {{.*}}, i32 1
81   // CHECK-ASM: vllezf
82   vd = vec_insert_and_zero(cptrd);
83   // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i32 0
84   // CHECK-ASM: vllezg
85 
86   vf = vec_revb(vf);
87   // CHECK-ASM: vperm
88   vd = vec_revb(vd);
89   // CHECK-ASM: vperm
90 
91   vf = vec_reve(vf);
92   // CHECK-ASM: vperm
93   vd = vec_reve(vd);
94   // CHECK-ASM: {{vperm|vpdi}}
95 
96   vf = vec_gather_element(vf, vui, cptrf, 0);
97   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
98   vf = vec_gather_element(vf, vui, cptrf, 1);
99   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
100   vf = vec_gather_element(vf, vui, cptrf, 2);
101   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
102   vf = vec_gather_element(vf, vui, cptrf, 3);
103   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
104   vd = vec_gather_element(vd, vul, cptrd, 0);
105   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
106   vd = vec_gather_element(vd, vul, cptrd, 1);
107   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
108 
109   vec_scatter_element(vf, vui, ptrf, 0);
110   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
111   vec_scatter_element(vf, vui, ptrf, 1);
112   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
113   vec_scatter_element(vf, vui, ptrf, 2);
114   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
115   vec_scatter_element(vf, vui, ptrf, 3);
116   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
117   vec_scatter_element(vd, vul, ptrd, 0);
118   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
119   vec_scatter_element(vd, vul, ptrd, 1);
120   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
121 
122   vf = vec_xl(idx, cptrf);
123   // CHECK-ASM: vl
124   vd = vec_xl(idx, cptrd);
125   // CHECK-ASM: vl
126 
127   vec_xst(vf, idx, ptrf);
128   // CHECK-ASM: vst
129   vec_xst(vd, idx, ptrd);
130   // CHECK-ASM: vst
131 
132   vf = vec_splat(vf, 0);
133   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
134   // CHECK-ASM: vrepf
135   vf = vec_splat(vf, 1);
136   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
137   // CHECK-ASM: vrepf
138   vd = vec_splat(vd, 0);
139   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
140   // CHECK-ASM: vrepg
141   vd = vec_splat(vd, 1);
142   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
143   // CHECK-ASM: vrepg
144 
145   vf = vec_splats(f);
146   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
147   // CHECK-ASM: vlrepf
148   vd = vec_splats(d);
149   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
150   // CHECK-ASM: vlrepg
151 
152   vf = vec_mergeh(vf, vf);
153   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
154   // CHECK-ASM: vmrhf
155   vd = vec_mergeh(vd, vd);
156   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
157   // CHECK-ASM: vmrhg
158 
159   vf = vec_mergel(vf, vf);
160   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
161   // CHECK-ASM: vmrlf
162   vd = vec_mergel(vd, vd);
163   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
164   // CHECK-ASM: vmrlg
165 }
166 
167 void test_compare(void) {
168   // CHECK-ASM-LABEL: test_compare
169 
170   vbi = vec_cmpeq(vf, vf);
171   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oeq", metadata !{{.*}})
172   // CHECK-ASM: vfcesb
173   vbl = vec_cmpeq(vd, vd);
174   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oeq", metadata !{{.*}})
175   // CHECK-ASM: vfcedb
176 
177   vbi = vec_cmpge(vf, vf);
178   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oge", metadata !{{.*}})
179   // CHECK-ASM: vfkhesb
180   vbl = vec_cmpge(vd, vd);
181   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oge", metadata !{{.*}})
182   // CHECK-ASM: vfkhedb
183 
184   vbi = vec_cmpgt(vf, vf);
185   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ogt", metadata !{{.*}})
186   // CHECK-ASM: vfkhsb
187   vbl = vec_cmpgt(vd, vd);
188   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ogt", metadata !{{.*}})
189   // CHECK-ASM: vfkhdb
190 
191   vbi = vec_cmple(vf, vf);
192   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ole", metadata !{{.*}})
193   // CHECK-ASM: vfkhesb
194   vbl = vec_cmple(vd, vd);
195   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ole", metadata !{{.*}})
196   // CHECK-ASM: vfkhedb
197 
198   vbi = vec_cmplt(vf, vf);
199   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"olt", metadata !{{.*}})
200   // CHECK-ASM: vfkhsb
201   vbl = vec_cmplt(vd, vd);
202   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"olt", metadata !{{.*}})
203   // CHECK-ASM: vfkhdb
204 
205   idx = vec_all_eq(vf, vf);
206   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
207   // CHECK-ASM: vfcesbs
208   idx = vec_all_eq(vd, vd);
209   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
210   // CHECK-ASM: vfcedbs
211 
212   idx = vec_all_ne(vf, vf);
213   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
214   // CHECK-ASM: vfcesbs
215   idx = vec_all_ne(vd, vd);
216   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
217   // CHECK-ASM: vfcedbs
218 
219   idx = vec_all_ge(vf, vf);
220   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
221   // CHECK-ASM: vfchesbs
222   idx = vec_all_ge(vd, vd);
223   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
224   // CHECK-ASM: vfchedbs
225 
226   idx = vec_all_gt(vf, vf);
227   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
228   // CHECK-ASM: vfchsbs
229   idx = vec_all_gt(vd, vd);
230   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
231   // CHECK-ASM: vfchdbs
232 
233   idx = vec_all_le(vf, vf);
234   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
235   // CHECK-ASM: vfchesbs
236   idx = vec_all_le(vd, vd);
237   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
238   // CHECK-ASM: vfchedbs
239 
240   idx = vec_all_lt(vf, vf);
241   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
242   // CHECK-ASM: vfchsbs
243   idx = vec_all_lt(vd, vd);
244   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
245   // CHECK-ASM: vfchdbs
246 
247   idx = vec_all_nge(vf, vf);
248   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
249   // CHECK-ASM: vfchesbs
250   idx = vec_all_nge(vd, vd);
251   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
252   // CHECK-ASM: vfchedbs
253 
254   idx = vec_all_ngt(vf, vf);
255   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
256   // CHECK-ASM: vfchsbs
257   idx = vec_all_ngt(vd, vd);
258   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
259   // CHECK-ASM: vfchdbs
260 
261   idx = vec_all_nle(vf, vf);
262   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
263   // CHECK-ASM: vfchesbs
264   idx = vec_all_nle(vd, vd);
265   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
266   // CHECK-ASM: vfchedbs
267 
268   idx = vec_all_nlt(vf, vf);
269   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
270   // CHECK-ASM: vfchsbs
271   idx = vec_all_nlt(vd, vd);
272   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
273   // CHECK-ASM: vfchdbs
274 
275   idx = vec_all_nan(vf);
276   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
277   // CHECK-ASM: vftcisb
278   idx = vec_all_nan(vd);
279   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
280   // CHECK-ASM: vftcidb
281 
282   idx = vec_all_numeric(vf);
283   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
284   // CHECK-ASM: vftcisb
285   idx = vec_all_numeric(vd);
286   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
287   // CHECK-ASM: vftcidb
288 
289   idx = vec_any_eq(vf, vf);
290   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
291   // CHECK-ASM: vfcesbs
292   idx = vec_any_eq(vd, vd);
293   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
294   // CHECK-ASM: vfcedbs
295 
296   idx = vec_any_ne(vf, vf);
297   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
298   // CHECK-ASM: vfcesbs
299   idx = vec_any_ne(vd, vd);
300   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
301   // CHECK-ASM: vfcedbs
302 
303   idx = vec_any_ge(vf, vf);
304   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
305   // CHECK-ASM: vfchesbs
306   idx = vec_any_ge(vd, vd);
307   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
308   // CHECK-ASM: vfchedbs
309 
310   idx = vec_any_gt(vf, vf);
311   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
312   // CHECK-ASM: vfchsbs
313   idx = vec_any_gt(vd, vd);
314   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
315   // CHECK-ASM: vfchdbs
316 
317   idx = vec_any_le(vf, vf);
318   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
319   // CHECK-ASM: vfchesbs
320   idx = vec_any_le(vd, vd);
321   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
322   // CHECK-ASM: vfchedbs
323 
324   idx = vec_any_lt(vf, vf);
325   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
326   // CHECK-ASM: vfchsbs
327   idx = vec_any_lt(vd, vd);
328   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
329   // CHECK-ASM: vfchdbs
330 
331   idx = vec_any_nge(vf, vf);
332   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
333   // CHECK-ASM: vfchesbs
334   idx = vec_any_nge(vd, vd);
335   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
336   // CHECK-ASM: vfchedbs
337 
338   idx = vec_any_ngt(vf, vf);
339   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
340   // CHECK-ASM: vfchsbs
341   idx = vec_any_ngt(vd, vd);
342   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
343   // CHECK-ASM: vfchdbs
344 
345   idx = vec_any_nle(vf, vf);
346   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
347   // CHECK-ASM: vfchesbs
348   idx = vec_any_nle(vd, vd);
349   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
350   // CHECK-ASM: vfchedbs
351 
352   idx = vec_any_nlt(vf, vf);
353   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
354   // CHECK-ASM: vfchsbs
355   idx = vec_any_nlt(vd, vd);
356   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
357   // CHECK-ASM: vfchdbs
358 
359   idx = vec_any_nan(vf);
360   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
361   // CHECK-ASM: vftcisb
362   idx = vec_any_nan(vd);
363   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
364   // CHECK-ASM: vftcidb
365 
366   idx = vec_any_numeric(vf);
367   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
368   // CHECK-ASM: vftcisb
369   idx = vec_any_numeric(vd);
370   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
371   // CHECK-ASM: vftcidb
372 }
373 
374 void test_float(void) {
375   // CHECK-ASM-LABEL: test_float
376 
377   vf = vec_abs(vf);
378   // CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
379   // CHECK-ASM: vflpsb
380   vd = vec_abs(vd);
381   // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
382   // CHECK-ASM: vflpdb
383 
384   vf = vec_nabs(vf);
385   // CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
386   // CHECK-NEXT: fneg <4 x float> [[ABS]]
387   // CHECK-ASM: vflnsb
388   vd = vec_nabs(vd);
389   // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
390   // CHECK-NEXT: fneg <2 x double> [[ABS]]
391   // CHECK-ASM: vflndb
392 
393   vf = vec_max(vf, vf);
394   // CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
395   // CHECK-ASM: vfmaxsb
396   vd = vec_max(vd, vd);
397   // CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
398   // CHECK-ASM: vfmaxdb
399 
400   vf = vec_min(vf, vf);
401   // CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
402   // CHECK-ASM: vfminsb
403   vd = vec_min(vd, vd);
404   // CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
405   // CHECK-ASM: vfmindb
406 
407   vf = vec_madd(vf, vf, vf);
408   // CHECK: call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !{{.*}})
409   // CHECK-ASM: vfmasb
410   vd = vec_madd(vd, vd, vd);
411   // CHECK: call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !{{.*}})
412   // CHECK-ASM: vfmadb
413 
414   vf = vec_msub(vf, vf, vf);
415   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
416   // CHECK: call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]], metadata !{{.*}})
417   // CHECK-ASM: vfmssb
418   vd = vec_msub(vd, vd, vd);
419   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
420   // CHECK: call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]], metadata !{{.*}})
421   // CHECK-ASM: vfmsdb
422 
423   vf = vec_nmadd(vf, vf, vf);
424   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !{{.*}})
425   // CHECK: fneg <4 x float> [[RES]]
426   // CHECK-ASM: vfnmasb
427   vd = vec_nmadd(vd, vd, vd);
428   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !{{.*}})
429   // CHECK: fneg <2 x double> [[RES]]
430   // CHECK-ASM: vfnmadb
431 
432   vf = vec_nmsub(vf, vf, vf);
433   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
434   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]], metadata !{{.*}})
435   // CHECK: fneg <4 x float> [[RES]]
436   // CHECK-ASM: vfnmssb
437   vd = vec_nmsub(vd, vd, vd);
438   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
439   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]], metadata !{{.*}})
440   // CHECK: fneg <2 x double> [[RES]]
441   // CHECK-ASM: vfnmsdb
442 
443   vf = vec_sqrt(vf);
444   // CHECK: call <4 x float> @llvm.experimental.constrained.sqrt.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
445   // CHECK-ASM: vfsqsb
446   vd = vec_sqrt(vd);
447   // CHECK: call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
448   // CHECK-ASM: vfsqdb
449 
450   vd = vec_doublee(vf);
451   // CHECK: call <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float> %{{.*}}, metadata !{{.*}})
452   // CHECK-ASM: vldeb
453   vf = vec_floate(vd);
454   // CHECK: call <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
455   // CHECK-ASM: vledb
456 
457   vd = vec_double(vsl);
458   // CHECK: call <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i64(<2 x i64> %{{.*}}, metadata !{{.*}})
459   // CHECK-ASM: vcdgb
460   vd = vec_double(vul);
461   // CHECK: call <2 x double> @llvm.experimental.constrained.uitofp.v2f64.v2i64(<2 x i64> %{{.*}}, metadata !{{.*}})
462   // CHECK-ASM: vcdlgb
463 
464   vsl = vec_signed(vd);
465   // CHECK: call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
466   // CHECK-ASM: vcgdb
467   vul = vec_unsigned(vd);
468   // CHECK: call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
469   // CHECK-ASM: vclgdb
470 
471   vf = vec_roundp(vf);
472   // CHECK: call <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
473   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
474   vf = vec_ceil(vf);
475   // CHECK: call <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
476   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
477   vd = vec_roundp(vd);
478   // CHECK: call <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
479   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
480   vd = vec_ceil(vd);
481   // CHECK: call <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
482   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
483 
484   vf = vec_roundm(vf);
485   // CHECK: call <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
486   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
487   vf = vec_floor(vf);
488   // CHECK: call <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
489   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
490   vd = vec_roundm(vd);
491   // CHECK: call <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
492   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
493   vd = vec_floor(vd);
494   // CHECK: call <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
495   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
496 
497   vf = vec_roundz(vf);
498   // CHECK: call <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
499   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
500   vf = vec_trunc(vf);
501   // CHECK: call <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
502   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
503   vd = vec_roundz(vd);
504   // CHECK: call <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
505   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
506   vd = vec_trunc(vd);
507   // CHECK: call <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
508   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
509 
510   vf = vec_roundc(vf);
511   // CHECK: call <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
512   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
513   vd = vec_roundc(vd);
514   // CHECK: call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
515   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
516 
517   vf = vec_rint(vf);
518   // CHECK: call <4 x float> @llvm.experimental.constrained.rint.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
519   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
520   vd = vec_rint(vd);
521   // CHECK: call <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
522   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
523 
524   vf = vec_round(vf);
525   // CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
526   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
527   vd = vec_round(vd);
528   // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
529   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
530 
531   vbi = vec_fp_test_data_class(vf, 0, &cc);
532   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
533   // CHECK-ASM: vftcisb
534   vbi = vec_fp_test_data_class(vf, 4095, &cc);
535   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
536   // CHECK-ASM: vftcisb
537   vbl = vec_fp_test_data_class(vd, 0, &cc);
538   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
539   // CHECK-ASM: vftcidb
540   vbl = vec_fp_test_data_class(vd, 4095, &cc);
541   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
542   // CHECK-ASM: vftcidb
543 }
544