[Polly] Merge TempScop into Scop

[Meinersbur]

Summary

TempScop is basically a holder for AccFuncMap, the dictionary from BasicBlocks to IRAccess lists. We move the list into polly::Scop and remove the polly::TempScop class.

There is one small change in behavior: If ScopInfo finds that its AssumedContext is impossible, it bails out by deleting the Scop object. The TempScop::print (invoked with opt -polly-scops -analyze) cannot print the AccFuncMap anymore as it would with a separate TempScop.

[grosser]

LGTM.

[Meinersbur]

rebase to r247470

include/polly/ScopInfo.h

 struct isl_schedule;
 
 namespace polly {
 
 class IRAccess;
 class Scop;
 class ScopStmt;
 class ScopInfo;
-class TempScop;
 class Comparison;
 class SCEVAffFunc;
 
 class Comparison {
   const SCEV *LHS;
   const SCEV *RHS;
 
   ICmpInst::Predicate Pred;

 public:
   /// @brief List to hold all (scalar) memory accesses mapped to an instruction.
   using MemoryAccessList = std::forward_list<MemoryAccess>;
 
   ScopStmt(const ScopStmt &) = delete;
   const ScopStmt &operator=(const ScopStmt &) = delete;
 
   /// Create the ScopStmt from a BasicBlock.
-  ScopStmt(Scop &parent, TempScop &tempScop, BasicBlock &bb);
+  ScopStmt(Scop &parent, BasicBlock &bb);
 
   /// Create an overapproximating ScopStmt for the region @p R.
-  ScopStmt(Scop &parent, TempScop &tempScop, Region &R);
+  ScopStmt(Scop &parent, Region &R);
 
 private:
   /// Polyhedral description
   //@{
 
   /// The Scop containing this ScopStmt
   Scop &Parent;
 
private:
   //@{
   void buildDomain();
 
   /// @brief Fill NestLoops with loops surrounding this statement.
   void collectSurroundingLoops();
 
   /// @brief Create the accesses for instructions in @p Block.
   ///
-  /// @param tempScop       The template SCoP.
   /// @param Block          The basic block for which accesses should be
   ///                       created.
   /// @param isApproximated Flag to indicate blocks that might not be executed,
   ///                       hence for which write accesses need to be modeled as
   ///                       may-write accesses.
-  void buildAccesses(TempScop &tempScop, BasicBlock *Block,
-                     bool isApproximated = false);
+  void buildAccesses(BasicBlock *Block, bool isApproximated = false);
 
   /// @brief Detect and mark reductions in the ScopStmt
   void checkForReductions();
 
   /// @brief Collect loads which might form a reduction chain with @p StoreMA
   void
   collectCandiateReductionLoads(MemoryAccess *StoreMA,
                                 llvm::SmallVectorImpl<MemoryAccess *> &Loads);
private:
   const Scop &operator=(const Scop &) = delete;
 
   DominatorTree &DT;
   ScalarEvolution *SE;
 
   /// The underlying Region.
   Region &R;
 
+  // Access function of bbs.
+  AccFuncMapType &AccFuncMap;
+
   /// Flag to indicate that the scheduler actually optimized the SCoP.
   bool IsOptimized;
 
   /// @brief True if the underlying region has a single exiting block.
   bool HasSingleExitEdge;
 
   /// Max loop depth.
   unsigned MaxLoopDepth;
private:
   /// In a program with int and float pointers annotated with tbaa information
   /// we would probably generate two alias groups, one for the int pointers and
   /// one for the float pointers.
   ///
   /// During code generation we will create a runtime alias check for each alias
   /// group to ensure the SCoP is executed in an alias free environment.
   MinMaxVectorPairVectorTy MinMaxAliasGroups;
 
-  /// @brief Scop constructor; used by static createFromTempScop
-  Scop(Region &R, ScalarEvolution &SE, DominatorTree &DT, isl_ctx *ctx,
-       unsigned MaxLoopDepth);
-
-  /// @brief Initialize this ScopInfo using a TempScop object.
-  void initFromTempScop(TempScop &TempScop, LoopInfo &LI, ScopDetection &SD,
-                        AliasAnalysis &AA);
-
-  /// Create the static control part with a region, max loop depth of this
-  /// region and parameters used in this region.
-  static Scop *createFromTempScop(TempScop &TempScop, LoopInfo &LI,
-                                  ScalarEvolution &SE, ScopDetection &SD,
-                                  AliasAnalysis &AA, DominatorTree &DT,
-                                  isl_ctx *ctx);
+  /// @brief Scop constructor; invoked from ScopInfo::buildScop.
+  Scop(Region &R, AccFuncMapType &AccFuncMap, ScalarEvolution &SE,
+       DominatorTree &DT, isl_ctx *ctx, unsigned MaxLoopDepth);
+
+  /// @brief Initialize this ScopInfo .
+  void init(LoopInfo &LI, ScopDetection &SD, AliasAnalysis &AA);
 
   /// @brief Add loop carried constraints to the header blocks of loops.
   ///
   /// @param LI The LoopInfo analysis.
   /// @param SD The ScopDetection analysis to identify non-affine sub-regions.
   /// @param DT The dominator tree of the current function.
   void addLoopBoundsToHeaderDomains(LoopInfo &LI, ScopDetection &SD,
                                     DominatorTree &DT);
void buildDomains(Region *R, LoopInfo &LI, ScopDetection &SD,
                     DominatorTree &DT);
 
   /// @brief Check if a basic block is trivial.
   ///
   /// A trivial basic block does not contain any useful calculation. Therefore,
   /// it does not need to be represented as a polyhedral statement.
   ///
   /// @param BB The basic block to check
-  /// @param tempScop TempScop returning further information regarding the Scop.
   ///
   /// @return True if the basic block is trivial, otherwise false.
-  static bool isTrivialBB(BasicBlock *BB, TempScop &tempScop);
+  bool isTrivialBB(BasicBlock *BB);
 
   /// @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 Build the Context of the Scop.
   void buildContext();
 
   /// @brief Add user provided parameter constraints to context.
   void addUserContext();
 
   /// @brief Add the bounds of the parameters to the context.
   void addParameterBounds();
 
   /// @brief Simplify the assumed context.
   void simplifyAssumedContext();
 
   /// @brief Create a new SCoP statement for either @p BB or @p R.
   ///
   /// Either @p BB or @p R should be non-null. A new statement for the non-null
   /// argument will be created and added to the statement vector and map.
   ///
   /// @param BB         The basic block we build the statement for (or null)
   /// @param R          The region we build the statement for (or null).
-  /// @param tempScop   The temp SCoP we use as model.
-  ScopStmt *addScopStmt(BasicBlock *BB, Region *R, TempScop &tempScop);
+  ScopStmt *addScopStmt(BasicBlock *BB, Region *R);
 
-  /// @brief Build Schedule and ScopStmts from a given TempScop.
+  /// @brief Build Schedule and ScopStmts.
   ///
   /// @param R  The current region traversed.
-  /// @param TS The temporary scop that is translated into an actual scop.
   /// @param LI The LoopInfo object.
   /// @param SD The ScopDetection object.
   void buildSchedule(
-      Region *R, TempScop &TS, LoopInfo &LI, ScopDetection &SD,
+      Region *R, LoopInfo &LI, ScopDetection &SD,
       DenseMap<Loop *, std::pair<isl_schedule *, unsigned>> &LoopSchedules);
 
   /// @name Helper function for printing the Scop.
   ///
   ///{
   void printContext(raw_ostream &OS) const;
   void printArrayInfo(raw_ostream &OS) const;
   void printStatements(raw_ostream &OS) const;
   void printAliasAssumptions(raw_ostream &OS) const;
   ///}
 
   friend class ScopInfo;
 
 public:
   ~Scop();
 
+  /// @brief Get all access functions in a BasicBlock
+  ///
+  /// @param  BB The BasicBlock that containing the access functions.
+  ///
+  /// @return All access functions in BB
+  ///
+  AccFuncSetType *getAccessFunctions(const BasicBlock *BB) {
+    AccFuncMapType::iterator at = AccFuncMap.find(BB);
+    return at != AccFuncMap.end() ? &(at->second) : 0;
+  }
+  //@}
+
+  /// @brief Print data access information.
+  ///
+  /// @param OS The output stream the access functions is printed to.
+  /// @param SE The ScalarEvolution to help printing more details.
+  /// @param LI The LoopInfo that help printing the access functions.
+  void printIRAccesses(raw_ostream &OS, ScalarEvolution *SE,
+                       LoopInfo *LI) const;
+
+  /// @brief Print the access functions and loop bounds in this Scop.
+  ///
+  /// @param OS The output stream the access functions is printed to.
+  /// @param SE The ScalarEvolution that help printing the access functions.
+  /// @param LI The LoopInfo that help printing the access functions.
+  void printIRAccessesDetail(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI,
+                             const Region *Reg, unsigned ind) const;
+
   ScalarEvolution *getSE() const;
 
   /// @brief Get the count of parameters used in this Scop.
   ///
   /// @return The count of parameters used in this Scop.
   inline ParamVecType::size_type getNumParams() const {
     return Parameters.size();
   }

 };
 
 /// @brief Print Scop scop to raw_ostream O.
 static inline raw_ostream &operator<<(raw_ostream &O, const Scop &scop) {
   scop.print(O);
   return O;
 }
 
-//===---------------------------------------------------------------------===//
-/// @brief Scop represent with llvm objects.
-///
-/// A helper class for remembering the parameter number and the max depth in
-/// this Scop, and others context.
-class TempScop {
-  // The Region.
-  Region &R;
-
-  // Access function of bbs.
-  AccFuncMapType &AccFuncMap;
-
-  friend class ScopInfo;
-
-  explicit TempScop(Region &r, AccFuncMapType &accFuncMap)
-      : R(r), AccFuncMap(accFuncMap) {}
-
-public:
-  ~TempScop();
-
-  /// @brief Get the maximum Region contained by this Scop.
-  ///
-  /// @return The maximum Region contained by this Scop.
-  Region &getMaxRegion() const { return R; }
-
-  /// @brief Get all access functions in a BasicBlock
-  ///
-  /// @param  BB The BasicBlock that containing the access functions.
-  ///
-  /// @return All access functions in BB
-  ///
-  AccFuncSetType *getAccessFunctions(const BasicBlock *BB) {
-    AccFuncMapType::iterator at = AccFuncMap.find(BB);
-    return at != AccFuncMap.end() ? &(at->second) : 0;
-  }
-  //@}
-
-  /// @brief Print the Temporary Scop information.
-  ///
-  /// @param OS The output stream the access functions is printed to.
-  /// @param SE The ScalarEvolution that help printing Temporary Scop
-  ///           information.
-  /// @param LI The LoopInfo that help printing the access functions.
-  void print(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI) const;
-
-  /// @brief Print the access functions and loop bounds in this Scop.
-  ///
-  /// @param OS The output stream the access functions is printed to.
-  /// @param SE The ScalarEvolution that help printing the access functions.
-  /// @param LI The LoopInfo that help printing the access functions.
-  void printDetail(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI,
-                   const Region *Reg, unsigned ind) const;
-};
-
-typedef std::map<const Region *, TempScop *> TempScopMapType;
-
 ///===---------------------------------------------------------------------===//
 /// @brief Build the Polly IR (Scop and ScopStmt) on a Region.
 ///
 class ScopInfo : public RegionPass {
   //===-------------------------------------------------------------------===//
   ScopInfo(const ScopInfo &) = delete;
   const ScopInfo &operator=(const ScopInfo &) = delete;
 
class ScopInfo : public RegionPass {
 
   // Access function of statements (currently BasicBlocks) .
   AccFuncMapType AccFuncMap;
 
   // Pre-created zero for the scalar accesses, with it we do not need create a
   // zero scev every time when we need it.
   const SCEV *ZeroOffset;
 
-  // The TempScop for this region.
-  TempScop *TempScopOfRegion;
-
   // The Scop
   Scop *scop;
   isl_ctx *ctx;
 
   // Clear the context.
   void clear();
 
-  // Build the temporary information of Region R, where R must be a valid part
-  // of Scop.
-  TempScop *buildTempScop(Region &R);
+  // Build the SCoP for Region @p R.
+  Scop *buildScop(Region &R, DominatorTree &DT);
 
   /// @brief Build an instance of IRAccess from the Load/Store instruction.
   ///
   /// @param Inst       The Load/Store instruction that access the memory
   /// @param L          The parent loop of the instruction
-  /// @param R          The region on which we are going to build a TempScop
+  /// @param R          The region on which to build the data access dictionary.
   /// @param BoxedLoops The set of loops that are overapproximated in @p R.
   ///
   /// @return     The IRAccess to describe the access function of the
   ///             instruction.
   IRAccess buildIRAccess(Instruction *Inst, Loop *L, Region *R,
                          const ScopDetection::BoxedLoopsSetTy *BoxedLoops);
 
   /// @brief Analyze and extract the cross-BB scalar dependences (or,
void buildAccessFunctions(Region &R, BasicBlock &BB,
                             Region *NonAffineSubRegion = nullptr,
                             bool IsExitBlock = false);
 
 public:
   static char ID;
   explicit ScopInfo();
   ~ScopInfo();
 
-  /// @brief Get the temporay Scop information in LLVM IR for this region.
-  ///
-  /// @return The Scop information in LLVM IR represent.
-  TempScop *getTempScop() const;
-
   /// @brief Try to build the Polly IR of static control part on the current
   ///        SESE-Region.
   ///
   /// @return If the current region is a valid for a static control part,
   ///         return the Polly IR representing this static control part,
   ///         return null otherwise.
   Scop *getScop() { return scop; }
   const Scop *getScop() const { return scop; }

lib/Analysis/ScopInfo.cpp

 
 void ScopStmt::restrictDomain(__isl_take isl_set *NewDomain) {
   assert(isl_set_is_subset(NewDomain, Domain) &&
          "New domain is not a subset of old domain!");
   isl_set_free(Domain);
   Domain = NewDomain;
 }
 
-void ScopStmt::buildAccesses(TempScop &tempScop, BasicBlock *Block,
-                             bool isApproximated) {
-  AccFuncSetType *AFS = tempScop.getAccessFunctions(Block);
+void ScopStmt::buildAccesses(BasicBlock *Block, bool isApproximated) {
+  AccFuncSetType *AFS = Parent.getAccessFunctions(Block);
   if (!AFS)
     return;
 
   for (auto &AccessPair : *AFS) {
     IRAccess &Access = AccessPair.first;
     Instruction *AccessInst = AccessPair.second;
     Type *ElementType = Access.getAccessValue()->getType();
 

 void ScopStmt::collectSurroundingLoops() {
   for (unsigned u = 0, e = isl_set_n_dim(Domain); u < e; u++) {
     isl_id *DimId = isl_set_get_dim_id(Domain, isl_dim_set, u);
     NestLoops.push_back(static_cast<Loop *>(isl_id_get_user(DimId)));
     isl_id_free(DimId);
   }
 }
 
-ScopStmt::ScopStmt(Scop &parent, TempScop &tempScop, Region &R)
+ScopStmt::ScopStmt(Scop &parent, Region &R)
     : Parent(parent), BB(nullptr), R(&R), Build(nullptr) {
 
   BaseName = getIslCompatibleName("Stmt_", R.getNameStr(), "");
 
   buildDomain();
   collectSurroundingLoops();
 
   BasicBlock *EntryBB = R.getEntry();
   for (BasicBlock *Block : R.blocks()) {
-    buildAccesses(tempScop, Block, Block != EntryBB);
+    buildAccesses(Block, Block != EntryBB);
     deriveAssumptions(Block);
   }
   if (DetectReductions)
     checkForReductions();
 }
 
-ScopStmt::ScopStmt(Scop &parent, TempScop &tempScop, BasicBlock &bb)
+ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb)
     : Parent(parent), BB(&bb), R(nullptr), Build(nullptr) {
 
   BaseName = getIslCompatibleName("Stmt_", &bb, "");
 
   buildDomain();
   collectSurroundingLoops();
-  buildAccesses(tempScop, BB);
+  buildAccesses(BB);
   deriveAssumptions(BB);
   if (DetectReductions)
     checkForReductions();
 }
 
 /// @brief Collect loads which might form a reduction chain with @p StoreMA
 ///
 /// Check if the stored value for @p StoreMA is a binary operator with one or
if (MaxLD == 0)
     return 1;
 
   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, ScalarEvolution &ScalarEvolution, DominatorTree &DT,
+Scop::Scop(Region &R, AccFuncMapType &AccFuncMap,
+           ScalarEvolution &ScalarEvolution, DominatorTree &DT,
            isl_ctx *Context, unsigned MaxLoopDepth)
-    : DT(DT), SE(&ScalarEvolution), R(R), IsOptimized(false),
-      HasSingleExitEdge(R.getExitingBlock()), MaxLoopDepth(MaxLoopDepth),
-      IslCtx(Context), Affinator(this) {}
+    : DT(DT), AccFuncMap(AccFuncMap), SE(&ScalarEvolution), R(R),
+      IsOptimized(false), HasSingleExitEdge(R.getExitingBlock()),
+      MaxLoopDepth(MaxLoopDepth), IslCtx(Context), Affinator(this) {}
 
-void Scop::initFromTempScop(TempScop &TempScop, LoopInfo &LI, ScopDetection &SD,
-                            AliasAnalysis &AA) {
+void Scop::init(LoopInfo &LI, ScopDetection &SD, AliasAnalysis &AA) {
   buildContext();
 
   buildDomains(&R, LI, SD, DT);
 
   DenseMap<Loop *, std::pair<isl_schedule *, unsigned>> LoopSchedules;
 
   Loop *L = getLoopSurroundingRegion(R, LI);
   LoopSchedules[L];
-  buildSchedule(&R, TempScop, LI, SD, LoopSchedules);
+  buildSchedule(&R, LI, SD, LoopSchedules);
   Schedule = LoopSchedules[L].first;
 
   realignParams();
   addParameterBounds();
   addUserContext();
   simplifyAssumedContext();
   buildAliasChecks(AA);
 }
 
-Scop *Scop::createFromTempScop(TempScop &TempScop, LoopInfo &LI,
-                               ScalarEvolution &SE, ScopDetection &SD,
-                               AliasAnalysis &AA, DominatorTree &DT,
-                               isl_ctx *ctx) {
-  auto &R = TempScop.getMaxRegion();
-  auto MaxLoopDepth = getMaxLoopDepthInRegion(R, LI, SD);
-  auto S = new Scop(R, SE, DT, ctx, MaxLoopDepth);
-  S->initFromTempScop(TempScop, LI, SD, AA);
-
-  return S;
-}
-
 Scop::~Scop() {
   isl_set_free(Context);
   isl_set_free(AssumedContext);
   isl_schedule_free(Schedule);
 
   for (auto It : DomainMap)
     isl_set_free(It.second);
 
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::isTrivialBB(BasicBlock *BB, TempScop &tempScop) {
-  if (tempScop.getAccessFunctions(BB) && !isErrorBlock(*BB))
+bool Scop::isTrivialBB(BasicBlock *BB) {
+  if (getAccessFunctions(BB) && !isErrorBlock(*BB))
     return false;
 
   return true;
 }
 
 struct MapToDimensionDataTy {
   int N;
   isl_union_pw_multi_aff *Res;
mapToDimension(__isl_take isl_union_set *Domain, int N) {
   Data.Res = isl_union_pw_multi_aff_empty(Space);
   if (isl_union_set_foreach_set(Domain, &mapToDimension_AddSet, &Data) < 0)
     Data.Res = isl_union_pw_multi_aff_free(Data.Res);
 
   isl_union_set_free(Domain);
   return isl_multi_union_pw_aff_from_union_pw_multi_aff(Data.Res);
 }
 
-ScopStmt *Scop::addScopStmt(BasicBlock *BB, Region *R, TempScop &tempScop) {
+ScopStmt *Scop::addScopStmt(BasicBlock *BB, Region *R) {
   ScopStmt *Stmt;
   if (BB) {
-    Stmts.emplace_back(*this, tempScop, *BB);
+    Stmts.emplace_back(*this, *BB);
     Stmt = &Stmts.back();
     StmtMap[BB] = Stmt;
   } else {
     assert(R && "Either basic block or a region expected.");
-    Stmts.emplace_back(*this, tempScop, *R);
+    Stmts.emplace_back(*this, *R);
     Stmt = &Stmts.back();
     for (BasicBlock *BB : R->blocks())
       StmtMap[BB] = Stmt;
   }
   return Stmt;
 }
 
 void Scop::buildSchedule(
-    Region *R, TempScop &TS, LoopInfo &LI, ScopDetection &SD,
+    Region *R, LoopInfo &LI, ScopDetection &SD,
     DenseMap<Loop *, std::pair<isl_schedule *, unsigned>> &LoopSchedules) {
 
   ReversePostOrderTraversal<Region *> RTraversal(R);
   for (auto *RN : RTraversal) {
 
     if (RN->isSubRegion()) {
       Region *SubRegion = RN->getNodeAs<Region>();
       if (!SD.isNonAffineSubRegion(SubRegion, &getRegion())) {
-        buildSchedule(SubRegion, TS, LI, SD, LoopSchedules);
+        buildSchedule(SubRegion, LI, SD, LoopSchedules);
         continue;
       }
     }
 
     Loop *L = getRegionNodeLoop(RN, LI);
     int LD = getRelativeLoopDepth(L);
     auto &LSchedulePair = LoopSchedules[L];
     LSchedulePair.second += getNumBlocksInRegionNode(RN);
 
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
-    if (RN->isSubRegion() || !isTrivialBB(BB, TS)) {
+    if (RN->isSubRegion() || !isTrivialBB(BB)) {
 
       ScopStmt *Stmt;
       if (RN->isSubRegion())
-        Stmt = addScopStmt(nullptr, RN->getNodeAs<Region>(), TS);
+        Stmt = addScopStmt(nullptr, RN->getNodeAs<Region>());
       else
-        Stmt = addScopStmt(BB, nullptr, TS);
+        Stmt = addScopStmt(BB, nullptr);
 
       auto *UDomain = isl_union_set_from_set(Stmt->getDomain());
       auto *StmtSchedule = isl_schedule_from_domain(UDomain);
       LSchedulePair.first =
           combineInSequence(LSchedulePair.first, StmtSchedule);
     }
 
     unsigned NumVisited = LSchedulePair.second;

 
 ScopStmt *Scop::getStmtForBasicBlock(BasicBlock *BB) const {
   auto StmtMapIt = StmtMap.find(BB);
   if (StmtMapIt == StmtMap.end())
     return nullptr;
   return StmtMapIt->second;
 }
 
-//===----------------------------------------------------------------------===//
-// TempScop implementation
-TempScop::~TempScop() {}
-
-void TempScop::print(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI) const {
+void Scop::printIRAccesses(raw_ostream &OS, ScalarEvolution *SE,
+                           LoopInfo *LI) const {
   OS << "Scop: " << R.getNameStr() << "\n";
 
-  printDetail(OS, SE, LI, &R, 0);
+  printIRAccessesDetail(OS, SE, LI, &R, 0);
 }
 
-void TempScop::printDetail(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI,
-                           const Region *CurR, unsigned ind) const {
+void Scop::printIRAccessesDetail(raw_ostream &OS, ScalarEvolution *SE,
+                                 LoopInfo *LI, const Region *CurR,
+                                 unsigned ind) const {
   // FIXME: Print other details rather than memory accesses.
   for (const auto &CurBlock : CurR->blocks()) {
     AccFuncMapType::const_iterator AccSetIt = AccFuncMap.find(CurBlock);
 
     // Ignore trivial blocks that do not contain any memory access.
     if (AccSetIt == AccFuncMap.end())
       continue;
 
void ScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB,
 
   if (Functions.empty())
     return;
 
   AccFuncSetType &Accs = AccFuncMap[&BB];
   Accs.insert(Accs.end(), Functions.begin(), Functions.end());
 }
 
-TempScop *ScopInfo::buildTempScop(Region &R) {
-  TempScop *TScop = new TempScop(R, AccFuncMap);
+Scop *ScopInfo::buildScop(Region &R, DominatorTree &DT) {
+  unsigned MaxLoopDepth = getMaxLoopDepthInRegion(R, *LI, *SD);
+  Scop *S = new Scop(R, AccFuncMap, *SE, DT, ctx, MaxLoopDepth);
 
   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);
 
-  return TScop;
+  S->init(*LI, *SD, *AA);
+  return S;
 }
 
-TempScop *ScopInfo::getTempScop() const { return TempScopOfRegion; }
-
 void ScopInfo::print(raw_ostream &OS, const Module *) const {
-  if (TempScopOfRegion)
-    TempScopOfRegion->print(OS, SE, LI);
+  if (!scop) {
+    OS << "Invalid Scop!\n";
+    return;
+  }
 
-  if (scop)
+  scop->printIRAccesses(OS, SE, LI);
     scop->print(OS);
-  else
-    OS << "Invalid Scop!\n";
 }
 
 void ScopInfo::clear() {
   AccFuncMap.clear();
-  if (TempScopOfRegion)
-    delete TempScopOfRegion;
-  TempScopOfRegion = nullptr;
-
   if (scop) {
     delete scop;
     scop = 0;
   }
 }
 
 //===----------------------------------------------------------------------===//
-ScopInfo::ScopInfo() : RegionPass(ID), TempScopOfRegion(nullptr), scop(0) {
+ScopInfo::ScopInfo() : RegionPass(ID), scop(0) {
   ctx = isl_ctx_alloc();
   isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
 }
 
 ScopInfo::~ScopInfo() {
   clear();
   isl_ctx_free(ctx);
 }
bool ScopInfo::runOnRegion(Region *R, RGPassManager &RGM) {
   Function *F = R->getEntry()->getParent();
   SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   TD = &F->getParent()->getDataLayout();
   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   ZeroOffset = SE->getConstant(TD->getIntPtrType(F->getContext()), 0);
 
-  assert(!TempScopOfRegion && "Build the TempScop only once");
-  TempScopOfRegion = buildTempScop(*R);
-
-  // This region is no Scop.
-  if (!TempScopOfRegion) {
-    scop = nullptr;
-    return false;
-  }
-
-  scop =
-      Scop::createFromTempScop(*TempScopOfRegion, *LI, *SE, *SD, *AA, DT, ctx);
+  scop = buildScop(*R, DT);
 
   DEBUG(scop->print(dbgs()));
 
   if (!scop->hasFeasibleRuntimeContext()) {
     delete scop;
     scop = nullptr;
     return false;
   }