[Polly][Isl] Use isl::union_map::unite() instead of isl::union_map::add_map(). 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:

• Use isl::union_map::unite() instead of isl::union_map::add_map()
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/3f43ae29fa2a22936a583b85b2fe8d439f805d8d

Depends on D106059

[patacca]

Force buildbot to build again

[Meinersbur]

LGTM

[patacca]

Rebase to main

polly/lib/Analysis/DependenceInfo.cpp

for (ScopStmt &Stmt : S) {
     else
       StmtScat = Lookup->second;
     assert(!StmtScat.is_null() &&
            "Schedules that contain extension nodes require special handling.");
 
     if (ScheduleSpace.is_null())
       ScheduleSpace = StmtScat.get_space().range();
 
-    Schedule = Schedule.add_map(StmtScat);
+    Schedule = Schedule.unite(StmtScat);
   }
 
   Dependences = Dependences.apply_domain(Schedule);
   Dependences = Dependences.apply_range(Schedule);
 
   isl::set Zero = isl::set::universe(ScheduleSpace);
   for (auto i : seq<isl_size>(0, Zero.dim(isl::dim::set)))
     Zero = Zero.fix_si(isl::dim::set, i, 0);

polly/lib/Analysis/ScopBuilder.cpp

 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->getIslCtx());
 
   for (MemoryAccess *MA : AliasGroup)
-    Accesses = Accesses.add_map(MA->getAccessRelation());
+    Accesses = Accesses.unite(MA->getAccessRelation());
 
   Accesses = Accesses.intersect_domain(Domains);
   isl::union_set Locations = Accesses.range();
 
   bool LimitReached = false;
   for (isl::set Set : Locations.get_set_list()) {
     LimitReached |= !buildMinMaxAccess(Set, MinMaxAccesses, *scop);
     if (LimitReached)

polly/lib/Analysis/ScopInfo.cpp

Scop::getAccessesOfType(std::function<bool(MemoryAccess &)> Predicate) {
   for (ScopStmt &Stmt : *this) {
     for (MemoryAccess *MA : Stmt) {
       if (!Predicate(*MA))
         continue;
 
       isl::set Domain = Stmt.getDomain();
       isl::map AccessDomain = MA->getAccessRelation();
       AccessDomain = AccessDomain.intersect_domain(Domain);
-      Accesses = Accesses.add_map(AccessDomain);
+      Accesses = Accesses.unite(AccessDomain);
     }
   }
 
   return Accesses.coalesce();
 }
 
 isl::union_map Scop::getMustWrites() {
   return getAccessesOfType([](MemoryAccess &MA) { return MA.isMustWrite(); });

polly/lib/Exchange/JSONExporter.cpp

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.getIslCtx());
   for (ScopStmt &Stmt : S) {
     if (NewSchedule.find(&Stmt) != NewSchedule.end())
-      ScheduleMap = ScheduleMap.add_map(NewSchedule[&Stmt]);
+      ScheduleMap = ScheduleMap.unite(NewSchedule[&Stmt]);
     else
-      ScheduleMap = ScheduleMap.add_map(Stmt.getSchedule());
+      ScheduleMap = ScheduleMap.unite(Stmt.getSchedule());
   }
 
   S.setSchedule(ScheduleMap);
 
   return true;
 }
 
 /// Import new memory accesses from JScop.

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

public:
   inline __isl_give isl_union_map *copy() const &;
   inline __isl_give isl_union_map *copy() && = delete;
   inline __isl_keep isl_union_map *get() const;
   inline __isl_give isl_union_map *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
   inline void dump() const;
 
-  inline isl::union_map add_map(isl::map map) const;
   inline isl::union_map affine_hull() const;
   inline isl::union_map align_params(isl::space model) const;
   inline isl::union_map apply_domain(isl::union_map umap2) const;
   inline isl::union_map apply_range(isl::union_map umap2) const;
   inline isl::union_set bind_range(isl::multi_id tuple) const;
   inline isl::union_map coalesce() const;
   inline boolean contains(const isl::space &space) const;
   inline isl::union_map curry() const;
