[Polly] Remove the LoopBounds from the TempScop class

[jdoerfert]

Summary

We will use ScalarEvolution in the ScopInfo.cpp to get the loop trip
count, not cache it in the TempScop object.

[jdoerfert]

Closed by commit rL221035 (authored by @jdoerfert).

polly/trunk/include/polly/TempScopInfo.h

 ///
 /// A helper class for remembering the parameter number and the max depth in
 /// this Scop, and others context.
 class TempScop {
   // The Region.
   Region &R;
 
   // 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), LoopBounds(loopBounds), BBConds(BBCmps), AccFuncMap(accFuncMap) {}
+  explicit TempScop(Region &r, BBCondMapType &BBCmps,
+                    AccFuncMapType &accFuncMap)
+      : R(r), 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 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);
-    assert(at != LoopBounds.end() && "Bound for loop not available!");
-    return at->second;
-  }
-
   /// @brief Get the condition from entry block of the Scop to a BasicBlock
   ///
   /// @param BB The BasicBlock
   ///
   /// @return The condition from entry block of the Scop to a BB
   ///
   const BBCond *getBBCond(const BasicBlock *BB) const {
     BBCondMapType::const_iterator at = BBConds.find(BB);
class TempScopInfo : public FunctionPass {
 
   // For condition extraction support.
   DominatorTree *DT;
   PostDominatorTree *PDT;
 
   // Target data for element size computing.
   const DataLayout *TD;
 
-  // Remember the bounds of loops, to help us build iteration domain of BBs.
-  LoopBoundMapType LoopBounds;
-
   // And also Remember the constrains for BBs
   BBCondMapType BBConds;
 
   // 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.
class TempScopInfo : public FunctionPass {
   /// @param R    The SCoP region
   ///
   /// @return     True if the Instruction is used in other BB and a scalar write
   ///             Access is required.
   bool buildScalarDependences(Instruction *Inst, Region *R);
 
   void buildAccessFunctions(Region &RefRegion, BasicBlock &BB);
 
-  void buildLoopBounds(TempScop &Scop);
-
 public:
   static char ID;
   explicit TempScopInfo() : FunctionPass(ID) {}
   ~TempScopInfo();
 
   /// @brief Get the temporay Scop information in LLVM IR represent
   ///        for Region R.
   ///

polly/trunk/lib/Analysis/ScopInfo.cpp

 __isl_give isl_set *ScopStmt::addLoopBoundsToDomain(__isl_take isl_set *Domain,
                                                     TempScop &tempScop) {
   isl_space *Space;
   isl_local_space *LocalSpace;
 
   Space = isl_set_get_space(Domain);
   LocalSpace = isl_local_space_from_space(Space);
 
+  ScalarEvolution *SE = getParent()->getSE();
   for (int i = 0, e = getNumIterators(); i != e; ++i) {
     isl_aff *Zero = isl_aff_zero_on_domain(isl_local_space_copy(LocalSpace));
     isl_pw_aff *IV =
         isl_pw_aff_from_aff(isl_aff_set_coefficient_si(Zero, isl_dim_in, i, 1));
 
     // 0 <= IV.
     isl_set *LowerBound = isl_pw_aff_nonneg_set(isl_pw_aff_copy(IV));
     Domain = isl_set_intersect(Domain, LowerBound);
 
     // IV <= LatchExecutions.
     const Loop *L = getLoopForDimension(i);
-    const SCEV *LatchExecutions = tempScop.getLoopBound(L);
+    const SCEV *LatchExecutions = SE->getBackedgeTakenCount(L);
     isl_pw_aff *UpperBound = SCEVAffinator::getPwAff(this, LatchExecutions);
     isl_set *UpperBoundSet = isl_pw_aff_le_set(IV, UpperBound);
     Domain = isl_set_intersect(Domain, UpperBoundSet);
   }
 
   isl_local_space_free(LocalSpace);
   return Domain;
 }

polly/trunk/lib/Analysis/TempScopInfo.cpp

void TempScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB) {
 
   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();
-
-  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;
-  }
-}
-
 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);
     const SCEV *RHS = SE->getConstant(C->getType(), 1);
 
while (BBNode != EntryNode) {
     Cond.push_back(*Cmp);
   }
 
   if (!Cond.empty())
     BBConds[BB] = Cond;
 }
 
 TempScop *TempScopInfo::buildTempScop(Region &R) {
-  TempScop *TScop = new TempScop(R, LoopBounds, BBConds, AccFuncMap);
+  TempScop *TScop = new TempScop(R, BBConds, AccFuncMap);
 
   for (const auto &BB : R.blocks()) {
     buildAccessFunctions(R, *BB);
     buildCondition(BB, R.getEntry());
   }
 
-  buildLoopBounds(*TScop);
-
   return TScop;
 }
 
 TempScop *TempScopInfo::getTempScop(const Region *R) const {
   TempScopMapType::const_iterator at = TempScops.find(R);
   return at == TempScops.end() ? 0 : at->second;
 }
 
void TempScopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<AliasAnalysis>();
   AU.setPreservesAll();
 }
 
 TempScopInfo::~TempScopInfo() { clear(); }
 
 void TempScopInfo::clear() {
   BBConds.clear();
-  LoopBounds.clear();
   AccFuncMap.clear();
   DeleteContainerSeconds(TempScops);
   TempScops.clear();
 }
 
 //===----------------------------------------------------------------------===//
 // TempScop information extraction pass implement
 char TempScopInfo::ID = 0;