[StackNesting] NFC: Allocs are just insts.

Stop requiring that allocation instructions produce single values.

Author: nate-chandler

include/swift/SILOptimizer/Utils/StackNesting.h

@@ -83,10 +83,10 @@ class StackNesting {
   ///
   /// Each stack location is allocated by a single allocation instruction.
   struct StackLoc {
-    StackLoc(SingleValueInstruction *Alloc) : Alloc(Alloc) { }
+    StackLoc(SILInstruction *Alloc) : Alloc(Alloc) {}
 
     /// Back-link to the allocation instruction.
-    SingleValueInstruction *Alloc;
+    SILInstruction *Alloc;
 
     /// Bit-set which represents all alive locations at this allocation.
     /// It obviously includes this location itself. And it includes all "outer"
@@ -95,7 +95,7 @@ class StackNesting {
   };
 
   /// Mapping from stack allocations (= locations) to bit numbers.
-  llvm::DenseMap<SingleValueInstruction *, unsigned> StackLoc2BitNumbers;
+  llvm::DenseMap<SILInstruction *, unsigned> StackLoc2BitNumbers;
 
   /// The list of stack locations. The index into this array is also the bit
   /// number in the bit-sets.
@@ -142,7 +142,7 @@ class StackNesting {
   /// Returns the location bit number for a stack allocation instruction.
   int bitNumberForAlloc(SILInstruction *AllocInst) {
     assert(AllocInst->isAllocatingStack());
-    return StackLoc2BitNumbers[cast<SingleValueInstruction>(AllocInst)];
+    return StackLoc2BitNumbers[AllocInst];
   }
 
   /// Returns the location bit number for a stack deallocation instruction.
@@ -154,9 +154,8 @@ class StackNesting {
 
   /// Returns the stack allocation instruction for a stack deallocation
   /// instruction.
-  SingleValueInstruction *getAllocForDealloc(SILInstruction *Dealloc) const {
-    return cast<SingleValueInstruction>(
-        Dealloc->getOperand(0)->getDefiningInstruction());
+  SILInstruction *getAllocForDealloc(SILInstruction *Dealloc) const {
+    return Dealloc->getOperand(0)->getDefiningInstruction();
   }
 
   /// Insert deallocations at block boundaries.

lib/SILOptimizer/Utils/StackNesting.cpp

@@ -36,7 +36,7 @@ void StackNesting::setup() {
     BlockInfo &BI = BlockInfos[Block];
     for (SILInstruction &I : *Block) {
       if (I.isAllocatingStack()) {
-        auto Alloc = cast<SingleValueInstruction>(&I);
+        auto Alloc = &I;
         // Register this stack location.
         unsigned CurrentBitNumber = StackLocs.size();
         StackLoc2BitNumbers[Alloc] = CurrentBitNumber;
@@ -178,7 +178,7 @@ bool StackNesting::solve() {
   return isNested;
 }
 
-static SILInstruction *createDealloc(SingleValueInstruction *Alloc,
+static SILInstruction *createDealloc(SILInstruction *Alloc,
                                      SILInstruction *InsertionPoint,
                                      SILLocation Location) {
   SILBuilderWithScope B(InsertionPoint);
@@ -188,13 +188,14 @@ static SILInstruction *createDealloc(SingleValueInstruction *Alloc,
       assert((isa<AllocStackInst>(Alloc) ||
               cast<PartialApplyInst>(Alloc)->isOnStack()) &&
              "wrong instruction");
-      return B.createDeallocStack(Location, Alloc);
+      return B.createDeallocStack(Location,
+                                  cast<SingleValueInstruction>(Alloc));
     case SILInstructionKind::AllocRefDynamicInst:
     case SILInstructionKind::AllocRefInst:
       assert(cast<AllocRefInstBase>(Alloc)->canAllocOnStack());
-      return B.createDeallocStackRef(Location, Alloc);
+      return B.createDeallocStackRef(Location, cast<AllocRefInstBase>(Alloc));
     case SILInstructionKind::AllocPackInst:
-      return B.createDeallocPack(Location, Alloc);
+      return B.createDeallocPack(Location, cast<AllocPackInst>(Alloc));
     default:
       llvm_unreachable("unknown stack allocation");
   }
@@ -343,7 +344,7 @@ void StackNesting::dump() const {
     llvm::dbgs() << '\n';
     for (SILInstruction *StackInst : bd.data.StackInsts) {
       if (StackInst->isAllocatingStack()) {
-        auto AllocInst = cast<SingleValueInstruction>(StackInst);
+        auto AllocInst = StackInst;
         int BitNr = StackLoc2BitNumbers.lookup(AllocInst);
         llvm::dbgs() << "  alloc #" << BitNr << ": alive=";
         dumpBits(StackLocs[BitNr].AliveLocs);