[Polly][NFC][ScopBuilder] Move verifyInvariantLoads function from ScopInfo

[domada]

Summary

Refactor Scop and ScopBuilder class. Move verifyInvariantLoads from Scop class to ScopBuilder class.

[Meinersbur]

LGTM.

Do you want me to commit?

[domada]

Yes, please do a commit.

polly/include/polly/ScopBuilder.h

class ScopBuilder {
   /// base address check rules out impossible reductions candidates early. The
   /// overlap check, together with the "only one user" check in
   /// collectCandidateReductionLoads, guarantees that none of the intermediate
   /// results will escape during execution of the loop nest. We basically check
   /// here that no other memory access can access the same memory as the
   /// potential reduction.
   void checkForReductions(ScopStmt &Stmt);
 
+  /// Verify that all required invariant loads have been hoisted.
+  ///
+  /// Invariant load hoisting is not guaranteed to hoist all loads that were
+  /// assumed to be scop invariant during scop detection. This function checks
+  /// for cases where the hoisting failed, but where it would have been
+  /// necessary for our scop modeling to be correct. In case of insufficient
+  /// hoisting the scop is marked as invalid.
+  ///
+  /// In the example below Bound[1] is required to be invariant:
+  ///
+  /// for (int i = 1; i < Bound[0]; i++)
+  ///   for (int j = 1; j < Bound[1]; j++)
+  ///     ...
+  void verifyInvariantLoads();
+
   /// Collect loads which might form a reduction chain with @p StoreMA.
   ///
   /// Check if the stored value for @p StoreMA is a binary operator with one or
   /// two loads as operands. If the binary operand is commutative & associative,
   /// used only once (by @p StoreMA) and its load operands are also used only
   /// once, we have found a possible reduction chain. It starts at an operand
   /// load and includes the binary operator and @p StoreMA.
   ///

polly/include/polly/ScopInfo.h

private:
   ///
   /// @param Access The access to check.
   /// @param Writes The set of all memory writes in the scop.
   ///
   /// @return Return the context under which the access cannot be hoisted or a
   ///         nullptr if it cannot be hoisted at all.
   isl::set getNonHoistableCtx(MemoryAccess *Access, isl::union_map Writes);
 
-  /// Verify that all required invariant loads have been hoisted.
-  ///
-  /// Invariant load hoisting is not guaranteed to hoist all loads that were
-  /// assumed to be scop invariant during scop detection. This function checks
-  /// for cases where the hoisting failed, but where it would have been
-  /// necessary for our scop modeling to be correct. In case of insufficient
-  /// hoisting the scop is marked as invalid.
-  ///
-  /// In the example below Bound[1] is required to be invariant:
-  ///
-  /// for (int i = 1; i < Bound[0]; i++)
-  ///   for (int j = 1; j < Bound[1]; j++)
-  ///     ...
-  void verifyInvariantLoads();
-
   /// Hoist invariant memory loads and check for required ones.
   ///
   /// We first identify "common" invariant loads, thus loads that are invariant
   /// and can be hoisted. Then we check if all required invariant loads have
   /// been identified as (common) invariant. A load is a required invariant load
   /// if it was assumed to be invariant during SCoP detection, e.g., to assume
   /// loop bounds to be affine or runtime alias checks to be placeable. In case
   /// a required invariant load was not identified as (common) invariant we will

polly/lib/Analysis/ScopBuilder.cpp

for (const auto &CandidatePair : Candidates) {
 
     // If no overlapping access was found we mark the load and store as
     // reduction like.
     CandidatePair.first->markAsReductionLike(RT);
     CandidatePair.second->markAsReductionLike(RT);
   }
 }
 
+void ScopBuilder::verifyInvariantLoads() {
+  auto &RIL = scop->getRequiredInvariantLoads();
+  for (LoadInst *LI : RIL) {
+    assert(LI && scop->contains(LI));
+    // If there exists a statement in the scop which has a memory access for
+    // @p LI, then mark this scop as infeasible for optimization.
+    for (ScopStmt &Stmt : *scop)
+      if (Stmt.getArrayAccessOrNULLFor(LI)) {
+        scop->invalidate(INVARIANTLOAD, LI->getDebugLoc(), LI->getParent());
+        return;
+      }
+  }
+}
+
 void ScopBuilder::collectCandidateReductionLoads(
     MemoryAccess *StoreMA, SmallVectorImpl<MemoryAccess *> &Loads) {
   ScopStmt *Stmt = StoreMA->getStatement();
 
   auto *Store = dyn_cast<StoreInst>(StoreMA->getAccessInstruction());
   if (!Store)
     return;
 
void ScopBuilder::buildScop(Region &R, AssumptionCache &AC,
   scop->simplifyContexts();
   if (!scop->buildAliasChecks(AA)) {
     LLVM_DEBUG(dbgs() << "Bailing-out because could not build alias checks\n");
     return;
   }
 
   scop->hoistInvariantLoads();
   scop->canonicalizeDynamicBasePtrs();
-  scop->verifyInvariantLoads();
+  verifyInvariantLoads();
   scop->simplifySCoP(true);
 
   // Check late for a feasible runtime context because profitability did not
   // change.
   if (!scop->hasFeasibleRuntimeContext()) {
     LLVM_DEBUG(dbgs() << "Bailing-out because of unfeasible context (late)\n");
     return;
   }

polly/lib/Analysis/ScopInfo.cpp

isl::set Scop::getNonHoistableCtx(MemoryAccess *Access, isl::union_map Writes) {
   if (TooComplex || !isRequiredInvariantLoad(LI))
     return nullptr;
 
   addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(), AS_RESTRICTION,
                 LI->getParent());
   return WrittenCtx;
 }
 
-void Scop::verifyInvariantLoads() {
-  auto &RIL = getRequiredInvariantLoads();
-  for (LoadInst *LI : RIL) {
-    assert(LI && contains(LI));
-    // If there exists a statement in the scop which has a memory access for
-    // @p LI, then mark this scop as infeasible for optimization.
-    for (ScopStmt &Stmt : Stmts)
-      if (Stmt.getArrayAccessOrNULLFor(LI)) {
-        invalidate(INVARIANTLOAD, LI->getDebugLoc(), LI->getParent());
-        return;
-      }
-  }
-}
-
 void Scop::hoistInvariantLoads() {
   if (!PollyInvariantLoadHoisting)
     return;
 
   isl::union_map Writes = getWrites();
   for (ScopStmt &Stmt : *this) {
     InvariantAccessesTy InvariantAccesses;