isl::ctx union_map::ctx() const {
   return isl::ctx(isl_union_map_get_ctx(ptr));
 }
 
 void union_map::dump() const {
   isl_union_map_dump(get());
 }
 
 
-isl::union_map union_map::add_map(isl::map map) const
-{
-  auto res = isl_union_map_add_map(copy(), map.release());
-  return manage(res);
-}
-
 isl::union_map union_map::affine_hull() const
 {
   auto res = isl_union_map_affine_hull(copy());
   return manage(res);
 }
 
 isl::union_map union_map::align_params(isl::space model) const
 {

polly/lib/Support/ISLTools.cpp

isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   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.ctx());
 
   for (isl::map Map : UMap.get_map_list()) {
     isl::map After = beforeScatter(Map, Strict);
-    Result = Result.add_map(After);
+    Result = Result.unite(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.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     isl::map After = afterScatter(Map, Strict);
-    Result = Result.add_map(After);
+    Result = Result.unite(After);
   }
   return Result;
 }
 
 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
                                bool InclTo) {
   isl::map AfterFrom = afterScatter(From, !InclFrom);
   isl::map BeforeTo = beforeScatter(To, !InclTo);
isl::map polly::makeIdentityMap(const isl::set &Set, bool RestrictDomain) {
   return Result;
 }
 
 isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
                                       bool RestrictDomain) {
   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);
+    Result = Result.unite(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.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Reversed = reverseDomain(std::move(Map));
-    Result = Result.add_map(Reversed);
+    Result = Result.unite(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;

 }
 
 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.ctx());
 
   for (isl::map Map : UMap.get_map_list()) {
     isl::map Shifted = shiftDim(Map, Dim, Pos, Amount);
-    Result = Result.add_map(Shifted);
+    Result = Result.unite(Shifted);
   }
   return Result;
 }
 
 void polly::simplify(isl::set &Set) {
   Set = isl::manage(isl_set_compute_divs(Set.copy()));
   Set = Set.detect_equalities();
   Set = Set.coalesce();
isl::map polly::distributeDomain(isl::map Map) {
 
   return Map.wrap().apply(Translator).unwrap();
 }
 
 isl::union_map polly::distributeDomain(isl::union_map UMap) {
   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);
+    Result = Result.unite(Distributed);
   }
   return Result;
 }
 
 isl::union_map polly::liftDomains(isl::union_map UMap, isl::union_set Factor) {
 
   // { Factor[] -> Factor[] }
   isl::union_map Factors = makeIdentityMap(Factor, true);

polly/lib/Transform/FlattenAlgo.cpp

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.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Outprojected = Map.project_out(isl::dim::out, first, n);
-    Result = Result.add_map(Outprojected);
+    Result = Result.unite(Outprojected);
   }
   return Result;
 }
 
 /// Return the number of dimensions in the input map's range.
 ///
 /// Because this function takes an isl_union_map, the out dimensions could be
 /// different. We return the maximum number in this case. However, a different

 
 /// 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.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);
+    SingleUMap = SingleUMap.unite(SingleMap);
   };
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
   return FirstMAff.get_union_pw_aff(0);
 }
 
 /// Flatten a sequence-like first dimension.

polly/lib/Transform/ForwardOpTree.cpp

auto ExecAction = [this, TargetStmt, LI, SameVal,
                        LocalTranslator]() -> bool {
       TargetStmt->prependInstruction(LI);
       MemoryAccess *Access = makeReadArrayAccess(TargetStmt, LI, SameVal);
       LLVM_DEBUG(dbgs() << "    forwarded known load with new MemoryAccess"
                         << Access << "\n");
       (void)Access;
 
       if (!LocalTranslator.is_null())
-        Translator = Translator.add_map(LocalTranslator);
+        Translator = Translator.unite(LocalTranslator);
 
       NumKnownLoadsForwarded++;
       TotalKnownLoadsForwarded++;
       return true;
     };
     return ForwardingAction::canForward(
         ExecAction, {{LI->getPointerOperand(), DefStmt}}, true);
   }

