[SCEV] Swap guards estimation sequence. NFC

[dfukalov]

Summary

Loop unroll spends a lot of time in SCEVs processing in case when a function
contains hundreds of simple 'for' loops with a quite complex arrays indexes like

for (int i = 0; i < 8; ++i) {
  for (int j = 0; j < 32; ++j) {
    C[j*8+i] = B[j*32+i+128] + A[i*64+128];
  }
}
for (int i = 0; i < 8; ++i) {
  for (int j = 0; j < 8; ++j) {
    for (int k = 0; k < 32; ++k) {
      D[k*64+i*8+j] = D[k*64+i*8+j] + E[i+16] * C[k*8+j+256];
    }
  }
}

The patch improves loop unroll speed since isLoopBackedgeGuardedByCond takes
much less time than isLoopEntryGuardedByCond in the edge case.

[sanjoy]

lgtm, although it would be nice to independently check if isLoopEntryGuardedByCond can be sped up.

Please also add a comment stating that the order and short circuit behavior is intentional.

llvm/lib/Analysis/ScalarEvolution.cpp

#endif
   assert (SplitRHS.second != getCouldNotCompute() && "Unexpected CNC");
   // It is possible that init SCEV contains an invariant load but it does
   // not dominate MDL and is not available at MDL loop entry, so we should
   // check it here.
   if (!isAvailableAtLoopEntry(SplitLHS.first, MDL) ||
       !isAvailableAtLoopEntry(SplitRHS.first, MDL))
     return false;
 
-  return isLoopEntryGuardedByCond(MDL, Pred, SplitLHS.first, SplitRHS.first) &&
-         isLoopBackedgeGuardedByCond(MDL, Pred, SplitLHS.second,
-                                     SplitRHS.second);
+  return isLoopBackedgeGuardedByCond(MDL, Pred, SplitLHS.second,
+                                     SplitRHS.second) &&
+         isLoopEntryGuardedByCond(MDL, Pred, SplitLHS.first, SplitRHS.first);
 }
 
 bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
                                        const SCEV *LHS, const SCEV *RHS) {
   // Canonicalize the inputs first.
   (void)SimplifyICmpOperands(Pred, LHS, RHS);
 
   if (isKnownViaInduction(Pred, LHS, RHS))