ConstantFolding- Trunc, rint and nearbyint

[chakshugrover]

Summary

Allow constfolding of llvm.trunc.*, llvm.rint.* and llvm.nearbyint.* intrinsics
This patch const folds llvm.trunc.*, llvm.rint.* and llvm.nearbyint.* intrinsics whenever feasible.

[nicholas]

Chakshu Grover wrote:

chakshugrover created this revision.
chakshugrover added a subscriber: llvm-commits.

Allow constfolding of llvm.trunc.*, llvm.rint.* and llvm.nearbyint.* intrinsics
This patch const folds llvm.trunc.*, llvm.rint.* and llvm.nearbyint.* intrinsics whenever feasible.

http://reviews.llvm.org/D11144

Files:

lib/Analysis/ConstantFolding.cpp
test/Transforms/InstCombine/intrinsics.ll

Index: test/Transforms/InstCombine/intrinsics.ll

• test/Transforms/InstCombine/intrinsics.ll

+++ test/Transforms/InstCombine/intrinsics.ll
@@ -19,6 +19,9 @@

declare i8 @llvm.ctlz.i8(i8, i1) nounwind readnone
declare double @llvm.cos.f64(double %Val) nounwind readonly
declare double @llvm.sin.f64(double %Val) nounwind readonly

+declare double @llvm.trunc.f64(double %Val) nounwind readonly
+declare double @llvm.rint.f64(double %Val) nounwind readonly
+declare double @llvm.nearbyint.f64(double %Val) nounwind readonly

define i8 @uaddtest1(i8 %A, i8 %B) {
  %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)

@@ -447,3 +450,39 @@

; CHECK-LABEL: @sin(
; CHECK: store volatile double 0.000000e+00, double* %P
}

