MultiDefPrunedLiveness: add support for arbitrary uses/defs.

This now supports liveness holes within blocks where previously we
expected a phi def.

PrunedLiveness is streamlined for SSA liveness where we expect the
defs and uses to be related in the SSA def-use graph.
MultiDefPrunedLiveness was added on top of SSAPrunedLivenes to handle
extended SSA liveness that occurs with phis, but are still connected
in the def-use graph. Recently MultiDefPrunedLiveness was repurposed
for liveness of addressible storage. This means that we can now have
uses before defs in the same block without a corresponding phi.

Fortunately, handling this case is a straightforward extension of
MultiDefPrunedLiveness that does not complicate or penalize the
streamlined SSA case.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -226,21 +226,20 @@ class PrunedLiveBlocks {
 
   /// Update this liveness result for a single use.
   ///
-  /// Note: this never propagates liveness upward beyond def blocks.
-  /// PrunedLiveRange knows about defs and whether it is possible for a
-  /// block to contain a use before the first def. It must check that case
-  /// separately and propagate liveness to predecessors.
-  IsLive updateForUse(SILInstruction *user) {
+  /// \p isUseBeforeDef is true if \p user occures before the first def in this
+  /// block. This indicates "liveness holes" inside the block, causing liveness
+  /// to propagate to predecessors.
+  IsLive updateForUse(SILInstruction *user, bool isUseBeforeDef) {
     assert(isInitialized() && "at least one definition must be initialized");
 
     auto *block = user->getParent();
-    auto liveness = getBlockLiveness(block);
-    // If a block is already marked live, assume that liveness was propagated to
-    // its predecessors. This assumes that uses will never be added above a def
-    // in the same block.
-    if (liveness != Dead)
-      return liveness;
-
+    if (!isUseBeforeDef) {
+      auto liveness = getBlockLiveness(block);
+      // If a block is already marked live, it must either "kill" liveness, or
+      // liveness was already propagated to its predecessors.
+      if (liveness != Dead)
+        return liveness;
+    }
     computeUseBlockLiveness(block);
     return getBlockLiveness(block);
   }
@@ -662,6 +661,9 @@ class SSAPrunedLiveness : public PrunedLiveRange<SSAPrunedLiveness> {
     return def->getParentBlock() == block;
   }
 
+  /// In SSA, uses never occur before the single def.
+  bool isUserBeforeDef(SILInstruction *user) const { return false; }
+
   /// SSA implementation of computeBoundary.
   void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
                              PrunedLivenessBoundary &boundary) const;
@@ -713,7 +715,7 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
   }
 
   void initializeDef(SILInstruction *defInst) {
-    initializeDefNode(defInst->asSILNode());
+    initializeDefNode(cast<SILNode>(defInst));
   }
 
   void initializeDef(SILArgument *defArg) { initializeDefNode(defArg); }
@@ -735,10 +737,25 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
     return defs.contains(cast<SILNode>(inst));
   }
 
+  bool isDef(SILArgument *arg) const {
+    return defs.contains(arg);
+  }
+
   bool isDefBlock(SILBasicBlock *block) const {
     return defBlocks.contains(block);
   }
 
+  /// Return true if \p user occurs before the first def in the same basic
+  /// block. In classical liveness dataflow terms, gen/kill conditions over all
+  /// users in 'bb' are:
+  ///
+  ///   Gen(bb)  |= !isDefBlock(bb) || isUserBeforeDef(bb)
+  ///   Kill(bb) &= isDefBlock(bb) && !isUserBeforeDef(bb)
+  ///
+  /// If 'bb' has no users, it is neither a Gen nor Kill. Otherwise, Gen and
+  /// Kill are complements.
+  bool isUserBeforeDef(SILInstruction *user) const;
+
   /// Multi-Def implementation of computeBoundary.
   void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
                              PrunedLivenessBoundary &boundary) const;

lib/SIL/Utils/PrunedLiveness.cpp

@@ -168,7 +168,7 @@ void PrunedLivenessBoundary::visitInsertionPoints(
 template <typename LivenessWithDefs>
 void PrunedLiveRange<LivenessWithDefs>::updateForUse(SILInstruction *user,
                                                      bool lifetimeEnding) {
-  liveBlocks.updateForUse(user);
+  liveBlocks.updateForUse(user, asImpl().isUserBeforeDef(user));
 
   // Note that a user may use the current value from multiple operands. If any
   // of the uses are non-lifetime-ending, then we must consider the user
@@ -527,6 +527,29 @@ void SSAPrunedLiveness::findBoundariesInBlock(
 //                           MultiDefPrunedLiveness
 //===----------------------------------------------------------------------===//
 
+bool MultiDefPrunedLiveness::isUserBeforeDef(SILInstruction *user) const {
+  auto *block = user->getParent();
+  if (!isDefBlock(block))
+    return false;
+
+  if (llvm::any_of(block->getArguments(), [this](SILArgument *arg) {
+    return isDef(arg);
+  })) {
+    return false;
+  }
+
+  auto *current = user;
+  while (true) {
+    // If user is also a def, then the use is considered before the def.
+    current = current->getPreviousInstruction();
+    if (!current)
+      return true;
+
+    if (isDef(current))
+      return false;
+  }
+}
+
 void MultiDefPrunedLiveness::findBoundariesInBlock(
     SILBasicBlock *block, bool isLiveOut,
     PrunedLivenessBoundary &boundary) const {

test/SILOptimizer/liveness_unit.sil

@@ -507,22 +507,20 @@ bb0(%0 : @guaranteed $C):
 // CHECK-LABEL: begin running test 1 of 1 on testMultiDefUseAddressReinit
 // CHECK: MultiDef lifetime analysis:
 // CHECK:   def instruction:   store %{{.*}} to [init] [[ADR:%.*]] : $*C
-// CHECK:   def instruction:   destroy_addr [[ADR]] : $*C
-// CHECK: bb0: LiveWithin
+// CHECK:   def instruction:   store %0 to [init] [[ADR]] : $*C
+// CHECK: bb0: LiveOut
 // CHECK: bb1: LiveWithin
 // CHECK: regular user: %{{.*}} = load [copy] [[ADR]] : $*C
 // CHECK: last user:    %{{.*}} = load [copy] [[ADR]] : $*C
-//
-// FIXME: This store is not really a dead def!
-// CHECK: dead def:   store %2 to [init] %1 : $*C
-// CHECK: dead def:   destroy_addr %1 : $*C
+// CHECK: boundary edge: bb2
+// CHECK: dead def:   store %0 to [init] %1 : $*C
 // CHECK-LABEL: end running test 1 of 1 on testMultiDefUseAddressReinit
 sil [ossa] @testMultiDefUseAddressReinit : $@convention(thin) (@owned C) -> () {
 bb0(%0: @owned $C):
   %1 = alloc_stack $C
   %2 = copy_value %0 : $C
   test_specification """
-                     multidefuse-liveness defs: @instruction @block[1].instruction[1]
+                     multidefuse-liveness defs: @instruction @block[1].instruction[2]
                      uses: @block[1].instruction[0]
                      """
   store %2 to [init] %1 : $*C