[SLC] Allow llvm.pow(x,2.0) -> x*x etc even if no pow() lib func

[foad]

Summary

Previously, SLC was disallowing those optimizations if TLI said there is
no pow() library function.

Change-Id: I01c461df3537760b4919422b5ad3a2f004eb4f0f

[tpr]

@foad pointed out that this fix is wrong. TLI saying pow() is not supported means if we find a call to a function called pow() then we don't know its semantics. So I will push a revised fix.

[tpr]

V2: Better fix that does not accidentally allow pow() transforms.

[efriedma]

I don't understand what the check is supposed to be doing in the first place. If we're in LibCallSimplifier::optimizePow, we've already checked that the call is actually calling a function with the right semantics, not just the name.

[evandro]

Indeed, it seemed to be a coarse check in case the following transformations end up calling pow(). However, the only transformation that calls pow() is when shrinking to powf(), which itself chacks for the availability of this routine. So this patch seems to address this issue the wrong way. It seems that removing this check would be better.

[evandro]

test/Transforms/InstCombine/pow-1.ll

120 ↗

(On Diff #222468)

I don't see a good reason why this check was removed.

[foad]

Rebase. Address review comments.

[spatel]

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

6–7

Please update/rebase - I added a test to cover the case that I assume was intended:
rG5013a788f8e

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

1 ↗

(On Diff #261259)

Can you add a RUN line for this to the existing "pow-1.ll" test file instead of adding a new test file? The existing file is already used to test various target combos.

[foad]

Rebase. Merge pow-amdgcn.ll into pow-1.ll.

[lebedev.ri]

The patch description is only stating the previous status-quo as a fact,
but gives no reasoning as to why it should change, why it is legal/okay to change it.

Is this really sane?
Can we really invent calls to non-builtin (aka potentially user-provided/overriden) C math function?

[foad]

In D68231#2016090, @lebedev.ri wrote:

Can we really invent calls to non-builtin (aka potentially user-provided/overriden) C math function?

We're not creating library calls. We're only creating instructions and generic intrinsic calls, neither of which (should) depend on what TLI says about the available library functions.

[foad]

In D68231#2016090, @lebedev.ri wrote:

The patch description is only stating the previous status-quo as a fact,
but gives no reasoning as to why it should change, why it is legal/okay to change it.

How about something like: "optimizePow does not create any new calls to pow, so it should work regardless of whether the pow library function is available. This allows it to optimize the llvm.pow intrinsic on targets with no math library."

Annoyingly, if I change the commit message, arc diff doesn't propagate that to the web interface.

[lebedev.ri]

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

3–17

Can you precommit this please?

[foad]

Rebase.

[lebedev.ri]

Patch description still needs an update but i think this looks okay.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilderBase &B) {
   Function *Callee = Pow->getCalledFunction();
   StringRef Name = Callee->getName();
   Type *Ty = Pow->getType();
   Module *M = Pow->getModule();
   Value *Shrunk = nullptr;
   bool AllowApprox = Pow->hasApproxFunc();
   bool Ignored;
 
-  // Bail out if simplifying libcalls to pow() is disabled.
-  if (!hasFloatFn(TLI, Ty, LibFunc_pow, LibFunc_powf, LibFunc_powl))
-    return nullptr;
-
   // Propagate the math semantics from the call to any created instructions.
   IRBuilderBase::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))

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

 ; Test that the pow library call simplifier works correctly.
 ;
 ; RUN: opt -instcombine -S < %s                                   | FileCheck %s --check-prefixes=CHECK,LIB,ANY
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-apple-macosx10.9  | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios7.0         | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-apple-macosx10.8  | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios6.0         | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-netbsd            | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-tvos9.0        | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=arm-apple-watchos2.0     | FileCheck %s --check-prefixes=CHECK,LIB,ANY,CHECK-EXP10
 ; rdar://7251832
 ; RUN: opt -instcombine -S < %s -mtriple=i386-pc-windows-msvc18   | FileCheck %s --check-prefixes=CHECK,LIB,MSVC,VC32,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=i386-pc-windows-msvc     | FileCheck %s --check-prefixes=CHECK,LIB,MSVC,VC51,VC19,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-pc-windows-msvc18 | FileCheck %s --check-prefixes=CHECK,LIB,MSVC,VC64,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=x86_64-pc-windows-msvc   | FileCheck %s --check-prefixes=CHECK,LIB,MSVC,VC83,VC19,CHECK-NO-EXP10
 ; RUN: opt -instcombine -S < %s -mtriple=amdgcn--                 | FileCheck %s --check-prefixes=CHECK,NOLIB,CHECK-NO-EXP10
 
 ; 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

 ; NOLIB-NEXT:    ret float [[POW]]
 ;
   %retval = call float @powf(float 1.0, float %x)
   ret float %retval
 }
 
 define <2 x float> @test_simplify1v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify1v(
-; ANY-NEXT:    ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> [[X:%.*]])
-; MSVC-NEXT:   ret <2 x float> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> [[X:%.*]])
-; NOLIB-NEXT:    ret <2 x float> [[POW]]
+; CHECK-NEXT:    ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
 ;
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 1.0, float 1.0>, <2 x float> %x)
   ret <2 x float> %retval
 }
 
 define double @test_simplify2(double %x) {
 ; CHECK-LABEL: @test_simplify2(
 ; LIB-NEXT:    ret double 1.000000e+00
 ; NOLIB-NEXT:    [[POW:%.*]] = call double @pow(double 1.000000e+00, double [[X:%.*]])
 ; NOLIB-NEXT:    ret double [[POW]]
 ;
   %retval = call double @pow(double 1.0, double %x)
   ret double %retval
 }
 
 define <2 x double> @test_simplify2v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify2v(
-; ANY-NEXT:    ret <2 x double> <double 1.000000e+00, double 1.000000e+00>
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double> [[X:%.*]])
-; MSVC-NEXT:   ret <2 x double> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double> [[X:%.*]])
-; NOLIB-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    ret <2 x double> <double 1.000000e+00, double 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) {

 }
 
 define <2 x float> @test_simplify3v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify3v(
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> [[X:%.*]])
 ; ANY-NEXT:    ret <2 x float> [[EXP2]]
 ; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> [[X:%.*]])
 ; MSVC-NEXT:   ret <2 x float> [[POW]]
