getDependences to new C++ interface

[grosser]

LGTM.

include/polly/DependenceInfo.h

struct Dependences {
 
   const std::shared_ptr<isl_ctx> &getSharedIslCtx() const { return IslCtx; }
 
   /// Get the dependences of type @p Kinds.
   ///
   /// @param Kinds This integer defines the different kinds of dependences
   ///              that will be returned. To return more than one kind, the
   ///              different kinds are 'ored' together.
-  __isl_give isl_union_map *getDependences(int Kinds) const;
+  isl::union_map getDependences(int Kinds) const;
 
   /// Report if valid dependences are available.
   bool hasValidDependences() const;
 
   /// Return the reduction dependences caused by @p MA.
   ///
   /// @return The reduction dependences caused by @p MA or nullptr if none.
   __isl_give isl_map *getReductionDependences(MemoryAccess *MA) const;

lib/Analysis/DependenceInfo.cpp

void Dependences::calculateDependences(Scop &S) {
   LLVM_DEBUG(dump());
 }
 
 bool Dependences::isValidSchedule(Scop &S,
                                   StatementToIslMapTy *NewSchedule) const {
   if (LegalityCheckDisabled)
     return true;
 
-  isl_union_map *Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);
+  isl_union_map *Dependences =
+      (getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR)).release();
   isl_space *Space = S.getParamSpace().release();
   isl_union_map *Schedule = isl_union_map_empty(Space);
 
   isl_space *ScheduleSpace = nullptr;
 
   for (ScopStmt &Stmt : S) {
     isl_map *StmtScat;
 
void Dependences::releaseMemory() {
 
   RED = RAW = WAR = WAW = TC_RED = nullptr;
 
   for (auto &ReductionDeps : ReductionDependences)
     isl_map_free(ReductionDeps.second);
   ReductionDependences.clear();
 }
 
-__isl_give isl_union_map *Dependences::getDependences(int Kinds) const {
+isl::union_map Dependences::getDependences(int Kinds) const {
   assert(hasValidDependences() && "No valid dependences available");
-  isl_space *Space = isl_union_map_get_space(RAW);
-  isl_union_map *Deps = isl_union_map_empty(Space);
+  isl::space Space = isl::manage_copy(RAW).get_space();
+  isl::union_map Deps = Deps.empty(Space);
 
   if (Kinds & TYPE_RAW)
-    Deps = isl_union_map_union(Deps, isl_union_map_copy(RAW));
+    Deps = Deps.unite(isl::manage_copy(RAW));
 
   if (Kinds & TYPE_WAR)
-    Deps = isl_union_map_union(Deps, isl_union_map_copy(WAR));
+    Deps = Deps.unite(isl::manage_copy(WAR));
 
   if (Kinds & TYPE_WAW)
-    Deps = isl_union_map_union(Deps, isl_union_map_copy(WAW));
+    Deps = Deps.unite(isl::manage_copy(WAW));
 
   if (Kinds & TYPE_RED)
-    Deps = isl_union_map_union(Deps, isl_union_map_copy(RED));
+    Deps = Deps.unite(isl::manage_copy(RED));
 
   if (Kinds & TYPE_TC_RED)
-    Deps = isl_union_map_union(Deps, isl_union_map_copy(TC_RED));
+    Deps = Deps.unite(isl::manage_copy(TC_RED));
 
-  Deps = isl_union_map_coalesce(Deps);
-  Deps = isl_union_map_detect_equalities(Deps);
+  Deps = Deps.coalesce();
+  Deps = Deps.detect_equalities();
   return Deps;
 }
 
 bool Dependences::hasValidDependences() const {
   return (RAW != nullptr) && (WAR != nullptr) && (WAW != nullptr);
 }
 
 __isl_give isl_map *

lib/Analysis/PolyhedralInfo.cpp

bool PolyhedralInfo::checkParallel(Loop *L, isl_pw_aff **MinDepDistPtr) const {
   const Dependences &D =
       DI->getDependences(const_cast<Scop *>(S), Dependences::AL_Access);
   if (!D.hasValidDependences())
     return false;
   LLVM_DEBUG(dbgs() << "Loop :\t" << L->getHeader()->getName() << ":\n");
 
   isl_union_map *Deps =
       D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
-                       Dependences::TYPE_WAR | Dependences::TYPE_RED);
+                       Dependences::TYPE_WAR | Dependences::TYPE_RED)
+          .release();
+
   LLVM_DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps) << "\n");
 
   isl_union_map *Schedule = getScheduleForLoop(S, L);
   LLVM_DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule) << "\n");
 
   IsParallel = D.isParallel(Schedule, Deps, MinDepDistPtr);
   isl_union_map_free(Schedule);
   return IsParallel;

