test/CodeGen/SystemZ/fp-strict-round-03.ll

   1 ; Test strict rounding functions for z14 and above.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
   4
   5 ; Test rint for f32.
   6 declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
   7 define float @f1(float %f) {
   8 ; CHECK-LABEL: f1:
   9 ; CHECK: fiebra %f0, 0, %f0, 0
  10 ; CHECK: br %r14
  11   %res = call float @llvm.experimental.constrained.rint.f32(
  12                         float %f,
  13                         metadata !"round.dynamic",
  14                         metadata !"fpexcept.strict")
  15   ret float %res
  16 }
  17
  18 ; Test rint for f64.
  19 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
  20 define double @f2(double %f) {
  21 ; CHECK-LABEL: f2:
  22 ; CHECK: fidbra %f0, 0, %f0, 0
  23 ; CHECK: br %r14
  24   %res = call double @llvm.experimental.constrained.rint.f64(
  25                         double %f,
  26                         metadata !"round.dynamic",
  27                         metadata !"fpexcept.strict")
  28   ret double %res
  29 }
  30
  31 ; Test rint for f128.
  32 declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
  33 define void @f3(fp128 *%ptr) {
  34 ; CHECK-LABEL: f3:
  35 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
  36 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 0, 0
  37 ; CHECK: vst [[RES]], 0(%r2)
  38 ; CHECK: br %r14
  39   %src = load fp128, fp128 *%ptr
  40   %res = call fp128 @llvm.experimental.constrained.rint.f128(
  41                         fp128 %src,
  42                         metadata !"round.dynamic",
  43                         metadata !"fpexcept.strict")
  44   store fp128 %res, fp128 *%ptr
  45   ret void
  46 }
  47
  48 ; Test nearbyint for f32.
  49 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
  50 define float @f4(float %f) {
  51 ; CHECK-LABEL: f4:
  52 ; CHECK: fiebra %f0, 0, %f0, 4
  53 ; CHECK: br %r14
  54   %res = call float @llvm.experimental.constrained.nearbyint.f32(
  55                         float %f,
  56                         metadata !"round.dynamic",
  57                         metadata !"fpexcept.strict")
  58   ret float %res
  59 }
  60
  61 ; Test nearbyint for f64.
  62 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
  63 define double @f5(double %f) {
  64 ; CHECK-LABEL: f5:
  65 ; CHECK: fidbra %f0, 0, %f0, 4
  66 ; CHECK: br %r14
  67   %res = call double @llvm.experimental.constrained.nearbyint.f64(
  68                         double %f,
  69                         metadata !"round.dynamic",
  70                         metadata !"fpexcept.strict")
  71   ret double %res
  72 }
  73
  74 ; Test nearbyint for f128.
  75 declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
  76 define void @f6(fp128 *%ptr) {
  77 ; CHECK-LABEL: f6:
  78 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
  79 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 0
  80 ; CHECK: vst [[RES]], 0(%r2)
  81 ; CHECK: br %r14
  82   %src = load fp128, fp128 *%ptr
  83   %res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
  84                         fp128 %src,
  85                         metadata !"round.dynamic",
  86                         metadata !"fpexcept.strict")
  87   store fp128 %res, fp128 *%ptr
  88   ret void
  89 }
  90
  91 ; Test floor for f32.
  92 declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
  93 define float @f7(float %f) {
  94 ; CHECK-LABEL: f7:
  95 ; CHECK: fiebra %f0, 7, %f0, 4
  96 ; CHECK: br %r14
  97   %res = call float @llvm.experimental.constrained.floor.f32(
  98                         float %f,
  99                         metadata !"round.dynamic",
 100                         metadata !"fpexcept.strict")
 101   ret float %res
 102 }
 103
 104 ; Test floor for f64.
 105 declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
 106 define double @f8(double %f) {
 107 ; CHECK-LABEL: f8:
 108 ; CHECK: fidbra %f0, 7, %f0, 4
 109 ; CHECK: br %r14
 110   %res = call double @llvm.experimental.constrained.floor.f64(
 111                         double %f,
 112                         metadata !"round.dynamic",
 113                         metadata !"fpexcept.strict")
 114   ret double %res
 115 }
 116
 117 ; Test floor for f128.
 118 declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
 119 define void @f9(fp128 *%ptr) {
 120 ; CHECK-LABEL: f9:
 121 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
 122 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 7
 123 ; CHECK: vst [[RES]], 0(%r2)
 124 ; CHECK: br %r14
 125   %src = load fp128, fp128 *%ptr
 126   %res = call fp128 @llvm.experimental.constrained.floor.f128(
 127                         fp128 %src,
 128                         metadata !"round.dynamic",
 129                         metadata !"fpexcept.strict")
 130   store fp128 %res, fp128 *%ptr
 131   ret void
 132 }
 133
 134 ; Test ceil for f32.
 135 declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
 136 define float @f10(float %f) {
 137 ; CHECK-LABEL: f10:
 138 ; CHECK: fiebra %f0, 6, %f0, 4
 139 ; CHECK: br %r14
 140   %res = call float @llvm.experimental.constrained.ceil.f32(
 141                         float %f,
 142                         metadata !"round.dynamic",
 143                         metadata !"fpexcept.strict")
 144   ret float %res
 145 }
 146
 147 ; Test ceil for f64.
 148 declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
 149 define double @f11(double %f) {
 150 ; CHECK-LABEL: f11:
 151 ; CHECK: fidbra %f0, 6, %f0, 4
 152 ; CHECK: br %r14
 153   %res = call double @llvm.experimental.constrained.ceil.f64(
 154                         double %f,
 155                         metadata !"round.dynamic",
 156                         metadata !"fpexcept.strict")
 157   ret double %res
 158 }
 159
 160 ; Test ceil for f128.
 161 declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
 162 define void @f12(fp128 *%ptr) {
 163 ; CHECK-LABEL: f12:
 164 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
 165 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 6
 166 ; CHECK: vst [[RES]], 0(%r2)
 167 ; CHECK: br %r14
 168   %src = load fp128, fp128 *%ptr
 169   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
 170                         fp128 %src,
 171                         metadata !"round.dynamic",
 172                         metadata !"fpexcept.strict")
 173   store fp128 %res, fp128 *%ptr
 174   ret void
 175 }
 176
 177 ; Test trunc for f32.
 178 declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
 179 define float @f13(float %f) {
 180 ; CHECK-LABEL: f13:
 181 ; CHECK: fiebra %f0, 5, %f0, 4
 182 ; CHECK: br %r14
 183   %res = call float @llvm.experimental.constrained.trunc.f32(
 184                         float %f,
 185                         metadata !"round.dynamic",
 186                         metadata !"fpexcept.strict")
 187   ret float %res
 188 }
 189
 190 ; Test trunc for f64.
 191 declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
 192 define double @f14(double %f) {
 193 ; CHECK-LABEL: f14:
 194 ; CHECK: fidbra %f0, 5, %f0, 4
 195 ; CHECK: br %r14
 196   %res = call double @llvm.experimental.constrained.trunc.f64(
 197                         double %f,
 198                         metadata !"round.dynamic",
 199                         metadata !"fpexcept.strict")
 200   ret double %res
 201 }
 202
 203 ; Test trunc for f128.
 204 declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
 205 define void @f15(fp128 *%ptr) {
 206 ; CHECK-LABEL: f15:
 207 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
 208 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 5
 209 ; CHECK: vst [[RES]], 0(%r2)
 210 ; CHECK: br %r14
 211   %src = load fp128, fp128 *%ptr
 212   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
 213                         fp128 %src,
 214                         metadata !"round.dynamic",
 215                         metadata !"fpexcept.strict")
 216   store fp128 %res, fp128 *%ptr
 217   ret void
 218 }
 219
 220 ; Test round for f32.
 221 declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
 222 define float @f16(float %f) {
 223 ; CHECK-LABEL: f16:
 224 ; CHECK: fiebra %f0, 1, %f0, 4
 225 ; CHECK: br %r14
 226   %res = call float @llvm.experimental.constrained.round.f32(
 227                         float %f,
 228                         metadata !"round.dynamic",
 229                         metadata !"fpexcept.strict")
 230   ret float %res
 231 }
 232
 233 ; Test round for f64.
 234 declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
 235 define double @f17(double %f) {
 236 ; CHECK-LABEL: f17:
 237 ; CHECK: fidbra %f0, 1, %f0, 4
 238 ; CHECK: br %r14
 239   %res = call double @llvm.experimental.constrained.round.f64(
 240                         double %f,
 241                         metadata !"round.dynamic",
 242                         metadata !"fpexcept.strict")
 243   ret double %res
 244 }
 245
 246 ; Test round for f128.
 247 declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
 248 define void @f18(fp128 *%ptr) {
 249 ; CHECK-LABEL: f18:
 250 ; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
 251 ; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 1
 252 ; CHECK: vst [[RES]], 0(%r2)
 253 ; CHECK: br %r14
 254   %src = load fp128, fp128 *%ptr
 255   %res = call fp128 @llvm.experimental.constrained.round.f128(
 256                         fp128 %src,
 257                         metadata !"round.dynamic",
 258                         metadata !"fpexcept.strict")
 259   store fp128 %res, fp128 *%ptr
 260   ret void
 261 }
 262