[LifetimeExtension] Handle use-before-def.

The multi-def algorithm is based off the single-def algorithm.  However,
it differs from it in needing to handle "liveness holes"--uses before defs.

When identifying blocks which are originally live, the algorithm starts
from consuming blocks and walks backwards until a condition is met.

Previously, that condition was finding blocks which were originally
live.  That makes sense in the single-def case: if a block is originally
live, either it was already walked through or else it was one of the
blocks discovered by liveness.  In either case, its predecessors have
already been visited if appropriate.

However, in the multi-def case, this condition is too stringent.  It
fails to account for the possibility of a block with has a "liveness
hole".  Only stop the backwards walk if the predecessor not only (1) was
in originally live but additionally (2) "kills liveness"--doesn't have a
use before a def.

rdar://111221183

Author: nate-chandler

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1414,6 +1414,8 @@ class ExtendUnconsumedLiveness {
 
 private:
   bool hasDefAfter(SILInstruction *inst, unsigned element);
+  bool isLiveAtBegin(SILBasicBlock *block, unsigned element, bool isLiveAtEnd,
+                     DestroysCollection const &destroys);
 
   bool
   shouldAddDestroyToLiveness(SILInstruction *destroy, unsigned element,
@@ -2967,7 +2969,14 @@ void ExtendUnconsumedLiveness::runOnField(
     // as the other consuming uses).
     BasicBlockWorklist worklist(currentDef->getFunction());
     for (auto *consumingBlock : consumingBlocks) {
-      worklist.push(consumingBlock);
+      if (!originalLiveBlocks.insert(consumingBlock)
+          // Don't walk into the predecessors of blocks which kill liveness.
+          && !isLiveAtBegin(consumingBlock, element, /*isLiveAtEnd=*/true, destroys)) {
+        continue;
+      }
+      for (auto *predecessor : consumingBlock->getPredecessorBlocks()) {
+        worklist.pushIfNotVisited(predecessor);
+      }
     }
 
     // Walk backwards from consuming blocks.
@@ -2976,10 +2985,6 @@ void ExtendUnconsumedLiveness::runOnField(
         continue;
       }
       for (auto *predecessor : block->getPredecessorBlocks()) {
-        // If the block was discovered by liveness, we already added it to the
-        // set.
-        if (originalLiveBlocks.contains(predecessor))
-          continue;
         worklist.pushIfNotVisited(predecessor);
       }
     }
@@ -3096,6 +3101,37 @@ bool ExtendUnconsumedLiveness::shouldAddDestroyToLiveness(
   return !consumedAtEntryBlocks.contains(block);
 }
 
+/// Compute the block's effect on liveness and apply it to \p isLiveAtEnd.
+bool ExtendUnconsumedLiveness::isLiveAtBegin(SILBasicBlock *block,
+                                             unsigned element, bool isLiveAtEnd,
+                                             DestroysCollection const &destroys) {
+  enum class Effect {
+    None, // 0
+    Kill, // 1
+    Gen,  // 2
+  };
+  auto effect = Effect::None;
+  for (auto &instruction : llvm::reverse(*block)) {
+    // An instruction can be both a destroy and a def.  If it is, its
+    // behavior is first to destroy and then to init.  So when walking
+    // backwards, its last action is to destroy, so its effect is that of any
+    // destroy.
+    if (destroys.find(&instruction) != destroys.end()) {
+      effect = Effect::Gen;
+    } else if (liveness.isDef(&instruction, element)) {
+      effect = Effect::Kill;
+    }
+  }
+  switch (effect) {
+  case Effect::None:
+    return isLiveAtEnd;
+  case Effect::Kill:
+    return false;
+  case Effect::Gen:
+    return true;
+  }
+}
+
 bool ExtendUnconsumedLiveness::hasDefAfter(SILInstruction *start,
                                            unsigned element) {
   // NOTE: Start iteration at \p start, not its sequel, because