Use value semantics for list of ScopStmt(s) instead of std::owningptr

[grosser]

Summary

David Blaike suggested this as an alternative to the use of owningptr(s) for our
memory management, as value semantics allow to avoid the additional interface
complexity caused by owningptr while still providing similar memory consistency
guarantees. We could also have used a std::vector, but the use of std::vector
would yield possibly changing pointers which currently causes problems as for
example the memory accesses carry pointers to their parent statements. Such
pointers should not change.

[dblaikie]

Looks great - deque's a great option (imho - opinions vary, of course) when you're never removing things but are adding new things that all need consistent pointer identity.

[jdoerfert]

I think this is much more intuitive than the smart pointer version.

If you do only worry about the order but you would like to use a list, define the begin()/end() function of a Scop as rbegin()/rend() of the underlying list of scopstmts, that should give us the same order but avoid the deque (which isn't that bad I guess).

lib/Analysis/ScopInfo.cpp

2024

Why no const &?

[grosser]

In D10041#179021, @jdoerfert wrote:

If you do only worry about the order but you would like to use a list, define the begin()/end() function of a Scop as rbegin()/rend() of the underlying list of scopstmts, that should give us the same order but avoid the deque (which isn't that bad I guess).

I decided to stay with the deque as the use of rbegin()/rend() is possible, but would (only slightly) increase complexity. As I doubt this has any performance effect, I decided to minimize complexity.

lib/Analysis/ScopInfo.cpp

2024

Changed.

include/polly/ScopInfo.h

 #define POLLY_SCOP_INFO_H
 
 #include "polly/ScopDetection.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Analysis/RegionPass.h"
 #include "isl/ctx.h"
 
 #include <forward_list>
+#include <deque>
 
 using namespace llvm;
 
 namespace llvm {
 class Loop;
 class LoopInfo;
 class PHINode;
 class ScalarEvolution;

 /// It is further described by its iteration domain, its schedule and its data
 /// accesses.
 /// At the moment every statement represents a single basic block of LLVM-IR.
 class ScopStmt {
 public:
   /// @brief List to hold all (scalar) memory accesses mapped to an instruction.
   using MemoryAccessList = std::forward_list<MemoryAccess>;
 
-private:
   ScopStmt(const ScopStmt &) = delete;
   const ScopStmt &operator=(const ScopStmt &) = delete;
 
+  /// Create the ScopStmt from a BasicBlock.
+  ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion,
+           BasicBlock &bb, SmallVectorImpl<Loop *> &NestLoops,
+           SmallVectorImpl<unsigned> &ScheduleVec);
+
+  /// Create an overapproximating ScopStmt for the region @p R.
+  ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion, Region &R,
+           SmallVectorImpl<Loop *> &NestLoops,
+           SmallVectorImpl<unsigned> &ScheduleVec);
+
+private:
   /// Polyhedral description
   //@{
 
   /// The Scop containing this ScopStmt
   Scop &Parent;
 
   /// The iteration domain describes the set of iterations for which this
   /// statement is executed.
private:
   /// result scanning for GEP[s] is imprecise. Even though this is not a
   /// correctness problem, this imprecision may result in missed optimizations
   /// or non-optimal run-time checks.
   void deriveAssumptionsFromGEP(GetElementPtrInst *Inst);
 
   /// @brief Scan @p Block and derive assumptions about parameter values.
   void deriveAssumptions(BasicBlock *Block);
 
-  /// Create the ScopStmt from a BasicBlock.
-  ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion,
-           BasicBlock &bb, SmallVectorImpl<Loop *> &NestLoops,
-           SmallVectorImpl<unsigned> &ScheduleVec);
-
-  /// Create an overapproximating ScopStmt for the region @p R.
-  ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion, Region &R,
-           SmallVectorImpl<Loop *> &NestLoops,
-           SmallVectorImpl<unsigned> &ScheduleVec);
-
-  friend class Scop;
-
 public:
   ~ScopStmt();
 
   /// @brief Get an isl_ctx pointer.
   isl_ctx *getIslCtx() const;
 
   /// @brief Get the iteration domain of this ScopStmt.
   ///
