1 // REQUIRES: systemz-registered-target
2 // RUN: %clang_cc1 -target-cpu z15 -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 z15 -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 signed short vss2;
68   vector signed int vsi2;
69   vector signed long long vsl2;
70   vector unsigned short vus2;
71   vector unsigned int vui2;
72   vector unsigned long long vul2;
73   vector float vf2;
74   vector double vd2;
75 
76   vss += vec_revb(vec_xl(idx, cptrss));
77   // CHECK-ASM: vlbrh
78   vus += vec_revb(vec_xl(idx, cptrus));
79   // CHECK-ASM: vlbrh
80   vsi += vec_revb(vec_xl(idx, cptrsi));
81   // CHECK-ASM: vlbrf
82   vui += vec_revb(vec_xl(idx, cptrui));
83   // CHECK-ASM: vlbrf
84   vsl += vec_revb(vec_xl(idx, cptrsl));
85   // CHECK-ASM: vlbrg
86   vul += vec_revb(vec_xl(idx, cptrul));
87   // CHECK-ASM: vlbrg
88   vf += vec_revb(vec_xl(idx, cptrf));
89   // CHECK-ASM: vlbrf
90   vd += vec_revb(vec_xl(idx, cptrd));
91   // CHECK-ASM: vlbrg
92 
93   vec_xst(vec_revb(vss), idx, ptrss);
94   // CHECK-ASM: vstbrh
95   vec_xst(vec_revb(vus), idx, ptrus);
96   // CHECK-ASM: vstbrh
97   vec_xst(vec_revb(vsi), idx, ptrsi);
98   // CHECK-ASM: vstbrf
99   vec_xst(vec_revb(vui), idx, ptrui);
100   // CHECK-ASM: vstbrf
101   vec_xst(vec_revb(vsl), idx, ptrsl);
102   // CHECK-ASM: vstbrg
103   vec_xst(vec_revb(vul), idx, ptrul);
104   // CHECK-ASM: vstbrg
105   vec_xst(vec_revb(vf), idx, ptrf);
106   // CHECK-ASM: vstbrf
107   vec_xst(vec_revb(vd), idx, ptrd);
108   // CHECK-ASM: vstbrg
109 
110   vss += vec_revb(vec_insert_and_zero(cptrss));
111   // CHECK-ASM: vllebrzh
112   vus += vec_revb(vec_insert_and_zero(cptrus));
113   // CHECK-ASM: vllebrzh
114   vsi += vec_revb(vec_insert_and_zero(cptrsi));
115   // CHECK-ASM: vllebrzf
116   vui += vec_revb(vec_insert_and_zero(cptrui));
117   // CHECK-ASM: vllebrzf
118   vsl += vec_revb(vec_insert_and_zero(cptrsl));
119   // CHECK-ASM: vllebrzg
120   vul += vec_revb(vec_insert_and_zero(cptrul));
121   // CHECK-ASM: vllebrzg
122   vf += vec_revb(vec_insert_and_zero(cptrf));
123   // CHECK-ASM: vllebrzf
124   vd += vec_revb(vec_insert_and_zero(cptrd));
125   // CHECK-ASM: vllebrzg
126 
127   vss += vec_revb(vec_splats(ss));
128   // CHECK-ASM: vlbrreph
129   vus += vec_revb(vec_splats(us));
130   // CHECK-ASM: vlbrreph
131   vsi += vec_revb(vec_splats(si));
132   // CHECK-ASM: vlbrrepf
133   vui += vec_revb(vec_splats(ui));
134   // CHECK-ASM: vlbrrepf
135   vsl += vec_revb(vec_splats(sl));
136   // CHECK-ASM: vlbrrepg
137   vul += vec_revb(vec_splats(ul));
138   // CHECK-ASM: vlbrrepg
139   vf += vec_revb(vec_splats(f));
140   // CHECK-ASM: vlbrrepf
141   vd += vec_revb(vec_splats(d));
142   // CHECK-ASM: vlbrrepg
143 
144   vus = vec_splats(__builtin_bswap16(us));
145   // CHECK-ASM: vlbrreph
146   vui = vec_splats(__builtin_bswap32(ui));
147   // CHECK-ASM: vlbrrepf
148   vul = vec_splats((unsigned long long)__builtin_bswap64(ul));
149   // CHECK-ASM: vlbrrepg
150 
151   vss2 = vss;
152   vss += vec_revb(vec_insert(ss, vec_revb(vss2), 0));
153   // CHECK-ASM: vlebrh
154   vus2 = vus;
155   vus += vec_revb(vec_insert(us, vec_revb(vus2), 0));
156   // CHECK-ASM: vlebrh
157   vsi2 = vsi;
158   vsi += vec_revb(vec_insert(si, vec_revb(vsi2), 0));
159   // CHECK-ASM: vlebrf
160   vui2 = vui;
161   vui += vec_revb(vec_insert(ui, vec_revb(vui2), 0));
162   // CHECK-ASM: vlebrf
163   vsl2 = vsl;
164   vsl += vec_revb(vec_insert(sl, vec_revb(vsl2), 0));
165   // CHECK-ASM: vlebrg
166   vul2 = vul;
167   vul += vec_revb(vec_insert(ul, vec_revb(vul2), 0));
168   // CHECK-ASM: vlebrg
169   vf2 = vf;
170   vf += vec_revb(vec_insert(f, vec_revb(vf2), 0));
171   // CHECK-ASM: vlebrf
172   vd2 = vd;
173   vd += vec_revb(vec_insert(d, vec_revb(vd2), 0));
174   // CHECK-ASM: vlebrg
175 
176   vus2 = vus;
177   vus = vec_insert(__builtin_bswap16(us), vus2, 0);
178   // CHECK-ASM: vlebrh
179   vui2 = vui;
180   vui = vec_insert(__builtin_bswap32(ui), vui2, 0);
181   // CHECK-ASM: vlebrf
182   vul2 = vul;
183   vul = vec_insert(__builtin_bswap64(ul), vul2, 0);
184   // CHECK-ASM: vlebrg
185 
186   ss = vec_extract(vec_revb(vss), 0);
187   // CHECK-ASM: vstebrh
188   us = vec_extract(vec_revb(vus), 0);
189   // CHECK-ASM: vstebrh
190   si = vec_extract(vec_revb(vsi), 0);
191   // CHECK-ASM: vstebrf
192   ui = vec_extract(vec_revb(vui), 0);
193   // CHECK-ASM: vstebrf
194   sl = vec_extract(vec_revb(vsl), 0);
195   // CHECK-ASM: vstebrg
196   ul = vec_extract(vec_revb(vul), 0);
197   // CHECK-ASM: vstebrg
198   f = vec_extract(vec_revb(vf), 0);
199   // CHECK-ASM: vstebrf
200   d = vec_extract(vec_revb(vd), 0);
201   // CHECK-ASM: vstebrg
202 
203   us = __builtin_bswap16(vec_extract(vus, 0));
204   // CHECK-ASM: vstebrh
205   ui = __builtin_bswap32(vec_extract(vui, 0));
206   // CHECK-ASM: vstebrf
207   ul = __builtin_bswap64(vec_extract(vul, 0));
208   // CHECK-ASM: vstebrg
209 
210   vsc += vec_reve(vec_xl(idx, cptrsc));
211   // CHECK-ASM: vlbrq
212   vuc += vec_reve(vec_xl(idx, cptruc));
213   // CHECK-ASM: vlbrq
214   vss += vec_reve(vec_xl(idx, cptrss));
215   // CHECK-ASM: vlerh
216   vus += vec_reve(vec_xl(idx, cptrus));
217   // CHECK-ASM: vlerh
218   vsi += vec_reve(vec_xl(idx, cptrsi));
219   // CHECK-ASM: vlerf
220   vui += vec_reve(vec_xl(idx, cptrui));
221   // CHECK-ASM: vlerf
222   vsl += vec_reve(vec_xl(idx, cptrsl));
223   // CHECK-ASM: vlerg
224   vul += vec_reve(vec_xl(idx, cptrul));
225   // CHECK-ASM: vlerg
226   vf += vec_reve(vec_xl(idx, cptrf));
227   // CHECK-ASM: vlerf
228   vd += vec_reve(vec_xl(idx, cptrd));
229   // CHECK-ASM: vlerg
230 
231   vec_xst(vec_reve(vsc), idx, ptrsc);
232   // CHECK-ASM: vstbrq
233   vec_xst(vec_reve(vuc), idx, ptruc);
234   // CHECK-ASM: vstbrq
235   vec_xst(vec_reve(vss), idx, ptrss);
236   // CHECK-ASM: vsterh
237   vec_xst(vec_reve(vus), idx, ptrus);
238   // CHECK-ASM: vsterh
239   vec_xst(vec_reve(vsi), idx, ptrsi);
240   // CHECK-ASM: vsterf
241   vec_xst(vec_reve(vui), idx, ptrui);
242   // CHECK-ASM: vsterf
243   vec_xst(vec_reve(vsl), idx, ptrsl);
244   // CHECK-ASM: vsterg
245   vec_xst(vec_reve(vul), idx, ptrul);
246   // CHECK-ASM: vsterg
247   vec_xst(vec_reve(vf), idx, ptrf);
248   // CHECK-ASM: vsterf
249   vec_xst(vec_reve(vd), idx, ptrd);
250   // CHECK-ASM: vsterg
251 }
252 
253 void test_integer(void) {
254   // CHECK-ASM-LABEL: test_integer
255 
256   vsc = vec_sldb(vsc, vsc, 0);
257   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
258   // CHECK-ASM: vsld
259   vsc = vec_sldb(vsc, vsc, 7);
260   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
261   // CHECK-ASM: vsld
262   vuc = vec_sldb(vuc, vuc, 0);
263   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
264   // CHECK-ASM: vsld
265   vuc = vec_sldb(vuc, vuc, 7);
266   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
267   // CHECK-ASM: vsld
268   vss = vec_sldb(vss, vss, 0);
269   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
270   // CHECK-ASM: vsld
271   vss = vec_sldb(vss, vss, 7);
272   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
273   // CHECK-ASM: vsld
274   vus = vec_sldb(vus, vus, 0);
275   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
276   // CHECK-ASM: vsld
277   vus = vec_sldb(vus, vus, 7);
278   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
279   // CHECK-ASM: vsld
280   vsi = vec_sldb(vsi, vsi, 0);
281   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
282   // CHECK-ASM: vsld
283   vsi = vec_sldb(vsi, vsi, 7);
284   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
285   // CHECK-ASM: vsld
286   vui = vec_sldb(vui, vui, 0);
287   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
288   // CHECK-ASM: vsld
289   vui = vec_sldb(vui, vui, 7);
290   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
291   // CHECK-ASM: vsld
292   vsl = vec_sldb(vsl, vsl, 0);
293   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
294   // CHECK-ASM: vsld
295   vsl = vec_sldb(vsl, vsl, 7);
296   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
297   // CHECK-ASM: vsld
298   vul = vec_sldb(vul, vul, 0);
299   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
300   // CHECK-ASM: vsld
301   vul = vec_sldb(vul, vul, 7);
302   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
303   // CHECK-ASM: vsld
304   vf = vec_sldb(vf, vf, 0);
305   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
306   // CHECK-ASM: vsld
307   vf = vec_sldb(vf, vf, 7);
308   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
309   // CHECK-ASM: vsld
310   vd = vec_sldb(vd, vd, 0);
311   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
312   // CHECK-ASM: vsld
313   vd = vec_sldb(vd, vd, 7);
314   // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
315   // CHECK-ASM: vsld
316 
317   vsc = vec_srdb(vsc, vsc, 0);
318   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
319   // CHECK-ASM: vsrd
320   vsc = vec_srdb(vsc, vsc, 7);
321   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
322   // CHECK-ASM: vsrd
323   vuc = vec_srdb(vuc, vuc, 0);
324   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
325   // CHECK-ASM: vsrd
326   vuc = vec_srdb(vuc, vuc, 7);
327   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
328   // CHECK-ASM: vsrd
329   vss = vec_srdb(vss, vss, 0);
330   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
331   // CHECK-ASM: vsrd
332   vss = vec_srdb(vss, vss, 7);
333   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
334   // CHECK-ASM: vsrd
335   vus = vec_srdb(vus, vus, 0);
336   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
337   // CHECK-ASM: vsrd
338   vus = vec_srdb(vus, vus, 7);
339   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
340   // CHECK-ASM: vsrd
341   vsi = vec_srdb(vsi, vsi, 0);
342   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
343   // CHECK-ASM: vsrd
344   vsi = vec_srdb(vsi, vsi, 7);
345   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
346   // CHECK-ASM: vsrd
347   vui = vec_srdb(vui, vui, 0);
348   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
349   // CHECK-ASM: vsrd
350   vui = vec_srdb(vui, vui, 7);
351   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
352   // CHECK-ASM: vsrd
353   vsl = vec_srdb(vsl, vsl, 0);
354   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
355   // CHECK-ASM: vsrd
356   vsl = vec_srdb(vsl, vsl, 7);
357   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
358   // CHECK-ASM: vsrd
359   vul = vec_srdb(vul, vul, 0);
360   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
361   // CHECK-ASM: vsrd
362   vul = vec_srdb(vul, vul, 7);
363   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
364   // CHECK-ASM: vsrd
365   vf = vec_srdb(vf, vf, 0);
366   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
367   // CHECK-ASM: vsrd
368   vf = vec_srdb(vf, vf, 7);
369   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
370   // CHECK-ASM: vsrd
371   vd = vec_srdb(vd, vd, 0);
372   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
373   // CHECK-ASM: vsrd
374   vd = vec_srdb(vd, vd, 7);
375   // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7)
376   // CHECK-ASM: vsrd
377 }
378 
379 void test_string(void) {
380   // CHECK-ASM-LABEL: test_string
381 
382   vuc = vec_search_string_cc(vsc, vsc, vuc, &cc);
383   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
384   // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
385   vuc = vec_search_string_cc(vbc, vbc, vuc, &cc);
386   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
387   // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
388   vuc = vec_search_string_cc(vuc, vuc, vuc, &cc);
389   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
390   // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
391   vuc = vec_search_string_cc(vss, vss, vuc, &cc);
392   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
393   // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
394   vuc = vec_search_string_cc(vbs, vbs, vuc, &cc);
395   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
396   // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
397   vuc = vec_search_string_cc(vus, vus, vuc, &cc);
398   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
399   // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
400   vuc = vec_search_string_cc(vsi, vsi, vuc, &cc);
401   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
402   // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
403   vuc = vec_search_string_cc(vbi, vbi, vuc, &cc);
404   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
405   // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
406   vuc = vec_search_string_cc(vui, vui, vuc, &cc);
407   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
408   // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0
409 
410   vuc = vec_search_string_until_zero_cc(vsc, vsc, vuc, &cc);
411   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
412   // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
413   vuc = vec_search_string_until_zero_cc(vbc, vbc, vuc, &cc);
414   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
415   // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
416   vuc = vec_search_string_until_zero_cc(vuc, vuc, vuc, &cc);
417   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
418   // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
419   vuc = vec_search_string_until_zero_cc(vss, vss, vuc, &cc);
420   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
421   // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
422   vuc = vec_search_string_until_zero_cc(vbs, vbs, vuc, &cc);
423   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
424   // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
425   vuc = vec_search_string_until_zero_cc(vus, vus, vuc, &cc);
426   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}})
427   // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
428   vuc = vec_search_string_until_zero_cc(vsi, vsi, vuc, &cc);
429   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
430   // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
431   vuc = vec_search_string_until_zero_cc(vbi, vbi, vuc, &cc);
432   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
433   // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
434   vuc = vec_search_string_until_zero_cc(vui, vui, vuc, &cc);
435   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}})
436   // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
437 }
438 
439 void test_float(void) {
440   // CHECK-ASM-LABEL: test_float
441 
442   vd = vec_double(vsl);
443   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
444   // CHECK-ASM: vcdgb
445   vd = vec_double(vul);
446   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
447   // CHECK-ASM: vcdlgb
448   vf = vec_float(vsi);
449   // CHECK: sitofp <4 x i32> %{{.*}} to <4 x float>
450   // CHECK-ASM: vcefb
451   vf = vec_float(vui);
452   // CHECK: uitofp <4 x i32> %{{.*}} to <4 x float>
453   // CHECK-ASM: vcelfb
454 
455   vsl = vec_signed(vd);
456   // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
457   // CHECK-ASM: vcgdb
458   vsi = vec_signed(vf);
459   // CHECK: fptosi <4 x float> %{{.*}} to <4 x i32>
460   // CHECK-ASM: vcfeb
461   vul = vec_unsigned(vd);
462   // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
463   // CHECK-ASM: vclgdb
464   vui = vec_unsigned(vf);
465   // CHECK: fptoui <4 x float> %{{.*}} to <4 x i32>
466   // CHECK-ASM: vclfeb
467 }
468 
469