[SimplifyLibCalls] powf(x, sitofp(n)) -> powi(x, n)

[xbolva00]

Summary

Partially solves https://bugs.llvm.org/show_bug.cgi?id=42190

[xbolva00]

@spatel do you want to see some more tests?

I will precommit them when they are OK.

[xbolva00]

Removed one invalid Todo comment

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1495

We have no pow(int, int) intrinsic right? So there is no easy way how to do it as follow up...

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1493

Maybe I should move transformation before:
if (Value *Exp = replacePowWithExp(Pow, B))

return Exp;

?

[nikic]

Can you please provide some more information under which circumstances powf(x, (float) y) will provide a different result than powi(x, y), and which fast-math flags specifically are necessary to make that transform legal?

[xbolva00]

In D63038#1535121, @nikic wrote:

Can you please provide some more information under which circumstances powf(x, (float) y) will provide a different result than powi(x, y), and which fast-math flags specifically are necessary to make that transform legal?

I don’t have such info, I personally think this is fine also without fast math, but since I cannot say it for sure, In the first version, I put it under fast math.

Maybe some experts like @spatel or @efriedma can confirm that this transformation is always fine?

[xbolva00]

Removed "isFast" requirement for powf(x, sitofp(n)) -> powi(x, n).
New: powf(x, C) -> powi(x, C) iff C is a constant integer value

[xbolva00]

added new test

[xbolva00]

Some tests precommited for review.
Rebased.

[xbolva00]

test/Transforms/InstCombine/pow_fp_int.ll

304

@spatel @nikic what do you think about this case ?

[xbolva00]

Handle uitofp too

[spatel]

In D63038#1535140, @xbolva00 wrote:

In D63038#1535121, @nikic wrote:

Can you please provide some more information under which circumstances powf(x, (float) y) will provide a different result than powi(x, y), and which fast-math flags specifically are necessary to make that transform legal?

I don’t have such info, I personally think this is fine also without fast math, but since I cannot say it for sure, In the first version, I put it under fast math.

Maybe some experts like @spatel or @efriedma can confirm that this transformation is always fine?

I don't see how this is valid without some kind of fast-math. What if the integer exponent is not exactly representable as an FP value?

$ cat powi.c 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  float base = atof(argv[1]);
  printf("base as float = %.8f\n", base);

  int exponent = atoi(argv[2]);
  printf("exponent = %d\n", exponent);
  printf("exponent as float = %.8f\n", (float)exponent);

  float d = powf(base, exponent);
  float i = __builtin_powif(base, exponent);
  printf("powf = %f\n", d);
  printf("powif = %f\n", i);
  return 0;
}

$ ./a.out 1.0000001 16777217
base as float = 1.00000012
exponent = 16777217
exponent as float = 16777216.00000000
powf = 7.389055
powif = 7.385338

[efriedma]

We definitely need afn for this; powi performs multiple intermediate rounding steps, so it can be significantly less accurate than pow.

Beyond that, we might need nsz in some cases? Probably worth writing a bunch of tests for zero/inf/nan base with zero/positive/negative exponents to figure out exactly which cases are different.

lib/Transforms/Utils/SimplifyLibCalls.cpp

1455

I think you're missing some checks here.

1544

powi takes a signed exponent.

[xbolva00]

Transform only when full fast math mode.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1455

I think isFast (-Ofast) check is good enough for now.

I wrote some tests with various bases, https://pastebin.com/xpysEY0f.
I got same output for pow and powi.

1544

false means isUnsigned = false. Or if you meant a comment - I added it there more explicitely.

If you meant something else, I don't know what is wrong :(

[xbolva00]

Some more things to do, or is it fine now? :)

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1455

This code doesn't even run in those cases?

I'm specifically concerned about cases where the exponent isn't an int32_t... if it's wider, or unsigned.

1544

That's all I meant; didn't realize that was "isUnsigned"...

[xbolva00]

More check for exponent int bitwidth.
Added more tests.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1455

You are right, we need to check it.

[xbolva00]

Revert unneeded formating changes.

[efriedma]

test/Transforms/InstCombine/pow_fp_int.ll

301

I don't think this is right; consider, for example , pow(.999999999,4000000000).

[xbolva00]

