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
test_core(void)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 undef, 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 undef, 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> undef, <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> undef, <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> undef, <4 x i32> zeroinitializer
147 // CHECK-ASM: vlrepf
148 vd = vec_splats(d);
149 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <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
test_compare(void)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
test_float(void)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