[IRCE][NFC] Check that Index is AddRec in the parseRangeCheckICmp

[aleksandr.popov]

Summary

Next step of the preparatory refactoring for the upcoming support of
new range check form to parse.

Previous one: https://reviews.llvm.org/D154156

With this change we avoid meaningless parsing after realizing that Index
is not AddRec

[aleksandr.popov]

rebased

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

 class InductiveRangeCheck {
 
   const SCEV *Begin = nullptr;
   const SCEV *Step = nullptr;
   const SCEV *End = nullptr;
   Use *CheckUse = nullptr;
 
   static bool parseRangeCheckICmp(Loop *L, ICmpInst *ICI, ScalarEvolution &SE,
-                                  const SCEV *&Index, const SCEV *&End);
+                                  const SCEVAddRecExpr *&Index,
+                                  const SCEV *&End);
 
   static void
   extractRangeChecksFromCond(Loop *L, ScalarEvolution &SE, Use &ConditionUse,
                              SmallVectorImpl<InductiveRangeCheck> &Checks,
                              SmallPtrSetImpl<Value *> &Visited);
 
 public:
   const SCEV *getBegin() const { return Begin; }

 } // end anonymous namespace
 
 /// Parse a single ICmp instruction, `ICI`, into a range check.  If `ICI` cannot
 /// be interpreted as a range check, return false.  Otherwise set `Index` to the
 /// SCEV being range checked, and set `End` to the upper or lower limit `Index`
 /// is being range checked.
 bool InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
                                               ScalarEvolution &SE,
-                                              const SCEV *&Index,
+                                              const SCEVAddRecExpr *&Index,
                                               const SCEV *&End) {
   auto IsLoopInvariant = [&SE, L](Value *V) {
     return SE.isLoopInvariant(SE.getSCEV(V), L);
   };
 
   auto SIntMaxSCEV = [&](Type *T) {
     unsigned BitWidth = cast<IntegerType>(T)->getBitWidth();
     return SE.getConstant(APInt::getSignedMaxValue(BitWidth));
   };
 
   ICmpInst::Predicate Pred = ICI->getPredicate();
   Value *LHS = ICI->getOperand(0);
   Value *RHS = ICI->getOperand(1);
 
   // Canonicalize to the `Index Pred Invariant` comparison
   if (IsLoopInvariant(LHS)) {
     std::swap(LHS, RHS);
     Pred = CmpInst::getSwappedPredicate(Pred);
   } else if (!IsLoopInvariant(RHS))
     // Both LHS and RHS are loop variant
     return false;
 
+  const auto *AddRec = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(LHS));
+  if (!AddRec)
+    return false;
+
   // We strengthen "0 <= I" to "0 <= I < INT_SMAX" and "I < L" to "0 <= I < L".
   // We can potentially do much better here.
   // If we want to adjust upper bound for the unsigned range check as we do it
   // for signed one, we will need to pick Unsigned max
   switch (Pred) {
   default:
     return false;
 
   case ICmpInst::ICMP_SGE:
     if (match(RHS, m_ConstantInt<0>())) {
-      Index = SE.getSCEV(LHS);
+      Index = AddRec;
       End = SIntMaxSCEV(Index->getType());
       return true;
     }
     return false;
 
   case ICmpInst::ICMP_SGT:
     if (match(RHS, m_ConstantInt<-1>())) {
-      Index = SE.getSCEV(LHS);
+      Index = AddRec;
       End = SIntMaxSCEV(Index->getType());
       return true;
     }
     return false;
 
   case ICmpInst::ICMP_SLT:
   case ICmpInst::ICMP_ULT:
-    Index = SE.getSCEV(LHS);
+    Index = AddRec;
     End = SE.getSCEV(RHS);
     return true;
 
   case ICmpInst::ICMP_SLE:
   case ICmpInst::ICMP_ULE:
     const SCEV *One = SE.getOne(RHS->getType());
     const SCEV *RHSS = SE.getSCEV(RHS);
     bool Signed = Pred == ICmpInst::ICMP_SLE;
     if (SE.willNotOverflow(Instruction::BinaryOps::Add, Signed, RHSS, One)) {
-      Index = SE.getSCEV(LHS);
+      Index = AddRec;
       End = SE.getAddExpr(RHSS, One);
       return true;
     }
     return false;
   }
 
   llvm_unreachable("default clause returns!");
 }
extractRangeChecksFromCond(L, SE, cast<User>(Condition)->getOperandUse(1),
                                Checks, Visited);
     return;
   }
 
   ICmpInst *ICI = dyn_cast<ICmpInst>(Condition);
   if (!ICI)
     return;
 
-  const SCEV *End = nullptr, *Index = nullptr;
-  if (!parseRangeCheckICmp(L, ICI, SE, Index, End))
+  const SCEV *End = nullptr;
+  const SCEVAddRecExpr *IndexAddRec = nullptr;
+  if (!parseRangeCheckICmp(L, ICI, SE, IndexAddRec, End))
     return;
 
-  assert(Index && "Index was not computed");
+  assert(IndexAddRec && "IndexAddRec was not computed");
   assert(End && "End was not computed");
 
-  const auto *IndexAddRec = dyn_cast<SCEVAddRecExpr>(Index);
-  bool IsAffineIndex =
-      IndexAddRec && (IndexAddRec->getLoop() == L) && IndexAddRec->isAffine();
-
-  if (!IsAffineIndex)
+  if ((IndexAddRec->getLoop() != L) || !IndexAddRec->isAffine())
     return;
 
   InductiveRangeCheck IRC;
   IRC.End = End;
   IRC.Begin = IndexAddRec->getStart();
   IRC.Step = IndexAddRec->getStepRecurrence(SE);
   IRC.CheckUse = &ConditionUse;
   Checks.push_back(IRC);