lib/CodeGen/IslAst.cpp

 /// (or non-zero) dependence distance on the dimension in question.
 static bool astScheduleDimIsParallel(__isl_keep isl_ast_build *Build,
                                      const Dependences *D,
                                      IslAstUserPayload *NodeInfo) {
   if (!D->hasValidDependences())
     return false;
 
   isl_union_map *Schedule = isl_ast_build_get_schedule(Build);
-  isl_union_map *Deps = D->getDependences(
-      Dependences::TYPE_RAW | Dependences::TYPE_WAW | Dependences::TYPE_WAR);
+  isl_union_map *Deps =
+      D->getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
+                        Dependences::TYPE_WAR)
+          .release();
 
   if (!D->isParallel(Schedule, Deps)) {
     isl_union_map *DepsAll =
         D->getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
-                          Dependences::TYPE_WAR | Dependences::TYPE_TC_RED);
+                          Dependences::TYPE_WAR | Dependences::TYPE_TC_RED)
+            .release();
     D->isParallel(Schedule, DepsAll, &NodeInfo->MinimalDependenceDistance);
     isl_union_map_free(Schedule);
     return false;
   }
 
-  isl_union_map *RedDeps = D->getDependences(Dependences::TYPE_TC_RED);
+  isl_union_map *RedDeps =
+      D->getDependences(Dependences::TYPE_TC_RED).release();
   if (!D->isParallel(Schedule, RedDeps))
     NodeInfo->IsReductionParallel = true;
 
   if (!NodeInfo->IsReductionParallel && !isl_union_map_free(Schedule))
     return true;
 
   // Annotate reduction parallel nodes with the memory accesses which caused the
   // reduction dependences parallel execution of the node conflicts with.

lib/Transform/DeadCodeElimination.cpp

 bool DeadCodeElim::eliminateDeadCode(Scop &S, int PreciseSteps) {
   DependenceInfo &DI = getAnalysis<DependenceInfo>();
   const Dependences &D = DI.getDependences(Dependences::AL_Statement);
 
   if (!D.hasValidDependences())
     return false;
 
   isl::union_set Live = getLiveOut(S);
-  isl::union_map Dep = isl::manage(
-      D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_RED));
+  isl::union_map Dep =
+      D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_RED);
   Dep = Dep.reverse();
 
   if (PreciseSteps == -1)
     Live = Live.affine_hull();
 
   isl::union_set OriginalDomain = S.getDomains();
   int Steps = 0;
   while (true) {

lib/Transform/MaximalStaticExpansion.cpp

 
 bool MaximalStaticExpander::runOnScop(Scop &S) {
   // Get the ORE from OptimizationRemarkEmitterWrapperPass.
   ORE = &(getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE());
 
   // Get the RAW Dependences.
   auto &DI = getAnalysis<DependenceInfo>();
   auto &D = DI.getDependences(Dependences::AL_Reference);
-  auto Dependences = isl::manage(D.getDependences(Dependences::TYPE_RAW));
+  isl::union_map Dependences = D.getDependences(Dependences::TYPE_RAW);
 
   SmallVector<ScopArrayInfo *, 4> CurrentSAI(S.arrays().begin(),
                                              S.arrays().end());
 
   for (auto SAI : CurrentSAI) {
     SmallPtrSet<MemoryAccess *, 4> AllWrites;
     SmallPtrSet<MemoryAccess *, 4> AllReads;
     if (!isExpandable(SAI, AllWrites, AllReads, S, Dependences))

lib/Transform/ScheduleOptimizer.cpp

 /// @param  D The SCoP dependencies.
 /// @param  Pos The parameter to describe an acceptable true dependence.
 ///             In case it has a negative value, try to determine its
 ///             acceptable value.
 /// @return True in case dependencies correspond to the matrix multiplication
 ///         and false, otherwise.
 static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
                                   int &Pos) {
-  auto Dep = isl::manage(D->getDependences(Dependences::TYPE_RAW));
-  auto Red = isl::manage(D->getDependences(Dependences::TYPE_RED));
+  isl::union_map Dep = D->getDependences(Dependences::TYPE_RAW);
+  isl::union_map Red = D->getDependences(Dependences::TYPE_RED);
   if (Red)
     Dep = Dep.unite(Red);
   auto DomainSpace = Schedule.get_space().domain();
   auto Space = DomainSpace.map_from_domain_and_range(DomainSpace);
   auto Deltas = Dep.extract_map(Space).deltas();
   int DeltasDimNum = Deltas.dim(isl::dim::set);
   for (int i = 0; i < DeltasDimNum; i++) {
     auto Val = Deltas.plain_get_val_if_fixed(isl::dim::set, i);
bool IslScheduleOptimizer::runOnScop(Scop &S) {
   isl::union_set Domain = S.getDomains();
 
   if (!Domain)
     return false;
 
   ScopsProcessed++;
   walkScheduleTreeForStatistics(S.getScheduleTree(), 0);
 
-  isl::union_map Validity = isl::manage(D.getDependences(ValidityKinds));
-  isl::union_map Proximity = isl::manage(D.getDependences(ProximityKinds));
+  isl::union_map Validity = D.getDependences(ValidityKinds);
+  isl::union_map Proximity = D.getDependences(ProximityKinds);
 
   // Simplify the dependences by removing the constraints introduced by the
   // domains. This can speed up the scheduling time significantly, as large
   // constant coefficients will be removed from the dependences. The
   // introduction of some additional dependences reduces the possible
   // transformations, but in most cases, such transformation do not seem to be
   // interesting anyway. In some cases this option may stop the scheduler to
   // find any schedule.