[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–39 ↗

(On Diff #160018)

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–39 ↗

(On Diff #160018)

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

1200

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

1262–1263

isInteger -> IsInteger
isReciprocal -> IsReciprocal

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

201

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/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 Value *getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B) {
   };
 
   InnerChain[Exp] = B.CreateFMul(getPow(InnerChain, AddChain[Exp][0], B),
                                  getPow(InnerChain, AddChain[Exp][1], B));
   return InnerChain[Exp];
 }
 
 /// Use exp{,2}(x * y) for pow(exp{,2}(x), y);
-/// exp2(x) for pow(2.0, x); exp10(x) for pow(10.0, x).
+/// exp2(n * x) for pow(2.0 ** n, x); exp10(x) for pow(10.0, x).
 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)
   // If exp{,2}() is used only once, it is better to fold two transcendental
   // math functions into one.  If used again, exp{,2}() would still have to be
   // called with the original argument, then keep both original transcendental
   // functions.  However, this transformation is only safe with fully relaxed
   // math semantics, since, besides rounding differences, it 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)
   // TODO: Loosen the requirement for fully relaxed math semantics.
if (CalleeFn &&
       BaseFn->eraseFromParent();
 
       return ExpFn;
     }
   }
 
   // Evaluate special cases related to a constant base.
 
-  // pow(2.0, x) -> exp2(x)
-  if (match(Base, m_SpecificFP(2.0))) {
-    Value *Exp2 = Intrinsic::getDeclaration(Mod, Intrinsic::exp2, Ty);
-    return B.CreateCall(Exp2, Expo, "exp2");
+  const APFloat *BaseF;
+  if (!match(Pow->getArgOperand(0), m_APFloat(BaseF)))
+    return nullptr;
+
+  // pow(2.0 ** n, x) -> exp2(n * x)
+  if (hasUnaryFloatFn(TLI, Ty, LibFunc_exp2, LibFunc_exp2f, LibFunc_exp2l)) {
+    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 *FMul = B.CreateFMul(Expo, ConstantFP::get(Ty, N), "mul");
+      if (Pow->doesNotAccessMemory())
+        return B.CreateCall(Intrinsic::getDeclaration(Mod, Intrinsic::exp2, Ty),
+                            FMul, "exp2");
+      else
+        return emitUnaryFloatFnCall(FMul, TLI->getName(LibFunc_exp2), B, Attrs);
+    }
   }
 
   // pow(10.0, x) -> exp10(x)
   // TODO: There is no exp10() intrinsic yet, but some day there shall be one.
   if (match(Base, m_SpecificFP(10.0)) &&
       hasUnaryFloatFn(TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l))
     return emitUnaryFloatFnCall(Expo, TLI->getName(LibFunc_exp10), B, Attrs);
 

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the pow library call simplifier works correctly.
 ;
 ; RUN: opt -instcombine -S < %s                                  | FileCheck %s --check-prefixes=ANY
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-apple-macosx10.9 | FileCheck %s --check-prefixes=ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios7.0        | FileCheck %s --check-prefixes=ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-apple-macosx10.8 | FileCheck %s --check-prefixes=ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios6.0        | FileCheck %s --check-prefixes=ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-netbsd           | FileCheck %s --check-prefixes=ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-tvos9.0       | FileCheck %s --check-prefixes=ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-watchos2.0    | FileCheck %s --check-prefixes=ANY,CHECK-EXP10
 ; rdar://7251832
+; RUN: opt -instcombine -S < %s -mtriple=x86_64-pc-windows-msvc  | FileCheck %s --check-prefixes=CHECK-WIN
 
 ; NOTE: The readonly attribute on the pow call should be preserved
 ; in the cases below where pow is transformed into another function call.
 
 declare float @powf(float, float) nounwind readonly
 declare double @pow(double, double) nounwind readonly
