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

[philip.pfaffe]

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.

[Meinersbur]

Thanks for getting this for started. The part of adding those passes to the new pass manager's pipeline must be done in RegisterPasses.cpp, but all passes must be registered to the new pass manager, otherwise it cannot use them.

Note that we have two correctness issues that are fragile with the pass managers:

1. Polly's codegen can change the IR of other SCoPs. Particularly it can make previously detected scops invalid. Thats why the sequence must be:

ScopDetection: A and B
ScopInfo on A, verify whether A is still a SCoP
CodeGeneration of A
ScopInfo on B, verify whether B is still a SCoP
CodeGeneration of B

but not:

ScopDetection: A and B
ScopInfo on A
ScopInfo on B
CodeGeneration of A
CodeGeneration of B

CodeGeneration of A can invalidate B, resulting in miscompiles because the IR of B was changed and does not correspond to its ScopInfo anymore.

This is way we rely on the RegionPass to run all passes on region, the continue with the next region.

2. Polly does a bad job preserving analyses. It does not create new regions and loops in generated code. There is currently an ugly hack called NoopBarrier added to the pass pipeline that effectively throws away all analyses with the legacy pass manager. I get miscompiles when that barrier pass is removed. The new pass manager just caches all analyses.

Before these are not resolved, we cannot really use the new pass manager in production.

include/polly/ScopDetection.h

204–208 ↗

