[LoopBoundSplit] Check the condition of the first iteration in pre-loop using isLoopEntryGuardedByCond

[jaykang10]

Summary

The condition of the first iteration in pre-loop can be inferred by isLoopEntryGuardedByCond.

It is a following patch of https://reviews.llvm.org/D109354.

[mkazantsev]

llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp

67

!isa<SCEVAddRecExpr>(AddRecSCEV) is impossible

[jaykang10]

llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp

67

Ah, let me update it with dyn_cast.

[jaykang10]

Following comment of @mkazantsev, updated patch.

[jaykang10]

This patch is merged into https://reviews.llvm.org/D110060.

Let's close this patch.

[jaykang10]

https://reviews.llvm.org/D110060 The patch is split into two patches. As one of them, this patch is merged.

llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp

struct ConditionInfo {
   ICmpInst *ICmp;
   /// Preciate info
   ICmpInst::Predicate Pred;
   /// AddRec llvm value
   Value *AddRecValue;
   /// Bound llvm value
   Value *BoundValue;
   /// AddRec SCEV
-  const SCEV *AddRecSCEV;
+  const SCEVAddRecExpr *AddRecSCEV;
   /// Bound SCEV
   const SCEV *BoundSCEV;
 
   ConditionInfo()
       : BI(nullptr), ICmp(nullptr), Pred(ICmpInst::BAD_ICMP_PREDICATE),
         AddRecValue(nullptr), BoundValue(nullptr), AddRecSCEV(nullptr),
         BoundSCEV(nullptr) {}
 };
 } // namespace
 
 static void analyzeICmp(ScalarEvolution &SE, ICmpInst *ICmp,
                         ConditionInfo &Cond) {
   Cond.ICmp = ICmp;
   if (match(ICmp, m_ICmp(Cond.Pred, m_Value(Cond.AddRecValue),
                          m_Value(Cond.BoundValue)))) {
-    Cond.AddRecSCEV = SE.getSCEV(Cond.AddRecValue);
-    Cond.BoundSCEV = SE.getSCEV(Cond.BoundValue);
+    const SCEV *AddRecSCEV = SE.getSCEV(Cond.AddRecValue);
+    const SCEV *BoundSCEV = SE.getSCEV(Cond.BoundValue);
+    const SCEVAddRecExpr *LHSAddRecSCEV = dyn_cast<SCEVAddRecExpr>(AddRecSCEV);
+    const SCEVAddRecExpr *RHSAddRecSCEV = dyn_cast<SCEVAddRecExpr>(BoundSCEV);
     // Locate AddRec in LHSSCEV and Bound in RHSSCEV.
-    if (isa<SCEVAddRecExpr>(Cond.BoundSCEV) &&
-        !isa<SCEVAddRecExpr>(Cond.AddRecSCEV)) {
+    if (!LHSAddRecSCEV && RHSAddRecSCEV) {
       std::swap(Cond.AddRecValue, Cond.BoundValue);
-      std::swap(Cond.AddRecSCEV, Cond.BoundSCEV);
+      std::swap(AddRecSCEV, BoundSCEV);
       Cond.Pred = ICmpInst::getSwappedPredicate(Cond.Pred);
     }
+
+    Cond.AddRecSCEV = dyn_cast<SCEVAddRecExpr>(AddRecSCEV);
+    Cond.BoundSCEV = BoundSCEV;
   }
 }
 
 static bool calculateUpperBound(const Loop &L, ScalarEvolution &SE,
                                 ConditionInfo &Cond, bool IsExitCond) {
   if (IsExitCond) {
     const SCEV *ExitCount = SE.getExitCount(&L, Cond.ICmp->getParent());
     if (isa<SCEVCouldNotCompute>(ExitCount))
static bool hasProcessableCondition(const Loop &L, ScalarEvolution &SE,
                                     ICmpInst *ICmp, ConditionInfo &Cond,
                                     bool IsExitCond) {
   analyzeICmp(SE, ICmp, Cond);
 
   // The BoundSCEV should be evaluated at loop entry.
   if (!SE.isAvailableAtLoopEntry(Cond.BoundSCEV, &L))
     return false;
 
-  const SCEVAddRecExpr *AddRecSCEV = dyn_cast<SCEVAddRecExpr>(Cond.AddRecSCEV);
   // Allowed AddRec as induction variable.
-  if (!AddRecSCEV)
+  if (!Cond.AddRecSCEV)
     return false;
 
-  if (!AddRecSCEV->isAffine())
+  if (!Cond.AddRecSCEV->isAffine())
     return false;
 
-  const SCEV *StepRecSCEV = AddRecSCEV->getStepRecurrence(SE);
+  const SCEV *StepRecSCEV = Cond.AddRecSCEV->getStepRecurrence(SE);
   // Allowed constant step.
   if (!isa<SCEVConstant>(StepRecSCEV))
     return false;
 
   ConstantInt *StepCI = cast<SCEVConstant>(StepRecSCEV)->getValue();
   // Allowed positive step for now.
   // TODO: Support negative step.
   if (StepCI->isNegative() || StepCI->isZero())
for (auto *BB : L.blocks()) {
 
     if (ExitingCond.BoundSCEV->getType() !=
         SplitCandidateCond.BoundSCEV->getType())
       continue;
 
     // After transformation, we assume the split condition of the pre-loop is
     // always true. In order to guarantee it, we need to check the start value
     // of the split cond AddRec satisfies the split condition.
-    const SCEV *SplitAddRecStartSCEV =
-        cast<SCEVAddRecExpr>(SplitCandidateCond.AddRecSCEV)->getStart();
-    if (!SE.isKnownPredicate(SplitCandidateCond.Pred, SplitAddRecStartSCEV,
+    if (!SE.isLoopEntryGuardedByCond(&L, SplitCandidateCond.Pred,
+                                     SplitCandidateCond.AddRecSCEV->getStart(),
                                      SplitCandidateCond.BoundSCEV))
       continue;
 
     SplitCandidateCond.BI = BI;
     return BI;
   }
 
   return nullptr;
 }