[InstCombine] remove flop from lerp patterns

[spatel]

Summary

(Y * (1.0 - Z)) + (X * Z) -->
Y - (Y * Z) + (X * Z) -->
Y + Z * (X - Y)

This is part of solving:
https://bugs.llvm.org/show_bug.cgi?id=42716

Factoring eliminates an instruction, so that should be a good canonicalization. The potential conversion to FMA would be handled by the backend based on target capabilities.

[lebedev.ri]

I'm not confident about the FP fast-math flags, but the match/transform looks good.

[xbolva00]

LG

[spatel]

In D65305#1601864, @lebedev.ri wrote:

I'm not confident about the FP fast-math flags, but the match/transform looks good.

The required 1 is 'reassoc' - it gives us the ability to rearrange terms however we want. We're also requiring 'nsz' to be safe on related factorizations, so I kept that here to be conservative. In practice, if we're allowed to 'reassoc', then we've been given license to go crazy with FP, so all of the other flags are likely in play too (aka 'fast').

llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp

if (Instruction *V = canonicalizeLowbitMask(I, Builder))
     return V;
 
   if (Instruction *SatAdd = foldToUnsignedSaturatedAdd(I))
     return SatAdd;
 
   return Changed ? &I : nullptr;
 }
 
+/// Eliminate an op from a linear interpolation (lerp) pattern.
+static Instruction *factorizeLerp(BinaryOperator &I,
+                                  InstCombiner::BuilderTy &Builder) {
+  Value *X, *Y, *Z;
+  if (!match(&I, m_c_FAdd(m_OneUse(m_c_FMul(m_Value(Y),
+                                            m_OneUse(m_FSub(m_FPOne(),
+                                                            m_Value(Z))))),
+                          m_OneUse(m_c_FMul(m_Value(X), m_Deferred(Z))))))
+    return nullptr;
+
+  // (Y * (1.0 - Z)) + (X * Z) --> Y + Z * (X - Y) [8 commuted variants]
+  Value *XY = Builder.CreateFSubFMF(X, Y, &I);
+  Value *MulZ = Builder.CreateFMulFMF(Z, XY, &I);
+  return BinaryOperator::CreateFAddFMF(Y, MulZ, &I);
+}
+
 /// Factor a common operand out of fadd/fsub of fmul/fdiv.
 static Instruction *factorizeFAddFSub(BinaryOperator &I,
                                       InstCombiner::BuilderTy &Builder) {
   assert((I.getOpcode() == Instruction::FAdd ||
           I.getOpcode() == Instruction::FSub) && "Expecting fadd/fsub");
   assert(I.hasAllowReassoc() && I.hasNoSignedZeros() &&
          "FP factorization requires FMF");
+
+  if (Instruction *Lerp = factorizeLerp(I, Builder))
+    return Lerp;
+
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   Value *X, *Y, *Z;
   bool IsFMul;
   if ((match(Op0, m_OneUse(m_FMul(m_Value(X), m_Value(Z)))) &&
        match(Op1, m_OneUse(m_c_FMul(m_Value(Y), m_Specific(Z))))) ||
       (match(Op0, m_OneUse(m_FMul(m_Value(Z), m_Value(X)))) &&
        match(Op1, m_OneUse(m_c_FMul(m_Value(Y), m_Specific(Z))))))
     IsFMul = true;

llvm/trunk/test/Transforms/InstCombine/fadd-fsub-factor.ll

;
   %t1 = fdiv fast float 0x3810000000000000, %x
   %t2 = fdiv fast float 0x3800000000000000, %x
   %r = fsub fast float %t1, %t2
   ret float %r
 }
 
 define float @lerp_commute0(float %a, float %b, float %c) {
 ; CHECK-LABEL: @lerp_commute0(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast float 1.000000e+00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul fast float [[C]], [[B:%.*]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast float [[MUL]], [[BC]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast float [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %sub = fsub fast float 1.0, %c
   %mul = fmul fast float %sub, %a
   %bc = fmul fast float %c, %b
   %add = fadd fast float %mul, %bc
   ret float %add
 }
 
 define <2 x float> @lerp_commute1(<2 x float> %a, <2 x float> %b, <2 x float> %c) {
 ; CHECK-LABEL: @lerp_commute1(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub <2 x float> <float 1.000000e+00, float 1.000000e+00>, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul <2 x float> [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul <2 x float> [[C]], [[B:%.*]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast <2 x float> [[BC]], [[MUL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast <2 x float> [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast <2 x float> [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast <2 x float> [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret <2 x float> [[ADD]]
 ;
   %sub = fsub <2 x float> <float 1.0, float 1.0>, %c
   %mul = fmul <2 x float> %sub, %a
   %bc = fmul <2 x float> %c, %b
   %add = fadd fast <2 x float> %bc, %mul
   ret <2 x float> %add
 }
 
 define float @lerp_commute2(float %a, float %b, float %c) {
 ; CHECK-LABEL: @lerp_commute2(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub float 1.000000e+00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul float [[B:%.*]], [[C]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd reassoc nsz float [[MUL]], [[BC]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd reassoc nsz float [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %sub = fsub float 1.0, %c
   %mul = fmul float %sub, %a
   %bc = fmul float %b, %c
   %add = fadd reassoc nsz float %mul, %bc
   ret float %add
 }
 
 define float @lerp_commute3(float %a, float %b, float %c) {
 ; CHECK-LABEL: @lerp_commute3(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast float 1.000000e+00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul float [[B:%.*]], [[C]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd reassoc ninf nsz float [[BC]], [[MUL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc ninf nsz float [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc ninf nsz float [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd reassoc ninf nsz float [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %sub = fsub fast float 1.0, %c
   %mul = fmul float %sub, %a
   %bc = fmul float %b, %c
   %add = fadd reassoc nsz ninf float %bc, %mul
   ret float %add
 }
 
 define double @lerp_commute4(double %a, double %b, double %c) {
 ; CHECK-LABEL: @lerp_commute4(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast double 1.000000e+00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast double [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul fast double [[C]], [[B:%.*]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast double [[MUL]], [[BC]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast double [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast double [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret double [[ADD]]
 ;
   %sub = fsub fast double 1.0, %c
   %mul = fmul fast double %a, %sub
   %bc = fmul fast double %c, %b
   %add = fadd fast double %mul, %bc
   ret double %add
 }
 
 define double @lerp_commute5(double %a, double %b, double %c) {
 ; CHECK-LABEL: @lerp_commute5(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast double 1.000000e+00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast double [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul fast double [[C]], [[B:%.*]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast double [[BC]], [[MUL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast double [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast double [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret double [[ADD]]
 ;
   %sub = fsub fast double 1.0, %c
   %mul = fmul fast double %a, %sub
   %bc = fmul fast double %c, %b
   %add = fadd fast double %bc, %mul
   ret double %add
 }
 
 define half @lerp_commute6(half %a, half %b, half %c) {
 ; CHECK-LABEL: @lerp_commute6(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast half 0xH3C00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast half [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul fast half [[B:%.*]], [[C]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[MUL]], [[BC]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast half [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast half [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret half [[ADD]]
 ;
   %sub = fsub fast half 1.0, %c
   %mul = fmul fast half %a, %sub
   %bc = fmul fast half %b, %c
   %add = fadd fast half %mul, %bc
   ret half %add
 }
 
 define half @lerp_commute7(half %a, half %b, half %c) {
 ; CHECK-LABEL: @lerp_commute7(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub fast half 0xH3C00, [[C:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fmul fast half [[SUB]], [[A:%.*]]
-; CHECK-NEXT:    [[BC:%.*]] = fmul fast half [[B:%.*]], [[C]]
-; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[BC]], [[MUL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast half [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast half [[TMP1]], [[C:%.*]]
+; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[TMP2]], [[A]]
 ; CHECK-NEXT:    ret half [[ADD]]
 ;
   %sub = fsub fast half 1.0, %c
   %mul = fmul fast half %a, %sub
   %bc = fmul fast half %b, %c
   %add = fadd fast half %bc, %mul
   ret half %add
 }