(On Diff #93365)

My personal opinion is to prefer pointers over references when the class is not copyable/value-like. References cannot be used in all contexts. The reason is consistency of how an object of a type is used independent from which function it is used in. It also avoids global rewriting such as this one.

However, this is my personal opinion and I see not everyone agrees with it.

lib/Analysis/ScopDetection.cpp

272–321 ↗

(On Diff #93365)

I do not recommend having a lot of logic in a constructor:

• Makes composability more difficult. Assume we have to create this object in a different way. Then we'd have to clone the complete constructor although most members still have the 'obvious' initialization. Here: the analyses. This happened aready to the ScopStmt and MemoryAccess ctors.

• If an exception is raised, the destructors are called, on possibly uninitialized variables. This is problaby not what you expect.

• Calling an overridded virtual method calls the non-overridden method. This way it is possible to call an unimplemented method of an abstract class. Even if it is not an abstract class, if you are running an algorithm, you want the instantiated class' methods to be called, not one of the base classes. That is, better don't implement an algorithm in a constructor.

LLVM has exception switched off and ScopDetection is not derived from, so stricly speaking the 2. and 3. points do not appy. However, there is still the first and IMHO it is a good coding practice to only initialize members in constructors and nothing else. Expecially be careful when calling other members.

[philip.pfaffe]

In D31459#713119, @Meinersbur wrote:

Thanks for getting this for started. The part of adding those passes to the new pass manager's pipeline must be done in RegisterPasses.cpp, but all passes must be registered to the new pass manager, otherwise it cannot use them.

Pass Registration is still a pending issue. Until D11032 is ready to land, there is no defined way to set up a polly pipeline.

Note that we have two correctness issues that are fragile with the pass managers:

1. Polly's codegen can change the IR of other SCoPs. Particularly it can make previously detected scops invalid. Thats why the sequence must be:

This is precisely the problem a ScopXManager would solve...

CodeGeneration of A can invalidate B, resulting in miscompiles because the IR of B was changed and does not correspond to its ScopInfo anymore.

... however this violates fundamental assumptions both the new and(!) the old pass managers make. It's an upstream miscompile or crash waiting to happen. In what way do SCoPs specifically interact? If there is no way to break that dependence, we can't run our own SCoP pipeline and must widen the IRUnit of the analyses to Function.

2. Polly does a bad job preserving analyses. It does not create new regions and loops in generated code. There is currently an ugly hack called NoopBarrier added to the pass pipeline that effectively throws away all analyses with the legacy pass manager. I get miscompiles when that barrier pass is removed. The new pass manager just caches all analyses.

This is a non-issue. The new PM pessimistically invalidates all cached analysis results after a transfrom by default.

[philip.pfaffe]

include/polly/ScopDetection.h

204–208 ↗

(On Diff #93365)

I tentatively disagree. References are perfectly copyable. In turn, pointers convey one extra semantic, namely being nullable. This is of course nowhere being checked here.
Unless there's a reason to allow this extra state, I find references to be the better defalt.

It made sense to use pointers before, because they were lazily initialized. But now they aren't anymore.

lib/Analysis/ScopDetection.cpp

272–321 ↗

(On Diff #93365)

I will add a factory.

[Meinersbur]

In D31459#713310, @philip.pfaffe wrote:

In D31459#713119, @Meinersbur wrote:

Thanks for getting this for started. The part of adding those passes to the new pass manager's pipeline must be done in RegisterPasses.cpp, but all passes must be registered to the new pass manager, otherwise it cannot use them.

Pass Registration is still a pending issue. Until D11032 is ready to land, there is no defined way to set up a polly pipeline.

I was trying to ask Chandler Carruth ask about this in the Hacker's Lab. Unfortunately I already asked too many questions and he preferred to let other people ask questions as well.

Note that we have two correctness issues that are fragile with the pass managers:

1. Polly's codegen can change the IR of other SCoPs. Particularly it can make previously detected scops invalid. Thats why the sequence must be:

This is precisely the problem a ScopXManager would solve...

What is ScopXManager? If it is a single pass (Tobias suggested "-polly-sched") that would run all the other passes itself, then we have full control and can run in any order we like. However, we then also don't need to convert to existing passes to the new pass manager, they would be not be scheduled by any LLVM's pass manager anymore.

CodeGeneration of A can invalidate B, resulting in miscompiles because the IR of B was changed and does not correspond to its ScopInfo anymore.

... however this violates fundamental assumptions both the new and(!) the old pass managers make. It's an upstream miscompile or crash waiting to happen.

This happens with Loop passes all the time. Loop passes can create new loops (loop distribution) or remove them as it they like, as long as the LoopInfo remains consistent.

In what way do SCoPs specifically interact? If there is no way to break that dependence, we can't run our own SCoP pipeline and must widen the IRUnit of the analyses to Function.

I did not observe by myself (probably because it is already handled), but according to Tobias it happened in the past.

What I can think of is that the exit block of one SCoP is the entry block of the next one (and they are not combined to a single SCoP, e.g. because there is another edge from somewhere to that block). After codegen, there will be a merge block (polly.merge_new_and_old), combining the control flow from the the loop versioning branch, which would be the new entry block of the second. However, if ScopInfo already ran on the second SCoP, it will still reference the original entry block, which landed somewhere else, e.g. as the original code section.

2. Polly does a bad job preserving analyses. It does not create new regions and loops in generated code. There is currently an ugly hack called NoopBarrier added to the pass pipeline that effectively throws away all analyses with the legacy pass manager. I get miscompiles when that barrier pass is removed. The new pass manager just caches all analyses.

This is a non-issue. The new PM pessimistically invalidates all cached analysis results after a transfrom by default.

Because pass dependencies are mostly transitive, invalidating all analysis would mean it also invalidates ScopDetection and we would try to re-detect the output of CodeGeneration. This is actually because polly passes have to preserve _all_ analyses used by any polly pass. It is also inefficient because we'd need to run all these analyses multiple times.

[Meinersbur]

In D31459#713310, @philip.pfaffe wrote:

If there is no way to break that dependence, we can't run our own SCoP pipeline and must widen the IRUnit of the analyses to Function.

There is already ScopInfoWrapperPass which tries this. It as the aforementioned problem that generating one SCoP may invalidate another.

[philip.pfaffe]

In D31459#713425, @Meinersbur wrote:

I was trying to ask Chandler Carruth ask about this in the Hacker's Lab. Unfortunately I already asked too many questions and he preferred to let other people ask questions as well.

I've discussed this a bit with Chandler. If my patch lands it will enable pass registration. Hopefully that'll happen soonish.

What is ScopXManager? If it is a single pass (Tobias suggested "-polly-sched") that would run all the other passes itself, then we have full control and can run in any order we like. However, we then also don't need to convert to existing passes to the new pass manager, they would be not be scheduled by any LLVM's pass manager anymore.

The X stands for Pass and Analysis. I was thinking about adding these Managers to keep the pipelining behavior as it was before. But this depends on the issues below.

This happens with Loop passes all the time. Loop passes can create new loops (loop distribution) or remove them as it they like, as long as the LoopInfo remains consistent.

Loop passes modify the current loop nest, add loops to it or delete it or its children. They don't affect entirely different loops in the same function, I think. Either way, the PM is flexible enough to allow for adding and removing Scops from the current worklist.

What I can think of is that the exit block of one SCoP is the entry block of the next one (and they are not combined to a single SCoP, e.g. because there is another edge from somewhere to that block). After codegen, there will be a merge block (polly.merge_new_and_old), combining the control flow from the the loop versioning branch, which would be the new entry block of the second. However, if ScopInfo already ran on the second SCoP, it will still reference the original entry block, which landed somewhere else, e.g. as the original code section.

If we keep ScopInfo as a ScopPass, this cannot happen.

Because pass dependencies are mostly transitive, invalidating all analysis would mean it also invalidates ScopDetection and we would try to re-detect the output of CodeGeneration. This is actually because polly passes have to preserve _all_ analyses used by any polly pass. It is also inefficient because we'd need to run all these analyses multiple times.

It wouldn't necessarily mean that. If, as discussed above, I add a ScopPass pipeline, ScopDetection would naturally be preserved. Inside a ScopPass individual analyses can be preserved, if we can pessimistically guarantee that that's sound. Frequent cache invalidation may happen, and it does in the current O2, O3 pipelines. However, so far the performance impact is negligible.

Fundamentally I don't see anything of this as a blocker to using a ScopPassManager. I'll thus move forward with building one and porting the existing passes over to the new Scop pipeline. Any further pointers with regard to SCoP interaction would much appreciated!

[philip.pfaffe]

This patch is currently blocked by an ugly bug in RegionInfo, which I'll have to sort out first before I can move this further. Apologies!

lib/Analysis/ScopDetection.cpp

272–321 ↗

(On Diff #93365)

Some bikeshedding on this:

• I disagree with your Composiability point. Right now this type serves a specific and narrow purpose. Widening this always requires some redesign.
• Exception (un)safety is an issue, but only when there are managed resources. In the constructor, the object is fully initialized an in a defined state. Thus, if we stick to exception safe code (i.e., using RAII and/or exception safe resource management), we need not worry about exceptions.
• This point I actually agree with fully. Right now there's no virtual dispatch here, but who knows if that might change in the future. So accepting this hazard right now might bite us in the future.

In summary: I'd still like to do the full initialization in the constructor, because the full knowledge of the ValidRegions is the specific internal state that defines an object of this class (a factory would externalize this). To deal with the missing virtual dispatch in the constructor, I however propose moving a lot of the private interface of the ScopDetection class and its implementation out out of the type. This would further satisfy your composability concerns. Thoughts?

[grosser]

Out of interest: What is the RegionInfo bug you are talking about?

lib/Analysis/ScopDetection.cpp

1615 ↗

(On Diff #93365)

Is this change related. If it is not, I suggest to commit this as-obvious without further review.

(Do you have commit access. If not please ask Chris for commit access. Your code is great and I believe you have plans for further contributions).

[philip.pfaffe]

In D31459#718991, @grosser wrote:

Out of interest: What is the RegionInfo bug you are talking about?

Region-objects capture the address of the creating RegionInfo instance. RegionInfo is movable, and after a move performed by the AnalysisManager, most accesses to the Region objects segfault. This will be a rather noisy fix, because I'll probably need to strictly decouple the Regions from RegionInfo.

Is the RegionInfoAnalysis actually maintained by the Polly community?

lib/Analysis/ScopDetection.cpp

1615 ↗

(On Diff #93365)

It's not related. Will commit seperately!

[grosser]

Polly is one (but not the only) user of the region infrastructure. So yes, a portion of the bugs is resolved by us. Would be great if this could be fixed, though. If the change is noisy, but simple, the review should be easy.

[philip.pfaffe]

Add the as of yet missing printing facilities as a PrinterPass.

[grosser]

Hi Philip,

thanks for working on this. I just had a first view and I think the direction looks very good. There are still some style discussions open, but otherwise the patch looks great. I would like to get it in soon. The final thing missing is to actually be able to run and test this. What is needed to actually make this run and testable? I would really like to see a test case that verifies this is working. Also, could you add a comment in the commit message that explains how to run the viewers in the new pass manager?

include/polly/ScopDetection.h

204–208 ↗

(On Diff #93365)

Even though I dislike global rewrites (as most of us), LLVM has a long tradition of not letting such dislikes prevent progress in terms of code quality and functionality. Hence, if there is an argument for a rewrite -- at best if it is mostly mechanical and just a single kind of change -- I am happy even with larger changes.

Now, I think Philip has a good point. If we can ensure the reference is never null, expressing this semantic by using references makes sense. Hence, I would agree with him and suggest to proceed with his choice assuming Michael is OK with this. If we do this, I would just suggest to mention the reason why this change was applied in the commit message.

Now, this is very subjective. Neither of the two choices is a lot better. One of the typical ways to get around bikesheding is to use 'grep' to get simple statistics what LLVM is doing. Sometimes this gives a clear picture, what we can follow. Otherwise, I suggest to agree on something and then follow this in Polly consistently.

[philip.pfaffe]

What is needed to actually make this run and testable? I would really like to see a test case that verifies this is working.

While the 'right' way to do this is still depending on the outcome of D11032, what I could do right now is add a set of unit tests which hand-craft pipelines. That way I can at least demonstrate that the passes work with the new PM as well.

Also, could you add a comment in the commit message that explains how to run the viewers in the new pass manager?

What exactly do you mean by 'viewers' here?

[grosser]

Yes, please add such unit tests

[grosser]

Hey Philipp,

if it is easy to add these unit tests, this would be really helpful. I started to review some of your later patches and some unit tests that show how to run these passes would be really helpful.

Best,
Tobias

[Meinersbur]

include/polly/ScopDetection.h

204–208 ↗

(On Diff #93365)

I am OK with it.

lib/Analysis/ScopDetection.cpp

272–321 ↗

(On Diff #93365)

• Composability: Whether a class has one or more constructors does not depend on how specific the class'es purpose is. A new/different constructor might be required in different contexts it is used in or even for even narrower contexts. For instance, a ScopDetection might be instantiated only to verify that a given Region is a SCoP.
• Exceptions: While this is true, it is easy to forget (especially by new contributors) and then add a constructor to manually free some resource. Again, this is theoretical (e.g. someone loading Polly in context where exceptions) since LLVM has exceptions disabled.
• A factory is not the only possibility to avoid large constructors. You can also create a public method findScops(Function &) where the main work happens. llvm::IDFCalculator is an example of using this.

This is not a blocking issue for me, so if this is important for you, feel free to ignore my opinion. However, I think avoiding large constructors is preferable in general for the reasons already mentioned, even if these do not apply for a particulat case.

[philip.pfaffe]

Rebase. NFC.

[philip.pfaffe]

Rebase.

[Fixing the previous update, I failed at arc ...]

[grosser]

Hi Philip,

I am not sure what / if the update changed here. Is this a pure rebase with no functional change. In my last comment I asked if it would be possible to add test cases, are you currently working on this or is this not possible? It would be really great to move this patch upstream.

Best,
Tobias

[grosser]

This patch looks good to me. I understand, we can currently not have execution test coverage. I suggest to commit this exceptionally without test cases to at least get compile time test coverage and to also facilitate further testing with the pass manager plugins.

[philip.pfaffe]

Final rebase and clang-format. NFC.

polly/trunk/include/polly/LinkAllPasses.h

 llvm::Pass *createDOTOnlyPrinterPass();
 llvm::Pass *createDOTOnlyViewerPass();
 llvm::Pass *createDOTPrinterPass();
 llvm::Pass *createDOTViewerPass();
 llvm::Pass *createJSONExporterPass();
 llvm::Pass *createJSONImporterPass();
 llvm::Pass *createPollyCanonicalizePass();
 llvm::Pass *createPolyhedralInfoPass();
-llvm::Pass *createScopDetectionPass();
+llvm::Pass *createScopDetectionWrapperPassPass();
 llvm::Pass *createScopInfoRegionPassPass();
 llvm::Pass *createScopInfoWrapperPassPass();
 llvm::Pass *createIslAstInfoPass();
 llvm::Pass *createCodeGenerationPass();
 #ifdef GPU_CODEGEN
 llvm::Pass *createPPCGCodeGenerationPass(GPUArch Arch = GPUArch::NVPTX64,
                                          GPURuntime Runtime = GPURuntime::CUDA);
 #endif
PollyForcePassLinking() {
     polly::createDeadCodeElimPass();
     polly::createDependenceInfoPass();
     polly::createDOTOnlyPrinterPass();
     polly::createDOTOnlyViewerPass();
     polly::createDOTPrinterPass();
     polly::createDOTViewerPass();
     polly::createJSONExporterPass();
     polly::createJSONImporterPass();
-    polly::createScopDetectionPass();
+    polly::createScopDetectionWrapperPassPass();
     polly::createScopInfoRegionPassPass();
     polly::createPollyCanonicalizePass();
     polly::createPolyhedralInfoPass();
     polly::createIslAstInfoPass();
     polly::createCodeGenerationPass();
 #ifdef GPU_CODEGEN
     polly::createPPCGCodeGenerationPass();
 #endif

polly/trunk/include/polly/ScopDetection.h

 extern bool PollyAllowUnsignedOperations;
 
 /// A function attribute which will cause Polly to skip the function
 extern llvm::StringRef PollySkipFnAttr;
 
 //===----------------------------------------------------------------------===//
 /// Pass to detect the maximal static control parts (Scops) of a
 /// function.
-class ScopDetection : public FunctionPass {
+class ScopDetection {
 public:
   typedef SetVector<const Region *> RegionSet;
 
   // Remember the valid regions
   RegionSet ValidRegions;
 
   /// Context variables for SCoP detection.
   struct DetectionContext {
public:
   /// Helper data structure to collect statistics about loop counts.
   struct LoopStats {
     int NumLoops;
     int MaxDepth;
   };
 
 private:
   //===--------------------------------------------------------------------===//
-  ScopDetection(const ScopDetection &) = delete;
-  const ScopDetection &operator=(const ScopDetection &) = delete;
 
-  /// Analysis passes used.
+  /// Analyses used
   //@{
-  const DominatorTree *DT;
-  ScalarEvolution *SE;
-  LoopInfo *LI;
-  RegionInfo *RI;
-  AliasAnalysis *AA;
+  const DominatorTree &DT;
+  ScalarEvolution &SE;
+  LoopInfo &LI;
+  RegionInfo &RI;
+  AliasAnalysis &AA;
   //@}
 
   /// Map to remember detection contexts for all regions.
   using DetectionContextMapTy = DenseMap<BBPair, DetectionContext>;
   mutable DetectionContextMapTy DetectionContextMap;
 
   /// Remove cached results for @p R.
   void removeCachedResults(const Region &R);
private:
   /// @param Context The context of scop detection.
   /// @param Assert Throw an assert in verify mode or not.
   /// @param Args Argument list that gets passed to the constructor of RR.
   template <class RR, typename... Args>
   inline bool invalid(DetectionContext &Context, bool Assert,
                       Args &&... Arguments) const;
 
 public:
-  static char ID;
-  explicit ScopDetection();
+  ScopDetection(Function &F, const DominatorTree &DT, ScalarEvolution &SE,
+                LoopInfo &LI, RegionInfo &RI, AliasAnalysis &AA);
 
   /// Get the RegionInfo stored in this pass.
   ///
   /// This was added to give the DOT printer easy access to this information.
-  RegionInfo *getRI() const { return RI; }
+  RegionInfo *getRI() const { return &RI; }
 
   /// Get the LoopInfo stored in this pass.
-  LoopInfo *getLI() const { return LI; }
+  LoopInfo *getLI() const { return &LI; }
 
   /// Is the region is the maximum region of a Scop?
   ///
   /// @param R The Region to test if it is maximum.
   /// @param Verify Rerun the scop detection to verify SCoP was not invalidated
   ///               meanwhile.
   ///
   /// @return Return true if R is the maximum Region in a Scop, false otherwise.
public:
   /// after some transformations.
   void verifyAnalysis() const;
 
   /// Verify if R is still a valid part of Scop after some transformations.
   ///
   /// @param R The Region to verify.
   void verifyRegion(const Region &R) const;
 
-  /// @name FunctionPass interface
-  //@{
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-  virtual void releaseMemory();
-  virtual bool runOnFunction(Function &F);
-  virtual void print(raw_ostream &OS, const Module *) const;
-  //@}
-
   /// Count the number of loops and the maximal loop depth in @p R.
   ///
   /// @param R The region to check
   /// @param SE The scalar evolution analysis.
   /// @param MinProfitableTrips The minimum number of trip counts from which
   ///                           a loop is assumed to be profitable and
   ///                           consequently is counted.
   /// returns A tuple of number of loops and their maximal depth.
   static ScopDetection::LoopStats
   countBeneficialLoops(Region *R, ScalarEvolution &SE, LoopInfo &LI,
                        unsigned MinProfitableTrips);
 };
 
+struct ScopAnalysis : public AnalysisInfoMixin<ScopAnalysis> {
+  static AnalysisKey Key;
+  using Result = ScopDetection;
+  Result run(Function &F, FunctionAnalysisManager &FAM);
+};
+
+struct ScopAnalysisPrinterPass : public PassInfoMixin<ScopAnalysisPrinterPass> {
+  ScopAnalysisPrinterPass(raw_ostream &O) : Stream(O) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  raw_ostream &Stream;
+};
+
+struct ScopDetectionWrapperPass : public FunctionPass {
+  static char ID;
+  std::unique_ptr<ScopDetection> Result;
+
+  ScopDetectionWrapperPass();
+  /// @name FunctionPass interface
+  //@{
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+  virtual void releaseMemory();
+  virtual bool runOnFunction(Function &F);
+  virtual void print(raw_ostream &OS, const Module *) const;
+  //@}
+
+  ScopDetection &getSD() { return *Result; }
+  const ScopDetection &getSD() const { return *Result; }
+};
+
 } // end namespace polly
 
 namespace llvm {
 class PassRegistry;
-void initializeScopDetectionPass(llvm::PassRegistry &);
+void initializeScopDetectionWrapperPassPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif

polly/trunk/include/polly/ScopInfo.h

 #ifndef POLLY_SCOP_INFO_H
 #define POLLY_SCOP_INFO_H
 
 #include "polly/ScopDetection.h"
 #include "polly/Support/SCEVAffinator.h"
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Analysis/RegionPass.h"
+#include "llvm/IR/PassManager.h"
 #include "isl/aff.h"
 #include "isl/ctx.h"
 #include "isl/set.h"
 
 #include <deque>
 #include <forward_list>
 
 using namespace llvm;

polly/trunk/lib/Analysis/ScopDetection.cpp

STATISTIC(NumProfScopsDepthFive,
           "Number of scops with maximal loop depth 5 (profitable scops only)");
 STATISTIC(NumProfScopsDepthLarger,
           "Number of scops with maximal loop depth 6 and larger "
           "(profitable scops only)");
 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;
 
   Function &F;
   std::string FileName;
   unsigned EntryLine, ExitLine;
 
void DiagnosticScopFound::print(DiagnosticPrinter &DP) const {
 
   DP << FileName << ":" << EntryLine << ": Start of scop\n";
   DP << FileName << ":" << ExitLine << ": End of scop";
 }
 
 //===----------------------------------------------------------------------===//
 // 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>
 inline bool ScopDetection::invalid(DetectionContext &Context, bool Assert,
                                    Args &&... Arguments) const {
 
   if (!Context.Verifying) {
     RejectLog &Log = Context.Log;

 bool ScopDetection::isMaxRegionInScop(const Region &R, bool Verify) const {
   if (!ValidRegions.count(&R))
     return false;
 
   if (Verify) {
     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);
   }
 
   return true;
 }
 
 std::string ScopDetection::regionIsInvalidBecause(const Region *R) const {
bool ScopDetection::addOverApproximatedRegion(Region *AR,
   // If we already know about Ar we can exit.
   if (!Context.NonAffineSubRegionSet.insert(AR))
     return true;
 
   // All loops in the region have to be overapproximated too if there
   // 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);
   }
 
   return (AllowNonAffineSubLoops || Context.BoxedLoopsSet.empty());
 }
 
 bool ScopDetection::onlyValidRequiredInvariantLoads(
     InvariantLoadsSetTy &RequiredILS, DetectionContext &Context) const {
   Region &CurRegion = Context.CurRegion;
   const DataLayout &DL = CurRegion.getEntry()->getModule()->getDataLayout();
 
   if (!PollyInvariantLoadHoisting && !RequiredILS.empty())
     return false;
 
   for (LoadInst *Load : RequiredILS) {
     // If we already know a load has been accepted as required invariant, we
     // already run the validation below once and consequently don't need to
     // run it again. Hence, we return early. For certain test cases (e.g.,
     // COSMO this avoids us spending 50% of scop-detection time in this
     // very function (and its children).
     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) {
 
       if (isSafeToLoadUnconditionally(Load->getPointerOperand(),
                                       Load->getAlignment(), DL))
         continue;
 
       if (NonAffineRegion->contains(Load) &&
           Load->getParent() != NonAffineRegion->getEntry())
         return false;
     }
   }
 
   Context.RequiredILS.insert(RequiredILS.begin(), RequiredILS.end());
 
   return true;
 }
 
 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) {
     if (auto *P2I = dyn_cast<PtrToIntInst>(V))
       V = P2I->getOperand(0);
 
     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;
     }
   }
 
   return false;
 }
 
 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))
     return false;
 
   return true;
 }
 
 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;
 
   // Check for invalid usage of different pointers in one expression.
   if (involvesMultiplePtrs(ConditionSCEV, nullptr, L))
     return false;
 
   if (isAffine(ConditionSCEV, L, Context))
     return true;
 
   if (AllowNonAffineSubRegions &&
-      addOverApproximatedRegion(RI->getRegionFor(&BB), Context))
+      addOverApproximatedRegion(RI.getRegionFor(&BB), Context))
     return true;
 
   return invalid<ReportNonAffBranch>(Context, /*Assert=*/true, &BB,
                                      ConditionSCEV, ConditionSCEV, SI);
 }
 
 bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
                                   Value *Condition, bool IsLoopBranch,
if (Opcode == Instruction::And || Opcode == Instruction::Or) {
       return isValidBranch(BB, BI, Op0, IsLoopBranch, Context) &&
              isValidBranch(BB, BI, Op1, IsLoopBranch, Context);
     }
   }
 
   // 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);
   }
 
   ICmpInst *ICmp = cast<ICmpInst>(Condition);
 
   // Are both operands of the ICmp affine?
   if (isa<UndefValue>(ICmp->getOperand(0)) ||
       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) &&
       involvesMultiplePtrs(RHS, nullptr, L))
     return false;
 
   // Check for invalid usage of different pointers in a relational comparison.
   if (ICmp->isRelational() && involvesMultiplePtrs(LHS, RHS, L))
     return false;
 
   if (isAffine(LHS, L, Context) && isAffine(RHS, L, Context))
     return true;
 
   if (!IsLoopBranch && AllowNonAffineSubRegions &&
-      addOverApproximatedRegion(RI->getRegionFor(&BB), Context))
+      addOverApproximatedRegion(RI.getRegionFor(&BB), Context))
     return true;
 
   if (IsLoopBranch)
     return false;
 
   return invalid<ReportNonAffBranch>(Context, /*Assert=*/true, &BB, LHS, RHS,
                                      ICmp);
 }
