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

[Michael Kruse via llvm-commits]

Author: meinersbur
Date: Thu May 31 15:44:23 2018
New Revision: 333709

URL: http://llvm.org/viewvc/llvm-project?rev=333709&view=rev
Log:
[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.

Modified:
    polly/trunk/include/polly/ZoneAlgo.h
    polly/trunk/lib/Transform/ForwardOpTree.cpp
    polly/trunk/lib/Transform/ZoneAlgo.cpp

Modified: polly/trunk/include/polly/ZoneAlgo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ZoneAlgo.h?rev=333709&r1=333708&r2=333709&view=diff
==============================================================================
--- polly/trunk/include/polly/ZoneAlgo.h (original)
+++ polly/trunk/include/polly/ZoneAlgo.h Thu May 31 15:44:23 2018
@@ -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:

Modified: polly/trunk/lib/Transform/ForwardOpTree.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/ForwardOpTree.cpp?rev=333709&r1=333708&r2=333709&view=diff
==============================================================================
--- polly/trunk/lib/Transform/ForwardOpTree.cpp (original)
+++ polly/trunk/lib/Transform/ForwardOpTree.cpp Thu May 31 15:44:23 2018
@@ -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);

Modified: polly/trunk/lib/Transform/ZoneAlgo.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/ZoneAlgo.cpp?rev=333709&r1=333708&r2=333709&view=diff
==============================================================================
--- polly/trunk/lib/Transform/ZoneAlgo.cpp (original)
+++ polly/trunk/lib/Transform/ZoneAlgo.cpp Thu May 31 15:44:23 2018
@@ -842,20 +842,26 @@ bool ZoneAlgorithm::isNormalizable(Memor
   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;
-
-  auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
-      RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
+  isl::boolean IsWrapping = RangeSpace.is_wrapping();
+  if (!IsWrapping.is_true())
+    return !IsWrapping;
+  isl::space Unwrapped = RangeSpace.unwrap();
+
+  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::ma
   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() {