[Polly][PM][WIP] Polly pass registration

[philip.pfaffe]

Summary

This patch is a first attempt at registering Polly passes with the LLVM tools. Tool plugins are still unsupported, but this registration is usable from the tools if Polly is linked into them (albeit requiring minimal patches to those tools). Registration requires a small amount of machinery (the owning analysis proxies), necessary for injecting ScopAnalysisManager objects into the calling tools.

This patch is marked WIP because the registration is incomplete. Parsing manual pipelines is fully supported, but default pass injection into the O3 pipeline is lacking, mostly because there is opportunity for some redesign here, I believe. The first point of order would be insertion points. I think it makes sense to run before the vectorizers. Running Polly Early, however, is weird. Mostly because it actually is the default (which to me is unexpected), and because Polly runs it's own O1 pipeline. Why not instead insert it at an appropriate place somewhere after simplification happend? Running after the loop optimizers seems intuitive, but it also seems wasteful, since multiple consecutive loops might well be a single scop, and we don't need to run for all of them.

My second request for comments would be regarding all those smallish helper passes we have, like PollyViewer, PollyPrinter, PollyImportJScop. Right now these are controlled by command line options, deciding whether they should be part of the Polly pipeline. What is your opinion on treating them like real passes, and have the user write an appropriate pipeline if they want to use any of them?

[grosser]

Hi Philip,

http://polly.llvm.org/docs/Architecture.html#polly-in-the-llvm-pass-pipeline discusses exactly why Polly is run at which position in the pass pipeline. We all seem to agree that the best position is to place it right before the vectorizer. We are just waiting for Michael's delicm to be finally enabled and upstreamed. We are very close, I believe. Maybe @Meinersbur can give an update on the timeline. Would it be possible to just take over the -polly-position command line option as we have it for the old pass manager. This will allow us to play with the different options.

Regarding the other small passes. The idea is that users can enable certain optimizations from the clang command line. E.g. our buildbots use commands such as 'clang -O3 -mllvm -polly -mllvm -polly-enable-simplify". The easiest way to add such options was for us to add/remove passes as needed. However, maybe there is a better design we could evolve towards?

Best,
Tobias

[grosser]

Mark this as "request changes" to move this out of my "to-review" queue.

[philip.pfaffe]

Hi Tobias,

I concur with your assessment regarding adding the passes via command line options. Will update the patch accordingly. Since none of the respective passes have been ported yet, that update might just be a TODO for the moment. Incremental progress and all :)

Some more thoughts regarding the appropriate extension points for Polly: The Early EP doesn't exist anymore. While I have an idea about getting something comparable back, we still should explore other options. I think the CGSCCOptimizerLateEPCallback could be worth consideration. It runs CGSCC passes right at the end of the module simplification pipeline. Another option could be ScalarLate. While that isn't exactly a full O1 (because that is a subset of O3, but not a true prefix) it could be close enough. Most importantly, it does include an InlinerPass. To get a good idea about the O pipelines, check out https://github.com/llvm-mirror/llvm/blob/master/test/Other/new-pm-defaults.ll. This test shows the complete order of passes in the O pipelines, as well as the positions of the individual extension points.
LoopLate seems to be a bad idea to me, I'd probably just skip this for now, and add it should the need arise.

[philip.pfaffe]

Here is what I meant with minimal changes required to the LLVM tools: https://github.com/llvm-mirror/clang/blob/master/tools/driver/cc1_main.cpp#L68
Things like clang, opt, and bugpoint need to call RegisterPollyPasses from this patch on the new-PM path just like they did initializePollyPasses for the legacy PM. Will follow up with patches.

[grosser]

Hi Philip,

I don't think CGSCCOptimizerLateEPCallback corresponds to what we have nowadays with Polly early. I think for experiments it would be helpful to have an EP that corresponds to the original 'early' point. For the actual uses in the future, I believe the before-vectorizer EP is indeed what we want.

