[LoopIdiom] Use utility from SE instead of local rewriter

[eopXD]

Summary

ScalarEvolution::applyLoopGuards shall do the work.

[reames]

LGTM

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

public:
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     AU.addPreserved<MemorySSAWrapperPass>();
     getLoopAnalysisUsage(AU);
   }
 };
 
-// The Folder will fold expressions that are guarded by the loop entry.
-class SCEVSignToZeroExtentionRewriter
-    : public SCEVRewriteVisitor<SCEVSignToZeroExtentionRewriter> {
-public:
-  ScalarEvolution &SE;
-  const Loop *CurLoop;
-  SCEVSignToZeroExtentionRewriter(ScalarEvolution &SE, const Loop *CurLoop)
-      : SCEVRewriteVisitor(SE), SE(SE), CurLoop(CurLoop) {}
-
-  const SCEV *visitSignExtendExpr(const SCEVSignExtendExpr *Expr) {
-    // If expression is guarded by CurLoop to be greater or equal to zero
-    // then convert sext to zext. Otherwise return the original expression.
-    if (SE.isLoopEntryGuardedByCond(CurLoop, ICmpInst::ICMP_SGE, Expr,
-                                    SE.getZero(Expr->getType())))
-      return SE.getZeroExtendExpr(visit(Expr->getOperand()), Expr->getType());
-    return Expr;
-  }
-};
-
 } // end anonymous namespace
 
 char LoopIdiomRecognizeLegacyPass::ID = 0;
 
 PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L, LoopAnalysisManager &AM,
                                               LoopStandardAnalysisResults &AR,
                                               LPMUpdater &) {
   if (DisableLIRP::All)
if (IsConstantSize) {
     const SCEV *PositiveStrideSCEV =
         IsNegStride ? SE->getNegativeSCEV(PointerStrideSCEV)
                     : PointerStrideSCEV;
     LLVM_DEBUG(dbgs() << "  MemsetSizeSCEV: " << *MemsetSizeSCEV << "\n"
                       << "  PositiveStrideSCEV: " << *PositiveStrideSCEV
                       << "\n");
 
     if (PositiveStrideSCEV != MemsetSizeSCEV) {
-      // The folding is to fold an expression that is covered by the loop guard
-      // at loop entry. After the folding, compare again and proceed with
-      // optimization, if equal.
-      SCEVSignToZeroExtentionRewriter Folder(*SE, CurLoop);
-      const SCEV *FoldedPositiveStride = Folder.visit(PositiveStrideSCEV);
-      const SCEV *FoldedMemsetSize = Folder.visit(MemsetSizeSCEV);
+      // If an expression is covered by the loop guard, compare again and
+      // proceed with optimization if equal.
+      const SCEV *FoldedPositiveStride =
+          SE->applyLoopGuards(PositiveStrideSCEV, CurLoop);
+      const SCEV *FoldedMemsetSize =
+          SE->applyLoopGuards(MemsetSizeSCEV, CurLoop);
 
       LLVM_DEBUG(dbgs() << "  Try to fold SCEV based on loop guard\n"
                         << "    FoldedMemsetSize: " << *FoldedMemsetSize << "\n"
                         << "    FoldedPositiveStride: " << *FoldedPositiveStride
                         << "\n");
 
       if (FoldedPositiveStride != FoldedMemsetSize) {
         LLVM_DEBUG(dbgs() << "  SCEV don't match, abort\n");