bool ScopDetection::isValidCallInst(CallInst &CI,
 
   Function *CalledFunction = CI.getCalledFunction();
 
   // Indirect calls are not supported.
   if (CalledFunction == nullptr)
     return false;
 
   if (AllowModrefCall) {
-    switch (AA->getModRefBehavior(CalledFunction)) {
+    switch (AA.getModRefBehavior(CalledFunction)) {
     case FMRB_UnknownModRefBehavior:
       return false;
     case FMRB_DoesNotAccessMemory:
     case FMRB_OnlyReadsMemory:
       // Implicitly disable delinearization since we have an unknown
       // accesses with an unknown access function.
       Context.HasUnknownAccess = true;
       Context.AST.add(&CI);
       return true;
     case FMRB_OnlyReadsArgumentPointees:
     case FMRB_OnlyAccessesArgumentPointees:
       for (const auto &Arg : CI.arg_operands()) {
         if (!Arg->getType()->isPointerTy())
           continue;
 
         // 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;
 
         // Implicitly disable delinearization since we have an unknown
         // accesses with an unknown access function.
         Context.HasUnknownAccess = true;
       }
 

 }
 
 bool ScopDetection::isValidIntrinsicInst(IntrinsicInst &II,
                                          DetectionContext &Context) const {
   if (isIgnoredIntrinsic(&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;
   const SCEVUnknown *BP;
 
   switch (II.getIntrinsicID()) {
   // 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;
 
     return true;
   default:
     break;
   }
 

 };
 
 SmallVector<const SCEV *, 4>
 ScopDetection::getDelinearizationTerms(DetectionContext &Context,
                                        const SCEVUnknown *BasePointer) const {
   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;
     }
     // In case the outermost expression is a plain add, we check if any of its
     // terms has the form 4 * %inst * %param * %param ..., aka a term that
     // contains a product between a parameter and an instruction that is
     // inside the scop. Such instructions, if allowed at all, are instructions
     // SCEV can not represent, but Polly is still looking through. As a
     // result, these instructions can depend on induction variables and are
     // most likely no array sizes. However, terms that are multiplied with
     // them are likely candidates for array sizes.
     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;
 
           for (auto *MulOp : AF2->operands()) {
             if (auto *Const = dyn_cast<SCEVConstant>(MulOp))
               Operands.push_back(Const);
             if (auto *Unknown = dyn_cast<SCEVUnknown>(MulOp)) {
               if (auto *Inst = dyn_cast<Instruction>(Unknown->getValue())) {
                 if (!Context.CurRegion.contains(Inst))
                   Operands.push_back(MulOp);
 
               } else {
                 Operands.push_back(MulOp);
               }
             }
           }
           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;
 }
 
 bool ScopDetection::hasValidArraySizes(DetectionContext &Context,
                                        SmallVectorImpl<const SCEV *> &Sizes,
                                        const SCEVUnknown *BasePointer,
                                        Loop *Scope) const {
   Value *BaseValue = BasePointer->getValue();
   Region &CurRegion = Context.CurRegion;
   for (const SCEV *DelinearizedSize : Sizes) {
     if (!isAffine(DelinearizedSize, Scope, Context)) {
       Sizes.clear();
       break;
     }
     if (auto *Unknown = dyn_cast<SCEVUnknown>(DelinearizedSize)) {
       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;
       }
     }
     if (hasScalarDepsInsideRegion(DelinearizedSize, &CurRegion, Scope, false))
       return invalid<ReportNonAffineAccess>(
           Context, /*Assert=*/true, DelinearizedSize,
           Context.Accesses[BasePointer].front().first, BaseValue);
bool ScopDetection::computeAccessFunctions(
     DetectionContext &Context, const SCEVUnknown *BasePointer,
     std::shared_ptr<ArrayShape> Shape) const {
   Value *BaseValue = BasePointer->getValue();
   bool BasePtrHasNonAffine = false;
   MapInsnToMemAcc TempMemoryAccesses;
   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))
         Acc->DelinearizedSubscripts.push_back(Pair.second);
       else
         IsNonAffine = true;
     } else {
-      SE->computeAccessFunctions(AF, Acc->DelinearizedSubscripts,
-                                 Shape->DelinearizedSizes);
+      SE.computeAccessFunctions(AF, Acc->DelinearizedSubscripts,
       if (Acc->DelinearizedSubscripts.size() == 0)
         IsNonAffine = true;
       for (const SCEV *S : Acc->DelinearizedSubscripts)
         if (!isAffine(S, Scope, Context))
           IsNonAffine = true;
     }
 
     // (Possibly) report non affine access

 
 bool ScopDetection::hasBaseAffineAccesses(DetectionContext &Context,
                                           const SCEVUnknown *BasePointer,
                                           Loop *Scope) const {
   auto Shape = std::shared_ptr<ArrayShape>(new ArrayShape(BasePointer));
 
   auto Terms = getDelinearizationTerms(Context, BasePointer);
 
-  SE->findArrayDimensions(Terms, Shape->DelinearizedSizes,
-                          Context.ElementSize[BasePointer]);
+  SE.findArrayDimensions(Terms, Shape->DelinearizedSizes,
 
   if (!hasValidArraySizes(Context, Shape->DelinearizedSizes, BasePointer,
                           Scope))
     return false;
 
   return computeAccessFunctions(Context, BasePointer, Shape);
 }
 
bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
   if (IntToPtrInst *Inst = dyn_cast<IntToPtrInst>(BV))
     return invalid<ReportIntToPtr>(Context, /*Assert=*/true, Inst);
 
   // Check that the base address of the access is invariant in the current
   // region.
   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]) {
     if (!AllowDifferentTypes && Context.ElementSize[BP] != Size)
       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;
   }
 
   bool IsVariantInNonAffineLoop = false;
   SetVector<const Loop *> Loops;
   findLoops(AF, Loops);
   for (const Loop *L : Loops)
     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) {
     return invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Inst,
                                           BV);
   } else if (PollyDelinearize && !IsVariantInNonAffineLoop) {
     Context.Accesses[BP].push_back({Inst, 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);
   }
 
   if (IgnoreAliasing)
     return true;
 
if (PollyUseRuntimeAliasChecks) {
       // the beginning of the SCoP. This breaks if the base pointer is defined
       // inside the scop. Hence, we can only create a run-time check if we are
       // sure the base pointer is not an instruction defined inside the scop.
       // However, we can ignore loads that will be hoisted.
       for (const auto &Ptr : AS) {
         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;
           }
 
           CanBuildRunTimeCheck = false;
           break;
         }
       }
 
       if (CanBuildRunTimeCheck)
         return true;
     }
     return invalid<ReportAlias>(Context, /*Assert=*/true, Inst, AS);
   }
 
   return true;
 }
 
 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);
 }
 
 bool ScopDetection::isValidInstruction(Instruction &Inst,
                                        DetectionContext &Context) const {
   for (auto &Op : Inst.operands()) {
     auto *OpInst = dyn_cast<Instruction>(&Op);
 
     if (!OpInst)
       continue;
 
-    if (isErrorBlock(*OpInst->getParent(), Context.CurRegion, *LI, *DT))
+    if (isErrorBlock(*OpInst->getParent(), Context.CurRegion, LI, DT))
       return false;
   }
 
   if (isa<LandingPadInst>(&Inst) || isa<ResumeInst>(&Inst))
     return false;
 
   // We only check the call instruction but not invoke instruction.
   if (CallInst *CI = dyn_cast<CallInst>(&Inst)) {
bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
   // by isErrorBlock(). We hence only have to reject endless loops here.
   if (!hasExitingBlocks(L))
     return invalid<ReportLoopHasNoExit>(Context, /*Assert=*/true, L);
 
   if (canUseISLTripCount(L, Context))
     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();
 
     if (addOverApproximatedRegion(R, Context))
       return true;
   }
 
-  const SCEV *LoopCount = SE->getBackedgeTakenCount(L);
+  const SCEV *LoopCount = SE.getBackedgeTakenCount(L);
   return invalid<ReportLoopBound>(Context, /*Assert=*/true, L, LoopCount);
 }
 
 /// Return the number of loops in @p L (incl. @p L) that have a trip
 ///        count that is not known to be less than @MinProfitableTrips.
 ScopDetection::LoopStats
 ScopDetection::countBeneficialSubLoops(Loop *L, ScalarEvolution &SE,
                                        unsigned MinProfitableTrips) {
Region *ScopDetection::expandRegion(Region &R) {
   std::unique_ptr<Region> LastValidRegion;
   auto ExpandedRegion = std::unique_ptr<Region>(R.getExpandedRegion());
 
   DEBUG(dbgs() << "\tExpanding " << R.getNameStr() << "\n");
 
   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.
 
     if (!Context.Log.hasErrors()) {
       // If the exit is valid check all blocks
       //  - if true, a valid region was found => store it + keep expanding
       //  - if false, .tbd. => stop  (should this really end the loop?)
DEBUG({
     if (LastValidRegion)
       dbgs() << "\tto " << LastValidRegion->getNameStr() << "\n";
     else
       dbgs() << "\tExpanding " << R.getNameStr() << " failed\n";
   });
 
   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;
 }
 
 void ScopDetection::removeCachedResultsRecursively(const Region &R) {
   for (auto &SubRegion : R) {
     if (ValidRegions.count(SubRegion.get())) {
       removeCachedResults(*SubRegion.get());
     } else
       removeCachedResultsRecursively(*SubRegion);
   }
 }
 
 void ScopDetection::removeCachedResults(const Region &R) {
   ValidRegions.remove(&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;
   if (!PollyProcessUnprofitable && regionWithoutLoops(R, LI))
     invalid<ReportUnprofitable>(Context, /*Assert=*/true, &R);
   else
     RegionIsValid = isValidRegion(Context);
 
for (Region *CurrentRegion : ToExpand) {
     removeCachedResultsRecursively(*ExpandedR);
   }
 }
 
 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
     // to forward-propagate domain constraints during ScopInfo construction.
     if (!isValidCFG(*BB, false, IsErrorBlock, Context) && !KeepGoing)
       return false;
 
     if (IsErrorBlock)

 bool ScopDetection::hasSufficientCompute(DetectionContext &Context,
                                          int NumLoops) const {
   int InstCount = 0;
 
   if (NumLoops == 0)
     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;
 
   return InstCount >= ProfitabilityMinPerLoopInstructions;
 }
 
 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))
       continue;
     unsigned StmtsWithStoresInLoops = 0;
     for (auto *LBB : L->blocks()) {
       bool MemStore = false;
       for (auto &I : *LBB)
if (PollyProcessUnprofitable)
     return true;
 
   // We can probably not do a lot on scops that only write or only read
   // data.
   if (!Context.hasStores || !Context.hasLoads)
     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
   // are consequently interesting to look at.
   if (NumAffineLoops >= 2)
     return true;
 
   // A loop with multiple non-trivial blocks migt be amendable to distribution.
for (unsigned I = AdjacentBlockIndex; I < NSucc;
         DFSStack.push(std::make_pair(SuccBB, 0));
         // First time the BB is being processed.
         BBColorMap[SuccBB] = GREY;
         break;
       } else if (BBColorMap[SuccBB] == GREY) {
         // 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;
         }
       }
     }
 
     // If all children of current BB have been processed,
     // then mark that BB as fully processed.
     if (AdjacentBlockIndex == NSucc)
       BBColorMap[CurrBB] = BLACK;
   }
 
   return true;
 }
 