Regarding the small calls to register Polly. I think they are very uncontroversial and can probably be committed quickly. Having pass registration working for external modules would be great, as this is what our buildbots are using. Looking forward for D35258 to become available.

[philip.pfaffe]

The Early and Late mechanisms aren't available. If we really (like, _really_) want to use them, I can submit another patch to the PassBuilder to add an equivalent mechanism back. The idea is having another callback that gets to wrap the entire pipeline. That's just one callback, but it's a lot more powerful than the EPs. In my eyes the urgency of this depends on the status of BeforeVectorizer usability.

[grosser]

It seems adding an "early" EP is not so easy. In this case, let's just leave it and start testing with DeLICM and co enabled. If they are not yet up-to what we need, we anyhow should report bugs. Feel free to commit this as soon as the prerequsites are in.

[philip.pfaffe]

Skeleton implementation for building the Polly pipeline. It's currently lacking the utilities available from the command line options. These should be added incrementally once someone took the time to port them over.

I've also ported the CodePreparation pass that takes care of splitting out the entry alloca block for the function.

[grosser]

That looks great so far.

[bollu]

A question from someone following this as an "outsider" with no context -
Does this allow others to obtain, say, Scop information (outside of polly) the way one can access DomTree / SCEV information?

If so, that would be really cool. If not, is that something that can be made possible? I'm just curious if this brings more flexible ways to use Polly.

[philip.pfaffe]

In D35458#812036, @bollu wrote:

A question from someone following this as an "outsider" with no context -
Does this allow others to obtain, say, Scop information (outside of polly) the way one can access DomTree / SCEV information?

Yes, this is absolutely possible. This works for Function-level analyses of course (e.g. ScopInfo), but also for Scop-level analyses. If the querying pass is itself a ScopPass, this Just Works. Any other pass type can access Scop-analyses through the ScopAnalysisManagerFunctionProxy, like this:

/* ... */ run(Function &F, FunctionAnalysisManager &FAM) {
  Scop &S = /*...*/;
  auto &SAM = FAM.getResult<ScopAnalysisManagerFunctionProxy>(F).getManager();
  auto &IA = SAM.getResult<IslAstAnalysis>(S);
}

[philip.pfaffe]

Small updates:

• Add the CodePreparation-Pass
• Accept empty Scop-Pipelines
• Add NotImplemented-assertions for the passes added via commandline options

[grosser]

Nice!

[philip.pfaffe]

Do not preserve RegionInfo in polly-prepare. This fixes PR33876 for the New-PM.
The bug is still there in the legacy PM, as it is a bug in RegionInfo itself.

Also includes a rebase.

polly/trunk/include/polly/CodePreparation.h

+#ifndef POLLY_CODEPREPARATION_H
+#define POLLY_CODEPREPARATION_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace polly {
+struct CodePreparationPass : public llvm::PassInfoMixin<CodePreparationPass> {
+  llvm::PreservedAnalyses run(llvm::Function &F,
+                              llvm::FunctionAnalysisManager &FAM);
+};
+}
+
+#endif /* POLLY_CODEPREPARATION_H */

polly/trunk/include/polly/ScopPass.h

public:
   bool invalidate(Function &F, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &Inv);
 
 private:
   ScopAnalysisManager *InnerAM;
   ScopInfo *SI;
 };
 
