Index: lib/Analysis/ScopInfo.cpp
===================================================================
--- lib/Analysis/ScopInfo.cpp
+++ lib/Analysis/ScopInfo.cpp
@@ -2302,18 +2302,24 @@
 }
 
 /// Add the minimal/maximal access in @p Set to @p User.
-static isl::stat
-buildMinMaxAccess(isl::set Set, Scop::MinMaxVectorTy &MinMaxAccesses, Scop &S) {
+static isl::stat buildMinMaxAccess(isl::set Set,
+                                   Scop::MinMaxVectorTy &MinMaxAccesses,
+                                   Scop &S, bool &Aborted) {
   isl::pw_multi_aff MinPMA, MaxPMA;
   isl::pw_aff LastDimAff;
   isl::aff OneAff;
   unsigned Pos;
   isl::ctx Ctx = Set.get_ctx();
 
+  if (Aborted)
+    return isl::stat::ok;
+
   Set = Set.remove_divs();
 
-  if (isl_set_n_basic_set(Set.get()) >= MaxDisjunctsInDomain)
-    return isl::stat::error;
+  if (isl_set_n_basic_set(Set.get()) >= MaxDisjunctsInDomain) {
+    Aborted = true;
+    return isl::stat::ok;
+  }
 
   // Restrict the number of parameters involved in the access as the lexmin/
   // lexmax computation will take too long if this number is high.
@@ -2335,18 +2341,24 @@
       if (Set.involves_dims(isl::dim::param, u, 1))
         InvolvedParams++;
 
-    if (InvolvedParams > RunTimeChecksMaxParameters)
-      return isl::stat::error;
+    if (InvolvedParams > RunTimeChecksMaxParameters) {
+      Aborted = true;
+      return isl::stat::ok;
+    }
   }
 
-  if (isl_set_n_basic_set(Set.get()) > RunTimeChecksMaxAccessDisjuncts)
-    return isl::stat::error;
+  if (isl_set_n_basic_set(Set.get()) > RunTimeChecksMaxAccessDisjuncts) {
+    Aborted = true;
+    return isl::stat::ok;
+  }
 
   MinPMA = Set.lexmin_pw_multi_aff();
   MaxPMA = Set.lexmax_pw_multi_aff();
 
-  if (isl_ctx_last_error(Ctx.get()) == isl_error_quota)
-    return isl::stat::error;
+  if (isl_ctx_last_error(Ctx.get()) == isl_error_quota) {
+    Aborted = true;
+    return isl::stat::ok;
+  }
 
   MinPMA = MinPMA.coalesce();
   MaxPMA = MaxPMA.coalesce();
@@ -2390,10 +2402,13 @@
   Locations = Locations.coalesce();
   Locations = Locations.detect_equalities();
 
-  auto Lambda = [&MinMaxAccesses, &S](isl::set Set) -> isl::stat {
-    return buildMinMaxAccess(Set, MinMaxAccesses, S);
+  bool Aborted = false;
+  auto Lambda = [&MinMaxAccesses, &S, &Aborted](isl::set Set) -> isl::stat {
+    return buildMinMaxAccess(Set, MinMaxAccesses, S, Aborted);
   };
-  return Locations.foreach_set(Lambda) == isl::stat::ok;
+  Locations.foreach_set(Lambda);
+
+  return !Aborted;
 }
 
 /// Helper to treat non-affine regions and basic blocks the same.
Index: lib/Support/ISLTools.cpp
===================================================================
--- lib/Support/ISLTools.cpp
+++ lib/Support/ISLTools.cpp
@@ -542,7 +542,7 @@
     // Set is constant-bounded.
     if (!Aff.is_cst()) {
       Result = isl::val::nan(Aff.get_ctx());
-      return isl::stat::error;
+      return isl::stat::ok;
     }
 
     isl::val ThisVal = Aff.get_constant_val();
@@ -566,7 +566,7 @@
 
     // Not compatible
     Result = isl::val::nan(Aff.get_ctx());
-    return isl::stat::error;
+    return isl::stat::ok;
   });
   return Result;
 }
Index: lib/Transform/FlattenAlgo.cpp
===================================================================
--- lib/Transform/FlattenAlgo.cpp
+++ lib/Transform/FlattenAlgo.cpp
@@ -54,20 +54,28 @@
 
 /// Whether Map's first out dimension is no constant nor piecewise constant.
 bool isVariableDim(const isl::map &Map) {
-  return Map.foreach_basic_map([](isl::basic_map BMap) -> isl::stat {
+  bool IsVariableDim = false;
+
+  Map.foreach_basic_map([&](isl::basic_map BMap) -> isl::stat {
     if (isVariableDim(BMap))
-      return isl::stat::error;
+      IsVariableDim = true;
     return isl::stat::ok;
-  }) == isl::stat::ok;
+  });
+
+  return IsVariableDim;
 }
 
 /// Whether UMap's first out dimension is no (piecewise) constant.
 bool isVariableDim(const isl::union_map &UMap) {
-  return UMap.foreach_map([](isl::map Map) -> isl::stat {
+  bool IsVariableDim = false;
+
+  UMap.foreach_map([&](isl::map Map) {
     if (isVariableDim(Map))
-      return isl::stat::error;
+      IsVariableDim = true;
     return isl::stat::ok;
-  }) == isl::stat::ok;
+  });
+
+  return IsVariableDim;
 }
 
 /// Compute @p UPwAff - @p Val.
