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

   1 // REQUIRES: systemz-registered-target
   2 // RUN: %clang_cc1 -target-cpu z13 -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 z13 -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 double vd;
  24
  25 volatile signed char sc;
  26 volatile signed short ss;
  27 volatile signed int si;
  28 volatile signed long long sl;
  29 volatile unsigned char uc;
  30 volatile unsigned short us;
  31 volatile unsigned int ui;
  32 volatile unsigned long long ul;
  33 volatile double d;
  34
  35 const void * volatile cptr;
  36 const signed char * volatile cptrsc;
  37 const signed short * volatile cptrss;
  38 const signed int * volatile cptrsi;
  39 const signed long long * volatile cptrsl;
  40 const unsigned char * volatile cptruc;
  41 const unsigned short * volatile cptrus;
  42 const unsigned int * volatile cptrui;
  43 const unsigned long long * volatile cptrul;
  44 const float * volatile cptrf;
  45 const double * volatile cptrd;
  46
  47 void * volatile ptr;
  48 signed char * volatile ptrsc;
  49 signed short * volatile ptrss;
  50 signed int * volatile ptrsi;
  51 signed long long * volatile ptrsl;
  52 unsigned char * volatile ptruc;
  53 unsigned short * volatile ptrus;
  54 unsigned int * volatile ptrui;
  55 unsigned long long * volatile ptrul;
  56 float * volatile ptrf;
  57 double * volatile ptrd;
  58
  59 volatile unsigned int len;
  60 volatile int idx;
  61 int cc;
  62
  63 void test_core(void) {
  64   // CHECK-ASM-LABEL: test_core
  65
  66   len = __lcbb(cptr, 64);
  67   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 0)
  68   // CHECK-ASM: lcbb
  69   len = __lcbb(cptr, 128);
  70   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 1)
  71   // CHECK-ASM: lcbb
  72   len = __lcbb(cptr, 256);
  73   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 2)
  74   // CHECK-ASM: lcbb
  75   len = __lcbb(cptr, 512);
  76   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 3)
  77   // CHECK-ASM: lcbb
  78   len = __lcbb(cptr, 1024);
  79   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 4)
  80   // CHECK-ASM: lcbb
  81   len = __lcbb(cptr, 2048);
  82   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 5)
  83   // CHECK-ASM: lcbb
  84   len = __lcbb(cptr, 4096);
  85   // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 6)
  86   // CHECK-ASM: lcbb
  87
  88   sc = vec_extract(vsc, idx);
  89   // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
  90   // CHECK-ASM: vlgvb
  91   uc = vec_extract(vuc, idx);
  92   // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
  93   // CHECK-ASM: vlgvb
  94   uc = vec_extract(vbc, idx);
  95   // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}
  96   // CHECK-ASM: vlgvb
  97   ss = vec_extract(vss, idx);
  98   // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
  99   // CHECK-ASM: vlgvh
 100   us = vec_extract(vus, idx);
 101   // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
 102   // CHECK-ASM: vlgvh
 103   us = vec_extract(vbs, idx);
 104   // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}
 105   // CHECK-ASM: vlgvh
 106   si = vec_extract(vsi, idx);
 107   // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
 108   // CHECK-ASM: vlgvf
 109   ui = vec_extract(vui, idx);
 110   // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
 111   // CHECK-ASM: vlgvf
 112   ui = vec_extract(vbi, idx);
 113   // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}
 114   // CHECK-ASM: vlgvf
 115   sl = vec_extract(vsl, idx);
 116   // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
 117   // CHECK-ASM: vlgvg
 118   ul = vec_extract(vul, idx);
 119   // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
 120   // CHECK-ASM: vlgvg
 121   ul = vec_extract(vbl, idx);
 122   // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}
 123   // CHECK-ASM: vlgvg
 124   d = vec_extract(vd, idx);
 125   // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
 126   // CHECK-ASM: vlgvg
 127
 128   vsc = vec_insert(sc, vsc, idx);
 129   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
 130   // CHECK-ASM: vlvgb
 131   vuc = vec_insert(uc, vuc, idx);
 132   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
 133   // CHECK-ASM: vlvgb
 134   vuc = vec_insert(uc, vbc, idx);
 135   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
 136   // CHECK-ASM: vlvgb
 137   vss = vec_insert(ss, vss, idx);
 138   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
 139   // CHECK-ASM: vlvgh
 140   vus = vec_insert(us, vus, idx);
 141   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
 142   // CHECK-ASM: vlvgh
 143   vus = vec_insert(us, vbs, idx);
 144   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
 145   // CHECK-ASM: vlvgh
 146   vsi = vec_insert(si, vsi, idx);
 147   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
 148   // CHECK-ASM: vlvgf
 149   vui = vec_insert(ui, vui, idx);
 150   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
 151   // CHECK-ASM: vlvgf
 152   vui = vec_insert(ui, vbi, idx);
 153   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
 154   // CHECK-ASM: vlvgf
 155   vsl = vec_insert(sl, vsl, idx);
 156   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
 157   // CHECK-ASM: vlvgg
 158   vul = vec_insert(ul, vul, idx);
 159   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
 160   // CHECK-ASM: vlvgg
 161   vul = vec_insert(ul, vbl, idx);
 162   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
 163   // CHECK-ASM: vlvgg
 164   vd = vec_insert(d, vd, idx);
 165   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
 166   // CHECK-ASM: vlvgg
 167
 168   vsc = vec_promote(sc, idx);
 169   // CHECK: insertelement <16 x i8> poison, i8 %{{.*}}, i32 %{{.*}}
 170   // CHECK-ASM: vlvgb
 171   vuc = vec_promote(uc, idx);
 172   // CHECK: insertelement <16 x i8> poison, i8 %{{.*}}, i32 %{{.*}}
 173   // CHECK-ASM: vlvgb
 174   vss = vec_promote(ss, idx);
 175   // CHECK: insertelement <8 x i16> poison, i16 %{{.*}}, i32 %{{.*}}
 176   // CHECK-ASM: vlvgh
 177   vus = vec_promote(us, idx);
 178   // CHECK: insertelement <8 x i16> poison, i16 %{{.*}}, i32 %{{.*}}
 179   // CHECK-ASM: vlvgh
 180   vsi = vec_promote(si, idx);
 181   // CHECK: insertelement <4 x i32> poison, i32 %{{.*}}, i32 %{{.*}}
 182   // CHECK-ASM: vlvgf
 183   vui = vec_promote(ui, idx);
 184   // CHECK: insertelement <4 x i32> poison, i32 %{{.*}}, i32 %{{.*}}
 185   // CHECK-ASM: vlvgf
 186   vsl = vec_promote(sl, idx);
 187   // CHECK: insertelement <2 x i64> poison, i64 %{{.*}}, i32 %{{.*}}
 188   // CHECK-ASM: vlvgg
 189   vul = vec_promote(ul, idx);
 190   // CHECK: insertelement <2 x i64> poison, i64 %{{.*}}, i32 %{{.*}}
 191   // CHECK-ASM: vlvgg
 192   vd = vec_promote(d, idx);
 193   // CHECK: insertelement <2 x double> poison, double %{{.*}}, i32 %{{.*}}
 194   // CHECK-ASM: vlvgg
 195
 196   vsc = vec_insert_and_zero(cptrsc);
 197   // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i64 7
 198   // CHECK-ASM: vllezb
 199   vuc = vec_insert_and_zero(cptruc);
 200   // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i64 7
 201   // CHECK-ASM: vllezb
 202   vss = vec_insert_and_zero(cptrss);
 203   // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 poison, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i64 3
 204   // CHECK-ASM: vllezh
 205   vus = vec_insert_and_zero(cptrus);
 206   // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 poison, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i64 3
 207   // CHECK-ASM: vllezh
 208   vsi = vec_insert_and_zero(cptrsi);
 209   // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i64 1
 210   // CHECK-ASM: vllezf
 211   vui = vec_insert_and_zero(cptrui);
 212   // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i64 1
 213   // CHECK-ASM: vllezf
 214   vsl = vec_insert_and_zero(cptrsl);
 215   // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i64 0
 216   // CHECK-ASM: vllezg
 217   vul = vec_insert_and_zero(cptrul);
 218   // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i64 0
 219   // CHECK-ASM: vllezg
 220   vd = vec_insert_and_zero(cptrd);
 221   // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i64 0
 222   // CHECK-ASM: vllezg
 223
 224   vsc = vec_perm(vsc, vsc, vuc);
 225   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 226   // CHECK-ASM: vperm
 227   vuc = vec_perm(vuc, vuc, vuc);
 228   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 229   // CHECK-ASM: vperm
 230   vbc = vec_perm(vbc, vbc, vuc);
 231   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 232   // CHECK-ASM: vperm
 233   vss = vec_perm(vss, vss, vuc);
 234   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 235   // CHECK-ASM: vperm
 236   vus = vec_perm(vus, vus, vuc);
 237   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 238   // CHECK-ASM: vperm
 239   vbs = vec_perm(vbs, vbs, vuc);
 240   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 241   // CHECK-ASM: vperm
 242   vsi = vec_perm(vsi, vsi, vuc);
 243   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 244   // CHECK-ASM: vperm
 245   vui = vec_perm(vui, vui, vuc);
 246   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 247   // CHECK-ASM: vperm
 248   vbi = vec_perm(vbi, vbi, vuc);
 249   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 250   // CHECK-ASM: vperm
 251   vsl = vec_perm(vsl, vsl, vuc);
 252   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 253   // CHECK-ASM: vperm
 254   vul = vec_perm(vul, vul, vuc);
 255   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 256   // CHECK-ASM: vperm
 257   vbl = vec_perm(vbl, vbl, vuc);
 258   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 259   // CHECK-ASM: vperm
 260   vd = vec_perm(vd, vd, vuc);
 261   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 262   // CHECK-ASM: vperm
 263
 264   vsl = vec_permi(vsl, vsl, 0);
 265   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
 266   // CHECK-ASM: vpdi
 267   vsl = vec_permi(vsl, vsl, 1);
 268   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
 269   // CHECK-ASM: vpdi
 270   vsl = vec_permi(vsl, vsl, 2);
 271   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
 272   // CHECK-ASM: vpdi
 273   vsl = vec_permi(vsl, vsl, 3);
 274   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
 275   // CHECK-ASM: vpdi
 276   vul = vec_permi(vul, vul, 0);
 277   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
 278   // CHECK-ASM: vpdi
 279   vul = vec_permi(vul, vul, 1);
 280   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
 281   // CHECK-ASM: vpdi
 282   vul = vec_permi(vul, vul, 2);
 283   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
 284   // CHECK-ASM: vpdi
 285   vul = vec_permi(vul, vul, 3);
 286   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
 287   // CHECK-ASM: vpdi
 288   vbl = vec_permi(vbl, vbl, 0);
 289   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
 290   // CHECK-ASM: vpdi
 291   vbl = vec_permi(vbl, vbl, 1);
 292   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
 293   // CHECK-ASM: vpdi
 294   vbl = vec_permi(vbl, vbl, 2);
 295   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
 296   // CHECK-ASM: vpdi
 297   vbl = vec_permi(vbl, vbl, 3);
 298   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
 299   // CHECK-ASM: vpdi
 300   vd = vec_permi(vd, vd, 0);
 301   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
 302   // CHECK-ASM: vpdi
 303   vd = vec_permi(vd, vd, 1);
 304   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1)
 305   // CHECK-ASM: vpdi
 306   vd = vec_permi(vd, vd, 2);
 307   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4)
 308   // CHECK-ASM: vpdi
 309   vd = vec_permi(vd, vd, 3);
 310   // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5)
 311   // CHECK-ASM: vpdi
 312
 313   vss = vec_revb(vss);
 314   // CHECK-ASM: vperm
 315   vus = vec_revb(vus);
 316   // CHECK-ASM: vperm
 317   vsi = vec_revb(vsi);
 318   // CHECK-ASM: vperm
 319   vui = vec_revb(vui);
 320   // CHECK-ASM: vperm
 321   vsl = vec_revb(vsl);
 322   // CHECK-ASM: vperm
 323   vul = vec_revb(vul);
 324   // CHECK-ASM: vperm
 325   vd = vec_revb(vd);
 326   // CHECK-ASM: vperm
 327
 328   vsc = vec_reve(vsc);
 329   // CHECK-ASM: vperm
 330   vuc = vec_reve(vuc);
 331   // CHECK-ASM: vperm
 332   vbc = vec_reve(vbc);
 333   // CHECK-ASM: vperm
 334   vss = vec_reve(vss);
 335   // CHECK-ASM: vperm
 336   vus = vec_reve(vus);
 337   // CHECK-ASM: vperm
 338   vbs = vec_reve(vbs);
 339   // CHECK-ASM: vperm
 340   vsi = vec_reve(vsi);
 341   // CHECK-ASM: vperm
 342   vui = vec_reve(vui);
 343   // CHECK-ASM: vperm
 344   vbi = vec_reve(vbi);
 345   // CHECK-ASM: vperm
 346   vsl = vec_reve(vsl);
 347   // CHECK-ASM: {{vperm|vpdi}}
 348   vul = vec_reve(vul);
 349   // CHECK-ASM: {{vperm|vpdi}}
 350   vbl = vec_reve(vbl);
 351   // CHECK-ASM: {{vperm|vpdi}}
 352   vd = vec_reve(vd);
 353   // CHECK-ASM: {{vperm|vpdi}}
 354
 355   vsc = vec_sel(vsc, vsc, vuc);
 356   // CHECK-ASM: vsel
 357   vsc = vec_sel(vsc, vsc, vbc);
 358   // CHECK-ASM: vsel
 359   vuc = vec_sel(vuc, vuc, vuc);
 360   // CHECK-ASM: vsel
 361   vuc = vec_sel(vuc, vuc, vbc);
 362   // CHECK-ASM: vsel
 363   vbc = vec_sel(vbc, vbc, vuc);
 364   // CHECK-ASM: vsel
 365   vbc = vec_sel(vbc, vbc, vbc);
 366   // CHECK-ASM: vsel
 367   vss = vec_sel(vss, vss, vus);
 368   // CHECK-ASM: vsel
 369   vss = vec_sel(vss, vss, vbs);
 370   // CHECK-ASM: vsel
 371   vus = vec_sel(vus, vus, vus);
 372   // CHECK-ASM: vsel
 373   vus = vec_sel(vus, vus, vbs);
 374   // CHECK-ASM: vsel
 375   vbs = vec_sel(vbs, vbs, vus);
 376   // CHECK-ASM: vsel
 377   vbs = vec_sel(vbs, vbs, vbs);
 378   // CHECK-ASM: vsel
 379   vsi = vec_sel(vsi, vsi, vui);
 380   // CHECK-ASM: vsel
 381   vsi = vec_sel(vsi, vsi, vbi);
 382   // CHECK-ASM: vsel
 383   vui = vec_sel(vui, vui, vui);
 384   // CHECK-ASM: vsel
 385   vui = vec_sel(vui, vui, vbi);
 386   // CHECK-ASM: vsel
 387   vbi = vec_sel(vbi, vbi, vui);
 388   // CHECK-ASM: vsel
 389   vbi = vec_sel(vbi, vbi, vbi);
 390   // CHECK-ASM: vsel
 391   vsl = vec_sel(vsl, vsl, vul);
 392   // CHECK-ASM: vsel
 393   vsl = vec_sel(vsl, vsl, vbl);
 394   // CHECK-ASM: vsel
 395   vul = vec_sel(vul, vul, vul);
 396   // CHECK-ASM: vsel
 397   vul = vec_sel(vul, vul, vbl);
 398   // CHECK-ASM: vsel
 399   vbl = vec_sel(vbl, vbl, vul);
 400   // CHECK-ASM: vsel
 401   vbl = vec_sel(vbl, vbl, vbl);
 402   // CHECK-ASM: vsel
 403   vd = vec_sel(vd, vd, vul);
 404   // CHECK-ASM: vsel
 405   vd = vec_sel(vd, vd, vbl);
 406   // CHECK-ASM: vsel
 407
 408   vsi = vec_gather_element(vsi, vui, cptrsi, 0);
 409   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 410   vsi = vec_gather_element(vsi, vui, cptrsi, 1);
 411   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 412   vsi = vec_gather_element(vsi, vui, cptrsi, 2);
 413   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 414   vsi = vec_gather_element(vsi, vui, cptrsi, 3);
 415   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 416   vui = vec_gather_element(vui, vui, cptrui, 0);
 417   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 418   vui = vec_gather_element(vui, vui, cptrui, 1);
 419   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 420   vui = vec_gather_element(vui, vui, cptrui, 2);
 421   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 422   vui = vec_gather_element(vui, vui, cptrui, 3);
 423   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 424   vbi = vec_gather_element(vbi, vui, cptrui, 0);
 425   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 426   vbi = vec_gather_element(vbi, vui, cptrui, 1);
 427   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 428   vbi = vec_gather_element(vbi, vui, cptrui, 2);
 429   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 430   vbi = vec_gather_element(vbi, vui, cptrui, 3);
 431   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 432   vsl = vec_gather_element(vsl, vul, cptrsl, 0);
 433   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 434   vsl = vec_gather_element(vsl, vul, cptrsl, 1);
 435   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 436   vul = vec_gather_element(vul, vul, cptrul, 0);
 437   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 438   vul = vec_gather_element(vul, vul, cptrul, 1);
 439   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 440   vbl = vec_gather_element(vbl, vul, cptrul, 0);
 441   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 442   vbl = vec_gather_element(vbl, vul, cptrul, 1);
 443   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 444   vd = vec_gather_element(vd, vul, cptrd, 0);
 445   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 446   vd = vec_gather_element(vd, vul, cptrd, 1);
 447   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 448
 449   vec_scatter_element(vsi, vui, ptrsi, 0);
 450   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 451   vec_scatter_element(vsi, vui, ptrsi, 1);
 452   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 453   vec_scatter_element(vsi, vui, ptrsi, 2);
 454   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 455   vec_scatter_element(vsi, vui, ptrsi, 3);
 456   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 457   vec_scatter_element(vui, vui, ptrui, 0);
 458   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 459   vec_scatter_element(vui, vui, ptrui, 1);
 460   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 461   vec_scatter_element(vui, vui, ptrui, 2);
 462   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 463   vec_scatter_element(vui, vui, ptrui, 3);
 464   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 465   vec_scatter_element(vbi, vui, ptrui, 0);
 466   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 467   vec_scatter_element(vbi, vui, ptrui, 1);
 468   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 469   vec_scatter_element(vbi, vui, ptrui, 2);
 470   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 471   vec_scatter_element(vbi, vui, ptrui, 3);
 472   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 473   vec_scatter_element(vsl, vul, ptrsl, 0);
 474   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 475   vec_scatter_element(vsl, vul, ptrsl, 1);
 476   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 477   vec_scatter_element(vul, vul, ptrul, 0);
 478   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 479   vec_scatter_element(vul, vul, ptrul, 1);
 480   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 481   vec_scatter_element(vbl, vul, ptrul, 0);
 482   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 483   vec_scatter_element(vbl, vul, ptrul, 1);
 484   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 485   vec_scatter_element(vd, vul, ptrd, 0);
 486   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 487   vec_scatter_element(vd, vul, ptrd, 1);
 488   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 489
 490   vsc = vec_xl(idx, cptrsc);
 491   // CHECK-ASM: vl
 492   vuc = vec_xl(idx, cptruc);
 493   // CHECK-ASM: vl
 494   vss = vec_xl(idx, cptrss);
 495   // CHECK-ASM: vl
 496   vus = vec_xl(idx, cptrus);
 497   // CHECK-ASM: vl
 498   vsi = vec_xl(idx, cptrsi);
 499   // CHECK-ASM: vl
 500   vui = vec_xl(idx, cptrui);
 501   // CHECK-ASM: vl
 502   vsl = vec_xl(idx, cptrsl);
 503   // CHECK-ASM: vl
 504   vul = vec_xl(idx, cptrul);
 505   // CHECK-ASM: vl
 506   vd = vec_xl(idx, cptrd);
 507   // CHECK-ASM: vl
 508
 509   vsc = vec_xld2(idx, cptrsc);
 510   // CHECK-ASM: vl
 511   vuc = vec_xld2(idx, cptruc);
 512   // CHECK-ASM: vl
 513   vss = vec_xld2(idx, cptrss);
 514   // CHECK-ASM: vl
 515   vus = vec_xld2(idx, cptrus);
 516   // CHECK-ASM: vl
 517   vsi = vec_xld2(idx, cptrsi);
 518   // CHECK-ASM: vl
 519   vui = vec_xld2(idx, cptrui);
 520   // CHECK-ASM: vl
 521   vsl = vec_xld2(idx, cptrsl);
 522   // CHECK-ASM: vl
 523   vul = vec_xld2(idx, cptrul);
 524   // CHECK-ASM: vl
 525   vd = vec_xld2(idx, cptrd);
 526   // CHECK-ASM: vl
 527
 528   vsc = vec_xlw4(idx, cptrsc);
 529   // CHECK-ASM: vl
 530   vuc = vec_xlw4(idx, cptruc);
 531   // CHECK-ASM: vl
 532   vss = vec_xlw4(idx, cptrss);
 533   // CHECK-ASM: vl
 534   vus = vec_xlw4(idx, cptrus);
 535   // CHECK-ASM: vl
 536   vsi = vec_xlw4(idx, cptrsi);
 537   // CHECK-ASM: vl
 538   vui = vec_xlw4(idx, cptrui);
 539   // CHECK-ASM: vl
 540
 541   vec_xst(vsc, idx, ptrsc);
 542   // CHECK-ASM: vst
 543   vec_xst(vuc, idx, ptruc);
 544   // CHECK-ASM: vst
 545   vec_xst(vss, idx, ptrss);
 546   // CHECK-ASM: vst
 547   vec_xst(vus, idx, ptrus);
 548   // CHECK-ASM: vst
 549   vec_xst(vsi, idx, ptrsi);
 550   // CHECK-ASM: vst
 551   vec_xst(vui, idx, ptrui);
 552   // CHECK-ASM: vst
 553   vec_xst(vsl, idx, ptrsl);
 554   // CHECK-ASM: vst
 555   vec_xst(vul, idx, ptrul);
 556   // CHECK-ASM: vst
 557   vec_xst(vd, idx, ptrd);
 558   // CHECK-ASM: vst
 559
 560   vec_xstd2(vsc, idx, ptrsc);
 561   // CHECK-ASM: vst
 562   vec_xstd2(vuc, idx, ptruc);
 563   // CHECK-ASM: vst
 564   vec_xstd2(vss, idx, ptrss);
 565   // CHECK-ASM: vst
 566   vec_xstd2(vus, idx, ptrus);
 567   // CHECK-ASM: vst
 568   vec_xstd2(vsi, idx, ptrsi);
 569   // CHECK-ASM: vst
 570   vec_xstd2(vui, idx, ptrui);
 571   // CHECK-ASM: vst
 572   vec_xstd2(vsl, idx, ptrsl);
 573   // CHECK-ASM: vst
 574   vec_xstd2(vul, idx, ptrul);
 575   // CHECK-ASM: vst
 576   vec_xstd2(vd, idx, ptrd);
 577   // CHECK-ASM: vst
 578
 579   vec_xstw4(vsc, idx, ptrsc);
 580   // CHECK-ASM: vst
 581   vec_xstw4(vuc, idx, ptruc);
 582   // CHECK-ASM: vst
 583   vec_xstw4(vss, idx, ptrss);
 584   // CHECK-ASM: vst
 585   vec_xstw4(vus, idx, ptrus);
 586   // CHECK-ASM: vst
 587   vec_xstw4(vsi, idx, ptrsi);
 588   // CHECK-ASM: vst
 589   vec_xstw4(vui, idx, ptrui);
 590   // CHECK-ASM: vst
 591
 592   vsc = vec_load_bndry(cptrsc, 64);
 593   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 594   // CHECK-ASM: vlbb
 595   vuc = vec_load_bndry(cptruc, 64);
 596   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 597   // CHECK-ASM: vlbb
 598   vss = vec_load_bndry(cptrss, 64);
 599   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 600   // CHECK-ASM: vlbb
 601   vus = vec_load_bndry(cptrus, 64);
 602   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 603   // CHECK-ASM: vlbb
 604   vsi = vec_load_bndry(cptrsi, 64);
 605   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 606   // CHECK-ASM: vlbb
 607   vui = vec_load_bndry(cptrui, 64);
 608   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 609   // CHECK-ASM: vlbb
 610   vsl = vec_load_bndry(cptrsl, 64);
 611   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 612   // CHECK-ASM: vlbb
 613   vul = vec_load_bndry(cptrul, 64);
 614   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 615   // CHECK-ASM: vlbb
 616   vd = vec_load_bndry(cptrd, 64);
 617   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 618   // CHECK-ASM: vlbb
 619   vsc = vec_load_bndry(cptrsc, 128);
 620   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 1)
 621   // CHECK-ASM: vlbb
 622   vsc = vec_load_bndry(cptrsc, 256);
 623   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 2)
 624   // CHECK-ASM: vlbb
 625   vsc = vec_load_bndry(cptrsc, 512);
 626   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 3)
 627   // CHECK-ASM: vlbb
 628   vsc = vec_load_bndry(cptrsc, 1024);
 629   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 4)
 630   // CHECK-ASM: vlbb
 631   vsc = vec_load_bndry(cptrsc, 2048);
 632   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 5)
 633   // CHECK-ASM: vlbb
 634   vsc = vec_load_bndry(cptrsc, 4096);
 635   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 6)
 636   // CHECK-ASM: vlbb
 637
 638   vsc = vec_load_len(cptrsc, idx);
 639   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 640   // CHECK-ASM: vll
 641   vuc = vec_load_len(cptruc, idx);
 642   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 643   // CHECK-ASM: vll
 644   vss = vec_load_len(cptrss, idx);
 645   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 646   // CHECK-ASM: vll
 647   vus = vec_load_len(cptrus, idx);
 648   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 649   // CHECK-ASM: vll
 650   vsi = vec_load_len(cptrsi, idx);
 651   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 652   // CHECK-ASM: vll
 653   vui = vec_load_len(cptrui, idx);
 654   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 655   // CHECK-ASM: vll
 656   vsl = vec_load_len(cptrsl, idx);
 657   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 658   // CHECK-ASM: vll
 659   vul = vec_load_len(cptrul, idx);
 660   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 661   // CHECK-ASM: vll
 662   vd = vec_load_len(cptrd, idx);
 663   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 664   // CHECK-ASM: vll
 665
 666   vec_store_len(vsc, ptrsc, idx);
 667   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 668   // CHECK-ASM: vstl
 669   vec_store_len(vuc, ptruc, idx);
 670   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 671   // CHECK-ASM: vstl
 672   vec_store_len(vss, ptrss, idx);
 673   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 674   // CHECK-ASM: vstl
 675   vec_store_len(vus, ptrus, idx);
 676   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 677   // CHECK-ASM: vstl
 678   vec_store_len(vsi, ptrsi, idx);
 679   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 680   // CHECK-ASM: vstl
 681   vec_store_len(vui, ptrui, idx);
 682   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 683   // CHECK-ASM: vstl
 684   vec_store_len(vsl, ptrsl, idx);
 685   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 686   // CHECK-ASM: vstl
 687   vec_store_len(vul, ptrul, idx);
 688   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 689   // CHECK-ASM: vstl
 690   vec_store_len(vd, ptrd, idx);
 691   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 692   // CHECK-ASM: vstl
 693
 694   vsl = vec_load_pair(sl + 1, sl - 1);
 695   // CHECK-ASM: vlvgp
 696   vul = vec_load_pair(ul + 1, ul - 1);
 697   // CHECK-ASM: vlvgp
 698
 699   vuc = vec_genmask(0);
 700   // CHECK: <16 x i8> zeroinitializer
 701   vuc = vec_genmask(0x8000);
 702   // CHECK: <16 x i8> <i8 -1, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>
 703   vuc = vec_genmask(0xffff);
 704   // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 705
 706   vuc = vec_genmasks_8(0, 7);
 707   // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 708   vuc = vec_genmasks_8(1, 4);
 709   // CHECK: <16 x i8> <i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120>
 710   vuc = vec_genmasks_8(6, 2);
 711   // CHECK: <16 x i8> <i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29>
 712   vus = vec_genmasks_16(0, 15);
 713   // CHECK: <8 x i16> <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 714   vus = vec_genmasks_16(2, 11);
 715   // CHECK: <8 x i16> <i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368>
 716   vus = vec_genmasks_16(9, 2);
 717   // CHECK:  <8 x i16> <i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065>
 718   vui = vec_genmasks_32(0, 31);
 719   // CHECK: <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>
 720   vui = vec_genmasks_32(7, 20);
 721   // CHECK: <4 x i32> <i32 33552384, i32 33552384, i32 33552384, i32 33552384>
 722   vui = vec_genmasks_32(25, 4);
 723   // CHECK: <4 x i32> <i32 -134217601, i32 -134217601, i32 -134217601, i32 -134217601>
 724   vul = vec_genmasks_64(0, 63);
 725   // CHECK: <2 x i64> <i64 -1, i64 -1>
 726   vul = vec_genmasks_64(3, 40);
 727   // CHECK: <2 x i64> <i64 2305843009205305344, i64 2305843009205305344>
 728   vul = vec_genmasks_64(30, 11);
 729   // CHECK: <2 x i64> <i64 -4503582447501313, i64 -4503582447501313>
 730
 731   vsc = vec_splat(vsc, 0);
 732   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer
 733   // CHECK-ASM: vrepb
 734   vsc = vec_splat(vsc, 15);
 735   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
 736   // CHECK-ASM: vrepb
 737   vuc = vec_splat(vuc, 0);
 738   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer
 739   // CHECK-ASM: vrepb
 740   vuc = vec_splat(vuc, 15);
 741   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
 742   // CHECK-ASM: vrepb
 743   vbc = vec_splat(vbc, 0);
 744   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer
 745   // CHECK-ASM: vrepb
 746   vbc = vec_splat(vbc, 15);
 747   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15>
 748   // CHECK-ASM: vrepb
 749   vss = vec_splat(vss, 0);
 750   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer
 751   // CHECK-ASM: vreph
 752   vss = vec_splat(vss, 7);
 753   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 754   // CHECK-ASM: vreph
 755   vus = vec_splat(vus, 0);
 756   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer
 757   // CHECK-ASM: vreph
 758   vus = vec_splat(vus, 7);
 759   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 760   // CHECK-ASM: vreph
 761   vbs = vec_splat(vbs, 0);
 762   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer
 763   // CHECK-ASM: vreph
 764   vbs = vec_splat(vbs, 7);
 765   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 766   // CHECK-ASM: vreph
 767   vsi = vec_splat(vsi, 0);
 768   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer
 769   // CHECK-ASM: vrepf
 770   vsi = vec_splat(vsi, 3);
 771   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 772   // CHECK-ASM: vrepf
 773   vui = vec_splat(vui, 0);
 774   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer
 775   // CHECK-ASM: vrepf
 776   vui = vec_splat(vui, 3);
 777   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 778   // CHECK-ASM: vrepf
 779   vbi = vec_splat(vbi, 0);
 780   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer
 781   // CHECK-ASM: vrepf
 782   vbi = vec_splat(vbi, 3);
 783   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 784   // CHECK-ASM: vrepf
 785   vsl = vec_splat(vsl, 0);
 786   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer
 787   // CHECK-ASM: vrepg
 788   vsl = vec_splat(vsl, 1);
 789   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 790   // CHECK-ASM: vrepg
 791   vul = vec_splat(vul, 0);
 792   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer
 793   // CHECK-ASM: vrepg
 794   vul = vec_splat(vul, 1);
 795   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 796   // CHECK-ASM: vrepg
 797   vbl = vec_splat(vbl, 0);
 798   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer
 799   // CHECK-ASM: vrepg
 800   vbl = vec_splat(vbl, 1);
 801   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 802   // CHECK-ASM: vrepg
 803   vd = vec_splat(vd, 0);
 804   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 805   // CHECK-ASM: vrepg
 806   vd = vec_splat(vd, 1);
 807   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
 808   // CHECK-ASM: vrepg
 809
 810   vsc = vec_splat_s8(-128);
 811   // CHECK: <16 x i8> <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
 812   vsc = vec_splat_s8(127);
 813   // CHECK: <16 x i8> <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
 814   vuc = vec_splat_u8(1);
 815   // CHECK: <16 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
 816   vuc = vec_splat_u8(254);
 817   // CHECK: <16 x i8> <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2>
 818   vss = vec_splat_s16(-32768);
 819   // CHECK: <8 x i16> <i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768>
 820   vss = vec_splat_s16(32767);
 821   // CHECK: <8 x i16> <i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767>
 822   vus = vec_splat_u16(1);
 823   // CHECK: <8 x i16> <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
 824   vus = vec_splat_u16(65534);
 825   // CHECK: <8 x i16> <i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2>
 826   vsi = vec_splat_s32(-32768);
 827   // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
 828   vsi = vec_splat_s32(32767);
 829   // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
 830   vui = vec_splat_u32(-32768);
 831   // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768>
 832   vui = vec_splat_u32(32767);
 833   // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767>
 834   vsl = vec_splat_s64(-32768);
 835   // CHECK: <2 x i64> <i64 -32768, i64 -32768>
 836   vsl = vec_splat_s64(32767);
 837   // CHECK: <2 x i64> <i64 32767, i64 32767>
 838   vul = vec_splat_u64(-32768);
 839   // CHECK: <2 x i64> <i64 -32768, i64 -32768>
 840   vul = vec_splat_u64(32767);
 841   // CHECK: <2 x i64> <i64 32767, i64 32767>
 842
 843   vsc = vec_splats(sc);
 844   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer
 845   // CHECK-ASM: vlrepb
 846   vuc = vec_splats(uc);
 847   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer
 848   // CHECK-ASM: vlrepb
 849   vss = vec_splats(ss);
 850   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer
 851   // CHECK-ASM: vlreph
 852   vus = vec_splats(us);
 853   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer
 854   // CHECK-ASM: vlreph
 855   vsi = vec_splats(si);
 856   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer
 857   // CHECK-ASM: vlrepf
 858   vui = vec_splats(ui);
 859   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer
 860   // CHECK-ASM: vlrepf
 861   vsl = vec_splats(sl);
 862   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer
 863   // CHECK-ASM: vlrepg
 864   vul = vec_splats(ul);
 865   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer
 866   // CHECK-ASM: vlrepg
 867   vd = vec_splats(d);
 868   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 869   // CHECK-ASM: vlrepg
 870
 871   vsl = vec_extend_s64(vsc);
 872   // CHECK-ASM: vsegb
 873   vsl = vec_extend_s64(vss);
 874   // CHECK-ASM: vsegh
 875   vsl = vec_extend_s64(vsi);
 876   // CHECK-ASM: vsegf
 877
 878   vsc = vec_mergeh(vsc, vsc);
 879   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 880   // CHECK-ASM: vmrhb
 881   vuc = vec_mergeh(vuc, vuc);
 882   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 883   // CHECK-ASM: vmrhb
 884   vbc = vec_mergeh(vbc, vbc);
 885   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 886   // CHECK-ASM: vmrhb
 887   vss = vec_mergeh(vss, vss);
 888   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 889   // CHECK-ASM: vmrhh
 890   vus = vec_mergeh(vus, vus);
 891   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 892   // CHECK-ASM: vmrhh
 893   vbs = vec_mergeh(vbs, vbs);
 894   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 895   // CHECK-ASM: vmrhh
 896   vsi = vec_mergeh(vsi, vsi);
 897   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 898   // CHECK-ASM: vmrhf
 899   vui = vec_mergeh(vui, vui);
 900   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 901   // CHECK-ASM: vmrhf
 902   vbi = vec_mergeh(vbi, vbi);
 903   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 904   // CHECK-ASM: vmrhf
 905   vsl = vec_mergeh(vsl, vsl);
 906   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
 907   // CHECK-ASM: vmrhg
 908   vul = vec_mergeh(vul, vul);
 909   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
 910   // CHECK-ASM: vmrhg
 911   vbl = vec_mergeh(vbl, vbl);
 912   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
 913   // CHECK-ASM: vmrhg
 914   vd = vec_mergeh(vd, vd);
 915   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
 916   // CHECK-ASM: vmrhg
 917
 918   vsc = vec_mergel(vsc, vsc);
 919   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 920   // CHECK-ASM: vmrlb
 921   vuc = vec_mergel(vuc, vuc);
 922   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 923   // CHECK-ASM: vmrlb
 924   vbc = vec_mergel(vbc, vbc);
 925   // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 926   // CHECK-ASM: vmrlb
 927   vss = vec_mergel(vss, vss);
 928   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 929   // CHECK-ASM: vmrlh
 930   vus = vec_mergel(vus, vus);
 931   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 932   // CHECK-ASM: vmrlh
 933   vbs = vec_mergel(vbs, vbs);
 934   // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 935   // CHECK-ASM: vmrlh
 936   vsi = vec_mergel(vsi, vsi);
 937   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
 938   // CHECK-ASM: vmrlf
 939   vui = vec_mergel(vui, vui);
 940   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
 941   // CHECK-ASM: vmrlf
 942   vbi = vec_mergel(vbi, vbi);
 943   // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
 944   // CHECK-ASM: vmrlf
 945   vsl = vec_mergel(vsl, vsl);
 946   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
 947   // CHECK-ASM: vmrlg
 948   vul = vec_mergel(vul, vul);
 949   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
 950   // CHECK-ASM: vmrlg
 951   vbl = vec_mergel(vbl, vbl);
 952   // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>
 953   // CHECK-ASM: vmrlg
 954   vd = vec_mergel(vd, vd);
 955   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
 956   // CHECK-ASM: vmrlg
 957
 958   vsc = vec_pack(vss, vss);
 959   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 960   // CHECK-ASM: vpkh
 961   vuc = vec_pack(vus, vus);
 962   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 963   // CHECK-ASM: vpkh
 964   vbc = vec_pack(vbs, vbs);
 965   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 966   // CHECK-ASM: vpkh
 967   vss = vec_pack(vsi, vsi);
 968   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 969   // CHECK-ASM: vpkf
 970   vus = vec_pack(vui, vui);
 971   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 972   // CHECK-ASM: vpkf
 973   vbs = vec_pack(vbi, vbi);
 974   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 975   // CHECK-ASM: vpkf
 976   vsi = vec_pack(vsl, vsl);
 977   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 978   // CHECK-ASM: vpkg
 979   vui = vec_pack(vul, vul);
 980   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 981   // CHECK-ASM: vpkg
 982   vbi = vec_pack(vbl, vbl);
 983   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 984   // CHECK-ASM: vpkg
 985
 986   vsc = vec_packs(vss, vss);
 987   // CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 988   // CHECK-ASM: vpksh
 989   vuc = vec_packs(vus, vus);
 990   // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 991   // CHECK-ASM: vpklsh
 992   vss = vec_packs(vsi, vsi);
 993   // CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 994   // CHECK-ASM: vpksf
 995   vus = vec_packs(vui, vui);
 996   // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 997   // CHECK-ASM: vpklsf
 998   vsi = vec_packs(vsl, vsl);
 999   // CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1000   // CHECK-ASM: vpksg