+// A partial specialization of the require analysis template pass to handle
+// extra parameters
+template <typename AnalysisT>
+struct RequireAnalysisPass<AnalysisT, Scop, ScopAnalysisManager,
+                           ScopStandardAnalysisResults &, SPMUpdater &>
+    : PassInfoMixin<
+          RequireAnalysisPass<AnalysisT, Scop, ScopAnalysisManager,
+                              ScopStandardAnalysisResults &, SPMUpdater &>> {
+  PreservedAnalyses run(Scop &L, ScopAnalysisManager &AM,
+                        ScopStandardAnalysisResults &AR, SPMUpdater &) {
+    (void)AM.template getResult<AnalysisT>(L, AR);
+    return PreservedAnalyses::all();
+  }
+};
+
 template <>
 InnerAnalysisManagerProxy<ScopAnalysisManager, Function>::Result
 InnerAnalysisManagerProxy<ScopAnalysisManager, Function>::run(
     Function &F, FunctionAnalysisManager &FAM);
 
 template <>
 PreservedAnalyses
 PassManager<Scop, ScopAnalysisManager, ScopStandardAnalysisResults &,
             SPMUpdater &>::run(Scop &InitialS, ScopAnalysisManager &AM,
                                ScopStandardAnalysisResults &, SPMUpdater &);
 extern template class PassManager<Scop, ScopAnalysisManager,
                                   ScopStandardAnalysisResults &, SPMUpdater &>;
 extern template class InnerAnalysisManagerProxy<ScopAnalysisManager, Function>;
 extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Scop,
                                                 ScopStandardAnalysisResults &>;
 } // namespace llvm
 
 namespace polly {
+
+template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
+class OwningInnerAnalysisManagerProxy
+    : public InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT> {
+public:
+  OwningInnerAnalysisManagerProxy()
+      : InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>(InnerAM) {}
+  using Result = typename InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT,
+                                                    ExtraArgTs...>::Result;
+  Result run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
+             ExtraArgTs...) {
+    return Result(InnerAM);
+  }
+
+  AnalysisManagerT &getManager() { return InnerAM; }
+
+private:
+  friend AnalysisInfoMixin<
+      OwningInnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
+
+  static AnalysisKey Key;
+
+  AnalysisManagerT InnerAM;
+};
+
+template <>
+OwningInnerAnalysisManagerProxy<ScopAnalysisManager, Function>::Result
+OwningInnerAnalysisManagerProxy<ScopAnalysisManager, Function>::run(
+    Function &F, FunctionAnalysisManager &FAM);
+extern template class OwningInnerAnalysisManagerProxy<ScopAnalysisManager,
+                                                      Function>;
+
+using OwningScopAnalysisManagerFunctionProxy =
+    OwningInnerAnalysisManagerProxy<ScopAnalysisManager, Function>;
 using ScopPassManager =
     PassManager<Scop, ScopAnalysisManager, ScopStandardAnalysisResults &,
                 SPMUpdater &>;
 
 /// ScopPass - This class adapts the RegionPass interface to allow convenient
 /// creation of passes that operate on the Polly IR. Instead of overriding
 /// runOnRegion, subclasses override runOnScop.
 class ScopPass : public RegionPass {

polly/trunk/include/polly/Support/ScopHelper.h

 /// Split the entry block of a function to store the newly inserted
 ///        allocations outside of all Scops.
 ///
 /// @param EntryBlock The entry block of the current function.
 /// @param P          The pass that currently running.
 ///
 void splitEntryBlockForAlloca(llvm::BasicBlock *EntryBlock, llvm::Pass *P);
 
+/// Split the entry block of a function to store the newly inserted
+///        allocations outside of all Scops.
+///
+/// @param DT DominatorTree to be updated.
+/// @param LI LoopInfo to be updated.
+/// @param RI RegionInfo to be updated.
+void splitEntryBlockForAlloca(llvm::BasicBlock *EntryBlock,
+                              llvm::DominatorTree *DT, llvm::LoopInfo *LI,
+                              llvm::RegionInfo *RI);
+
 /// Wrapper for SCEVExpander extended to all Polly features.
 ///
 /// This wrapper will internally call the SCEVExpander but also makes sure that
 /// all additional features not represented in SCEV (e.g., SDiv/SRem are not
 /// black boxes but can be part of the function) will be expanded correctly.
 ///
 /// The parameters are the same as for the creation of a SCEVExpander as well
 /// as the call to SCEVExpander::expandCodeFor:

polly/trunk/lib/Analysis/ScopPass.cpp

if (S)
     printScop(OS, *S);
 }
 
 void ScopPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<ScopInfoRegionPass>();
   AU.setPreservesAll();
 }
 
