[Polly][Isl] Use isl::union_set::unite() instead of isl::union_set::add_set(). 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_set::unite() instead of isl::union_set::add_set()
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/390c44982b5cee7eb43f8f7a80e185e6d21466b2

Depends on D104994

[Meinersbur]

polly/lib/Analysis/DependenceInfo.cpp

195

Doesn't isl::set convert implicitly to isl::union_set?

Or is this due to some compiler error, e.g. ambiguous overload?

[patacca]

Use implicit conversion from isl::set to isl::union_set

I didn't think about it the first time.

[patacca]

Rebase to main

[Meinersbur]

LGTM

polly/lib/Analysis/DependenceInfo.cpp

static void collectInfo(Scop &S, isl_union_map *&Read,
   MustWrite = isl_union_map_coalesce(MustWrite);
   MayWrite = isl_union_map_coalesce(MayWrite);
 }
 
 /// Fix all dimension of @p Zero to 0 and add it to @p user
 static void fixSetToZero(isl::set Zero, isl::union_set *User) {
   for (auto i : seq<isl_size>(0, Zero.tuple_dim()))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
-  *User = User->add_set(Zero);
+  *User = User->unite(isl::union_set(Zero));
 }
 
 /// Compute the privatization dependences for a given dependency @p Map
 ///
 /// Privatization dependences are widened original dependences which originate
 /// or end in a reduction access. To compute them we apply the transitive close
 /// of the reduction dependences (which maps each iteration of a reduction
 /// statement to all following ones) on the RAW/WAR/WAW dependences. The

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

public:
   inline __isl_give isl_union_set *copy() const &;
   inline __isl_give isl_union_set *copy() && = delete;
   inline __isl_keep isl_union_set *get() const;
   inline __isl_give isl_union_set *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
-  inline union_set add_set(set set) const;
   inline union_set affine_hull() const;
   inline union_set align_params(space model) const;
   inline union_set apply(union_map umap) const;
   inline union_set coalesce() const;
   inline union_set coefficients() const;
   inline schedule compute_schedule(union_map validity, union_map proximity) const;
   inline boolean contains(const space &space) const;
   inline union_set detect_equalities() const;
ctx union_set::get_ctx() const {
   return ctx(isl_union_set_get_ctx(ptr));
 }
 
 void union_set::dump() const {
   isl_union_set_dump(get());
 }
 
 
-union_set union_set::add_set(set set) const
-{
-  auto res = isl_union_set_add_set(copy(), set.release());
-  return manage(res);
-}
-
 union_set union_set::affine_hull() const
 {
   auto res = isl_union_set_affine_hull(copy());
   return manage(res);
 }
 
 union_set union_set::align_params(space model) const
 {

polly/lib/Support/ISLTools.cpp

isl::set polly::shiftDim(isl::set Set, int Pos, int 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());
   for (isl::set Set : USet.get_set_list()) {
     isl::set Shifted = shiftDim(Set, Pos, Amount);
-    Result = Result.add_set(Shifted);
+    Result = Result.unite(isl::union_set(Shifted));
   }
   return Result;
 }
 
 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
   int NumDims = Map.dim(Dim);
   if (Pos < 0)
     Pos = NumDims + Pos;

 
 /// 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());
   for (isl::set Set : USet.get_set_list()) {
     isl::set SetExpanded = expand(Set);
-    Expanded = Expanded.add_set(SetExpanded);
+    Expanded = Expanded.unite(isl::union_set(SetExpanded));
   }
   return Expanded;
 }
 
 LLVM_DUMP_METHOD void polly::dumpPw(const isl::set &Set) {
   printSortedPolyhedra(Set, llvm::errs(), true, false);
 }
 

polly/lib/Transform/DeLICM.cpp

