[6.2] Fix InstructionDeleter for drop_deinit instruction

Currently we delete dead drop_deinit instructions in InstructionDeleter. For address results, we may end up with ownership errors after being promoted to value forms. For value results, fixLifetimes mode of InstructionDeleter will insert an illegal destroy_value

rdar://151104993

Author: meg-gupta

lib/SILOptimizer/Utils/InstructionDeleter.cpp

@@ -63,6 +63,12 @@ static bool isScopeAffectingInstructionDead(SILInstruction *inst,
     return false;
   }
 
+  // Don't delete dead drop_deinit instruction. They are a marker to eliminate
+  // user-defined deinit and we do not want to lose it.
+  if (isa<DropDeinitInst>(inst)) {
+    return false;
+  }
+
   for (auto result : inst->getResults()) {
     // If inst has any owned move-only value as a result, deleting it may
     // shorten that value's lifetime which is illegal according to language
@@ -268,9 +274,16 @@ void InstructionDeleter::deleteWithUses(SILInstruction *inst, bool fixLifetimes,
       if (fixLifetimes) {
         LoadInst *li = nullptr;
         if (operand.isConsuming()) {
-          SILBuilderWithScope builder(inst);
-          auto *dvi = builder.createDestroyValue(inst->getLoc(), operandValue);
-          getCallbacks().createdNewInst(dvi);
+          if (isa<DropDeinitInst>(operandValue)) {
+            SILBuilderWithScope builder(inst);
+            auto *eli = builder.createEndLifetime(inst->getLoc(), operandValue);
+            getCallbacks().createdNewInst(eli);
+          } else {
+            SILBuilderWithScope builder(inst);
+            auto *dvi =
+                builder.createDestroyValue(inst->getLoc(), operandValue);
+            getCallbacks().createdNewInst(dvi);
+          }
         } else if ((li = dyn_cast<LoadInst>(inst)) &&
                    li->getOwnershipQualifier() ==
                        LoadOwnershipQualifier::Take) {

test/SILOptimizer/drop_deinit_opt.sil

@@ -0,0 +1,47 @@
+// RUN: %target-sil-opt %s -early-inline -mem2reg | %FileCheck %s
+
+import Swift
+import Builtin
+
+struct FileDescriptor : ~Copyable {
+  @_hasStorage private var fd: Int { get set }
+  init(_ fd: Int)
+  deinit
+}
+
+sil hidden [ossa] @fd_close : $@convention(thin) (Int) -> () {
+bb0(%0 : $Int):
+  debug_value %0, let, name "fd", argno 1
+  %2 = tuple ()
+  return %2
+}
+
+// CHECK-LABEL: sil hidden [ossa] @fd_deinit1 :
+// CHECK: drop_deinit
+// CHECK-LABEL: } // end sil function 'fd_deinit1'
+sil hidden [ossa] @fd_deinit1 : $@convention(method) (@owned FileDescriptor) -> () {
+bb0(%0 : @owned $FileDescriptor):
+  %1 = alloc_stack $FileDescriptor, let, name "self", argno 1
+  store %0 to [init] %1
+  %3 = drop_deinit %1
+  %6 = struct_element_addr %3, #FileDescriptor.fd
+  %7 = load [trivial] %6
+  %9 = function_ref @fd_close : $@convention(thin) (Int) -> ()
+  %10 = apply %9(%7) : $@convention(thin) (Int) -> ()
+  dealloc_stack %1
+  %12 = tuple ()
+  return %12
+}
+
+// CHECK-LABEL: sil hidden [ossa] @fd_deinit2 :
+// CHECK: end_lifetime
+// CHECK-LABEL: } // end sil function 'fd_deinit2'
+sil hidden [ossa] @fd_deinit2 : $@convention(method) (@owned FileDescriptor) -> () {
+bb0(%0 : @owned $FileDescriptor):
+  %3 = drop_deinit %0
+  %6 = destructure_struct %3
+  %9 = function_ref @fd_close : $@convention(thin) (Int) -> ()
+  %10 = apply %9(%6) : $@convention(thin) (Int) -> ()
+  %12 = tuple ()
+  return %12
+}