-void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
+static void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
                                      bool OnlyProfitable) {
   if (!OnlyProfitable) {
     NumLoopsInScop += Stats.NumLoops;
     MaxNumLoopsInScop =
         std::max(MaxNumLoopsInScop.getValue(), (unsigned)Stats.NumLoops);
     if (Stats.MaxDepth == 1)
       NumScopsDepthOne++;
     else if (Stats.MaxDepth == 2)
       NumScopsDepthTwo++;
else if (Stats.MaxDepth == 4)
       NumProfScopsDepthFour++;
     else if (Stats.MaxDepth == 5)
       NumProfScopsDepthFive++;
     else
       NumProfScopsDepthLarger++;
   }
 }
 
-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));
   if (DCMIt == DetectionContextMap.end())
     return nullptr;
   return &DCMIt->second;
 }
 
 const RejectLog *ScopDetection::lookupRejectionLog(const Region *R) const {
   const DetectionContext *DC = getDetectionContext(R);
   return DC ? &DC->Log : nullptr;
 }
 
 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);
 }
 
 void polly::ScopDetection::verifyAnalysis() const {
   if (!VerifyScops)
     return;
 
   for (const Region *R : ValidRegions)
     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>();
   // We also need AA and RegionInfo when we are verifying analysis.
   AU.addRequiredTransitive<AAResultsWrapperPass>();
   AU.addRequiredTransitive<RegionInfoPass>();
   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);
 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)

