refactor into foldIntrinsicUsingDistributiveLaws

Author: el-ev

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

@@ -1554,7 +1554,11 @@ static bool leftDistributesOverRight(Instruction::BinaryOps LOp, bool HasNUW,
   switch (ROp) {
   case Intrinsic::umax:
   case Intrinsic::umin:
-    return HasNUW && LOp == Instruction::Add;
+    if (HasNUW && LOp == Instruction::Add)
+      return true;
+    if (HasNUW && LOp == Instruction::Shl)
+      return true;
+    return false;
   case Intrinsic::smax:
   case Intrinsic::smin:
     return HasNSW && LOp == Instruction::Add;
@@ -1592,29 +1596,34 @@ foldIntrinsicUsingDistributiveLaws(IntrinsicInst *II,
   if (!leftDistributesOverRight(InnerOpcode, HasNUW, HasNSW, TopLevelOpcode))
     return nullptr;
 
-  assert(II->isCommutative() && Op0->isCommutative() &&
-         "Only inner and outer commutative op codes are supported.");
-
   Value *A = Op0->getOperand(0);
   Value *B = Op0->getOperand(1);
   Value *C = Op1->getOperand(0);
   Value *D = Op1->getOperand(1);
 
-  // Attempts to swap variables such that A always equals C
-  if (A != C && A != D)
-    std::swap(A, B);
-  if (A == C || A == D) {
-    if (A != C)
-      std::swap(C, D);
+  // Attempts to swap variables such that A equals C or B equals D,
+  // if the inner operation is commutative.
+  if (Op0->isCommutative() && A != C && B != D && A == D)
+    std::swap(C, D);
+
+  if (A != C && B != D)
+    return nullptr;
+
+  BinaryOperator *NewBinop;
+  if (A == C) {
     Value *NewIntrinsic = Builder.CreateBinaryIntrinsic(TopLevelOpcode, B, D);
-    BinaryOperator *NewBinop =
-        cast<BinaryOperator>(Builder.CreateBinOp(InnerOpcode, NewIntrinsic, A));
-    NewBinop->setHasNoSignedWrap(HasNSW);
-    NewBinop->setHasNoUnsignedWrap(HasNUW);
-    return NewBinop;
+    NewBinop =
+        cast<BinaryOperator>(Builder.CreateBinOp(InnerOpcode, A, NewIntrinsic));
+  } else { // B == D
+    Value *NewIntrinsic = Builder.CreateBinaryIntrinsic(TopLevelOpcode, A, C);
+    NewBinop =
+        cast<BinaryOperator>(Builder.CreateBinOp(InnerOpcode, NewIntrinsic, B));
   }
 
-  return nullptr;
+  NewBinop->setHasNoUnsignedWrap(HasNUW);
+  NewBinop->setHasNoSignedWrap(HasNSW);
+
+  return NewBinop;
 }
 
 /// CallInst simplification. This mostly only handles folding of intrinsic
@@ -1888,29 +1897,6 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
         return I;
     }
 
-    Value *CommonShlOperand;
-    BinaryOperator *NewShl = nullptr;
-    // umax(nuw_shl(z, x), nuw_shl(z, y)) -> nuw_shl(z, umax(x, y))
-    // umin(nuw_shl(z, x), nuw_shl(z, y)) -> nuw_shl(z, umin(x, y))
-    if (match(I0, m_OneUse(m_NUWShl(m_Value(CommonShlOperand), m_Value(X)))) &&
-        match(I1,
-              m_OneUse(m_NUWShl(m_Deferred(CommonShlOperand), m_Value(Y))))) {
-      Value *MaxMin = Builder.CreateBinaryIntrinsic(IID, X, Y);
-      NewShl = BinaryOperator::CreateNUWShl(CommonShlOperand, MaxMin);
-    } else if (match(I0, m_OneUse(m_NUWShl(m_Value(X),
-                                           m_Value(CommonShlOperand)))) &&
-               match(I1, m_OneUse(m_NUWShl(m_Value(Y),
-                                           m_Deferred(CommonShlOperand))))) {
-      Value *MaxMin = Builder.CreateBinaryIntrinsic(IID, X, Y);
-      NewShl = BinaryOperator::CreateNUWShl(MaxMin, CommonShlOperand);
-    }
-    if (NewShl) {
-      if (cast<BinaryOperator>(I0)->hasNoSignedWrap() &&
-          cast<BinaryOperator>(I1)->hasNoSignedWrap())
-        NewShl->setHasNoSignedWrap();
-      return NewShl;
-    }
-
     // If both operands of unsigned min/max are sign-extended, it is still ok
     // to narrow the operation.
     [[fallthrough]];