Unverified Commit a0cd6265 authored by Allen's avatar Allen Committed by GitHub
Browse files

[InstCombine] Split the FMul with reassoc into a helper function, NFC (#71493) 

The reassoc check is really hard to find because the handle branch it
too large, so spilt it into a helper function.
parent 02540b2f

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

+1 −0
Original line number Diff line number Diff line
@@ -98,6 +98,7 @@ public: 
  Instruction *visitSub(BinaryOperator &I);

  Instruction *visitFSub(BinaryOperator &I);

  Instruction *visitMul(BinaryOperator &I);

  Instruction *foldFMulReassoc(BinaryOperator &I);

  Instruction *visitFMul(BinaryOperator &I);

  Instruction *visitURem(BinaryOperator &I);

  Instruction *visitSRem(BinaryOperator &I);

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

+177 −170
Original line number Diff line number Diff line
@@ -560,54 +560,12 @@ Instruction *InstCombinerImpl::foldFPSignBitOps(BinaryOperator &I) { 
  return nullptr;

}



Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) {

  if (Value *V = simplifyFMulInst(I.getOperand(0), I.getOperand(1),

                                  I.getFastMathFlags(),

                                  SQ.getWithInstruction(&I)))

    return replaceInstUsesWith(I, V);



  if (SimplifyAssociativeOrCommutative(I))

    return &I;



  if (Instruction *X = foldVectorBinop(I))

    return X;



  if (Instruction *Phi = foldBinopWithPhiOperands(I))

    return Phi;



  if (Instruction *FoldedMul = foldBinOpIntoSelectOrPhi(I))

    return FoldedMul;



  if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))

    return replaceInstUsesWith(I, FoldedMul);



  if (Instruction *R = foldFPSignBitOps(I))

    return R;



  // X * -1.0 --> -X

  Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);

  if (match(Op1, m_SpecificFP(-1.0)))

    return UnaryOperator::CreateFNegFMF(Op0, &I);



  // With no-nans: X * 0.0 --> copysign(0.0, X)

  if (I.hasNoNaNs() && match(Op1, m_PosZeroFP())) {

    CallInst *CopySign = Builder.CreateIntrinsic(Intrinsic::copysign,

                                                 {I.getType()}, {Op1, Op0}, &I);

    return replaceInstUsesWith(I, CopySign);

  }



  // -X * C --> X * -C

