[Polly][NFC][ScopBuilder] Move addUserContext to ScopBuilder

[domada]

Summary

Scope of changes:

1. Moved addUserContext to ScopBuilder.
2. Moved command line option UserContextStr to ScopBuilder.

[Meinersbur]

LGTM.

Can I commit this patch for you?

[domada]

I think we need to wait with this patch until older patches are merged into repository. I was not able to apply this patch directly on master branch.

polly/trunk/include/polly/ScopBuilder.h

class ScopBuilder {
   ///                      .phiops one. Required for values escaping through a
   ///                      PHINode in the SCoP region's exit block.
   /// @see addPHIReadAccess()
   /// @see MemoryKind
   void ensurePHIWrite(PHINode *PHI, ScopStmt *IncomintStmt,
                       BasicBlock *IncomingBlock, Value *IncomingValue,
                       bool IsExitBlock);
 
+  /// Add user provided parameter constraints to context (command line).
+  void addUserContext();
+
   /// Add all recorded assumptions to the assumed context.
   void addRecordedAssumptions();
 
   /// Create a MemoryAccess for reading the value of a phi.
   ///
   /// The modeling assumes that all incoming blocks write their incoming value
   /// to the same location. Thus, this access will read the incoming block's
   /// value as instructed by this @p PHI.

polly/trunk/include/polly/ScopInfo.h

private:
 
   /// Build the Context of the Scop.
   void buildContext();
 