+template class OwningInnerAnalysisManagerProxy<ScopAnalysisManager, Function>;
+
 namespace llvm {
 
 template class PassManager<Scop, ScopAnalysisManager,
                            ScopStandardAnalysisResults &, SPMUpdater &>;
 template class InnerAnalysisManagerProxy<ScopAnalysisManager, Function>;
 template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Scop,
                                          ScopStandardAnalysisResults &>;
 
for (auto &S : *SI) {
     if (!allPreserved)
       InnerAM->invalidate(*scop, PA);
   }
 
   return false; // This proxy is still valid
 }
 
 template <>
+OwningScopAnalysisManagerFunctionProxy::Result
+OwningScopAnalysisManagerFunctionProxy::run(Function &F,
+                                            FunctionAnalysisManager &FAM) {
+  return Result(InnerAM, FAM.getResult<ScopInfoAnalysis>(F));
+}
+template <>
 ScopAnalysisManagerFunctionProxy::Result
 ScopAnalysisManagerFunctionProxy::run(Function &F,
                                       FunctionAnalysisManager &FAM) {
   return Result(*InnerAM, FAM.getResult<ScopInfoAnalysis>(F));
 }
 } // namespace llvm

polly/trunk/lib/Support/PollyPasses.def

+#ifndef FUNCTION_ANALYSIS
+#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
+#endif
+FUNCTION_ANALYSIS("polly-detect", ScopAnalysis())
+FUNCTION_ANALYSIS("polly-function-scops", ScopInfoAnalysis())
+#undef FUNCTION_ANALYSIS
+
+#ifndef FUNCTION_PASS
+#define FUNCTION_PASS(NAME, CREATE_PASS)
+#endif
+FUNCTION_PASS("polly-prepare", CodePreparationPass())
+FUNCTION_PASS("print<polly-detect>", ScopAnalysisPrinterPass(errs()))
+FUNCTION_PASS("print<polly-function-scops>", ScopInfoPrinterPass(errs()))
+#undef FUNCTION_PASS
+
+#ifndef SCOP_ANALYSIS
+#define SCOP_ANALYSIS(NAME, CREATE_PASS)
+#endif
+SCOP_ANALYSIS("polly-ast", IslAstAnalysis())
+SCOP_ANALYSIS("polly-dependences", DependenceAnalysis())
+#undef SCOP_ANALYSIS
+
+#ifndef SCOP_PASS
+#define SCOP_PASS(NAME, CREATE_PASS)
+#endif
+SCOP_PASS("print<polly-ast>", IslAstPrinterPass(outs()))
+SCOP_PASS("print<polly-dependences>", DependenceInfoPrinterPass(outs()))
+SCOP_PASS("polly-codegen", CodeGenerationPass())
+#undef SCOP_PASS

polly/trunk/lib/Support/RegisterPasses.cpp

 // changed, but that the flag '-polly' provided at optimization level '-O3'
 // enables additional polyhedral optimizations.
 //===----------------------------------------------------------------------===//
 
 #include "polly/RegisterPasses.h"
 #include "polly/Canonicalization.h"
 #include "polly/CodeGen/CodeGeneration.h"
 #include "polly/CodeGen/CodegenCleanup.h"
+#include "polly/CodeGen/IslAst.h"
 #include "polly/CodeGen/PPCGCodeGeneration.h"
+#include "polly/CodePreparation.h"
 #include "polly/DeLICM.h"
 #include "polly/DependenceInfo.h"
 #include "polly/FlattenSchedule.h"
 #include "polly/ForwardOpTree.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/PolyhedralInfo.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
 #include "polly/Simplify.h"
 #include "polly/Support/DumpModulePass.h"
 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Verifier.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Vectorize.h"
 
 using namespace llvm;
 using namespace polly;
registerPollyScalarOptimizerLatePasses(const llvm::PassManagerBuilder &Builder,
   if (PassPosition != POSITION_BEFORE_VECTORIZER)
     return;
 
   PM.add(polly::createCodePreparationPass());
   polly::registerPollyPasses(PM);
   PM.add(createCodegenCleanupPass());
 }
 