1001   vui = vec_packs(vul, vul);
1002   // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1003   // CHECK-ASM: vpklsg
1004
1005   vsc = vec_packs_cc(vss, vss, &cc);
1006   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpkshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1007   // CHECK-ASM: vpkshs
1008   vuc = vec_packs_cc(vus, vus, &cc);
1009   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1010   // CHECK-ASM: vpklshs
1011   vss = vec_packs_cc(vsi, vsi, &cc);
1012   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpksfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1013   // CHECK-ASM: vpksfs
1014   vus = vec_packs_cc(vui, vui, &cc);
1015   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1016   // CHECK-ASM: vpklsfs
1017   vsi = vec_packs_cc(vsl, vsl, &cc);
1018   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpksgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1019   // CHECK-ASM: vpksgs
1020   vui = vec_packs_cc(vul, vul, &cc);
1021   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1022   // CHECK-ASM: vpklsgs
1023
1024   vuc = vec_packsu(vss, vss);
1025   // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1026   // CHECK-ASM: vpklsh
1027   vuc = vec_packsu(vus, vus);
1028   // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1029   // CHECK-ASM: vpklsh
1030   vus = vec_packsu(vsi, vsi);
1031   // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1032   // CHECK-ASM: vpklsf
1033   vus = vec_packsu(vui, vui);
1034   // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1035   // CHECK-ASM: vpklsf
1036   vui = vec_packsu(vsl, vsl);
1037   // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1038   // CHECK-ASM: vpklsg
1039   vui = vec_packsu(vul, vul);
1040   // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1041   // CHECK-ASM: vpklsg
1042
1043   vuc = vec_packsu_cc(vus, vus, &cc);
1044   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1045   // CHECK-ASM: vpklshs
1046   vus = vec_packsu_cc(vui, vui, &cc);
1047   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1048   // CHECK-ASM: vpklsfs
1049   vui = vec_packsu_cc(vul, vul, &cc);
1050   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1051   // CHECK-ASM: vpklsgs
1052
1053   vss = vec_unpackh(vsc);
1054   // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
1055   // CHECK-ASM: vuphb
1056   vus = vec_unpackh(vuc);
1057   // CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}})
1058   // CHECK-ASM: vuplhb
1059   vbs = vec_unpackh(vbc);
1060   // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})
1061   // CHECK-ASM: vuphb
1062   vsi = vec_unpackh(vss);
1063   // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
1064   // CHECK-ASM: vuphh
1065   vui = vec_unpackh(vus);
1066   // CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}})
1067   // CHECK-ASM: vuplhh
1068   vbi = vec_unpackh(vbs);
1069   // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})
1070   // CHECK-ASM: vuphh
1071   vsl = vec_unpackh(vsi);
1072   // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
1073   // CHECK-ASM: vuphf
1074   vul = vec_unpackh(vui);
1075   // CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}})
1076   // CHECK-ASM: vuplhf
1077   vbl = vec_unpackh(vbi);
1078   // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})
1079   // CHECK-ASM: vuphf
1080
1081   vss = vec_unpackl(vsc);
1082   // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
1083   // CHECK-ASM: vuplb
1084   vus = vec_unpackl(vuc);
1085   // CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}})
1086   // CHECK-ASM: vupllb
1087   vbs = vec_unpackl(vbc);
1088   // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})
1089   // CHECK-ASM: vuplb
1090   vsi = vec_unpackl(vss);
1091   // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
1092   // CHECK-ASM: vuplhw
1093   vui = vec_unpackl(vus);
1094   // CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}})
1095   // CHECK-ASM: vupllh
1096   vbi = vec_unpackl(vbs);
1097   // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})
1098   // CHECK-ASM: vuplhw
1099   vsl = vec_unpackl(vsi);
1100   // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
1101   // CHECK-ASM: vuplf
1102   vul = vec_unpackl(vui);
1103   // CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}})
1104   // CHECK-ASM: vupllf
1105   vbl = vec_unpackl(vbi);
1106   // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})
1107   // CHECK-ASM: vuplf
1108 }
1109
1110 void test_compare(void) {
1111   // CHECK-ASM-LABEL: test_compare
1112
1113   vbc = vec_cmpeq(vsc, vsc);
1114   // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1115   // CHECK-ASM: vceqb
1116   vbc = vec_cmpeq(vuc, vuc);
1117   // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1118   // CHECK-ASM: vceqb
1119   vbc = vec_cmpeq(vbc, vbc);
1120   // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
1121   // CHECK-ASM: vceqb
1122   vbs = vec_cmpeq(vss, vss);
1123   // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1124   // CHECK-ASM: vceqh
1125   vbs = vec_cmpeq(vus, vus);
1126   // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1127   // CHECK-ASM: vceqh
1128   vbs = vec_cmpeq(vbs, vbs);
1129   // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
1130   // CHECK-ASM: vceqh
1131   vbi = vec_cmpeq(vsi, vsi);
1132   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1133   // CHECK-ASM: vceqf
1134   vbi = vec_cmpeq(vui, vui);
1135   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1136   // CHECK-ASM: vceqf
1137   vbi = vec_cmpeq(vbi, vbi);
1138   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
1139   // CHECK-ASM: vceqf
1140   vbl = vec_cmpeq(vsl, vsl);
1141   // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1142   // CHECK-ASM: vceqg
1143   vbl = vec_cmpeq(vul, vul);
1144   // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1145   // CHECK-ASM: vceqg
1146   vbl = vec_cmpeq(vbl, vbl);
1147   // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
1148   // CHECK-ASM: vceqg
1149   vbl = vec_cmpeq(vd, vd);
1150   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
1151   // CHECK-ASM: vfcedb
1152
1153   vbc = vec_cmpge(vsc, vsc);
1154   // CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}}
1155   // CHECK-ASM: vchb
1156   vbc = vec_cmpge(vuc, vuc);
1157   // CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}}
1158   // CHECK-ASM: vchlb
1159   vbs = vec_cmpge(vss, vss);
1160   // CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}}
1161   // CHECK-ASM: vchh
1162   vbs = vec_cmpge(vus, vus);
1163   // CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}}
1164   // CHECK-ASM: vchlh
1165   vbi = vec_cmpge(vsi, vsi);
1166   // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
1167   // CHECK-ASM: vchf
1168   vbi = vec_cmpge(vui, vui);
1169   // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
1170   // CHECK-ASM: vchlf
1171   vbl = vec_cmpge(vsl, vsl);
1172   // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
1173   // CHECK-ASM: vchg
1174   vbl = vec_cmpge(vul, vul);
1175   // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
1176   // CHECK-ASM: vchlg
1177   vbl = vec_cmpge(vd, vd);
1178   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
1179   // CHECK-ASM: vfchedb
1180
1181   vbc = vec_cmpgt(vsc, vsc);
1182   // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}}
1183   // CHECK-ASM: vchb
1184   vbc = vec_cmpgt(vuc, vuc);
1185   // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}}
1186   // CHECK-ASM: vchlb
1187   vbs = vec_cmpgt(vss, vss);
1188   // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}}
1189   // CHECK-ASM: vchh
1190   vbs = vec_cmpgt(vus, vus);
1191   // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}}
1192   // CHECK-ASM: vchlh
1193   vbi = vec_cmpgt(vsi, vsi);
1194   // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}}
1195   // CHECK-ASM: vchf
1196   vbi = vec_cmpgt(vui, vui);
1197   // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
1198   // CHECK-ASM: vchlf
1199   vbl = vec_cmpgt(vsl, vsl);
1200   // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}}
1201   // CHECK-ASM: vchg
1202   vbl = vec_cmpgt(vul, vul);
1203   // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
1204   // CHECK-ASM: vchlg
1205   vbl = vec_cmpgt(vd, vd);
1206   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
1207   // CHECK-ASM: vfchdb
1208
1209   vbc = vec_cmple(vsc, vsc);
1210   // CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}}
1211   // CHECK-ASM: vchb
1212   vbc = vec_cmple(vuc, vuc);
1213   // CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}}
1214   // CHECK-ASM: vchlb
1215   vbs = vec_cmple(vss, vss);
1216   // CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}}
1217   // CHECK-ASM: vchh
1218   vbs = vec_cmple(vus, vus);
1219   // CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}}
1220   // CHECK-ASM: vchlh
1221   vbi = vec_cmple(vsi, vsi);
1222   // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
1223   // CHECK-ASM: vchf
1224   vbi = vec_cmple(vui, vui);
1225   // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
1226   // CHECK-ASM: vchlf
1227   vbl = vec_cmple(vsl, vsl);
1228   // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
1229   // CHECK-ASM: vchg
1230   vbl = vec_cmple(vul, vul);
1231   // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
1232   // CHECK-ASM: vchlg
1233   vbl = vec_cmple(vd, vd);
1234   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
1235   // CHECK-ASM: vfchedb
1236
1237   vbc = vec_cmplt(vsc, vsc);
1238   // CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}}
1239   // CHECK-ASM: vchb
1240   vbc = vec_cmplt(vuc, vuc);
1241   // CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}}
1242   // CHECK-ASM: vchlb
1243   vbs = vec_cmplt(vss, vss);
1244   // CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}}
1245   // CHECK-ASM: vchh
1246   vbs = vec_cmplt(vus, vus);
1247   // CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}}
1248   // CHECK-ASM: vchlh
1249   vbi = vec_cmplt(vsi, vsi);
1250   // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
1251   // CHECK-ASM: vchf
1252   vbi = vec_cmplt(vui, vui);
1253   // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
1254   // CHECK-ASM: vchlf
1255   vbl = vec_cmplt(vsl, vsl);
1256   // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
1257   // CHECK-ASM: vchg
1258   vbl = vec_cmplt(vul, vul);
1259   // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
1260   // CHECK-ASM: vchlg
1261   vbl = vec_cmplt(vd, vd);
1262   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
1263   // CHECK-ASM: vfchdb
1264
1265   idx = vec_all_eq(vsc, vsc);
1266   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1267   // CHECK-ASM: vceqbs
1268   idx = vec_all_eq(vsc, vbc);
1269   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1270   // CHECK-ASM: vceqbs
1271   idx = vec_all_eq(vbc, vsc);
1272   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1273   // CHECK-ASM: vceqbs
1274   idx = vec_all_eq(vuc, vuc);
1275   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1276   // CHECK-ASM: vceqbs
1277   idx = vec_all_eq(vuc, vbc);
1278   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1279   // CHECK-ASM: vceqbs
1280   idx = vec_all_eq(vbc, vuc);
1281   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1282   // CHECK-ASM: vceqbs
1283   idx = vec_all_eq(vbc, vbc);
1284   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1285   // CHECK-ASM: vceqbs
1286   idx = vec_all_eq(vss, vss);
1287   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1288   // CHECK-ASM: vceqhs
1289   idx = vec_all_eq(vss, vbs);
1290   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1291   // CHECK-ASM: vceqhs
1292   idx = vec_all_eq(vbs, vss);
1293   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1294   // CHECK-ASM: vceqhs
1295   idx = vec_all_eq(vus, vus);
1296   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1297   // CHECK-ASM: vceqhs
1298   idx = vec_all_eq(vus, vbs);
1299   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1300   // CHECK-ASM: vceqhs
1301   idx = vec_all_eq(vbs, vus);
1302   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1303   // CHECK-ASM: vceqhs
1304   idx = vec_all_eq(vbs, vbs);
1305   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1306   // CHECK-ASM: vceqhs
1307   idx = vec_all_eq(vsi, vsi);
1308   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1309   // CHECK-ASM: vceqfs
1310   idx = vec_all_eq(vsi, vbi);
1311   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1312   // CHECK-ASM: vceqfs
1313   idx = vec_all_eq(vbi, vsi);
1314   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1315   // CHECK-ASM: vceqfs
1316   idx = vec_all_eq(vui, vui);
1317   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1318   // CHECK-ASM: vceqfs
1319   idx = vec_all_eq(vui, vbi);
1320   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1321   // CHECK-ASM: vceqfs
1322   idx = vec_all_eq(vbi, vui);
1323   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1324   // CHECK-ASM: vceqfs
1325   idx = vec_all_eq(vbi, vbi);
1326   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1327   // CHECK-ASM: vceqfs
1328   idx = vec_all_eq(vsl, vsl);
1329   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1330   // CHECK-ASM: vceqgs
1331   idx = vec_all_eq(vsl, vbl);
1332   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1333   // CHECK-ASM: vceqgs
1334   idx = vec_all_eq(vbl, vsl);
1335   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1336   // CHECK-ASM: vceqgs
1337   idx = vec_all_eq(vul, vul);
1338   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1339   // CHECK-ASM: vceqgs
1340   idx = vec_all_eq(vul, vbl);
1341   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1342   // CHECK-ASM: vceqgs
1343   idx = vec_all_eq(vbl, vul);
1344   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1345   // CHECK-ASM: vceqgs
1346   idx = vec_all_eq(vbl, vbl);
1347   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1348   // CHECK-ASM: vceqgs
1349   idx = vec_all_eq(vd, vd);
1350   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1351   // CHECK-ASM: vfcedbs
1352
1353   idx = vec_all_ne(vsc, vsc);
1354   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1355   // CHECK-ASM: vceqbs
1356   idx = vec_all_ne(vsc, vbc);
1357   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1358   // CHECK-ASM: vceqbs
1359   idx = vec_all_ne(vbc, vsc);
1360   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1361   // CHECK-ASM: vceqbs
1362   idx = vec_all_ne(vuc, vuc);
1363   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1364   // CHECK-ASM: vceqbs
1365   idx = vec_all_ne(vuc, vbc);
1366   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1367   // CHECK-ASM: vceqbs
1368   idx = vec_all_ne(vbc, vuc);
1369   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1370   // CHECK-ASM: vceqbs
1371   idx = vec_all_ne(vbc, vbc);
1372   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1373   // CHECK-ASM: vceqbs
1374   idx = vec_all_ne(vss, vss);
1375   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1376   // CHECK-ASM: vceqhs
1377   idx = vec_all_ne(vss, vbs);
1378   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1379   // CHECK-ASM: vceqhs
1380   idx = vec_all_ne(vbs, vss);
1381   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1382   // CHECK-ASM: vceqhs
1383   idx = vec_all_ne(vus, vus);
1384   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1385   // CHECK-ASM: vceqhs
1386   idx = vec_all_ne(vus, vbs);
1387   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1388   // CHECK-ASM: vceqhs
1389   idx = vec_all_ne(vbs, vus);
1390   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1391   // CHECK-ASM: vceqhs
1392   idx = vec_all_ne(vbs, vbs);
1393   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1394   // CHECK-ASM: vceqhs
1395   idx = vec_all_ne(vsi, vsi);
1396   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1397   // CHECK-ASM: vceqfs
1398   idx = vec_all_ne(vsi, vbi);
1399   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1400   // CHECK-ASM: vceqfs
1401   idx = vec_all_ne(vbi, vsi);
1402   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1403   // CHECK-ASM: vceqfs
1404   idx = vec_all_ne(vui, vui);
1405   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1406   // CHECK-ASM: vceqfs
1407   idx = vec_all_ne(vui, vbi);
1408   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1409   // CHECK-ASM: vceqfs
1410   idx = vec_all_ne(vbi, vui);
1411   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1412   // CHECK-ASM: vceqfs
1413   idx = vec_all_ne(vbi, vbi);
1414   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1415   // CHECK-ASM: vceqfs
1416   idx = vec_all_ne(vsl, vsl);
1417   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1418   // CHECK-ASM: vceqgs
1419   idx = vec_all_ne(vsl, vbl);
1420   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1421   // CHECK-ASM: vceqgs
1422   idx = vec_all_ne(vbl, vsl);
1423   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1424   // CHECK-ASM: vceqgs
1425   idx = vec_all_ne(vul, vul);
1426   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1427   // CHECK-ASM: vceqgs
1428   idx = vec_all_ne(vul, vbl);
1429   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1430   // CHECK-ASM: vceqgs
1431   idx = vec_all_ne(vbl, vul);
1432   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1433   // CHECK-ASM: vceqgs
1434   idx = vec_all_ne(vbl, vbl);
1435   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1436   // CHECK-ASM: vceqgs
1437   idx = vec_all_ne(vd, vd);
1438   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1439   // CHECK-ASM: vfcedbs
1440
1441   idx = vec_all_ge(vsc, vsc);
1442   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1443   // CHECK-ASM: vchbs
1444   idx = vec_all_ge(vsc, vbc);
1445   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1446   // CHECK-ASM: vchbs
1447   idx = vec_all_ge(vbc, vsc);
1448   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1449   // CHECK-ASM: vchbs
1450   idx = vec_all_ge(vuc, vuc);
1451   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1452   // CHECK-ASM: vchlbs
1453   idx = vec_all_ge(vuc, vbc);
1454   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1455   // CHECK-ASM: vchlbs
1456   idx = vec_all_ge(vbc, vuc);
1457   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1458   // CHECK-ASM: vchlbs
1459   idx = vec_all_ge(vbc, vbc);
1460   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1461   // CHECK-ASM: vchlbs
1462   idx = vec_all_ge(vss, vss);
1463   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1464   // CHECK-ASM: vchhs
1465   idx = vec_all_ge(vss, vbs);
1466   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1467   // CHECK-ASM: vchhs
1468   idx = vec_all_ge(vbs, vss);
1469   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1470   // CHECK-ASM: vchhs
1471   idx = vec_all_ge(vus, vus);
1472   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1473   // CHECK-ASM: vchlhs
1474   idx = vec_all_ge(vus, vbs);
1475   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1476   // CHECK-ASM: vchlhs
1477   idx = vec_all_ge(vbs, vus);
1478   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1479   // CHECK-ASM: vchlhs
1480   idx = vec_all_ge(vbs, vbs);
1481   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1482   // CHECK-ASM: vchlhs
1483   idx = vec_all_ge(vsi, vsi);
1484   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1485   // CHECK-ASM: vchfs
1486   idx = vec_all_ge(vsi, vbi);
1487   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1488   // CHECK-ASM: vchfs
1489   idx = vec_all_ge(vbi, vsi);
1490   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1491   // CHECK-ASM: vchfs
1492   idx = vec_all_ge(vui, vui);
1493   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1494   // CHECK-ASM: vchlfs
1495   idx = vec_all_ge(vui, vbi);
1496   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1497   // CHECK-ASM: vchlfs
1498   idx = vec_all_ge(vbi, vui);
1499   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1500   // CHECK-ASM: vchlfs
1501   idx = vec_all_ge(vbi, vbi);
1502   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1503   // CHECK-ASM: vchlfs
1504   idx = vec_all_ge(vsl, vsl);
1505   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1506   // CHECK-ASM: vchgs
1507   idx = vec_all_ge(vsl, vbl);
1508   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1509   // CHECK-ASM: vchgs
1510   idx = vec_all_ge(vbl, vsl);
1511   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1512   // CHECK-ASM: vchgs
1513   idx = vec_all_ge(vul, vul);
1514   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1515   // CHECK-ASM: vchlgs
1516   idx = vec_all_ge(vul, vbl);
1517   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1518   // CHECK-ASM: vchlgs
1519   idx = vec_all_ge(vbl, vul);
1520   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1521   // CHECK-ASM: vchlgs
1522   idx = vec_all_ge(vbl, vbl);
1523   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1524   // CHECK-ASM: vchlgs
1525   idx = vec_all_ge(vd, vd);
1526   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1527   // CHECK-ASM: vfchedbs
1528
1529   idx = vec_all_gt(vsc, vsc);
1530   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1531   // CHECK-ASM: vchbs
1532   idx = vec_all_gt(vsc, vbc);
1533   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1534   // CHECK-ASM: vchbs
1535   idx = vec_all_gt(vbc, vsc);
1536   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1537   // CHECK-ASM: vchbs
1538   idx = vec_all_gt(vuc, vuc);
1539   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1540   // CHECK-ASM: vchlbs
1541   idx = vec_all_gt(vuc, vbc);
1542   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1543   // CHECK-ASM: vchlbs
1544   idx = vec_all_gt(vbc, vuc);
1545   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1546   // CHECK-ASM: vchlbs
1547   idx = vec_all_gt(vbc, vbc);
1548   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1549   // CHECK-ASM: vchlbs
1550   idx = vec_all_gt(vss, vss);
1551   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1552   // CHECK-ASM: vchhs
1553   idx = vec_all_gt(vss, vbs);
1554   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1555   // CHECK-ASM: vchhs
1556   idx = vec_all_gt(vbs, vss);
1557   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1558   // CHECK-ASM: vchhs
1559   idx = vec_all_gt(vus, vus);
1560   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1561   // CHECK-ASM: vchlhs
1562   idx = vec_all_gt(vus, vbs);
1563   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1564   // CHECK-ASM: vchlhs
1565   idx = vec_all_gt(vbs, vus);
1566   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1567   // CHECK-ASM: vchlhs
1568   idx = vec_all_gt(vbs, vbs);
1569   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1570   // CHECK-ASM: vchlhs
1571   idx = vec_all_gt(vsi, vsi);
1572   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1573   // CHECK-ASM: vchfs
1574   idx = vec_all_gt(vsi, vbi);
1575   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1576   // CHECK-ASM: vchfs
1577   idx = vec_all_gt(vbi, vsi);
1578   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1579   // CHECK-ASM: vchfs
1580   idx = vec_all_gt(vui, vui);
1581   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1582   // CHECK-ASM: vchlfs
1583   idx = vec_all_gt(vui, vbi);
1584   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1585   // CHECK-ASM: vchlfs
1586   idx = vec_all_gt(vbi, vui);
1587   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1588   // CHECK-ASM: vchlfs
1589   idx = vec_all_gt(vbi, vbi);
1590   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1591   // CHECK-ASM: vchlfs
1592   idx = vec_all_gt(vsl, vsl);
1593   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1594   // CHECK-ASM: vchgs
1595   idx = vec_all_gt(vsl, vbl);
1596   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1597   // CHECK-ASM: vchgs
1598   idx = vec_all_gt(vbl, vsl);
1599   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1600   // CHECK-ASM: vchgs
1601   idx = vec_all_gt(vul, vul);
1602   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1603   // CHECK-ASM: vchlgs
1604   idx = vec_all_gt(vul, vbl);
1605   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1606   // CHECK-ASM: vchlgs
1607   idx = vec_all_gt(vbl, vul);
1608   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1609   // CHECK-ASM: vchlgs
1610   idx = vec_all_gt(vbl, vbl);
1611   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1612   // CHECK-ASM: vchlgs
1613   idx = vec_all_gt(vd, vd);
1614   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1615   // CHECK-ASM: vfchdbs
1616
1617   idx = vec_all_le(vsc, vsc);
1618   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1619   // CHECK-ASM: vchbs
1620   idx = vec_all_le(vsc, vbc);
1621   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1622   // CHECK-ASM: vchbs
1623   idx = vec_all_le(vbc, vsc);
1624   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1625   // CHECK-ASM: vchbs
1626   idx = vec_all_le(vuc, vuc);
1627   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1628   // CHECK-ASM: vchlbs
1629   idx = vec_all_le(vuc, vbc);
1630   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1631   // CHECK-ASM: vchlbs
1632   idx = vec_all_le(vbc, vuc);
1633   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1634   // CHECK-ASM: vchlbs
1635   idx = vec_all_le(vbc, vbc);
1636   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1637   // CHECK-ASM: vchlbs
1638   idx = vec_all_le(vss, vss);
1639   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1640   // CHECK-ASM: vchhs
1641   idx = vec_all_le(vss, vbs);
1642   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1643   // CHECK-ASM: vchhs
1644   idx = vec_all_le(vbs, vss);
1645   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1646   // CHECK-ASM: vchhs
1647   idx = vec_all_le(vus, vus);
1648   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1649   // CHECK-ASM: vchlhs
1650   idx = vec_all_le(vus, vbs);
1651   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1652   // CHECK-ASM: vchlhs
1653   idx = vec_all_le(vbs, vus);
1654   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1655   // CHECK-ASM: vchlhs
1656   idx = vec_all_le(vbs, vbs);
1657   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1658   // CHECK-ASM: vchlhs
1659   idx = vec_all_le(vsi, vsi);
1660   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1661   // CHECK-ASM: vchfs
1662   idx = vec_all_le(vsi, vbi);
1663   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1664   // CHECK-ASM: vchfs
1665   idx = vec_all_le(vbi, vsi);
1666   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1667   // CHECK-ASM: vchfs
1668   idx = vec_all_le(vui, vui);
1669   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1670   // CHECK-ASM: vchlfs
1671   idx = vec_all_le(vui, vbi);
1672   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1673   // CHECK-ASM: vchlfs
1674   idx = vec_all_le(vbi, vui);
1675   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1676   // CHECK-ASM: vchlfs
1677   idx = vec_all_le(vbi, vbi);
1678   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1679   // CHECK-ASM: vchlfs
1680   idx = vec_all_le(vsl, vsl);
1681   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1682   // CHECK-ASM: vchgs
1683   idx = vec_all_le(vsl, vbl);
1684   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1685   // CHECK-ASM: vchgs
1686   idx = vec_all_le(vbl, vsl);
1687   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1688   // CHECK-ASM: vchgs
1689   idx = vec_all_le(vul, vul);
1690   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1691   // CHECK-ASM: vchlgs
1692   idx = vec_all_le(vul, vbl);
1693   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1694   // CHECK-ASM: vchlgs
1695   idx = vec_all_le(vbl, vul);
1696   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1697   // CHECK-ASM: vchlgs
1698   idx = vec_all_le(vbl, vbl);
1699   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1700   // CHECK-ASM: vchlgs
1701   idx = vec_all_le(vd, vd);
1702   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1703   // CHECK-ASM: vfchedbs
1704
1705   idx = vec_all_lt(vsc, vsc);
1706   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1707   // CHECK-ASM: vchbs
1708   idx = vec_all_lt(vsc, vbc);
1709   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1710   // CHECK-ASM: vchbs
1711   idx = vec_all_lt(vbc, vsc);
1712   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1713   // CHECK-ASM: vchbs
1714   idx = vec_all_lt(vuc, vuc);
1715   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1716   // CHECK-ASM: vchlbs
1717   idx = vec_all_lt(vuc, vbc);
1718   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1719   // CHECK-ASM: vchlbs
1720   idx = vec_all_lt(vbc, vuc);
1721   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1722   // CHECK-ASM: vchlbs
1723   idx = vec_all_lt(vbc, vbc);
1724   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1725   // CHECK-ASM: vchlbs
1726   idx = vec_all_lt(vss, vss);
1727   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1728   // CHECK-ASM: vchhs
1729   idx = vec_all_lt(vss, vbs);
1730   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1731   // CHECK-ASM: vchhs
1732   idx = vec_all_lt(vbs, vss);
1733   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1734   // CHECK-ASM: vchhs
1735   idx = vec_all_lt(vus, vus);
1736   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1737   // CHECK-ASM: vchlhs
1738   idx = vec_all_lt(vus, vbs);
1739   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1740   // CHECK-ASM: vchlhs
1741   idx = vec_all_lt(vbs, vus);
1742   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1743   // CHECK-ASM: vchlhs
1744   idx = vec_all_lt(vbs, vbs);
1745   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1746   // CHECK-ASM: vchlhs
1747   idx = vec_all_lt(vsi, vsi);
1748   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1749   // CHECK-ASM: vchfs
1750   idx = vec_all_lt(vsi, vbi);
1751   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1752   // CHECK-ASM: vchfs
1753   idx = vec_all_lt(vbi, vsi);
1754   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1755   // CHECK-ASM: vchfs
1756   idx = vec_all_lt(vui, vui);
1757   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1758   // CHECK-ASM: vchlfs
1759   idx = vec_all_lt(vui, vbi);
1760   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1761   // CHECK-ASM: vchlfs
1762   idx = vec_all_lt(vbi, vui);
1763   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1764   // CHECK-ASM: vchlfs
1765   idx = vec_all_lt(vbi, vbi);
1766   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1767   // CHECK-ASM: vchlfs
1768   idx = vec_all_lt(vsl, vsl);
1769   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1770   // CHECK-ASM: vchgs
1771   idx = vec_all_lt(vsl, vbl);
1772   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1773   // CHECK-ASM: vchgs
1774   idx = vec_all_lt(vbl, vsl);
1775   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1776   // CHECK-ASM: vchgs
1777   idx = vec_all_lt(vul, vul);
1778   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1779   // CHECK-ASM: vchlgs
1780   idx = vec_all_lt(vul, vbl);
1781   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1782   // CHECK-ASM: vchlgs
1783   idx = vec_all_lt(vbl, vul);
1784   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1785   // CHECK-ASM: vchlgs
1786   idx = vec_all_lt(vbl, vbl);
1787   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1788   // CHECK-ASM: vchlgs
1789   idx = vec_all_lt(vd, vd);
1790   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1791   // CHECK-ASM: vfchdbs
1792
1793   idx = vec_all_nge(vd, vd);
1794   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1795   // CHECK-ASM: vfchedbs
1796   idx = vec_all_ngt(vd, vd);
1797   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1798   // CHECK-ASM: vfchdbs
1799   idx = vec_all_nle(vd, vd);
1800   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1801   // CHECK-ASM: vfchedbs
1802   idx = vec_all_nlt(vd, vd);
1803   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1804   // CHECK-ASM: vfchdbs
1805
1806   idx = vec_all_nan(vd);
1807   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
1808   // CHECK-ASM: vftcidb
1809   idx = vec_all_numeric(vd);
1810   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
1811   // CHECK-ASM: vftcidb
1812
1813   idx = vec_any_eq(vsc, vsc);
1814   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1815   // CHECK-ASM: vceqbs
1816   idx = vec_any_eq(vsc, vbc);
1817   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1818   // CHECK-ASM: vceqbs
1819   idx = vec_any_eq(vbc, vsc);
1820   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1821   // CHECK-ASM: vceqbs
1822   idx = vec_any_eq(vuc, vuc);
1823   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1824   // CHECK-ASM: vceqbs
1825   idx = vec_any_eq(vuc, vbc);
1826   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1827   // CHECK-ASM: vceqbs
1828   idx = vec_any_eq(vbc, vuc);
1829   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1830   // CHECK-ASM: vceqbs
1831   idx = vec_any_eq(vbc, vbc);
1832   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1833   // CHECK-ASM: vceqbs
1834   idx = vec_any_eq(vss, vss);
1835   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1836   // CHECK-ASM: vceqhs
1837   idx = vec_any_eq(vss, vbs);
1838   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1839   // CHECK-ASM: vceqhs
1840   idx = vec_any_eq(vbs, vss);
1841   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1842   // CHECK-ASM: vceqhs
1843   idx = vec_any_eq(vus, vus);
1844   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1845   // CHECK-ASM: vceqhs
1846   idx = vec_any_eq(vus, vbs);
1847   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1848   // CHECK-ASM: vceqhs
1849   idx = vec_any_eq(vbs, vus);
1850   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1851   // CHECK-ASM: vceqhs
1852   idx = vec_any_eq(vbs, vbs);
1853   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1854   // CHECK-ASM: vceqhs
1855   idx = vec_any_eq(vsi, vsi);
1856   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1857   // CHECK-ASM: vceqfs
1858   idx = vec_any_eq(vsi, vbi);
1859   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1860   // CHECK-ASM: vceqfs
1861   idx = vec_any_eq(vbi, vsi);
1862   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1863   // CHECK-ASM: vceqfs
1864   idx = vec_any_eq(vui, vui);
1865   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1866   // CHECK-ASM: vceqfs
1867   idx = vec_any_eq(vui, vbi);
1868   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1869   // CHECK-ASM: vceqfs
1870   idx = vec_any_eq(vbi, vui);
1871   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1872   // CHECK-ASM: vceqfs
1873   idx = vec_any_eq(vbi, vbi);
1874   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1875   // CHECK-ASM: vceqfs
1876   idx = vec_any_eq(vsl, vsl);
1877   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1878   // CHECK-ASM: vceqgs
1879   idx = vec_any_eq(vsl, vbl);
1880   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1881   // CHECK-ASM: vceqgs
1882   idx = vec_any_eq(vbl, vsl);
1883   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1884   // CHECK-ASM: vceqgs
1885   idx = vec_any_eq(vul, vul);
1886   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1887   // CHECK-ASM: vceqgs
1888   idx = vec_any_eq(vul, vbl);
1889   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1890   // CHECK-ASM: vceqgs
1891   idx = vec_any_eq(vbl, vul);
1892   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1893   // CHECK-ASM: vceqgs
1894   idx = vec_any_eq(vbl, vbl);
1895   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1896   // CHECK-ASM: vceqgs
1897   idx = vec_any_eq(vd, vd);
1898   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1899   // CHECK-ASM: vfcedbs
1900
1901   idx = vec_any_ne(vsc, vsc);
1902   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1903   // CHECK-ASM: vceqbs
1904   idx = vec_any_ne(vsc, vbc);
1905   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1906   // CHECK-ASM: vceqbs
1907   idx = vec_any_ne(vbc, vsc);
1908   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1909   // CHECK-ASM: vceqbs
1910   idx = vec_any_ne(vuc, vuc);
1911   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1912   // CHECK-ASM: vceqbs
1913   idx = vec_any_ne(vuc, vbc);
1914   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1915   // CHECK-ASM: vceqbs
1916   idx = vec_any_ne(vbc, vuc);
1917   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1918   // CHECK-ASM: vceqbs
1919   idx = vec_any_ne(vbc, vbc);
1920   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1921   // CHECK-ASM: vceqbs
1922   idx = vec_any_ne(vss, vss);
1923   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1924   // CHECK-ASM: vceqhs
1925   idx = vec_any_ne(vss, vbs);
1926   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1927   // CHECK-ASM: vceqhs
1928   idx = vec_any_ne(vbs, vss);
1929   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1930   // CHECK-ASM: vceqhs
1931   idx = vec_any_ne(vus, vus);
1932   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1933   // CHECK-ASM: vceqhs
1934   idx = vec_any_ne(vus, vbs);
1935   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1936   // CHECK-ASM: vceqhs
1937   idx = vec_any_ne(vbs, vus);
1938   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1939   // CHECK-ASM: vceqhs
1940   idx = vec_any_ne(vbs, vbs);
1941   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1942   // CHECK-ASM: vceqhs
1943   idx = vec_any_ne(vsi, vsi);
1944   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1945   // CHECK-ASM: vceqfs
1946   idx = vec_any_ne(vsi, vbi);
1947   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1948   // CHECK-ASM: vceqfs
1949   idx = vec_any_ne(vbi, vsi);
1950   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1951   // CHECK-ASM: vceqfs
1952   idx = vec_any_ne(vui, vui);
1953   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1954   // CHECK-ASM: vceqfs
1955   idx = vec_any_ne(vui, vbi);
1956   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1957   // CHECK-ASM: vceqfs
1958   idx = vec_any_ne(vbi, vui);
1959   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1960   // CHECK-ASM: vceqfs
1961   idx = vec_any_ne(vbi, vbi);
1962   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1963   // CHECK-ASM: vceqfs
1964   idx = vec_any_ne(vsl, vsl);
1965   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1966   // CHECK-ASM: vceqgs
1967   idx = vec_any_ne(vsl, vbl);
1968   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1969   // CHECK-ASM: vceqgs
1970   idx = vec_any_ne(vbl, vsl);
1971   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1972   // CHECK-ASM: vceqgs
1973   idx = vec_any_ne(vul, vul);
1974   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1975   // CHECK-ASM: vceqgs
1976   idx = vec_any_ne(vul, vbl);
1977   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1978   // CHECK-ASM: vceqgs
1979   idx = vec_any_ne(vbl, vul);
1980   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1981   // CHECK-ASM: vceqgs
1982   idx = vec_any_ne(vbl, vbl);
1983   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1984   // CHECK-ASM: vceqgs
1985   idx = vec_any_ne(vd, vd);
1986   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1987   // CHECK-ASM: vfcedbs
1988
1989   idx = vec_any_ge(vsc, vsc);
1990   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1991   // CHECK-ASM: vchbs
1992   idx = vec_any_ge(vsc, vbc);
1993   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1994   // CHECK-ASM: vchbs
1995   idx = vec_any_ge(vbc, vsc);
1996   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1997   // CHECK-ASM: vchbs
1998   idx = vec_any_ge(vuc, vuc);
1999   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2000   // CHECK-ASM: vchlbs
2001   idx = vec_any_ge(vuc, vbc);
2002   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2003   // CHECK-ASM: vchlbs
2004   idx = vec_any_ge(vbc, vuc);
2005   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2006   // CHECK-ASM: vchlbs
2007   idx = vec_any_ge(vbc, vbc);
2008   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2009   // CHECK-ASM: vchlbs
2010   idx = vec_any_ge(vss, vss);
2011   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2012   // CHECK-ASM: vchhs
2013   idx = vec_any_ge(vss, vbs);
2014   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2015   // CHECK-ASM: vchhs
2016   idx = vec_any_ge(vbs, vss);
2017   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2018   // CHECK-ASM: vchhs
2019   idx = vec_any_ge(vus, vus);
2020   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2021   // CHECK-ASM: vchlhs
2022   idx = vec_any_ge(vus, vbs);
2023   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2024   // CHECK-ASM: vchlhs
2025   idx = vec_any_ge(vbs, vus);
2026   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2027   // CHECK-ASM: vchlhs
2028   idx = vec_any_ge(vbs, vbs);
2029   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2030   // CHECK-ASM: vchlhs
2031   idx = vec_any_ge(vsi, vsi);
2032   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2033   // CHECK-ASM: vchfs
2034   idx = vec_any_ge(vsi, vbi);
2035   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2036   // CHECK-ASM: vchfs
2037   idx = vec_any_ge(vbi, vsi);
2038   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2039   // CHECK-ASM: vchfs
2040   idx = vec_any_ge(vui, vui);
2041   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2042   // CHECK-ASM: vchlfs
2043   idx = vec_any_ge(vui, vbi);
2044   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2045   // CHECK-ASM: vchlfs
2046   idx = vec_any_ge(vbi, vui);
2047   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2048   // CHECK-ASM: vchlfs
2049   idx = vec_any_ge(vbi, vbi);
2050   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2051   // CHECK-ASM: vchlfs
2052   idx = vec_any_ge(vsl, vsl);
2053   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2054   // CHECK-ASM: vchgs
2055   idx = vec_any_ge(vsl, vbl);
2056   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2057   // CHECK-ASM: vchgs
2058   idx = vec_any_ge(vbl, vsl);
2059   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2060   // CHECK-ASM: vchgs
2061   idx = vec_any_ge(vul, vul);
2062   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2063   // CHECK-ASM: vchlgs
2064   idx = vec_any_ge(vul, vbl);
2065   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2066   // CHECK-ASM: vchlgs
2067   idx = vec_any_ge(vbl, vul);
2068   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2069   // CHECK-ASM: vchlgs
2070   idx = vec_any_ge(vbl, vbl);
2071   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2072   // CHECK-ASM: vchlgs
2073   idx = vec_any_ge(vd, vd);
2074   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2075   // CHECK-ASM: vfchedbs
2076
2077   idx = vec_any_gt(vsc, vsc);
2078   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2079   // CHECK-ASM: vchbs
2080   idx = vec_any_gt(vsc, vbc);
2081   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2082   // CHECK-ASM: vchbs
2083   idx = vec_any_gt(vbc, vsc);
2084   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2085   // CHECK-ASM: vchbs
2086   idx = vec_any_gt(vuc, vuc);
2087   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2088   // CHECK-ASM: vchlbs
2089   idx = vec_any_gt(vuc, vbc);
2090   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2091   // CHECK-ASM: vchlbs
2092   idx = vec_any_gt(vbc, vuc);
2093   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2094   // CHECK-ASM: vchlbs
2095   idx = vec_any_gt(vbc, vbc);
2096   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2097   // CHECK-ASM: vchlbs
2098   idx = vec_any_gt(vss, vss);
2099   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2100   // CHECK-ASM: vchhs
2101   idx = vec_any_gt(vss, vbs);
2102   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2103   // CHECK-ASM: vchhs
2104   idx = vec_any_gt(vbs, vss);
2105   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2106   // CHECK-ASM: vchhs
2107   idx = vec_any_gt(vus, vus);
2108   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2109   // CHECK-ASM: vchlhs
2110   idx = vec_any_gt(vus, vbs);
2111   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2112   // CHECK-ASM: vchlhs
2113   idx = vec_any_gt(vbs, vus);
2114   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2115   // CHECK-ASM: vchlhs
2116   idx = vec_any_gt(vbs, vbs);
2117   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2118   // CHECK-ASM: vchlhs
2119   idx = vec_any_gt(vsi, vsi);
2120   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2121   // CHECK-ASM: vchfs
2122   idx = vec_any_gt(vsi, vbi);
2123   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2124   // CHECK-ASM: vchfs
2125   idx = vec_any_gt(vbi, vsi);
2126   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2127   // CHECK-ASM: vchfs
2128   idx = vec_any_gt(vui, vui);
2129   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2130   // CHECK-ASM: vchlfs
2131   idx = vec_any_gt(vui, vbi);
2132   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2133   // CHECK-ASM: vchlfs
2134   idx = vec_any_gt(vbi, vui);
2135   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2136   // CHECK-ASM: vchlfs
2137   idx = vec_any_gt(vbi, vbi);
2138   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2139   // CHECK-ASM: vchlfs
2140   idx = vec_any_gt(vsl, vsl);
2141   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2142   // CHECK-ASM: vchgs
2143   idx = vec_any_gt(vsl, vbl);
2144   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2145   // CHECK-ASM: vchgs
2146   idx = vec_any_gt(vbl, vsl);
2147   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2148   // CHECK-ASM: vchgs
2149   idx = vec_any_gt(vul, vul);
2150   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2151   // CHECK-ASM: vchlgs
2152   idx = vec_any_gt(vul, vbl);
2153   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2154   // CHECK-ASM: vchlgs
2155   idx = vec_any_gt(vbl, vul);
2156   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2157   // CHECK-ASM: vchlgs
2158   idx = vec_any_gt(vbl, vbl);
2159   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2160   // CHECK-ASM: vchlgs
2161   idx = vec_any_gt(vd, vd);
2162   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2163   // CHECK-ASM: vfchdbs
2164
2165   idx = vec_any_le(vsc, vsc);
2166   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2167   // CHECK-ASM: vchbs
2168   idx = vec_any_le(vsc, vbc);
2169   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2170   // CHECK-ASM: vchbs
2171   idx = vec_any_le(vbc, vsc);
2172   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2173   // CHECK-ASM: vchbs
2174   idx = vec_any_le(vuc, vuc);
2175   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2176   // CHECK-ASM: vchlbs
2177   idx = vec_any_le(vuc, vbc);
2178   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2179   // CHECK-ASM: vchlbs
2180   idx = vec_any_le(vbc, vuc);
2181   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2182   // CHECK-ASM: vchlbs
2183   idx = vec_any_le(vbc, vbc);
2184   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2185   // CHECK-ASM: vchlbs
2186   idx = vec_any_le(vss, vss);
2187   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2188   // CHECK-ASM: vchhs
2189   idx = vec_any_le(vss, vbs);
2190   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2191   // CHECK-ASM: vchhs
2192   idx = vec_any_le(vbs, vss);
2193   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2194   // CHECK-ASM: vchhs
2195   idx = vec_any_le(vus, vus);
2196   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2197   // CHECK-ASM: vchlhs
2198   idx = vec_any_le(vus, vbs);
2199   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2200   // CHECK-ASM: vchlhs
2201   idx = vec_any_le(vbs, vus);
2202   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2203   // CHECK-ASM: vchlhs
2204   idx = vec_any_le(vbs, vbs);
2205   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2206   // CHECK-ASM: vchlhs
2207   idx = vec_any_le(vsi, vsi);
2208   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2209   // CHECK-ASM: vchfs
2210   idx = vec_any_le(vsi, vbi);
2211   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2212   // CHECK-ASM: vchfs
2213   idx = vec_any_le(vbi, vsi);
2214   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2215   // CHECK-ASM: vchfs
2216   idx = vec_any_le(vui, vui);
2217   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2218   // CHECK-ASM: vchlfs
2219   idx = vec_any_le(vui, vbi);
2220   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2221   // CHECK-ASM: vchlfs
2222   idx = vec_any_le(vbi, vui);
2223   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2224   // CHECK-ASM: vchlfs
2225   idx = vec_any_le(vbi, vbi);
2226   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2227   // CHECK-ASM: vchlfs
2228   idx = vec_any_le(vsl, vsl);
2229   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2230   // CHECK-ASM: vchgs
2231   idx = vec_any_le(vsl, vbl);
2232   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2233   // CHECK-ASM: vchgs
2234   idx = vec_any_le(vbl, vsl);
2235   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2236   // CHECK-ASM: vchgs
2237   idx = vec_any_le(vul, vul);
2238   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2239   // CHECK-ASM: vchlgs
2240   idx = vec_any_le(vul, vbl);
2241   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2242   // CHECK-ASM: vchlgs
2243   idx = vec_any_le(vbl, vul);
2244   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2245   // CHECK-ASM: vchlgs
2246   idx = vec_any_le(vbl, vbl);
2247   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2248   // CHECK-ASM: vchlgs
2249   idx = vec_any_le(vd, vd);
2250   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2251   // CHECK-ASM: vfchedbs
2252
2253   idx = vec_any_lt(vsc, vsc);
2254   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2255   // CHECK-ASM: vchbs
2256   idx = vec_any_lt(vsc, vbc);
2257   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2258   // CHECK-ASM: vchbs
2259   idx = vec_any_lt(vbc, vsc);
2260   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2261   // CHECK-ASM: vchbs
2262   idx = vec_any_lt(vuc, vuc);
2263   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2264   // CHECK-ASM: vchlbs
2265   idx = vec_any_lt(vuc, vbc);
2266   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2267   // CHECK-ASM: vchlbs
2268   idx = vec_any_lt(vbc, vuc);
2269   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2270   // CHECK-ASM: vchlbs
2271   idx = vec_any_lt(vbc, vbc);
2272   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2273   // CHECK-ASM: vchlbs
2274   idx = vec_any_lt(vss, vss);
2275   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2276   // CHECK-ASM: vchhs
2277   idx = vec_any_lt(vss, vbs);
2278   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2279   // CHECK-ASM: vchhs
2280   idx = vec_any_lt(vbs, vss);
2281   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2282   // CHECK-ASM: vchhs
2283   idx = vec_any_lt(vus, vus);
2284   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2285   // CHECK-ASM: vchlhs
2286   idx = vec_any_lt(vus, vbs);
2287   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2288   // CHECK-ASM: vchlhs
2289   idx = vec_any_lt(vbs, vus);
2290   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2291   // CHECK-ASM: vchlhs
2292   idx = vec_any_lt(vbs, vbs);
2293   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2294   // CHECK-ASM: vchlhs
2295   idx = vec_any_lt(vsi, vsi);
2296   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2297   // CHECK-ASM: vchfs
2298   idx = vec_any_lt(vsi, vbi);
2299   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2300   // CHECK-ASM: vchfs
2301   idx = vec_any_lt(vbi, vsi);
2302   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2303   // CHECK-ASM: vchfs
2304   idx = vec_any_lt(vui, vui);
2305   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2306   // CHECK-ASM: vchlfs
2307   idx = vec_any_lt(vui, vbi);
2308   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2309   // CHECK-ASM: vchlfs
2310   idx = vec_any_lt(vbi, vui);
2311   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2312   // CHECK-ASM: vchlfs
2313   idx = vec_any_lt(vbi, vbi);
2314   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2315   // CHECK-ASM: vchlfs
2316   idx = vec_any_lt(vsl, vsl);
2317   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2318   // CHECK-ASM: vchgs
2319   idx = vec_any_lt(vsl, vbl);
2320   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2321   // CHECK-ASM: vchgs
2322   idx = vec_any_lt(vbl, vsl);
2323   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2324   // CHECK-ASM: vchgs
2325   idx = vec_any_lt(vul, vul);
2326   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2327   // CHECK-ASM: vchlgs
2328   idx = vec_any_lt(vul, vbl);
2329   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2330   // CHECK-ASM: vchlgs
2331   idx = vec_any_lt(vbl, vul);
2332   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2333   // CHECK-ASM: vchlgs
2334   idx = vec_any_lt(vbl, vbl);
2335   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2336   // CHECK-ASM: vchlgs
2337   idx = vec_any_lt(vd, vd);
2338   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2339   // CHECK-ASM: vfchdbs
2340
2341   idx = vec_any_nge(vd, vd);
2342   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2343   // CHECK-ASM: vfchedbs
2344   idx = vec_any_ngt(vd, vd);
2345   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2346   // CHECK-ASM: vfchdbs
2347   idx = vec_any_nle(vd, vd);
2348   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2349   // CHECK-ASM: vfchedbs
2350   idx = vec_any_nlt(vd, vd);
2351   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2352   // CHECK-ASM: vfchdbs
2353
2354   idx = vec_any_nan(vd);
2355   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
2356   // CHECK-ASM: vftcidb
2357   idx = vec_any_numeric(vd);
2358   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
2359   // CHECK-ASM: vftcidb
2360 }
2361
2362 void test_integer(void) {
2363   // CHECK-ASM-LABEL: test_integer
2364
2365   vsc = vec_andc(vsc, vsc);
2366   // CHECK-ASM: vnc
2367   vsc = vec_andc(vsc, vbc);
2368   // CHECK-ASM: vnc
2369   vsc = vec_andc(vbc, vsc);
2370   // CHECK-ASM: vnc
2371   vuc = vec_andc(vuc, vuc);
2372   // CHECK-ASM: vnc
2373   vuc = vec_andc(vuc, vbc);
2374   // CHECK-ASM: vnc
2375   vuc = vec_andc(vbc, vuc);
2376   // CHECK-ASM: vnc
2377   vbc = vec_andc(vbc, vbc);
2378   // CHECK-ASM: vnc
2379   vss = vec_andc(vss, vss);
2380   // CHECK-ASM: vnc
2381   vss = vec_andc(vss, vbs);
2382   // CHECK-ASM: vnc
2383   vss = vec_andc(vbs, vss);
2384   // CHECK-ASM: vnc
2385   vus = vec_andc(vus, vus);
2386   // CHECK-ASM: vnc
2387   vus = vec_andc(vus, vbs);
2388   // CHECK-ASM: vnc
2389   vus = vec_andc(vbs, vus);
2390   // CHECK-ASM: vnc
2391   vbs = vec_andc(vbs, vbs);
2392   // CHECK-ASM: vnc
2393   vsi = vec_andc(vsi, vsi);
2394   // CHECK-ASM: vnc
2395   vsi = vec_andc(vsi, vbi);
2396   // CHECK-ASM: vnc
2397   vsi = vec_andc(vbi, vsi);
2398   // CHECK-ASM: vnc
2399   vui = vec_andc(vui, vui);
2400   // CHECK-ASM: vnc
2401   vui = vec_andc(vui, vbi);
2402   // CHECK-ASM: vnc
2403   vui = vec_andc(vbi, vui);
2404   // CHECK-ASM: vnc
2405   vbi = vec_andc(vbi, vbi);
2406   // CHECK-ASM: vnc
2407   vsl = vec_andc(vsl, vsl);
2408   // CHECK-ASM: vnc
2409   vsl = vec_andc(vsl, vbl);
2410   // CHECK-ASM: vnc
2411   vsl = vec_andc(vbl, vsl);
2412   // CHECK-ASM: vnc
2413   vul = vec_andc(vul, vul);
2414   // CHECK-ASM: vnc
2415   vul = vec_andc(vul, vbl);
2416   // CHECK-ASM: vnc
2417   vul = vec_andc(vbl, vul);
2418   // CHECK-ASM: vnc
2419   vbl = vec_andc(vbl, vbl);
2420   // CHECK-ASM: vnc
2421   vd = vec_andc(vd, vd);
2422   // CHECK-ASM: vnc
2423   vd = vec_andc(vd, vbl);
2424   // CHECK-ASM: vnc
2425   vd = vec_andc(vbl, vd);
2426   // CHECK-ASM: vnc
2427
2428   vsc = vec_nor(vsc, vsc);
2429   // CHECK-ASM: vno
2430   vsc = vec_nor(vsc, vbc);
2431   // CHECK-ASM: vno
2432   vsc = vec_nor(vbc, vsc);
2433   // CHECK-ASM: vno
2434   vuc = vec_nor(vuc, vuc);
2435   // CHECK-ASM: vno
2436   vuc = vec_nor(vuc, vbc);
2437   // CHECK-ASM: vno
2438   vuc = vec_nor(vbc, vuc);
2439   // CHECK-ASM: vno
2440   vbc = vec_nor(vbc, vbc);
2441   // CHECK-ASM: vno
2442   vss = vec_nor(vss, vss);
2443   // CHECK-ASM: vno
2444   vss = vec_nor(vss, vbs);
2445   // CHECK-ASM: vno
2446   vss = vec_nor(vbs, vss);
2447   // CHECK-ASM: vno
2448   vus = vec_nor(vus, vus);
2449   // CHECK-ASM: vno
2450   vus = vec_nor(vus, vbs);
2451   // CHECK-ASM: vno
2452   vus = vec_nor(vbs, vus);
2453   // CHECK-ASM: vno
2454   vbs = vec_nor(vbs, vbs);
2455   // CHECK-ASM: vno
2456   vsi = vec_nor(vsi, vsi);
2457   // CHECK-ASM: vno
2458   vsi = vec_nor(vsi, vbi);
2459   // CHECK-ASM: vno
2460   vsi = vec_nor(vbi, vsi);
2461   // CHECK-ASM: vno
2462   vui = vec_nor(vui, vui);
2463   // CHECK-ASM: vno
2464   vui = vec_nor(vui, vbi);
2465   // CHECK-ASM: vno
2466   vui = vec_nor(vbi, vui);
2467   // CHECK-ASM: vno
2468   vbi = vec_nor(vbi, vbi);
2469   // CHECK-ASM: vno
2470   vsl = vec_nor(vsl, vsl);
2471   // CHECK-ASM: vno
2472   vsl = vec_nor(vsl, vbl);
2473   // CHECK-ASM: vno
2474   vsl = vec_nor(vbl, vsl);
2475   // CHECK-ASM: vno
2476   vul = vec_nor(vul, vul);
2477   // CHECK-ASM: vno
2478   vul = vec_nor(vul, vbl);
2479   // CHECK-ASM: vno
2480   vul = vec_nor(vbl, vul);
2481   // CHECK-ASM: vno
2482   vbl = vec_nor(vbl, vbl);
2483   // CHECK-ASM: vno
2484   vd = vec_nor(vd, vd);
2485   // CHECK-ASM: vno
2486   vd = vec_nor(vd, vbl);
2487   // CHECK-ASM: vno
2488   vd = vec_nor(vbl, vd);
2489   // CHECK-ASM: vno
2490
2491   vuc = vec_cntlz(vsc);
2492   // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
2493   // CHECK-ASM: vclzb
2494   vuc = vec_cntlz(vuc);
2495   // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false)
2496   // CHECK-ASM: vclzb
2497   vus = vec_cntlz(vss);
2498   // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
2499   // CHECK-ASM: vclzh
2500   vus = vec_cntlz(vus);
2501   // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false)
2502   // CHECK-ASM: vclzh
2503   vui = vec_cntlz(vsi);
2504   // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
2505   // CHECK-ASM: vclzf
2506   vui = vec_cntlz(vui);
2507   // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false)
2508   // CHECK-ASM: vclzf
2509   vul = vec_cntlz(vsl);
2510   // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
2511   // CHECK-ASM: vclzg
2512   vul = vec_cntlz(vul);
2513   // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false)
2514   // CHECK-ASM: vclzg
2515
2516   vuc = vec_cnttz(vsc);
2517   // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
2518   // CHECK-ASM: vctzb
2519   vuc = vec_cnttz(vuc);
2520   // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false)
2521   // CHECK-ASM: vctzb
2522   vus = vec_cnttz(vss);
2523   // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
2524   // CHECK-ASM: vctzh
2525   vus = vec_cnttz(vus);
2526   // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false)
2527   // CHECK-ASM: vctzh
2528   vui = vec_cnttz(vsi);
2529   // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
2530   // CHECK-ASM: vctzf
2531   vui = vec_cnttz(vui);
2532   // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false)
2533   // CHECK-ASM: vctzf
2534   vul = vec_cnttz(vsl);
2535   // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
2536   // CHECK-ASM: vctzg
2537   vul = vec_cnttz(vul);
2538   // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false)
2539   // CHECK-ASM: vctzg
2540
2541   vuc = vec_popcnt(vsc);
2542   // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
2543   // CHECK-ASM: vpopct
2544   vuc = vec_popcnt(vuc);
2545   // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
2546   // CHECK-ASM: vpopct
2547   vus = vec_popcnt(vss);
2548   // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
2549   // (emulated)
2550   vus = vec_popcnt(vus);
2551   // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
2552   // (emulated)
2553   vui = vec_popcnt(vsi);
2554   // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
2555   // (emulated)
2556   vui = vec_popcnt(vui);
2557   // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
2558   // (emulated)
2559   vul = vec_popcnt(vsl);
2560   // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
2561   // (emulated)
2562   vul = vec_popcnt(vul);
2563   // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
2564   // (emulated)
2565
2566   vsc = vec_rl(vsc, vuc);
2567   // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2568   // CHECK-ASM: verllvb
2569   vuc = vec_rl(vuc, vuc);
2570   // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2571   // CHECK-ASM: verllvb
2572   vss = vec_rl(vss, vus);
2573   // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2574   // CHECK-ASM: verllvh
2575   vus = vec_rl(vus, vus);
2576   // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2577   // CHECK-ASM: verllvh
2578   vsi = vec_rl(vsi, vui);
2579   // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2580   // CHECK-ASM: verllvf
2581   vui = vec_rl(vui, vui);
2582   // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
2583   // CHECK-ASM: verllvf
2584   vsl = vec_rl(vsl, vul);
2585   // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2586   // CHECK-ASM: verllvg
2587   vul = vec_rl(vul, vul);
2588   // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
2589   // CHECK-ASM: verllvg
2590
2591   vsc = vec_rli(vsc, ul);
2592   // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
2593   // CHECK-ASM: verllb
2594   vuc = vec_rli(vuc, ul);
2595   // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}})
2596   // CHECK-ASM: verllb
2597   vss = vec_rli(vss, ul);
2598   // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
2599   // CHECK-ASM: verllh
2600   vus = vec_rli(vus, ul);
2601   // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}})
2602   // CHECK-ASM: verllh
2603   vsi = vec_rli(vsi, ul);
2604   // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
2605   // CHECK-ASM: verllf
2606   vui = vec_rli(vui, ul);
2607   // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}})
2608   // CHECK-ASM: verllf
2609   vsl = vec_rli(vsl, ul);
2610   // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
2611   // CHECK-ASM: verllg
2612   vul = vec_rli(vul, ul);
2613   // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}})
2614   // CHECK-ASM: verllg
2615
2616   vsc = vec_rl_mask(vsc, vuc, 0);
2617   // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2618   // CHECK-ASM: verimb
2619   vsc = vec_rl_mask(vsc, vuc, 255);
2620   // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
2621   // CHECK-ASM: verimb
2622   vuc = vec_rl_mask(vuc, vuc, 0);
2623   // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2624   // CHECK-ASM: verimb
2625   vuc = vec_rl_mask(vuc, vuc, 255);
2626   // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255)
2627   // CHECK-ASM: verimb
2628   vss = vec_rl_mask(vss, vus, 0);
2629   // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
2630   // CHECK-ASM: verimh
2631   vss = vec_rl_mask(vss, vus, 255);
2632   // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
2633   // CHECK-ASM: verimh
2634   vus = vec_rl_mask(vus, vus, 0);
2635   // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
2636   // CHECK-ASM: verimh
2637   vus = vec_rl_mask(vus, vus, 255);
2638   // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255)
2639   // CHECK-ASM: verimh
2640   vsi = vec_rl_mask(vsi, vui, 0);
2641   // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
2642   // CHECK-ASM: verimf
2643   vsi = vec_rl_mask(vsi, vui, 255);
2644   // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
2645   // CHECK-ASM: verimf
2646   vui = vec_rl_mask(vui, vui, 0);
2647   // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
2648   // CHECK-ASM: verimf
2649   vui = vec_rl_mask(vui, vui, 255);
2650   // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255)
2651   // CHECK-ASM: verimf
2652   vsl = vec_rl_mask(vsl, vul, 0);
2653   // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
2654   // CHECK-ASM: verimg
2655   vsl = vec_rl_mask(vsl, vul, 255);
2656   // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
2657   // CHECK-ASM: verimg
2658   vul = vec_rl_mask(vul, vul, 0);
2659   // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0)
2660   // CHECK-ASM: verimg
2661   vul = vec_rl_mask(vul, vul, 255);
2662   // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255)
2663   // CHECK-ASM: verimg
2664
2665   vsc = vec_sll(vsc, vuc);
2666   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2667   // CHECK-ASM: vsl
2668   vsc = vec_sll(vsc, vus);
2669   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2670   // CHECK-ASM: vsl
2671   vsc = vec_sll(vsc, vui);
2672   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2673   // CHECK-ASM: vsl
2674   vuc = vec_sll(vuc, vuc);
2675   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2676   // CHECK-ASM: vsl
2677   vuc = vec_sll(vuc, vus);
2678   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2679   // CHECK-ASM: vsl
2680   vuc = vec_sll(vuc, vui);
2681   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2682   // CHECK-ASM: vsl
2683   vbc = vec_sll(vbc, vuc);
2684   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2685   // CHECK-ASM: vsl
2686   vbc = vec_sll(vbc, vus);
2687   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2688   // CHECK-ASM: vsl
2689   vbc = vec_sll(vbc, vui);
2690   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2691   // CHECK-ASM: vsl
2692   vss = vec_sll(vss, vuc);
2693   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2694   // CHECK-ASM: vsl
2695   vss = vec_sll(vss, vus);
2696   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2697   // CHECK-ASM: vsl
2698   vss = vec_sll(vss, vui);
2699   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2700   // CHECK-ASM: vsl
2701   vus = vec_sll(vus, vuc);
2702   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2703   // CHECK-ASM: vsl
2704   vus = vec_sll(vus, vus);
2705   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2706   // CHECK-ASM: vsl
2707   vus = vec_sll(vus, vui);
2708   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2709   // CHECK-ASM: vsl
2710   vbs = vec_sll(vbs, vuc);
2711   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2712   // CHECK-ASM: vsl
2713   vbs = vec_sll(vbs, vus);
2714   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2715   // CHECK-ASM: vsl
2716   vbs = vec_sll(vbs, vui);
2717   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2718   // CHECK-ASM: vsl
2719   vsi = vec_sll(vsi, vuc);
2720   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2721   // CHECK-ASM: vsl
2722   vsi = vec_sll(vsi, vus);
2723   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2724   // CHECK-ASM: vsl
2725   vsi = vec_sll(vsi, vui);
2726   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2727   // CHECK-ASM: vsl
2728   vui = vec_sll(vui, vuc);
2729   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2730   // CHECK-ASM: vsl
2731   vui = vec_sll(vui, vus);
2732   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2733   // CHECK-ASM: vsl
2734   vui = vec_sll(vui, vui);
2735   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2736   // CHECK-ASM: vsl
2737   vbi = vec_sll(vbi, vuc);
2738   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2739   // CHECK-ASM: vsl
2740   vbi = vec_sll(vbi, vus);
2741   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2742   // CHECK-ASM: vsl
2743   vbi = vec_sll(vbi, vui);
2744   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2745   // CHECK-ASM: vsl
2746   vsl = vec_sll(vsl, vuc);
2747   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2748   // CHECK-ASM: vsl
2749   vsl = vec_sll(vsl, vus);
2750   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2751   // CHECK-ASM: vsl
2752   vsl = vec_sll(vsl, vui);
2753   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2754   // CHECK-ASM: vsl
2755   vul = vec_sll(vul, vuc);
2756   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2757   // CHECK-ASM: vsl
2758   vul = vec_sll(vul, vus);
2759   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2760   // CHECK-ASM: vsl
2761   vul = vec_sll(vul, vui);
2762   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2763   // CHECK-ASM: vsl
2764   vbl = vec_sll(vbl, vuc);
2765   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2766   // CHECK-ASM: vsl
2767   vbl = vec_sll(vbl, vus);
2768   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2769   // CHECK-ASM: vsl
2770   vbl = vec_sll(vbl, vui);
2771   // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2772   // CHECK-ASM: vsl
2773
2774   vsc = vec_slb(vsc, vsc);
2775   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2776   // CHECK-ASM: vslb
2777   vsc = vec_slb(vsc, vuc);
2778   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2779   // CHECK-ASM: vslb
2780   vuc = vec_slb(vuc, vsc);
2781   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2782   // CHECK-ASM: vslb
2783   vuc = vec_slb(vuc, vuc);
2784   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2785   // CHECK-ASM: vslb
2786   vss = vec_slb(vss, vss);
2787   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2788   // CHECK-ASM: vslb
2789   vss = vec_slb(vss, vus);
2790   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2791   // CHECK-ASM: vslb
2792   vus = vec_slb(vus, vss);
2793   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2794   // CHECK-ASM: vslb
2795   vus = vec_slb(vus, vus);
2796   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2797   // CHECK-ASM: vslb
2798   vsi = vec_slb(vsi, vsi);
2799   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2800   // CHECK-ASM: vslb
2801   vsi = vec_slb(vsi, vui);
2802   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2803   // CHECK-ASM: vslb
2804   vui = vec_slb(vui, vsi);
2805   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2806   // CHECK-ASM: vslb
2807   vui = vec_slb(vui, vui);
2808   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2809   // CHECK-ASM: vslb
2810   vsl = vec_slb(vsl, vsl);
2811   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2812   // CHECK-ASM: vslb
2813   vsl = vec_slb(vsl, vul);
2814   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2815   // CHECK-ASM: vslb
2816   vul = vec_slb(vul, vsl);
2817   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2818   // CHECK-ASM: vslb
2819   vul = vec_slb(vul, vul);
2820   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2821   // CHECK-ASM: vslb
2822   vd = vec_slb(vd, vsl);
2823   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2824   // CHECK-ASM: vslb
2825   vd = vec_slb(vd, vul);
2826   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2827   // CHECK-ASM: vslb
2828
2829   vsc = vec_sld(vsc, vsc, 0);
2830   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2831   // CHECK-ASM: vsldb
2832   vsc = vec_sld(vsc, vsc, 15);
2833   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2834   // CHECK-ASM: vsldb
2835   vuc = vec_sld(vuc, vuc, 0);
2836   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2837   // CHECK-ASM: vsldb
2838   vuc = vec_sld(vuc, vuc, 15);
2839   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2840   // CHECK-ASM: vsldb
2841   vbc = vec_sld(vbc, vbc, 0);
2842   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2843   // CHECK-ASM: vsldb
2844   vbc = vec_sld(vbc, vbc, 15);
2845   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2846   // CHECK-ASM: vsldb
2847   vss = vec_sld(vss, vss, 0);
2848   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2849   // CHECK-ASM: vsldb
2850   vss = vec_sld(vss, vss, 15);
2851   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2852   // CHECK-ASM: vsldb
2853   vus = vec_sld(vus, vus, 0);
2854   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2855   // CHECK-ASM: vsldb
2856   vus = vec_sld(vus, vus, 15);
2857   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2858   // CHECK-ASM: vsldb
2859   vbs = vec_sld(vbs, vbs, 0);
2860   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2861   // CHECK-ASM: vsldb
2862   vbs = vec_sld(vbs, vbs, 15);
2863   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2864   // CHECK-ASM: vsldb
2865   vsi = vec_sld(vsi, vsi, 0);
2866   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2867   // CHECK-ASM: vsldb
2868   vsi = vec_sld(vsi, vsi, 15);
2869   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2870   // CHECK-ASM: vsldb
2871   vui = vec_sld(vui, vui, 0);
2872   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2873   // CHECK-ASM: vsldb
2874   vui = vec_sld(vui, vui, 15);
2875   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2876   // CHECK-ASM: vsldb
2877   vbi = vec_sld(vbi, vbi, 0);
2878   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2879   // CHECK-ASM: vsldb
2880   vbi = vec_sld(vbi, vbi, 15);
2881   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2882   // CHECK-ASM: vsldb
2883   vsl = vec_sld(vsl, vsl, 0);
2884   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2885   // CHECK-ASM: vsldb
2886   vsl = vec_sld(vsl, vsl, 15);
2887   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2888   // CHECK-ASM: vsldb
2889   vul = vec_sld(vul, vul, 0);
2890   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2891   // CHECK-ASM: vsldb
2892   vul = vec_sld(vul, vul, 15);
2893   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2894   // CHECK-ASM: vsldb
2895   vbl = vec_sld(vbl, vbl, 0);
2896   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2897   // CHECK-ASM: vsldb
2898   vbl = vec_sld(vbl, vbl, 15);
2899   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2900   // CHECK-ASM: vsldb
2901   vd = vec_sld(vd, vd, 0);
2902   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2903   // CHECK-ASM: vsldb
2904   vd = vec_sld(vd, vd, 15);
2905   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
2906   // CHECK-ASM: vsldb
2907
2908   vsc = vec_sldw(vsc, vsc, 0);
2909   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2910   // CHECK-ASM: vsldb
2911   vsc = vec_sldw(vsc, vsc, 3);
2912   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2913   // CHECK-ASM: vsldb
2914   vuc = vec_sldw(vuc, vuc, 0);
2915   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2916   // CHECK-ASM: vsldb
2917   vuc = vec_sldw(vuc, vuc, 3);
2918   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2919   // CHECK-ASM: vsldb
2920   vss = vec_sldw(vss, vss, 0);
2921   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2922   // CHECK-ASM: vsldb
2923   vss = vec_sldw(vss, vss, 3);
2924   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2925   // CHECK-ASM: vsldb
2926   vus = vec_sldw(vus, vus, 0);
2927   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2928   // CHECK-ASM: vsldb
2929   vus = vec_sldw(vus, vus, 3);
2930   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2931   // CHECK-ASM: vsldb
2932   vsi = vec_sldw(vsi, vsi, 0);
2933   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2934   // CHECK-ASM: vsldb
2935   vsi = vec_sldw(vsi, vsi, 3);
2936   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2937   // CHECK-ASM: vsldb
2938   vui = vec_sldw(vui, vui, 0);
2939   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2940   // CHECK-ASM: vsldb
2941   vui = vec_sldw(vui, vui, 3);
2942   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2943   // CHECK-ASM: vsldb
2944   vsl = vec_sldw(vsl, vsl, 0);
2945   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2946   // CHECK-ASM: vsldb
2947   vsl = vec_sldw(vsl, vsl, 3);
2948   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2949   // CHECK-ASM: vsldb
2950   vul = vec_sldw(vul, vul, 0);
2951   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2952   // CHECK-ASM: vsldb
2953   vul = vec_sldw(vul, vul, 3);
2954   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2955   // CHECK-ASM: vsldb
2956   vd = vec_sldw(vd, vd, 0);
2957   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
2958   // CHECK-ASM: vsldb
2959   vd = vec_sldw(vd, vd, 3);
2960   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
2961   // CHECK-ASM: vsldb
2962
2963   vsc = vec_sral(vsc, vuc);
2964   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2965   // CHECK-ASM: vsra
2966   vsc = vec_sral(vsc, vus);
2967   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2968   // CHECK-ASM: vsra
2969   vsc = vec_sral(vsc, vui);
2970   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2971   // CHECK-ASM: vsra
2972   vuc = vec_sral(vuc, vuc);
2973   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2974   // CHECK-ASM: vsra
2975   vuc = vec_sral(vuc, vus);
2976   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2977   // CHECK-ASM: vsra
2978   vuc = vec_sral(vuc, vui);
2979   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2980   // CHECK-ASM: vsra
2981   vbc = vec_sral(vbc, vuc);
2982   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2983   // CHECK-ASM: vsra
2984   vbc = vec_sral(vbc, vus);
2985   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2986   // CHECK-ASM: vsra
2987   vbc = vec_sral(vbc, vui);
2988   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2989   // CHECK-ASM: vsra
2990   vss = vec_sral(vss, vuc);
2991   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2992   // CHECK-ASM: vsra
2993   vss = vec_sral(vss, vus);
2994   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2995   // CHECK-ASM: vsra
2996   vss = vec_sral(vss, vui);
2997   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
2998   // CHECK-ASM: vsra
2999   vus = vec_sral(vus, vuc);
3000   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3001   // CHECK-ASM: vsra
3002   vus = vec_sral(vus, vus);
3003   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3004   // CHECK-ASM: vsra
3005   vus = vec_sral(vus, vui);
3006   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3007   // CHECK-ASM: vsra
3008   vbs = vec_sral(vbs, vuc);
3009   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3010   // CHECK-ASM: vsra
3011   vbs = vec_sral(vbs, vus);
3012   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3013   // CHECK-ASM: vsra
3014   vbs = vec_sral(vbs, vui);
3015   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3016   // CHECK-ASM: vsra
3017   vsi = vec_sral(vsi, vuc);
3018   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3019   // CHECK-ASM: vsra
3020   vsi = vec_sral(vsi, vus);
3021   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3022   // CHECK-ASM: vsra
3023   vsi = vec_sral(vsi, vui);
3024   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3025   // CHECK-ASM: vsra
3026   vui = vec_sral(vui, vuc);
3027   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3028   // CHECK-ASM: vsra
3029   vui = vec_sral(vui, vus);
3030   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3031   // CHECK-ASM: vsra
3032   vui = vec_sral(vui, vui);
3033   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3034   // CHECK-ASM: vsra
3035   vbi = vec_sral(vbi, vuc);
3036   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3037   // CHECK-ASM: vsra
3038   vbi = vec_sral(vbi, vus);
3039   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3040   // CHECK-ASM: vsra
3041   vbi = vec_sral(vbi, vui);
3042   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3043   // CHECK-ASM: vsra
3044   vsl = vec_sral(vsl, vuc);
3045   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3046   // CHECK-ASM: vsra
3047   vsl = vec_sral(vsl, vus);
3048   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3049   // CHECK-ASM: vsra
3050   vsl = vec_sral(vsl, vui);
3051   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3052   // CHECK-ASM: vsra
3053   vul = vec_sral(vul, vuc);
3054   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3055   // CHECK-ASM: vsra
3056   vul = vec_sral(vul, vus);
3057   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3058   // CHECK-ASM: vsra
3059   vul = vec_sral(vul, vui);
3060   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3061   // CHECK-ASM: vsra
3062   vbl = vec_sral(vbl, vuc);
3063   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3064   // CHECK-ASM: vsra
3065   vbl = vec_sral(vbl, vus);
3066   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3067   // CHECK-ASM: vsra
3068   vbl = vec_sral(vbl, vui);
3069   // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3070   // CHECK-ASM: vsra
3071
3072   vsc = vec_srab(vsc, vsc);
3073   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3074   // CHECK-ASM: vsrab
3075   vsc = vec_srab(vsc, vuc);
3076   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3077   // CHECK-ASM: vsrab
3078   vuc = vec_srab(vuc, vsc);
3079   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3080   // CHECK-ASM: vsrab
3081   vuc = vec_srab(vuc, vuc);
3082   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3083   // CHECK-ASM: vsrab
3084   vss = vec_srab(vss, vss);
3085   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3086   // CHECK-ASM: vsrab
3087   vss = vec_srab(vss, vus);
3088   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3089   // CHECK-ASM: vsrab
3090   vus = vec_srab(vus, vss);
3091   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3092   // CHECK-ASM: vsrab
3093   vus = vec_srab(vus, vus);
3094   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3095   // CHECK-ASM: vsrab
3096   vsi = vec_srab(vsi, vsi);
3097   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3098   // CHECK-ASM: vsrab
3099   vsi = vec_srab(vsi, vui);
3100   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3101   // CHECK-ASM: vsrab
3102   vui = vec_srab(vui, vsi);
3103   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3104   // CHECK-ASM: vsrab
3105   vui = vec_srab(vui, vui);
3106   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3107   // CHECK-ASM: vsrab
3108   vsl = vec_srab(vsl, vsl);
3109   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3110   // CHECK-ASM: vsrab
3111   vsl = vec_srab(vsl, vul);
3112   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3113   // CHECK-ASM: vsrab
3114   vul = vec_srab(vul, vsl);
3115   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3116   // CHECK-ASM: vsrab
3117   vul = vec_srab(vul, vul);
3118   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3119   // CHECK-ASM: vsrab
3120   vd = vec_srab(vd, vsl);
3121   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3122   // CHECK-ASM: vsrab
3123   vd = vec_srab(vd, vul);
3124   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3125   // CHECK-ASM: vsrab
3126
3127   vsc = vec_srl(vsc, vuc);
3128   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3129   // CHECK-ASM: vsrl
3130   vsc = vec_srl(vsc, vus);
3131   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3132   // CHECK-ASM: vsrl
3133   vsc = vec_srl(vsc, vui);
3134   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3135   // CHECK-ASM: vsrl
3136   vuc = vec_srl(vuc, vuc);
3137   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3138   // CHECK-ASM: vsrl
3139   vuc = vec_srl(vuc, vus);
3140   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3141   // CHECK-ASM: vsrl
3142   vuc = vec_srl(vuc, vui);
3143   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3144   // CHECK-ASM: vsrl
3145   vbc = vec_srl(vbc, vuc);
3146   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3147   // CHECK-ASM: vsrl
3148   vbc = vec_srl(vbc, vus);
3149   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3150   // CHECK-ASM: vsrl
3151   vbc = vec_srl(vbc, vui);
3152   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3153   // CHECK-ASM: vsrl
3154   vss = vec_srl(vss, vuc);
3155   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3156   // CHECK-ASM: vsrl
3157   vss = vec_srl(vss, vus);
3158   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3159   // CHECK-ASM: vsrl
3160   vss = vec_srl(vss, vui);
3161   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3162   // CHECK-ASM: vsrl
3163   vus = vec_srl(vus, vuc);
3164   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3165   // CHECK-ASM: vsrl
3166   vus = vec_srl(vus, vus);
3167   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3168   // CHECK-ASM: vsrl
3169   vus = vec_srl(vus, vui);
3170   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3171   // CHECK-ASM: vsrl
3172   vbs = vec_srl(vbs, vuc);
3173   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3174   // CHECK-ASM: vsrl
3175   vbs = vec_srl(vbs, vus);
3176   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3177   // CHECK-ASM: vsrl
3178   vbs = vec_srl(vbs, vui);
3179   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3180   // CHECK-ASM: vsrl
3181   vsi = vec_srl(vsi, vuc);
3182   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3183   // CHECK-ASM: vsrl
3184   vsi = vec_srl(vsi, vus);
3185   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3186   // CHECK-ASM: vsrl
3187   vsi = vec_srl(vsi, vui);
3188   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3189   // CHECK-ASM: vsrl
3190   vui = vec_srl(vui, vuc);
3191   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3192   // CHECK-ASM: vsrl
3193   vui = vec_srl(vui, vus);
3194   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3195   // CHECK-ASM: vsrl
3196   vui = vec_srl(vui, vui);
3197   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3198   // CHECK-ASM: vsrl
3199   vbi = vec_srl(vbi, vuc);
3200   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3201   // CHECK-ASM: vsrl
3202   vbi = vec_srl(vbi, vus);
3203   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3204   // CHECK-ASM: vsrl
3205   vbi = vec_srl(vbi, vui);
3206   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3207   // CHECK-ASM: vsrl
3208   vsl = vec_srl(vsl, vuc);
3209   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3210   // CHECK-ASM: vsrl
3211   vsl = vec_srl(vsl, vus);
3212   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3213   // CHECK-ASM: vsrl
3214   vsl = vec_srl(vsl, vui);
3215   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3216   // CHECK-ASM: vsrl
3217   vul = vec_srl(vul, vuc);
3218   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3219   // CHECK-ASM: vsrl
3220   vul = vec_srl(vul, vus);
3221   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3222   // CHECK-ASM: vsrl
3223   vul = vec_srl(vul, vui);
3224   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3225   // CHECK-ASM: vsrl
3226   vbl = vec_srl(vbl, vuc);
3227   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3228   // CHECK-ASM: vsrl
3229   vbl = vec_srl(vbl, vus);
3230   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3231   // CHECK-ASM: vsrl
3232   vbl = vec_srl(vbl, vui);
3233   // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3234   // CHECK-ASM: vsrl
3235
3236   vsc = vec_srb(vsc, vsc);
3237   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3238   // CHECK-ASM: vsrlb
3239   vsc = vec_srb(vsc, vuc);
3240   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3241   // CHECK-ASM: vsrlb
3242   vuc = vec_srb(vuc, vsc);
3243   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3244   // CHECK-ASM: vsrlb
3245   vuc = vec_srb(vuc, vuc);
3246   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3247   // CHECK-ASM: vsrlb
3248   vss = vec_srb(vss, vss);
3249   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3250   // CHECK-ASM: vsrlb
3251   vss = vec_srb(vss, vus);
3252   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3253   // CHECK-ASM: vsrlb
3254   vus = vec_srb(vus, vss);
3255   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3256   // CHECK-ASM: vsrlb
3257   vus = vec_srb(vus, vus);
3258   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3259   // CHECK-ASM: vsrlb
3260   vsi = vec_srb(vsi, vsi);
3261   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3262   // CHECK-ASM: vsrlb
3263   vsi = vec_srb(vsi, vui);
3264   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3265   // CHECK-ASM: vsrlb
3266   vui = vec_srb(vui, vsi);
3267   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3268   // CHECK-ASM: vsrlb
3269   vui = vec_srb(vui, vui);
3270   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3271   // CHECK-ASM: vsrlb
3272   vsl = vec_srb(vsl, vsl);
3273   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3274   // CHECK-ASM: vsrlb
3275   vsl = vec_srb(vsl, vul);
3276   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3277   // CHECK-ASM: vsrlb
3278   vul = vec_srb(vul, vsl);
3279   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3280   // CHECK-ASM: vsrlb
3281   vul = vec_srb(vul, vul);
3282   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3283   // CHECK-ASM: vsrlb
3284   vd = vec_srb(vd, vsl);
3285   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3286   // CHECK-ASM: vsrlb
3287   vd = vec_srb(vd, vul);
3288   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3289   // CHECK-ASM: vsrlb
3290
3291   vsc = vec_abs(vsc);
3292   // CHECK-ASM: vlcb
3293   vss = vec_abs(vss);
3294   // CHECK-ASM: vlch
3295   vsi = vec_abs(vsi);
3296   // CHECK-ASM: vlcf
3297   vsl = vec_abs(vsl);
3298   // CHECK-ASM: vlcg
3299
3300   vsc = vec_max(vsc, vsc);
3301   // CHECK-ASM: vmxb
3302   vsc = vec_max(vsc, vbc);
3303   // CHECK-ASM: vmxb
3304   vsc = vec_max(vbc, vsc);
3305   // CHECK-ASM: vmxb
3306   vuc = vec_max(vuc, vuc);
3307   // CHECK-ASM: vmxlb
3308   vuc = vec_max(vuc, vbc);
3309   // CHECK-ASM: vmxlb
3310   vuc = vec_max(vbc, vuc);
3311   // CHECK-ASM: vmxlb
3312   vss = vec_max(vss, vss);
3313   // CHECK-ASM: vmxh
3314   vss = vec_max(vss, vbs);
3315   // CHECK-ASM: vmxh
3316   vss = vec_max(vbs, vss);
3317   // CHECK-ASM: vmxh
3318   vus = vec_max(vus, vus);
3319   // CHECK-ASM: vmxlh
3320   vus = vec_max(vus, vbs);
3321   // CHECK-ASM: vmxlh
3322   vus = vec_max(vbs, vus);
3323   // CHECK-ASM: vmxlh
3324   vsi = vec_max(vsi, vsi);
3325   // CHECK-ASM: vmxf
3326   vsi = vec_max(vsi, vbi);
3327   // CHECK-ASM: vmxf
3328   vsi = vec_max(vbi, vsi);
3329   // CHECK-ASM: vmxf
3330   vui = vec_max(vui, vui);
3331   // CHECK-ASM: vmxlf
3332   vui = vec_max(vui, vbi);
3333   // CHECK-ASM: vmxlf
3334   vui = vec_max(vbi, vui);
3335   // CHECK-ASM: vmxlf
3336   vsl = vec_max(vsl, vsl);
3337   // CHECK-ASM: vmxg
3338   vsl = vec_max(vsl, vbl);
3339   // CHECK-ASM: vmxg
3340   vsl = vec_max(vbl, vsl);
3341   // CHECK-ASM: vmxg
3342   vul = vec_max(vul, vul);
3343   // CHECK-ASM: vmxlg
3344   vul = vec_max(vul, vbl);
3345   // CHECK-ASM: vmxlg
3346   vul = vec_max(vbl, vul);
3347   // CHECK-ASM: vmxlg
3348   vd = vec_max(vd, vd);
3349   // (emulated)
3350
3351   vsc = vec_min(vsc, vsc);
3352   // CHECK-ASM: vmnb
3353   vsc = vec_min(vsc, vbc);
3354   // CHECK-ASM: vmnb
3355   vsc = vec_min(vbc, vsc);
3356   // CHECK-ASM: vmnb
3357   vuc = vec_min(vuc, vuc);
3358   // CHECK-ASM: vmnlb
3359   vuc = vec_min(vuc, vbc);
3360   // CHECK-ASM: vmnlb
3361   vuc = vec_min(vbc, vuc);
3362   // CHECK-ASM: vmnlb
3363   vss = vec_min(vss, vss);
3364   // CHECK-ASM: vmnh
3365   vss = vec_min(vss, vbs);
3366   // CHECK-ASM: vmnh
3367   vss = vec_min(vbs, vss);
3368   // CHECK-ASM: vmnh
3369   vus = vec_min(vus, vus);
3370   // CHECK-ASM: vmnlh
3371   vus = vec_min(vus, vbs);
3372   // CHECK-ASM: vmnlh
3373   vus = vec_min(vbs, vus);
3374   // CHECK-ASM: vmnlh
3375   vsi = vec_min(vsi, vsi);
3376   // CHECK-ASM: vmnf
3377   vsi = vec_min(vsi, vbi);
3378   // CHECK-ASM: vmnf
3379   vsi = vec_min(vbi, vsi);
3380   // CHECK-ASM: vmnf
3381   vui = vec_min(vui, vui);
3382   // CHECK-ASM: vmnlf
3383   vui = vec_min(vui, vbi);
3384   // CHECK-ASM: vmnlf
3385   vui = vec_min(vbi, vui);
3386   // CHECK-ASM: vmnlf
3387   vsl = vec_min(vsl, vsl);
3388   // CHECK-ASM: vmng
3389   vsl = vec_min(vsl, vbl);
3390   // CHECK-ASM: vmng
3391   vsl = vec_min(vbl, vsl);
3392   // CHECK-ASM: vmng
3393   vul = vec_min(vul, vul);
3394   // CHECK-ASM: vmnlg
3395   vul = vec_min(vul, vbl);
3396   // CHECK-ASM: vmnlg
3397   vul = vec_min(vbl, vul);
3398   // CHECK-ASM: vmnlg
3399   vd = vec_min(vd, vd);
3400   // (emulated)
3401
3402   vuc = vec_addc(vuc, vuc);
3403   // CHECK: call <16 x i8> @llvm.s390.vaccb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3404   // CHECK-ASM: vaccb
3405   vus = vec_addc(vus, vus);
3406   // CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3407   // CHECK-ASM: vacch
3408   vui = vec_addc(vui, vui);
3409   // CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3410   // CHECK-ASM: vaccf
3411   vul = vec_addc(vul, vul);
3412   // CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3413   // CHECK-ASM: vaccg
3414
3415   vuc = vec_add_u128(vuc, vuc);
3416   // CHECK: call <16 x i8> @llvm.s390.vaq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3417   // CHECK-ASM: vaq
3418   vuc = vec_addc_u128(vuc, vuc);
3419   // CHECK: call <16 x i8> @llvm.s390.vaccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3420   // CHECK-ASM: vaccq
3421   vuc = vec_adde_u128(vuc, vuc, vuc);
3422   // CHECK: call <16 x i8> @llvm.s390.vacq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3423   // CHECK-ASM: vacq
3424   vuc = vec_addec_u128(vuc, vuc, vuc);
3425   // CHECK: call <16 x i8> @llvm.s390.vacccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3426   // CHECK-ASM: vacccq
3427
3428   vsc = vec_avg(vsc, vsc);
3429   // CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3430   // CHECK-ASM: vavgb
3431   vuc = vec_avg(vuc, vuc);
3432   // CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3433   // CHECK-ASM: vavglb
3434   vss = vec_avg(vss, vss);
3435   // CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3436   // CHECK-ASM: vavgh
3437   vus = vec_avg(vus, vus);
3438   // CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3439   // CHECK-ASM: vavglh
3440   vsi = vec_avg(vsi, vsi);
3441   // CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3442   // CHECK-ASM: vavgf
3443   vui = vec_avg(vui, vui);
3444   // CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3445   // CHECK-ASM: vavglf
3446   vsl = vec_avg(vsl, vsl);
3447   // CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3448   // CHECK-ASM: vavgg
3449   vul = vec_avg(vul, vul);
3450   // CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3451   // CHECK-ASM: vavglg
3452
3453   vui = vec_checksum(vui, vui);
3454   // CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3455   // CHECK-ASM: vcksm
3456
3457   vus = vec_gfmsum(vuc, vuc);
3458   // CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3459   // CHECK-ASM: vgfmb
3460   vui = vec_gfmsum(vus, vus);
3461   // CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3462   // CHECK-ASM: vgfmh
3463   vul = vec_gfmsum(vui, vui);
3464   // CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3465   // CHECK-ASM: vgfmf
3466   vuc = vec_gfmsum_128(vul, vul);
3467   // CHECK: call <16 x i8> @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3468   // CHECK-ASM: vgfmg
3469
3470   vus = vec_gfmsum_accum(vuc, vuc, vus);
3471   // CHECK: call <8 x i16> @llvm.s390.vgfmab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3472   // CHECK-ASM: vgfmab
3473   vui = vec_gfmsum_accum(vus, vus, vui);
3474   // CHECK: call <4 x i32> @llvm.s390.vgfmah(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3475   // CHECK-ASM: vgfmah
3476   vul = vec_gfmsum_accum(vui, vui, vul);
3477   // CHECK: call <2 x i64> @llvm.s390.vgfmaf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3478   // CHECK-ASM: vgfmaf
3479   vuc = vec_gfmsum_accum_128(vul, vul, vuc);
3480   // CHECK: call <16 x i8> @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}})
3481   // CHECK-ASM: vgfmag
3482
3483   vsc = vec_mladd(vsc, vsc, vsc);
3484   // CHECK-ASM: vmalb
3485   vsc = vec_mladd(vuc, vsc, vsc);
3486   // CHECK-ASM: vmalb
3487   vsc = vec_mladd(vsc, vuc, vuc);
3488   // CHECK-ASM: vmalb
3489   vuc = vec_mladd(vuc, vuc, vuc);
3490   // CHECK-ASM: vmalb
3491   vss = vec_mladd(vss, vss, vss);
3492   // CHECK-ASM: vmalhw
3493   vss = vec_mladd(vus, vss, vss);
3494   // CHECK-ASM: vmalhw
3495   vss = vec_mladd(vss, vus, vus);
3496   // CHECK-ASM: vmalhw
3497   vus = vec_mladd(vus, vus, vus);
3498   // CHECK-ASM: vmalhw
3499   vsi = vec_mladd(vsi, vsi, vsi);
3500   // CHECK-ASM: vmalf
3501   vsi = vec_mladd(vui, vsi, vsi);
3502   // CHECK-ASM: vmalf
3503   vsi = vec_mladd(vsi, vui, vui);
3504   // CHECK-ASM: vmalf
3505   vui = vec_mladd(vui, vui, vui);
3506   // CHECK-ASM: vmalf
3507
3508   vsc = vec_mhadd(vsc, vsc, vsc);
3509   // CHECK: call <16 x i8> @llvm.s390.vmahb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3510   // CHECK-ASM: vmahb
3511   vuc = vec_mhadd(vuc, vuc, vuc);
3512   // CHECK: call <16 x i8> @llvm.s390.vmalhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3513   // CHECK-ASM: vmalhb
3514   vss = vec_mhadd(vss, vss, vss);
3515   // CHECK: call <8 x i16> @llvm.s390.vmahh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3516   // CHECK-ASM: vmahh
3517   vus = vec_mhadd(vus, vus, vus);
3518   // CHECK: call <8 x i16> @llvm.s390.vmalhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3519   // CHECK-ASM: vmalhh
3520   vsi = vec_mhadd(vsi, vsi, vsi);
3521   // CHECK: call <4 x i32> @llvm.s390.vmahf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3522   // CHECK-ASM: vmahf
3523   vui = vec_mhadd(vui, vui, vui);
3524   // CHECK: call <4 x i32> @llvm.s390.vmalhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3525   // CHECK-ASM: vmalhf
3526
3527   vss = vec_meadd(vsc, vsc, vss);
3528   // CHECK: call <8 x i16> @llvm.s390.vmaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3529   // CHECK-ASM: vmaeb
3530   vus = vec_meadd(vuc, vuc, vus);
3531   // CHECK: call <8 x i16> @llvm.s390.vmaleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3532   // CHECK-ASM: vmaleb
3533   vsi = vec_meadd(vss, vss, vsi);
3534   // CHECK: call <4 x i32> @llvm.s390.vmaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3535   // CHECK-ASM: vmaeh
3536   vui = vec_meadd(vus, vus, vui);
3537   // CHECK: call <4 x i32> @llvm.s390.vmaleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3538   // CHECK-ASM: vmaleh
3539   vsl = vec_meadd(vsi, vsi, vsl);
3540   // CHECK: call <2 x i64> @llvm.s390.vmaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3541   // CHECK-ASM: vmaef
3542   vul = vec_meadd(vui, vui, vul);
3543   // CHECK: call <2 x i64> @llvm.s390.vmalef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3544   // CHECK-ASM: vmalef
3545
3546   vss = vec_moadd(vsc, vsc, vss);
3547   // CHECK: call <8 x i16> @llvm.s390.vmaob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3548   // CHECK-ASM: vmaob
3549   vus = vec_moadd(vuc, vuc, vus);
3550   // CHECK: call <8 x i16> @llvm.s390.vmalob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}})
3551   // CHECK-ASM: vmalob
3552   vsi = vec_moadd(vss, vss, vsi);
3553   // CHECK: call <4 x i32> @llvm.s390.vmaoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3554   // CHECK-ASM: vmaoh
3555   vui = vec_moadd(vus, vus, vui);
3556   // CHECK: call <4 x i32> @llvm.s390.vmaloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}})
3557   // CHECK-ASM: vmaloh
3558   vsl = vec_moadd(vsi, vsi, vsl);
3559   // CHECK: call <2 x i64> @llvm.s390.vmaof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3560   // CHECK-ASM: vmaof
3561   vul = vec_moadd(vui, vui, vul);
3562   // CHECK: call <2 x i64> @llvm.s390.vmalof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}})
3563   // CHECK-ASM: vmalof
3564
3565   vsc = vec_mulh(vsc, vsc);
3566   // CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3567   // CHECK-ASM: vmhb
3568   vuc = vec_mulh(vuc, vuc);
3569   // CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3570   // CHECK-ASM: vmlhb
3571   vss = vec_mulh(vss, vss);
3572   // CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3573   // CHECK-ASM: vmhh
3574   vus = vec_mulh(vus, vus);
3575   // CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3576   // CHECK-ASM: vmlhh
3577   vsi = vec_mulh(vsi, vsi);
3578   // CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3579   // CHECK-ASM: vmhf
3580   vui = vec_mulh(vui, vui);
3581   // CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3582   // CHECK-ASM: vmlhf
3583
3584   vss = vec_mule(vsc, vsc);
3585   // CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3586   // CHECK-ASM: vmeb
3587   vus = vec_mule(vuc, vuc);
3588   // CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3589   // CHECK-ASM: vmleb
3590   vsi = vec_mule(vss, vss);
3591   // CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3592   // CHECK-ASM: vmeh
3593   vui = vec_mule(vus, vus);
3594   // CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3595   // CHECK-ASM: vmleh
3596   vsl = vec_mule(vsi, vsi);
3597   // CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3598   // CHECK-ASM: vmef
3599   vul = vec_mule(vui, vui);
3600   // CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3601   // CHECK-ASM: vmlef
3602
3603   vss = vec_mulo(vsc, vsc);
3604   // CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3605   // CHECK-ASM: vmob
3606   vus = vec_mulo(vuc, vuc);
3607   // CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3608   // CHECK-ASM: vmlob
3609   vsi = vec_mulo(vss, vss);
3610   // CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3611   // CHECK-ASM: vmoh
3612   vui = vec_mulo(vus, vus);
3613   // CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3614   // CHECK-ASM: vmloh
3615   vsl = vec_mulo(vsi, vsi);
3616   // CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3617   // CHECK-ASM: vmof
3618   vul = vec_mulo(vui, vui);
3619   // CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3620   // CHECK-ASM: vmlof
3621
3622   vuc = vec_subc(vuc, vuc);
3623   // CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3624   // CHECK-ASM: vscbib
3625   vus = vec_subc(vus, vus);
3626   // CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3627   // CHECK-ASM: vscbih
3628   vui = vec_subc(vui, vui);
3629   // CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3630   // CHECK-ASM: vscbif
3631   vul = vec_subc(vul, vul);
3632   // CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3633   // CHECK-ASM: vscbig
3634
3635   vuc = vec_sub_u128(vuc, vuc);
3636   // CHECK: call <16 x i8> @llvm.s390.vsq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3637   // CHECK-ASM: vsq
3638   vuc = vec_subc_u128(vuc, vuc);
3639   // CHECK: call <16 x i8> @llvm.s390.vscbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3640   // CHECK-ASM: vscbiq
3641   vuc = vec_sube_u128(vuc, vuc, vuc);
3642   // CHECK: call <16 x i8> @llvm.s390.vsbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3643   // CHECK-ASM: vsbiq
3644   vuc = vec_subec_u128(vuc, vuc, vuc);
3645   // CHECK: call <16 x i8> @llvm.s390.vsbcbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3646   // CHECK-ASM: vsbcbiq
3647
3648   vui = vec_sum4(vuc, vuc);
3649   // CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3650   // CHECK-ASM: vsumb
3651   vui = vec_sum4(vus, vus);
3652   // CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3653   // CHECK-ASM: vsumh
3654   vul = vec_sum2(vus, vus);
3655   // CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3656   // CHECK-ASM: vsumgh
3657   vul = vec_sum2(vui, vui);
3658   // CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3659   // CHECK-ASM: vsumgf
3660   vuc = vec_sum_u128(vui, vui);
3661   // CHECK: call <16 x i8> @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3662   // CHECK-ASM: vsumqf
3663   vuc = vec_sum_u128(vul, vul);
3664   // CHECK: call <16 x i8> @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
3665   // CHECK-ASM: vsumqg
3666
3667   idx = vec_test_mask(vsc, vuc);
3668   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3669   // CHECK-ASM: vtm
3670   idx = vec_test_mask(vuc, vuc);
3671   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3672   // CHECK-ASM: vtm
3673   idx = vec_test_mask(vss, vus);
3674   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3675   // CHECK-ASM: vtm
3676   idx = vec_test_mask(vus, vus);
3677   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3678   // CHECK-ASM: vtm
3679   idx = vec_test_mask(vsi, vui);
3680   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3681   // CHECK-ASM: vtm
3682   idx = vec_test_mask(vui, vui);
3683   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3684   // CHECK-ASM: vtm
3685   idx = vec_test_mask(vsl, vul);
3686   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3687   // CHECK-ASM: vtm
3688   idx = vec_test_mask(vul, vul);
3689   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3690   // CHECK-ASM: vtm
3691   idx = vec_test_mask(vd, vul);
3692   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3693   // CHECK-ASM: vtm
3694 }
3695
3696 void test_string(void) {
3697   // CHECK-ASM-LABEL: test_string
3698
3699   vsc = vec_cp_until_zero(vsc);
3700   // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3701   // CHECK-ASM: vistrb
3702   vuc = vec_cp_until_zero(vuc);
3703   // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3704   // CHECK-ASM: vistrb
3705   vbc = vec_cp_until_zero(vbc);
3706   // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})
3707   // CHECK-ASM: vistrb
3708   vss = vec_cp_until_zero(vss);
3709   // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3710   // CHECK-ASM: vistrh
3711   vus = vec_cp_until_zero(vus);
3712   // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3713   // CHECK-ASM: vistrh
3714   vbs = vec_cp_until_zero(vbs);
3715   // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})
3716   // CHECK-ASM: vistrh
3717   vsi = vec_cp_until_zero(vsi);
3718   // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3719   // CHECK-ASM: vistrf
3720   vui = vec_cp_until_zero(vui);
3721   // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3722   // CHECK-ASM: vistrf
3723   vbi = vec_cp_until_zero(vbi);
3724   // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})
3725   // CHECK-ASM: vistrf
3726
3727   vsc = vec_cp_until_zero_cc(vsc, &cc);
3728   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3729   // CHECK-ASM: vistrbs
3730   vuc = vec_cp_until_zero_cc(vuc, &cc);
3731   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3732   // CHECK-ASM: vistrbs
3733   vbc = vec_cp_until_zero_cc(vbc, &cc);
3734   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})
3735   // CHECK-ASM: vistrbs
3736   vss = vec_cp_until_zero_cc(vss, &cc);
3737   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3738   // CHECK-ASM: vistrhs
3739   vus = vec_cp_until_zero_cc(vus, &cc);
3740   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3741   // CHECK-ASM: vistrhs
3742   vbs = vec_cp_until_zero_cc(vbs, &cc);
3743   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})
3744   // CHECK-ASM: vistrhs
3745   vsi = vec_cp_until_zero_cc(vsi, &cc);
3746   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3747   // CHECK-ASM: vistrfs
3748   vui = vec_cp_until_zero_cc(vui, &cc);
3749   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3750   // CHECK-ASM: vistrfs
3751   vbi = vec_cp_until_zero_cc(vbi, &cc);
3752   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})
3753   // CHECK-ASM: vistrfs
3754
3755   vsc = vec_cmpeq_idx(vsc, vsc);
3756   // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3757   // CHECK-ASM: vfeeb
3758   vuc = vec_cmpeq_idx(vuc, vuc);
3759   // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3760   // CHECK-ASM: vfeeb
3761   vuc = vec_cmpeq_idx(vbc, vbc);
3762   // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3763   // CHECK-ASM: vfeeb
3764   vss = vec_cmpeq_idx(vss, vss);
3765   // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3766   // CHECK-ASM: vfeeh
3767   vus = vec_cmpeq_idx(vus, vus);
3768   // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3769   // CHECK-ASM: vfeeh
3770   vus = vec_cmpeq_idx(vbs, vbs);
3771   // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3772   // CHECK-ASM: vfeeh
3773   vsi = vec_cmpeq_idx(vsi, vsi);
3774   // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3775   // CHECK-ASM: vfeef
3776   vui = vec_cmpeq_idx(vui, vui);
3777   // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3778   // CHECK-ASM: vfeef
3779   vui = vec_cmpeq_idx(vbi, vbi);
3780   // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3781   // CHECK-ASM: vfeef
3782
3783   vsc = vec_cmpeq_idx_cc(vsc, vsc, &cc);
3784   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3785   // CHECK-ASM: vfeebs
3786   vuc = vec_cmpeq_idx_cc(vuc, vuc, &cc);
3787   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3788   // CHECK-ASM: vfeebs
3789   vuc = vec_cmpeq_idx_cc(vbc, vbc, &cc);
3790   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3791   // CHECK-ASM: vfeebs
3792   vss = vec_cmpeq_idx_cc(vss, vss, &cc);
3793   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3794   // CHECK-ASM: vfeehs
3795   vus = vec_cmpeq_idx_cc(vus, vus, &cc);
3796   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3797   // CHECK-ASM: vfeehs
3798   vus = vec_cmpeq_idx_cc(vbs, vbs, &cc);
3799   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3800   // CHECK-ASM: vfeehs
3801   vsi = vec_cmpeq_idx_cc(vsi, vsi, &cc);
3802   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3803   // CHECK-ASM: vfeefs
3804   vui = vec_cmpeq_idx_cc(vui, vui, &cc);
3805   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3806   // CHECK-ASM: vfeefs
3807   vui = vec_cmpeq_idx_cc(vbi, vbi, &cc);
3808   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3809   // CHECK-ASM: vfeefs
3810
3811   vsc = vec_cmpeq_or_0_idx(vsc, vsc);
3812   // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3813   // CHECK-ASM: vfeezb
3814   vuc = vec_cmpeq_or_0_idx(vuc, vuc);
3815   // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3816   // CHECK-ASM: vfeezb
3817   vuc = vec_cmpeq_or_0_idx(vbc, vbc);
3818   // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3819   // CHECK-ASM: vfeezb
3820   vss = vec_cmpeq_or_0_idx(vss, vss);
3821   // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3822   // CHECK-ASM: vfeezh
3823   vus = vec_cmpeq_or_0_idx(vus, vus);
3824   // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3825   // CHECK-ASM: vfeezh
3826   vus = vec_cmpeq_or_0_idx(vbs, vbs);
3827   // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3828   // CHECK-ASM: vfeezh
3829   vsi = vec_cmpeq_or_0_idx(vsi, vsi);
3830   // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3831   // CHECK-ASM: vfeezf
3832   vui = vec_cmpeq_or_0_idx(vui, vui);
3833   // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3834   // CHECK-ASM: vfeezf
3835   vui = vec_cmpeq_or_0_idx(vbi, vbi);
3836   // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3837   // CHECK-ASM: vfeezf
3838
3839   vsc = vec_cmpeq_or_0_idx_cc(vsc, vsc, &cc);
3840   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3841   // CHECK-ASM: vfeezbs
3842   vuc = vec_cmpeq_or_0_idx_cc(vuc, vuc, &cc);
3843   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3844   // CHECK-ASM: vfeezbs
3845   vuc = vec_cmpeq_or_0_idx_cc(vbc, vbc, &cc);
3846   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3847   // CHECK-ASM: vfeezbs
3848   vss = vec_cmpeq_or_0_idx_cc(vss, vss, &cc);
3849   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3850   // CHECK-ASM: vfeezhs
3851   vus = vec_cmpeq_or_0_idx_cc(vus, vus, &cc);
3852   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3853   // CHECK-ASM: vfeezhs
3854   vus = vec_cmpeq_or_0_idx_cc(vbs, vbs, &cc);
3855   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3856   // CHECK-ASM: vfeezhs
3857   vsi = vec_cmpeq_or_0_idx_cc(vsi, vsi, &cc);
3858   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3859   // CHECK-ASM: vfeezfs
3860   vui = vec_cmpeq_or_0_idx_cc(vui, vui, &cc);
3861   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3862   // CHECK-ASM: vfeezfs
3863   vui = vec_cmpeq_or_0_idx_cc(vbi, vbi, &cc);
3864   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3865   // CHECK-ASM: vfeezfs
3866
3867   vsc = vec_cmpne_idx(vsc, vsc);
3868   // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3869   // CHECK-ASM: vfeneb
3870   vuc = vec_cmpne_idx(vuc, vuc);
3871   // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3872   // CHECK-ASM: vfeneb
3873   vuc = vec_cmpne_idx(vbc, vbc);
3874   // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3875   // CHECK-ASM: vfeneb
3876   vss = vec_cmpne_idx(vss, vss);
3877   // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3878   // CHECK-ASM: vfeneh
3879   vus = vec_cmpne_idx(vus, vus);
3880   // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3881   // CHECK-ASM: vfeneh
3882   vus = vec_cmpne_idx(vbs, vbs);
3883   // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3884   // CHECK-ASM: vfeneh
3885   vsi = vec_cmpne_idx(vsi, vsi);
3886   // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3887   // CHECK-ASM: vfenef
3888   vui = vec_cmpne_idx(vui, vui);
3889   // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3890   // CHECK-ASM: vfenef
3891   vui = vec_cmpne_idx(vbi, vbi);
3892   // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3893   // CHECK-ASM: vfenef
3894
3895   vsc = vec_cmpne_idx_cc(vsc, vsc, &cc);
3896   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3897   // CHECK-ASM: vfenebs
3898   vuc = vec_cmpne_idx_cc(vuc, vuc, &cc);
3899   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3900   // CHECK-ASM: vfenebs
3901   vuc = vec_cmpne_idx_cc(vbc, vbc, &cc);
3902   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3903   // CHECK-ASM: vfenebs
3904   vss = vec_cmpne_idx_cc(vss, vss, &cc);
3905   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3906   // CHECK-ASM: vfenehs
3907   vus = vec_cmpne_idx_cc(vus, vus, &cc);
3908   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3909   // CHECK-ASM: vfenehs
3910   vus = vec_cmpne_idx_cc(vbs, vbs, &cc);
3911   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3912   // CHECK-ASM: vfenehs
3913   vsi = vec_cmpne_idx_cc(vsi, vsi, &cc);
3914   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3915   // CHECK-ASM: vfenefs
3916   vui = vec_cmpne_idx_cc(vui, vui, &cc);
3917   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3918   // CHECK-ASM: vfenefs
3919   vui = vec_cmpne_idx_cc(vbi, vbi, &cc);
3920   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3921   // CHECK-ASM: vfenefs
3922
3923   vsc = vec_cmpne_or_0_idx(vsc, vsc);
3924   // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3925   // CHECK-ASM: vfenezb
3926   vuc = vec_cmpne_or_0_idx(vuc, vuc);
3927   // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3928   // CHECK-ASM: vfenezb
3929   vuc = vec_cmpne_or_0_idx(vbc, vbc);
3930   // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3931   // CHECK-ASM: vfenezb
3932   vss = vec_cmpne_or_0_idx(vss, vss);
3933   // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3934   // CHECK-ASM: vfenezh
3935   vus = vec_cmpne_or_0_idx(vus, vus);
3936   // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3937   // CHECK-ASM: vfenezh
3938   vus = vec_cmpne_or_0_idx(vbs, vbs);
3939   // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3940   // CHECK-ASM: vfenezh
3941   vsi = vec_cmpne_or_0_idx(vsi, vsi);
3942   // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3943   // CHECK-ASM: vfenezf
3944   vui = vec_cmpne_or_0_idx(vui, vui);
3945   // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3946   // CHECK-ASM: vfenezf
3947   vui = vec_cmpne_or_0_idx(vbi, vbi);
3948   // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3949   // CHECK-ASM: vfenezf
3950
3951   vsc = vec_cmpne_or_0_idx_cc(vsc, vsc, &cc);
3952   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3953   // CHECK-ASM: vfenezbs
3954   vuc = vec_cmpne_or_0_idx_cc(vuc, vuc, &cc);
3955   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3956   // CHECK-ASM: vfenezbs
3957   vuc = vec_cmpne_or_0_idx_cc(vbc, vbc, &cc);
3958   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
3959   // CHECK-ASM: vfenezbs
3960   vss = vec_cmpne_or_0_idx_cc(vss, vss, &cc);
3961   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3962   // CHECK-ASM: vfenezhs
3963   vus = vec_cmpne_or_0_idx_cc(vus, vus, &cc);
3964   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3965   // CHECK-ASM: vfenezhs
3966   vus = vec_cmpne_or_0_idx_cc(vbs, vbs, &cc);
3967   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3968   // CHECK-ASM: vfenezhs
3969   vsi = vec_cmpne_or_0_idx_cc(vsi, vsi, &cc);
3970   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3971   // CHECK-ASM: vfenezfs
3972   vui = vec_cmpne_or_0_idx_cc(vui, vui, &cc);
3973   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3974   // CHECK-ASM: vfenezfs
3975   vui = vec_cmpne_or_0_idx_cc(vbi, vbi, &cc);
3976   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
3977   // CHECK-ASM: vfenezfs
3978
3979   vbc = vec_cmprg(vuc, vuc, vuc);
3980   // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
3981   // CHECK-ASM: vstrcb
3982   vbs = vec_cmprg(vus, vus, vus);
3983   // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
3984   // CHECK-ASM: vstrch
3985   vbi = vec_cmprg(vui, vui, vui);
3986   // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
3987   // CHECK-ASM: vstrcf
3988
3989   vbc = vec_cmprg_cc(vuc, vuc, vuc, &cc);
3990   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
3991   // CHECK-ASM: vstrcbs
3992   vbs = vec_cmprg_cc(vus, vus, vus, &cc);
3993   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
3994   // CHECK-ASM: vstrchs
3995   vbi = vec_cmprg_cc(vui, vui, vui, &cc);
3996   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
3997   // CHECK-ASM: vstrcfs
3998
3999   vuc = vec_cmprg_idx(vuc, vuc, vuc);
4000   // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4001   // CHECK-ASM: vstrcb
4002   vus = vec_cmprg_idx(vus, vus, vus);
4003   // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4004   // CHECK-ASM: vstrch
4005   vui = vec_cmprg_idx(vui, vui, vui);
4006   // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4007   // CHECK-ASM: vstrcf
4008
4009   vuc = vec_cmprg_idx_cc(vuc, vuc, vuc, &cc);
4010   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4011   // CHECK-ASM: vstrcbs
4012   vus = vec_cmprg_idx_cc(vus, vus, vus, &cc);
4013   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4014   // CHECK-ASM: vstrchs
4015   vui = vec_cmprg_idx_cc(vui, vui, vui, &cc);
4016   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4017   // CHECK-ASM: vstrcfs
4018
4019   vuc = vec_cmprg_or_0_idx(vuc, vuc, vuc);
4020   // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4021   // CHECK-ASM: vstrczb
4022   vus = vec_cmprg_or_0_idx(vus, vus, vus);
4023   // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4024   // CHECK-ASM: vstrczh
4025   vui = vec_cmprg_or_0_idx(vui, vui, vui);
4026   // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4027   // CHECK-ASM: vstrczf
4028
4029   vuc = vec_cmprg_or_0_idx_cc(vuc, vuc, vuc, &cc);
4030   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4031   // CHECK-ASM: vstrczbs
4032   vus = vec_cmprg_or_0_idx_cc(vus, vus, vus, &cc);
4033   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4034   // CHECK-ASM: vstrczhs
4035   vui = vec_cmprg_or_0_idx_cc(vui, vui, vui, &cc);
4036   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4037   // CHECK-ASM: vstrczfs
4038
4039   vbc = vec_cmpnrg(vuc, vuc, vuc);
4040   // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4041   // CHECK-ASM: vstrcb
4042   vbs = vec_cmpnrg(vus, vus, vus);
4043   // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4044   // CHECK-ASM: vstrch
4045   vbi = vec_cmpnrg(vui, vui, vui);
4046   // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4047   // CHECK-ASM: vstrcf
4048
4049   vbc = vec_cmpnrg_cc(vuc, vuc, vuc, &cc);
4050   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4051   // CHECK-ASM: vstrcbs
4052   vbs = vec_cmpnrg_cc(vus, vus, vus, &cc);
4053   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4054   // CHECK-ASM: vstrchs
4055   vbi = vec_cmpnrg_cc(vui, vui, vui, &cc);
4056   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4057   // CHECK-ASM: vstrcfs
4058
4059   vuc = vec_cmpnrg_idx(vuc, vuc, vuc);
4060   // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4061   // CHECK-ASM: vstrcb
4062   vus = vec_cmpnrg_idx(vus, vus, vus);
4063   // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4064   // CHECK-ASM: vstrch
4065   vui = vec_cmpnrg_idx(vui, vui, vui);
4066   // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4067   // CHECK-ASM: vstrcf
4068
4069   vuc = vec_cmpnrg_idx_cc(vuc, vuc, vuc, &cc);
4070   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4071   // CHECK-ASM: vstrcbs
4072   vus = vec_cmpnrg_idx_cc(vus, vus, vus, &cc);
4073   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4074   // CHECK-ASM: vstrchs
4075   vui = vec_cmpnrg_idx_cc(vui, vui, vui, &cc);
4076   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4077   // CHECK-ASM: vstrcfs
4078
4079   vuc = vec_cmpnrg_or_0_idx(vuc, vuc, vuc);
4080   // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4081   // CHECK-ASM: vstrczb
4082   vus = vec_cmpnrg_or_0_idx(vus, vus, vus);
4083   // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4084   // CHECK-ASM: vstrczh
4085   vui = vec_cmpnrg_or_0_idx(vui, vui, vui);
4086   // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4087   // CHECK-ASM: vstrczf
4088
4089   vuc = vec_cmpnrg_or_0_idx_cc(vuc, vuc, vuc, &cc);
4090   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4091   // CHECK-ASM: vstrczbs
4092   vus = vec_cmpnrg_or_0_idx_cc(vus, vus, vus, &cc);
4093   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4094   // CHECK-ASM: vstrczhs
4095   vui = vec_cmpnrg_or_0_idx_cc(vui, vui, vui, &cc);
4096   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4097   // CHECK-ASM: vstrczfs
4098
4099   vbc = vec_find_any_eq(vsc, vsc);
4100   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4101   // CHECK-ASM: vfaeb
4102   vbc = vec_find_any_eq(vuc, vuc);
4103   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4104   // CHECK-ASM: vfaeb
4105   vbc = vec_find_any_eq(vbc, vbc);
4106   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4107   // CHECK-ASM: vfaeb
4108   vbs = vec_find_any_eq(vss, vss);
4109   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4110   // CHECK-ASM: vfaeh
4111   vbs = vec_find_any_eq(vus, vus);
4112   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4113   // CHECK-ASM: vfaeh
4114   vbs = vec_find_any_eq(vbs, vbs);
4115   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4116   // CHECK-ASM: vfaeh
4117   vbi = vec_find_any_eq(vsi, vsi);
4118   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4119   // CHECK-ASM: vfaef
4120   vbi = vec_find_any_eq(vui, vui);
4121   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4122   // CHECK-ASM: vfaef
4123   vbi = vec_find_any_eq(vbi, vbi);
4124   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4125   // CHECK-ASM: vfaef
4126
4127   vbc = vec_find_any_eq_cc(vsc, vsc, &cc);
4128   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4129   // CHECK-ASM: vfaebs
4130   vbc = vec_find_any_eq_cc(vuc, vuc, &cc);
4131   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4132   // CHECK-ASM: vfaebs
4133   vbc = vec_find_any_eq_cc(vbc, vbc, &cc);
4134   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4)
4135   // CHECK-ASM: vfaebs
4136   vbs = vec_find_any_eq_cc(vss, vss, &cc);
4137   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4138   // CHECK-ASM: vfaehs
4139   vbs = vec_find_any_eq_cc(vus, vus, &cc);
4140   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4141   // CHECK-ASM: vfaehs
4142   vbs = vec_find_any_eq_cc(vbs, vbs, &cc);
4143   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4)
4144   // CHECK-ASM: vfaehs
4145   vbi = vec_find_any_eq_cc(vsi, vsi, &cc);
4146   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4147   // CHECK-ASM: vfaefs
4148   vbi = vec_find_any_eq_cc(vui, vui, &cc);
4149   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4150   // CHECK-ASM: vfaefs
4151   vbi = vec_find_any_eq_cc(vbi, vbi, &cc);
4152   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4)
4153   // CHECK-ASM: vfaefs
4154
4155   vsc = vec_find_any_eq_idx(vsc, vsc);
4156   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4157   // CHECK-ASM: vfaeb
4158   vuc = vec_find_any_eq_idx(vuc, vuc);
4159   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4160   // CHECK-ASM: vfaeb
4161   vuc = vec_find_any_eq_idx(vbc, vbc);
4162   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4163   // CHECK-ASM: vfaeb
4164   vss = vec_find_any_eq_idx(vss, vss);
4165   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4166   // CHECK-ASM: vfaeh
4167   vus = vec_find_any_eq_idx(vus, vus);
4168   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4169   // CHECK-ASM: vfaeh
4170   vus = vec_find_any_eq_idx(vbs, vbs);
4171   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4172   // CHECK-ASM: vfaeh
4173   vsi = vec_find_any_eq_idx(vsi, vsi);
4174   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4175   // CHECK-ASM: vfaef
4176   vui = vec_find_any_eq_idx(vui, vui);
4177   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4178   // CHECK-ASM: vfaef
4179   vui = vec_find_any_eq_idx(vbi, vbi);
4180   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4181   // CHECK-ASM: vfaef
4182
4183   vsc = vec_find_any_eq_idx_cc(vsc, vsc, &cc);
4184   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4185   // CHECK-ASM: vfaebs
4186   vuc = vec_find_any_eq_idx_cc(vuc, vuc, &cc);
4187   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4188   // CHECK-ASM: vfaebs
4189   vuc = vec_find_any_eq_idx_cc(vbc, vbc, &cc);
4190   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4191   // CHECK-ASM: vfaebs
4192   vss = vec_find_any_eq_idx_cc(vss, vss, &cc);
4193   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4194   // CHECK-ASM: vfaehs
4195   vus = vec_find_any_eq_idx_cc(vus, vus, &cc);
4196   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4197   // CHECK-ASM: vfaehs
4198   vus = vec_find_any_eq_idx_cc(vbs, vbs, &cc);
4199   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4200   // CHECK-ASM: vfaehs
4201   vsi = vec_find_any_eq_idx_cc(vsi, vsi, &cc);
4202   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4203   // CHECK-ASM: vfaefs
4204   vui = vec_find_any_eq_idx_cc(vui, vui, &cc);
4205   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4206   // CHECK-ASM: vfaefs
4207   vui = vec_find_any_eq_idx_cc(vbi, vbi, &cc);
4208   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4209   // CHECK-ASM: vfaefs
4210
4211   vsc = vec_find_any_eq_or_0_idx(vsc, vsc);
4212   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4213   // CHECK-ASM: vfaezb
4214   vuc = vec_find_any_eq_or_0_idx(vuc, vuc);
4215   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4216   // CHECK-ASM: vfaezb
4217   vuc = vec_find_any_eq_or_0_idx(vbc, vbc);
4218   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4219   // CHECK-ASM: vfaezb
4220   vss = vec_find_any_eq_or_0_idx(vss, vss);
4221   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4222   // CHECK-ASM: vfaezh
4223   vus = vec_find_any_eq_or_0_idx(vus, vus);
4224   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4225   // CHECK-ASM: vfaezh
4226   vus = vec_find_any_eq_or_0_idx(vbs, vbs);
4227   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4228   // CHECK-ASM: vfaezh
4229   vsi = vec_find_any_eq_or_0_idx(vsi, vsi);
4230   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4231   // CHECK-ASM: vfaezf
4232   vui = vec_find_any_eq_or_0_idx(vui, vui);
4233   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4234   // CHECK-ASM: vfaezf
4235   vui = vec_find_any_eq_or_0_idx(vbi, vbi);
4236   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4237   // CHECK-ASM: vfaezf
4238
4239   vsc = vec_find_any_eq_or_0_idx_cc(vsc, vsc, &cc);
4240   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4241   // CHECK-ASM: vfaezbs
4242   vuc = vec_find_any_eq_or_0_idx_cc(vuc, vuc, &cc);
4243   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4244   // CHECK-ASM: vfaezbs
4245   vuc = vec_find_any_eq_or_0_idx_cc(vbc, vbc, &cc);
4246   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
4247   // CHECK-ASM: vfaezbs
4248   vss = vec_find_any_eq_or_0_idx_cc(vss, vss, &cc);
4249   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4250   // CHECK-ASM: vfaezhs
4251   vus = vec_find_any_eq_or_0_idx_cc(vus, vus, &cc);
4252   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4253   // CHECK-ASM: vfaezhs
4254   vus = vec_find_any_eq_or_0_idx_cc(vbs, vbs, &cc);
4255   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0)
4256   // CHECK-ASM: vfaezhs
4257   vsi = vec_find_any_eq_or_0_idx_cc(vsi, vsi, &cc);
4258   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4259   // CHECK-ASM: vfaezfs
4260   vui = vec_find_any_eq_or_0_idx_cc(vui, vui, &cc);
4261   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4262   // CHECK-ASM: vfaezfs
4263   vui = vec_find_any_eq_or_0_idx_cc(vbi, vbi, &cc);
4264   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0)
4265   // CHECK-ASM: vfaezfs
4266
4267   vbc = vec_find_any_ne(vsc, vsc);
4268   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4269   // CHECK-ASM: vfaeb
4270   vbc = vec_find_any_ne(vuc, vuc);
4271   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4272   // CHECK-ASM: vfaeb
4273   vbc = vec_find_any_ne(vbc, vbc);
4274   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4275   // CHECK-ASM: vfaeb
4276   vbs = vec_find_any_ne(vss, vss);
4277   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4278   // CHECK-ASM: vfaeh
4279   vbs = vec_find_any_ne(vus, vus);
4280   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4281   // CHECK-ASM: vfaeh
4282   vbs = vec_find_any_ne(vbs, vbs);
4283   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4284   // CHECK-ASM: vfaeh
4285   vbi = vec_find_any_ne(vsi, vsi);
4286   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4287   // CHECK-ASM: vfaef
4288   vbi = vec_find_any_ne(vui, vui);
4289   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4290   // CHECK-ASM: vfaef
4291   vbi = vec_find_any_ne(vbi, vbi);
4292   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4293   // CHECK-ASM: vfaef
4294
4295   vbc = vec_find_any_ne_cc(vsc, vsc, &cc);
4296   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4297   // CHECK-ASM: vfaebs
4298   vbc = vec_find_any_ne_cc(vuc, vuc, &cc);
4299   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4300   // CHECK-ASM: vfaebs
4301   vbc = vec_find_any_ne_cc(vbc, vbc, &cc);
4302   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12)
4303   // CHECK-ASM: vfaebs
4304   vbs = vec_find_any_ne_cc(vss, vss, &cc);
4305   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4306   // CHECK-ASM: vfaehs
4307   vbs = vec_find_any_ne_cc(vus, vus, &cc);
4308   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4309   // CHECK-ASM: vfaehs
4310   vbs = vec_find_any_ne_cc(vbs, vbs, &cc);
4311   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12)
4312   // CHECK-ASM: vfaehs
4313   vbi = vec_find_any_ne_cc(vsi, vsi, &cc);
4314   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4315   // CHECK-ASM: vfaefs
4316   vbi = vec_find_any_ne_cc(vui, vui, &cc);
4317   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4318   // CHECK-ASM: vfaefs
4319   vbi = vec_find_any_ne_cc(vbi, vbi, &cc);
4320   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12)
4321   // CHECK-ASM: vfaefs
4322
4323   vsc = vec_find_any_ne_idx(vsc, vsc);
4324   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4325   // CHECK-ASM: vfaeb
4326   vuc = vec_find_any_ne_idx(vuc, vuc);
4327   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4328   // CHECK-ASM: vfaeb
4329   vuc = vec_find_any_ne_idx(vbc, vbc);
4330   // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4331   // CHECK-ASM: vfaeb
4332   vss = vec_find_any_ne_idx(vss, vss);
4333   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4334   // CHECK-ASM: vfaeh
4335   vus = vec_find_any_ne_idx(vus, vus);
4336   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4337   // CHECK-ASM: vfaeh
4338   vus = vec_find_any_ne_idx(vbs, vbs);
4339   // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4340   // CHECK-ASM: vfaeh
4341   vsi = vec_find_any_ne_idx(vsi, vsi);
4342   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4343   // CHECK-ASM: vfaef
4344   vui = vec_find_any_ne_idx(vui, vui);
4345   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4346   // CHECK-ASM: vfaef
4347   vui = vec_find_any_ne_idx(vbi, vbi);
4348   // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4349   // CHECK-ASM: vfaef
4350
4351   vsc = vec_find_any_ne_idx_cc(vsc, vsc, &cc);
4352   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4353   // CHECK-ASM: vfaebs
4354   vuc = vec_find_any_ne_idx_cc(vuc, vuc, &cc);
4355   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4356   // CHECK-ASM: vfaebs
4357   vuc = vec_find_any_ne_idx_cc(vbc, vbc, &cc);
4358   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4359   // CHECK-ASM: vfaebs
4360   vss = vec_find_any_ne_idx_cc(vss, vss, &cc);
4361   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4362   // CHECK-ASM: vfaehs
4363   vus = vec_find_any_ne_idx_cc(vus, vus, &cc);
4364   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4365   // CHECK-ASM: vfaehs
4366   vus = vec_find_any_ne_idx_cc(vbs, vbs, &cc);
4367   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4368   // CHECK-ASM: vfaehs
4369   vsi = vec_find_any_ne_idx_cc(vsi, vsi, &cc);
4370   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4371   // CHECK-ASM: vfaefs
4372   vui = vec_find_any_ne_idx_cc(vui, vui, &cc);
4373   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4374   // CHECK-ASM: vfaefs
4375   vui = vec_find_any_ne_idx_cc(vbi, vbi, &cc);
4376   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4377   // CHECK-ASM: vfaefs
4378
4379   vsc = vec_find_any_ne_or_0_idx(vsc, vsc);
4380   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4381   // CHECK-ASM: vfaezb
4382   vuc = vec_find_any_ne_or_0_idx(vuc, vuc);
4383   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4384   // CHECK-ASM: vfaezb
4385   vuc = vec_find_any_ne_or_0_idx(vbc, vbc);
4386   // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4387   // CHECK-ASM: vfaezb
4388   vss = vec_find_any_ne_or_0_idx(vss, vss);
4389   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4390   // CHECK-ASM: vfaezh
4391   vus = vec_find_any_ne_or_0_idx(vus, vus);
4392   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4393   // CHECK-ASM: vfaezh
4394   vus = vec_find_any_ne_or_0_idx(vbs, vbs);
4395   // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4396   // CHECK-ASM: vfaezh
4397   vsi = vec_find_any_ne_or_0_idx(vsi, vsi);
4398   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4399   // CHECK-ASM: vfaezf
4400   vui = vec_find_any_ne_or_0_idx(vui, vui);
4401   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4402   // CHECK-ASM: vfaezf
4403   vui = vec_find_any_ne_or_0_idx(vbi, vbi);
4404   // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4405   // CHECK-ASM: vfaezf
4406
4407   vsc = vec_find_any_ne_or_0_idx_cc(vsc, vsc, &cc);
4408   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4409   // CHECK-ASM: vfaezbs
4410   vuc = vec_find_any_ne_or_0_idx_cc(vuc, vuc, &cc);
4411   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4412   // CHECK-ASM: vfaezbs
4413   vuc = vec_find_any_ne_or_0_idx_cc(vbc, vbc, &cc);
4414   // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8)
4415   // CHECK-ASM: vfaezbs
4416   vss = vec_find_any_ne_or_0_idx_cc(vss, vss, &cc);
4417   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4418   // CHECK-ASM: vfaezhs
4419   vus = vec_find_any_ne_or_0_idx_cc(vus, vus, &cc);
4420   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4421   // CHECK-ASM: vfaezhs
4422   vus = vec_find_any_ne_or_0_idx_cc(vbs, vbs, &cc);
4423   // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8)
4424   // CHECK-ASM: vfaezhs
4425   vsi = vec_find_any_ne_or_0_idx_cc(vsi, vsi, &cc);
4426   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4427   // CHECK-ASM: vfaezfs
4428   vui = vec_find_any_ne_or_0_idx_cc(vui, vui, &cc);
4429   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4430   // CHECK-ASM: vfaezfs
4431   vui = vec_find_any_ne_or_0_idx_cc(vbi, vbi, &cc);
4432   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8)
4433   // CHECK-ASM: vfaezfs
4434 }
4435
4436 void test_float(void) {
4437   // CHECK-ASM-LABEL: test_float
4438
4439   vd = vec_abs(vd);
4440   // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
4441   // CHECK-ASM: vflpdb
4442
4443   vd = vec_nabs(vd);
4444   // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
4445   // CHECK-NEXT: fneg <2 x double> [[ABS]]
4446   // CHECK-ASM: vflndb
4447
4448   vd = vec_madd(vd, vd, vd);
4449   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
4450   // CHECK-ASM: vfmadb
4451   vd = vec_msub(vd, vd, vd);
4452   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
4453   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
4454   // CHECK-ASM: vfmsdb
4455   vd = vec_sqrt(vd);
4456   // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
4457   // CHECK-ASM: vfsqdb
4458
4459   vd = vec_ld2f(cptrf);
4460   // CHECK: [[VAL:%[^ ]+]] = load <2 x float>, ptr %{{.*}}
4461   // CHECK: fpext <2 x float> [[VAL]] to <2 x double>
4462   // (emulated)
4463   vec_st2f(vd, ptrf);
4464   // CHECK: [[VAL:%[^ ]+]] = fptrunc <2 x double> %{{.*}} to <2 x float>
4465   // CHECK: store <2 x float> [[VAL]], ptr %{{.*}}
4466   // (emulated)
4467
4468   vd = vec_ctd(vsl, 0);
4469   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
4470   // (emulated)
4471   vd = vec_ctd(vul, 0);
4472   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
4473   // (emulated)
4474   vd = vec_ctd(vsl, 1);
4475   // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
4476   // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
4477   // (emulated)
4478   vd = vec_ctd(vul, 1);
4479   // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
4480   // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01>
4481   // (emulated)
4482   vd = vec_ctd(vsl, 31);
4483   // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double>
4484   // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
4485   // (emulated)
4486   vd = vec_ctd(vul, 31);
4487   // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double>
4488   // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000>
4489   // (emulated)
4490
4491   vsl = vec_ctsl(vd, 0);
4492   // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
4493   // (emulated)
4494   vul = vec_ctul(vd, 0);
4495   // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
4496   // (emulated)
4497   vsl = vec_ctsl(vd, 1);
4498   // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
4499   // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
4500   // (emulated)
4501   vul = vec_ctul(vd, 1);
4502   // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00>
4503   // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
4504   // (emulated)
4505   vsl = vec_ctsl(vd, 31);
4506   // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
4507   // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64>
4508   // (emulated)
4509   vul = vec_ctul(vd, 31);
4510   // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000>
4511   // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64>
4512   // (emulated)
4513
4514   vd = vec_double(vsl);
4515   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
4516   // CHECK-ASM: vcdgb
4517   vd = vec_double(vul);
4518   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
4519   // CHECK-ASM: vcdlgb
4520
4521   vsl = vec_signed(vd);
4522   // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
4523   // CHECK-ASM: vcgdb
4524   vul = vec_unsigned(vd);
4525   // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
4526   // CHECK-ASM: vclgdb
4527
4528   vd = vec_roundp(vd);
4529   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
4530   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
4531   vd = vec_ceil(vd);
4532   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
4533   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
4534   vd = vec_roundm(vd);
4535   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
4536   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
4537   vd = vec_floor(vd);
4538   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
4539   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
4540   vd = vec_roundz(vd);
4541   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
4542   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
4543   vd = vec_trunc(vd);
4544   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
4545   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
4546   vd = vec_roundc(vd);
4547   // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
4548   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
4549   vd = vec_rint(vd);
4550   // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
4551   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
4552   vd = vec_round(vd);
4553   // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
4554   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
4555
4556   vbl = vec_fp_test_data_class(vd, 0, &cc);
4557   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
4558   // CHECK-ASM: vftcidb
4559   vbl = vec_fp_test_data_class(vd, 4095, &cc);
4560   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
4561   // CHECK-ASM: vftcidb
4562   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_P, &cc);
4563   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2048)
4564   // CHECK-ASM: vftcidb
4565   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_N, &cc);
4566   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1024)
4567   // CHECK-ASM: vftcidb
4568   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO, &cc);
4569   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3072)
4570   // CHECK-ASM: vftcidb
4571   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_P, &cc);
4572   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 512)
4573   // CHECK-ASM: vftcidb
4574   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_N, &cc);
4575   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 256)
4576   // CHECK-ASM: vftcidb
4577   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL, &cc);
4578   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 768)
4579   // CHECK-ASM: vftcidb
4580   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_P, &cc);
4581   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 128)
4582   // CHECK-ASM: vftcidb
4583   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_N, &cc);
4584   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 64)
4585   // CHECK-ASM: vftcidb
4586   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL, &cc);
4587   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 192)
4588   // CHECK-ASM: vftcidb
4589   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_P, &cc);
4590   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 32)
4591   // CHECK-ASM: vftcidb
4592   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_N, &cc);
4593   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 16)
4594   // CHECK-ASM: vftcidb
4595   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY, &cc);
4596   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 48)
4597   // CHECK-ASM: vftcidb
4598   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_P, &cc);
4599   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 8)
4600   // CHECK-ASM: vftcidb
4601   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_N, &cc);
4602   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4)
4603   // CHECK-ASM: vftcidb
4604   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN, &cc);
4605   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 12)
4606   // CHECK-ASM: vftcidb
4607   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_P, &cc);
4608   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2)
4609   // CHECK-ASM: vftcidb
4610   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_N, &cc);
4611   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1)
4612   // CHECK-ASM: vftcidb
4613   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN, &cc);
4614   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3)
4615   // CHECK-ASM: vftcidb
4616   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NAN, &cc);
4617   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
4618   // CHECK-ASM: vftcidb
4619   vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NOT_NORMAL, &cc);
4620   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3327)
4621   // CHECK-ASM: vftcidb
4622 }