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 kindof 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 reason I'm doing this, besides it just being a simpler, 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.

The test cases that changed are... I don't think the new output
is wrong under the current rules that are being enforced, but
really we should be enforcing different rules, because it's not
really okay to have broken stack nesting in blocks just because
they don't lead to an exit. But it's broken coming into
StackNesting, and I don't think the rewrite actually makes it
worse, so...

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

include/swift/SILOptimizer/Utils/StackNesting.h

@@ -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.
   ///