private:
   Region &R;
 
   /// Flag to indicate that the scheduler actually optimized the SCoP.
   bool IsOptimized;
 
   /// Max loop depth.
   unsigned MaxLoopDepth;
 
-  typedef std::vector<std::unique_ptr<ScopStmt>> StmtSet;
+  typedef std::deque<ScopStmt> StmtSet;
   /// The statements in this Scop.
   StmtSet Stmts;
 
   /// Parameters of this Scop
   typedef SmallVector<const SCEV *, 8> ParamVecType;
   ParamVecType Parameters;
 
   /// The isl_ids that are used to represent the parameters
public:
   inline unsigned getMaxLoopDepth() const { return MaxLoopDepth; }
 
   /// @brief Get the schedule dimension number of this Scop.
   ///
   /// @return The schedule dimension number of this Scop.
   inline unsigned getScheduleDim() const {
     unsigned maxScheduleDim = 0;
 
-    for (const_iterator SI = begin(), SE = end(); SI != SE; ++SI)
-      maxScheduleDim = std::max(maxScheduleDim, (*SI)->getNumSchedule());
+    for (const ScopStmt &Stmt : *this)
+      maxScheduleDim = std::max(maxScheduleDim, Stmt.getNumSchedule());
 
     return maxScheduleDim;
   }
 
   /// @brief Mark the SCoP as optimized by the scheduler.
   void markAsOptimized() { IsOptimized = true; }
 
   /// @brief Check if the SCoP has been optimized by the scheduler.

lib/Analysis/DependenceInfo.cpp

static void collectInfo(Scop &S, isl_union_map **Read, isl_union_map **Write,
   isl_space *Space = S.getParamSpace();
   *Read = isl_union_map_empty(isl_space_copy(Space));
   *Write = isl_union_map_empty(isl_space_copy(Space));
   *MayWrite = isl_union_map_empty(isl_space_copy(Space));
   *AccessSchedule = isl_union_map_empty(isl_space_copy(Space));
   *StmtSchedule = isl_union_map_empty(Space);
 
   SmallPtrSet<const Value *, 8> ReductionBaseValues;
-  for (auto &Stmt : S)
-    for (MemoryAccess *MA : *Stmt)
+  for (ScopStmt &Stmt : S)
+    for (MemoryAccess *MA : Stmt)
       if (MA->isReductionLike())
         ReductionBaseValues.insert(MA->getBaseAddr());
 
-  for (auto &Stmt : S) {
-    for (MemoryAccess *MA : *Stmt) {
-      isl_set *domcp = Stmt->getDomain();
+  for (ScopStmt &Stmt : S) {
+    for (MemoryAccess *MA : Stmt) {
+      isl_set *domcp = Stmt.getDomain();
       isl_map *accdom = MA->getAccessRelation();
 
       accdom = isl_map_intersect_domain(accdom, domcp);
 
       if (ReductionBaseValues.count(MA->getBaseAddr())) {
         // Wrap the access domain and adjust the schedule accordingly.
         //
         // An access domain like
         //   Stmt[i0, i1] -> MemAcc_A[i0 + i1]
         // will be transformed into
         //   [Stmt[i0, i1] -> MemAcc_A[i0 + i1]] -> MemAcc_A[i0 + i1]
         //
         // The original schedule looks like
         //   Stmt[i0, i1] -> [0, i0, 2, i1, 0]
         // but as we transformed the access domain we need the schedule
         // to match the new access domains, thus we need
         //   [Stmt[i0, i1] -> MemAcc_A[i0 + i1]] -> [0, i0, 2, i1, 0]
-        isl_map *Schedule = Stmt->getSchedule();
+        isl_map *Schedule = Stmt.getSchedule();
         Schedule = isl_map_apply_domain(
             Schedule,
             isl_map_reverse(isl_map_domain_map(isl_map_copy(accdom))));
         accdom = isl_map_range_map(accdom);
         *AccessSchedule = isl_union_map_add_map(*AccessSchedule, Schedule);
       }
 
       if (MA->isRead())
         *Read = isl_union_map_add_map(*Read, accdom);
       else
         *Write = isl_union_map_add_map(*Write, accdom);
     }
-    *StmtSchedule = isl_union_map_add_map(*StmtSchedule, Stmt->getSchedule());
+    *StmtSchedule = isl_union_map_add_map(*StmtSchedule, Stmt.getSchedule());
   }
 
   *StmtSchedule =
       isl_union_map_intersect_params(*StmtSchedule, S.getAssumedContext());
 }
 
 /// @brief Fix all dimension of @p Zero to 0 and add it to @p user
 static int fixSetToZero(__isl_take isl_set *Zero, void *user) {
void Dependences::calculateDependences(Scop &S) {
   //    the same, RAW and WAW dependences.
   // 4) Add the privatization dependences which are widened versions of
   //    already present dependences. They model the effect of manual
   //    privatization at the outermost possible place (namely after the last
   //    write and before the first access to a reduction location).
 
   // Step 1)
   RED = isl_union_map_empty(isl_union_map_get_space(RAW));
-  for (auto &Stmt : S) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : S) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isReductionLike())
         continue;
       isl_set *AccDomW = isl_map_wrap(MA->getAccessRelation());
       isl_map *Identity =
           isl_map_from_domain_and_range(isl_set_copy(AccDomW), AccDomW);
       RED = isl_union_map_add_map(RED, Identity);
     }
   }
