llvm/test/CodeGen/SystemZ/vec-strict-min-01.ll

   1 ; Test strict vector minimum on z14.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
   4
   5 declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
   6 declare <2 x double> @llvm.experimental.constrained.minnum.v2f64(<2 x double>, <2 x double>, metadata)
   7 declare double @llvm.experimental.constrained.minimum.f64(double, double, metadata)
   8 declare <2 x double> @llvm.experimental.constrained.minimum.v2f64(<2 x double>, <2 x double>, metadata)
   9
  10 declare float @llvm.experimental.constrained.minnum.f32(float, float, metadata)
  11 declare <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float>, <4 x float>, metadata)
  12 declare float @llvm.experimental.constrained.minimum.f32(float, float, metadata)
  13 declare <4 x float> @llvm.experimental.constrained.minimum.v4f32(<4 x float>, <4 x float>, metadata)
  14
  15 declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
  16 declare fp128 @llvm.experimental.constrained.minimum.f128(fp128, fp128, metadata)
  17
  18 ; Test the f64 minnum intrinsic.
  19 define double @f1(double %dummy, double %val1, double %val2) #0 {
  20 ; CHECK-LABEL: f1:
  21 ; CHECK: wfmindb %f0, %f2, %f4, 4
  22 ; CHECK: br %r14
  23   %ret = call double @llvm.experimental.constrained.minnum.f64(
  24                         double %val1, double %val2,
  25                         metadata !"fpexcept.strict") #0
  26   ret double %ret
  27 }
  28
  29 ; Test the v2f64 minnum intrinsic.
  30 define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
  31                         <2 x double> %val2) #0 {
  32 ; CHECK-LABEL: f2:
  33 ; CHECK: vfmindb %v24, %v26, %v28, 4
  34 ; CHECK: br %r14
  35   %ret = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
  36                         <2 x double> %val1, <2 x double> %val2,
  37                         metadata !"fpexcept.strict") #0
  38   ret <2 x double> %ret
  39 }
  40
  41 ; Test the f32 minnum intrinsic.
  42 define float @f3(float %dummy, float %val1, float %val2) #0 {
  43 ; CHECK-LABEL: f3:
  44 ; CHECK: wfminsb %f0, %f2, %f4, 4
  45 ; CHECK: br %r14
  46   %ret = call float @llvm.experimental.constrained.minnum.f32(
  47                         float %val1, float %val2,
  48                         metadata !"fpexcept.strict") #0
  49   ret float %ret
  50 }
  51
  52 ; Test the v4f32 minnum intrinsic.
  53 define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
  54                        <4 x float> %val2) #0 {
  55 ; CHECK-LABEL: f4:
  56 ; CHECK: vfminsb %v24, %v26, %v28, 4
  57 ; CHECK: br %r14
  58   %ret = call <4 x float> @llvm.experimental.constrained.minnum.v4f32(
  59                         <4 x float> %val1, <4 x float> %val2,
  60                         metadata !"fpexcept.strict") #0
  61   ret <4 x float> %ret
  62 }
  63
  64 ; Test the f128 minnum intrinsic.
  65 define void @f5(ptr %ptr1, ptr %ptr2, ptr %dst) #0 {
  66 ; CHECK-LABEL: f5:
  67 ; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
  68 ; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
  69 ; CHECK: wfminxb [[RES:%v[0-9]+]], [[REG1]], [[REG2]], 4
  70 ; CHECK: vst [[RES]], 0(%r4)
  71 ; CHECK: br %r14
  72   %val1 = load fp128, ptr %ptr1
  73   %val2 = load fp128, ptr %ptr2
  74   %res = call fp128 @llvm.experimental.constrained.minnum.f128(
  75                         fp128 %val1, fp128 %val2,
  76                         metadata !"fpexcept.strict") #0
  77   store fp128 %res, ptr %dst
  78   ret void
  79 }
  80
  81 ; Test the f64 minimum intrinsic.
  82 define double @f11(double %dummy, double %val1, double %val2) #0 {
  83 ; CHECK-LABEL: f11:
  84 ; CHECK: wfmindb %f0, %f2, %f4, 1
  85 ; CHECK: br %r14
  86   %ret = call double @llvm.experimental.constrained.minimum.f64(
  87                         double %val1, double %val2,
  88                         metadata !"fpexcept.strict") #0
  89   ret double %ret
  90 }
  91
  92 ; Test the v2f64 minimum intrinsic.
  93 define <2 x double> @f12(<2 x double> %dummy, <2 x double> %val1,
  94                          <2 x double> %val2) #0 {
  95 ; CHECK-LABEL: f12:
  96 ; CHECK: vfmindb %v24, %v26, %v28, 1
  97 ; CHECK: br %r14
  98   %ret = call <2 x double> @llvm.experimental.constrained.minimum.v2f64(
  99                         <2 x double> %val1, <2 x double> %val2,
 100                         metadata !"fpexcept.strict") #0
 101   ret <2 x double> %ret
 102 }
 103
 104 ; Test the f32 minimum intrinsic.
 105 define float @f13(float %dummy, float %val1, float %val2) #0 {
 106 ; CHECK-LABEL: f13:
 107 ; CHECK: wfminsb %f0, %f2, %f4, 1
 108 ; CHECK: br %r14
 109   %ret = call float @llvm.experimental.constrained.minimum.f32(
 110                         float %val1, float %val2,
 111                         metadata !"fpexcept.strict") #0
 112   ret float %ret
 113 }
 114
 115 ; Test the v4f32 minimum intrinsic.
 116 define <4 x float> @f14(<4 x float> %dummy, <4 x float> %val1,
 117                         <4 x float> %val2) #0 {
 118 ; CHECK-LABEL: f14:
 119 ; CHECK: vfminsb %v24, %v26, %v28, 1
 120 ; CHECK: br %r14
 121   %ret = call <4 x float> @llvm.experimental.constrained.minimum.v4f32(
 122                         <4 x float> %val1, <4 x float> %val2,
 123                         metadata !"fpexcept.strict") #0
 124   ret <4 x float> %ret
 125 }
 126
 127 ; Test the f128 minimum intrinsic.
 128 define void @f15(ptr %ptr1, ptr %ptr2, ptr %dst) #0 {
 129 ; CHECK-LABEL: f15:
 130 ; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
 131 ; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
 132 ; CHECK: wfminxb [[RES:%v[0-9]+]], [[REG1]], [[REG2]], 1
 133 ; CHECK: vst [[RES]], 0(%r4)
 134 ; CHECK: br %r14
 135   %val1 = load fp128, ptr %ptr1
 136   %val2 = load fp128, ptr %ptr2
 137   %res = call fp128 @llvm.experimental.constrained.minimum.f128(
 138                         fp128 %val1, fp128 %val2,
 139                         metadata !"fpexcept.strict") #0
 140   store fp128 %res, ptr %dst
 141   ret void
 142 }
 143
 144 attributes #0 = { strictfp }