[Polly] Remove the MaxLoopDepth attribute from TempScops

[jdoerfert]

Summary

Now MaxLoopDepth only lives in Scops not in TempScops anymore.
This is the first part of a series of changes to make TempScops
obsolete.

[jdoerfert]

Closed by commit rL221026 (authored by @jdoerfert).

include/polly/TempScopInfo.h

 /// @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;
 
-  // The max loop depth of this Scop
-  unsigned MaxLoopDepth;
-
   // Remember the bounds of loops, to help us build iteration domain of BBs.
   const LoopBoundMapType &LoopBounds;
   const BBCondMapType &BBConds;
 
   // Access function of bbs.
   const AccFuncMapType &AccFuncMap;
 
   friend class TempScopInfo;
 
   explicit TempScop(Region &r, LoopBoundMapType &loopBounds,
                     BBCondMapType &BBCmps, AccFuncMapType &accFuncMap)
-      : R(r), MaxLoopDepth(0), LoopBounds(loopBounds), BBConds(BBCmps),
-        AccFuncMap(accFuncMap) {}
+      : R(r), LoopBounds(loopBounds), BBConds(BBCmps), 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 the maximum loop depth of Region R.
-  ///
-  /// @return The maximum loop depth of Region R.
-  unsigned getMaxLoopDepth() const { return MaxLoopDepth; }
-
   /// @brief Get the loop bounds of the given loop.
   ///
   /// @param L The loop to get the bounds.
   ///
   /// @return The bounds of the loop L in { Lower bound, Upper bound } form.
   ///
   const SCEV *getLoopBound(const Loop *L) const {
     LoopBoundMapType::const_iterator at = LoopBounds.find(L);

lib/Analysis/ScopInfo.cpp

for (AliasGroupTy &AG : AliasGroups) {
 
     if (!Valid)
       break;
   }
 
   return Valid;
 }
 
+static unsigned getMaxLoopDepthInRegion(const Region &R, LoopInfo &LI) {
+  unsigned MinLD = INT_MAX, MaxLD = 0;
+  for (BasicBlock *BB : R.blocks()) {
+    if (Loop *L = LI.getLoopFor(BB)) {
+      unsigned LD = L->getLoopDepth();
+      MinLD = std::min(MinLD, LD);
+      MaxLD = std::max(MaxLD, LD);
+    }
+  }
+
+  // Handle the case that there is no loop in the SCoP first.
+  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(TempScop &tempScop, LoopInfo &LI, ScalarEvolution &ScalarEvolution,
            isl_ctx *Context)
     : SE(&ScalarEvolution), R(tempScop.getMaxRegion()),
-      MaxLoopDepth(tempScop.getMaxLoopDepth()) {
+      MaxLoopDepth(getMaxLoopDepthInRegion(tempScop.getMaxRegion(), LI)) {
   IslCtx = Context;
   buildContext();
 
   SmallVector<Loop *, 8> NestLoops;
   SmallVector<unsigned, 8> Scatter;
 
   Scatter.assign(MaxLoopDepth + 1, 0);
 
if (!Valid) {
 
     delete scop;
     scop = nullptr;
     return false;
   }
 
   // Statistics after we know the SCoP is valid.
   ++ScopFound;
-  if (tempScop->getMaxLoopDepth() > 0)
+  if (scop->getMaxLoopDepth() > 0)
     ++RichScopFound;
 
   return false;
 }
 
 char ScopInfo::ID = 0;
 
 Pass *polly::createScopInfoPass() { return new ScopInfo(); }

lib/Analysis/TempScopInfo.cpp

inline raw_ostream &operator<<(raw_ostream &OS, const BBCond &Cond) {
   return OS;
 }
 
 //===----------------------------------------------------------------------===//
 // TempScop implementation
 TempScop::~TempScop() {}
 
 void TempScop::print(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI) const {
-  OS << "Scop: " << R.getNameStr() << ", Max Loop Depth: " << MaxLoopDepth
-     << "\n";
+  OS << "Scop: " << R.getNameStr() << "\n";
 
   printDetail(OS, SE, LI, &R, 0);
 }
 
 void TempScop::printDetail(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()) {
if (Functions.empty())
     return;
 
   AccFuncSetType &Accs = AccFuncMap[&BB];
   Accs.insert(Accs.end(), Functions.begin(), Functions.end());
 }
 
 void TempScopInfo::buildLoopBounds(TempScop &Scop) {
   Region &R = Scop.getMaxRegion();
-  unsigned MaxLoopDepth = 0;
 
   for (auto const &BB : R.blocks()) {
     Loop *L = LI->getLoopFor(BB);
 
     if (!L || !R.contains(L))
       continue;
 
     if (LoopBounds.find(L) != LoopBounds.end())
       continue;
 
     const SCEV *BackedgeTakenCount = SE->getBackedgeTakenCount(L);
     LoopBounds[L] = BackedgeTakenCount;
-
-    Loop *OL = R.outermostLoopInRegion(L);
-    unsigned LoopDepth = L->getLoopDepth() - OL->getLoopDepth() + 1;
-
-    if (LoopDepth > MaxLoopDepth)
-      MaxLoopDepth = LoopDepth;
   }
-
-  Scop.MaxLoopDepth = MaxLoopDepth;
 }
 
 void TempScopInfo::buildAffineCondition(Value &V, bool inverted,
                                         Comparison **Comp) const {
   if (ConstantInt *C = dyn_cast<ConstantInt>(&V)) {
     // If this is always true condition, we will create 0 <= 1,
     // otherwise we will create 0 >= 1.
     const SCEV *LHS = SE->getConstant(C->getType(), 0);