test/Transforms/InstCombine/pow_fp_int.ll

301

This is a negative test, nothing was changed here.

[xbolva00]

test/Transforms/InstCombine/pow_fp_int.ll

301

Yeah, I should change variable naming in negative tests

[efriedma]

test/Transforms/InstCombine/pow_fp_int.ll

178

Meant to write a comment on this. Treating "uitofp" like this means you're converting pow(.999999999,4000000000) into pow(.999999999,-294967296).

301

Accidentally commented on the wrong test.

[xbolva00]

test/Transforms/InstCombine/pow_fp_int.ll

178

Ah, right.

Can we still do this atleast for some "unsigned" cases, up to i16 (i31?) ?

[xbolva00]

Handle uitofp better.

[xbolva00]

ping :)

[xbolva00]

test/Transforms/InstCombine/pow_fp_int.ll

178

It should be ok now. PTAL @efriedma

[efriedma]

It would be nice to use the exact necessary fast-math flags here, while we're thinking about it, instead of just "isFast()". From the discussion, it seems like we only need "afn"?

[xbolva00]

In D63038#1554089, @efriedma wrote:

It would be nice to use the exact necessary fast-math flags here, while we're thinking about it, instead of just "isFast()". From the discussion, it seems like we only need "afn"?

Okey. Maybe @spatel could help us with fast flags, whether afn is enough.

[spatel]

In D63038#1554099, @xbolva00 wrote:

In D63038#1554089, @efriedma wrote:

It would be nice to use the exact necessary fast-math flags here, while we're thinking about it, instead of just "isFast()". From the discussion, it seems like we only need "afn"?

Okey. Maybe @spatel could help us with fast flags, whether afn is enough.

Yes, I think 'afn' gives us the freedom for this sort of thing. As a practical matter, I'm not sure if clang has the means to turn on 'afn' without the entirety of "-ffast-math", but that may change in the future.

[xbolva00]

Require just "afn".

[efriedma]

It looks like you didn't change all the uses of isFast() in optimizePow?

Also, I'd like to see some performance numbers; I assume powi is faster, but it would be nice to confirm, particularly for larger exponents.

[xbolva00]

clang -O3 pw.c -lm
xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,195s
user 0m0,195s
sys 0m0,000s
xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,195s
user 0m0,195s
sys 0m0,000s
xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,195s
user 0m0,195s
sys 0m0,000s

clang -Ofast pw.c -lm / clang -O3 -ffast-math pw.c -lm

xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,053s
user 0m0,049s
sys 0m0,004s
xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,050s
user 0m0,050s
sys 0m0,000s
xbolva00@xbolva00-G551JW:~$ time ./a.out &> log

real 0m0,051s
user 0m0,051s
sys 0m0,000s

"Benchmark": https://pastebin.com/Z0yZD4qU

[xbolva00]

Replace IsFast with AllowApprox

[xbolva00]

ping

[xbolva00]

Anything else to address?

[efriedma]

LGTM

lib/Transforms/Utils/SimplifyLibCalls.cpp

1414

Indentation

[xbolva00]

Fixed formatting

[xbolva00]

Anything else to address?

In D63038#1565727, @efriedma wrote:

LGTM

Thank you!

lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilder<> &B) {
   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();
+    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) &&
+        NF->convertToInteger(NI, APFloat::rmTowardZero, &Ignored) ==
+            APFloat::opOK &&
         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, LibFunc_exp2, LibFunc_exp2f,
Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) {
 
   // If the exponent is negative, then get the reciprocal.
   if (ExpoF->isNegative())
     Sqrt = B.CreateFDiv(ConstantFP::get(Ty, 1.0), Sqrt, "reciprocal");
 
   return Sqrt;
 }
 
+static Value *createPowWithIntegerExponent(Value *Base, Value *Expo, Module *M,
+                                      IRBuilder<> &B) {
+  Value *Args[] = {Base, Expo};
+  Function *F = Intrinsic::getDeclaration(M, Intrinsic::powi, Base->getType());
+  return B.CreateCall(F, Args);
+}
+
 Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
-  Value *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
+  Value *Base = Pow->getArgOperand(0);
+  Value *Expo = Pow->getArgOperand(1);
   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 (!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))