+; TODO: should be able to simplify llvm.pow to llvm.exp2 even without libcalls
 ; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> [[X:%.*]])
 ; NOLIB-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
 }
 
 define <2 x double> @test_simplify3vn(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify3vn(
 ; 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]]
 ; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> [[X:%.*]])
 ; MSVC-NEXT:   ret <2 x double> [[POW]]
+; TODO: should be able to simplify llvm.pow to llvm.exp2 even without libcalls
 ; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> [[X:%.*]])
 ; NOLIB-NEXT:    ret <2 x double> [[POW]]
 ;
   %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) {

 }
 
 define <2 x double> @test_simplify4v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify4v(
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x double> @llvm.exp2.v2f64(<2 x double> [[X:%.*]])
 ; ANY-NEXT:    ret <2 x double> [[EXP2]]
 ; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> [[X:%.*]])
 ; MSVC-NEXT:   ret <2 x double> [[POW]]
+; TODO: should be able to simplify llvm.pow to llvm.exp2 even without libcalls
 ; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> [[X:%.*]])
 ; NOLIB-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
 }
 
 define <2 x float> @test_simplify4vn(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify4vn(
 ; ANY-NEXT:    [[MUL:%.*]] = fneg <2 x float> [[X:%.*]]
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> [[MUL]])
 ; ANY-NEXT:    ret <2 x float> [[EXP2]]
 ; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 5.000000e-01, float 5.000000e-01>, <2 x float> [[X:%.*]])
 ; MSVC-NEXT:   ret <2 x float> [[POW]]
