[NFC] [LoopDeletion] Move ICmpInst handling to getValueOnFirstIteration()

[dmakogon]

Summary

As noticed in https://reviews.llvm.org/D105688, it would be great to move handling of ICmpInst which was in canProveExitOnFirstIteration() to getValueOnFirstIteration()

[reames]

LGTM

Though, I don't believe this is NFC. It would be stronger in the case such as:
%a = icmp ...
%b = icmp ...
%c = or i1 %a, %b
%d = icmp eq i1 %c, 1
br i1 %d....

This is non-canonical IR so this should be a rare pattern in practice, but I don't think this is actually NFC.

llvm/lib/Transforms/Scalar/LoopDeletion.cpp

329

As a follow up, it looks like this test is now redundant for the new code structure. Only part I'm unsure of is the integer test, but I also don't understand why that's there at all.

[mkazantsev]

llvm/lib/Transforms/Scalar/LoopDeletion.cpp

329

You're right, vector type should not pass the matcher. We'll remove it in a follow-up.

llvm/lib/Transforms/Scalar/LoopDeletion.cpp

if (Existing != FirstIterValue.end())
     return Existing->second;
   Value *FirstIterV = nullptr;
   if (auto *BO = dyn_cast<BinaryOperator>(V)) {
     Value *LHS =
         getValueOnFirstIteration(BO->getOperand(0), FirstIterValue, SQ);
     Value *RHS =
         getValueOnFirstIteration(BO->getOperand(1), FirstIterValue, SQ);
     FirstIterV = SimplifyBinOp(BO->getOpcode(), LHS, RHS, SQ);
+  } else if (auto *Cmp = dyn_cast<ICmpInst>(V)) {
+    Value *LHS =
+        getValueOnFirstIteration(Cmp->getOperand(0), FirstIterValue, SQ);
+    Value *RHS =
+        getValueOnFirstIteration(Cmp->getOperand(1), FirstIterValue, SQ);
+    FirstIterV = SimplifyICmpInst(Cmp->getPredicate(), LHS, RHS, SQ);
   }
   if (!FirstIterV)
     FirstIterV = V;
   FirstIterValue[V] = FirstIterV;
   return FirstIterV;
 }
 
 // Try to prove that one of conditions that dominates the latch must exit on 1st
for (auto &PN : BB->phis()) {
       if (Incoming && DT.dominates(Incoming, BB->getTerminator())) {
         Value *FirstIterV =
             getValueOnFirstIteration(Incoming, FirstIterValue, SQ);
         FirstIterValue[&PN] = FirstIterV;
       }
     }
 
     using namespace PatternMatch;
-    ICmpInst::Predicate Pred;
-    Value *LHS, *RHS;
+    Value *Cond;
     BasicBlock *IfTrue, *IfFalse;
     auto *Term = BB->getTerminator();
-    if (match(Term, m_Br(m_ICmp(Pred, m_Value(LHS), m_Value(RHS)),
+    if (match(Term, m_Br(m_Value(Cond),
                          m_BasicBlock(IfTrue), m_BasicBlock(IfFalse)))) {
-      if (!LHS->getType()->isIntegerTy()) {
+      auto *ICmp = dyn_cast<ICmpInst>(Cond);
+      if (!ICmp || !ICmp->getType()->isIntegerTy()) {
         MarkAllSuccessorsLive(BB);
         continue;
       }
 
       // Can we prove constant true or false for this condition?
-      LHS = getValueOnFirstIteration(LHS, FirstIterValue, SQ);
-      RHS = getValueOnFirstIteration(RHS, FirstIterValue, SQ);
-      auto *KnownCondition = SimplifyICmpInst(Pred, LHS, RHS, SQ);
-      if (!KnownCondition) {
+      auto *KnownCondition = getValueOnFirstIteration(ICmp, FirstIterValue, SQ);
+      if (KnownCondition == ICmp) {
         // Failed to simplify.
         MarkAllSuccessorsLive(BB);
         continue;
       }
       if (isa<UndefValue>(KnownCondition)) {
         // TODO: According to langref, branching by undef is undefined behavior.
         // It means that, theoretically, we should be able to just continue
         // without marking any successors as live. However, we are not certain