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