[Refactor] Do not carry LoopInfo along with a Scop.

[etherzhhb]

Summary

Make Scop become more portable such that we can use it in a CallGraphSCC pass.
The first step is to drop the analyses that are only used during Scop construction.
This patch drop LoopInfo from Scop.

[etherzhhb]

Pushed

include/polly/ScopInfo.h

public:
   /// @brief Vector of pair of minimal/maximal access vectors representing
   /// non read only and read only accesses for each alias group.
   using MinMaxVectorPairVectorTy = SmallVector<MinMaxVectorPairTy, 4>;
 
 private:
   Scop(const Scop &) = delete;
   const Scop &operator=(const Scop &) = delete;
 
-  LoopInfo &LI;
   ScalarEvolution *SE;
 
   /// The underlying Region.
   Region &R;
 
   // Access function of bbs.
   AccFuncMapType &AccFuncMap;
 
private:
   /// @brief Mapping from invariant loads to the representing invariant load of
   ///        their equivalence class.
   ValueToValueMap InvEquivClassVMap;
 
   /// @brief List of invariant accesses.
   InvariantEquivClassesTy InvariantEquivClasses;
 
   /// @brief Scop constructor; invoked from ScopInfo::buildScop.
-  Scop(Region &R, AccFuncMapType &AccFuncMap, ScalarEvolution &SE, LoopInfo &LI,
-       isl_ctx *ctx, unsigned MaxLoopDepth);
+  Scop(Region &R, AccFuncMapType &AccFuncMap, ScalarEvolution &SE, isl_ctx *ctx,
+       unsigned MaxLoopDepth);
 
   /// @brief Initialize this ScopInfo .
   void init(AliasAnalysis &AA, AssumptionCache &AC, ScopDetection &SD,
-            DominatorTree &DT);
+            DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Add loop carried constraints to the header block of the loop @p L.
   ///
   /// @param L  The loop to process.
-  void addLoopBoundsToHeaderDomain(Loop *L);
+  /// @param LI The LoopInfo for the current function.
+  void addLoopBoundsToHeaderDomain(Loop *L, LoopInfo &LI);
 
   /// @brief Compute the branching constraints for each basic block in @p R.
   ///
   /// @param R  The region we currently build branching conditions for.
   /// @param SD The ScopDetection analysis for the current function.
   /// @param DT The DominatorTree for the current function.
+  /// @param LI The LoopInfo for the current function.
   void buildDomainsWithBranchConstraints(Region *R, ScopDetection &SD,
-                                         DominatorTree &DT);
+                                         DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Propagate the domain constraints through the region @p R.
   ///
   /// @param R  The region we currently build branching conditions for.
   /// @param SD The ScopDetection analysis for the current function.
   /// @param DT The DominatorTree for the current function.
