[InstCombine] powi(x, y) * powi(x, z) -> powi(x, y + z)

[xbolva00]

Summary

We already have pow(x, y) * pow(x, z) -> pow(x, y + z) transformation, but we are missing same transformation for powi (power is integer).

Requires reassoc.

[xbolva00]

One more neg. test (different bases).

[spatel]

Pre-commit tests please, so it's easier to see transforms vs. negative tests.
We need to propagate the FMF to the new powi (should be able to compare against the existing 'pow' tests to see if we're missing any corner cases).

I'd vary at least one positive test to have extra FMF (eg, "fast"), so we know everything is transferred as expected.

And we need at least one more test like this:

define double @different_types_powi(double %x, i32 %y, i64 %z) {
  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
  %p2 = tail call double @llvm.powi.f64.i64(double %x, i64 %z)
  %mul = fmul reassoc double %p2, %p1
  ret double %mul
}

[xbolva00]

Tests added & precommited.

[xbolva00]

In D109954#3006594, @spatel wrote:

Pre-commit tests please, so it's easier to see transforms vs. negative tests.
We need to propagate the FMF to the new powi (should be able to compare against the existing 'pow' tests to see if we're missing any corner cases).

I'd vary at least one positive test to have extra FMF (eg, "fast"), so we know everything is transferred as expected.

And we need at least one more test like this:

define double @different_types_powi(double %x, i32 %y, i64 %z) {
  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
  %p2 = tail call double @llvm.powi.f64.i64(double %x, i64 %z)
  %mul = fmul reassoc double %p2, %p1
  ret double %mul
}

Thanks!

different_types_powi

gotcha, added type check.

[spatel]

LGTM

llvm/test/Transforms/InstCombine/powi.ll

82–217

I don't think this actually tests the pattern that we want. We just swapped the names of y and z, so it's functionally the same as the previous test. Just commute the fmul operands instead?

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (I.isOnlyUserOfAnyOperand()) {
       // pow(x, y) * pow(x, z) -> pow(x, y + z)
       if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
           match(Op1, m_Intrinsic<Intrinsic::pow>(m_Specific(X), m_Value(Z)))) {
         auto *YZ = Builder.CreateFAddFMF(Y, Z, &I);
         auto *NewPow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, YZ, &I);
         return replaceInstUsesWith(I, NewPow);
       }
 
+      // powi(x, y) * powi(x, z) -> powi(x, y + z)
+      if (match(Op0, m_Intrinsic<Intrinsic::powi>(m_Value(X), m_Value(Y))) &&
+          match(Op1, m_Intrinsic<Intrinsic::powi>(m_Specific(X), m_Value(Z)))) {
+        auto *YZ = Builder.CreateAdd(Y, Z);
+        Function *F = Intrinsic::getDeclaration(I.getModule(), Intrinsic::powi,
+                                                {X->getType(), YZ->getType()});
+        auto *NewPow = Builder.CreateCall(F, {X, YZ});
+        return replaceInstUsesWith(I, NewPow);
+      }
+
       // exp(X) * exp(Y) -> exp(X + Y)
       if (match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X))) &&
           match(Op1, m_Intrinsic<Intrinsic::exp>(m_Value(Y)))) {
         Value *XY = Builder.CreateFAddFMF(X, Y, &I);
         Value *Exp = Builder.CreateUnaryIntrinsic(Intrinsic::exp, XY, &I);
         return replaceInstUsesWith(I, Exp);
       }
 

llvm/test/Transforms/InstCombine/powi.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 declare double @llvm.powi.f64.i32(double, i32)
 declare double @llvm.fabs.f64(double)
 declare double @llvm.copysign.f64(double, double)