+static void buildDefaultPollyPipeline(FunctionPassManager &PM,
+                                      PassBuilder::OptimizationLevel Level) {
+  if (!polly::shouldEnablePolly())
+    return;
+  PassBuilder PB;
+  ScopPassManager SPM;
+
+  // TODO add utility passes for the various command line options, once they're
+  // ported
+  assert(!DumpBefore && "This option is not implemented");
+  assert(DumpBeforeFile.empty() && "This option is not implemented");
+
+  if (PollyDetectOnly)
+    return;
+
+  assert(!PollyViewer && "This option is not implemented");
+  assert(!PollyOnlyViewer && "This option is not implemented");
+  assert(!PollyPrinter && "This option is not implemented");
+  assert(!PollyOnlyPrinter && "This option is not implemented");
+  assert(!EnablePolyhedralInfo && "This option is not implemented");
+  assert(!EnableDeLICM && "This option is not implemented");
+  assert(!EnableSimplify && "This option is not implemented");
+  assert(!ImportJScop && "This option is not implemented");
+  assert(!DeadCodeElim && "This option is not implemented");
+  assert(!EnablePruneUnprofitable && "This option is not implemented");
+  if (Target == TARGET_CPU || Target == TARGET_HYBRID)
+    switch (Optimizer) {
+    case OPTIMIZER_NONE:
+      break; /* Do nothing */
+    case OPTIMIZER_ISL:
+      assert("ISL optimizer is not implemented");
+      break;
+    }
+
+  assert(!ExportJScop && "This option is not implemented");
+
+  if (Target == TARGET_CPU || Target == TARGET_HYBRID) {
+    switch (CodeGeneration) {
+    case CODEGEN_FULL:
+      SPM.addPass(polly::CodeGenerationPass());
+      break;
+    case CODEGEN_AST:
+    default: // Does it actually make sense to distinguish IslAst codegen?
+      break;
+    }
+  }
+#ifdef GPU_CODEGEN
+  else
+    assert("Hybrid Target with GPU support is not implemented");
+#endif
+
+  PM.addPass(CodePreparationPass());
+  PM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
+  PM.addPass(PB.buildFunctionSimplificationPipeline(
+      Level, PassBuilder::ThinLTOPhase::None)); // Cleanup
+
+  assert(!DumpAfter && "This option is not implemented");
+  assert(DumpAfterFile.empty() && "This option is not implemented");
+
+  if (CFGPrinter)
+    PM.addPass(llvm::CFGPrinterPass());
+}
+
 /// Register Polly to be available as an optimizer
 ///
 ///
 /// We can currently run Polly at three different points int the pass manager.
 /// a) very early, b) after the canonicalizing loop transformations and c) right
 /// before the vectorizer.
 ///
 /// The default is currently a), to register Polly such that it runs as early as

 
 static llvm::RegisterStandardPasses
     RegisterPollyOptimizerLoopEnd(llvm::PassManagerBuilder::EP_LoopOptimizerEnd,
                                   registerPollyLoopOptimizerEndPasses);
 
 static llvm::RegisterStandardPasses RegisterPollyOptimizerScalarLate(
     llvm::PassManagerBuilder::EP_VectorizerStart,
     registerPollyScalarOptimizerLatePasses);
