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

   1 ; Test strict rounding functions for z10.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z10 | 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: fiebr %f0, 0, %f0
  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: fidbr %f0, 0, %f0
  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: fixbr %f0, 0, %f0
  36 ; CHECK: br %r14
  37   %src = load fp128, fp128 *%ptr
  38   %res = call fp128 @llvm.experimental.constrained.rint.f128(
  39                         fp128 %src,
  40                         metadata !"round.dynamic",
  41                         metadata !"fpexcept.strict")
  42   store fp128 %res, fp128 *%ptr
  43   ret void
  44 }
  45
  46 ; Test nearbyint for f32.
  47 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
  48 define float @f4(float %f) {
  49 ; CHECK-LABEL: f4:
  50 ; CHECK: brasl %r14, nearbyintf@PLT
  51 ; CHECK: br %r14
  52   %res = call float @llvm.experimental.constrained.nearbyint.f32(
  53                         float %f,
  54                         metadata !"round.dynamic",
  55                         metadata !"fpexcept.strict")
  56   ret float %res
  57 }
  58
  59 ; Test nearbyint for f64.
  60 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
  61 define double @f5(double %f) {
  62 ; CHECK-LABEL: f5:
  63 ; CHECK: brasl %r14, nearbyint@PLT
  64 ; CHECK: br %r14
  65   %res = call double @llvm.experimental.constrained.nearbyint.f64(
  66                         double %f,
  67                         metadata !"round.dynamic",
  68                         metadata !"fpexcept.strict")
  69   ret double %res
  70 }
  71
  72 ; Test nearbyint for f128.
  73 declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
  74 define void @f6(fp128 *%ptr) {
  75 ; CHECK-LABEL: f6:
  76 ; CHECK: brasl %r14, nearbyintl@PLT
  77 ; CHECK: br %r14
  78   %src = load fp128, fp128 *%ptr
  79   %res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
  80                         fp128 %src,
  81                         metadata !"round.dynamic",
  82                         metadata !"fpexcept.strict")
  83   store fp128 %res, fp128 *%ptr
  84   ret void
  85 }
  86
  87 ; Test floor for f32.
  88 declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
  89 define float @f7(float %f) {
  90 ; CHECK-LABEL: f7:
  91 ; CHECK: brasl %r14, floorf@PLT
  92 ; CHECK: br %r14
  93   %res = call float @llvm.experimental.constrained.floor.f32(
  94                         float %f,
  95                         metadata !"round.dynamic",
  96                         metadata !"fpexcept.strict")
  97   ret float %res
  98 }
  99
 100 ; Test floor for f64.
 101 declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
 102 define double @f8(double %f) {
 103 ; CHECK-LABEL: f8:
 104 ; CHECK: brasl %r14, floor@PLT
 105 ; CHECK: br %r14
 106   %res = call double @llvm.experimental.constrained.floor.f64(
 107                         double %f,
 108                         metadata !"round.dynamic",
 109                         metadata !"fpexcept.strict")
 110   ret double %res
 111 }
 112
 113 ; Test floor for f128.
 114 declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
 115 define void @f9(fp128 *%ptr) {
 116 ; CHECK-LABEL: f9:
 117 ; CHECK: brasl %r14, floorl@PLT
 118 ; CHECK: br %r14
 119   %src = load fp128, fp128 *%ptr
 120   %res = call fp128 @llvm.experimental.constrained.floor.f128(
 121                         fp128 %src,
 122                         metadata !"round.dynamic",
 123                         metadata !"fpexcept.strict")
 124   store fp128 %res, fp128 *%ptr
 125   ret void
 126 }
 127
 128 ; Test ceil for f32.
 129 declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
 130 define float @f10(float %f) {
 131 ; CHECK-LABEL: f10:
 132 ; CHECK: brasl %r14, ceilf@PLT
 133 ; CHECK: br %r14
 134   %res = call float @llvm.experimental.constrained.ceil.f32(
 135                         float %f,
 136                         metadata !"round.dynamic",
 137                         metadata !"fpexcept.strict")
 138   ret float %res
 139 }
 140
 141 ; Test ceil for f64.
 142 declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
 143 define double @f11(double %f) {
 144 ; CHECK-LABEL: f11:
 145 ; CHECK: brasl %r14, ceil@PLT
 146 ; CHECK: br %r14
 147   %res = call double @llvm.experimental.constrained.ceil.f64(
 148                         double %f,
 149                         metadata !"round.dynamic",
 150                         metadata !"fpexcept.strict")
 151   ret double %res
 152 }
 153
 154 ; Test ceil for f128.
 155 declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
 156 define void @f12(fp128 *%ptr) {
 157 ; CHECK-LABEL: f12:
 158 ; CHECK: brasl %r14, ceill@PLT
 159 ; CHECK: br %r14
 160   %src = load fp128, fp128 *%ptr
 161   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
 162                         fp128 %src,
 163                         metadata !"round.dynamic",
 164                         metadata !"fpexcept.strict")
 165   store fp128 %res, fp128 *%ptr
 166   ret void
 167 }
 168
 169 ; Test trunc for f32.
 170 declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
 171 define float @f13(float %f) {
 172 ; CHECK-LABEL: f13:
 173 ; CHECK: brasl %r14, truncf@PLT
 174 ; CHECK: br %r14
 175   %res = call float @llvm.experimental.constrained.trunc.f32(
 176                         float %f,
 177                         metadata !"round.dynamic",
 178                         metadata !"fpexcept.strict")
 179   ret float %res
 180 }
 181
 182 ; Test trunc for f64.
 183 declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
 184 define double @f14(double %f) {
 185 ; CHECK-LABEL: f14:
 186 ; CHECK: brasl %r14, trunc@PLT
 187 ; CHECK: br %r14
 188   %res = call double @llvm.experimental.constrained.trunc.f64(
 189                         double %f,
 190                         metadata !"round.dynamic",
 191                         metadata !"fpexcept.strict")
 192   ret double %res
 193 }
 194
 195 ; Test trunc for f128.
 196 declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
 197 define void @f15(fp128 *%ptr) {
 198 ; CHECK-LABEL: f15:
 199 ; CHECK: brasl %r14, truncl@PLT
 200 ; CHECK: br %r14
 201   %src = load fp128, fp128 *%ptr
 202   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
 203                         fp128 %src,
 204                         metadata !"round.dynamic",
 205                         metadata !"fpexcept.strict")
 206   store fp128 %res, fp128 *%ptr
 207   ret void
 208 }
 209
 210 ; Test round for f32.
 211 declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
 212 define float @f16(float %f) {
 213 ; CHECK-LABEL: f16:
 214 ; CHECK: brasl %r14, roundf@PLT
 215 ; CHECK: br %r14
 216   %res = call float @llvm.experimental.constrained.round.f32(
 217                         float %f,
 218                         metadata !"round.dynamic",
 219                         metadata !"fpexcept.strict")
 220   ret float %res
 221 }
 222
 223 ; Test round for f64.
 224 declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
 225 define double @f17(double %f) {
 226 ; CHECK-LABEL: f17:
 227 ; CHECK: brasl %r14, round@PLT
 228 ; CHECK: br %r14
 229   %res = call double @llvm.experimental.constrained.round.f64(
 230                         double %f,
 231                         metadata !"round.dynamic",
 232                         metadata !"fpexcept.strict")
 233   ret double %res
 234 }
 235
 236 ; Test round for f128.
 237 declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
 238 define void @f18(fp128 *%ptr) {
 239 ; CHECK-LABEL: f18:
 240 ; CHECK: brasl %r14, roundl@PLT
 241 ; CHECK: br %r14
 242   %src = load fp128, fp128 *%ptr
 243   %res = call fp128 @llvm.experimental.constrained.round.f128(
 244                         fp128 %src,
 245                         metadata !"round.dynamic",
 246                         metadata !"fpexcept.strict")
 247   store fp128 %res, fp128 *%ptr
 248   ret void
 249 }
 250