[Polly] Translate Scop::DomainMap to islpp

[grosser]

Amazing. I just pushed this out! Good work.

include/polly/ScopInfo.h

private:
   /// counter. By doing this, we guarantee that the context is deleted when we
   /// delete the last object that creates isl objects with the context.
   std::shared_ptr<isl_ctx> IslCtx;
 
   /// A map from basic blocks to SCoP statements.
   DenseMap<BasicBlock *, ScopStmt *> StmtMap;
 
   /// A map from basic blocks to their domains.
-  DenseMap<BasicBlock *, isl_set *> DomainMap;
+  DenseMap<BasicBlock *, isl::set> DomainMap;
 
   /// Constraints on parameters.
   isl_set *Context;
 
   /// The affinator used to translate SCEVs to isl expressions.
   SCEVAffinator Affinator;
 
   typedef std::map<std::pair<AssertingVH<const Value>, MemoryKind>,

lib/Analysis/ScopInfo.cpp

 
 __isl_give isl_set *Scop::getDomainConditions(const ScopStmt *Stmt) const {
   return getDomainConditions(Stmt->getEntryBlock());
 }
 
 __isl_give isl_set *Scop::getDomainConditions(BasicBlock *BB) const {
   auto DIt = DomainMap.find(BB);
   if (DIt != DomainMap.end())
-    return isl_set_copy(DIt->getSecond());
+    return DIt->getSecond().copy();
 
   auto &RI = *R.getRegionInfo();
   auto *BBR = RI.getRegionFor(BB);
   while (BBR->getEntry() == BB)
     BBR = BBR->getParent();
   return getDomainConditions(BBR->getEntry());
 }
 
 bool Scop::buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI,
                         DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
   bool IsOnlyNonAffineRegion = isNonAffineSubRegion(R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
   int LD = getRelativeLoopDepth(L);
   auto *S = isl_set_universe(isl_space_set_alloc(getIslCtx(), 0, LD + 1));
 
   while (LD-- >= 0) {
     S = addDomainDimId(S, LD + 1, L);
     L = L->getParentLoop();
   }
 
   InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
-  DomainMap[EntryBB] = S;
+  DomainMap[EntryBB] = isl::manage(S);
 
   if (IsOnlyNonAffineRegion)
     return !containsErrorBlock(R->getNode(), *R, LI, DT);
 
   if (!buildDomainsWithBranchConstraints(R, DT, LI, InvalidDomainMap))
     return false;
 
   if (!propagateDomainConstraints(R, DT, LI, InvalidDomainMap))
if (RN->isSubRegion()) {
       if (!isNonAffineSubRegion(SubRegion)) {
         propagateInvalidStmtDomains(SubRegion, DT, LI, InvalidDomainMap);
         continue;
       }
     }
 
     bool ContainsErrorBlock = containsErrorBlock(RN, getRegion(), LI, DT);
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
-    isl_set *&Domain = DomainMap[BB];
+    isl::set &Domain = DomainMap[BB];
     assert(Domain && "Cannot propagate a nullptr");
 
-    auto *InvalidDomain = InvalidDomainMap[BB].copy();
+    isl::set InvalidDomain = InvalidDomainMap[BB];
 
-    bool IsInvalidBlock =
-        ContainsErrorBlock || isl_set_is_subset(Domain, InvalidDomain);
+    bool IsInvalidBlock = ContainsErrorBlock || Domain.is_subset(InvalidDomain);
 
     if (!IsInvalidBlock) {
-      InvalidDomain = isl_set_intersect(InvalidDomain, isl_set_copy(Domain));
+      InvalidDomain = InvalidDomain.intersect(Domain);
     } else {
-      isl_set_free(InvalidDomain);
       InvalidDomain = Domain;
-      isl_set *DomPar = isl_set_params(isl_set_copy(Domain));
-      recordAssumption(ERRORBLOCK, DomPar, BB->getTerminator()->getDebugLoc(),
-                       AS_RESTRICTION);
+      isl::set DomPar = Domain.params();
+      recordAssumption(ERRORBLOCK, DomPar.release(),
+                       BB->getTerminator()->getDebugLoc(), AS_RESTRICTION);
       Domain = nullptr;
     }
 
-    if (isl_set_is_empty(InvalidDomain)) {
-      InvalidDomainMap[BB] = isl::manage(InvalidDomain);
+    if (InvalidDomain.is_empty()) {
+      InvalidDomainMap[BB] = InvalidDomain;
       continue;
     }
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     auto *TI = BB->getTerminator();
     unsigned NumSuccs = RN->isSubRegion() ? 1 : TI->getNumSuccessors();
     for (unsigned u = 0; u < NumSuccs; u++) {
       auto *SuccBB = getRegionNodeSuccessor(RN, TI, u);
 
       // Skip successors outside the SCoP.
       if (!contains(SuccBB))
         continue;
 
       // Skip backedges.
       if (DT.dominates(SuccBB, BB))
         continue;
 
       Loop *SuccBBLoop = getFirstNonBoxedLoopFor(SuccBB, LI, getBoxedLoops());
 
       auto *AdjustedInvalidDomain = adjustDomainDimensions(
-          *this, isl_set_copy(InvalidDomain), BBLoop, SuccBBLoop);
+          *this, InvalidDomain.copy(), BBLoop, SuccBBLoop);
 
       auto *SuccInvalidDomain = InvalidDomainMap[SuccBB].copy();
       SuccInvalidDomain =
           isl_set_union(SuccInvalidDomain, AdjustedInvalidDomain);
       SuccInvalidDomain = isl_set_coalesce(SuccInvalidDomain);
       unsigned NumConjucts = isl_set_n_basic_set(SuccInvalidDomain);
 
       InvalidDomainMap[SuccBB] = isl::manage(SuccInvalidDomain);
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will bail.
       if (NumConjucts < MaxDisjunctsInDomain)
         continue;
 
-      isl_set_free(InvalidDomain);
       InvalidDomainMap.erase(BB);
       invalidate(COMPLEXITY, TI->getDebugLoc());
       return false;
     }
 
-    InvalidDomainMap[BB] = isl::manage(InvalidDomain);
+    InvalidDomainMap[BB] = InvalidDomain;
   }
 
   return true;
 }
 
 void Scop::propagateDomainConstraintsToRegionExit(
     BasicBlock *BB, Loop *BBLoop,
     SmallPtrSetImpl<BasicBlock *> &FinishedExitBlocks, LoopInfo &LI,
while (L && contains(L)) {
     SmallVector<BasicBlock *, 4> LatchBBs;
     BBLoop->getLoopLatches(LatchBBs);
     for (auto *LatchBB : LatchBBs)
       if (BB != LatchBB && BBReg->contains(LatchBB))
         return;
     L = L->getParentLoop();
   }
 
-  auto *Domain = DomainMap[BB];
+  isl::set Domain = DomainMap[BB];
   assert(Domain && "Cannot propagate a nullptr");
 
   Loop *ExitBBLoop = getFirstNonBoxedLoopFor(ExitBB, LI, getBoxedLoops());
 
   // Since the dimensions of @p BB and @p ExitBB might be different we have to
   // adjust the domain before we can propagate it.
-  auto *AdjustedDomain =
-      adjustDomainDimensions(*this, isl_set_copy(Domain), BBLoop, ExitBBLoop);
-  auto *&ExitDomain = DomainMap[ExitBB];
+  isl::set AdjustedDomain = isl::manage(
+      adjustDomainDimensions(*this, Domain.copy(), BBLoop, ExitBBLoop));
+  isl::set &ExitDomain = DomainMap[ExitBB];
 
   // If the exit domain is not yet created we set it otherwise we "add" the
   // current domain.
-  ExitDomain =
-      ExitDomain ? isl_set_union(AdjustedDomain, ExitDomain) : AdjustedDomain;
+  ExitDomain = ExitDomain ? AdjustedDomain.unite(ExitDomain) : AdjustedDomain;
 
   // Initialize the invalid domain.
-  InvalidDomainMap[ExitBB] =
-      isl::manage(isl_set_empty(isl_set_get_space(ExitDomain)));
+  InvalidDomainMap[ExitBB] = ExitDomain.empty(ExitDomain.get_space());
 
   FinishedExitBlocks.insert(ExitBB);
 }
 
 bool Scop::buildDomainsWithBranchConstraints(
     Region *R, DominatorTree &DT, LoopInfo &LI,
     DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
if (containsErrorBlock(RN, getRegion(), LI, DT))
       HasErrorBlock = true;
 
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
     TerminatorInst *TI = BB->getTerminator();
 
     if (isa<UnreachableInst>(TI))
       continue;
 
-    isl_set *Domain = DomainMap.lookup(BB);
+    isl::set Domain = DomainMap.lookup(BB);
     if (!Domain)
       continue;
-    MaxLoopDepth = std::max(MaxLoopDepth, isl_set_n_dim(Domain));
+    MaxLoopDepth = std::max(MaxLoopDepth, isl_set_n_dim(Domain.get()));
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     // Propagate the domain from BB directly to blocks that have a superset
     // domain, at the moment only region exit nodes of regions that start in BB.
     propagateDomainConstraintsToRegionExit(BB, BBLoop, FinishedExitBlocks, LI,
                                            InvalidDomainMap);
 
     // If all successors of BB have been set a domain through the propagation
     // above we do not need to build condition sets but can just skip this
     // block. However, it is important to note that this is a local property
     // with regards to the region @p R. To this end FinishedExitBlocks is a
     // local variable.
     auto IsFinishedRegionExit = [&FinishedExitBlocks](BasicBlock *SuccBB) {
       return FinishedExitBlocks.count(SuccBB);
     };
     if (std::all_of(succ_begin(BB), succ_end(BB), IsFinishedRegionExit))
       continue;
 
     // Build the condition sets for the successor nodes of the current region
     // node. If it is a non-affine subregion we will always execute the single
     // exit node, hence the single entry node domain is the condition set. For
     // basic blocks we use the helper function buildConditionSets.
     SmallVector<isl_set *, 8> ConditionSets;
     if (RN->isSubRegion())
-      ConditionSets.push_back(isl_set_copy(Domain));
-    else if (!buildConditionSets(*this, BB, TI, BBLoop, Domain,
+      ConditionSets.push_back(Domain.copy());
+    else if (!buildConditionSets(*this, BB, TI, BBLoop, Domain.get(),
                                  InvalidDomainMap, ConditionSets))
       return false;
 
     // Now iterate over the successors and set their initial domain based on
     // their condition set. We skip back edges here and have to be careful when
     // we leave a loop not to keep constraints over a dimension that doesn't
     // exist anymore.
     assert(RN->isSubRegion() || TI->getNumSuccessors() == ConditionSets.size());
     for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
-      isl_set *CondSet = ConditionSets[u];
+      isl::set CondSet = isl::manage(ConditionSets[u]);
       BasicBlock *SuccBB = getRegionNodeSuccessor(RN, TI, u);
 
       // Skip blocks outside the region.
-      if (!contains(SuccBB)) {
-        isl_set_free(CondSet);
+      if (!contains(SuccBB))
         continue;
-      }
 
       // If we propagate the domain of some block to "SuccBB" we do not have to
       // adjust the domain.
-      if (FinishedExitBlocks.count(SuccBB)) {
-        isl_set_free(CondSet);
+      if (FinishedExitBlocks.count(SuccBB))
         continue;
-      }
 
       // Skip back edges.
-      if (DT.dominates(SuccBB, BB)) {
-        isl_set_free(CondSet);
+      if (DT.dominates(SuccBB, BB))
         continue;
-      }
 
       Loop *SuccBBLoop = getFirstNonBoxedLoopFor(SuccBB, LI, getBoxedLoops());
 
-      CondSet = adjustDomainDimensions(*this, CondSet, BBLoop, SuccBBLoop);
+      CondSet = isl::manage(
+          adjustDomainDimensions(*this, CondSet.copy(), BBLoop, SuccBBLoop));
 
       // Set the domain for the successor or merge it with an existing domain in
       // case there are multiple paths (without loop back edges) to the
       // successor block.
-      isl_set *&SuccDomain = DomainMap[SuccBB];
+      isl::set &SuccDomain = DomainMap[SuccBB];
 
       if (SuccDomain) {
-        SuccDomain = isl_set_coalesce(isl_set_union(SuccDomain, CondSet));
+        SuccDomain = SuccDomain.unite(CondSet).coalesce();
       } else {
         // Initialize the invalid domain.
-        InvalidDomainMap[SuccBB] =
-            isl::manage(isl_set_empty(isl_set_get_space(CondSet)));
+        InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
         SuccDomain = CondSet;
       }
 
-      SuccDomain = isl_set_detect_equalities(SuccDomain);
+      SuccDomain = SuccDomain.detect_equalities();
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will clean up and bail.
-      if (isl_set_n_basic_set(SuccDomain) < MaxDisjunctsInDomain)
+      if (isl_set_n_basic_set(SuccDomain.get()) < MaxDisjunctsInDomain)
         continue;
 
       invalidate(COMPLEXITY, DebugLoc());
       while (++u < ConditionSets.size())
         isl_set_free(ConditionSets[u]);
       return false;
     }
   }
if (RN->isSubRegion()) {
       if (!isNonAffineSubRegion(SubRegion)) {
         if (!propagateDomainConstraints(SubRegion, DT, LI, InvalidDomainMap))
           return false;
         continue;
       }
     }
 
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
-    isl_set *&Domain = DomainMap[BB];
+    isl::set &Domain = DomainMap[BB];
     assert(Domain);
 
     // Under the union of all predecessor conditions we can reach this block.
-    auto *PredDom = getPredecessorDomainConstraints(BB, Domain, DT, LI);
-    Domain = isl_set_coalesce(isl_set_intersect(Domain, PredDom));
-    Domain = isl_set_align_params(Domain, getParamSpace());
+    isl::set PredDom =
+        isl::manage(getPredecessorDomainConstraints(BB, Domain.get(), DT, LI));
+    Domain = Domain.intersect(PredDom).coalesce();
+    Domain = Domain.align_params(isl::manage(getParamSpace()));
 
     Loop *BBLoop = getRegionNodeLoop(RN, LI);
     if (BBLoop && BBLoop->getHeader() == BB && contains(BBLoop))
       if (!addLoopBoundsToHeaderDomain(BBLoop, LI, InvalidDomainMap))
         return false;
   }
 
   return true;

 
 bool Scop::addLoopBoundsToHeaderDomain(
     Loop *L, LoopInfo &LI, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   int LoopDepth = getRelativeLoopDepth(L);
   assert(LoopDepth >= 0 && "Loop in region should have at least depth one");
 
   BasicBlock *HeaderBB = L->getHeader();
   assert(DomainMap.count(HeaderBB));
-  isl_set *&HeaderBBDom = DomainMap[HeaderBB];
+  isl::set &HeaderBBDom = DomainMap[HeaderBB];
 
-  isl_map *NextIterationMap =
-      createNextIterationMap(isl_set_get_space(HeaderBBDom), LoopDepth);
+  isl::map NextIterationMap = isl::manage(
+      createNextIterationMap(HeaderBBDom.get_space().release(), LoopDepth));
 
-  isl_set *UnionBackedgeCondition =
-      isl_set_empty(isl_set_get_space(HeaderBBDom));
+  isl::set UnionBackedgeCondition = HeaderBBDom.empty(HeaderBBDom.get_space());
 
   SmallVector<llvm::BasicBlock *, 4> LatchBlocks;
   L->getLoopLatches(LatchBlocks);
 
   for (BasicBlock *LatchBB : LatchBlocks) {
 
     // If the latch is only reachable via error statements we skip it.
-    isl_set *LatchBBDom = DomainMap.lookup(LatchBB);
+    isl::set LatchBBDom = DomainMap.lookup(LatchBB);
     if (!LatchBBDom)
       continue;
 
-    isl_set *BackedgeCondition = nullptr;
+    isl::set BackedgeCondition = nullptr;
 
     TerminatorInst *TI = LatchBB->getTerminator();
     BranchInst *BI = dyn_cast<BranchInst>(TI);
     assert(BI && "Only branch instructions allowed in loop latches");
 
     if (BI->isUnconditional())
-      BackedgeCondition = isl_set_copy(LatchBBDom);
+      BackedgeCondition = LatchBBDom;
     else {
       SmallVector<isl_set *, 8> ConditionSets;
       int idx = BI->getSuccessor(0) != HeaderBB;
-      if (!buildConditionSets(*this, LatchBB, TI, L, LatchBBDom,
-                              InvalidDomainMap, ConditionSets)) {
-        isl_map_free(NextIterationMap);
-        isl_set_free(UnionBackedgeCondition);
+      if (!buildConditionSets(*this, LatchBB, TI, L, LatchBBDom.get(),
+                              InvalidDomainMap, ConditionSets))
         return false;
-      }
 
       // Free the non back edge condition set as we do not need it.
       isl_set_free(ConditionSets[1 - idx]);
 
-      BackedgeCondition = ConditionSets[idx];
+      BackedgeCondition = isl::manage(ConditionSets[idx]);
     }
 
     int LatchLoopDepth = getRelativeLoopDepth(LI.getLoopFor(LatchBB));
     assert(LatchLoopDepth >= LoopDepth);
-    BackedgeCondition =
-        isl_set_project_out(BackedgeCondition, isl_dim_set, LoopDepth + 1,
-                            LatchLoopDepth - LoopDepth);
-    UnionBackedgeCondition =
-        isl_set_union(UnionBackedgeCondition, BackedgeCondition);
+    BackedgeCondition = BackedgeCondition.project_out(
+        isl::dim::set, LoopDepth + 1, LatchLoopDepth - LoopDepth);
+    UnionBackedgeCondition = UnionBackedgeCondition.unite(BackedgeCondition);
   }
 
-  isl_map *ForwardMap = isl_map_lex_le(isl_set_get_space(HeaderBBDom));
+  isl::map ForwardMap = ForwardMap.lex_le(HeaderBBDom.get_space());
   for (int i = 0; i < LoopDepth; i++)
-    ForwardMap = isl_map_equate(ForwardMap, isl_dim_in, i, isl_dim_out, i);
+    ForwardMap = ForwardMap.equate(isl::dim::in, i, isl::dim::out, i);
 
-  isl_set *UnionBackedgeConditionComplement =
-      isl_set_complement(UnionBackedgeCondition);
-  UnionBackedgeConditionComplement = isl_set_lower_bound_si(
-      UnionBackedgeConditionComplement, isl_dim_set, LoopDepth, 0);
+  isl::set UnionBackedgeConditionComplement =
+      UnionBackedgeCondition.complement();
+  UnionBackedgeConditionComplement =
+      UnionBackedgeConditionComplement.lower_bound_si(isl::dim::set, LoopDepth,
+                                                      0);
   UnionBackedgeConditionComplement =
-      isl_set_apply(UnionBackedgeConditionComplement, ForwardMap);
-  HeaderBBDom = isl_set_subtract(HeaderBBDom, UnionBackedgeConditionComplement);
-  HeaderBBDom = isl_set_apply(HeaderBBDom, NextIterationMap);
+      UnionBackedgeConditionComplement.apply(ForwardMap);
+  HeaderBBDom = HeaderBBDom.subtract(UnionBackedgeConditionComplement);
+  HeaderBBDom = HeaderBBDom.apply(NextIterationMap);
 
-  auto Parts = partitionSetParts(HeaderBBDom, LoopDepth);
-  HeaderBBDom = Parts.second;
+  auto Parts = partitionSetParts(HeaderBBDom.copy(), LoopDepth);
+  HeaderBBDom = isl::manage(Parts.second);
 
   // Check if there is a <nsw> tagged AddRec for this loop and if so do not add
   // the bounded assumptions to the context as they are already implied by the
   // <nsw> tag.
   if (Affinator.hasNSWAddRecForLoop(L)) {
     isl_set_free(Parts.first);
     return true;
   }
Scop::~Scop() {
   isl_set_free(Context);
   isl_set_free(AssumedContext);
   isl_set_free(InvalidContext);
   isl_schedule_free(Schedule);
 
   for (auto &It : ParameterIds)
     isl_id_free(It.second);
 
-  for (auto It : DomainMap)
-    isl_set_free(It.second);
-
   for (auto &AS : RecordedAssumptions)
     isl_set_free(AS.Set);
 
   // 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);