+  if (UnsafeFPShrink && Name == TLI->getName(LibFunc_pow) &&
+      hasFloatVersion(Name))
     Shrunk = optimizeBinaryDoubleFP(Pow, B, true);
 
   // Evaluate special cases related to the base.
 
   // pow(1.0, x) -> 1.0
   if (match(Base, m_FPOne()))
     return Base;
 
+  // powf(x, sitofp(e)) -> powi(x, e)
+  // powf(x, uitofp(e)) -> powi(x, e)
+  if (AllowApprox && (isa<SIToFPInst>(Expo) || isa<UIToFPInst>(Expo))) {
+    Value *IntExpo = cast<Instruction>(Expo)->getOperand(0);
+    Value *NewExpo = nullptr;
+    unsigned BitWidth = IntExpo->getType()->getPrimitiveSizeInBits();
+    if (isa<SIToFPInst>(Expo) && BitWidth == 32)
+      NewExpo = IntExpo;
+    else if (BitWidth < 32)
+      NewExpo = isa<SIToFPInst>(Expo) ? B.CreateSExt(IntExpo, B.getInt32Ty())
+                                      : B.CreateZExt(IntExpo, B.getInt32Ty());
+    if (NewExpo)
+      return createPowWithIntegerExponent(Base, NewExpo, M, B);
+  }
+
   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
   if (match(Expo, m_SpecificFP(0.0)))
-      return ConstantFP::get(Ty, 1.0);
 
   // pow(x, 1.0) -> x
   if (match(Expo, m_FPOne()))
     return Base;
 
   // pow(x, 2.0) -> x * x
   if (match(Expo, m_SpecificFP(2.0)))
     return B.CreateFMul(Base, Base, "square");
 
   if (Value *Sqrt = replacePowWithSqrt(Pow, B))
     return Sqrt;
 
+  if (!AllowApprox)
+    return Shrunk;
+
   // pow(x, n) -> x * x * x * ...
   const APFloat *ExpoF;
