[InstCombine] Adding Z / (1.0 / Y) => (Y * Z)

[raghesh]

Summary

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.

The following testcase is updated.

test/Transforms/InstCombine/fdiv.ll

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1249

I don't think these constant checks are necessary. (I'm not sure why they are part of the existing code either - maybe some corner case with denorm values?)

If Y is a constant, 1.0/C will get constant folded and Z/C' will eventually get folded too, so this should just get to canonical form quicker. The 'Z' is constant pattern is similar.

FDiv with constant operand are generally handled within:
foldFDivConstantDivisor()
foldFDivConstantDividend()

llvm/test/Transforms/InstCombine/fdiv-to-fmul-opt.ll

15–21

1. Add a test within test/Transforms/InstCombine/fdiv.ll instead of creating a new file.
2. Create minimal test(s) to show the transform; in particular, this transform does not require any of alloca, load, store, so the test shouldn't have those.
3. Use this script to auto-generate the CHECK lines:

utils/update_test_checks.py

4. I prefer that you add the test *without* this code patch showing the current IR produced as a preliminary patch. That way, we will see the diff from the new transform when this patch is committed.
5. If you need help committing/pushing the patches, let me know.

[raghesh]

llvm/test/Transforms/InstCombine/fdiv-to-fmul-opt.ll

15–21

Thanks for the commets. I will address these.

However, point number 4 is not clear to me. Could you please explain it?

Yes. As I don't have commit access, I will need your help in committing it.

[craig.topper]

llvm/test/Transforms/InstCombine/fdiv-to-fmul-opt.ll

15–21

For point 4. Create a new review containing just the new test case with no other changes. This will show what the current behavior is. Then rebase this review to be on top of that so that this review just shows how the test changes with the transformation.

[raghesh]

llvm/test/Transforms/InstCombine/fdiv-to-fmul-opt.ll

15–21

Test case added with a new reivew https://reviews.llvm.org/D72388

[spatel]

llvm/test/Transforms/InstCombine/fdiv-to-fmul-opt.ll

15–21

Thanks - that was pushed here:
rG5dfd52398f5c

You can now rebase/update this patch.

[raghesh]

This revision is updated with the expected change in the testcase test/Transforms/InstCombine/fdiv-to-fmul-opt.ll. Other comments are addressed too.

[spatel]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (match(Op0, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
       return BinaryOperator::CreateFDivFMF(X, YZ, &I);
     }
     if (match(Op1, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
         (!isa<Constant>(Y) || !isa<Constant>(Op0))) {
       // Z / (X / Y) => (Y * Z) / X
       Value *YZ = Builder.CreateFMulFMF(Y, Op0, &I);
       return BinaryOperator::CreateFDivFMF(YZ, X, &I);
     }
+    // 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))) &&
+        (!isa<Constant>(Y) || !isa<Constant>(Op0)))
+      return BinaryOperator::CreateFMulFMF(Y, Op0, &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-to-fmul-opt.ll

+; RUN: opt -S -instcombine < %s | FileCheck %s
+
+; NOTE: double fun() {
+; NOTE:   double r1, r2, r3, r4, r5, r6, r7;
+; NOTE:
+; NOTE:   r2 = 1.0 / sqrt(r1);
+; NOTE:   r3 = r4 / r2;
+; NOTE:
+; NOTE:   r7 = r6 * r2;
+; NOTE:
+; NOTE:   return r7 * r3;
+; NOTE: }
+; NOTE: IR for the above C code is given below.
+
+define dso_local double @fun() #0 {
+  %r1 = alloca double, align 8
+  %r2 = alloca double, align 8
+  %r3 = alloca double, align 8
+  %r4 = alloca double, align 8
+  %r5 = alloca double, align 8
+  %r6 = alloca double, align 8
+  %r7 = alloca double, align 8
+  %A = load double, double* %r1, align 8
+  %B = call fast double @llvm.sqrt.f64(double %A)
+  %div = fdiv fast double 1.000000e+00, %B
+  store double %div, double* %r2, align 8
+  %C = load double, double* %r4, align 8
+  %D = load double, double* %r2, align 8
+  %div1 = fdiv fast double %C, %D
+  store double %div1, double* %r3, align 8
+  %E = load double, double* %r6, align 8
+  %F = load double, double* %r2, align 8
+  %mul = fmul fast double %E, %F
+  store double %mul, double* %r7, align 8
+  %G = load double, double* %r7, align 8
+  %H = load double, double* %r3, align 8
+  %mul2 = fmul fast double %G, %H
+  ret double %mul2
+
+; CHECK-NOT:  fdiv fast double 1.000000e+00, %B
+; CHECK-NOT:  %div1 = fdiv fast double %C, %D
+; CHECK:      %B = call fast double @llvm.sqrt.f64(double %A)
+; CHECK-NEXT: %C = load double, double* %r4, align 8
+; CHECK-NEXT: %div1 = fmul fast double %B, %C
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare double @llvm.sqrt.f64(double) #1