polly/trunk/lib/Analysis/ScopGraphPrinter.cpp

struct GraphTraits<ScopDetection *> : public GraphTraits<RegionInfo *> {
   static nodes_iterator nodes_begin(ScopDetection *SD) {
     return nodes_iterator::begin(getEntryNode(SD));
   }
   static nodes_iterator nodes_end(ScopDetection *SD) {
     return nodes_iterator::end(getEntryNode(SD));
   }
 };
 
+template <>
+struct GraphTraits<ScopDetectionWrapperPass *>
+    : public GraphTraits<ScopDetection *> {
+  static NodeRef getEntryNode(ScopDetectionWrapperPass *P) {
+    return GraphTraits<ScopDetection *>::getEntryNode(&P->getSD());
+  }
+  static nodes_iterator nodes_begin(ScopDetectionWrapperPass *P) {
+    return nodes_iterator::begin(getEntryNode(P));
+  }
+  static nodes_iterator nodes_end(ScopDetectionWrapperPass *P) {
+    return nodes_iterator::end(getEntryNode(P));
+  }
+};
+
 template <> struct DOTGraphTraits<RegionNode *> : public DefaultDOTGraphTraits {
   DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
 
   std::string getNodeLabel(RegionNode *Node, RegionNode *Graph) {
     if (!Node->isSubRegion()) {
       BasicBlock *BB = Node->getNodeAs<BasicBlock>();
 
       if (isSimple())
         return DOTGraphTraits<const Function *>::getSimpleNodeLabel(
             BB, BB->getParent());
       else
         return DOTGraphTraits<const Function *>::getCompleteNodeLabel(
             BB, BB->getParent());
     }
 
     return "Not implemented";
   }
 };
 
 template <>
