Rewrite StackNesting to be a non-iterative single-pass algorithm.

The previous algorithm was doing an iterative forward data flow analysis
followed by a reverse data flow analysis. I suspect the history here is that
it was a reverse analysis, and that didn't really work for infinite loops,
and so complexity accumulated.

The new algorithm is quite straightforward and relies on the allocations
being properly jointly post-dominated, just not nested. We simply walk
forward through the blocks in consistent-with-dominance order, maintaining
the stack of active allocations and deferring deallocations that are
improperly nested until we deallocate the allocations above it. The only
real subtlety is that we have to delay walking into dead-end regions until
we've seen all of the edges into them, so that we can know whether we have
a coherent stack state in them. If the state is incoherent, we need to
remove any deallocations of previous allocations because we cannot talk
correctly about what's on top of the stack.

The reason I'm doing this, besides it just being a simpler and hopefully
faster algorithm, is that modeling some of the uses of the async stack
allocator properly requires builtins that cannot just be semantically
reordered. That should be somewhat easier to handle with the new approach,
although really (1) we should not have runtime functions that need this and
(2) we're going to need a conservatively-correct solution that's different
from this anyway because hoisting allocations is *also* limited in its own
way.

I've attached a rather pedantic proof of the correctness of the algorithm.

The thing that concerns me most about the rewritten pass is that it isn't
actually validating joint post-dominance on input, so if you give it bad
input, it might be a little mystifying to debug the verifier failures.

Author: rjmccall

docs/SIL/SIL.md

@@ -866,7 +866,8 @@ scope-ending instructions if:
   through a scope-ending instruction of `I` in between.
 
 - All initial paths that pass through a scope-ending instruction
-  of `I` twice must also pass through `I` in between.
+  of `I` twice (not necessarily the same instruction) must also
+  pass through `I` in between.
 
 - All terminating initial paths that pass through `I` must also
   pass through a scope-ending instruction of `I`.

docs/StackNestingProof.txt

@@ -45,8 +45,11 @@ namespace swift {
 ///   dealloc_stack %1
 /// \endcode
 ///
+/// Each allocation must still be properly jointly post-dominated by
+/// its deallocations. StackNesting only fixes the nesting of allocations
+/// deallocations; it does not insert required deallocations that are
+/// missing entirely.
 class StackNesting {
-
 public:
 
   /// The possible return values of fixNesting().
@@ -61,122 +64,6 @@ class StackNesting {
     CFG
   };
 
-private:
-  typedef SmallBitVector BitVector;
-
-  /// Data stored for each block (actually for each block which is not dead).
-  struct BlockInfo {
-    /// The list of stack allocating/deallocating instructions in the block.
-    llvm::SmallVector<SILInstruction *, 8> StackInsts;
-
-    /// The bit-set of alive stack locations at the block entry.
-    BitVector AliveStackLocsAtEntry;
-
-    /// The bit-set of alive stack locations at the block exit.
-    BitVector AliveStackLocsAtExit;
-
-    /// Used in the setup function to walk over the CFG.
-    bool visited = false;
-
-    /// True for dead-end blocks, i.e. blocks from which there is no path to
-    /// a function exit, e.g. blocks which end with `unreachable` or an
-    /// infinite loop.
-    bool isDeadEnd = false;
-  };
-
-  /// Data stored for each stack location (= allocation).
-  ///
-  /// Each stack location is allocated by a single allocation instruction.
-  struct StackLoc {
-    StackLoc(SILInstruction *Alloc) : Alloc(Alloc) {}
-
-    /// Back-link to the allocation instruction.
-    SILInstruction *Alloc;
-
-    /// Bit-set which represents all alive locations at this allocation.
-    /// It obviously includes this location itself. And it includes all "outer"
-    /// locations which surround this location.
-    BitVector AliveLocs;
-  };
-
-  /// Mapping from stack allocations (= locations) to bit numbers.
-  llvm::DenseMap<SILInstruction *, unsigned> StackLoc2BitNumbers;
-
-  /// The list of stack locations. The index into this array is also the bit
-  /// number in the bit-sets.
-  llvm::SmallVector<StackLoc, 8> StackLocs;
-
-  BasicBlockData<BlockInfo> BlockInfos;
-
-  StackNesting(SILFunction *F) : BlockInfos(F) { }
-
-  /// Performs correction of stack nesting by moving stack-deallocation
-  /// instructions down the control flow.
-  ///
-  /// Returns the status of what changes were made.
-  Changes run();
-  
-  /// For debug dumping.
-  void dump() const;
-
-  static void dumpBits(const BitVector &Bits);
-
-  /// Initializes the data structures.
-  void setup();
-
-  /// Solves the dataflow problem.
-  ///
-  /// Returns true if there is a nesting of locations in any way, which can
-  /// potentially in the wrong order.
-  bool solve();
-
-  bool analyze() {
-    setup();
-    return solve();
-  }
-
-  /// Insert deallocation instructions for all locations which are alive before
-  /// the InsertionPoint (AliveBefore) but not alive after the InsertionPoint
-  /// (AliveAfter).
-  ///
-  /// Returns true if any deallocations were inserted.
-  bool insertDeallocs(const BitVector &AliveBefore, const BitVector &AliveAfter,
-                      SILInstruction *InsertionPoint,
-                      std::optional<SILLocation> Location);
-
-  /// Returns the location bit number for a stack allocation instruction.
-  int bitNumberForAlloc(SILInstruction *AllocInst) {
-    assert(AllocInst->isAllocatingStack());
-    return StackLoc2BitNumbers[AllocInst];
-  }
-
-  /// Returns the location bit number for a stack deallocation instruction.
-  int bitNumberForDealloc(SILInstruction *DeallocInst) {
-    assert(DeallocInst->isDeallocatingStack());
-    auto *AllocInst = getAllocForDealloc(DeallocInst);
-    return bitNumberForAlloc(AllocInst);
-  }
-
-  /// Returns the stack allocation instruction for a stack deallocation
-  /// instruction.
-  SILInstruction *getAllocForDealloc(SILInstruction *Dealloc) const {
-    SILValue op = Dealloc->getOperand(0);
-    while (auto *mvi = dyn_cast<MoveValueInst>(op)) {
-      op = mvi->getOperand();
-    }
-    return op->getDefiningInstruction();
-  }
-
-  /// Insert deallocations at block boundaries.
-  Changes insertDeallocsAtBlockBoundaries();
-
-  /// Modifies the SIL to end up with a correct stack nesting.
-  ///
-  /// Returns the status of what changes were made.
-  Changes adaptDeallocs();
-
-public:
-
   /// Performs correction of stack nesting by moving stack-deallocation
   /// instructions down the control flow.
   ///