private:
   computeValueUses(const ScopArrayInfo *SAI) {
     assert(SAI->isValueKind());
 
     // { DomainRead[] }
     auto Reads = makeEmptyUnionSet();
 
     // Find all uses.
     for (auto *MA : S->getValueUses(SAI))
-      Reads = Reads.add_set(getDomainFor(MA));
+      Reads = Reads.unite(isl::union_set(getDomainFor(MA)));
 
     // { DomainRead[] -> Scatter[] }
     auto ReadSchedule = getScatterFor(Reads);
 
     auto *DefMA = S->getValueDef(SAI);
     assert(DefMA);
 
     // { DomainDef[] }
bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = PerPHIWrites.apply_domain(PHITarget).reverse();
     simplify(WritesTarget);
 
     // { DomainWrite[] }
     auto UniverseWritesDom = isl::union_set::empty(ParamSpace);
 
     for (auto *MA : S->getPHIIncomings(SAI))
-      UniverseWritesDom = UniverseWritesDom.add_set(getDomainFor(MA));
+      UniverseWritesDom =
+          UniverseWritesDom.unite(isl::union_set(getDomainFor(MA)));
 
     auto RelevantWritesTarget = WritesTarget;
     if (DelicmOverapproximateWrites)
       WritesTarget = expandMapping(WritesTarget, UniverseWritesDom);
 
     auto ExpandedWritesDom = WritesTarget.domain();
     if (!DelicmPartialWrites &&
         !UniverseWritesDom.is_subset(ExpandedWritesDom)) {

polly/lib/Transform/MaximalStaticExpansion.cpp

if (SAI->isValueKind()) {
     auto Writes = S.getPHIIncomings(SAI);
 
     // Get the domain where all the writes are writing to.
     auto WriteDomain = isl::union_set::empty(S.getParamSpace());
 
     for (auto Write : Writes) {
       auto MapDeps = filterDependences(S, Dependences, Write);
       for (isl::map Map : MapDeps.get_map_list())
-        WriteDomain = WriteDomain.add_set(Map.range());
+        WriteDomain = WriteDomain.unite(isl::union_set(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;
     }

polly/lib/Transform/ZoneAlgo.cpp

if (!MA->isOriginalArrayKind())
       continue;
 
     isl::map AccRelMap = getAccessRelationFor(MA);
     isl::union_map AccRel = AccRelMap;
 
     // To avoid solving any ILP problems, always add entire arrays instead of
     // just the elements that are accessed.
     auto ArrayElts = isl::set::universe(AccRelMap.get_space().range());
-    AllElts = AllElts.add_set(ArrayElts);
+    AllElts = AllElts.unite(isl::union_set(ArrayElts));
 
     if (MA->isRead()) {
       // Reject load after store to same location.
       if (!Stores.is_disjoint(AccRel)) {
         LLVM_DEBUG(
             dbgs() << "Load after store of same element in same statement\n");
         OptimizationRemarkMissed R(PassName, "LoadAfterStore",
                                    MA->getAccessInstruction());
         R << "load after store of same element in same statement";
         R << " (previous stores: " << Stores;
         R << ", loading: " << AccRel << ")";
         S->getFunction().getContext().diagnose(R);
 
-        IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
+        IncompatibleElts = IncompatibleElts.unite(isl::union_set(ArrayElts));
       }
 
       Loads = Loads.unite(AccRel);
 
       continue;
     }
 
     // In region statements the order is less clear, eg. the load and store
     // might be in a boxed loop.
     if (Stmt->isRegionStmt() && !Loads.is_disjoint(AccRel)) {
       LLVM_DEBUG(dbgs() << "WRITE in non-affine subregion not supported\n");
       OptimizationRemarkMissed R(PassName, "StoreInSubregion",
                                  MA->getAccessInstruction());
       R << "store is in a non-affine subregion";
       S->getFunction().getContext().diagnose(R);
 
-      IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
+      IncompatibleElts = IncompatibleElts.unite(isl::union_set(ArrayElts));
     }
 
     // Do not allow more than one store to the same location.
     if (!Stores.is_disjoint(AccRel) && !onlySameValueWrites(Stmt)) {
       LLVM_DEBUG(dbgs() << "WRITE after WRITE to same element\n");
       OptimizationRemarkMissed R(PassName, "StoreAfterStore",
                                  MA->getAccessInstruction());
       R << "store after store of same element in same statement";
       R << " (previous stores: " << Stores;
       R << ", storing: " << AccRel << ")";
       S->getFunction().getContext().diagnose(R);
 
-      IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
+      IncompatibleElts = IncompatibleElts.unite(isl::union_set(ArrayElts));
     }
 
     Stores = Stores.unite(AccRel);
   }
 }
 
 void ZoneAlgorithm::addArrayReadAccess(MemoryAccess *MA) {
   assert(MA->isLatestArrayKind());

polly/unittests/DeLICM/DeLICMTest.cpp

 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());
   for (isl::set Set : USet.get_set_list()) {
     isl::space Space = Set.get_space();
     isl::set Universe = isl::set::universe(Space);
-    Result = Result.add_set(Universe);
+    Result = Result.unite(isl::union_set(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();
bool checkIsConflictingNonsymmetricCommon(
   // Add a space the universe that does not occur anywhere else to ensure
   // robustness. Use &NewId to ensure that this Id is unique.
   isl::id NewId = isl::id::alloc(Ctx, "Unrelated", &NewId);
   // The space must contains at least one dimension to allow order
   // modifications.
   auto NewSpace = isl::space(Ctx, 0, 1);
   NewSpace = NewSpace.set_tuple_id(isl::dim::set, NewId);
   auto NewSet = isl::set::universe(NewSpace);
-  Universe = Universe.add_set(NewSet);
+  Universe = Universe.unite(isl::union_set(NewSet));
 
   // Using the universe, fill missing data.
   isl::union_set ExistingOccupied;
   isl::union_map ExistingKnown;
   completeLifetime(Universe, ExistingOccupiedAndKnown, ExistingOccupied,
                    ExistingKnown, ExistingUnused);
 
   isl::union_set ProposedOccupied;