-struct DOTGraphTraits<ScopDetection *> : public DOTGraphTraits<RegionNode *> {
+struct DOTGraphTraits<ScopDetectionWrapperPass *>
+    : public DOTGraphTraits<RegionNode *> {
   DOTGraphTraits(bool isSimple = false)
       : DOTGraphTraits<RegionNode *>(isSimple) {}
-  static std::string getGraphName(ScopDetection *SD) { return "Scop Graph"; }
+  static std::string getGraphName(ScopDetectionWrapperPass *SD) {
+    return "Scop Graph";
+  }
 
   std::string getEdgeAttributes(RegionNode *srcNode,
                                 GraphTraits<RegionInfo *>::ChildIteratorType CI,
-                                ScopDetection *SD) {
+                                ScopDetectionWrapperPass *P) {
     RegionNode *destNode = *CI;
+    auto *SD = &P->getSD();
 
     if (srcNode->isSubRegion() || destNode->isSubRegion())
       return "";
 
     // In case of a backedge, do not use it to define the layout of the nodes.
     BasicBlock *srcBB = srcNode->getNodeAs<BasicBlock>();
     BasicBlock *destBB = destNode->getNodeAs<BasicBlock>();
 
     RegionInfo *RI = SD->getRI();
     Region *R = RI->getRegionFor(destBB);
 
     while (R && R->getParent())
       if (R->getParent()->getEntry() == destBB)
         R = R->getParent();
       else
         break;
 
     if (R && R->getEntry() == destBB && R->contains(srcBB))
       return "constraint=false";
 
     return "";
   }
 
-  std::string getNodeLabel(RegionNode *Node, ScopDetection *SD) {
+  std::string getNodeLabel(RegionNode *Node, ScopDetectionWrapperPass *P) {
     return DOTGraphTraits<RegionNode *>::getNodeLabel(
-        Node, reinterpret_cast<RegionNode *>(SD->getRI()->getTopLevelRegion()));
+        Node, reinterpret_cast<RegionNode *>(
+                  P->getSD().getRI()->getTopLevelRegion()));
   }
 
   static std::string escapeString(std::string String) {
     std::string Escaped;
 
     for (const auto &C : String) {
       if (C == '"')
         Escaped += '\\';
for (const auto &BB : R->blocks())
       if (RI->getRegionFor(BB) == R)
         O.indent(2 * (depth + 1))
             << "Node"
             << static_cast<void *>(RI->getTopLevelRegion()->getBBNode(BB))
             << ";\n";
 
     O.indent(2 * depth) << "}\n";
   }
-  static void addCustomGraphFeatures(const ScopDetection *SD,
-                                     GraphWriter<ScopDetection *> &GW) {
+  static void
+  addCustomGraphFeatures(const ScopDetectionWrapperPass *SD,
+                         GraphWriter<ScopDetectionWrapperPass *> &GW) {
     raw_ostream &O = GW.getOStream();
     O << "\tcolorscheme = \"paired12\"\n";
-    printRegionCluster(SD, SD->getRI()->getTopLevelRegion(), O, 4);
+    printRegionCluster(&SD->getSD(), SD->getSD().getRI()->getTopLevelRegion(),
+                       O, 4);
   }
 };
 
 } // end namespace llvm
 
-struct ScopViewer : public DOTGraphTraitsViewer<ScopDetection, false> {
+struct ScopViewer
+    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, false> {
   static char ID;
-  ScopViewer() : DOTGraphTraitsViewer<ScopDetection, false>("scops", ID) {}
-  bool processFunction(Function &F, ScopDetection &SD) override {
+  ScopViewer()
+      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, false>("scops", ID) {}
+  bool processFunction(Function &F, ScopDetectionWrapperPass &SD) override {
     if (ViewFilter != "" && !F.getName().count(ViewFilter))
       return false;
 
     if (ViewAll)
       return true;
 
     // Check that at least one scop was detected.
-    return std::distance(SD.begin(), SD.end()) > 0;
+    return std::distance(SD.getSD().begin(), SD.getSD().end()) > 0;
   }
 };
 char ScopViewer::ID = 0;
 
-struct ScopOnlyViewer : public DOTGraphTraitsViewer<ScopDetection, true> {
+struct ScopOnlyViewer
+    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyViewer()
-      : DOTGraphTraitsViewer<ScopDetection, true>("scopsonly", ID) {}
+      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, true>("scopsonly", ID) {}
 };
 char ScopOnlyViewer::ID = 0;
 
-struct ScopPrinter : public DOTGraphTraitsPrinter<ScopDetection, false> {
+struct ScopPrinter
+    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false> {
   static char ID;
-  ScopPrinter() : DOTGraphTraitsPrinter<ScopDetection, false>("scops", ID) {}
+  ScopPrinter()
+      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false>("scops", ID) {}
 };
 char ScopPrinter::ID = 0;
 
-struct ScopOnlyPrinter : public DOTGraphTraitsPrinter<ScopDetection, true> {
+struct ScopOnlyPrinter
+    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyPrinter()
-      : DOTGraphTraitsPrinter<ScopDetection, true>("scopsonly", ID) {}
+      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true>("scopsonly", ID) {
+  }
 };
 char ScopOnlyPrinter::ID = 0;
 
 static RegisterPass<ScopViewer> X("view-scops",
                                   "Polly - View Scops of function");
 
 static RegisterPass<ScopOnlyViewer>
     Y("view-scops-only",

polly/trunk/lib/Analysis/ScopInfo.cpp

 }
 
 //===----------------------------------------------------------------------===//
 void ScopInfoRegionPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
-  AU.addRequiredTransitive<ScopDetection>();
+  AU.addRequiredTransitive<ScopDetectionWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<AssumptionCacheTracker>();
   AU.setPreservesAll();
 }
 
 void updateLoopCountStatistic(ScopDetection::LoopStats Stats) {
   NumLoopsInScop += Stats.NumLoops;
   MaxNumLoopsInScop =
else if (Stats.MaxDepth == 4)
     NumScopsDepthFour++;
   else if (Stats.MaxDepth == 5)
     NumScopsDepthFive++;
   else
     NumScopsDepthLarger++;
 }
 
 bool ScopInfoRegionPass::runOnRegion(Region *R, RGPassManager &RGM) {
-  auto &SD = getAnalysis<ScopDetection>();
+  auto &SD = getAnalysis<ScopDetectionWrapperPass>().getSD();
 
   if (!SD.isMaxRegionInScop(*R))
     return false;
 
   Function *F = R->getEntry()->getParent();
   auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();

 INITIALIZE_PASS_BEGIN(ScopInfoRegionPass, "polly-scops",
                       "Polly - Create polyhedral description of Scops", false,
                       false);
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_DEPENDENCY(ScopDetection);
+INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops",
                     "Polly - Create polyhedral description of Scops", false,
                     false)
 
 //===----------------------------------------------------------------------===//
 void ScopInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
-  AU.addRequiredTransitive<ScopDetection>();
+  AU.addRequiredTransitive<ScopDetectionWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<AssumptionCacheTracker>();
   AU.setPreservesAll();
 }
 
 bool ScopInfoWrapperPass::runOnFunction(Function &F) {
-  auto &SD = getAnalysis<ScopDetection>();
+  auto &SD = getAnalysis<ScopDetectionWrapperPass>().getSD();
 
   auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
   auto const &DL = F.getParent()->getDataLayout();
   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
 
INITIALIZE_PASS_BEGIN(
     ScopInfoWrapperPass, "polly-function-scops",
     "Polly - Create polyhedral description of all Scops of a function", false,
     false);
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_DEPENDENCY(ScopDetection);
+INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_END(
     ScopInfoWrapperPass, "polly-function-scops",
     "Polly - Create polyhedral description of all Scops of a function", false,
     false)

polly/trunk/lib/CodeGen/CodeGeneration.cpp

public:
   }
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<IslAstInfo>();
     AU.addRequired<RegionInfoPass>();
     AU.addRequired<ScalarEvolutionWrapperPass>();
-    AU.addRequired<ScopDetection>();
+    AU.addRequired<ScopDetectionWrapperPass>();
     AU.addRequired<ScopInfoRegionPass>();
     AU.addRequired<LoopInfoWrapperPass>();
 
     AU.addPreserved<DependenceInfo>();
 
     AU.addPreserved<AAResultsWrapperPass>();
     AU.addPreserved<BasicAAWrapperPass>();
     AU.addPreserved<LoopInfoWrapperPass>();
     AU.addPreserved<DominatorTreeWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
     AU.addPreserved<IslAstInfo>();
-    AU.addPreserved<ScopDetection>();
+    AU.addPreserved<ScopDetectionWrapperPass>();
     AU.addPreserved<ScalarEvolutionWrapperPass>();
     AU.addPreserved<SCEVAAWrapperPass>();
 
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
     AU.addPreserved<RegionInfoPass>();
     AU.addPreserved<ScopInfoRegionPass>();
   }
 };
 } // namespace
 
 char CodeGeneration::ID = 1;
 
 Pass *polly::createCodeGenerationPass() { return new CodeGeneration(); }
 
 INITIALIZE_PASS_BEGIN(CodeGeneration, "polly-codegen",
                       "Polly - Create LLVM-IR from SCoPs", false, false);
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_DEPENDENCY(ScopDetection);
+INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_END(CodeGeneration, "polly-codegen",
                     "Polly - Create LLVM-IR from SCoPs", false, false)

