[LibCallSimplifier] use instruction-level fast-math-flags to transform pow(x, [small integer]) calls

[spatel]

Summary

This is a continuation of adding FMF to call instructions:
http://reviews.llvm.org/rL255555

As with D15937, the intent of the patch is to preserve the current behavior of the transform except that we use the pow call's 'fast' attribute as a trigger rather than a function-level attribute.

But this raises a possible improvement noted by the TODO comment:
Should all of the new instructions be marked 'fast' since they were derived from a fast pow()? I think a user of -ffast-math would expect that despite the potentially increased risk of numerical disaster. In particular, the possible 'fdiv' would benefit from being turned into a reciprocal estimate on a target that supports that. There's probably less risk/opportunity to do anything with the chain of dependent multiplies, but if we're going 'fast', we might as well flag them all?

[mgrang]

LGTM.

lib/Transforms/Utils/SimplifyLibCalls.cpp

if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
     // pow(10.0, x) -> exp10(x)
     if (Op1C->isExactlyValue(10.0) &&
         hasUnaryFloatFn(TLI, Op1->getType(), LibFunc::exp10, LibFunc::exp10f,
                         LibFunc::exp10l))
       return EmitUnaryFloatFnCall(Op2, TLI->getName(LibFunc::exp10), B,
                                   Callee->getAttributes());
   }
 
-  // FIXME: Use instruction-level FMF.
-  bool UnsafeFPMath = canUseUnsafeFPMath(CI->getParent()->getParent());
-
   // pow(exp(x), y) -> exp(x * y)
   // pow(exp2(x), y) -> exp2(x * y)
   // We enable these only with fast-math. Besides rounding differences, the
   // transformation changes overflow and underflow behavior quite dramatically.
   // Example: x = 1000, y = 0.001.
   // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1).
   auto *OpC = dyn_cast<CallInst>(Op1);
   if (OpC && OpC->hasUnsafeAlgebra() && CI->hasUnsafeAlgebra()) {
Value *LibCallSimplifier::optimizePow(CallInst *CI, IRBuilder<> &B) {
   if (Op2C->isExactlyValue(1.0)) // pow(x, 1.0) -> x
     return Op1;
   if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x
     return B.CreateFMul(Op1, Op1, "pow2");
   if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x
     return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Op1, "powrecip");
 
   // In -ffast-math, generate repeated fmul instead of generating pow(x, n).
-  if (UnsafeFPMath) {
+  if (CI->hasUnsafeAlgebra()) {
     APFloat V = abs(Op2C->getValueAPF());
     // We limit to a max of 7 fmul(s). Thus max exponent is 32.
     // This transformation applies to integer exponents only.
     if (V.compare(APFloat(V.getSemantics(), 32.0)) == APFloat::cmpGreaterThan ||
         !V.isInteger())
       return nullptr;
 
     // We will memoize intermediate products of the Addition Chain.
     Value *InnerChain[33] = {nullptr};
     InnerChain[1] = Op1;
     InnerChain[2] = B.CreateFMul(Op1, Op1);
 
     // We cannot readily convert a non-double type (like float) to a double.
     // So we first convert V to something which could be converted to double.
     bool ignored;
     V.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
+    
+    // TODO: Should the new instructions propagate the 'fast' flag of the pow()?
     Value *FMul = getPow(InnerChain, V.convertToDouble(), B);
     // For negative exponents simply compute the reciprocal.
     if (Op2C->isNegative())
       FMul = B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), FMul);
     return FMul;
   }
 
   return nullptr;

test/Transforms/InstCombine/pow-4.ll

 ; Test that the pow library call simplifier works correctly.
 
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 ; Function Attrs: nounwind readnone
 declare double @llvm.pow.f64(double, double)
 declare float @llvm.pow.f32(float, float)
 
 ; pow(x, 4.0f)
