[FIX] Adjust execution context of hoisted loads wrt. error domains

[jdoerfert]

Summary

This is a fix for PR26683 that lacks a test case but allows to start a
discussion.

Personally I do not like this solution and will therefor look into another one.
Nevertheless, it might help to compare them.

[etherzhhb]

lib/Analysis/ScopInfo.cpp

2130–2133

Maybe we can just do an insert here:

if (!ErrorDomainMap.insert(std::make_pair(ErrorChildBlock, CurrentDomain).second)
  isl_set_free(CurrentDomain);

[jdoerfert]

I think the solution in http://reviews.llvm.org/D18822 is much better in the long run, thus I abandon this version.

include/polly/ScopInfo.h

private:
   std::shared_ptr<isl_ctx> IslCtx;
 
   /// @brief A map from basic blocks to SCoP statements.
   DenseMap<BasicBlock *, ScopStmt *> StmtMap;
 
   /// @brief A map from basic blocks to their domains.
   DenseMap<BasicBlock *, isl_set *> DomainMap;
 
+  /// @brief A map from error blocks to their domains.
+  DenseMap<BasicBlock *, isl_set *> ErrorDomainMap;
+
   /// Constraints on parameters.
   isl_set *Context;
 
   /// @brief The affinator used to translate SCEVs to isl expressions.
   SCEVAffinator Affinator;
 
   typedef MapVector<std::pair<AssertingVH<const Value>, int>,
                     std::unique_ptr<ScopArrayInfo>>
private:
   /// @brief Simplify the SCoP representation
   ///
   /// At the moment we perform the following simplifications:
   ///   - removal of no-op statements
   /// @param RemoveIgnoredStmts If true, also removed ignored statments.
   /// @see isIgnored()
   void simplifySCoP(bool RemoveIgnoredStmts, DominatorTree &DT, LoopInfo &LI);
 
+  /// @brief TODO
+  __isl_give isl_set *getErrorCtxReachingStmt(ScopStmt &Stmt);
+
   /// @brief Create equivalence classes for required invariant accesses.
   ///
   /// These classes will consolidate multiple required invariant loads from the
   /// same address in order to keep the number of dimensions in the SCoP
   /// description small. For each such class equivalence class only one
   /// representing element, hence one required invariant load, will be chosen
   /// and modeled as parameter. The method
   /// Scop::getRepresentingInvariantLoadSCEV() will replace each element from an

lib/Analysis/ScopInfo.cpp

void Scop::removeErrorBlockDomains(ScopDetection &SD, DominatorTree &DT,
                                    LoopInfo &LI) {
   auto removeDomains = [this, &DT](BasicBlock *Start) {
     auto *BBNode = DT.getNode(Start);
     for (auto *ErrorChild : depth_first(BBNode)) {
       auto *ErrorChildBlock = ErrorChild->getBlock();
       auto *CurrentDomain = DomainMap[ErrorChildBlock];
       auto *Empty = isl_set_empty(isl_set_get_space(CurrentDomain));
       DomainMap[ErrorChildBlock] = Empty;
+      if (!ErrorDomainMap.count(ErrorChildBlock))
+        ErrorDomainMap[ErrorChildBlock] = CurrentDomain;
+      else
         isl_set_free(CurrentDomain);
     }
   };
 
   SmallVector<Region *, 4> Todo = {&R};
 
   while (!Todo.empty()) {
     auto *SubRegion = Todo.back();
     Todo.pop_back();

 Scop::~Scop() {
   isl_set_free(Context);
   isl_set_free(AssumedContext);
   isl_set_free(InvalidContext);
   isl_schedule_free(Schedule);
 
   for (auto It : DomainMap)
     isl_set_free(It.second);
+  for (auto It : ErrorDomainMap)
+    isl_set_free(It.second);
 
   // Free the alias groups
   for (MinMaxVectorPairTy &MinMaxAccessPair : MinMaxAliasGroups) {
     for (MinMaxAccessTy &MMA : MinMaxAccessPair.first) {
       isl_pw_multi_aff_free(MMA.first);
       isl_pw_multi_aff_free(MMA.second);
     }
     for (MinMaxAccessTy &MMA : MinMaxAccessPair.second) {
for (auto &IAClass : InvariantEquivClasses) {
     for (auto *MA : MAs)
       if (MA->getAccessInstruction() == Val)
         return &IAClass;
   }
 
   return nullptr;
 }
 
+isl_set *Scop::getErrorCtxReachingStmt(ScopStmt &Stmt) {
+  auto *ErrorCtx = isl_set_empty(getParamSpace());
+
+  SmallPtrSet<BasicBlock *, 32> FinishedBlocks;
+  SmallVector<BasicBlock *, 32> RemainingBlocks;
+  RemainingBlocks.push_back(Stmt.getEntryBlock());
+  while (!RemainingBlocks.empty()) {
+    auto *BB = RemainingBlocks.pop_back_val();
+    if (!R.contains(BB) || !FinishedBlocks.insert(BB).second)
+      continue;
+    RemainingBlocks.append(pred_begin(BB), pred_end(BB));
+
+    auto It = ErrorDomainMap.find(BB);
+    if (It == ErrorDomainMap.end())
+      continue;
+
+    auto *ErrorDomain = isl_set_copy(It->second);
+    ErrorCtx = isl_set_union(ErrorCtx, isl_set_params(ErrorDomain));
+  }
+
+  return ErrorCtx;
+}
+
 void Scop::addInvariantLoads(ScopStmt &Stmt, MemoryAccessList &InvMAs) {
 
-  // Get the context under which the statement is executed.
+  // Get the context under which the statement is executed but remove error
+  // block domains that reach this statement.
   isl_set *DomainCtx = isl_set_params(Stmt.getDomain());
+  DomainCtx = isl_set_subtract(DomainCtx, getErrorCtxReachingStmt(Stmt));
   DomainCtx = isl_set_remove_redundancies(DomainCtx);
   DomainCtx = isl_set_detect_equalities(DomainCtx);
   DomainCtx = isl_set_coalesce(DomainCtx);
 
   // Project out all parameters that relate to loads in the statement. Otherwise
   // we could have cyclic dependences on the constraints under which the
   // hoisted loads are executed and we could not determine an order in which to
   // pre-load them. This happens because not only lower bounds are part of the