polly/trunk/lib/CodeGen/PPCGCodeGeneration.cpp

public:
   }
 
   void printScop(raw_ostream &, Scop &) const override {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<RegionInfoPass>();
     AU.addRequired<ScalarEvolutionWrapperPass>();
-    AU.addRequired<ScopDetection>();
+    AU.addRequired<ScopDetectionWrapperPass>();
     AU.addRequired<ScopInfoRegionPass>();
     AU.addRequired<LoopInfoWrapperPass>();
 
     AU.addPreserved<AAResultsWrapperPass>();
     AU.addPreserved<BasicAAWrapperPass>();
     AU.addPreserved<LoopInfoWrapperPass>();
     AU.addPreserved<DominatorTreeWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
-    AU.addPreserved<ScopDetection>();
+    AU.addPreserved<ScopDetectionWrapperPass>();
     AU.addPreserved<ScalarEvolutionWrapperPass>();
     AU.addPreserved<SCEVAAWrapperPass>();
 
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
     AU.addPreserved<RegionInfoPass>();
     AU.addPreserved<ScopInfoRegionPass>();
   }

 
 INITIALIZE_PASS_BEGIN(PPCGCodeGeneration, "polly-codegen-ppcg",
                       "Polly - Apply PPCG translation to SCOP", false, false)
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_DEPENDENCY(ScopDetection);
+INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_END(PPCGCodeGeneration, "polly-codegen-ppcg",
                     "Polly - Apply PPCG translation to SCOP", false, false)

