[SCEV] Add trivial case handling for umin utilities

[mkazantsev]

LGTM, please add NFC annotation.

lib/Analysis/ScalarEvolution.cpp

 
 const SCEV *ScalarEvolution::getUMinExpr(const SCEV *LHS,
                                          const SCEV *RHS) {
   SmallVector<const SCEV *, 2> Ops = { LHS, RHS };
   return getUMinExpr(Ops);
 }
 
 const SCEV *ScalarEvolution::getUMinExpr(SmallVectorImpl<const SCEV *> &Ops) {
+  assert(!Ops.empty() && "At least one operand must be!");
+  // Trivial case.
+  if (Ops.size() == 1)
+    return Ops[0];
+
   // ~umax(~x, ~y, ~z) == umin(x, y, z).
   SmallVector<const SCEV *, 2> NotOps;
   for (auto *S : Ops)
     NotOps.push_back(getNotSCEV(S));
   return getNotSCEV(getUMaxExpr(NotOps));
 }
 
 const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {

 const SCEV *ScalarEvolution::getUMinFromMismatchedTypes(const SCEV *LHS,
                                                         const SCEV *RHS) {
   SmallVector<const SCEV *, 2> Ops = { LHS, RHS };
   return getUMinFromMismatchedTypes(Ops);
 }
 
 const SCEV *ScalarEvolution::getUMinFromMismatchedTypes(
     SmallVectorImpl<const SCEV *> &Ops) {
+  assert(!Ops.empty() && "At least one operand must be!");
+  // Trivial case.
+  if (Ops.size() == 1)
+    return Ops[0];
+
   // Find the max type first.
   Type *MaxType = nullptr;
   for (auto *S : Ops)
     if (MaxType)
       MaxType = getWiderType(MaxType, S->getType());
     else
       MaxType = S->getType();
 
for (auto &ENT : ExitNotTaken) {
 
     if (Preds && !ENT.hasAlwaysTruePredicate())
       Preds->add(ENT.Predicate.get());
 
     assert((Preds || ENT.hasAlwaysTruePredicate()) &&
            "Predicate should be always true!");
   }
 
-  assert(!Ops.empty() && "Loop without exits");
-  return Ops.size() == 1 ? Ops[0] : SE->getUMinFromMismatchedTypes(Ops);
+  return SE->getUMinFromMismatchedTypes(Ops);
 }
 
 /// Get the exact not taken count for this loop exit.
 const SCEV *
 ScalarEvolution::BackedgeTakenInfo::getExact(BasicBlock *ExitingBlock,
                                              ScalarEvolution *SE) const {
   for (auto &ENT : ExitNotTaken)
     if (ENT.ExitingBlock == ExitingBlock && ENT.hasAlwaysTruePredicate())