[ConstFolding] Allow constfolding of llvm.sin.* and llvm.cos.* intrinsics

[karthikthecool]

Summary

Hi All,
This is a minor patch to allow constfolding of llvm.sin* and llvm.cos* intrinsic.
Please let me know if this looks good to be committed into svn.

Thanks and Regards
Karthik Bhat

[karthikthecool]

gentle ping...

[mzolotukhin]

Looks good to me.

test/Transforms/InstCombine/intrinsics.ll

22–23 ↗

(On Diff #28767)

Please don't add empty lines.

452 ↗

(On Diff #28767)

Another unnecessary empty line.

llvm/trunk/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const Function *F) {
   case Intrinsic::log:
   case Intrinsic::log2:
   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::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])) {
         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;
 
       switch (Name[0]) {
       case 'a':
         if (Name == "acos" && TLI->has(LibFunc::acos))

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

 declare %ov.result.32 @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
 declare %ov.result.32 @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
 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
 
 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

 
 define %ov.result.32 @never_overflows_ssub_test0(i32 %a) {
   %x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %a, i32 0)
   ret %ov.result.32 %x
 ; CHECK-LABEL: @never_overflows_ssub_test0
 ; CHECK-NEXT: %[[x:.*]] = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %a, 0
 ; CHECK-NEXT:  ret %ov.result.32 %[[x]]
 }
+
+define void @cos(double *%P) {
+entry:
+  %B = tail call double @llvm.cos.f64(double 0.0) nounwind
+  store volatile double %B, double* %P
+
+  ret void
+; CHECK-LABEL: @cos(
+; CHECK: store volatile double 1.000000e+00, double* %P
+}
+
+define void @sin(double *%P) {
+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
+}