[ZoneAlgo] Make ZoneAlgorithm::isNormalized out-of-quota safe.

The aosp-O3-polly-before-vectorizer-unprofitable buildbot currently
fails in ZoneAlgorithm::isNormalized, presumably because an
out-of-quota happens in that function.

Modify ZoneAlgorithm::isNormalized to return an isl::boolean such
it can report an error.

In the failing case, it was called in an assertion in ForwardOpTree.
Allow to pass the assertion in an out-of-quota event, a condition that
is later checked before forwarding an operand tree.

llvm-svn: 333709

3 files changed, 23 insertions, 14 deletions

diff --git a/polly/include/polly/ZoneAlgo.h b/polly/include/polly/ZoneAlgo.h
index 43a9da9eb32..5f009c8befc 100644
--- a/polly/include/polly/ZoneAlgo.h
+++ b/polly/include/polly/ZoneAlgo.h
@@ -336,8 +336,8 @@ protected:
   /// should have been replaced by their incoming values.
   ///
   /// @see #NormalizedPHI
-  bool isNormalized(isl::map Map);
-  bool isNormalized(isl::union_map Map);
+  isl::boolean isNormalized(isl::map Map);
+  isl::boolean isNormalized(isl::union_map Map);
   /// @}
 
 public:
diff --git a/polly/lib/Transform/ForwardOpTree.cpp b/polly/lib/Transform/ForwardOpTree.cpp
index 9a643916781..9c24170bcd5 100644
--- a/polly/lib/Transform/ForwardOpTree.cpp
+++ b/polly/lib/Transform/ForwardOpTree.cpp
@@ -500,7 +500,8 @@ public:
 
     // { DomainDef[] -> ValInst[] }
     isl::map ExpectedVal = makeValInst(Inst, UseStmt, UseLoop);
-    assert(isNormalized(ExpectedVal) && "LoadInsts are always normalized");
+    assert(!isNormalized(ExpectedVal).is_false() &&
+           "LoadInsts are always normalized");
 
     // { DomainUse[] -> DomainTarget[] }
     isl::map UseToTarget = getDefToTarget(UseStmt, TargetStmt);
diff --git a/polly/lib/Transform/ZoneAlgo.cpp b/polly/lib/Transform/ZoneAlgo.cpp
index 2ad40d83d36..a34fcb37754 100644
--- a/polly/lib/Transform/ZoneAlgo.cpp
+++ b/polly/lib/Transform/ZoneAlgo.cpp
@@ -842,20 +842,26 @@ bool ZoneAlgorithm::isNormalizable(MemoryAccess *MA) {
   return true;
 }
 
-bool ZoneAlgorithm::isNormalized(isl::map Map) {
+isl::boolean ZoneAlgorithm::isNormalized(isl::map Map) {
   isl::space Space = Map.get_space();
   isl::space RangeSpace = Space.range();
 
-  if (!RangeSpace.is_wrapping())
-    return true;
+  isl::boolean IsWrapping = RangeSpace.is_wrapping();
+  if (!IsWrapping.is_true())
+    return !IsWrapping;
+  isl::space Unwrapped = RangeSpace.unwrap();
 
-  auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
-      RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
+  isl::id OutTupleId = Unwrapped.get_tuple_id(isl::dim::out);
+  if (OutTupleId.is_null())
+    return isl::boolean();
+  auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(OutTupleId.get_user()));
   if (!PHI)
     return true;
 
-  auto *IncomingStmt = static_cast<ScopStmt *>(
-      RangeSpace.unwrap().get_tuple_id(isl::dim::in).get_user());
+  isl::id InTupleId = Unwrapped.get_tuple_id(isl::dim::in);
+  if (OutTupleId.is_null())
+    return isl::boolean();
+  auto *IncomingStmt = static_cast<ScopStmt *>(InTupleId.get_user());
   MemoryAccess *PHIRead = IncomingStmt->lookupPHIReadOf(PHI);
   if (!isNormalizable(PHIRead))
     return true;
@@ -863,13 +869,15 @@ bool ZoneAlgorithm::isNormalized(isl::map Map) {
   return false;
 }
 
-bool ZoneAlgorithm::isNormalized(isl::union_map UMap) {
-  auto Result = UMap.foreach_map([this](isl::map Map) -> isl::stat {
-    if (isNormalized(Map))
+isl::boolean ZoneAlgorithm::isNormalized(isl::union_map UMap) {
+  isl::boolean Result = true;
+  UMap.foreach_map([this, &Result](isl::map Map) -> isl::stat {
+    Result = isNormalized(Map);
+    if (Result.is_true())
       return isl::stat::ok;
     return isl::stat::error;
   });
-  return Result == isl::stat::ok;
+  return Result;
 }
 
 void ZoneAlgorithm::computeCommon() {