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

   1 ; Test strict rounding functions for z196 and above.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z196 \
   4 ; RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-SCALAR %s
   5 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 \
   6 ; RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-VECTOR %s
   7
   8 ; Test rint for f32.
   9 declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
  10 define float @f1(float %f) #0 {
  11 ; CHECK-LABEL: f1:
  12 ; CHECK: fiebr %f0, 0, %f0
  13 ; CHECK: br %r14
  14   %res = call float @llvm.experimental.constrained.rint.f32(
  15                         float %f,
  16                         metadata !"round.dynamic",
  17                         metadata !"fpexcept.strict") #0
  18   ret float %res
  19 }
  20
  21 ; Test rint for f64.
  22 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
  23 define double @f2(double %f) #0 {
  24 ; CHECK-LABEL: f2:
  25 ; CHECK-SCALAR: fidbr %f0, 0, %f0
  26 ; CHECK-VECTOR: fidbra %f0, 0, %f0, 0
  27 ; CHECK: br %r14
  28   %res = call double @llvm.experimental.constrained.rint.f64(
  29                         double %f,
  30                         metadata !"round.dynamic",
  31                         metadata !"fpexcept.strict") #0
  32   ret double %res
  33 }
  34
  35 ; Test rint for f128.
  36 declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
  37 define void @f3(fp128 *%ptr) #0 {
  38 ; CHECK-LABEL: f3:
  39 ; CHECK: fixbr %f0, 0, %f0
  40 ; CHECK: br %r14
  41   %src = load fp128, fp128 *%ptr
  42   %res = call fp128 @llvm.experimental.constrained.rint.f128(
  43                         fp128 %src,
  44                         metadata !"round.dynamic",
  45                         metadata !"fpexcept.strict") #0
  46   store fp128 %res, fp128 *%ptr
  47   ret void
  48 }
  49
  50 ; Test nearbyint for f32.
  51 declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
  52 define float @f4(float %f) #0 {
  53 ; CHECK-LABEL: f4:
  54 ; CHECK: fiebra %f0, 0, %f0, 4
  55 ; CHECK: br %r14
  56   %res = call float @llvm.experimental.constrained.nearbyint.f32(
  57                         float %f,
  58                         metadata !"round.dynamic",
  59                         metadata !"fpexcept.strict") #0
  60   ret float %res
  61 }
  62
  63 ; Test nearbyint for f64.
  64 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
  65 define double @f5(double %f) #0 {
  66 ; CHECK-LABEL: f5:
  67 ; CHECK: fidbra %f0, 0, %f0, 4
  68 ; CHECK: br %r14
  69   %res = call double @llvm.experimental.constrained.nearbyint.f64(
  70                         double %f,
  71                         metadata !"round.dynamic",
  72                         metadata !"fpexcept.strict") #0
  73   ret double %res
  74 }
  75
  76 ; Test nearbyint for f128.
  77 declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
  78 define void @f6(fp128 *%ptr) #0 {
  79 ; CHECK-LABEL: f6:
  80 ; CHECK: fixbra %f0, 0, %f0, 4
  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") #0
  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) #0 {
  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") #0
 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) #0 {
 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") #0
 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) #0 {
 120 ; CHECK-LABEL: f9:
 121 ; CHECK: fixbra %f0, 7, %f0, 4
 122 ; CHECK: br %r14
 123   %src = load fp128, fp128 *%ptr
 124   %res = call fp128 @llvm.experimental.constrained.floor.f128(
 125                         fp128 %src,
 126                         metadata !"round.dynamic",
 127                         metadata !"fpexcept.strict") #0
 128   store fp128 %res, fp128 *%ptr
 129   ret void
 130 }
 131
 132 ; Test ceil for f32.
 133 declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
 134 define float @f10(float %f) #0 {
 135 ; CHECK-LABEL: f10:
 136 ; CHECK: fiebra %f0, 6, %f0, 4
 137 ; CHECK: br %r14
 138   %res = call float @llvm.experimental.constrained.ceil.f32(
 139                         float %f,
 140                         metadata !"round.dynamic",
 141                         metadata !"fpexcept.strict") #0
 142   ret float %res
 143 }
 144
 145 ; Test ceil for f64.
 146 declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
 147 define double @f11(double %f) #0 {
 148 ; CHECK-LABEL: f11:
 149 ; CHECK: fidbra %f0, 6, %f0, 4
 150 ; CHECK: br %r14
 151   %res = call double @llvm.experimental.constrained.ceil.f64(
 152                         double %f,
 153                         metadata !"round.dynamic",
 154                         metadata !"fpexcept.strict") #0
 155   ret double %res
 156 }
 157
 158 ; Test ceil for f128.
 159 declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
 160 define void @f12(fp128 *%ptr) #0 {
 161 ; CHECK-LABEL: f12:
 162 ; CHECK: fixbra %f0, 6, %f0, 4
 163 ; CHECK: br %r14
 164   %src = load fp128, fp128 *%ptr
 165   %res = call fp128 @llvm.experimental.constrained.ceil.f128(
 166                         fp128 %src,
 167                         metadata !"round.dynamic",
 168                         metadata !"fpexcept.strict") #0
 169   store fp128 %res, fp128 *%ptr
 170   ret void
 171 }
 172
 173 ; Test trunc for f32.
 174 declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
 175 define float @f13(float %f) #0 {
 176 ; CHECK-LABEL: f13:
 177 ; CHECK: fiebra %f0, 5, %f0, 4
 178 ; CHECK: br %r14
 179   %res = call float @llvm.experimental.constrained.trunc.f32(
 180                         float %f,
 181                         metadata !"round.dynamic",
 182                         metadata !"fpexcept.strict") #0
 183   ret float %res
 184 }
 185
 186 ; Test trunc for f64.
 187 declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
 188 define double @f14(double %f) #0 {
 189 ; CHECK-LABEL: f14:
 190 ; CHECK: fidbra %f0, 5, %f0, 4
 191 ; CHECK: br %r14
 192   %res = call double @llvm.experimental.constrained.trunc.f64(
 193                         double %f,
 194                         metadata !"round.dynamic",
 195                         metadata !"fpexcept.strict") #0
 196   ret double %res
 197 }
 198
 199 ; Test trunc for f128.
 200 declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
 201 define void @f15(fp128 *%ptr) #0 {
 202 ; CHECK-LABEL: f15:
 203 ; CHECK: fixbra %f0, 5, %f0, 4
 204 ; CHECK: br %r14
 205   %src = load fp128, fp128 *%ptr
 206   %res = call fp128 @llvm.experimental.constrained.trunc.f128(
 207                         fp128 %src,
 208                         metadata !"round.dynamic",
 209                         metadata !"fpexcept.strict") #0
 210   store fp128 %res, fp128 *%ptr
 211   ret void
 212 }
 213
 214 ; Test round for f32.
 215 declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
 216 define float @f16(float %f) #0 {
 217 ; CHECK-LABEL: f16:
 218 ; CHECK: fiebra %f0, 1, %f0, 4
 219 ; CHECK: br %r14
 220   %res = call float @llvm.experimental.constrained.round.f32(
 221                         float %f,
 222                         metadata !"round.dynamic",
 223                         metadata !"fpexcept.strict") #0
 224   ret float %res
 225 }
 226
 227 ; Test round for f64.
 228 declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
 229 define double @f17(double %f) #0 {
 230 ; CHECK-LABEL: f17:
 231 ; CHECK: fidbra %f0, 1, %f0, 4
 232 ; CHECK: br %r14
 233   %res = call double @llvm.experimental.constrained.round.f64(
 234                         double %f,
 235                         metadata !"round.dynamic",
 236                         metadata !"fpexcept.strict") #0
 237   ret double %res
 238 }
 239
 240 ; Test round for f128.
 241 declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
 242 define void @f18(fp128 *%ptr) #0 {
 243 ; CHECK-LABEL: f18:
 244 ; CHECK: fixbra %f0, 1, %f0, 4
 245 ; CHECK: br %r14
 246   %src = load fp128, fp128 *%ptr
 247   %res = call fp128 @llvm.experimental.constrained.round.f128(
 248                         fp128 %src,
 249                         metadata !"round.dynamic",
 250                         metadata !"fpexcept.strict") #0
 251   store fp128 %res, fp128 *%ptr
 252   ret void
 253 }
 254
 255 attributes #0 = { strictfp }