polly/trunk/lib/Support/RegisterPasses.cpp

#endif
   initializeDependenceInfoPass(Registry);
   initializeDependenceInfoWrapperPassPass(Registry);
   initializeJSONExporterPass(Registry);
   initializeJSONImporterPass(Registry);
   initializeIslAstInfoPass(Registry);
   initializeIslScheduleOptimizerPass(Registry);
   initializePollyCanonicalizePass(Registry);
   initializePolyhedralInfoPass(Registry);
-  initializeScopDetectionPass(Registry);
+  initializeScopDetectionWrapperPassPass(Registry);
   initializeScopInfoRegionPassPass(Registry);
   initializeScopInfoWrapperPassPass(Registry);
   initializeCodegenCleanupPass(Registry);
   initializeFlattenSchedulePass(Registry);
   initializeDeLICMPass(Registry);
   initializeSimplifyPass(Registry);
   initializeDumpModulePass(Registry);
   initializePruneUnprofitablePass(Registry);

 ///
 /// Polly supports the isl internal code generator.
 void registerPollyPasses(llvm::legacy::PassManagerBase &PM) {
   if (DumpBefore)
     PM.add(polly::createDumpModulePass("-before", true));
   for (auto &Filename : DumpBeforeFile)
     PM.add(polly::createDumpModulePass(Filename, false));
 
-  PM.add(polly::createScopDetectionPass());
+  PM.add(polly::createScopDetectionWrapperPassPass());
 
   if (PollyDetectOnly)
     return;
 
   if (PollyViewer)
     PM.add(polly::createDOTViewerPass());
   if (PollyOnlyViewer)
     PM.add(polly::createDOTOnlyViewerPass());