Instruction *InstCombinerImpl::foldFMulReassoc(BinaryOperator &I) {

  Value *Op0 = I.getOperand(0);

  Value *Op1 = I.getOperand(1);

  Value *X, *Y;

  Constant *C;

  if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))

    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))

      return BinaryOperator::CreateFMulFMF(X, NegC, &I);



  // (select A, B, C) * (select A, D, E) --> select A, (B*D), (C*E)

  if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))

    return replaceInstUsesWith(I, V);



  if (I.hasAllowReassoc()) {

  // Reassociate constant RHS with another constant to form constant

  // expression.

  if (match(Op1, m_Constant(C)) && C->isFiniteNonZeroFP()) {
@@ -639,16 +597,16 @@ Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) { 
    // further folds and (X * C) + C2 is 'fma'.

    if (match(Op0, m_OneUse(m_FAdd(m_Value(X), m_Constant(C1))))) {

      // (X + C1) * C --> (X * C) + (C * C1)

        if (Constant *CC1 = ConstantFoldBinaryOpOperands(

                Instruction::FMul, C, C1, DL)) {

      if (Constant *CC1 =

              ConstantFoldBinaryOpOperands(Instruction::FMul, C, C1, DL)) {

        Value *XC = Builder.CreateFMulFMF(X, C, &I);

        return BinaryOperator::CreateFAddFMF(XC, CC1, &I);

      }

    }

    if (match(Op0, m_OneUse(m_FSub(m_Constant(C1), m_Value(X))))) {

      // (C1 - X) * C --> (C * C1) - (X * C)

        if (Constant *CC1 = ConstantFoldBinaryOpOperands(

                Instruction::FMul, C, C1, DL)) {

      if (Constant *CC1 =

              ConstantFoldBinaryOpOperands(Instruction::FMul, C, C1, DL)) {

        Value *XC = Builder.CreateFMulFMF(X, C, &I);

        return BinaryOperator::CreateFSubFMF(CC1, XC, &I);

      }
@@ -656,8 +614,8 @@ Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) { 
  }



  Value *Z;

    if (match(&I, m_c_FMul(m_OneUse(m_FDiv(m_Value(X), m_Value(Y))),

                           m_Value(Z)))) {

  if (match(&I,

            m_c_FMul(m_OneUse(m_FDiv(m_Value(X), m_Value(Y))), m_Value(Z)))) {

    // Sink division: (X / Y) * Z --> (X * Z) / Y

    Value *NewFMul = Builder.CreateFMulFMF(X, Z, &I);

    return BinaryOperator::CreateFDivFMF(NewFMul, Y, &I);
@@ -690,8 +648,7 @@ Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) { 


  // Like the similar transform in instsimplify, this requires 'nsz' because

  // sqrt(-0.0) = -0.0, and -0.0 * -0.0 does not simplify to -0.0.

    if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 &&

        Op0->hasNUses(2)) {

  if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 && Op0->hasNUses(2)) {

    // Peek through fdiv to find squaring of square root:

    // (X / sqrt(Y)) * (X / sqrt(Y)) --> (X * X) / Y

    if (match(Op0, m_FDiv(m_Value(X), m_Sqrt(m_Value(Y))))) {
@@ -710,8 +667,7 @@ Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) { 
  if (match(&I, m_c_FMul(m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Value(X),

                                                              m_Value(Y))),

                         m_Deferred(X)))) {

      Value *Y1 =

          Builder.CreateFAddFMF(Y, ConstantFP::get(I.getType(), 1.0), &I);

    Value *Y1 = Builder.CreateFAddFMF(Y, ConstantFP::get(I.getType(), 1.0), &I);

    Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, Y1, &I);

    return replaceInstUsesWith(I, Pow);

  }
@@ -766,18 +722,69 @@ Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) { 
  //  latency of the instruction Y is amortized by the expression of X*X,

  //  and therefore Y is in a "less critical" position compared to what it

  //  was before the transformation.

    if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) &&

        Op1 != Y) {

  if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {

    Value *XX = Builder.CreateFMulFMF(Op1, Op1, &I);

    return BinaryOperator::CreateFMulFMF(XX, Y, &I);

  }

    if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) &&

        Op0 != Y) {

  if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {

    Value *XX = Builder.CreateFMulFMF(Op0, Op0, &I);

    return BinaryOperator::CreateFMulFMF(XX, Y, &I);

  }



  return nullptr;

}



Instruction *InstCombinerImpl::visitFMul(BinaryOperator &I) {

  if (Value *V = simplifyFMulInst(I.getOperand(0), I.getOperand(1),

                                  I.getFastMathFlags(),

                                  SQ.getWithInstruction(&I)))

    return replaceInstUsesWith(I, V);



  if (SimplifyAssociativeOrCommutative(I))

    return &I;



  if (Instruction *X = foldVectorBinop(I))

    return X;



  if (Instruction *Phi = foldBinopWithPhiOperands(I))

    return Phi;



  if (Instruction *FoldedMul = foldBinOpIntoSelectOrPhi(I))

    return FoldedMul;



  if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))

    return replaceInstUsesWith(I, FoldedMul);



  if (Instruction *R = foldFPSignBitOps(I))

    return R;



  // X * -1.0 --> -X

  Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);

  if (match(Op1, m_SpecificFP(-1.0)))

    return UnaryOperator::CreateFNegFMF(Op0, &I);



  // With no-nans: X * 0.0 --> copysign(0.0, X)

  if (I.hasNoNaNs() && match(Op1, m_PosZeroFP())) {

    CallInst *CopySign = Builder.CreateIntrinsic(Intrinsic::copysign,

                                                 {I.getType()}, {Op1, Op0}, &I);

    return replaceInstUsesWith(I, CopySign);

  }



  // -X * C --> X * -C

  Value *X, *Y;

  Constant *C;

  if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))

    if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))

      return BinaryOperator::CreateFMulFMF(X, NegC, &I);



  // (select A, B, C) * (select A, D, E) --> select A, (B*D), (C*E)

  if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))

    return replaceInstUsesWith(I, V);



  if (I.hasAllowReassoc())

    if (Instruction *FoldedMul = foldFMulReassoc(I))

      return FoldedMul;



  // log2(X * 0.5) * Y = log2(X) * Y - Y

  if (I.isFast()) {

    IntrinsicInst *Log2 = nullptr;