+declare void @use(double)
 
 define double @powi_fneg_even_int(double %x) {
 ; CHECK-LABEL: @powi_fneg_even_int(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[R:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 4)
 ; CHECK-NEXT:    ret double [[R]]
 ;
 entry:

 ; CHECK-NEXT:    [[CS:%.*]] = tail call double @llvm.copysign.f64(double [[X:%.*]], double [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = tail call double @llvm.powi.f64.i32(double [[CS]], i32 5)
 ; CHECK-NEXT:    ret double [[R]]
 ;
 entry:
   %cs = tail call double @llvm.copysign.f64(double %x, double %y)
   %r = tail call double @llvm.powi.f64.i32(double %cs, i32 5)
   ret double %r
 }
+
+define double @powi_fmul_arg0_no_reassoc(double %x, i32 %i) {
+; CHECK-LABEL: @powi_fmul_arg0_no_reassoc(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[POW:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[I:%.*]])
+; CHECK-NEXT:    [[MUL:%.*]] = fmul double [[POW]], [[X]]
+; CHECK-NEXT:    ret double [[MUL]]
+;
+entry:
+  %pow = tail call double @llvm.powi.f64.i32(double %x, i32 %i)
+  %mul = fmul double %pow, %x
+  ret double %mul
+}
+
+
+define double @powi_fmul_arg0(double %x, i32 %i) {
+; CHECK-LABEL: @powi_fmul_arg0(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[POW:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[I:%.*]])
+; CHECK-NEXT:    [[MUL:%.*]] = fmul reassoc double [[POW]], [[X]]
+; CHECK-NEXT:    ret double [[MUL]]
+;
+entry:
+  %pow = tail call double @llvm.powi.f64.i32(double %x, i32 %i)
+  %mul = fmul reassoc double %pow, %x
+  ret double %mul
+}
+
+define double @powi_fmul_arg0_use(double %x, i32 %i) {
+; CHECK-LABEL: @powi_fmul_arg0_use(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[POW:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[I:%.*]])
+; CHECK-NEXT:    tail call void @use(double [[POW]])
+; CHECK-NEXT:    [[MUL:%.*]] = fmul reassoc double [[POW]], [[X]]
+; CHECK-NEXT:    ret double [[MUL]]
+;
+entry:
+  %pow = tail call double @llvm.powi.f64.i32(double %x, i32 %i)
+  tail call void @use(double %pow)
+  %mul = fmul reassoc double %pow, %x
+  ret double %mul
+}
+
+define double @powi_fmul_powi_no_reassoc(double %x, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_powi_no_reassoc(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[P1:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[Y:%.*]])
+; CHECK-NEXT:    [[P2:%.*]] = tail call double @llvm.powi.f64.i32(double [[X]], i32 [[Z:%.*]])
+; CHECK-NEXT:    [[MUL:%.*]] = fmul double [[P2]], [[P1]]
+; CHECK-NEXT:    ret double [[MUL]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %p2 = tail call double @llvm.powi.f64.i32(double %x, i32 %z)
+  %mul = fmul double %p2, %p1
+  ret double %mul
+}
+
+
+define double @powi_fmul_powi(double %x, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_powi(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[Z:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[TMP0]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %p2 = tail call double @llvm.powi.f64.i32(double %x, i32 %z)
+  %mul = fmul reassoc double %p2, %p1
+  ret double %mul
+}
+
+define double @powi_fmul_powi_same_power(double %x, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_powi_same_power(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = shl i32 [[Y:%.*]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[TMP0]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %p2 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %mul = fmul reassoc double %p2, %p1
+  ret double %mul
+}
+
+define double @powi_fmul_powi_use_first(double %x, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_powi_use_first(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[P1:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[Y:%.*]])
+; CHECK-NEXT:    tail call void @use(double [[P1]])
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[Z:%.*]], [[Y]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.powi.f64.i32(double [[X]], i32 [[TMP0]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  tail call void @use(double %p1)
+  %p2 = tail call double @llvm.powi.f64.i32(double %x, i32 %z)
+  %mul = fmul reassoc double %p2, %p1
+  ret double %mul
+}
+
+define double @powi_fmul_powi_use_second(double %x, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_powi_use_second(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[P1:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[Z:%.*]])
+; CHECK-NEXT:    tail call void @use(double [[P1]])
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[Y:%.*]], [[Z]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.powi.f64.i32(double [[X]], i32 [[TMP0]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %z)
+  tail call void @use(double %p1)
+  %p2 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %mul = fmul reassoc double %p2, %p1
+  ret double %mul
+}
+
+define double @powi_fmul_different_base(double %x, double %m, i32 %y, i32 %z) {
+; CHECK-LABEL: @powi_fmul_different_base(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[P1:%.*]] = tail call double @llvm.powi.f64.i32(double [[X:%.*]], i32 [[Y:%.*]])
+; CHECK-NEXT:    [[P2:%.*]] = tail call double @llvm.powi.f64.i32(double [[M:%.*]], i32 [[Z:%.*]])
+; CHECK-NEXT:    [[MUL:%.*]] = fmul reassoc double [[P2]], [[P1]]
+; CHECK-NEXT:    ret double [[MUL]]
+;
+entry:
+  %p1 = tail call double @llvm.powi.f64.i32(double %x, i32 %y)
+  %p2 = tail call double @llvm.powi.f64.i32(double %m, i32 %z)
+  %mul = fmul reassoc double %p2, %p1
+  ret double %mul
+}