[Polly][Refactor][NFC] Map basic blocks to SCoP statements.

[jdoerfert]

Summary

This will simplify the construction of domains and the modeling of
PHI's.

[jdoerfert]

closed 221015.

[jdoerfert]

Tobias approved on the mailing list

[jdoerfert]

closed 221015.

include/polly/ScopInfo.h

private:
 
   /// The isl_ids that are used to represent the parameters
   typedef std::map<const SCEV *, int> ParamIdType;
   ParamIdType ParameterIds;
 
   /// Isl context.
   isl_ctx *IslCtx;
 
+  /// @brief A map from basic blocks to SCoP statements.
+  DenseMap<BasicBlock *, ScopStmt *> StmtMap;
+
   /// Constraints on parameters.
   isl_set *Context;
 
   /// @brief A map to remember ScopArrayInfo objects for all base pointers.
   DenseMap<const Value *, const ScopArrayInfo *> ScopArrayInfoMap;
 
   /// @brief The assumptions under which this scop was built.
   ///
public:
   }
 
   /// @brief Get an isl string representing the context.
   std::string getContextStr() const;
 
   /// @brief Get an isl string representing the assumed context.
   std::string getAssumedContextStr() const;
 
+  /// @brief Return the stmt for the given @p BB or nullptr if none.
+  ScopStmt *getStmtForBasicBlock(BasicBlock *BB) const;
+
   /// @name Statements Iterators
   ///
   /// These iterators iterate over all statements of this Scop.
   //@{
   typedef StmtSet::iterator iterator;
   typedef StmtSet::const_iterator const_iterator;
 
   iterator begin() { return Stmts.begin(); }

lib/Analysis/ScopInfo.cpp

for (Region::const_element_iterator I = CurRegion.element_begin(),
     if (I->isSubRegion())
       buildScop(tempScop, *(I->getNodeAs<Region>()), NestLoops, Scatter, LI);
     else {
       BasicBlock *BB = I->getNodeAs<BasicBlock>();
 
       if (isTrivialBB(BB, tempScop))
         continue;
 
-      Stmts.push_back(
-          new ScopStmt(*this, tempScop, CurRegion, *BB, NestLoops, Scatter));
+      ScopStmt *Stmt =
+          new ScopStmt(*this, tempScop, CurRegion, *BB, NestLoops, Scatter);
+
+      // Insert all statements into the statement map and the statement vector.
+      StmtMap[BB] = Stmt;
+      Stmts.push_back(Stmt);
 
       // Increasing the Scattering function is OK for the moment, because
       // we are using a depth first iterator and the program is well structured.
       ++Scatter[loopDepth];
     }
 
   if (!L)
     return;
 
   // Exiting a loop region.
   Scatter[loopDepth] = 0;
   NestLoops.pop_back();
   ++Scatter[loopDepth - 1];
 }
 
+ScopStmt *Scop::getStmtForBasicBlock(BasicBlock *BB) const {
+  const auto &StmtMapIt = StmtMap.find(BB);
+  if (StmtMapIt == StmtMap.end())
+    return nullptr;
+  return StmtMapIt->second;
+}
+
 //===----------------------------------------------------------------------===//
 ScopInfo::ScopInfo() : RegionPass(ID), scop(0) {
   ctx = isl_ctx_alloc();
   isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
 }
 
 ScopInfo::~ScopInfo() {
   clear();

lib/Support/ScopHelper.cpp

for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI)
     if (R->contains(*PI))
       Preds.push_back(*PI);
 
   return SplitBlockPredecessors(BB, Preds, ".region", P);
 }
 
 static void replaceScopAndRegionEntry(polly::Scop *S, BasicBlock *OldEntry,
                                       BasicBlock *NewEntry) {
-  for (polly::ScopStmt *Stmt : *S)
-    if (Stmt->getBasicBlock() == OldEntry) {
-      Stmt->setBasicBlock(NewEntry);
-      break;
-    }
+  if (polly::ScopStmt *Stmt = S->getStmtForBasicBlock(OldEntry))
 
   S->getRegion().replaceEntryRecursive(NewEntry);
 }
 
 BasicBlock *polly::simplifyRegion(Scop *S, Pass *P) {
   Region *R = &S->getRegion();
 
   // The entering block for the region.