[Polly][NewPM] Pull references to the legacy PM interface from utilities and helpers

[philip.pfaffe]

Summary

A couple of the utilities used to analyze or build IR make explicit use of the legacy PM on their interface, to access analysis results. This patch removes the legacy PM from the interface, and just passes the required results directly.

This shouldn't introduce any function changes, although the API technically allowed to obtain two different analysis results before, one passed by reference and one through the PM. I don't believe that was ever intended, however.

[grosser]

This is a great cleanup! Very nice! Please commit!

polly/trunk/include/polly/CodeGen/IslNodeBuilder.h

 ///                         SubtreeReferences structure.
 /// @param CreateScalarRefs Should the result include allocas of scalar
 ///                         references?
 isl_stat addReferencesFromStmt(const ScopStmt *Stmt, void *UserPtr,
                                bool CreateScalarRefs = true);
 
 class IslNodeBuilder {
 public:
-  IslNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator, Pass *P,
+  IslNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator,
                  const DataLayout &DL, LoopInfo &LI, ScalarEvolution &SE,
                  DominatorTree &DT, Scop &S, BasicBlock *StartBlock)
       : S(S), Builder(Builder), Annotator(Annotator),
         ExprBuilder(S, Builder, IDToValue, ValueMap, DL, SE, DT, LI,
                     StartBlock),
         BlockGen(Builder, LI, SE, DT, ScalarMap, EscapeMap, ValueMap,
                  &ExprBuilder, StartBlock),
-        RegionGen(BlockGen), P(P), DL(DL), LI(LI), SE(SE), DT(DT),
+        RegionGen(BlockGen), DL(DL), LI(LI), SE(SE), DT(DT),
         StartBlock(StartBlock) {}
 
   virtual ~IslNodeBuilder() = default;
 
   void addParameters(__isl_take isl_set *Context);
 
   /// Generate code that evaluates @p Condition at run-time.
   ///
protected:
   ///@}
 
   /// The generator used to copy a basic block.
   BlockGenerator BlockGen;
 
   /// The generator used to copy a non-affine region.
   RegionGenerator RegionGen;
 
-  Pass *const P;
   const DataLayout &DL;
   LoopInfo &LI;
   ScalarEvolution &SE;
   DominatorTree &DT;
   BasicBlock *StartBlock;
 
   /// The current iteration of out-of-scop loops
   ///

