[AddressLowering] Omit dealloc_stack in dead ends.

It is valid for owned values not to be destroyed on paths terminating in
unreachable.  Similarly, it is valid for storage not to be deallocated
on paths terminating in unreachable.  However, it is _not_ valid for
storage to be deallocated before being deinitialized, even in paths
terminating in unreachable.  Consequently, when AddressLowering,
dealloc_stacks must not be created in dead-end blocks: because the input
OSSA may not destroy an owned value, the output may not deinitialize
owned storage; so a dealloc_stack in an unreachable block could dealloc
storage which was not deinitialized.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -149,6 +149,7 @@
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILVisitor.h"
+#include "swift/SILOptimizer/Analysis/DeadEndBlocksAnalysis.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/BasicBlockOptUtils.h"
@@ -413,6 +414,9 @@ struct AddressLoweringState {
   // Dominators remain valid throughout this pass.
   DominanceInfo *domInfo;
 
+  // Dead-end blocks remain valid through this pass.
+  DeadEndBlocks *deBlocks;
+
   InstructionDeleter deleter;
 
   // All opaque values mapped to their associated storage.
@@ -441,9 +445,10 @@ struct AddressLoweringState {
   // Handle moves from a phi's operand storage to the phi storage.
   std::unique_ptr<PhiRewriter> phiRewriter;
 
-  AddressLoweringState(SILFunction *function, DominanceInfo *domInfo)
+  AddressLoweringState(SILFunction *function, DominanceInfo *domInfo,
+                       DeadEndBlocks *deBlocks)
       : function(function), loweredFnConv(getLoweredFnConv(function)),
-        domInfo(domInfo) {
+        domInfo(domInfo), deBlocks(deBlocks) {
     for (auto &block : *function) {
       if (block.getTerminator()->isFunctionExiting())
         exitingInsts.push_back(block.getTerminator());
@@ -1332,6 +1337,8 @@ void OpaqueStorageAllocation::finalizeOpaqueStorage() {
     // a use projection.
     computeDominatedBoundaryBlocks(alloc->getParent(), pass.domInfo, boundary);
     for (SILBasicBlock *deallocBlock : boundary) {
+      if (pass.deBlocks->isDeadEnd(deallocBlock))
+        continue;
       auto deallocBuilder = pass.getBuilder(deallocBlock->back().getIterator());
       deallocBuilder.createDeallocStack(pass.genLoc(), alloc);
     }
@@ -3859,8 +3866,10 @@ void AddressLowering::runOnFunction(SILFunction *function) {
   removeUnreachableBlocks(*function);
 
   auto *dominance = PM->getAnalysis<DominanceAnalysis>();
+  auto *deadEnds = PM->getAnalysis<DeadEndBlocksAnalysis>();
 
-  AddressLoweringState pass(function, dominance->get(function));
+  AddressLoweringState pass(function, dominance->get(function),
+                            deadEnds->get(function));
 
   // ## Step #1: Map opaque values
   //

test/SILOptimizer/address_lowering.sil

@@ -1740,6 +1740,19 @@ bb2:
   unwind
 }
 
+// CHECK-LABEL: sil [ossa] @testUnreachable1NoDestroy : {{.*}} {
+// CHECK:         [[STORAGE:%[^,]+]] = alloc_stack $T                             
+// CHECK:         apply undef<T>([[STORAGE]])
+// CHECK:         apply undef<T>([[STORAGE]])
+// CHECK:         unreachable                                     
+// CHECK-LABEL: } // end sil function 'testUnreachable1NoDestroy'
+sil [ossa] @testUnreachable1NoDestroy : $@convention(thin) <T> () -> () {
+bb0:
+    %instance = apply undef<T>() : $@convention(thin) <τ> () -> @out τ
+    apply undef<T>(%instance) : $@convention(thin) <τ> (@in_guaranteed τ) -> ()
+    unreachable
+}
+
 sil [ossa] @use_T : $@convention(thin) <T> (@in T) -> ()
 
 // CHECK-LABEL: sil [ossa] @test_checked_cast_br1 : $@convention(method) <T> (@in Any) -> () {