[Polly] Get a list of statements for a Region Node. [NFC]

[nandini12396]

Rebased over D35665.

[Meinersbur]

Looks surprisingly simple, but there is nothing why this shouldn't work.

include/polly/ScopInfo.h

   /// Return the last statement representing @p BB.
   ///
   /// Of the sequence of statements that represent a @p BB, this is the last one
   /// to be executed. It is typically used to determine which instruction to add
   /// a MemoryKind::PHI WRITE to. For this purpose, it is not strictly required
   /// to be executed last, only that the incoming value is available in it.
   ScopStmt *getLastStmtFor(BasicBlock *BB) const;
 
-  /// Return the ScopStmt that represents the Region @p R, or nullptr if
+  /// Return the ScopStmts that represents the Region @p R, or nullptr if
   ///        it is not represented by any statement in this Scop.
-  ScopStmt *getStmtFor(Region *R) const;
+  ArrayRef<ScopStmt *> getStmtListFor(Region *R) const;
 
-  /// Return the ScopStmt that represents @p RN; can return nullptr if
+  /// Return the ScopStmts that represents @p RN; can return nullptr if
   ///        the RegionNode is not within the SCoP or has been removed due to
   ///        simplifications.
-  ScopStmt *getStmtFor(RegionNode *RN) const;
+  ArrayRef<ScopStmt *> getStmtListFor(RegionNode *RN) const;
 
   /// Return the ScopStmt an instruction belongs to, or nullptr if it
   ///        does not belong to any statement in this Scop.
   ScopStmt *getStmtFor(Instruction *Inst) const {
     return getStmtFor(Inst->getParent());
   }
 
   /// Return the number of statements in the SCoP.

lib/Analysis/ScopInfo.cpp

       buildSchedule(LocalRegion, LoopStack, LI);
       return;
     }
   }
 
   auto &LoopData = LoopStack.back();
   LoopData.NumBlocksProcessed += getNumBlocksInRegionNode(RN);
 
-  if (auto *Stmt = getStmtFor(RN)) {
+  for (auto *Stmt : getStmtListFor(RN)) {
     auto *UDomain = isl_union_set_from_set(Stmt->getDomain());
     auto *StmtSchedule = isl_schedule_from_domain(UDomain);
     LoopData.Schedule = combineInSequence(LoopData.Schedule, StmtSchedule);
   }
 
   // Check if we just processed the last node in this loop. If we did, finalize
   // the loop by:
   //

 }
 
 ScopStmt *Scop::getLastStmtFor(BasicBlock *BB) const {
   if (getStmtListFor(BB).size() > 0)
     return getStmtListFor(BB).back();
   return nullptr;
 }
 
-ScopStmt *Scop::getStmtFor(RegionNode *RN) const {
+ArrayRef<ScopStmt *> Scop::getStmtListFor(RegionNode *RN) const {
   if (RN->isSubRegion())
-    return getStmtFor(RN->getNodeAs<Region>());
-  return getStmtFor(RN->getNodeAs<BasicBlock>());
+    return getStmtListFor(RN->getNodeAs<Region>());
+  return getStmtListFor(RN->getNodeAs<BasicBlock>());
 }
 
-ScopStmt *Scop::getStmtFor(Region *R) const {
-  ScopStmt *Stmt = getStmtFor(R->getEntry());
-  assert(!Stmt || Stmt->getRegion() == R);
-  return Stmt;
+ArrayRef<ScopStmt *> Scop::getStmtListFor(Region *R) const {
+  return getStmtListFor(R->getEntry());
 }
 
 int Scop::getRelativeLoopDepth(const Loop *L) const {
   if (!L || !R.contains(L))
     return -1;
   // outermostLoopInRegion always returns nullptr for top level regions
   if (R.isTopLevelRegion()) {
     // LoopInfo's depths start at 1, we start at 0