[IRCE] Refactor parseRangeCheckICmp

[aleksandr.popov]

Summary

Simplify parseRangeCheckICmp:

• If RHS is loop-variant, swap LHS/RHS and swap predicate
• all checks are either IV >(=) const or IV <(=) RHS (maybe not const)

[mkazantsev]

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

311

Now you can change Index and return false, which was not the case in the old implementation.

[mkazantsev]

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

307

{ } not needed

[aleksandr.popov]

Now you can change Index and return false, which was not the case in the old implementation.

Ok, updated the diff to make it more straightforward

[mkazantsev]

LG, thanks

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

bool InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
   auto IsLoopInvariant = [&SE, L](Value *V) {
     return SE.isLoopInvariant(SE.getSCEV(V), L);
   };
 
   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;
+
   switch (Pred) {
   default:
     return false;
 
-  case ICmpInst::ICMP_SLE:
-    std::swap(LHS, RHS);
-    [[fallthrough]];
   case ICmpInst::ICMP_SGE:
     if (match(RHS, m_ConstantInt<0>())) {
       Index = SE.getSCEV(LHS);
       return true; // Lower.
     }
     return false;
 
-  case ICmpInst::ICMP_SLT:
-    std::swap(LHS, RHS);
-    [[fallthrough]];
   case ICmpInst::ICMP_SGT:
     if (match(RHS, m_ConstantInt<-1>())) {
       Index = SE.getSCEV(LHS);
       return true; // Lower.
     }
-
-    if (IsLoopInvariant(LHS)) {
-      Index = SE.getSCEV(RHS);
-      End = SE.getSCEV(LHS);
-      return true; // Upper.
-    }
     return false;
 
+  case ICmpInst::ICMP_SLT:
   case ICmpInst::ICMP_ULT:
-    std::swap(LHS, RHS);
-    [[fallthrough]];
-  case ICmpInst::ICMP_UGT:
-    if (IsLoopInvariant(LHS)) {
-      Index = SE.getSCEV(RHS);
-      End = SE.getSCEV(LHS);
-      return true; // Both lower and upper.
-    }
-    return false;
+    Index = SE.getSCEV(LHS);
+    End = SE.getSCEV(RHS);
+    return true; // Both lower and upper for ULT, upper for SLT
   }
 
   llvm_unreachable("default clause returns!");
 }
 
 void InductiveRangeCheck::extractRangeChecksFromCond(
     Loop *L, ScalarEvolution &SE, Use &ConditionUse,
     SmallVectorImpl<InductiveRangeCheck> &Checks,