clang/test/CodeGen/SystemZ/builtins-systemz-zvector3.c

   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