!fixup strip unneeded changes

Author: fhahn

llvm/lib/Analysis/ScalarEvolution.cpp

@@ -2300,16 +2300,9 @@ CollectAddOperandsWithScales(SmallDenseMap<const SCEV *, APInt, 16> &M,
   return Interesting;
 }
 
-namespace {
-enum class OverflowCheckTy { WillOverflow, WillNotOverflow };
-}
-
-// Return true if (LHS BinOp RHS) is guaranteed to overflow (if \p Check is
-// WillOverflow) or to not overflow (if \p Check is WillNotOverflow).
-static bool checkOverflow(OverflowCheckTy Check, ScalarEvolution *SE,
-                          Instruction::BinaryOps BinOp, bool Signed,
-                          const SCEV *LHS, const SCEV *RHS,
-                          const Instruction *CtxI) {
+bool ScalarEvolution::willNotOverflow(Instruction::BinaryOps BinOp, bool Signed,
+                                      const SCEV *LHS, const SCEV *RHS,
+                                      const Instruction *CtxI) {
   const SCEV *(ScalarEvolution::*Operation)(const SCEV *, const SCEV *,
                                             SCEV::NoWrapFlags, unsigned);
   switch (BinOp) {
@@ -2335,12 +2328,12 @@ static bool checkOverflow(OverflowCheckTy Check, ScalarEvolution *SE,
   auto *WideTy =
       IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2);
 
-  const SCEV *A = (SE->*Extension)(
-      (SE->*Operation)(LHS, RHS, SCEV::FlagAnyWrap, 0), WideTy, 0);
-  const SCEV *LHSB = (SE->*Extension)(LHS, WideTy, 0);
-  const SCEV *RHSB = (SE->*Extension)(RHS, WideTy, 0);
-  const SCEV *B = (SE->*Operation)(LHSB, RHSB, SCEV::FlagAnyWrap, 0);
-  if (Check == OverflowCheckTy::WillNotOverflow && A == B)
+  const SCEV *A = (this->*Extension)(
+      (this->*Operation)(LHS, RHS, SCEV::FlagAnyWrap, 0), WideTy, 0);
+  const SCEV *LHSB = (this->*Extension)(LHS, WideTy, 0);
+  const SCEV *RHSB = (this->*Extension)(RHS, WideTy, 0);
+  const SCEV *B = (this->*Operation)(LHSB, RHSB, SCEV::FlagAnyWrap, 0);
+  if (A == B)
     return true;
   // Can we use context to prove the fact we need?
   if (!CtxI)
@@ -2368,31 +2361,21 @@ static bool checkOverflow(OverflowCheckTy Check, ScalarEvolution *SE,
   }
 
   ICmpInst::Predicate Pred = Signed ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
-  if (Check == OverflowCheckTy::WillOverflow)
-    Pred = CmpInst::getInversePredicate(Pred);
-
   if (OverflowDown) {
     // To avoid overflow down, we need to make sure that MIN + Magnitude <= LHS.
     APInt Min = Signed ? APInt::getSignedMinValue(NumBits)
                        : APInt::getMinValue(NumBits);
     APInt Limit = Min + Magnitude;
-    return SE->isKnownPredicateAt(Pred, SE->getConstant(Limit), LHS, CtxI);
+    return isKnownPredicateAt(Pred, getConstant(Limit), LHS, CtxI);
   } else {
     // To avoid overflow up, we need to make sure that LHS <= MAX - Magnitude.
     APInt Max = Signed ? APInt::getSignedMaxValue(NumBits)
                        : APInt::getMaxValue(NumBits);
     APInt Limit = Max - Magnitude;
-    return SE->isKnownPredicateAt(Pred, LHS, SE->getConstant(Limit), CtxI);
+    return isKnownPredicateAt(Pred, LHS, getConstant(Limit), CtxI);
   }
 }
 
-bool ScalarEvolution::willNotOverflow(Instruction::BinaryOps BinOp, bool Signed,
-                                      const SCEV *LHS, const SCEV *RHS,
-                                      const Instruction *CtxI) {
-  return checkOverflow(OverflowCheckTy::WillNotOverflow, this, BinOp, Signed,
-                       LHS, RHS, CtxI);
-}
-
 std::optional<SCEV::NoWrapFlags>
 ScalarEvolution::getStrengthenedNoWrapFlagsFromBinOp(
     const OverflowingBinaryOperator *OBO) {
@@ -14987,11 +14970,6 @@ const SCEVAddRecExpr *ScalarEvolution::convertSCEVToAddRecWithPredicates(
       continue;
 
     ExitCount = getTruncateOrSignExtend(ExitCount, Step->getType());
-    if (checkOverflow(OverflowCheckTy::WillOverflow, this, Instruction::Add,
-                      /*CheckSigned=*/true, AddRecToCheck->getStart(),
-                      ExitCount, nullptr)) {
-      return nullptr;
-    }
     const SCEV *Add = getAddExpr(AddRecToCheck->getStart(), ExitCount);
     if (isKnownPredicate(CmpInst::ICMP_SLT, Add, AddRecToCheck->getStart())) {
       return nullptr;