-define float @test_simplify_4f(float %x) #0 {
+define float @test_simplify_4f(float %x) {
 ; CHECK-LABEL: @test_simplify_4f(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul float %x, %x
 ; CHECK-NEXT: %2 = fmul float %1, %1
 ; CHECK-NEXT: ret float %2
-  %1 = call float @llvm.pow.f32(float %x, float 4.000000e+00)
+  %1 = call fast float @llvm.pow.f32(float %x, float 4.000000e+00)
   ret float %1
 }
 
 ; pow(x, 3.0)
-define double @test_simplify_3(double %x) #0 {
+define double @test_simplify_3(double %x) {
 ; CHECK-LABEL: @test_simplify_3(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %x
 ; CHECK-NEXT: ret double %2
-  %1 = call double @llvm.pow.f64(double %x, double 3.000000e+00)
+  %1 = call fast double @llvm.pow.f64(double %x, double 3.000000e+00)
   ret double %1
 }
 
 ; pow(x, 4.0)
-define double @test_simplify_4(double %x) #0 {
+define double @test_simplify_4(double %x) {
 ; CHECK-LABEL: @test_simplify_4(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %1
 ; CHECK-NEXT: ret double %2
-  %1 = call double @llvm.pow.f64(double %x, double 4.000000e+00)
+  %1 = call fast double @llvm.pow.f64(double %x, double 4.000000e+00)
   ret double %1
 }
 
 ; pow(x, 15.0)
-define double @test_simplify_15(double %x) #0 {
+define double @test_simplify_15(double %x) {
 ; CHECK-LABEL: @test_simplify_15(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %x
 ; CHECK-NEXT: %3 = fmul double %2, %2
 ; CHECK-NEXT: %4 = fmul double %3, %3
 ; CHECK-NEXT: %5 = fmul double %2, %4
 ; CHECK-NEXT: ret double %5
-  %1 = call double @llvm.pow.f64(double %x, double 1.500000e+01)
+  %1 = call fast double @llvm.pow.f64(double %x, double 1.500000e+01)
   ret double %1
 }
 
 ; pow(x, -7.0)
-define double @test_simplify_neg_7(double %x) #0 {
+define double @test_simplify_neg_7(double %x) {
 ; CHECK-LABEL: @test_simplify_neg_7(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %x
 ; CHECK-NEXT: %3 = fmul double %1, %2
 ; CHECK-NEXT: %4 = fmul double %1, %3
 ; CHECK-NEXT: %5 = fdiv double 1.000000e+00, %4
 ; CHECK-NEXT: ret double %5
-  %1 = call double @llvm.pow.f64(double %x, double -7.000000e+00)
+  %1 = call fast double @llvm.pow.f64(double %x, double -7.000000e+00)
   ret double %1
 }
 
 ; pow(x, -19.0)
-define double @test_simplify_neg_19(double %x) #0 {
+define double @test_simplify_neg_19(double %x) {
 ; CHECK-LABEL: @test_simplify_neg_19(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %1
 ; CHECK-NEXT: %3 = fmul double %2, %2
 ; CHECK-NEXT: %4 = fmul double %3, %3
 ; CHECK-NEXT: %5 = fmul double %1, %4
 ; CHECK-NEXT: %6 = fmul double %5, %x
 ; CHECK-NEXT: %7 = fdiv double 1.000000e+00, %6
 ; CHECK-NEXT: ret double %7
-  %1 = call double @llvm.pow.f64(double %x, double -1.900000e+01)
+  %1 = call fast double @llvm.pow.f64(double %x, double -1.900000e+01)
   ret double %1
 }
 
 ; pow(x, 11.23)
-define double @test_simplify_11_23(double %x) #0 {
+define double @test_simplify_11_23(double %x) {
 ; CHECK-LABEL: @test_simplify_11_23(
 ; CHECK-NOT: fmul
-; CHECK-NEXT: %1 = call double @llvm.pow.f64(double %x, double 1.123000e+01)
+; CHECK-NEXT: %1 = call fast double @llvm.pow.f64(double %x, double 1.123000e+01)
 ; CHECK-NEXT: ret double %1
-  %1 = call double @llvm.pow.f64(double %x, double 1.123000e+01)
+  %1 = call fast double @llvm.pow.f64(double %x, double 1.123000e+01)
   ret double %1
 }
 
 ; pow(x, 32.0)
-define double @test_simplify_32(double %x) #0 {
+define double @test_simplify_32(double %x) {
 ; CHECK-LABEL: @test_simplify_32(
 ; CHECK-NOT: pow
 ; CHECK-NEXT: %1 = fmul double %x, %x
 ; CHECK-NEXT: %2 = fmul double %1, %1
 ; CHECK-NEXT: %3 = fmul double %2, %2
 ; CHECK-NEXT: %4 = fmul double %3, %3
 ; CHECK-NEXT: %5 = fmul double %4, %4
 ; CHECK-NEXT: ret double %5
-  %1 = call double @llvm.pow.f64(double %x, double 3.200000e+01)
+  %1 = call fast double @llvm.pow.f64(double %x, double 3.200000e+01)
   ret double %1
 }
 
 ; pow(x, 33.0)
-define double @test_simplify_33(double %x) #0 {
+define double @test_simplify_33(double %x) {
 ; CHECK-LABEL: @test_simplify_33(
 ; CHECK-NOT: fmul
-; CHECK-NEXT: %1 = call double @llvm.pow.f64(double %x, double 3.300000e+01)
+; CHECK-NEXT: %1 = call fast double @llvm.pow.f64(double %x, double 3.300000e+01)
 ; CHECK-NEXT: ret double %1
-  %1 = call double @llvm.pow.f64(double %x, double 3.300000e+01)
+  %1 = call fast double @llvm.pow.f64(double %x, double 3.300000e+01)
   ret double %1
 }
 
-attributes #0 = { nounwind readnone "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="generic" "target-features"="+neon" "unsafe-fp-math"="true" "use-soft-float"="false" }