-  if (Pow->isFast() && match(Expo, m_APFloat(ExpoF))) {
+  if (match(Expo, m_APFloat(ExpoF))) {
     // We limit to a max of 7 multiplications, thus the maximum exponent is 32.
     // If the exponent is an integer+0.5 we generate a call to sqrt and an
     // additional fmul.
     // TODO: This whole transformation should be backend specific (e.g. some
     //       backends might prefer libcalls or the limit for the exponent might
     //       be different) and it should also consider optimizing for size.
     APFloat LimF(ExpoF->getSemantics(), 33.0),
             ExpoA(abs(*ExpoF));
     if (ExpoA.compare(LimF) == APFloat::cmpLessThan) {
       // This transformation applies to integer or integer+0.5 exponents only.
       // For integer+0.5, we create a sqrt(Base) call.
       Value *Sqrt = nullptr;
       if (!ExpoA.isInteger()) {
         APFloat Expo2 = ExpoA;
         // To check if ExpoA is an integer + 0.5, we add it to itself. If there
         // is no floating point exception and the result is an integer, then
         // ExpoA == integer + 0.5
         if (Expo2.add(ExpoA, APFloat::rmNearestTiesToEven) != APFloat::opOK)
           return nullptr;
 
         if (!Expo2.isInteger())
           return nullptr;
 
-        Sqrt =
-            getSqrtCall(Base, Pow->getCalledFunction()->getAttributes(),
-                        Pow->doesNotAccessMemory(), Pow->getModule(), B, TLI);
+        Sqrt = getSqrtCall(Base, Pow->getCalledFunction()->getAttributes(),
+                           Pow->doesNotAccessMemory(), M, B, TLI);
       }
 
       // 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);
 
       // Expand pow(x, y+0.5) to pow(x, y) * sqrt(x).
       if (Sqrt)
         FMul = B.CreateFMul(FMul, Sqrt);
 
       // If the exponent is negative, then get the reciprocal.
       if (ExpoF->isNegative())
         FMul = B.CreateFDiv(ConstantFP::get(Ty, 1.0), FMul, "reciprocal");
 
       return FMul;
     }
+
+    APSInt IntExpo(32, /*isUnsigned=*/false);
+    // powf(x, C) -> powi(x, C) iff C is a constant signed integer value
+    if (ExpoF->convertToInteger(IntExpo, APFloat::rmTowardZero, &Ignored) ==
+        APFloat::opOK) {
+      return createPowWithIntegerExponent(
+          Base, ConstantInt::get(B.getInt32Ty(), IntExpo), M, B);
+    }
   }
 
   return Shrunk;
 }
 
 Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Ret = nullptr;
Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI) {
   default:
     break;
   }
   return nullptr;
 }
 
 FortifiedLibCallSimplifier::FortifiedLibCallSimplifier(
     const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
-    : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
+    : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
 No newline at end of file

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)
 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>)
 declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>)
 declare double @pow(double, double)
 
 ; 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]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[SQUARE]], [[X]]
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %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]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[SQUARE]], [[SQUARE]]
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %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]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[SQUARE]], [[SQUARE]]
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double 4.000000e+00)
   ret double %1
 }
 
 ; 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 <2 x float> [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x float> [[TMP1]], [[X]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast <2 x float> [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <2 x float> [[SQUARE]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x float> [[TMP1]], [[TMP1]]
 ; 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]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast <2 x float> [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    ret <2 x float> [[TMP4]]
 ;
   %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 <2 x double> @test_simplify_neg_7(<2 x double> %x) {
 ; CHECK-LABEL: @test_simplify_neg_7(
-; 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]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast <2 x double> [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <2 x double> [[SQUARE]], [[SQUARE]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x double> [[TMP1]], [[X]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast <2 x double> [[SQUARE]], [[TMP2]]
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP3]]
+; CHECK-NEXT:    ret <2 x double> [[RECIPROCAL]]
 ;
   %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
 }
 
 ; powf(x, -19.0)
 define float @test_simplify_neg_19(float %x) {
 ; CHECK-LABEL: @test_simplify_neg_19(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[SQUARE]], [[SQUARE]]
 ; 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]]
+; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast float [[SQUARE]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = fmul fast float [[TMP4]], [[X]]
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast float 1.000000e+00, [[TMP5]]
+; CHECK-NEXT:    ret float [[RECIPROCAL]]
 ;
   %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
 }
 
 ; powf(x, 32.0)
 define float @test_simplify_32(float %x) {
 ; CHECK-LABEL: @test_simplify_32(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast float [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[SQUARE]], [[SQUARE]]
 ; 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]]
+; CHECK-NEXT:    ret float [[TMP4]]
 ;
   %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:    [[TMP1:%.*]] = call fast double @llvm.powi.f64(double [[X:%.*]], i32 33)
 ; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double 3.300000e+01)
   ret double %1
 }
 
 ; pow(x, 16.5) with double
 define double @test_simplify_16_5(double %x) {
 ; CHECK-LABEL: @test_simplify_16_5(
-; CHECK-NEXT:    [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X]])
-; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X]], [[X]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[SQUARE]], [[SQUARE]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
 ; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[TMP2]]
 ; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP3]], [[SQRT]]
 ; CHECK-NEXT:    ret double [[TMP4]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double 1.650000e+01)
   ret double %1
 }
 
 ; pow(x, -16.5) with double
 define double @test_simplify_neg_16_5(double %x) {
 ; CHECK-LABEL: @test_simplify_neg_16_5(
-; CHECK-NEXT:    [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X]])
-; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X:%.*]], [[X]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast double [[X]], [[X]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[SQUARE]], [[SQUARE]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[TMP1]]
 ; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast double [[TMP2]], [[TMP2]]
 ; CHECK-NEXT:    [[TMP4:%.*]] = fmul fast double [[TMP3]], [[SQRT]]
 ; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv fast double 1.000000e+00, [[TMP4]]
 ; CHECK-NEXT:    ret double [[RECIPROCAL]]
 ;
   %1 = call fast double @llvm.pow.f64(double %x, double -1.650000e+01)
;
   %1 = call fast <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double 7.500000e+00, double 7.500000e+00>)
   ret <2 x double> %1
 }
 
 ; pow(x, 3.5) with <4 x float>
 define <4 x float> @test_simplify_3_5(<4 x float> %x) {
 ; CHECK-LABEL: @test_simplify_3_5(
 ; CHECK-NEXT:    [[SQRT:%.*]] = call fast <4 x float> @llvm.sqrt.v4f32(<4 x float> [[X:%.*]])
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <4 x float> [[X]], [[X]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <4 x float> [[TMP1]], [[X]]
-; CHECK-NEXT:    [[TMP3:%.*]] = fmul fast <4 x float> [[TMP2]], [[SQRT]]
-; CHECK-NEXT:    ret <4 x float> [[TMP3]]
+; CHECK-NEXT:    [[SQUARE:%.*]] = fmul fast <4 x float> [[X]], [[X]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast <4 x float> [[SQUARE]], [[X]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <4 x float> [[TMP1]], [[SQRT]]
+; CHECK-NEXT:    ret <4 x float> [[TMP2]]
 ;
   %1 = call fast <4 x float> @llvm.pow.v4f32(<4 x float> %x, <4 x float> <float 3.500000e+00, float 3.500000e+00, float 3.500000e+00, float 3.500000e+00>)
   ret <4 x float> %1
 }
 

test/Transforms/InstCombine/pow_fp_int.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 ; PR42190
 
 define double @pow_sitofp_const_base_fast(i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_const_base_fast(
-; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[POWI:%.*]] = tail call fast float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
-; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POWI]] to double
+; CHECK-NEXT:    [[TMP1:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[X:%.*]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP1]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call fast float @llvm.pow.f32(float 7.000000e+00, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
-define double @pow_sitofp_const_base_power_of_2_fast(i32 %x) {
-; CHECK-LABEL: @pow_sitofp_const_base_power_of_2_fast(
-; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[SUBFP]], 4.000000e+00
-; CHECK-NEXT:    [[EXP2:%.*]] = call fast float @llvm.exp2.f32(float [[MUL]])
-; CHECK-NEXT:    [[RES:%.*]] = fpext float [[EXP2]] to double
+define double @pow_uitofp_const_base_fast(i31 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i31 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_sitofp_double_const_base_fast(i32 %x) {
+; CHECK-LABEL: @pow_sitofp_double_const_base_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = call afn double @llvm.powi.f64(double 7.000000e+00, i32 [[X:%.*]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+  %subfp = sitofp i32 %x to double
+  %pow = tail call afn double @llvm.pow.f64(double 7.000000e+00, double %subfp)
+  ret double %pow
+}
+
+define double @pow_uitofp_double_const_base_fast(i31 %x) {
+; CHECK-LABEL: @pow_uitofp_double_const_base_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn double @llvm.powi.f64(double 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    ret double [[TMP2]]
+;
+  %subfp = uitofp i31 %x to double
+  %pow = tail call afn double @llvm.pow.f64(double 7.000000e+00, double %subfp)
+  ret double %pow
+}
+
+define double @pow_sitofp_double_const_base_power_of_2_fast(i32 %x) {
+; CHECK-LABEL: @pow_sitofp_double_const_base_power_of_2_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = call afn float @llvm.powi.f32(float 1.600000e+01, i32 [[X:%.*]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP1]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call fast float @llvm.pow.f32(float 16.000000e+00, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call afn float @llvm.pow.f32(float 16.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_power_of_2_fast(i31 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_power_of_2_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 1.600000e+01, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i31 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 16.000000e+00, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_float_base_fast(float %base, i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_float_base_fast(
-; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[POWI:%.*]] = tail call fast float @llvm.pow.f32(float [[BASE:%.*]], float [[SUBFP]])
-; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POWI]] to double
+; CHECK-NEXT:    [[TMP1:%.*]] = call afn float @llvm.powi.f32(float [[BASE:%.*]], i32 [[X:%.*]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP1]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call fast float @llvm.pow.f32(float %base, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call afn float @llvm.pow.f32(float %base, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_float_base_fast(float %base, i31 %x) {
+; CHECK-LABEL: @pow_uitofp_float_base_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float [[BASE:%.*]], i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i31 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float %base, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_double_base_fast(double %base, i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_double_base_fast(
-; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to double
-; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @llvm.pow.f64(double [[BASE:%.*]], double [[SUBFP]])
-; CHECK-NEXT:    ret double [[RES]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call afn double @llvm.powi.f64(double [[BASE:%.*]], i32 [[X:%.*]])
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %subfp = sitofp i32 %x to double
-  %res = tail call fast double @llvm.pow.f64(double %base, double %subfp)
+  %res = tail call afn double @llvm.pow.f64(double %base, double %subfp)
+  ret double %res
+}
+
+define double @pow_uitofp_double_base_fast(double %base, i31 %x) {
+; CHECK-LABEL: @pow_uitofp_double_base_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn double @llvm.powi.f64(double [[BASE:%.*]], i32 [[TMP1]])
+; CHECK-NEXT:    ret double [[TMP2]]
+;
+  %subfp = uitofp i31 %x to double
+  %res = tail call afn double @llvm.pow.f64(double %base, double %subfp)
+  ret double %res
+}
+
+define double @pow_sitofp_const_base_fast_i8(i8 %x) {
+; CHECK-LABEL: @pow_sitofp_const_base_fast_i8(
+; CHECK-NEXT:    [[TMP1:%.*]] = sext i8 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = sitofp i8 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_sitofp_const_base_fast_i16(i16 %x) {
+; CHECK-LABEL: @pow_sitofp_const_base_fast_i16(
+; CHECK-NEXT:    [[TMP1:%.*]] = sext i16 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = sitofp i16 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+
+define double @pow_uitofp_const_base_fast_i8(i8 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_fast_i8(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i8 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_fast_i16(i16 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_fast_i16(
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i16 [[X:%.*]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = call afn float @llvm.powi.f32(float 7.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[TMP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i16 %x to float
+  %pow = tail call afn float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @powf_exp_const_int_fast(double %base) {
 ; CHECK-LABEL: @powf_exp_const_int_fast(
-; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @llvm.pow.f64(double [[BASE:%.*]], double 4.000000e+01)
-; CHECK-NEXT:    ret double [[RES]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.powi.f64(double [[BASE:%.*]], i32 40)
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %res = tail call fast double @llvm.pow.f64(double %base, double 4.000000e+01)
   ret double %res
 }
 
+define double @powf_exp_const2_int_fast(double %base) {
+; CHECK-LABEL: @powf_exp_const2_int_fast(
+; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.powi.f64(double [[BASE:%.*]], i32 -40)
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+  %res = tail call fast double @llvm.pow.f64(double %base, double -4.000000e+01)
+  ret double %res
+}
+
+; Negative tests
+
+define double @pow_uitofp_const_base_fast_i32(i32 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_fast_i32(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call fast float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call fast float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_power_of_2_fast_i32(i32 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_power_of_2_fast_i32(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[SUBFP]], 4.000000e+00
+; CHECK-NEXT:    [[EXP2:%.*]] = call fast float @llvm.exp2.f32(float [[MUL]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[EXP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call fast float @llvm.pow.f32(float 16.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_float_base_fast_i32(float %base, i32 %x) {
+; CHECK-LABEL: @pow_uitofp_float_base_fast_i32(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call fast float @llvm.pow.f32(float [[BASE:%.*]], float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call fast float @llvm.pow.f32(float %base, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_double_base_fast_i32(double %base, i32 %x) {
+; CHECK-LABEL: @pow_uitofp_double_base_fast_i32(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to double
+; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @llvm.pow.f64(double [[BASE:%.*]], double [[SUBFP]])
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to double
+  %res = tail call fast double @llvm.pow.f64(double %base, double %subfp)
+  ret double %res
+}
+
+define double @pow_sitofp_const_base_fast_i64(i64 %x) {
+; CHECK-LABEL: @pow_sitofp_const_base_fast_i64(
+; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i64 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call fast float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = sitofp i64 %x to float
+  %pow = tail call fast float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_fast_i64(i64 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_fast_i64(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i64 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call fast float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i64 %x to float
+  %pow = tail call fast float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
 define double @pow_sitofp_const_base_no_fast(i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_const_base_no_fast(
 ; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[POWI:%.*]] = tail call float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
-; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POWI]] to double
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call float @llvm.pow.f32(float 7.000000e+00, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_no_fast(i32 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_no_fast(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @llvm.pow.f32(float 7.000000e+00, float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call float @llvm.pow.f32(float 7.000000e+00, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_const_base_power_of_2_no_fast(i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_const_base_power_of_2_no_fast(
 ; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUBFP]], 4.000000e+00
 ; CHECK-NEXT:    [[EXP2:%.*]] = call float @llvm.exp2.f32(float [[MUL]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[EXP2]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call float @llvm.pow.f32(float 16.000000e+00, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call float @llvm.pow.f32(float 16.000000e+00, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_const_base_power_of_2_no_fast(i32 %x) {
+; CHECK-LABEL: @pow_uitofp_const_base_power_of_2_no_fast(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUBFP]], 4.000000e+00
+; CHECK-NEXT:    [[EXP2:%.*]] = call float @llvm.exp2.f32(float [[MUL]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[EXP2]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call float @llvm.pow.f32(float 16.000000e+00, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_float_base_no_fast(float %base, i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_float_base_no_fast(
 ; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[POWI:%.*]] = tail call float @llvm.pow.f32(float [[BASE:%.*]], float [[SUBFP]])
-; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POWI]] to double
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @llvm.pow.f32(float [[BASE:%.*]], float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
-  %powi = tail call float @llvm.pow.f32(float %base, float %subfp)
-  %res = fpext float %powi to double
+  %pow = tail call float @llvm.pow.f32(float %base, float %subfp)
+  %res = fpext float %pow to double
+  ret double %res
+}
+
+define double @pow_uitofp_float_base_no_fast(float %base, i32 %x) {
+; CHECK-LABEL: @pow_uitofp_float_base_no_fast(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @llvm.pow.f32(float [[BASE:%.*]], float [[SUBFP]])
+; CHECK-NEXT:    [[RES:%.*]] = fpext float [[POW]] to double
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %subfp = uitofp i32 %x to float
+  %pow = tail call float @llvm.pow.f32(float %base, float %subfp)
+  %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_double_base_no_fast(double %base, i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_double_base_no_fast(
 ; CHECK-NEXT:    [[SUBFP:%.*]] = sitofp i32 [[X:%.*]] to double
-; CHECK-NEXT:    [[POWI:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double [[SUBFP]])
-; CHECK-NEXT:    ret double [[POWI]]
+; CHECK-NEXT:    [[POW:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double [[SUBFP]])
+; CHECK-NEXT:    ret double [[POW]]
 ;
   %subfp = sitofp i32 %x to double
-  %powi = tail call double @llvm.pow.f64(double %base, double %subfp)
-  ret double %powi
+  %pow = tail call double @llvm.pow.f64(double %base, double %subfp)
+  ret double %pow
+}
+
+define double @pow_uitofp_double_base_no_fast(double %base, i32 %x) {
+; CHECK-LABEL: @pow_uitofp_double_base_no_fast(
+; CHECK-NEXT:    [[SUBFP:%.*]] = uitofp i32 [[X:%.*]] to double
+; CHECK-NEXT:    [[POW:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double [[SUBFP]])
+; CHECK-NEXT:    ret double [[POW]]
+;
+  %subfp = uitofp i32 %x to double
+  %pow = tail call double @llvm.pow.f64(double %base, double %subfp)
+  ret double %pow
 }
 
 define double @powf_exp_const_int_no_fast(double %base) {
 ; CHECK-LABEL: @powf_exp_const_int_no_fast(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double 4.000000e+01)
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %res = tail call double @llvm.pow.f64(double %base, double 4.000000e+01)

 ; CHECK-LABEL: @powf_exp_const_not_int_no_fast(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double 3.750000e+01)
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %res = tail call double @llvm.pow.f64(double %base, double 3.750000e+01)
   ret double %res
 }
 
+define double @powf_exp_const2_int_no_fast(double %base) {
+; CHECK-LABEL: @powf_exp_const2_int_no_fast(
+; CHECK-NEXT:    [[RES:%.*]] = tail call double @llvm.pow.f64(double [[BASE:%.*]], double -4.000000e+01)
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %res = tail call double @llvm.pow.f64(double %base, double -4.000000e+01)
+  ret double %res
+}
+
 declare float @llvm.pow.f32(float, float)
 declare double @llvm.pow.f64(double, double)