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