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

   1 // REQUIRES: systemz-registered-target
   2 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
   3 // RUN: -O2 -fzvector -flax-vector-conversions=none \
   4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
   5 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
   6 // RUN: -O2 -fzvector -flax-vector-conversions=none \
   7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
   8
   9 #include <vecintrin.h>
  10
  11 volatile vector signed char vsc;
  12 volatile vector signed short vss;
  13 volatile vector signed int vsi;
  14 volatile vector signed long long vsl;
  15 volatile vector signed __int128 vslll;
  16 volatile vector unsigned char vuc;
  17 volatile vector unsigned short vus;
  18 volatile vector unsigned int vui;
  19 volatile vector unsigned long long vul;
  20 volatile vector unsigned __int128 vulll;
  21 volatile vector bool char vbc;
  22 volatile vector bool short vbs;
  23 volatile vector bool int vbi;
  24 volatile vector bool long long vbl;
  25 volatile vector bool __int128 vblll;
  26 volatile vector float vf;
  27 volatile vector double vd;
  28
  29 volatile signed char sc;
  30 volatile signed short ss;
  31 volatile signed int si;
  32 volatile signed long long sl;
  33 volatile unsigned char uc;
  34 volatile unsigned short us;
  35 volatile unsigned int ui;
  36 volatile unsigned long long ul;
  37 volatile float f;
  38 volatile double d;
  39
  40 const void * volatile cptr;
  41 const signed char * volatile cptrsc;
  42 const signed short * volatile cptrss;
  43 const signed int * volatile cptrsi;
  44 const signed long long * volatile cptrsl;
  45 const unsigned char * volatile cptruc;
  46 const unsigned short * volatile cptrus;
  47 const unsigned int * volatile cptrui;
  48 const unsigned long long * volatile cptrul;
  49 const float * volatile cptrf;
  50 const double * volatile cptrd;
  51
  52 void * volatile ptr;
  53 signed char * volatile ptrsc;
  54 signed short * volatile ptrss;
  55 signed int * volatile ptrsi;
  56 signed long long * volatile ptrsl;
  57 unsigned char * volatile ptruc;
  58 unsigned short * volatile ptrus;
  59 unsigned int * volatile ptrui;
  60 unsigned long long * volatile ptrul;
  61 float * volatile ptrf;
  62 double * volatile ptrd;
  63
  64 volatile unsigned int len;
  65 volatile int idx;
  66 int cc;
  67
  68 void test_core(void) {
  69   // CHECK-ASM-LABEL: test_core
  70   vector float vf2;
  71   vector double vd2;
  72
  73   f = vec_extract(vf, 0);
  74   // CHECK: extractelement <4 x float> %{{.*}}, i64 0
  75   // CHECK-ASM: vstef
  76   f = vec_extract(vf, idx);
  77   // CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
  78   // CHECK-ASM: vlgvf
  79   d = vec_extract(vd, 0);
  80   // CHECK: extractelement <2 x double> %{{.*}}, i64 0
  81   // CHECK-ASM: vsteg
  82   d = vec_extract(vd, idx);
  83   // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
  84   // CHECK-ASM: vlgvg
  85
  86   vf2 = vf;
  87   vf = vec_insert(f, vf2, 0);
  88   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0
  89   // CHECK-ASM: vlef
  90   vf = vec_insert(0.0f, vf, 1);
  91   // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i64 1
  92   // CHECK-ASM: vleif %{{.*}}, 0, 1
  93   vf = vec_insert(f, vf, idx);
  94   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
  95   // CHECK-ASM: vlvgf
  96   vd2 = vd;
  97   vd = vec_insert(d, vd2, 0);
  98   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0
  99   // CHECK-ASM: vleg
 100   vd = vec_insert(0.0, vd, 1);
 101   // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i64 1
 102   // CHECK-ASM: vleig %{{.*}}, 0, 1
 103   vd = vec_insert(d, vd, idx);
 104   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
 105   // CHECK-ASM: vlvgg
 106
 107   vf = vec_promote(f, idx);
 108   // CHECK: insertelement <4 x float> poison, float %{{.*}}, i32 %{{.*}}
 109   // CHECK-ASM: vlvgf
 110   vd = vec_promote(d, idx);
 111   // CHECK: insertelement <2 x double> poison, double %{{.*}}, i32 %{{.*}}
 112   // CHECK-ASM: vlvgg
 113
 114   vf = vec_insert_and_zero(cptrf);
 115   // CHECK: insertelement <4 x float> <float 0.000000e+00, float poison, float 0.000000e+00, float 0.000000e+00>, float %{{.*}}, i64 1
 116   // CHECK-ASM: vllezf
 117   vd = vec_insert_and_zero(cptrd);
 118   // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i64 0
 119   // CHECK-ASM: vllezg
 120
 121   vf = vec_perm(vf, vf, vuc);
 122   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 123   // CHECK-ASM: vperm
 124   vd = vec_perm(vd, vd, vuc);
 125   // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 126   // CHECK-ASM: vperm
 127
 128   vul = vec_bperm(vulll, vuc);
 129   // CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 130   // CHECK-ASM: vbperm
 131
 132   vul = vec_bperm_u128(vuc, vuc);
 133   // CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 134   // CHECK-ASM: vbperm
 135
 136   vf = vec_revb(vf);
 137   // CHECK-ASM: vperm
 138   vd = vec_revb(vd);
 139   // CHECK-ASM: vperm
 140
 141   vf = vec_reve(vf);
 142   // CHECK-ASM: vperm
 143   vd = vec_reve(vd);
 144   // CHECK-ASM: {{vperm|vpdi}}
 145
 146   vf = vec_sel(vf, vf, vui);
 147   // CHECK-ASM: vsel
 148   vf = vec_sel(vf, vf, vbi);
 149   // CHECK-ASM: vsel
 150   vd = vec_sel(vd, vd, vul);
 151   // CHECK-ASM: vsel
 152   vd = vec_sel(vd, vd, vbl);
 153   // CHECK-ASM: vsel
 154
 155   vf = vec_gather_element(vf, vui, cptrf, 0);
 156   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 157   vf = vec_gather_element(vf, vui, cptrf, 1);
 158   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 159   vf = vec_gather_element(vf, vui, cptrf, 2);
 160   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 161   vf = vec_gather_element(vf, vui, cptrf, 3);
 162   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 163   vd = vec_gather_element(vd, vul, cptrd, 0);
 164   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 165   vd = vec_gather_element(vd, vul, cptrd, 1);
 166   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 167
 168   vec_scatter_element(vf, vui, ptrf, 0);
 169   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 170   vec_scatter_element(vf, vui, ptrf, 1);
 171   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 172   vec_scatter_element(vf, vui, ptrf, 2);
 173   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 174   vec_scatter_element(vf, vui, ptrf, 3);
 175   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 176   vec_scatter_element(vd, vul, ptrd, 0);
 177   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 178   vec_scatter_element(vd, vul, ptrd, 1);
 179   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 180
 181   vf = vec_xl(idx, cptrf);
 182   // CHECK-ASM: vl
 183   vd = vec_xl(idx, cptrd);
 184   // CHECK-ASM: vl
 185
 186   vec_xst(vf, idx, ptrf);
 187   // CHECK-ASM: vst
 188   vec_xst(vd, idx, ptrd);
 189   // CHECK-ASM: vst
 190
 191   vd = vec_load_bndry(cptrd, 64);
 192   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 193   // CHECK-ASM: vlbb
 194   vf = vec_load_bndry(cptrf, 64);
 195   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)
 196   // CHECK-ASM: vlbb
 197   vf = vec_load_bndry(cptrf, 128);
 198   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 1)
 199   // CHECK-ASM: vlbb
 200   vf = vec_load_bndry(cptrf, 256);
 201   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 2)
 202   // CHECK-ASM: vlbb
 203   vf = vec_load_bndry(cptrf, 512);
 204   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 3)
 205   // CHECK-ASM: vlbb
 206   vf = vec_load_bndry(cptrf, 1024);
 207   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 4)
 208   // CHECK-ASM: vlbb
 209   vf = vec_load_bndry(cptrf, 2048);
 210   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 5)
 211   // CHECK-ASM: vlbb
 212   vf = vec_load_bndry(cptrf, 4096);
 213   // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 6)
 214   // CHECK-ASM: vlbb
 215
 216   vf = vec_load_len(cptrf, idx);
 217   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 218   // CHECK-ASM: vll
 219   vd = vec_load_len(cptrd, idx);
 220   // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})
 221   // CHECK-ASM: vll
 222
 223   vec_store_len(vf, ptrf, idx);
 224   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 225   // CHECK-ASM: vstl
 226   vec_store_len(vd, ptrd, idx);
 227   // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 228   // CHECK-ASM: vstl
 229
 230   vsc = vec_load_len_r(cptrsc, 0);
 231   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, ptr %{{.*}})
 232   // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0
 233   vsc = vec_load_len_r(cptrsc, idx);
 234   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, ptr %{{.*}})
 235   // CHECK-ASM: vlrlr
 236   vuc = vec_load_len_r(cptruc, 0);
 237   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, ptr %{{.*}})
 238   // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0
 239   vuc = vec_load_len_r(cptruc, idx);
 240   // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, ptr %{{.*}})
 241   // CHECK-ASM: vlrlr
 242
 243   vec_store_len_r(vsc, ptrsc, 0);
 244   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, ptr %{{.*}})
 245   // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0
 246   vec_store_len_r(vsc, ptrsc, idx);
 247   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 248   // CHECK-ASM: vstrlr
 249   vec_store_len_r(vuc, ptruc, 0);
 250   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, ptr %{{.*}})
 251   // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0
 252   vec_store_len_r(vuc, ptruc, idx);
 253   // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})
 254   // CHECK-ASM: vstrlr
 255
 256   vf = vec_splat(vf, 0);
 257   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
 258   // CHECK-ASM: vrepf
 259   vf = vec_splat(vf, 1);
 260   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 261   // CHECK-ASM: vrepf
 262   vd = vec_splat(vd, 0);
 263   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 264   // CHECK-ASM: vrepg
 265   vd = vec_splat(vd, 1);
 266   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> <i32 1, i32 1>
 267   // CHECK-ASM: vrepg
 268
 269   vf = vec_splats(f);
 270   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
 271   // CHECK-ASM: vlrepf
 272   vd = vec_splats(d);
 273   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 274   // CHECK-ASM: vlrepg
 275
 276   vf = vec_mergeh(vf, vf);
 277   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 278   // CHECK-ASM: vmrhf
 279   vd = vec_mergeh(vd, vd);
 280   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
 281   // CHECK-ASM: vmrhg
 282
 283   vf = vec_mergel(vf, vf);
 284   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
 285   // CHECK-ASM: vmrlf
 286   vd = vec_mergel(vd, vd);
 287   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
 288   // CHECK-ASM: vmrlg
 289 }
 290
 291 void test_compare(void) {
 292   // CHECK-ASM-LABEL: test_compare
 293
 294   vbi = vec_cmpeq(vf, vf);
 295   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
 296   // CHECK-ASM: vfcesb
 297   vbl = vec_cmpeq(vd, vd);
 298   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
 299   // CHECK-ASM: vfcedb
 300
 301   vbi = vec_cmpge(vf, vf);
 302   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
 303   // CHECK-ASM: vfchesb
 304   vbl = vec_cmpge(vd, vd);
 305   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
 306   // CHECK-ASM: vfchedb
 307
 308   vbi = vec_cmpgt(vf, vf);
 309   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
 310   // CHECK-ASM: vfchsb
 311   vbl = vec_cmpgt(vd, vd);
 312   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
 313   // CHECK-ASM: vfchdb
 314
 315   vbi = vec_cmple(vf, vf);
 316   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
 317   // CHECK-ASM: vfchesb
 318   vbl = vec_cmple(vd, vd);
 319   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
 320   // CHECK-ASM: vfchedb
 321
 322   vbi = vec_cmplt(vf, vf);
 323   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
 324   // CHECK-ASM: vfchsb
 325   vbl = vec_cmplt(vd, vd);
 326   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
 327   // CHECK-ASM: vfchdb
 328
 329   idx = vec_all_eq(vf, vf);
 330   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 331   // CHECK-ASM: vfcesbs
 332   idx = vec_all_eq(vd, vd);
 333   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 334   // CHECK-ASM: vfcedbs
 335
 336   idx = vec_all_ne(vf, vf);
 337   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 338   // CHECK-ASM: vfcesbs
 339   idx = vec_all_ne(vd, vd);
 340   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 341   // CHECK-ASM: vfcedbs
 342
 343   idx = vec_all_ge(vf, vf);
 344   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 345   // CHECK-ASM: vfchesbs
 346   idx = vec_all_ge(vd, vd);
 347   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 348   // CHECK-ASM: vfchedbs
 349
 350   idx = vec_all_gt(vf, vf);
 351   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 352   // CHECK-ASM: vfchsbs
 353   idx = vec_all_gt(vd, vd);
 354   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 355   // CHECK-ASM: vfchdbs
 356
 357   idx = vec_all_le(vf, vf);
 358   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 359   // CHECK-ASM: vfchesbs
 360   idx = vec_all_le(vd, vd);
 361   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 362   // CHECK-ASM: vfchedbs
 363
 364   idx = vec_all_lt(vf, vf);
 365   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 366   // CHECK-ASM: vfchsbs
 367   idx = vec_all_lt(vd, vd);
 368   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 369   // CHECK-ASM: vfchdbs
 370
 371   idx = vec_all_nge(vf, vf);
 372   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 373   // CHECK-ASM: vfchesbs
 374   idx = vec_all_nge(vd, vd);
 375   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 376   // CHECK-ASM: vfchedbs
 377
 378   idx = vec_all_ngt(vf, vf);
 379   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 380   // CHECK-ASM: vfchsbs
 381   idx = vec_all_ngt(vd, vd);
 382   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 383   // CHECK-ASM: vfchdbs
 384
 385   idx = vec_all_nle(vf, vf);
 386   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 387   // CHECK-ASM: vfchesbs
 388   idx = vec_all_nle(vd, vd);
 389   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 390   // CHECK-ASM: vfchedbs
 391
 392   idx = vec_all_nlt(vf, vf);
 393   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 394   // CHECK-ASM: vfchsbs
 395   idx = vec_all_nlt(vd, vd);
 396   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 397   // CHECK-ASM: vfchdbs
 398
 399   idx = vec_all_nan(vf);
 400   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 401   // CHECK-ASM: vftcisb
 402   idx = vec_all_nan(vd);
 403   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 404   // CHECK-ASM: vftcidb
 405
 406   idx = vec_all_numeric(vf);
 407   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 408   // CHECK-ASM: vftcisb
 409   idx = vec_all_numeric(vd);
 410   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 411   // CHECK-ASM: vftcidb
 412
 413   idx = vec_any_eq(vf, vf);
 414   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 415   // CHECK-ASM: vfcesbs
 416   idx = vec_any_eq(vd, vd);
 417   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 418   // CHECK-ASM: vfcedbs
 419
 420   idx = vec_any_ne(vf, vf);
 421   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 422   // CHECK-ASM: vfcesbs
 423   idx = vec_any_ne(vd, vd);
 424   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 425   // CHECK-ASM: vfcedbs
 426
 427   idx = vec_any_ge(vf, vf);
 428   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 429   // CHECK-ASM: vfchesbs
 430   idx = vec_any_ge(vd, vd);
 431   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 432   // CHECK-ASM: vfchedbs
 433
 434   idx = vec_any_gt(vf, vf);
 435   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 436   // CHECK-ASM: vfchsbs
 437   idx = vec_any_gt(vd, vd);
 438   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 439   // CHECK-ASM: vfchdbs
 440
 441   idx = vec_any_le(vf, vf);
 442   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 443   // CHECK-ASM: vfchesbs
 444   idx = vec_any_le(vd, vd);
 445   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 446   // CHECK-ASM: vfchedbs
 447
 448   idx = vec_any_lt(vf, vf);
 449   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 450   // CHECK-ASM: vfchsbs
 451   idx = vec_any_lt(vd, vd);
 452   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 453   // CHECK-ASM: vfchdbs
 454
 455   idx = vec_any_nge(vf, vf);
 456   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 457   // CHECK-ASM: vfchesbs
 458   idx = vec_any_nge(vd, vd);
 459   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 460   // CHECK-ASM: vfchedbs
 461
 462   idx = vec_any_ngt(vf, vf);
 463   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 464   // CHECK-ASM: vfchsbs
 465   idx = vec_any_ngt(vd, vd);
 466   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 467   // CHECK-ASM: vfchdbs
 468
 469   idx = vec_any_nle(vf, vf);
 470   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 471   // CHECK-ASM: vfchesbs
 472   idx = vec_any_nle(vd, vd);
 473   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 474   // CHECK-ASM: vfchedbs
 475
 476   idx = vec_any_nlt(vf, vf);
 477   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 478   // CHECK-ASM: vfchsbs
 479   idx = vec_any_nlt(vd, vd);
 480   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 481   // CHECK-ASM: vfchdbs
 482
 483   idx = vec_any_nan(vf);
 484   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 485   // CHECK-ASM: vftcisb
 486   idx = vec_any_nan(vd);
 487   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 488   // CHECK-ASM: vftcidb
 489
 490   idx = vec_any_numeric(vf);
 491   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 492   // CHECK-ASM: vftcisb
 493   idx = vec_any_numeric(vd);
 494   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 495   // CHECK-ASM: vftcidb
 496 }
 497
 498 void test_integer(void) {
 499   // CHECK-ASM-LABEL: test_integer
 500
 501   vf = vec_and(vf, vf);
 502   // CHECK-ASM: vn
 503   vd = vec_and(vd, vd);
 504   // CHECK-ASM: vn
 505
 506   vf = vec_or(vf, vf);
 507   // CHECK-ASM: vo
 508   vd = vec_or(vd, vd);
 509   // CHECK-ASM: vo
 510
 511   vf = vec_xor(vf, vf);
 512   // CHECK-ASM: vx
 513   vd = vec_xor(vd, vd);
 514   // CHECK-ASM: vx
 515
 516   vf = vec_andc(vf, vf);
 517   // CHECK-ASM: vnc
 518   vd = vec_andc(vd, vd);
 519   // CHECK-ASM: vnc
 520
 521   vf = vec_nor(vf, vf);
 522   // CHECK-ASM: vno
 523   vd = vec_nor(vd, vd);
 524   // CHECK-ASM: vno
 525
 526   vsc = vec_nand(vsc, vsc);
 527   // CHECK-ASM: vnn
 528   vuc = vec_nand(vuc, vuc);
 529   // CHECK-ASM: vnn
 530   vbc = vec_nand(vbc, vbc);
 531   // CHECK-ASM: vnn
 532   vss = vec_nand(vss, vss);
 533   // CHECK-ASM: vnn
 534   vus = vec_nand(vus, vus);
 535   // CHECK-ASM: vnn
 536   vbs = vec_nand(vbs, vbs);
 537   // CHECK-ASM: vnn
 538   vsi = vec_nand(vsi, vsi);
 539   // CHECK-ASM: vnn
 540   vui = vec_nand(vui, vui);
 541   // CHECK-ASM: vnn
 542   vbi = vec_nand(vbi, vbi);
 543   // CHECK-ASM: vnn
 544   vsl = vec_nand(vsl, vsl);
 545   // CHECK-ASM: vnn
 546   vul = vec_nand(vul, vul);
 547   // CHECK-ASM: vnn
 548   vbl = vec_nand(vbl, vbl);
 549   // CHECK-ASM: vnn
 550   vslll = vec_nand(vslll, vslll);
 551   // CHECK-ASM: vnn
 552   vulll = vec_nand(vulll, vulll);
 553   // CHECK-ASM: vnn
 554   vblll = vec_nand(vblll, vblll);
 555   // CHECK-ASM: vnn
 556   vf = vec_nand(vf, vf);
 557   // CHECK-ASM: vnn
 558   vd = vec_nand(vd, vd);
 559   // CHECK-ASM: vnn
 560
 561   vsc = vec_orc(vsc, vsc);
 562   // CHECK-ASM: voc
 563   vuc = vec_orc(vuc, vuc);
 564   // CHECK-ASM: voc
 565   vbc = vec_orc(vbc, vbc);
 566   // CHECK-ASM: voc
 567   vss = vec_orc(vss, vss);
 568   // CHECK-ASM: voc
 569   vus = vec_orc(vus, vus);
 570   // CHECK-ASM: voc
 571   vbs = vec_orc(vbs, vbs);
 572   // CHECK-ASM: voc
 573   vsi = vec_orc(vsi, vsi);
 574   // CHECK-ASM: voc
 575   vui = vec_orc(vui, vui);
 576   // CHECK-ASM: voc
 577   vbi = vec_orc(vbi, vbi);
 578   // CHECK-ASM: voc
 579   vsl = vec_orc(vsl, vsl);
 580   // CHECK-ASM: voc
 581   vul = vec_orc(vul, vul);
 582   // CHECK-ASM: voc
 583   vbl = vec_orc(vbl, vbl);
 584   // CHECK-ASM: voc
 585   vslll = vec_orc(vslll, vslll);
 586   // CHECK-ASM: voc
 587   vulll = vec_orc(vulll, vulll);
 588   // CHECK-ASM: voc
 589   vblll = vec_orc(vblll, vblll);
 590   // CHECK-ASM: voc
 591   vf = vec_orc(vf, vf);
 592   // CHECK-ASM: voc
 593   vd = vec_orc(vd, vd);
 594   // CHECK-ASM: voc
 595
 596   vsc = vec_eqv(vsc, vsc);
 597   // CHECK-ASM: vnx
 598   vuc = vec_eqv(vuc, vuc);
 599   // CHECK-ASM: vnx
 600   vbc = vec_eqv(vbc, vbc);
 601   // CHECK-ASM: vnx
 602   vss = vec_eqv(vss, vss);
 603   // CHECK-ASM: vnx
 604   vus = vec_eqv(vus, vus);
 605   // CHECK-ASM: vnx
 606   vbs = vec_eqv(vbs, vbs);
 607   // CHECK-ASM: vnx
 608   vsi = vec_eqv(vsi, vsi);
 609   // CHECK-ASM: vnx
 610   vui = vec_eqv(vui, vui);
 611   // CHECK-ASM: vnx
 612   vbi = vec_eqv(vbi, vbi);
 613   // CHECK-ASM: vnx
 614   vsl = vec_eqv(vsl, vsl);
 615   // CHECK-ASM: vnx
 616   vul = vec_eqv(vul, vul);
 617   // CHECK-ASM: vnx
 618   vbl = vec_eqv(vbl, vbl);
 619   // CHECK-ASM: vnx
 620   vslll = vec_eqv(vslll, vslll);
 621   // CHECK-ASM: vnx
 622   vulll = vec_eqv(vulll, vulll);
 623   // CHECK-ASM: vnx
 624   vblll = vec_eqv(vblll, vblll);
 625   // CHECK-ASM: vnx
 626   vf = vec_eqv(vf, vf);
 627   // CHECK-ASM: vnx
 628   vd = vec_eqv(vd, vd);
 629   // CHECK-ASM: vnx
 630
 631   vuc = vec_popcnt(vsc);
 632   // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
 633   // CHECK-ASM: vpopctb
 634   vuc = vec_popcnt(vuc);
 635   // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})
 636   // CHECK-ASM: vpopctb
 637   vus = vec_popcnt(vss);
 638   // CHECK: call range(i16 0, 17) <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
 639   // CHECK-ASM: vpopcth
 640   vus = vec_popcnt(vus);
 641   // CHECK: call range(i16 0, 17) <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}})
 642   // CHECK-ASM: vpopcth
 643   vui = vec_popcnt(vsi);
 644   // CHECK: call range(i32 0, 33) <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
 645   // CHECK-ASM: vpopctf
 646   vui = vec_popcnt(vui);
 647   // CHECK: call range(i32 0, 33) <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}})
 648   // CHECK-ASM: vpopctf
 649   vul = vec_popcnt(vsl);
 650   // CHECK: call range(i64 0, 65) <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
 651   // CHECK-ASM: vpopctg
 652   vul = vec_popcnt(vul);
 653   // CHECK: call range(i64 0, 65) <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}})
 654   // CHECK-ASM: vpopctg
 655
 656   vf = vec_slb(vf, vsi);
 657   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 658   // CHECK-ASM: vslb
 659   vf = vec_slb(vf, vui);
 660   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 661   // CHECK-ASM: vslb
 662   vf = vec_slb(vf, vuc);
 663   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 664   // CHECK-ASM: vslb
 665   vd = vec_slb(vd, vsl);
 666   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 667   // CHECK-ASM: vslb
 668   vd = vec_slb(vd, vul);
 669   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 670   // CHECK-ASM: vslb
 671   vd = vec_slb(vd, vuc);
 672   // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 673   // CHECK-ASM: vslb
 674
 675   vf = vec_sld(vf, vf, 0);
 676   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
 677   // CHECK-ASM: vsldb
 678   vf = vec_sld(vf, vf, 15);
 679   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
 680   // CHECK-ASM: vsldb
 681   vd = vec_sld(vd, vd, 0);
 682   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0)
 683   // CHECK-ASM: vsldb
 684   vd = vec_sld(vd, vd, 15);
 685   // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15)
 686   // CHECK-ASM: vsldb
 687
 688   vf = vec_srab(vf, vsi);
 689   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 690   // CHECK-ASM: vsrab
 691   vf = vec_srab(vf, vui);
 692   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 693   // CHECK-ASM: vsrab
 694   vf = vec_srab(vf, vuc);
 695   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 696   // CHECK-ASM: vsrab
 697   vd = vec_srab(vd, vsl);
 698   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 699   // CHECK-ASM: vsrab
 700   vd = vec_srab(vd, vul);
 701   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 702   // CHECK-ASM: vsrab
 703   vd = vec_srab(vd, vuc);
 704   // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 705   // CHECK-ASM: vsrab
 706
 707   vf = vec_srb(vf, vsi);
 708   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 709   // CHECK-ASM: vsrlb
 710   vf = vec_srb(vf, vui);
 711   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 712   // CHECK-ASM: vsrlb
 713   vf = vec_srb(vf, vuc);
 714   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 715   // CHECK-ASM: vsrlb
 716   vd = vec_srb(vd, vsl);
 717   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 718   // CHECK-ASM: vsrlb
 719   vd = vec_srb(vd, vul);
 720   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 721   // CHECK-ASM: vsrlb
 722   vd = vec_srb(vd, vuc);
 723   // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 724   // CHECK-ASM: vsrlb
 725
 726   idx = vec_test_mask(vf, vui);
 727   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 728   // CHECK-ASM: vtm
 729   idx = vec_test_mask(vd, vul);
 730   // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 731   // CHECK-ASM: vtm
 732
 733   vulll = vec_msum(vul, vul, vulll, 0);
 734   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 0)
 735   // CHECK-ASM: vmslg
 736   vulll = vec_msum(vul, vul, vulll, 4);
 737   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 4)
 738   // CHECK-ASM: vmslg
 739   vulll = vec_msum(vul, vul, vulll, 8);
 740   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 8)
 741   // CHECK-ASM: vmslg
 742   vulll = vec_msum(vul, vul, vulll, 12);
 743   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 12)
 744   // CHECK-ASM: vmslg
 745
 746   vuc = vec_msum_u128(vul, vul, vuc, 0);
 747   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 0)
 748   // CHECK-ASM: vmslg
 749   vuc = vec_msum_u128(vul, vul, vuc, 4);
 750   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 4)
 751   // CHECK-ASM: vmslg
 752   vuc = vec_msum_u128(vul, vul, vuc, 8);
 753   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 8)
 754   // CHECK-ASM: vmslg
 755   vuc = vec_msum_u128(vul, vul, vuc, 12);
 756   // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 12)
 757   // CHECK-ASM: vmslg
 758 }
 759
 760 void test_float(void) {
 761   // CHECK-ASM-LABEL: test_float
 762
 763   vf = vec_abs(vf);
 764   // CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
 765   // CHECK-ASM: vflpsb
 766   vd = vec_abs(vd);
 767   // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
 768   // CHECK-ASM: vflpdb
 769
 770   vf = vec_nabs(vf);
 771   // CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
 772   // CHECK-NEXT: fneg <4 x float> [[ABS]]
 773   // CHECK-ASM: vflnsb
 774   vd = vec_nabs(vd);
 775   // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
 776   // CHECK-NEXT: fneg <2 x double> [[ABS]]
 777   // CHECK-ASM: vflndb
 778
 779   vf = vec_max(vf, vf);
 780   // CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
 781   // CHECK-ASM: vfmaxsb
 782   vd = vec_max(vd, vd);
 783   // CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
 784   // CHECK-ASM: vfmaxdb
 785
 786   vf = vec_min(vf, vf);
 787   // CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
 788   // CHECK-ASM: vfminsb
 789   vd = vec_min(vd, vd);
 790   // CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
 791   // CHECK-ASM: vfmindb
 792
 793   vf = vec_madd(vf, vf, vf);
 794   // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
 795   // CHECK-ASM: vfmasb
 796   vd = vec_madd(vd, vd, vd);
 797   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
 798   // CHECK-ASM: vfmadb
 799
 800   vf = vec_msub(vf, vf, vf);
 801   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
 802   // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
 803   // CHECK-ASM: vfmssb
 804   vd = vec_msub(vd, vd, vd);
 805   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
 806   // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
 807   // CHECK-ASM: vfmsdb
 808
 809   vf = vec_nmadd(vf, vf, vf);
 810   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
 811   // CHECK: fneg <4 x float> [[RES]]
 812   // CHECK-ASM: vfnmasb
 813   vd = vec_nmadd(vd, vd, vd);
 814   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
 815   // CHECK: fneg <2 x double> [[RES]]
 816   // CHECK-ASM: vfnmadb
 817
 818   vf = vec_nmsub(vf, vf, vf);
 819   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
 820   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]])
 821   // CHECK: fneg <4 x float> [[RES]]
 822   // CHECK-ASM: vfnmssb
 823   vd = vec_nmsub(vd, vd, vd);
 824   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
 825   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]])
 826   // CHECK: fneg <2 x double> [[RES]]
 827   // CHECK-ASM: vfnmsdb
 828
 829   vf = vec_sqrt(vf);
 830   // CHECK: call <4 x float> @llvm.sqrt.v4f32(<4 x float> %{{.*}})
 831   // CHECK-ASM: vfsqsb
 832   vd = vec_sqrt(vd);
 833   // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
 834   // CHECK-ASM: vfsqdb
 835
 836   vd = vec_doublee(vf);
 837   // CHECK: fpext <2 x float> %{{.*}} to <2 x double>
 838   // CHECK-ASM: vldeb
 839   vf = vec_floate(vd);
 840   // CHECK: fptrunc <2 x double> %{{.*}} to <2 x float>
 841   // CHECK-ASM: vledb
 842
 843   vd = vec_double(vsl);
 844   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
 845   // CHECK-ASM: vcdgb
 846   vd = vec_double(vul);
 847   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 848   // CHECK-ASM: vcdlgb
 849
 850   vsl = vec_signed(vd);
 851   // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>
 852   // CHECK-ASM: vcgdb
 853   vul = vec_unsigned(vd);
 854   // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>
 855   // CHECK-ASM: vclgdb
 856
 857   vf = vec_roundp(vf);
 858   // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
 859   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
 860   vf = vec_ceil(vf);
 861   // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}})
 862   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
 863   vd = vec_roundp(vd);
 864   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
 865   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
 866   vd = vec_ceil(vd);
 867   // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})
 868   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
 869
 870   vf = vec_roundm(vf);
 871   // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
 872   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
 873   vf = vec_floor(vf);
 874   // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}})
 875   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
 876   vd = vec_roundm(vd);
 877   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
 878   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
 879   vd = vec_floor(vd);
 880   // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})
 881   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
 882
 883   vf = vec_roundz(vf);
 884   // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
 885   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
 886   vf = vec_trunc(vf);
 887   // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}})
 888   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
 889   vd = vec_roundz(vd);
 890   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
 891   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
 892   vd = vec_trunc(vd);
 893   // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})
 894   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
 895
 896   vf = vec_roundc(vf);
 897   // CHECK: call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %{{.*}})
 898   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
 899   vd = vec_roundc(vd);
 900   // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
 901   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
 902
 903   vf = vec_rint(vf);
 904   // CHECK: call <4 x float> @llvm.rint.v4f32(<4 x float> %{{.*}})
 905   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
 906   vd = vec_rint(vd);
 907   // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})
 908   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
 909
 910   vf = vec_round(vf);
 911   // CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
 912   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
 913   vd = vec_round(vd);
 914   // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
 915   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
 916
 917   vbi = vec_fp_test_data_class(vf, 0, &cc);
 918   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
 919   // CHECK-ASM: vftcisb
 920   vbi = vec_fp_test_data_class(vf, 4095, &cc);
 921   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
 922   // CHECK-ASM: vftcisb
 923   vbl = vec_fp_test_data_class(vd, 0, &cc);
 924   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
 925   // CHECK-ASM: vftcidb
 926   vbl = vec_fp_test_data_class(vd, 4095, &cc);
 927   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
 928   // CHECK-ASM: vftcidb
 929 }