Index: include/polly/ScopInfo.h =================================================================== --- include/polly/ScopInfo.h +++ include/polly/ScopInfo.h @@ -1842,7 +1842,7 @@ void propagateDomainConstraintsToRegionExit( BasicBlock *BB, Loop *BBLoop, SmallPtrSetImpl &FinishedExitBlocks, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Compute the union of predecessor domains for @p BB. /// @@ -1870,7 +1870,7 @@ /// @returns True if there was no problem and false otherwise. bool addLoopBoundsToHeaderDomain( Loop *L, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Compute the branching constraints for each basic block in @p R. /// @@ -1884,7 +1884,7 @@ /// @returns True if there was no problem and false otherwise. bool buildDomainsWithBranchConstraints( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Propagate the domain constraints through the region @p R. /// @@ -1898,7 +1898,7 @@ /// @returns True if there was no problem and false otherwise. bool propagateDomainConstraints( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Propagate invalid domains of statements through @p R. /// @@ -1916,7 +1916,7 @@ /// @returns True if there was no problem and false otherwise. bool propagateInvalidStmtDomains( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Compute the domain for each basic block in @p R. /// @@ -1929,7 +1929,7 @@ /// @returns True if there was no problem and false otherwise. bool buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Add parameter constraints to @p C that imply a non-empty domain. __isl_give isl_set *addNonEmptyDomainConstraints(__isl_take isl_set *C) const; @@ -2039,7 +2039,7 @@ /// Add user provided parameter constraints to context (source code). void addUserAssumptions( AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap); + DenseMap &InvalidDomainMap); /// Add user provided parameter constraints to context (command line). void addUserContext(); Index: lib/Analysis/ScopBuilder.cpp =================================================================== --- lib/Analysis/ScopBuilder.cpp +++ lib/Analysis/ScopBuilder.cpp @@ -964,28 +964,19 @@ scop->buildInvariantEquivalenceClasses(); /// A map from basic blocks to their invalid domains. - DenseMap InvalidDomainMap; + DenseMap InvalidDomainMap; - if (!scop->buildDomains(&R, DT, LI, InvalidDomainMap)) { - for (auto It : InvalidDomainMap) - isl_set_free(It.second); + if (!scop->buildDomains(&R, DT, LI, InvalidDomainMap)) return; - } scop->addUserAssumptions(AC, DT, LI, InvalidDomainMap); // Initialize the invalid domain. for (ScopStmt &Stmt : scop->Stmts) if (Stmt.isBlockStmt()) - Stmt.setInvalidDomain( - isl_set_copy(InvalidDomainMap[Stmt.getEntryBlock()])); + Stmt.setInvalidDomain(InvalidDomainMap[Stmt.getEntryBlock()].get()); else - Stmt.setInvalidDomain( - isl_set_copy(InvalidDomainMap[getRegionNodeBasicBlock( - Stmt.getRegion()->getNode())])); - - for (auto It : InvalidDomainMap) - isl_set_free(It.second); + Stmt.setInvalidDomain(InvalidDomainMap[getRegionNodeBasicBlock(Stmt.getRegion()->getNode())].get()); // Remove empty statements. // Exit early in case there are no executable statements left in this scop. Index: lib/Analysis/ScopInfo.cpp =================================================================== --- lib/Analysis/ScopInfo.cpp +++ lib/Analysis/ScopInfo.cpp @@ -1479,10 +1479,10 @@ __isl_give isl_pw_aff * getPwAff(Scop &S, BasicBlock *BB, - DenseMap &InvalidDomainMap, + DenseMap &InvalidDomainMap, const SCEV *E, bool NonNegative = false) { PWACtx PWAC = S.getPwAff(E, BB, NonNegative); - InvalidDomainMap[BB] = isl_set_union(InvalidDomainMap[BB], PWAC.second); + InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(isl::manage(PWAC.second)); return PWAC.first; } @@ -1494,7 +1494,7 @@ static bool buildConditionSets( Scop &S, BasicBlock *BB, SwitchInst *SI, Loop *L, __isl_keep isl_set *Domain, - DenseMap &InvalidDomainMap, + DenseMap &InvalidDomainMap, SmallVectorImpl<__isl_give isl_set *> &ConditionSets) { Value *Condition = getConditionFromTerminator(SI); @@ -1541,7 +1541,7 @@ static bool buildConditionSets( Scop &S, BasicBlock *BB, Value *Condition, TerminatorInst *TI, Loop *L, __isl_keep isl_set *Domain, - DenseMap &InvalidDomainMap, + DenseMap &InvalidDomainMap, SmallVectorImpl<__isl_give isl_set *> &ConditionSets) { isl_set *ConsequenceCondSet = nullptr; @@ -1632,7 +1632,7 @@ static bool buildConditionSets( Scop &S, BasicBlock *BB, TerminatorInst *TI, Loop *L, __isl_keep isl_set *Domain, - DenseMap &InvalidDomainMap, + DenseMap &InvalidDomainMap, SmallVectorImpl<__isl_give isl_set *> &ConditionSets) { if (SwitchInst *SI = dyn_cast(TI)) @@ -2157,7 +2157,7 @@ void Scop::addUserAssumptions( AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { auto &F = getFunction(); for (auto &Assumption : AC.assumptions()) { auto *CI = dyn_cast_or_null(Assumption); @@ -2656,7 +2656,7 @@ bool Scop::buildDomains( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { bool IsOnlyNonAffineRegion = isNonAffineSubRegion(R); auto *EntryBB = R->getEntry(); @@ -2669,7 +2669,7 @@ L = L->getParentLoop(); } - InvalidDomainMap[EntryBB] = isl_set_empty(isl_set_get_space(S)); + InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S))); DomainMap[EntryBB] = S; if (IsOnlyNonAffineRegion) @@ -2751,7 +2751,7 @@ bool Scop::propagateInvalidStmtDomains( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { ReversePostOrderTraversal RTraversal(R); for (auto *RN : RTraversal) { @@ -2768,26 +2768,25 @@ bool ContainsErrorBlock = containsErrorBlock(RN, getRegion(), LI, DT); BasicBlock *BB = getRegionNodeBasicBlock(RN); - isl_set *&Domain = DomainMap[BB]; + isl::set Domain = isl::manage(DomainMap[BB]); assert(Domain && "Cannot propagate a nullptr"); - auto *InvalidDomain = InvalidDomainMap[BB]; + isl::set InvalidDomain = InvalidDomainMap[BB]; bool IsInvalidBlock = - ContainsErrorBlock || isl_set_is_subset(Domain, InvalidDomain); + ContainsErrorBlock || isl_set_is_subset(Domain.keep(), InvalidDomain.keep()); 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(), + isl::set DomPar = Domain.params(); + recordAssumption(ERRORBLOCK, DomPar.release(), BB->getTerminator()->getDebugLoc(), AS_RESTRICTION); Domain = nullptr; } - if (isl_set_is_empty(InvalidDomain)) { + if (InvalidDomain.is_empty()) { InvalidDomainMap[BB] = InvalidDomain; continue; } @@ -2809,13 +2808,12 @@ 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]; - SuccInvalidDomain = - isl_set_union(SuccInvalidDomain, AdjustedInvalidDomain); - SuccInvalidDomain = isl_set_coalesce(SuccInvalidDomain); - unsigned NumConjucts = isl_set_n_basic_set(SuccInvalidDomain); + isl::set SuccInvalidDomain = InvalidDomainMap[SuccBB]; + SuccInvalidDomain = SuccInvalidDomain.unite(isl::manage(AdjustedInvalidDomain)); + SuccInvalidDomain = SuccInvalidDomain.coalesce(); + unsigned NumConjucts = isl_set_n_basic_set(SuccInvalidDomain.get()); InvalidDomainMap[SuccBB] = SuccInvalidDomain; @@ -2824,7 +2822,6 @@ if (NumConjucts < MaxDisjunctsInDomain) continue; - isl_set_free(InvalidDomain); invalidate(COMPLEXITY, TI->getDebugLoc()); return false; } @@ -2838,7 +2835,7 @@ void Scop::propagateDomainConstraintsToRegionExit( BasicBlock *BB, Loop *BBLoop, SmallPtrSetImpl &FinishedExitBlocks, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { // Check if the block @p BB is the entry of a region. If so we propagate it's // domain to the exit block of the region. Otherwise we are done. @@ -2877,17 +2874,14 @@ ExitDomain ? isl_set_union(AdjustedDomain, ExitDomain) : AdjustedDomain; // Initialize the invalid domain. - auto IDIt = InvalidDomainMap.find(ExitBB); - if (IDIt != InvalidDomainMap.end()) - isl_set_free(IDIt->getSecond()); - InvalidDomainMap[ExitBB] = isl_set_empty(isl_set_get_space(ExitDomain)); + InvalidDomainMap[ExitBB] = isl::manage(isl_set_empty(isl_set_get_space(ExitDomain))); FinishedExitBlocks.insert(ExitBB); } bool Scop::buildDomainsWithBranchConstraints( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { // To create the domain for each block in R we iterate over all blocks and // subregions in R and propagate the conditions under which the current region @@ -2925,10 +2919,10 @@ if (isa(TI)) continue; - isl_set *Domain = DomainMap.lookup(BB); + isl::set Domain = isl::manage(DomainMap.lookup(BB)); if (!Domain) continue; - MaxLoopDepth = std::max(MaxLoopDepth, isl_set_n_dim(Domain)); + MaxLoopDepth = std::max(MaxLoopDepth, isl_set_n_dim(Domain.keep())); auto *BBLoop = getRegionNodeLoop(RN, LI); // Propagate the domain from BB directly to blocks that have a superset @@ -2953,8 +2947,8 @@ // basic blocks we use the helper function buildConditionSets. SmallVector 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; @@ -2993,24 +2987,21 @@ // 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 = isl::manage(DomainMap[SuccBB]); if (SuccDomain) { - SuccDomain = isl_set_coalesce(isl_set_union(SuccDomain, CondSet)); + SuccDomain = SuccDomain.unite(isl::manage(CondSet)).coalesce(); } else { // Initialize the invalid domain. - auto IDIt = InvalidDomainMap.find(SuccBB); - if (IDIt != InvalidDomainMap.end()) - isl_set_free(IDIt->getSecond()); - InvalidDomainMap[SuccBB] = isl_set_empty(isl_set_get_space(CondSet)); - SuccDomain = CondSet; + InvalidDomainMap[SuccBB] = isl::manage(isl_set_empty(isl_set_get_space(CondSet))); + SuccDomain = isl::manage(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()); @@ -3082,7 +3073,7 @@ bool Scop::propagateDomainConstraints( Region *R, DominatorTree &DT, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &InvalidDomainMap) { // Iterate over the region R and propagate the domain constrains from the // predecessors to the current node. In contrast to the // buildDomainsWithBranchConstraints function, this one will pull the domain @@ -3107,13 +3098,13 @@ } BasicBlock *BB = getRegionNodeBasicBlock(RN); - isl_set *&Domain = DomainMap[BB]; + isl::set Domain = isl::manage(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)) @@ -3149,19 +3140,17 @@ bool Scop::addLoopBoundsToHeaderDomain( Loop *L, LoopInfo &LI, - DenseMap &InvalidDomainMap) { + DenseMap &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 = isl::manage(DomainMap[HeaderBB]); - isl_map *NextIterationMap = - createNextIterationMap(isl_set_get_space(HeaderBBDom), LoopDepth); + isl::map NextIterationMap = isl::manage(createNextIterationMap(HeaderBBDom.get_space().get(), LoopDepth)); - isl_set *UnionBackedgeCondition = - isl_set_empty(isl_set_get_space(HeaderBBDom)); + isl::set UnionBackedgeCondition = UnionBackedgeCondition.empty(HeaderBBDom.get_space()); SmallVector LatchBlocks; L->getLoopLatches(LatchBlocks); @@ -3169,57 +3158,48 @@ 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 = isl::manage(DomainMap.lookup(LatchBB)); if (!LatchBBDom) continue; - isl_set *BackedgeCondition = nullptr; + isl::set BackedgeCondition = nullptr; TerminatorInst *TI = LatchBB->getTerminator(); BranchInst *BI = dyn_cast(TI); assert(BI && "Only branch instructions allowed in loop latches"); if (BI->isUnconditional()) - BackedgeCondition = isl_set_copy(LatchBBDom); + BackedgeCondition = LatchBBDom; else { SmallVector 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); - - isl_set *UnionBackedgeConditionComplement = - isl_set_complement(UnionBackedgeCondition); - UnionBackedgeConditionComplement = isl_set_lower_bound_si( - UnionBackedgeConditionComplement, isl_dim_set, LoopDepth, 0); - UnionBackedgeConditionComplement = - isl_set_apply(UnionBackedgeConditionComplement, ForwardMap); - HeaderBBDom = isl_set_subtract(HeaderBBDom, UnionBackedgeConditionComplement); - HeaderBBDom = isl_set_apply(HeaderBBDom, NextIterationMap); - - auto Parts = partitionSetParts(HeaderBBDom, LoopDepth); + ForwardMap = ForwardMap.equate(isl::dim::in, i, isl::dim::out, i); + + isl::set UnionBackedgeConditionComplement = UnionBackedgeCondition.complement(); + UnionBackedgeConditionComplement = UnionBackedgeConditionComplement.lower_bound_si(isl::dim::set, LoopDepth, 0); + UnionBackedgeConditionComplement = UnionBackedgeConditionComplement.apply(ForwardMap); + HeaderBBDom = HeaderBBDom.subtract(UnionBackedgeConditionComplement); + HeaderBBDom = HeaderBBDom.apply(NextIterationMap); + + auto Parts = isl::manage(partitionSetParts(HeaderBBDom.copy(), LoopDepth)); HeaderBBDom = Parts.second; // Check if there is a tagged AddRec for this loop and if so do not add