Remove complexity in findBoundariesInBlock

We can remove a ton of complexity by assuming that SSA uses never
occur before a def in the same block. This will hold true as long as
useless phis are only removed after all unreachable code is first
removed. Then we don't have the self-loop problem.

The SILVerifier already checks this invariant and I added an in-depth
comment in SimplifyCFG.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -530,11 +530,6 @@ struct PrunedLivenessBoundary {
 ///
 ///   bool isDefBlock(SILBasicBlock *block) const
 ///
-///   SILArgument *getArgDef(SILBasicBlock *block) const
-///
-///   SILInstruction *findPreviousDef(SILInstruction *searchPos,
-///                                   SILInstruction *nextDef)
-///
 template <typename LivenessWithDefs>
 class PrunedLiveRange : public PrunedLiveness {
 protected:
@@ -587,10 +582,6 @@ class PrunedLiveRange : public PrunedLiveness {
   /// by DeadEndBlocks.
   void computeBoundary(PrunedLivenessBoundary &boundary,
                        ArrayRef<SILBasicBlock *> postDomBlocks) const;
-
-protected:
-  void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
-                             PrunedLivenessBoundary &boundary) const;
 };
 
 // Singly-defined liveness.
@@ -642,28 +633,9 @@ class SSAPrunedLiveness : public PrunedLiveRange<SSAPrunedLiveness> {
     return def->getParentBlock() == block;
   }
 
-  /// If the argument list of \p block contains a definition, return it.
-  SILArgument *getArgDef(SILBasicBlock *block) const {
-    if (auto *arg = dyn_cast<SILArgument>(def)) {
-      if (arg->getParent() == block)
-        return arg;
-    }
-    return nullptr;
-  }
-
-  /// Return the definition if it occurs in the same block before \p searchPos.
-  ///
-  /// Precondition: if the definition occurs in the same block on or after \p
-  /// searchPos, then \p nextDef must point to the definition.
-  SILInstruction *findPreviousDef(SILInstruction *searchPos,
-                                  SILInstruction *nextDef) const {
-    if (!defInst || nextDef) {
-      assert(nextDef == defInst);
-      return nullptr;
-    }
-    auto *block = searchPos->getParent();
-    return defInst->getParent() == block ? defInst : nullptr;
-  }
+  /// SSA implementation of computeBoundary.
+  void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
+                             PrunedLivenessBoundary &boundary) const;
 
   /// Compute liveness for a single SSA definition. The lifetime-ending uses are
   /// also recorded--destroy_value or end_borrow.
@@ -722,26 +694,9 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
     return defBlocks.contains(block);
   }
 
-  /// If the argument list of \p block contains a definition, return it.
-  SILArgument *getArgDef(SILBasicBlock *block) const {
-    if (!isDefBlock(block))
-      return nullptr;
-
-    for (SILArgument *arg : block->getArguments()) {
-      if (defs.contains(arg))
-        return arg;
-    }
-    return nullptr;
-  }
-
-  /// Return the previous definition that occurs in the same block before \p
-  /// searchPos, or nullptr if none exists.
-  ///
-  /// Precondition: if a definition occurs in the same block on or after \p
-  /// searchPos, then \p nextDef must point to the next definition. searchPos
-  /// cannot point to nextDef.
-  SILInstruction *findPreviousDef(SILInstruction *searchPos,
-                                  SILInstruction *nextDef) const;
+  /// Multi-Def implementation of computeBoundary.
+  void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
+                             PrunedLivenessBoundary &boundary) const;
 
   /// Compute liveness for a all currently initialized definitions. The
   /// lifetime-ending uses are also recorded--destroy_value or

lib/SIL/Utils/PrunedLiveness.cpp

@@ -367,44 +367,6 @@ bool PrunedLiveRange<LivenessWithDefs>::areUsesOutsideBoundary(
   return true;
 }
 
-template <typename LivenessWithDefs>
-void PrunedLiveRange<LivenessWithDefs>::findBoundariesInBlock(
-    SILBasicBlock *block, bool isLiveOut,
-    PrunedLivenessBoundary &boundary) const {
-  assert(asImpl().isInitialized());
-
-  bool isLive = isLiveOut;
-  bool isDefBlock = asImpl().isDefBlock(block);
-  SILInstruction *nextDef = nullptr;
-  SILInstruction *searchPos = block->getTerminator();
-  while (searchPos) {
-    if (isLive) {
-      nextDef = asImpl().findPreviousDef(searchPos, nextDef);
-      if (!nextDef)
-        return;
-
-      searchPos = nextDef;
-      isLive = false;
-    } else if (isDefBlock) {
-      // Check if the previous instruction is a def before checking whether it
-      // is a use. The same instruction can be both a dead def and boundary use.
-      if (asImpl().isDef(searchPos)) {
-        boundary.deadDefs.push_back(cast<SILNode>(searchPos));
-      }
-    }
-    if (isInterestingUser(searchPos)) {
-      boundary.lastUsers.push_back(searchPos);
-      isLive = true;
-    }
-    searchPos = searchPos->getPreviousInstruction();
-  }
-  if (!isLive && isDefBlock) {
-    if (SILArgument *deadArg = asImpl().getArgDef(block)) {
-      boundary.deadDefs.push_back(deadArg);
-    }
-  }
-}
-
 template <typename LivenessWithDefs>
 void PrunedLiveRange<LivenessWithDefs>::computeBoundary(
     PrunedLivenessBoundary &boundary) const {
@@ -419,10 +381,10 @@ void PrunedLiveRange<LivenessWithDefs>::computeBoundary(
           boundary.boundaryEdges.push_back(succBB);
         }
       }