+  /// @param LI The LoopInfo for the current function.
   void propagateDomainConstraints(Region *R, ScopDetection &SD,
-                                  DominatorTree &DT);
+                                  DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Remove domains of error blocks/regions (and blocks dominated by
   ///        them).
   ///
   /// @param SD The ScopDetection analysis for the current function.
   /// @param DT The DominatorTree for the current function.
-  void removeErrorBlockDomains(ScopDetection &SD, DominatorTree &DT);
+  /// @param LI The LoopInfo for the current function.
+  void removeErrorBlockDomains(ScopDetection &SD, DominatorTree &DT,
+                               LoopInfo &LI);
 
   /// @brief Compute the domain for each basic block in @p R.
   ///
   /// @param R  The region we currently traverse.
   /// @param SD The ScopDetection analysis for the current function.
   /// @param DT The DominatorTree for the current function.
-  void buildDomains(Region *R, ScopDetection &SD, DominatorTree &DT);
+  /// @param LI The LoopInfo for the current function.
+  void buildDomains(Region *R, ScopDetection &SD, DominatorTree &DT,
+                    LoopInfo &LI);
 
   /// @brief Check if a region part should be represented in the SCoP or not.
   ///
   /// If @p RN does not contain any useful calculation or is only reachable
   /// via error blocks we do not model it in the polyhedral representation.
   ///
   /// @param RN The region part to check.
   /// @param DT The DominatorTree for the current function.
+  /// @param LI The LoopInfo for the current function.
   ///
   /// @return True if the part should be ignored, otherwise false.
-  bool isIgnored(RegionNode *RN, DominatorTree &DT);
+  bool isIgnored(RegionNode *RN, DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Add parameter constraints to @p C that imply a non-empty domain.
   __isl_give isl_set *addNonEmptyDomainConstraints(__isl_take isl_set *C) const;
 
   /// @brief Simplify the SCoP representation
   ///
   /// At the moment we perform the following simplifications:
   ///   - removal of no-op statements
   /// @param RemoveIgnoredStmts If true, also removed ignored statments.
   /// @see isIgnored()
-  void simplifySCoP(bool RemoveIgnoredStmts, DominatorTree &DT);
+  void simplifySCoP(bool RemoveIgnoredStmts, DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Create equivalence classes for required invariant accesses.
   ///
   /// These classes will consolidate multiple required invariant loads from the
   /// same address in order to keep the number of dimensions in the SCoP
   /// description small. For each such class equivalence class only one
   /// representing element, hence one required invariant load, will be chosen
   /// and modeled as parameter. The method
private:
 
   /// @brief Build the Context of the Scop.
   void buildContext();
 
   /// @brief Build the BoundaryContext based on the wrapping of expressions.
   void buildBoundaryContext();
 
   /// @brief Add user provided parameter constraints to context (source code).
-  void addUserAssumptions(AssumptionCache &AC, DominatorTree &DT);
+  void addUserAssumptions(AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI);
 
   /// @brief Add user provided parameter constraints to context (command line).
   void addUserContext();
 
   /// @brief Add the bounds of the parameters to the context.
   void addParameterBounds();
 
   /// @brief Simplify the assumed and boundary context.
private:
   /// may not have been recognized as separate dimensions. This function goes
   /// again over all memory accesses and updates their dimensionality to match
   /// the dimensionality of the underlying ScopArrayInfo object.
   void updateAccessDimensionality();
 
   /// @brief Construct the schedule of this SCoP.
   ///
   /// @param SD The ScopDetection analysis for the current function.
-  void buildSchedule(ScopDetection &SD);
+  /// @param LI The LoopInfo for the current function.
+  void buildSchedule(ScopDetection &SD, LoopInfo &LI);
 
   /// @brief A loop stack element to keep track of per-loop information during
   ///        schedule construction.
   typedef struct LoopStackElement {
     // The loop for which we keep information.
     Loop *L;
 
     // The (possibly incomplete) schedule for this loop.
private:
   /// Given a Region we derive schedule information for all RegionNodes
   /// contained in this region ensuring that the assigned execution times
   /// correctly model the existing control flow relations.
   ///
   /// @param R              The region which to process.
   /// @param LoopStack      A stack of loops that are currently under
   ///                       construction.
   /// @param SD The ScopDetection analysis for the current function.
-  void buildSchedule(Region *R, LoopStackTy &LoopStack, ScopDetection &SD);
+  /// @param LI The LoopInfo for the current function.
+  void buildSchedule(Region *R, LoopStackTy &LoopStack, ScopDetection &SD,
+                     LoopInfo &LI);
 
   /// @brief Build Schedule for the region node @p RN and add the derived
   ///        information to @p LoopStack.
   ///
   /// In case @p RN is a BasicBlock or a non-affine Region, we construct the
   /// schedule for this @p RN and also finalize loop schedules in case the
   /// current @p RN completes the loop.
   ///
   /// In case @p RN is a not-non-affine Region, we delegate the construction to
   /// buildSchedule(Region *R, ...).
   ///
   /// @param RN             The RegionNode region traversed.
   /// @param LoopStack      A stack of loops that are currently under
   ///                       construction.
   /// @param SD The ScopDetection analysis for the current function.
-  void buildSchedule(RegionNode *RN, LoopStackTy &LoopStack, ScopDetection &SD);
+  /// @param LI The LoopInfo for the current function.
+  void buildSchedule(RegionNode *RN, LoopStackTy &LoopStack, ScopDetection &SD,
+                     LoopInfo &LI);
 
   /// @brief Collect all memory access relations of a given type.
   ///
   /// @param Predicate A predicate function that returns true if an access is
   ///                  of a given type.
   ///
   /// @returns The set of memory accesses in the scop that match the predicate.
   __isl_give isl_union_map *

lib/Analysis/ScopInfo.cpp

void Scop::buildBoundaryContext() {
 
   isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
   isl_ctx_reset_operations(getIslCtx());
   isl_ctx_set_max_operations(getIslCtx(), MaxOpsOld);
   BoundaryContext = isl_set_gist_params(BoundaryContext, getContext());
   trackAssumption(WRAPPING, BoundaryContext, DebugLoc());
 }
 
-void Scop::addUserAssumptions(AssumptionCache &AC, DominatorTree &DT) {
+void Scop::addUserAssumptions(AssumptionCache &AC, DominatorTree &DT,
+                              LoopInfo &LI) {
   auto *R = &getRegion();
   auto &F = *R->getEntry()->getParent();
   for (auto &Assumption : AC.assumptions()) {
     auto *CI = dyn_cast_or_null<CallInst>(Assumption);
     if (!CI || CI->getNumArgOperands() != 1)
       continue;
     if (!DT.dominates(CI->getParent(), R->getEntry()))
       continue;
isl_set *Scop::getDomainConditions(ScopStmt *Stmt) {
   return getDomainConditions(BB);
 }
 
 isl_set *Scop::getDomainConditions(BasicBlock *BB) {
   assert(DomainMap.count(BB) && "Requested BB did not have a domain");
   return isl_set_copy(DomainMap[BB]);
 }
 
-void Scop::removeErrorBlockDomains(ScopDetection &SD, DominatorTree &DT) {
+void Scop::removeErrorBlockDomains(ScopDetection &SD, DominatorTree &DT,
+                                   LoopInfo &LI) {
   auto removeDomains = [this, &DT](BasicBlock *Start) {
     auto BBNode = DT.getNode(Start);
     for (auto ErrorChild : depth_first(BBNode)) {
       auto ErrorChildBlock = ErrorChild->getBlock();
       auto CurrentDomain = DomainMap[ErrorChildBlock];
       auto Empty = isl_set_empty(isl_set_get_space(CurrentDomain));
       DomainMap[ErrorChildBlock] = Empty;
       isl_set_free(CurrentDomain);
if (containsErrorBlock(SubRegion->getNode(), getRegion(), LI, DT))
       removeDomains(SubRegion->getEntry());
   }
 
   for (auto BB : R.blocks())
     if (isErrorBlock(*BB, R, LI, DT))
       removeDomains(BB);
 }
 
-void Scop::buildDomains(Region *R, ScopDetection &SD, DominatorTree &DT) {
+void Scop::buildDomains(Region *R, ScopDetection &SD, DominatorTree &DT,
+                        LoopInfo &LI) {
 
   bool IsOnlyNonAffineRegion = SD.isNonAffineSubRegion(R, R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
   int LD = getRelativeLoopDepth(L);
   auto *S = isl_set_universe(isl_space_set_alloc(getIslCtx(), 0, LD + 1));
 
   while (LD-- >= 0) {
     S = addDomainDimId(S, LD + 1, L);
     L = L->getParentLoop();
   }
 
   DomainMap[EntryBB] = S;
 
   if (IsOnlyNonAffineRegion)
     return;
 
-  buildDomainsWithBranchConstraints(R, SD, DT);
-  propagateDomainConstraints(R, SD, DT);
+  buildDomainsWithBranchConstraints(R, SD, DT, LI);
+  propagateDomainConstraints(R, SD, DT, LI);
 
   // Error blocks and blocks dominated by them have been assumed to never be
   // executed. Representing them in the Scop does not add any value. In fact,
   // it is likely to cause issues during construction of the ScopStmts. The
   // contents of error blocks have not been verfied to be expressible and
   // will cause problems when building up a ScopStmt for them.
   // Furthermore, basic blocks dominated by error blocks may reference
   // instructions in the error block which, if the error block is not modeled,
   // can themselves not be constructed properly.
-  removeErrorBlockDomains(SD, DT);
+  removeErrorBlockDomains(SD, DT, LI);
 }
 
 void Scop::buildDomainsWithBranchConstraints(Region *R, ScopDetection &SD,
-                                             DominatorTree &DT) {
+                                             DominatorTree &DT, LoopInfo &LI) {
   auto &BoxedLoops = *SD.getBoxedLoops(&getRegion());
 
   // To create the domain for each block in R we iterate over all blocks and
   // subregions in R and propagate the conditions under which the current region
   // element is executed. To this end we iterate in reverse post order over R as
   // it ensures that we first visit all predecessors of a region node (either a
   // basic block or a subregion) before we visit the region node itself.
   // Initially, only the domain for the SCoP region entry block is set and from
   // there we propagate the current domain to all successors, however we add the
   // condition that the successor is actually executed next.
   // As we are only interested in non-loop carried constraints here we can
   // simply skip loop back edges.
 
   ReversePostOrderTraversal<Region *> RTraversal(R);
   for (auto *RN : RTraversal) {
 
     // Recurse for affine subregions but go on for basic blocks and non-affine
     // subregions.
     if (RN->isSubRegion()) {
       Region *SubRegion = RN->getNodeAs<Region>();
       if (!SD.isNonAffineSubRegion(SubRegion, &getRegion())) {
-        buildDomainsWithBranchConstraints(SubRegion, SD, DT);
+        buildDomainsWithBranchConstraints(SubRegion, SD, DT, LI);
         continue;
       }
     }
 
     if (containsErrorBlock(RN, getRegion(), LI, DT))
       HasErrorBlock = true;
 
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
getDomainForBlock(BasicBlock *BB, DenseMap<BasicBlock *, isl_set *> &DomainMap,
 
   Region *R = RI.getRegionFor(BB);
   while (R->getEntry() == BB)
     R = R->getParent();
   return getDomainForBlock(R->getEntry(), DomainMap, RI);
 }
 
 void Scop::propagateDomainConstraints(Region *R, ScopDetection &SD,
-                                      DominatorTree &DT) {
+                                      DominatorTree &DT, LoopInfo &LI) {
   // Iterate over the region R and propagate the domain constrains from the
   // predecessors to the current node. In contrast to the
   // buildDomainsWithBranchConstraints function, this one will pull the domain
   // information from the predecessors instead of pushing it to the successors.
   // Additionally, we assume the domains to be already present in the domain
   // map here. However, we iterate again in reverse post order so we know all
   // predecessors have been visited before a block or non-affine subregion is
   // visited.
 
   // The set of boxed loops (loops in non-affine subregions) for this SCoP.
   auto &BoxedLoops = *SD.getBoxedLoops(&getRegion());
 
   ReversePostOrderTraversal<Region *> RTraversal(R);
   for (auto *RN : RTraversal) {
 
     // Recurse for affine subregions but go on for basic blocks and non-affine
     // subregions.
     if (RN->isSubRegion()) {
       Region *SubRegion = RN->getNodeAs<Region>();
       if (!SD.isNonAffineSubRegion(SubRegion, &getRegion())) {
-        propagateDomainConstraints(SubRegion, SD, DT);
+        propagateDomainConstraints(SubRegion, SD, DT, LI);
         continue;
       }
     }
 
     // Get the domain for the current block and check if it was initialized or
     // not. The only way it was not is if this block is only reachable via error
     // blocks, thus will not be executed under the assumptions we make. Such
     // blocks have to be skipped as their predecessors might not have domains
for (auto *PredBB : predecessors(BB)) {
 
       PredDom = isl_set_union(PredDom, PredBBDom);
     }
 
     // Under the union of all predecessor conditions we can reach this block.
     Domain = isl_set_coalesce(isl_set_intersect(Domain, PredDom));
 
     if (BBLoop && BBLoop->getHeader() == BB && getRegion().contains(BBLoop))
-      addLoopBoundsToHeaderDomain(BBLoop);
+      addLoopBoundsToHeaderDomain(BBLoop, LI);
 
     // Add assumptions for error blocks.
     if (containsErrorBlock(RN, getRegion(), LI, DT)) {
       IsOptimized = true;
       isl_set *DomPar = isl_set_params(isl_set_copy(Domain));
       addAssumption(ERRORBLOCK, isl_set_complement(DomPar),
                     BB->getTerminator()->getDebugLoc());
     }
createNextIterationMap(__isl_take isl_space *SetSpace, unsigned Dim) {
   auto *C = isl_constraint_alloc_equality(isl_local_space_from_space(MapSpace));
   C = isl_constraint_set_constant_si(C, 1);
   C = isl_constraint_set_coefficient_si(C, isl_dim_in, Dim, 1);
   C = isl_constraint_set_coefficient_si(C, isl_dim_out, Dim, -1);
   NextIterationMap = isl_map_add_constraint(NextIterationMap, C);
   return NextIterationMap;
 }
 
-void Scop::addLoopBoundsToHeaderDomain(Loop *L) {
+void Scop::addLoopBoundsToHeaderDomain(Loop *L, LoopInfo &LI) {
   int LoopDepth = getRelativeLoopDepth(L);
   assert(LoopDepth >= 0 && "Loop in region should have at least depth one");
 
   BasicBlock *HeaderBB = L->getHeader();
   assert(DomainMap.count(HeaderBB));
   isl_set *&HeaderBBDom = DomainMap[HeaderBB];
 
   isl_map *NextIterationMap =
static unsigned getMaxLoopDepthInRegion(const Region &R, LoopInfo &LI,
 
   assert(MinLD >= 1 && "Minimal loop depth should be at least one");
   assert(MaxLD >= MinLD &&
          "Maximal loop depth was smaller than mininaml loop depth?");
   return MaxLD - MinLD + 1;
 }
 
 Scop::Scop(Region &R, AccFuncMapType &AccFuncMap,
-           ScalarEvolution &ScalarEvolution, LoopInfo &LI, isl_ctx *Context,
+           ScalarEvolution &ScalarEvolution, isl_ctx *Context,
            unsigned MaxLoopDepth)
-    : LI(LI), SE(&ScalarEvolution), R(R), AccFuncMap(AccFuncMap),
-      IsOptimized(false), HasSingleExitEdge(R.getExitingBlock()),
-      HasErrorBlock(false), MaxLoopDepth(MaxLoopDepth), IslCtx(Context),
-      Context(nullptr), Affinator(this), AssumedContext(nullptr),
-      BoundaryContext(nullptr), Schedule(nullptr) {
+    : SE(&ScalarEvolution), R(R), AccFuncMap(AccFuncMap), IsOptimized(false),
+      HasSingleExitEdge(R.getExitingBlock()), HasErrorBlock(false),
+      MaxLoopDepth(MaxLoopDepth), IslCtx(Context), Context(nullptr),
+      Affinator(this), AssumedContext(nullptr), BoundaryContext(nullptr),
+      Schedule(nullptr) {
   buildContext();
 }
 
 void Scop::init(AliasAnalysis &AA, AssumptionCache &AC, ScopDetection &SD,
-                DominatorTree &DT) {
-  addUserAssumptions(AC, DT);
+                DominatorTree &DT, LoopInfo &LI) {
+  addUserAssumptions(AC, DT, LI);
   buildInvariantEquivalenceClasses(SD);
 
-  buildDomains(&R, SD, DT);
+  buildDomains(&R, SD, DT, LI);
 
   // Remove empty and ignored statements.
   // Exit early in case there are no executable statements left in this scop.
-  simplifySCoP(true, DT);
+  simplifySCoP(true, DT, LI);
   if (Stmts.empty())
     return;
 
   // The ScopStmts now have enough information to initialize themselves.
   for (ScopStmt &Stmt : Stmts)
     Stmt.init(SD);
 
-  buildSchedule(SD);
+  buildSchedule(SD, LI);
 
   if (isl_set_is_empty(AssumedContext))
     return;
 
   updateAccessDimensionality();
   realignParams();
   addParameterBounds();
   addUserContext();
   buildBoundaryContext();
   simplifyContexts();
   buildAliasChecks(AA);
 
   hoistInvariantLoads(SD);
-  simplifySCoP(false, DT);
+  simplifySCoP(false, DT, LI);
 }
 
 Scop::~Scop() {
   isl_set_free(Context);
   isl_set_free(AssumedContext);
   isl_set_free(BoundaryContext);
   isl_schedule_free(Schedule);
 

 }
 
 void Scop::updateAccessDimensionality() {
   for (auto &Stmt : *this)
     for (auto &Access : Stmt)
       Access->updateDimensionality();
 }
 
-void Scop::simplifySCoP(bool RemoveIgnoredStmts, DominatorTree &DT) {
+void Scop::simplifySCoP(bool RemoveIgnoredStmts, DominatorTree &DT,
+                        LoopInfo &LI) {
   for (auto StmtIt = Stmts.begin(), StmtEnd = Stmts.end(); StmtIt != StmtEnd;) {
     ScopStmt &Stmt = *StmtIt;
     RegionNode *RN = Stmt.isRegionStmt()
                          ? Stmt.getRegion()->getNode()
                          : getRegion().getBBNode(Stmt.getBasicBlock());
 
     bool RemoveStmt = StmtIt->isEmpty();
     if (!RemoveStmt)
       RemoveStmt = isl_set_is_empty(DomainMap[getRegionNodeBasicBlock(RN)]);
     if (!RemoveStmt)
-      RemoveStmt = (RemoveIgnoredStmts && isIgnored(RN, DT));
+      RemoveStmt = (RemoveIgnoredStmts && isIgnored(RN, DT, LI));
 
     // Remove read only statements only after invariant loop hoisting.
     if (!RemoveStmt && !RemoveIgnoredStmts) {
       bool OnlyRead = true;
       for (MemoryAccess *MA : Stmt) {
         if (MA->isRead())
           continue;
 
if (isl_union_set_is_empty(NewStmtDomain)) {
       Stmt.restrictDomain(isl_set_from_union_set(NewStmtDomain));
   }
   isl_union_set_free(Domain);
   return Changed;
 }
 
 ScalarEvolution *Scop::getSE() const { return SE; }
 
-bool Scop::isIgnored(RegionNode *RN, DominatorTree &DT) {
+bool Scop::isIgnored(RegionNode *RN, DominatorTree &DT, LoopInfo &LI) {
   BasicBlock *BB = getRegionNodeBasicBlock(RN);
   ScopStmt *Stmt = getStmtForRegionNode(RN);
 
   // If there is no stmt, then it already has been removed.
   if (!Stmt)
     return true;
 
   // Check if there are accesses contained.
if (BB) {
     assert(R && "Either basic block or a region expected.");
     Stmts.emplace_back(*this, *R);
     auto Stmt = &Stmts.back();
     for (BasicBlock *BB : R->blocks())
       StmtMap[BB] = Stmt;
   }
 }
 
-void Scop::buildSchedule(ScopDetection &SD) {
+void Scop::buildSchedule(ScopDetection &SD, LoopInfo &LI) {
   Loop *L = getLoopSurroundingRegion(getRegion(), LI);
   LoopStackTy LoopStack({LoopStackElementTy(L, nullptr, 0)});
-  buildSchedule(getRegion().getNode(), LoopStack, SD);
+  buildSchedule(getRegion().getNode(), LoopStack, SD, LI);
   assert(LoopStack.size() == 1 && LoopStack.back().L == L);
   Schedule = LoopStack[0].Schedule;
 }
 
 /// To generate a schedule for the elements in a Region we traverse the Region
 /// in reverse-post-order and add the contained RegionNodes in traversal order
 /// to the schedule of the loop that is currently at the top of the LoopStack.
 /// For loop-free codes, this results in a correct sequential ordering.

 /// from an empty schedule, we first process all RegionNodes that are within
 /// this loop and complete the sequential schedule at this loop-level before
 /// processing about any other nodes. To implement this
 /// loop-nodes-first-processing, the reverse post-order traversal is
 /// insufficient. Hence, we additionally check if the traversal yields
 /// sub-regions or blocks that are outside the last loop on the @p LoopStack.
 /// These region-nodes are then queue and only traverse after the all nodes
 /// within the current loop have been processed.
-void Scop::buildSchedule(Region *R, LoopStackTy &LoopStack, ScopDetection &SD) {
+void Scop::buildSchedule(Region *R, LoopStackTy &LoopStack, ScopDetection &SD,
+                         LoopInfo &LI) {
   Loop *OuterScopLoop = getLoopSurroundingRegion(getRegion(), LI);
 
   ReversePostOrderTraversal<Region *> RTraversal(R);
   std::deque<RegionNode *> WorkList(RTraversal.begin(), RTraversal.end());
   std::deque<RegionNode *> DelayList;
   bool LastRNWaiting = false;
 
   // Iterate over the region @p R in reverse post-order but queue
while (!WorkList.empty() || !DelayList.empty()) {
     if (LastLoop != L) {
       if (!LastLoop->contains(L)) {
         LastRNWaiting = true;
         DelayList.push_back(RN);
         continue;
       }
       LoopStack.push_back({L, nullptr, 0});
     }
-    buildSchedule(RN, LoopStack, SD);
+    buildSchedule(RN, LoopStack, SD, LI);
   }
 
   return;
 }
 
 void Scop::buildSchedule(RegionNode *RN, LoopStackTy &LoopStack,
-                         ScopDetection &SD) {
+                         ScopDetection &SD, LoopInfo &LI) {
 
   if (RN->isSubRegion()) {
     auto *LocalRegion = RN->getNodeAs<Region>();
     if (!SD.isNonAffineSubRegion(LocalRegion, &getRegion())) {
-      buildSchedule(LocalRegion, LoopStack, SD);
+      buildSchedule(LocalRegion, LoopStack, SD, LI);
       return;
     }
   }
 
   auto &LoopData = LoopStack.back();
   LoopData.NumBlocksProcessed += getNumBlocksInRegionNode(RN);
 
   if (auto *Stmt = getStmtForRegionNode(RN)) {

 void ScopInfo::addPHIReadAccess(PHINode *PHI) {
   addMemoryAccess(PHI->getParent(), PHI, MemoryAccess::READ, PHI, 1, true, PHI,
                   ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
                   ScopArrayInfo::MK_PHI);
 }
 
 void ScopInfo::buildScop(Region &R, AssumptionCache &AC) {
   unsigned MaxLoopDepth = getMaxLoopDepthInRegion(R, *LI, *SD);
-  scop = new Scop(R, AccFuncMap, *SE, *LI, ctx, MaxLoopDepth);
+  scop = new Scop(R, AccFuncMap, *SE, ctx, MaxLoopDepth);
 
   buildStmts(R, R);
   buildAccessFunctions(R, R);
 
   // In case the region does not have an exiting block we will later (during
   // code generation) split the exit block. This will move potential PHI nodes
   // from the current exit block into the new region exiting block. Hence, PHI
   // nodes that are at this point not part of the region will be.
   // To handle these PHI nodes later we will now model their operands as scalar
   // accesses. Note that we do not model anything in the exit block if we have
   // an exiting block in the region, as there will not be any splitting later.
   if (!R.getExitingBlock())
     buildAccessFunctions(R, *R.getExit(), nullptr, /* IsExitBlock */ true);
 
-  scop->init(*AA, AC, *SD, *DT);
+  scop->init(*AA, AC, *SD, *DT, *LI);
 }
 
 void ScopInfo::print(raw_ostream &OS, const Module *) const {
   if (!scop) {
     OS << "Invalid Scop!\n";
     return;
   }