From a508a4e619c9c7f531bf504af347d1c90f0d8408 Mon Sep 17 00:00:00 2001
From: Michael Kruse <llvm@meinersbur.de>
Date: Thu, 27 Jul 2017 14:39:52 +0000
Subject: [PATCH] [ScopBuilder/Simplify] Refactor isEscaping. NFC.

ScopBuilder and Simplify (through VirtualInstruction.cpp) previously
used this functionality in their own implementation. Refactor them
both into a common one into the Scop class.

BlockGenerator also makes use of a similiar functionality, but also
records outside users and takes place after region simplification.
Merging it as well would be more complicated.

llvm-svn: 309273
---
 polly/include/polly/ScopInfo.h           |  3 +++
 polly/lib/Analysis/ScopBuilder.cpp       | 23 ++---------------------
 polly/lib/Analysis/ScopInfo.cpp          | 19 +++++++++++++++++++
 polly/lib/Support/VirtualInstruction.cpp | 22 ++--------------------
 4 files changed, 26 insertions(+), 41 deletions(-)

diff --git a/polly/include/polly/ScopInfo.h b/polly/include/polly/ScopInfo.h
index b8fa7dc3f0cc..65c98153ea07 100644
--- a/polly/include/polly/ScopInfo.h
+++ b/polly/include/polly/ScopInfo.h
@@ -2974,6 +2974,9 @@ public:
   /// Return all MemoryAccesses for all incoming statements of a PHINode,
   /// represented by a ScopArrayInfo.
   ArrayRef<MemoryAccess *> getPHIIncomings(const ScopArrayInfo *SAI) const;
+
+  /// Return whether @p Inst has a use outside of this SCoP.
+  bool isEscaping(Instruction *Inst);
 };
 
 /// Print Scop scop to raw_ostream O.
diff --git a/polly/lib/Analysis/ScopBuilder.cpp b/polly/lib/Analysis/ScopBuilder.cpp
index 1210a525f75f..e6e3952622e9 100644
--- a/polly/lib/Analysis/ScopBuilder.cpp
+++ b/polly/lib/Analysis/ScopBuilder.cpp
@@ -105,27 +105,8 @@ void ScopBuilder::buildEscapingDependences(Instruction *Inst) {
   // Check for uses of this instruction outside the scop. Because we do not
   // iterate over such instructions and therefore did not "ensure" the existence
   // of a write, we must determine such use here.
-  for (Use &U : Inst->uses()) {
-    Instruction *UI = dyn_cast<Instruction>(U.getUser());
-    if (!UI)
-      continue;
-
-    BasicBlock *UseParent = getUseBlock(U);
-    BasicBlock *UserParent = UI->getParent();
-
-    // An escaping value is either used by an instruction not within the scop,
-    // or (when the scop region's exit needs to be simplified) by a PHI in the
-    // scop's exit block. This is because region simplification before code
-    // generation inserts new basic blocks before the PHI such that its incoming
-    // blocks are not in the scop anymore.
-    if (!scop->contains(UseParent) ||
-        (isa<PHINode>(UI) && scop->isExit(UserParent) &&
-         scop->hasSingleExitEdge())) {
-      // At least one escaping use found.
-      ensureValueWrite(Inst);
-      break;
-    }
-  }
+  if (scop->isEscaping(Inst))
+    ensureValueWrite(Inst);
 }
 
 /// Check that a value is a Fortran Array descriptor.
diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index 0c65f2e013c7..d6b82efdb659 100644
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -5138,6 +5138,25 @@ ArrayRef<MemoryAccess *> Scop::getPHIIncomings(const ScopArrayInfo *SAI) const {
   return It->second;
 }
 
+bool Scop::isEscaping(Instruction *Inst) {
+  assert(contains(Inst) && "The concept of escaping makes only sense for "
+                           "values defined inside the SCoP");
+
+  for (Use &Use : Inst->uses()) {
+    BasicBlock *UserBB = getUseBlock(Use);
+    if (!contains(UserBB))
+      return true;
+
+    // When the SCoP region exit needs to be simplified, PHIs in the region exit
+    // move to a new basic block such that its incoming blocks are not in the
+    // SCoP anymore.
+    if (hasSingleExitEdge() && isa<PHINode>(Use.getUser()) &&
+        isExit(cast<PHINode>(Use.getUser())->getParent()))
+      return true;
+  }
+  return false;
+}
+
 raw_ostream &polly::operator<<(raw_ostream &O, const Scop &scop) {
   scop.print(O, PollyPrintInstructions);
   return O;
diff --git a/polly/lib/Support/VirtualInstruction.cpp b/polly/lib/Support/VirtualInstruction.cpp
index 33538c78dab3..1d34efb512d0 100644
--- a/polly/lib/Support/VirtualInstruction.cpp
+++ b/polly/lib/Support/VirtualInstruction.cpp
@@ -163,30 +163,12 @@ static bool isRoot(const Instruction *Inst) {
   return false;
 }
 
-/// Return true if @p ComputingInst is used after SCoP @p S. It must not be
-/// removed in order for its value to be available after the SCoP.
-static bool isEscaping(Scop *S, Instruction *ComputingInst) {
-  for (Use &Use : ComputingInst->uses()) {
-    BasicBlock *UserBB = getUseBlock(Use);
-    if (!S->contains(UserBB))
-      return true;
-
-    // When the SCoP region exit needs to be simplified, PHIs in the region exit
-    // move to a new basic block such that its incoming blocks are not in the
-    // scop anymore.
-    if (S->hasSingleExitEdge() && isa<PHINode>(Use.getUser()) &&
-        S->isExit(cast<PHINode>(Use.getUser())->getParent()))
-      return true;
-  }
-  return false;
-}
-
 /// Return true for MemoryAccesses that cannot be removed because it represents
 /// an llvm::Value that is used after the SCoP.
 static bool isEscaping(MemoryAccess *MA) {
   assert(MA->isOriginalValueKind());
-  return isEscaping(MA->getStatement()->getParent(),
-                    cast<Instruction>(MA->getAccessValue()));
+  Scop *S = MA->getStatement()->getParent();
+  return S->isEscaping(cast<Instruction>(MA->getAccessValue()));
 }
 
 /// Add non-removable virtual instructions in @p Stmt to @p RootInsts.
-- 
GitLab