void Dependences::calculateDependences(Scop &S) {
   isl_union_map *RED_SIN = isl_union_map_empty(isl_union_map_get_space(RAW));
 
   // For each reduction like memory access, check if there are reduction
   // dependences with the access relation of the memory access as a domain
   // (wrapped space!). If so these dependences are caused by this memory access.
   // We then move this portion of reduction dependences back to the statement ->
   // statement space and add a mapping from the memory access to these
   // dependences.
-  for (auto &Stmt : S) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : S) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isReductionLike())
         continue;
 
       isl_set *AccDomW = isl_map_wrap(MA->getAccessRelation());
       isl_union_map *AccRedDepU = isl_union_map_intersect_domain(
           isl_union_map_copy(TC_RED), isl_union_set_from_set(AccDomW));
       if (isl_union_map_is_empty(AccRedDepU) && !isl_union_map_free(AccRedDepU))
         continue;
if (LegalityCheckDisabled)
     return true;
 
   isl_union_map *Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);
   isl_space *Space = S.getParamSpace();
   isl_union_map *Schedule = isl_union_map_empty(Space);
 
   isl_space *ScheduleSpace = nullptr;
 
-  for (auto &Stmt : S) {
+  for (ScopStmt &Stmt : S) {
     isl_map *StmtScat;
 
-    if (NewSchedule->find(&*Stmt) == NewSchedule->end())
-      StmtScat = Stmt->getSchedule();
+    if (NewSchedule->find(&Stmt) == NewSchedule->end())
+      StmtScat = Stmt.getSchedule();
     else
-      StmtScat = isl_map_copy((*NewSchedule)[&*Stmt]);
+      StmtScat = isl_map_copy((*NewSchedule)[&Stmt]);
 
     if (!ScheduleSpace)
       ScheduleSpace = isl_space_range(isl_map_get_space(StmtScat));
 
     Schedule = isl_union_map_add_map(Schedule, StmtScat);
   }
 
   Dependences =

lib/Analysis/ScopInfo.cpp

for (const auto &ParamID : ParameterIds) {
     const SCEV *Parameter = ParamID.first;
     isl_id *id = getIdForParam(Parameter);
     Space = isl_space_set_dim_id(Space, isl_dim_param, ParamID.second, id);
   }
 
   // Align the parameters of all data structures to the model.
   Context = isl_set_align_params(Context, Space);
 
-  for (auto &Stmt : *this)
-    Stmt->realignParams();
+  for (ScopStmt &Stmt : *this)
+    Stmt.realignParams();
 }
 
 void Scop::simplifyAssumedContext() {
   // The parameter constraints of the iteration domains give us a set of
   // constraints that need to hold for all cases where at least a single
   // statement iteration is executed in the whole scop. We now simplify the
   // assumed context under the assumption that such constraints hold and at
   // least a single statement iteration is executed. For cases where no
bool Scop::buildAliasGroups(AliasAnalysis &AA) {
   //   o) For each group with more than one base pointer we then compute minimal
   //      and maximal accesses to each array in this group.
   using AliasGroupTy = SmallVector<MemoryAccess *, 4>;
 
   AliasSetTracker AST(AA);
 
   DenseMap<Value *, MemoryAccess *> PtrToAcc;
   DenseSet<Value *> HasWriteAccess;
-  for (auto &Stmt : *this) {
+  for (ScopStmt &Stmt : *this) {
 
     // Skip statements with an empty domain as they will never be executed.
-    isl_set *StmtDomain = Stmt->getDomain();
+    isl_set *StmtDomain = Stmt.getDomain();
     bool StmtDomainEmpty = isl_set_is_empty(StmtDomain);
     isl_set_free(StmtDomain);
     if (StmtDomainEmpty)
       continue;
 
-    for (MemoryAccess *MA : *Stmt) {
+    for (MemoryAccess *MA : Stmt) {
       if (MA->isScalar())
         continue;
       if (!MA->isRead())
         HasWriteAccess.insert(MA->getBaseAddr());
       Instruction *Acc = MA->getAccessInstruction();
       PtrToAcc[getPointerOperand(*Acc)] = MA;
       AST.add(Acc);
     }
for (unsigned i = 0; i < isl_set_dim(ScheduleSpace, isl_dim_set); i += 2) {
     if (isl_val_is_int(FixedVal)) {
       DropDimMap =
           isl_map_project_out(DropDimMap, isl_dim_out, i - NumDimsDropped, 1);
       NumDimsDropped++;
     }
     isl_val_free(FixedVal);
   }
 
-  for (auto &S : *this) {
-    isl_map *Schedule = S->getSchedule();
+  for (ScopStmt &Stmt : *this) {
+    isl_map *Schedule = Stmt.getSchedule();
     Schedule = isl_map_apply_range(Schedule, isl_map_copy(DropDimMap));
-    S->setSchedule(Schedule);
+    Stmt.setSchedule(Schedule);
   }
   isl_set_free(ScheduleSpace);
   isl_map_free(DropDimMap);
 }
 
 Scop::Scop(TempScop &tempScop, LoopInfo &LI, ScalarEvolution &ScalarEvolution,
            ScopDetection &SD, isl_ctx *Context)
     : SE(&ScalarEvolution), R(tempScop.getMaxRegion()), IsOptimized(false),
for (MinMaxAccessTy &MinMacAccess : *MinMaxAccesses)
       OS << " <" << MinMacAccess.first << ", " << MinMacAccess.second << ">";
     OS << " ]]\n";
   }
 }
 
 void Scop::printStatements(raw_ostream &OS) const {
   OS << "Statements {\n";
 
-  for (auto &Stmt : *this)
-    OS.indent(4) << *Stmt;
+  for (const ScopStmt &Stmt : *this)
+    OS.indent(4) << Stmt;
 
   OS.indent(4) << "}\n";
 }
 
 void Scop::printArrayInfo(raw_ostream &OS) const {
   OS << "Arrays {\n";
 
   for (auto &Array : arrays())

 
 void Scop::dump() const { print(dbgs()); }
 
 isl_ctx *Scop::getIslCtx() const { return IslCtx; }
 
 __isl_give isl_union_set *Scop::getDomains() {
   isl_union_set *Domain = isl_union_set_empty(getParamSpace());
 
-  for (auto &Stmt : *this)
-    Domain = isl_union_set_add_set(Domain, Stmt->getDomain());
+  for (ScopStmt &Stmt : *this)
+    Domain = isl_union_set_add_set(Domain, Stmt.getDomain());
 
   return Domain;
 }
 
 __isl_give isl_union_map *Scop::getMustWrites() {
   isl_union_map *Write = isl_union_map_empty(getParamSpace());
 
-  for (auto &Stmt : *this) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : *this) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isMustWrite())
         continue;
 
-      isl_set *Domain = Stmt->getDomain();
+      isl_set *Domain = Stmt.getDomain();
       isl_map *AccessDomain = MA->getAccessRelation();
       AccessDomain = isl_map_intersect_domain(AccessDomain, Domain);
       Write = isl_union_map_add_map(Write, AccessDomain);
     }
   }
   return isl_union_map_coalesce(Write);
 }
 
 __isl_give isl_union_map *Scop::getMayWrites() {
   isl_union_map *Write = isl_union_map_empty(getParamSpace());
 
-  for (auto &Stmt : *this) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : *this) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isMayWrite())
         continue;
 
