[InstCombine] fold fdiv with pow divisor (PR49147)

[spatel]

Summary

This is unusual in the general (non-reciprocal) case because we need an extra instruction, but that should be better for general FP reassociation and codegen. We conservatively check for "arcp" FMF here as we do with existing fdiv folds, but it is not strictly necessary to have that.

This is part of solving:
https://llvm.org/PR49147
(The powi variant potentially has a different constraint.)

[lebedev.ri]

Hm, alive2 doesn't support fast-math flags still?
Filed https://github.com/AliveToolkit/alive2/issues/667

This seems fine to me.

llvm/test/Transforms/InstCombine/fdiv.ll

698

Might be worth duplicating the test with reassoc missing instead?

[spatel]

In D96648#2561792, @lebedev.ri wrote:

Hm, alive2 doesn't support fast-math flags still?
Filed https://github.com/AliveToolkit/alive2/issues/667

Thanks! Yes, I think Alive2 knows how to handle the "special value" FMF (ninf, nnan, nsz), but not these math properties.

llvm/test/Transforms/InstCombine/fdiv.ll

698

Yes, good point - or I can just have both variants (only reassoc and only arcp). If we change our FMF fdiv constraints in the future, we'll have coverage in either direction.

[RKSimon]

llvm.powi ?

[RKSimon]

In D96648#2561810, @RKSimon wrote:

llvm.powi ?

Sorry - just read your comment on PR49147. Could we at least support inrange constant ints?

[spatel]

Added another test for FMF.

[lebedev.ri]

Looks good to me.

[spatel]

In D96648#2561821, @RKSimon wrote:

In D96648#2561810, @RKSimon wrote:

llvm.powi ?

Sorry - just read your comment on PR49147. Could we at least support inrange constant ints?

We could do that, but it won't solve the example in the bug report. I think we need to check if the call has an fdiv use and suppress the conversion to powi in SimplifyLibCalls:

// powf(x, itofp(y)) -> powi(x, y)

...or fold the whole pattern at once.

Otherwise, we lose information when we fold the cast into the call. Either way, I think we want to do that in an independent patch. I can work on that next.

[RKSimon]

OK cheers - lets go with this first to get the pow variant dealt with

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (I.hasAllowReassoc() && I.hasAllowReciprocal()) {
     // Z / (1.0 / Y) => (Y * Z)
     //
     // This is a special case of Z / (X / Y) => (Y * Z) / X, with X = 1.0. The
     // m_OneUse check is avoided because even in the case of the multiple uses
     // for 1.0/Y, the number of instructions remain the same and a division is
     // replaced by a multiplication.
     if (match(Op1, m_FDiv(m_SpecificFP(1.0), m_Value(Y))))
       return BinaryOperator::CreateFMulFMF(Y, Op0, &I);
+
+    // Negate the exponent of pow to fold division-by-pow() into multiply:
+    // Z / pow(X, Y) --> Z * pow(X, -Y)
+    // In the general case, this creates an extra instruction, but fmul allows
+    // for better canonicalization and optimization than fdiv.
+    if (match(Op1,
+              m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))))) {
+      Value *NegY = Builder.CreateFNegFMF(Y, &I);
+      Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, NegY, &I);
+      return BinaryOperator::CreateFMulFMF(Op0, Pow, &I);
+    }
   }
 
   if (I.hasAllowReassoc() && Op0->hasOneUse() && Op1->hasOneUse()) {
     // sin(X) / cos(X) -> tan(X)
     // cos(X) / sin(X) -> 1/tan(X) (cotangent)
     Value *X;
     bool IsTan = match(Op0, m_Intrinsic<Intrinsic::sin>(m_Value(X))) &&
                  match(Op1, m_Intrinsic<Intrinsic::cos>(m_Specific(X)));

llvm/test/Transforms/InstCombine/fdiv.ll

;
   %y.fabs = call float @llvm.fabs.f32(float %y)
   call void @use_f32(float %y.fabs)
   %r = fdiv float %x.fabs, %y.fabs
   ret float %r
 }
 
 define float @pow_divisor(float %x, float %y, float %z) {
 ; CHECK-LABEL: @pow_divisor(
-; CHECK-NEXT:    [[P:%.*]] = call float @llvm.pow.f32(float [[X:%.*]], float [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv reassoc arcp float [[Z:%.*]], [[P]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg reassoc arcp float [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call reassoc arcp float @llvm.pow.f32(float [[X:%.*]], float [[TMP1]])
+; CHECK-NEXT:    [[R:%.*]] = fmul reassoc arcp float [[TMP2]], [[Z:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %p = call float @llvm.pow.f32(float %x, float %y)
   %r = fdiv reassoc arcp float %z, %p
   ret float %r
 }
 
+; Negative test - don't create an extra pow
+
 define float @pow_divisor_extra_use(float %x, float %y, float %z) {
 ; CHECK-LABEL: @pow_divisor_extra_use(
 ; CHECK-NEXT:    [[P:%.*]] = call float @llvm.pow.f32(float [[X:%.*]], float [[Y:%.*]])
 ; CHECK-NEXT:    call void @use_f32(float [[P]])
 ; CHECK-NEXT:    [[R:%.*]] = fdiv reassoc arcp float [[Z:%.*]], [[P]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %p = call float @llvm.pow.f32(float %x, float %y)
   call void @use_f32(float %p)
   %r = fdiv reassoc arcp float %z, %p
   ret float %r
 }
 
+; Negative test - must have reassoc+arcp
+
 define float @pow_divisor_not_enough_fmf(float %x, float %y, float %z) {
 ; CHECK-LABEL: @pow_divisor_not_enough_fmf(
 ; CHECK-NEXT:    [[P:%.*]] = call fast float @llvm.pow.f32(float [[X:%.*]], float [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = fdiv reassoc float [[Z:%.*]], [[P]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %p = call fast float @llvm.pow.f32(float %x, float %y)
   %r = fdiv reassoc float %z, %p
   ret float %r
 }
 
+; Negative test - must have reassoc+arcp
+
 define float @pow_divisor_not_enough_fmf2(float %x, float %y, float %z) {
 ; CHECK-LABEL: @pow_divisor_not_enough_fmf2(
 ; CHECK-NEXT:    [[P:%.*]] = call fast float @llvm.pow.f32(float [[X:%.*]], float [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = fdiv arcp float [[Z:%.*]], [[P]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %p = call fast float @llvm.pow.f32(float %x, float %y)
   %r = fdiv arcp float %z, %p
   ret float %r
 }
 
+; Special-case - reciprocal does not require extra fmul
+
 define <2 x half> @pow_recip(<2 x half> %x, <2 x half> %y) {
 ; CHECK-LABEL: @pow_recip(
-; CHECK-NEXT:    [[P:%.*]] = call <2 x half> @llvm.pow.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv reassoc ninf arcp <2 x half> <half 0xH3C00, half 0xH3C00>, [[P]]
-; CHECK-NEXT:    ret <2 x half> [[R]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg reassoc ninf arcp <2 x half> [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call reassoc ninf arcp <2 x half> @llvm.pow.v2f16(<2 x half> [[X:%.*]], <2 x half> [[TMP1]])
+; CHECK-NEXT:    ret <2 x half> [[TMP2]]
 ;
   %p = call <2 x half> @llvm.pow.v2f16(<2 x half> %x, <2 x half> %y)
   %r = fdiv reassoc arcp ninf <2 x half> <half 1.0, half 1.0>, %p
   ret <2 x half> %r
 }