[Polly][NewPM] Port ScopDetection to the new PassManager

Summary: This is a proof of concept of how to port polly-passes to the new PassManager architecture.  This approach works ootb for Function-Passes, but might not be directly applicable to Scop/Region-Passes. While we could just run the Analyses/Transforms over functions instead, we'd surrender the nice pipelining behaviour we have now.

Reviewers: Meinersbur, grosser

Reviewed By: grosser

Subscribers: pollydev, sanjoy, nemanjai, llvm-commits

Tags: #polly

Differential Revision: https://reviews.llvm.org/D31459

llvm-svn: 302902

1 files changed, 162 insertions, 135 deletions

diff --git a/polly/lib/Analysis/ScopDetection.cpp b/polly/lib/Analysis/ScopDetection.cpp
index 0e8e0efbeaf..b8df3940a24 100644
--- a/polly/lib/Analysis/ScopDetection.cpp
+++ b/polly/lib/Analysis/ScopDetection.cpp
@@ -225,6 +225,9 @@ STATISTIC(MaxNumLoopsInScop, "Maximal number of loops in scops");
 STATISTIC(MaxNumLoopsInProfScop,
           "Maximal number of loops in scops (profitable scops only)");
 
+static void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
+                                     bool OnlyProfitable);
+
 class DiagnosticScopFound : public DiagnosticInfo {
 private:
   static int PluginDiagnosticKind;
@@ -266,10 +269,55 @@ void DiagnosticScopFound::print(DiagnosticPrinter &DP) const {
 //===----------------------------------------------------------------------===//
 // ScopDetection.
 
-ScopDetection::ScopDetection() : FunctionPass(ID) {
-  // Disable runtime alias checks if we ignore aliasing all together.
-  if (IgnoreAliasing)
-    PollyUseRuntimeAliasChecks = false;
+ScopDetection::ScopDetection(Function &F, const DominatorTree &DT,
+                             ScalarEvolution &SE, LoopInfo &LI, RegionInfo &RI,
+                             AliasAnalysis &AA)
+    : DT(DT), SE(SE), LI(LI), RI(RI), AA(AA) {
+
+  if (!PollyProcessUnprofitable && LI.empty())
+    return;
+
+  Region *TopRegion = RI.getTopLevelRegion();
+
+  if (OnlyFunction != "" && !F.getName().count(OnlyFunction))
+    return;
+
+  if (!isValidFunction(F))
+    return;
+
+  findScops(*TopRegion);
+
+  NumScopRegions += ValidRegions.size();
+
+  // Prune non-profitable regions.
+  for (auto &DIt : DetectionContextMap) {
+    auto &DC = DIt.getSecond();
+    if (DC.Log.hasErrors())
+      continue;
+    if (!ValidRegions.count(&DC.CurRegion))
+      continue;
+    LoopStats Stats = countBeneficialLoops(&DC.CurRegion, SE, LI, 0);
+    updateLoopCountStatistic(Stats, false /* OnlyProfitable */);
+    if (isProfitableRegion(DC)) {
+      updateLoopCountStatistic(Stats, true /* OnlyProfitable */);
+      continue;
+    }
+
+    ValidRegions.remove(&DC.CurRegion);
+  }
+
+  NumProfScopRegions += ValidRegions.size();
+  NumLoopsOverall += countBeneficialLoops(TopRegion, SE, LI, 0).NumLoops;
+
+  // Only makes sense when we tracked errors.
+  if (PollyTrackFailures)
+    emitMissedRemarks(F);
+
+  if (ReportLevel)
+    printLocations(F);
+
+  assert(ValidRegions.size() <= DetectionContextMap.size() &&
+         "Cached more results than valid regions");
 }
 
 template <class RR, typename... Args>
@@ -300,7 +348,7 @@ bool ScopDetection::isMaxRegionInScop(const Region &R, bool Verify) const {
     DetectionContextMap.erase(getBBPairForRegion(&R));
     const auto &It = DetectionContextMap.insert(std::make_pair(
         getBBPairForRegion(&R),
-        DetectionContext(const_cast<Region &>(R), *AA, false /*verifying*/)));
+        DetectionContext(const_cast<Region &>(R), AA, false /*verifying*/)));
     DetectionContext &Context = It.first->second;
     return isValidRegion(Context);
   }
@@ -333,7 +381,7 @@ bool ScopDetection::addOverApproximatedRegion(Region *AR,
   // are accesses that depend on the iteration count.
 
   for (BasicBlock *BB : AR->blocks()) {
-    Loop *L = LI->getLoopFor(BB);
+    Loop *L = LI.getLoopFor(BB);
     if (AR->contains(L))
       Context.BoxedLoopsSet.insert(L);
   }
@@ -358,7 +406,7 @@ bool ScopDetection::onlyValidRequiredInvariantLoads(
     if (Context.RequiredILS.count(Load))
       continue;
 
-    if (!isHoistableLoad(Load, CurRegion, *LI, *SE, *DT))
+    if (!isHoistableLoad(Load, CurRegion, LI, SE, DT))
       return false;
 
     for (auto NonAffineRegion : Context.NonAffineSubRegionSet) {
@@ -381,9 +429,9 @@ bool ScopDetection::onlyValidRequiredInvariantLoads(
 bool ScopDetection::involvesMultiplePtrs(const SCEV *S0, const SCEV *S1,
                                          Loop *Scope) const {
   SetVector<Value *> Values;
-  findValues(S0, *SE, Values);
+  findValues(S0, SE, Values);
   if (S1)
-    findValues(S1, *SE, Values);
+    findValues(S1, SE, Values);
 
   SmallPtrSet<Value *, 8> PtrVals;
   for (auto *V : Values) {
@@ -393,18 +441,18 @@ bool ScopDetection::involvesMultiplePtrs(const SCEV *S0, const SCEV *S1,
     if (!V->getType()->isPointerTy())
       continue;
 
-    auto *PtrSCEV = SE->getSCEVAtScope(V, Scope);
+    auto *PtrSCEV = SE.getSCEVAtScope(V, Scope);
     if (isa<SCEVConstant>(PtrSCEV))
       continue;
 
-    auto *BasePtr = dyn_cast<SCEVUnknown>(SE->getPointerBase(PtrSCEV));
+    auto *BasePtr = dyn_cast<SCEVUnknown>(SE.getPointerBase(PtrSCEV));
     if (!BasePtr)
       return true;
 
     auto *BasePtrVal = BasePtr->getValue();
     if (PtrVals.insert(BasePtrVal).second) {
       for (auto *PtrVal : PtrVals)
-        if (PtrVal != BasePtrVal && !AA->isNoAlias(PtrVal, BasePtrVal))
+        if (PtrVal != BasePtrVal && !AA.isNoAlias(PtrVal, BasePtrVal))
           return true;
     }
   }
@@ -416,7 +464,7 @@ bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
                              DetectionContext &Context) const {
 
   InvariantLoadsSetTy AccessILS;
-  if (!isAffineExpr(&Context.CurRegion, Scope, S, *SE, &AccessILS))
+  if (!isAffineExpr(&Context.CurRegion, Scope, S, SE, &AccessILS))
     return false;
 
   if (!onlyValidRequiredInvariantLoads(AccessILS, Context))
@@ -428,8 +476,8 @@ bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
 bool ScopDetection::isValidSwitch(BasicBlock &BB, SwitchInst *SI,
                                   Value *Condition, bool IsLoopBranch,
                                   DetectionContext &Context) const {
-  Loop *L = LI->getLoopFor(&BB);
-  const SCEV *ConditionSCEV = SE->getSCEVAtScope(Condition, L);
+  Loop *L = LI.getLoopFor(&BB);
+  const SCEV *ConditionSCEV = SE.getSCEVAtScope(Condition, L);
 
   if (IsLoopBranch && L->isLoopLatch(&BB))
     return false;
@@ -442,7 +490,7 @@ bool ScopDetection::isValidSwitch(BasicBlock &BB, SwitchInst *SI,
     return true;
 
   if (AllowNonAffineSubRegions &&
-      addOverApproximatedRegion(RI->getRegionFor(&BB), Context))
+      addOverApproximatedRegion(RI.getRegionFor(&BB), Context))
     return true;
 
   return invalid<ReportNonAffBranch>(Context, /*Assert=*/true, &BB,
@@ -470,7 +518,7 @@ bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
   // Non constant conditions of branches need to be ICmpInst.
   if (!isa<ICmpInst>(Condition)) {
     if (!IsLoopBranch && AllowNonAffineSubRegions &&
-        addOverApproximatedRegion(RI->getRegionFor(&BB), Context))
+        addOverApproximatedRegion(RI.getRegionFor(&BB), Context))
       return true;
     return invalid<ReportInvalidCond>(Context, /*Assert=*/true, BI, &BB);
   }
@@ -482,14 +530,14 @@ bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
       isa<UndefValue>(ICmp->getOperand(1)))
     return invalid<ReportUndefOperand>(Context, /*Assert=*/true, &BB, ICmp);
 
-  Loop *L = LI->getLoopFor(&BB);
-  const SCEV *LHS = SE->getSCEVAtScope(ICmp->getOperand(0), L);
-  const SCEV *RHS = SE->getSCEVAtScope(ICmp->getOperand(1), L);
+  Loop *L = LI.getLoopFor(&BB);
+  const SCEV *LHS = SE.getSCEVAtScope(ICmp->getOperand(0), L);
+  const SCEV *RHS = SE.getSCEVAtScope(ICmp->getOperand(1), L);
 
   // If unsigned operations are not allowed try to approximate the region.
   if (ICmp->isUnsigned() && !PollyAllowUnsignedOperations)
     return !IsLoopBranch && AllowNonAffineSubRegions &&
-           addOverApproximatedRegion(RI->getRegionFor(&BB), Context);
+           addOverApproximatedRegion(RI.getRegionFor(&BB), Context);
 
   // Check for invalid usage of different pointers in one expression.
   if (ICmp->isEquality() && involvesMultiplePtrs(LHS, nullptr, L) &&
@@ -504,7 +552,7 @@ bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
     return true;
 
   if (!IsLoopBranch && AllowNonAffineSubRegions &&
-      addOverApproximatedRegion(RI->getRegionFor(&BB), Context))
+      addOverApproximatedRegion(RI.getRegionFor(&BB), Context))
     return true;
 
   if (IsLoopBranch)
@@ -565,7 +613,7 @@ bool ScopDetection::isValidCallInst(CallInst &CI,
     return false;
 
   if (AllowModrefCall) {
-    switch (AA->getModRefBehavior(CalledFunction)) {
+    switch (AA.getModRefBehavior(CalledFunction)) {
     case FMRB_UnknownModRefBehavior:
       return false;
     case FMRB_DoesNotAccessMemory:
@@ -583,11 +631,11 @@ bool ScopDetection::isValidCallInst(CallInst &CI,
 
         // Bail if a pointer argument has a base address not known to
         // ScalarEvolution. Note that a zero pointer is acceptable.
-        auto *ArgSCEV = SE->getSCEVAtScope(Arg, LI->getLoopFor(CI.getParent()));
+        auto *ArgSCEV = SE.getSCEVAtScope(Arg, LI.getLoopFor(CI.getParent()));
         if (ArgSCEV->isZero())
           continue;
 
-        auto *BP = dyn_cast<SCEVUnknown>(SE->getPointerBase(ArgSCEV));
+        auto *BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(ArgSCEV));
         if (!BP)
           return false;
 
@@ -614,7 +662,7 @@ bool ScopDetection::isValidIntrinsicInst(IntrinsicInst &II,
     return true;
 
   // The closest loop surrounding the call instruction.
-  Loop *L = LI->getLoopFor(II.getParent());
+  Loop *L = LI.getLoopFor(II.getParent());
 
   // The access function and base pointer for memory intrinsics.
   const SCEV *AF;
@@ -624,25 +672,25 @@ bool ScopDetection::isValidIntrinsicInst(IntrinsicInst &II,
   // Memory intrinsics that can be represented are supported.
   case llvm::Intrinsic::memmove:
   case llvm::Intrinsic::memcpy:
-    AF = SE->getSCEVAtScope(cast<MemTransferInst>(II).getSource(), L);
+    AF = SE.getSCEVAtScope(cast<MemTransferInst>(II).getSource(), L);
     if (!AF->isZero()) {
-      BP = dyn_cast<SCEVUnknown>(SE->getPointerBase(AF));
+      BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(AF));
       // Bail if the source pointer is not valid.
       if (!isValidAccess(&II, AF, BP, Context))
         return false;
     }
   // Fall through
   case llvm::Intrinsic::memset:
-    AF = SE->getSCEVAtScope(cast<MemIntrinsic>(II).getDest(), L);
+    AF = SE.getSCEVAtScope(cast<MemIntrinsic>(II).getDest(), L);
     if (!AF->isZero()) {
-      BP = dyn_cast<SCEVUnknown>(SE->getPointerBase(AF));
+      BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(AF));
       // Bail if the destination pointer is not valid.
       if (!isValidAccess(&II, AF, BP, Context))
         return false;
     }
 
     // Bail if the length is not affine.
-    if (!isAffine(SE->getSCEVAtScope(cast<MemIntrinsic>(II).getLength(), L), L,
+    if (!isAffine(SE.getSCEVAtScope(cast<MemIntrinsic>(II).getLength(), L), L,
                   Context))
       return false;
 
@@ -722,7 +770,7 @@ ScopDetection::getDelinearizationTerms(DetectionContext &Context,
   SmallVector<const SCEV *, 4> Terms;
   for (const auto &Pair : Context.Accesses[BasePointer]) {
     std::vector<const SCEV *> MaxTerms;
-    SCEVRemoveMax::rewrite(Pair.second, *SE, &MaxTerms);
+    SCEVRemoveMax::rewrite(Pair.second, SE, &MaxTerms);
     if (MaxTerms.size() > 0) {
       Terms.insert(Terms.begin(), MaxTerms.begin(), MaxTerms.end());
       continue;
@@ -738,7 +786,7 @@ ScopDetection::getDelinearizationTerms(DetectionContext &Context,
     if (auto *AF = dyn_cast<SCEVAddExpr>(Pair.second)) {
       for (auto Op : AF->operands()) {
         if (auto *AF2 = dyn_cast<SCEVAddRecExpr>(Op))
-          SE->collectParametricTerms(AF2, Terms);
+          SE.collectParametricTerms(AF2, Terms);
         if (auto *AF2 = dyn_cast<SCEVMulExpr>(Op)) {
           SmallVector<const SCEV *, 0> Operands;
 
@@ -756,12 +804,12 @@ ScopDetection::getDelinearizationTerms(DetectionContext &Context,
             }
           }
           if (Operands.size())
-            Terms.push_back(SE->getMulExpr(Operands));
+            Terms.push_back(SE.getMulExpr(Operands));
         }
       }
     }
     if (Terms.empty())
-      SE->collectParametricTerms(Pair.second, Terms);
+      SE.collectParametricTerms(Pair.second, Terms);
   }
   return Terms;
 }
@@ -781,7 +829,7 @@ bool ScopDetection::hasValidArraySizes(DetectionContext &Context,
       auto *V = dyn_cast<Value>(Unknown->getValue());
       if (auto *Load = dyn_cast<LoadInst>(V)) {
         if (Context.CurRegion.contains(Load) &&
-            isHoistableLoad(Load, CurRegion, *LI, *SE, *DT))
+            isHoistableLoad(Load, CurRegion, LI, SE, DT))
           Context.RequiredILS.insert(Load);
         continue;
       }
@@ -828,11 +876,11 @@ bool ScopDetection::computeAccessFunctions(
   for (const auto &Pair : Context.Accesses[BasePointer]) {
     const Instruction *Insn = Pair.first;
     auto *AF = Pair.second;
-    AF = SCEVRemoveMax::rewrite(AF, *SE);
+    AF = SCEVRemoveMax::rewrite(AF, SE);
     bool IsNonAffine = false;
     TempMemoryAccesses.insert(std::make_pair(Insn, MemAcc(Insn, Shape)));
     MemAcc *Acc = &TempMemoryAccesses.find(Insn)->second;
-    auto *Scope = LI->getLoopFor(Insn->getParent());
+    auto *Scope = LI.getLoopFor(Insn->getParent());
 
     if (!AF) {
       if (isAffine(Pair.second, Scope, Context))
@@ -840,8 +888,8 @@ bool ScopDetection::computeAccessFunctions(
       else
         IsNonAffine = true;
     } else {
-      SE->computeAccessFunctions(AF, Acc->DelinearizedSubscripts,
-                                 Shape->DelinearizedSizes);
+      SE.computeAccessFunctions(AF, Acc->DelinearizedSubscripts,
+                                Shape->DelinearizedSizes);
       if (Acc->DelinearizedSubscripts.size() == 0)
         IsNonAffine = true;
       for (const SCEV *S : Acc->DelinearizedSubscripts)
@@ -874,8 +922,8 @@ bool ScopDetection::hasBaseAffineAccesses(DetectionContext &Context,
 
   auto Terms = getDelinearizationTerms(Context, BasePointer);
 
-  SE->findArrayDimensions(Terms, Shape->DelinearizedSizes,
-                          Context.ElementSize[BasePointer]);
+  SE.findArrayDimensions(Terms, Shape->DelinearizedSizes,
+                         Context.ElementSize[BasePointer]);
 
   if (!hasValidArraySizes(Context, Shape->DelinearizedSizes, BasePointer,
                           Scope))
@@ -923,15 +971,15 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
   if (!isInvariant(*BV, Context.CurRegion, Context))
     return invalid<ReportVariantBasePtr>(Context, /*Assert=*/true, BV, Inst);
 
-  AF = SE->getMinusSCEV(AF, BP);
+  AF = SE.getMinusSCEV(AF, BP);
 
   const SCEV *Size;
   if (!isa<MemIntrinsic>(Inst)) {
-    Size = SE->getElementSize(Inst);
+    Size = SE.getElementSize(Inst);
   } else {
     auto *SizeTy =
-        SE->getEffectiveSCEVType(PointerType::getInt8PtrTy(SE->getContext()));
-    Size = SE->getConstant(SizeTy, 8);
+        SE.getEffectiveSCEVType(PointerType::getInt8PtrTy(SE.getContext()));
+    Size = SE.getConstant(SizeTy, 8);
   }
 
   if (Context.ElementSize[BP]) {
@@ -939,7 +987,7 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
       return invalid<ReportDifferentArrayElementSize>(Context, /*Assert=*/true,
                                                       Inst, BV);
 
-    Context.ElementSize[BP] = SE->getSMinExpr(Size, Context.ElementSize[BP]);
+    Context.ElementSize[BP] = SE.getSMinExpr(Size, Context.ElementSize[BP]);
   } else {
     Context.ElementSize[BP] = Size;
   }
@@ -951,7 +999,7 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
     if (Context.BoxedLoopsSet.count(L))
       IsVariantInNonAffineLoop = true;
 
-  auto *Scope = LI->getLoopFor(Inst->getParent());
+  auto *Scope = LI.getLoopFor(Inst->getParent());
   bool IsAffine = !IsVariantInNonAffineLoop && isAffine(AF, Scope, Context);
   // Do not try to delinearize memory intrinsics and force them to be affine.
   if (isa<MemIntrinsic>(Inst) && !IsAffine) {
@@ -962,7 +1010,7 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
 
     if (!IsAffine)
       Context.NonAffineAccesses.insert(
-          std::make_pair(BP, LI->getLoopFor(Inst->getParent())));
+          std::make_pair(BP, LI.getLoopFor(Inst->getParent())));
   } else if (!AllowNonAffine && !IsAffine) {
     return invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Inst,
                                           BV);
@@ -990,7 +1038,7 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
         Instruction *Inst = dyn_cast<Instruction>(Ptr.getValue());
         if (Inst && Context.CurRegion.contains(Inst)) {
           auto *Load = dyn_cast<LoadInst>(Inst);
-          if (Load && isHoistableLoad(Load, Context.CurRegion, *LI, *SE, *DT)) {
+          if (Load && isHoistableLoad(Load, Context.CurRegion, LI, SE, DT)) {
             Context.RequiredILS.insert(Load);
             continue;
           }
@@ -1012,11 +1060,11 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
 bool ScopDetection::isValidMemoryAccess(MemAccInst Inst,
                                         DetectionContext &Context) const {
   Value *Ptr = Inst.getPointerOperand();
-  Loop *L = LI->getLoopFor(Inst->getParent());
-  const SCEV *AccessFunction = SE->getSCEVAtScope(Ptr, L);
+  Loop *L = LI.getLoopFor(Inst->getParent());
+  const SCEV *AccessFunction = SE.getSCEVAtScope(Ptr, L);
   const SCEVUnknown *BasePointer;
 
-  BasePointer = dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFunction));
+  BasePointer = dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
 
   return isValidAccess(Inst, AccessFunction, BasePointer, Context);
 }
@@ -1029,7 +1077,7 @@ bool ScopDetection::isValidInstruction(Instruction &Inst,
     if (!OpInst)
       continue;
 
-    if (isErrorBlock(*OpInst->getParent(), Context.CurRegion, *LI, *DT))
+    if (isErrorBlock(*OpInst->getParent(), Context.CurRegion, LI, DT))
       return false;
   }
 
@@ -1130,7 +1178,7 @@ bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
     return true;
 
   if (AllowNonAffineSubLoops && AllowNonAffineSubRegions) {
-    Region *R = RI->getRegionFor(L->getHeader());
+    Region *R = RI.getRegionFor(L->getHeader());
     while (R != &Context.CurRegion && !R->contains(L))
       R = R->getParent();
 
@@ -1138,7 +1186,7 @@ bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
       return true;
   }
 
-  const SCEV *LoopCount = SE->getBackedgeTakenCount(L);
+  const SCEV *LoopCount = SE.getBackedgeTakenCount(L);
   return invalid<ReportLoopBound>(Context, /*Assert=*/true, L, LoopCount);
 }
 
@@ -1199,7 +1247,7 @@ Region *ScopDetection::expandRegion(Region &R) {
   while (ExpandedRegion) {
     const auto &It = DetectionContextMap.insert(std::make_pair(
         getBBPairForRegion(ExpandedRegion.get()),
-        DetectionContext(*ExpandedRegion, *AA, false /*verifying*/)));
+        DetectionContext(*ExpandedRegion, AA, false /*verifying*/)));
     DetectionContext &Context = It.first->second;
     DEBUG(dbgs() << "\t\tTrying " << ExpandedRegion->getNameStr() << "\n");
     // Only expand when we did not collect errors.
@@ -1244,9 +1292,9 @@ Region *ScopDetection::expandRegion(Region &R) {
 
   return LastValidRegion.release();
 }
-static bool regionWithoutLoops(Region &R, LoopInfo *LI) {
+static bool regionWithoutLoops(Region &R, LoopInfo &LI) {
   for (const BasicBlock *BB : R.blocks())
-    if (R.contains(LI->getLoopFor(BB)))
+    if (R.contains(LI.getLoopFor(BB)))
       return false;
 
   return true;
@@ -1267,7 +1315,7 @@ void ScopDetection::removeCachedResults(const Region &R) {
 
 void ScopDetection::findScops(Region &R) {
   const auto &It = DetectionContextMap.insert(std::make_pair(
-      getBBPairForRegion(&R), DetectionContext(R, *AA, false /*verifying*/)));
+      getBBPairForRegion(&R), DetectionContext(R, AA, false /*verifying*/)));
   DetectionContext &Context = It.first->second;
 
   bool RegionIsValid = false;
@@ -1326,14 +1374,14 @@ bool ScopDetection::allBlocksValid(DetectionContext &Context) const {
   Region &CurRegion = Context.CurRegion;
 
   for (const BasicBlock *BB : CurRegion.blocks()) {
-    Loop *L = LI->getLoopFor(BB);
+    Loop *L = LI.getLoopFor(BB);
     if (L && L->getHeader() == BB && CurRegion.contains(L) &&
         (!isValidLoop(L, Context) && !KeepGoing))
       return false;
   }
 
   for (BasicBlock *BB : CurRegion.blocks()) {
-    bool IsErrorBlock = isErrorBlock(*BB, CurRegion, *LI, *DT);
+    bool IsErrorBlock = isErrorBlock(*BB, CurRegion, LI, DT);
 
     // Also check exception blocks (and possibly register them as non-affine
     // regions). Even though exception blocks are not modeled, we use them
@@ -1363,7 +1411,7 @@ bool ScopDetection::hasSufficientCompute(DetectionContext &Context,
     return false;
 
   for (auto *BB : Context.CurRegion.blocks())
-    if (Context.CurRegion.contains(LI->getLoopFor(BB)))
+    if (Context.CurRegion.contains(LI.getLoopFor(BB)))
       InstCount += BB->size();
 
   InstCount = InstCount / NumLoops;
@@ -1374,7 +1422,7 @@ bool ScopDetection::hasSufficientCompute(DetectionContext &Context,
 bool ScopDetection::hasPossiblyDistributableLoop(
     DetectionContext &Context) const {
   for (auto *BB : Context.CurRegion.blocks()) {
-    auto *L = LI->getLoopFor(BB);
+    auto *L = LI.getLoopFor(BB);
     if (!Context.CurRegion.contains(L))
       continue;
     if (Context.BoxedLoopsSet.count(L))
@@ -1403,7 +1451,7 @@ bool ScopDetection::isProfitableRegion(DetectionContext &Context) const {
     return invalid<ReportUnprofitable>(Context, /*Assert=*/true, &CurRegion);
 
   int NumLoops =
-      countBeneficialLoops(&CurRegion, *SE, *LI, MIN_LOOP_TRIP_COUNT).NumLoops;
+      countBeneficialLoops(&CurRegion, SE, LI, MIN_LOOP_TRIP_COUNT).NumLoops;
   int NumAffineLoops = NumLoops - Context.BoxedLoopsSet.size();
 
   // Scops with at least two loops may allow either loop fusion or tiling and
@@ -1553,7 +1601,7 @@ bool ScopDetection::isReducibleRegion(Region &R, DebugLoc &DbgLoc) const {
         // GREY indicates a loop in the control flow.
         // If the destination dominates the source, it is a natural loop
         // else, an irreducible control flow in the region is detected.
-        if (!DT->dominates(SuccBB, CurrBB)) {
+        if (!DT.dominates(SuccBB, CurrBB)) {
           // Get debug info of instruction which causes irregular control flow.
           DbgLoc = TInst->getDebugLoc();
           return false;
@@ -1570,8 +1618,8 @@ bool ScopDetection::isReducibleRegion(Region &R, DebugLoc &DbgLoc) const {
   return true;
 }
 
-void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
-                              bool OnlyProfitable) {
+static void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
+                                     bool OnlyProfitable) {
   if (!OnlyProfitable) {
     NumLoopsInScop += Stats.NumLoops;
     MaxNumLoopsInScop =
@@ -1607,61 +1655,6 @@ void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
   }
 }
 
-bool ScopDetection::runOnFunction(llvm::Function &F) {
-  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
-  RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
-  if (!PollyProcessUnprofitable && LI->empty())
-    return false;
-
-  AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
-  SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
-  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  Region *TopRegion = RI->getTopLevelRegion();
-
-  releaseMemory();
-
-  if (OnlyFunction != "" && !F.getName().count(OnlyFunction))
-    return false;
-
-  if (!isValidFunction(F))
-    return false;
-
-  findScops(*TopRegion);
-
-  NumScopRegions += ValidRegions.size();
-
-  // Prune non-profitable regions.
-  for (auto &DIt : DetectionContextMap) {
-    auto &DC = DIt.getSecond();
-    if (DC.Log.hasErrors())
-      continue;
-    if (!ValidRegions.count(&DC.CurRegion))
-      continue;
-    LoopStats Stats = countBeneficialLoops(&DC.CurRegion, *SE, *LI, 0);
-    updateLoopCountStatistic(Stats, false /* OnlyProfitable */);
-    if (isProfitableRegion(DC)) {
-      updateLoopCountStatistic(Stats, true /* OnlyProfitable */);
-      continue;
-    }
-
-    ValidRegions.remove(&DC.CurRegion);
-  }
-
-  NumProfScopRegions += ValidRegions.size();
-  NumLoopsOverall += countBeneficialLoops(TopRegion, *SE, *LI, 0).NumLoops;
-
-  // Only makes sense when we tracked errors.
-  if (PollyTrackFailures)
-    emitMissedRemarks(F);
-
-  if (ReportLevel)
-    printLocations(F);
-
-  assert(ValidRegions.size() <= DetectionContextMap.size() &&
-         "Cached more results than valid regions");
-  return false;
-}
-
 ScopDetection::DetectionContext *
 ScopDetection::getDetectionContext(const Region *R) const {
   auto DCMIt = DetectionContextMap.find(getBBPairForRegion(R));
@@ -1678,7 +1671,7 @@ const RejectLog *ScopDetection::lookupRejectionLog(const Region *R) const {
 void polly::ScopDetection::verifyRegion(const Region &R) const {
   assert(isMaxRegionInScop(R) && "Expect R is a valid region.");
 
-  DetectionContext Context(const_cast<Region &>(R), *AA, true /*verifying*/);
+  DetectionContext Context(const_cast<Region &>(R), AA, true /*verifying*/);
   isValidRegion(Context);
 }
 
@@ -1690,7 +1683,17 @@ void polly::ScopDetection::verifyAnalysis() const {
     verifyRegion(*R);
 }
 
-void ScopDetection::getAnalysisUsage(AnalysisUsage &AU) const {
+bool ScopDetectionWrapperPass::runOnFunction(llvm::Function &F) {
+  auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
+  auto &RI = getAnalysis<RegionInfoPass>().getRegionInfo();
+  auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
+  auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
+  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  Result.reset(new ScopDetection(F, DT, SE, LI, RI, AA));
+  return false;
+}
+
+void ScopDetectionWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
@@ -1700,25 +1703,49 @@ void ScopDetection::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }
 
-void ScopDetection::print(raw_ostream &OS, const Module *) const {
-  for (const Region *R : ValidRegions)
+void ScopDetectionWrapperPass::print(raw_ostream &OS, const Module *) const {
+  for (const Region *R : Result->ValidRegions)
     OS << "Valid Region for Scop: " << R->getNameStr() << '\n';
 
   OS << "\n";
 }
 
-void ScopDetection::releaseMemory() {
-  ValidRegions.clear();
-  DetectionContextMap.clear();
+ScopDetectionWrapperPass::ScopDetectionWrapperPass() : FunctionPass(ID) {
+  // Disable runtime alias checks if we ignore aliasing all together.
+  if (IgnoreAliasing)
+    PollyUseRuntimeAliasChecks = false;
+}
+
+void ScopDetectionWrapperPass::releaseMemory() { Result.reset(); }
+
+char ScopDetectionWrapperPass::ID;
+
+AnalysisKey ScopAnalysis::Key;
 
-  // Do not clear the invalid function set.
+ScopDetection ScopAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
+  auto &LI = FAM.getResult<LoopAnalysis>(F);
+  auto &RI = FAM.getResult<RegionInfoAnalysis>(F);
+  auto &AA = FAM.getResult<AAManager>(F);
+  auto &SE = FAM.getResult<ScalarEvolutionAnalysis>(F);
+  auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
+  return {F, DT, SE, LI, RI, AA};
 }
 
-char ScopDetection::ID = 0;
+PreservedAnalyses ScopAnalysisPrinterPass::run(Function &F,
+                                               FunctionAnalysisManager &FAM) {
+  auto &SD = FAM.getResult<ScopAnalysis>(F);
+  for (const Region *R : SD.ValidRegions)
+    Stream << "Valid Region for Scop: " << R->getNameStr() << '\n';
 
-Pass *polly::createScopDetectionPass() { return new ScopDetection(); }
+  Stream << "\n";
+  return PreservedAnalyses::all();
+}
+
+Pass *polly::createScopDetectionWrapperPassPass() {
+  return new ScopDetectionWrapperPass();
+}
 
-INITIALIZE_PASS_BEGIN(ScopDetection, "polly-detect",
+INITIALIZE_PASS_BEGIN(ScopDetectionWrapperPass, "polly-detect",
                       "Polly - Detect static control parts (SCoPs)", false,
                       false);
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass);
@@ -1726,5 +1753,5 @@ INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_END(ScopDetection, "polly-detect",
+INITIALIZE_PASS_END(ScopDetectionWrapperPass, "polly-detect",
                     "Polly - Detect static control parts (SCoPs)", false, false)