-      isl_set *Domain = Stmt->getDomain();
+      isl_set *Domain = Stmt.getDomain();
       isl_map *AccessDomain = MA->getAccessRelation();
       AccessDomain = isl_map_intersect_domain(AccessDomain, Domain);
       Write = isl_union_map_add_map(Write, AccessDomain);
     }
   }
   return isl_union_map_coalesce(Write);
 }
 
 __isl_give isl_union_map *Scop::getWrites() {
   isl_union_map *Write = isl_union_map_empty(getParamSpace());
 
-  for (auto &Stmt : *this) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : *this) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isWrite())
         continue;
 
-      isl_set *Domain = Stmt->getDomain();
+      isl_set *Domain = Stmt.getDomain();
       isl_map *AccessDomain = MA->getAccessRelation();
       AccessDomain = isl_map_intersect_domain(AccessDomain, Domain);
       Write = isl_union_map_add_map(Write, AccessDomain);
     }
   }
   return isl_union_map_coalesce(Write);
 }
 
 __isl_give isl_union_map *Scop::getReads() {
   isl_union_map *Read = isl_union_map_empty(getParamSpace());
 
-  for (auto &Stmt : *this) {
-    for (MemoryAccess *MA : *Stmt) {
+  for (ScopStmt &Stmt : *this) {
+    for (MemoryAccess *MA : Stmt) {
       if (!MA->isRead())
         continue;
 
-      isl_set *Domain = Stmt->getDomain();
+      isl_set *Domain = Stmt.getDomain();
       isl_map *AccessDomain = MA->getAccessRelation();
 
       AccessDomain = isl_map_intersect_domain(AccessDomain, Domain);
       Read = isl_union_map_add_map(Read, AccessDomain);
     }
   }
   return isl_union_map_coalesce(Read);
 }
 
 __isl_give isl_union_map *Scop::getSchedule() {
   isl_union_map *Schedule = isl_union_map_empty(getParamSpace());
 
-  for (auto &Stmt : *this)
-    Schedule = isl_union_map_add_map(Schedule, Stmt->getSchedule());
+  for (ScopStmt &Stmt : *this)
+    Schedule = isl_union_map_add_map(Schedule, Stmt.getSchedule());
 
   return isl_union_map_coalesce(Schedule);
 }
 
 bool Scop::restrictDomains(__isl_take isl_union_set *Domain) {
   bool Changed = false;
-  for (auto &Stmt : *this) {
-    isl_union_set *StmtDomain = isl_union_set_from_set(Stmt->getDomain());
+  for (ScopStmt &Stmt : *this) {
+    isl_union_set *StmtDomain = isl_union_set_from_set(Stmt.getDomain());
     isl_union_set *NewStmtDomain = isl_union_set_intersect(
         isl_union_set_copy(StmtDomain), isl_union_set_copy(Domain));
 
     if (isl_union_set_is_subset(StmtDomain, NewStmtDomain)) {
       isl_union_set_free(StmtDomain);
       isl_union_set_free(NewStmtDomain);
       continue;
     }
 
     Changed = true;
 
     isl_union_set_free(StmtDomain);
     NewStmtDomain = isl_union_set_coalesce(NewStmtDomain);
 
     if (isl_union_set_is_empty(NewStmtDomain)) {
-      Stmt->restrictDomain(isl_set_empty(Stmt->getDomainSpace()));
+      Stmt.restrictDomain(isl_set_empty(Stmt.getDomainSpace()));
       isl_union_set_free(NewStmtDomain);
     } else
-      Stmt->restrictDomain(isl_set_from_union_set(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))
     return false;
 
   return true;
 }
 
 void Scop::addScopStmt(BasicBlock *BB, Region *R, TempScop &tempScop,
                        const Region &CurRegion,
                        SmallVectorImpl<Loop *> &NestLoops,
                        SmallVectorImpl<unsigned> &ScheduleVec) {
-  std::unique_ptr<ScopStmt> Stmt;
-
   if (BB) {
-    Stmt = std::unique_ptr<ScopStmt>(
-        new ScopStmt(*this, tempScop, CurRegion, *BB, NestLoops, ScheduleVec));
-    StmtMap[BB] = &*Stmt;
+    Stmts.emplace_back(*this, tempScop, CurRegion, *BB, NestLoops, ScheduleVec);
+    StmtMap[BB] = &Stmts.back();
   } else {
-    assert(R && "Either a basic block or a region is needed to "
-                "create a new SCoP stmt.");
-    Stmt = std::unique_ptr<ScopStmt>(
-        new ScopStmt(*this, tempScop, CurRegion, *R, NestLoops, ScheduleVec));
+    assert(R && "Either basic block or a region expected.");
+    Stmts.emplace_back(*this, tempScop, CurRegion, *R, NestLoops, ScheduleVec);
+    auto *Ptr = &Stmts.back();
     for (BasicBlock *BB : R->blocks())
-      StmtMap[BB] = &*Stmt;
+      StmtMap[BB] = Ptr;
   }
 
-  // Insert all statements into the statement map and the statement vector.
-  Stmts.push_back(std::move(Stmt));
-
   // Increasing the Schedule function is OK for the moment, because
   // we are using a depth first iterator and the program is well structured.
   ++ScheduleVec[NestLoops.size()];
 }
 
 void Scop::buildScop(TempScop &tempScop, const Region &CurRegion,
                      SmallVectorImpl<Loop *> &NestLoops,
                      SmallVectorImpl<unsigned> &ScheduleVec, LoopInfo &LI,
void Scop::buildScop(TempScop &tempScop, const Region &CurRegion,
 
   // Exiting a loop region.
   ScheduleVec[loopDepth] = 0;
   NestLoops.pop_back();
   ++ScheduleVec[loopDepth - 1];
 }
 
 ScopStmt *Scop::getStmtForBasicBlock(BasicBlock *BB) const {
-  const auto &StmtMapIt = StmtMap.find(BB);
+  auto StmtMapIt = StmtMap.find(BB);
   if (StmtMapIt == StmtMap.end())
     return nullptr;
   return StmtMapIt->second;
 }
 
 //===----------------------------------------------------------------------===//
 ScopInfo::ScopInfo() : RegionPass(ID), scop(0) {
   ctx = isl_ctx_alloc();

lib/CodeGen/IRBuilder.cpp

void ScopAnnotator::buildAliasScopes(Scop &S) {
 
   LLVMContext &Ctx = SE->getContext();
   AliasScopeDomain = getID(Ctx, MDString::get(Ctx, "polly.alias.scope.domain"));
 
   AliasScopeMap.clear();
   OtherAliasScopeListMap.clear();
 
   SetVector<Value *> BasePtrs;
-  for (auto &Stmt : S)
-    for (MemoryAccess *MA : *Stmt)
+  for (ScopStmt &Stmt : S)
+    for (MemoryAccess *MA : Stmt)
       BasePtrs.insert(MA->getBaseAddr());
 
   std::string AliasScopeStr = "polly.alias.scope.";
   for (Value *BasePtr : BasePtrs)
     AliasScopeMap[BasePtr] = getID(
         Ctx, AliasScopeDomain,
         MDString::get(Ctx, (AliasScopeStr + BasePtr->getName()).str().c_str()));
 

lib/CodeGen/Utils.cpp

BasicBlock *polly::executeScopConditionally(Scop &S, Pass *P, Value *RTC) {
   // Split the entry edge of the region and generate a new basic block on this
   // edge. This function also updates ScopInfo and RegionInfo.
   NewBlock = SplitEdge(R.getEnteringBlock(), R.getEntry(), &DT, &LI);
   if (DT.dominates(R.getEntry(), NewBlock)) {
     BasicBlock *OldBlock = R.getEntry();
     std::string OldName = OldBlock->getName();
 
     // Update ScopInfo.
-    for (auto &Stmt : S)
-      if (Stmt->getBasicBlock() == OldBlock) {
-        Stmt->setBasicBlock(NewBlock);
+    for (ScopStmt &Stmt : S)
+      if (Stmt.getBasicBlock() == OldBlock) {
+        Stmt.setBasicBlock(NewBlock);
         break;
       }
 
     // Update RegionInfo.
     SplitBlock = OldBlock;
     OldBlock->setName("polly.split");
     NewBlock->setName(OldName);
     R.replaceEntryRecursive(NewBlock);

lib/Exchange/JSONExporter.cpp

Location = FileName + ":" + std::to_string(LineBegin) + "-" +
                std::to_string(LineEnd);
 
   root["name"] = S.getRegion().getNameStr();
   root["context"] = S.getContextStr();
   if (LineBegin != (unsigned)-1)
     root["location"] = Location;
   root["statements"];
 
-  for (auto &Stmt : S) {
+  for (ScopStmt &Stmt : S) {
     Json::Value statement;
 
-    statement["name"] = Stmt->getBaseName();
-    statement["domain"] = Stmt->getDomainStr();
-    statement["schedule"] = Stmt->getScheduleStr();
+    statement["name"] = Stmt.getBaseName();
+    statement["domain"] = Stmt.getDomainStr();
+    statement["schedule"] = Stmt.getScheduleStr();
     statement["accesses"];
 
-    for (MemoryAccess *MA : *Stmt) {
+    for (MemoryAccess *MA : Stmt) {
       Json::Value access;
 
       access["kind"] = MA->isRead() ? "read" : "write";
       access["relation"] = MA->getOriginalAccessRelationStr();
 
       statement["accesses"].append(access);
     }
 
bool JSONImporter::runOnScop(Scop &S) {
 
   isl_set_free(OldContext);
   S.setContext(NewContext);
 
   StatementToIslMapTy NewSchedule;
 
   int index = 0;
 
-  for (auto &Stmt : S) {
+  for (ScopStmt &Stmt : S) {
     Json::Value schedule = jscop["statements"][index]["schedule"];
     isl_map *m = isl_map_read_from_str(S.getIslCtx(), schedule.asCString());
-    isl_space *Space = Stmt->getDomainSpace();
+    isl_space *Space = Stmt.getDomainSpace();
 
     // Copy the old tuple id. This is necessary to retain the user pointer,
     // that stores the reference to the ScopStmt this schedule belongs to.
     m = isl_map_set_tuple_id(m, isl_dim_in,
                              isl_space_get_tuple_id(Space, isl_dim_set));
     for (unsigned i = 0; i < isl_space_dim(Space, isl_dim_param); i++) {
       isl_id *id = isl_space_get_dim_id(Space, isl_dim_param, i);
       m = isl_map_set_dim_id(m, isl_dim_param, i, id);
     }
     isl_space_free(Space);
-    NewSchedule[&*Stmt] = m;
+    NewSchedule[&Stmt] = m;
     index++;
   }
 
   if (!D.isValidSchedule(S, &NewSchedule)) {
     errs() << "JScop file contains a schedule that changes the "
            << "dependences. Use -disable-polly-legality to continue anyways\n";
     for (StatementToIslMapTy::iterator SI = NewSchedule.begin(),
                                        SE = NewSchedule.end();
          SI != SE; ++SI)
       isl_map_free(SI->second);
     return false;
   }
 
-  for (auto &Stmt : S) {
-    if (NewSchedule.find(&*Stmt) != NewSchedule.end())
-      Stmt->setSchedule(NewSchedule[&*Stmt]);
+  for (ScopStmt &Stmt : S) {
+    if (NewSchedule.find(&Stmt) != NewSchedule.end())
+      Stmt.setSchedule(NewSchedule[&Stmt]);
   }
 
   int statementIdx = 0;
-  for (auto &Stmt : S) {
+  for (ScopStmt &Stmt : S) {
     int memoryAccessIdx = 0;
-    for (MemoryAccess *MA : *Stmt) {
+    for (MemoryAccess *MA : Stmt) {
       Json::Value accesses = jscop["statements"][statementIdx]["accesses"]
                                   [memoryAccessIdx]["relation"];
       isl_map *newAccessMap =
           isl_map_read_from_str(S.getIslCtx(), accesses.asCString());
       isl_map *currentAccessMap = MA->getAccessRelation();
 
       if (isl_map_dim(newAccessMap, isl_dim_param) !=
           isl_map_dim(currentAccessMap, isl_dim_param)) {

lib/Transform/ScheduleOptimizer.cpp

bool IslScheduleOptimizer::runOnScop(Scop &S) {
   if (!isProfitableSchedule(S, NewSchedule)) {
     isl_schedule_free(Schedule);
     isl_union_map_free(NewSchedule);
     return false;
   }
 
   S.markAsOptimized();
 
-  for (auto &Stmt : S) {
+  for (ScopStmt &Stmt : S) {
     isl_map *StmtSchedule;
-    isl_set *Domain = Stmt->getDomain();
+    isl_set *Domain = Stmt.getDomain();
     isl_union_map *StmtBand;
     StmtBand = isl_union_map_intersect_domain(isl_union_map_copy(NewSchedule),
                                               isl_union_set_from_set(Domain));
     if (isl_union_map_is_empty(StmtBand)) {
-      StmtSchedule = isl_map_from_domain(isl_set_empty(Stmt->getDomainSpace()));
+      StmtSchedule = isl_map_from_domain(isl_set_empty(Stmt.getDomainSpace()));
       isl_union_map_free(StmtBand);
     } else {
       assert(isl_union_map_n_map(StmtBand) == 1);
       StmtSchedule = isl_map_from_union_map(StmtBand);
     }
 
-    Stmt->setSchedule(StmtSchedule);
+    Stmt.setSchedule(StmtSchedule);
   }
 
   isl_schedule_free(Schedule);
   isl_union_map_free(NewSchedule);
   return false;
 }
 
 void IslScheduleOptimizer::printScop(raw_ostream &OS, Scop &) const {