[SLC] Expand simplification of pow() for vector types

[spatel]

This patch is still making multiple functional changes, so it needs to be split up.

IIUC, the changes to the match() statements are all functional diffs (maybe only using the llvm intrinsics with vector types?), but there are no tests for those?

I'm still distracted by the NFC whitespace, formatting, and comment diffs. Please make those before/after the functional change.

I updated the test file and added the baseline tests from this rev at rL338392. Use the script to auto-generate new CHECK lines.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1181 ↗

(On Diff #158157)

This change should be its own patch. It fixes a miscompile - we were wrongly shrinking pow(x, y) as a unary function.

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1186 ↗

(On Diff #158436)

IIUC, this is NFC, so you could just commit that before the other changes

1263–1265 ↗

(On Diff #158436)

Is there a test for this transform?

[evandro]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1263–1265 ↗

(On Diff #158436)

Will do.

[evandro]

Added test cases for vector types in pow(x, n).

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

Why do we need this check? In all of the affected transforms, we're not transforming *to* pow(). Is there a known bug without this check? Given that we have a pow intrinsic, I don't see the problem.

[evandro]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

Without this check, pow() would be simplified even with -disable-simplify-libcalls and pow-3.ll would fail.

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

No, that test still passes (we don't convert) because we check for the availability of sqrt() before trying the transform.

I suppose this raises a question: if -disable-simplify-libcalls is specified, should that preclude simplifications from LLVM intrinsics that mimic libcalls to other LLVM intrinsics that mimic libcalls?
...but that's probably best left to another patch or asked on llvm-dev.

[evandro]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

-disable-simplify-libcalls disables all functions, including pow() itself. As I understand it, no optimization should then be performed on libcalls. Again, without these lines, pow-3.ll fails.

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

There must be something different between our local machines then. I'm applying this patch on an unmodified trunk r339434, deleting the check for pow(), and running 'make check'. Everything passes.

And I even stepped through in the debugger to confirm the reason as I stated earlier - the sqrt() check fails, so there is no transform. Can you step through and see how that check is bypassed on your machine?

[evandro]

Added test for shrinking pow() when simplifying libcalls is disabled.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

You're right. We're looking at different stages of the tree.

Regardless, without this check, pow() could still be shrunk below, which I don't think is desired with -disable-simplify-libcalls.

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

No, the shrinking is guarded by TLI->getName(LibFunc_pow) and so that won't happen independent of this patch. I added tests for this at rL339467.

[spatel]

I suppose the extra check doesn't hurt anything, and this is all disorganized anyway. The simplifications of calls to constants should really be in InstSimplify.
The vector changes look correct, so LGTM.

[evandro]

Thank you.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

Which is virtually the same test. I'm confused...

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

Confused by the tests? The 1st test is exactly what you proposed to add here. The 2nd test is identical except it proves the same behavior for the intrinsic rather than the libcall. The checks are auto-generated and show that no shrinking is happening even without this patch.

Confused by the fact that your local results don't match trunk? I can't help there. :)
What is the next patch in this sequence to review? Let's make sure it's rebased after this gets committed, so we're looking at the same code/tests.

[evandro]

The dependent patches can be found in the Stack below: D49273 and D50036.

Thank you.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1171–1172 ↗

(On Diff #158776)

Sorry. I meant that TLI->getName(LibFunc_pow) is virtually the same inside hasUnaryFloatFn().

llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
   Function *Callee = Pow->getCalledFunction();
   AttributeList Attrs = Callee->getAttributes();
   StringRef Name = Callee->getName();
   Module *Module = Pow->getModule();
   Type *Ty = Pow->getType();
   Value *Shrunk = nullptr;
   bool Ignored;
 
+  // Bail out if simplifying libcalls to pow() is disabled.
+  if (!hasUnaryFloatFn(TLI, Ty, LibFunc_pow, LibFunc_powf, LibFunc_powl))
+    return nullptr;
+
   // Propagate the math semantics from the call to any created instructions.
   IRBuilder<>::FastMathFlagGuard Guard(B);
   B.setFastMathFlags(Pow->getFastMathFlags());
 
   // Shrink pow() to powf() if the arguments are single precision,
   // unless the result is expected to be double precision.
   if (UnsafeFPShrink &&
       Name == TLI->getName(LibFunc_pow) && hasFloatVersion(Name))
Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
   // Example: x = 1000, y = 0.001.
   // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1).
   auto *BaseFn = dyn_cast<CallInst>(Base);
   if (BaseFn && BaseFn->isFast() && Pow->isFast()) {
     LibFunc LibFn;
     Function *CalleeFn = BaseFn->getCalledFunction();
     if (CalleeFn && TLI->getLibFunc(CalleeFn->getName(), LibFn) &&
         (LibFn == LibFunc_exp || LibFn == LibFunc_exp2) && TLI->has(LibFn)) {
-      IRBuilder<>::FastMathFlagGuard Guard(B);
-      B.setFastMathFlags(Pow->getFastMathFlags());
-
       Value *FMul = B.CreateFMul(BaseFn->getArgOperand(0), Expo, "mul");
       return emitUnaryFloatFnCall(FMul, CalleeFn->getName(), B,
                                   CalleeFn->getAttributes());
     }
   }
 
   // Evaluate special cases related to the exponent.
 
-  if (Value *Sqrt = replacePowWithSqrt(Pow, B))
-    return Sqrt;
-
-  ConstantFP *ExpoC = dyn_cast<ConstantFP>(Expo);
-  if (!ExpoC)
-    return Shrunk;
-
   // pow(x, -1.0) -> 1.0 / x
-  if (ExpoC->isExactlyValue(-1.0))
+  if (match(Expo, m_SpecificFP(-1.0)))
     return B.CreateFDiv(ConstantFP::get(Ty, 1.0), Base, "reciprocal");
 
   // pow(x, 0.0) -> 1.0
-  if (ExpoC->getValueAPF().isZero())
+  if (match(Expo, m_SpecificFP(0.0)))
       return ConstantFP::get(Ty, 1.0);
 
   // pow(x, 1.0) -> x
-  if (ExpoC->isExactlyValue(1.0))
+  if (match(Expo, m_FPOne()))
     return Base;
 
   // pow(x, 2.0) -> x * x
-  if (ExpoC->isExactlyValue(2.0))
+  if (match(Expo, m_SpecificFP(2.0)))
     return B.CreateFMul(Base, Base, "square");
 
+  if (Value *Sqrt = replacePowWithSqrt(Pow, B))
+    return Sqrt;
+
   // FIXME: Correct the transforms and pull this into replacePowWithSqrt().
-  if (ExpoC->isExactlyValue(0.5) &&
+  ConstantFP *ExpoC = dyn_cast<ConstantFP>(Expo);
+  if (ExpoC && ExpoC->isExactlyValue(0.5) &&
       hasUnaryFloatFn(TLI, Ty, LibFunc_sqrt, LibFunc_sqrtf, LibFunc_sqrtl)) {
     // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
     // This is faster than calling pow(), and still handles -0.0 and
     // negative infinity correctly.
     // TODO: In finite-only mode, this could be just fabs(sqrt(x)).
     Value *PosInf = ConstantFP::getInfinity(Ty);
     Value *NegInf = ConstantFP::getInfinity(Ty, true);
 
     // TODO: As above, we should lower to the sqrt() intrinsic if the pow() is
     // an intrinsic, to match errno semantics.
     Value *Sqrt = emitUnaryFloatFnCall(Base, TLI->getName(LibFunc_sqrt),
                                        B, Attrs);
     Function *FAbsFn = Intrinsic::getDeclaration(Module, Intrinsic::fabs, Ty);
     Value *FAbs = B.CreateCall(FAbsFn, Sqrt, "abs");
     Value *FCmp = B.CreateFCmpOEQ(Base, NegInf, "isinf");
     Sqrt = B.CreateSelect(FCmp, PosInf, FAbs);
     return Sqrt;
   }
 
-  // pow(x, n) -> x * x * x * ....
-  if (Pow->isFast()) {
-    APFloat ExpoA = abs(ExpoC->getValueAPF());
-    // We limit to a max of 7 fmul(s). Thus the maximum exponent is 32.
-    // This transformation applies to integer exponents only.
-    if (!ExpoA.isInteger() ||
-        ExpoA.compare
-            (APFloat(ExpoA.getSemantics(), 32.0)) == APFloat::cmpGreaterThan)
-      return Shrunk;
-
+  // pow(x, n) -> x * x * x * ...
+  const APFloat *ExpoF;
+  if (Pow->isFast() && match(Expo, m_APFloat(ExpoF))) {
+    // We limit to a max of 7 multiplications, thus the maximum exponent is 32.
+    APFloat LimF(ExpoF->getSemantics(), 33.0),
+            ExpoA(abs(*ExpoF));
+    if (ExpoA.isInteger() && ExpoA.compare(LimF) == APFloat::cmpLessThan) {
       // We will memoize intermediate products of the Addition Chain.
       Value *InnerChain[33] = {nullptr};
       InnerChain[1] = Base;
       InnerChain[2] = B.CreateFMul(Base, Base, "square");
 
       // We cannot readily convert a non-double type (like float) to a double.
       // So we first convert it to something which could be converted to double.
       ExpoA.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &Ignored);
       Value *FMul = getPow(InnerChain, ExpoA.convertToDouble(), B);
 
       // If the exponent is negative, then get the reciprocal.
-    if (ExpoC->isNegative())
+      if (ExpoF->isNegative())
         FMul = B.CreateFDiv(ConstantFP::get(Ty, 1.0), FMul, "reciprocal");
+
       return FMul;
     }
+  }
 
   return Shrunk;
 }
 
 Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Ret = nullptr;
   StringRef Name = Callee->getName();

llvm/trunk/test/Transforms/InstCombine/pow-1.ll

; CHECK-LABEL: @test_simplify5(
   ret float %retval
 ; CHECK-NEXT: ret float 1.000000e+00
 }
 
 define <2 x float> @test_simplify5v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify5v(
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 0.0, float 0.0>)
   ret <2 x float> %retval
-; CHECK-NEXT: %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
+; CHECK-NEXT: ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
 }
 
 define double @test_simplify6(double %x) {
 ; CHECK-LABEL: @test_simplify6(
   %retval = call double @pow(double %x, double 0.0)
   ret double %retval
 ; CHECK-NEXT: ret double 1.000000e+00
 }
 
 define <2 x double> @test_simplify6v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify6v(
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 0.0, double 0.0>)
   ret <2 x double> %retval
-; CHECK-NEXT: %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> zeroinitializer)
+; CHECK-NEXT: ret <2 x double> <double 1.000000e+00, double 1.000000e+00>
 }
 
 ; Check pow(x, 0.5) -> fabs(sqrt(x)), where x != -infinity.
 
 define float @test_simplify7(float %x) {
 ; CHECK-LABEL: @test_simplify7(
   %retval = call float @powf(float %x, float 0.5)
 ; CHECK-NEXT: [[SQRTF:%[a-z0-9]+]] = call float @sqrtf(float %x) [[$NUW_RO:#[0-9]+]]
; CHECK-LABEL: @test_simplify11(
   ret float %retval
 ; CHECK-NEXT: ret float %x
 }
 
 define <2 x float> @test_simplify11v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify11v(
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 1.0, float 1.0>)
   ret <2 x float> %retval
-; CHECK-NEXT: %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT: ret <2 x float> %x
 }
 
 define double @test_simplify12(double %x) {
 ; CHECK-LABEL: @test_simplify12(
   %retval = call double @pow(double %x, double 1.0)
   ret double %retval
 ; CHECK-NEXT: ret double %x
 }
 
 define <2 x double> @test_simplify12v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify12v(
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 1.0, double 1.0>)
   ret <2 x double> %retval
-; CHECK-NEXT: %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
+; CHECK-NEXT: ret <2 x double> %x
 }
 
 ; Check pow(x, 2.0) -> x*x.
 
 define float @pow2_strict(float %x) {
 ; CHECK-LABEL: @pow2_strict(
 ; CHECK-NEXT:    [[POW2:%.*]] = fmul float %x, %x
 ; CHECK-NEXT:    ret float [[POW2]]
 ;
   %r = call float @powf(float %x, float 2.0)
   ret float %r
 }
 
 define <2 x float> @pow2_strictv(<2 x float> %x) {
 ; CHECK-LABEL: @pow2_strictv(
-; CHECK-NEXT:    [[POW2:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 2.000000e+00, float 2.000000e+00>)
+; CHECK-NEXT:    [[POW2:%.*]] = fmul <2 x float> %x, %x
 ; CHECK-NEXT:    ret <2 x float> [[POW2]]
 ;
   %r = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 2.0, float 2.0>)
   ret <2 x float> %r
 }
 
 define double @pow2_double_strict(double %x) {
 ; CHECK-LABEL: @pow2_double_strict(
 ; CHECK-NEXT:    [[POW2:%.*]] = fmul double %x, %x
 ; CHECK-NEXT:    ret double [[POW2]]
 ;
   %r = call double @pow(double %x, double 2.0)
   ret double %r
 }
 define <2 x double> @pow2_double_strictv(<2 x double> %x) {
 ; CHECK-LABEL: @pow2_double_strictv(
-; CHECK-NEXT:    [[POW2:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 2.000000e+00, double 2.000000e+00>)
+; CHECK-NEXT:    [[POW2:%.*]] = fmul <2 x double> %x, %x
 ; CHECK-NEXT:    ret <2 x double> [[POW2]]
 ;
   %r = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 2.0, double 2.0>)
   ret <2 x double> %r
 }
 
 ; Don't drop the FMF - PR35601 ( https://bugs.llvm.org/show_bug.cgi?id=35601 )
 

 ; CHECK-NEXT:    ret float [[POWRECIP]]
 ;
   %r = call float @powf(float %x, float -1.0)
   ret float %r
 }
 
 define <2 x float> @pow_neg1_strictv(<2 x float> %x) {
 ; CHECK-LABEL: @pow_neg1_strictv(
-; CHECK-NEXT:    [[POWRECIP:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float -1.000000e+00, float -1.000000e+00>)
+; CHECK-NEXT:    [[POWRECIP:%.*]] = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, %x
 ; CHECK-NEXT:    ret <2 x float> [[POWRECIP]]
 ;
   %r = call <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float -1.0, float -1.0>)
   ret <2 x float> %r
 }
 
 define double @pow_neg1_double_fast(double %x) {
 ; CHECK-LABEL: @pow_neg1_double_fast(
 ; CHECK-NEXT:    [[POWRECIP:%.*]] = fdiv fast double 1.000000e+00, %x
 ; CHECK-NEXT:    ret double [[POWRECIP]]
 ;
   %r = call fast double @pow(double %x, double -1.0)
   ret double %r
 }
 
 define <2 x double> @pow_neg1_double_fastv(<2 x double> %x) {
 ; CHECK-LABEL: @pow_neg1_double_fastv(
-; CHECK-NEXT:    [[POWRECIP:%.*]] = call fast <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -1.000000e+00, double -1.000000e+00>)
+; CHECK-NEXT:    [[POWRECIP:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, %x
 ; CHECK-NEXT:    ret <2 x double> [[POWRECIP]]
 ;
   %r = call fast <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -1.0, double -1.0>)
   ret <2 x double> %r
 }
 
 declare double @llvm.pow.f64(double %Val, double %Power)
 define double @test_simplify17(double %x) {

llvm/trunk/test/Transforms/InstCombine/pow-3.ll

 ; CHECK-NEXT:    ret float [[FR]]
 ;
   %df = fpext float %f to double
   %dg = fpext float %g to double
   %call = call fast double @llvm.pow.f64(double %df, double %dg)
   %fr = fptrunc double %call to float
   ret float %fr
 }
-

llvm/trunk/test/Transforms/InstCombine/pow-4.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 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) {
-; CHECK-LABEL: @test_simplify_4f(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[TMP1]]
-; CHECK-NEXT:    ret float [[TMP2]]
-;
-  %1 = call fast float @llvm.pow.f32(float %x, float 4.000000e+00)
-  ret float %1
-}
+declare <2 x double> @llvm.pow.v2f64(<2 x double>, <2 x double>)
+declare <2 x float> @llvm.pow.v2f32(<2 x float>, <2 x float>)
 
 ; pow(x, 3.0)
 define double @test_simplify_3(double %x) {
 ; CHECK-LABEL: @test_simplify_3(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[X]]
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double 3.000000e+00)
   ret double %1
 }
 
+; powf(x, 4.0)
+define float @test_simplify_4f(float %x) {
+; CHECK-LABEL: @test_simplify_4f(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[TMP1]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %1 = call fast float @llvm.pow.f32(float %x, float 4.000000e+00)
+  ret float %1
+}
+
 ; pow(x, 4.0)
 define double @test_simplify_4(double %x) {
 ; CHECK-LABEL: @test_simplify_4(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
   %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) {
+; powf(x, <15.0, 15.0>)
+define <2 x float> @test_simplify_15(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify_15(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[X]]
-; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[TMP2]]
-; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP3]], [[TMP3]]
-; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast double [[TMP2]], [[TMP4]]
-; CHECK-NEXT:    ret double [[TMP5]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <2 x float> [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x float> [[TMP1]], [[X]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast <2 x float> [[TMP2]], [[TMP2]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast <2 x float> [[TMP3]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast <2 x float> [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret <2 x float> [[TMP5]]
 ;
-  %1 = call fast double @llvm.pow.f64(double %x, double 1.500000e+01)
-  ret double %1
+  %1 = call fast <2 x float> @llvm.pow.v2f32(<2 x float> %x, <2 x float> <float 1.500000e+01, float 1.500000e+01>)
+  ret <2 x float> %1
 }
 
 ; pow(x, -7.0)
-define double @test_simplify_neg_7(double %x) {
+define <2 x double> @test_simplify_neg_7(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify_neg_7(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
-; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[X]]
-; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP1]], [[TMP3]]
-; CHECK-NEXT:    [[TMP5:%.*]] = fdiv fast double 1.000000e+00, [[TMP4]]
-; CHECK-NEXT:    ret double [[TMP5]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <2 x double> [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x double> [[TMP1]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast <2 x double> [[TMP2]], [[X]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast <2 x double> [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP4]]
+; CHECK-NEXT:    ret <2 x double> [[TMP5]]
 ;
-  %1 = call fast double @llvm.pow.f64(double %x, double -7.000000e+00)
-  ret double %1
+  %1 = call fast <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -7.000000e+00, double -7.000000e+00>)
+  ret <2 x double> %1
 }
 
-; pow(x, -19.0)
-define double @test_simplify_neg_19(double %x) {
+; powf(x, -19.0)
+define float @test_simplify_neg_19(float %x) {
 ; CHECK-LABEL: @test_simplify_neg_19(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
-; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[TMP2]]
-; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP3]], [[TMP3]]
-; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast double [[TMP1]], [[TMP4]]
-; CHECK-NEXT:    [[TMP6:%.*]] = fmul fast double [[TMP5]], [[X]]
-; CHECK-NEXT:    [[TMP7:%.*]] = fdiv fast double 1.000000e+00, [[TMP6]]
-; CHECK-NEXT:    ret double [[TMP7]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast float [[TMP2]], [[TMP2]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast float [[TMP3]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast float [[TMP1]], [[TMP4]]
+; CHECK-NEXT:    [[TMP6:%.*]] = fmul fast float [[TMP5]], [[X]]
+; CHECK-NEXT:    [[TMP7:%.*]] = fdiv fast float 1.000000e+00, [[TMP6]]
+; CHECK-NEXT:    ret float [[TMP7]]
 ;
-  %1 = call fast double @llvm.pow.f64(double %x, double -1.900000e+01)
-  ret double %1
+  %1 = call fast float @llvm.pow.f32(float %x, float -1.900000e+01)
+  ret float %1
 }
 
 ; pow(x, 11.23)
 define double @test_simplify_11_23(double %x) {
 ; CHECK-LABEL: @test_simplify_11_23(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.pow.f64(double [[X:%.*]], double 1.123000e+01)
 ; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %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) {
+; powf(x, 32.0)
+define float @test_simplify_32(float %x) {
 ; CHECK-LABEL: @test_simplify_32(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
-; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[TMP2]]
-; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP3]], [[TMP3]]
-; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast double [[TMP4]], [[TMP4]]
-; CHECK-NEXT:    ret double [[TMP5]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast float [[TMP2]], [[TMP2]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast float [[TMP3]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast float [[TMP4]], [[TMP4]]
+; CHECK-NEXT:    ret float [[TMP5]]
 ;
-  %1 = call fast double @llvm.pow.f64(double %x, double 3.200000e+01)
-  ret double %1
+  %1 = call fast float @llvm.pow.f32(float %x, float 3.200000e+01)
+  ret float %1
 }
 
 ; pow(x, 33.0)
 define double @test_simplify_33(double %x) {
 ; CHECK-LABEL: @test_simplify_33(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.pow.f64(double [[X:%.*]], double 3.300000e+01)
 ; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double 3.300000e+01)
   ret double %1
 }