5.9: [InstructionDeleter] Don't delete-as dead instructions which produce owned move-only values.

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -302,6 +302,22 @@ struct PrintTypeLowering : UnitTest {
   }
 };
 
+// Arguments:
+// - instruction: the instruction to delete
+// Dumps:
+// - the function
+struct DeleterDeleteIfDeadTest : UnitTest {
+  DeleterDeleteIfDeadTest(UnitTestRunner *pass) : UnitTest(pass) {}
+  void invoke(Arguments &arguments) override {
+    auto *inst = arguments.takeInstruction();
+    InstructionDeleter deleter;
+    llvm::dbgs() << "Deleting-if-dead " << *inst;
+    auto deleted = deleter.deleteIfDead(inst);
+    llvm::dbgs() << "deleteIfDead returned " << deleted << "\n";
+    getFunction()->dump();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // MARK: OSSA Lifetime Unit Tests
 //===----------------------------------------------------------------------===//
@@ -975,6 +991,7 @@ void UnitTestRunner::withTest(StringRef name, Doit doit) {
     ADD_UNIT_TEST_SUBCLASS("function-get-self-argument-index", FunctionGetSelfArgumentIndex)
     ADD_UNIT_TEST_SUBCLASS("has-pointer-escape", OwnershipUtilsHasPointerEscape)
     ADD_UNIT_TEST_SUBCLASS("print-type-lowering", PrintTypeLowering)
+    ADD_UNIT_TEST_SUBCLASS("deleter-delete-if-dead", DeleterDeleteIfDeadTest)
     ADD_UNIT_TEST_SUBCLASS("interior-liveness", InteriorLivenessTest)
     ADD_UNIT_TEST_SUBCLASS("is-deinit-barrier", IsDeinitBarrierTest)
     ADD_UNIT_TEST_SUBCLASS("is-lexical", IsLexicalTest)

lib/SILOptimizer/Utils/InstructionDeleter.cpp

@@ -10,10 +10,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/SILOptimizer/Utils/InstructionDeleter.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SILOptimizer/Utils/ConstExpr.h"
 #include "swift/SILOptimizer/Utils/DebugOptUtils.h"
-#include "swift/SILOptimizer/Utils/InstructionDeleter.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 
 using namespace swift;
@@ -60,6 +60,21 @@ static bool isScopeAffectingInstructionDead(SILInstruction *inst,
   if (!hasOnlyEndOfScopeOrEndOfLifetimeUses(inst)) {
     return false;
   }
+
+  // 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 rules.
+  //
+  // In particular, this check is needed before returning true when
+  // getSingleValueCopyOrCast returns true.  That function returns true for
+  // move_value instructions.  And `move_value %moveOnlyValue` must not be
+  // deleted.
+  for (auto result : inst->getResults()) {
+    if (result->getType().isPureMoveOnly() &&
+        result->getOwnershipKind() == OwnershipKind::Owned) {
+      return false;
+    }
+  }
+
   // If inst is a copy or beginning of scope, inst is dead, since we know that
   // it is used only in a destroy_value or end-of-scope instruction.
   if (getSingleValueCopyOrCast(inst))

test/SILOptimizer/instruction_deleter.sil

@@ -0,0 +1,30 @@
+// RUN: %target-sil-opt -unit-test-runner %s -o /dev/null 2>&1 | %FileCheck %s
+
+struct MOS : ~Copyable {}
+
+sil @getMOS : $() -> (@owned MOS)
+sil @barrier : $() -> ()
+
+// CHECK-LABEL: begin running test {{.*}} on dontDeleteDeadMoveOnlyValue
+// CHECK:       Deleting-if-dead {{.*}} move_value
+// CHECK:       deleteIfDead returned 0
+// CHECK-LABEL: sil [ossa] @dontDeleteDeadMoveOnlyValue : {{.*}} {
+// CHECK:         [[GET:%[^,]+]] = function_ref @getMOS
+// CHECK:         [[BARRIER:%[^,]+]] = function_ref @barrier
+// CHECK:         [[MOS:%[^,]+]] = apply [[GET]]()
+// CHECK:         [[MOV:%[^,]+]] = move_value [[MOS]]
+// CHECK:         apply [[BARRIER]]()
+// CHECK:         destroy_value [[MOV]]
+// CHECK-LABEL: } // end sil function 'dontDeleteDeadMoveOnlyValue'
+// CHECK-LABEL: end running test {{.*}} on dontDeleteDeadMoveOnlyValue
+sil [ossa] @dontDeleteDeadMoveOnlyValue : $() -> () {
+  %get = function_ref @getMOS : $@convention(thin) () -> (@owned MOS)
+  %barrier = function_ref @barrier : $@convention(thin) () -> ()
+  %mos = apply %get() : $@convention(thin) () -> (@owned MOS)
+  test_specification "deleter-delete-if-dead @instruction"
+  %mov = move_value %mos : $MOS
+  apply %barrier() : $@convention(thin) () -> ()
+  destroy_value %mov : $MOS
+  %retval = tuple ()
+  return %retval : $()
+}