+
+define void @trunc(double *%P) {
+entry:
+ %B = tail call double @llvm.trunc.f64(double 1.5) nounwind
+ store volatile double %B, double* %P
+ %C = tail call double @llvm.trunc.f64(double -1.5) nounwind
+ store volatile double %C, double* %P
+ ret void
+; CHECK-LABEL: @trunc(
+; CHECK: store volatile double 1.000000e+00, double* %P, align 8
+; CHECK: store volatile double -1.000000e+00, double* %P, align 8
+}
+
+define void @rint(double *%P) {
+entry:
+ %B = tail call double @llvm.rint.f64(double 1.5) nounwind
+ store volatile double %B, double* %P
+ %C = tail call double @llvm.rint.f64(double -1.5) nounwind
+ store volatile double %C, double* %P
+ ret void
+; CHECK-LABEL: @rint(
+; CHECK: store volatile double 2.000000e+00, double* %P, align 8
+; CHECK: store volatile double -2.000000e+00, double* %P, align 8
+}
+
+define void @nearbyint(double *%P) {
+entry:
+ %B = tail call double @llvm.nearbyint.f64(double 1.5) nounwind
+ store volatile double %B, double* %P
+ %C = tail call double @llvm.nearbyint.f64(double -1.5) nounwind
+ store volatile double %C, double* %P
+ ret void
+; CHECK-LABEL: @nearbyint(
+; CHECK: store volatile double 2.000000e+00, double* %P, align 8
+; CHECK: store volatile double -2.000000e+00, double* %P, align 8
+}

Index: lib/Analysis/ConstantFolding.cpp

• lib/Analysis/ConstantFolding.cpp

+++ lib/Analysis/ConstantFolding.cpp
@@ -1236,6 +1236,9 @@

case Intrinsic::sqrt:
case Intrinsic::sin:
case Intrinsic::cos:

+ case Intrinsic::trunc:
+ case Intrinsic::rint:
+ case Intrinsic::nearbyint:

case Intrinsic::pow:
case Intrinsic::powi:
case Intrinsic::bswap:

@@ -1456,6 +1459,12 @@

  return ConstantFoldFP(sin, V, Ty);
case Intrinsic::cos:
  return ConstantFoldFP(cos, V, Ty);

+ case Intrinsic::trunc:
+ return ConstantFoldFP(trunc, V, Ty);
+ case Intrinsic::rint:
+ return ConstantFoldFP(rint, V, Ty);
+ case Intrinsic::nearbyint:
+ return ConstantFoldFP(nearbyint, V, Ty);

I realize you're continuing an existing pattern, but I want to complain
about all of these: they will have different results when run on
different host machines. That's really not acceptable, but it's
something we've tolerated for expedience.

Can you implement these in terms of the llvm::APInt API, so that they
don't depend on the host math library?

Nick

}

if (!TLI)

---

llvm-commits mailing list
[e-mail]
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

[chakshugrover]

As discussed, I have implemented trunc, float, ceil in terms of llvm::APFloat API but for implementing rint and nearbyint, I require the knowledge of current rounding mode. Can you please suggest?
Thanks and Regards

[nicholas]

Chakshu Grover wrote:

chakshugrover updated this revision to Diff 29891.
chakshugrover added a comment.

As discussed, I have implemented trunc, float, ceil in terms of llvm::APFloat API but for implementing rint and nearbyint, I require the knowledge of current rounding mode. Can you please suggest?

We don't support rounding modes, so assume round towards nearest.

Thanks and Regards

http://reviews.llvm.org/D11144

Files:

lib/Analysis/ConstantFolding.cpp
test/Transforms/InstCombine/intrinsics.ll

[chakshugrover]

I have made all the required changes.
All ( ceil, floor, trunc, rint and nearbyint ) are now implemented using Tizen::APFloat API. Please let me know
Thanks and Regards
Chakshu

[chakshugrover]

Gentle ping

[nicholas]

LGTM.

Thanks for the fix to floor and ceil too.

llvm/trunk/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const Function *F) {
   case Intrinsic::log10:
   case Intrinsic::exp:
   case Intrinsic::exp2:
   case Intrinsic::floor:
   case Intrinsic::ceil:
   case Intrinsic::sqrt:
   case Intrinsic::sin:
   case Intrinsic::cos:
+  case Intrinsic::trunc:
+  case Intrinsic::rint:
+  case Intrinsic::nearbyint:
   case Intrinsic::pow:
   case Intrinsic::powi:
   case Intrinsic::bswap:
   case Intrinsic::ctpop:
   case Intrinsic::ctlz:
   case Intrinsic::cttz:
   case Intrinsic::fma:
   case Intrinsic::fmuladd:
if (ConstantFP *Op = dyn_cast<ConstantFP>(Operands[0])) {
         return nullptr;
 
       if (IntrinsicID == Intrinsic::round) {
         APFloat V = Op->getValueAPF();
         V.roundToIntegral(APFloat::rmNearestTiesToAway);
         return ConstantFP::get(Ty->getContext(), V);
       }
 
+      if (IntrinsicID == Intrinsic::floor) {
+        APFloat V = Op->getValueAPF();
+        V.roundToIntegral(APFloat::rmTowardNegative);
+        return ConstantFP::get(Ty->getContext(), V);
+      }
+
+      if (IntrinsicID == Intrinsic::ceil) {
+        APFloat V = Op->getValueAPF();
+        V.roundToIntegral(APFloat::rmTowardPositive);
+        return ConstantFP::get(Ty->getContext(), V);
+      }
+
+      if (IntrinsicID == Intrinsic::trunc) {
+        APFloat V = Op->getValueAPF();
+        V.roundToIntegral(APFloat::rmTowardZero);
+        return ConstantFP::get(Ty->getContext(), V);
+      }
+
+      if (IntrinsicID == Intrinsic::rint) {
+        APFloat V = Op->getValueAPF();
+        V.roundToIntegral(APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(Ty->getContext(), V);
+      }
+
+      if (IntrinsicID == Intrinsic::nearbyint) {
+        APFloat V = Op->getValueAPF();
+        V.roundToIntegral(APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(Ty->getContext(), V);
+      }
+
       /// We only fold functions with finite arguments. Folding NaN and inf is
       /// likely to be aborted with an exception anyway, and some host libms
       /// have known errors raising exceptions.
       if (Op->getValueAPF().isNaN() || Op->getValueAPF().isInfinity())
         return nullptr;
 
       /// Currently APFloat versions of these functions do not exist, so we use
       /// the host native double versions.  Float versions are not called
if (ConstantFP *Op = dyn_cast<ConstantFP>(Operands[0])) {
         case Intrinsic::log:
           return ConstantFoldFP(log, V, Ty);
         case Intrinsic::log10:
           return ConstantFoldFP(log10, V, Ty);
         case Intrinsic::exp:
           return ConstantFoldFP(exp, V, Ty);
         case Intrinsic::exp2:
           return ConstantFoldFP(exp2, V, Ty);
-        case Intrinsic::floor:
-          return ConstantFoldFP(floor, V, Ty);
-        case Intrinsic::ceil:
-          return ConstantFoldFP(ceil, V, Ty);
         case Intrinsic::sin:
           return ConstantFoldFP(sin, V, Ty);
         case Intrinsic::cos:
           return ConstantFoldFP(cos, V, Ty);
       }
 
       if (!TLI)
         return nullptr;

llvm/trunk/test/Transforms/InstCombine/intrinsics.ll

 declare %ov.result.32 @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
 declare double @llvm.powi.f64(double, i32) nounwind readonly
 declare i32 @llvm.cttz.i32(i32, i1) nounwind readnone
 declare i32 @llvm.ctlz.i32(i32, i1) nounwind readnone
 declare i32 @llvm.ctpop.i32(i32) nounwind readnone
 declare i8 @llvm.ctlz.i8(i8, i1) nounwind readnone
 declare double @llvm.cos.f64(double %Val) nounwind readonly
 declare double @llvm.sin.f64(double %Val) nounwind readonly
+declare double @llvm.floor.f64(double %Val) nounwind readonly
+declare double @llvm.ceil.f64(double %Val) nounwind readonly
+declare double @llvm.trunc.f64(double %Val) nounwind readonly
+declare double @llvm.rint.f64(double %Val) nounwind readonly
+declare double @llvm.nearbyint.f64(double %Val) nounwind readonly
 
 define i8 @uaddtest1(i8 %A, i8 %B) {
   %x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)
   %y = extractvalue %overflow.result %x, 0
   ret i8 %y
 ; CHECK-LABEL: @uaddtest1(
 ; CHECK-NEXT: %y = add i8 %A, %B
 ; CHECK-NEXT: ret i8 %y

 entry:
   %B = tail call double @llvm.sin.f64(double 0.0) nounwind
   store volatile double %B, double* %P
 
   ret void
 ; CHECK-LABEL: @sin(
 ; CHECK: store volatile double 0.000000e+00, double* %P
 }
+
+define void @floor(double *%P) {
+entry:
+  %B = tail call double @llvm.floor.f64(double 1.5) nounwind
+  store volatile double %B, double* %P
+  %C = tail call double @llvm.floor.f64(double -1.5) nounwind
+  store volatile double %C, double* %P
+  ret void
+; CHECK-LABEL: @floor(
+; CHECK: store volatile double 1.000000e+00, double* %P, align 8
+; CHECK: store volatile double -2.000000e+00, double* %P, align 8
+}
+
+define void @ceil(double *%P) {
+entry:
+  %B = tail call double @llvm.ceil.f64(double 1.5) nounwind
+  store volatile double %B, double* %P
+  %C = tail call double @llvm.ceil.f64(double -1.5) nounwind
+  store volatile double %C, double* %P
+  ret void
+; CHECK-LABEL: @ceil(
+; CHECK: store volatile double 2.000000e+00, double* %P, align 8
+; CHECK: store volatile double -1.000000e+00, double* %P, align 8
+}
+
+define void @trunc(double *%P) {
+entry:
+  %B = tail call double @llvm.trunc.f64(double 1.5) nounwind
+  store volatile double %B, double* %P
+  %C = tail call double @llvm.trunc.f64(double -1.5) nounwind
+  store volatile double %C, double* %P
+  ret void
+; CHECK-LABEL: @trunc(
+; CHECK: store volatile double 1.000000e+00, double* %P, align 8
+; CHECK: store volatile double -1.000000e+00, double* %P, align 8
+}
+
+define void @rint(double *%P) {
+entry:
+  %B = tail call double @llvm.rint.f64(double 1.5) nounwind
+  store volatile double %B, double* %P
+  %C = tail call double @llvm.rint.f64(double -1.5) nounwind
+  store volatile double %C, double* %P
+  ret void
+; CHECK-LABEL: @rint(
+; CHECK: store volatile double 2.000000e+00, double* %P, align 8
+; CHECK: store volatile double -2.000000e+00, double* %P, align 8
+}
+
+define void @nearbyint(double *%P) {
+entry:
+  %B = tail call double @llvm.nearbyint.f64(double 1.5) nounwind
+  store volatile double %B, double* %P
+  %C = tail call double @llvm.nearbyint.f64(double -1.5) nounwind
+  store volatile double %C, double* %P
+  ret void
+; CHECK-LABEL: @nearbyint(
+; CHECK: store volatile double 2.000000e+00, double* %P, align 8
+; CHECK: store volatile double -2.000000e+00, double* %P, align 8
+}