clang/test/CodeGen/SystemZ/builtins-systemz-zvector2-constrained.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: -ffp-exception-behavior=strict \
   5 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s
   6 // RUN: %clang_cc1 -target-cpu z14 -triple s390x-linux-gnu \
   7 // RUN: -O2 -fzvector -flax-vector-conversions=none \
   8 // RUN: -ffp-exception-behavior=strict \
   9 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM
  10
  11 #include <vecintrin.h>
  12
  13 volatile vector signed long long vsl;
  14 volatile vector unsigned int vui;
  15 volatile vector unsigned long long vul;
  16 volatile vector bool int vbi;
  17 volatile vector bool long long vbl;
  18 volatile vector float vf;
  19 volatile vector double vd;
  20
  21 volatile float f;
  22 volatile double d;
  23
  24 const float * volatile cptrf;
  25 const double * volatile cptrd;
  26
  27 float * volatile ptrf;
  28 double * volatile ptrd;
  29
  30 volatile int idx;
  31 int cc;
  32
  33 void test_core(void) {
  34   // CHECK-ASM-LABEL: test_core
  35   vector float vf2;
  36   vector double vd2;
  37
  38   f = vec_extract(vf, 0);
  39   // CHECK: extractelement <4 x float> %{{.*}}, i64 0
  40   // CHECK-ASM: vstef
  41   f = vec_extract(vf, idx);
  42   // CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}}
  43   // CHECK-ASM: vlgvf
  44   d = vec_extract(vd, 0);
  45   // CHECK: extractelement <2 x double> %{{.*}}, i64 0
  46   // CHECK-ASM: vsteg
  47   d = vec_extract(vd, idx);
  48   // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}
  49   // CHECK-ASM: vlgvg
  50
  51   vf2 = vf;
  52   vf = vec_insert(f, vf2, 0);
  53   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0
  54   // CHECK-ASM: vlef
  55   vf = vec_insert(0.0f, vf, 1);
  56   // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i64 1
  57   // CHECK-ASM: vleif %{{.*}}, 0, 1
  58   vf = vec_insert(f, vf, idx);
  59   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}}
  60   // CHECK-ASM: vlvgf
  61   vd2 = vd;
  62   vd = vec_insert(d, vd2, 0);
  63   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0
  64   // CHECK-ASM: vleg
  65   vd = vec_insert(0.0, vd, 1);
  66   // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i64 1
  67   // CHECK-ASM: vleig %{{.*}}, 0, 1
  68   vd = vec_insert(d, vd, idx);
  69   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}
  70   // CHECK-ASM: vlvgg
  71
  72   vf = vec_promote(f, idx);
  73   // CHECK: insertelement <4 x float> poison, float %{{.*}}, i32 %{{.*}}
  74   // CHECK-ASM: vlvgf
  75   vd = vec_promote(d, idx);
  76   // CHECK: insertelement <2 x double> poison, double %{{.*}}, i32 %{{.*}}
  77   // CHECK-ASM: vlvgg
  78
  79   vf = vec_insert_and_zero(cptrf);
  80   // CHECK: insertelement <4 x float> <float 0.000000e+00, float poison, float 0.000000e+00, float 0.000000e+00>, float {{.*}}, i64 1
  81   // CHECK-ASM: vllezf
  82   vd = vec_insert_and_zero(cptrd);
  83   // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i64 0
  84   // CHECK-ASM: vllezg
  85
  86   vf = vec_revb(vf);
  87   // CHECK-ASM: vperm
  88   vd = vec_revb(vd);
  89   // CHECK-ASM: vperm
  90
  91   vf = vec_reve(vf);
  92   // CHECK-ASM: vperm
  93   vd = vec_reve(vd);
  94   // CHECK-ASM: {{vperm|vpdi}}
  95
  96   vf = vec_gather_element(vf, vui, cptrf, 0);
  97   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
  98   vf = vec_gather_element(vf, vui, cptrf, 1);
  99   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 100   vf = vec_gather_element(vf, vui, cptrf, 2);
 101   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 102   vf = vec_gather_element(vf, vui, cptrf, 3);
 103   // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 104   vd = vec_gather_element(vd, vul, cptrd, 0);
 105   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 106   vd = vec_gather_element(vd, vul, cptrd, 1);
 107   // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 108
 109   vec_scatter_element(vf, vui, ptrf, 0);
 110   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 111   vec_scatter_element(vf, vui, ptrf, 1);
 112   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 113   vec_scatter_element(vf, vui, ptrf, 2);
 114   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2
 115   vec_scatter_element(vf, vui, ptrf, 3);
 116   // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3
 117   vec_scatter_element(vd, vul, ptrd, 0);
 118   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0
 119   vec_scatter_element(vd, vul, ptrd, 1);
 120   // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1
 121
 122   vf = vec_xl(idx, cptrf);
 123   // CHECK-ASM: vl
 124   vd = vec_xl(idx, cptrd);
 125   // CHECK-ASM: vl
 126
 127   vec_xst(vf, idx, ptrf);
 128   // CHECK-ASM: vst
 129   vec_xst(vd, idx, ptrd);
 130   // CHECK-ASM: vst
 131
 132   vf = vec_splat(vf, 0);
 133   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
 134   // CHECK-ASM: vrepf
 135   vf = vec_splat(vf, 1);
 136   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 137   // CHECK-ASM: vrepf
 138   vd = vec_splat(vd, 0);
 139   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 140   // CHECK-ASM: vrepg
 141   vd = vec_splat(vd, 1);
 142   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1>
 143   // CHECK-ASM: vrepg
 144
 145   vf = vec_splats(f);
 146   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer
 147   // CHECK-ASM: vlrepf
 148   vd = vec_splats(d);
 149   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer
 150   // CHECK-ASM: vlrepg
 151
 152   vf = vec_mergeh(vf, vf);
 153   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 154   // CHECK-ASM: vmrhf
 155   vd = vec_mergeh(vd, vd);
 156   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
 157   // CHECK-ASM: vmrhg
 158
 159   vf = vec_mergel(vf, vf);
 160   // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>
 161   // CHECK-ASM: vmrlf
 162   vd = vec_mergel(vd, vd);
 163   // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>
 164   // CHECK-ASM: vmrlg
 165 }
 166
 167 void test_compare(void) {
 168   // CHECK-ASM-LABEL: test_compare
 169
 170   vbi = vec_cmpeq(vf, vf);
 171   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oeq", metadata !{{.*}})
 172   // CHECK-ASM: vfcesb
 173   vbl = vec_cmpeq(vd, vd);
 174   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oeq", metadata !{{.*}})
 175   // CHECK-ASM: vfcedb
 176
 177   vbi = vec_cmpge(vf, vf);
 178   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oge", metadata !{{.*}})
 179   // CHECK-ASM: vfkhesb
 180   vbl = vec_cmpge(vd, vd);
 181   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oge", metadata !{{.*}})
 182   // CHECK-ASM: vfkhedb
 183
 184   vbi = vec_cmpgt(vf, vf);
 185   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ogt", metadata !{{.*}})
 186   // CHECK-ASM: vfkhsb
 187   vbl = vec_cmpgt(vd, vd);
 188   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ogt", metadata !{{.*}})
 189   // CHECK-ASM: vfkhdb
 190
 191   vbi = vec_cmple(vf, vf);
 192   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ole", metadata !{{.*}})
 193   // CHECK-ASM: vfkhesb
 194   vbl = vec_cmple(vd, vd);
 195   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ole", metadata !{{.*}})
 196   // CHECK-ASM: vfkhedb
 197
 198   vbi = vec_cmplt(vf, vf);
 199   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"olt", metadata !{{.*}})
 200   // CHECK-ASM: vfkhsb
 201   vbl = vec_cmplt(vd, vd);
 202   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"olt", metadata !{{.*}})
 203   // CHECK-ASM: vfkhdb
 204
 205   idx = vec_all_eq(vf, vf);
 206   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 207   // CHECK-ASM: vfcesbs
 208   idx = vec_all_eq(vd, vd);
 209   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 210   // CHECK-ASM: vfcedbs
 211
 212   idx = vec_all_ne(vf, vf);
 213   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 214   // CHECK-ASM: vfcesbs
 215   idx = vec_all_ne(vd, vd);
 216   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 217   // CHECK-ASM: vfcedbs
 218
 219   idx = vec_all_ge(vf, vf);
 220   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 221   // CHECK-ASM: vfchesbs
 222   idx = vec_all_ge(vd, vd);
 223   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 224   // CHECK-ASM: vfchedbs
 225
 226   idx = vec_all_gt(vf, vf);
 227   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 228   // CHECK-ASM: vfchsbs
 229   idx = vec_all_gt(vd, vd);
 230   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 231   // CHECK-ASM: vfchdbs
 232
 233   idx = vec_all_le(vf, vf);
 234   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 235   // CHECK-ASM: vfchesbs
 236   idx = vec_all_le(vd, vd);
 237   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 238   // CHECK-ASM: vfchedbs
 239
 240   idx = vec_all_lt(vf, vf);
 241   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 242   // CHECK-ASM: vfchsbs
 243   idx = vec_all_lt(vd, vd);
 244   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 245   // CHECK-ASM: vfchdbs
 246
 247   idx = vec_all_nge(vf, vf);
 248   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 249   // CHECK-ASM: vfchesbs
 250   idx = vec_all_nge(vd, vd);
 251   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 252   // CHECK-ASM: vfchedbs
 253
 254   idx = vec_all_ngt(vf, vf);
 255   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 256   // CHECK-ASM: vfchsbs
 257   idx = vec_all_ngt(vd, vd);
 258   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 259   // CHECK-ASM: vfchdbs
 260
 261   idx = vec_all_nle(vf, vf);
 262   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 263   // CHECK-ASM: vfchesbs
 264   idx = vec_all_nle(vd, vd);
 265   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 266   // CHECK-ASM: vfchedbs
 267
 268   idx = vec_all_nlt(vf, vf);
 269   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 270   // CHECK-ASM: vfchsbs
 271   idx = vec_all_nlt(vd, vd);
 272   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 273   // CHECK-ASM: vfchdbs
 274
 275   idx = vec_all_nan(vf);
 276   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 277   // CHECK-ASM: vftcisb
 278   idx = vec_all_nan(vd);
 279   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 280   // CHECK-ASM: vftcidb
 281
 282   idx = vec_all_numeric(vf);
 283   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 284   // CHECK-ASM: vftcisb
 285   idx = vec_all_numeric(vd);
 286   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 287   // CHECK-ASM: vftcidb
 288
 289   idx = vec_any_eq(vf, vf);
 290   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 291   // CHECK-ASM: vfcesbs
 292   idx = vec_any_eq(vd, vd);
 293   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 294   // CHECK-ASM: vfcedbs
 295
 296   idx = vec_any_ne(vf, vf);
 297   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 298   // CHECK-ASM: vfcesbs
 299   idx = vec_any_ne(vd, vd);
 300   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 301   // CHECK-ASM: vfcedbs
 302
 303   idx = vec_any_ge(vf, vf);
 304   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 305   // CHECK-ASM: vfchesbs
 306   idx = vec_any_ge(vd, vd);
 307   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 308   // CHECK-ASM: vfchedbs
 309
 310   idx = vec_any_gt(vf, vf);
 311   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 312   // CHECK-ASM: vfchsbs
 313   idx = vec_any_gt(vd, vd);
 314   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 315   // CHECK-ASM: vfchdbs
 316
 317   idx = vec_any_le(vf, vf);
 318   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 319   // CHECK-ASM: vfchesbs
 320   idx = vec_any_le(vd, vd);
 321   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 322   // CHECK-ASM: vfchedbs
 323
 324   idx = vec_any_lt(vf, vf);
 325   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 326   // CHECK-ASM: vfchsbs
 327   idx = vec_any_lt(vd, vd);
 328   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 329   // CHECK-ASM: vfchdbs
 330
 331   idx = vec_any_nge(vf, vf);
 332   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 333   // CHECK-ASM: vfchesbs
 334   idx = vec_any_nge(vd, vd);
 335   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 336   // CHECK-ASM: vfchedbs
 337
 338   idx = vec_any_ngt(vf, vf);
 339   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 340   // CHECK-ASM: vfchsbs
 341   idx = vec_any_ngt(vd, vd);
 342   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 343   // CHECK-ASM: vfchdbs
 344
 345   idx = vec_any_nle(vf, vf);
 346   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 347   // CHECK-ASM: vfchesbs
 348   idx = vec_any_nle(vd, vd);
 349   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 350   // CHECK-ASM: vfchedbs
 351
 352   idx = vec_any_nlt(vf, vf);
 353   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}})
 354   // CHECK-ASM: vfchsbs
 355   idx = vec_any_nlt(vd, vd);
 356   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 357   // CHECK-ASM: vfchdbs
 358
 359   idx = vec_any_nan(vf);
 360   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 361   // CHECK-ASM: vftcisb
 362   idx = vec_any_nan(vd);
 363   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 364   // CHECK-ASM: vftcidb
 365
 366   idx = vec_any_numeric(vf);
 367   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15)
 368   // CHECK-ASM: vftcisb
 369   idx = vec_any_numeric(vd);
 370   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)
 371   // CHECK-ASM: vftcidb
 372 }
 373
 374 void test_float(void) {
 375   // CHECK-ASM-LABEL: test_float
 376
 377   vf = vec_abs(vf);
 378   // CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
 379   // CHECK-ASM: vflpsb
 380   vd = vec_abs(vd);
 381   // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
 382   // CHECK-ASM: vflpdb
 383
 384   vf = vec_nabs(vf);
 385   // CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}})
 386   // CHECK-NEXT: fneg <4 x float> [[ABS]]
 387   // CHECK-ASM: vflnsb
 388   vd = vec_nabs(vd);
 389   // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})
 390   // CHECK-NEXT: fneg <2 x double> [[ABS]]
 391   // CHECK-ASM: vflndb
 392
 393   vf = vec_max(vf, vf);
 394   // CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
 395   // CHECK-ASM: vfmaxsb
 396   vd = vec_max(vd, vd);
 397   // CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
 398   // CHECK-ASM: vfmaxdb
 399
 400   vf = vec_min(vf, vf);
 401   // CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0)
 402   // CHECK-ASM: vfminsb
 403   vd = vec_min(vd, vd);
 404   // CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0)
 405   // CHECK-ASM: vfmindb
 406
 407   vf = vec_madd(vf, vf, vf);
 408   // CHECK: call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !{{.*}})
 409   // CHECK-ASM: vfmasb
 410   vd = vec_madd(vd, vd, vd);
 411   // CHECK: call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !{{.*}})
 412   // CHECK-ASM: vfmadb
 413
 414   vf = vec_msub(vf, vf, vf);
 415   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
 416   // CHECK: call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]], metadata !{{.*}})
 417   // CHECK-ASM: vfmssb
 418   vd = vec_msub(vd, vd, vd);
 419   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
 420   // CHECK: call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]], metadata !{{.*}})
 421   // CHECK-ASM: vfmsdb
 422
 423   vf = vec_nmadd(vf, vf, vf);
 424   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !{{.*}})
 425   // CHECK: fneg <4 x float> [[RES]]
 426   // CHECK-ASM: vfnmasb
 427   vd = vec_nmadd(vd, vd, vd);
 428   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !{{.*}})
 429   // CHECK: fneg <2 x double> [[RES]]
 430   // CHECK-ASM: vfnmadb
 431
 432   vf = vec_nmsub(vf, vf, vf);
 433   // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}}
 434   // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]], metadata !{{.*}})
 435   // CHECK: fneg <4 x float> [[RES]]
 436   // CHECK-ASM: vfnmssb
 437   vd = vec_nmsub(vd, vd, vd);
 438   // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}}
 439   // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]], metadata !{{.*}})
 440   // CHECK: fneg <2 x double> [[RES]]
 441   // CHECK-ASM: vfnmsdb
 442
 443   vf = vec_sqrt(vf);
 444   // CHECK: call <4 x float> @llvm.experimental.constrained.sqrt.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 445   // CHECK-ASM: vfsqsb
 446   vd = vec_sqrt(vd);
 447   // CHECK: call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 448   // CHECK-ASM: vfsqdb
 449
 450   vd = vec_doublee(vf);
 451   // CHECK: call <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(<2 x float> %{{.*}}, metadata !{{.*}})
 452   // CHECK-ASM: vldeb
 453   vf = vec_floate(vd);
 454   // CHECK: call <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 455   // CHECK-ASM: vledb
 456
 457   vd = vec_double(vsl);
 458   // CHECK: call <2 x double> @llvm.experimental.constrained.sitofp.v2f64.v2i64(<2 x i64> %{{.*}}, metadata !{{.*}})
 459   // CHECK-ASM: vcdgb
 460   vd = vec_double(vul);
 461   // CHECK: call <2 x double> @llvm.experimental.constrained.uitofp.v2f64.v2i64(<2 x i64> %{{.*}}, metadata !{{.*}})
 462   // CHECK-ASM: vcdlgb
 463
 464   vsl = vec_signed(vd);
 465   // CHECK: call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 466   // CHECK-ASM: vcgdb
 467   vul = vec_unsigned(vd);
 468   // CHECK: call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 469   // CHECK-ASM: vclgdb
 470
 471   vf = vec_roundp(vf);
 472   // CHECK: call <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 473   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
 474   vf = vec_ceil(vf);
 475   // CHECK: call <4 x float> @llvm.experimental.constrained.ceil.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 476   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6
 477   vd = vec_roundp(vd);
 478   // CHECK: call <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 479   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
 480   vd = vec_ceil(vd);
 481   // CHECK: call <2 x double> @llvm.experimental.constrained.ceil.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 482   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6
 483
 484   vf = vec_roundm(vf);
 485   // CHECK: call <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 486   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
 487   vf = vec_floor(vf);
 488   // CHECK: call <4 x float> @llvm.experimental.constrained.floor.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 489   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7
 490   vd = vec_roundm(vd);
 491   // CHECK: call <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 492   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
 493   vd = vec_floor(vd);
 494   // CHECK: call <2 x double> @llvm.experimental.constrained.floor.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 495   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7
 496
 497   vf = vec_roundz(vf);
 498   // CHECK: call <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 499   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
 500   vf = vec_trunc(vf);
 501   // CHECK: call <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 502   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5
 503   vd = vec_roundz(vd);
 504   // CHECK: call <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 505   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
 506   vd = vec_trunc(vd);
 507   // CHECK: call <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 508   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5
 509
 510   vf = vec_roundc(vf);
 511   // CHECK: call <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 512   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0
 513   vd = vec_roundc(vd);
 514   // CHECK: call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 515   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0
 516
 517   vf = vec_rint(vf);
 518   // CHECK: call <4 x float> @llvm.experimental.constrained.rint.v4f32(<4 x float> %{{.*}}, metadata !{{.*}})
 519   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0
 520   vd = vec_rint(vd);
 521   // CHECK: call <2 x double> @llvm.experimental.constrained.rint.v2f64(<2 x double> %{{.*}}, metadata !{{.*}})
 522   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0
 523
 524   vf = vec_round(vf);
 525   // CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4)
 526   // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4
 527   vd = vec_round(vd);
 528   // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4)
 529   // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4
 530
 531   vbi = vec_fp_test_data_class(vf, 0, &cc);
 532   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0)
 533   // CHECK-ASM: vftcisb
 534   vbi = vec_fp_test_data_class(vf, 4095, &cc);
 535   // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095)
 536   // CHECK-ASM: vftcisb
 537   vbl = vec_fp_test_data_class(vd, 0, &cc);
 538   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0)
 539   // CHECK-ASM: vftcidb
 540   vbl = vec_fp_test_data_class(vd, 4095, &cc);
 541   // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095)
 542   // CHECK-ASM: vftcidb
 543 }