[Polly][Isl] Stop generating isl::union_{set,map} from isl::space. NFC

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.

Changes made:

• Stop generating isl::union_set and isl::union_map` from isl::space and instead generate them from isl::ctx
• Disable clang-format on isl-noexceptions.h
• Removed isl::union_{set,map} generator from isl::space from isl-noexceptions.h
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/87c3413b6f1d62ca3dddf716352f90a0b8533353

[patacca]

Disable clang-format on isl-noexceptions.h

[Meinersbur]

polly/lib/Analysis/DependenceInfo.cpp

645

Prefer S.getIslCtx()

polly/lib/Analysis/ScopBuilder.cpp

3369

Prefer scop->getIslCtx()

polly/lib/Analysis/ScopInfo.cpp

2317

Prefer S.getIslCtx()

[Meinersbur]

polly/lib/Exchange/JSONExporter.cpp

324

polly/lib/External/isl/include/isl/isl-noexceptions.h

8

When running ninja polly-update-format this file should have been ignored. Are you calling clang-format manually?

In any case, adding this annotation by the generator is fine.

[patacca]

Prefer Scop::getIslCtx() to Scop::getContext().ctx()

[patacca]

polly/lib/External/isl/include/isl/isl-noexceptions.h

8

I added this annotation to remove the lint errors that are added automatically by the buildbot and that make harder to read the diff, but I see that the clang-tidy warnings are still present so there might be a different annotation for those (maybe //clang-tidy off?)
I've never had troubles with ninja polly-update-format in the sense that it never affected isl-noexceptions.h but in the previous revision (https://reviews.llvm.org/D105691?vs=on&id=357473) there were tons of clang-format warnings on isl-noexceptions.h generated by the buildbot so it might be using a different command than ninja polly-check-format

[patacca]

Rebase to main to get rid of the unrelated failed tests

[Meinersbur]

LGTM

polly/lib/External/isl/include/isl/isl-noexceptions.h

8

The warning is indeed by clang-tidy (clang-format does not try to open included files).

I don't know a way to switch it off locally.

polly/lib/Analysis/DependenceInfo.cpp

 }
 
 bool Dependences::isValidSchedule(
     Scop &S, const StatementToIslMapTy &NewSchedule) const {
   if (LegalityCheckDisabled)
     return true;
 
   isl::union_map Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);
-  isl::space Space = S.getParamSpace();
-  isl::union_map Schedule = isl::union_map::empty(Space);
+  isl::union_map Schedule = isl::union_map::empty(S.getIslCtx());
 
   isl::space ScheduleSpace;
 
   for (ScopStmt &Stmt : S) {
     isl::map StmtScat;
 
     auto Lookup = NewSchedule.find(&Stmt);
     if (Lookup == NewSchedule.end())
void Dependences::releaseMemory() {
   for (auto &ReductionDeps : ReductionDependences)
     isl_map_free(ReductionDeps.second);
   ReductionDependences.clear();
 }
 
 isl::union_map Dependences::getDependences(int Kinds) const {
   assert(hasValidDependences() && "No valid dependences available");
   isl::space Space = isl::manage_copy(RAW).get_space();
-  isl::union_map Deps = Deps.empty(Space);
+  isl::union_map Deps = Deps.empty(Space.ctx());
 
   if (Kinds & TYPE_RAW)
     Deps = Deps.unite(isl::manage_copy(RAW));
 
   if (Kinds & TYPE_WAR)
     Deps = Deps.unite(isl::manage_copy(WAR));
 
   if (Kinds & TYPE_WAW)

polly/lib/Analysis/ScopBuilder.cpp

 }
 
 /// Wrapper function to calculate minimal/maximal accesses to each array.
 bool ScopBuilder::calculateMinMaxAccess(AliasGroupTy AliasGroup,
                                         Scop::MinMaxVectorTy &MinMaxAccesses) {
   MinMaxAccesses.reserve(AliasGroup.size());
 
   isl::union_set Domains = scop->getDomains();
-  isl::union_map Accesses = isl::union_map::empty(scop->getParamSpace());
+  isl::union_map Accesses = isl::union_map::empty(scop->getIslCtx());
 
   for (MemoryAccess *MA : AliasGroup)
     Accesses = Accesses.add_map(MA->getAccessRelation());
 
   Accesses = Accesses.intersect_domain(Domains);
   isl::union_set Locations = Accesses.range();
 
   bool LimitReached = false;

polly/lib/Analysis/ScopInfo.cpp

 isl::pw_aff Scop::getPwAffOnly(const SCEV *E, BasicBlock *BB,
                                RecordedAssumptionsTy *RecordedAssumptions) {
   PWACtx PWAC = getPwAff(E, BB, RecordedAssumptions);
   return PWAC.first;
 }
 
 isl::union_map
 Scop::getAccessesOfType(std::function<bool(MemoryAccess &)> Predicate) {
-  isl::union_map Accesses = isl::union_map::empty(getParamSpace());
+  isl::union_map Accesses = isl::union_map::empty(getIslCtx());
 
   for (ScopStmt &Stmt : *this) {
     for (MemoryAccess *MA : Stmt) {
       if (!Predicate(*MA))
         continue;
 
       isl::set Domain = Stmt.getDomain();
       isl::map AccessDomain = MA->getAccessRelation();

polly/lib/CodeGen/PPCGCodeGeneration.cpp

static MustKillsInfo computeMustKillsInfo(const Scop &S) {
   //      1.2 scalars that are only used within the scop
   SmallVector<isl::id, 4> KillMemIds;
   for (ScopArrayInfo *SAI : S.arrays()) {
     if (SAI->isPHIKind() ||
         (SAI->isValueKind() && isScalarUsesContainedInScop(S, SAI)))
       KillMemIds.push_back(isl::manage(SAI->getBasePtrId().release()));
   }
 
-  Info.TaggedMustKills = isl::union_map::empty(ParamSpace);
-  Info.MustKills = isl::union_map::empty(ParamSpace);
+  Info.TaggedMustKills = isl::union_map::empty(ParamSpace.ctx());
+  Info.MustKills = isl::union_map::empty(ParamSpace.ctx());
 
   // Initialising KillsSchedule to `isl_set_empty` creates an empty node in the
   // schedule:
   //     - filter: "[control] -> { }"
   // So, we choose to not create this to keep the output a little nicer,
   // at the cost of some code complexity.
   Info.KillsSchedule = {};
 

polly/lib/Exchange/JSONExporter.cpp

static bool importSchedule(Scop &S, const json::Object &JScop,
 
   // Check whether the new schedule is valid or not.
   if (!D.isValidSchedule(S, NewSchedule)) {
     errs() << "JScop file contains a schedule that changes the "
            << "dependences. Use -disable-polly-legality to continue anyways\n";
     return false;
   }
 
-  auto ScheduleMap = isl::union_map::empty(S.getParamSpace());
+  auto ScheduleMap = isl::union_map::empty(S.getIslCtx());
   for (ScopStmt &Stmt : S) {
     if (NewSchedule.find(&Stmt) != NewSchedule.end())
       ScheduleMap = ScheduleMap.add_map(NewSchedule[&Stmt]);
     else
       ScheduleMap = ScheduleMap.add_map(Stmt.getSchedule());
   }
 
   S.setSchedule(ScheduleMap);

polly/lib/External/isl/include/isl/isl-noexceptions.h

 /// These are automatically generated checked C++ bindings for isl.
 ///
 /// isl is a library for computing with integer sets and maps described by
 /// Presburger formulas. On top of this, isl provides various tools for
 /// polyhedral compilation, ranging from dependence analysis over scheduling
 /// to AST generation.
 
+// clang-format off
+
 #ifndef ISL_CPP_CHECKED
 #define ISL_CPP_CHECKED
 
 #include <isl/id.h>
 #include <isl/space.h>
 #include <isl/val.h>
 #include <isl/aff.h>
 #include <isl/set.h>
public:
   inline isl::union_map detect_equalities() const;
   inline isl_size dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_map domain_factor_domain() const;
   inline isl::union_map domain_factor_range() const;
   inline isl::union_map domain_map() const;
   inline isl::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
   inline isl::union_map domain_product(isl::union_map umap2) const;
-  static inline isl::union_map empty(isl::space space);
   static inline isl::union_map empty(isl::ctx ctx);
-  static inline isl::union_map empty_space(isl::space space);
   inline isl::union_map eq_at(isl::multi_union_pw_aff mupa) const;
   inline isl::map extract_map(isl::space space) const;
   inline isl::union_map factor_domain() const;
   inline isl::union_map factor_range() const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::union_map fixed_power(isl::val exp) const;
   inline isl::union_map flat_domain_product(isl::union_map umap2) const;
   inline isl::union_map flat_range_product(isl::union_map umap2) const;
public:
   inline isl::union_set align_params(isl::space model) const;
   inline isl::union_set apply(isl::union_map umap) const;
   inline isl::union_set coalesce() const;
   inline isl::union_set coefficients() const;
   inline isl::schedule compute_schedule(isl::union_map validity, isl::union_map proximity) const;
   inline boolean contains(const isl::space &space) const;
   inline isl::union_set detect_equalities() const;
   inline isl_size dim(isl::dim type) const;
-  static inline isl::union_set empty(isl::space space);
   static inline isl::union_set empty(isl::ctx ctx);
-  static inline isl::union_set empty_space(isl::space space);
   inline isl::set extract_set(isl::space space) const;
   inline stat foreach_point(const std::function<stat(point)> &fn) const;
   inline stat foreach_set(const std::function<stat(set)> &fn) const;
   inline isl::basic_set_list get_basic_set_list() const;
   inline uint32_t get_hash() const;
   inline isl::set_list get_set_list() const;
   inline isl::space get_space() const;
   inline isl::union_set gist(isl::union_set context) const;

 }
 
 isl::union_map union_map::domain_product(isl::union_map umap2) const
 {
   auto res = isl_union_map_domain_product(copy(), umap2.release());
   return manage(res);
 }
 
-isl::union_map union_map::empty(isl::space space)
-{
-  auto res = isl_union_map_empty(space.release());
-  return manage(res);
-}
-
 isl::union_map union_map::empty(isl::ctx ctx)
 {
   auto res = isl_union_map_empty_ctx(ctx.release());
   return manage(res);
 }
 
-isl::union_map union_map::empty_space(isl::space space)
-{
-  auto res = isl_union_map_empty_space(space.release());
-  return manage(res);
-}
-
 isl::union_map union_map::eq_at(isl::multi_union_pw_aff mupa) const
 {
   auto res = isl_union_map_eq_at_multi_union_pw_aff(copy(), mupa.release());
   return manage(res);
 }
 
 isl::map union_map::extract_map(isl::space space) const
 {

 }
 
 isl_size union_set::dim(isl::dim type) const
 {
   auto res = isl_union_set_dim(get(), static_cast<enum isl_dim_type>(type));
   return res;
 }
 
-isl::union_set union_set::empty(isl::space space)
-{
-  auto res = isl_union_set_empty(space.release());
-  return manage(res);
-}
-
 isl::union_set union_set::empty(isl::ctx ctx)
 {
   auto res = isl_union_set_empty_ctx(ctx.release());
   return manage(res);
 }
 
-isl::union_set union_set::empty_space(isl::space space)
-{
-  auto res = isl_union_set_empty_space(space.release());
-  return manage(res);
-}
-
 isl::set union_set::extract_set(isl::space space) const
 {
   auto res = isl_union_set_extract_set(get(), space.release());
   return manage(res);
 }
 
 stat union_set::foreach_point(const std::function<stat(point)> &fn) const
 {

polly/lib/Support/ISLTools.cpp

 isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   isl::space RangeSpace = Map.get_space().range();
   isl::map ScatterRel =
       Strict ? isl::map::lex_gt(RangeSpace) : isl::map::lex_ge(RangeSpace);
   return Map.apply_range(ScatterRel);
 }
 
 isl::union_map polly::beforeScatter(isl::union_map UMap, bool Strict) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
 
   for (isl::map Map : UMap.get_map_list()) {
     isl::map After = beforeScatter(Map, Strict);
     Result = Result.add_map(After);
   }
 
   return Result;
 }
 
 isl::map polly::afterScatter(isl::map Map, bool Strict) {
   isl::space RangeSpace = Map.get_space().range();
   isl::map ScatterRel =
       Strict ? isl::map::lex_lt(RangeSpace) : isl::map::lex_le(RangeSpace);
   return Map.apply_range(ScatterRel);
 }
 
 isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     isl::map After = afterScatter(Map, Strict);
     Result = Result.add_map(After);
   }
   return Result;
 }
 
 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
isl::map polly::makeIdentityMap(const isl::set &Set, bool RestrictDomain) {
   isl::map Result = isl::map::identity(Set.get_space().map_from_set());
   if (RestrictDomain)
     Result = Result.intersect_domain(Set);
   return Result;
 }
 
 isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
                                       bool RestrictDomain) {
-  isl::union_map Result = isl::union_map::empty(USet.get_space());
+  isl::union_map Result = isl::union_map::empty(USet.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::map IdentityMap = makeIdentityMap(Set, RestrictDomain);
     Result = Result.add_map(IdentityMap);
   }
   return Result;
 }
 
 isl::map polly::reverseDomain(isl::map Map) {
   isl::space DomSpace = Map.get_space().domain().unwrap();
   isl::space Space1 = DomSpace.domain();
   isl::space Space2 = DomSpace.range();
   isl::map Swap = makeTupleSwapMap(Space1, Space2);
   return Map.apply_domain(Swap);
 }
 
 isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = Result.add_map(Reversed);
   }
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
   int NumDims = Set.tuple_dim();
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Set.get_space();
   Space = Space.map_from_domain_and_range(Space);
   isl::multi_aff Translator = makeShiftDimAff(Space, Pos, Amount);
   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
   return Set.apply(TranslatorMap);
 }
 
 isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
-  isl::union_set Result = isl::union_set::empty(USet.get_space());
+  isl::union_set Result = isl::union_set::empty(USet.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::set Shifted = shiftDim(Set, Pos, Amount);
     Result = Result.unite(Shifted);
   }
   return Result;
 }
 
 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
case isl::dim::out:
     return Map.apply_range(TranslatorMap);
   default:
     llvm_unreachable("Unsupported value for 'dim'");
   }
 }
 
 isl::union_map polly::shiftDim(isl::union_map UMap, isl::dim Dim, int Pos,
                                int Amount) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
 
   for (isl::map Map : UMap.get_map_list()) {
     isl::map Shifted = shiftDim(Map, Dim, Pos, Amount);
     Result = Result.add_map(Shifted);
   }
   return Result;
 }
 
for (unsigned i = 0; i < Range2Dims; i += 1)
     Translator = Translator.equate(isl::dim::in, DomainDims + Range1Dims + i,
                                    isl::dim::out,
                                    DomainDims + Range1Dims + DomainDims + i);
 
   return Map.wrap().apply(Translator).unwrap();
 }
 
 isl::union_map polly::distributeDomain(isl::union_map UMap) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Distributed = distributeDomain(Map);
     Result = Result.add_map(Distributed);
   }
   return Result;
 }
 
 isl::union_map polly::liftDomains(isl::union_map UMap, isl::union_set Factor) {
for (isl::basic_set BSet : Set.get_basic_set_list())
     recursiveExpand(BSet, 0, Expanded);
   return Expanded;
 }
 
 /// Expand all points of a union set explicit.
 ///
 /// @see expand(const isl::set)
 static isl::union_set expand(const isl::union_set &USet) {
-  isl::union_set Expanded = isl::union_set::empty(USet.get_space());
+  isl::union_set Expanded = isl::union_set::empty(USet.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::set SetExpanded = expand(Set);
     Expanded = Expanded.unite(SetExpanded);
   }
   return Expanded;
 }
 
 LLVM_DUMP_METHOD void polly::dumpPw(const isl::set &Set) {

polly/lib/Transform/DeLICM.cpp

if (PerPHIWrites.is_null()) {
       return false;
     }
 
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = PerPHIWrites.apply_domain(PHITarget).reverse();
     simplify(WritesTarget);
 
     // { DomainWrite[] }
-    auto UniverseWritesDom = isl::union_set::empty(ParamSpace);
+    auto UniverseWritesDom = isl::union_set::empty(ParamSpace.ctx());
 
     for (auto *MA : S->getPHIIncomings(SAI))
       UniverseWritesDom = UniverseWritesDom.unite(getDomainFor(MA));
 
     auto RelevantWritesTarget = WritesTarget;
     if (DelicmOverapproximateWrites)
       WritesTarget = expandMapping(WritesTarget, UniverseWritesDom);
 

polly/lib/Transform/FlattenAlgo.cpp

 /// It is assumed that all maps in the maps have at least the necessary number
 /// of out dimensions.
 isl::union_map scheduleProjectOut(const isl::union_map &UMap, unsigned first,
                                   unsigned n) {
   if (n == 0)
     return UMap; /* isl_map_project_out would also reset the tuple, which should
                     have no effect on schedule ranges */
 
-  auto Result = isl::union_map::empty(UMap.get_space());
+  auto Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Outprojected = Map.project_out(isl::dim::out, first, n);
     Result = Result.add_map(Outprojected);
   }
   return Result;
 }
 
 /// Return the number of dimensions in the input map's range.
for (isl::map Map : Schedule.get_map_list()) {
 
     Dims = std::max(Dims, Map.range_tuple_dim());
   }
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
 isl::union_pw_aff scheduleExtractDimAff(isl::union_map UMap, unsigned pos) {
-  auto SingleUMap = isl::union_map::empty(UMap.get_space());
+  auto SingleUMap = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     unsigned MapDims = Map.range_tuple_dim();
     isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.add_map(SingleMap);
   };
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
isl::union_map tryFlattenSequence(isl::union_map Schedule) {
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
     return {};
   }
 
   auto AllDomains = Schedule.domain();
   auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
 
-  auto NewSchedule = isl::union_map::empty(ParamSpace);
+  auto NewSchedule = isl::union_map::empty(ParamSpace.ctx());
   auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
 
   while (!ScatterSet.is_empty()) {
     LLVM_DEBUG(dbgs() << "Next counter:\n  " << Counter << "\n");
     LLVM_DEBUG(dbgs() << "Remaining scatter set:\n  " << ScatterSet << "\n");
     auto ThisSet = ScatterSet.project_out(isl::dim::set, 1, Dims - 1);
     auto ThisFirst = ThisSet.lexmin();
     auto ScatterFirst = ThisFirst.add_dims(isl::dim::set, Dims - 1);

polly/lib/Transform/MaximalStaticExpansion.cpp

 
 isl::union_map MaximalStaticExpander::filterDependences(
     Scop &S, const isl::union_map &Dependences, MemoryAccess *MA) {
   auto SAI = MA->getLatestScopArrayInfo();
 
   auto AccessDomainSet = MA->getAccessRelation().domain();
   auto AccessDomainId = AccessDomainSet.get_tuple_id();
 
-  isl::union_map MapDependences = isl::union_map::empty(S.getParamSpace());
+  isl::union_map MapDependences = isl::union_map::empty(S.getIslCtx());
 
   for (isl::map Map : Dependences.get_map_list()) {
     // Filter out Statement to Statement dependences.
     if (!Map.can_curry())
       continue;
 
     // Intersect with the relevant SAI.
     auto TmpMapDomainId =
bool MaximalStaticExpander::isExpandable(
   } else if (SAI->isPHIKind()) {
     auto Read = S.getPHIRead(SAI);
 
     auto StmtDomain = isl::union_set(Read->getStatement()->getDomain());
 
     auto Writes = S.getPHIIncomings(SAI);
 
     // Get the domain where all the writes are writing to.
-    auto WriteDomain = isl::union_set::empty(S.getParamSpace());
+    auto WriteDomain = isl::union_set::empty(S.getIslCtx());
 
     for (auto Write : Writes) {
       auto MapDeps = filterDependences(S, Dependences, Write);
       for (isl::map Map : MapDeps.get_map_list())
         WriteDomain = WriteDomain.unite(Map.range());
     }
 
     // For now, read from original scalar is not possible.
     if (!StmtDomain.is_equal(WriteDomain)) {
       emitRemark(SAI->getName() + " read from its original value.",
                  Read->getAccessInstruction());
       return false;
     }
 
     return true;
   } else if (SAI->isExitPHIKind()) {
     // For now, we are not able to expand ExitPhi.
     emitRemark(SAI->getName() + " is a ExitPhi node.",
                S.getEnteringBlock()->getFirstNonPHI());
     return false;
   }
 
   int NumberWrites = 0;
   for (ScopStmt &Stmt : S) {
-    auto StmtReads = isl::union_map::empty(S.getParamSpace());
-    auto StmtWrites = isl::union_map::empty(S.getParamSpace());
+    auto StmtReads = isl::union_map::empty(S.getIslCtx());
+    auto StmtWrites = isl::union_map::empty(S.getIslCtx());
 
     for (MemoryAccess *MA : Stmt) {
       // Check if the current MemoryAccess involved the current SAI.
       if (SAI != MA->getLatestScopArrayInfo())
         continue;
 
       // For now, we are not able to expand array where read come after write
       // (to the same location) in a same statement.

polly/lib/Transform/ScheduleTreeTransform.cpp

for (int i = 1; i < NumChildren; i += 1) {
       Extensions = Extensions.unite(NewChildExtensions);
     }
     return NewNode;
   }
 
   isl::schedule visitLeaf(const isl::schedule_node &Leaf,
                           const isl::union_set &Domain,
                           isl::union_map &Extensions) {
-    isl::ctx Ctx = Leaf.ctx();
-    Extensions = isl::union_map::empty(isl::space::params_alloc(Ctx, 0));
+    Extensions = isl::union_map::empty(Leaf.ctx());
     return isl::schedule::from_domain(Domain);
   }
 
   isl::schedule visitBand(const isl::schedule_node &OldNode,
                           const isl::union_set &Domain,
                           isl::union_map &OuterExtensions) {
     isl::schedule_node OldChild = OldNode.first_child();
     isl::multi_union_pw_aff PartialSched =
         isl::manage(isl_schedule_node_band_get_partial_schedule(OldNode.get()));
 
     isl::union_map NewChildExtensions;
     isl::schedule NewChild = visit(OldChild, Domain, NewChildExtensions);
 
     // Add the extensions to the partial schedule.
-    OuterExtensions = isl::union_map::empty(NewChildExtensions.get_space());
+    OuterExtensions = isl::union_map::empty(NewChildExtensions.ctx());
     isl::union_map NewPartialSchedMap = isl::union_map::from(PartialSched);
     unsigned BandDims = isl_schedule_node_band_n_member(OldNode.get());
     for (isl::map Ext : NewChildExtensions.get_map_list()) {
       unsigned ExtDims = Ext.domain_tuple_dim();
       assert(ExtDims >= BandDims);
       unsigned OuterDims = ExtDims - BandDims;
 
       isl::map BandSched =

polly/lib/Transform/Simplify.cpp

 /// Remove writes that are overwritten unconditionally later in the same
 /// statement.
 ///
 /// There must be no read of the same value between the write (that is to be
 /// removed) and the overwrite.
 void SimplifyImpl::removeOverwrites() {
   for (auto &Stmt : *S) {
     isl::set Domain = Stmt.getDomain();
-    isl::union_map WillBeOverwritten =
-        isl::union_map::empty(S->getParamSpace());
+    isl::union_map WillBeOverwritten = isl::union_map::empty(S->getIslCtx());
 
     SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
 
     // Iterate in reverse order, so the overwrite comes before the write that
     // is to be removed.
     for (auto *MA : reverse(Accesses)) {
 
       // In region statements, the explicit accesses can be in blocks that are
auto makeValueSet = [&ValueSets, this](Value *V) -> isl::set {
         Result = isl::set::universe(
             isl::space(Ctx, 0, 0).set_tuple_id(isl::dim::set, Id));
       }
       return Result;
     };
 
     // List of all eligible (for coalescing) writes of the future.
     // { [Domain[] -> Element[]] -> [Value[] -> MemoryAccess[]] }
-    isl::union_map FutureWrites = isl::union_map::empty(S->getParamSpace());
+    isl::union_map FutureWrites = isl::union_map::empty(S->getIslCtx());
 
     // Iterate over accesses from the last to the first.
     SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
     for (MemoryAccess *MA : reverse(Accesses)) {
       // In region statements, the explicit accesses can be in blocks that can
       // be executed in any order. We therefore process only the implicit
       // writes and stop after that.
       if (Stmt.isRegionStmt() && isExplicitAccess(MA))
for (MemoryAccess *MA : reverse(Accesses)) {
         MemoryAccess *MA = (MemoryAccess *)Map.get_space()
                                .range()
                                .unwrap()
                                .get_tuple_id(isl::dim::out)
                                .get_user();
         TouchedAccesses.insert(MA);
       }
       isl::union_map NewFutureWrites =
-          isl::union_map::empty(FutureWrites.get_space());
+          isl::union_map::empty(FutureWrites.ctx());
       for (isl::map FutureWrite : FutureWrites.get_map_list()) {
         MemoryAccess *MA = (MemoryAccess *)FutureWrite.get_space()
                                .range()
                                .unwrap()
                                .get_tuple_id(isl::dim::out)
                                .get_user();
         if (!TouchedAccesses.count(MA))
           NewFutureWrites = NewFutureWrites.add_map(FutureWrite);
for (auto &Stmt : *S) {
     };
 
     isl::set Domain = Stmt.getDomain();
     Domain = Domain.intersect_params(S->getContext());
 
     // List of element reads that still have the same value while iterating
     // through the MemoryAccesses.
     // { [Domain[] -> Element[]] -> Val[] }
-    isl::union_map Known = isl::union_map::empty(S->getParamSpace());
+    isl::union_map Known = isl::union_map::empty(S->getIslCtx());
 
     SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
     for (MemoryAccess *MA : Accesses) {
       // Is the memory access in a defined order relative to the other
       // accesses? In region statements, only the first and the last accesses
       // have defined order. Execution of those in the middle may depend on
       // runtime conditions an therefore cannot be modified.
       bool IsOrdered =

polly/lib/Transform/ZoneAlgo.cpp

 /// @param { [] -> ValInst[] }
 static bool isMapToUnknown(const isl::map &Map) {
   isl::space Space = Map.get_space().range();
   return Space.has_tuple_id(isl::dim::set).is_false() &&
          Space.is_wrapping().is_false() && Space.dim(isl::dim::set) == 0;
 }
 
 isl::union_map polly::filterKnownValInst(const isl::union_map &UMap) {
-  isl::union_map Result = isl::union_map::empty(UMap.get_space());
+  isl::union_map Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     if (!isMapToUnknown(Map))
       Result = Result.add_map(Map);
   }
   return Result;
 }
 
 ZoneAlgorithm::ZoneAlgorithm(const char *PassName, Scop *S, LoopInfo *LI)
isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
   assert(!Result.is_single_valued().is_false());
   assert(!Result.is_injective().is_false());
 
   PerPHIMaps.insert({PHI, Result});
   return Result;
 }
 
 isl::union_set ZoneAlgorithm::makeEmptyUnionSet() const {
-  return isl::union_set::empty(ParamSpace);
+  return isl::union_set::empty(ParamSpace.ctx());
 }
 
 isl::union_map ZoneAlgorithm::makeEmptyUnionMap() const {
-  return isl::union_map::empty(ParamSpace);
+  return isl::union_map::empty(ParamSpace.ctx());
 }
 
 void ZoneAlgorithm::collectCompatibleElts() {
   // First find all the incompatible elements, then take the complement.
   // We compile the list of compatible (rather than incompatible) elements so
   // users can intersect with the list, not requiring a subtract operation. It
   // also allows us to define a 'universe' of all elements and makes it more
   // explicit in which array elements can be used.

 ///
 /// @param Input        { [] -> ValInst[] }
 /// @param ComputedPHIs Set of PHIs that are replaced. Its ValInst must appear
 ///                     on the LHS of @p NormalizeMap.
 /// @param NormalizeMap { ValInst[] -> ValInst[] }
 static isl::union_map normalizeValInst(isl::union_map Input,
                                        const DenseSet<PHINode *> &ComputedPHIs,
                                        isl::union_map NormalizeMap) {
-  isl::union_map Result = isl::union_map::empty(Input.get_space());
+  isl::union_map Result = isl::union_map::empty(Input.ctx());
   for (isl::map Map : Input.get_map_list()) {
     isl::space Space = Map.get_space();
     isl::space RangeSpace = Space.range();
 
     // Instructions within the SCoP are always wrapped. Non-wrapped tuples
     // are therefore invariant in the SCoP and don't need normalization.
     if (!RangeSpace.is_wrapping()) {
       Result = Result.add_map(Map);

polly/unittests/DeLICM/DeLICMTest.cpp

 
 using namespace llvm;
 using namespace polly;
 
 namespace {
 
 /// Get the universes of all spaces in @p USet.
 isl::union_set unionSpace(const isl::union_set &USet) {
-  auto Result = isl::union_set::empty(USet.get_space());
+  auto Result = isl::union_set::empty(USet.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::space Space = Set.get_space();
     isl::set Universe = isl::set::universe(Space);
     Result = Result.unite(Universe);
   }
   return Result;
 }
 
 void completeLifetime(isl::union_set Universe, isl::union_map OccupiedAndKnown,
                       isl::union_set &Occupied, isl::union_map &Known,
                       isl::union_set &Undef) {
   auto ParamSpace = Universe.get_space();
 
   if (!Undef.is_null() && Occupied.is_null()) {
     assert(Occupied.is_null());
     Occupied = Universe.subtract(Undef);
   }
 
   if (!OccupiedAndKnown.is_null()) {
     assert(Known.is_null());
 
-    Known = isl::union_map::empty(ParamSpace);
+    Known = isl::union_map::empty(ParamSpace.ctx());
 
     if (Occupied.is_null())
       Occupied = OccupiedAndKnown.domain();
 
     for (isl::map Map : OccupiedAndKnown.get_map_list()) {
       if (!Map.has_tuple_name(isl::dim::out))
         continue;
       Known = Known.add_map(Map);
     }
   }
 
   if (Undef.is_null()) {
     assert(!Occupied.is_null());
     Undef = Universe.subtract(Occupied);
   }
 
   if (Known.is_null()) { // By default, nothing is known.
-    Known = isl::union_map::empty(ParamSpace);
+    Known = isl::union_map::empty(ParamSpace.ctx());
   }
 
   // Conditions that must hold when returning.
   assert(!Occupied.is_null());
   assert(!Undef.is_null());
   assert(!Known.is_null());
 }
 

 }
 
 bool checkIsConflictingNonsymmetricCommon(
     isl_ctx *Ctx, isl::union_map ExistingOccupiedAndKnown,
     isl::union_set ExistingUnused, isl::union_map ExistingWritten,
     isl::union_map ProposedOccupiedAndKnown, isl::union_set ProposedUnused,
     isl::union_map ProposedWritten) {
   // Determine universe (set of all possible domains).
-  auto Universe = isl::union_set::empty(isl::space::params_alloc(Ctx, 0));
+  auto Universe = isl::union_set::empty(Ctx);
   if (!ExistingOccupiedAndKnown.is_null())
     Universe = Universe.unite(ExistingOccupiedAndKnown.domain());
   if (!ExistingUnused.is_null())
     Universe = Universe.unite(ExistingUnused);
   if (!ExistingWritten.is_null())
     Universe = Universe.unite(ExistingWritten.domain());
   if (!ProposedOccupiedAndKnown.is_null())
     Universe = Universe.unite(ProposedOccupiedAndKnown.domain());