Index: lib/Transform/ForwardOpTree.cpp
===================================================================
--- lib/Transform/ForwardOpTree.cpp
+++ lib/Transform/ForwardOpTree.cpp
@@ -243,8 +243,12 @@
     // (i.e. not: { Dom[0] -> A[0]; Dom[1] -> B[1] }).
     // Look through all spaces until we find one that contains at least the
     // wanted statement instance.s
+    bool Aborted = false;
     MustKnown.foreach_map([&](isl::map Map) -> isl::stat {
       // Get the array this is accessing.
+      if (Aborted)
+        return isl::stat::ok;
+
       isl::id ArrayId = Map.get_tuple_id(isl::dim::out);
       ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(ArrayId.get_user());
 
@@ -262,7 +266,9 @@
       // mapping, we do not care about which one.
       // TODO: Get the simplest access function.
       Result = Map.lexmin();
-      return isl::stat::error; // break
+
+      Aborted = true;
+      return isl::stat::ok; // break
     });
 
     return Result;
Index: lib/Transform/MaximalStaticExpansion.cpp
===================================================================
--- lib/Transform/MaximalStaticExpansion.cpp
+++ lib/Transform/MaximalStaticExpansion.cpp
@@ -142,7 +142,7 @@
     // Set is constant-bounded.
     if (!Aff.is_cst()) {
       Result = isl::val::nan(Aff.get_ctx());
-      return isl::stat::error;
+      return isl::stat::ok;
     }
 
     auto ThisVal = Aff.get_constant_val();
@@ -166,7 +166,7 @@
 
     // Not compatible
     Result = isl::val::nan(Aff.get_ctx());
-    return isl::stat::error;
+    return isl::stat::ok;
   });
   return Result;
 }
Index: lib/Transform/Simplify.cpp
===================================================================
--- lib/Transform/Simplify.cpp
+++ lib/Transform/Simplify.cpp
@@ -97,15 +97,28 @@
     return UMap.add_map(Map);
 
   isl::map Result = isl::map::empty(PrevMap.get_space());
-  PrevMap.foreach_basic_map([&Result](isl::basic_map BMap) -> isl::stat {
-    if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts)
-      return isl::stat::error;
-    Result = Result.unite(BMap);
-    return isl::stat::ok;
-  });
-  Map.foreach_basic_map([&Result](isl::basic_map BMap) -> isl::stat {
-    if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts)
-      return isl::stat::error;
+  bool Aborted;
+
+  Aborted = false;
+  PrevMap.foreach_basic_map(
+      [&Result, &Aborted](isl::basic_map BMap) -> isl::stat {
+        if (Aborted)
+          return isl::stat::ok;
+
+        if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts) {
+          Aborted = true;
+          return isl::stat::ok;
+        }
+        Result = Result.unite(BMap);
+        return isl::stat::ok;
+      });
+
+  Aborted = false;
+  Map.foreach_basic_map([&Result, &Aborted](isl::basic_map BMap) -> isl::stat {
+    if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts) {
+      Aborted = true;
+      return isl::stat::ok;
+    }
     Result = Result.unite(BMap);
     return isl::stat::ok;
   });
@@ -312,7 +325,10 @@
               FutureWrites.uncurry().intersect_domain(Filter.wrap());
 
           // Iterate through the candidates.
+          bool Aborted = false;
           Filtered.foreach_map([&, this](isl::map Map) -> isl::stat {
+            if (Aborted)
+              return isl::stat::ok;
             MemoryAccess *OtherMA = (MemoryAccess *)Map.get_space()
                                         .get_tuple_id(isl::dim::out)
                                         .get_user();
@@ -342,7 +358,8 @@
             WritesCoalesced++;
 
             // Don't look for more candidates.
-            return isl::stat::error;
+            Aborted = true;
+            return isl::stat::ok;
           });
         }
 
Index: lib/Transform/ZoneAlgo.cpp
===================================================================
--- lib/Transform/ZoneAlgo.cpp
+++ lib/Transform/ZoneAlgo.cpp
@@ -877,12 +877,13 @@
 }
 
 bool ZoneAlgorithm::isNormalized(isl::union_map UMap) {
-  auto Result = UMap.foreach_map([this](isl::map Map) -> isl::stat {
-    if (isNormalized(Map))
-      return isl::stat::ok;
-    return isl::stat::error;
+  bool IsNormalized = true;
+  auto Result = UMap.foreach_map([&](isl::map Map) -> isl::stat {
+    if (!isNormalized(Map))
+      IsNormalized = false;
+    return isl::stat::ok;
   });
-  return Result == isl::stat::ok;
+  return IsNormalized;
 }
 
 void ZoneAlgorithm::computeCommon() {