polly/lib/Transform/MaximalStaticExpansion.cpp

for (isl::map Map : Dependences.get_map_list()) {
     // Get the correct S1[] -> S2[] dependence.
     auto NewMap = Map.factor_domain();
     auto NewMapDomainId = NewMap.domain().get_tuple_id();
 
     if (AccessDomainId.get() != NewMapDomainId.get())
       continue;
 
     // Add the corresponding map to MapDependences.
-    MapDependences = MapDependences.add_map(NewMap);
+    MapDependences = MapDependences.unite(NewMap);
   }
 
   return MapDependences;
 }
 
 bool MaximalStaticExpander::isExpandable(
     const ScopArrayInfo *SAI, SmallPtrSetImpl<MemoryAccess *> &Writes,
     SmallPtrSetImpl<MemoryAccess *> &Reads, Scop &S,

polly/lib/Transform/ScheduleTreeTransform.cpp

for (isl::map Ext : NewChildExtensions.get_map_list()) {
       isl::map BandSched =
           Ext.project_out(isl::dim::in, 0, OuterDims).reverse();
       NewPartialSchedMap = NewPartialSchedMap.unite(BandSched);
 
       // There might be more outer bands that have to schedule the extensions.
       if (OuterDims > 0) {
         isl::map OuterSched =
             Ext.project_out(isl::dim::in, OuterDims, BandDims);
-        OuterExtensions = OuterExtensions.add_map(OuterSched);
+        OuterExtensions = OuterExtensions.unite(OuterSched);
       }
     }
     isl::multi_union_pw_aff NewPartialSchedAsAsMultiUnionPwAff =
         isl::multi_union_pw_aff::from_union_map(NewPartialSchedMap);
     isl::schedule_node NewNode =
         NewChild.insert_partial_schedule(NewPartialSchedAsAsMultiUnionPwAff)
             .get_root()
             .get_child(0);

polly/lib/Transform/Simplify.cpp

 static bool isExplicitAccess(MemoryAccess *MA) {
   return MA->isOriginalArrayKind();
 }
 
 static bool isImplicitWrite(MemoryAccess *MA) {
   return MA->isWrite() && MA->isOriginalScalarKind();
 }
 
-/// Like isl::union_map::add_map, but may also return an underapproximated
+/// Like isl::union_map::unite, but may also return an underapproximated
 /// result if getting too complex.
 ///
 /// This is implemented by adding disjuncts to the results until the limit is
 /// reached.
 static isl::union_map underapproximatedAddMap(isl::union_map UMap,
                                               isl::map Map) {
   if (UMap.is_null() || Map.is_null())
     return {};
 
   isl::map PrevMap = UMap.extract_map(Map.get_space());
 
   // Fast path: If known that we cannot exceed the disjunct limit, just add
   // them.
   if (isl_map_n_basic_map(PrevMap.get()) + isl_map_n_basic_map(Map.get()) <=
       SimplifyMaxDisjuncts)
-    return UMap.add_map(Map);
+    return UMap.unite(Map);
 
   isl::map Result = isl::map::empty(PrevMap.get_space());
   for (isl::basic_map BMap : PrevMap.get_basic_map_list()) {
     if (Result.n_basic_map() > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }
   for (isl::basic_map BMap : Map.get_basic_map_list()) {
     if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }
 
   isl::union_map UResult =
       UMap.subtract(isl::map::universe(PrevMap.get_space()));
-  UResult.add_map(Result);
+  UResult.unite(Result);
 
   return UResult;
 }
 
 class SimplifyImpl {
 private:
   /// The invocation id (if there are multiple instances in the pass manager's
   /// pipeline) to determine which statistics to update.
for (MemoryAccess *MA : reverse(Accesses)) {
           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);
+          NewFutureWrites = NewFutureWrites.unite(FutureWrite);
       }
       FutureWrites = NewFutureWrites;
 
       if (MA->isMustWrite() && !ValSet.is_null()) {
         // { MemoryAccess[] }
         auto AccSet =
             isl::set::universe(isl::space(S->getIslCtx(), 0, 0)
                                    .set_tuple_id(isl::dim::set, MA->getId()));
 
         // { Val[] -> MemoryAccess[] }
         isl::map ValAccSet = isl::map::from_domain_and_range(ValSet, AccSet);
 
         // { [Domain[] -> Element[]] -> [Value[] -> MemoryAccess[]] }
         isl::map AccRelValAcc =
             isl::map::from_domain_and_range(AccRelWrapped, ValAccSet.wrap());
-        FutureWrites = FutureWrites.add_map(AccRelValAcc);
+        FutureWrites = FutureWrites.unite(AccRelValAcc);
       }
     }
   }
 }
 
 /// Remove writes that just write the same value already stored in the
 /// element.
 void SimplifyImpl::removeRedundantWrites() {
for (MemoryAccess *MA : Accesses) {
       if (MA->isRead()) {
         // Loaded values are the currently known values of the array element
         // it was loaded from.
         Value *LoadedVal = MA->getAccessValue();
         if (LoadedVal && IsOrdered) {
           isl::map AccRelVal = isl::map::from_domain_and_range(
               AccRelWrapped, makeValueSet(LoadedVal));
 
-          Known = Known.add_map(AccRelVal);
+          Known = Known.unite(AccRelVal);
         }
       } else if (MA->isWrite()) {
         // Remove (possibly) overwritten values from the known elements set.
         // We remove all elements of the accessed array to avoid too complex
         // isl sets.
         isl::set AccRelUniv = isl::set::universe(AccRelWrapped.get_space());
         Known = Known.subtract_domain(AccRelUniv);
 

polly/lib/Transform/ZoneAlgo.cpp

static bool isMapToUnknown(const isl::map &Map) {
   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.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     if (!isMapToUnknown(Map))
-      Result = Result.add_map(Map);
+      Result = Result.unite(Map);
   }
   return Result;
 }
 
 ZoneAlgorithm::ZoneAlgorithm(const char *PassName, Scop *S, LoopInfo *LI)
     : PassName(PassName), IslCtx(S->getSharedIslCtx()), S(S), LI(LI),
       Schedule(S->getSchedule()) {
   auto Domains = S->getDomains();

 
 void ZoneAlgorithm::addArrayReadAccess(MemoryAccess *MA) {
   assert(MA->isLatestArrayKind());
   assert(MA->isRead());
   ScopStmt *Stmt = MA->getStatement();
 
   // { DomainRead[] -> Element[] }
   auto AccRel = intersectRange(getAccessRelationFor(MA), CompatibleElts);
-  AllReads = AllReads.add_map(AccRel);
+  AllReads = AllReads.unite(AccRel);
 
   if (LoadInst *Load = dyn_cast_or_null<LoadInst>(MA->getAccessInstruction())) {
     // { DomainRead[] -> ValInst[] }
     isl::map LoadValInst = makeValInst(
         Load, Stmt, LI->getLoopFor(Load->getParent()), Stmt->isBlockStmt());
 
     // { DomainRead[] -> [Element[] -> DomainRead[]] }
     isl::map IncludeElement = AccRel.domain_map().curry();
 
     // { [Element[] -> DomainRead[]] -> ValInst[] }
     isl::map EltLoadValInst = LoadValInst.apply_domain(IncludeElement);
 
-    AllReadValInst = AllReadValInst.add_map(EltLoadValInst);
+    AllReadValInst = AllReadValInst.unite(EltLoadValInst);
   }
 }
 
 isl::union_map ZoneAlgorithm::getWrittenValue(MemoryAccess *MA,
                                               isl::map AccRel) {
   if (!MA->isMustWrite())
     return {};
 
void ZoneAlgorithm::addArrayWriteAccess(MemoryAccess *MA) {
   assert(MA->isLatestArrayKind());
   assert(MA->isWrite());
   auto *Stmt = MA->getStatement();
 
   // { Domain[] -> Element[] }
   isl::map AccRel = intersectRange(getAccessRelationFor(MA), CompatibleElts);
 
   if (MA->isMustWrite())
-    AllMustWrites = AllMustWrites.add_map(AccRel);
+    AllMustWrites = AllMustWrites.unite(AccRel);
 
   if (MA->isMayWrite())
-    AllMayWrites = AllMayWrites.add_map(AccRel);
+    AllMayWrites = AllMayWrites.unite(AccRel);
 
   // { Domain[] -> ValInst[] }
   isl::union_map WriteValInstance = getWrittenValue(MA, AccRel);
   if (WriteValInstance.is_null())
     WriteValInstance = makeUnknownForDomain(Stmt);
 
   // { Domain[] -> [Element[] -> Domain[]] }
   isl::map IncludeElement = AccRel.domain_map().curry();
isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
   assert(SAI->isPHIKind());
 
   // { DomainPHIWrite[] -> Scatter[] }
   isl::union_map PHIWriteScatter = makeEmptyUnionMap();
 
   // Collect all incoming block timepoints.
   for (MemoryAccess *MA : S->getPHIIncomings(SAI)) {
     isl::map Scatter = getScatterFor(MA);
-    PHIWriteScatter = PHIWriteScatter.add_map(Scatter);
+    PHIWriteScatter = PHIWriteScatter.unite(Scatter);
   }
 
   // { DomainPHIRead[] -> Scatter[] }
   isl::map PHIReadScatter = getScatterFor(S->getPHIRead(SAI));
 
   // { DomainPHIRead[] -> Scatter[] }
   isl::map BeforeRead = beforeScatter(PHIReadScatter, true);
 
static isl::union_map normalizeValInst(isl::union_map Input,
   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);
+      Result = Result.unite(Map);
       continue;
     }
 
     auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
         RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
 
     // If no normalization is necessary, then the ValInst stands for itself.
     if (!ComputedPHIs.count(PHI)) {
-      Result = Result.add_map(Map);
+      Result = Result.unite(Map);
       continue;
     }
 
     // Otherwise, apply the normalization.
     isl::union_map Mapped = isl::union_map(Map).apply_range(NormalizeMap);
     Result = Result.unite(Mapped);
     NumPHINormialization++;
   }
for (MemoryAccess *MA : Stmt) {
                                        "representable by something else than "
                                        "the PHI itself");
         Value *IncomingVal = Incoming[0].second;
 
         // { IncomingDomain[] -> IncomingValInst[] }
         isl::map IncomingValInst = makeValInst(
             IncomingVal, IncomingStmt, IncomingStmt->getSurroundingLoop());
 
-        IncomingValInsts = IncomingValInsts.add_map(IncomingValInst);
+        IncomingValInsts = IncomingValInsts.unite(IncomingValInst);
       }
 
       // { PHIValInst[] -> IncomingValInst[] }
       isl::union_map PHIMap =
           PerPHI.apply_domain(PHIValInst).apply_range(IncomingValInsts);
       assert(!PHIMap.is_single_valued().is_false());
 
       // Resolve transitiveness: The incoming value of the newly discovered PHI

polly/unittests/DeLICM/DeLICMTest.cpp

if (!OccupiedAndKnown.is_null()) {
     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);
+      Known = Known.unite(Map);
     }
   }
 
   if (Undef.is_null()) {
     assert(!Occupied.is_null());
     Undef = Universe.subtract(Occupied);
   }