   /// Add user provided parameter constraints to context (source code).
   void addUserAssumptions(AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI,
                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
-  /// Add user provided parameter constraints to context (command line).
-  void addUserContext();
-
   /// Add the bounds of the parameters to the context.
   void addParameterBounds();
 
   /// Simplify the assumed and invalid context.
   void simplifyContexts();
 
   /// Get the representing SCEV for @p S if applicable, otherwise @p S.
   ///

polly/trunk/lib/Analysis/ScopBuilder.cpp

static cl::opt<unsigned> RunTimeChecksMaxParameters(
     cl::desc("The maximal number of parameters allowed in RTCs."), cl::Hidden,
     cl::ZeroOrMore, cl::init(8), cl::cat(PollyCategory));
 
 static cl::opt<bool> UnprofitableScalarAccs(
     "polly-unprofitable-scalar-accs",
     cl::desc("Count statements with scalar accesses as not optimizable"),
     cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
+static cl::opt<std::string> UserContextStr(
+    "polly-context", cl::value_desc("isl parameter set"),
+    cl::desc("Provide additional constraints on the context parameters"),
+    cl::init(""), cl::cat(PollyCategory));
+
 static cl::opt<bool> DetectFortranArrays(
     "polly-detect-fortran-arrays",
     cl::desc("Detect Fortran arrays and use this for code generation"),
     cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<bool> DetectReductions("polly-detect-reductions",
                                       cl::desc("Detect and exploit reductions"),
                                       cl::Hidden, cl::ZeroOrMore,
bool ScopBuilder::hasNonHoistableBasePtrInScop(MemoryAccess *MA,
   Value *BaseAddr = MA->getOriginalBaseAddr();
   if (auto *BasePtrInst = dyn_cast<Instruction>(BaseAddr))
     if (!isa<LoadInst>(BasePtrInst))
       return scop->contains(BasePtrInst);
 
   return false;
 }
 
+void ScopBuilder::addUserContext() {
+  if (UserContextStr.empty())
+    return;
+
+  isl::set UserContext = isl::set(scop->getIslCtx(), UserContextStr.c_str());
+  isl::space Space = scop->getParamSpace();
+  if (Space.dim(isl::dim::param) != UserContext.dim(isl::dim::param)) {
+    std::string SpaceStr = Space.to_str();
+    errs() << "Error: the context provided in -polly-context has not the same "
+           << "number of dimensions than the computed context. Due to this "
+           << "mismatch, the -polly-context option is ignored. Please provide "
+           << "the context in the parameter space: " << SpaceStr << ".\n";
+    return;
+  }
+
+  for (unsigned i = 0; i < Space.dim(isl::dim::param); i++) {
+    std::string NameContext =
+        scop->getContext().get_dim_name(isl::dim::param, i);
+    std::string NameUserContext = UserContext.get_dim_name(isl::dim::param, i);
+
+    if (NameContext != NameUserContext) {
+      std::string SpaceStr = Space.to_str();
+      errs() << "Error: the name of dimension " << i
+             << " provided in -polly-context "
+             << "is '" << NameUserContext << "', but the name in the computed "
+             << "context is '" << NameContext
+             << "'. Due to this name mismatch, "
+             << "the -polly-context option is ignored. Please provide "
+             << "the context in the parameter space: " << SpaceStr << ".\n";
+      return;
+    }
+
+    UserContext = UserContext.set_dim_id(isl::dim::param, i,
+                                         Space.get_dim_id(isl::dim::param, i));
+  }
+  isl::set newContext = scop->getContext().intersect(UserContext);
+  scop->setContext(newContext);
+}
+
 isl::set ScopBuilder::getNonHoistableCtx(MemoryAccess *Access,
                                          isl::union_map Writes) {
   // TODO: Loads that are not loop carried, hence are in a statement with
   //       zero iterators, are by construction invariant, though we
   //       currently "hoist" them anyway. This is necessary because we allow
   //       them to be treated as parameters (e.g., in conditions) and our code
   //       generation would otherwise use the old value.
 
if (!scop->isProfitable(UnprofitableScalarAccs)) {
     return;
   }
 
   scop->buildSchedule(LI);
 
   scop->finalizeAccesses();
 
   scop->realignParams();
-  scop->addUserContext();
+  addUserContext();
 
   // After the context was fully constructed, thus all our knowledge about
   // the parameters is in there, we add all recorded assumptions to the
   // assumed/invalid context.
   addRecordedAssumptions();
 
   scop->simplifyContexts();
   if (!buildAliasChecks()) {

polly/trunk/lib/Analysis/ScopInfo.cpp

 // number of disjunct when adding non-convex sets to the context.
 static int const MaxDisjunctsInContext = 4;
 
 static cl::opt<bool> PollyRemarksMinimal(
     "polly-remarks-minimal",
     cl::desc("Do not emit remarks about assumptions that are known"),
     cl::Hidden, cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
 
-static cl::opt<std::string> UserContextStr(
-    "polly-context", cl::value_desc("isl parameter set"),
-    cl::desc("Provide additional constraints on the context parameters"),
-    cl::init(""), cl::cat(PollyCategory));
-
 static cl::opt<bool>
     IslOnErrorAbort("polly-on-isl-error-abort",
                     cl::desc("Abort if an isl error is encountered"),
                     cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool> PollyPreciseInbounds(
     "polly-precise-inbounds",
     cl::desc("Take more precise inbounds assumptions (do not scale well)"),
if (!NewParams.empty()) {
       }
     }
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "UserAssumption", CI)
              << "Use user assumption: " << stringFromIslObj(AssumptionCtx));
     Context = Context.intersect(isl::manage(AssumptionCtx));
   }
 }
 
-void Scop::addUserContext() {
-  if (UserContextStr.empty())
-    return;
-
-  isl::set UserContext = isl::set(getIslCtx(), UserContextStr.c_str());
-  isl::space Space = getParamSpace();
-  if (Space.dim(isl::dim::param) != UserContext.dim(isl::dim::param)) {
-    std::string SpaceStr = Space.to_str();
-    errs() << "Error: the context provided in -polly-context has not the same "
-           << "number of dimensions than the computed context. Due to this "
-           << "mismatch, the -polly-context option is ignored. Please provide "
-           << "the context in the parameter space: " << SpaceStr << ".\n";
-    return;
-  }
-
-  for (unsigned i = 0; i < Space.dim(isl::dim::param); i++) {
-    std::string NameContext = Context.get_dim_name(isl::dim::param, i);
-    std::string NameUserContext = UserContext.get_dim_name(isl::dim::param, i);
-
-    if (NameContext != NameUserContext) {
-      std::string SpaceStr = Space.to_str();
-      errs() << "Error: the name of dimension " << i
-             << " provided in -polly-context "
-             << "is '" << NameUserContext << "', but the name in the computed "
-             << "context is '" << NameContext
-             << "'. Due to this name mismatch, "
-             << "the -polly-context option is ignored. Please provide "
-             << "the context in the parameter space: " << SpaceStr << ".\n";
-      return;
-    }
-
-    UserContext = UserContext.set_dim_id(isl::dim::param, i,
-                                         Space.get_dim_id(isl::dim::param, i));
-  }
-
-  Context = Context.intersect(UserContext);
-}
-
 void Scop::buildContext() {
   isl::space Space = isl::space::params_alloc(getIslCtx(), 0);
   Context = isl::set::universe(Space);
   InvalidContext = isl::set::empty(Space);
   AssumedContext = isl::set::universe(Space);
 }
 
 void Scop::addParameterBounds() {