Index: include/polly/DependenceInfo.h
===================================================================
--- include/polly/DependenceInfo.h
+++ include/polly/DependenceInfo.h
@@ -99,7 +99,7 @@
   /// @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;
Index: lib/Analysis/DependenceInfo.cpp
===================================================================
--- lib/Analysis/DependenceInfo.cpp
+++ lib/Analysis/DependenceInfo.cpp
@@ -736,7 +736,8 @@
   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);
 
@@ -874,28 +875,28 @@
   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;
 }
 
Index: lib/Analysis/PolyhedralInfo.cpp
===================================================================
--- lib/Analysis/PolyhedralInfo.cpp
+++ lib/Analysis/PolyhedralInfo.cpp
@@ -83,7 +83,9 @@
 
   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);
Index: lib/CodeGen/IslAst.cpp
===================================================================
--- lib/CodeGen/IslAst.cpp
+++ lib/CodeGen/IslAst.cpp
@@ -216,19 +216,23 @@
     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;
 
Index: lib/Transform/DeadCodeElimination.cpp
===================================================================
--- lib/Transform/DeadCodeElimination.cpp
+++ lib/Transform/DeadCodeElimination.cpp
@@ -124,8 +124,8 @@
     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)
Index: lib/Transform/MaximalStaticExpansion.cpp
===================================================================
--- lib/Transform/MaximalStaticExpansion.cpp
+++ lib/Transform/MaximalStaticExpansion.cpp
@@ -444,7 +444,7 @@
   // 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());
Index: lib/Transform/ScheduleOptimizer.cpp
===================================================================
--- lib/Transform/ScheduleOptimizer.cpp
+++ lib/Transform/ScheduleOptimizer.cpp
@@ -728,8 +728,8 @@
 ///         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();
@@ -1518,8 +1518,8 @@
   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