+
+static OwningScopAnalysisManagerFunctionProxy
+createScopAnalyses(FunctionAnalysisManager &FAM) {
+  OwningScopAnalysisManagerFunctionProxy Proxy;
+#define SCOP_ANALYSIS(NAME, CREATE_PASS)                                       \
+  Proxy.getManager().registerPass([] { return CREATE_PASS; });
+
+#include "PollyPasses.def"
+
+  Proxy.getManager().registerPass(
+      [&FAM] { return FunctionAnalysisManagerScopProxy(FAM); });
+  return Proxy;
+}
+
+static void registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
+#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
+  FAM.registerPass([] { return CREATE_PASS; });
+
+#include "PollyPasses.def"
+
+  FAM.registerPass([&FAM] { return createScopAnalyses(FAM); });
+}
+
+static bool
+parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
+                      ArrayRef<PassBuilder::PipelineElement> Pipeline) {
+  if (parseAnalysisUtilityPasses<OwningScopAnalysisManagerFunctionProxy>(
+          "polly-scop-analyses", Name, FPM))
+    return true;
+
+#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
+  if (parseAnalysisUtilityPasses<                                              \
+          std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name,      \
+                                                              FPM))            \
+    return true;
+
+#define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
+  if (Name == NAME) {                                                          \
+    FPM.addPass(CREATE_PASS);                                                  \
+    return true;                                                               \
+  }
+
+#include "PollyPasses.def"
+  return false;
+}
+
+static bool parseScopPass(StringRef Name, ScopPassManager &SPM) {
+#define SCOP_ANALYSIS(NAME, CREATE_PASS)                                       \
+  if (parseAnalysisUtilityPasses<                                              \
+          std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name,      \
+                                                              SPM))            \
+    return true;
+
+#define SCOP_PASS(NAME, CREATE_PASS)                                           \
+  if (Name == NAME) {                                                          \
+    SPM.addPass(CREATE_PASS);                                                  \
+    return true;                                                               \
+  }
+
+#include "PollyPasses.def"
+
+  return false;
+}
+
+static bool parseScopPipeline(StringRef Name, FunctionPassManager &FPM,
+                              ArrayRef<PassBuilder::PipelineElement> Pipeline) {
+  if (Name != "scop")
+    return false;
+  if (!Pipeline.empty()) {
+    ScopPassManager SPM;
+    for (const auto &E : Pipeline)
+      if (!parseScopPass(E.Name, SPM))
+        return false;
+    FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
+  }
+  return true;
+}
+
+static bool isScopPassName(StringRef Name) {
+#define SCOP_ANALYSIS(NAME, CREATE_PASS)                                       \
+  if (Name == "require<" NAME ">")                                             \
+    return true;                                                               \
+  if (Name == "invalidate<" NAME ">")                                          \
+    return true;
+
+#define SCOP_PASS(NAME, CREATE_PASS)                                           \
+  if (Name == NAME)                                                            \
+    return true;
+
+#include "PollyPasses.def"
+
+  return false;
+}
+
+static bool
+parseTopLevelPipeline(ModulePassManager &MPM,
+                      ArrayRef<PassBuilder::PipelineElement> Pipeline,
+                      bool VerifyEachPass, bool DebugLogging) {
+  std::vector<PassBuilder::PipelineElement> FullPipeline;
+  StringRef FirstName = Pipeline.front().Name;
+
+  if (!isScopPassName(FirstName))
+    return false;
+
+  FunctionPassManager FPM(DebugLogging);
+  ScopPassManager SPM(DebugLogging);
+
+  for (auto &Element : Pipeline) {
+    auto &Name = Element.Name;
+    auto &InnerPipeline = Element.InnerPipeline;
+    if (!InnerPipeline.empty()) // Scop passes don't have inner pipelines
+      return false;
+    if (!parseScopPass(Name, SPM))
+      return false;
+  }
+
+  FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
+  if (VerifyEachPass)
+    FPM.addPass(VerifierPass());
+  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+  if (VerifyEachPass)
+    MPM.addPass(VerifierPass());
+
+  return true;
+}
+
+void RegisterPollyPasses(PassBuilder &PB) {
+  PB.registerAnalysisRegistrationCallback(registerFunctionAnalyses);
+  PB.registerPipelineParsingCallback(parseFunctionPipeline);
+  PB.registerPipelineParsingCallback(parseScopPipeline);
+  PB.registerParseTopLevelPipelineCallback(parseTopLevelPipeline);
+
+  if (PassPosition == POSITION_BEFORE_VECTORIZER)
+    PB.registerVectorizerStartEPCallback(buildDefaultPollyPipeline);
+  // FIXME else Error?
+}
 } // namespace polly

