Index: llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1127,9 +1127,6 @@ 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 @@ -1193,7 +1190,7 @@ 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. @@ -1210,6 +1207,8 @@ // 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()) Index: llvm/trunk/test/Transforms/InstCombine/pow-4.ll =================================================================== --- llvm/trunk/test/Transforms/InstCombine/pow-4.ll +++ llvm/trunk/test/Transforms/InstCombine/pow-4.ll @@ -7,40 +7,40 @@ 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 @@ -49,12 +49,12 @@ ; 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 @@ -63,12 +63,12 @@ ; 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 @@ -79,22 +79,22 @@ ; 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 @@ -103,18 +103,17 @@ ; 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" }