[InstCombine] Expand the simplification of pow() into exp2()

[evandro]

Summary

Generalize the simplification of pow(2.0, y) to pow(2.0 ** n, y) for all scalar and vector types.

This improvement helps some benchmarks in SPEC CPU2000 and CPU2006, such as 252.eon, 447.dealII, 453.povray. Otherwise, no significant regressions on x86-64 or A64.

[evandro]

Also consider cases in pow(2.0 ** n, y) where n is negative.

[evandro]

Ping! 🔔

[evandro]

¡Ping! 🔔🔔

[evandro]

Ping! 🔔

[evandro]

Remove additional simplification when exp10() is the base in pow(), since it's not enabled by many targets.

[spatel]

llvm/test/Transforms/InstCombine/pow-sqrt.ll

37–40

No need to update this file if this is just a cosmetic diff in the value naming.
I updated the other files with auto-generated checks. Please make any IR changes in those tests that are necessary to show functional changes from this patch as a preliminary step. Then, update the assertions using the script.

[evandro]

llvm/test/Transforms/InstCombine/pow-sqrt.ll

37–40

The functionality changes are shown in the tests above.

[spatel]

I think this is ok, but it's hard to tell exactly what all of the diffs are. Please split it up so:

1. All of the new tests are committed first with baseline assertions.
2. Two code improvement pieces: (a) pow(exp(x), y), (b) pow(2.0 ** n, x). (if you can do the refactoring to create the replacePowWithExp() helper as an NFC commit ahead of that, that's even better)

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1137

Please add a TODO comment to loosen the FMF restriction. I'm not sure what the minimal set will be, but it can't be all of the flags.

[evandro]

Rebase after the preliminary patches rL340060 and rL340061.

[spatel]

This could still be split into 2 patches...
I'm just looking at the first code hunk, and I'm not sure this if this behaving as intended. We should have tests (please add) where both of the calls (exp{2}/pow) in the pattern are actual libcalls (rather than intrinsics). And in that case, this patch will replace a libcall with an intrinsic? Do the FMF allow that?

We should also have some test coverage for long double (fp128).

[evandro]

Increased test coverage in rL340462, where I also identified an issue with pow(exp{,2}(x), y).

[evandro]

Rebase after D51194.

[spatel]

Are there any negative tests where the base is not a power-of-2? If not, please add at least 1 test like that to make sure we're not transforming that.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1130–1131

isInteger -> IsInteger
isReciprocal -> IsReciprocal

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

73–74

It would be better to leave this and the similar assertions as-is because they confirm that the attribute statement actually contains the expected strings.

The update script should leave existing CHECK lines alone if you specify "--function=foo" to only change the tests that you are targeting with this patch.

[evandro]

In D49273#1216110, @spatel wrote:

Are there any negative tests where the base is not a power-of-2? If not, please add at least 1 test like that to make sure we're not transforming that.

I believe that @test_simplify1, @test_simplify2, @test_simplify9, @test_simplify10, @test_simplify18, @test_simplify19 already function as negative tests for this transformation. Yes?

[spatel]

In D49273#1216402, @evandro wrote:

In D49273#1216110, @spatel wrote:

Are there any negative tests where the base is not a power-of-2? If not, please add at least 1 test like that to make sure we're not transforming that.

I believe that @test_simplify1, @test_simplify2, @test_simplify9, @test_simplify10, @test_simplify18, @test_simplify19 already function as negative tests for this transformation. Yes?

Not sure if most of those actually make it into this function or if they're simplified sooner. I suppose the exp10 case must, so that's fine.

LGTM

[a.elovikov]

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

1258 ↗

(On Diff #163141)

Why don't we guard it with hasUnaryFloatFn similar to line 1264?

[evandro]

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

1258 ↗

(On Diff #163141)

I was thinking if this was the reason why this patch was reverted in rL340991. Will investigate it, thank you.

[evandro]

Windows lacks exp2() support.

[evandro]

Guard this transformation against targets that lack support for exp2(). In this case, refrain from transforming into either an intrinsic or a libcall.

[evandro]

Add more tests.

[spatel]

LGTM

Did someone confirm that producing exp2() was the cause of the bot failure?

[evandro]

@rnk has kindly reduced the issue to:

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"                              
target triple = "x86_64-unknown-windows-msvc19.11.0"                                     
@a = dso_local global double 0.000000e+00, align 8                                       
define dso_local double @b() {                                                           
entry:                                                                                   
  %0 = load double, double* @a, align 8                                                  
  %call = call double @pow(double 2.000000e+00, double %0)                               
  ret double %call                                                                       
}                                                                                        
declare dso_local double @pow(double, double)

I added a test to cover this case and variations of it on Windows.

[uabelho]

Hi,
A late comment about a problem I've noticed with this change.

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

1276 ↗

(On Diff #163389)

On my target, exp2f is available, but exp2 isn't, so the

hasUnaryFloatFn(TLI, Ty, LibFunc_exp2, LibFunc_exp2f, LibFunc_exp2l)

guard above returns true, but then when we try to find the name of LibFunc_exp2 we get "".

emitUnaryFloatFnCall doesn't check that the input name is something nice, it just happily adds an "f" to the name, and we end up with code trying to call the function "f" which eventually leads to a linking error.

Any thoughts about such cases?

[efriedma]

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

1276 ↗

(On Diff #163389)

I think the issue you're describing affects every user of emitUnaryFloatFnCall/emitBinaryFloatFnCall.

emitUnaryFloatFnCall should be fixed so it takes the same list of LibFunc enums that hasUnaryFloatFn does, and gets the appropriate name using getName(). The "appendTypeSuffix" helper is clearly inconsistent with the way TargetLibraryInfo is supposed to work. I doubt the issue you're describing affects any in-tree target, but I'd approve the patch anyway as a cleanup.

[uabelho]

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

1276 ↗

(On Diff #163389)

There are a few uses of emitUnaryFloatFnCall that I don't think are problematic atm, e.g. in optimizeDoubleFP. There we don't fetch the name via TLI, but pass in the name of the already existing function (which I suppose is the "double" version), and then I guess it works.

Anyway, it sounds good that you agree this is a problem and that it should work even if the "float" function is available and the "double" isn't like on my target.

I can try to make a cleanup patch that improves this in some way.

Thanks!

[uabelho]

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

1276 ↗

(On Diff #163389)

I created something here:
https://reviews.llvm.org/D53370
Let's continue the discussion there.

[xbolva00]

Hello, ldexp seems to be faster here. Did you try it?

pow(2, e) to ldexp(1, e)

[evandro]

In D49273#1619685, @xbolva00 wrote:

Hello, ldexp seems to be faster here. Did you try it?

pow(2, e) to ldexp(1, e)

ldexp() restricts the exponent to integers, so only then is it potentially faster.

Will think about it.

Thank you.

[xbolva00]

We have exp to ldexp fold, so we indirectly fold pow integer case to ldexp. I think it is okay as is.

Thanks.

[evandro]

In D49273#1619772, @xbolva00 wrote:

We have exp to ldexp fold, so we indirectly fold pow integer case to ldexp. I think it is okay as is.

The test pow_fp_int.ll indicates that it doesn't fold exp2() into ldexp() then.

[xbolva00]

Oh right, we miss this for pow of two bases other than 2.0.

Yeah, we need a direct fold.

[evandro]

In D49273#1619819, @xbolva00 wrote:

Oh right, we miss this for pow of two bases other than 2.0.

Yeah, we need a direct fold.

Methinks that I got a patch working. The only drawback is that there is no intrinsic ldexp(), which means that it's probably better to use exp2() for vector types.

[xbolva00]

Great :)

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
   // Wrapper for all String/Memory Library Call Optimizations
   Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
 
   // Math Library Optimizations
   Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
   Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
   Value *optimizePow(CallInst *CI, IRBuilder<> &B);
+  Value *replacePowWithExp(CallInst *Pow, IRBuilder<> &B);
   Value *replacePowWithRoot(CallInst *Pow, IRBuilder<> &B);
   Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
   Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
   Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
   // Wrapper for all floating point library call optimizations

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

 //===------ SimplifyLibCalls.cpp - Library calls simplifier ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the library calls simplifier. It does not implement
 // any pass, but can't be used by other passes to do simplifications.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
+#include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Analysis/ValueTracking.h"
static const unsigned AddChain[33][2] = {
       {3, 24}, {14, 14}, {4, 25}, {15, 15}, {3, 28}, {16, 16},
   };
 
   InnerChain[Exp] = B.CreateFMul(getPow(InnerChain, AddChain[Exp][0], B),
                                  getPow(InnerChain, AddChain[Exp][1], B));
   return InnerChain[Exp];
 }
 
+/// Use exp2(n * x) for pow(2.0 ** n, x); exp10(n * x) for pow(10.0 ** n, x);
+/// exp{,2,10}(x * y) for pow(exp{,2,10}(x), y).
+Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilder<> &B) {
+  Value *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
+  AttributeList Attrs = Pow->getCalledFunction()->getAttributes();
+  Module *Mod = Pow->getModule();
+  Type *Ty = Pow->getType();
+  bool Ignored;
+
+  // Evaluate special cases related to a nested function as the base.
+
+  // pow(exp(x), y) -> exp(x * y)
+  // pow(exp2(x), y) -> exp2(x * y)
+  // pow(exp10(x), y) -> exp10(x * y)
+  // We enable these only with fast-math. Besides rounding differences, the
+  // transformation changes overflow and underflow behavior quite dramatically.
+  // For example:
+  //   pow(exp(1000), 0.001) = pow(inf, 0.001) = inf
+  // Whereas:
+  //   exp(1000 * 0.001) = exp(1)
+  CallInst *BaseFn = dyn_cast<CallInst>(Base);
+  if (BaseFn && BaseFn->isFast() && Pow->isFast()) {
+    Function *CalledFn = BaseFn->getCalledFunction();
+    if (CalledFn) {
+      StringRef NameFn = CalledFn->getName();
+      LibFunc Fn;
+      if (TLI->getLibFunc(NameFn, Fn) && TLI->has(Fn)) {
+        Value *FMul = B.CreateFMul(BaseFn->getArgOperand(0), Expo, "mul");
+        Value *ExpFn;
+
+        switch (Fn) {
+        default:
+          return nullptr;
+        case LibFunc_exp:
+        case LibFunc_expf:
+        case LibFunc_expl:
+          ExpFn = Intrinsic::getDeclaration(Mod, Intrinsic::exp, Ty);
+          return B.CreateCall(ExpFn, FMul, "exp");
+        case LibFunc_exp2:
+        case LibFunc_exp2f:
+        case LibFunc_exp2l:
+          ExpFn = Intrinsic::getDeclaration(Mod, Intrinsic::exp2, Ty);
+          return B.CreateCall(ExpFn, FMul, "exp2");
+        case LibFunc_exp10:
+        case LibFunc_exp10f:
+        case LibFunc_exp10l:
+          return emitUnaryFloatFnCall(FMul, NameFn, B, Attrs);
+        }
+      }
+    }
+  }
+
+  // Evaluate special cases related to a constant base.
+
+  const APFloat *BaseF;
+  if (!match(Pow->getArgOperand(0), m_APFloat(BaseF)))
+    return nullptr;
+
+  // pow(2.0 ** n, x) -> exp2(n * x)
+  APFloat BaseR = APFloat(1.0);
+  BaseR.convert(BaseF->getSemantics(), APFloat::rmTowardZero, &Ignored);
+  BaseR = BaseR / *BaseF;
+  bool isInteger    = BaseF->isInteger(),
+       isReciprocal = BaseR.isInteger();
+  const APFloat *NF = isReciprocal ? &BaseR : BaseF;
+  APSInt NI(64, false);
+  if ((isInteger || isReciprocal) &&
+      !NF->convertToInteger(NI, APFloat::rmTowardZero, &Ignored) &&
+      NI > 1 && NI.isPowerOf2()) {
+    double N = NI.logBase2() * (isReciprocal ? -1.0 : 1.0);
+    Value *ExpoN = B.CreateFMul(Expo, ConstantFP::get(Ty, N));
+    Value *Exp2Fn = Intrinsic::getDeclaration(Mod, Intrinsic::exp2, Ty);
+    return B.CreateCall(Exp2Fn, ExpoN, "exp2");
+  }
+
+  // pow(10.0, x) -> exp10(x)
+  // TODO: There is no exp10() intrinsic yet, but some day there shall be one.
+  if (BaseF->isExactlyValue(10.0) &&
+      hasUnaryFloatFn(TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l))
+    return emitUnaryFloatFnCall(Expo, TLI->getName(LibFunc_exp10), B, Attrs);
+
+  return nullptr;
+}
+
 /// Use sqrt() for pow(x, +/-0.5) and cbrt() for pow(x, +/-0.333...).
 Value *LibCallSimplifier::replacePowWithRoot(CallInst *Pow, IRBuilder<> &B) {
   Value *Root, *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
   AttributeList Attrs = Pow->getCalledFunction()->getAttributes();
   Module *Mod = Pow->getModule();
   Type *Ty = Pow->getType();
 
   const APFloat *ExpoF;
if (ExpoF->isNegative())
     Root = B.CreateFDiv(ConstantFP::get(Ty, 1.0), Root, "reciprocal");
 
   return Root;
 }
 
 Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
   Value *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
   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.
   if (UnsafeFPShrink &&
       Name == TLI->getName(LibFunc_pow) && hasFloatVersion(Name))
     Shrunk = optimizeBinaryDoubleFP(Pow, B);
 
   // Evaluate special cases related to the base.
 
   // pow(1.0, x) -> 1.0
   if (match(Base, m_FPOne()))
     return Base;
 
-  // pow(2.0, x) -> exp2(x)
-  if (match(Base, m_SpecificFP(2.0))) {
-    Value *Exp2 = Intrinsic::getDeclaration(Module, Intrinsic::exp2, Ty);
-    return B.CreateCall(Exp2, Expo, "exp2");
-  }
-
-  // pow(10.0, x) -> exp10(x)
-  if (ConstantFP *BaseC = dyn_cast<ConstantFP>(Base))
-    // There's no exp10() intrinsic yet, but, maybe, some day there shall be one.
-    if (BaseC->isExactlyValue(10.0) &&
-        hasUnaryFloatFn(TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l))
-      return emitUnaryFloatFnCall(Expo, TLI->getName(LibFunc_exp10), B, Attrs);
-
-  // 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 *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)) {
-      Value *FMul = B.CreateFMul(BaseFn->getArgOperand(0), Expo, "mul");
-      return emitUnaryFloatFnCall(FMul, CalleeFn->getName(), B,
-                                  CalleeFn->getAttributes());
-    }
-  }
+  if (Value *Exp = replacePowWithExp(Pow, B))
+    return Exp;
 
   // Evaluate special cases related to the exponent.
 
   // pow(x, -1.0) -> 1.0 / x
   if (match(Expo, m_SpecificFP(-1.0)))
     return B.CreateFDiv(ConstantFP::get(Ty, 1.0), Base, "reciprocal");
 
   // pow(x, 0.0) -> 1.0

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

 
 define double @test_simplify2(double %x) {
 ; CHECK-LABEL: @test_simplify2(
   %retval = call double @pow(double 1.0, double %x)
   ret double %retval
 ; CHECK-NEXT: ret double 1.000000e+00
 }
 
-; Check pow(2.0, x) -> exp2(x).
+; Check pow(2.0 ** n, x) -> exp2(n * x).
 
 define float @test_simplify3(float %x) {
 ; CHECK-LABEL: @test_simplify3(
-  %retval = call float @powf(float 2.0, float %x)
-; CHECK-NEXT: [[EXP2F:%[a-z0-9]+]] = call float @llvm.exp2.f32(float %x)
+  %retval = call float @powf(float 0.25, float %x)
+; CHECK-NEXT: [[TMP1:%.*]] = fmul float %x, -2.000000e+00
+; CHECK-NEXT: [[EXP2F:%[a-z0-9]+]] = call float @llvm.exp2.f32(float [[TMP1]])
   ret float %retval
 ; CHECK-NEXT: ret float [[EXP2F]]
 }
 
 define double @test_simplify4(double %x) {
 ; CHECK-LABEL: @test_simplify4(
-  %retval = call double @pow(double 2.0, double %x)
-; CHECK-NEXT: [[EXP2:%[a-z0-9]+]] = call double @llvm.exp2.f64(double %x)
+  %retval = call double @pow(double 4.0, double %x)
+; CHECK-NEXT: [[TMP1:%.*]] = fmul double %x, 2.000000e+00
+; CHECK-NEXT: [[EXP2:%[a-z0-9]+]] = call double @llvm.exp2.f64(double [[TMP1]])
   ret double %retval
 ; CHECK-NEXT: ret double [[EXP2]]
 }
 
 ; Check pow(x, 0.0) -> 1.0.
 
 define float @test_simplify5(float %x) {
 ; CHECK-LABEL: @test_simplify5(
   %retval = call float @powf(float %x, float 0.0)
   ret float %retval
 ; CHECK-NEXT: ret 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
 }
 
 ; 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-NEXT: [[FABSF:%[a-z0-9]+]] = call float @llvm.fabs.f32(float [[SQRTF]])
 ; CHECK-NEXT: [[FCMP:%[a-z0-9]+]] = fcmp oeq float %x, 0xFFF0000000000000
 ; CHECK-NEXT: [[SELECT:%[a-z0-9]+]] = select i1 [[FCMP]], float 0x7FF0000000000000, float [[FABSF]]
   ret float %retval
 ; CHECK-NEXT: ret float [[SELECT]]
 }

llvm/test/Transforms/InstCombine/pow-exp.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
-define double @pow_exp(double %x, double %y) {
-  %call = call fast double @exp(double %x) nounwind readnone
-  %pow = call fast double @llvm.pow.f64(double %call, double %y)
-  ret double %pow
+define float @pow_exp(float %x, float %y) {
+  %call = call fast float @expf(float %x) nounwind readnone
+  %pow = call fast float @llvm.pow.f32(float %call, float %y)
+  ret float %pow
 }
 
-; CHECK-LABEL: define double @pow_exp(
-; CHECK-NEXT:  %mul = fmul fast double %x, %y
-; CHECK-NEXT:  %exp = call fast double @exp(double %mul)
-; CHECK-NEXT:  ret double %exp
+; CHECK-LABEL: define float @pow_exp(
+; CHECK-NEXT:  %mul = fmul fast float %x, %y
+; CHECK-NEXT:  %exp = call fast float @llvm.exp.f32(float %mul)
+; CHECK-NEXT:  ret float %exp
 
 define double @pow_exp2(double %x, double %y) {
   %call = call fast double @exp2(double %x) nounwind readnone
   %pow = call fast double @llvm.pow.f64(double %call, double %y)
   ret double %pow
 }
 
 ; CHECK-LABEL: define double @pow_exp2(
 ; CHECK-NEXT:  %mul = fmul fast double %x, %y
-; CHECK-NEXT:  %exp2 = call fast double @exp2(double %mul)
+; CHECK-NEXT:  %exp2 = call fast double @llvm.exp2.f64(double %mul)
 ; CHECK-NEXT:  ret double %exp2
 
 define double @pow_exp_not_fast(double %x, double %y) {
   %call = call double @exp(double %x)
   %pow = call fast double @llvm.pow.f64(double %call, double %y)
   ret double %pow
 }
 
 ; CHECK-LABEL: define double @pow_exp_not_fast(
 ; CHECK-NEXT:  %call = call double @exp(double %x)
 ; CHECK-NEXT:  %pow = call fast double @llvm.pow.f64(double %call, double %y)
 ; CHECK-NEXT:  ret double %pow
 
 define double @function_pointer(double ()* %fptr, double %p1) {
   %call1 = call fast double %fptr()
   %pow = call fast double @llvm.pow.f64(double %call1, double %p1)
   ret double %pow
 }
 
 ; CHECK-LABEL: @function_pointer
 ; CHECK-NEXT:  %call1 = call fast double %fptr()
 ; CHECK-NEXT:  %pow = call fast double @llvm.pow.f64(double %call1, double %p1)
 
+declare float @expf(float)
 declare double @exp(double)
 declare double @exp2(double)
+declare float @llvm.pow.f32(float, float)
 declare double @llvm.pow.f64(double, double)
-

llvm/test/Transforms/InstCombine/pow-sqrt.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define float @powf_intrinsic_half_fast(float %x) {
 ; CHECK-LABEL: @powf_intrinsic_half_fast(
 ; CHECK-NEXT:    [[SQRT:%.*]] = call fast float @llvm.sqrt.f32(float %x)
 ; CHECK-NEXT:    ret float [[SQRT]]
 ;
   %pow = call fast float @llvm.pow.f32(float %x, float 5.0e-01)

 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %pow = call ninf float @powf(float %x, float 5.0e-01)
   ret float %pow
 }
 
 define <2 x double> @pow_intrinsic_neghalf_fast(<2 x double> %x) {
 ; CHECK-LABEL: @pow_intrinsic_neghalf_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast <2 x double> @llvm.sqrt.v2f64(<2 x double> %x)
-; CHECK-NEXT:    [[TMP2:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP1]]
-; CHECK-NEXT:    ret <2 x double> [[TMP2]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call fast <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]])
+; CHECK-NEXT:    [[RECP:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[SQRT]]
+; CHECK-NEXT:    ret <2 x double> [[RECP]]
 ;
   %pow = call fast <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -5.0e-01, double -5.0e-01>)
   ret <2 x double> %pow
 }
 
 define <2 x float> @powf_intrinsic_neghalf_ninf(<2 x float> %x) {
 ; CHECK-LABEL: @powf_intrinsic_neghalf_ninf(
 ; CHECK-NEXT:    [[SQRT:%.*]] = call ninf <2 x float> @llvm.sqrt.v2f32(<2 x float> %x)
 ; CHECK-NEXT:    [[TMP1:%.*]] = call ninf <2 x float> @llvm.fabs.v2f32(<2 x float> [[SQRT]])

 declare float @llvm.pow.f32(float, float) #0
 declare <2 x double> @llvm.pow.v2f64(<2 x double>, <2 x double>) #0
 declare <2 x float> @llvm.pow.v2f32(<2 x float>, <2 x float>) #0
 declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) #0
 declare double @pow(double, double)
 declare float @powf(float, float)
 
 attributes #0 = { nounwind readnone speculatable }
-attributes #1 = { nounwind readnone }
-