+; TODO: should be able to simplify llvm.pow to llvm.exp2 even without libcalls
 ; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 5.000000e-01, float 5.000000e-01>, <2 x float> [[X:%.*]])
 ; NOLIB-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.

 ; NOLIB-NEXT:    ret float [[POW]]
 ;
   %retval = call float @powf(float %x, float 0.0)
   ret float %retval
 }
 
 define <2 x float> @test_simplify5v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify5v(
-; ANY-NEXT:    ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> zeroinitializer)
-; MSVC-NEXT:   ret <2 x float> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> zeroinitializer)
-; NOLIB-NEXT:    ret <2 x float> [[POW]]
+; CHECK-NEXT:    ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
 ;
   %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
 }
 
 define double @test_simplify6(double %x) {
 ; CHECK-LABEL: @test_simplify6(
 ; LIB-NEXT:    ret double 1.000000e+00
 ; NOLIB-NEXT:    [[POW:%.*]] = call double @pow(double [[X:%.*]], double 0.000000e+00)
 ; NOLIB-NEXT:    ret double [[POW]]
 ;
   %retval = call double @pow(double %x, double 0.0)
   ret double %retval
 }
 
 define <2 x double> @test_simplify6v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify6v(
-; ANY-NEXT:    ret <2 x double> <double 1.000000e+00, double 1.000000e+00>
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> zeroinitializer)
-; MSVC-NEXT:   ret <2 x double> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> zeroinitializer)
-; NOLIB-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    ret <2 x double> <double 1.000000e+00, double 1.000000e+00>
 ;
   %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) {

 ; NOLIB-NEXT:    ret float [[POW]]
 ;
   %retval = call float @powf(float %x, float 1.0)
   ret float %retval
 }
 
 define <2 x float> @test_simplify11v(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify11v(
-; ANY-NEXT:    ret <2 x float> [[X:%.*]]
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
-; MSVC-NEXT:   ret <2 x float> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
-; NOLIB-NEXT:    ret <2 x float> [[POW]]
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %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
 }
 
 define double @test_simplify12(double %x) {
 ; CHECK-LABEL: @test_simplify12(
 ; LIB-NEXT:    ret double [[X:%.*]]
 ; NOLIB-NEXT:    [[POW:%.*]] = call double @pow(double [[X:%.*]], double 1.000000e+00)
 ; NOLIB-NEXT:    ret double [[POW]]
 ;
   %retval = call double @pow(double %x, double 1.0)
   ret double %retval
 }
 
 define <2 x double> @test_simplify12v(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify12v(
-; ANY-NEXT:    ret <2 x double> [[X:%.*]]
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double 1.000000e+00, double 1.000000e+00>)
-; MSVC-NEXT:   ret <2 x double> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double 1.000000e+00, double 1.000000e+00>)
-; NOLIB-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    ret <2 x double> [[X:%.*]]
 ;
   %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 pow(x, 2.0) -> x*x.
 
 define float @pow2_strict(float %x) {

 ; NOLIB-NEXT:    ret float [[POW]]
 ;
   %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(
-; ANY-NEXT:    [[SQUARE:%.*]] = fmul <2 x float> [[X:%.*]], [[X]]
-; ANY-NEXT:    ret <2 x float> [[SQUARE]]
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float 2.000000e+00, float 2.000000e+00>)
-; MSVC-NEXT:   ret <2 x float> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float 2.000000e+00, float 2.000000e+00>)
-; NOLIB-NEXT:    ret <2 x float> [[POW]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul <2 x float> [[X:%.*]], [[X]]
+; CHECK-NEXT:    ret <2 x float> [[SQUARE]]
 ;
   %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(
 ; LIB-NEXT:    [[SQUARE:%.*]] = fmul double [[X:%.*]], [[X]]
 ; LIB-NEXT:    ret double [[SQUARE]]
 ; NOLIB-NEXT:    [[POW:%.*]] = call double @pow(double [[X:%.*]], double 2.000000e+00)
 ; NOLIB-NEXT:    ret double [[POW]]
 ;
   %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(
-; ANY-NEXT:    [[SQUARE:%.*]] = fmul <2 x double> [[X:%.*]], [[X]]
-; ANY-NEXT:    ret <2 x double> [[SQUARE]]
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double 2.000000e+00, double 2.000000e+00>)
-; MSVC-NEXT:   ret <2 x double> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double 2.000000e+00, double 2.000000e+00>)
-; NOLIB-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul <2 x double> [[X:%.*]], [[X]]
+; CHECK-NEXT:    ret <2 x double> [[SQUARE]]
 ;
   %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 )
 
 define float @pow2_fast(float %x) {

 ; NOLIB-NEXT:    ret float [[POW]]
 ;
   %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(
-; ANY-NEXT:    [[RECIPROCAL:%.*]] = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, [[X:%.*]]
-; ANY-NEXT:    ret <2 x float> [[RECIPROCAL]]
-; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float -1.000000e+00, float -1.000000e+00>)
-; MSVC-NEXT:   ret <2 x float> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> [[X:%.*]], <2 x float> <float -1.000000e+00, float -1.000000e+00>)
-; NOLIB-NEXT:    ret <2 x float> [[POW]]
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    ret <2 x float> [[RECIPROCAL]]
 ;
   %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(
 ; LIB-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast double 1.000000e+00, [[X:%.*]]
 ; LIB-NEXT:    ret double [[RECIPROCAL]]
 ; NOLIB-NEXT:    [[POW:%.*]] = call fast double @pow(double [[X:%.*]], double -1.000000e+00)
 ; NOLIB-NEXT:    ret double [[POW]]
 ;
   %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(
-; ANY-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[X:%.*]]
-; ANY-NEXT:    ret <2 x double> [[RECIPROCAL]]
-; MSVC-NEXT:   [[POW:%.*]] = call fast <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double -1.000000e+00, double -1.000000e+00>)
-; MSVC-NEXT:   ret <2 x double> [[POW]]
-; NOLIB-NEXT:    [[POW:%.*]] = call fast <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double -1.000000e+00, double -1.000000e+00>)
-; NOLIB-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[X:%.*]]
+; CHECK-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
 }
 
 define double @test_simplify17(double %x) {
 ; CHECK-LABEL: @test_simplify17(
-; LIB-NEXT:    [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
-; LIB-NEXT:    [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]])
-; LIB-NEXT:    [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000
-; LIB-NEXT:    [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]]
-; LIB-NEXT:    ret double [[TMP1]]
-; NOLIB-NEXT:    [[POW:%.*]] = call double @llvm.pow.f64(double [[X:%.*]], double 5.000000e-01)
-; NOLIB-NEXT:    ret double [[POW]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT:    [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]])
+; CHECK-NEXT:    [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]]
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %retval = call double @llvm.pow.f64(double %x, double 0.5)
   ret double %retval
 }
 
 ; Check pow(10.0, x) -> __exp10(x) on OS X 10.9+ and iOS 7.0+.
 
 define float @test_simplify18(float %x) {

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -disable-simplify-libcalls -instcombine -S | FileCheck %s
 
 declare double @llvm.pow.f64(double, double)
 declare double @pow(double, double)
 
 define double @sqrt_libcall(double %x) {
 ; CHECK-LABEL: @sqrt_libcall(
 ; CHECK-NEXT:    [[RETVAL:%.*]] = call double @pow(double [[X:%.*]], double 5.000000e-01)
 ; CHECK-NEXT:    ret double [[RETVAL]]
 ;
   %retval = call double @pow(double %x, double 0.5)
   ret double %retval
 }
 
 define double @sqrt_intrinsic(double %x) {
 ; CHECK-LABEL: @sqrt_intrinsic(
-; CHECK-NEXT:    [[RETVAL:%.*]] = call double @llvm.pow.f64(double [[X:%.*]], double 5.000000e-01)
-; CHECK-NEXT:    ret double [[RETVAL]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT:    [[ABS:%.*]] = call double @llvm.fabs.f64(double [[SQRT]])
+; CHECK-NEXT:    [[ISINF:%.*]] = fcmp oeq double [[X]], 0xFFF0000000000000
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[ISINF]], double 0x7FF0000000000000, double [[ABS]]
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %retval = call double @llvm.pow.f64(double %x, double 0.5)
   ret double %retval
 }
 
 ; Shrinking is disabled too.
 
 define float @shrink_libcall(float %f, float %g) {