-      findBoundariesInBlock(block, /*isLiveOut*/ true, boundary);
+      asImpl().findBoundariesInBlock(block, /*isLiveOut*/ true, boundary);
       break;
     case PrunedLiveBlocks::LiveWithin: {
-      findBoundariesInBlock(block, /*isLiveOut*/ false, boundary);
+      asImpl().findBoundariesInBlock(block, /*isLiveOut*/ false, boundary);
       break;
     }
     case PrunedLiveBlocks::Dead:
@@ -451,10 +413,10 @@ void PrunedLiveRange<LivenessWithDefs>::computeBoundary(
     // Process each block that has not been visited and is not LiveOut.
     switch (getBlockLiveness(block)) {
     case PrunedLiveBlocks::LiveOut:
-      findBoundariesInBlock(block, /*isLiveOut*/ true, boundary);
+      asImpl().findBoundariesInBlock(block, /*isLiveOut*/ true, boundary);
       break;
     case PrunedLiveBlocks::LiveWithin: {
-      findBoundariesInBlock(block, /*isLiveOut*/ false, boundary);
+      asImpl().findBoundariesInBlock(block, /*isLiveOut*/ false, boundary);
       break;
     }
     case PrunedLiveBlocks::Dead:
@@ -476,26 +438,71 @@ template class PrunedLiveRange<SSAPrunedLiveness>;
 template class PrunedLiveRange<MultiDefPrunedLiveness>;
 } // namespace swift
 
+//===----------------------------------------------------------------------===//
+//                             SSAPrunedLiveness
+//===----------------------------------------------------------------------===//
+
+void SSAPrunedLiveness::findBoundariesInBlock(
+    SILBasicBlock *block, bool isLiveOut,
+    PrunedLivenessBoundary &boundary) const {
+  assert(isInitialized());
+
+  // For SSA, a live-out block cannot have a boundary.
+  if (isLiveOut)
+    return;
+
+  bool isDefBlockState = isDefBlock(block);
+  for (SILInstruction &inst : llvm::reverse(*block)) {
+    if (isDefBlockState && isDef(&inst)) {
+      boundary.deadDefs.push_back(cast<SILNode>(&inst));
+      return;
+    }
+    if (isInterestingUser(&inst)) {
+      boundary.lastUsers.push_back(&inst);
+      return;
+    }
+  }
+  auto *deadArg = dyn_cast<SILArgument>(def);
+  assert(deadArg && deadArg->getParent() == block
+         && "findBoundariesInBlock must be called on a live block");
+  boundary.deadDefs.push_back(deadArg);
+}
+
 //===----------------------------------------------------------------------===//
 //                           MultiDefPrunedLiveness
 //===----------------------------------------------------------------------===//
 
-SILInstruction *
-MultiDefPrunedLiveness::findPreviousDef(SILInstruction *searchPos,
-                                        SILInstruction *nextDef) const {
-  auto *block = searchPos->getParent();
-  if (!defBlocks.contains(block))
-    return nullptr;
+void MultiDefPrunedLiveness::findBoundariesInBlock(
+    SILBasicBlock *block, bool isLiveOut,
+    PrunedLivenessBoundary &boundary) const {
+  assert(isInitialized());
+  unsigned prevCount = boundary.deadDefs.size() + boundary.lastUsers.size();
 
-  auto it = searchPos->getReverseIterator();
-  if (searchPos == nextDef) {
-    ++it;
+  bool isLive = isLiveOut;
+  bool isDefBlockState = isDefBlock(block);
+  for (auto &inst : llvm::reverse(*block)) {
+    // Check if the instruction is a def before checking whether it is a
+    // use. The same instruction can be both a dead def and boundary use.
+    if (isDefBlockState && isDef(&inst)) {
+      if (!isLive) {
+        boundary.deadDefs.push_back(cast<SILNode>(&inst));
+      }
+      isLive = false;
+    }
+    if (!isLive && isInterestingUser(&inst)) {
+      boundary.lastUsers.push_back(&inst);
+      isLive = true;
+    }
   }
-  for (auto end = block->rend(); it != end; ++it) {
-    if (isDef(&*it))
-      return &*it;
+  if (!isLive && isDefBlockState) {
+    for (SILArgument *deadArg : block->getArguments()) {
+      if (defs.contains(deadArg)) {
+        boundary.deadDefs.push_back(deadArg);
+      }
+    }
   }
-  return nullptr;
+  assert(prevCount < boundary.deadDefs.size() + boundary.lastUsers.size()
+         && "findBoundariesInBlock must be called on a live block");
 }
 
 SimpleLiveRangeSummary MultiDefPrunedLiveness::computeSimple() {