+declare double @llvm.pow.f64(double, double)
 declare <2 x float> @llvm.pow.v2f32(<2 x float>, <2 x float>) nounwind readonly
 declare <2 x double> @llvm.pow.v2f64(<2 x double>, <2 x double>) nounwind readonly
 
 ; Check pow(1.0, x) -> 1.0.
 
 define float @test_simplify1(float %x) {
 ; ANY-LABEL: @test_simplify1(
 ; ANY-NEXT:    ret float 1.000000e+00
;
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 1.0, double 1.0>, <2 x double> %x)
   ret <2 x double> %retval
 }
 
 ; Check pow(2.0 ** n, x) -> exp2(n * x).
 
 define float @test_simplify3(float %x) {
 ; ANY-LABEL: @test_simplify3(
-; ANY-NEXT:    [[EXP2:%.*]] = call float @llvm.exp2.f32(float [[X:%.*]])
-; ANY-NEXT:    ret float [[EXP2]]
+; ANY-NEXT:    [[EXP2F:%.*]] = call float @exp2f(float [[X:%.*]]) [[NUW_RO:#[0-9]+]]
+; ANY-NEXT:    ret float [[EXP2F]]
+;
+; CHECK-WIN-LABEL: @test_simplify3(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call float @powf(float 2.000000e+00, float [[X:%.*]])
+; CHECK-WIN-NEXT:    ret float [[POW]]
 ;
   %retval = call float @powf(float 2.0, float %x)
   ret float %retval
 }
 
-; TODO: Should result in exp2(-2.0 * x).
 define double @test_simplify3n(double %x) {
 ; ANY-LABEL: @test_simplify3n(
-; ANY-NEXT:    [[RETVAL:%.*]] = call double @pow(double 2.500000e-01, double [[X:%.*]])
-; ANY-NEXT:    ret double [[RETVAL]]
+; ANY-NEXT:    [[MUL:%.*]] = fmul double [[X:%.*]], -2.000000e+00
+; ANY-NEXT:    [[EXP2:%.*]] = call double @exp2(double [[MUL]]) [[NUW_RO]]
+; ANY-NEXT:    ret double [[EXP2]]
+;
+; CHECK-WIN-LABEL: @test_simplify3n(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call double @pow(double 2.500000e-01, double [[X:%.*]])
+; CHECK-WIN-NEXT:    ret double [[POW]]
 ;
   %retval = call double @pow(double 0.25, double %x)
   ret double %retval
 }
 
 define <2 x float> @test_simplify3v(<2 x float> %x) {
 ; ANY-LABEL: @test_simplify3v(
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> [[X:%.*]])
 ; ANY-NEXT:    ret <2 x float> [[EXP2]]
 ;
+; CHECK-WIN-LABEL: @test_simplify3v(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> [[X:%.*]])
+; CHECK-WIN-NEXT:    ret <2 x float> [[POW]]
+;
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 2.0, float 2.0>, <2 x float> %x)
   ret <2 x float> %retval
 }
 
-; TODO: Should result in exp2(2.0 * x).
 define <2 x double> @test_simplify3vn(<2 x double> %x) {
 ; ANY-LABEL: @test_simplify3vn(
-; ANY-NEXT:    [[RETVAL:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> [[X:%.*]])
-; ANY-NEXT:    ret <2 x double> [[RETVAL]]
+; ANY-NEXT:    [[MUL:%.*]] = fmul <2 x double> [[X:%.*]], <double 2.000000e+00, double 2.000000e+00>
+; ANY-NEXT:    [[EXP2:%.*]] = call <2 x double> @llvm.exp2.v2f64(<2 x double> [[MUL]])
+; ANY-NEXT:    ret <2 x double> [[EXP2]]
 ;
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 4.0, double 4.0>, <2 x double> %x)
   ret <2 x double> %retval
 }
 
 define double @test_simplify4(double %x) {
 ; ANY-LABEL: @test_simplify4(
-; ANY-NEXT:    [[EXP2:%.*]] = call double @llvm.exp2.f64(double [[X:%.*]])
+; ANY-NEXT:    [[EXP2:%.*]] = call double @exp2(double [[X:%.*]]) [[NUW_RO]]
 ; ANY-NEXT:    ret double [[EXP2]]
 ;
+; CHECK-WIN-LABEL: @test_simplify4(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call double @pow(double 2.000000e+00, double [[X:%.*]])
+; CHECK-WIN-NEXT:    ret double [[POW]]
+;
   %retval = call double @pow(double 2.0, double %x)
   ret double %retval
 }
 
-; TODO: Should result in exp2f(3.0 * x).
 define float @test_simplify4n(float %x) {
 ; ANY-LABEL: @test_simplify4n(
-; ANY-NEXT:    [[RETVAL:%.*]] = call float @powf(float 8.000000e+00, float [[X:%.*]])
-; ANY-NEXT:    ret float [[RETVAL]]
+; ANY-NEXT:    [[MUL:%.*]] = fmul float [[X:%.*]], 3.000000e+00
+; ANY-NEXT:    [[EXP2F:%.*]] = call float @exp2f(float [[MUL]]) [[NUW_RO]]
+; ANY-NEXT:    ret float [[EXP2F]]
+;
+; CHECK-WIN-LABEL: @test_simplify4n(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call float @powf(float 8.000000e+00, float [[X:%.*]])
+; CHECK-WIN-NEXT:    ret float [[POW]]
 ;
   %retval = call float @powf(float 8.0, float %x)
   ret float %retval
 }
 
 define <2 x double> @test_simplify4v(<2 x double> %x) {
 ; ANY-LABEL: @test_simplify4v(
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x double> @llvm.exp2.v2f64(<2 x double> [[X:%.*]])
 ; ANY-NEXT:    ret <2 x double> [[EXP2]]
 ;
+; CHECK-WIN-LABEL: @test_simplify4v(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> [[X:%.*]])
+; CHECK-WIN-NEXT:    ret <2 x double> [[POW]]
+;
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 2.0, double 2.0>, <2 x double> %x)
   ret <2 x double> %retval
 }
 
-; TODO: Should result in exp2f(-x).
 define <2 x float> @test_simplify4vn(<2 x float> %x) {
 ; ANY-LABEL: @test_simplify4vn(
-; ANY-NEXT:    [[RETVAL:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 5.000000e-01, float 5.000000e-01>, <2 x float> [[X:%.*]])
-; ANY-NEXT:    ret <2 x float> [[RETVAL]]
+; ANY-NEXT:    [[MUL:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; ANY-NEXT:    [[EXP2:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> [[MUL]])
+; ANY-NEXT:    ret <2 x float> [[EXP2]]
+;
+; CHECK-WIN-LABEL: @test_simplify4vn(
+; CHECK-WIN-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 5.000000e-01, float 5.000000e-01>, <2 x float> [[X:%.*]])
+; CHECK-WIN-NEXT:    ret <2 x float> [[POW]]
 ;
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 0.5, float 0.5>, <2 x float> %x)
   ret <2 x float> %retval
 }
 
 ; Check pow(x, 0.0) -> 1.0.
 
 define float @test_simplify5(float %x) {
;
   %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 pow(x, 0.5) -> fabs(sqrt(x)), where x != -infinity.
 
 define float @test_simplify7(float %x) {
 ; ANY-LABEL: @test_simplify7(
-; ANY-NEXT:    [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]]) [[NUW_RO:#[0-9]+]]
+; ANY-NEXT:    [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]]) [[NUW_RO]]
 ; ANY-NEXT:    [[ABS:%.*]] = call float @llvm.fabs.f32(float [[SQRTF]])
 ; ANY-NEXT:    [[ISINF:%.*]] = fcmp oeq float [[X]], 0xFFF0000000000000
 ; ANY-NEXT:    [[TMP1:%.*]] = select i1 [[ISINF]], float 0x7FF0000000000000, float [[ABS]]
 ; ANY-NEXT:    ret float [[TMP1]]
 ;
   %retval = call float @powf(float %x, float 0.5)
   ret float %retval
 }

 ; ANY-LABEL: @pow_neg1_double_fastv(
 ; ANY-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[X:%.*]]
 ; ANY-NEXT:    ret <2 x double> [[RECIPROCAL]]
 ;
   %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) {
 ; ANY-LABEL: @test_simplify17(
 ; ANY-NEXT:    [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
 ; ANY-NEXT:    [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]])
 ; ANY-NEXT:    [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000
 ; ANY-NEXT:    [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]]
 ; ANY-NEXT:    ret double [[TMP1]]
 ;