polly/trunk/lib/Support/ScopHelper.cpp

static BasicBlock *splitBlock(BasicBlock *Old, Instruction *SplitPt,
   //    Old     //
   //     |      //
   //  NewBlock  //
   //   /   \    //
 
   return NewBlock;
 }
 
-void polly::splitEntryBlockForAlloca(BasicBlock *EntryBlock, Pass *P) {
+void polly::splitEntryBlockForAlloca(BasicBlock *EntryBlock, DominatorTree *DT,
+                                     LoopInfo *LI, RegionInfo *RI) {
   // Find first non-alloca instruction. Every basic block has a non-alloca
   // instruction, as every well formed basic block has a terminator.
   BasicBlock::iterator I = EntryBlock->begin();
   while (isa<AllocaInst>(I))
     ++I;
 
+  // splitBlock updates DT, LI and RI.
+  splitBlock(EntryBlock, &*I, DT, LI, RI);
+}
+
+void polly::splitEntryBlockForAlloca(BasicBlock *EntryBlock, Pass *P) {
   auto *DTWP = P->getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
   auto *LIWP = P->getAnalysisIfAvailable<LoopInfoWrapperPass>();
   auto *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
   RegionInfoPass *RIP = P->getAnalysisIfAvailable<RegionInfoPass>();
   RegionInfo *RI = RIP ? &RIP->getRegionInfo() : nullptr;
 
   // splitBlock updates DT, LI and RI.
-  splitBlock(EntryBlock, &*I, DT, LI, RI);
+  polly::splitEntryBlockForAlloca(EntryBlock, DT, LI, RI);
 }
 
 /// The SCEVExpander will __not__ generate any code for an existing SDiv/SRem
 /// instruction but just use it, if it is referenced as a SCEVUnknown. We want
 /// however to generate new code if the instruction is in the analyzed region
 /// and we generate code outside/in front of that region. Hence, we generate the
 /// code for the SDiv/SRem operands in front of the analyzed region and then
 /// create a new SDiv/SRem operation there too.

polly/trunk/lib/Transform/CodePreparation.cpp

 // currently only splits the entry block of the SCoP to make room for alloc
 // instructions as they are generated during code generation.
 //
 // XXX: In the future, we should remove the need for this pass entirely and
 // instead add this spitting to the code generation pass.
 //
 //===----------------------------------------------------------------------===//
 
+#include "polly/CodePreparation.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/ScopDetection.h"
 #include "polly/Support/ScopHelper.h"
 #include "llvm/Analysis/DominanceFrontier.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Transforms/Utils/Local.h"
public:
   virtual void getAnalysisUsage(AnalysisUsage &AU) const;
   virtual void releaseMemory();
   virtual bool runOnFunction(Function &F);
   virtual void print(raw_ostream &OS, const Module *) const;
   //@}
 };
 } // namespace
 
+PreservedAnalyses CodePreparationPass::run(Function &F,
+                                           FunctionAnalysisManager &FAM) {
+
+  // Find first non-alloca instruction. Every basic block has a non-alloca
+  // instruction, as every well formed basic block has a terminator.
+  auto &EntryBlock = F.getEntryBlock();
+  BasicBlock::iterator I = EntryBlock.begin();
+  while (isa<AllocaInst>(I))
+    ++I;
+
+  auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
+  auto &LI = FAM.getResult<LoopAnalysis>(F);
+
+  // splitBlock updates DT, LI and RI.
+  splitEntryBlockForAlloca(&EntryBlock, &DT, &LI, nullptr);
+
+  PreservedAnalyses PA;
+  PA.preserve<DominatorTreeAnalysis>();
+  PA.preserve<LoopAnalysis>();
+  return PA;
+}
+
 void CodePreparation::clear() {}
 
 CodePreparation::~CodePreparation() { clear(); }
 
 void CodePreparation::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<ScalarEvolutionWrapperPass>();