polly/trunk/include/polly/CodeGen/LoopGenerators.h

 /// @param Annotator  This function can (optionally) take a ScopAnnotator which
 ///                   annotates loops and alias information in the SCoP.
 /// @param Parallel   If this loop should be marked parallel in the Annotator.
 /// @param UseGuard   Create a guard in front of the header to check if the
 ///                   loop is executed at least once, otherwise just assume it.
 ///
 /// @return Value*    The newly created induction variable for this loop.
 Value *createLoop(Value *LowerBound, Value *UpperBound, Value *Stride,
-                  PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
-                  DominatorTree &DT, BasicBlock *&ExitBlock,
-                  ICmpInst::Predicate Predicate,
+                  PollyIRBuilder &Builder, LoopInfo &LI, DominatorTree &DT,
+                  BasicBlock *&ExitBlock, ICmpInst::Predicate Predicate,
                   ScopAnnotator *Annotator = NULL, bool Parallel = false,
                   bool UseGuard = true);
 
 /// The ParallelLoopGenerator allows to create parallelized loops
 ///
 /// To parallelize a loop, we perform the following steps:
 ///   o  Generate a subfunction which will hold the loop body.
 ///   o  Create a struct to hold all outer values needed in the loop body.

 ///         for (int j = 0; j < M; j++)
 ///           S1(i, j);
 ///     }
 ///     cleanup_thread();
 ///   }
 class ParallelLoopGenerator {
 public:
   /// Create a parallel loop generator for the current function.
-  ParallelLoopGenerator(PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
+  ParallelLoopGenerator(PollyIRBuilder &Builder, LoopInfo &LI,
                         DominatorTree &DT, const DataLayout &DL)
-      : Builder(Builder), P(P), LI(LI), DT(DT),
+      : Builder(Builder), LI(LI), DT(DT),
         LongType(
             Type::getIntNTy(Builder.getContext(), DL.getPointerSizeInBits())),
         M(Builder.GetInsertBlock()->getParent()->getParent()) {}
 
   /// Create a parallel loop.
   ///
   /// This function is the main function to automatically generate a parallel
   /// loop with all its components.
public:
   Value *createParallelLoop(Value *LB, Value *UB, Value *Stride,
                             SetVector<Value *> &Values, ValueMapT &VMap,
                             BasicBlock::iterator *LoopBody);
 
 private:
   /// The IR builder we use to create instructions.
   PollyIRBuilder &Builder;
 
-  /// A pass pointer to update analysis information.
-  Pass *P;
-
   /// The loop info of the current function we need to update.
   LoopInfo &LI;
 
   /// The dominance tree of the current function we need to update.
   DominatorTree &DT;
 
   /// The type of a "long" on this hardware used for backend calls.
   Type *LongType;

polly/trunk/include/polly/CodeGen/Utils.h

 
 #ifndef POLLY_CODEGEN_UTILS_H
 #define POLLY_CODEGEN_UTILS_H
 
 namespace llvm {
 class Pass;
 class Value;
 class BasicBlock;
+class DominatorTree;
+class RegionInfo;
+class LoopInfo;
 } // namespace llvm
 
 namespace polly {
 
 class Scop;
 
 /// Execute a Scop conditionally wrt @p RTC.
 ///

 ///                      \    /
 ///                        bb1 (joinBlock)
 ///
 /// @param S   The Scop to execute conditionally.
 /// @param P   A reference to the pass calling this function.
 /// @param RTC The runtime condition checked before executing the new SCoP.
 ///
 /// @return The 'StartBlock' to which new code can be added.
-llvm::BasicBlock *executeScopConditionally(Scop &S, llvm::Pass *P,
-                                           llvm::Value *RTC);
+llvm::BasicBlock *executeScopConditionally(Scop &S, llvm::Value *RTC,
+                                           llvm::DominatorTree &DT,
+                                           llvm::RegionInfo &RI,
+                                           llvm::LoopInfo &LI);
 } // namespace polly
 #endif

polly/trunk/lib/CodeGen/CodeGeneration.cpp

bool runOnScop(Scop &S) override {
 
     // Only build the run-time condition and parameters _after_ having
     // introduced the conditional branch. This is important as the conditional
     // branch will guard the original scop from new induction variables that
     // the SCEVExpander may introduce while code generating the parameters and
     // which may introduce scalar dependences that prevent us from correctly
     // code generating this scop.
     BasicBlock *StartBlock =
-        executeScopConditionally(S, this, Builder.getTrue());
+        executeScopConditionally(S, Builder.getTrue(), *DT, *RI, *LI);
     auto *SplitBlock = StartBlock->getSinglePredecessor();
 
-    IslNodeBuilder NodeBuilder(Builder, Annotator, this, *DL, *LI, *SE, *DT, S,
+    IslNodeBuilder NodeBuilder(Builder, Annotator, *DL, *LI, *SE, *DT, S,
                                StartBlock);
 
     if (PerfMonitoring) {
       PerfMonitor P(EnteringBB->getParent()->getParent());
       P.initialize();
       P.insertRegionStart(SplitBlock->getTerminator());
 
       BasicBlock *MergeBlock = SplitBlock->getTerminator()

polly/trunk/lib/CodeGen/IslNodeBuilder.cpp

if (MaxType != ValueUB->getType())
     ValueUB = Builder.CreateSExt(ValueUB, MaxType);
   if (MaxType != ValueInc->getType())
     ValueInc = Builder.CreateSExt(ValueInc, MaxType);
 
   // If we can show that LB <Predicate> UB holds at least once, we can
   // omit the GuardBB in front of the loop.
   bool UseGuardBB =
       !SE.isKnownPredicate(Predicate, SE.getSCEV(ValueLB), SE.getSCEV(ValueUB));
-  IV = createLoop(ValueLB, ValueUB, ValueInc, Builder, P, LI, DT, ExitBlock,
+  IV = createLoop(ValueLB, ValueUB, ValueInc, Builder, LI, DT, ExitBlock,
                   Predicate, &Annotator, Parallel, UseGuardBB);
   IDToValue[IteratorID] = IV;
 
   create(Body);
 
   Annotator.popLoop(Parallel);
 
   IDToValue.erase(IDToValue.find(IteratorID));
const SCEV *OuterLIV = SE.getAddRecExpr(SE.getUnknown(Builder.getInt64(0)),
                                             SE.getUnknown(Builder.getInt64(1)),
                                             L, SCEV::FlagAnyWrap);
     Value *V = generateSCEV(OuterLIV);
     OutsideLoopIterations[L] = SE.getUnknown(V);
     SubtreeValues.insert(V);
   }
 
   ValueMapT NewValues;
-  ParallelLoopGenerator ParallelLoopGen(Builder, P, LI, DT, DL);
+  ParallelLoopGenerator ParallelLoopGen(Builder, LI, DT, DL);
 
   IV = ParallelLoopGen.createParallelLoop(ValueLB, ValueUB, ValueInc,
                                           SubtreeValues, NewValues, &LoopBody);
   BasicBlock::iterator AfterLoop = Builder.GetInsertPoint();
   Builder.SetInsertPoint(&*LoopBody);
 
   // Remember the parallel subfunction
   ParallelSubfunctions.push_back(LoopBody->getFunction());

polly/trunk/lib/CodeGen/LoopGenerators.cpp

 //
 // depending on whether or not we know that it is executed at least once. If
 // not, GuardBB checks if the loop is executed at least once. If this is the
 // case we branch to PreHeaderBB and subsequently to the HeaderBB, which
 // contains the loop iv 'polly.indvar', the incremented loop iv
 // 'polly.indvar_next' as well as the condition to check if we execute another
 // iteration of the loop. After the loop has finished, we branch to ExitBB.
 Value *polly::createLoop(Value *LB, Value *UB, Value *Stride,
-                         PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
+                         PollyIRBuilder &Builder, LoopInfo &LI,
                          DominatorTree &DT, BasicBlock *&ExitBB,
                          ICmpInst::Predicate Predicate,
                          ScopAnnotator *Annotator, bool Parallel,
                          bool UseGuard) {
   Function *F = Builder.GetInsertBlock()->getParent();
   LLVMContext &Context = F->getContext();
 
   assert(LB->getType() == UB->getType() && "Types of loop bounds do not match");
Value *ParallelLoopGenerator::createSubFn(Value *Stride, AllocaInst *StructData,
 
   // Subtract one as the upper bound provided by openmp is a < comparison
   // whereas the codegenForSequential function creates a <= comparison.
   UB = Builder.CreateSub(UB, ConstantInt::get(LongType, 1),
                          "polly.par.UBAdjusted");
 
   Builder.CreateBr(CheckNextBB);
   Builder.SetInsertPoint(&*--Builder.GetInsertPoint());
-  IV = createLoop(LB, UB, Stride, Builder, P, LI, DT, AfterBB,
+  IV = createLoop(LB, UB, Stride, Builder, LI, DT, AfterBB,
                   ICmpInst::ICMP_SLE, nullptr, true, /* UseGuard */ false);
 
   BasicBlock::iterator LoopBody = Builder.GetInsertPoint();
 
   // Add code to terminate this subfunction.
   Builder.SetInsertPoint(ExitBB);
   createCallCleanupThread();
   Builder.CreateRetVoid();
 
   Builder.SetInsertPoint(&*LoopBody);
   *SubFnPtr = SubFn;
 
   return IV;
 }

polly/trunk/lib/CodeGen/PPCGCodeGeneration.cpp

 ///
 /// The GPUNodeBuilder augments the general existing IslNodeBuilder, which
 /// generates code for general-prupose AST nodes, with special functionality
 /// for generating GPU specific user nodes.
 ///
 /// @see GPUNodeBuilder::createUser
 class GPUNodeBuilder : public IslNodeBuilder {
 public:
-  GPUNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator, Pass *P,
+  GPUNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator,
                  const DataLayout &DL, LoopInfo &LI, ScalarEvolution &SE,
                  DominatorTree &DT, Scop &S, BasicBlock *StartBlock,
                  gpu_prog *Prog)
-      : IslNodeBuilder(Builder, Annotator, P, DL, LI, SE, DT, S, StartBlock),
+      : IslNodeBuilder(Builder, Annotator, DL, LI, SE, DT, S, StartBlock),
         Prog(Prog) {
     getExprBuilder().setIDToSAI(&IDToSAI);
   }
 
   /// Create after-run-time-check initialization code.
   void initializeAfterRTH();
 
   /// Finalize the generated scop.
void GPUNodeBuilder::createKernelFunction(ppcg_kernel *Kernel,
   GPUModule->setTargetTriple(Triple::normalize("nvptx64-nvidia-cuda"));
   GPUModule->setDataLayout(computeNVPTXDataLayout(true /* is64Bit */));
 
   Function *FN = createKernelFunctionDecl(Kernel, SubtreeValues);
 
   BasicBlock *PrevBlock = Builder.GetInsertBlock();
   auto EntryBlock = BasicBlock::Create(Builder.getContext(), "entry", FN);
 
-  DominatorTree &DT = P->getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   DT.addNewBlock(EntryBlock, PrevBlock);
 
   Builder.SetInsertPoint(EntryBlock);
   Builder.CreateRetVoid();
   Builder.SetInsertPoint(EntryBlock, EntryBlock->begin());
 
   ScopDetection::markFunctionAsInvalid(FN);
 
void generateCode(__isl_take isl_ast_node *Root, gpu_prog *Prog) {
 
     // Only build the run-time condition and parameters _after_ having
     // introduced the conditional branch. This is important as the conditional
     // branch will guard the original scop from new induction variables that
     // the SCEVExpander may introduce while code generating the parameters and
     // which may introduce scalar dependences that prevent us from correctly
     // code generating this scop.
     BasicBlock *StartBlock =
-        executeScopConditionally(*S, this, Builder.getTrue());
+        executeScopConditionally(*S, Builder.getTrue(), *DT, *RI, *LI);
 
-    GPUNodeBuilder NodeBuilder(Builder, Annotator, this, *DL, *LI, *SE, *DT, *S,
+    GPUNodeBuilder NodeBuilder(Builder, Annotator, *DL, *LI, *SE, *DT, *S,
                                StartBlock, Prog);
 
     // TODO: Handle LICM
     auto SplitBlock = StartBlock->getSinglePredecessor();
     Builder.SetInsertPoint(SplitBlock->getTerminator());
     NodeBuilder.addParameters(S->getContext());
 
     isl_ast_build *Build = isl_ast_build_alloc(S->getIslCtx());

polly/trunk/lib/CodeGen/Utils.cpp

static BasicBlock *splitEdge(BasicBlock *Prev, BasicBlock *Succ,
   //     |   ___      //
   //     |  /   \     //
   //    Succ     \    //
   //   /    \     \   //
 
   return MiddleBlock;
 }
 
-BasicBlock *polly::executeScopConditionally(Scop &S, Pass *P, Value *RTC) {
+BasicBlock *polly::executeScopConditionally(Scop &S, Value *RTC,
+                                            DominatorTree &DT, RegionInfo &RI,
+                                            LoopInfo &LI) {
   Region &R = S.getRegion();
   PollyIRBuilder Builder(S.getEntry());
-  DominatorTree &DT = P->getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  RegionInfo &RI = P->getAnalysis<RegionInfoPass>().getRegionInfo();
-  LoopInfo &LI = P->getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 
   // Before:
   //
   //      \   /      //
   //    EnteringBB   //
   //   _____|_____   //
   //  /  EntryBB  \  //
   //  |  (region) |  //